Ověření a otestování nasazení databáze PostgreSQL ve službě Azure Kubernetes Service (AKS)

V tomto článku provedete různé kroky testování a ověření databáze PostgreSQL nasazené v AKS. To zahrnuje ověření nasazení, připojení k databázi a testování scénářů převzetí služeb při selhání.

Pokud jste postgreSQL ještě nenasadili, postupujte podle kroků v tématu Nasazení vysoce dostupné databáze PostgreSQL v AKS pomocí Azure CLI a pak se můžete vrátit k tomuto článku.

Důležité

Opensourcový software je zmíněn v dokumentaci a ukázkách AKS. Software, který nasadíte, je vyloučený ze smluv o úrovni služeb AKS, omezené záruky a podpora Azure. Při používání opensourcových technologií společně s AKS se obraťte na možnosti podpory, které jsou k dispozici v příslušných komunitách a správci projektů, a vytvořte plán.

Microsoft zodpovídá za vytváření opensourcových balíčků, které nasazujeme v AKS. Tato odpovědnost zahrnuje úplnou zodpovědnost za proces sestavení, skenu, podepisování, ověřování a hotfixů spolu s kontrolou nad binárními soubory v obrazech kontejneru. Další informace najdete v tématu Řízení zranitelností pro AKS a Podpora pro AKS a rozsah pokrytí.

Kontrola nasazeného clusteru PostgreSQL

Ověřte, že je PostgreSQL rozložený do více zón dostupnosti, a to načtením podrobností o uzlu AKS pomocí kubectl get příkazu.

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"}'

Výstup by měl vypadat podobně jako v následujícím příkladu výstupu se zónou dostupnosti zobrazenou pro každý uzel:

{
    "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"
}

Připojení k PostgreSQL a vytvoření ukázkové datové sady

V této části vytvoříte tabulku a vložíte některá data do databáze aplikace, která byla vytvořena v clusteru CNPG, který jste nasadili dříve. Tato data použijete k ověření operací zálohování a obnovení clusteru PostgreSQL.

Vytvořte tabulku a vložte data do databáze aplikace pomocí následujících příkazů:

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;

Pro ukončení psql zadejte \q po dokončení.

Výstup by měl vypadat podobně jako v následujícím příkladu výstupu:

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

Připojte se k replikám PostgreSQL jen pro čtení

Připojte se k replikám jen pro čtení PostgreSQL a pomocí následujících příkazů ověřte ukázkovou datovou sadu:

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

SELECT pg_is_in_recovery();

Příklad výstupu

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

SELECT COUNT(*) FROM datasample;

Příklad výstupu

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

Nastavení zálohování PostgreSQL na vyžádání a plánované pomocí Barmanu

Poznámka:

Očekává se, že CloudNativePG vyřadí nativní podporu Barman Cloudu ve prospěch modulu plug-in Barman Cloud v nadcházející verzi 1.29. Kroky v této příručce budou fungovat i dnes, ale jakmile se stabilizuje, naplánujte migraci na modul plug-in.

Ověřte, že cluster PostgreSQL má přístup k účtu úložiště Azure zadanému v CRD Clusteru CNPG a že Working WAL archiving se hlásí jako OK pomocí následujícího příkazu:

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

Příklad výstupu

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:                -

Nasaďte zálohu na vyžádání do služby Azure Storage, která používá integraci identity úloh AKS pomocí souboru YAML s příkazem 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

Ověřte stav zálohování na vyžádání pomocí příkazu kubectl describe.

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

Příklad výstupu

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

Pomocí následujícího příkazu ověřte, že cluster má první bod obnovení:

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

Příklad výstupu

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

Nakonfigurujte naplánované zálohování pro každou hodinu v 15 minut pomocí souboru YAML a příkazu .

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

Pomocí příkazu ověřte stav plánovaného zálohování kubectl describe .

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

Pomocí příkazu zobrazte záložní soubory uložené v úložišti objektů blob v Azure pro primární cluster az storage blob list .

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

Výstup by měl vypadat podobně jako v následujícím příkladu výstupu a ověření zálohování proběhlo úspěšně:

[
  "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"
]

Obnovení zálohy na vyžádání do nového clusteru PostgreSQL

V této části obnovíte zálohu na vyžádání, kterou jste vytvořili dříve, pomocí operátoru CNPG do nové instance pomocí bootstrap Cluster CRD. Pro zjednodušení se používá jeden cluster instancí. Nezapomeňte, že identita úlohy AKS (prostřednictvím CNPG inheritFromAzureAD) přistupuje k záložním souborům a že název obnovovacího clusteru se používá k vygenerování nového účtu služby Kubernetes specifického pro obnovovací cluster.

Vytvoříte také druhé federované pověření, které propojí nový účet služeb obnovy s existujícím UAMI, který má roli "Přispěvatel dat úložiště objektů blob" pro záložní soubory v blob úložišti.

Pomocí příkazu az identity federated-credential create vytvořte druhý doklad federované identity.

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

Obnovte zálohu na vyžádání pomocí Cluster CRD s příkazem kubectl apply.

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

Připojte se k obnovené instanci a poté ověřte, že je přítomna datová sada vytvořená na původním clusteru, kde byla provedena úplná záloha, pomocí následujícího příkazu:
```
kubectl cnpg psql $PG_PRIMARY_CLUSTER_NAME_RECOVERED --namespace $PG_NAMESPACE
```
```
SELECT COUNT(*) FROM datasample;
```
Příklad výstupu
```
 count
-------
     3
(1 row)

Type \q to exit psql
```

Pomocí následujícího příkazu odstraňte obnovený cluster:

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

Odstraňte přihlašovací údaje federované identity pomocí příkazu az identity federated-credential delete.

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

Zveřejnění clusteru PostgreSQL pomocí veřejného nástroje pro vyrovnávání zatížení

V této části nakonfigurujete potřebnou infrastrukturu tak, abyste veřejně zpřístupnili koncové body PostgreSQL pro čtení a zápis a pouze pro čtení s omezeními zdroje IP adresy na veřejnou IP adresu vaší klientské pracovní stanice.

Ze služby IP clusteru také načtete následující koncové body:

Jeden primární koncový bod pro čtení i zápis, který končí *-rw.
Nula až N (v závislosti na počtu replik) koncových bodů pouze pro čtení, které končí *-ro.
Jeden koncový bod replikace, který končí na *-r.

Pomocí příkazu získejte podrobnosti o službě IP clusteru kubectl get .
```
kubectl get services \
    --context $AKS_PRIMARY_CLUSTER_NAME \
    --namespace $PG_NAMESPACE \
    -l cnpg.io/cluster=$PG_PRIMARY_CLUSTER_NAME
```
Příklad výstupu
```
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
```
Poznámka:

Existují tři služby: namespace/cluster-name-ro namapované na port 5433 namespace/cluster-name-rwa namespace/cluster-name-r mapované na port 5433. Je důležité se vyhnout použití stejného portu jako uzel pro čtení a zápis databázového clusteru PostgreSQL. Pokud chcete, aby aplikace přistupovaly pouze k replice databáze PostgreSQL jen pro čtení, nasměrujte je na port 5433. Konečná služba se obvykle používá pro zálohy dat, ale může také fungovat jako uzel jen pro čtení.

Pomocí příkazu získejte podrobnosti o službě kubectl get .

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

Pomocí příkazu nakonfigurujte službu nástroje pro vyrovnávání zatížení s následujícími soubory kubectl apply YAML.

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

Pomocí příkazu získejte podrobnosti o službě kubectl describe .

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

Ověření veřejných koncových bodů PostgreSQL

V této části ověříte, že je Azure Load Balancer správně nastavený pomocí statické IP adresy, kterou jste vytvořili dříve. Zkontrolujete směrování připojení na primární repliky pro čtení a zápis a na repliky pouze pro čtení. Nakonec se pomocí psql připojte k oběma typům replik.

Nezapomeňte, že primární koncový bod pro čtení i zápis se mapuje na port TCP 5432 a koncové body repliky jen pro čtení na port 5433, aby se pro čtenáře a zapisovače používal stejný název DNS PostgreSQL.

Poznámka:

Potřebujete hodnotu uživatelského hesla aplikace pro základní ověřování PostgreSQL, která byla vygenerována dříve a uložena v $PG_DATABASE_APPUSER_SECRET proměnné prostředí.

Pomocí následujících psql příkazů ověřte veřejné koncové body PostgreSQL:

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();"

Příklad výstupu

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();"

Příklad výstupu

# Example output

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

Po úspěšném připojení k primárnímu koncovému bodu pro čtení a zápis vrátí funkce PostgreSQL f jako false, což znamená, že současné připojení je zapisovatelné.

Když je funkce připojená k replice, vrátí thodnotu true, což znamená, že databáze je v obnovení a jen pro čtení.

Simulace neplánovaného selhání systému

V této části aktivujete náhlé selhání serveru odstraněním podu, na kterém běží primární server, což simuluje náhlý pád nebo ztrátu síťového připojení k uzlu, který hostuje primární server PostgreSQL.

Pomocí následujícího příkazu zkontrolujte stav spuštěných instancí podů:

kubectl cnpg status $PG_PRIMARY_CLUSTER_NAME --namespace $PG_NAMESPACE

Příklad výstupu

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

Odstraňte primární pod pomocí příkazu kubectl delete.

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

Pomocí následujícího příkazu ověřte, že pg-primary-cnpg-sryti1qf-2 je instance podu primární:

kubectl cnpg status $PG_PRIMARY_CLUSTER_NAME --namespace $PG_NAMESPACE

Příklad výstupu

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

Pomocí následujícího příkazu obnovte instanci podu pg-primary-cnpg-sryti1qf-1 jako primární:
```
kubectl cnpg promote $PG_PRIMARY_CLUSTER_NAME 1 --namespace $PG_NAMESPACE
```

Pomocí následujícího příkazu ověřte, že se instance podů vrátily do svého původního stavu před provedením neplánovaného testu převzetí služeb při selhání:

kubectl cnpg status $PG_PRIMARY_CLUSTER_NAME --namespace $PG_NAMESPACE

Příklad výstupu

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

Čištění zdrojů

Jakmile dokončíte kontrolu nasazení, použijte příkaz az group delete k odstranění všech prostředků, které jste vytvořili v této příručce.
```
az group delete --resource-group $RESOURCE_GROUP_NAME --no-wait --yes
```

Další kroky

V tomto průvodci postupy jste se naučili:

Pomocí Azure CLI vytvořte cluster AKS s více zónami.
Nasaďte vysoce dostupný cluster a databázi PostgreSQL pomocí operátoru CNPG.
Nastavení monitorování pro PostgreSQL pomocí Prometheus a Grafany
Nasaďte ukázkovou datovou sadu do databáze PostgreSQL.
Simulujte přerušení clusteru a přepnutí na záložní replikaci PostgreSQL při selhání.
Proveďte zálohování a obnovení databáze PostgreSQL.

Další informace o tom, jak můžete používat AKS pro vaše úlohy, najdete v tématu Co je Azure Kubernetes Service (AKS)? Další informace o službě Azure Database for PostgreSQL najdete v tématu Co je Azure Database for PostgreSQL?

Přispěvatelé

Microsoft udržuje tento článek. Následující přispěvatelé ho původně napsali:

Ken Kilty | Vedoucí odborný manažer TPM
Russell de Pina | Hlavní technický projektový manažer
Adrian Joian | Vedoucí zákaznický inženýr
Jenny Hayes | Vedoucí vývojář obsahu
Carol Smith | Vedoucí vývojář obsahu
Erin Schaffer | Content Developer 2
Adam Sharif | Inženýr zákaznické podpory 2

Uznání

Tato dokumentace byla společně vyvinuta s EnterpriseDB, správci operátoru CloudNativePG. Děkujeme Gabriele Bartolini za revizi dřívějších konceptů tohoto dokumentu a za nabízená technická vylepšení.

Váš názor

Byla tato stránka užitečná?

Last updated on 2025-11-09

Sdílet prostřednictvím

Ověření a otestování nasazení databáze PostgreSQL ve službě Azure Kubernetes Service (AKS)

Kontrola nasazeného clusteru PostgreSQL

Připojení k PostgreSQL a vytvoření ukázkové datové sady

Připojte se k replikám PostgreSQL jen pro čtení

Nastavení zálohování PostgreSQL na vyžádání a plánované pomocí Barmanu

Obnovení zálohy na vyžádání do nového clusteru PostgreSQL

Zveřejnění clusteru PostgreSQL pomocí veřejného nástroje pro vyrovnávání zatížení

Ověření veřejných koncových bodů PostgreSQL

Simulace neplánovaného selhání systému

Čištění zdrojů

Další kroky

Přispěvatelé

Uznání

Váš názor

Další materiály