> 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.md).

# Déployer Devolutions Server avec Docker

Déployez Devolutions Server avec Docker sur SQL Server ou PostgreSQL, initialisation initiale, configuration du chiffrement, ports personnalisés et certificats TLS.

Cet article montre comment déployer Devolutions Server avec Docker et une base de données SQL Server ou PostgreSQL. L'image Docker de Devolutions Server est une image Linux offerte pour les plateformes `linux/amd64` et `linux/arm64`.

{% 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. Modifiez cette variable selon la version que vous souhaitez utiliser.
{% endhint %}

### Prérequis

* Docker version `20.10.X` ou ultérieure.
* Une instance de base de données :
  * Une instance SQL Server, y compris Azure SQL Database, correctement [configurée pour Devolutions Server](/server/fr/getting-started/installation/database-setup.md).
  * Ou une instance [PostgreSQL](/server/fr/getting-started/installation/database-setup/database-instance/postgresql.md) 14 ou ultérieure, auto-hébergée ou gérée, avec un rôle qui possède l'attribut `SUPERUSER`.
* Les [exigences système](/server/fr/overview-of-devolutions-server/system-requirements.md) minimales pour exécuter Devolutions Server.

### Préparer la base de données

Le conteneur se connecte à la base de données avec un seul compte, utilisé pour l'initialisation, les mises à niveau du schéma de base de données et le fonctionnement normal. Créez un compte dédié pour Devolutions Server plutôt que d'utiliser un compte administrateur tel que `sa` ou `postgres`.

#### SQL Server

À l'aide d'un compte administrateur (par exemple, `sa` ou un administrateur Azure SQL), créez une connexion dédiée et la base de données de Devolutions Server, puis ajoutez la connexion au rôle `db_owner` de cette base de données.

Si la base de données n'existe pas, l'initialisation la crée avec le classement `Latin1_General_CS_AS`, ce qui exige que la connexion ait la permission de créer des bases de données.

#### PostgreSQL

À l'aide d'un compte administrateur, créez un rôle de connexion dédié pour Devolutions Server. L'initialisation se connecte à la base de données de maintenance `postgres` pour vérifier si la base de données de Devolutions Server existe, donc le rôle a besoin du privilège `CONNECT` sur `postgres` (PostgreSQL l'accorde à tous les rôles par défaut).

{% hint style="warning" %}
Le rôle doit avoir l'attribut `SUPERUSER` pour créer le schéma de base de données pendant l'initialisation. La création du schéma modifie les transtypages de PostgreSQL, ce que seul un superutilisateur peut faire.
{% endhint %}

```sql
CREATE ROLE dvls_user WITH LOGIN SUPERUSER PASSWORD 'YourSecurePassword!';
```

Après l'initialisation, les mises à niveau du schéma et le fonctionnement normal de Devolutions Server ne requièrent pas l'attribut `SUPERUSER`. Pour limiter les privilèges du rôle, retirez l'attribut. Le rôle demeure le propriétaire de la base de données :

```sql
ALTER ROLE dvls_user NOSUPERUSER;
```

### Variables de connexion à la base de données

Les exemples de cet article se connectent à SQL Server. Pour vous connecter à PostgreSQL, ajoutez `-e DATABASE_TYPE=PostgreSQL` et `-e DATABASE_ENCRYPT=true` aux commandes d'initialisation et d'exécution, et définissez `DATABASE_HOST` au nom du serveur PostgreSQL. Les autres variables sont les mêmes pour les deux moteurs de base de données.

| Variable                            | SQL Server                                                                                   | PostgreSQL                                                                                                                       |
| ----------------------------------- | -------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
| `DATABASE_TYPE`                     | `SqlServer` (par défaut).                                                                    | `PostgreSQL`.                                                                                                                    |
| `DATABASE_HOST`                     | Nom du serveur. Un port peut être ajouté au format `host,port`.                              | Nom du serveur. Un port peut être ajouté au format `host:port`, qui a préséance sur `DATABASE_PORT`.                             |
| `DATABASE_PORT`                     | `1433` (par défaut).                                                                         | `5432` (par défaut).                                                                                                             |
| `DATABASE_ENCRYPT`                  | `true` chiffre la connexion. Valeur par défaut : `false`.                                    | `true` chiffre la connexion et valide le certificat du serveur. Valeur par défaut : `false` (non chiffré).                       |
| `DATABASE_TRUST_SERVER_CERTIFICATE` | `true` fait confiance au certificat du serveur sans le valider. Valeur par défaut : `false`. | Avec `DATABASE_ENCRYPT=true`, `true` conserve le chiffrement sans valider le certificat du serveur. Valeur par défaut : `false`. |

{% hint style="warning" %}
Avec PostgreSQL, la valeur par défaut `DATABASE_ENCRYPT=false` désactive SSL : la connexion à la base de données n'est pas chiffrée. Avec `DATABASE_ENCRYPT=true`, le certificat du serveur PostgreSQL doit être émis par une autorité de certification approuvée dans le conteneur et correspondre au nom `DATABASE_HOST`. Sinon, définissez aussi `DATABASE_TRUST_SERVER_CERTIFICATE=true`.
{% endhint %}

La liste complète des variables se trouve dans [Configuration Docker avancée pour Devolutions Server](/server/fr/knowledge-base/how-to-articles/devolutions-server-docker-deployment/advanced-docker-configuration-for-devolutions-server.md).

### Configuration initiale de Devolutions Server

{% tabs %}
{% tab title="Windows" %}

1. Téléchargez la dernière [image Docker de Devolutions Server](https://hub.docker.com/r/devolutions/devolutions-server) :

   ```powershell
   docker pull devolutions/devolutions-server:release-20XX.X
   ```
2. Exécutez Devolutions Server en mode initialisation pour créer la base de données si elle n'existe pas, créer son schéma et son premier administrateur, générer les clés de chiffrement et configurer HTTPS avec un certificat auto-signé. Le volume `dvls-init-data` conserve `App_Data` afin que la configuration de chiffrement puisse être extraite par la suite. Avec PostgreSQL, ajoutez `-e DATABASE_TYPE=PostgreSQL` et `-e DATABASE_ENCRYPT=true`, et définissez `DATABASE_HOST` au nom du serveur PostgreSQL.

   ```powershell
   docker volume create dvls-init-data

   docker run --rm `
     -e DATABASE_HOST=your-sql-server.database.windows.net `
     -e DATABASE_NAME=dvls `
     -e DATABASE_USERNAME=dvls_user `
     -e DATABASE_PASSWORD='YourSecurePassword!' `
     -e HOSTNAME=localhost `
     -e WEB_SCHEME=https `
     -e PORT=5000 `
     -e DVLS_INIT=true `
     -v dvls-init-data:/opt/devolutions/dvls/App_Data `
     -p 5000:5000 `
     devolutions/devolutions-server:release-20XX.X
   ```
3. Attendez le message `Initialization completed successfully.`, puis appuyez sur <kbd>Ctrl</kbd>+<kbd>C</kbd> pour arrêter le conteneur. Après l'initialisation, le conteneur continue d'exécuter Devolutions Server jusqu'à ce qu'il soit arrêté. L'option `--rm` supprime le conteneur et conserve le volume `dvls-init-data`.
4. Extrayez `encryption.config` du volume d'initialisation et convertissez-le en base64. Conservez le fichier `encryption.config.b64` en lieu sûr : chaque démarrage en exécution en a besoin.

   ```powershell
   docker run --rm `
     -v dvls-init-data:/data `
     alpine `
     cat /data/encryption.config > $env:TEMP\encryption.config

   $content = Get-Content -Path "$env:TEMP\encryption.config" -Raw
   $bytes = [System.Text.Encoding]::UTF8.GetBytes($content)
   $base64 = [System.Convert]::ToBase64String($bytes)
   $base64 | Out-File -FilePath "$env:TEMP\encryption.config.b64" -NoNewline -Encoding ASCII
   ```
5. Démarrez Devolutions Server en mode exécution avec la configuration de chiffrement en base64. Avec PostgreSQL, ajoutez les mêmes variables `DATABASE_TYPE` et `DATABASE_ENCRYPT` que dans la commande d'initialisation. Une fois cela fait, utilisez les commandes `docker ps` et `docker logs dvls-server` pour vous assurer que tout fonctionne.

   ```powershell
   $encryptionConfig = Get-Content "$env:TEMP\encryption.config.b64" -Raw

   docker run -d --name dvls-server `
     -e DATABASE_HOST=your-sql-server.database.windows.net `
     -e DATABASE_NAME=dvls `
     -e DATABASE_USERNAME=dvls_user `
     -e DATABASE_PASSWORD='YourSecurePassword!' `
     -e HOSTNAME=localhost `
     -e WEB_SCHEME=https `
     -e PORT=5000 `
     -e DVLS_ENCRYPTION_CONFIG_B64="$encryptionConfig" `
     -p 5000:5000 `
     devolutions/devolutions-server:release-20XX.X
   ```
6. Accédez à l'interface Web en ouvrant `https://localhost:5000` dans votre navigateur. Passez l'avertissement de sécurité du certificat auto-signé en cliquant sur ***Avancé*** – ***Continuer***. Un certificat TLS personnalisé peut être monté plus tard.
7. Connectez-vous en utilisant `dvls-admin` comme nom d’utilisateur et comme mot de passe. Devolutions Server exige ensuite un nouveau mot de passe pour ce compte.
8. Assurez-vous que Devolutions Server s'exécute avec `DVLS_ENCRYPTION_CONFIG_B64`, que son interface Web est accessible et que `encryption.config.b64` est enregistré dans un emplacement sécurisé (il est nécessaire à chaque redémarrage et redéploiement). Une fois cela fait, supprimez le volume d'initialisation temporaire :

   ```powershell
   docker volume rm dvls-init-data
   ```

{% endtab %}

{% tab title="macOS" %}

1. Téléchargez la dernière [image Docker de Devolutions Server](https://hub.docker.com/r/devolutions/devolutions-server) :

   ```bash
   docker pull devolutions/devolutions-server:release-20XX.X
   ```
2. Exécutez Devolutions Server en mode initialisation pour créer la base de données si elle n'existe pas, créer son schéma et son premier administrateur, générer les clés de chiffrement et configurer HTTPS avec un certificat auto-signé. Le volume `dvls-init-data` conserve `App_Data` afin que la configuration de chiffrement puisse être extraite par la suite. Avec PostgreSQL, ajoutez `-e DATABASE_TYPE=PostgreSQL` et `-e DATABASE_ENCRYPT=true`, et définissez `DATABASE_HOST` au nom du serveur PostgreSQL.

   ```bash
   docker volume create dvls-init-data

   docker run --rm \
     -e DATABASE_HOST=your-sql-server.database.windows.net \
     -e DATABASE_NAME=dvls \
     -e DATABASE_USERNAME=dvls_user \
     -e DATABASE_PASSWORD='YourSecurePassword!' \
     -e HOSTNAME=localhost \
     -e WEB_SCHEME=https \
     -e PORT=5000 \
     -e DVLS_INIT=true \
     -v dvls-init-data:/opt/devolutions/dvls/App_Data \
     -p 5000:5000 \
     devolutions/devolutions-server:release-20XX.X
   ```
3. Attendez le message `Initialization completed successfully.`, puis appuyez sur <kbd>Ctrl</kbd>+<kbd>C</kbd> pour arrêter le conteneur. Après l'initialisation, le conteneur continue d'exécuter Devolutions Server jusqu'à ce qu'il soit arrêté. L'option `--rm` supprime le conteneur et conserve le volume `dvls-init-data`.
4. Extrayez `encryption.config` du volume d'initialisation et convertissez-le en base64. Conservez le fichier `encryption.config.b64` en lieu sûr : chaque démarrage en exécution en a besoin.

   ```bash
   docker run --rm \
     -v dvls-init-data:/data \
     alpine \
     cat /data/encryption.config > /tmp/encryption.config

   base64 -i /tmp/encryption.config -o /tmp/encryption.config.b64
   ```
5. Démarrez Devolutions Server en mode exécution avec la configuration de chiffrement en base64. Avec PostgreSQL, ajoutez les mêmes variables `DATABASE_TYPE` et `DATABASE_ENCRYPT` que dans la commande d'initialisation. Une fois cela fait, utilisez les commandes `docker ps` et `docker logs dvls-server` pour vous assurer que tout fonctionne.

   ```bash
   docker run -d --name dvls-server \
     -e DATABASE_HOST=your-sql-server.database.windows.net \
     -e DATABASE_NAME=dvls \
     -e DATABASE_USERNAME=dvls_user \
     -e DATABASE_PASSWORD='YourSecurePassword!' \
     -e HOSTNAME=localhost \
     -e WEB_SCHEME=https \
     -e PORT=5000 \
     -e DVLS_ENCRYPTION_CONFIG_B64="$(cat /tmp/encryption.config.b64)" \
     -p 5000:5000 \
     devolutions/devolutions-server:release-20XX.X
   ```
6. Accédez à l'interface Web en ouvrant `https://localhost:5000` dans votre navigateur. Passez l'avertissement de sécurité du certificat auto-signé en cliquant sur ***Avancé*** – ***Continuer***. Un certificat TLS personnalisé peut être monté plus tard.
7. Connectez-vous en utilisant `dvls-admin` comme nom d’utilisateur et comme mot de passe. Devolutions Server exige ensuite un nouveau mot de passe pour ce compte.
8. Assurez-vous que Devolutions Server s'exécute avec `DVLS_ENCRYPTION_CONFIG_B64`, que son interface Web est accessible et que `encryption.config.b64` est enregistré dans un emplacement sécurisé (il est nécessaire à chaque redémarrage et redéploiement). Une fois cela fait, supprimez le volume d'initialisation temporaire :

   ```bash
   docker volume rm dvls-init-data
   ```

{% endtab %}

{% tab title="Linux" %}

1. Téléchargez la dernière [image Docker de Devolutions Server](https://hub.docker.com/r/devolutions/devolutions-server) :

   ```bash
   docker pull devolutions/devolutions-server:release-20XX.X
   ```
2. Exécutez Devolutions Server en mode initialisation pour créer la base de données si elle n'existe pas, créer son schéma et son premier administrateur, générer les clés de chiffrement et configurer HTTPS avec un certificat auto-signé. Le volume `dvls-init-data` conserve `App_Data` afin que la configuration de chiffrement puisse être extraite par la suite. Avec PostgreSQL, ajoutez `-e DATABASE_TYPE=PostgreSQL` et `-e DATABASE_ENCRYPT=true`, et définissez `DATABASE_HOST` au nom du serveur PostgreSQL.

   ```bash
   docker volume create dvls-init-data

   docker run --rm \
     -e DATABASE_HOST=your-sql-server.database.windows.net \
     -e DATABASE_NAME=dvls \
     -e DATABASE_USERNAME=dvls_user \
     -e DATABASE_PASSWORD='YourSecurePassword!' \
     -e HOSTNAME=localhost \
     -e WEB_SCHEME=https \
     -e PORT=5000 \
     -e DVLS_INIT=true \
     -v dvls-init-data:/opt/devolutions/dvls/App_Data \
     -p 5000:5000 \
     devolutions/devolutions-server:release-20XX.X
   ```
3. Attendez le message `Initialization completed successfully.`, puis appuyez sur <kbd>Ctrl</kbd>+<kbd>C</kbd> pour arrêter le conteneur. Après l'initialisation, le conteneur continue d'exécuter Devolutions Server jusqu'à ce qu'il soit arrêté. L'option `--rm` supprime le conteneur et conserve le volume `dvls-init-data`.
4. Extrayez `encryption.config` du volume d'initialisation et convertissez-le en base64. Conservez le fichier `encryption.config.b64` en lieu sûr : chaque démarrage en exécution en a besoin.

   ```bash
   docker run --rm \
     -v dvls-init-data:/data \
     alpine \
     cat /data/encryption.config > /tmp/encryption.config

   base64 -w 0 /tmp/encryption.config > /tmp/encryption.config.b64
   ```
5. Démarrez Devolutions Server en mode exécution avec la configuration de chiffrement en base64. Avec PostgreSQL, ajoutez les mêmes variables `DATABASE_TYPE` et `DATABASE_ENCRYPT` que dans la commande d'initialisation. Une fois cela fait, utilisez les commandes `docker ps` et `docker logs dvls-server` pour vous assurer que tout fonctionne.

   ```bash
   docker run -d --name dvls-server \
     -e DATABASE_HOST=your-sql-server.database.windows.net \
     -e DATABASE_NAME=dvls \
     -e DATABASE_USERNAME=dvls_user \
     -e DATABASE_PASSWORD='YourSecurePassword!' \
     -e HOSTNAME=localhost \
     -e WEB_SCHEME=https \
     -e PORT=5000 \
     -e DVLS_ENCRYPTION_CONFIG_B64="$(cat /tmp/encryption.config.b64)" \
     -p 5000:5000 \
     devolutions/devolutions-server:release-20XX.X
   ```
6. Accédez à l'interface Web en ouvrant `https://localhost:5000` dans votre navigateur. Passez l'avertissement de sécurité du certificat auto-signé en cliquant sur ***Avancé*** – ***Continuer***. Un certificat TLS personnalisé peut être monté plus tard.
7. Connectez-vous en utilisant `dvls-admin` comme nom d’utilisateur et comme mot de passe. Devolutions Server exige ensuite un nouveau mot de passe pour ce compte.
8. Assurez-vous que Devolutions Server s'exécute avec `DVLS_ENCRYPTION_CONFIG_B64`, que son interface Web est accessible et que `encryption.config.b64` est enregistré dans un emplacement sécurisé (il est nécessaire à chaque redémarrage et redéploiement). Une fois cela fait, supprimez le volume d'initialisation temporaire :

   ```bash
   docker volume rm dvls-init-data
   ```

{% endtab %}
{% endtabs %}

{% hint style="warning" %}
Exécutez l'initialisation une seule fois par base de données. L'exécuter de nouveau sur une base de données déjà initialisée échoue, car le compte administrateur existe déjà.
{% endhint %}

### Modes de fonctionnement

Le conteneur Devolutions Server fonctionne selon trois modes distincts :

| Mode                           | Variable d'environnement | Objectif                            | Comportement                                                                                                                                                          |
| ------------------------------ | ------------------------ | ----------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Exécution** **(par défaut)** | Aucune variable spéciale | Fonctionnement normal               | Applique les mises à niveau du schéma de base de données en attente, puis démarre le serveur Web et continue de s'exécuter.                                           |
| **Initialisation**             | `DVLS_INIT=true`         | Configuration initiale              | Crée la base de données si elle n'existe pas, son schéma, les clés de chiffrement et le compte administrateur, puis démarre le serveur Web et continue de s'exécuter. |
| **Mise à jour**                | `DVLS_UPDATE_MODE=true`  | Mise à niveau de la base de données | Sauvegarde les fichiers de configuration et le dossier d'installation, migre la base de données, puis se termine.                                                     |

{% hint style="info" %}
Les modes **Initialisation** et **Mise à jour** sont mutuellement exclusifs.

Pour démarrer le mode exécution sans appliquer les mises à niveau du schéma en attente, définissez `DVLS_DATABASE_UPGRADE_ON_STARTUP=false`.
{% endhint %}

{% hint style="warning" %}
Le mode mise à jour ne sauvegarde pas les bases de données SQL Server ni PostgreSQL. Sauvegardez la base de données avant de l'exécuter, par exemple avec `BACKUP DATABASE` sur SQL Server ou `pg_dump` sur PostgreSQL.
{% endhint %}

{% hint style="warning" %}
L'image Devolutions Server n'inclut pas les outils client PostgreSQL `pg_dump` et `pg_restore`, que la tâche de sauvegarde de données intégrée utilise avec PostgreSQL. Pour utiliser cette tâche, créez une image dérivée qui installe le paquet `postgresql-client`, avec une version majeure égale ou supérieure à celle du serveur PostgreSQL, ou montez les outils dans le conteneur et définissez leurs chemins complets dans les variables `DVLS_PG_DUMP_PATH` et `DVLS_PG_RESTORE_PATH`.
{% endhint %}

### Port personnalisé

Devolutions Server écoute sur le port `5000` par défaut. Pour le changer, définissez la variable d'environnement `PORT` et publiez le même port dans la commande `docker run`. Par exemple, pour utiliser le port `8080`, remplacez `-e PORT=5000` et `-p 5000:5000` par `-e PORT=8080` et `-p 8080:8080`, puis ouvrez `https://localhost:8080`.

`PORT` a préséance sur `WEB_PORT`. La variable `ASPNETCORE_URLS` n'a aucun effet : le conteneur définit l'adresse d'écoute à partir de `WEB_SCHEME` et `PORT`.

### Monter un certificat TLS personnalisé

Montez vos propres fichiers de certificat plutôt que d'utiliser le certificat auto-signé généré automatiquement :

1. Copiez le certificat et sa clé privée, au format PEM, dans un dossier de l'hôte Docker, par exemple `/host/path/certs`.
2. Ajoutez ces options à la commande d'exécution, avec `WEB_SCHEME=https` et `HOSTNAME` défini au nom figurant dans le certificat (par exemple, `devolutions-server.company.com`) :

   ```bash
   -e TLS_CERTIFICATE_FILE=/opt/devolutions/dvls/certs/server.pem
   -e TLS_PRIVATE_KEY_FILE=/opt/devolutions/dvls/certs/server.key
   -v /host/path/certs:/opt/devolutions/dvls/certs:ro
   ```

{% hint style="info" %}
Si aucun des deux fichiers n'est trouvé à ces chemins, Devolutions Server génère plutôt un certificat auto-signé. Si un seul des deux fichiers est trouvé, le conteneur s'arrête avec une erreur.
{% endhint %}

### Gestion des conteneurs

| Commandes                  | Fonctions              |
| -------------------------- | ---------------------- |
| `docker start dvls-server` | Démarre le conteneur.  |
| `docker stop dvls-server`  | Arrête le conteneur.   |
| `docker rm dvls-server`    | Supprime le conteneur. |

{% hint style="info" %}
Supprimer le conteneur est sans risque tant que vous avez le fichier `encryption.config.b64`, l'accès à votre base de données et vos variables d'environnement documentées.
{% endhint %}

#### Voir aussi

* [Liste de vérification de la sécurité](/server/fr/getting-started/security-checklist.md)
* [PostgreSQL](/server/fr/getting-started/installation/database-setup/database-instance/postgresql.md)
* [Déploiement de Devolutions Server sur Azure App Service à l'aide d'un conteneur](/server/fr/knowledge-base/how-to-articles/devolutions-server-docker-deployment/devolutions-server-deployment-to-azure-app-service-using-a-container.md)
* [Configuration Docker avancée pour Devolutions Server](/server/fr/knowledge-base/how-to-articles/devolutions-server-docker-deployment/advanced-docker-configuration-for-devolutions-server.md)
* [Déployer Devolutions Server et SQL Server avec Docker Compose sur Windows](/server/fr/knowledge-base/how-to-articles/devolutions-server-docker-deployment/deploy-devolutions-server-and-sql-server-with-docker-compose-on-windows.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.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.