> 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/deploy-devolutions-server-and-sql-server-with-docker-compose-on-windows.md).

# Udrul Devolutions Server og SQL Server med Docker Compose på Windows

Udrul Devolutions Server og SQL Server på Windows med Docker Compose, enten alt i containere eller mod en eksisterende SQL Server, og verificer og fejlfind derefter udrulningen.

Denne artikel viser, hvordan De udruller Devolutions Server på en Windows-maskine med Docker Compose. To udrulningsmuligheder gennemgås:

* **Alt i én**: Devolutions Server og SQL Server kører begge i containere på det samme Docker-netværk. Passer bedst til evalueringer, laboratorier og testmiljøer.
* **Hybrid**: Devolutions Server kører i en container og opretter forbindelse til en eksisterende SQL Server, der er installeret på værten eller på en anden server. Passer bedst til organisationer, der allerede administrerer deres egen SQL Server.

Begge muligheder bruger de samme containernavne. Brug kun én mulighed pr. vært.

For at udrulle Devolutions Server med individuelle kommandoer af typen `docker run` i stedet skal De se [Udrul Devolutions Server med Docker](/server/da/knowledge-base/how-to-articles/devolutions-server-docker-deployment.md). Den fulde liste over miljøvariabler findes under [Avanceret Docker-konfiguration til Devolutions Server](/server/da/knowledge-base/how-to-articles/devolutions-server-docker-deployment/advanced-docker-configuration-for-devolutions-server.md).

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

### Forudsætninger

* [Docker Desktop](https://docs.docker.com/desktop/setup/install/windows-install/) til Windows med WSL 2-backend, der kører i tilstanden **Linux-containere**. Imagerne til Devolutions Server og SQL Server er Linux-imager.
* Docker Compose v2 eller nyere (følger med Docker Desktop). Kør `docker compose version` for at bekræfte, at det er tilgængeligt.
* Mindst 4 GB hukommelse tildelt til Docker. SQL Server skal bruge mindst 2 GB for at starte.
* De mindste [systemkrav](/server/da/overview-of-devolutions-server/system-requirements.md) for at køre Devolutions Server.
* Kun for hybridmuligheden: en eksisterende SQL Server-instans, der er forberedt som beskrevet i [Forbered en eksisterende SQL Server](#prepare-an-existing-sql-server-hybrid-option).

{% hint style="warning" %}
Containeren med Devolutions Server opretter forbindelse til SQL Server med **SQL Server-godkendelse**. Windows-godkendelse fra en Linux-container kræver en Kerberos-konfiguration, som ikke gennemgås her. Hvis De har brug for Windows-godkendelse, skal De [installere Devolutions Server på Windows](/server/da/getting-started/installation.md) i stedet.
{% endhint %}

### Vælg et imagetag

Imaget `devolutions/devolutions-server` udgiver **ikke** et `latest`-tag. Brug et af følgende tagformater, som findes på [Docker Hub](https://hub.docker.com/r/devolutions/devolutions-server/tags):

| Tagformat                        | Eksempel         | Anvendelse                                                           |
| -------------------------------- | ---------------- | -------------------------------------------------------------------- |
| `release-<year>.<minor>`         | `release-20XX.X` | Følger den nyeste programrettelse til en version. Praktisk til test. |
| `<year>.<minor>.<patch>.<build>` | `20XX.X.X.X`     | Fast version. Anbefales til produktion.                              |

### Alt-i-en-udrulning

#### Opret konfigurationsfilerne

1. Opret en tom mappe til udrulningen, for eksempel `C:\dvls`, og begræns derefter adgangen til den aktuelle bruger, SYSTEM og gruppen Administrators. Kør følgende kommandoer i PowerShell:

   ```powershell
   New-Item -ItemType Directory -Path C:\dvls
   icacls C:\dvls /inheritance:r /grant:r "$(whoami):(OI)(CI)F" "*S-1-5-18:(OI)(CI)F" "*S-1-5-32-544:(OI)(CI)F"
   ```
2. I den mappe skal De oprette en fil med navnet `.env` med følgende indhold og erstatte hver værdi mellem vinkelparenteser:

   ```
   MSSQL_SA_PASSWORD=<StrongSaPassword>
   MSSQL_PID=Express
   DVLS_IMAGE_TAG=release-20XX.X
   DATABASE_NAME=DVLS
   DVLS_ADMIN_USERNAME=dvls-admin
   DVLS_ADMIN_PASSWORD=<StrongAdminPassword>
   DVLS_HOSTNAME=localhost
   DVLS_HOST_PORT=5000
   SQL_HOST_PORT=1434
   ```

   * `MSSQL_SA_PASSWORD` skal indeholde mindst 8 tegn og mindst tre af følgende: store bogstaver, små bogstaver, cifre og symboler. Ellers nægter SQL Server at starte.
   * `MSSQL_PID` vælger SQL Server-udgaven. `Express` er gratis, men begrænset til 10 GB pr. database. `Developer` er gratis, men kan ikke bruges i produktion. `Standard` og `Enterprise` kræver en SQL Server-licens.
   * `SQL_HOST_PORT` er den port, der bruges til at nå SQL Server-containeren fra værten, for eksempel med SQL Server Management Studio. Port `1434` undgår en konflikt med en SQL Server, der allerede er installeret på værten.

{% hint style="warning" %}
Filen `.env` indeholder adgangskoder. Bevar de begrænsede mappetilladelser, og hold filen ude af versionsstyring. Undgå tegnet `$` i adgangskoder, da Docker Compose fortolker det som en variabel.
{% endhint %}

3. I den samme mappe skal De oprette en fil med navnet `docker-compose.yml` med følgende indhold:

   ```yaml
   services:
     sqlserver:
       image: mcr.microsoft.com/mssql/server:2022-latest
       container_name: dvls-sqlserver
       restart: unless-stopped
       environment:
         ACCEPT_EULA: "Y"
         MSSQL_SA_PASSWORD: ${MSSQL_SA_PASSWORD}
         MSSQL_PID: ${MSSQL_PID}
       ports:
         - "${SQL_HOST_PORT}:1433"
       volumes:
         - mssqldata:/var/opt/mssql
       healthcheck:
         test: ["CMD-SHELL", "/opt/mssql-tools18/bin/sqlcmd -S localhost -U sa -P \"$$MSSQL_SA_PASSWORD\" -Q 'SELECT 1' -C -N -b"]
         interval: 10s
         timeout: 5s
         retries: 30
         start_period: 120s

     # One-time initialization: creates the database schema, the administrator, and the encryption configuration.
     dvls-init:
       image: devolutions/devolutions-server:${DVLS_IMAGE_TAG}
       profiles: ["init"]
       volumes:
         - dvlsdata:/opt/devolutions/dvls/App_Data
       environment:
         DVLS_INIT: "true"
         DATABASE_HOST: sqlserver
         DATABASE_PORT: "1433"
         DATABASE_NAME: ${DATABASE_NAME}
         DATABASE_USERNAME: sa
         DATABASE_PASSWORD: ${MSSQL_SA_PASSWORD}
         DATABASE_ENCRYPT: "true"
         DATABASE_TRUST_SERVER_CERTIFICATE: "true"
         DVLS_ADMIN_USERNAME: ${DVLS_ADMIN_USERNAME}
         DVLS_ADMIN_PASSWORD: ${DVLS_ADMIN_PASSWORD}
         HOSTNAME: ${DVLS_HOSTNAME}
         WEB_SCHEME: http
         WEB_PORT: "5000"
         EXTERNAL_WEB_PORT: "${DVLS_HOST_PORT}"
       depends_on:
         sqlserver:
           condition: service_healthy

     dvls:
       image: devolutions/devolutions-server:${DVLS_IMAGE_TAG}
       container_name: dvls-app
       restart: unless-stopped
       ports:
         - "${DVLS_HOST_PORT}:5000"
       volumes:
         - dvlsdata:/opt/devolutions/dvls/App_Data
       environment:
         DATABASE_HOST: sqlserver
         DATABASE_PORT: "1433"
         DATABASE_NAME: ${DATABASE_NAME}
         DATABASE_USERNAME: sa
         DATABASE_PASSWORD: ${MSSQL_SA_PASSWORD}
         DATABASE_ENCRYPT: "true"
         DATABASE_TRUST_SERVER_CERTIFICATE: "true"
         HOSTNAME: ${DVLS_HOSTNAME}
         WEB_SCHEME: http
         WEB_PORT: "5000"
         EXTERNAL_WEB_PORT: "${DVLS_HOST_PORT}"
       depends_on:
         sqlserver:
           condition: service_healthy

   volumes:
     mssqldata:
     dvlsdata:
   ```

Volumenet `dvlsdata` deles af tjenesterne `dvls-init` og `dvls`. Det gemmer den krypteringskonfiguration, som initialiseringen genererer, så runtime-containeren kan dekryptere dataene i databasen. Volumenet `mssqldata` gemmer SQL Server-databaserne.

{% hint style="warning" %}
Dette eksempel bruger SQL Server-kontoen `sa` for at holde evalueringsopsætningen enkel. Til produktion skal De oprette et dedikeret SQL-logon med [adgang efter mindste privilegium](/server/da/knowledge-base/knowledge-base-articles/pre-deployment-account-survey.md#windows-sql-accounts) og bruge det i `DATABASE_USERNAME` og `DATABASE_PASSWORD`.
{% endhint %}

#### Start udrulningen

1. Åbn PowerShell, og gå til udrulningsmappen:

   ```powershell
   cd C:\dvls
   ```
2. Bekræft, at Docker Compose læser filen `.env` korrekt. Begge imagenavne skal indeholde et tag:

   ```powershell
   docker compose config | Select-String 'image:'
   ```
3. Download imagerne, herunder initialiseringsimaget:

   ```powershell
   docker compose --profile init pull
   ```
4. Initialiser databasen, og opret administratorkontoen. Dette trin er kun nødvendigt ved den første udrulning:

   ```powershell
   docker compose --profile init run --rm dvls-init
   ```
5. Hvis kommandoen ikke vender tilbage, efter at `Initialization completed successfully.` vises, skal De trykke på Ctrl+C. Initialiseringscontaineren fjernes automatisk.

{% hint style="warning" %}
Start ikke Devolutions Server, mens initialiseringscontaineren stadig kører. Kør ikke initialiseringen igen på en eksisterende udrulning.
{% endhint %}

6. Start Devolutions Server og SQL Server:

   ```powershell
   docker compose up -d
   ```
7. Følg loggen for Devolutions Server. SQL Server kan bruge op til to minutter ved første start. Devolutions Server er normalt klar få sekunder senere, da initialiseringen allerede har anvendt databasemigreringerne. Tryk på Ctrl+C for at stoppe med at følge loggen:

   ```powershell
   docker compose exec dvls sh -c "tail -n 50 -f /opt/devolutions/dvls/App_Data/DPS_Main*.log"
   ```
8. Åbn `http://localhost:5000` i en browser (eller den port, der er angivet i `DVLS_HOST_PORT`), og log derefter på med værdierne `DVLS_ADMIN_USERNAME` og `DVLS_ADMIN_PASSWORD` fra filen `.env`.
9. Sikkerhedskopiér krypteringskonfigurationen. Den kræves for at gendanne eller genudrulle Devolutions Server med den samme database:

   ```powershell
   docker compose cp dvls:/opt/devolutions/dvls/App_Data/encryption.config .\encryption.config
   ```
10. Flyt `encryption.config` til en sikker placering uden for udrulningsmappen.

{% hint style="danger" %}
Uden krypteringskonfigurationen kan de data, der er gemt i databasen, ikke dekrypteres. Slet aldrig volumenet `dvlsdata`, medmindre De har en sikkerhedskopi af `encryption.config`.
{% endhint %}

{% hint style="info" %}
Dette eksempel betjener Devolutions Server via HTTP for at holde opsætningen enkel. Før De giver brugerne adgang, skal De konfigurere HTTPS med et TLS-certifikat eller en reverse proxy som beskrevet 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#tls-certificate-configuration).
{% endhint %}

### Hybridudrulning

I denne mulighed kører kun Devolutions Server i en container. Den opretter forbindelse til en eksisterende SQL Server, for eksempel SQL Server Express, der er installeret på den samme Windows-vært.

#### Forbered en eksisterende SQL Server (hybridmulighed)

Med SQL Server Configuration Manager og SQL Server Management Studio skal De sikre, at SQL Server-instansen har:

1. Protokollen **TCP/IP** aktiveret. SQL Server Express leveres med TCP/IP deaktiveret.
2. En **statisk TCP-port** konfigureret (for eksempel `1433`). En container kan ikke bruge en navngiven instans som `HOST\SQLEXPRESS`. Den skal oprette forbindelse til en vært og en port.
3. **Tilstand med SQL Server- og Windows-godkendelse** (blandet tilstand) er aktiveret.
4. Et dedikeret SQL-logon til Devolutions Server. Brug ikke `sa`. Opret enten databasen først, og gør logon til dens `db_owner` (anbefales), eller giv logon serverrollen `dbcreator`, og lad initialiseringen oprette databasen.
5. En indgående Windows Firewall-regel, der tillader SQL Server-porten.

Følgende script opretter logon og databasen og gør logon til databaseejer. Erstat `<StrongPassword>`, før De kører det:

```sql
CREATE LOGIN dvls_login WITH PASSWORD = N'<StrongPassword>';
CREATE DATABASE DVLS;
GO
USE DVLS;
CREATE USER dvls_login FOR LOGIN dvls_login;
ALTER ROLE db_owner ADD MEMBER dvls_login;
```

Værdien `SQL_DATABASE` i filen `.env` skal svare til dette databasenavn.

#### Opret de hybride konfigurationsfiler

1. Opret en tom mappe til udrulningen, for eksempel `C:dvls`, og begræns derefter adgangen til den aktuelle bruger, SYSTEM og gruppen Administrators. Kør følgende kommandoer i PowerShell:

   ```powershell
   New-Item -ItemType Directory -Path C:dvls
   icacls C:dvls /inheritance:r /grant:r "$(whoami):(OI)(CI)F" "*S-1-5-18:(OI)(CI)F" "*S-1-5-32-544:(OI)(CI)F"
   ```
2. I den mappe skal De oprette en `.env`-fil med følgende indhold og erstatte hver værdi mellem vinkelparenteser:

   ```
   DVLS_IMAGE_TAG=release-20XX.X
   SQL_HOST=host.docker.internal
   SQL_PORT=1433
   SQL_DATABASE=DVLS
   SQL_LOGIN=<DvlsSqlLogin>
   SQL_PASSWORD=<DvlsSqlLoginPassword>
   DVLS_ADMIN_USERNAME=dvls-admin
   DVLS_ADMIN_PASSWORD=<StrongAdminPassword>
   DVLS_HOSTNAME=localhost
   DVLS_HOST_PORT=5000
   ```

   `host.docker.internal` lader containeren nå en SQL Server, der er installeret på Docker-værten. Hvis SQL Server kører på en anden server, skal De erstatte den med den servers navn eller IP-adresse.
3. I den samme mappe skal De oprette en `docker-compose.yml`-fil med følgende indhold:

   ```yaml
   services:
     # One-time initialization: creates the database schema, the administrator, and the encryption configuration.
     dvls-init:
       image: devolutions/devolutions-server:${DVLS_IMAGE_TAG}
       profiles: ["init"]
       volumes:
         - dvlsdata:/opt/devolutions/dvls/App_Data
       environment:
         DVLS_INIT: "true"
         DATABASE_HOST: ${SQL_HOST}
         DATABASE_PORT: "${SQL_PORT}"
         DATABASE_NAME: ${SQL_DATABASE}
         DATABASE_USERNAME: ${SQL_LOGIN}
         DATABASE_PASSWORD: ${SQL_PASSWORD}
         DATABASE_ENCRYPT: "true"
         DATABASE_TRUST_SERVER_CERTIFICATE: "true"
         DVLS_ADMIN_USERNAME: ${DVLS_ADMIN_USERNAME}
         DVLS_ADMIN_PASSWORD: ${DVLS_ADMIN_PASSWORD}
         HOSTNAME: ${DVLS_HOSTNAME}
         WEB_SCHEME: http
         WEB_PORT: "5000"
         EXTERNAL_WEB_PORT: "${DVLS_HOST_PORT}"
       extra_hosts:
         - "host.docker.internal:host-gateway"

     dvls:
       image: devolutions/devolutions-server:${DVLS_IMAGE_TAG}
       container_name: dvls-app
       restart: unless-stopped
       ports:
         - "${DVLS_HOST_PORT}:5000"
       volumes:
         - dvlsdata:/opt/devolutions/dvls/App_Data
       environment:
         DATABASE_HOST: ${SQL_HOST}
         DATABASE_PORT: "${SQL_PORT}"
         DATABASE_NAME: ${SQL_DATABASE}
         DATABASE_USERNAME: ${SQL_LOGIN}
         DATABASE_PASSWORD: ${SQL_PASSWORD}
         DATABASE_ENCRYPT: "true"
         DATABASE_TRUST_SERVER_CERTIFICATE: "true"
         HOSTNAME: ${DVLS_HOSTNAME}
         WEB_SCHEME: http
         WEB_PORT: "5000"
         EXTERNAL_WEB_PORT: "${DVLS_HOST_PORT}"
       extra_hosts:
         - "host.docker.internal:host-gateway"

   volumes:
     dvlsdata:
   ```

{% hint style="info" %}
`DATABASE_TRUST_SERVER_CERTIFICATE=true` accepterer SQL Server-certifikatet uden at validere det. Hvis SQL Server præsenterer et certifikat, der er udstedt af en betroet myndighed, skal De fjerne denne variabel. Se [Krypteret databaseforbindelse (TLS)](/server/da/knowledge-base/how-to-articles/devolutions-server-docker-deployment/advanced-docker-configuration-for-devolutions-server.md#encrypted-database-connection-tls).
{% endhint %}

#### Start hybridudrulningen

Kør de samme kommandoer som ved alt-i-en-udrulningen fra udrulningsmappen:

```powershell
docker compose --profile init pull
docker compose --profile init run --rm dvls-init
docker compose up -d
docker compose exec dvls sh -c "tail -n 50 -f /opt/devolutions/dvls/App_Data/DPS_Main*.log"
```

Hvis initialiseringskommandoen ikke vender tilbage, efter at `Initialization completed successfully.` vises, skal De trykke på Ctrl+C, før De kører `docker compose up -d`.

Log derefter på Devolutions Server, sikkerhedskopiér `encryption.config` med den samme kommando `docker compose cp` som ved alt-i-en-udrulningen, og flyt filen til en sikker placering uden for udrulningsmappen.

### Udrul på en anden server

For at genskabe udrulningen på en anden Windows-server skal De følge trinnene nedenfor. De opretter en ny, tom udrulning. Dataene og krypteringskonfigurationen fra den første server kopieres ikke.

1. Installér Docker Desktop på målserveren (se [Forudsætninger](#prerequisites)).
2. Opret en mappe, og kopiér filerne `docker-compose.yml` og `.env` til den. Skift adgangskoderne i `.env`, hvis det er nødvendigt.
3. Kør `Get-ChildItem` i mappen, og sørg for, at filerne hedder præcis `.env` og `docker-compose.yml`. Notesblok kan tilføje en skjult filtypenavn `.txt`.
4. Kør kommandoerne fra [Start udrulningen](#start-the-deployment).
5. For at nå Devolutions Server fra andre computere skal De angive `DVLS_HOSTNAME` til serverens fuldt kvalificerede domænenavn og tillade porten `DVLS_HOST_PORT` i Windows Firewall.

### Verificer udrulningen

Kør følgende kommandoer fra udrulningsmappen. Containernavnene svarer til eksemplerne ovenfor.

| Kontrol                                  | Kommando                                                                                                                                   |
| ---------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
| Containerne kører, og SQL er sund        | `docker compose ps`                                                                                                                        |
| Sundhedsstatus for SQL Server            | `docker inspect --format '{{.State.Health.Status}}' dvls-sqlserver` (forventet: `healthy`)                                                 |
| Devolutions Server opløser SQL-tjenesten | `docker exec dvls-app sh -c "getent hosts sqlserver"`                                                                                      |
| Devolutions Server når SQL på port 1433  | `docker exec dvls-app bash -c "(echo > /dev/tcp/sqlserver/1433) 2>&1 && echo OPEN \|\| echo BLOCKED"` (forventet: `OPEN`)                  |
| Devolutions Server startede korrekt      | `docker exec dvls-app sh -c "grep -h -E 'Now listening\|Scheduler initialized' /opt/devolutions/dvls/App_Data/DPS_Main*.log \| tail -n 2"` |
| Webgrænsefladen svarer                   | `curl.exe -s -o NUL -w "%{http_code}" http://localhost:5000/` (forventet: `200`)                                                           |

Ved hybridudrulningen skal De erstatte `sqlserver` med værdien af `SQL_HOST` og `1433` med værdien af `SQL_PORT`. De to rækker om SQL Server-sundhed gælder ikke, da der ikke er nogen SQL Server-container.

Hvis De har ændret `DVLS_HOST_PORT`, skal De erstatte `5000` med dens værdi i den sidste række.

### Fejlfinding

| Symptom                                                                                                  | Løsning                                                                                                                                                                                                                                                                                                                                                                  |
| -------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `failed to resolve reference "docker.io/devolutions/devolutions-server:latest": not found`               | Tagget `latest` findes ikke. Brug et tag `release-20XX.X` eller `20XX.X.X.X` (se [Vælg et imagetag](#choose-an-image-tag)).                                                                                                                                                                                                                                              |
| `The "DVLS_IMAGE_TAG" variable is not set` eller `invalid reference format`                              | Filen `.env` mangler `DVLS_IMAGE_TAG` eller hedder ikke præcis `.env`. Tilføj linjen, og sørg for, at filen ikke har filtypenavnet `.txt`.                                                                                                                                                                                                                               |
| `DATABASE_HOST or AZURE_SQL_HOST is required.`                                                           | Compose-filen bruger miljøvariabler fra en ældre imageversion. Brug variablerne `DATABASE_*`, som vises i denne artikel, tilknyt værtsporten til containerport `5000`, og kør tjenesten `dvls-init` før den første start.                                                                                                                                                |
| Containeren med SQL Server bliver aldrig sund, og loggen viser `Password validation failed`              | `MSSQL_SA_PASSWORD` opfylder ikke adgangskodepolitikken for SQL Server. Brug mindst 8 tegn med store bogstaver, små bogstaver, cifre og symboler.                                                                                                                                                                                                                        |
| Containeren med SQL Server forbliver `unhealthy`, og loggen gentager `Login failed for user 'sa'`        | `MSSQL_SA_PASSWORD` anvendes kun første gang, volumenet `mssqldata` oprettes. Hvis volumenet allerede fandtes, beholdt SQL Server den tidligere adgangskode. Gendan den tidligere adgangskode i `.env`, eller fjern volumenerne som beskrevet i [Fjern udrulningen](#remove-the-deployment), hvis dataene kan kasseres.                                                  |
| `dependency sqlserver failed to start`, eller sundhedsstatussen skifter mellem `starting` og `unhealthy` | Den første start af SQL Server kan tage op til to minutter på langsommere diske. Behold `retries: 30` og `start_period: 120s` i sundhedskontrollen, eller forøg dem.                                                                                                                                                                                                     |
| Containeren med SQL Server stopper lige efter, at den starter (ikke nok hukommelse)                      | Forøg den hukommelse, der er tilgængelig for Docker, til mindst 4 GB i Docker Desktop (**Indstillinger** – **Ressourcer**).                                                                                                                                                                                                                                              |
| Webgrænsefladen returnerer en fejl de første minutter efter `docker compose up -d`                       | Det er forventet, mens SQL Server fuldfører sin første start. Vent, og følg loggen for Devolutions Server med `docker compose exec dvls sh -c "tail -n 50 -f /opt/devolutions/dvls/App_Data/DPS_Main*.log"`.                                                                                                                                                             |
| `Bind for 0.0.0.0:5000 failed: port is already allocated`                                                | Et andet program bruger port 5000 på værten. Angiv en anden værdi for `DVLS_HOST_PORT` i `.env`. For at se, hvilket program der bruger porten, skal De køre `Get-NetTCPConnection -LocalPort 5000 -State Listen`.                                                                                                                                                        |
| Kommandoen `dvls-init` vender ikke tilbage efter `Initialization completed successfully.`                | Tryk på Ctrl+C, og fortsæt derefter med næste trin.                                                                                                                                                                                                                                                                                                                      |
| `Unhandled exception. System.InvalidOperationException` ved `CreateAdministrator` fra `dvls-init`        | Udrulningen er allerede initialiseret. Spring initialiseringstrinnet over. Der ændres intet. Krypteringskonfigurationen og administratoradgangskoden forbliver de samme.                                                                                                                                                                                                 |
| `Login failed for user '<login>'` (fejl 18456) fra `dvls-init`                                           | Kontrollér værdierne `SQL_LOGIN` og `SQL_PASSWORD` i `.env`, at logon findes, og at tilstanden SQL Server- og Windows-godkendelse (blandet tilstand) er aktiveret.                                                                                                                                                                                                       |
| Logonsiden viser `Unable to find the encryption file. Please contact your administrator.`                | Runtime-containeren har ikke den krypteringskonfiguration, der blev oprettet ved initialiseringen. Sørg for, at både `dvls-init` og `dvls` monterer det samme volumen `dvlsdata` på `/opt/devolutions/dvls/App_Data`. Hvis databasen allerede indeholder data, der er krypteret med en mistet nøgle, kan de data ikke gendannes, og udrulningen skal initialiseres igen. |
| Containeren kan ikke nå en eksisterende SQL Server (hybridmulighed)                                      | Kontrollér, at TCP/IP er aktiveret, at en statisk port er konfigureret, at Windows Firewall tillader porten, og at posten `extra_hosts` findes, når `SQL_HOST` er `host.docker.internal`.                                                                                                                                                                                |
| `docker` genkendes ikke i PowerShell                                                                     | Start Docker Desktop, og åbn derefter et nyt PowerShell-vindue, så den opdaterede `PATH` indlæses.                                                                                                                                                                                                                                                                       |

### Opdater Devolutions Server

Sikkerhedskopiér databasen og `encryption.config`, før De opdaterer.

1. Tilføj følgende tjeneste `dvls-update` under `services:` i `docker-compose.yml`, og tilføj `dvlsbackup:` under `volumes:`. Eksemplet bruger alt-i-en-værdierne:

   ```yaml
     dvls-update:
       image: devolutions/devolutions-server:${DVLS_IMAGE_TAG}
       profiles: ["update"]
       volumes:
         - dvlsdata:/opt/devolutions/dvls/App_Data
         - dvlsbackup:/backup
       environment:
         DVLS_UPDATE_MODE: "true"
         DVLS_BACKUP_PATH: /backup
         DATABASE_HOST: sqlserver
         DATABASE_PORT: "1433"
         DATABASE_NAME: ${DATABASE_NAME}
         DATABASE_USERNAME: sa
         DATABASE_PASSWORD: ${MSSQL_SA_PASSWORD}
         DATABASE_ENCRYPT: "true"
         DATABASE_TRUST_SERVER_CERTIFICATE: "true"
       depends_on:
         sqlserver:
           condition: service_healthy
   ```

   Ved hybridudrulningen skal De bruge de samme værdier `DATABASE_*` som tjenesten `dvls` og erstatte `depends_on` med posten `extra_hosts` fra tjenesten `dvls`.
2. Stop Devolutions Server:

   ```powershell
   docker compose stop dvls
   ```
3. Skift `DVLS_IMAGE_TAG` i filen `.env`.
4. Download de nye imager, og opdater databasen:

   ```powershell
   docker compose --profile update pull
   docker compose --profile update run --rm dvls-update
   ```
5. Vent på `Database update completed successfully.`, og start derefter Devolutions Server med den nye version:

   ```powershell
   docker compose up -d
   ```

Variablerne til opdateringstilstand findes under [Avanceret Docker-konfiguration til Devolutions Server](/server/da/knowledge-base/how-to-articles/devolutions-server-docker-deployment/advanced-docker-configuration-for-devolutions-server.md#version-updates).

### Fjern udrulningen

Stop og fjern containerne, mens databasen og dataene i Devolutions Server beholdes:

```powershell
docker compose down
```

{% hint style="danger" %}
Følgende kommando sletter også volumenerne. Det kan ikke fortrydes.

* **Alt i én**: sletter SQL Server-databaserne og krypteringskonfigurationen.
* **Hybrid**: sletter kun krypteringskonfigurationen. Databasen forbliver på SQL Server og kan ikke længere dekrypteres.

```powershell
docker compose --profile init down -v
```

{% endhint %}

#### Se også

* [Udrul Devolutions Server med Docker](/server/da/knowledge-base/how-to-articles/devolutions-server-docker-deployment.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)
* [Databaseopsætning](/server/da/getting-started/installation/database-setup.md)
* [Sikkerhedstjekliste](/server/da/getting-started/security-checklist.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/deploy-devolutions-server-and-sql-server-with-docker-compose-on-windows.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.