> 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/fr/knowledge-base/how-to-articles/install-devolutions-server-for-linux.md).

# Installer Devolutions Server pour Linux

Installez Devolutions Server pour Linux avec Bash et PowerShell sur une base de données SQL Server ou PostgreSQL, avec la configuration TLS, les mises à jour et la suppression par systemd.

Devolutions Server est offert pour Linux avec Microsoft Kestrel comme serveur Web intégré et Microsoft PowerShell 7 pour l'installation en ligne de commande. La base de données peut être Microsoft SQL Server ou PostgreSQL. Le présent sujet montre comment installer manuellement Devolutions Server pour Linux à l'aide d'invites Bash et de scripts PowerShell, ainsi que comment y accéder, le mettre à jour et le supprimer.

Autrement, Devolutions Server peut être installé automatiquement à l'aide des scripts qui se trouvent dans le [dépôt GitHub ScriptLibrary de Devolutions](https://github.com/Devolutions/ScriptLibrary/tree/main/DVLSForLinux).

### Installation des prérequis <a href="#installing-prerequisites" id="installing-prerequisites"></a>

Devolutions Server a besoin d'un serveur de base de données. Installez le moteur de base de données à utiliser avec la procédure SQL Server ou PostgreSQL, ou passez directement à l'installation PowerShell si le serveur de base de données existe déjà.

#### SQL Server

1. Si Microsoft SQL Server n'est pas déjà installé, exécutez l'invite Bash suivante en remplaçant la variable `MSSQL_SA_PASSWORD` par un mot de passe fort :

   ```bash
   source /etc/os-release
   curl -fsSL https://packages.microsoft.com/keys/microsoft.asc | sudo gpg --dearmor --batch --yes -o /usr/share/keyrings/microsoft-prod.gpg
   curl -fsSL https://packages.microsoft.com/config/ubuntu/$VERSION_ID/mssql-server-2022.list | sudo tee /etc/apt/sources.list.d/mssql-server-2022.list
   sudo apt-get update
   sudo apt-get install -y mssql-server
   sudo MSSQL_PID="evaluation" MSSQL_SA_PASSWORD="mystrongpassword" /opt/mssql/bin/mssql-conf -n setup accept-eula
   sudo /opt/mssql/bin/mssql-conf set sqlagent.enabled true
   sudo systemctl restart mssql-server
   ```

   `MSSQL_PID` est défini à ***evaluation*** dans cet exemple, mais une clé de produit peut être saisie ici à la place.

{% hint style="warning" %}
Microsoft ne prend en charge que [certaines versions de SQL](/server/fr/overview-of-devolutions-server/system-requirements.md#software-dependencies). Consultez la documentation de Microsoft pour vous assurer que votre version de SQL est officiellement prise en charge pour votre distribution.
{% endhint %}

#### PostgreSQL

Devolutions Server prend en charge PostgreSQL 14 ou ultérieur, installé sur un serveur ou fourni par un service PostgreSQL géré qui accorde l'attribut `SUPERUSER`. Devolutions Server se connecte avec un seul rôle, au moyen d'un nom d’utilisateur et d'un mot de passe : l'authentification intégrée n'est pas offerte avec PostgreSQL.

1. Si PostgreSQL n'est pas déjà offert, installez-le sur le serveur de base de données avec cette invite Bash :

   ```bash
   sudo apt-get update
   sudo apt-get install -y postgresql
   psql --version
   ```

   La version de PostgreSQL fournie par la distribution dépend de sa version. Assurez-vous que la version installée est PostgreSQL 14 ou ultérieure.
2. Créez un rôle dédié qui possède la base de données de Devolutions Server, avec l'attribut `SUPERUSER` requis pour créer le schéma de base de données. Remplacez `YOURSTRONGPASSWORD` par un mot de passe robuste :

   ```bash
   sudo -u postgres psql -c "CREATE ROLE dvls_owner LOGIN SUPERUSER PASSWORD 'YOURSTRONGPASSWORD';"
   sudo -u postgres psql -c "CREATE DATABASE dvls OWNER dvls_owner;"
   ```

   La création du schéma modifie les transtypages de PostgreSQL, ce que seul un superutilisateur peut faire. Avec un service PostgreSQL géré, créez le rôle et la base de données avec le compte administrateur du service. Après l'installation, le rôle n'a pas besoin de l'attribut `SUPERUSER` : retirez-le avec `sudo -u postgres psql -c "ALTER ROLE dvls_owner NOSUPERUSER;"`.
3. Sur la machine qui exécute Devolutions Server, installez les outils client PostgreSQL. La tâche de sauvegarde de données de base de données intégrée de Devolutions Server exécute `pg_dump` et `pg_restore`, et les procédures de mise à jour et de suppression de cette page les utilisent :

   ```bash
   sudo apt-get install -y postgresql-client
   pg_dump --version
   ```

   La version majeure de `pg_dump` doit être égale ou supérieure à la version majeure du serveur PostgreSQL, sinon la sauvegarde de données échoue. Lorsque le paquet de la distribution est plus ancien que le serveur, installez le paquet `postgresql-client-<major version>` correspondant à partir du dépôt APT de PostgreSQL.

#### PowerShell et le module Devolutions.PowerShell

1. Exécutez cette invite Bash pour installer PowerShell 7 :

   ```bash
   sudo apt-get update
   sudo apt-get install -y wget apt-transport-https software-properties-common
   source /etc/os-release
   wget -q https://packages.microsoft.com/config/ubuntu/$VERSION_ID/packages-microsoft-prod.deb
   sudo dpkg -i packages-microsoft-prod.deb
   rm packages-microsoft-prod.deb
   sudo apt-get update
   sudo apt-get install -y powershell
   ```

   Exécutez cette invite depuis un répertoire où l'utilisateur actuel peut écrire, car `wget` télécharge le paquet `.deb` dans le répertoire actuel.
2. Installez le [module Devolutions.PowerShell](https://www.powershellgallery.com/packages/Devolutions.PowerShell/) pour tous les utilisateurs (emplacement : `/opt/microsoft/powershell/7/Modules`). Les procédures d'installation et de mise à jour de cette page exécutent PowerShell en tant que root, qui ne trouve que les modules installés pour tous les utilisateurs :

   ```powershell
   & sudo pwsh -Command { Install-Module -Name 'Devolutions.PowerShell' -Confirm:$False -Scope 'AllUsers' -Force }
   ```

   Un avertissement est susceptible d'apparaître indiquant que l'installation provient d'un dépôt non fiable. Le module est hébergé sur PowerShell Gallery, l'emplacement officiel d'hébergement des modules PowerShell géré par Microsoft. Pour ne plus voir cet avertissement, exécutez `Set-PSRepository -Name PSGallery -InstallationPolicy Trusted`.
3. Créez un utilisateur et un groupe pour Devolutions Server. Un utilisateur et un groupe distincts sont facultatifs et isolent Devolutions Server des autres services. Cette invite Bash crée un utilisateur et un groupe tous deux nommés ***dvls***, avec le répertoire d'installation défini à `/opt/devolutions/dvls` :

   ```bash
   sudo useradd -N dvls
   sudo groupadd dvls
   sudo usermod -a -G dvls dvls
   # optional, add current user to dvls group
   sudo usermod -a -G dvls $(id -un)
   sudo mkdir -p /opt/devolutions/dvls
   sudo chown -R dvls:dvls /opt/devolutions/dvls
   sudo chmod 550 /opt/devolutions/dvls
   ```

### Téléchargement et installation de Devolutions Server pour Linux <a href="#downloading-and-installing-dvls-for-linux" id="downloading-and-installing-dvls-for-linux"></a>

Le répertoire d'installation appartient à `dvls:dvls` en mode 550, donc l'installation s'exécute en tant que root. Démarrez PowerShell avec `sudo pwsh` et exécutez tous les scripts PowerShell de cette section dans cette session.

1. Téléchargez la dernière version de Devolutions Server pour Linux et extrayez le fichier `.tar.gz` dans `/opt/devolutions/dvls` :

   ```powershell
   Import-Module -Name 'Devolutions.PowerShell'

   $DVLSPath = '/opt/devolutions/dvls'
   $DVLSDownloadPath = '/tmp/dvls-linux-x64.tar.gz'

   Get-DPSProduct -Name 'DPSLinuxX64bin' -Destination $DVLSDownloadPath
   & tar -xzf $DVLSDownloadPath -C $DVLSPath --strip-components=1
   Remove-Item -Path $DVLSDownloadPath

   & chown -R dvls:dvls $DVLSPath
   & chmod -R o-rwx $DVLSPath
   & chmod 660 (Join-Path -Path $DVLSPath -ChildPath 'appsettings.json')
   & chmod 770 (Join-Path -Path $DVLSPath -ChildPath 'App_Data')

   Set-Location -Path $DVLSPath
   ```
2. Générez un certificat si Devolutions Server doit répondre en TLS et qu'aucun certificat n'existe encore. Remplacez `MYHOST` par le nom d'hôte du serveur :

   ```powershell
   & openssl req -x509 -newkey rsa:4096 -sha256 -days 3650 -nodes -keyout cert.key -out cert.crt -subj "/CN=MYHOST" -addext "subjectAltName=DNS:MYHOST"
   & openssl pkcs12 -export -out cert.pfx -inkey cert.key -in cert.crt -passout pass:
   ```

   Le `subjectAltName` utilise `DNS:` dans cet exemple. Pour répondre seulement sur une adresse IP, utilisez `IP:` à la place. Le certificat `.pfx` généré n'a pas de mot de passe.

#### Paramètres d'installation pour SQL Server

Définissez les paramètres d'installation dans la même session PowerShell. Remplacez `MYHOST`, `MYEMAIL`, `MSSQLHOST`, `DBUSERNAME` et `YOURSTRONGPASSWORD` par les valeurs de l'environnement. `MSSQLHOST` est l'hôte SQL Server, `localhost` lorsque SQL Server s'exécute sur la même machine. Pour répondre en TLS, utilisez `https` dans `$DVLSURI`.

```powershell
$DVLSPath = '/opt/devolutions/dvls'
$DVLSURI  = 'http://MYHOST:5000/'

$DVLSAdminUsername = 'dvls-admin'
$DVLSAdminPassword = 'dvls-admin'
$DVLSAdminEmail    = 'MYEMAIL'

$Params = @{
    'DatabaseHost'           = 'MSSQLHOST'
    'DatabaseName'           = 'DSERVER'
    'DatabaseUserName'       = 'DBUSERNAME'
    'DatabasePassword'       = 'YOURSTRONGPASSWORD'
    'ServerName'             = 'DSERVER'
    'AccessUri'              = $DVLSURI
    'HttpListenerUri'        = $DVLSURI
    'DPSPath'                = $DVLSPath
    'UseEncryptedConnection' = $False # Modify as needed
    'TrustServerCertificate' = $False # Modify as needed
    'EnableTelemetry'        = $True  # Modify as needed
    'DisableEncryptConfig'   = $True
}
```

#### Paramètres d'installation pour PostgreSQL

Définissez les paramètres d'installation dans la même session PowerShell. Remplacez `MYHOST`, `MYEMAIL`, `PGHOST` et `YOURSTRONGPASSWORD` par les valeurs de l'environnement. `PGHOST` est l'hôte PostgreSQL, `localhost` lorsque PostgreSQL s'exécute sur la même machine. Pour répondre en TLS, utilisez `https` dans `$DVLSURI`.

```powershell
$DVLSPath = '/opt/devolutions/dvls'
$DVLSURI  = 'http://MYHOST:5000/'

$DVLSAdminUsername = 'dvls-admin'
$DVLSAdminPassword = 'dvls-admin'
$DVLSAdminEmail    = 'MYEMAIL'

$Params = @{
    'DatabaseType'         = 'PostgreSql'
    'DatabaseHost'         = 'PGHOST'
    'DatabasePort'         = 5432
    'DatabaseName'         = 'dvls'
    'DatabaseUserName'     = 'dvls_owner'
    'DatabasePassword'     = 'YOURSTRONGPASSWORD'
    'ServerName'           = 'DSERVER'
    'AccessUri'            = $DVLSURI
    'HttpListenerUri'      = $DVLSURI
    'DPSPath'              = $DVLSPath
    'EnableTelemetry'      = $True # Modify as needed
    'DisableEncryptConfig' = $True
}
```

`DatabasePort` vaut 5432 par défaut lorsqu'il est omis. Utilisez un nom de base de données en minuscules : l'installation crée la base de données avec son nom entre guillemets, donc le nom est sensible à la casse dans les commandes PostgreSQL.

Avec `DatabaseType` défini à `PostgreSql`, `New-DPSInstallConfiguration` ignore les paramètres SQL Server `-IntegratedSecurity`, `-FailoverPartner`, `-RetryCount` et `-RetryInterval` et affiche un avertissement lorsqu'ils sont spécifiés. `-UseEncryptedConnection` et `-TrustServerCertificate` ne s'appliquent pas non plus : la chaîne de connexion utilise `SSL Mode=Prefer`, qui chiffre la connexion seulement lorsque le serveur PostgreSQL offre TLS. Pour exiger le chiffrement, changez `SSL Mode` pour `Require` ou `VerifyFull` dans les chaînes de connexion de `appsettings.json` après l'installation, puis redémarrez Devolutions Server.

La chaîne de connexion conserve les mots-clés PostgreSQL (`Host=`, `Port=`, `Database=`, `Username=`, `Password=`), c'est ainsi que Devolutions Server détecte le moteur PostgreSQL. Elle est stockée sous `ConnectionStrings.LocalSqlServer` dans `appsettings.json`, la même clé qu'avec SQL Server. Devolutions Server ajoute `Search Path=dbo,public` et `Keep Alive=30` lorsqu'ils ne sont pas spécifiés. Lorsque vous définissez `Search Path` manuellement, conservez `dbo` dedans, car toutes les tables de Devolutions Server sont dans le schéma `dbo`.

#### Exécution de l'installation

1. Exécutez l'installation de Devolutions Server avec le module Devolutions.PowerShell, dans la même session PowerShell :

   ```powershell
   $Configuration = New-DPSInstallConfiguration @Params
   New-DPSAppSettings -Configuration $Configuration

   $Settings = Get-DPSAppSettings -ApplicationPath $DVLSPath
   $ConnectionString = $Settings.ConnectionStrings.LocalSqlServer

   New-DPSDatabase -ConnectionString $ConnectionString
   Update-DPSDatabase -ConnectionString $ConnectionString -InstallationPath $DVLSPath
   New-DPSWorkspaceSettings -ConnectionString $ConnectionString

   New-DPSEncryptConfiguration -ApplicationPath $DVLSPath
   New-DPSDatabaseAppSettings -Configuration $Configuration

   New-DPSAdministrator -ConnectionString $ConnectionString -Name $DVLSAdminUsername -Password $DVLSAdminPassword -Email $DVLSAdminEmail
   ```

   `New-DPSDatabase` affiche un avertissement et continue lorsque la base de données existe déjà, ce qui est le cas lorsque la base de données a été créée au préalable. `Update-DPSDatabase` crée ensuite le schéma.
2. Si un certificat a été généré, modifiez le fichier `appsettings.json` pour permettre à Kestrel de répondre en TLS :

   ```powershell
   $JSON = Get-Content -Path (Join-Path -Path $DVLSPath -ChildPath 'appsettings.json') | ConvertFrom-JSON -Depth 100

   $JSON.Kestrel.Endpoints.Http | Add-Member -MemberType NoteProperty -Name 'Certificate' -Value @{
       'Path'     = (Join-Path -Path $DVLSPath -ChildPath 'cert.pfx')
       'Password' = ''
   }

   $JSON | ConvertTo-JSON -Depth 100 | Set-Content -Path (Join-Path -Path $DVLSPath -ChildPath 'appsettings.json')

   $AccessUri = (Get-DPSAccessUri -ConnectionString $ConnectionString).AccessUri
   Set-DPSAccessUri -ApplicationPath $DVLSPath -ConnectionString $ConnectionString -AccessURI ($AccessUri -Replace '^http:', 'https:')
   ```
3. Réappliquez la propriété et les permissions des fichiers créés par l'installation, puis fermez la session PowerShell root :

   ```powershell
   & chown -R dvls:dvls $DVLSPath
   & chmod -R o-rwx $DVLSPath
   & chmod 550 $DVLSPath
   & chmod 660 (Join-Path -Path $DVLSPath -ChildPath 'appsettings.json')
   & chmod 770 (Join-Path -Path $DVLSPath -ChildPath 'App_Data')
   exit
   ```
4. Créez un fichier d'unité systemd pour exécuter Devolutions Server pour Linux en arrière-plan et activez-le au démarrage, avec cette invite Bash :

   ```bash
   sudo tee /etc/systemd/system/dvls.service > /dev/null <<EOT
   [Unit]
   Description=Devolutions Server

   [Service]
   Type=simple
   Restart=always
   RestartSec=10
   User=dvls
   ExecStart=/opt/devolutions/dvls/Devolutions.Server
   WorkingDirectory=/opt/devolutions/dvls
   KillSignal=SIGINT
   SyslogIdentifier=dvls
   Environment="SCHEDULER_EMBEDDED=true"

   [Install]
   WantedBy=multi-user.target
   EOT

   sudo systemctl daemon-reload
   sudo systemctl enable dvls
   ```

   `SCHEDULER_EMBEDDED=true` exécute le planificateur de Devolutions Server à l'intérieur du service. Avec PostgreSQL, la tâche de sauvegarde de données intégrée cherche `pg_dump` et `pg_restore` dans le `PATH` du service. S'ils sont installés ailleurs, ajoutez `Environment="DVLS_PG_DUMP_PATH=/path/to/pg_dump"` et `Environment="DVLS_PG_RESTORE_PATH=/path/to/pg_restore"` à la section `[Service]`.
5. Démarrez Devolutions Server et affichez son état :

   ```bash
   sudo systemctl start dvls
   sudo systemctl status dvls
   ```

### Accéder à Devolutions Server pour Linux <a href="#accessing-dvls-linux" id="accessing-dvls-linux"></a>

Devolutions Server pour Linux écoute sur le port de l'`HttpListenerUri` défini pendant l'installation, sur l'adresse IP ou le nom d'hôte du système d'installation, par exemple `http://MYHOST:5000`. Des erreurs OAuth peuvent survenir au premier lancement lors de l'accès à Devolutions Server depuis une URL qui n'est pas configurée. Si c'est le cas, ajoutez des URI supplémentaires sur lesquels écouter, ou modifiez l'URI principal, en exécutant le script suivant dans PowerShell :

```powershell
Import-Module -Name 'Devolutions.PowerShell'

$DVLSPath = '/opt/devolutions/dvls'

$Settings = Get-DPSAppSettings -ApplicationPath $DVLSPath
$ConnectionString = $Settings.ConnectionStrings.LocalSqlServer

Get-DPSAccessUri -ConnectionString $ConnectionString

Set-DPSAccessUri -ConnectionString $ConnectionString -ApplicationPath $DVLSPath -AccessURI 'http://10.10.0.20:5000/' -AdditionalAccessURIs @('http://ubuntu-2204:5000/')
```

Si Devolutions Server demeure inaccessible en dehors du système installé, assurez-vous que le pare-feu autorise le port, par exemple avec Uncomplicated Firewall : `sudo ufw allow 5000`.

### Importation de la clé de chiffrement de Devolutions Server <a href="#importing-devolutions-server-encryption-key" id="importing-devolutions-server-encryption-key"></a>

Lorsque l'installation Linux utilise la base de données d'une installation Windows existante, elle a besoin des clés de chiffrement de cette installation.

**Exportation à partir d'une installation Windows existante**

```powershell
Import-Module -Name 'Devolutions.PowerShell'
$existingDVLSInstance = 'C:\my\path\dvlsInstance\'
$destination = 'C:\other\path\encryption.config'
Export-DPSEncryptionKeys -ApplicationPath $existingDVLSInstance -Destination $destination
```

**Importation vers la nouvelle installation Linux**

```powershell
Import-Module -Name 'Devolutions.PowerShell'
$DVLSPath = '/opt/devolutions/dvls'
$keysToImport = '/path/to/encryption.config'
Import-DPSEncryptionKeys -ApplicationPath $DVLSPath -Filename $keysToImport
```

Lorsque les clés ont été exportées avec `-Password`, ajoutez le même `-Password` à `Import-DPSEncryptionKeys`.

### Mise à jour de Devolutions Server pour Linux <a href="#updating-devolutions-server-for-linux" id="updating-devolutions-server-for-linux"></a>

N'extrayez pas la nouvelle archive `.tar.gz` directement par-dessus `/opt/devolutions/dvls`. Cela remplace `appsettings.json`, qui contient les chaînes de connexion et les paramètres Kestrel, et laisse en place les fichiers de la version précédente, ce qui empêche le service de démarrer. Suivez toujours la méthode de mise à jour détaillée sur cette page.

#### Sauvegarde de la base de données

Sauvegardez la base de données avant la mise à jour.

Avec SQL Server, exécutez `sqlcmd` à partir du paquet `mssql-tools18`, sur Linux ou vers un SQL Server distant :

```bash
/opt/mssql-tools18/bin/sqlcmd -S <MSSQLHOST> -U <DBUSERNAME> -P '<PASSWORD>' -C \
  -Q "BACKUP DATABASE [DSERVER] TO DISK = N'/var/opt/mssql/data/DSERVER-$(date +%F-%H%M).bak' WITH INIT, COMPRESSION;"
```

Le chemin complet vers `sqlcmd` évite l'erreur « command not found » dans les interpréteurs qui ne sont pas des interpréteurs de connexion, où `/etc/profile.d/mssql-tools.sh` n'a pas été chargé. `-C` fait confiance au certificat du serveur, ce qui est requis pour les installations SQL Server locales qui utilisent un certificat auto-signé. Le répertoire de sauvegarde de données doit être accessible en écriture par l'utilisateur `mssql` : `/var/opt/mssql/data/` fonctionne d'emblée. Assurez-vous que le fichier `.bak` existe et n'est pas vide avant de continuer.

Avec PostgreSQL, exécutez `pg_dump` avec le rôle de la base de données, puis validez l'archive avec `pg_restore --list` :

```bash
sudo mkdir -p /var/backups/dvls
sudo chown $(id -un) /var/backups/dvls
BACKUP_FILE=/var/backups/dvls/dvls-$(date +%F-%H%M).backup
pg_dump --format=custom --host=<PGHOST> --port=5432 --username=dvls_owner --dbname=dvls --file=$BACKUP_FILE
pg_restore --list $BACKUP_FILE > /dev/null && echo "Backup is valid: $BACKUP_FILE"
```

`pg_dump` demande le mot de passe du rôle. L'archive contient seulement la base de données : sauvegardez les clés de chiffrement séparément, car une sauvegarde de données de la base de données ne peut pas être utilisée sans elles.

#### Mise à jour de l'installation

1. Arrêtez le service Devolutions Server :

   ```bash
   sudo systemctl stop dvls.service
   sudo systemctl status dvls.service   # confirm inactive (dead)
   ```
2. Sauvegardez les fichiers d'installation et de configuration. `/opt/devolutions/dvls` est en mode 550 et appartient à `dvls:dvls`, donc les applets de commande de sauvegarde de données doivent s'exécuter en tant que root. Démarrez PowerShell avec `sudo pwsh`, exécutez ce script et gardez la session ouverte pour le reste de la mise à jour :

   ```powershell
   Import-Module -Name 'Devolutions.PowerShell'
   $DVLSPath      = '/opt/devolutions/dvls'
   $BackupBase    = "/var/backups/dvls/$(Get-Date -Format 'yyyy-MM-dd-HHmm')"
   $BackupConfig  = Join-Path -Path $BackupBase -ChildPath 'config'
   $BackupInstall = Join-Path -Path $BackupBase -ChildPath 'installation'
   New-Item -ItemType Directory -Path $BackupConfig, $BackupInstall -Force | Out-Null
   Backup-DPSConfigurationFiles -ApplicationPath $DVLSPath -BackupConfigurationPath $BackupConfig
   Backup-DPSInstallationFiles  -ApplicationPath $DVLSPath -BackupPath $BackupInstall
   ```

   `Backup-DPSConfigurationFiles` copie `App_Data/encryption.config`, `appsettings.json` et `web.config` lorsqu'il existe, et échoue si `encryption.config` est absent. `Backup-DPSInstallationFiles` copie tout le répertoire d'installation et exige un répertoire de destination vide.
3. Téléchargez la nouvelle version, videz le répertoire d'installation à l'exception de `App_Data`, qui contient `encryption.config` et l'état d'exécution, puis extrayez la nouvelle version :

   ```powershell
   $DVLSDownloadPath = '/tmp/dvls-linux-x64.tar.gz'
   Get-DPSProduct -Name 'DPSLinuxX64bin' -Destination $DVLSDownloadPath
   Get-ChildItem -Path $DVLSPath -Force | Where-Object { $_.Name -ne 'App_Data' } | Remove-Item -Recurse -Force
   & tar -xzf $DVLSDownloadPath -C $DVLSPath --strip-components=1
   Remove-Item -Path $DVLSDownloadPath
   ```
4. Restaurez les dossiers personnalisés et la configuration :

   ```powershell
   Restore-DPSCustomFolders          -BackupPath $BackupInstall -ApplicationPath $DVLSPath
   Restore-DPSAnomalyDetectionFolder -BackupPath $BackupInstall -ApplicationPath $DVLSPath
   Restore-DPSConfigurationFiles     -BackupConfigurationPath $BackupConfig -ApplicationPath $DVLSPath
   ```

   `Restore-DPSConfigurationFiles` fusionne le `appsettings.json` enregistré, y compris les chaînes de connexion, dans le `appsettings.json` de la nouvelle version, et copie le `encryption.config` enregistré vers `App_Data`.
5. Mettez à jour le schéma de base de données avec la chaîne de connexion du `appsettings.json` restauré :

   ```powershell
   $ConnectionString = (Get-DPSAppSettings -ApplicationPath $DVLSPath).ConnectionStrings.LocalSqlServer
   Update-DPSDatabase -ConnectionString $ConnectionString -InstallationPath $DVLSPath
   ```

   `Update-DPSDatabase` fonctionne avec les chaînes de connexion SQL Server et PostgreSQL. Il n'affiche rien en cas de réussite et affiche l'avertissement `Update failed.` en cas d'échec.
6. Réappliquez la propriété et les permissions :

   ```powershell
   & chown -R dvls:dvls $DVLSPath
   & chmod -R o-rwx $DVLSPath
   & chmod 550 $DVLSPath
   & chmod 660 (Join-Path -Path $DVLSPath -ChildPath 'appsettings.json')
   & chmod 770 (Join-Path -Path $DVLSPath -ChildPath 'App_Data')
   # If a certs directory is in use:
   if (Test-Path -Path (Join-Path -Path $DVLSPath -ChildPath 'certs')) { & chmod 750 (Join-Path -Path $DVLSPath -ChildPath 'certs') }
   ```
7. Démarrez le service et assurez-vous qu'il fonctionne correctement :

   ```powershell
   & systemctl start dvls.service
   & systemctl status dvls.service --no-pager
   & journalctl -u dvls.service -n 100 --no-pager
   ```

   Le journal affiche des entrées ***Migration done with status Done*** et aucune ligne `[ERR]` lorsque la mise à jour a réussi.

#### Dépannage <a href="#troubleshooting" id="troubleshooting"></a>

* **Le service ne démarre pas, `appsettings.json` est absent ou vide :** copiez `$BackupConfig/appsettings.json` vers `/opt/devolutions/dvls`, réappliquez la propriété et les permissions, puis démarrez le service.
* **La connexion fonctionne, mais les entrées ne se déchiffrent pas :** `encryption.config` n'a pas été restauré. Copiez `$BackupConfig/encryption.config` dans `/opt/devolutions/dvls/App_Data/`, définissez son propriétaire et son mode avec `chown dvls:dvls` et `chmod 660`, puis redémarrez le service.
* **Erreurs de schéma de base de données à l'exécution :** `Update-DPSDatabase` a été ignoré ou a échoué. Exécutez de nouveau `Update-DPSDatabase` avec la chaîne de connexion de `appsettings.json`.
* **Restauration complète :** arrêtez le service, videz `/opt/devolutions/dvls` à l'exception de `App_Data`, copiez le contenu de `$BackupInstall` dans `/opt/devolutions/dvls`, réappliquez la propriété et les permissions, restaurez la base de données à partir de la sauvegarde de données prise avant la mise à jour, puis démarrez le service. Avec SQL Server, restaurez le fichier `.bak` avec `sqlcmd` et `RESTORE DATABASE [DSERVER] FROM DISK = N'<backup file>' WITH REPLACE;`. Avec PostgreSQL, restaurez l'archive avec `pg_restore --clean --if-exists --single-transaction --host=<PGHOST> --username=dvls_owner --dbname=dvls <backup file>`. Si les rôles du serveur de destination diffèrent de ceux de la source, ajoutez `--no-owner --role=dvls_owner`.

### Maintenance de la base de données PostgreSQL <a href="#postgresql-database-maintenance" id="postgresql-database-maintenance"></a>

Un database PostgreSQL usato da Devolutions Server necessita della seguente manutenzione:

* **Autovacuum:** lasci autovacuum abilitato, che è l'impostazione predefinita di PostgreSQL.
* **Statistiche:** esegua `ANALYZE;` nel database di Devolutions Server una volta dopo l'installazione e dopo le importazioni di grandi dimensioni, ad esempio `psql --host=<PGHOST> --username=dvls_owner --dbname=dvls -c "ANALYZE;"`.
* **Indici:** PostgreSQL non necessita dei processi di ricostruzione e riorganizzazione degli indici usati con SQL Server. Se nel tempo si accumula il bloat degli indici, esegua `REINDEX CONCURRENTLY` sull'indice interessato.
* **Pianificazione:** PostgreSQL non ha un equivalente di SQL Server Agent. Pianifichi le attività di manutenzione personalizzate con cron.
* **Query:** gli identificatori dello schema di Devolutions Server sono in minuscolo in PostgreSQL. In `psql`, esegua query su `dbo.connections`, non su `dbo.Connections`.

### Suppression de Devolutions Server <a href="#removing-dvls" id="removing-dvls"></a>

Arresti e rimuova il servizio, la directory di installazione e l'utente e il gruppo ***dvls*** eseguendo questo script in PowerShell, adattato al sistema:

```powershell
& sudo systemctl stop dvls.service
& sudo systemctl disable dvls.service
& sudo rm /etc/systemd/system/dvls.service
& sudo systemctl daemon-reload
& sudo rm -rf /opt/devolutions/dvls
& sudo userdel -r dvls
& sudo groupdel dvls
```

Quindi elimini il database di Devolutions Server.

#### Suppression de la base de données SQL Server

Ce script PowerShell s'appuie sur le [module PowerShell DbaTools](https://dbatools.io/) pour supprimer la base de données. Il suppose que `localhost` est l'installation SQL Server et que `DSERVER` est le nom de la base de données :

```powershell
Import-Module dbatools
$Credential = Get-Credential

Set-DbaToolsInsecureConnection

Remove-DbaDatabase -SqlInstance localhost -SqlCredential $Credential -Database 'DSERVER' -Confirm:$False
```

#### Suppression de la base de données PostgreSQL

Exécutez `dropdb` avec le rôle propriétaire de la base de données, ou avec un rôle administrateur :

```bash
dropdb --host=<PGHOST> --port=5432 --username=dvls_owner dvls
```

`DROP DATABASE dvls;` dans `psql` donne le même résultat, à partir d'une connexion à une autre base de données comme `postgres`. Pour supprimer aussi le rôle, exécutez `DROP ROLE dvls_owner;` avec un rôle administrateur.


---

# 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/fr/knowledge-base/how-to-articles/install-devolutions-server-for-linux.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.
