Transparente Datenverschlüsselung (Transparent Data Encryption, TDE) für AlloyDB Omni RPM aktivieren

1. Einführung

In diesem Codelab wird gezeigt, wie Sie die transparente Datenverschlüsselung (Transparent Data Encryption, TDE) in AlloyDB Omni mit RPM-Paketen konfigurieren und aktivieren. Mit TDE werden Datendateien, Write-Ahead-Logs (WAL) und temporäre Datendateien im Ruhezustand verschlüsselt. So werden Daten vor unbefugtem Zugriff auf zugrunde liegende physische Speichermedien geschützt.

In diesem Codelab erfahren Sie, wie Sie Speichervolumes bereitstellen, einen TDE-fähigen AlloyDB Omni-Cluster mit File KMS initialisieren und ausführen und die Verschlüsselung von Daten im Ruhezustand in Festplattendateien überprüfen.

Voraussetzungen

• Zugriff auf ein Google Cloud-Projekt und die Cloud Shell über die Google Cloud Console.
• Google Cloud SDK (gcloud) installiert und konfiguriert. Weitere Informationen zur Installation von gcloud finden Sie unter gcloud installieren.

Lerninhalte

• Eine Compute Engine-VM mit dedizierten Festplatten für Datenbank, Sicherung und Auslagerungsspeicher erstellen.
• Speichervolumes (XFS) formatieren, /etc/fstab konfigurieren und Datenpfade vorbereiten.
• Schlüsselverschlüsselungsschlüssel (Key Encryption Keys, KEK) mit File KMS generieren und verwalten.
• AlloyDB Omni-RPM-Pakete und PostgreSQL-Clientdienstprogramme installieren.
• Einen TDE-fähigen AlloyDB Omni-Cluster mit RPM-Einrichtungstools (alloydbomni18-setup) und --tde-kek-url bootstrappen.
• Die Verschlüsselung auf der Festplatte mit der Rohdatei-Prüfung (grep) überprüfen.

Voraussetzungen

• Rufen Sie einen URL-Link zu AlloyDB Omni-RPMs ab, indem Sie das AlloyDB Omni-RPM-Registrierungsformular ausfüllen oder die AlloyDB Omni-Übersicht unter Linux aufrufen. Die Repository-URL wird an Ihre registrierte E-Mail-Adresse gesendet.
• Ein funktionierendes Terminal mit Zugriff auf Google Cloud (Cloud Shell empfohlen).

2. Einrichtung und Anforderungen

Projekteinrichtung

Google Cloud-Projekt erstellen

1. Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.
2. Die Abrechnung für das Cloud-Projekt muss aktiviert sein. So prüfen Sie, ob die Abrechnung für ein Projekt aktiviert ist.

Cloud Shell starten

Sie können Google Cloud zwar von Ihrem Laptop aus per Fernzugriff nutzen, in diesem Codelab verwenden Sie jedoch die Google Cloud Shell, eine Befehlszeilenumgebung, die in der Cloud ausgeführt wird.

1. Öffnen Sie die Google Cloud Console und klicken Sie in der Symbolleiste rechts oben auf das Cloud Shell-Symbol. Sie können die Cloud Shell auch öffnen, indem Sie in der Console G und dann S drücken oder shell.cloud.google.com aufrufen.
2. Die Bereitstellung und Verbindung mit der Umgebung dauert in der Regel einige Augenblicke. Wenn der Vorgang abgeschlossen ist, wird eine Terminaleingabeaufforderung angezeigt.

3. Compute Engine-VM erstellen

In diesem Abschnitt erstellen Sie eine Compute Engine-VM (GCE) mit Rocky Linux 9 und dedizierten nichtflüchtigen Speichern für Datenbankdaten (/data1), Sicherungen/Beobachtbarkeit (/obs) und Auslagerungsspeicher.

1. Definieren Sie Umgebungsvariablen für Ihre Projekt-ID, den VM-Namen, die Zone und die Region.

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

2. Konfigurieren Sie Ihr Standardprojekt.

   gcloud config set project $PROJECT
   

3. Erstellen Sie Firewallregeln für das Netzwerk für den SSH-Traffic.

   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. Da die VM ohne öffentliche IP-Adresse erstellt wird, konfigurieren Sie einen Cloud Router und ein Cloud NAT-Gateway, um den ausgehenden Internetzugriff zum Herunterladen von RPM-Paketen zu ermöglichen. Wenn in Ihrer Projektregion bereits ein Cloud NAT vorhanden ist, können Sie fortfahren.

   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
   

   Hinweis: Wenn in Ihrer Region bereits ein Cloud NAT-Gateway vorhanden ist, gibt GCP eine Meldung zurück, dass NAT bereits für alle Subnetze konfiguriert ist. Sie können diesen Fehler ignorieren und fortfahren.
5. Erstellen Sie zusätzliche nichtflüchtige Speicher für Datenbankdaten, Sicherungen und Auslagerungsspeicher.

   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. Stellen Sie die Rocky Linux 9-VM-Instanz mit den angehängten Speichervolumes bereit.

   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. Festplatten, Systemoptimierung und File KMS-Schlüssel vorbereiten

In diesem Abschnitt stellen Sie eine Verbindung zur VM her, formatieren und stellen die nichtflüchtigen Speichervolumes bereit, konfigurieren den Auslagerungsspeicher, optimieren SELinux und generieren den TDE-Schlüsselverschlüsselungsschlüssel (KEK) mit File KMS.

1. Stellen Sie eine SSH-Verbindung zur VM über Identity-Aware Proxy (IAP) her.

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

2. Formatieren und stellen Sie das Datenvolume (/data1) und das Volume für Beobachtbarkeit/Sicherung (/obs) bereit.

   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. Erstellen und aktivieren Sie Auslagerungsspeicher auf der dedizierten Auslagerungsfestplatte.

   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. Definieren Sie Umgebungsvariablen für das Datenbankverzeichnis und die File KMS-Schlüsseldatei.

   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. Erstellen Sie Speicherverzeichnisse für die Datenbank und den File KMS-Schlüssel.

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

6. Generieren Sie mit OpenSSL einen 32 Byte großen kryptografisch sicheren Schlüsselverschlüsselungsschlüssel (KEK) für File KMS.

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

7. Installieren Sie die erforderlichen SELinux-Verwaltungsdienstprogramme.

   sudo dnf install -y policycoreutils-python-utils
   

5. AlloyDB Omni-RPM-Pakete installieren

Konfigurieren Sie Paket-Repositories und installieren Sie den AlloyDB Omni-Datenbankserver zusammen mit den Standardtools von PostgreSQL 18.

Hinweis: Ersetzen Sie $ALLOYDB_OMNI_REPOSITORY_URL durch die Repository-URL, die Sie nach dem Ausfüllen des AlloyDB Omni-RPM-Registrierungsformulars per E-Mail erhalten haben. Weitere Informationen finden Sie in der AlloyDB Omni-Übersicht unter Linux.

1. Erstellen Sie die YUM-Repository-Konfigurationsdatei für 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. Aktualisieren Sie den YUM-Repository-Cache und installieren Sie die AlloyDB Omni 18-Server-RPM-Pakete.

   sudo yum makecache
   sudo dnf install -y alloydbomni18
   

3. Installieren Sie das offizielle PostgreSQL PGDG-RPM-Repository und das Standard-PostgreSQL 18-Clientpaket (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. Weisen Sie den Eigentümer von /data1 und dem KMS-Schlüsselverzeichnis dem Nutzer postgres zu.

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

6. TDE-fähigen Cluster bootstrappen

Konfigurieren Sie Ressourcenkontingente, öffnen Sie Host-Firewallports und initialisieren Sie den AlloyDB Omni-Cluster mit aktivierter transparenter Datenverschlüsselung über den File KMS-Schlüssel (POSTGRES_INITDB_ARGS="--tde-kek-url=file://$KEK_FILE").

1. Setzen Sie SELinux in den zulässigen Modus und konfigurieren Sie Host-Firewallregeln für PostgreSQL.

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

2. Konfigurieren Sie die Parameter für die Systemd-Dienstüberschreibung, um Limits für Speicher- und CPU-Ressourcen zuzuweisen.

   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. Legen Sie Umgebungsvariablen für den Administrator fest und initialisieren Sie den TDE-Datenbankcluster mit 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. Konfigurieren Sie den Serverport 5432 in postgresql.conf.

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

5. Bereiten Sie Systemkataloge und -erweiterungen mit alloydbomni18-setup preparedb vor.

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

6. Aktivieren und starten Sie den Systemd-Dienst alloydbomni18.

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

   Prüfen Sie, ob die Ausgabe Active: active (running) anzeigt.

7. Datenbankvorgänge und Überprüfung der TDE-Festplattenverschlüsselung

Stellen Sie eine Verbindung zur TDE-Datenbank her, fügen Sie Beispieldatensätze ein, führen Sie CHECKPOINT aus, um das Schreiben von Daten auf die Festplatte zu erzwingen, und führen Sie direkte Festplattenscans (grep) aus, um die Verschlüsselung von Daten im Ruhezustand nachzuweisen.

1. Stellen Sie mit psql eine Verbindung zur Datenbank alloydbadmin her.

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

2. Erstellen Sie eine Testtabelle, fügen Sie einen vertraulichen String ein und lösen Sie einen Prüfpunkt aus, um geänderte Puffer in den Speicher zu schreiben.

   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. Fragen Sie die interne AlloyDB-Ansicht für TDE-Statistiken pgsnap.g$tde_stats ab, um den aktiven Verschlüsselungsstatus, den KEK-Speicherort und Blockmesswerte zu überprüfen.

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

   Beispielausgabe, die die aktive TDE (is_tde_enabled = t), den KEK-Dateipfad und die Zähler für verschlüsselte Blöcke bestätigt:

    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. Beenden Sie psql.

   \q
   

5. Suchen Sie in den Rohdatenbank-Speicherdateien unter /data1/18/base/ nach dem Passcode-String, um den TDE-Schutz auf der Festplatte zu überprüfen.

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

Wichtige Erkenntnisse zur Überprüfung

• In einer Nicht-TDE -Datenbankinstanz wird der Nur-Text-String auf der Festplatte angezeigt, wenn Sie grep für Tabellenbeziehungsdateien ausführen.
• In einer TDE-fähigen Datenbankinstanz gibt grep keine Treffer zurück, da alle Datendateien, Indexe, Write-Ahead-Logs (WAL) und temporären Daten im Ruhezustand vollständig mit AES-Blockchiffren verschlüsselt sind.

8. Bereinigen

Wenn Sie mit den Übungen fertig sind, bereinigen Sie die Ressourcen, um unerwünschte Compute-Kosten zu vermeiden.

1. Trennen Sie die Verbindung zur VM-SSH-Sitzung.

   exit
   

2. Entfernen Sie die GCE-VM und die angehängten nichtflüchtigen Speicher.

   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. Löschen Sie Firewallregeln und Cloud NAT-Gateway-Ressourcen.

   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. Glückwunsch

Glückwunsch! Sie haben das Codelab zur TDE in AlloyDB Omni mit RPM erfolgreich abgeschlossen.

Behandelte Themen

• Speicherfestplatten (/data1, /obs) bereitstellen, Auslagerungsspeicher einrichten und XFS-Dateisysteme formatieren.
• Schlüsselverschlüsselungsschlüssel mit File KMS generieren und verwalten.
• Einen TDE-fähigen AlloyDB Omni-Cluster mit RPM-Tools initialisieren und starten.
• Die Verschlüsselung von Daten im Ruhezustand mit direkter Rohdatenprüfung (grep) überprüfen.

Weitere Informationen finden Sie in der AlloyDB Omni-Dokumentation.

10. Umfrage

Wie werden Sie diese Anleitung verwenden?

Nur lesen Lesen und Übungen ausführen