Tworzenie kopii zapasowych i przywracanie AlloyDB Omni w pamięci masowej zgodnej z S3 za pomocą aranżera RPM

1. Wprowadzenie

W tym ćwiczeniu utworzysz kopię zapasową klastra o wysokiej dostępności w magazynie obiektów zgodnym z S3 dla AlloyDB Omni za pomocą aranżera RPM.

W tym ćwiczeniu używamy klastra z ćwiczenia Wdrażanie klastra o wysokiej dostępności AlloyDB Omni na maszynach wirtualnych GCE przy użyciu aranżera RPM do utworzenia klastra o wysokiej dostępności na maszynach wirtualnych Compute Engine. W tym ćwiczeniu dodasz serwer magazynu obiektów zgodny z S3 na jednej z maszyn wirtualnych. Serwer magazynu obiektów klastra HA służy do tworzenia kopii zapasowych danych i przywracania klastra z serwera.

Wymagania wstępne

• projekt Google Cloud z włączonymi płatnościami;
• Role uprawnień wymienione w instrukcji HA.
• Podstawowa znajomość poleceń Linuksa i SQL.

Czego się nauczysz

• Jak zainstalować i uruchomić serwer magazynu obiektów zgodnego z S3 na potrzeby kopii zapasowych.
• Jak utworzyć plan tworzenia kopii zapasowych, który zapisuje kopie zapasowe w pamięci zgodnej z S3.
• Jak utworzyć kopię zapasową na żądanie.
• Jak przywrócić klaster z kopii zapasowej i do określonego momentu.

Czego potrzebujesz

• Adresy URL repozytoriów oprogramowania AlloyDB Omni i kolekcji Ansible aranżera. Aby otrzymać adresy URL, wypełnij formularz rejestracji w usłudze AlloyDB Omni. Więcej informacji znajdziesz w omówieniu AlloyDB Omni z użyciem RPM. Adresów URL używasz w ćwiczeniu w Codelabs dotyczącym HA.
• Klaster AlloyDB Omni HA z ćwiczenia Wdrażanie klastra AlloyDB Omni o wysokiej dostępności w maszynach wirtualnych GCE za pomocą aranżera RPM.
• terminal z dostępem do Google Cloud i Cloud Shell;

2. Konfiguracja i wymagania

1. W tym kroku utworzysz klaster HA, korzystając z ćwiczenia Wdrażanie klastra AlloyDB Omni o wysokiej dostępności w maszynach wirtualnych GCE za pomocą aranżera RPM. Wykonaj następujące czynności. Jeśli masz już klaster z ćwiczenia w Codelabs, przejdź do następnego kroku.
   • Konfiguracja i wymagania
   • Tworzenie maszyn wirtualnych Google Cloud Compute Engine
   • Przygotowywanie maszyn wirtualnych do wdrożenia
   • Zainstaluj wymagane komponenty oprogramowania na wszystkich maszynach wirtualnych
   • Uruchamianie klastra AlloyDB Omni
   • Weryfikowanie klastra AlloyDB Omni
2. Uwaga: na tym etapie nie wykonuj kroku „Oczyść zasoby”. Ten krok wykonasz na końcu tego ćwiczenia.
3. Wróć do tego ćwiczenia

3. Łączenie z klastrem i dodawanie przykładowych danych

W tym kroku wczytasz ustawienia klastra na maszynie wirtualnej sterowania. Następnie połącz się z klastrem i dodaj tabelę z danymi próbkowanymi.

1. Jeśli nie masz połączenia z maszyną wirtualną sterowania, połącz się z nią z Cloud Shell:

   gcloud compute ssh "$CLUSTER-control" --zone="$ZONE" --project="$PROJECT"
   

   Zmienne CLUSTER, ZONE i PROJECT pochodzą z kroku Przygotuj maszyny wirtualne do wdrożenia w ćwiczeniu Wdrażanie klastra AlloyDB Omni o wysokiej dostępności na maszynach wirtualnych GCE za pomocą aranżera RPM. Jeśli Cloud Shell nie ma tych zmiennych, ustaw je ponownie.
2. Na maszynie wirtualnej sterowania przejdź do katalogu głównego i wczytaj zmienne środowiskowe. Następnie dodaj nazwę klastra i użytkownika SSH do pliku środowiska:

   cd ~
   source /tmp/cluster.conf
   cat >> ~/.codelab.env <<EOF
   export CLUSTER="$cluster"
   export SSH_USER="$service_account"
   EOF
   source ~/.codelab.env
   env | grep -E '^(CLUSTER|SSH_USER|VIRTUAL_IP)='
   

   Sprawdź, czy w danych wyjściowych widać wartości CLUSTER, SSH_USER i VIRTUAL_IP. Uwaga: jeśli później ponownie połączysz się z maszyną wirtualną sterowania, przed kontynuowaniem uruchom polecenia cd ~ i source ~/.codelab.env.
3. Dodaj ustawienia połączenia do pliku środowiska. Gdy polecenie read poprosi o hasło, wpisz hasło użytkownika postgres. To hasło ustawiasz w kroku Bootstrap AlloyDB Omni Cluster (Uruchom klaster AlloyDB Omni) w ćwiczeniu Deploy AlloyDB Omni high availability cluster on GCE VMs using RPM Orchestrator (Wdrażanie klastra AlloyDB Omni o wysokiej dostępności w maszynach wirtualnych GCE za pomocą aranżera RPM).

   cat >> ~/.codelab.env <<'EOF'
   export PATH="/usr/pgsql-18/bin:$PATH"
   export PGHOST="$VIRTUAL_IP"
   export PGUSER="postgres"
   EOF
   read -rsp "Password of the postgres user: " PGPASSWORD; echo
   printf 'export PGPASSWORD=%q\n' "$PGPASSWORD" >> ~/.codelab.env
   source ~/.codelab.env
   env | grep -E '^(PGHOST|PGUSER|PGPASSWORD)='
   

4. Utwórz tabelę i dodaj 1000 wierszy:

   psql <<'SQL'
   CREATE TABLE public.orders (
     id integer PRIMARY KEY,
     item text NOT NULL,
     created_at timestamptz NOT NULL DEFAULT pg_catalog.now()
   );
   INSERT INTO public.orders (id, item)
   SELECT g, 'item-' || g FROM pg_catalog.generate_series(1, 1000) AS g;
   SQL
   

5. Policz wiersze:

   psql -c "SELECT pg_catalog.count(*) FROM public.orders;"
   

   Sprawdź, czy dane wyjściowe zwracają wartość 1000.

4. Instalowanie i uruchamianie obiektowej pamięci masowej zgodnej z S3

W tym kroku napiszesz plik playbook Ansible, który zainstaluje serwer MinIO na maszynie wirtualnej sterowania. Skrypt tworzy też zasobnik i użytkownika na potrzeby kopii zapasowych oraz dba o to, aby maszyny wirtualne bazy danych mogły łączyć się z MinIO. Wszystkie polecenia z tego kroku uruchom na maszynie wirtualnej sterowania.

1. Na maszynie wirtualnej sterowania dodaj ustawienia pamięci masowej do pliku środowiska. Polecenia openssl tworzą losowe hasła.

   MD=http://metadata.google.internal/computeMetadata/v1/instance
   S3_IP=$(curl -s -H "Metadata-Flavor: Google" "$MD/network-interfaces/0/ip")
   cat >> ~/.codelab.env <<EOF
   export S3_IP="$S3_IP"
   export S3_HOST="$CLUSTER-control"
   export S3_BUCKET="alloydb-backups"
   export S3_REGION="us-east-1"
   export MINIO_ROOT_USER="s3admin"
   export MINIO_ROOT_PASSWORD="$(openssl rand -hex 16)"
   export S3_ACCESS_KEY_ID="alloydb-backup"
   export S3_SECRET_ACCESS_KEY="$(openssl rand -hex 16)"
   export MINIO_URL="https://github.com/minio/minio/releases/download/RELEASE.2024-05-10T01-41-38Z/minio.linux-amd64.RELEASE.2024-05-10T01-41-38Z"
   export MC_URL="https://github.com/minio/mc/releases/download/RELEASE.2024-05-09T17-04-24Z/mc.linux-amd64.RELEASE.2024-05-09T17-04-24Z"
   EOF
   source ~/.codelab.env
   echo "$S3_HOST $S3_IP"
   

   Sprawdź, czy w danych wyjściowych widać nazwę i wewnętrzny adres IP maszyny wirtualnej sterowania, np. my-cluster-control 10.1.0.2. Maszyny wirtualne bazy danych używają tej nazwy hosta i adresu IP do łączenia się z MinIO. Adres IP jest podawany przez serwer metadanych maszyny wirtualnej. Więcej informacji znajdziesz w dokumentacji metadanych maszyny wirtualnej.Wartości MINIO_URL i MC_URL to adresy URL pobierania serwera MinIO i klienta MinIO (mc).
2. Zainstaluj wymaganą kolekcję community.crypto Ansible na maszynie wirtualnej sterowania:

   ansible-galaxy collection install community.crypto
   

3. Utwórz scenariusz s3_server.yaml:

   cat > s3_server.yaml <<EOF
   - name: Install and run MinIO on the control VM
     hosts: localhost
     connection: local
     become: true
     gather_facts: false
     tasks:
       - name: Create MinIO directories
         ansible.builtin.file:
           path: "{{ item }}"
           state: directory
           mode: "0755"
         loop:
           - /var/lib/minio/data
           - /var/lib/minio/certs
   
       - name: Download MinIO server and client
         ansible.builtin.get_url:
           url: "{{ item.url }}"
           dest: "{{ item.dest }}"
           mode: "0755"
         loop:
           - url: "$MINIO_URL"
             dest: /usr/local/bin/minio
           - url: "$MC_URL"
             dest: /usr/local/bin/mc
   
       - name: Generate MinIO TLS private key
         community.crypto.openssl_privatekey:
           path: /var/lib/minio/certs/private.key
           size: 2048
           mode: "0600"
   
       - name: Generate MinIO certificate signing request
         community.crypto.openssl_csr_pipe:
           privatekey_path: /var/lib/minio/certs/private.key
           common_name: "$S3_HOST"
           subject_alt_name:
             - "DNS:$S3_HOST"
             - "DNS:$S3_BUCKET.$S3_HOST"
             - "DNS:localhost"
             - "IP:127.0.0.1"
             - "IP:$S3_IP"
         register: minio_csr
   
       - name: Generate self-signed MinIO TLS certificate
         community.crypto.x509_certificate:
           path: /var/lib/minio/certs/public.crt
           csr_content: "{{ minio_csr.csr }}"
           privatekey_path: /var/lib/minio/certs/private.key
           provider: selfsigned
           selfsigned_not_after: "+365d"
           mode: "0644"
   
       - name: Create MinIO systemd service unit
         ansible.builtin.copy:
           dest: /etc/systemd/system/minio.service
           mode: "0600"
           content: |
             [Unit]
             Description=MinIO Object Storage
             After=network.target
   
             [Service]
             Environment="MINIO_ROOT_USER=$MINIO_ROOT_USER"
             Environment="MINIO_ROOT_PASSWORD=$MINIO_ROOT_PASSWORD"
             Environment="MINIO_DOMAIN=$S3_HOST"
             ExecStart=/usr/local/bin/minio server /var/lib/minio/data --certs-dir /var/lib/minio/certs
             Restart=on-failure
   
             [Install]
             WantedBy=multi-user.target
   
       - name: Start and enable MinIO service
         ansible.builtin.systemd_service:
           name: minio
           daemon_reload: true
           state: started
           enabled: true
   
       - name: Add storage host names to /etc/hosts on the control VM
         ansible.builtin.lineinfile:
           path: /etc/hosts
           line: "$S3_IP $S3_HOST $S3_BUCKET.$S3_HOST"
           state: present
   
       - name: Wait for MinIO health endpoint
         ansible.builtin.uri:
           url: "https://$S3_HOST:9000/minio/health/live"
           ca_path: /var/lib/minio/certs/public.crt
           status_code: 200
         register: minio_health
         until: minio_health.status == 200
         retries: 6
         delay: 5
   
       - name: Create backup bucket and user in MinIO
         ansible.builtin.command:
           argv: "{{ item }}"
         loop:
           - - /usr/local/bin/mc
             - --insecure
             - alias
             - set
             - s3repo
             - "https://$S3_HOST:9000"
             - "$MINIO_ROOT_USER"
             - "$MINIO_ROOT_PASSWORD"
           - - /usr/local/bin/mc
             - --insecure
             - mb
             - --ignore-existing
             - "s3repo/$S3_BUCKET"
           - - /usr/local/bin/mc
             - --insecure
             - admin
             - user
             - add
             - s3repo
             - "$S3_ACCESS_KEY_ID"
             - "$S3_SECRET_ACCESS_KEY"
           - - /usr/local/bin/mc
             - --insecure
             - admin
             - policy
             - attach
             - s3repo
             - readwrite
             - --user
             - "$S3_ACCESS_KEY_ID"
         become: false
         no_log: true
   
   - name: Configure database VMs for MinIO
     hosts: primary_instance_nodes
     become: true
     gather_facts: false
     vars:
       ansible_user: $SSH_USER
       ansible_ssh_private_key_file: $HOME/ssh-key-cluster-sa
     tasks:
       - name: Set SELinux to permissive mode
         ansible.builtin.command:
           cmd: setenforce 0
   
       - name: Add storage host names to /etc/hosts
         ansible.builtin.lineinfile:
           path: /etc/hosts
           line: "$S3_IP $S3_HOST $S3_BUCKET.$S3_HOST"
           state: present
   
       - name: Verify storage host resolution
         ansible.builtin.getent:
           database: hosts
           key: "$S3_BUCKET.$S3_HOST"
   
       - name: Verify connection to MinIO
         ansible.builtin.uri:
           url: "https://$S3_HOST:9000/minio/health/live"
           validate_certs: false
           status_code: 200
   EOF
   

   Zmienna MINIO_DOMAIN umożliwia MinIO akceptowanie żądań w stylu hostowania wirtualnego. Aranżer RPM używa użytkownika alloydb-backup do zapisywania kopii zapasowych. Zasada readwrite to wbudowana zasada MinIO.
4. Uruchom scenariusz:

   ansible-playbook s3_server.yaml -i deployment_spec.yaml
   

   Sprawdź, czy w danych wyjściowych polecenia PLAY RECAP w przypadku localhost i każdej maszyny wirtualnej bazy danych wyświetla się wartość failed=0.
5. Sprawdź, czy zasobnik istnieje:

   mc --insecure ls s3repo
   

   Sprawdź, czy w danych wyjściowych widoczny jest zasobnik alloydb-backups/.

5. Utwórz plan wykonywania kopii zapasowych

Plan tworzenia kopii zapasowych zawiera lokalizację pamięci, harmonogram i okres przechowywania kopii zapasowych klastra. W tym kroku utworzysz plan tworzenia kopii zapasowych zasobnika MinIO.

1. Na maszynie wirtualnej sterowania utwórz plik playbook kopii zapasowej i plik playbook stanu. Korzystasz z poradnika dotyczącego tworzenia kopii zapasowych zasobów Secret, BackupPlan i Backup. Za pomocą przewodnika po stanie możesz wyświetlić stan zasobu.

   cat > backup.yaml <<EOF
   - name: Manage AlloyDB Omni backups
     hosts: localhost
     roles:
       - role: google.alloydbomni_orchestrator.backup
   EOF
   cat > status.yaml <<EOF
   - name: Get resource status
     hosts: localhost
     roles:
       - role: google.alloydbomni_orchestrator.status
   EOF
   

2. Utwórz zasób Secret dla danych logowania S3. Następnie zastosuj zasób:

   S3_KEY_ID_B64=$(printf '%s' "$S3_ACCESS_KEY_ID" | base64 -w 0)
   S3_KEY_B64=$(printf '%s' "$S3_SECRET_ACCESS_KEY" | base64 -w 0)
   cat > s3_secret.yaml <<EOF
   Secret:
     metadata:
       name: s3-backup-secret
     spec:
       type: Opaque
       data:
         access-key-id: "$S3_KEY_ID_B64"
         access-key: "$S3_KEY_B64"
   EOF
   ansible-playbook backup.yaml -i deployment_spec.yaml \
       -e resource_spec=s3_secret.yaml
   

   Nazwy kluczy w sekcji data muszą mieć postać access-key-id i access-key. Zanim zastosujesz zasób BackupPlan, musisz zastosować zasób Secret.
3. Utwórz zasób BackupPlan, a potem go zastosuj:

   cat > backup_plan.yaml <<EOF
   BackupPlan:
     metadata:
       name: s3-backup-plan
     spec:
       dbclusterRef: $CLUSTER
       backupLocation:
         type: S3
         s3Options:
           bucket: $S3_BUCKET
           key: /backups
           endpoint: https://$S3_HOST:9000
           region: $S3_REGION
           secretRef:
             name: s3-backup-secret
           caBundle:
             - |
   $(sed 's/^/            /' /var/lib/minio/certs/public.crt)
   EOF
   ansible-playbook backup.yaml -i deployment_spec.yaml \
       -e resource_spec=backup_plan.yaml
   

   Wartość key to ścieżka do kopii zapasowych w zasobniku. Ścieżka musi zaczynać się od ukośnika (/). Pole caBundle zawiera certyfikat CA zakodowany w formacie PEM, który weryfikuje certyfikat serwera pamięci S3.
4. Sprawdź, czy plan tworzenia kopii zapasowych jest gotowy:

   ansible-playbook status.yaml -i deployment_spec.yaml \
       -e resource_type=BackupPlan -e resource_name=s3-backup-plan
   

   Sprawdź, czy w polu phase wyświetla się wartość Ready. Jeśli faza nie jest Ready, poczekaj minutę i ponownie uruchom polecenie.
5. Po utworzeniu planu kopii zapasowej koordynator RPM automatycznie rozpoczyna początkową pełną kopię zapasową. Zanim utworzysz kopię zapasową na żądanie, sprawdź, czy pierwsza kopia zapasowa została utworzona:

   ansible-playbook status.yaml -i deployment_spec.yaml \
       -e resource_type=Backup
   

   Sprawdź, czy początkowa faza tworzenia kopii zapasowej zakończyła się powodzeniem.

6. Utwórz kopię zapasową na żądanie

W tym kroku utworzysz kopię zapasową klastra na żądanie.

1. Na maszynie wirtualnej sterowania utwórz zasób Backup. Następnie zastosuj zasób:

   cat > create_backup.yaml <<EOF
   Backup:
     metadata:
       name: s3-backup-1
     spec:
       backupPlanRef: s3-backup-plan
       dbclusterRef: $CLUSTER
   EOF
   ansible-playbook backup.yaml -i deployment_spec.yaml \
       -e resource_spec=create_backup.yaml
   

   Pole backupPlanRef to nazwa planu tworzenia kopii zapasowych. Pole dbclusterRef to nazwa klastra.
2. Sprawdź, czy kopia zapasowa została utworzona:

   ansible-playbook status.yaml -i deployment_spec.yaml \
       -e resource_type=Backup -e resource_name=s3-backup-1
   

   Sprawdź, czy w polu phase wyświetla się wartość Succeeded. Jeśli faza nie jest Succeeded, poczekaj minutę i ponownie uruchom polecenie.
3. Sprawdź, czy pliki kopii zapasowej znajdują się w zasobniku:

   mc --insecure tree "s3repo/$S3_BUCKET"
   

   Sprawdź, czy w danych wyjściowych widać folder backup, który zawiera folder db.

7. Przywracanie klastra z kopii zapasowej

Aranżer RPM przywraca klaster w miejscu. W tym kroku usuniesz tabelę i przywrócisz ją z kopii zapasowej. Następnie możesz opcjonalnie przywrócić klaster do określonego momentu.

Ostrzeżenie: operacja przywracania zastępuje wszystkie dane w klastrze bazy danych.

Przywróć z kopii zapasowej

1. Na maszynie wirtualnej kontrolera usuń tabelę orders. Następnie policz wiersze:

   psql -c "DROP TABLE public.orders;"
   psql -c "SELECT pg_catalog.count(*) FROM public.orders;"
   

   Sprawdź, czy drugie polecenie kończy się niepowodzeniem i wyświetla błąd. Komunikat o błędzie informuje, że relacja nie istnieje. Na przykład „ERROR: table "orders" does not exist'
2. Utwórz scenariusz przywracania:

   cat > restore.yaml <<EOF
   - name: Restore AlloyDB Omni cluster
     hosts: localhost
     roles:
       - role: google.alloydbomni_orchestrator.restore
   EOF
   

3. Utwórz zasób Restore dla kopii zapasowej s3-backup-1. Następnie zastosuj zasób:

   cat > restore_backup.yaml <<EOF
   Restore:
     metadata:
       name: s3-restore-1
     spec:
       sourceDBCluster: $CLUSTER
       backup: s3-backup-1
   EOF
   ansible-playbook restore.yaml -i deployment_spec.yaml \
       -e resource_spec=restore_backup.yaml
   

4. Sprawdź, czy operacja przywracania została zakończona:

   ansible-playbook status.yaml -i deployment_spec.yaml \
       -e resource_type=Restore -e resource_name=s3-restore-1
   

   Sprawdź, czy w polu phase wyświetla się wartość ProvisionSucceeded. Jeśli faza nie jest ProvisionSucceeded, poczekaj minutę i ponownie uruchom polecenie.
5. Policz wiersze w przywróconej tabeli:

   psql -c "SELECT pg_catalog.count(*) FROM public.orders;"
   

   Sprawdź, czy w danych wyjściowych wyświetla się wartość 1000.

(Opcjonalnie) Przywracanie do określonego momentu

Przywracanie do określonego momentu wykorzystuje kopię zapasową i zarchiwizowany log zapisywany z wyprzedzeniem (WAL). Klaster możesz przywrócić do dowolnego momentu w okresie przywracania planu tworzenia kopii zapasowych.

Reguły dotyczące czasu docelowego

Aby wybrać wartość i format czasu docelowego, musisz przestrzegać wszystkich tych reguł:

• Użyj formatu RFC 3339 w strefie czasowej UTC: YYYY-MM-DDThh:mm:ssZ. Na przykład 2026-06-19T14:30:00Z to 19 czerwca 2026 r. o godz. 14:30:00 czasu UTC. Litera T oddziela datę od godziny. Litera Z oznacza czas UTC.
• Użyj czasu z przeszłości.
• Użyj czasu po wartości begin w polu recoveryWindow obiektu CRD BackupPlan.

Aby wyświetlić bieżący czas w formacie RFC 3339, uruchom to polecenie:

date -u +%Y-%m-%dT%H:%M:%SZ

Aby zmienić czas lokalny na ten format, dodaj przesunięcie UTC czasu lokalnego do polecenia date. Na przykład to polecenie zmienia 16:30:00 na 19 June 2026 o godzinie UTC+02:00:

date -u -d "2026-06-19 16:30:00 +0200" +%Y-%m-%dT%H:%M:%SZ

Polecenie zwraca wartość 2026-06-19T14:30:00Z.

Przywracanie do zarejestrowanego czasu

W tej procedurze dodasz wiersze do tabeli i zarejestrujesz czas. Podczas rejestrowania czasu zapisujesz dokładny moment, w którym baza danych jest w pełni nienaruszona (zawiera dokładnie 1500 wierszy).Następnie usuwasz wiersze i przywracasz klaster do zarejestrowanego czasu.

1. Dodaj do tabeli 500 wierszy:

   psql <<'SQL'
   INSERT INTO public.orders (id, item)
   SELECT g, 'item-' || g FROM pg_catalog.generate_series(1001, 1500) AS g;
   SQL
   

2. Zapisz czas. Tabela ma obecnie 1500 wierszy.

   sleep 5
   PITR_TIME=$(date -u +%Y-%m-%dT%H:%M:%SZ)
   echo "export PITR_TIME=$PITR_TIME" >> ~/.codelab.env
   echo "$PITR_TIME"
   sleep 5
   

   Sprawdź, czy dane wyjściowe zawierają godzinę w formacie YYYY-MM-DDThh:mm:ssZ, np. 2026-10-05T11:16:02Z.
3. Usuń wiersze z tabeli, aby zasymulować przypadkowe usunięcie danych. Następnie rozpocznij nowy plik WAL:

   psql -c "DELETE FROM public.orders WHERE id > 1000;"
   psql -c "SELECT pg_catalog.count(*) FROM public.orders;"
   psql -c "SELECT pg_catalog.pg_switch_wal();"
   

   Sprawdź, czy zapytanie count zwraca wartość 1000. Funkcja pg_switch_wal powoduje, że serwer rozpoczyna nowy plik WAL. Następnie serwer może zarchiwizować plik WAL zawierający Twoje zmiany.
4. Sprawdź, czy okno przywracania planu tworzenia kopii zapasowych zawiera zarejestrowany czas:

   test -n "$PITR_TIME" || { echo "PITR_TIME is not set. Run step 2 again."; exit 1; }
   echo "$PITR_TIME"
   ansible-playbook status.yaml -i deployment_spec.yaml \
       -e resource_type=BackupPlan -e resource_name=s3-backup-plan
   

   Sprawdź, czy wartość PITR_TIME występuje po wartości begin w polu recoveryWindow.
5. Utwórz zasób Restore dla zarejestrowanego czasu. Następnie zastosuj zasób:

   cat > restore_pitr.yaml <<EOF
   Restore:
     metadata:
       name: s3-restore-pitr
     spec:
       sourceDBCluster: $CLUSTER
       pointInTime: "$PITR_TIME"
   EOF
   ansible-playbook restore.yaml -i deployment_spec.yaml \
       -e resource_spec=restore_pitr.yaml
   

6. Sprawdź, czy operacja przywracania została zakończona:

   ansible-playbook status.yaml -i deployment_spec.yaml \
       -e resource_type=Restore -e resource_name=s3-restore-pitr
   

   Sprawdź, czy w polu phase wyświetla się wartość ProvisionSucceeded. Jeśli faza nie jest ProvisionSucceeded, poczekaj minutę i ponownie uruchom polecenie.
7. Policz wiersze:

   psql -c "SELECT pg_catalog.count(*) FROM public.orders;"
   

   Sprawdź, czy w danych wyjściowych wyświetla się wartość 1500.

8. Czyszczenie

Aby uniknąć obciążenia konta Google Cloud opłatami, usuń zasoby z tego ćwiczenia w Codelabs i z ćwiczenia w Codelabs Wdrażanie klastra AlloyDB Omni o wysokiej dostępności na maszynach wirtualnych GCE za pomocą narzędzia RPM Orchestrator. Najpierw usuń zasoby kopii zapasowej, a potem klaster i środowisko obliczeniowe.

1. Na maszynie wirtualnej sterującej utwórz plik playbook usuwania:

   cat > delete.yaml <<EOF
   - name: Delete AlloyDB Omni resources
     hosts: localhost
     roles:
       - role: google.alloydbomni_orchestrator.delete
   EOF
   

2. Wyświetl listę kopii zapasowych:

   ansible-playbook status.yaml -i deployment_spec.yaml -e resource_type=Backup
   

   Sprawdź, czy w danych wyjściowych widoczna jest kopia zapasowa s3-backup-1.
3. Usuń kopię zapasową s3-backup-1:

   ansible-playbook delete.yaml -i deployment_spec.yaml \
       -e resource_type=Backup -e resource_name=s3-backup-1
   

4. Usuń plan tworzenia kopii zapasowych:

   ansible-playbook delete.yaml -i deployment_spec.yaml \
       -e resource_type=BackupPlan -e resource_name=s3-backup-plan
   

5. Usuń klaster i środowisko obliczeniowe, wykonując krok Clean up Resources (Czyszczenie zasobów) z ćwiczenia Deploy AlloyDB Omni high availability cluster on GCE VMs using RPM Orchestrator (Wdrażanie klastra AlloyDB Omni o wysokiej dostępności na maszynach wirtualnych GCE za pomocą aranżera RPM). Serwer MinIO i kopie zapasowe znajdują się na maszynie wirtualnej sterowania. Usunięcie środowiska obliczeniowego powoduje usunięcie zarówno serwera, jak i kopii zapasowych.

9. Gratulacje

Gratulacje. Utworzono kopię zapasową klastra o wysokiej dostępności w magazynie obiektów zgodnym z S3 w przypadku AlloyDB Omni z użyciem aranżera RPM. Następnie przywrócono klaster z kopii zapasowych.

Omówione zagadnienia

• Jak zainstalować i uruchomić MinIO jako magazyn obiektów zgodny z S3.
• Jak utworzyć plan tworzenia kopii zapasowych i kopię zapasową na żądanie.
• Jak przywrócić klaster z kopii zapasowej i do określonego momentu.

Więcej informacji znajdziesz na tych stronach:

• Tworzenie kopii zapasowej i przywracanie danych za pomocą pgBackRest
• Przykłady AlloyDB Omni z użyciem aranżera RPM
• Definicja zasobu niestandardowego BackupPlan
• Definicja zasobu niestandardowego kopii zapasowej
• Przywracanie definicji zasobu niestandardowego

10. Ankieta

Jak zamierzasz korzystać z tego samouczka?

Tylko przeczytaj Przeczytaj i wykonaj ćwiczenia