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

# Udrul Devolutions Server med Docker

Udrul Devolutions Server med Docker på SQL Server eller PostgreSQL, initialisering første gang, krypteringskonfiguration, brugerdefinerede porte og TLS-certifikater.

Denne artikel viser, hvordan De udruller Devolutions Server med Docker og en SQL Server- eller PostgreSQL-database. Docker-imaget til Devolutions Server er et Linux-image, der er tilgængeligt til platformene `linux/amd64` og `linux/arm64`.

{% hint style="info" %}
Af hensyn til enkelheden skrives versionen af Docker-imaget til Devolutions Server som `20XX.X` i kodeblokkene i denne artikel. Skift denne variabel til den version, De vil bruge.
{% endhint %}

### Forudsætninger

* Docker version `20.10.X` eller nyere.
* En databaseinstans:
  * En SQL Server-instans, herunder Azure SQL Database, der er korrekt [konfigureret til Devolutions Server](/server/da/getting-started/installation/database-setup.md).
  * Eller en [PostgreSQL](/server/da/getting-started/installation/database-setup/database-instance/postgresql.md)-instans version 14 eller nyere, selvhostet eller administreret, med en rolle, der har attributten `SUPERUSER`.
* De minimale [systemkrav](/server/da/overview-of-devolutions-server/system-requirements.md) for at køre Devolutions Server.

### Klargør databasen

Containeren opretter forbindelse til databasen med én enkelt konto, der bruges til initialiseringen, skemaopgraderingerne og normal drift. Opret en dedikeret konto til Devolutions Server i stedet for at bruge en administratorkonto som `sa` eller `postgres`.

#### SQL Server

Med en administratorkonto (for eksempel `sa` eller en Azure SQL-administrator) skal De oprette et dedikeret login og Devolutions Server-databasen og derefter føje loginnet til rollen `db_owner` i den database.

Hvis databasen ikke findes, opretter initialiseringen den med sorteringen `Latin1_General_CS_AS`, hvilket kræver, at logonet har tilladelse til at oprette databaser.

#### PostgreSQL

Med en administratorkonto skal De oprette en dedikeret loginrolle til Devolutions Server. Initialiseringen opretter forbindelse til vedligeholdelsesdatabasen `postgres` for at kontrollere, om Devolutions Server-databasen findes, så rollen skal have privilegiet `CONNECT` på `postgres` (PostgreSQL tildeler det til alle roller som standard).

{% hint style="warning" %}
Rollen skal have attributten `SUPERUSER` for at oprette databaseskemaet under initialiseringen. Oprettelsen af skemaet ændrer PostgreSQL-typecasts, hvilket kun en superbruger kan gøre.
{% endhint %}

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

Efter initialiseringen kræver skemaopgraderingerne og den normale drift af Devolutions Server ikke attributten `SUPERUSER`. For at begrænse rollens privilegier skal De fjerne attributten. Rollen forbliver ejer af databasen:

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

### Variabler for databaseforbindelse

Eksemplerne i denne artikel opretter forbindelse til SQL Server. For at oprette forbindelse til PostgreSQL skal De tilføje `-e DATABASE_TYPE=PostgreSQL` og `-e DATABASE_ENCRYPT=true` til initialiserings- og kørselskommandoerne og angive `DATABASE_HOST` som navnet på PostgreSQL-serveren. De øvrige variabler er de samme for begge databasemotorer.

| Variable                            | SQL Server                                                                        | PostgreSQL                                                                                                      |
| ----------------------------------- | --------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------- |
| `DATABASE_TYPE`                     | `SqlServer` (standard).                                                           | `PostgreSQL`.                                                                                                   |
| `DATABASE_HOST`                     | Servernavn. En port kan tilføjes i formatet `host,port`.                          | Servernavn. En port kan tilføjes i formatet `host:port`, som har forrang for `DATABASE_PORT`.                   |
| `DATABASE_PORT`                     | `1433` (standard).                                                                | `5432` (standard).                                                                                              |
| `DATABASE_ENCRYPT`                  | `true` krypterer forbindelsen. Standard: `false`.                                 | `true` krypterer forbindelsen og validerer servercertifikatet. Standard: `false` (ikke krypteret).              |
| `DATABASE_TRUST_SERVER_CERTIFICATE` | `true` har tillid til servercertifikatet uden at validere det. Standard: `false`. | Med `DATABASE_ENCRYPT=true` bevarer `true` krypteringen uden at validere servercertifikatet. Standard: `false`. |

{% hint style="warning" %}
Med PostgreSQL deaktiverer standardværdien `DATABASE_ENCRYPT=false` SSL: forbindelsen til databasen er ikke krypteret. Med `DATABASE_ENCRYPT=true` skal certifikatet for PostgreSQL-serveren være udstedt af en certifikatmyndighed, der er betroet i containeren, og matche navnet `DATABASE_HOST`. Ellers skal De også angive `DATABASE_TRUST_SERVER_CERTIFICATE=true`.
{% endhint %}

Den fuldstændige liste over variabler findes i [Avanceret Docker-konfiguration til Devolutions Server](/server/da/knowledge-base/how-to-articles/devolutions-server-docker-deployment/advanced-docker-configuration-for-devolutions-server.md).

### Første opsætning af Devolutions Server

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

1. Hent det seneste [Docker-image til Devolutions Server](https://hub.docker.com/r/devolutions/devolutions-server):

   ```powershell
   docker pull devolutions/devolutions-server:release-20XX.X
   ```
2. Kør Devolutions Server i initialiseringstilstand for at oprette databasen, hvis den ikke findes, oprette dens skema og dens første administrator, generere krypteringsnøglerne og konfigurere HTTPS med et selvsigneret certifikat. Volumen `dvls-init-data` bevarer `App_Data`, så krypteringskonfigurationen kan udtrækkes bagefter. Med PostgreSQL skal De tilføje `-e DATABASE_TYPE=PostgreSQL` og `-e DATABASE_ENCRYPT=true` og angive `DATABASE_HOST` som navnet på PostgreSQL-serveren.

   ```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. Vent på meddelelsen `Initialization completed successfully.`, og tryk derefter på <kbd>Ctrl</kbd>+<kbd>C</kbd> for at stoppe containeren. Efter initialiseringen bliver containeren ved med at køre Devolutions Server, indtil den stoppes. Indstillingen `--rm` fjerner containeren og beholder volumen `dvls-init-data`.
4. Udtræk `encryption.config` fra initialiseringsvolumenet, og konvertér det til base64. Opbevar filen `encryption.config.b64` sikkert: hver kørselsstart har brug for den.

   ```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. Start Devolutions Server i kørselstilstand med base64-krypteringskonfigurationen. Med PostgreSQL skal De tilføje de samme variabler `DATABASE_TYPE` og `DATABASE_ENCRYPT` som i initialiseringskommandoen. Når det er gjort, skal De bruge kommandoerne `docker ps` og `docker logs dvls-server` for at sikre, at alt fungerer.

   ```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. Få adgang til webgrænsefladen ved at åbne `https://localhost:5000` i Deres browser. Gå forbi sikkerhedsadvarslen for det selvsignerede certifikat ved at klikke på ***Avanceret*** – ***Fortsæt***. Et brugerdefineret TLS-certifikat kan monteres senere.
7. Log på med `dvls-admin` som både brugernavn og adgangskode. Devolutions Server kræver derefter en ny adgangskode til denne konto.
8. Sørg for, at Devolutions Server kører med `DVLS_ENCRYPTION_CONFIG_B64`, at webgrænsefladen er tilgængelig, og at `encryption.config.b64` er gemt et sikkert sted (den skal bruges ved hver genstart og genudrulning). Når det er gjort, skal De fjerne den midlertidige initialiseringsvolumen:

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

{% endtab %}

{% tab title="macOS" %}

1. Hent det seneste [Docker-image til Devolutions Server](https://hub.docker.com/r/devolutions/devolutions-server):

   ```bash
   docker pull devolutions/devolutions-server:release-20XX.X
   ```
2. Kør Devolutions Server i initialiseringstilstand for at oprette databasen, hvis den ikke findes, oprette dens skema og dens første administrator, generere krypteringsnøglerne og konfigurere HTTPS med et selvsigneret certifikat. Volumen `dvls-init-data` bevarer `App_Data`, så krypteringskonfigurationen kan udtrækkes bagefter. Med PostgreSQL skal De tilføje `-e DATABASE_TYPE=PostgreSQL` og `-e DATABASE_ENCRYPT=true` og angive `DATABASE_HOST` som navnet på PostgreSQL-serveren.

   ```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. Vent på meddelelsen `Initialization completed successfully.`, og tryk derefter på <kbd>Ctrl</kbd>+<kbd>C</kbd> for at stoppe containeren. Efter initialiseringen bliver containeren ved med at køre Devolutions Server, indtil den stoppes. Indstillingen `--rm` fjerner containeren og beholder volumen `dvls-init-data`.
4. Udtræk `encryption.config` fra initialiseringsvolumenet, og konvertér det til base64. Opbevar filen `encryption.config.b64` sikkert: hver kørselsstart har brug for den.

   ```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. Start Devolutions Server i kørselstilstand med base64-krypteringskonfigurationen. Med PostgreSQL skal De tilføje de samme variabler `DATABASE_TYPE` og `DATABASE_ENCRYPT` som i initialiseringskommandoen. Når det er gjort, skal De bruge kommandoerne `docker ps` og `docker logs dvls-server` for at sikre, at alt fungerer.

   ```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. Få adgang til webgrænsefladen ved at åbne `https://localhost:5000` i Deres browser. Gå forbi sikkerhedsadvarslen for det selvsignerede certifikat ved at klikke på ***Avanceret*** – ***Fortsæt***. Et brugerdefineret TLS-certifikat kan monteres senere.
7. Log på med `dvls-admin` som både brugernavn og adgangskode. Devolutions Server kræver derefter en ny adgangskode til denne konto.
8. Sørg for, at Devolutions Server kører med `DVLS_ENCRYPTION_CONFIG_B64`, at webgrænsefladen er tilgængelig, og at `encryption.config.b64` er gemt et sikkert sted (den skal bruges ved hver genstart og genudrulning). Når det er gjort, skal De fjerne den midlertidige initialiseringsvolumen:

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

{% endtab %}

{% tab title="Linux" %}

1. Hent det seneste [Docker-image til Devolutions Server](https://hub.docker.com/r/devolutions/devolutions-server):

   ```bash
   docker pull devolutions/devolutions-server:release-20XX.X
   ```
2. Kør Devolutions Server i initialiseringstilstand for at oprette databasen, hvis den ikke findes, oprette dens skema og dens første administrator, generere krypteringsnøglerne og konfigurere HTTPS med et selvsigneret certifikat. Volumen `dvls-init-data` bevarer `App_Data`, så krypteringskonfigurationen kan udtrækkes bagefter. Med PostgreSQL skal De tilføje `-e DATABASE_TYPE=PostgreSQL` og `-e DATABASE_ENCRYPT=true` og angive `DATABASE_HOST` som navnet på PostgreSQL-serveren.

   ```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. Vent på meddelelsen `Initialization completed successfully.`, og tryk derefter på <kbd>Ctrl</kbd>+<kbd>C</kbd> for at stoppe containeren. Efter initialiseringen bliver containeren ved med at køre Devolutions Server, indtil den stoppes. Indstillingen `--rm` fjerner containeren og beholder volumen `dvls-init-data`.
4. Udtræk `encryption.config` fra initialiseringsvolumenet, og konvertér det til base64. Opbevar filen `encryption.config.b64` sikkert: hver kørselsstart har brug for den.

   ```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. Start Devolutions Server i kørselstilstand med base64-krypteringskonfigurationen. Med PostgreSQL skal De tilføje de samme variabler `DATABASE_TYPE` og `DATABASE_ENCRYPT` som i initialiseringskommandoen. Når det er gjort, skal De bruge kommandoerne `docker ps` og `docker logs dvls-server` for at sikre, at alt fungerer.

   ```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. Få adgang til webgrænsefladen ved at åbne `https://localhost:5000` i Deres browser. Gå forbi sikkerhedsadvarslen for det selvsignerede certifikat ved at klikke på ***Avanceret*** – ***Fortsæt***. Et brugerdefineret TLS-certifikat kan monteres senere.
7. Log på med `dvls-admin` som både brugernavn og adgangskode. Devolutions Server kræver derefter en ny adgangskode til denne konto.
8. Sørg for, at Devolutions Server kører med `DVLS_ENCRYPTION_CONFIG_B64`, at webgrænsefladen er tilgængelig, og at `encryption.config.b64` er gemt et sikkert sted (den skal bruges ved hver genstart og genudrulning). Når det er gjort, skal De fjerne den midlertidige initialiseringsvolumen:

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

{% endtab %}
{% endtabs %}

{% hint style="warning" %}
Kør initialiseringen kun én gang pr. database. Hvis den køres igen mod en initialiseret database, mislykkes den, fordi administratorkontoen allerede findes.
{% endhint %}

### Driftstilstande

Devolutions Server-containeren kører i tre forskellige tilstande:

| Mode                      | Miljøvariabel           | Formål              | Funktionsmåde                                                                                                                                              |
| ------------------------- | ----------------------- | ------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Kørsel** **(standard)** | Ingen særlige variabler | Normal drift        | Bruger ventende opgraderinger af databaseskemaet, starter derefter webserveren og bliver ved med at køre.                                                  |
| **Initialisering**        | `DVLS_INIT=true`        | Første opsætning    | Opretter databasen, hvis den ikke findes, dens skema, krypteringsnøglerne og administratorkontoen, starter derefter webserveren og bliver ved med at køre. |
| **Opdatering**            | `DVLS_UPDATE_MODE=true` | Databaseopgradering | Sikkerhedskopierer konfigurationsfilerne og installationsmappen, migrerer databasen og afslutter derefter.                                                 |

{% hint style="info" %}
Tilstandene **Initialisering** og **Opdatering** udelukker hinanden.

For at starte kørselstilstanden uden at anvende de ventende skemaopgraderinger skal De angive `DVLS_DATABASE_UPGRADE_ON_STARTUP=false`.
{% endhint %}

{% hint style="warning" %}
Opdateringstilstanden sikkerhedskopierer ikke SQL Server- eller PostgreSQL-databaser. Sikkerhedskopiér databasen, før De kører den, for eksempel med `BACKUP DATABASE` på SQL Server eller `pg_dump` på PostgreSQL.
{% endhint %}

{% hint style="warning" %}
Devolutions Server-imaget indeholder ikke PostgreSQL-klientværktøjerne `pg_dump` og `pg_restore`, som det indbyggede sikkerhedskopieringsjob bruger med PostgreSQL. For at bruge dette job skal De bygge et afledt image, der installerer pakken `postgresql-client`, med en hovedversion, der er lig med eller nyere end PostgreSQL-serverens, eller montere værktøjerne i containeren og angive deres fulde stier i variablerne `DVLS_PG_DUMP_PATH` og `DVLS_PG_RESTORE_PATH`.
{% endhint %}

### Brugerdefineret port

Devolutions Server lytter som standard på port `5000`. For at ændre den skal De angive miljøvariablen `PORT` og publicere den samme port i kommandoen `docker run`. For at bruge port `8080` skal De for eksempel erstatte `-e PORT=5000` og `-p 5000:5000` med `-e PORT=8080` og `-p 8080:8080` og derefter åbne `https://localhost:8080`.

`PORT` har forrang for `WEB_PORT`. Variablen `ASPNETCORE_URLS` har ingen virkning: containeren angiver lytteadressen ud fra `WEB_SCHEME` og `PORT`.

### Montér et brugerdefineret TLS-certifikat

Montér Deres egne certifikatfiler i stedet for at bruge det automatisk genererede selvsignerede certifikat:

1. Kopiér certifikatet og dets private nøgle i PEM-format til en mappe på Docker-værten, for eksempel `/host/path/certs`.
2. Tilføj disse indstillinger til kørselskommandoen, med `WEB_SCHEME=https` og `HOSTNAME` sat til navnet i certifikatet (for eksempel `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" %}
Hvis ingen af filerne findes på disse stier, genererer Devolutions Server i stedet et selvsigneret certifikat. Hvis kun den ene af de to filer findes, stopper containeren med en fejl.
{% endhint %}

### Containeradministration

| Kommandoer                 | Funktioner           |
| -------------------------- | -------------------- |
| `docker start dvls-server` | Starter containeren. |
| `docker stop dvls-server`  | Stopper containeren. |
| `docker rm dvls-server`    | Fjerner containeren. |

{% hint style="info" %}
Det er sikkert at fjerne containeren, så længe De har filen `encryption.config.b64`, adgang til Deres database, og Deres miljøvariabler er dokumenteret.
{% endhint %}

#### Se også

* [Sikkerhedstjekliste](/server/da/getting-started/security-checklist.md)
* [PostgreSQL](/server/da/getting-started/installation/database-setup/database-instance/postgresql.md)
* [Udrulning af Devolutions Server til Azure App Service med en container](/server/da/knowledge-base/how-to-articles/devolutions-server-docker-deployment/devolutions-server-deployment-to-azure-app-service-using-a-container.md)
* [Avanceret Docker-konfiguration til Devolutions Server](/server/da/knowledge-base/how-to-articles/devolutions-server-docker-deployment/advanced-docker-configuration-for-devolutions-server.md)
* [Udrul Devolutions Server og SQL Server med Docker Compose på Windows](/server/da/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/da/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.