Início Rápido: Criar um cluster AKS (Serviço de Kubernetes do Azure) Automático

Aplica-se a: ✔️ AKS Automatic

AKS (Serviço de Kubernetes do Azure) Automatic é uma experiência gerenciada do Kubernetes que automatiza a instalação e as operações de cluster do AKS e insere configurações de prática recomendada. O AKS Automatic também inclui um [SLA de preparação para pod][azure-sla] que garante que 99,9% de operações de preparação de pod qualificadas sejam concluídas em até 5 minutos, garantindo uma infraestrutura confiável e auto-cura para seus aplicativos. Neste guia de início rápido, você aprende a:

Implante um cluster do AKS Automático.
Executa um aplicativo de vários contêineres de exemplo com um grupo de microsserviços e front-ends da Web simulando um cenário de varejo.

Antes de começar

Este guia de início rápido pressupõe uma compreensão básica dos conceitos do Kubernetes. Para obter mais informações, consulte os principais conceitos Kubernetes para AKS (Serviço de Kubernetes do Azure).
AKS Automatic habilita a Política do Azure no cluster AKS, mas você deve preregistrar o provedor de recursos Microsoft.PolicyInsights em sua assinatura. Para obter mais informações, consulte provedores de recursos e tipos do Azure.

Use o ambiente bash em Azure Cloud Shell. Para obter mais informações, consulte Get iniciado com Azure Cloud Shell.
Se você preferir executar comandos de referência da CLI localmente, instalar o CLI do Azure. Se você estiver executando em Windows ou macOS, considere executar CLI do Azure em um contêiner do Docker. Para obter mais informações, consulte Como executar o CLI do Azure em um contêiner do Docker.
- Se você estiver usando uma instalação local, entre no CLI do Azure usando o comando az login. Para concluir o processo de autenticação, siga as etapas exibidas em seu terminal. Para obter outras opções de entrada, consulte Authenticate para Azure usando CLI do Azure.
- Quando for solicitado, instale a extensão CLI do Azure no primeiro uso. Para obter mais informações sobre extensões, consulte Use e gerencie extensões com o CLI do Azure.
- Execute o comando az version para localizar a versão e as bibliotecas dependentes que estão instaladas. Para atualizar para a versão mais recente, execute az upgrade.

CLI do Azure versão 2.86.0 ou posterior. Para localizar a versão, execute az --version o comando. Se precisar instalar ou atualizar, consulte Instalar CLI do Azure.
Se você tiver várias assinaturas Azure, selecione a ID de assinatura apropriada para cobrar os recursos usando o comando az account set.

Para implantar um arquivo Bicep, você precisa de acesso de gravação nos recursos criados e acesso a todas as operações no tipo de recurso Microsoft.Resources/deployments. Por exemplo, para criar uma VM (máquina virtual), você precisa de permissões Microsoft.Compute/virtualMachines/write e Microsoft.Resources/deployments/*. Para obter uma lista de funções e permissões, consulte funções internas do Azure.

Instale e configure o Terraform.

Observação

Este exemplo cria o cluster AKS Automatic com o recurso v4.81 do provedor AzureRM, que requer a versão azurerm_kubernetes_automatic_cluster ou posterior do provedor AzureRM. Para obter um exemplo equivalente que usa o provedor AzAPI , consulte 101-aks-automatic-azapi. Recorra à AzAPI quando precisar de controle direto sobre a carga útil da API do cluster gerenciado ou de uma versão da API ou de uma propriedade que o provedor AzureRM ainda não expôs.

Importante

A partir do AKS 1.36, os novos clusters AKS Automatic habilitarão por padrão a Gateway API do Kubernetes por meio do complemento de roteamento de aplicativos, em vez do ingresso NGINX gerenciado com o complemento de roteamento de aplicativos, devido à descontinuação do Ingress NGINX upstream.

Os clusters automáticos existentes não são afetados, mas devem iniciar a migração para a API de Gateway do Kubernetes por meio do complemento de roteamento de aplicativos.

Limitações

As seguintes limitações se aplicam aos clusters automáticos do AKS:

O AKS Automatic geralmente está disponível nas seguintes regiões: australiacentral, australiaeast, australiasoutheast, austriaeast, belgiumcentral, brazilsouth, canadaeast, southeastasia, southcentralus, southafricanorth, polandcentral, southindia, eastus2, francecentral, eastus, germanywestcentral, eastasia, indonesiacentral, denmarkeast, israelcentral, chilecentral, italynorth, centralus, japaneast, japanwest, canadacentral, norwayeast, northeurope, koreacentral, koreasouth, northcentralus, centralindia, newzealandnorth, mexicocentral, malaysiawest, swedencentral, uksouth, uaenorth, switzerlandnorth, spaincentral, ukwest, westcentralus, westeurope, westus, westus3, westus2.
Os novos clusters AKS automáticos, por padrão, habilitam pools de nós de sistema gerenciados e LocalDNS. Você não pode criar clusters automáticos do AKS sem pools de nós do sistema gerenciado em qualquer região.
O cluster automático do AKS tem bloqueio do grupo de recursos de nó pré-configurado, o que não permite alterações no MC_ grupo de recursos MC_, impedindo links de VNet na zona DNS privada padrão. Para cenários de DNS entre redes virtuais (VNets) ou DNS personalizado, use uma rede personalizada e um DNS privado seguindo as instruções em Criar um cluster automático do AKS (Serviço de Kubernetes do Azure) privado em uma rede virtual personalizada.
CLI do Azure versão 2.86.0 ou posterior é necessária. Para localizar a versão, execute az --version o comando. Se precisar instalar ou atualizar, consulte Instalar CLI do Azure.
Não há suporte para as seguintes extensões:
- Dapr
- Azure Machine Learning
Não há suporte para nós do Windows.
Não há suporte para a migração do SKU base do AKS para o SKU automático.
Há suporte, em versão prévia, para a migração de um cluster AKS Automatic existente sem pools de nós de sistema gerenciados para o AKS Automatic com pools de nós de sistema gerenciados, nas regiões em que esses pools estão em disponibilidade geral. Não há suporte para migrar do AKS Automatic com pools de nós do sistema gerenciados de volta para o AKS Automatic sem pools de nós do sistema gerenciados.

Criar um grupo de recursos

Um grupo de recursos Azure é um grupo lógico no qual Azure recursos são implantados e gerenciados.

Crie um grupo de recursos usando o comando az group create. O exemplo a seguir cria um grupo de recursos chamado myResourceGroup no local canadacentral :

az group create --name myResourceGroup --location canadacentral

A saída de exemplo a seguir é semelhante à criação bem-sucedida do grupo de recursos:

{
  "id": "/subscriptions/<guid>/resourceGroups/myResourceGroup",
  "location": "canadacentral",
  "managedBy": null,
  "name": "myResourceGroup",
  "properties": {
    "provisioningState": "Succeeded"
  },
  "tags": null
}

Criar um cluster do AKS Automático

Crie um cluster automático do AKS usando o az aks create comando com o --sku parâmetro definido como automatic. O exemplo a seguir cria um cluster chamado myAKSAutomaticCluster com o Managed Prometheus e a integração do Container Insights habilitada:

az aks create \
    --resource-group myResourceGroup \
    --name myAKSAutomaticCluster \
    --sku automatic
    --enable-hosted-system

Quando a implantação terminar, a saída exibirá uma propriedade hostedSystemProfile, com a propriedade enabled definida como true. Você também pode executar o seguinte comando para exibir as hostedSystemProfile propriedades:

az aks show \
  --resource-group myResourceGroup \
  --name myAKSAutomaticCluster \
  --query hostedSystemProfile

{
  "enabled": true,
  "nodeSubnetId": null,
  "systemNodeSubnetId": null
}

Criar cluster do Kubernetes Automático

Para criar um cluster automático do AKS, pesquise e selecione os serviços do Kubernetes. Isso leva você à página do centro de Kubernetes (versão prévia).
Na página centro do Kubernetes (versão preliminar), selecione Criar>cluster do Kubernetes Automático.
Na guia Noções básicas , preencha todos os campos necessários (Assinatura, Grupo de recursos, nome do cluster do Kubernetes e Região) e selecione Avançar.
Na guia Monitoramento, selecione as configurações de monitoramento desejadas em Azure Monitor (Insights do contêiner), Prometheus gerenciado, Painéis do Grafana e Alertas e selecione Próximo.
Na guia Avançado, selecione as configurações avançadas desejadas: acesso privado, Rede Virtual do Azure, Identidade Gerenciada, Segurança de Rede de Contêiner (ACNS) e Namespaces do Kubernetes Gerenciado e selecione Revisar + criar.
Examine as configurações na guia Examinar + criar e, em seguida, selecione Criar para implantar o cluster automático do AKS.
Comece a configurar seu primeiro aplicativo de GitHub e configure um pipeline de implantação automatizado.

Examinar o arquivo Bicep

O seguinte arquivo Bicep define um cluster automático do AKS:

@description('The name of the managed cluster resource.')
param clusterName string = 'myAKSAutomaticCluster'

@description('The location of the managed cluster resource.')
param location string = resourceGroup().location

resource aks 'Microsoft.ContainerService/managedClusters@2026-02-01' ' = {
  name: clusterName
  location: location
  sku: {
    name: 'Automatic'
  }
  identity: {
    type: 'SystemAssigned'
  }
}

Para obter mais informações sobre o recurso definido no arquivo Bicep, consulte a referência Microsoft.ContainerService/managedClusters.

Implantar o arquivo de Bicep

Salve o arquivo Bicep como main.bicep ao computador local.

Importante

O arquivo Bicep define o parâmetro clusterName para a cadeia de caracteres myAKSAutomaticCluster. Se você quiser usar um nome de cluster diferente, certifique-se de atualizar a cadeia de caracteres para o nome do cluster preferido antes de salvar o arquivo em seu computador.
Implante o arquivo Bicep usando o comando [az deployment group create][az-deployment-group-create].
```
az deployment group create --resource-group myResourceGroup --template-file main.bicep
```
Leva alguns minutos para o cluster do AKS ser criado. Aguarde até que o cluster seja implantado com êxito antes de passar para a próxima etapa.

Revisar o código Terraform

Observação

O código de exemplo deste artigo está localizado no repositório GitHub do Azure Terraform. Você pode exibir o arquivo de log que contém os resultados dos testes das versões atuais e anteriores do Terraform.

Veja mais artigos e exemplos de código mostrando como usar o Terraform para gerenciar recursos do Azure.

Crie um diretório para testar o código terraform de exemplo e defini-lo como o diretório atual.

Crie um arquivo chamado providers.tf e insira o seguinte código:

terraform {
  required_version = ">= 1.0"
  required_providers {
    azurerm = {
      source  = "hashicorp/azurerm"
      version = "~>5.0"
    }
    random = {
      source  = "hashicorp/random"
      version = "~>3.0"
    }
  }
}

provider "azurerm" {
  features {}
}

Crie um arquivo nomeado main.tf e adicione o seguinte código:

# Create a random name for the resource group using random_pet
resource "random_pet" "rg_name" {
  prefix = var.resource_group_name_prefix
}

# Create a resource group using the generated random name
resource "azurerm_resource_group" "rg" {
  location = var.resource_group_location
  name     = random_pet.rg_name.id
}

# Create a random name for the AKS Automatic cluster
resource "random_pet" "cluster_name" {
  prefix = var.cluster_name_prefix
}

# Create the AKS Automatic cluster
resource "azurerm_kubernetes_automatic_cluster" "aks_automatic" {
  name                = random_pet.cluster_name.id
  location            = azurerm_resource_group.rg.location
  resource_group_name = azurerm_resource_group.rg.name

  identity {
    type = "SystemAssigned"
  }
}

Crie um arquivo nomeado variables.tf e adicione o seguinte código:

variable "resource_group_location" {
  type        = string
  default     = "westus2"
  description = "Location of the resource group."
}

variable "resource_group_name_prefix" {
  type        = string
  default     = "rg"
  description = "Prefix of the resource group name that's combined with a random ID so name is unique in your Azure subscription."
}

variable "cluster_name_prefix" {
  type        = string
  default     = "aks-automatic"
  description = "Prefix of the AKS Automatic cluster name that's combined with a random ID so the name is unique in your Azure subscription."
}

Crie um arquivo chamado outputs.tf e insira o seguinte código:

output "resource_group_name" {
  value = azurerm_resource_group.rg.name
}

output "cluster_name" {
  value = azurerm_kubernetes_automatic_cluster.aks_automatic.name
}

output "cluster_id" {
  value = azurerm_kubernetes_automatic_cluster.aks_automatic.id
}

output "node_resource_group_id" {
  value = azurerm_kubernetes_automatic_cluster.aks_automatic.node_resource_group_id
}

output "fully_qualified_domain_name" {
  value = azurerm_kubernetes_automatic_cluster.aks_automatic.fully_qualified_domain_name
}

Inicializar Terraform

Execute terraform init para inicializar a implantação do Terraform. Esse comando baixa os provedores de Azure necessários para gerenciar seus recursos de Azure.

terraform init -upgrade

Criar um plano de execução do Terraform

Execute o comando terraform plan para criar um plano de execução.

terraform plan -out main.tfplan

Aplicar um plano de execução do Terraform

Execute o comando terraform apply para aplicar o plano de execução à sua infraestrutura de nuvem.

terraform apply main.tfplan

A criação de um cluster automático do AKS leva vários minutos para ser concluída.

Verificar o cluster

Obtenha o nome do grupo de recursos Azure e o nome do cluster.

resource_group_name=$(terraform output -raw resource_group_name)
cluster_name=$(terraform output -raw cluster_name)

Execute az aks show para exibir o cluster e confirmar se ele usa o Automatic SKU.

az aks show --resource-group $resource_group_name --name $cluster_name --query "{name:name, sku:sku, provisioningState:provisioningState}"

Conectar-se ao cluster

Para gerenciar um cluster do Kubernetes, use o cliente de linha de comando do Kubernetes, kubectl. kubectl já está instalado se você usar Azure Cloud Shell. Você pode instalar kubectl localmente usando o az aks install-cli comando. Os clusters automáticos do AKS são configurados com Microsoft Entra ID para controle de acesso baseado em funções do Kubernetes (RBAC).

Observação

Quando você cria um cluster usando o CLI do Azure, o usuário é atribuído a funções internas para Serviço de Kubernetes do Azure RBAC Cluster Admin.

Configure o kubectl para se conectar ao cluster do Kubernetes usando o comando az aks get-credentials. Este comando baixa as credenciais e configura a CLI do Kubernetes para usá-las.
```
az aks get-credentials --resource-group myResourceGroup --name myAKSAutomaticCluster
```

Configure kubectl para se conectar ao cluster do Kubernetes usando o az aks get-credentials comando. Este comando baixa as credenciais e configura a CLI do Kubernetes para usá-las.
```
az aks get-credentials --resource-group $resource_group_name --name $cluster_name
```

Verifique a conexão com o cluster usando o comando kubectl get. Esse comando retorna uma lista dos nós de cluster.

kubectl get nodes

O resultado de exemplo a seguir mostra como é solicitado que você faça login:

To sign in, use a web browser to open the page https://microsoft.com/devicelogin and enter the code AAAAAAAAA to authenticate.

Depois de fazer login, o exemplo de saída a seguir mostra os conjuntos de nós do sistema gerenciado. Verifique se que o status do nó é Pronto.

NAME                           STATUS   ROLES    AGE   VERSION
aks-hostedpool-16652789-vms1   Ready    <none>   19m   v1.34.7
aks-hostedpool-16652789-vms2   Ready    <none>   19m   v1.34.7
aks-hostedpool-16652789-vms3   Ready    <none>   19m   v1.34.7
aks-system-surge-zq4d2         Ready    <none>   19m   v1.34.7

Implantar o aplicativo

Para implantar o aplicativo, use um arquivo de manifesto para criar todos os objetos necessários para executar o aplicativo AKS Store. Um arquivo de manifesto do Kubernetes define o estado desejado de um cluster, por exemplo, as imagens de contêiner a serem executadas. O manifesto inclui as seguintes implantações e serviços do Kubernetes:

Vitrine Web: aplicativo Web para clientes visualizarem produtos e fazerem pedidos.
Serviço de produto: mostra informações do produto.
Serviço de pedido: realiza pedidos.
Rabbit MQ: fila de mensagens para uma fila de pedidos.

Observação

Não é recomendável executar contêineres com estado, como o Rabbit MQ, sem armazenamento persistente para produção. Elas são usadas aqui para simplificar, mas recomendamos o uso de serviços gerenciados, como Azure Cosmos DB ou Barramento de Serviço do Azure.

Crie um namespace aks-store-demo onde você irá implantar os recursos do Kubernetes.
```
kubectl create ns aks-store-demo
```

Implante o aplicativo usando o comando kubectl apply no namespace aks-store-demo. O arquivo YAML que define a implantação está em GitHub.

kubectl apply -n aks-store-demo -f https://raw.githubusercontent.com/Azure-Samples/aks-store-demo/main/aks-store-ingress-quickstart.yaml

A amostra de saída a seguir mostra as implantações e os serviços:

statefulset.apps/rabbitmq created
configmap/rabbitmq-enabled-plugins created
service/rabbitmq created
deployment.apps/order-service created
service/order-service created
deployment.apps/product-service created
service/product-service created
deployment.apps/store-front created
service/store-front created
ingress/store-front created

Testar o aplicativo

Quando o aplicativo é executado, um serviço de Kubernetes expõe o front-end do aplicativo à Internet. A conclusão desse processo pode levar alguns minutos.

Verifique o status dos pods implantados usando o comando kubectl get pods. Garanta que todos os pods estejam Running, antes de continuar. Se essa for a primeira carga de trabalho que você implanta, pode levar alguns minutos para que o provisionamento automático de nós crie um pool de nós para executar os pods.
```
kubectl get pods -n aks-store-demo
```

Verifique se há um endereço IP público para o aplicativo de store-front. Monitore o andamento usando o comando kubectl get service com o argumento --watch.

kubectl get ingress store-front -n aks-store-demo --watch

A saída ADDRESS para o serviço store-front inicialmente aparece vazia:

NAME          CLASS                                HOSTS   ADDRESS        PORTS   AGE
store-front   webapprouting.kubernetes.azure.com   *                      80      12m

Quando o ADDRESS muda de vazio para um endereço IP público real, use CTRL-C para interromper o processo de inspeção do kubectl.

A seguinte saída de exemplo mostra um endereço de IP público válido atribuído ao serviço:
```
NAME          CLASS                                HOSTS   ADDRESS        PORTS   AGE
store-front   webapprouting.kubernetes.azure.com   *       4.255.22.196   80      12m
```
Abra um navegador da web para o endereço IP externo da sua entrada para ver o aplicativo do Azure Store em ação.

Excluir o cluster

Se você não planeja passar pelo tutorial AKS, limpe os recursos desnecessários para evitar custos no Azure.

Remova o grupo de recursos, o serviço de contêiner e todos os recursos relacionados usando o comando az group delete.

az group delete --name myResourceGroup --yes --no-wait

Observação

O cluster do AKS foi criado com uma identidade gerenciada atribuída pelo sistema, que é a opção de identidade padrão usada neste início rápido. A plataforma gerencia essa identidade, para que você não precise removê-la manualmente.

Quando não precisar mais dos recursos criados com o Terraform, execute terraform plan e especifique a flag destroy.

terraform plan -destroy -out main.destroy.tfplan

Execute o comando terraform apply para aplicar o plano de execução.

terraform apply main.destroy.tfplan

Nesse início rápido, você implantou um cluster do Kubernetes usando o AKS Automático e, a seguir, implantou nele um aplicativo simples com vários contêineres. Esse aplicativo de exemplo é apenas para fins de demonstração e não representa todas as melhores práticas para aplicativos do Kubernetes. Para obter diretrizes sobre como criar soluções completas com o AKS para produção, consulte Diretrizes sobre a solução AKS.

Para saber mais sobre o AKS Automatic, consulte o Introduction to AKS (Serviço de Kubernetes do Azure) Automatic

Comentários

Esta página foi útil?

Last updated on 2026-09-16

Início Rápido: Criar um cluster AKS (Serviço de Kubernetes do Azure) Automático

Antes de começar

Limitações

Criar um grupo de recursos

Criar um cluster do AKS Automático

Criar cluster do Kubernetes Automático

Examinar o arquivo Bicep

Implantar o arquivo de Bicep

Revisar o código Terraform

Inicializar Terraform

Criar um plano de execução do Terraform

Aplicar um plano de execução do Terraform

Verificar o cluster

Conectar-se ao cluster

Implantar o aplicativo

Testar o aplicativo

Excluir o cluster

Conteúdo relacionado

Comentários

Recursos adicionais