Memvalidasi dan menguji penyebaran database PostgreSQL di Azure Kubernetes Service (AKS)

Dalam artikel ini, Anda melakukan berbagai langkah pengujian dan validasi pada database PostgreSQL yang disebarkan di AKS. Ini termasuk memverifikasi penyebaran, menyambungkan ke database, dan menguji skenario failover.

Jika Anda belum menyebarkan PostgreSQL, ikuti langkah-langkah dalam Menyebarkan database PostgreSQL yang sangat tersedia di AKS dengan Azure CLI untuk disiapkan, lalu Anda dapat kembali ke artikel ini.

Penting

Perangkat lunak sumber terbuka disebutkan di seluruh dokumentasi dan sampel AKS. Perangkat lunak yang Anda sebarkan dikecualikan dari perjanjian tingkat layanan AKS, garansi terbatas, dan dukungan Azure. Saat Anda menggunakan teknologi sumber terbuka bersama AKS, konsultasikan opsi dukungan yang tersedia dari masing-masing komunitas dan pengelola proyek untuk mengembangkan rencana.

Microsoft bertanggung jawab untuk membangun paket sumber terbuka yang kami sebarkan di AKS. Tanggung jawab itu termasuk memiliki kepemilikan lengkap atas proses build, pemindaian, penandatanganan, validasi, dan perbaikan, bersama dengan kontrol atas biner pada citra kontainer. Untuk informasi selengkapnya, lihat Manajemen kerentanan untuk AKS dan cakupan dukungan AKS.

Memeriksa kluster PostgreSQL yang disebarkan

Validasi bahwa PostgreSQL tersebar di beberapa zona ketersediaan dengan mengambil detail simpul AKS menggunakan perintah kubectl get.

kubectl get nodes \
    --context $AKS_PRIMARY_CLUSTER_NAME \
    --namespace $PG_NAMESPACE \
    --output json | jq '.items[] | {node: .metadata.name, zone: .metadata.labels."failure-domain.beta.kubernetes.io/zone"}'

Output Anda harus menyerupai contoh output berikut dengan zona ketersediaan yang ditampilkan untuk setiap simpul:

{
    "node": "aks-postgres-15810965-vmss000000",
    "zone": "westus3-1"
}
{
    "node": "aks-postgres-15810965-vmss000001",
    "zone": "westus3-2"
}
{
    "node": "aks-postgres-15810965-vmss000002",
    "zone": "westus3-3"
}
{
    "node": "aks-systempool-26112968-vmss000000",
    "zone": "westus3-1"
}
{
    "node": "aks-systempool-26112968-vmss000001",
    "zone": "westus3-2"
}

Menyambungkan ke PostgreSQL dan membuat himpunan data sampel

Di bagian ini, Anda membuat tabel dan menyisipkan beberapa data ke dalam database aplikasi yang dibuat di CRD Kluster CNPG yang Anda sebarkan sebelumnya. Anda menggunakan data ini untuk memvalidasi operasi pencadangan dan pemulihan untuk kluster PostgreSQL.

Buat tabel dan sisipkan data ke database aplikasi menggunakan perintah berikut:

kubectl cnpg psql $PG_PRIMARY_CLUSTER_NAME --namespace $PG_NAMESPACE

-- Create a small dataset
CREATE TABLE datasample (id INTEGER, name VARCHAR(255));
INSERT INTO datasample (id, name) VALUES (1, 'John');
INSERT INTO datasample (id, name) VALUES (2, 'Jane');
INSERT INTO datasample (id, name) VALUES (3, 'Alice');
SELECT COUNT(*) FROM datasample;

Ketik \q untuk keluar dari psql setelah selesai.

Output Anda harus menyerupai contoh output berikut:

CREATE TABLE
INSERT 0 1
INSERT 0 1
INSERT 0 1
count
-------
    3
(1 row)

Sambungkan ke Replika Baca-Saja PostgreSQL

Sambungkan ke replika baca-saja PostgreSQL dan validasi himpunan data sampel menggunakan perintah berikut:

kubectl cnpg psql --replica $PG_PRIMARY_CLUSTER_NAME --namespace $PG_NAMESPACE

SELECT pg_is_in_recovery();

Contoh output

pg_is_in_recovery
-------------------
t
(1 row)

SELECT COUNT(*) FROM datasample;

Contoh output

count
-------
  3
(1 row)

Menyiapkan cadangan PostgreSQL sesuai permintaan dan terjadwal menggunakan Barman

Nota

CloudNativePG diperkirakan akan menghapus secara bertahap dukungan Barman Cloud bawaan demi plugin Barman Cloud dalam rilis 1.29 mendatang. Langkah-langkah dalam panduan ini terus berfungsi hari ini, tetapi berencana untuk bermigrasi ke plugin setelah stabil.

Memvalidasi bahwa kluster PostgreSQL dapat mengakses akun penyimpanan Azure yang ditentukan dalam CRD Kluster CNPG dan bahwa Working WAL archiving dilaporkan sebagai OK menggunakan perintah berikut:

kubectl cnpg status $PG_PRIMARY_CLUSTER_NAME 1 \
    --context $AKS_PRIMARY_CLUSTER_NAME \
    --namespace $PG_NAMESPACE

Contoh output

Continuous Backup status
First Point of Recoverability:  Not Available
Working WAL archiving:          OK
WALs waiting to be archived:    0
Last Archived WAL:              00000001000000000000000A   @   2024-07-09T17:18:13.982859Z
Last Failed WAL:                -

Sebarkan cadangan sesuai permintaan ke Azure Storage yang menggunakan integrasi identitas beban kerja AKS, dengan file YAML dan perintah kubectl apply.

export BACKUP_ONDEMAND_NAME="on-demand-backup-1"

cat <<EOF | kubectl apply --context $AKS_PRIMARY_CLUSTER_NAME --namespace $PG_NAMESPACE -v 9 -f -
apiVersion: postgresql.cnpg.io/v1
kind: Backup
metadata:
  name: $BACKUP_ONDEMAND_NAME
spec:
  method: barmanObjectStore
  cluster:
    name: $PG_PRIMARY_CLUSTER_NAME
EOF

Validasi status cadangan sesuai permintaan menggunakan kubectl describe perintah .

kubectl describe backup $BACKUP_ONDEMAND_NAME \
    --context $AKS_PRIMARY_CLUSTER_NAME \
    --namespace $PG_NAMESPACE

Contoh output

Type    Reason     Age   From                   Message
 ----    ------     ----  ----                   -------
Normal  Starting   6s    cloudnative-pg-backup  Starting backup for cluster pg-primary-cnpg-r8c7unrw
Normal  Starting   5s    instance-manager       Backup started
Normal  Completed  1s    instance-manager       Backup completed

Validasi bahwa kluster memiliki titik pemulihan pertama menggunakan perintah berikut:

kubectl cnpg status $PG_PRIMARY_CLUSTER_NAME 1 \
    --context $AKS_PRIMARY_CLUSTER_NAME \
    --namespace $PG_NAMESPACE

Contoh output

Continuous Backup status
First Point of Recoverability:  2024-06-05T13:47:18Z
Working WAL archiving:          OK

Konfigurasikan cadangan terjadwal untuk setiap jam pada 15 menit lewat jam menggunakan file YAML dengan perintah kubectl apply.

export BACKUP_SCHEDULED_NAME="scheduled-backup-1"

cat <<EOF | kubectl apply --context $AKS_PRIMARY_CLUSTER_NAME --namespace $PG_NAMESPACE -v 9 -f -
apiVersion: postgresql.cnpg.io/v1
kind: ScheduledBackup
metadata:
  name: $BACKUP_SCHEDULED_NAME
spec:
  # Backup once per hour
  schedule: "0 15 * ? * *"
  backupOwnerReference: self
  cluster:
    name: $PG_PRIMARY_CLUSTER_NAME
EOF

Validasi status pencadangan terjadwal menggunakan perintah kubectl describe.

kubectl describe scheduledbackup $BACKUP_SCHEDULED_NAME \
    --context $AKS_PRIMARY_CLUSTER_NAME \
    --namespace $PG_NAMESPACE

Lihat file cadangan yang disimpan di penyimpanan blob Azure untuk kluster utama menggunakan az storage blob list perintah .

az storage blob list \
    --account-name $PG_PRIMARY_STORAGE_ACCOUNT_NAME \
    --container-name backups \
    --query "[*].name" \
    --only-show-errors

Output Anda harus menyerupai contoh output berikut, memvalidasi cadangan berhasil:

[
  "pg-primary-cnpg-r8c7unrw/base/20240605T134715/backup.info",
  "pg-primary-cnpg-r8c7unrw/base/20240605T134715/data.tar",
  "pg-primary-cnpg-r8c7unrw/wals/0000000100000000/000000010000000000000001",
  "pg-primary-cnpg-r8c7unrw/wals/0000000100000000/000000010000000000000002",
  "pg-primary-cnpg-r8c7unrw/wals/0000000100000000/000000010000000000000003",
  "pg-primary-cnpg-r8c7unrw/wals/0000000100000000/000000010000000000000003.00000028.backup",
  "pg-primary-cnpg-r8c7unrw/wals/0000000100000000/000000010000000000000004",
  "pg-primary-cnpg-r8c7unrw/wals/0000000100000000/000000010000000000000005",
  "pg-primary-cnpg-r8c7unrw/wals/0000000100000000/000000010000000000000005.00000028.backup",
  "pg-primary-cnpg-r8c7unrw/wals/0000000100000000/000000010000000000000006",
  "pg-primary-cnpg-r8c7unrw/wals/0000000100000000/000000010000000000000007",
  "pg-primary-cnpg-r8c7unrw/wals/0000000100000000/000000010000000000000008",
  "pg-primary-cnpg-r8c7unrw/wals/0000000100000000/000000010000000000000009"
]

Memulihkan cadangan sesuai permintaan ke kluster PostgreSQL baru

Di bagian ini, Anda memulihkan cadangan sesuai permintaan yang Anda buat sebelumnya menggunakan operator CNPG ke instans baru menggunakan Bootstrap Cluster CRD. Kluster instans tunggal digunakan untuk kesederhanaan. Ingatlah bahwa identitas beban kerja AKS (melalui CNPG inheritFromAzureAD) mengakses file cadangan, dan bahwa nama kluster pemulihan digunakan untuk menghasilkan akun layanan Kubernetes baru khusus untuk kluster pemulihan.

Anda juga membuat kredensial federasi kedua untuk memetakan akun layanan kluster pemulihan baru ke UAMI yang sudah ada yang memiliki akses sebagai "Kontributor Data Blob Penyimpanan" ke file cadangan di penyimpanan blob.

Buat kredensial identitas federasi kedua menggunakan az identity federated-credential create perintah .

export PG_PRIMARY_CLUSTER_NAME_RECOVERED="$PG_PRIMARY_CLUSTER_NAME-recovered-db"

az identity federated-credential create \
    --name $PG_PRIMARY_CLUSTER_NAME_RECOVERED \
    --identity-name $AKS_UAMI_CLUSTER_IDENTITY_NAME \
    --resource-group $RESOURCE_GROUP_NAME \
    --issuer "${AKS_PRIMARY_CLUSTER_OIDC_ISSUER}" \
    --subject system:serviceaccount:"${PG_NAMESPACE}":"${PG_PRIMARY_CLUSTER_NAME_RECOVERED}" \
    --audience api://AzureADTokenExchange

Pulihkan cadangan sesuai permintaan menggunakan Cluster CRD dengan kubectl apply perintah .

cat <<EOF | kubectl apply --context $AKS_PRIMARY_CLUSTER_NAME --namespace $PG_NAMESPACE -v 9 -f -
apiVersion: postgresql.cnpg.io/v1
kind: Cluster
metadata:
  name: $PG_PRIMARY_CLUSTER_NAME_RECOVERED
spec:

  inheritedMetadata:
    annotations:
      service.beta.kubernetes.io/azure-dns-label-name: $AKS_PRIMARY_CLUSTER_PG_DNSPREFIX
    labels:
      azure.workload.identity/use: "true"

  instances: 1

  affinity:
    nodeSelector:
      workload: postgres

  # Point to cluster backup created earlier and stored on Azure Blob Storage
  bootstrap:
    recovery:
      source: clusterBackup

  storage:
    size: 2Gi
    pvcTemplate:
      accessModes:
        - ReadWriteOnce
      resources:
        requests:
          storage: 2Gi
      storageClassName: managed-csi-premium
      volumeMode: Filesystem

  walStorage:
    size: 2Gi
    pvcTemplate:
      accessModes:
        - ReadWriteOnce
      resources:
        requests:
          storage: 2Gi
      storageClassName: managed-csi-premium
      volumeMode: Filesystem

  serviceAccountTemplate:
    metadata:
      annotations:
        azure.workload.identity/client-id: "$AKS_UAMI_WORKLOAD_CLIENTID"
      labels:
        azure.workload.identity/use: "true"

  externalClusters:
    - name: clusterBackup
      barmanObjectStore:
        destinationPath: https://${PG_PRIMARY_STORAGE_ACCOUNT_NAME}.blob.core.windows.net/backups
        serverName: $PG_PRIMARY_CLUSTER_NAME
        azureCredentials:
          inheritFromAzureAD: true
        wal:
          maxParallel: 8
EOF

Sambungkan ke instans yang dipulihkan, lalu validasi bahwa himpunan data yang dibuat pada kluster asli tempat pencadangan penuh diambil ada menggunakan perintah berikut:
```
kubectl cnpg psql $PG_PRIMARY_CLUSTER_NAME_RECOVERED --namespace $PG_NAMESPACE
```
```
SELECT COUNT(*) FROM datasample;
```
Contoh output
```
 count
-------
     3
(1 row)

Type \q to exit psql
```

Hapus kluster yang dipulihkan menggunakan perintah berikut:

kubectl cnpg destroy $PG_PRIMARY_CLUSTER_NAME_RECOVERED 1 \
    --context $AKS_PRIMARY_CLUSTER_NAME \
    --namespace $PG_NAMESPACE

Hapus kredensial identitas federasi menggunakan az identity federated-credential delete perintah .

az identity federated-credential delete \
    --name $PG_PRIMARY_CLUSTER_NAME_RECOVERED \
    --identity-name $AKS_UAMI_CLUSTER_IDENTITY_NAME \
    --resource-group $RESOURCE_GROUP_NAME \
    --yes

Mengekspos kluster PostgreSQL menggunakan load balancer publik

Di bagian ini, Anda mengonfigurasi infrastruktur yang diperlukan untuk membuka akses publik ke titik akhir baca-tulis dan baca-saja PostgreSQL dengan pembatasan sumber IP yang hanya memungkinkan akses dari alamat IP publik stasiun kerja klien Anda.

Anda juga mengambil endpoint berikut dari layanan IP Cluster.

Satu titik akhir baca-tulis utama yang berakhir dengan *-rw.
Nol hingga N (tergantung pada jumlah replika) titik akhir baca-saja yang diakhir dengan *-ro.
Satu titik akhir replikasi yang diakhiri dengan *-r.

Dapatkan detail layanan IP Kluster menggunakan kubectl get perintah .
```
kubectl get services \
    --context $AKS_PRIMARY_CLUSTER_NAME \
    --namespace $PG_NAMESPACE \
    -l cnpg.io/cluster=$PG_PRIMARY_CLUSTER_NAME
```
Contoh output
```
NAME                          TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)    AGE
pg-primary-cnpg-sryti1qf-r    ClusterIP   10.0.193.27    <none>        5432/TCP   3h57m
pg-primary-cnpg-sryti1qf-ro   ClusterIP   10.0.237.19    <none>        5432/TCP   3h57m
pg-primary-cnpg-sryti1qf-rw   ClusterIP   10.0.244.125   <none>        5432/TCP   3h57m
```
Nota

Ada tiga layanan: namespace/cluster-name-ro dipetakan ke port 5433, namespace/cluster-name-rw, dan namespace/cluster-name-r dipetakan ke port 5433. Penting untuk menghindari penggunaan port yang sama dengan node baca/tulis kluster database PostgreSQL. Jika Anda ingin aplikasi hanya mengakses replika baca-saja dari kluster database PostgreSQL, arahkan ke port 5433. Layanan akhir biasanya digunakan untuk pencadangan data tetapi juga dapat berfungsi sebagai simpul baca-saja.

Dapatkan detail layanan menggunakan kubectl get perintah .

export PG_PRIMARY_CLUSTER_RW_SERVICE=$(kubectl get services \
    --namespace $PG_NAMESPACE \
    --context $AKS_PRIMARY_CLUSTER_NAME \
    -l "cnpg.io/cluster" \
    --output json | jq -r '.items[] | select(.metadata.name | endswith("-rw")) | .metadata.name')

echo $PG_PRIMARY_CLUSTER_RW_SERVICE

export PG_PRIMARY_CLUSTER_RO_SERVICE=$(kubectl get services \
    --namespace $PG_NAMESPACE \
    --context $AKS_PRIMARY_CLUSTER_NAME \
    -l "cnpg.io/cluster" \
    --output json | jq -r '.items[] | select(.metadata.name | endswith("-ro")) | .metadata.name')

echo $PG_PRIMARY_CLUSTER_RO_SERVICE

Konfigurasikan layanan load balancer dengan file YAML berikut menggunakan kubectl apply perintah .

cat <<EOF | kubectl apply --context $AKS_PRIMARY_CLUSTER_NAME -f -
apiVersion: v1
kind: Service
metadata:
  annotations:
    service.beta.kubernetes.io/azure-load-balancer-resource-group: $AKS_PRIMARY_CLUSTER_NODERG_NAME
    service.beta.kubernetes.io/azure-pip-name: $AKS_PRIMARY_CLUSTER_PUBLICIP_NAME
    service.beta.kubernetes.io/azure-dns-label-name: $AKS_PRIMARY_CLUSTER_PG_DNSPREFIX
  name: cnpg-cluster-load-balancer-rw
  namespace: "${PG_NAMESPACE}"
spec:
  type: LoadBalancer
  ports:
  - protocol: TCP
    port: 5432
    targetPort: 5432
  selector:
    cnpg.io/instanceRole: primary
    cnpg.io/podRole: instance
  loadBalancerSourceRanges:
  - "$MY_PUBLIC_CLIENT_IP/32"
EOF

cat <<EOF | kubectl apply --context $AKS_PRIMARY_CLUSTER_NAME -f -
apiVersion: v1
kind: Service
metadata:
  annotations:
    service.beta.kubernetes.io/azure-load-balancer-resource-group: $AKS_PRIMARY_CLUSTER_NODERG_NAME
    service.beta.kubernetes.io/azure-pip-name: $AKS_PRIMARY_CLUSTER_PUBLICIP_NAME
    service.beta.kubernetes.io/azure-dns-label-name: $AKS_PRIMARY_CLUSTER_PG_DNSPREFIX
  name: cnpg-cluster-load-balancer-ro
  namespace: "${PG_NAMESPACE}"
spec:
  type: LoadBalancer
  ports:
  - protocol: TCP
    port: 5433
    targetPort: 5432
  selector:
    cnpg.io/instanceRole: replica
    cnpg.io/podRole: instance
  loadBalancerSourceRanges:
  - "$MY_PUBLIC_CLIENT_IP/32"
EOF

Dapatkan detail layanan menggunakan kubectl describe perintah .

kubectl describe service cnpg-cluster-load-balancer-rw \
    --context $AKS_PRIMARY_CLUSTER_NAME \
    --namespace $PG_NAMESPACE

kubectl describe service cnpg-cluster-load-balancer-ro \
    --context $AKS_PRIMARY_CLUSTER_NAME \
    --namespace $PG_NAMESPACE

export AKS_PRIMARY_CLUSTER_ALB_DNSNAME="$(az network public-ip show \
    --resource-group $AKS_PRIMARY_CLUSTER_NODERG_NAME \
    --name $AKS_PRIMARY_CLUSTER_PUBLICIP_NAME \
    --query "dnsSettings.fqdn" --output tsv)"

echo $AKS_PRIMARY_CLUSTER_ALB_DNSNAME

Memvalidasi titik akhir PostgreSQL publik

Di bagian ini, Anda memvalidasi bahwa Azure Load Balancer telah disiapkan dengan benar, menggunakan IP statis yang Anda buat sebelumnya untuk merutekan koneksi ke replika utama baca-tulis dan baca-saja, dan menggunakan CLI psql untuk menyambungkan ke keduanya.

Ingat bahwa endpoint utama baca-tulis dipetakan ke port TCP 5432 dan endpoint replika baca-saja dipetakan ke port 5433 sehingga memungkinkan penggunaan nama DNS PostgreSQL yang sama untuk baca dan tulis.

Nota

Anda memerlukan nilai kata sandi pengguna aplikasi untuk autentikasi dasar PostgreSQL yang dihasilkan sebelumnya dan disimpan dalam $PG_DATABASE_APPUSER_SECRET variabel lingkungan.

Validasi endpoint publik PostgreSQL menggunakan perintah berikut psql :

echo "Public endpoint for PostgreSQL cluster: $AKS_PRIMARY_CLUSTER_ALB_DNSNAME"

# Query the primary, pg_is_in_recovery = false

psql -h $AKS_PRIMARY_CLUSTER_ALB_DNSNAME \
    -p 5432 -U app -d appdb -W -c "SELECT pg_is_in_recovery();"

Contoh output

pg_is_in_recovery
-------------------
 f
(1 row)

echo "Query a replica, pg_is_in_recovery = true"

psql -h $AKS_PRIMARY_CLUSTER_ALB_DNSNAME \
    -p 5433 -U app -d appdb -W -c "SELECT pg_is_in_recovery();"

Contoh output

# Example output

pg_is_in_recovery
-------------------
t
(1 row)

Ketika berhasil tersambung ke titik akhir baca-tulis utama, fungsi PostgreSQL mengembalikan f untuk false, yang menunjukkan bahwa koneksi saat ini dapat ditulis.

Saat tersambung ke replika, fungsi mengembalikan tuntuk true, menunjukkan database dalam pemulihan dan hanya bisa dibaca.

Mensimulasikan failover yang tidak direncanakan

Di bagian ini, Anda memicu kegagalan mendadak dengan menghapus pod yang menjalankan primer, yang mensimulasikan crash mendadak atau hilangnya konektivitas jaringan ke node yang menghosting primer PostgreSQL.

Periksa status instans pod yang sedang berjalan menggunakan perintah berikut:

kubectl cnpg status $PG_PRIMARY_CLUSTER_NAME --namespace $PG_NAMESPACE

Contoh output

Name                        Current LSN Rep role        Status  Node
--------------------------- ----------- --------        ------- -----------
pg-primary-cnpg-sryti1qf-1  0/9000060   Primary         OK      aks-postgres-32388626-vmss000000
pg-primary-cnpg-sryti1qf-2  0/9000060   Standby (sync)  OK      aks-postgres-32388626-vmss000001
pg-primary-cnpg-sryti1qf-3  0/9000060   Standby (sync)  OK      aks-postgres-32388626-vmss000002

Hapus pod utama menggunakan kubectl delete perintah .

PRIMARY_POD=$(kubectl get pod \
    --namespace $PG_NAMESPACE \
    --no-headers \
    -o custom-columns=":metadata.name" \
    -l role=primary)

kubectl delete pod $PRIMARY_POD --grace-period=1 --namespace $PG_NAMESPACE

Pastikan bahwa pg-primary-cnpg-sryti1qf-2 instans pod sekarang menjadi sebagai utama menggunakan perintah berikut:

kubectl cnpg status $PG_PRIMARY_CLUSTER_NAME --namespace $PG_NAMESPACE

Contoh output

pg-primary-cnpg-sryti1qf-2  0/9000060   Primary         OK      aks-postgres-32388626-vmss000001
pg-primary-cnpg-sryti1qf-1  0/9000060   Standby (sync)  OK      aks-postgres-32388626-vmss000000
pg-primary-cnpg-sryti1qf-3  0/9000060   Standby (sync)  OK      aks-postgres-32388626-vmss000002

Reset pg-primary-cnpg-sryti1qf-1 instans pod sebagai utama menggunakan perintah berikut:
```
kubectl cnpg promote $PG_PRIMARY_CLUSTER_NAME 1 --namespace $PG_NAMESPACE
```

Validasi bahwa instans pod telah kembali ke status aslinya sebelum pengujian failover yang tidak direncanakan menggunakan perintah berikut:

kubectl cnpg status $PG_PRIMARY_CLUSTER_NAME --namespace $PG_NAMESPACE

Contoh output

Name                        Current LSN Rep role        Status  Node
--------------------------- ----------- --------        ------- -----------
pg-primary-cnpg-sryti1qf-1  0/9000060   Primary         OK      aks-postgres-32388626-vmss000000
pg-primary-cnpg-sryti1qf-2  0/9000060   Standby (sync)  OK      aks-postgres-32388626-vmss000001
pg-primary-cnpg-sryti1qf-3  0/9000060   Standby (sync)  OK      aks-postgres-32388626-vmss000002

Membersihkan sumber daya

Setelah selesai meninjau penyebaran, hapus semua sumber daya yang Anda buat dalam panduan ini dengan menggunakan perintah az group delete.
```
az group delete --resource-group $RESOURCE_GROUP_NAME --no-wait --yes
```

Langkah berikutnya

Dalam panduan ini, Anda mempelajari cara:

Gunakan Azure CLI untuk membuat kluster AKS multi-zona.
Sebarkan kluster dan database PostgreSQL yang sangat tersedia menggunakan operator CNPG.
Siapkan pemantauan untuk PostgreSQL menggunakan Prometheus dan Grafana.
Sebarkan himpunan data sampel ke database PostgreSQL.
Simulasikan gangguan kluster dan failover replika PostgreSQL.
Lakukan pencadangan dan pemulihan database PostgreSQL.

Untuk mempelajari selengkapnya tentang bagaimana Anda dapat menggunakan AKS untuk beban kerja Anda, lihat Apa itu Azure Kubernetes Service (AKS)? Untuk mempelajari selengkapnya tentang Azure Database for PostgreSQL, lihat Apa itu Azure Database for PostgreSQL?

Kontributor

Microsoft mempertahankan artikel ini. Kontributor berikut awalnya menulisnya:

Ken Kilty | TPM Utama
Russell de Pina | TPM Utama
Adrian Joian | Insinyur Pelanggan Senior
Jenny Hayes | Pengembang Konten Senior
Carol Smith | Pengembang Konten Senior
Erin Schaffer | Pengembang Konten 2
Adam Sharif | Teknisi Pelanggan 2

Pengakuan

Dokumentasi ini dikembangkan bersama dengan EnterpriseDB, pengurus operator CloudNativePG. Kami berterima kasih kepada Gabriele Bartolini yang telah meninjau draf sebelumnya dari dokumen ini dan menawarkan peningkatan teknis.

Saran dan Komentar

Apakah halaman ini membantu?

Terakhir diperbarui pada 2025-11-09

Memvalidasi dan menguji penyebaran database PostgreSQL di Azure Kubernetes Service (AKS)

Memeriksa kluster PostgreSQL yang disebarkan

Menyambungkan ke PostgreSQL dan membuat himpunan data sampel

Sambungkan ke Replika Baca-Saja PostgreSQL

Menyiapkan cadangan PostgreSQL sesuai permintaan dan terjadwal menggunakan Barman

Memulihkan cadangan sesuai permintaan ke kluster PostgreSQL baru

Mengekspos kluster PostgreSQL menggunakan load balancer publik

Memvalidasi titik akhir PostgreSQL publik

Mensimulasikan failover yang tidak direncanakan

Membersihkan sumber daya

Langkah berikutnya

Kontributor

Pengakuan

Saran dan Komentar

Sumber Daya Tambahan: