Abilita Transparent Data Encryption (TDE) su AlloyDB Omni RPM

1. Introduzione

Questo codelab mostra come configurare e abilitare la crittografia dei dati trasparente (TDE) su AlloyDB Omni utilizzando i pacchetti RPM. La TDE cripta i file di dati, i log di write-ahead (WAL) e i file di dati temporanei inattivi, fornendo protezione dei dati contro l'accesso non autorizzato ai supporti di archiviazione fisica sottostanti.

In questo codelab, imparerai a eseguire il provisioning dei volumi di archiviazione, inizializzare ed eseguire un cluster AlloyDB Omni abilitato per la TDE utilizzando File KMS e verificare la crittografia dei dati inattivi sui file su disco.

Prerequisiti

• Accesso a un progetto Google Cloud e a Cloud Shell dalla console Google Cloud.
• Google Cloud SDK (gcloud) installato e configurato. Per informazioni dettagliate sull'installazione di gcloud, consulta gcloud-install

Cosa imparerai a fare

• Come creare una VM di Compute Engine con dischi dedicati per database, backup e swap.
• Come formattare i volumi di archiviazione (XFS), configurare /etc/fstab e preparare i percorsi dei dati.
• Come generare e gestire le chiavi di crittografia delle chiavi (KEK) utilizzando File KMS.
• Come installare i pacchetti RPM di AlloyDB Omni e le utilità client PostgreSQL.
• Come eseguire il bootstrap di un cluster AlloyDB Omni abilitato per la TDE utilizzando gli strumenti di configurazione RPM (alloydbomni18-setup) e --tde-kek-url.
• Come verificare la crittografia su disco utilizzando l'ispezione dei file non elaborati (grep).

Che cosa ti serve

• Ottieni un link URL agli RPM di AlloyDB Omni compilando il modulo di registrazione agli RPM di AlloyDB Omni o facendo riferimento alla panoramica di AlloyDB Omni su Linux. L'URL del repository verrà inviato al tuo indirizzo email registrato.
• Un terminale funzionante con accesso a Google Cloud (Cloud Shell consigliato).

2. Configurazione e requisiti

Configurazione del progetto

Crea un progetto Google Cloud

1. Nella console Google Cloud, nella pagina di selezione del progetto, seleziona o crea un progetto Google Cloud.
2. Verifica che la fatturazione sia attivata per il tuo progetto Cloud. Scopri come verificare se la fatturazione è abilitata per un progetto.

Avvia Cloud Shell

Sebbene tu possa utilizzare Google Cloud da remoto dal tuo laptop, in questo codelab utilizzerai il Google Cloud Shell, un ambiente a riga di comando in esecuzione nel cloud.

1. Apri la console Google Cloud e fai clic sull'icona di Cloud Shell nella barra degli strumenti in alto a destra. Puoi anche aprire Cloud Shell premendo G e poi S nella console o visitando shell.cloud.google.com.
2. In genere, bastano pochi istanti per eseguire il provisioning e connettersi all'ambiente. Al termine, vedrai un prompt del terminale pronto per l'input.

3. Crea la VM di Compute Engine

In questa sezione, creerai una macchina virtuale (VM) di Compute Engine (GCE) che esegue Rocky Linux 9 con dischi permanenti dedicati per i dati del database (/data1), i backup/l'osservabilità (/obs) e lo spazio di swap.

1. Definisci le variabili di ambiente per l'ID progetto, il nome della VM, la zona e la regione.

   export PROJECT="your-project-id"
   export INSTANCE_NAME="alloydb-omni-tde-vm"
   export ZONE="us-central1-c"
   export REGION="us-central1"
   

2. Configura il progetto predefinito.

   gcloud config set project $PROJECT
   

3. Crea regole firewall di rete per il traffico SSH.

   gcloud compute firewall-rules create allow-ssh-alloydb-omni-tde \
       --project=$PROJECT \
       --direction=INGRESS \
       --action=allow \
       --rules=tcp:22 \
       --source-ranges="0.0.0.0/0"
   

4. Poiché la VM viene creata senza un indirizzo IP pubblico, configura un router Cloud e un gateway Cloud NAT per fornire l'accesso a internet in uscita per il download dei pacchetti RPM. Se nel progetto esiste già un Cloud NAT, puoi procedere.

   gcloud compute routers create alloydb-omni-tde-router \
       --project=$PROJECT \
       --network=default \
       --region=$REGION 2>/dev/null || true
   
   gcloud compute routers nats create alloydb-omni-tde-nat \
       --project=$PROJECT \
       --router=alloydb-omni-tde-router \
       --region=$REGION \
       --nat-all-subnet-ip-ranges \
       --auto-allocate-nat-external-ips 2>/dev/null || true
   

   Nota: se nella regione esiste già un gateway Cloud NAT, Google Cloud restituirà un messaggio che indica che NAT è già configurato per tutte le subnet. Puoi ignorare questo errore e procedere.
5. Crea dischi permanenti aggiuntivi per i dati del database, i backup e lo spazio di swap.

   gcloud compute disks create $INSTANCE_NAME-data \
       --project=$PROJECT --zone=$ZONE --size=50GB --type=pd-balanced
   
   gcloud compute disks create $INSTANCE_NAME-obs \
       --project=$PROJECT --zone=$ZONE --size=50GB --type=pd-balanced
   
   gcloud compute disks create $INSTANCE_NAME-swap \
       --project=$PROJECT --zone=$ZONE --size=10GB --type=pd-balanced
   

6. Esegui il provisioning dell'istanza VM Rocky Linux 9 con i volumi di archiviazione collegati.

   gcloud compute instances create $INSTANCE_NAME \
       --project=$PROJECT \
       --zone=$ZONE \
       --machine-type=n2-highmem-16 \
       --image-family=rocky-linux-9 \
       --image-project=rocky-linux-cloud \
       --boot-disk-size=30GB \
       --boot-disk-type=pd-balanced \
       --disk=name=$INSTANCE_NAME-data,device-name=db-data,mode=rw \
       --disk=name=$INSTANCE_NAME-obs,device-name=obs,mode=rw \
       --disk=name=$INSTANCE_NAME-swap,device-name=swap,mode=rw \
       --no-address
   

4. Prepara i dischi, l'ottimizzazione del sistema e la chiave di File KMS

In questa sezione, ti connetterai alla VM, formatta e monta i volumi di archiviazione permanenti, configura lo swap, ottimizza SELinux e genera la chiave di crittografia della chiave (KEK) della TDE utilizzando File KMS.

1. Esegui SSH nella VM tramite Identity-Aware Proxy (IAP).

   gcloud compute ssh $INSTANCE_NAME --zone=$ZONE --project=$PROJECT --tunnel-through-iap
   

2. Formatta e monta il volume di dati (/data1) e il volume di osservabilità/backup (/obs).

   sudo mkdir -p /data1 /obs
   
   sudo parted /dev/disk/by-id/google-db-data mklabel gpt
   sudo parted /dev/disk/by-id/google-db-data mkpart primary 0% 100%
   
   sudo parted /dev/disk/by-id/google-obs mklabel gpt
   sudo parted /dev/disk/by-id/google-obs mkpart primary 0% 100%
   
   sleep 3
   sudo mkfs.xfs -L data /dev/disk/by-id/google-db-data-part1
   sudo mkfs.xfs -L obs /dev/disk/by-id/google-obs-part1
   
   echo -e "LABEL=data\t/data1\txfs\tdefaults\t0 0" | sudo tee -a /etc/fstab
   echo -e "LABEL=obs\t/obs\txfs\tdefaults\t0 0" | sudo tee -a /etc/fstab
   
   sudo systemctl daemon-reload
   sudo mount /data1
   sudo mount /obs
   

3. Crea e abilita lo spazio di swap sul disco di swap dedicato.

   SWAP_UUID=$(sudo mkswap /dev/disk/by-id/google-swap 2>/dev/null | awk '$0 ~ "UUID" {print $NF}')
   echo -e "${SWAP_UUID}\tswap\tswap\tdefaults\t0 0" | sudo tee -a /etc/fstab
   sudo swapon -a
   

4. Definisci le variabili di ambiente per la directory del database e il file della chiave di File KMS.

   export PGDATA="/data1/18"
   export KMS_DIR="/data1/kms"
   export KEK_FILE="$KMS_DIR/tde_key"
   export ALLOYDB_OMNI_REPOSITORY_URL="<your-repository-url>"
   

5. Crea directory di archiviazione per il database e l'archiviazione delle chiavi di File KMS.

   sudo mkdir -p $PGDATA
   sudo mkdir -p $KMS_DIR
   

6. Genera una chiave di crittografia della chiave (KEK) di 32 byte crittograficamente sicura utilizzando OpenSSL per File KMS.

   sudo openssl rand -base64 32 | sudo tee $KEK_FILE
   sudo chmod 700 $KMS_DIR
   sudo chmod 600 $KEK_FILE
   

7. Installa le utilità di gestione SELinux richieste.

   sudo dnf install -y policycoreutils-python-utils
   

5. Installa i pacchetti RPM di AlloyDB Omni

Configura i repository di pacchetti e installa il server di database AlloyDB Omni insieme agli strumenti standard di PostgreSQL 18.

Nota: sostituisci $ALLOYDB_OMNI_REPOSITORY_URL con l'URL del repository ricevuto via email dopo aver compilato il modulo di registrazione agli RPM di AlloyDB Omni. Per saperne di più, consulta la panoramica di AlloyDB Omni su Linux.

1. Crea il file di configurazione del repository YUM per AlloyDB Omni.

   sudo tee /etc/yum.repos.d/alloydbomni.repo << EOF
   [alloydbomni]
   name=alloydbomni
   baseurl=$ALLOYDB_OMNI_REPOSITORY_URL
   enabled=1
   repo_gpgcheck=0
   gpgcheck=1
   gpgkey=https://dl.google.com/linux/linux_signing_key.pub
   EOF
   

2. Aggiorna la cache del repository YUM e installa i pacchetti RPM del server AlloyDB Omni 18.

   sudo yum makecache
   sudo dnf install -y alloydbomni18
   

3. Installa il repository RPM PGDG ufficiale di PostgreSQL e il pacchetto client PostgreSQL 18 standard (psql).

   sudo dnf install -y https://download.postgresql.org/pub/repos/yum/reporpms/EL-9-x86_64/pgdg-redhat-repo-latest.noarch.rpm
   sudo dnf install -y postgresql18
   

4. Assegna la proprietà di /data1 e della directory delle chiavi KMS all'utente postgres.

   sudo chown -R postgres:postgres /data1 $KMS_DIR
   sudo chmod 755 /data1 $PGDATA
   

6. Esegui il bootstrap di un cluster abilitato per la TDE

Configura le quote delle risorse, apri le porte del firewall host e inizializza il cluster AlloyDB Omni con la crittografia dei dati trasparente abilitata tramite la chiave di File KMS (POSTGRES_INITDB_ARGS="--tde-kek-url=file://$KEK_FILE").

1. Imposta SELinux in modalità permissiva e configura le regole firewall host per PostgreSQL.

   sudo setenforce 0
   sudo firewall-cmd --add-port=5432/tcp --permanent
   sudo firewall-cmd --reload
   

2. Configura i parametri di override del servizio systemd per assegnare limiti di risorse di memoria e CPU.

   sudo mkdir -p /etc/systemd/system/alloydbomni18.service.d
   sudo tee /etc/systemd/system/alloydbomni18.service.d/override.conf << EOF
   [Service]
   CPUQuota=90%
   MemoryMax=80%
   EOF
   sudo chown root:root /etc/systemd/system/alloydbomni18.service.d/override.conf
   sudo chmod 644 /etc/systemd/system/alloydbomni18.service.d/override.conf
   sudo systemctl daemon-reload
   

3. Imposta le variabili di ambiente dell'amministratore e inizializza il cluster di database TDE utilizzando alloydbomni18-setup initdb.

   export PGPASSWORD="YourStrongPassword123!"
   export POSTGRES_INITDB_ARGS="--tde-kek-url=file://$KEK_FILE"
   
   sudo POSTGRES_INITDB_ARGS="$POSTGRES_INITDB_ARGS" PGPASSWORD="$PGPASSWORD" PGDATA="$PGDATA" \
       /usr/lib/postgresql/18/bin/alloydbomni18-setup initdb
   

4. Configura la porta del server 5432 in postgresql.conf.

   sudo sed -i "s/^#*[[:space:]]*port[[:space:]]*=[[:space:]]*[0-9]*/port = 5432/" $PGDATA/postgresql.conf
   

5. Prepara i cataloghi di sistema e le estensioni utilizzando alloydbomni18-setup preparedb.

   sudo PGPORT=5432 PGPASSWORD="$PGPASSWORD" PGDATA="$PGDATA" \
       /usr/lib/postgresql/18/bin/alloydbomni18-setup preparedb
   

6. Abilita e avvia il servizio systemd alloydbomni18.

   sudo systemctl enable alloydbomni18
   sudo systemctl start alloydbomni18
   sudo systemctl status alloydbomni18
   

   Verifica che l'output mostri Active: active (running).

7. Operazioni del database e verifica della crittografia del disco TDE

Connettiti al database TDE, inserisci record di esempio, esegui un CHECKPOINT per forzare la scrittura dei dati su disco ed esegui scansioni dirette del disco (grep) per dimostrare la crittografia at-rest.

1. Connettiti al database alloydbadmin utilizzando psql.

   PGPASSWORD="YourStrongPassword123!" /usr/lib/postgresql/18/bin/psql -h localhost -p 5432 -U postgres -d alloydbadmin
   

2. Crea una tabella di test, inserisci una stringa riservata e attiva un checkpoint per scrivere i buffer modificati nell'archiviazione.

   CREATE TABLE customer_credentials (
       id SERIAL PRIMARY KEY,
       username TEXT,
       secret_passcode TEXT
   );
   
   INSERT INTO customer_credentials (username, secret_passcode)
   VALUES ('alice_user', 'UNENCRYPTED_DEMO_SECRET_98765');
   
   CHECKPOINT;
   

3. Esegui una query sulla visualizzazione delle statistiche TDE interne di AlloyDB pgsnap.g$tde_stats per verificare lo stato di crittografia attivo, la posizione della KEK e le metriche dei blocchi.

   SELECT is_tde_enabled, tde_kek_url, tde_data_blocks_encrypted, tde_wal_blocks_encrypted
   FROM pgsnap.g$tde_stats;
   

   Output di esempio che conferma la TDE attiva (is_tde_enabled = t), il percorso del file KEK e i contatori dei blocchi criptati:

    is_tde_enabled |        tde_kek_url        | tde_data_blocks_encrypted | tde_wal_blocks_encrypted 
   ----------------+---------------------------+---------------------------+--------------------------
    t              | file:///data1/kms/tde_key |                      2023 |                     2717
   (1 row)
   

4. Esci da psql.

   \q
   

5. Cerca la stringa del passcode nei file di archiviazione del database non elaborati in /data1/18/base/ per verificare la protezione TDE su disco.

   sudo grep -a -rn "UNENCRYPTED_DEMO_SECRET_98765" /data1/18/base/
   

Informazioni chiave sulla verifica:

• In un'istanza di database non TDE, l'esecuzione di grep sui file di relazione della tabella visualizza la stringa di testo normale sul disco.
• In un'istanza di database abilitata per la TDE , grep restituisce zero corrispondenze perché tutti i file di dati, gli indici, i log di write-ahead (WAL) e i dati temporanei sono completamente criptati con cifrari a blocchi AES a riposo.

8. Esegui la pulizia

Al termine degli esercizi, esegui la pulizia delle risorse per evitare addebiti di calcolo indesiderati.

1. Disconnettiti dalla sessione SSH della VM.

   exit
   

2. Rimuovi la macchina virtuale GCE e i dischi permanenti collegati.

   gcloud compute instances delete $INSTANCE_NAME --zone=$ZONE --project=$PROJECT --quiet
   gcloud compute disks delete $INSTANCE_NAME-data $INSTANCE_NAME-obs $INSTANCE_NAME-swap --zone=$ZONE --project=$PROJECT --quiet
   

3. Elimina le regole firewall e le risorse del gateway Cloud NAT.

   gcloud compute firewall-rules delete allow-ssh-alloydb-omni-tde --project=$PROJECT --quiet
   gcloud compute routers nats delete alloydb-omni-tde-nat --router=alloydb-omni-tde-router --region=$REGION --project=$PROJECT --quiet
   gcloud compute routers delete alloydb-omni-tde-router --region=$REGION --project=$PROJECT --quiet
   

9. Complimenti

Complimenti! Hai completato il codelab TDE su AlloyDB Omni RPM.

Argomenti trattati

• Come eseguire il provisioning dei dischi di archiviazione (/data1, /obs), configurare lo swap e formattare i file system XFS.
• Come generare e gestire le chiavi di crittografia delle chiavi utilizzando File KMS.
• Come inizializzare e avviare un cluster AlloyDB Omni abilitato per la TDE utilizzando gli strumenti RPM.
• Come verificare la crittografia at-rest dei dati utilizzando l'ispezione diretta del disco non elaborato (grep).

Per ulteriori informazioni, consulta la documentazione di AlloyDB Omni.

10. Sondaggio

Come utilizzerai questo tutorial?

Leggilo solo Leggilo e completa gli esercizi