Merge branch 'development' into nc-maia-plan-jira

Author: NicoletaComan

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/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/ms-windows/sql-server/setting-up-a-new-sql-server-database.md

@@ -19,15 +19,15 @@ Some of these steps are only required for specific versions of SQL Server or Men
 
 When setting up a new database for Mendix, you can leave most of the settings to the default configuration. When looking at the general settings, you only need to set up the database name. Set up the database files according to the [Microsoft SQL Server best practices](https://www.mssqltips.com/sqlservertip/4891/sql-server-installation-best-practices/).
 
-{{< figure src="/attachments/deployment/on-premises-design/ms-windows/sql-server/setting-up-a-new-sql-server-database/18580676.png" class="no-border" >}}
+{{< figure src="/attachments/deployment/on-premises-design/ms-windows/sql-server/setting-up-a-new-sql-server-database/sql-server-general.png" alt="New Database dialog General page with database name and files configuration" >}}
 
 In the database options, the default properties need to be evaluated. When choosing a collation, pay attention to the type of collation you are going to use. Mendix uses UTF-8 for all data evaluation. Depending on your exact locale, you will most likely want to choose one of the `SQL_Latin1_General_` collations. The exact encoding depends on your OS. For an **en_US** installation, for example, the encoding is `CP1`.
 
 The last two collation arguments identify how sorting and uniqueness are interpreted. For example, the collation argument `CS` indicates that the collation sorting style is case sensitive. For more information on collations and case sensitivity, see [Case-Sensitive Database Behavior](/refguide/case-sensitive-database-behavior/) and the Microsoft documentation [Windows Collation Name](https://docs.microsoft.com/en-us/sql/t-sql/statements/windows-collation-name-transact-sql).
 
 Mendix recommends using the **Simple** recovery model option. Mendix does not use the full functionality offered in the **Full** recovery model option; although you can successfully use the **Full** recovery model, it could increase the data usage of all the transactions and might slow down any rollbacks in case of an error.
 
-{{< figure src="/attachments/deployment/on-premises-design/ms-windows/sql-server/setting-up-a-new-sql-server-database/18580675.png" class="no-border" >}}
+{{< figure src="/attachments/deployment/on-premises-design/ms-windows/sql-server/setting-up-a-new-sql-server-database/sql-server-options.png" alt="New Database dialog Options page showing collation and recovery model settings" >}}
 
 After the database is created, the Mendix Runtime can initiate the initial setup and prepare all the tables and functions for usage by the platform. Some of these queries require `sysadmin` privileges. The `sysadmin` role can be temporarily assigned to the user, or these queries can be executed by the administrator. Other queries need privileges that are implicitly assigned to the `db_owner` role. If the user used by the Mendix Runtime does not have enough permissions for any of these queries, you can run them manually – see below for more information.
 

content/en/docs/deployment/private-cloud/private-cloud-license-manager.md

@@ -164,7 +164,6 @@ To apply the manifest to configure the ingress in the Kubernetes namespace, use
 You can confirm that you can connect to the PCLM server using the following URLs:
 
 * `http<s>://pclm.<domain>/health` should return `HTTP 200 OK`
-* `https<s>://pclm.<domain>/metrics` should return `HTTP 200 OK` together with the collected server metrics
 
 ### Using the Kubernetes Service
 

content/en/docs/marketplace/genai/reference-guide/mcp-modules/mcp-server.md

@@ -23,7 +23,6 @@ The current version has the following limitations:
 
 * Tools can only return String values, either directly as a String type or using the `TextContent` entity.
 * Prompts can only return a single message.
-* Running an MCP Server is currently only supported on single-instance environments.
 
 {{% alert color="info" %}}
 Note that the MCP Server module is still in its early version, and the latest version may include breaking changes. Since both the open-source protocol and the Java SDK are still evolving and regularly updated, these changes may also affect this module.