> 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/it/knowledge-base/how-to-articles/devolutions-server-docker-deployment.md).

# Distribuire Devolutions Server con Docker

Distribuisca Devolutions Server con Docker su SQL Server o PostgreSQL, con l'inizializzazione iniziale, la configurazione della crittografia, porte personalizzate e certificati TLS.

Questo articolo mostra come distribuire Devolutions Server con Docker e un database SQL Server o PostgreSQL. L'immagine Docker di Devolutions Server è un'immagine Linux disponibile per le piattaforme `linux/amd64` e `linux/arm64`.

{% hint style="info" %}
Per semplicità, la versione dell'immagine Docker di Devolutions Server è indicata come `20XX.X` nei blocchi di codice di questo articolo. Modifichi questa variabile con la versione che desidera utilizzare.
{% endhint %}

### Prerequisiti

* Docker versione `20.10.X` o successiva.
* Un'istanza di database:
  * Un'istanza SQL Server, inclusa Azure SQL Database, correttamente [configurata per Devolutions Server](https://docs.devolutions.net/server/it/getting-started/installation/database-setup.md).
  * Oppure un'istanza [PostgreSQL](https://docs.devolutions.net/server/it/getting-started/installation/database-setup/database-instance/postgresql.md) 14 o successiva, self-hosted o gestita, con un ruolo che ha l'attributo `SUPERUSER`.
* I [requisiti di sistema](https://docs.devolutions.net/server/it/overview-of-devolutions-server/system-requirements.md) minimi per eseguire Devolutions Server.

### Preparare il database

Il contenitore si connette al database con un unico account, usato per l'inizializzazione, gli aggiornamenti dello schema e il funzionamento normale. Crei un account dedicato per Devolutions Server invece di usare un account amministratore come `sa` o `postgres`.

#### SQL Server

Con un account amministratore (ad esempio `sa` o un amministratore di Azure SQL), crei un account di accesso dedicato e il database di Devolutions Server, quindi aggiunga l'account di accesso al ruolo `db_owner` di quel database.

Se il database non esiste, l'inizializzazione lo crea con le regole di confronto `Latin1_General_CS_AS`, il che richiede che l'account di accesso abbia l'autorizzazione a creare database.

#### PostgreSQL

Con un account amministratore, crei un ruolo di accesso dedicato per Devolutions Server. L'inizializzazione si connette al database di manutenzione `postgres` per verificare se il database di Devolutions Server esiste, quindi il ruolo necessita del privilegio `CONNECT` su `postgres` (PostgreSQL lo concede a tutti i ruoli per impostazione predefinita).

{% hint style="warning" %}
Il ruolo deve avere l'attributo `SUPERUSER` per creare lo schema del database durante l'inizializzazione. La creazione dello schema modifica le conversioni di tipo di PostgreSQL, operazione che solo un superutente può eseguire.
{% endhint %}

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

Dopo l'inizializzazione, gli aggiornamenti dello schema e il funzionamento normale di Devolutions Server non richiedono l'attributo `SUPERUSER`. Per limitare i privilegi del ruolo, rimuova l'attributo. Il ruolo rimane il proprietario del database:

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

### Variabili di connessione al database

Gli esempi di questo articolo si connettono a SQL Server. Per connettersi a PostgreSQL, aggiunga `-e DATABASE_TYPE=PostgreSQL` e `-e DATABASE_ENCRYPT=true` ai comandi di inizializzazione e di runtime e imposti `DATABASE_HOST` sul nome del server PostgreSQL. Le altre variabili sono le stesse per entrambi i motori di database.

| Variabile                           | SQL Server                                                                                       | PostgreSQL                                                                                                                      |
| ----------------------------------- | ------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------- |
| `DATABASE_TYPE`                     | `SqlServer` (predefinito).                                                                       | `PostgreSQL`.                                                                                                                   |
| `DATABASE_HOST`                     | Nome del server. È possibile aggiungere una porta nel formato `host,port`.                       | Nome del server. È possibile aggiungere una porta nel formato `host:port`, che ha la precedenza su `DATABASE_PORT`.             |
| `DATABASE_PORT`                     | `1433` (predefinito).                                                                            | `5432` (predefinito).                                                                                                           |
| `DATABASE_ENCRYPT`                  | `true` crittografa la connessione. Predefinito: `false`.                                         | `true` crittografa la connessione e convalida il certificato del server. Predefinito: `false` (non crittografata).              |
| `DATABASE_TRUST_SERVER_CERTIFICATE` | `true` considera attendibile il certificato del server senza convalidarlo. Predefinito: `false`. | Con `DATABASE_ENCRYPT=true`, `true` mantiene la crittografia senza convalidare il certificato del server. Predefinito: `false`. |

{% hint style="warning" %}
Con PostgreSQL, il valore predefinito `DATABASE_ENCRYPT=false` disabilita SSL: la connessione al database non è crittografata. Con `DATABASE_ENCRYPT=true`, il certificato del server PostgreSQL deve essere emesso da un'autorità di certificazione attendibile nel contenitore e corrispondere al nome `DATABASE_HOST`. In caso contrario, imposti anche `DATABASE_TRUST_SERVER_CERTIFICATE=true`.
{% endhint %}

L'elenco completo delle variabili si trova in [Configurazione Docker avanzata per Devolutions Server](https://docs.devolutions.net/server/it/knowledge-base/how-to-articles/devolutions-server-docker-deployment/advanced-docker-configuration-for-devolutions-server.md).

### Configurazione iniziale di Devolutions Server

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

1. Scarichi l'ultima [immagine Docker di Devolutions Server](https://hub.docker.com/r/devolutions/devolutions-server):

   ```powershell
   docker pull devolutions/devolutions-server:release-20XX.X
   ```
2. Esegua Devolutions Server in modalità di inizializzazione per creare il database se non esiste, crearne lo schema e il primo amministratore, generare le chiavi di crittografia e configurare HTTPS con un certificato autofirmato. Il volume `dvls-init-data` conserva `App_Data` in modo che la configurazione della crittografia possa essere estratta in seguito. Con PostgreSQL, aggiunga `-e DATABASE_TYPE=PostgreSQL` e `-e DATABASE_ENCRYPT=true` e imposti `DATABASE_HOST` sul nome del server 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. Attenda il messaggio `Initialization completed successfully.`, quindi prema <kbd>Ctrl</kbd>+<kbd>C</kbd> per arrestare il contenitore. Dopo l'inizializzazione, il contenitore continua a eseguire Devolutions Server finché non viene arrestato. L'opzione `--rm` rimuove il contenitore e conserva il volume `dvls-init-data`.
4. Estragga `encryption.config` dal volume di inizializzazione e lo converta in base64. Conservi il file `encryption.config.b64` in modo sicuro: ogni avvio in runtime ne ha bisogno.

   ```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. Avvii Devolutions Server in modalità runtime con la configurazione della crittografia in base64. Con PostgreSQL, aggiunga le stesse variabili `DATABASE_TYPE` e `DATABASE_ENCRYPT` del comando di inizializzazione. Al termine, usi i comandi `docker ps` e `docker logs dvls-server` per verificare che tutto funzioni.

   ```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. Acceda all'interfaccia web aprendo `https://localhost:5000` nel browser. Superi l'avviso di sicurezza del certificato autofirmato facendo clic su ***Avanzate*** – ***Procedi***. Un certificato TLS personalizzato può essere montato in seguito.
7. Acceda usando `dvls-admin` sia come nome utente sia come password. Devolutions Server richiede quindi una nuova password per questo account.
8. Si assicuri che Devolutions Server sia in esecuzione con `DVLS_ENCRYPTION_CONFIG_B64`, che l'interfaccia web sia accessibile e che `encryption.config.b64` sia salvato in un luogo sicuro (è necessario a ogni riavvio e nuova distribuzione). Al termine, rimuova il volume di inizializzazione temporaneo:

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

{% endtab %}

{% tab title="macOS" %}

1. Scarichi l'ultima [immagine Docker di Devolutions Server](https://hub.docker.com/r/devolutions/devolutions-server):

   ```bash
   docker pull devolutions/devolutions-server:release-20XX.X
   ```
2. Esegua Devolutions Server in modalità di inizializzazione per creare il database se non esiste, crearne lo schema e il primo amministratore, generare le chiavi di crittografia e configurare HTTPS con un certificato autofirmato. Il volume `dvls-init-data` conserva `App_Data` in modo che la configurazione della crittografia possa essere estratta in seguito. Con PostgreSQL, aggiunga `-e DATABASE_TYPE=PostgreSQL` e `-e DATABASE_ENCRYPT=true` e imposti `DATABASE_HOST` sul nome del server 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. Attenda il messaggio `Initialization completed successfully.`, quindi prema <kbd>Ctrl</kbd>+<kbd>C</kbd> per arrestare il contenitore. Dopo l'inizializzazione, il contenitore continua a eseguire Devolutions Server finché non viene arrestato. L'opzione `--rm` rimuove il contenitore e conserva il volume `dvls-init-data`.
4. Estragga `encryption.config` dal volume di inizializzazione e lo converta in base64. Conservi il file `encryption.config.b64` in modo sicuro: ogni avvio in runtime ne ha bisogno.

   ```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. Avvii Devolutions Server in modalità runtime con la configurazione della crittografia in base64. Con PostgreSQL, aggiunga le stesse variabili `DATABASE_TYPE` e `DATABASE_ENCRYPT` del comando di inizializzazione. Al termine, usi i comandi `docker ps` e `docker logs dvls-server` per verificare che tutto funzioni.

   ```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. Acceda all'interfaccia web aprendo `https://localhost:5000` nel browser. Superi l'avviso di sicurezza del certificato autofirmato facendo clic su ***Avanzate*** – ***Procedi***. Un certificato TLS personalizzato può essere montato in seguito.
7. Acceda usando `dvls-admin` sia come nome utente sia come password. Devolutions Server richiede quindi una nuova password per questo account.
8. Si assicuri che Devolutions Server sia in esecuzione con `DVLS_ENCRYPTION_CONFIG_B64`, che l'interfaccia web sia accessibile e che `encryption.config.b64` sia salvato in un luogo sicuro (è necessario a ogni riavvio e nuova distribuzione). Al termine, rimuova il volume di inizializzazione temporaneo:

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

{% endtab %}

{% tab title="Linux" %}

1. Scarichi l'ultima [immagine Docker di Devolutions Server](https://hub.docker.com/r/devolutions/devolutions-server):

   ```bash
   docker pull devolutions/devolutions-server:release-20XX.X
   ```
2. Esegua Devolutions Server in modalità di inizializzazione per creare il database se non esiste, crearne lo schema e il primo amministratore, generare le chiavi di crittografia e configurare HTTPS con un certificato autofirmato. Il volume `dvls-init-data` conserva `App_Data` in modo che la configurazione della crittografia possa essere estratta in seguito. Con PostgreSQL, aggiunga `-e DATABASE_TYPE=PostgreSQL` e `-e DATABASE_ENCRYPT=true` e imposti `DATABASE_HOST` sul nome del server 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. Attenda il messaggio `Initialization completed successfully.`, quindi prema <kbd>Ctrl</kbd>+<kbd>C</kbd> per arrestare il contenitore. Dopo l'inizializzazione, il contenitore continua a eseguire Devolutions Server finché non viene arrestato. L'opzione `--rm` rimuove il contenitore e conserva il volume `dvls-init-data`.
4. Estragga `encryption.config` dal volume di inizializzazione e lo converta in base64. Conservi il file `encryption.config.b64` in modo sicuro: ogni avvio in runtime ne ha bisogno.

   ```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. Avvii Devolutions Server in modalità runtime con la configurazione della crittografia in base64. Con PostgreSQL, aggiunga le stesse variabili `DATABASE_TYPE` e `DATABASE_ENCRYPT` del comando di inizializzazione. Al termine, usi i comandi `docker ps` e `docker logs dvls-server` per verificare che tutto funzioni.

   ```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. Acceda all'interfaccia web aprendo `https://localhost:5000` nel browser. Superi l'avviso di sicurezza del certificato autofirmato facendo clic su ***Avanzate*** – ***Procedi***. Un certificato TLS personalizzato può essere montato in seguito.
7. Acceda usando `dvls-admin` sia come nome utente sia come password. Devolutions Server richiede quindi una nuova password per questo account.
8. Si assicuri che Devolutions Server sia in esecuzione con `DVLS_ENCRYPTION_CONFIG_B64`, che l'interfaccia web sia accessibile e che `encryption.config.b64` sia salvato in un luogo sicuro (è necessario a ogni riavvio e nuova distribuzione). Al termine, rimuova il volume di inizializzazione temporaneo:

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

{% endtab %}
{% endtabs %}

{% hint style="warning" %}
Esegua l'inizializzazione una sola volta per database. Eseguirla di nuovo su un database già inizializzato non riesce, perché l'account amministratore esiste già.
{% endhint %}

### Modalità operative

Il contenitore di Devolutions Server opera in tre modalità distinte:

| Modalità                      | Variabile d'ambiente       | Scopo                      | Comportamento                                                                                                                                          |
| ----------------------------- | -------------------------- | -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
| **Runtime** **(predefinita)** | Nessuna variabile speciale | Funzionamento normale      | Applica gli aggiornamenti dello schema del database in sospeso, quindi avvia il server web e resta in esecuzione.                                      |
| **Inizializzazione**          | `DVLS_INIT=true`           | Configurazione iniziale    | Crea il database se non esiste, il suo schema, le chiavi di crittografia e l'account amministratore, quindi avvia il server web e resta in esecuzione. |
| **Aggiornamento**             | `DVLS_UPDATE_MODE=true`    | Aggiornamento del database | Esegue il backup dei file di configurazione e della cartella di installazione, migra il database e quindi termina.                                     |

{% hint style="info" %}
Le modalità **Inizializzazione** e **Aggiornamento** si escludono a vicenda.

Per avviare la modalità runtime senza applicare gli aggiornamenti dello schema in sospeso, imposti `DVLS_DATABASE_UPGRADE_ON_STARTUP=false`.
{% endhint %}

{% hint style="warning" %}
La modalità di aggiornamento non esegue il backup dei database SQL Server o PostgreSQL. Esegua il backup del database prima di avviarla, ad esempio con `BACKUP DATABASE` su SQL Server o `pg_dump` su PostgreSQL.
{% endhint %}

{% hint style="warning" %}
L'immagine di Devolutions Server non include gli strumenti client di PostgreSQL `pg_dump` e `pg_restore`, che il processo di backup integrato usa con PostgreSQL. Per usare questo processo, crei un'immagine derivata che installi il pacchetto `postgresql-client`, con una versione principale uguale o successiva a quella del server PostgreSQL, oppure monti gli strumenti nel contenitore e imposti i percorsi completi nelle variabili `DVLS_PG_DUMP_PATH` e `DVLS_PG_RESTORE_PATH`.
{% endhint %}

### Porta personalizzata

Devolutions Server è in ascolto sulla porta `5000` per impostazione predefinita. Per modificarla, imposti la variabile di ambiente `PORT` e pubblichi la stessa porta nel comando `docker run`. Ad esempio, per usare la porta `8080`, sostituisca `-e PORT=5000` e `-p 5000:5000` con `-e PORT=8080` e `-p 8080:8080`, quindi apra `https://localhost:8080`.

`PORT` ha la precedenza su `WEB_PORT`. La variabile `ASPNETCORE_URLS` non ha effetto: il contenitore imposta l'indirizzo di ascolto da `WEB_SCHEME` e `PORT`.

### Montare un certificato TLS personalizzato

Monti i propri file di certificato invece di utilizzare il certificato autofirmato generato automaticamente:

1. Copi il certificato e la relativa chiave privata, in formato PEM, in una cartella dell'host Docker, ad esempio `/host/path/certs`.
2. Aggiunga queste opzioni al comando di runtime, con `WEB_SCHEME=https` e `HOSTNAME` impostato sul nome presente nel certificato (ad esempio `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" %}
Se nessuno dei due file viene trovato in questi percorsi, Devolutions Server genera invece un certificato autofirmato. Se viene trovato solo uno dei due file, il contenitore si arresta con un errore.
{% endhint %}

### Gestione del container

| Comandi                    | Funzioni                |
| -------------------------- | ----------------------- |
| `docker start dvls-server` | Avvia il container.     |
| `docker stop dvls-server`  | Arresta il container.   |
| `docker rm dvls-server`    | Rimuove il contenitore. |

{% hint style="info" %}
Rimuovere il contenitore è sicuro purché si disponga del file `encryption.config.b64`, dell'accesso al database e delle variabili di ambiente documentate.
{% endhint %}

#### Vedere anche

* [Elenco di controllo per la sicurezza](https://docs.devolutions.net/server/it/getting-started/security-checklist.md)
* [PostgreSQL](https://docs.devolutions.net/server/it/getting-started/installation/database-setup/database-instance/postgresql.md)
* [Distribuzione di Devolutions Server in Azure App Service tramite un container](https://docs.devolutions.net/server/it/knowledge-base/how-to-articles/devolutions-server-docker-deployment/devolutions-server-deployment-to-azure-app-service-using-a-container.md)
* [Configurazione Docker avanzata per Devolutions Server](https://docs.devolutions.net/server/it/knowledge-base/how-to-articles/devolutions-server-docker-deployment/advanced-docker-configuration-for-devolutions-server.md)
* [Distribuire Devolutions Server e SQL Server con Docker Compose in Windows](https://docs.devolutions.net/server/it/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/it/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.
