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

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

Pré-requisitos

Revisão da visão geral da implantação de um cluster do MongoDB no AKS.
Uma assinatura do Azure. Crie uma conta gratuita se ainda não tiver a sua.
CLI do Azure versão 2.61.0. Para instalar ou atualizar, confira Instalar a CLI do Azure.
Helm versão 3 ou posterior. Para instalar, consulte Instalar o Helm.
kubectl, que o Azure Cloud Shell instala por padrão.
O Docker instalado em seu computador local. Para instalar, confira 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 os segredos no Azure Key Vault

Nesta etapa, você criará uma identidade gerenciada atribuída pelo usuário que é usada pelo Operador de Segredos Externos para acessar as senhas do MongoDB armazenadas no Azure Key Vault.

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

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 comando az keyvault create.

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

Cria uma instância do Registro de Contêiner do Azure

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

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 do Armazenamento do Microsoft Azure para armazenar os backups do MongoDB usando o comando az acr create.

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 AKS

Nas próximas etapas, você criará um cluster do AKS com a identidade da carga de trabalho e o emissor do OIDC (OpenID Connect) habilitados. A identidade da carga de trabalho fornece a permissão da conta de serviço Operador de Segredos Externos para acessar a senha do MongoDB armazenada no seu cofre de chaves.

Crie um cluster do 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 usuário ao cluster do AKS usando o comando az aks nodepool add. Esse pool de nós é 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 do OIDC a ser usada para a configuração de identidade da carga de trabalho usando o comando az aks show.

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

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

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 do Percona no Registro de Contêiner do Azure

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

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

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

Implantar a infraestrutura com o Terraform

Para implantar a infraestrutura usando o Terraform, usaremos 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 AKS (Serviço de Kubernetes do Azure).

Observação

Se você estiver planejando executar isso em produção, recomendamos examinar o módulo de padrão de produção do AKS para módulos verificados do Azure. Isso vem juntamente com recomendações de práticas recomendadas.

Clone o repositório Git contendo o módulo 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 do 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 do 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 keepalive (o tempo de inatividade após o qual a primeira sonda keepalive é enviada) tem uma duração padrão de 7.200 segundos ou 2 horas. Para o MongoDB, você geralmente experimentará melhores resultados com um valor keepalive mais curto, na ordem de 120 segundos ou 2 minutos.

Conecte-se ao cluster do AKS

Configure kubectl para se conectar ao seu cluster do 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óxima etapa

Configurar e implantar o cluster do MongoDB no AKS

Comentários

Esta página foi útil?

Last updated on 2025-09-15

Compartilhar via

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

Pré-requisitos

Definir variáveis de ambiente

Criar um grupo de recursos

Criar uma identidade para acessar os segredos no Azure Key Vault

Criar uma instância do Azure Key Vault

Cria uma instância do Registro de Contêiner do Azure

Criar uma conta de armazenamento do Azure

Criar um cluster AKS

Carregar imagens do Percona no Registro de Contêiner do Azure

Implantar a infraestrutura com o Terraform

Conecte-se ao cluster do AKS

Próxima etapa

Comentários

Recursos adicionais