Una panoramica della replica a livello di volume per PostgreSQL utilizzando DRBD

La replica è la condivisione di dati transazionali tra più server per garantire la coerenza tra i nodi di database ridondanti. Un master prenderà gli inserti o gli aggiornamenti e li applicherà al proprio set di dati, mentre gli slave modificheranno i propri dati in base alle modifiche apportate al set di dati master. Il master è comunemente indicato come primario e registra le modifiche apportate in un WAL (Write Ahead Log). D'altra parte, gli slave sono indicati come secondari e replicano i loro dati dai registri REDO, in questo caso il WAL.

Esistono almeno 3 approcci di replica in PostgreSQL:

Replica integrata o replica in streaming.

In questo approccio, i dati vengono replicati dal nodo primario al nodo secondario. Tuttavia, viene fornito con una serie di battute d'arresto che sono:

Difficoltà nell'introduzione di una nuova secondaria. Richiederà la replica dell'intero stato, che può richiedere molte risorse.
Mancanza di monitoraggio e failover integrati. Un secondario deve essere promosso a primario in caso di fallimento di quest'ultimo. Spesso questa promozione può comportare un'incoerenza dei dati durante l'assenza del primario.

Ricostruire da WAL

Questo approccio utilizza in qualche modo l'approccio della replica in streaming poiché i secondari vengono ricostruiti da un backup eseguito dal primario. Il database primario esegue un backup completo del database ogni giorno oltre a un backup incrementale ogni 60 secondi. Il vantaggio di questo approccio è che nessun carico aggiuntivo è soggetto al primario fino a quando i secondari non sono abbastanza vicini al primario da iniziare lo streaming del WAL (Write Ahead Log) per recuperare il ritardo. Con questo approccio, puoi aggiungere o rimuovere repliche senza influire sulle prestazioni del tuo database PostgreSQL.

Replica a livello di volume per PostgreSQL (mirroring del disco)

Questo è un approccio generico che non si applica solo a PostgreSQL, ma anche a tutti i database relazionali. Utilizzeremo Distributed Replicated Block Device (DRBD), un sistema di archiviazione replicato distribuito per Linux. È pensato per funzionare eseguendo il mirroring dei contenuti archiviati nella memoria di un server su un altro. Di seguito è mostrata una semplice illustrazione della struttura.

DRBD può essere considerato come un'astrazione dal dispositivo disco che ospita il database PostgreSQL, ma il sistema operativo non saprà mai che i suoi dati si trovano anche in un altro server. Utilizzando questo approccio, non solo puoi condividere i dati ma anche il file system su più di 1 server. Le scritture sul DRBD sono quindi distribuite tra tutti i server per cui ciascun server scriverà le informazioni su un disco rigido fisico locale (dispositivo a blocchi). Quando un'operazione di scrittura viene applicata al primario, viene quindi registrata nel DRBD e quindi distribuita ai server DRBD secondari. Se invece il secondario riceve le operazioni di scrittura tramite il DRBD, queste vengono scritte sul dispositivo fisico locale. In caso di supporto per il failover, il DRBD fornisce un'elevata disponibilità dei dati poiché le informazioni sono condivise tra un nodo primario e molti nodi secondari che sono allineati in modo sincrono a livello di blocco.

La configurazione DRBD richiederebbe una risorsa aggiuntiva nota come Heartbeat, di cui parleremo in un altro articolo, al fine di migliorare il supporto per il failover automatico. Il pacchetto fondamentalmente gestisce l'interfaccia su più server e configura automaticamente uno dei server secondari come primario in caso di guasto.

Installazione e configurazione del DRBD

Il metodo preferito nell'installazione di DRBD consiste nell'usare i pacchetti di installazione binari precompilati. Assicurati che la versione del kernel dei pacchetti corrisponda al tuo attuale kernel attivo.

I file di configurazione per tutti i nodi primari o secondari devono essere identici. Inoltre, se è necessario aggiornare la versione del kernel, assicurarsi che il corrispondente kernel-module-drdb sia disponibile per la nuova versione del kernel.

Impostazione DRBD per il nodo primario

Questo è il primo passaggio in cui dovrai creare un dispositivo a blocchi DRBD e un file system con cui archiviare i tuoi dati. Il file di configurazione può essere trovato in /etc/drbd.conf. Il file definisce una serie di parametri per la configurazione DRBD che includono:dimensioni dei blocchi, definizione delle informazioni di sicurezza dei dispositivi DRBD che si desidera creare e frequenza degli aggiornamenti. Le configurazioni possono essere vincolate a essere globali o legate a una determinata risorsa. I passaggi coinvolti sono:

Velocità di sincronizzazione che definisce la velocità con cui i dispositivi vengono collegati in modo sincrono in background dopo una sostituzione del disco, un guasto o una configurazione iniziale. Questo può essere impostato modificando il parametro rate nel blocco di sincronizzazione:
```
syncer{
rate 15M
}
```
Configurazione dell'autenticazione per garantire che solo gli host con lo stesso segreto condiviso possano unirsi al gruppo di nodi DRBD. La password è un meccanismo di scambio hash supportato nel DRBD.
```
cram-hmac-alg “sha1”
shared-secret “hash-password-string”
```
Configurazione delle informazioni sull'host. Le informazioni sul nodo come l'host possono essere trovate in ciascuno dei file drbd.conf dei nodi. Alcuni dei parametri da configurare sono:
- Indirizzo:indirizzo IP e numero di porta dell'host che contiene il dispositivo DRBD.
- Dispositivo:il percorso del dispositivo a blocchi logici creato dal DRBD.
- Disco:si riferisce al dispositivo a blocchi che memorizza i dati.
- Meta-disco:memorizza i metadati del dispositivo DRBD. La sua dimensione può arrivare fino a 128 MB. Puoi impostarlo come disco interno in modo che il DRBD utilizzi un dispositivo a blocchi fisici per memorizzare queste informazioni nelle ultime sezioni del disco.
Una semplice configurazione per il primario:
```
on drbd-one {
device /dev/drbd0;
disk /dev/sdd1;
address 192.168.103.40:8080;
meta-disk internal;
}
```
La configurazione deve essere ripetuta con i secondari con l'indirizzo IP corrispondente al suo host corrispondente.
```
on drbd-two {
device /dev/drbd0;
disk /dev/sdd1;
address 192.168.103.41:8080;
meta-disk internal;
}
```
Creazione dei metadati per i dispositivi utilizzando questo comando:
```
$ drbdadm create create-md all
```
Questo processo è obbligatorio prima di avviare il nodo primario.
Avvia il DRBD con questo comando:
```
$ /etc/init.d/drbd start
```
Ciò consente al DRBD di avviare, inizializzare e creare i dispositivi definiti da DRBD.
Segna il nuovo dispositivo come primario e inizializza il dispositivo usando questo comando:
```
$ drbdadm -- --overwrite-data-of-peer primary all
```
Crea un file system sul dispositivo a blocchi per rendere utilizzabile un dispositivo a blocchi standard creato dal DRBD.
Rendi il primario pronto per l'uso montando il file system. Questi comandi dovrebbero prepararlo per te:
```
$ mkdir /mnt/drbd
$ mount /dev/drbd0 /mnt/drbd
$ echo “DRBD Device” > /mnt/drbd/example_file
```

Impostazione DRBD per il nodo secondario

Puoi utilizzare gli stessi passaggi precedenti, ad eccezione della creazione del file system su un nodo secondario poiché le informazioni vengono trasferite automaticamente dal nodo primario.

Copia il file /etc/drbd.conf dal nodo primario al nodo secondario. Questo file contiene le informazioni e la configurazione necessarie.
Sul dispositivo del disco sottostante crea i metadati DRBD usando il comando:
```
$ drbdadm create-md all
```

Avvia il DRBD con il comando:

$ /etc/init.d/drbd start

DRBD inizierà a copiare i dati dal nodo primario al nodo secondario e il tempo dipende dalla dimensione dei dati da trasferire. Se visualizzi il file /proc/drbd puoi visualizzare lo stato di avanzamento.

$ cat /proc/drbd
version: 8.0.0 (api:80/proto:80)
  SVN Revision: 2947 build by [email protected], 2018-08-24 16:43:05
   0: cs:SyncSource st:Primary/Secondary ds:UpToDate/Inconsistent C r---
       ns:252284 nr:0 dw:0 dr:257280 al:0 bm:15 lo:0 pe:7 ua:157 ap:0
       [==>.................] sync'ed: 12.3% (1845088/2097152)K
       finish: 0:06:06 speed: 4,972 (4,580) K/sec
       resync: used:1/31 hits:15901 misses:16 starving:0 dirty:0 changed:16
       act_log: used:0/257 hits:0 misses:0 starving:0 dirty:0 changed:0

Monitora la sincronizzazione utilizzando il comando watch a intervalli specifici
```
$ watch -n 10 ‘cat /proc/drbd‘
```

Gestione installazione DRBD

Per tenere traccia dello stato del dispositivo DRBD utilizziamo /proc/drbd.

Puoi impostare lo stato di tutti i dispositivi locali come primari usando il comando

$ drbdadm primary all

Rendi secondario un dispositivo principale

$ drbdadm secondary all

Per disconnettere i nodi DRBD

$ drbdadm disconnect all

Riconnetti i nodi DRBD

$ drbd connect all

Scarica il whitepaper oggi Gestione e automazione di PostgreSQL con ClusterControlScopri cosa devi sapere per distribuire, monitorare, gestire e ridimensionare PostgreSQLScarica il whitepaper

Configurazione di PostgreSQL per DRBD

Ciò comporta la selezione di un dispositivo per il quale PostgreSQL memorizzerà i dati. Per una nuova installazione, puoi scegliere di installare PostgreSQL interamente sul dispositivo DRBD o una directory di dati da posizionare sul nuovo file system e deve trovarsi nel nodo primario. Questo perché il nodo primario è l'unico autorizzato a montare un file system del dispositivo DRBD come lettura/scrittura. I file di dati di Postgres sono spesso archiviati in /var/lib/pgsql mentre i file di configurazione sono archiviati in /etc/sysconfig/pgsql.

Configurazione di PostgreSQL per l'utilizzo del nuovo dispositivo DRBD

Se hai PostgreSQL in esecuzione, fermali con questo comando:
```
$  /etc/init.d/postgresql -9.0
```

Aggiorna il dispositivo DRBD con i file di configurazione utilizzando i comandi:

$ mkdir /mnt/drbd/pgsql/sysconfig
$ cp /etc/sysconfig/pgsql/* /mnt/drbd/pgsql/sysconfig

Aggiorna il DRBD con la directory dei dati di PostgreSQL e i file di sistema usando:
```
$ cp -pR /var/lib/pgsql /mnt/drbd/pgsql/data
```
Crea un collegamento simbolico alla nuova directory di configurazione sul file system del dispositivo DRBD da /etc/sysconfig/pgsql usando il comando:
```
$ ln -s /mnt/drbd/pgsql/sysconfig  /etc/sysconfig/pgsql
```
Rimuovere la directory /var/lib/pgsql, smontare /mnt/drbd/pgsql e montare il dispositivo drbd su /var/lib/pgsql.
Avvia PostgreSQL con il comando:
```
$ /etc/init.d/postgresql -9.0 start
```

I dati PostgreSQL ora dovrebbero essere presenti sul file system in esecuzione sul tuo dispositivo DRBD sotto il dispositivo configurato. Anche il contenuto dei database viene copiato nel nodo DRBD secondario ma non è possibile accedervi poiché il dispositivo DRBD che lavora nel nodo secondario potrebbe essere assente.

Caratteristiche importanti con l'approccio DRBD

I parametri di ottimizzazione sono altamente personalizzabili.
Le implementazioni esistenti possono essere facilmente configurate con DRBD senza alcuna perdita di dati.
Le richieste di lettura sono ugualmente equilibrate
L'autenticazione del segreto condiviso protegge la configurazione ei suoi dati.