Criar a infraestrutura para executar um cluster MongoDB no Serviço Kubernetes do Azure (AKS)

Neste artigo, você cria os recursos de infraestrutura necessários para executar um cluster MongoDB no Serviço Kubernetes do Azure (AKS).

Prerequisites

Revisão da visão geral da implantação de um cluster MongoDB no AKS.
Uma assinatura do Azure. Se não tiver uma, crie uma conta gratuita.
CLI do Azure versão 2.61.0. Para instalar ou atualizar, consulte Instalar a CLI do Azure.
Helm versão 3 ou posterior. Para instalar, consulte Instalando o Helm.
kubectl, que o Azure Cloud Shell instala por padrão.
Docker instalado em sua máquina local. Para instalar, consulte Obter o Docker.

Definir variáveis de ambiente

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

random=$(echo $RANDOM | tr '[0-9]' '[a-z]')
export MY_LOCATION=australiaeast
export MY_RESOURCE_GROUP_NAME=myResourceGroup-rg-$(echo $MY_LOCATION)
export MY_ACR_REGISTRY=mydnsrandomname$(echo $random)
export MY_IDENTITY_NAME=ua-identity-123
export MY_KEYVAULT_NAME=vault-$(echo $random)-kv
export MY_CLUSTER_NAME=cluster-aks
export SERVICE_ACCOUNT_NAME=mongodb
export SERVICE_ACCOUNT_NAMESPACE=mongodb
export AKS_MONGODB_NAMESPACE=mongodb
export AKS_MONGODB_SECRETS_NAME=cluster-aks-mongodb-secrets
export AKS_MONGODB_CLUSTER_NAME=cluster-aks-mongodb
export AKS_MONGODB_SECRETS_ENCRYPTION_KEY=cluster-aks-mongodb-secrets-mongodb-encryption-key
export AKS_AZURE_SECRETS_NAME=cluster-aks-azure-secrets
export AKS_MONGODB_BACKUP_STORAGE_ACCOUNT_NAME=mongodbsa$(echo $random)
export AKS_MONGODB_BACKUP_STORAGE_CONTAINER_NAME=backups

Criar um grupo de recursos

Crie um grupo de recursos usando o comando az group create.

az group create --name $MY_RESOURCE_GROUP_NAME --location $MY_LOCATION --output table

Exemplo de saída:

Location       Name
-------------  --------------------------------
australiaeast  myResourceGroup-rg-australiaeast

Criar uma identidade para acessar segredos no Cofre da Chave do Azure

Nesta etapa, você cria uma identidade gerenciada atribuída pelo usuário que o Operador de Segredos Externos usa para acessar as senhas do MongoDB armazenadas no Cofre de Chaves do Azure.

Crie uma identidade gerenciada atribuída pelo usuário usando o az identity create comando.

az identity create --name $MY_IDENTITY_NAME --resource-group $MY_RESOURCE_GROUP_NAME --output none
export MY_IDENTITY_NAME_ID=$(az identity show --name $MY_IDENTITY_NAME -g $MY_RESOURCE_GROUP_NAME --query id -o tsv)
export MY_IDENTITY_NAME_PRINCIPAL_ID=$(az identity show --name $MY_IDENTITY_NAME -g $MY_RESOURCE_GROUP_NAME --query principalId -o tsv)
export MY_IDENTITY_NAME_CLIENT_ID=$(az identity show --name $MY_IDENTITY_NAME -g $MY_RESOURCE_GROUP_NAME --query clientId -o tsv)

Criar uma instância do Azure Key Vault

Crie uma instância do Azure Key Vault usando o az keyvault create comando.

az keyvault create --name $MY_KEYVAULT_NAME --resource-group $MY_RESOURCE_GROUP_NAME --location $MY_LOCATION --enable-rbac-authorization false --output table
export KEYVAULTID=$(az keyvault show --name $MY_KEYVAULT_NAME --query "id" --output tsv)
export KEYVAULTURL=$(az keyvault show --name $MY_KEYVAULT_NAME --query "properties.vaultUri" --output tsv)

Exemplo de saída:

Location       Name            ResourceGroup
-------------  --------------  --------------------------------
australiaeast  vault-cjcfc-kv  myResourceGroup-rg-australiaeast

Criar uma instância do Azure Container Registry

Crie uma instância do Registro de Contêiner do Azure para armazenar e gerenciar suas imagens de contêiner usando o az acr create comando.

az acr create \
--name ${MY_ACR_REGISTRY} \
--resource-group $MY_RESOURCE_GROUP_NAME \
--sku Premium \
--location $MY_LOCATION \
--admin-enabled true \
--output table
export MY_ACR_REGISTRY_ID=$(az acr show --name $MY_ACR_REGISTRY --resource-group $MY_RESOURCE_GROUP_NAME --query id -o tsv)

Exemplo de saída:

NAME                  RESOURCE GROUP                    LOCATION       SKU      LOGIN SERVER                     CREATION DATE         ADMIN ENABLED
--------------------  --------------------------------  -------------  -------  -------------------------------  --------------------  ---------------
mydnsrandomnamecjcfc  myResourceGroup-rg-australiaeast  australiaeast  Premium  mydnsrandomnamecjcfc.azurecr.io  2024-07-01T12:18:34Z  True

Criar uma conta de armazenamento do Azure

Crie uma conta de armazenamento do Azure para armazenar os backups do MongoDB usando o az acr create comando.

az storage account create --name $AKS_MONGODB_BACKUP_STORAGE_ACCOUNT_NAME --resource-group $MY_RESOURCE_GROUP_NAME --location $MY_LOCATION --sku Standard_ZRS --output table
az storage container create --name $AKS_MONGODB_BACKUP_STORAGE_CONTAINER_NAME --account-name $AKS_MONGODB_BACKUP_STORAGE_ACCOUNT_NAME --output table
export AKS_MONGODB_BACKUP_STORAGE_ACCOUNT_KEY=$(az storage account keys list --account-name $AKS_MONGODB_BACKUP_STORAGE_ACCOUNT_NAME --query "[0].value" -o tsv)
az keyvault secret set --vault-name $MY_KEYVAULT_NAME --name AZURE-STORAGE-ACCOUNT-KEY --value $AKS_MONGODB_BACKUP_STORAGE_ACCOUNT_KEY --output none

Exemplo de saída:

AccessTier    AllowBlobPublicAccess    AllowCrossTenantReplication    CreationTime                      EnableHttpsTrafficOnly    Kind       Location       MinimumTlsVersion    Name            PrimaryLocation    ProvisioningState    ResourceGroup
StatusOfPrimary
------------  -----------------------  -----------------------------  --------------------------------  ------------------------  ---------  -------------  -------------------  --------------  -----------------  -------------------  --------------------------------  -----------------
Hot           False                    False                          2024-08-09T07:06:41.727230+00:00  True                      StorageV2  australiaeast  TLS1_0               mongodbsabdibh  australiaeast      Succeeded            myResourceGroup-rg-australiaeast  available
Created
---------
True

Criar um cluster do AKS

Nos seguintes passos, irá criar um cluster AKS com identidade de trabalho e com o emissor OpenID Connect (OIDC) ativado. A identidade da carga de trabalho dá à conta de serviço do Operador de Segredos Externos permissão para acessar as senhas do MongoDB armazenadas em seu cofre de chaves.

Crie um cluster AKS usando o comando az aks create.

az aks create \
--location $MY_LOCATION \
--name $MY_CLUSTER_NAME \
--tier standard \
--resource-group $MY_RESOURCE_GROUP_NAME \
--network-plugin azure \
--node-vm-size Standard_DS4_v2 \
--node-count 1 \
--nodepool-name systempool \
--nodepool-tags "pool=system" \
--auto-upgrade-channel stable \
--node-os-upgrade-channel NodeImage \
--attach-acr ${MY_ACR_REGISTRY} \
--enable-oidc-issuer \
--enable-workload-identity \
--zones 1 2 3 \
--generate-ssh-keys \
--output none

Adicione um pool de nós de utilizador ao cluster AKSc usando o comando az aks nodepool add. Este pool de nós é o local onde os pods do MongoDB são executados.

az aks nodepool add \
--resource-group $MY_RESOURCE_GROUP_NAME \
--cluster-name $MY_CLUSTER_NAME \
--name mongodbpool \
--node-vm-size Standard_DS4_v2 \
--node-count 3 \
--zones 1 2 3 \
--mode User \
--output table

Exemplo de saída:

Name        OsType    KubernetesVersion    VmSize           Count    MaxPods    ProvisioningState    Mode
----------  --------  -------------------  ---------------  -------  ---------  -------------------  ------
userpool    Linux     1.28                 Standard_DS4_v2  3        30         Succeeded            User

Obtenha a URL do emissor OIDC a ser usada para a configuração de identidade da carga de trabalho usando o az aks show comando.

export OIDC_URL=$(az aks show --resource-group $MY_RESOURCE_GROUP_NAME --name $MY_CLUSTER_NAME --query oidcIssuerProfile.issuerUrl -o tsv)

Atribua a AcrPull função à identidade kubelet usando o az role assignment create comando.

export KUBELET_IDENTITY=$(az aks show -g $MY_RESOURCE_GROUP_NAME --name $MY_CLUSTER_NAME -o tsv --query identityProfile.kubeletidentity.objectId)
az role assignment create \
--assignee ${KUBELET_IDENTITY} \
--role "AcrPull" \
--scope ${MY_ACR_REGISTRY_ID} \
--output none

Carregar imagens Percona no Registo de Contentores do Azure

Nesta seção, você baixa as imagens Percona do Docker Hub e as carrega no Registro de Contêiner do Azure. Esta etapa garante que a imagem esteja disponível em seu registro privado e possa ser usada em seu cluster AKS. Não recomendamos consumir a imagem pública em um ambiente de produção.

Importe as imagens Percona do Docker Hub e carregue-as no Registro de Contêiner do Azure usando os seguintes az acr import comandos:

az acr import \
    --name $MY_ACR_REGISTRY \
    --source docker.io/percona/percona-server-mongodb:7.0.8-5  \
    --image percona-server-mongodb:7.0.8-5

az acr import \
    --name $MY_ACR_REGISTRY \
    --source docker.io/percona/pmm-client:2.41.2  \
    --image pmm-client:2.41.2

az acr import \
    --name $MY_ACR_REGISTRY \
    --source docker.io/percona/percona-backup-mongodb:2.4.1  \
    --image percona-backup-mongodb:2.4.1

az acr import \
    --name $MY_ACR_REGISTRY \
    --source docker.io/percona/percona-server-mongodb-operator:1.16.1  \
    --image percona-server-mongodb-operator:1.16.1

Implante a infraestrutura com o Terraform

Para implantar a infraestrutura usando o Terraform, vamos usar o Módulo Verificado do Azure para AKS. O repositório terraform-azurerm-avm-res-containerservice-managedcluster contém um exemplo completo com a infraestrutura necessária para executar um cluster MongoDB no Serviço Kubernetes do Azure (AKS).

Observação

Se você estiver planejando executar isso em produção, recomendamos examinar o módulo de padrão de produção AKS para Módulos Verificados do Azure. Isto vem acompanhado de recomendações de melhores práticas.

Clone o repositório do Git com o módulo do Terraform.

git clone https://github.com/Azure/terraform-azurerm-avm-res-containerservice-managedcluster.git
cd examples/stateful-workloads

Crie um mongodb.tfvars arquivo para definir variáveis usando o seguinte comando:

cat > mongodb.tfvars <<EOL
location = "$MY_LOCATION"
resource_group_name = "$MY_RESOURCE_GROUP_NAME"
acr_registry_name = "$MY_ACR_REGISTRY"
cluster_name = "$MY_CLUSTER_NAME"
identity_name = "$MY_IDENTITY_NAME"
keyvault_name = "$MY_KEYVAULT_NAME"
aks_mongodb_backup_storage_account_name = "$AKS_MONGODB_BACKUP_STORAGE_ACCOUNT_NAME"
aks_mongodb_backup_storage_container_name = "$AKS_MONGODB_BACKUP_STORAGE_CONTAINER_NAME"
mongodb_enabled = true
mongodb_namespace = "$AKS_MONGODB_NAMESPACE"
service_account_name = "$SERVICE_ACCOUNT_NAME"

acr_task_content = <<-EOF
version: v1.1.0
steps:
  - cmd: bash echo Waiting 10 seconds the propagation of the Container Registry Data Importer and Data Reader role
  - cmd: bash sleep 10
  - cmd: az login --identity
  - cmd: az acr import --name \$RegistryName --source docker.io/percona/percona-server-mongodb:7.0.8-5 --image percona-server-mongodb:7.0.8-5
  - cmd: az acr import --name \$RegistryName --source docker.io/percona/pmm-client:2.41.2 --image pmm-client:2.41.2
  - cmd: az acr import --name \$RegistryName --source docker.io/percona/percona-backup-mongodb:2.4.1 --image percona-backup-mongodb:2.4.1
  - cmd: az acr import --name \$RegistryName --source docker.io/percona/percona-server-mongodb-operator:1.16.1 --image percona-server-mongodb-operator:1.16.1
EOF

node_pools = {
  mongodbserver = {
    name       = "mongodbpool"
    vm_size    = "Standard_D2ds_v4"
    node_count = 3
    zones      = [1, 2, 3]
    os_type    = "Linux"
  }
}
EOL

Execute os seguintes comandos Terraform para implantar a infraestrutura:

terraform init
terraform fmt
terraform apply -var-file="mongodb.tfvars"

Execute o seguinte comando para exportar os valores de saída Terraform como variáveis de ambiente no terminal para usá-los nas próximas etapas:

export MY_ACR_REGISTRY_ID=$(terraform output -raw acr_registry_id)
export MY_ACR_REGISTRY=$(terraform output -raw acr_registry_name)
export MY_CLUSTER_NAME=$(terraform output -raw aks_cluster_name)
export KUBELET_IDENTITY=$(terraform output -raw aks_kubelet_identity_id)
export OIDC_URL=$(terraform output -raw aks_oidc_issuer_url)
export identity_name=$(terraform output -raw identity_name)
export MY_IDENTITY_NAME_ID=$(terraform output -raw identity_name_id)
export MY_IDENTITY_NAME_PRINCIPAL_ID=$(terraform output -raw identity_name_principal_id)
export MY_IDENTITY_NAME_CLIENT_ID=$(terraform output -raw identity_name_client_id)
export KEYVAULTID=$(terraform output -raw key_vault_id)
export KEYVAULTURL=$(terraform output -raw key_vault_uri)
export AKS_MONGODB_BACKUP_STORAGE_ACCOUNT_KEY=$(terraform output -raw storage_account_key)
export STORAGE_ACCOUNT_NAME=$(terraform output -raw storage_account_name)
export TENANT_ID=$(terraform output -raw identity_name_tenant_id)

Observação

No AKS, o tempo padrão de keepalive (a duração da inatividade após a qual a primeira sonda keepalive é enviada) é de 7.200 segundos ou 2 horas. Para o MongoDB, você geralmente experimentará melhores resultados com um valor de keepalive mais curto, da ordem de 120 segundos ou 2 minutos.

Conectar-se ao cluster AKS

Configure kubectl para se conectar ao seu cluster AKS usando o comando az aks get-credentials.

az aks get-credentials --resource-group $MY_RESOURCE_GROUP_NAME --name $MY_CLUSTER_NAME --overwrite-existing --output table

Próximo passo

Configurar e implantar o cluster MongoDB no AKS

Feedback

Esta página foi útil?

Last updated on 2025-09-15

Partilhar via

Criar a infraestrutura para executar um cluster MongoDB no Serviço Kubernetes do Azure (AKS)

Prerequisites

Definir variáveis de ambiente

Criar um grupo de recursos

Criar uma identidade para acessar segredos no Cofre da Chave do Azure

Criar uma instância do Azure Key Vault

Criar uma instância do Azure Container Registry

Criar uma conta de armazenamento do Azure

Criar um cluster do AKS

Carregar imagens Percona no Registo de Contentores do Azure

Implante a infraestrutura com o Terraform

Conectar-se ao cluster AKS

Próximo passo

Feedback

Recursos adicionais