> 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/powershell-universal/fr/getting-started/docker/docker-compose-postgresql.md).

# Déployer PowerShell Universal avec PostgreSQL à l'aide de Docker Compose

Exécutez PowerShell Universal avec une base de données PostgreSQL sur Windows à l'aide de Docker Compose, avec des contrôles de santé, des volumes persistants, des étapes de vérification et le dépanna

Cet article explique comment exécuter PowerShell Universal et une base de données PostgreSQL sous forme de deux conteneurs Linux sur un ordinateur Windows avec Docker Compose. PowerShell Universal stocke ses données dans PostgreSQL plutôt que dans la base de données SQLite par défaut, et l'atteint par son nom de service sur le réseau Docker.

Pour des informations générales sur l'image de conteneur PowerShell Universal, consultez [Docker](https://docs.devolutions.net/powershell-universal/fr/getting-started/docker.md).

### Prérequis

* [Docker Desktop](https://docs.docker.com/desktop/setup/install/windows-install/) pour Windows en mode **conteneurs Linux**, ou Docker Engine sur Linux.
* Docker Compose v2. Exécutez `docker compose version` pour confirmer qu'il est disponible.
* Au moins 2 Go de mémoire disponibles pour Docker.
* Ports `5000` (PowerShell Universal) et `5432` (PostgreSQL) libres sur l'hôte, ou d'autres ports de votre choix.

### Créer les fichiers de configuration

1. Créez un dossier vide pour le déploiement, par exemple `C:\psu`.
2. Dans ce dossier, créez un fichier nommé `.env` avec le contenu suivant, et remplacez la valeur entre chevrons :

   ```
   POSTGRES_PASSWORD=<StrongPostgresPassword>
   ```

{% hint style="warning" %}
Le fichier `.env` contient un mot de passe. Limitez-y l'accès et ne le placez pas dans le contrôle de version. Évitez les caractères `$` et `;` dans le mot de passe, car Docker Compose et la chaîne de connexion les interprètent.
{% endhint %}

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

   ```yaml
   services:
     postgres:
       image: postgres:16-alpine
       container_name: psu-postgres
       restart: unless-stopped
       environment:
         POSTGRES_USER: psu
         POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
         POSTGRES_DB: psu
       ports:
         - "5432:5432"
       volumes:
         - pgdata:/var/lib/postgresql/data
       healthcheck:
         test: ["CMD-SHELL", "pg_isready -U psu -d psu"]
         interval: 5s
         timeout: 5s
         retries: 20

     psu:
       image: devolutions/powershell-universal:latest
       container_name: psu-app
       restart: unless-stopped
       ports:
         - "5000:5000"
       volumes:
         - psudata:/data
       environment:
         Plugins__0: PostgreSQL
         Data__ConnectionString: "Host=postgres;Port=5432;Database=psu;Username=psu;Password=${POSTGRES_PASSWORD}"
         Data__RepositoryPath: /data/Repository
       depends_on:
         postgres:
           condition: service_healthy

   volumes:
     pgdata:
     psudata:
   ```

* `Plugins__0: PostgreSQL` active le module d'extension de base de données PostgreSQL, et `Data__ConnectionString` dirige PowerShell Universal vers le service `postgres`.
* Le contrôle de santé et `depends_on` font attendre PowerShell Universal jusqu'à ce que PostgreSQL accepte les connexions. Sans eux, PowerShell Universal peut échouer au premier démarrage.
* Le volume `pgdata` stocke la base de données, et le volume `psudata` stocke le dépôt PowerShell Universal (scripts, applis et fichiers de configuration).
* La publication du port `5432` n'est nécessaire que pour se connecter à PostgreSQL depuis l'hôte, par exemple avec `psql` ou pgAdmin. Retirez l'entrée `ports` du service `postgres` si vous n'en avez pas besoin.

{% hint style="info" %}
En production, épinglez les deux images à une version précise plutôt qu'à `latest` ou à une étiquette flottante. Les étiquettes disponibles sont indiquées sur Docker Hub pour [PowerShell Universal](https://hub.docker.com/r/devolutions/powershell-universal/tags) et [PostgreSQL](https://hub.docker.com/_/postgres/tags).
{% endhint %}

### Démarrer le déploiement

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

   ```powershell
   cd C:\psu
   ```
2. Téléchargez les images :

   ```powershell
   docker compose pull
   ```
3. Démarrez les conteneurs :

   ```powershell
   docker compose up -d
   ```
4. Vérifiez l'état des conteneurs et suivez les journaux de PowerShell Universal :

   ```powershell
   docker compose ps
   docker compose logs -f psu
   ```
5. Après environ 30 secondes, ouvrez `http://localhost:5000` dans un navigateur et terminez la configuration initiale.

{% hint style="info" %}
Cet exemple sert PowerShell Universal par HTTP. Avant de donner accès aux utilisateurs, configurez HTTPS, par exemple avec un proxy inverse.
{% endhint %}

### Vérifier le déploiement

Confirmez que PowerShell Universal a créé ses tables dans PostgreSQL :

```powershell
docker exec psu-postgres psql -U psu -d psu -c "\dt"
```

La commande liste les tables de PowerShell Universal. Si elle renvoie `Did not find any relations`, PowerShell Universal ne s'est pas encore connecté à la base de données ; consultez les journaux avec `docker compose logs psu`.

Pour lister les connexions actives provenant de PowerShell Universal :

```powershell
docker exec psu-postgres psql -U psu -d psu -c "SELECT pid, application_name, client_addr, state FROM pg_stat_activity WHERE datname='psu';"
```

### Déployer sur un autre serveur

1. Installez Docker sur le serveur cible (consultez [Prérequis](#prerequisites)).
2. Copiez les fichiers `docker-compose.yml` et `.env` dans un nouveau dossier. Assurez-vous que les fichiers se nomment exactement `.env` et `docker-compose.yml`, sans extension `.txt` masquée.
3. Exécutez les commandes de [Démarrer le déploiement](#start-the-deployment).

Selon le serveur cible :

| Situation                                                      | Action                                                                                                |
| -------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------- |
| Le port `5000` ou `5432` est déjà utilisé                      | Changez le port hôte (la valeur de gauche) dans les entrées `ports`, par exemple `"8080:5000"`.       |
| Les utilisateurs doivent y accéder depuis d'autres ordinateurs | Autorisez le port hôte de PowerShell Universal dans le pare-feu du serveur.                           |
| Plusieurs déploiements sur le même hôte                        | Utilisez un dossier par déploiement, avec des valeurs `container_name` et des ports hôtes différents. |

### Dépannage

| Message dans `docker compose logs psu`                             | Solution                                                                                                                                                                                                                                                                             |
| ------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `Failed to connect to postgres:5432` avec un délai d'expiration    | PostgreSQL n'était pas prêt. Assurez-vous que le service `psu` possède `depends_on` avec `condition: service_healthy`.                                                                                                                                                               |
| `password authentication failed for user "psu"` (SQLSTATE `28P01`) | Le mot de passe dans la chaîne de connexion ne correspond pas au mot de passe PostgreSQL. PostgreSQL n'applique `POSTGRES_PASSWORD` que la première fois que le volume `pgdata` est créé ; si vous l'avez modifié ensuite, restaurez le mot de passe précédent ou recréez le volume. |
| `no pg_hba.conf entry for host` (SQLSTATE `28000`)                 | Un fichier `pg_hba.conf` personnalisé refuse la connexion. Ajoutez une règle autorisant le conteneur PowerShell Universal, ou utilisez la configuration par défaut.                                                                                                                  |
| `sorry, too many clients already` (SQLSTATE `53300`)               | PostgreSQL a atteint sa limite `max_connections`. Augmentez la limite ou réduisez les autres connexions à la base de données.                                                                                                                                                        |
| Une erreur indiquant que le chemin du dépôt n'existe pas           | Le volume ou le dossier monté pour `Data__RepositoryPath` est absent ou non accessible en écriture. Vérifiez l'entrée `volumes` du service `psu`.                                                                                                                                    |

### Sauvegarder la base de données

Créez une sauvegarde de la base de données PostgreSQL et copiez-la sur l'hôte :

```powershell
docker exec psu-postgres pg_dump -U psu -d psu -F c -f /tmp/psu.dump
docker cp psu-postgres:/tmp/psu.dump .\psu.dump
```

Pour la restaurer :

```powershell
docker cp .\psu.dump psu-postgres:/tmp/psu.dump
docker exec psu-postgres pg_restore -U psu -d psu --clean --if-exists /tmp/psu.dump
```

### Retirer le déploiement

Arrêtez et retirez les conteneurs tout en conservant les données :

```powershell
docker compose down
```

{% hint style="danger" %}
La commande suivante supprime aussi les volumes, y compris la base de données PostgreSQL et le dépôt PowerShell Universal. Cette action est irréversible.

```powershell
docker compose down -v
```

{% endhint %}

#### Voir aussi

* [Docker](https://docs.devolutions.net/powershell-universal/fr/getting-started/docker.md)
* [Mise à niveau](https://docs.devolutions.net/powershell-universal/fr/getting-started/upgrading.md)
* [Migrer et restaurer](https://docs.devolutions.net/powershell-universal/fr/getting-started/migration.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/powershell-universal/fr/getting-started/docker/docker-compose-postgresql.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.
