Merge branch 'development' into kv-mendixsso-deprecation

Author: Karuna-Mendix

content/en/docs/apidocs-mxsdk/apidocs/private-mendix-platform/deploy-api.md

@@ -0,0 +1,27 @@
+---
+title: "Private Mendix Platform Deploy API"
+url: /apidocs-mxsdk/apidocs/private-platform-deploy-api/
+type: swagger
+description: "This API allows you to create and manage environments in Private Mendix Platform."
+restapi: true
+weight: 60
+linktitle: "Deploy API"
+---
+
+{{% alert color="info" %}}
+This document is about [Private Mendix Platform](/private-mendix-platform/) API. This API is only available on instances of Private Mendix Platform. For [Mendix on Kubernetes](/developerportal/deploy/private-cloud/) API, see [Mendix on Kubernetes Build API](/apidocs-mxsdk/apidocs/private-cloud-build-api/) and [Mendix on Kubernetes Deploy API](/apidocs-mxsdk/apidocs/private-cloud-deploy-api/).
+{{% /alert %}}
+
+## Introduction
+
+The Private Mendix Platform Group API allows you to manage user groups in Private Mendix Platform. You can use the API to do the following:
+
+* Create a new environment for the application
+* Retrieve all environments for the application
+* Retrieve a specified environment for the application
+* Update a specified environment for the application
+* Delete a specified environment for the application
+
+## API Reference
+
+{{< swaggerui src="/openapi-spec/openapi-deploy.yaml"  >}}

content/en/docs/community-tools/contribute-to-mendix-docs/using-ai-tools.md

@@ -46,17 +46,17 @@ This file is gitignored and will override the shared settings.
 Do not modify `.claude/settings.json` or other files in the `.claude/` directory for personal configuration. These files contain shared configuration for all contributors.
 {{% /alert %}}
 
-### Custom Skills
+### Custom Skills {#custom-skills}
 
 This repository includes custom Claude Code skills optimized for documentation work:
 
-* `/docs-proofread` - Checks spelling, grammar, punctuation, and basic Markdown formatting
-* `/docs-polish` - Applies the Mendix style guide and improves clarity, readability, and word choice without changing meaning
-* `/docs-enhance` - Performs comprehensive editing including reorganization, restructuring, and stronger phrasing
-* `/docs-add` - Adds new content to an existing page while preserving original structure
-* `/docs-review` - Analyzes a page and generates suggestions for improvements without making any edits
-* `/docs-pr-review` - Reviews all changes in a PR rather than just a single document
-* `/docs-alt-text` - Suggests W3C-compliant alt text for images on a page
+* `/docs-proofread` – Checks spelling, grammar, punctuation, and basic Markdown formatting
+* `/docs-polish` – Applies the Mendix style guide and improves clarity, readability, and word choice without changing meaning
+* `/docs-enhance` – Performs comprehensive editing including reorganization, restructuring, and stronger phrasing
+* `/docs-add` – Adds new content to an existing page while preserving original structure
+* `/docs-review` – Analyzes a page and generates suggestions for improvements without making any edits
+* `/docs-pr-review` – Reviews all changes in a PR rather than just a single document
+* `/docs-alt-text` – Suggests W3C-compliant alt text for images on a page
 
 These skills are available to all contributors using Claude Code with this repository.
 

content/en/docs/deployment/docker-deploy/docker-pad.md

@@ -235,3 +235,177 @@ The Mendix Runtime exposes health check endpoints that can be used to monitor th
 | `/health/ready` | Returns the readiness status — indicates if the app is ready to serve traffic |
 
 These endpoints are especially useful when integrating with orchestration platforms such as Kubernetes, which rely on liveness and readiness probes to manage container lifecycle.
+
+## Reverse Proxy
+
+This section serves as a reference guide and starting point for configuring a reverse proxy on Docker. The configurations provided are intended for illustrative purposes only, as the required settings vary depending on your specific network environment and infrastructure setup.
+
+{{% alert color="info" %}}
+This example implementation is provided as-is, and is not covered under official support. Support requests related to this specific configuration cannot be addressed.
+{{% /alert %}}
+
+### Configuring Nginx
+
+To configure Nginx, perform the following steps:
+
+1. Define services for the app and Nginx reverse proxy:
+
+    ```text
+    services:
+      app:
+        build: .
+        ports:
+          - "127.0.0.1:8080:8080"  # Bind only localhost
+        environment:
+          - SPRING_PROFILES_ACTIVE=docker
+      nginx:
+        image: nginx:alpine
+        ports:
+          - "80:80"
+        volumes:
+          - ./nginx.conf:/etc/nginx/nginx.conf:ro
+        depends_on:
+          - app
+    ```
+
+2. Run the following command: `docker-compose up --build`.​
+3. Create the following `nginx.conf` file to proxy requests to the app:
+
+    ```text
+    events {}
+    http {
+      server {
+        listen 80;
+        location / {
+          proxy_pass http://app:8080;
+          proxy_set_header Host $host;
+          proxy_set_header X-Real-IP $remote_addr;
+          proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+          proxy_set_header X-Forwarded-Proto $scheme;
+        }
+      }
+    }
+    ```
+
+This configuration exposes only port 80 publicly while acting as a proxy to your app on the internal port 8080.
+
+### Configuring Traefik
+
+To simplify setting up Traefik as a reverse proxy for your app running in a Docker container, use Docker Compose. This configuration exposes Traefik on ports `80/8080`, automatically discovers your app container through labels, and routes traffic to it.
+
+Traefik uses two networks: *frontend* (public) and *backend* (internal). 
+
+1. Add Traefik labels to the app service:
+
+    ```text
+    services:
+      traefik:
+        image: traefik:v3.0
+        ports:
+          - "80:80"
+          - "8080:8080"  # Traefik dashboard
+        volumes:
+          - /var/run/docker.sock:/var/run/docker.sock:ro
+        command:
+          - --api.dashboard=true
+          - --providers.docker=true
+          - --providers.docker.exposedbydefault=false
+          - --entrypoints.web.address=:80
+        networks:
+          - frontend
+          - backend
+        restart: unless-stopped
+      app:
+        build: .
+        networks:
+          - backend
+        labels:
+          - traefik.enable=true
+          - traefik.docker.network=backend
+          - traefik.http.routers.app.rule=Host(`localhost`) || PathPrefix(`/api`)
+          - traefik.http.routers.app.entrypoints=web
+          - traefik.http.services.app.loadbalancer.server.port=8080
+        restart: unless-stopped
+    networks:
+      frontend:
+        external: false
+      backend:
+        external: false
+    ```
+
+2. Run the following command:  `docker compose up -d --build`. 
+
+You can now access your app at `http://localhost`. Traefik proxies to `app:8080` internally.
+
+#### Key Traefik Labels Explained
+
+This section explains the main labels used by Traefik.
+
+* `traefik.enable=true` - Enables Traefik for this container.
+* `traefik.http.routers.java-app.rule=Host(yourapp.example.com)` - Routes requests matching the host to this service.
+* `traefik.http.services.java-app.loadbalancer.server.port=8080` - Forwards to your app's internal port.
+
+Traefik automatically detects changes through a Docker socket. You do not need to restart it to update the labels.
+
+#### Main Differences between Traefik and Nginx
+
+This section explains how Traefik proxies differ from Nginx.
+
+* Traefik does not use static config files. Instead, the configuration is automatic through the use of labels.
+* A dashboard available at `http://localhost:8080` shows the routes.
+* You can easily scale by duplicating the `app service` with unique router rules (for example, `Host(app2.local)`).​
+
+## Example High Availability Implementation
+
+High availability (HA) requires redundancy, health checks, and restarts to handle failures. Scale for HA with Docker Compose (for local or development environments) or Kubernetes.
+
+This section serves as a reference guide and starting point for configuring high availability on Docker. The configurations provided are intended for illustrative purposes only, as the settings will vary depending on your specific network environment and infrastructure setup.
+
+{{% alert color="info" %}}
+This example implementation is provided as-is, and is not covered under official support. Support requests related to this specific configuration cannot be addressed.
+{{% /alert %}}
+
+1. Configure the *docker-compose.yml* as in the following example:
+
+    ```text
+    services:
+      myapp:
+        image: myapp
+        ports:
+          - "8080:8080"
+        deploy:
+          replicas: 3  # Run 3 instances
+        healthcheck:
+          test: ["CMD", "wget", "--no-verbose", "--tries=1", "--spider", "http://localhost:8080/actuator/health"]
+          interval: 30s
+          timeout: 10s
+          retries: 3
+    ```
+
+2. Start the process by running the following command: `docker-compose up --scale myapp=3`. 
+3. Add a load balancer like Traefik or an NGINX reverse proxy in the front:
+
+    ``` text
+    services:
+      traefik:
+        image: traefik:v3.0
+        command: --providers.docker --entrypoints.web.address=:80
+        ports: ["80:80"]
+      myapp:
+        # No ports exposed; Traefik load balances
+    ```
+
+    This creates a redundancy—kill container, and traffic shifts automatically.
+
+4. Build and run manually by running the following script:
+
+    ``` text
+    # Build image 
+    docker build -t myapp:latest .
+    # Test single instance
+    docker run -p 8080:8080 myapp:latest
+    # For HA: Run 3 replicas (use docker-compose.yml for production)
+    docker run -d -p 8081:8080 --name app1 myapp:latest
+    docker run -d -p 8082:8080 --name app2 myapp:latest  
+    docker run -d -p 8083:8080 --name app3 myapp:latest
+    ``` 

content/en/docs/deployment/general/salt.md

@@ -2,7 +2,7 @@
 title: "Siemens Advanced License Technology"
 url: /developerportal/deploy/salt/
 weight: 90
-description: "This guide explains how to use Siemens Advaned License Technology (SALT) with Mendix"
+description: "This guide explains how to use Siemens Advanced License Technology (SALT) with Mendix"
 aliases:
     - /deployment/salt/
 #To update these screenshots, you can log in with credentials detailed in How to Update Screenshots Using Team Apps.
@@ -24,18 +24,25 @@ This section explains the limitations for using SALT-based licenses.
 
 SALT Licenses can only be used with the following Mendix versions:
 
-* **Mendix 10**: 10.24.4 and above
-* **Mendix 11**: 11.2.0 and above
+* **Mendix 10** – 10.24.4 and above
+* **Mendix 11** – 11.2.0 and above
 
-Each SALT license is bound to a specific major version of Mendix and cannot be used in newer major versions.
+Each SALT license is tied to a specific major Mendix version, for example MXP11 for Mendix 11. The license permits use of that version and all earlier major versions. To use a newer major version, you must have an active maintenance contract and can request a renewed license when the new major version is released.
 
 ### Deployment Restrictions
 
 Mendix applications using a SALT License cannot be deployed to the Mendix Public Cloud.
 
+### User Limits
+
+SALT licenses distinguish between internal and external users:
+
+* **Internal users** – SALT licenses specify a maximum number of named internal users. This limit is enforced independently by each application and is defined at the time of purchase. Limiting concurrent users is not supported.
+* **External users** – Unlimited external users can optionally be purchased. When purchased, external users are no longer counted against the internal user limit. To take advantage of this, users must be explicitly flagged as external in your application using the [User Classification](/appstore/modules/user-classification/) module or by setting the `UserType` attribute directly. If external users are not flagged, they are counted as internal users.
+
 ## Obtaining the SALT-based License
 
-Upon purchase, your SALT-based license file is sent to you by email.
+Upon purchase, your SALT-based license file is sent to you by email. A single license file is valid for all of your Mendix applications. Multiple license files cannot be issued.
 
 ## Installing the Siemens License Server
 
@@ -50,6 +57,10 @@ For detailed instructions on how to install the Siemens License Server and confi
 * [Siemens License Server](https://support.sw.siemens.com/en-US/product/1586485382)
 * [Getting Started with Siemens Advanced Licensing Technology (SALT) and the Siemens License Server (SLS)](https://support.sw.siemens.com/en-US/product/1586485382/knowledge-base/MG612613)
 
+{{% alert color="info" %}}
+If you are deploying on-premises, you must generate a hardware ID (CID) using Siemens tools and provide it during the license provisioning process. Refer to the Siemens documentation above for instructions on generating a CID.
+{{% /alert %}}
+
 ## Configuring your Mendix Application
 
 Each Mendix application that uses a SALT license must be configured with the following [runtime setting](/refguide/custom-settings/):
@@ -58,17 +69,23 @@ Each Mendix application that uses a SALT license must be configured with the fol
 License.SaltLicenseLocation = port@host
 ```
 
-* `port`: The port number specified during the license server installation.
-* `host`: The hostname or IP address of the machine running the license server.
+* `port` – The port number specified during the license server installation.
+* `host` – The hostname or IP address of the machine running the license server.
 
 After you configure the runtime setting and start the Mendix application, the application connects to the Siemens License Server to validate the SALT license.
 
 ## FAQs
 
 ### When Does a Mendix Application Connect to the License Server?
 
-Mendix applications connect to the license server during startup to retrieve the license. After this initial connection, the applications do not maintain ongoing connections to the license serve
+Mendix applications connect to the license server during startup to retrieve the license. After this initial connection, the applications do not maintain ongoing connections to the license server.
 
 ### What Happens If the License Server Is Unavailable?
 
-If the license server becomes unavailable while a Mendix application is running, the application's current operation will not be affected. However, if the license server is unavailable during startup, the Mendix application will launch in trial mode. To resolve this, restart the Mendix application once the license server is available.
+If the license server becomes unavailable while a Mendix application is running, the application's current operation will not be affected. However, if the license server is unavailable during startup, the Mendix application will launch in trial mode. In trial mode, usage is limited to a specific number of users and the application stops running after a few hours.
+
+To resolve this, restart the Mendix application once the license server is available.
+
+### Does the License Server Require Internet Access?
+
+SALT-based licenses can operate fully offline. No outbound connectivity to Siemens systems is required.

content/en/docs/deployment/on-premises-design/cloud-foundry/cloud-foundry-deploy-pad.md

@@ -1,5 +1,5 @@
 ---
-title: "Portable App Distribution for Cloud Foundry"
+title: "Portable App Distribution on Cloud Foundry"
 url: /developerportal/deploy/cloud-foundry-pad/
 weight: 20
 description: "Describes how to deploy to a Cloud Foundry environment by using Portable App Distribution."
@@ -12,6 +12,7 @@ Cloud Foundry is a platform-as-a-service (PaaS) that automates the deployment, s
 This documentation provides guidance on understanding Cloud Foundry on-premise deployments and serves as a helpful reference rather than official implementation support.
 
 {{% alert color="info" %}}
+Unlike the Cloud Foundry Buildpack deployment where Mendix provides full end-to-end tooling support, the Portable App Distribution approach only requires Java to run, with Mendix's support strictly limited to the Portable App Distribution package itself. All implementation, configuration, and deployment activities, including Cloud Foundry deployment, remain the sole responsibility of the customer.
 For information about the scope of support, see [Support for Different Deployment Strategies](/support/deployment-strategy-support/).
 {{% /alert %}}
 

content/en/docs/deployment/on-premises-design/linux/linux-pad.md

@@ -1,5 +1,5 @@
 ---
-title: "Portable App Distribution for Linux"
+title: "Portable App Distribution on Linux"
 url: /developerportal/deploy/linux-pad/
 description: "How to install and configure Mendix on a Linux system using Portable App Distribution."
 weight: 20
@@ -12,12 +12,13 @@ Portable App Distribution refers to packaging applications in a self-contained f
 This documentation provides guidance for deploying Portable App Distribution in a Linux environment and serves as a helpful reference rather than official implementation support.
 
 {{% alert color="info" %}}
+Unlike the M2EE-based deployment, where Mendix provides full end-to-end tooling support, the Portable App Distribution approach only requires Java to run, with Mendix's support strictly limited to the Portable App Distribution package itself. All implementation, configuration, and deployment activities, including Linux deployment, remain the customer's sole responsibility.
 For information about the scope of support, see [Support for Different Deployment Strategies](/support/deployment-strategy-support/).
 {{% /alert %}}
 
 ## Prerequisites
 
-To deploy your app to an on-premises Cloud Foundry configuration using [Portable App Distribution](/developerportal/deploy/portable-app-distribution-deploy/), ensure that you fulfill the following prerequisites:
+To deploy your app to an on-premises Linux configuration using [Portable App Distribution](/developerportal/deploy/portable-app-distribution-deploy/), ensure that you fulfill the following prerequisites:
 
 * A Linux environment. This can be a virtual machine, a physical server, or a cloud instance (for example, AWS EC2, Azure VM, Google Cloud VM). You will need `sudo` or `root` privileges for some commands.
 * Java Development Kit (JDK). Your application requires a compatible Java runtime. For installation instructions, refer to the following sections.