Criar infraestrutura para implantar um banco de dados PostgreSQL altamente disponível no AKS (Serviço de Kubernetes do Azure)

Neste artigo, você criará os recursos de infraestrutura necessários para implantar um banco de dados PostgreSQL altamente disponível no AKS usando o operador CloudNativePG (CNPG ).

Importante

O software de código aberto é mencionado em toda a documentação e amostras do AKS. O software que você implanta está excluído dos contratos de nível de serviço do AKS, garantia limitada e suporte do Azure. Ao usar tecnologia de código aberto junto com o AKS, consulte as opções de suporte disponíveis nas comunidades e mantenedores de projetos respectivos para desenvolver um plano.

A Microsoft assume a responsabilidade por criar os pacotes de código aberto que implantamos no AKS. Essa responsabilidade inclui ter propriedade completa do processo de criação, verificação, sinalização, validação e hotfix, junto com o controle sobre os binários em imagens de contêiner. Para obter mais informações, confira Gerenciamento de vulnerabilidades para o AKS e Cobertura de suporte do AKS.

Antes de começar

Examine a visão geral da implantação e verifique se você atende a todos os pré-requisitos em Como implantar um banco de dados PostgreSQL altamente disponível no AKS com a CLI do Azure.
Defina variáveis de ambiente para uso ao longo deste guia.
Instale as extensões necessárias.

Definir variáveis de ambiente

Defina as seguintes variáveis de ambiente para uso ao longo deste guia:

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)

Instalar extensões necessárias

Instale as extensões necessárias para integração e monitoramento do Kubernetes:

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

Como pré-requisito para uso kubectl, você precisa primeiro instalar o Krew, seguido pela instalação do plug-in CNPG. Essas instalações permitem o gerenciamento do operador PostgreSQL usando os comandos subsequentes.

(
    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

Criar um grupo de recursos

Crie um grupo de recursos para manter os recursos criados neste guia usando o comando az group create.

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

Criar uma identidade gerenciada atribuída ao usuário

Nesta seção, você criará uma UAMI (identidade gerenciada) atribuída pelo usuário para permitir que o CNPG PostgreSQL use uma identidade de carga de trabalho do AKS para acessar o Armazenamento de Blobs do Azure. Essa configuração permite que o cluster PostgreSQL no AKS se conecte ao Armazenamento de Blobs do Azure sem segredo.

Crie uma identidade gerenciada atribuída pelo usuário usando o comando 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)

Habilite a identidade da carga de trabalho do AKS e gere uma conta de serviço para usar posteriormente neste guia usando os seguintes comandos:

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"

O ID do objeto é um identificador exclusivo para o ID do cliente (também conhecido como ID do aplicativo) que identifica exclusivamente uma entidade de segurança do tipo Aplicativo no locatário do Microsoft Entra ID. A ID do recurso é um identificador exclusivo para gerenciar e localizar um recurso no Azure. Esses valores são necessários para a identidade de carga de trabalho do AKS habilitada.

O operador CNPG gera automaticamente uma conta de serviço chamada postgres que você usa posteriormente no guia para criar uma credencial federada que permite o acesso do OAuth do PostgreSQL ao Armazenamento do Microsoft Azure.

Criar uma conta de armazenamento na região primária

Crie uma conta de armazenamento de objetos para armazenar backups do PostgreSQL na região primária usando o comando 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

Crie o contêiner de armazenamento para armazenar o WAL (Write Ahead Logs) e os backups regulares do PostgreSQL sob demanda e agendados usando o comando az storage container create.
```
az storage container create \
    --name $PG_STORAGE_BACKUP_CONTAINER_NAME \
    --account-name $PG_PRIMARY_STORAGE_ACCOUNT_NAME \
    --auth-mode login
```
Saída de exemplo:
```
{
    "created": true
}
```
Observação

Se você encontrar a mensagem de erro: 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'. Verifique as permissões de usuário para o Armazenamento de Blobs do Azure e, se necessário, aumente sua função para Storage Blob Data Owner usando os comandos fornecidos e depois tente novamente o comando 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
```

Atribuir RBAC a contas de armazenamento

Para habilitar backups, o cluster PostgreSQL precisa ler e gravar em um repositório de objetos. O cluster PostgreSQL em execução no AKS usa uma identidade de carga de trabalho para acessar a conta de armazenamento por meio do parâmetro inheritFromAzureAD de configuração do operador CNPG.

Obtenha a ID do recurso primário para a conta de armazenamento usando o comando 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

Atribua a função interna "Colaborador de Dados de Blob de Armazenamento" do Azure à ID do objeto com o escopo da ID do recurso da conta de armazenamento para a UAMI associada à identidade gerenciada para cada cluster do AKS usando o comando 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
```

Configurar a infraestrutura de monitoramento

Nesta seção, você implantará uma instância do Espaço Gerenciado do Azure para Grafana, um workspace do Azure Monitor e um workspace do Log Analytics do Azure Monitor para habilitar o monitoramento do cluster PostgreSQL. Você também armazena referências à infraestrutura de monitoramento criada para usar como entrada durante o processo de criação do cluster do AKS mais adiante no guia. Esta seção pode levar algum tempo para ser concluída.

Observação

As instâncias do Espaço Gerenciado do Azure para Grafana e os clusters AKS são cobrados de forma independente. Para obter mais informações sobre preços, consulte preços do Espaço Gerenciado do Azure para Grafana.

Crie uma instância do Espaço Gerenciado do Azure para Grafana usando o comando 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

Crie um workspace do Azure Monitor usando o comando 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

Crie um workspace do Log Analytics do Azure Monitor usando o comando 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

Criar o cluster do AKS para hospedar o cluster PostgreSQL

Nesta seção, você criará um cluster AKS multizone com um pool de nós do sistema. O cluster do AKS hospeda a réplica primária do cluster PostgreSQL e duas réplicas em espera, cada uma alinhada a uma zona de disponibilidade diferente para habilitar a redundância zonal.

Você também adiciona um pool de nós de usuário ao cluster do AKS para hospedar o cluster PostgreSQL. O uso de um pool de nós separado permite o controle sobre as SKUs de VM do Azure usadas para PostgreSQL e permite que o pool de sistemas do AKS otimize o desempenho e os custos. Você aplica um rótulo ao pool de nós de usuário que pode fazer referência à seleção de nós ao implantar o operador CNPG mais adiante neste guia. Esta seção pode levar algum tempo para ser concluída.

Importante

Se você optar por usar o NVMe local como armazenamento PostgreSQL nas partes posteriores deste guia, precisará escolher uma SKU de VM que dê suporte a unidades NVMe locais, por exemplo, SKUs de VM otimizadas para armazenamento ou SKUs de VM aceleradas por GPU. Atualize $USER_NODE_POOL_VMSKU de acordo.

Crie um cluster do AKS usando o comando 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

Aguarde a conclusão da operação inicial do cluster usando o az aks wait comando para que atualizações adicionais, como a adição do pool de nós do usuário, não colidam com uma atualização de cluster gerenciado em andamento:
```
az aks wait \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $AKS_PRIMARY_CLUSTER_NAME \
    --created
```

Adicione um pool de nós de usuário ao cluster do AKS usando o comando 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

Conectar-se ao cluster do AKS e criar namespaces

Nesta seção, você obtém as credenciais de cluster do AKS, que servem como chaves que permitem autenticar e interagir com o cluster. Uma vez conectado, você cria dois namespaces: um para os serviços do gerenciador do controlador CNPG e outro para o cluster PostgreSQL e seus serviços relacionados.

Obtenha as credenciais de cluster do AKS usando o comando az aks get-credentials.

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

Crie o namespace para os serviços do gerenciador do controlador CNPG, o cluster PostgreSQL e seus serviços relacionados usando o comando kubectl create namespace.
```
kubectl create namespace $PG_NAMESPACE --context $AKS_PRIMARY_CLUSTER_NAME
kubectl create namespace $PG_SYSTEM_NAMESPACE --context $AKS_PRIMARY_CLUSTER_NAME
```

Agora você pode definir outra variável de ambiente com base na opção de armazenamento desejada, que você referencia posteriormente no guia ao implantar o PostgreSQL.

Você pode referenciar a classe de armazenamento padrão pré-instalada do driver CSI do SSD Premium dos Discos do Azure:

export POSTGRES_STORAGE_CLASS="managed-csi-premium"

Para usar o SSD Premium v2, você pode criar uma classe de armazenamento personalizada.

Defina uma nova classe de armazenamento de driver da 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"

Importante

Verifique se o cluster está usando SKUs de VM que dão suporte a unidades NVMe locais, por exemplo, SKUs de VM otimizadas para armazenamento ou SKUs de VM aceleradas por GPU. As instruções abaixo exigem o Armazenamento de Contêineres do Azure v2.0.0 ou posterior.

Atualize o cluster do AKS para instalar o Armazenamento de Contêineres do Azure no pool de nós de usuário.

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

Use a classe de armazenamento de Contêiner do Azure fornecida.

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"

Atualizar a infraestrutura de monitoramento

O workspace do Azure Monitor para o Managed Prometheus e o Espaço Gerenciado do Azure para Grafana são automaticamente vinculados ao cluster do AKS para métricas e visualização durante o processo de criação do cluster. Nesta seção, você habilita a coleta de logs com insights de contêiner do AKS e valida que o Prometheus Gerenciado está raspando métricas e os insights de contêiner estão ingerindo logs.

Habilite o monitoramento de insights de contêiner no cluster do AKS usando o comando 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

Valide se o Managed Prometheus está raspando métricas e os insights de contêiner estão ingerindo logs do cluster do AKS inspecionando o DaemonSet usando o comando kubectl get e o comando 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

Sua saída deve ser semelhante à saída de exemplo a seguir, com seis nós no total (três para o pool de nós do sistema e três para o pool de nós do PostgreSQL) e os insights de contêiner mostrando "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
  }
}

Criar um IP estático público para entrada do cluster PostgreSQL

Para validar a implantação do cluster PostgreSQL e usar as ferramentas postgreSQL do cliente, como psql e PgAdmin, você precisa expor as réplicas primárias e somente leitura à entrada. Nesta seção, você criará um recurso de IP público do Azure que fornecerá posteriormente a um balanceador de carga do Azure para expor pontos de extremidade postgreSQL para consulta.

Obtenha o nome do grupo de recursos do nó de cluster do AKS usando o comando 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

Crie o endereço IP público usando o comando 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

Obtenha o endereço IP público recém-criado usando o comando 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

Obtenha a ID do recurso do grupo de recursos do nó usando o comando 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

Atribua a função "Colaborador de Rede" à ID do objeto UAMI usando o escopo do grupo de recursos do nó usando o comando 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}

Instalar o operador CNPG no cluster do AKS

Nesta seção, você instalará o operador CNPG no cluster do AKS usando o Helm ou um manifesto YAML.

Helm
YAML

Adicione o repositório CNPG Helm usando o comando helm repo add.
```
helm repo add cnpg https://cloudnative-pg.github.io/charts
```

Atualize o repositório CNPG Helm e instale-o no cluster do AKS usando o comando helm upgrade com o sinalizador --install.

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

Verifique a instalação do operador no cluster do AKS usando o comando kubectl get.

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

Instale o operador CNPG no cluster do AKS usando o comando 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

Verifique a instalação do operador no cluster do AKS usando o comando kubectl get.

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

Próximas etapas

Implantar o PostgreSQL no AKS

Colaboradores

A Microsoft atualiza este artigo. Os seguintes colaboradores o escreveram originalmente:

Ken Kilty | Diretor de TPM
Russell de Pina | Diretor de TPM
Adrian Joian | Engenheiro sênior de clientes
Jenny Hayes | Desenvolvedora sênior de conteúdo
Carol Smith | Desenvolvedora sênior de conteúdo
Erin Schaffer | Desenvolvedora de conteúdo 2

Reconhecimento

Esta documentação foi desenvolvida em conjunto com o EnterpriseDB, os mantenedores do operador CloudNativePG. Agradecemos a Gabriele Bartolini por revisar os rascunhos anteriores deste documento e oferecer melhorias técnicas.

Comentários

Esta página foi útil?

Last updated on 2025-09-23

Compartilhar via

Criar infraestrutura para implantar um banco de dados PostgreSQL altamente disponível no AKS (Serviço de Kubernetes do Azure)

Antes de começar

Definir variáveis de ambiente

Instalar extensões necessárias

Criar um grupo de recursos

Criar uma identidade gerenciada atribuída ao usuário

Criar uma conta de armazenamento na região primária

Atribuir RBAC a contas de armazenamento

Configurar a infraestrutura de monitoramento

Criar o cluster do AKS para hospedar o cluster PostgreSQL

Conectar-se ao cluster do AKS e criar namespaces

Atualizar a infraestrutura de monitoramento

Criar um IP estático público para entrada do cluster PostgreSQL

Instalar o operador CNPG no cluster do AKS

Próximas etapas

Colaboradores

Reconhecimento

Comentários

Recursos adicionais