Tworzenie infrastruktury na potrzeby wdrażania bazy danych PostgreSQL o wysokiej dostępności w usłudze Azure Kubernetes Service (AKS)

W tym artykule utworzysz zasoby infrastruktury potrzebne do wdrożenia bazy danych PostgreSQL o wysokiej dostępności w usłudze AKS przy użyciu operatora CloudNativePG (CNPG).

Ważne

Oprogramowanie typu open source jest wymienione w dokumentacji i przykładach usługi AKS. Oprogramowanie, które wdrażasz, jest wykluczone z umów dotyczących poziomu usług AKS, ograniczonej gwarancji i wsparcia technicznego Azure. W miarę korzystania z technologii open source wraz z usługą AKS zapoznaj się z opcjami pomocy technicznej dostępnymi w odpowiednich społecznościach i opiekunami projektów, aby opracować plan.

Firma Microsoft ponosi odpowiedzialność za tworzenie pakietów typu open source wdrażanych w usłudze AKS. Ta odpowiedzialność obejmuje posiadanie pełnej kontroli nad procesem kompilacji, skanowania, podpisywania, weryfikacji i szybkich poprawek, a także nad plikami binarnymi w obrazach kontenerów. Aby uzyskać więcej informacji, zobacz zarządzanie podatnościami dla AKS i zakres wsparcia dla AKS.

Zanim rozpoczniesz

Zapoznaj się z omówieniem wdrożenia i upewnij się, że zostały spełnione wszystkie wymagania wstępne w temacie Jak wdrożyć bazę danych PostgreSQL o wysokiej dostępności w usłudze AKS przy użyciu interfejsu wiersza polecenia platformy Azure.
Ustaw zmienne środowiskowe do użycia w tym przewodniku.
Zainstaluj wymagane rozszerzenia.

Ustawianie zmiennych środowiskowych

Ustaw następujące zmienne środowiskowe do użycia w tym przewodniku:

export SUFFIX=$(cat /dev/urandom | LC_ALL=C tr -dc 'a-z0-9' | fold -w 8 | head -n 1)
export LOCAL_NAME="cnpg"
export TAGS="owner=user"
export RESOURCE_GROUP_NAME="rg-${LOCAL_NAME}-${SUFFIX}"
export PRIMARY_CLUSTER_REGION="canadacentral"
export AKS_PRIMARY_CLUSTER_NAME="aks-primary-${LOCAL_NAME}-${SUFFIX}"
export AKS_PRIMARY_MANAGED_RG_NAME="rg-${LOCAL_NAME}-primary-aksmanaged-${SUFFIX}"
export AKS_PRIMARY_CLUSTER_FED_CREDENTIAL_NAME="pg-primary-fedcred1-${LOCAL_NAME}-${SUFFIX}"
export AKS_PRIMARY_CLUSTER_PG_DNSPREFIX=$(echo $(echo "a$(openssl rand -hex 5 | cut -c1-11)"))
export AKS_UAMI_CLUSTER_IDENTITY_NAME="mi-aks-${LOCAL_NAME}-${SUFFIX}"
export AKS_CLUSTER_VERSION="1.32"
export PG_NAMESPACE="cnpg-database"
export PG_SYSTEM_NAMESPACE="cnpg-system"
export PG_PRIMARY_CLUSTER_NAME="pg-primary-${LOCAL_NAME}-${SUFFIX}"
export PG_PRIMARY_STORAGE_ACCOUNT_NAME="hacnpgpsa${SUFFIX}"
export PG_STORAGE_BACKUP_CONTAINER_NAME="backups"
export MY_PUBLIC_CLIENT_IP=$(dig +short myip.opendns.com @resolver3.opendns.com)

Instalowanie wymaganych rozszerzeń

Zainstaluj rozszerzenia wymagane do integracji i monitorowania platformy Kubernetes:

az extension add --upgrade --name k8s-extension --yes
az extension add --upgrade --name amg --yes

Aby móc korzystać z kubectl, najpierw należy zainstalować Krew, a następnie zainstalować wtyczkę CNPG. Instalacje te umożliwiają zarządzanie operatorem PostgreSQL przy użyciu kolejnych poleceń.

(
    set -x; cd "$(mktemp -d)" &&
    OS="$(uname | tr '[:upper:]' '[:lower:]')" &&
    ARCH="$(uname -m | sed -e 's/x86_64/amd64/' -e 's/\(arm\)\(64\)\?.*/\1\2/' -e 's/aarch64$/arm64/')" &&
    KREW="krew-${OS}_${ARCH}" &&
    curl -fsSLO "https://github.com/kubernetes-sigs/krew/releases/latest/download/${KREW}.tar.gz" &&
    tar zxvf "${KREW}.tar.gz" &&
    ./"${KREW}" install krew
)

export PATH="${KREW_ROOT:-$HOME/.krew}/bin:$PATH"

kubectl krew install cnpg

Tworzenie grupy zasobów

Utwórz grupę zasobów do przechowywania zasobów, które tworzysz w tym przewodniku, używając polecenia az group create.

az group create \
    --name $RESOURCE_GROUP_NAME \
    --location $PRIMARY_CLUSTER_REGION \
    --tags $TAGS \
    --query 'properties.provisioningState' \
    --output tsv

Tworzenie tożsamości zarządzanej przypisanej przez użytkownika

W tej sekcji utworzysz tożsamość zarządzaną przypisaną przez użytkownika (UAMI), aby umożliwić usłudze CNPG PostgreSQL używanie tożsamości obciążenia usługi AKS w celu uzyskania dostępu do usługi Azure Blob Storage. Ta konfiguracja umożliwia klastrowi PostgreSQL w usłudze AKS łączenie się z usługą Azure Blob Storage bez sekretu.

Utwórz tożsamość zarządzaną przypisaną przez użytkownika przy użyciu az identity create polecenia .

AKS_UAMI_WI_IDENTITY=$(az identity create \
    --name $AKS_UAMI_CLUSTER_IDENTITY_NAME \
    --resource-group $RESOURCE_GROUP_NAME \
    --location $PRIMARY_CLUSTER_REGION \
    --output json)

Włącz tożsamość obciążenia AKS i utwórz konto usługi do wykorzystania w dalszej części tego przewodnika, używając następujących poleceń:

export AKS_UAMI_WORKLOAD_OBJECTID=$( \
    echo "${AKS_UAMI_WI_IDENTITY}" | jq -r '.principalId')
export AKS_UAMI_WORKLOAD_RESOURCEID=$( \
    echo "${AKS_UAMI_WI_IDENTITY}" | jq -r '.id')
export AKS_UAMI_WORKLOAD_CLIENTID=$( \
    echo "${AKS_UAMI_WI_IDENTITY}" | jq -r '.clientId')

echo "ObjectId: $AKS_UAMI_WORKLOAD_OBJECTID"
echo "ResourceId: $AKS_UAMI_WORKLOAD_RESOURCEID"
echo "ClientId: $AKS_UAMI_WORKLOAD_CLIENTID"

Identyfikator obiektu to unikatowy identyfikator dla identyfikatora klienta (znanego również jako identyfikator aplikacji), który jednoznacznie identyfikuje podmiot zabezpieczeń typu Aplikacja w dzierżawie Microsoft Entra ID. Identyfikator zasobu jest unikatowym identyfikatorem do zarządzania i lokalizowania zasobu na platformie Azure. Te wartości są wymagane do włączenia tożsamości obciążenia usługi AKS.

Operator CNPG automatycznie generuje konto usługi o nazwie postgres , które jest używane w dalszej części przewodnika w celu utworzenia poświadczeń federacyjnych, które umożliwiają dostęp OAuth z bazy danych PostgreSQL do usługi Azure Storage.

Utwórz konto przechowywania w regionie podstawowym

Utwórz konto magazynowania obiektów do przechowywania kopii zapasowych PostgreSQL w regionie podstawowym, używając polecenia az storage account create.

az storage account create \
    --name $PG_PRIMARY_STORAGE_ACCOUNT_NAME \
    --resource-group $RESOURCE_GROUP_NAME \
    --location $PRIMARY_CLUSTER_REGION \
    --sku Standard_ZRS \
    --kind StorageV2 \
    --query 'provisioningState' \
    --output tsv

Utwórz kontener magazynowy do przechowywania dzienników zapisu z wyprzedzeniem (WAL) oraz regularnych i zaplanowanych kopii zapasowych PostgreSQL, korzystając z polecenia az storage container create.
```
az storage container create \
    --name $PG_STORAGE_BACKUP_CONTAINER_NAME \
    --account-name $PG_PRIMARY_STORAGE_ACCOUNT_NAME \
    --auth-mode login
```
Przykładowe wyjście:
```
{
    "created": true
}
```
Uwaga

Jeśli wystąpi komunikat o błędzie: The request may be blocked by network rules of storage account. Please check network rule set using 'az storage account show -n accountname --query networkRuleSet'. If you want to change the default action to apply when no rule matches, please use 'az storage account update'. Upewnij się, że uprawnienia użytkownika są zweryfikowane dla usługi Azure Blob Storage i w razie potrzeby podnieś swoją rolę do Storage Blob Data Owner, używając podanych poleceń, a następnie ponownie spróbuj wykonać polecenie az storage container create.
```
export USER_ID=$(az ad signed-in-user show --query id --output tsv)

export STORAGE_ACCOUNT_PRIMARY_RESOURCE_ID=$(az storage account show \
    --name $PG_PRIMARY_STORAGE_ACCOUNT_NAME \
    --resource-group $RESOURCE_GROUP_NAME \
    --query "id" \
    --output tsv)

az role assignment list --scope $STORAGE_ACCOUNT_PRIMARY_RESOURCE_ID --output table

az role assignment create \
    --assignee-object-id $USER_ID \
    --assignee-principal-type User \
    --scope $STORAGE_ACCOUNT_PRIMARY_RESOURCE_ID \
    --role "Storage Blob Data Owner" \
    --output tsv
```

Przypisywanie kontroli dostępu opartej na rolach do konta magazynowego

Aby umożliwić tworzenie kopii zapasowych, klaster PostgreSQL musi odczytywać i zapisywać w magazynie obiektów. Klaster PostgreSQL działający na platformie AKS używa tożsamości obciążenia do uzyskania dostępu do konta magazynu za pośrednictwem parametru inheritFromAzureAD konfiguracji operatora CNPG.

Pobierz identyfikator zasobu podstawowego dla konta magazynu przy użyciu polecenia az storage account show.

export STORAGE_ACCOUNT_PRIMARY_RESOURCE_ID=$(az storage account show \
    --name $PG_PRIMARY_STORAGE_ACCOUNT_NAME \
    --resource-group $RESOURCE_GROUP_NAME \
    --query "id" \
    --output tsv)

echo $STORAGE_ACCOUNT_PRIMARY_RESOURCE_ID

Przypisz wbudowaną rolę platformy Azure "Współautor danych Blob Storage" do identyfikatora obiektu w zakresie identyfikatora zasobu konta magazynowego dla tożsamości zarządzanej każdego klastra AKS, używając polecenia az role assignment create.

az role assignment create \
    --role "Storage Blob Data Contributor" \
    --assignee-object-id $AKS_UAMI_WORKLOAD_OBJECTID \
    --assignee-principal-type ServicePrincipal \
    --scope $STORAGE_ACCOUNT_PRIMARY_RESOURCE_ID \
    --query "id" \
    --output tsv

Konfigurowanie infrastruktury monitorowania

W tej sekcji wdrożysz wystąpienie usługi Azure Managed Grafana, obszar roboczy usługi Azure Monitor i obszar roboczy usługi Azure Monitor Log Analytics, aby umożliwić monitorowanie klastra PostgreSQL. Odnośniki do utworzonej infrastruktury monitorowania są również przechowywane w celu wykorzystania jako dane wejściowe podczas procesu tworzenia klastra AKS w dalszej części przewodnika. Ukończenie tej sekcji może zająć trochę czasu.

Uwaga

Wystąpienia zarządzane przez platformę Azure Grafana i klastry usługi AKS są rozliczane niezależnie. Aby uzyskać więcej informacji o cenach, zobacz Cennik usługi Azure Managed Grafana.

Utwórz wystąpienie usługi Azure Managed Grafana przy użyciu polecenia az grafana create.

export GRAFANA_PRIMARY="grafana-${LOCAL_NAME}-${SUFFIX}"

export GRAFANA_RESOURCE_ID=$(az grafana create \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $GRAFANA_PRIMARY \
    --location $PRIMARY_CLUSTER_REGION \
    --zone-redundancy Enabled \
    --tags $TAGS \
    --query "id" \
    --output tsv)

echo $GRAFANA_RESOURCE_ID

Utwórz obszar roboczy usługi Azure Monitor przy użyciu az monitor account create polecenia .

export AMW_PRIMARY="amw-${LOCAL_NAME}-${SUFFIX}"

export AMW_RESOURCE_ID=$(az monitor account create \
    --name $AMW_PRIMARY \
    --resource-group $RESOURCE_GROUP_NAME \
    --location $PRIMARY_CLUSTER_REGION \
    --tags $TAGS \
    --query "id" \
    --output tsv)

echo $AMW_RESOURCE_ID

Utwórz obszar roboczy usługi Log Analytics w Azure Monitor przy użyciu polecenia az monitor log-analytics workspace create.

export ALA_PRIMARY="ala-${LOCAL_NAME}-${SUFFIX}"

export ALA_RESOURCE_ID=$(az monitor log-analytics workspace create \
    --resource-group $RESOURCE_GROUP_NAME \
    --workspace-name $ALA_PRIMARY \
    --location $PRIMARY_CLUSTER_REGION \
    --query "id" \
    --output tsv)

echo $ALA_RESOURCE_ID

Tworzenie klastra usługi AKS do hostowania klastra PostgreSQL

W tej sekcji utworzysz wielostrefowy klaster usługi AKS z pulą węzłów systemowych. Klaster AKS hostuje główną replikę klastra PostgreSQL i dwie repliki rezerwowe, z których każda przypisana jest do innej strefy dostępności, aby umożliwić zwiększenie niezawodności poprzez redundancję w strefach.

Do klastra usługi AKS można również dodać pulę węzłów użytkownika w celu hostowania klastra PostgreSQL. Użycie oddzielnej puli węzłów umożliwia kontrolę nad jednostkami SKU maszyn wirtualnych platformy Azure używanymi na potrzeby bazy danych PostgreSQL i umożliwia puli systemu AKS optymalizowanie wydajności i kosztów. Etykietę stosuje się do puli węzłów użytkownika, do której można odwoływać się do wyboru węzła podczas wdrażania operatora CNPG w dalszej części tego przewodnika. Ukończenie tej sekcji może zająć trochę czasu.

Ważne

Jeśli zdecydujesz się używać lokalnego dysku NVMe jako magazynu PostgreSQL w kolejnych częściach tego przewodnika, musisz wybrać jednostkę SKU maszyny wirtualnej, która obsługuje lokalne dyski NVMe, na przykład jednostki SKU maszyn wirtualnych zoptymalizowane pod kątem magazynu lub przyspieszone jednostki SKU maszyny wirtualnej z procesorem GPU. Odpowiednio zaktualizuj $USER_NODE_POOL_VMSKU .

Utwórz klaster AKS przy użyciu polecenia az aks create.

export SYSTEM_NODE_POOL_VMSKU="standard_d2s_v3"
export USER_NODE_POOL_NAME="postgres"
export USER_NODE_POOL_VMSKU="standard_d4s_v3"

az aks create \
    --name $AKS_PRIMARY_CLUSTER_NAME \
    --tags $TAGS \
    --resource-group $RESOURCE_GROUP_NAME \
    --location $PRIMARY_CLUSTER_REGION \
    --generate-ssh-keys \
    --node-resource-group $AKS_PRIMARY_MANAGED_RG_NAME \
    --enable-managed-identity \
    --assign-identity $AKS_UAMI_WORKLOAD_RESOURCEID \
    --network-plugin azure \
    --network-plugin-mode overlay \
    --network-dataplane cilium \
    --nodepool-name systempool \
    --enable-oidc-issuer \
    --enable-workload-identity \
    --enable-cluster-autoscaler \
    --min-count 2 \
    --max-count 3 \
    --node-vm-size $SYSTEM_NODE_POOL_VMSKU \
    --enable-azure-monitor-metrics \
    --azure-monitor-workspace-resource-id $AMW_RESOURCE_ID \
    --grafana-resource-id $GRAFANA_RESOURCE_ID \
    --api-server-authorized-ip-ranges $MY_PUBLIC_CLIENT_IP \
    --tier standard \
    --kubernetes-version $AKS_CLUSTER_VERSION \
    --zones 1 2 3 \
    --output table

Poczekaj na ukończenie początkowej operacji klastra za pomocą polecenia az aks wait, aby dodatkowe aktualizacje, takie jak dodawanie puli węzłów użytkownika, nie kolidowały z aktualizacją klastra zarządzanego w toku.
```
az aks wait \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $AKS_PRIMARY_CLUSTER_NAME \
    --created
```

Dodaj pulę węzłów użytkownika do klastra usługi AKS za pomocą polecenia az aks nodepool add.

az aks nodepool add \
    --resource-group $RESOURCE_GROUP_NAME \
    --cluster-name $AKS_PRIMARY_CLUSTER_NAME \
    --name $USER_NODE_POOL_NAME \
    --enable-cluster-autoscaler \
    --min-count 3 \
    --max-count 6 \
    --node-vm-size $USER_NODE_POOL_VMSKU \
    --zones 1 2 3 \
    --labels workload=postgres \
    --output table

Nawiązywanie połączenia z klastrem usługi AKS i tworzenie przestrzeni nazw

W tej sekcji uzyskasz poświadczenia klastra usługi AKS, które służą jako klucze, które umożliwiają uwierzytelnianie i interakcję z klastrem. Po nawiązaniu połączenia utworzysz dwie przestrzenie nazw: jedną dla usług menedżera kontrolera CNPG i jedną dla klastra PostgreSQL i powiązanych usług.

Pobierz poświadczenia klastra AKS za pomocą polecenia az aks get-credentials.

az aks get-credentials \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $AKS_PRIMARY_CLUSTER_NAME \
    --output none

Utwórz przestrzeń nazw dla usług menedżera kontrolera CNPG, klastra PostgreSQL i powiązanych z nią usług przy użyciu kubectl create namespace polecenia .
```
kubectl create namespace $PG_NAMESPACE --context $AKS_PRIMARY_CLUSTER_NAME
kubectl create namespace $PG_SYSTEM_NAMESPACE --context $AKS_PRIMARY_CLUSTER_NAME
```

Teraz możesz zdefiniować inną zmienną środowiskową na podstawie żądanej opcji magazynu, do której odwołujesz się w dalszej części przewodnika podczas wdrażania bazy danych PostgreSQL.

Możesz odwołać się do domyślnej wstępnie zainstalowanej klasy magazynu sterownika CSI dla dysków SSD Azure Premium:

export POSTGRES_STORAGE_CLASS="managed-csi-premium"

Aby użyć Premium SSD v2, możesz utworzyć niestandardową klasę magazynu.

Zdefiniuj nową klasę pamięci sterownika CSI.

cat <<EOF | kubectl apply --context $AKS_PRIMARY_CLUSTER_NAME -n $PG_NAMESPACE -v 9 -f -
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: premium2-disk-sc
parameters:
  cachingMode: None
  skuName: PremiumV2_LRS
  DiskIOPSReadWrite: "3500"
  DiskMBpsReadWrite: "125"
provisioner: disk.csi.azure.com
reclaimPolicy: Delete
volumeBindingMode: WaitForFirstConsumer
allowVolumeExpansion: true
EOF

export POSTGRES_STORAGE_CLASS="premium2-disk-sc"

Ważne

Upewnij się, że klaster korzysta z jednostek SKU maszyn wirtualnych obsługujących lokalne dyski NVMe, na przykład jednostki SKU maszyn wirtualnych zoptymalizowane pod kątem magazynu lub przyspieszone jednostki SKU maszyn wirtualnych z procesorem GPU. Poniższe instrukcje wymagają usługi Azure Container Storage w wersji 2.0.0 lub nowszej.

Zaktualizuj klaster usługi AKS, aby zainstalować usługę Azure Container Storage w puli węzłów użytkownika.

az aks update \
    --name $AKS_PRIMARY_CLUSTER_NAME \
    --resource-group $RESOURCE_GROUP_NAME \
    --enable-azure-container-storage

Użyj podanej klasy magazynu usługi Azure Container Storage.

cat <<EOF | kubectl apply -f -
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
    name: acstor-ephemeraldisk-nvme-db
provisioner: localdisk.csi.acstor.io
reclaimPolicy: Delete
volumeBindingMode: WaitForFirstConsumer
EOF

export POSTGRES_STORAGE_CLASS="acstor-ephemeraldisk-nvme-db"

Aktualizowanie infrastruktury monitorowania

Obszar roboczy usługi Azure Monitor dla zarządzanego rozwiązania Prometheus oraz usługi Azure Managed Grafana jest automatycznie połączony z klastrem AKS na potrzeby metryk i wizualizacji podczas procesu tworzenia klastra. W tej sekcji włączasz zbieranie dzienników za pomocą AKS Container Insights i sprawdzasz, czy Zarządzany Prometheus pobiera metryki, a informacje o kontenerach przetwarzają dzienniki.

Włącz monitorowanie Container Insights w klastrze AKS przy użyciu polecenia az aks enable-addons.

az aks enable-addons \
    --addon monitoring \
    --name $AKS_PRIMARY_CLUSTER_NAME \
    --resource-group $RESOURCE_GROUP_NAME \
    --workspace-resource-id $ALA_RESOURCE_ID \
    --output table

Zweryfikuj, czy zarządzany Prometheus zbiera metryki, a informacje o kontenerze pobierają dzienniki z klastra usługi AKS, sprawdzając element DaemonSet przy użyciu tych kubectl get polecenia i az aks show polecenia.

kubectl get ds ama-metrics-node \
    --context $AKS_PRIMARY_CLUSTER_NAME \
    --namespace=kube-system

kubectl get ds ama-logs \
    --context $AKS_PRIMARY_CLUSTER_NAME \
    --namespace=kube-system

az aks show \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $AKS_PRIMARY_CLUSTER_NAME \
    --query addonProfiles

Dane wyjściowe powinny przypominać następujące przykładowe dane wyjściowe, z sześcioma węzłami łącznie (trzy dla puli węzłów systemowych i trzy dla puli węzłów PostgreSQL) oraz szczegółowe informacje o kontenerze pokazujące "enabled": true.

NAME               DESIRED   CURRENT   READY   UP-TO-DATE   AVAILABLE   NODE SELECTOR
ama-metrics-node   6         6         6       6            6           <none>       

NAME               DESIRED   CURRENT   READY   UP-TO-DATE   AVAILABLE   NODE SELECTOR
ama-logs           6         6         6       6            6           <none>       

{
  "omsagent": {
    "config": {
      "logAnalyticsWorkspaceResourceID": "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/rg-cnpg-9vbin3p8/providers/Microsoft.OperationalInsights/workspaces/ala-cnpg-9vbin3p8",
      "useAADAuth": "true"
    },
    "enabled": true,
    "identity": null
  }
}

Utwórz publiczny statyczny adres IP dla ruchu do klastru PostgreSQL

Aby zweryfikować wdrożenie klastra PostgreSQL i użyć narzędzi klienta PostgreSQL, takich jak psql i PgAdmin, należy udostępnić repliki podstawowe i tylko do odczytu do ingresu. W tej sekcji utworzysz zasób publicznego adresu IP platformy Azure, który później zostanie udostępniony modułowi równoważenia obciążenia platformy Azure, aby uwidocznić punkty końcowe postgreSQL na potrzeby zapytań.

Pobierz nazwę grupy zasobów węzła klastra usługi AKS za pomocą polecenia az aks show.

export AKS_PRIMARY_CLUSTER_NODERG_NAME=$(az aks show \
    --name $AKS_PRIMARY_CLUSTER_NAME \
    --resource-group $RESOURCE_GROUP_NAME \
    --query nodeResourceGroup \
    --output tsv)

echo $AKS_PRIMARY_CLUSTER_NODERG_NAME

Utwórz publiczny adres IP przy użyciu az network public-ip create polecenia .

export AKS_PRIMARY_CLUSTER_PUBLICIP_NAME="$AKS_PRIMARY_CLUSTER_NAME-pip"

az network public-ip create \
    --resource-group $AKS_PRIMARY_CLUSTER_NODERG_NAME \
    --name $AKS_PRIMARY_CLUSTER_PUBLICIP_NAME \
    --location $PRIMARY_CLUSTER_REGION \
    --sku Standard \
    --zone 1 2 3 \
    --allocation-method static \
    --output table

Pobierz nowo utworzony publiczny adres IP przy użyciu az network public-ip show polecenia .

export AKS_PRIMARY_CLUSTER_PUBLICIP_ADDRESS=$(az network public-ip show \
    --resource-group $AKS_PRIMARY_CLUSTER_NODERG_NAME \
    --name $AKS_PRIMARY_CLUSTER_PUBLICIP_NAME \
    --query ipAddress \
    --output tsv)

echo $AKS_PRIMARY_CLUSTER_PUBLICIP_ADDRESS

Pobierz identyfikator zasobu grupy zasobów węzła przy użyciu polecenia az group show.

export AKS_PRIMARY_CLUSTER_NODERG_NAME_SCOPE=$(az group show --name \
    $AKS_PRIMARY_CLUSTER_NODERG_NAME \
    --query id \
    --output tsv)

echo $AKS_PRIMARY_CLUSTER_NODERG_NAME_SCOPE

Przypisz rolę "Współautor Sieci" do identyfikatora obiektu UAMI, korzystając z zakresu grupy zasobów węzła, za pomocą polecenia az role assignment create.

az role assignment create \
    --assignee-object-id ${AKS_UAMI_WORKLOAD_OBJECTID} \
    --assignee-principal-type ServicePrincipal \
    --role "Network Contributor" \
    --scope ${AKS_PRIMARY_CLUSTER_NODERG_NAME_SCOPE}

Zainstaluj operatora CNPG w klastrze AKS

W tej sekcji zainstalujesz operator CNPG w klastrze AKS przy użyciu Helm lub manifestu YAML.

Ster
YAML

Dodaj repozytorium programu Helm CNPG przy użyciu helm repo add polecenia .
```
helm repo add cnpg https://cloudnative-pg.github.io/charts
```

Zaktualizuj repozytorium Helm CNPG i zainstaluj je na klastrze AKS, używając polecenia helm upgrade z flagą --install.

helm upgrade --install cnpg \
    --namespace $PG_SYSTEM_NAMESPACE \
    --create-namespace \
    --kube-context=$AKS_PRIMARY_CLUSTER_NAME \
    cnpg/cloudnative-pg

Sprawdź instalację operatora w klastrze usługi AKS przy użyciu polecenia kubectl get.

kubectl get deployment \
    --context $AKS_PRIMARY_CLUSTER_NAME \
    --namespace $PG_SYSTEM_NAMESPACE cnpg-cloudnative-pg

Zainstaluj operatora CNPG w klastrze AKS przy użyciu polecenia kubectl apply.

kubectl apply --context $AKS_PRIMARY_CLUSTER_NAME \
    --namespace $PG_SYSTEM_NAMESPACE \
    --server-side -f \
    https://raw.githubusercontent.com/cloudnative-pg/cloudnative-pg/release-1.27/releases/cnpg-1.27.0.yaml

Sprawdź instalację operatora w klastrze usługi AKS przy użyciu polecenia kubectl get.

kubectl get deployment \
    --namespace $PG_SYSTEM_NAMESPACE cnpg-controller-manager \
    --context $AKS_PRIMARY_CLUSTER_NAME

Następne kroki

Wdrażanie bazy danych PostgreSQL w usłudze AKS

Współautorzy

Firma Microsoft utrzymuje ten artykuł. Następujący współautorzy pierwotnie to napisali:

Ken Kilty | Główny TPM
Russell de Pina | Główny Menedżer TPM
Adrian Joian | Starszy inżynier klienta
Jenny Hayes | Starszy deweloper zawartości
Carol Smith | Starszy deweloper zawartości
Erin Schaffer | Content Developer 2

Potwierdzenie

Ta dokumentacja została opracowana wspólnie z bazą danych EnterpriseDB, opiekunami operatora CloudNativePG. Dziękujemy Gabriele Bartolini za przejrzenie wcześniejszych wersji tego dokumentu i oferowanie ulepszeń technicznych.

Sprzężenie zwrotne

Czy ta strona była pomocna?

Last updated on 2025-09-23

Udostępnij przez

Tworzenie infrastruktury na potrzeby wdrażania bazy danych PostgreSQL o wysokiej dostępności w usłudze Azure Kubernetes Service (AKS)

Zanim rozpoczniesz

Ustawianie zmiennych środowiskowych

Instalowanie wymaganych rozszerzeń

Tworzenie grupy zasobów

Tworzenie tożsamości zarządzanej przypisanej przez użytkownika

Utwórz konto przechowywania w regionie podstawowym

Przypisywanie kontroli dostępu opartej na rolach do konta magazynowego

Konfigurowanie infrastruktury monitorowania

Tworzenie klastra usługi AKS do hostowania klastra PostgreSQL

Nawiązywanie połączenia z klastrem usługi AKS i tworzenie przestrzeni nazw

Aktualizowanie infrastruktury monitorowania

Utwórz publiczny statyczny adres IP dla ruchu do klastru PostgreSQL

Zainstaluj operatora CNPG w klastrze AKS

Następne kroki

Współautorzy

Potwierdzenie

Sprzężenie zwrotne

Dodatkowe źródła