RPM ऑर्केस्ट्रेटर का इस्तेमाल करके, AlloyDB Omni का S3 के साथ काम करने वाले स्टोरेज में बैक अप लेना और उसे वापस लाना

1. परिचय

इस कोडलैब में, आरपीएम ऑर्केस्ट्रेटर का इस्तेमाल करके, AlloyDB Omni के लिए S3 के साथ काम करने वाले ऑब्जेक्ट स्टोरेज में हाई अवेलेबिलिटी (एचए) क्लस्टर का बैक अप लेने का तरीका बताया गया है.

इस कोडलैब में, RPM Orchestrator का इस्तेमाल करके, GCE वीएम पर AlloyDB Omni का ज़्यादा अपटाइम क्लस्टर डिप्लॉय करना कोडलैब में इस्तेमाल किए गए क्लस्टर का इस्तेमाल किया गया है. इसका इस्तेमाल Compute Engine वर्चुअल मशीनों (वीएम) पर एचए क्लस्टर बनाने के लिए किया गया है. इस कोडलैब में, किसी एक वीएम पर S3 के साथ काम करने वाला ऑब्जेक्ट स्टोरेज सर्वर जोड़ा जाता है. एचए क्लस्टर के लिए ऑब्जेक्ट स्टोरेज सर्वर का इस्तेमाल, डेटा का बैक अप लेने और सर्वर से क्लस्टर को वापस लाने के लिए किया जाता है.

ज़रूरी शर्तें

• बिलिंग की सुविधा वाला Google क्लाउड प्रोजेक्ट.
• एचए कोडलैब में बताई गई IAM भूमिकाएं.
• Linux कमांड और एसक्यूएल की बुनियादी जानकारी.

आपको क्या सीखने को मिलेगा

• बैकअप के लिए, S3 के साथ काम करने वाले ऑब्जेक्ट स्टोरेज सर्वर को इंस्टॉल और चलाने का तरीका.
• S3 के साथ काम करने वाले स्टोरेज में बैकअप लिखने के लिए, बैकअप प्लान बनाने का तरीका.
• मांग पर बैकअप बनाने का तरीका.
• किसी क्लस्टर को बैकअप से और किसी समय पर वापस लाने का तरीका.

आपको इन चीज़ों की ज़रूरत होगी

• AlloyDB Omni सॉफ़्टवेयर रिपॉज़िटरी और ऑर्केस्ट्रेटर Ansible कलेक्शन के यूआरएल. यूआरएल पाने के लिए, AlloyDB Omni के लिए साइन-अप फ़ॉर्म भरें. ज़्यादा जानकारी के लिए, RPM का इस्तेमाल करके AlloyDB Omni की खास जानकारी देखें. आपने HA codelab में यूआरएल का इस्तेमाल किया हो.
• RPM Orchestrator का इस्तेमाल करके, GCE वीएम पर AlloyDB Omni हाई अवेलेबिलिटी क्लस्टर डिप्लॉय करें कोडलैब से AlloyDB Omni HA क्लस्टर.
• Google Cloud और Cloud Shell का ऐक्सेस वाला टर्मिनल.

2. सेटअप और ज़रूरी शर्तें

1. इस चरण में, RPM Orchestrator का इस्तेमाल करके, GCE वीएम पर AlloyDB Omni का हाई अवेलेबिलिटी क्लस्टर डिप्लॉय करें कोडलैब का इस्तेमाल करके, एचए क्लस्टर बनाया जाता है. यहां दिया गया तरीका अपनाएं. अगर आपके पास पहले से ही कोडलैब का क्लस्टर है, तो अगले चरण पर जाएं.
   • सेटअप और ज़रूरी शर्तें
   • Google Cloud Compute Engine वर्चुअल मशीनें बनाना
   • डेटाबेस को डिप्लॉय करने के लिए वीएम तैयार करना
   • सभी वीएम पर ज़रूरी सॉफ़्टवेयर कॉम्पोनेंट इंस्टॉल करना
   • AlloyDB Omni क्लस्टर बूटस्ट्रैप करना
   • AlloyDB Omni क्लस्टर की पुष्टि करना
2. ध्यान दें: इस चरण में, "संसाधन हटाएं" वाला चरण न करें. इस कोडलैब के आखिर में, आपको यह चरण पूरा करना होगा.
3. इस कोडलैब पर वापस जाएं

3. क्लस्टर से कनेक्ट करना और सैंपल डेटा जोड़ना

इस चरण में, कंट्रोल वीएम पर क्लस्टर की सेटिंग लोड की जाती हैं. इसके बाद, क्लस्टर से कनेक्ट करें और सैंपल डेटा वाली टेबल जोड़ें.

1. अगर आप कंट्रोल वीएम से कनेक्ट नहीं हैं, तो Cloud Shell से कनेक्ट करें:

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

   CLUSTER, ZONE, और PROJECT वैरिएबल, RPM Orchestrator का इस्तेमाल करके, GCE वीएम पर AlloyDB Omni ज़्यादा अपटाइम क्लस्टर डिप्लॉय करें कोडलैब में डिप्लॉयमेंट के लिए वीएम तैयार करें चरण से मिलते हैं. अगर Cloud Shell में ये वैरिएबल नहीं हैं, तो इन्हें फिर से सेट करें.
2. कंट्रोल वीएम पर, अपनी होम डायरेक्ट्री पर जाएं और एनवायरमेंट वैरिएबल लोड करें. इसके बाद, एनवायरमेंट फ़ाइल में क्लस्टर का नाम और एसएसएच उपयोगकर्ता जोड़ें:

   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)='
   

   पुष्टि करें कि आउटपुट में CLUSTER, SSH_USER, और VIRTUAL_IP दिख रहा हो. ध्यान दें: अगर आपको बाद में कंट्रोल वीएम से फिर से कनेक्ट करना है, तो जारी रखने से पहले cd ~ और source ~/.codelab.env चलाएं.
3. कनेक्शन की सेटिंग को एनवायरमेंट फ़ाइल में जोड़ें. जब read कमांड में पासवर्ड मांगा जाए, तब postgres उपयोगकर्ता का पासवर्ड डालें. आपने यह पासवर्ड, RPM Orchestrator का इस्तेमाल करके, GCE वीएम पर AlloyDB Omni ज़्यादा अपटाइम क्लस्टर डिप्लॉय करना कोडलैब में, AlloyDB Omni क्लस्टर बूटस्ट्रैप करें चरण में सेट किया था

   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. टेबल बनाना और उसमें 1,000 लाइनें जोड़ना:

   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. पंक्तियों की संख्या गिनें:

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

   पुष्टि करें कि आउटपुट में 1000 वैल्यू मिली हो.

4. S3 के साथ काम करने वाले ऑब्जेक्ट स्टोरेज को इंस्टॉल और चालू करना

इस चरण में, आपको एक Ansible प्लेबुक लिखनी होती है. यह कंट्रोल वीएम पर MinIO सर्वर इंस्टॉल करती है. यह प्लेबुक, बैकअप के लिए बकेट और उपयोगकर्ता भी बनाती है. साथ ही, यह पक्का करती है कि डेटाबेस वीएम, MinIO से कनेक्ट हो सकें. इस चरण में दिए गए सभी निर्देशों को कंट्रोल वीएम पर चलाएं.

1. कंट्रोल वीएम पर, एनवायरमेंट फ़ाइल में स्टोरेज की सेटिंग जोड़ें. openssl कमांड से रैंडम पासवर्ड बनाए जाते हैं.

   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"
   

   पक्का करें कि आउटपुट में कंट्रोल वीएम का नाम और इंटरनल आईपी पता दिख रहा हो. उदाहरण के लिए, my-cluster-control 10.1.0.2. डेटाबेस वीएम, MinIO से कनेक्ट करने के लिए इस होस्ट नेम और आईपी पते का इस्तेमाल करते हैं. वीएम का मेटाडेटा सर्वर, आईपी पता देता है. ज़्यादा जानकारी के लिए, वर्चुअल मशीन के मेटाडेटा का दस्तावेज़ देखें.MINIO_URL और MC_URL वैल्यू, MinIO सर्वर और MinIO क्लाइंट (mc) के डाउनलोड यूआरएल हैं.
2. कंट्रोल वीएम पर, ज़रूरी community.crypto Ansible कलेक्शन इंस्टॉल करें:

   ansible-galaxy collection install community.crypto
   

3. 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
   

   MINIO_DOMAIN वैरिएबल की मदद से, MinIO वर्चुअल-होस्ट-स्टाइल के अनुरोधों को स्वीकार कर सकता है. RPM ऑर्केस्ट्रेटर, बैकअप लिखने के लिए alloydb-backup उपयोगकर्ता का इस्तेमाल करता है. readwrite नीति, MinIO में पहले से मौजूद नीति है.
4. प्लेबुक चलाएं:

   ansible-playbook s3_server.yaml -i deployment_spec.yaml
   

   पुष्टि करें कि PLAY RECAP आउटपुट में, localhost और हर डेटाबेस वीएम के लिए failed=0 दिख रहा हो.
5. पुष्टि करें कि बकेट मौजूद है:

   mc --insecure ls s3repo
   

   पुष्टि करें कि आउटपुट में alloydb-backups/ बकेट दिख रहा हो.

5. बैकअप प्लान बनाना

बैकअप प्लान में, क्लस्टर के बैकअप के लिए स्टोरेज की जगह, शेड्यूल, और निजी डेटा रखने की अवधि की जानकारी होती है. इस चरण में, MinIO बकेट के लिए बैकअप प्लान बनाया जाता है.

1. कंट्रोल वीएम पर, बैकअप प्लेबुक और स्टेटस प्लेबुक बनाएं. आपने Secret, BackupPlan, और Backup संसाधनों के लिए, बैकअप लेने की प्लेबुक का इस्तेमाल किया हो. किसी संसाधन की स्थिति दिखाने के लिए, स्टेटस प्लेबुक का इस्तेमाल किया जाता है.

   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. S3 क्रेडेंशियल के लिए Secret संसाधन बनाएं. इसके बाद, संसाधन लागू करें:

   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
   

   data सेक्शन में मौजूद कुंजियों के नाम access-key-id और access-key होने चाहिए. BackupPlan रिसॉर्स लागू करने से पहले, Secret रिसॉर्स लागू करना ज़रूरी है.
3. BackupPlan संसाधन बनाएं. इसके बाद, संसाधन लागू करें:

   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
   

   key वैल्यू, बकेट में मौजूद बैकअप का पाथ होती है. यह पाथ, स्लैश (/) से शुरू होना चाहिए. caBundle फ़ील्ड में, PEM-कोड में बदला गया सीए सर्टिफ़िकेट होता है. यह S3 स्टोरेज सर्वर के सर्टिफ़िकेट की पुष्टि करता है.
4. पुष्टि करें कि बैकअप प्लान तैयार है:

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

   पुष्टि करें कि phase फ़ील्ड में Ready दिखता है. अगर फ़ेज़ Ready नहीं है, तो एक मिनट इंतज़ार करें और कमांड को फिर से चलाएं.
5. बैकअप प्लान बनाने पर, आरपीएम ऑर्केस्ट्रेटर अपने-आप शुरुआती फ़ुल बैकअप शुरू कर देता है. मांग पर बैकअप बनाने से पहले, पुष्टि करें कि शुरुआती बैकअप पूरा हो गया हो:

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

   पुष्टि करें कि शुरुआती बैकअप फ़ेज़ पूरा हो गया हो.

6. मांग पर बैकअप बनाना

इस चरण में, क्लस्टर का मांग पर बैकअप बनाया जाता है.

1. कंट्रोल वीएम पर, Backup संसाधन बनाएं. इसके बाद, संसाधन लागू करें:

   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
   

   backupPlanRef फ़ील्ड, बैकअप प्लान का नाम होता है. dbclusterRef फ़ील्ड, क्लस्टर का नाम होता है.
2. पुष्टि करें कि बैकअप पूरा हो गया है:

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

   पुष्टि करें कि phase फ़ील्ड में Succeeded दिखता है. अगर फ़ेज़ Succeeded नहीं है, तो एक मिनट इंतज़ार करें और कमांड को फिर से चलाएं.
3. पुष्टि करें कि बैकअप फ़ाइलें बकेट में मौजूद हैं:

   mc --insecure tree "s3repo/$S3_BUCKET"
   

   पुष्टि करें कि आउटपुट में backup फ़ोल्डर दिख रहा हो. साथ ही, उसमें db फ़ोल्डर मौजूद हो.

7. बैकअप से क्लस्टर को वापस लाना

आरपीएम ऑर्केस्ट्रेटर, क्लस्टर को उसकी जगह पर वापस लाता है. इस चरण में, आपको एक टेबल मिटानी होगी और उसे बैकअप से वापस लाना होगा. इसके बाद, क्लस्टर को किसी भी समय पर वापस लाया जा सकता है.

चेतावनी: डेटा वापस लाने की प्रोसेस में, डेटाबेस क्लस्टर में मौजूद सारा डेटा बदल जाता है.

बैकअप से वापस लाएं

1. कंट्रोल वीएम पर, orders टेबल मिटाएं. इसके बाद, पंक्तियों की संख्या गिनें:

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

   पुष्टि करें कि दूसरी कमांड में गड़बड़ी हुई है. गड़बड़ी के मैसेज से पता चलता है कि संबंध मौजूद नहीं है. उदाहरण के लिए, ‘ERROR: table "orders" does not exist'
2. डेटा वापस लाने की प्लेबुक बनाएं:

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

3. s3-backup-1 बैकअप के लिए, Restore संसाधन बनाएं. इसके बाद, संसाधन लागू करें:

   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. पुष्टि करें कि डेटा वापस लाने की प्रोसेस पूरी हो गई है:

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

   पुष्टि करें कि phase फ़ील्ड में ProvisionSucceeded दिखता है. अगर फ़ेज़ ProvisionSucceeded नहीं है, तो एक मिनट इंतज़ार करें और कमांड को फिर से चलाएं.
5. वापस लाई गई टेबल में पंक्तियों की संख्या गिनें:

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

   पुष्टि करें कि आउटपुट में 1000 दिख रहा हो.

(ज़रूरी नहीं) किसी समय के हिसाब से वर्शन वापस लाना

किसी समय पर डेटा को वापस लाने के लिए, बैकअप और संग्रहित किए गए राइट-अहेड लॉग (डब्ल्यूएएल) का इस्तेमाल किया जाता है. बैकअप प्लान की रिकवरी विंडो में, क्लस्टर को किसी भी समय वापस लाया जा सकता है.

टारगेट समय के लिए नियम

टारगेट समय के लिए वैल्यू और फ़ॉर्मैट चुनने के लिए, आपको इन सभी नियमों का पालन करना होगा:

• यूटीसी में RFC 3339 फ़ॉर्मैट का इस्तेमाल करें: YYYY-MM-DDThh:mm:ssZ. उदाहरण के लिए, 2026-06-19T14:30:00Z 19 जून, 2026 को दोपहर 02:30 बजे यूटीसी है. T अक्षर, तारीख़ और समय को अलग करता है. Z अक्षर से यूटीसी का पता चलता है.
• बीत चुके समय का इस्तेमाल करें.
• BackupPlan सीआरडी के recoveryWindow फ़ील्ड की begin वैल्यू के बाद का समय इस्तेमाल करें.

RFC 3339 फ़ॉर्मैट में मौजूदा समय दिखाने के लिए, यह निर्देश चलाएं:

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

स्थानीय समय को इस फ़ॉर्मैट में बदलने के लिए, date कमांड में स्थानीय समय का यूटीसी ऑफ़सेट जोड़ें. उदाहरण के लिए, यहां दिए गए निर्देश से UTC+02:00 को 19 June 2026 पर 16:30:00 में बदलाव किया जाता है:

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

इस निर्देश से 2026-06-19T14:30:00Z मिलता है.

रिकॉर्ड किए गए समय के हिसाब से वापस लाना

इस तरीके में, टेबल में लाइनें जोड़ी जाती हैं और समय रिकॉर्ड किया जाता है. समय रिकॉर्ड करने पर, डेटाबेस के पूरी तरह से इंटैक्ट होने (यानी कि उसमें 1,500 लाइनें होने) के समय को बुकमार्क किया जाता है. इसके बाद, लाइनों को मिटाया जाता है और क्लस्टर को रिकॉर्ड किए गए समय पर वापस लाया जाता है.

1. टेबल में 500 लाइनें जोड़ें:

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

2. समय रिकॉर्ड करें. इस टेबल में फ़िलहाल 1,500 लाइनें हैं.

   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
   

   पुष्टि करें कि आउटपुट में समय, YYYY-MM-DDThh:mm:ssZ फ़ॉर्मैट में दिख रहा हो. उदाहरण के लिए, 2026-10-05T11:16:02Z.
3. गलती से डेटा मिटने का सिम्युलेशन करने के लिए, टेबल से पंक्तियां मिटाएं. इसके बाद, नई 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();"
   

   पुष्टि करें कि count क्वेरी में 1000 दिख रहा हो. pg_switch_wal फ़ंक्शन की मदद से, सर्वर एक नई WAL फ़ाइल शुरू करता है. इसके बाद, सर्वर आपकी WAL फ़ाइल को संग्रहित कर सकता है.
4. पुष्टि करें कि बैकअप प्लान की रिकवरी विंडो में रिकॉर्ड किया गया समय शामिल हो:

   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
   

   पुष्टि करें कि PITR_TIME वैल्यू, recoveryWindow फ़ील्ड की begin वैल्यू के बाद की हो.
5. रिकॉर्ड किए गए समय के लिए, Restore संसाधन बनाएं. इसके बाद, संसाधन लागू करें:

   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. पुष्टि करें कि डेटा वापस लाने की प्रोसेस पूरी हो गई है:

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

   पुष्टि करें कि phase फ़ील्ड में ProvisionSucceeded दिखता है. अगर फ़ेज़ ProvisionSucceeded नहीं है, तो एक मिनट इंतज़ार करें और कमांड को फिर से चलाएं.
7. पंक्तियों की संख्या गिनें:

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

   पुष्टि करें कि आउटपुट में 1500 दिख रहा हो.

8. साफ़-सफ़ाई सेवा

अपने Google Cloud खाते से शुल्क न लिए जाने के लिए, इस कोडलैब और RPM Orchestrator का इस्तेमाल करके, GCE वीएम पर AlloyDB Omni हाई अवेलेबिलिटी क्लस्टर डिप्लॉय करें कोडलैब के संसाधन मिटाएं. सबसे पहले, बैकअप संसाधन मिटाएं. इसके बाद, क्लस्टर और कंप्यूट एनवायरमेंट मिटाएं.

1. कंट्रोल वीएम पर, मिटाने की प्लेबुक बनाएं:

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

2. बैकअप की सूची बनाएं:

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

   पुष्टि करें कि आउटपुट में s3-backup-1 बैकअप दिखता है.
3. s3-backup-1 का बैकअप मिटाने के लिए:

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

4. बैकअप प्लान मिटाने के लिए:

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

5. RPM Orchestrator का इस्तेमाल करके, GCE वीएम पर AlloyDB Omni का ज़्यादा अपटाइम क्लस्टर डिप्लॉय करें कोडलैब में दिए गए संसाधन हटाएं चरण का इस्तेमाल करके, क्लस्टर और कंप्यूट एनवायरमेंट को मिटाएं. MinIO सर्वर और इसमें मौजूद बैकअप, कंट्रोल वीएम पर होते हैं. कंप्यूट एनवायरमेंट को मिटाने पर, सर्वर और बैकअप, दोनों मिट जाते हैं.

9. बधाई हो

बधाई हो। आपने RPM ऑर्केस्ट्रेटर का इस्तेमाल करके, AlloyDB Omni के लिए S3 के साथ काम करने वाले ऑब्जेक्ट स्टोरेज में हाई अवेलेबिलिटी (एचए) क्लस्टर का बैक अप लिया हो. इसके बाद, आपने बैकअप से क्लस्टर को वापस लाया हो.

हमने क्या-क्या बताया

• S3 के साथ काम करने वाले ऑब्जेक्ट स्टोरेज के तौर पर MinIO को इंस्टॉल और चलाने का तरीका.
• बैकअप प्लान बनाने और मांग पर बैकअप लेने का तरीका.
• किसी क्लस्टर को बैकअप से और किसी समय पर वापस लाने का तरीका.

ज़्यादा जानकारी के लिए, इन पेजों पर जाएं:

• pgBackRest का इस्तेमाल करके डेटा का बैक अप लेना और उसे वापस लाना
• आरपीएम ऑर्केस्ट्रेटर के सैंपल का इस्तेमाल करके AlloyDB Omni
• BackupPlan कस्टम रिसॉर्स डेफ़िनिशन
• कस्टम रिसॉर्स डेफ़िनिशन का बैकअप
• कस्टम रिसॉर्स डेफ़िनिशन वापस लाना

10. सर्वे

इस ट्यूटोरियल का इस्तेमाल कैसे किया जाएगा?

सिर्फ़ इसे पढ़ें इसे पढ़ें और एक्सरसाइज़ पूरी करें