Membuat infrastruktur untuk menyebarkan database PostgreSQL yang sangat tersedia di Azure Kubernetes Service (AKS)

Dalam artikel ini, Anda membuat sumber daya infrastruktur yang diperlukan untuk menyebarkan database PostgreSQL yang sangat tersedia di AKS menggunakan operator CloudNativePG (CNPG).

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 cepat, bersama dengan kontrol atas file biner dalam gambar kontainer. Untuk informasi selengkapnya, lihat Manajemen kerentanan untuk AKS dan Cakupan dukungan AKS.

Sebelum Anda mulai

Tinjau gambaran umum penyebaran dan pastikan Anda memenuhi semua prasyarat dalam Cara menyebarkan database PostgreSQL yang sangat tersedia di AKS dengan Azure CLI.
Atur variabel lingkungan untuk digunakan di seluruh panduan ini.
Instal ekstensi yang diperlukan.

Atur variabel lingkungan

Atur variabel lingkungan berikut untuk digunakan di seluruh panduan ini:

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)

Menginstal ekstensi yang diperlukan

Instal ekstensi yang diperlukan untuk integrasi dan pemantauan Kubernetes:

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

Sebagai prasyarat untuk menggunakan kubectl, Anda perlu terlebih dahulu menginstal Krew, diikuti dengan penginstalan plugin CNPG. Penginstalan ini memungkinkan manajemen operator PostgreSQL menggunakan perintah berikutnya.

(
    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

Membuat grup sumber daya

Buat grup sumber daya untuk menyimpan sumber daya yang Anda buat dalam panduan ini menggunakan az group create perintah .

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

Buat identitas terkelola yang ditetapkan pengguna

Di bagian ini, Anda membuat identitas terkelola yang ditetapkan pengguna (UAMI) untuk memungkinkan CNPG PostgreSQL menggunakan identitas beban kerja AKS untuk mengakses Azure Blob Storage. Konfigurasi ini memungkinkan kluster PostgreSQL di AKS untuk terhubung ke Azure Blob Storage tanpa rahasia.

Buat identitas terkelola yang ditetapkan pengguna menggunakan perintah az identity create.

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

Aktifkan identitas beban kerja AKS dan buat akun layanan untuk digunakan nanti dalam panduan ini menggunakan perintah berikut:

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"

ID objek adalah pengidentifikasi unik untuk ID klien (juga dikenal sebagai ID aplikasi) yang secara unik mengidentifikasi prinsip keamanan jenis Aplikasi dalam penyewa ID Microsoft Entra. ID sumber daya adalah pengidentifikasi unik untuk mengelola dan menemukan sumber daya di Azure. Nilai-nilai ini diperlukan untuk mengaktifkan identitas beban kerja AKS.

Operator CNPG secara otomatis menghasilkan akun layanan yang disebut postgres yang Anda gunakan nanti dalam panduan untuk membuat kredensial federasi yang memungkinkan akses OAuth dari PostgreSQL ke Azure Storage.

Membuat akun penyimpanan di wilayah utama

Buat akun penyimpanan objek untuk menyimpan cadangan PostgreSQL di wilayah utama menggunakan az storage account create perintah .

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

Buat kontainer penyimpanan untuk menyimpan Write Ahead Logs (WAL) dan PostgreSQL reguler sesuai permintaan dan pencadangan terjadwal menggunakan az storage container create perintah .

az storage container create \
    --name $PG_STORAGE_BACKUP_CONTAINER_NAME \
    --account-name $PG_PRIMARY_STORAGE_ACCOUNT_NAME \
    --auth-mode login

Contoh output:

{
    "created": true
}

Nota

Jika Anda menemukan pesan kesalahan: 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'. Pastikan untuk memverifikasi izin pengguna untuk Azure Blob Storage dan, jika perlu, gunakan perintah yang disediakan untuk meningkatkan peran Anda, dan kemudian coba lagi perintah Storage Blob Data Owner.

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

Menetapkan RBAC ke akun penyimpanan

Untuk mengaktifkan cadangan, kluster PostgreSQL perlu membaca dan menulis ke penyimpanan objek. Kluster PostgreSQL yang berjalan di AKS menggunakan identitas beban kerja untuk mengakses akun penyimpanan melalui parameter inheritFromAzureADkonfigurasi operator CNPG .

Dapatkan ID sumber daya utama untuk akun penyimpanan menggunakan az storage account show perintah .

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

Tetapkan peran bawaan Azure "Storage Blob Data Contributor" ke ID objek dengan cakupan ID sumber daya akun penyimpanan untuk UAMI yang terkait dengan identitas terkelola untuk setiap kluster AKS menggunakan az role assignment create perintah .

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

Menyiapkan infrastruktur pemantauan

Di bagian ini, Anda menyebarkan instans Azure Managed Grafana, ruang kerja Azure Monitor, dan ruang kerja Azure Monitor Log Analytics untuk mengaktifkan pemantauan kluster PostgreSQL. Anda juga menyimpan referensi ke infrastruktur pemantauan yang dibuat untuk digunakan sebagai input selama proses pembuatan kluster AKS nanti dalam panduan. Bagian ini mungkin perlu waktu untuk menyelesaikannya.

Nota

Instans Azure Managed Grafana dan kluster AKS ditagih secara independen. Untuk informasi harga selengkapnya, lihat Harga Azure Managed Grafana.

Buat instans Azure Managed Grafana menggunakan az grafana create perintah .

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

Buat ruang kerja Azure Monitor menggunakan az monitor account create perintah .

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

Buat ruang kerja Log Analytics Azure Monitor menggunakan perintah 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

Membuat kluster AKS untuk menghosting kluster PostgreSQL

Di bagian ini, Anda membuat kluster AKS multizone dengan kumpulan simpul sistem. Kluster AKS menghosting replika utama kluster PostgreSQL dan dua replika siaga, masing-masing selaras dengan zona ketersediaan yang berbeda untuk mengaktifkan redundansi zona.

Anda juga menambahkan kumpulan simpul pengguna ke kluster AKS untuk menghosting kluster PostgreSQL. Menggunakan kumpulan simpul terpisah memungkinkan kontrol atas SKU Azure VM yang digunakan untuk PostgreSQL dan memungkinkan kumpulan sistem AKS untuk mengoptimalkan performa dan biaya. Anda menerapkan label ke kumpulan simpul pengguna yang dapat Anda referensikan untuk pilihan simpul saat menyebarkan operator CNPG nanti dalam panduan ini. Bagian ini mungkin perlu waktu untuk menyelesaikannya.

Penting

Jika Anda memilih untuk menggunakan NVMe lokal sebagai penyimpanan PostgreSQL Anda di bagian selanjutnya dari panduan ini, Anda perlu memilih SKU VM yang mendukung drive NVMe lokal, misalnya, SKU VM yang dioptimalkan Penyimpanan atau SKU VM yang dipercepat GPU. Perbarui $USER_NODE_POOL_VMSKU dengan sesuai.

Buat kluster AKS menggunakan perintah 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

Tunggu hingga operasi kluster awal selesai menggunakan az aks wait perintah sehingga pembaruan tambahan, seperti menambahkan kumpulan simpul pengguna, jangan bertabrakan dengan pembaruan kluster terkelola yang sedang berlangsung:
```
az aks wait \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $AKS_PRIMARY_CLUSTER_NAME \
    --created
```

Tambahkan kumpulan simpul pengguna ke kluster AKS menggunakan az aks nodepool add perintah .

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

Sambungkan ke kluster AKS dan buat namespace

Di bagian ini, Anda mendapatkan kredensial kluster AKS, yang berfungsi sebagai kunci yang memungkinkan Anda mengautentikasi dan berinteraksi dengan kluster. Setelah tersambung, Anda membuat dua namespace: satu untuk layanan manajer pengontrol CNPG dan satu untuk kluster PostgreSQL dan layanan terkait.

Dapatkan kredensial kluster AKS menggunakan az aks get-credentials perintah .

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

Buat namespace layanan untuk layanan manajer pengontrol CNPG, kluster PostgreSQL, dan layanan terkait dengan menggunakan kubectl create namespace perintah .

kubectl create namespace $PG_NAMESPACE --context $AKS_PRIMARY_CLUSTER_NAME
kubectl create namespace $PG_SYSTEM_NAMESPACE --context $AKS_PRIMARY_CLUSTER_NAME

Anda sekarang dapat menentukan variabel lingkungan lain berdasarkan opsi penyimpanan yang Anda inginkan, yang Anda referensikan nanti dalam panduan saat menyebarkan PostgreSQL.

Anda dapat merujuk ke kelas penyimpanan driver CSI untuk Premium SSD Azure Disks bawaan yang telah diinstal sebelumnya:

export POSTGRES_STORAGE_CLASS="managed-csi-premium"

Untuk menggunakan Premium SSD v2, Anda dapat membuat kelas penyimpanan kustom.

Tentukan kelas penyimpanan driver CSI baru:

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"

Penting

Pastikan kluster Anda menggunakan SKU VM yang mendukung drive NVMe lokal, misalnya, SKU VM yang dioptimalkan Penyimpanan atau SKU VM yang dipercepat GPU. Instruksi di bawah ini memerlukan Azure Container Storage v2.0.0 atau yang lebih baru.

Perbarui kluster AKS untuk menginstal Azure Container Storage pada kumpulan simpul pengguna.

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

Gunakan kelas penyimpanan Azure Container Storage yang disediakan.

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"

Memperbarui infrastruktur pemantauan

Ruang kerja Azure Monitor untuk Azure Managed Prometheus dan Azure Managed Grafana secara otomatis dikaitkan ke kluster AKS untuk metrik dan visualisasi selama proses pembuatan kluster. Di bagian ini, Anda mengaktifkan pengumpulan log dengan Container insights AKS dan memvalidasi bahwa Prometheus Terkelola mengumpulkan metrik dan Container insights memasukkan log.

Aktifkan pemantauan wawasan Kontainer pada kluster AKS menggunakan az aks enable-addons perintah .

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

Validasi bahwa Prometheus Terkelola mengekstrak metrik dan wawasan Kontainer menyerap log dari kluster AKS dengan memeriksa DaemonSet menggunakan kubectl get perintah dan az aks show perintah .

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

Output Anda harus menyerupai contoh output berikut, dengan total enam simpul (tiga untuk kumpulan simpul sistem dan tiga untuk kumpulan simpul PostgreSQL) dan wawasan Kontainer yang "enabled": truemenunjukkan :

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

Membuat IP statis publik untuk ingress kluster PostgreSQL

Untuk memvalidasi penyebaran kluster PostgreSQL dan menggunakan alat klien PostgreSQL, seperti psql dan PgAdmin, Anda perlu mengekspos replika utama dan hanya-baca ke ingress. Di bagian ini, Anda membuat sumber daya IP publik Azure yang nantinya Anda berikan ke load balancer Azure untuk mengekspos titik akhir PostgreSQL untuk kueri.

Dapatkan nama grup sumber daya simpul kluster AKS menggunakan az aks show perintah .

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

Buat alamat IP publik menggunakan az network public-ip create perintah .

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

Dapatkan alamat IP publik yang baru dibuat menggunakan az network public-ip show perintah .

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

Dapatkan ID sumber daya grup sumber daya simpul dengan menggunakan perintah 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

Tetapkan peran "Kontributor Jaringan" ke ID objek UAMI menggunakan cakupan grup sumber daya simpul dengan perintah 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}

Menginstal operator CNPG di kluster AKS

Di bagian ini, Anda menginstal operator CNPG di kluster AKS menggunakan Helm atau manifes YAML.

Helm
YAML

Tambahkan repositori Helm CNPG menggunakan perintah helm repo add.
```
helm repo add cnpg https://cloudnative-pg.github.io/charts
```

Perbarui repositori CNPG Helm dan instal pada kluster AKS menggunakan perintah helm upgrade dengan opsi --install.

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

Verifikasi pemasangan operator pada kluster AKS menggunakan perintah kubectl get.

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

Instal operator CNPG pada kluster AKS menggunakan kubectl apply perintah .

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

Verifikasi pemasangan operator pada kluster AKS menggunakan perintah kubectl get.

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

Langkah selanjutnya

Menyebarkan PostgreSQL di AKS

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

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?

Last updated on 2025-11-09

Bagikan melalui

Membuat infrastruktur untuk menyebarkan database PostgreSQL yang sangat tersedia di Azure Kubernetes Service (AKS)

Sebelum Anda mulai

Atur variabel lingkungan

Menginstal ekstensi yang diperlukan

Membuat grup sumber daya

Buat identitas terkelola yang ditetapkan pengguna

Membuat akun penyimpanan di wilayah utama

Menetapkan RBAC ke akun penyimpanan

Menyiapkan infrastruktur pemantauan

Membuat kluster AKS untuk menghosting kluster PostgreSQL

Sambungkan ke kluster AKS dan buat namespace

Memperbarui infrastruktur pemantauan

Membuat IP statis publik untuk ingress kluster PostgreSQL

Menginstal operator CNPG di kluster AKS

Langkah selanjutnya

Kontributor

Pengakuan

Saran dan Komentar

Sumber Daya Tambahan: