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

# Docker

Installer et configurer PowerShell Universal dans Docker, en couvrant les images de conteneur, Docker Compose, les Dockerfiles personnalisés, la persistance des volumes et les tags pris en charge.

## Docker

### Confirmer que Docker est installé correctement

> **REMARQUE :** Appareils Apple M1 : au moment de la rédaction, certains problèmes existent sur les appareils Apple M1 et sur certains appareils ARM64/ARMv8. Veuillez consulter [le forum PowerShell Universal](https://forum.devolutions.net/product/powershell-universal) avant de continuer.

#### Docker

Exécutez la commande suivante pour confirmer que Docker est installé :

```
docker version
```

Exemple de sortie :

```
Client: Docker Engine - Community
 Version:           23.0.1
 API version:       1.42
 Go version:        go1.19.5
 Git commit:        a5ee5b1
 Built:             Thu Feb  9 19:47:01 2023
 OS/Arch:           linux/amd64
 Context:           default

Server: Docker Engine - Community
 Engine:
  Version:          23.0.1
  API version:      1.42 (minimum version 1.12)
  Go version:        go1.19.5
  Git commit:        bc3805a
  Built:            Thu Feb  9 19:47:01 2023
  OS/Arch:          linux/amd64
  Experimental:     false
 containerd:
  Version:          1.6.18
  GitCommit:        2456e983eb9e37e47538f59ea18f2043c9a73640
 runc:
  Version:          1.1.4
  GitCommit:        v1.1.4-0-g5fd4c4d
 docker-init:
  Version:          0.19.0
  GitCommit:        de40ad0

```

#### Docker Compose

Docker Compose v1 utilise la commande `docker-compose`. Depuis juin 2023, la prise en charge de Docker Compose v1 est terminée.

Docker Compose v2 utilise la commande `docker compose`.

Si vous utilisez Docker Compose v1, veuillez ajuster les commandes en conséquence. Vous trouverez plus d'information sur Docker Compose [ici](https://docs.docker.com/compose/).

Exécutez l'une des commandes suivantes pour confirmer que Docker Compose est installé :

Docker Compose v1 :

```
docker-compose version
```

Docker Compose v2 :

```
docker compose version
```

Exemple de sortie :

```
Docker Compose version v2.16.0
```

#### Un Hello-World Docker

Pour vous assurer que Docker est en mesure d'extraire et d'exécuter des images de conteneur, exécutez la commande suivante :

```
docker run hello-world
```

Exemple de sortie :

```
Unable to find image 'hello-world:latest' locally
latest: Pulling from library/hello-world
2db29710123e: Pull complete 
Digest: sha256:ffb13da98453e0f04d33a6eee5bb8e46ee50d08ebe17735fc0779d0349e889e9
Status: Downloaded newer image for hello-world:latest

Hello from Docker!
This message shows that your installation appears to be working correctly.

To generate this message, Docker took the following steps:
 1. The Docker client contacted the Docker daemon.
 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
    (amd64)
 3. The Docker daemon created a new container from that image which runs the
    executable that produces the output you are currently reading.
 4. The Docker daemon streamed that output to the Docker client, which sent it
    to your terminal.

To try something more ambitious, you can run an Ubuntu container with:
 $ docker run -it ubuntu bash

Share images, automate workflows, and more with a free Docker ID:
 https://hub.docker.com/

For more examples and ideas, visit:
 https://docs.docker.com/get-started/
```

### Installation

### Utiliser le conteneur préconstruit

Pour exécuter PowerShell Universal, utilisez l'image de conteneur fournie. L'image docker est disponible sur [Docker Hub](https://hub.docker.com/r/devolutions/powershell-universal).

La version préconstruite prend en charge les fonctionnalités gratuites et payantes de PowerShell Universal.

Démarrez le conteneur en extrayant l'image, puis en exécutant un conteneur avec le port par défaut lié.

#### Exécuter une image de base

```
docker pull devolutions/powershell-universal
docker run --name 'PSU' -it -p 5000:5000 devolutions/powershell-universal
```

#### Présenter une image sur un port différent

Si le port 5000 n'est pas disponible sur votre hôte, utilisez un autre port.

p. ex. Présenter sur le port 80

```
docker pull devolutions/powershell-universal
docker run --name 'PSU' -it -p 80:5000 devolutions/powershell-universal
```

#### Monter un volume

La commande `docker run` vous permet de monter un volume pour le stockage persistant. Montez le volume dans le dossier /root.

**Monter un volume sur un conteneur sous Windows**

La commande suivante monte le dossier `C:\docker\volumes\PSU` dans `/root` sur votre conteneur :

```
docker pull devolutions/powershell-universal
docker run --name 'PSU' -it -p 5000:5000 -v C:\docker\volumes\PSU:/root devolutions/powershell-universal 
```

**Monter un volume sur un conteneur sous Mac et Linux**

La commande suivante monte le dossier `/docker/volumes/PSU` dans `/root` sur votre conteneur :

```
docker pull devolutions/powershell-universal
docker run --name 'PSU' -it -p 5000:5000 -v /docker/volumes/PSU:/root devolutions/powershell-universal 
```

#### Arrêter un conteneur

La commande suivante arrête un conteneur en cours d'exécution nommé `PSU` :

```
docker stop PSU
```

#### Supprimer un conteneur

La commande suivante supprime un conteneur arrêté nommé `PSU` :

```
docker rm PSU
```

L'indicateur `--force` peut supprimer un conteneur en cours d'exécution :

```
docker rm --force PSU
```

### Docker Compose

Docker Compose vous permet d'utiliser un fichier texte yaml pour normaliser votre génération et scripter le déploiement (ou la génération) de plusieurs conteneurs.

Le nom par défaut de tout fichier compose est `docker-compose.yml`. Il est recommandé de l'utiliser comme nom de fichier compose.

#### Créer un script Compose pour Windows

Le fichier compose suivant exécute un conteneur PowerShell Universal sous Windows :

```yml
version: "5.2.1"
services:
  PSU:
    container_name: PSU
    image: devolutions/powershell-universal:latest
    ports:
      - 5000:5000
    restart: unless-stopped
    environment:
      - TZ=Europe/London
    volumes:
      - C:\docker\volumes\PSU:/root
```

#### Créer un script Compose pour Mac / Linux

Le fichier compose suivant exécute un conteneur PowerShell Universal sous Mac et Linux :

```yml
version: "5.2.1"
services:
  PSU:
    container_name: PSU
    image: devolutions/powershell-universal:latest
    ports:
      - 5000:5000
    restart: unless-stopped
    environment:
      - TZ=Europe/London
    volumes:
      - /docker/volumes/PSU:/root
```

#### Démarrer des conteneurs à l'aide de scripts Compose

À l'aide d'un shell Terminal ou de PowerShell pour Windows. Utilisez la commande cd pour changer le répertoire de travail vers celui contenant votre script `docker-compose.yml`.

Exécutez la commande suivante :

```
docker compose up -d
```

Exemple de sortie :

```
Creating network "PSU_default" with the default driver
Pulling PSU (devolutions/powershell-universal:latest)...
latest: Pulling from devolutions/powershell-universal
7608715873ec: Pull complete
4e66273c6cfb: Pull complete
2649c52300c2: Pull complete
a20175666bc7: Pull complete
65ce93bc0653: Pull complete
Digest: sha256:d7ff98e6197d21070aac325c2efbefa393a4952d2e8ba6b1327dc97824ec4d55
Status: Downloaded newer image for devolutions/powershell-universal:latest
Creating PSU ... done
```

#### Arrêter des conteneurs à l'aide de scripts Compose

À l'aide d'un shell Terminal ou de PowerShell pour Windows. Utilisez cd pour accéder au répertoire contenant votre script `docker-compose.yml`.

Exécutez la commande suivante

```
docker compose down
```

Exemple de sortie :

```
[+] Running 2/2
 ⠿ Container PSU         Removed                                           0.5s
 ⠿ Network PSU_default   Removed                                           0.4s
```

#### Utiliser des variables d'environnement et la persistance SQL

Vous pouvez ajouter des variables d'environnement dans vos scripts Compose. Voici un exemple de :

* Définition d'un nom de nœud
* Ajout de la persistance SQL
* Ajout d'une chaîne de connexion SQL

```yaml
version: "5.2.1"
services:
  PSU:
    container_name: PSU
    image: devolutions/powershell-universal:latest
    ports:
      - 5000:5000
    restart: unless-stopped
    environment:
      - TZ=Europe/London
      - Plugins__0=SQL
      - Data__ConnectionString=Data Source=sql1.domain.com;Initial Catalog=PSUTicketBridge;User Id=psu_ticketbridge_dbo;******;TrustServerCertificate=True;Trusted_Connection=True;integrated security=false;
      - NodeName=mynodename
    volumes:
      - /docker/volumes/PSU:/root
```

#### Utiliser des variables d'environnement et la persistance PostgreSQL

Vous pouvez ajouter des variables d'environnement dans vos scripts Compose. Voici un exemple de :

* Définition d'un nom de nœud
* Ajout de la persistance PostgreSQL
* Ajout d'une chaîne de connexion PostgreSQL

```yaml
version: "5.2.1"
services:
  PSU:
    container_name: PSU
    image: devolutions/powershell-universal:latest
    ports:
      - 5000:5000
    restart: unless-stopped
    environment:
      - TZ=Europe/London
      - Plugins__0=PostgreSQL
      - Data__ConnectionString=Host=PGhostname; Database=PGdatabase; User Id=PGusername; ******;Port=5432
      - NodeName=mynodename
    volumes:
      - /docker/volumes/PSU:/root
```

### Créer un conteneur personnalisé

Si vous souhaitez ajouter d'autres fonctionnalités, modifier ou coder en dur des variables d'environnement dans votre conteneur, créez un `Dockerfile`

> ***REMARQUE :*** Les Dockerfile respectent la casse et doivent commencer par un « D » majuscule.

Pour créer une image Docker capable de conserver les données Universal, créez un dockerfile comme celui ci-dessous.

Ce Dockerfile expose le port 5000, crée un volume /data, définit des variables d'environnement de configuration pour stocker le dépôt et la base de données Universal dans le volume, puis définit Universal.Server comme point d'entrée du conteneur.

#### Écrire un script Dockerfile pour Linux

```docker
FROM devolutions/powershell-universal:latest
LABEL description="Universal - The ultimate platform for building web-based IT Tools" 

EXPOSE 5000
VOLUME ["/home/data"]
ENV Data__RepositoryPath /home/data/Repository
ENV Data__ConnectionString Data Source=/home/data/database.db
ENV UniversalDashboard__AssetsFolder /home/data/UniversalDashboard 
ENV Logging__Path /home/data/logs/log.txt
ENTRYPOINT ["./Universal.Server"]
```

#### Créer un conteneur

Depuis le chemin qui héberge votre Dockerfile, exécutez la commande suivante :

```
docker build . --tag=universal-persistent
```

#### Windows

```docker
FROM devolutions/powershell-universal:5.0.0-windowsservercore-1809
LABEL description="Universal - The ultimate platform for building web-based IT Tools" 

EXPOSE 5000
VOLUME ["C:/data"]
ENV Data__RepositoryPath C:/data/Repository
ENV Data__ConnectionString Data Source=C:/data/database.db
ENV UniversalDashboard__AssetsFolder C:/data/UniversalDashboard 
ENV Logging__Path C:/data/logs/log.txt
ENTRYPOINT ["C:/ProgramData/Universal/Universal.Server.exe"]
```

Lancez une génération avec la commande build :

```
docker build . --tag=universal-persistent
```

Démarrez le conteneur docker avec la commande run et assurez-vous de spécifier le volume à monter :

```
docker run -it --name powershelluniversal --mount source=psudata,target=/home/data --rm -d  -p 5000:5000/tcp universal-persistent:latest
```

#### SQL

Pour utiliser la persistance SQL, définissez le module d'extension et la chaîne de connexion comme suit :

```
ENV Data__ConnectionString=Data Source=ServerName; Initial Catalog=DatabaseName; Integrated Security=SSPI;
ENV Plugins:0=SQL
```

#### PostgreSQL

Pour utiliser la persistance PostgreSQL, définissez le module d'extension et la chaîne de connexion comme suit :

```
ENV Data__ConnectionString=Host=PGhostname; Database=PGdatabase; User Id=PGusername; ******;Port=5432
ENV Plugins:0=PostgreSQL
```

### Fuseaux horaires

Pour prendre correctement en charge les fuseaux horaires sous Linux lors de la planification des tâches, incluez le paquet `tzdata` dans votre dockerfile ainsi qu'une variable d'environnement qui spécifie le fuseau horaire du serveur.

```
ENV TZ Europe/Amsterdam
RUN apt-get install -y tzdata
```

## Étiquettes

Nous publions les étiquettes suivantes sur Docker Hub :

* latest - Version actuelle utilisant Ubuntu LTS
* 2026.x-\<OS>-\<PS> - Version de production avec la version d'OS et de PS spécifiée
* 2026.x-modules - Version de production actuelle sur Ubuntu LTS avec certains modules AZ installés
* 4.x-\<OS>-\<PS> - Version de production actuelle 4 avec les versions d'OS et de PS spécifiées

### Modules inclus

Les images de conteneur des modules incluent les modules suivants :

* Az.Accounts
* Az.Compute
* Az.KeyVault
* Az.Resources
* Invoke-SqlCmd2

## Résumé

Ce « Comment démarrer » de base vous permet de commencer à exécuter ou à créer des conteneurs PSU. Cette section de références répertorie toutes les sources des commandes :

## Références

### Exécuter des conteneurs

<https://docs.docker.com/engine/reference/commandline/run/>

<https://docs.docker.com/engine/reference/commandline/stop/>

<https://docs.docker.com/engine/reference/commandline/rm/>

<https://docs.docker.com/compose/>

### Créer des conteneurs

<https://docs.docker.com/engine/reference/commandline/build/>


---

# 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.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.
