> 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/it/getting-started/docker.md).

# Docker

## Docker

### Verificare che Docker sia installato correttamente

> **NOTA:** dispositivi Apple M1: al momento della stesura di questo documento sono presenti alcuni problemi sui dispositivi Apple M1 e su alcuni dispositivi ARM64/ARMv8. Consulti [il forum di PowerShell Universal](https://forum.devolutions.net/product/powershell-universal) prima di procedere.

#### Docker

Esegua il comando seguente per verificare che Docker sia installato:

```
docker version
```

Output di esempio:

```
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 utilizza il comando `docker-compose`. A partire da giugno 2023, il supporto per Docker Compose v1 è terminato.

Docker Compose v2 utilizza il comando `docker compose`.

Se utilizza Docker Compose v1, adatti i comandi di conseguenza. Maggiori informazioni su Docker Compose sono disponibili [qui](https://docs.docker.com/compose/).

Esegua uno dei comandi seguenti per verificare che Docker Compose sia installato:

Docker Compose v1:

```
docker-compose version
```

Docker Compose v2:

```
docker compose version
```

Output di esempio:

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

#### Un Hello-World di Docker

Per assicurarsi che Docker sia in grado di scaricare ed eseguire immagini di container, esegua il comando seguente:

```
docker run hello-world
```

Output di esempio:

```
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/
```

### Installazione

### Utilizzo del container predefinito

Per eseguire PowerShell Universal, utilizzi l'immagine del container fornita. L'immagine Docker è disponibile su [Docker Hub](https://hub.docker.com/r/ironmansoftware/universal).

La versione predefinita supporta sia le funzionalità gratuite sia quelle a pagamento di PowerShell Universal.

Avvii il container scaricando l'immagine e quindi eseguendo un container con la porta predefinita associata.

#### Esecuzione di un'immagine di base

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

#### Presentare un'immagine su una porta diversa

Se la porta 5000 non è disponibile sul suo host, passi a un'altra porta.

es. presentazione sulla porta 80

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

#### Montare un volume

Il comando `docker run` consente di montare un volume per l'archiviazione persistente. Monti il volume nella cartella /root.

**Montare un volume su un container in Windows**

Il comando seguente monta la cartella `C:\docker\volumes\PSU` in `/root` sul suo container:

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

**Montare un volume su un container su Mac e Linux**

Il comando seguente monta la cartella `/docker/volumes/PSU` in `/root` sul suo container:

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

#### Arrestare un container

Il comando seguente rimuove un container arrestato denominato `PSU`:

```
docker stop PSU
```

#### Rimuovere un container

Il comando seguente arresta un container denominato `PSU`:

```
docker rm PSU
```

Il flag `--force` può rimuovere un container in esecuzione:

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

### Docker Compose

Docker Compose consente di utilizzare un file di testo yaml per standardizzare la build e per creare uno script di distribuzione (o di build) di più container.

Il nome predefinito di un file compose è `docker-compose.yml`. Si consiglia di utilizzarlo come nome del file compose.

#### Creazione di uno script Compose per Windows

Il file compose seguente esegue un container Powershell Universal in 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
```

#### Creazione di uno script Compose per Mac / Linux

Il file compose seguente esegue un container Powershell Universal su Mac e 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
```

#### Avviare i container utilizzando gli script Compose

Utilizzando una shell Terminal o PowerShell per Windows. Usi il comando cd per cambiare la directory di lavoro con lo script `docker-compose.yml`.

Esegua il comando seguente:

```
docker compose up -d
```

Output di esempio:

```
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
```

#### Arrestare i container utilizzando gli script Compose

Utilizzando una shell Terminal o PowerShell per Windows. Esegua cd verso la directory con lo script `docker-compose.yml`.

Esegua il comando seguente

```
docker compose down
```

Output di esempio:

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

#### Utilizzo delle variabili di ambiente e della persistenza SQL

Può aggiungere variabili di ambiente negli script Compose. Di seguito un esempio di:

* Impostazione di un nome del nodo
* Aggiunta della persistenza SQL
* Aggiunta di una stringa di connessione 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;Password=Password123;TrustServerCertificate=True;Trusted_Connection=True;integrated security=false;
      - NodeName=mynodename
    volumes:
      - /docker/volumes/PSU:/root
```

#### Utilizzo delle variabili di ambiente e della persistenza PostgreSQL

Può aggiungere variabili di ambiente negli script Compose. Di seguito un esempio di:

* Impostazione di un nome del nodo
* Aggiunta della persistenza PostgreSQL
* Aggiunta di una stringa di connessione 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; Password=PGpassword!;Port=5432
      - NodeName=mynodename
    volumes:
      - /docker/volumes/PSU:/root
```

### Creazione di un container personalizzato

Se desidera creare altre funzionalità, modificare o codificare in modo fisso le variabili di ambiente nel suo container, crei un `Dockerfile`

> ***NOTA:*** i Dockerfile fanno distinzione tra maiuscole e minuscole e devono iniziare con la 'D' maiuscola.

Per creare un'immagine Docker in grado di rendere persistenti i dati di Universal, crei un dockerfile come quello riportato di seguito.

Questo Dockerfile espone la porta 5000, crea un volume /data, imposta le variabili di ambiente di configurazione per archiviare il repository e il database di Universal nel volume e quindi imposta Universal.Server come punto di ingresso del container.

#### Scrittura di uno script Dockerfile per 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/Universal.Server"]
```

#### Creazione di un container

Dal percorso che ospita il suo Dockerfile, esegua il comando seguente:

```
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"]
```

Esegua una build con il comando build:

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

Avvii il container Docker con il comando run e si assicuri di specificare il volume da montare:

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

#### SQL

Per utilizzare la persistenza SQL, definisca il plugin e la stringa di connessione come segue:

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

#### PostgreSQL

Per utilizzare la persistenza PostgreSQL, definisca il plugin e la stringa di connessione come segue:

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

### Fusi orari

Per supportare correttamente i fusi orari su Linux durante la pianificazione dei job, includa il pacchetto `tzdata` nel suo dockerfile insieme a una variabile di ambiente che specifichi il fuso orario del server.

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

## Tag

Pubblichiamo i seguenti tag su Docker Hub:

* latest - Versione corrente basata su Ubuntu LTS
* 2026.x-\<OS>-\<PS> - Versione di produzione con le versioni di OS e PS specificate
* 2026.x-modules - Versione di produzione corrente su Ubuntu LTS con alcuni moduli AZ selezionati installati
* 4.x-\<OS>-\<PS> - Versione di produzione 4 corrente con le versioni di OS e PS specificate

### Moduli inclusi

Le immagini dei container con moduli includono i seguenti moduli:

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

## Riepilogo

Questa guida di base "Come iniziare" le consente di iniziare a eseguire o creare container PSU. Questa sezione di riferimenti riporta tutte le fonti dei comandi:

## Riferimenti

### Esecuzione dei container

<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/>

### Creazione dei container

<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 dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.devolutions.net/powershell-universal/it/getting-started/docker.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.
