Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Prerequisiti e configurazione del cluster
<a name="pacemaker-tutorial-prerequisites"></a>

In questa sezione, configurerai l'infrastruttura per il tutorial sull'alta disponibilità. Puoi creare un gruppo di sicurezza, creare una coppia di key pair, avviare istanze Amazon EC2, installare Pacemaker e DRBD, creare un cluster e configurare la replica a livello di blocco tra le istanze.

## Crea e configura un gruppo di sicurezza
<a name="pacemaker-tutorial-prerequisites-sg"></a>

Crea un gruppo di sicurezza che consenta tutto il traffico tra le istanze del cluster. In questo tutorial, apri tutte le porte per semplificare la configurazione. Questo passaggio richiede un VPC. Se non ne hai uno, consulta [Creare un VPC](https://docs.aws.amazon.com/vpc/latest/userguide/create-vpc.html).

**Console**
+ Apri la console Amazon EC2 all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
+ Nel pannello di navigazione, scegli **Gruppi di sicurezza**, quindi scegli **Crea gruppo di sicurezza**.
+ Inserisci un nome (ad esempio`pacemaker-cluster-sg`) e una descrizione.
+ Seleziona il tuo VPC.
+ Scegliere **Create Security Group** (Crea gruppo di sicurezza).
+ Dopo la creazione, seleziona il nuovo gruppo di sicurezza e modificane le regole in entrata. Scegli **Aggiungi regola**. Imposta **Tipo** su **Tutto il traffico** e **Sorgente** sull'ID del gruppo di sicurezza. Ciò consente tutto il traffico tra le istanze di questo gruppo di sicurezza.
+ Aggiungi una seconda regola in entrata per l'accesso SSH. **Imposta **Type** su **SSH** e **Source su My IP**.**

**AWS Command Line Interface**
+ Crea il gruppo di sicurezza.

  ```
  aws ec2 create-security-group \
    --group-name pacemaker-cluster-sg \
    --description "Security group for Pacemaker HA cluster" \
    --vpc-id {{your-vpc-id}}
  ```

  `GroupId`Annotate quanto riportato nell'output (ad esempio,`sg-0123456789abcdef0`).
+ Aggiungi una regola in entrata per consentire tutto il traffico proveniente dalle istanze dello stesso gruppo di sicurezza.

  ```
  aws ec2 authorize-security-group-ingress \
    --group-id {{security-group-id}} \
    --protocol all \
    --source-group {{security-group-id}}
  ```
+ Aggiungi una regola in entrata per consentire l'accesso SSH dal tuo indirizzo IP.

  ```
  aws ec2 authorize-security-group-ingress \
    --group-id {{security-group-id}} \
    --protocol tcp \
    --port 22 \
    --cidr {{your-ip}}/32
  ```

## Creazione di una coppia di chiavi
<a name="pacemaker-tutorial-prerequisites-keypair"></a>

Crea una key pair da utilizzare per l'accesso SSH a tutte le istanze. Usa la stessa key pair per tutte le istanze in questo tutorial.

**Console**
+ Apri la console Amazon EC2 all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
+ Nel pannello di navigazione, scegli **Key Pairs**, quindi scegli **Crea key pair**.
+ Inserisci un nome (ad esempio,`pacemaker-key`).
+ Seleziona **RSA** come tipo di key pair e **.pem come formato** di file.
+ Scegliere **Create key pair** (Crea coppia di chiavi). Il file della chiave privata viene scaricato automaticamente.

**avvertimento**  
Salvate il file della chiave privata (`.pem`) in una posizione sicura. Non è possibile scaricarlo di nuovo. Hai bisogno di questo file in SSH per accedere alle tue istanze.

**AWS Command Line Interface**
+ Crea la key pair.

  ```
  aws ec2 create-key-pair \
    --key-name {{key-name}} \
    --query 'KeyMaterial' \
    --output text > pacemaker-key.pem
  ```
+ Imposta le autorizzazioni corrette sul file della chiave privata.

  ```
  chmod 400 pacemaker-key.pem
  ```

## Avvia le istanze EC2
<a name="pacemaker-tutorial-prerequisites-instances"></a>

Avvia due istanze Ubuntu Amazon EC2 nel gruppo di sicurezza che hai creato. Un piccolo tipo di istanza (ad esempio`t3.small`) è sufficiente per questo tutorial.

**Console**
+ Apri la console Amazon EC2 all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
+ Scegliere **Launch Instances (Avvia istanze)**.
+ Immettete un nome per l'istanza (ad esempio,`pacemaker-instance-1`).
+ In **Immagini dell'applicazione e del sistema operativo**, cerca **Ubuntu** e seleziona un'AMI Ubuntu Server (ad esempio, Ubuntu Server 24.04 LTS).
+ **In **Tipo di istanza**, seleziona t3.small.**
+ In **Coppia di chiavi**, seleziona la chiave che hai creato in precedenza.
+ In **Impostazioni di rete**, scegli **Modifica**, seleziona il tuo VPC e una sottorete e, in **Firewall (gruppi di sicurezza)**, scegli **Seleziona gruppo di sicurezza esistente** e seleziona. `pacemaker-cluster-sg`
+ Scegliere **Launch Instance (Avvia istanza)**.
+ Ripeti l'operazione per ogni istanza aggiuntiva (ad esempio,`pacemaker-instance-2`). Assicurati che tutte le istanze si trovino nello stesso VPC e nello stesso gruppo di sicurezza.

**AWS Command Line Interface**
+ Avvia un'istanza.

  ```
  aws ec2 run-instances \
    --image-id {{ubuntu-ami-id}} \
    --instance-type t3.small \
    --key-name {{key-name}} \
    --security-group-ids {{security-group-id}} \
    --subnet-id {{subnet-id}} \
    --count 1 \
    --tag-specifications 'ResourceType=instance,Tags=[{Key=Name,Value=pacemaker-instance-1}]'
  ```

  Ripeti con `Value=pacemaker-instance-2` per la seconda istanza.

È necessario l'indirizzo IP privato di ogni istanza per la configurazione del cluster.
+ **Console: nella console** **Amazon EC2, seleziona un'istanza e trova l'**indirizzo IPv4 privato** nella scheda Dettagli.**
+ **AWS Command Line Interface:**

  ```
  aws ec2 describe-instances \
    --filters "Name=tag:Name,Values=pacemaker-instance-*" \
    --query "Reservations[*].Instances[*].[Tags[?Key=='Name'].Value|[0],PrivateIpAddress]" \
    --output table
  ```

## Installa le utilità Pacemaker
<a name="pacemaker-tutorial-prerequisites-install"></a>

SSH in ogni istanza e installa le utilità Pacemaker.

```
ssh -i pacemaker-key.pem ubuntu@{{instance-public-ip}}
```

```
sudo apt update
sudo apt install -y pacemaker pcs resource-agents-extra resource-agents-common resource-agents-base
```

## Configura la comunicazione di rete
<a name="pacemaker-tutorial-prerequisites-network"></a>

1. **Verifica la comunicazione tra le istanze.** Nell'istanza di destinazione, esegui il comando seguente per ascoltare i ping dall'istanza di origine.

   ```
   sudo tcpdump host {{source-instance-private-ip}}
   ```

   Nell'istanza di origine, esegui il comando seguente per eseguire il ping dell'istanza di destinazione.

   ```
   ping -c 4 {{destination-instance-private-ip}}
   ```

   Dovresti vedere le risposte di ping su entrambi i lati. In caso contrario, verifica che il gruppo di sicurezza consenta tutto il traffico tra le istanze.

1. **Disattiva la gestione dei nomi host su cloud-init.** Nelle istanze Ubuntu Amazon EC2, cloud-init può ripristinare il nome host e le modifiche al riavvio. `/etc/hosts` Eseguilo su ogni istanza per evitarlo.

   ```
   sudo bash -c 'cat > /etc/cloud/cloud.cfg.d/99-preserve-hostconfig.cfg <<EOF
   preserve_hostname: true
   manage_etc_hosts: false
   EOF'
   ```

1. **Imposta il nome host su ogni istanza.** Pacemaker utilizza i nomi host per identificare le istanze del cluster.

   Nell'istanza 1:

   ```
   sudo hostnamectl set-hostname instance1
   ```

   Nell'istanza 2:

   ```
   sudo hostnamectl set-hostname instance2
   ```

1. **Configura`/etc/hosts`.** In ogni istanza, aggiungi le coppie di IP e hostname privati a. `/etc/hosts` Ciò consente alle istanze di risolversi a vicenda in base al nome host.

   ```
   sudo tee -a /etc/hosts <<EOF
   {{instance1-private-ip}} instance1
   {{instance2-private-ip}} instance2
   EOF
   ```

## Crea il cluster Pacemaker
<a name="pacemaker-tutorial-prerequisites-cluster"></a>

1. **Avvia il demone pcs su ogni istanza**.

   ```
   sudo systemctl enable pcsd.service
   sudo systemctl start pcsd.service
   ```

1. **Imposta la password di hacluster.** L'`hacluster`utente è un account di sistema creato automaticamente quando si installa il pacchetto. `pcs` Pacemaker utilizza questo account per l'autenticazione del cluster tra le istanze. Imposta la stessa password su ogni istanza.

   ```
   sudo passwd hacluster
   ```

1. **Autorizza gli host dei pc.** Autorizzate le istanze del cluster l'una con l'altra. Eseguilo su ogni istanza.

   ```
   sudo pcs host auth instance1 instance2
   ```

   Ti verranno richiesti il `hacluster` nome utente e la password.

1. **Configura il cluster.** Esegui questo comando su una sola istanza. Il `--force` flag distrugge qualsiasi cluster esistente sul dispositivo.

   ```
   sudo pcs cluster setup my-gg-cluster instance1 instance2 --force
   ```

1. **Avvia il cluster.** Esegui questo comando su una sola istanza.

   ```
   sudo pcs cluster start --all
   sudo pcs cluster enable --all
   ```

1. **Verifica lo stato del cluster** su entrambe le istanze.

   ```
   sudo pcs status
   ```

## Configura DRBD
<a name="pacemaker-tutorial-prerequisites-drbd"></a>

[DRBD](https://linbit.com/drbd/) (Distributed Replicated Block Device) è un modulo del kernel Linux che replica i dispositivi di archiviazione tra le istanze in tempo reale. Funziona a livello di dispositivo a blocchi, ovvero il livello del disco raw al di sotto del filesystem, in modo che tutti i dati scritti su disco su un'istanza vengano rispecchiati sull'altra. Ciò garantisce che, in caso di errore dell'istanza principale, l'istanza di standby disponga di una copia identica dei dati.

1. **Crea e collega volumi EBS.** Crea un volume EBS per ogni istanza. Il volume deve trovarsi nella stessa zona di disponibilità dell'istanza.

**Console**
   + Apri la console Amazon EC2 all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
   + Nel riquadro di navigazione, scegli **Volumi**, quindi scegli **Crea volume**.
   + Imposta **il tipo di volume** su **gp3**, la **dimensione** su **8 GiB** e **la zona di disponibilità sulla stessa zona** dell'istanza.
   + Selezionare **Create volume (Crea volume)**.
   + **Seleziona il nuovo volume, scegli **Azioni** > **Allega volume**, seleziona l'istanza di destinazione, imposta il nome del dispositivo su e scegli Allega volume. `/dev/xvdbz`**
   + Ripeti l'operazione per ogni istanza.

**AWS Command Line Interface**
   + Crea un volume nella stessa zona di disponibilità dell'istanza.

     ```
     aws ec2 create-volume \
       --volume-type gp3 \
       --size 8 \
       --availability-zone {{instance-availability-zone}}
     ```

     Nota quanto `VolumeId` riportato nell'output.
   + Collegate il volume a un'istanza.

     ```
     aws ec2 attach-volume \
       --volume-id {{volume-id}} \
       --instance-id {{instance-id}} \
       --device /dev/xvdbz
     ```

     Ripetere l'operazione per ogni istanza.

1. **Verifica il volume.** Inserisci SSH in ogni istanza e verifica che il volume sia collegato elencando i dispositivi a blocchi.

   ```
   lsblk
   ```

   Su tipi di Nitro-based istanze come`t3.small`, ad esempio, il volume viene visualizzato come dispositivo NVMe (ad esempio,`/dev/nvme1n1`) anziché. `/dev/xvdbz` `lsblk`Utilizzatelo per identificare il nome effettivo del dispositivo e utilizzatelo nella configurazione DRBD.

1. **Installa le utilità DRBD** su ogni istanza.

   ```
   sudo apt install -y drbd-utils
   ```

1. **Configura la risorsa DRBD.** Crea la directory e il file di configurazione delle risorse DRBD su entrambe le istanze.

   ```
   sudo mkdir -p /etc/drbd.d
   sudo vi /etc/drbd.d/greengrass.res
   ```

   Aggiungi la seguente configurazione. Sostituisci i nomi host e gli indirizzi IP con i tuoi valori.

   ```
   resource greengrass {
       protocol C;
   
       on instance1 {
           device    /dev/drbd0;
           disk      /dev/{{instance1-device-name}};
           address   {{instance1-private-ip}}:7788;
           meta-disk internal;
       }
   
       on instance2 {
           device    /dev/drbd0;
           disk      /dev/{{instance2-device-name}};
           address   {{instance2-private-ip}}:7788;
           meta-disk internal;
       }
   }
   ```

1. **Crea e avvia la risorsa DRBD.** Esegui su entrambe le istanze.

   ```
   sudo drbdadm create-md greengrass
   sudo drbdadm up greengrass
   ```

   Verifica `lsblk` che `drbd0` compaia sotto il tuo dispositivo di volume EBS (ad esempio, `xvdbz` o`nvme1n1`).

1. **Imposta l'istanza principale.** Esegui i seguenti comandi solo su instance1 per forzare che sia primaria e attendi la sincronizzazione.

   ```
   sudo drbdadm -- --overwrite-data-of-peer primary greengrass
   sudo drbdadm status
   ```

   Attendi che entrambe le istanze mostrino lo stato del `UpToDate` disco. Una volta sincronizzate, tutte le altre istanze diventano istanze di standby.

1. **Formatta e monta il dispositivo DRBD.**

   Solo sull'istanza principale, formatta il dispositivo DRBD:

   ```
   sudo mkfs.ext4 /dev/drbd0
   ```

   In tutte le istanze, crea la directory di montaggio:

   ```
   sudo mkdir -p /greengrass/v2
   ```

   Solo sull'istanza principale, monta il dispositivo DRBD:

   ```
   sudo mount /dev/drbd0 /greengrass/v2
   ```

1. **Verifica lo stato di sincronizzazione DRBD.**

   ```
   sudo drbdadm status
   mount | grep 'drbd'
   ```