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">
  Prima di iniziare, assicurarsi che il server e i client soddisfino i [requisiti di
  sistema](/it/platform/v3/requirements).
</Alert>

## Download dei file di installazione

È possibile scaricare le immagini di installazione della Piattaforma IIoT in due modi.

<Tabs labels={['Da supporto esterno', 'Tramite Internet']}>
  <Fragment slot="panel-0">
    Quando il server non dispone di accesso a Internet — ad esempio a causa di una politica di
    sicurezza aziendale — è possibile installare la piattaforma offline. Le immagini di
    installazione vengono trasferite sul server da un supporto esterno.
  </Fragment>
  <Fragment slot="panel-1">
    Quando il server dispone di accesso a Internet, le immagini di installazione vengono scaricate
    sul server da un repository remoto.
  </Fragment>
</Tabs>

## Procedura di installazione

<Steps>

### Copiare il pacchetto dati necessario

Copiare il pacchetto di installazione sul server (sono richiesti i diritti di amministratore):

- Copiare nella cartella home dell'utente l'archivio `unicloud.tgz` scaricato e la cartella `images`
  (il pacchetto di installazione autonomo con le immagini archiviate). L'archivio contiene inoltre i
  file di configurazione `docker-compose.yml` e `.env` (`.env` è nascosto, quindi abilitare la
  visualizzazione dei file nascosti).

<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' },
      ],
    },
  ]}
/>

- Copiare i file di configurazione in `/opt/vadtelnewweb/`.

- Impostare nel file `.env` i nomi utente e le password di sistema:

```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
```

### Installare Docker e Docker Compose

#### Su una distribuzione basata su CentOS

Installare Docker e Docker Compose:

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

Avviare Docker e abilitarne l'esecuzione all'avvio:

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

#### Su una distribuzione basata su Debian

Installare Docker e Docker Compose:

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

### Installare il sistema

I passaggi rimanenti sono identici su tutti i sistemi operativi. Aggiungere al gruppo `docker`
l'utente che eseguirà l'applicazione:

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

<Alert type="warning">
  Dopo aver eseguito questo comando, chiudere la sessione ed effettuare nuovamente l'accesso per
  applicare le nuove autorizzazioni.
</Alert>

Decomprimere l'archivio `unicloud.tgz` nella cartella home dell'utente:

```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' },
      ],
    },
  ]}
/>

Aprire la cartella `unicloud` decompressa nella cartella home dell'utente ed eseguire lo script di
installazione:

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

Una volta installato il pacchetto, aprire `/var/lib/unicloud` con privilegi di amministratore e
modificare il proprietario e il gruppo del file `.env` impostandoli sull'utente corrente.

Lo script genera il nome utente e la password del database in `/var/lib/unicloud/.env`. Copiare
questi valori in `/opt/vadtelnewweb/.env`:

```bash
VADTEL_UNICLOUD_TEST_USERNAME=NEED_USERNAME

VADTEL_UNICLOUD_TEST_PASSWORD=NEED_PASSWORD
```

### Estrarre e caricare le immagini

Decomprimere i file delle immagini nella cartella `images` copiata in precedenza:

```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
```

Caricare le immagini in 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
```

Verificare che le immagini siano disponibili:

```bash
docker images
```

Tutte le nove immagini caricate dovrebbero comparire nell'elenco.

Se le immagini sono state caricate senza errori, eseguire il comando seguente dalla cartella
`/var/lib/unicloud`:

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

Creare una directory per l'applicazione `vadtelnewweb` in `/opt`:

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

Quindi copiare i file `docker-compose.yml` e `.env` (se non sono già stati copiati in precedenza per
una nuova installazione) in `/opt/vadtelnewweb`.

Alla prima esecuzione, creare il database:

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

A questo punto, avviare l'applicazione:

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

<Details title="Risoluzione dei problemi">
Se dopo l'avvio l'applicazione segnala il seguente errore:

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

la rete esterna non è stata creata durante l'installazione. Eseguire l'installazione iniziale
dall'archivio `unicloud.tar.tgz` come descritto in [Installare il sistema](#installare-il-sistema),
quindi avviare nuovamente l'applicazione:

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

</Details>

Verificare i container in esecuzione:

```bash
docker ps
```

Tutti i container dovrebbero essere elencati con stato `Up`.

### Verificare il sistema

Dopo l'avvio dell'applicazione, aprire nel browser l'indirizzo IP del server su cui è in esecuzione
per confermare che il sistema sia attivo:

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

<Image
  src="/images/deployment/sign-in-en.webp"
  alt="Pagina di accesso della Piattaforma IIoT con i campi e-mail e password"
  caption="Pagina di accesso della Piattaforma IIoT"
  width={1873}
  height={902}
/>

L'e-mail e la password di accesso sono impostate in `/opt/vadtelnewweb/.env`:

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

</Steps>

## Passaggi successivi

Con la piattaforma installata e in esecuzione, configurarla per aggiornarsi in modo pulito e per riavviarsi automaticamente insieme al server.

<Cards>
  <Card
    icon="refresh-cw"
    title="Aggiornamento e avvio automatico"
    description="Aggiornare la piattaforma alle nuove versioni delle immagini e fare in modo che si avvii automaticamente insieme al server."
    href="/it/platform/v3/installation/updates"
  />
</Cards>