Créer une infrastructure pour déployer une base de données PostgreSQL hautement disponible sur Azure Kubernetes Service (AKS)

Dans cet article, vous allez créer les ressources d’infrastructure nécessaires pour déployer une base de données PostgreSQL hautement disponible sur AKS à l’aide de l’opérateur CloudNativePG (CNPG ).

Important

Les logiciels open source sont mentionnés dans la documentation et les exemples AKS. Les logiciels que vous déployez sont exclus des contrats de niveau de service AKS, de la garantie limitée et du support Azure. Quand vous utilisez une technologie open source avec AKS, consultez les options de support disponibles auprès des communautés et responsables de projet respectifs pour élaborer un plan.

Microsoft assume la responsabilité de la génération des packages open source que nous déployons sur AKS. Cette responsabilité comprend la maîtrise totale des processus de génération, d’analyse, de signature, de validation et de correction, ainsi que le contrôle des fichiers binaires dans les images conteneur. Pour plus d’informations, consultez Gestion des vulnérabilités pour AKS et Couverture du support AKS.

Avant de commencer

Parcourez la vue d’ensemble du déploiement et vérifiez que vous remplissez tous les prérequis dans Comment déployer une base de données PostgreSQL hautement disponible sur AKS avec Azure CLI.
Définissez des variables d’environnement à utiliser dans ce guide.
Installez les extensions requises.

Définir les variables d’environnement

Définissez les variables d’environnement suivantes à utiliser dans ce guide :

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)

Installer les extensions requises

Installez les extensions nécessaires pour l’intégration et la surveillance kubernetes :

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

En tant que prérequis pour l’utilisation kubectl, vous devez d’abord installer Krew, suivi de l’installation du plug-in CNPG. Ces installations permettent la gestion de l’opérateur PostgreSQL à l’aide des commandes suivantes.

(
    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

Créer un groupe de ressources

Créez un groupe de ressources pour contenir les ressources que vous créez dans ce guide à l’aide de la commande az group create.

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

Créer une identité managée affectée par l’utilisateur

Dans cette section, vous allez créer une identité managée affectée par l’utilisateur (UAMI) pour permettre au CNPG PostgreSQL d’utiliser une identité de charge de travail AKS pour accéder au Stockage Blob Azure. Cette configuration permet au cluster PostgreSQL sur AKS de se connecter au Stockage Blob Azure sans secret.

Créez une identité managée affectée par l’utilisateur à l’aide de la commande 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)

Activez l’identité de charge de travail AKS et générez un compte de service à utiliser plus loin dans ce guide à l’aide des commandes suivantes :

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"

L’ID d’objet est un identificateur unique pour l’ID client (également appelé ID d’application) qui identifie de manière unique un principal de sécurité de type Application dans le locataire Microsoft Entra ID. L’ID de ressource est un identificateur unique permettant de gérer et de localiser une ressource dans Azure. Ces valeurs sont requises pour activer l’identité de charge de travail AKS.

L’opérateur CNPG génère automatiquement un compte de service appelé postgres que vous utilisez plus loin dans le guide pour créer des informations d’identification fédérées qui permettent l’accès OAuth à partir de PostgreSQL vers le Stockage Azure.

Créer un compte de stockage dans la région principale

Créez un compte de stockage d’objets pour stocker les sauvegardes PostgreSQL dans la région principale à l’aide de la commande 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

Créez le conteneur de stockage pour stocker les journaux WAL (Write Ahead Logs) et les sauvegardes à la demande et planifiées standard de PostgreSQL à l’aide de la commande az storage container create.
```
az storage container create \
    --name $PG_STORAGE_BACKUP_CONTAINER_NAME \
    --account-name $PG_PRIMARY_STORAGE_ACCOUNT_NAME \
    --auth-mode login
```
Exemple de sortie :
```
{
    "created": true
}
```
Remarque

Si vous rencontrez le message d’erreur : 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'. Veillez à vérifier les autorisations utilisateur pour le stockage Blob Azure et, si nécessaire, élevez votre rôle à Storage Blob Data Owner à l'aide des commandes fournies, puis réessayez la commande 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
```

Attribuer le contrôle d’accès en fonction du rôle (RBAC) aux comptes de stockage

Pour activer les sauvegardes, le cluster PostgreSQL doit lire et écrire dans un magasin d’objets. Le cluster PostgreSQL exécuté sur AKS utilise une identité de charge de travail pour accéder au compte de stockage via le paramètre de configuration de l’opérateur CNPG inheritFromAzureAD.

Obtenez l’ID de ressource principale du compte de stockage à l’aide de la commande 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

Attribuez le rôle intégré Azure « Contributeur aux données Blob du stockage » à l’ID d’objet avec l’étendue ID de ressource du compte de stockage pour l’UAMI associé à l’identité managée pour chaque cluster AKS à l’aide de la commande 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
```

Configurer l’infrastructure de supervision

Dans cette section, vous déployez une instance d’Azure Managed Grafana, un espace de travail Azure Monitor et un espace de travail Log Analytics Azure Monitor pour activer la supervision du cluster PostgreSQL. Vous stockez également des références à l’infrastructure de supervision créée à utiliser comme entrée pendant le processus de création du cluster AKS plus loin dans le guide. Cette section peut prendre un certain temps.

Remarque

Les instances Azure Managed Grafana et les clusters AKS sont facturés indépendamment. Pour plus d’informations sur la tarification, consultez la tarification d’Azure Managed Grafana.

Créez une instance Azure Managed Grafana à l’aide de la commande 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

Créez un espace de travail Azure Monitor à l’aide de la commande az monitor account create.

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

Créez un espace de travail Log Analytics Azure Monitor à l’aide de la commande 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

Créer le cluster AKS pour héberger le cluster PostgreSQL

Dans cette section, vous allez créer un cluster AKS multizone avec un pool de nœuds système. Le cluster AKS héberge le réplica principal du cluster PostgreSQL et deux réplicas de secours, chacun aligné sur une zone de disponibilité différente pour permettre la redondance zonale.

Vous ajoutez également un pool de nœuds utilisateur au cluster AKS pour héberger le cluster PostgreSQL. L’utilisation d’un pool de nœuds distinct permet de contrôler les références SKU de machine virtuelle Azure utilisées pour PostgreSQL et permet au pool système AKS d’optimiser les performances et les coûts. Vous appliquez une étiquette au pool de nœuds utilisateur que vous pouvez référencer pour la sélection des nœuds lors du déploiement de l’opérateur CNPG plus loin dans ce guide. Cette section peut prendre un certain temps.

Important

Si vous choisissez d’utiliser un NVMe local comme stockage PostgreSQL dans les sections ultérieures de ce guide, vous devez choisir une référence SKU de VM qui prend en charge les lecteurs NVMe locaux, par exemple les références SKU de VM À stockage optimisé ou les références SKU de VM Accélération GPU. Mettez à jour $USER_NODE_POOL_VMSKU en conséquence.

Créez un cluster AKS avec la commande 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

Attendez que l’opération de cluster initiale se termine à l’aide de la az aks wait commande afin que des mises à jour supplémentaires, telles que l’ajout du pool de nœuds utilisateur, ne se heurtent pas à une mise à jour gérée en cours de cluster :
```
az aks wait \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $AKS_PRIMARY_CLUSTER_NAME \
    --created
```

Ajoutez un pool de nœuds utilisateur au cluster AKS à l’aide de la commande 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

Se connecter au cluster AKS et créer des espaces de noms

Dans cette section, vous obtenez les informations d’identification du cluster AKS, qui servent de clés qui vous permettent d’authentifier et d’interagir avec le cluster. Une fois connecté, vous créez deux espaces de noms : un pour les services de gestionnaire de contrôleur CNPG et un autre pour le cluster PostgreSQL et ses services associés.

Obtenez les informations d’identification du cluster AKS à l’aide de la commande az aks get-credentials.

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

Créez l’espace de noms pour les services du gestionnaire de contrôleur CNPG, le cluster PostgreSQL et ses services associés à l’aide de la commande kubectl create namespace.
```
kubectl create namespace $PG_NAMESPACE --context $AKS_PRIMARY_CLUSTER_NAME
kubectl create namespace $PG_SYSTEM_NAMESPACE --context $AKS_PRIMARY_CLUSTER_NAME
```

Vous pouvez maintenant définir une autre variable d’environnement basée sur votre option de stockage souhaitée, que vous référencez plus loin dans le guide lors du déploiement de PostgreSQL.

Vous pouvez utiliser la classe de stockage du pilote CSI pour les disques Azure Premium SSD préinstallée par défaut :

export POSTGRES_STORAGE_CLASS="managed-csi-premium"

Pour utiliser SSD Premium v2, vous pouvez créer une classe de stockage personnalisée.

Définissez une nouvelle classe de stockage de pilotes 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"

Important

Vérifiez que votre cluster utilise des références SKU de VM qui prennent en charge les lecteurs de NVMe local, par exemple les références SKU de VM À stockage optimisé ou les références SKU de VM Accélération GPU. Les instructions ci-dessous nécessitent Azure Container Storage v2.0.0 ou version ultérieure.

Mettez à jour le cluster AKS pour installer Azure Container Storage sur le pool de nœuds utilisateur.

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

Utilisez la classe de stockage Azure Container Storage fournie.

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"

Mettre à jour l’infrastructure de supervision

L’espace de travail Azure Monitor pour Managed Prometheus et Azure Managed Grafana est automatiquement lié au cluster AKS pour les métriques et la visualisation pendant le processus de création du cluster. Dans cette section, vous allez activer la collecte de journaux avec AKS Container Insights et vérifier que Managed Prometheus récupère des métriques et Container Insights ingère les journaux.

Activez la supervision Container Insights sur le cluster AKS à l’aide de la commande 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

Vérifiez que Managed Prometheus récupère des métriques et Container Insights ingère des journaux à partir du cluster AKS en inspectant DaemonSet à l’aide de la commandes kubectl get et az aks show.

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

Votre sortie doit ressembler à l’exemple de sortie suivant, avec un total de six nœuds (trois pour le pool de nœuds système et trois pour le pool de nœuds PostgreSQL) et Container Insights montrant "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
  }
}

Créer une adresse IP statique publique pour l’entrée de cluster PostgreSQL

Pour valider le déploiement du cluster PostgreSQL et utiliser les outils PostgreSQL clients, tels que psql et PgAdmin, vous devez exposer les réplicas principaux et en lecture seule à l’entrée. Dans cette section, vous allez créer une ressource d’adresse IP publique Azure que vous fournissez ultérieurement à un équilibreur de charge Azure pour exposer les points de terminaison PostgreSQL pour la requête.

Obtenez le nom du groupe de ressources du nœud de cluster AKS à l’aide de la commande 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

Créez l’adresse IP publique à l’aide de la commande az network public-ip create.

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

Obtenez l’adresse IP publique nouvellement créée à l’aide de la commande az network public-ip show.

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

Obtenez l’ID de ressource du groupe de ressources de nœud à l’aide de la commande 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

Attribuez le rôle « Contributeur de réseau » à l’ID d’objet UAMI en utilisant l’étendue du groupe de ressources de nœud à l’aide de la commande 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}

Installer l’opérateur CNPG dans le cluster AKS

Dans cette section, vous installez l’opérateur CNPG dans le cluster AKS avec Helm ou un manifeste YAML.

Helm
YAML

Ajoutez le référentiel Helm CNPG à l’aide de la commande helm repo add.
```
helm repo add cnpg https://cloudnative-pg.github.io/charts
```

Mettez à niveau le référentiel Helm CNPG et installez-le sur le cluster AKS à l’aide de la commande helm upgrade avec l’indicateur --install.

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

Vérifiez l’installation de l’opérateur sur le cluster AKS à l’aide de la commande kubectl get.

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

Installez l’opérateur CNPG sur le cluster AKS à l’aide de la commande 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

Vérifiez l’installation de l’opérateur sur le cluster AKS à l’aide de la commande kubectl get.

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

Étapes suivantes

Déployer PostgreSQL sur AKS

Contributeurs

La gestion de cet article est sous la responsabilité de Microsoft. Les contributeurs suivants ont rédigé sa version d’origine :

Ken Kitty | Responsable de programme technique en chef
Russell de Pina | Responsable de programme technique en chef
Adrian Joian | Ingénieur client senior
Jenny Hayes | Développeuse de contenu confirmée
Carol Smith | Développeuse de contenu confirmée
Erin Schaffer | Développeuse de contenu 2

Accusé de réception

Cette documentation a été développée conjointement avec EnterpriseDB, les mainteneurs de l’opérateur CloudNativePG. Nous remercions Gabriele Bartolini d’avoir examiné les brouillons précédents de ce document et d’offrir des améliorations techniques.

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2025-09-23

Partager via

Créer une infrastructure pour déployer une base de données PostgreSQL hautement disponible sur Azure Kubernetes Service (AKS)

Avant de commencer

Définir les variables d’environnement

Installer les extensions requises

Créer un groupe de ressources

Créer une identité managée affectée par l’utilisateur

Créer un compte de stockage dans la région principale

Attribuer le contrôle d’accès en fonction du rôle (RBAC) aux comptes de stockage

Configurer l’infrastructure de supervision

Créer le cluster AKS pour héberger le cluster PostgreSQL

Se connecter au cluster AKS et créer des espaces de noms

Mettre à jour l’infrastructure de supervision

Créer une adresse IP statique publique pour l’entrée de cluster PostgreSQL

Installer l’opérateur CNPG dans le cluster AKS

Étapes suivantes

Contributeurs

Accusé de réception

Commentaires

Ressources supplémentaires