> For the complete documentation index, see [llms.txt](https://docs.devolutions.net/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.devolutions.net/server/fr/knowledge-base/how-to-articles/devolutions-server-docker-deployment/deploy-devolutions-server-and-sql-server-with-docker-compose-on-windows.md).

# Déployer Devolutions Server et SQL Server avec Docker Compose sur Windows

Déployez Devolutions Server et SQL Server sur Windows avec Docker Compose, soit entièrement dans des conteneurs, soit avec un SQL Server existant, puis vérifiez le déploiement et effectuez la résoluti

Cet article montre comment déployer Devolutions Server sur une machine Windows avec Docker Compose. Deux options de déploiement sont présentées :

* **Tout-en-un** : Devolutions Server et SQL Server s'exécutent tous deux dans des conteneurs sur le même réseau Docker. Convient surtout aux évaluations, aux laboratoires et aux environnements de test.
* **Hybride** : Devolutions Server s'exécute dans un conteneur et se connecte à un SQL Server existant installé sur l'hôte ou sur un autre serveur. Convient surtout aux organisations qui gèrent déjà leur propre SQL Server.

Les deux options utilisent les mêmes noms de conteneurs. N'utilisez qu'une seule option par hôte.

Pour déployer Devolutions Server avec des commandes `docker run` individuelles, consultez [Déployer Devolutions Server avec Docker](https://docs.devolutions.net/server/fr/knowledge-base/how-to-articles/devolutions-server-docker-deployment.md). Pour la liste complète des variables d'environnement, consultez [Configuration Docker avancée pour Devolutions Server](https://docs.devolutions.net/server/fr/knowledge-base/how-to-articles/devolutions-server-docker-deployment/advanced-docker-configuration-for-devolutions-server.md).

{% hint style="info" %}
Par souci de simplicité, la version de l'image Docker de Devolutions Server est écrite `20XX.X` dans les blocs de code de cet article. Remplacez cette variable par la version que vous souhaitez utiliser.
{% endhint %}

### Prérequis

* [Docker Desktop](https://docs.docker.com/desktop/setup/install/windows-install/) pour Windows avec le backend WSL 2, exécuté en mode **conteneurs Linux**. Les images Devolutions Server et SQL Server sont des images Linux.
* Docker Compose v2 ou une version ultérieure (inclus avec Docker Desktop). Exécutez `docker compose version` pour confirmer qu'il est disponible.
* Au moins 4 Go de mémoire alloués à Docker. SQL Server a besoin d'au moins 2 Go pour démarrer.
* Les [exigences du système](https://docs.devolutions.net/server/fr/overview-of-devolutions-server/system-requirements.md) minimales pour exécuter Devolutions Server.
* Pour l'option hybride seulement : une instance SQL Server existante préparée comme décrit dans [Préparer un SQL Server existant](#prepare-an-existing-sql-server-hybrid-option).

{% hint style="warning" %}
Le conteneur Devolutions Server se connecte à SQL Server avec l'**authentification SQL Server**. L'authentification Windows depuis un conteneur Linux exige une configuration Kerberos qui n'est pas traitée ici. Si vous avez besoin de l'authentification Windows, [installez Devolutions Server sur Windows](https://docs.devolutions.net/server/fr/getting-started/installation.md) à la place.
{% endhint %}

### Choisir une étiquette d'image

L'image `devolutions/devolutions-server` ne publie **pas** d'étiquette `latest`. Utilisez l'un des formats d'étiquette suivants, offerts sur [Docker Hub](https://hub.docker.com/r/devolutions/devolutions-server/tags) :

| Format d'étiquette               | Exemple          | Utilisation                                                           |
| -------------------------------- | ---------------- | --------------------------------------------------------------------- |
| `release-<year>.<minor>`         | `release-20XX.X` | Suit le plus récent correctif d'une version. Pratique pour les tests. |
| `<year>.<minor>.<patch>.<build>` | `20XX.X.X.X`     | Version fixe. Recommandé pour la production.                          |

### Déploiement tout-en-un

#### Créer les fichiers de configuration

1. Créez un dossier vide pour le déploiement, par exemple `C:\dvls`, puis limitez son accès à l'utilisateur actuel, à SYSTEM et au groupe Administrators. Exécutez les commandes suivantes dans PowerShell :

   ```powershell
   New-Item -ItemType Directory -Path C:\dvls
   icacls C:\dvls /inheritance:r /grant:r "$(whoami):(OI)(CI)F" "*S-1-5-18:(OI)(CI)F" "*S-1-5-32-544:(OI)(CI)F"
   ```
2. Dans ce dossier, créez un fichier nommé `.env` avec le contenu suivant, et remplacez chaque valeur entre chevrons :

   ```
   MSSQL_SA_PASSWORD=<StrongSaPassword>
   MSSQL_PID=Express
   DVLS_IMAGE_TAG=release-20XX.X
   DATABASE_NAME=DVLS
   DVLS_ADMIN_USERNAME=dvls-admin
   DVLS_ADMIN_PASSWORD=<StrongAdminPassword>
   DVLS_HOSTNAME=localhost
   DVLS_HOST_PORT=5000
   SQL_HOST_PORT=1434
   ```

   * `MSSQL_SA_PASSWORD` doit contenir au moins 8 caractères et au moins trois des éléments suivants : lettres majuscules, lettres minuscules, chiffres et symboles. Sinon, SQL Server refuse de démarrer.
   * `MSSQL_PID` sélectionne l'édition de SQL Server. `Express` est gratuit, mais limité à 10 Go par base de données. `Developer` est gratuit, mais ne peut pas être utilisé en production. `Standard` et `Enterprise` exigent une licence SQL Server.
   * `SQL_HOST_PORT` est le port utilisé pour atteindre le conteneur SQL Server depuis l'hôte, par exemple avec SQL Server Management Studio. Le port `1434` évite un conflit avec un SQL Server déjà installé sur l'hôte.

{% hint style="warning" %}
Le fichier `.env` contient des mots de passe. Conservez les permissions restreintes du dossier et tenez le fichier hors du contrôle de version. Évitez le caractère `$` dans les mots de passe, car Docker Compose l'interprète comme une variable.
{% endhint %}

3. Dans le même dossier, créez un fichier nommé `docker-compose.yml` avec le contenu suivant :

   ```yaml
   services:
     sqlserver:
       image: mcr.microsoft.com/mssql/server:2022-latest
       container_name: dvls-sqlserver
       restart: unless-stopped
       environment:
         ACCEPT_EULA: "Y"
         MSSQL_SA_PASSWORD: ${MSSQL_SA_PASSWORD}
         MSSQL_PID: ${MSSQL_PID}
       ports:
         - "${SQL_HOST_PORT}:1433"
       volumes:
         - mssqldata:/var/opt/mssql
       healthcheck:
         test: ["CMD-SHELL", "/opt/mssql-tools18/bin/sqlcmd -S localhost -U sa -P \"$$MSSQL_SA_PASSWORD\" -Q 'SELECT 1' -C -N -b"]
         interval: 10s
         timeout: 5s
         retries: 30
         start_period: 120s

     # One-time initialization: creates the database schema, the administrator, and the encryption configuration.
     dvls-init:
       image: devolutions/devolutions-server:${DVLS_IMAGE_TAG}
       profiles: ["init"]
       volumes:
         - dvlsdata:/opt/devolutions/dvls/App_Data
       environment:
         DVLS_INIT: "true"
         DATABASE_HOST: sqlserver
         DATABASE_PORT: "1433"
         DATABASE_NAME: ${DATABASE_NAME}
         DATABASE_USERNAME: sa
         DATABASE_PASSWORD: ${MSSQL_SA_PASSWORD}
         DATABASE_ENCRYPT: "true"
         DATABASE_TRUST_SERVER_CERTIFICATE: "true"
         DVLS_ADMIN_USERNAME: ${DVLS_ADMIN_USERNAME}
         DVLS_ADMIN_PASSWORD: ${DVLS_ADMIN_PASSWORD}
         HOSTNAME: ${DVLS_HOSTNAME}
         WEB_SCHEME: http
         WEB_PORT: "5000"
         EXTERNAL_WEB_PORT: "${DVLS_HOST_PORT}"
       depends_on:
         sqlserver:
           condition: service_healthy

     dvls:
       image: devolutions/devolutions-server:${DVLS_IMAGE_TAG}
       container_name: dvls-app
       restart: unless-stopped
       ports:
         - "${DVLS_HOST_PORT}:5000"
       volumes:
         - dvlsdata:/opt/devolutions/dvls/App_Data
       environment:
         DATABASE_HOST: sqlserver
         DATABASE_PORT: "1433"
         DATABASE_NAME: ${DATABASE_NAME}
         DATABASE_USERNAME: sa
         DATABASE_PASSWORD: ${MSSQL_SA_PASSWORD}
         DATABASE_ENCRYPT: "true"
         DATABASE_TRUST_SERVER_CERTIFICATE: "true"
         HOSTNAME: ${DVLS_HOSTNAME}
         WEB_SCHEME: http
         WEB_PORT: "5000"
         EXTERNAL_WEB_PORT: "${DVLS_HOST_PORT}"
       depends_on:
         sqlserver:
           condition: service_healthy

   volumes:
     mssqldata:
     dvlsdata:
   ```

Le volume `dvlsdata` est partagé par les services `dvls-init` et `dvls`. Il stocke la configuration de chiffrement que l'initialisation génère, afin que le conteneur d'exécution puisse déchiffrer les données de la base de données. Le volume `mssqldata` stocke les bases de données SQL Server.

{% hint style="warning" %}
Cet exemple utilise le compte `sa` de SQL Server afin de simplifier la configuration d'évaluation. En production, créez une connexion SQL dédiée avec un [accès de moindre privilège](https://docs.devolutions.net/server/fr/knowledge-base/knowledge-base-articles/pre-deployment-account-survey.md#windows-sql-accounts) et utilisez-la dans `DATABASE_USERNAME` et `DATABASE_PASSWORD`.
{% endhint %}

#### Démarrer le déploiement

1. Ouvrez PowerShell et allez dans le dossier de déploiement :

   ```powershell
   cd C:\dvls
   ```
2. Confirmez que Docker Compose lit correctement le fichier `.env`. Les deux noms d'image doivent inclure une étiquette :

   ```powershell
   docker compose config | Select-String 'image:'
   ```
3. Téléchargez les images, y compris l'image d'initialisation :

   ```powershell
   docker compose --profile init pull
   ```
4. Initialisez la base de données et créez le compte d'administrateur. Cette étape n'est nécessaire que pour le premier déploiement :

   ```powershell
   docker compose --profile init run --rm dvls-init
   ```
5. Si la commande ne se termine pas après l'affichage de `Initialization completed successfully.`, appuyez sur Ctrl+C. Le conteneur d'initialisation est supprimé automatiquement.

{% hint style="warning" %}
Ne démarrez pas Devolutions Server tant que le conteneur d'initialisation est encore en cours d'exécution. N'exécutez pas l'initialisation de nouveau sur un déploiement existant.
{% endhint %}

6. Démarrez Devolutions Server et SQL Server :

   ```powershell
   docker compose up -d
   ```
7. Suivez le journal de Devolutions Server. SQL Server peut prendre jusqu'à deux minutes lors de son premier démarrage. Devolutions Server est habituellement prêt quelques secondes plus tard, car l'initialisation a déjà appliqué les migrations de base de données. Appuyez sur Ctrl+C pour cesser de suivre le journal :

   ```powershell
   docker compose exec dvls sh -c "tail -n 50 -f /opt/devolutions/dvls/App_Data/DPS_Main*.log"
   ```
8. Ouvrez `http://localhost:5000` dans un navigateur (ou le port défini dans `DVLS_HOST_PORT`), puis connectez-vous avec les valeurs `DVLS_ADMIN_USERNAME` et `DVLS_ADMIN_PASSWORD` du fichier `.env`.
9. Sauvegardez la configuration de chiffrement. Elle est requise pour restaurer ou redéployer Devolutions Server avec la même base de données :

   ```powershell
   docker compose cp dvls:/opt/devolutions/dvls/App_Data/encryption.config .\encryption.config
   ```
10. Déplacez `encryption.config` vers un emplacement sécurisé à l'extérieur du dossier de déploiement.

{% hint style="danger" %}
Sans la configuration de chiffrement, les données stockées dans la base de données ne peuvent pas être déchiffrées. Ne supprimez jamais le volume `dvlsdata` sans avoir une sauvegarde de données de `encryption.config`.
{% endhint %}

{% hint style="info" %}
Cet exemple sert Devolutions Server en HTTP afin de simplifier la configuration. Avant de donner accès aux utilisateurs, configurez HTTPS avec un certificat TLS ou un proxy inverse, comme décrit dans [Configuration Docker avancée pour Devolutions Server](https://docs.devolutions.net/server/fr/knowledge-base/how-to-articles/devolutions-server-docker-deployment/advanced-docker-configuration-for-devolutions-server.md#tls-certificate-configuration).
{% endhint %}

### Déploiement hybride

Dans cette option, seul Devolutions Server s'exécute dans un conteneur. Il se connecte à un SQL Server existant, par exemple SQL Server Express installé sur le même hôte Windows.

#### Préparer un SQL Server existant (option hybride)

À l'aide de SQL Server Configuration Manager et de SQL Server Management Studio, assurez-vous que l'instance SQL Server possède :

1. Le protocole **TCP/IP** activé. SQL Server Express est livré avec TCP/IP désactivé.
2. Un **port TCP statique** configuré (par exemple, `1433`). Un conteneur ne peut pas utiliser une instance nommée telle que `HOST\SQLEXPRESS`; il doit se connecter à un hôte et à un port.
3. Le **mode d'authentification SQL Server et Windows** (mode mixte) activé.
4. Une connexion SQL dédiée pour Devolutions Server. N'utilisez pas `sa`. Créez d'abord la base de données et faites de la connexion son `db_owner` (recommandé), ou attribuez à la connexion le rôle de serveur `dbcreator` et laissez l'initialisation créer la base de données.
5. Une règle de pare-feu Windows entrante qui autorise le port SQL Server.

Le script suivant crée la connexion et la base de données, et fait de la connexion le propriétaire de la base de données. Remplacez `<StrongPassword>` avant de l'exécuter :

```sql
CREATE LOGIN dvls_login WITH PASSWORD = N'<StrongPassword>';
CREATE DATABASE DVLS;
GO
USE DVLS;
CREATE USER dvls_login FOR LOGIN dvls_login;
ALTER ROLE db_owner ADD MEMBER dvls_login;
```

La valeur `SQL_DATABASE` du fichier `.env` doit correspondre à ce nom de base de données.

#### Créer les fichiers de configuration hybride

1. Créez un dossier vide pour le déploiement, par exemple `C:dvls`, puis limitez son accès à l'utilisateur actuel, à SYSTEM et au groupe Administrators. Exécutez les commandes suivantes dans PowerShell :

   ```powershell
   New-Item -ItemType Directory -Path C:dvls
   icacls C:dvls /inheritance:r /grant:r "$(whoami):(OI)(CI)F" "*S-1-5-18:(OI)(CI)F" "*S-1-5-32-544:(OI)(CI)F"
   ```
2. Dans ce dossier, créez un fichier `.env` avec le contenu suivant, et remplacez chaque valeur entre chevrons :

   ```
   DVLS_IMAGE_TAG=release-20XX.X
   SQL_HOST=host.docker.internal
   SQL_PORT=1433
   SQL_DATABASE=DVLS
   SQL_LOGIN=<DvlsSqlLogin>
   SQL_PASSWORD=<DvlsSqlLoginPassword>
   DVLS_ADMIN_USERNAME=dvls-admin
   DVLS_ADMIN_PASSWORD=<StrongAdminPassword>
   DVLS_HOSTNAME=localhost
   DVLS_HOST_PORT=5000
   ```

   `host.docker.internal` permet au conteneur d'atteindre un SQL Server installé sur l'hôte Docker. Si SQL Server s'exécute sur un autre serveur, remplacez-le par le nom ou l'adresse IP de ce serveur.
3. Dans le même dossier, créez un fichier `docker-compose.yml` avec le contenu suivant :

   ```yaml
   services:
     # One-time initialization: creates the database schema, the administrator, and the encryption configuration.
     dvls-init:
       image: devolutions/devolutions-server:${DVLS_IMAGE_TAG}
       profiles: ["init"]
       volumes:
         - dvlsdata:/opt/devolutions/dvls/App_Data
       environment:
         DVLS_INIT: "true"
         DATABASE_HOST: ${SQL_HOST}
         DATABASE_PORT: "${SQL_PORT}"
         DATABASE_NAME: ${SQL_DATABASE}
         DATABASE_USERNAME: ${SQL_LOGIN}
         DATABASE_PASSWORD: ${SQL_PASSWORD}
         DATABASE_ENCRYPT: "true"
         DATABASE_TRUST_SERVER_CERTIFICATE: "true"
         DVLS_ADMIN_USERNAME: ${DVLS_ADMIN_USERNAME}
         DVLS_ADMIN_PASSWORD: ${DVLS_ADMIN_PASSWORD}
         HOSTNAME: ${DVLS_HOSTNAME}
         WEB_SCHEME: http
         WEB_PORT: "5000"
         EXTERNAL_WEB_PORT: "${DVLS_HOST_PORT}"
       extra_hosts:
         - "host.docker.internal:host-gateway"

     dvls:
       image: devolutions/devolutions-server:${DVLS_IMAGE_TAG}
       container_name: dvls-app
       restart: unless-stopped
       ports:
         - "${DVLS_HOST_PORT}:5000"
       volumes:
         - dvlsdata:/opt/devolutions/dvls/App_Data
       environment:
         DATABASE_HOST: ${SQL_HOST}
         DATABASE_PORT: "${SQL_PORT}"
         DATABASE_NAME: ${SQL_DATABASE}
         DATABASE_USERNAME: ${SQL_LOGIN}
         DATABASE_PASSWORD: ${SQL_PASSWORD}
         DATABASE_ENCRYPT: "true"
         DATABASE_TRUST_SERVER_CERTIFICATE: "true"
         HOSTNAME: ${DVLS_HOSTNAME}
         WEB_SCHEME: http
         WEB_PORT: "5000"
         EXTERNAL_WEB_PORT: "${DVLS_HOST_PORT}"
       extra_hosts:
         - "host.docker.internal:host-gateway"

   volumes:
     dvlsdata:
   ```

{% hint style="info" %}
`DATABASE_TRUST_SERVER_CERTIFICATE=true` accepte le certificat SQL Server sans le valider. Si votre SQL Server présente un certificat émis par une autorité de confiance, retirez cette variable. Consultez [Connexion chiffrée à la base de données (TLS)](https://docs.devolutions.net/server/fr/knowledge-base/how-to-articles/devolutions-server-docker-deployment/advanced-docker-configuration-for-devolutions-server.md#encrypted-database-connection-tls).
{% endhint %}

#### Démarrer le déploiement hybride

Exécutez les mêmes commandes que pour le déploiement tout-en-un, depuis le dossier de déploiement :

```powershell
docker compose --profile init pull
docker compose --profile init run --rm dvls-init
docker compose up -d
docker compose exec dvls sh -c "tail -n 50 -f /opt/devolutions/dvls/App_Data/DPS_Main*.log"
```

Si la commande d'initialisation ne se termine pas après l'affichage de `Initialization completed successfully.`, appuyez sur Ctrl+C avant d'exécuter `docker compose up -d`.

Connectez-vous ensuite à Devolutions Server, sauvegardez `encryption.config` avec la même commande `docker compose cp` que pour le déploiement tout-en-un, et déplacez le fichier vers un emplacement sécurisé à l'extérieur du dossier de déploiement.

### Déployer sur un autre serveur

Pour reproduire le déploiement sur un autre serveur Windows, suivez les étapes ci-dessous. Elles créent un nouveau déploiement vide : les données et la configuration de chiffrement du premier serveur ne sont pas copiées.

1. Installez Docker Desktop sur le serveur cible (consultez [Prérequis](#prerequisites)).
2. Créez un dossier et copiez-y les fichiers `docker-compose.yml` et `.env`. Modifiez les mots de passe dans `.env` au besoin.
3. Exécutez `Get-ChildItem` dans le dossier et assurez-vous que les fichiers se nomment exactement `.env` et `docker-compose.yml`. Le Bloc-notes peut ajouter une extension `.txt` cachée.
4. Exécutez les commandes de [Démarrer le déploiement](#start-the-deployment).
5. Pour atteindre Devolutions Server depuis d'autres ordinateurs, définissez `DVLS_HOSTNAME` au nom de domaine complet du serveur et autorisez le port `DVLS_HOST_PORT` dans le pare-feu Windows.

### Vérifier le déploiement

Exécutez les commandes suivantes depuis le dossier de déploiement. Les noms de conteneurs correspondent aux exemples ci-dessus.

| Vérification                                             | Commande                                                                                                                                   |
| -------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
| Les conteneurs sont en cours d'exécution et SQL est sain | `docker compose ps`                                                                                                                        |
| État de santé de SQL Server                              | `docker inspect --format '{{.State.Health.Status}}' dvls-sqlserver` (attendu : `healthy`)                                                  |
| Devolutions Server résout le service SQL                 | `docker exec dvls-app sh -c "getent hosts sqlserver"`                                                                                      |
| Devolutions Server atteint SQL sur le port 1433          | `docker exec dvls-app bash -c "(echo > /dev/tcp/sqlserver/1433) 2>&1 && echo OPEN \|\| echo BLOCKED"` (attendu : `OPEN`)                   |
| Devolutions Server a démarré correctement                | `docker exec dvls-app sh -c "grep -h -E 'Now listening\|Scheduler initialized' /opt/devolutions/dvls/App_Data/DPS_Main*.log \| tail -n 2"` |
| L'interface Web répond                                   | `curl.exe -s -o NUL -w "%{http_code}" http://localhost:5000/` (attendu : `200`)                                                            |

Pour le déploiement hybride, remplacez `sqlserver` par la valeur de `SQL_HOST` et `1433` par la valeur de `SQL_PORT`. Les deux lignes sur la santé de SQL Server ne s'appliquent pas, puisqu'il n'y a pas de conteneur SQL Server.

Si vous avez modifié `DVLS_HOST_PORT`, remplacez `5000` par sa valeur dans la dernière ligne.

### Résolution de problèmes

| Symptôme                                                                                              | Solution                                                                                                                                                                                                                                                                                                                                                                                              |
| ----------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `failed to resolve reference "docker.io/devolutions/devolutions-server:latest": not found`            | L'étiquette `latest` n'existe pas. Utilisez une étiquette `release-20XX.X` ou `20XX.X.X.X` (consultez [Choisir une étiquette d'image](#choose-an-image-tag)).                                                                                                                                                                                                                                         |
| `The "DVLS_IMAGE_TAG" variable is not set` ou `invalid reference format`                              | Il manque `DVLS_IMAGE_TAG` dans le fichier `.env`, ou celui-ci ne se nomme pas exactement `.env`. Ajoutez la ligne et assurez-vous que le fichier n'a pas d'extension `.txt`.                                                                                                                                                                                                                         |
| `DATABASE_HOST or AZURE_SQL_HOST is required.`                                                        | Le fichier compose utilise des variables d'environnement d'une version d'image plus ancienne. Utilisez les variables `DATABASE_*` présentées dans cet article, mappez le port de l'hôte au port de conteneur `5000`, et exécutez le service `dvls-init` avant le premier démarrage.                                                                                                                   |
| Le conteneur SQL Server ne devient jamais sain et le journal affiche `Password validation failed`     | `MSSQL_SA_PASSWORD` ne respecte pas la stratégie de mot de passe de SQL Server. Utilisez au moins 8 caractères avec des lettres majuscules, des lettres minuscules, des chiffres et des symboles.                                                                                                                                                                                                     |
| Le conteneur SQL Server reste `unhealthy` et le journal répète `Login failed for user 'sa'`           | `MSSQL_SA_PASSWORD` n'est appliqué que la première fois que le volume `mssqldata` est créé. Si le volume existait déjà, SQL Server a conservé le mot de passe précédent. Restaurez le mot de passe précédent dans `.env`, ou retirez les volumes comme décrit dans [Supprimer le déploiement](#remove-the-deployment) si les données peuvent être écartées.                                           |
| `dependency sqlserver failed to start`, ou l'état de santé alterne entre `starting` et `unhealthy`    | Le premier démarrage de SQL Server peut prendre jusqu'à deux minutes sur des disques plus lents. Conservez `retries: 30` et `start_period: 120s` dans le contrôle de santé, ou augmentez-les.                                                                                                                                                                                                         |
| Le conteneur SQL Server s'arrête juste après avoir démarré (mémoire insuffisante)                     | Augmentez la mémoire disponible pour Docker à au moins 4 Go dans Docker Desktop (**Paramètres** – **Ressources**).                                                                                                                                                                                                                                                                                    |
| L'interface Web renvoie une erreur pendant les premières minutes après `docker compose up -d`         | C'est attendu pendant que SQL Server termine son premier démarrage. Attendez, et suivez le journal de Devolutions Server avec `docker compose exec dvls sh -c "tail -n 50 -f /opt/devolutions/dvls/App_Data/DPS_Main*.log"`.                                                                                                                                                                          |
| `Bind for 0.0.0.0:5000 failed: port is already allocated`                                             | Un autre programme utilise le port 5000 sur l'hôte. Définissez une autre valeur pour `DVLS_HOST_PORT` dans `.env`. Pour voir quel programme utilise le port, exécutez `Get-NetTCPConnection -LocalPort 5000 -State Listen`.                                                                                                                                                                           |
| La commande `dvls-init` ne se termine pas après `Initialization completed successfully.`              | Appuyez sur Ctrl+C, puis passez à l'étape suivante.                                                                                                                                                                                                                                                                                                                                                   |
| `Unhandled exception. System.InvalidOperationException` à `CreateAdministrator` depuis `dvls-init`    | Le déploiement est déjà initialisé. Ignorez l'étape d'initialisation. Rien n'est modifié : la configuration de chiffrement et le mot de passe d'administrateur restent les mêmes.                                                                                                                                                                                                                     |
| `Login failed for user '<login>'` (erreur 18456) depuis `dvls-init`                                   | Vérifiez les valeurs `SQL_LOGIN` et `SQL_PASSWORD` dans `.env`, que la connexion existe et que le mode d'authentification SQL Server et Windows (mode mixte) est activé.                                                                                                                                                                                                                              |
| La page de connexion affiche `Unable to find the encryption file. Please contact your administrator.` | Le conteneur d'exécution ne possède pas la configuration de chiffrement créée à l'initialisation. Assurez-vous que `dvls-init` et `dvls` montent tous deux le même volume `dvlsdata` à `/opt/devolutions/dvls/App_Data`. Si la base de données contient déjà des données chiffrées avec une clé perdue, ces données ne peuvent pas être récupérées et le déploiement doit être initialisé de nouveau. |
| Le conteneur ne peut pas atteindre un SQL Server existant (option hybride)                            | Vérifiez que TCP/IP est activé, qu'un port statique est configuré, que le pare-feu Windows autorise le port et que l'entrée `extra_hosts` est présente lorsque `SQL_HOST` vaut `host.docker.internal`.                                                                                                                                                                                                |
| `docker` n'est pas reconnu dans PowerShell                                                            | Démarrez Docker Desktop, puis ouvrez une nouvelle fenêtre PowerShell afin que le `PATH` mis à jour soit chargé.                                                                                                                                                                                                                                                                                       |

### Mettre à jour Devolutions Server

Sauvegardez la base de données et `encryption.config` avant la mise à jour.

1. Ajoutez le service `dvls-update` suivant sous `services:` dans `docker-compose.yml`, et ajoutez `dvlsbackup:` sous `volumes:`. L'exemple utilise les valeurs du déploiement tout-en-un :

   ```yaml
     dvls-update:
       image: devolutions/devolutions-server:${DVLS_IMAGE_TAG}
       profiles: ["update"]
       volumes:
         - dvlsdata:/opt/devolutions/dvls/App_Data
         - dvlsbackup:/backup
       environment:
         DVLS_UPDATE_MODE: "true"
         DVLS_BACKUP_PATH: /backup
         DATABASE_HOST: sqlserver
         DATABASE_PORT: "1433"
         DATABASE_NAME: ${DATABASE_NAME}
         DATABASE_USERNAME: sa
         DATABASE_PASSWORD: ${MSSQL_SA_PASSWORD}
         DATABASE_ENCRYPT: "true"
         DATABASE_TRUST_SERVER_CERTIFICATE: "true"
       depends_on:
         sqlserver:
           condition: service_healthy
   ```

   Pour le déploiement hybride, utilisez les mêmes valeurs `DATABASE_*` que le service `dvls`, et remplacez `depends_on` par l'entrée `extra_hosts` du service `dvls`.
2. Arrêtez Devolutions Server :

   ```powershell
   docker compose stop dvls
   ```
3. Modifiez `DVLS_IMAGE_TAG` dans le fichier `.env`.
4. Téléchargez les nouvelles images et mettez à jour la base de données :

   ```powershell
   docker compose --profile update pull
   docker compose --profile update run --rm dvls-update
   ```
5. Attendez `Database update completed successfully.`, puis démarrez Devolutions Server avec la nouvelle version :

   ```powershell
   docker compose up -d
   ```

Pour les variables du mode de mise à jour, consultez [Configuration Docker avancée pour Devolutions Server](https://docs.devolutions.net/server/fr/knowledge-base/how-to-articles/devolutions-server-docker-deployment/advanced-docker-configuration-for-devolutions-server.md#version-updates).

### Supprimer le déploiement

Arrêtez et retirez les conteneurs tout en conservant la base de données et les données de Devolutions Server :

```powershell
docker compose down
```

{% hint style="danger" %}
La commande suivante supprime aussi les volumes. Cette action est irréversible.

* **Tout-en-un** : supprime les bases de données SQL Server et la configuration de chiffrement.
* **Hybride** : supprime seulement la configuration de chiffrement. La base de données reste sur votre SQL Server et ne peut plus être déchiffrée.

```powershell
docker compose --profile init down -v
```

{% endhint %}

#### Voir aussi

* [Déployer Devolutions Server avec Docker](https://docs.devolutions.net/server/fr/knowledge-base/how-to-articles/devolutions-server-docker-deployment.md)
* [Configuration Docker avancée pour Devolutions Server](https://docs.devolutions.net/server/fr/knowledge-base/how-to-articles/devolutions-server-docker-deployment/advanced-docker-configuration-for-devolutions-server.md)
* [Configuration de la base de données](https://docs.devolutions.net/server/fr/getting-started/installation/database-setup.md)
* [Liste de vérification de sécurité](https://docs.devolutions.net/server/fr/getting-started/security-checklist.md)


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.devolutions.net/server/fr/knowledge-base/how-to-articles/devolutions-server-docker-deployment/deploy-devolutions-server-and-sql-server-with-docker-compose-on-windows.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
