import Tabs from '@/components/docs/Tabs.astro';
import Steps from '@/components/docs/Steps.astro';
import FileTree from '@/components/docs/FileTree.astro';
import Image from '@/components/docs/Image.astro';
import Alert from '@/components/docs/Alert.astro';
import Details from '@/components/docs/Details.astro';
import Cards from '@/components/docs/Cards.astro';
import Card from '@/components/docs/Card.astro';

<Alert type="note">
  Avant de commencer, assurez-vous que le serveur et les clients respectent la [configuration
  requise](/fr/platform/v3/requirements).
</Alert>

## Téléchargement des fichiers d'installation

Vous pouvez télécharger les images d'installation de la Plateforme IIoT de deux manières.

<Tabs labels={['Depuis un support externe', 'Via Internet']}>
  <Fragment slot="panel-0">
    Lorsque le serveur n'a pas accès à Internet — par exemple sous une politique de sécurité
    d'entreprise — vous pouvez installer la plateforme hors ligne. Les images d'installation sont
    transférées sur le serveur depuis un support externe.
  </Fragment>
  <Fragment slot="panel-1">
    Lorsque le serveur dispose d'un accès à Internet, les images d'installation sont récupérées sur
    le serveur depuis un dépôt distant.
  </Fragment>
</Tabs>

## Étapes d'installation

<Steps>

### Copier le paquet de données requis

Copiez le paquet d'installation sur le serveur (les droits d'administrateur sont requis) :

- Copiez l'archive `unicloud.tgz` téléchargée et le dossier `images` (le paquet d'installation
  autonome contenant les images archivées) dans le dossier personnel de l'utilisateur. L'archive
  contient également les fichiers de configuration `docker-compose.yml` et `.env` (le fichier `.env`
  est masqué, activez donc l'affichage des fichiers cachés).

<FileTree
  tree={[
    {
      name: 'images',
      children: [
        { name: 'vadtel-nginx-latest.tar.gz' },
        { name: 'vadtel-app-latest.tar.gz' },
        { name: 'anytelemetry-latest.tar.gz' },
        { name: 'pgbouncer-latest.tar.gz' },
        { name: 'vadteljsondaemon-latest.tar.gz' },
        { name: 'logrotate-latest.tar.gz' },
        { name: 'postgres-15.1-alpine.tar.gz' },
        { name: 'redis-6.0.16-alpine.tar.gz' },
        { name: 'vector-latest.tar.gz' },
      ],
    },
  ]}
/>

- Copiez les fichiers de configuration dans `/opt/vadtelnewweb/`.

- Renseignez les identifiants et mots de passe système dans le fichier `.env` :

```bash title=".env"
#key
SECRET_KEY_BASE=0356080kcn0ejgk4lwekrf

#DB PGSQL login
PG_APP_USER=ppppp

#DB PGSQL password
PG_APP_PASSWORD= ppppp

#WEB interface login
VADTEL_SUPER_ADMIN_EMAIL=NEED_USERNAME

#WEB interface password
VADTEL_SUPER_ADMIN_PASSWORD=NEED_PASSWORD

#DB PGSQL unicloud login
VADTEL_UNICLOUD_TEST_USERNAME=NEED_USERNAME

#DB PGSQL unicloud password
VADTEL_UNICLOUD_TEST_PASSWORD=NEED_PASSWORD
```

### Installer Docker et Docker Compose

#### Sur une distribution basée sur CentOS

Installez Docker et Docker Compose :

```bash
sudo dnf install docker-ce docker-compose
```

Démarrez Docker et activez son lancement au démarrage :

```bash
sudo systemctl enable --now docker && systemctl start docker
```

#### Sur une distribution basée sur Debian

Installez Docker et Docker Compose :

```bash
sudo apt update
sudo apt install docker docker-compose
```

### Installer le système

Les étapes restantes sont identiques sur tous les systèmes d'exploitation. Ajoutez l'utilisateur qui
exécutera l'application au groupe `docker` :

```bash
sudo usermod -aG docker ${USER}
```

<Alert type="warning">
  Après avoir exécuté cette commande, fermez la session puis reconnectez-vous pour appliquer les
  nouvelles permissions.
</Alert>

Décompressez l'archive `unicloud.tgz` dans le dossier personnel de l'utilisateur :

```bash
tar -xf unicloud.tgz
```

<FileTree
  tree={[
    {
      name: 'unicloud',
      children: [
        {
          name: 'run',
          state: 'closed',
          children: [{ name: 'db-unicloud', type: 'folder', state: 'closed' }],
        },
        { name: 'remote_install.sh' },
        { name: 'init-db', children: [{ name: 'create_tables.sql' }] },
        { name: 'script_conf.sh' },
        { name: 'docker-compose.yml' },
        {
          name: 'logs',
          state: 'closed',
          children: [
            { name: 'crontab', type: 'folder', state: 'closed' },
            { name: 'vadteljsondaemon', type: 'folder', state: 'closed' },
            { name: 'anytelemetry', type: 'folder', state: 'closed' },
          ],
        },
        { name: 'backups', type: 'folder', state: 'closed' },
        {
          name: 'data',
          state: 'closed',
          children: [{ name: 'db-unicloud', type: 'folder', state: 'closed' }],
        },
        {
          name: 'local-images',
          children: [
            { name: 'pgbouncer.tar.gz' },
            { name: 'postgres.tar.gz' },
            { name: 'vadteljsondaemon.tar.gz' },
            { name: 'anytelemetry.tar.gz' },
            { name: 'logrotate.tar.gz' },
          ],
        },
        { name: 'unicloud.service' },
      ],
    },
  ]}
/>

Ouvrez le dossier `unicloud` décompressé dans le dossier personnel de l'utilisateur et exécutez le script d'installation :

```bash
sudo ./remote_install.sh
```

Une fois le paquet installé, ouvrez `/var/lib/unicloud` avec les privilèges d'administrateur et
remplacez le propriétaire et le groupe du fichier `.env` par l'utilisateur courant.

Le script génère l'identifiant et le mot de passe de la base de données dans `/var/lib/unicloud/.env`.
Copiez ces valeurs dans `/opt/vadtelnewweb/.env` :

```bash
VADTEL_UNICLOUD_TEST_USERNAME=NEED_USERNAME

VADTEL_UNICLOUD_TEST_PASSWORD=NEED_PASSWORD
```

### Extraire et charger les images

Décompressez les fichiers d'images dans le dossier `images` copié précédemment :

```bash
gunzip vadtel-nginx-latest.tar.gz
gunzip vadtel-app-latest.tar.gz
gunzip anytelemetry-latest.tar.gz
gunzip pgbouncer-latest.tar.gz
gunzip vadteljsondaemon-latest.tar.gz
gunzip logrotate-latest.tar.gz
gunzip postgres-15.1-alpine.tar.gz
gunzip redis-6.0.16-alpine.tar.gz
gunzip vector-latest.tar.gz
```

Chargez les images dans Docker :

```bash
docker load -i vadtel-nginx-latest.tar
docker load -i vadtel-app-latest.tar
docker load -i anytelemetry-latest.tar
docker load -i pgbouncer-latest.tar
docker load -i vadteljsondaemon-latest.tar
docker load -i logrotate-latest.tar
docker load -i postgres-15.1-alpine.tar
docker load -i redis-6.0.16-alpine.tar
docker load -i vector-latest.tar.gz
```

Vérifiez que les images sont disponibles :

```bash
docker images
```

Les neuf images que vous avez chargées doivent apparaître dans la liste.

Si les images se sont chargées sans erreur, exécutez la commande suivante depuis le dossier `/var/lib/unicloud` :

```bash
docker-compose up -d
```

Créez un répertoire pour l'application `vadtelnewweb` sous `/opt` :

```bash
sudo mkdir /opt/vadtelnewweb
cd /opt/vadtelnewweb
```

Copiez ensuite les fichiers `docker-compose.yml` et `.env` (si vous ne les avez pas déjà copiés
auparavant pour une nouvelle installation) dans `/opt/vadtelnewweb`.

Lors du premier lancement, créez la base de données :

```bash
docker-compose run app bundle exec rails db:create
```

Démarrez maintenant l'application :

```bash
docker-compose up -d
```

<Details title="Dépannage">
Si l'application signale l'erreur suivante après le démarrage :

```bash
network unicloud_unicloud-net declared as external, but could not be found
```

c'est que le réseau externe n'a pas été créé lors de l'installation. Effectuez l'installation initiale
à partir de l'archive `unicloud.tar.tgz` comme décrit dans [Installer le système](#installer-le-système),
puis redémarrez l'application :

```bash
docker-compose up -d
```

</Details>

Vérifiez les conteneurs en cours d'exécution :

```bash
docker ps
```

Tous les conteneurs doivent être listés avec le statut `Up`.

### Vérifier le système

Une fois l'application démarrée, ouvrez dans votre navigateur l'adresse IP du serveur sur lequel elle
s'exécute pour confirmer que le système est opérationnel :

```bash
http://127.0.0.1/auth/users/sign_in
```

<Image
  src="/images/deployment/sign-in-en.webp"
  alt="Page de connexion de la Plateforme IIoT avec les champs e-mail et mot de passe"
  caption="Page de connexion de la Plateforme IIoT"
  width={1873}
  height={902}
/>

L'e-mail et le mot de passe de connexion sont définis dans `/opt/vadtelnewweb/.env` :

```shell title=".env"
VADTEL_SUPER_ADMIN_EMAIL= (login)
VADTEL_SUPER_ADMIN_PASSWORD= (password)
```

</Steps>

## Étapes suivantes

La plateforme étant installée et opérationnelle, configurez-la pour qu'elle se mette à jour proprement et redémarre automatiquement avec le serveur.

<Cards>
  <Card
    icon="refresh-cw"
    title="Mise à jour et démarrage automatique"
    description="Mettez à jour la plateforme vers de nouvelles versions d'images et faites-la démarrer automatiquement avec le serveur."
    href="/fr/platform/v3/installation/updates"
  />
</Cards>