Een infrastructuur maken voor het implementeren van een maximaal beschikbare PostgreSQL-database in Azure Kubernetes Service (AKS)

In dit artikel maakt u de infrastructuurresources die nodig zijn voor het implementeren van een maximaal beschikbare PostgreSQL-database op AKS met behulp van de CNPG-operator (CloudNativePG).

Belangrijk

Opensource-software wordt vermeld in AKS-documentatie en -voorbeelden. Software die u implementeert, is uitgesloten van AKS-serviceovereenkomsten, beperkte garantie en ondersteuning voor Azure. Wanneer u opensource-technologie naast AKS gebruikt, raadpleegt u de beschikbare ondersteuningsopties van de respectieve community's en projectonderhouders om een plan te ontwikkelen.

Microsoft neemt de verantwoordelijkheid voor het bouwen van de opensource-pakketten die we implementeren op AKS. Deze verantwoordelijkheid omvat het volledige eigendom van het bouw-, scan-, onderteken-, validatie- en hotfixproces, samen met controle over de binaire bestanden in container images. Zie Beveiligingsbeheer voor AKS- en AKS-ondersteuningsdekking voor meer informatie.

Voordat u begint

Bekijk het implementatieoverzicht en zorg ervoor dat u voldoet aan alle vereisten in Het implementeren van een maximaal beschikbare PostgreSQL-database op AKS met Azure CLI.
Stel omgevingsvariabelen in voor gebruik in deze handleiding.
Installeer de vereiste extensies.

Omgevingsvariabelen instellen

Stel de volgende omgevingsvariabelen in voor gebruik in deze handleiding:

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)

Vereiste extensies installeren

Installeer de extensies die nodig zijn voor Kubernetes-integratie en -bewaking:

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

Als vereiste voor het gebruik kubectlmoet u Eerst Krew installeren, gevolgd door de installatie van de CNPG-invoegtoepassing. Deze installaties maken het beheer van de PostgreSQL-operator mogelijk met behulp van de volgende opdrachten.

(
    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

Een brongroep maken

Maak een resourcegroep voor het opslaan van de resources die u in deze handleiding maakt met behulp van de az group create opdracht.

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

Een door de gebruiker toegewezen beheerde identiteit maken

In deze sectie maakt u een door de gebruiker toegewezen beheerde identiteit (UAMI) om de CNPG PostgreSQL toe te staan een AKS-workloadidentiteit te gebruiken voor toegang tot Azure Blob Storage. Met deze configuratie kan het PostgreSQL-cluster in AKS zonder geheim verbinding maken met Azure Blob Storage.

Maak een door de gebruiker toegewezen beheerde identiteit met behulp van de az identity create opdracht.

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

Schakel AKS-workloadidentiteit in en genereer een serviceaccount om later in deze handleiding te gebruiken met behulp van de volgende opdrachten:

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"

De object-id is een unieke id voor de client-id (ook wel de toepassings-id genoemd) waarmee een beveiligingsprincipaal van het type Toepassing in de Microsoft Entra ID-tenant uniek wordt geïdentificeerd. De resource-id is een unieke id voor het beheren en vinden van een resource in Azure. Deze waarden zijn vereist voor het inschakelen van AKS-workloadidentiteit.

De CNPG-operator genereert automatisch een serviceaccount met de naam postgres dat u later in de handleiding gebruikt om een federatieve referentie te maken die OAuth-toegang vanuit PostgreSQL naar Azure Storage mogelijk maakt.

Een opslagaccount maken in de primaire regio

Maak een objectopslagaccount voor het opslaan van PostgreSQL-back-ups in de primaire regio met behulp van de az storage account create opdracht.

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

Maak de opslagcontainer om de Write Ahead Logs (WAL) en reguliere PostgreSQL on-demand en geplande back-ups op te slaan met behulp van de az storage container create opdracht.

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

Voorbeelduitvoer:

{
    "created": true
}

Notitie

Als u het foutbericht krijgt: 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'. Zorg ervoor dat u gebruikersrechten voor Azure Blob Storage verifieert en, indien nodig, uw rol verhoogt met Storage Blob Data Owner behulp van de opgegeven opdrachten en probeer daarna de az storage container create opdracht opnieuw.

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

RBAC toewijzen aan opslagaccounts

Als u back-ups wilt inschakelen, moet het PostgreSQL-cluster lezen en schrijven naar een objectarchief. Het PostgreSQL-cluster dat wordt uitgevoerd op AKS maakt gebruik van een workloadidentiteit voor toegang tot het opslagaccount via de configuratieparameter inheritFromAzureADvan de CNPG-operator.

Haal de primaire resource-id voor het opslagaccount op met behulp van de az storage account show opdracht.

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

Wijs de ingebouwde Azure-rol "Inzender voor opslagblobgegevens" toe aan de object-ID binnen het resource-ID-bereik van het opslagaccount voor de UAMI die is gekoppeld aan de beheerde identiteit van elk AKS-cluster, met behulp van de az role assignment create opdracht.
```
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
```

Bewakingsinfrastructuur instellen

In deze sectie implementeert u een exemplaar van Azure Managed Grafana, een Azure Monitor-werkruimte en een Azure Monitor Log Analytics-werkruimte om bewaking van het PostgreSQL-cluster mogelijk te maken. U slaat ook verwijzingen op naar de gemaakte bewakingsinfrastructuur die moet worden gebruikt als invoer tijdens het maken van het AKS-cluster verderop in de handleiding. Het kan enige tijd duren voordat deze sectie is voltooid.

Notitie

Azure Managed Grafana-exemplaren en AKS-clusters worden onafhankelijk gefactureerd. Raadpleeg Azure Managed Grafana-prijzen voor meer informatie over prijzen.

Maak een Azure Managed Grafana-exemplaar met behulp van de az grafana create opdracht.

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

Maak een Azure Monitor-werkruimte met behulp van de az monitor account create opdracht.

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

Maak een Azure Monitor Log Analytics-werkruimte met behulp van de az monitor log-analytics workspace create opdracht.

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

Het AKS-cluster maken om het PostgreSQL-cluster te hosten

In deze sectie maakt u een AKS-cluster met meerdere zones met een systeemknooppuntgroep. Het AKS-cluster fungeert als host voor de primaire replica van het PostgreSQL-cluster en twee stand-byreplica's, die elk zijn uitgelijnd op een andere beschikbaarheidszone om zonegebonden redundantie mogelijk te maken.

U voegt ook een gebruikersknooppuntgroep toe aan het AKS-cluster om het PostgreSQL-cluster te hosten. Met behulp van een afzonderlijke knooppuntgroep kunt u controle krijgen over de Azure VM-SKU's die worden gebruikt voor PostgreSQL en zorgt u ervoor dat de AKS-systeemgroep de prestaties en kosten optimaliseert. U past een label toe op de gebruikersknooppuntgroep waarnaar u kunt verwijzen voor knooppuntselectie bij het implementeren van de CNPG-operator verderop in deze handleiding. Het kan enige tijd duren voordat deze sectie is voltooid.

Belangrijk

Als u ervoor kiest om lokale NVMe te gebruiken als postgreSQL-opslag in de latere onderdelen van deze handleiding, moet u een VM-SKU kiezen die ondersteuning biedt voor lokale NVMe-stations, bijvoorbeeld voor opslag geoptimaliseerde VM-SKU's of versnelde GPU-VM-SKU's. Werk $USER_NODE_POOL_VMSKU dienovereenkomstig bij.

Maak een AKS-cluster met behulp van de az aks create opdracht.

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

Wacht tot de eerste clusterbewerking is voltooid met behulp van de az aks wait opdracht, zodat aanvullende updates, zoals het toevoegen van de gebruikersknooppuntgroep, niet botsen met een beheerde-clusterupdate die wordt uitgevoerd:
```
az aks wait \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $AKS_PRIMARY_CLUSTER_NAME \
    --created
```

Voeg een gebruikersknooppuntgroep toe aan het AKS-cluster met behulp van de az aks nodepool add opdracht.

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

Verbinding maken met het AKS-cluster en naamruimten maken

In deze sectie krijgt u de AKS-clusterreferenties, die fungeren als de sleutels waarmee u het cluster kunt verifiëren en ermee kunt werken. Zodra u verbinding hebt gemaakt, maakt u twee naamruimten: één voor de CNPG Controller Manager-services en één voor het PostgreSQL-cluster en de bijbehorende services.

Haal de AKS-clusterreferenties op met behulp van de az aks get-credentials opdracht.

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

Maak de naamruimte voor de SERVICES van CNPG Controller Manager, het PostgreSQL-cluster en de bijbehorende services met behulp van de kubectl create namespace opdracht.
```
kubectl create namespace $PG_NAMESPACE --context $AKS_PRIMARY_CLUSTER_NAME
kubectl create namespace $PG_SYSTEM_NAMESPACE --context $AKS_PRIMARY_CLUSTER_NAME
```

U kunt nu een andere omgevingsvariabele definiëren op basis van de gewenste opslagoptie, waarnaar u verderop in de handleiding verwijst bij het implementeren van PostgreSQL.

U kunt verwijzen naar de standaard vooraf geïnstalleerde Premium SSD Azure Disks CSI-stuurprogrammaklasse:

export POSTGRES_STORAGE_CLASS="managed-csi-premium"

Als u Premium SSD v2 wilt gebruiken, kunt u een aangepaste opslagklasse maken.

Definieer een nieuwe CSI-stuurprogrammaopslagklasse:

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"

Belangrijk

Zorg ervoor dat uw cluster VM-SKU's gebruikt die ondersteuning bieden voor lokale NVMe-stations, bijvoorbeeld voor opslag geoptimaliseerde VM-SKU's of versnelde GPU-VM-SKU's. Voor de onderstaande instructies is Azure Container Storage v2.0.0 of hoger vereist.

Werk het AKS-cluster bij om Azure Container Storage te installeren in een gebruikersknooppuntgroep.

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

Gebruik de opgegeven Azure Container Storage-opslagklasse.

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"

De bewakingsinfrastructuur bijwerken

De Azure Monitor-werkruimte voor Managed Prometheus en Azure Managed Grafana worden automatisch gekoppeld aan het AKS-cluster voor metrische gegevens en visualisatie tijdens het maken van het cluster. In deze sectie schakelt u logboekverzameling met AKS Container Insights in en controleert u of Managed Prometheus metrische gegevens scrapt en Container Insights logboeken opneemt.

Schakel Container Insights-bewaking in op het AKS-cluster met behulp van de az aks enable-addons opdracht.

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

Controleer of Managed Prometheus metrische gegevens scrapt en Container Insights logboeken uit het AKS-cluster opneemt door de DaemonSet te inspecteren met behulp van de kubectl get opdracht en de az aks show opdracht.

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

Uw uitvoer moet lijken op de volgende voorbeelduitvoer, met zes knooppunten in totaal (drie voor de systeemknooppuntgroep en drie voor de PostgreSQL-knooppuntgroep) en de containerinzichten die worden weergegeven "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
  }
}

Maak een openbaar statisch IP-adres voor de toegang van het PostgreSQL-cluster

Als u de implementatie van het PostgreSQL-cluster wilt valideren en Client PostgreSQL-hulpprogramma's, zoals psql en PgAdmin, wilt gebruiken, moet u de primaire en alleen-lezen replica's beschikbaar maken voor inkomend verkeer. In deze sectie maakt u een openbare IP-resource van Azure die u later aan een Azure Load Balancer levert om PostgreSQL-eindpunten beschikbaar te maken voor query's.

Haal de naam van de resourcegroep van het AKS-clusterknooppunt op met behulp van de az aks show opdracht.

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

Maak het openbare IP-adres met behulp van de az network public-ip create opdracht.

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

Haal het zojuist gemaakte openbare IP-adres op met behulp van de az network public-ip show opdracht.

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

Haal de resource-id van de knooppuntresourcegroep op met behulp van de az group show opdracht.

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

Wijs de rol Netwerkbijdrager toe aan de UAMI-object-id via het knooppuntresourcegroepbereik met de az role assignment create opdracht.

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}

De CNPG-operator installeren in het AKS-cluster

In deze sectie installeert u de CNPG-operator in het AKS-cluster met behulp van Helm of een YAML-manifest.

Helm
YAML

Voeg de CNPG Helm-opslagplaats toe met behulp van de helm repo add opdracht.
```
helm repo add cnpg https://cloudnative-pg.github.io/charts
```

Werk de CNPG Helm-opslagplaats bij en installeer deze op het AKS-cluster met behulp van de helm upgrade opdracht met de --install vlag.

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

Controleer de operatorinstallatie op het AKS-cluster met behulp van de kubectl get opdracht.

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

Installeer de CNPG-operator op het AKS-cluster met behulp van de kubectl apply opdracht.

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

Controleer de operatorinstallatie op het AKS-cluster met behulp van de kubectl get opdracht.

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

Volgende stappen

PostgreSQL implementeren in AKS

Bijdragers

Microsoft onderhoudt dit artikel. De volgende inzenders hebben het oorspronkelijk geschreven:

Ken Kilty | Hoofd TPM
Russell de Pina | Principal TPM
Adrian Joian | Senior klanttechnicus
Jenny Hayes | Senior Content Developer
Carol Smith | Senior Content Developer
Erin Schaffer | Inhoudsontwikkelaar 2

Erkenning

Deze documentatie is gezamenlijk ontwikkeld met EnterpriseDB, de onderhouders van de CloudNativePG-operator. We danken Gabriele Bartolini voor het bekijken van eerdere concepten van dit document en het aanbieden van technische verbeteringen.

Feedback

Is deze pagina nuttig?

Last updated on 2025-09-23

Delen via

Een infrastructuur maken voor het implementeren van een maximaal beschikbare PostgreSQL-database in Azure Kubernetes Service (AKS)

Voordat u begint

Omgevingsvariabelen instellen

Vereiste extensies installeren

Een brongroep maken

Een door de gebruiker toegewezen beheerde identiteit maken

Een opslagaccount maken in de primaire regio

RBAC toewijzen aan opslagaccounts

Bewakingsinfrastructuur instellen

Het AKS-cluster maken om het PostgreSQL-cluster te hosten

Verbinding maken met het AKS-cluster en naamruimten maken

De bewakingsinfrastructuur bijwerken

Maak een openbaar statisch IP-adres voor de toegang van het PostgreSQL-cluster

De CNPG-operator installeren in het AKS-cluster

Volgende stappen

Bijdragers

Erkenning

Feedback

Aanvullende resources