Compartilhar via

Início Rápido: Criar um cluster automático do AKS (Serviço de Kubernetes do Azure) (versão prévia) em uma rede virtual personalizada

Aplica-se a: ✔️ AKS Automático (versão prévia)

O Serviço de Kubernetes do Azure (AKS) Automático (versão prévia) fornece a experiência de Kubernetes gerenciada mais fácil que existe para desenvolvedores, engenheiros de DevOps e engenheiros de plataforma. Ideal para aplicativos modernos e de IA, o AKS Automático automatiza a instalação e as operações de clusters do AKS e incorpora as boas práticas de configurações. Usuários de todos os níveis de habilidade podem se beneficiar da segurança, do desempenho e da confiabilidade do AKS Automático para seus aplicativos. Este guia de início rápido pressupõe uma compreensão básica dos conceitos do Kubernetes. Para obter mais informações, confira Principais conceitos do Kubernetes para o AKS (Serviço de Kubernetes do Azure).

Neste início rápido, você aprenderá a:

  • Crie uma rede virtual.
  • Crie uma identidade gerenciada com permissões na rede virtual.
  • Implantar um cluster automático do AKS na rede virtual.
  • 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.

Se você ainda não tem uma conta do Azure, crie uma conta gratuita.

Pré-requisitos

Pré-requisito Anotações
Azure CLI 2.68.0 ou posterior instalado. Para saber qual é a versão, execute az --version. Se você precisa instalar ou atualizar, consulte Instalar a CLI do Azure.
Extensão aks-preview da CLI do Azure 13.0.0b3 ou posterior. Para saber qual é a versão, execute az --version. Se você precisar instalar ou atualizar, consulte Gerenciar extensões da CLI do Azure.
Sinalizadores de recurso AutomaticSKUPreview deve ser registrado na assinatura para usar o AKS Automatic.
Permissões necessárias Identidade do cluster com uma atribuição de função interna Network Contributor na sub-rede do servidor de API.
Identidade do cluster com uma atribuição de função interna Network Contributor na rede virtual para dar suporte ao provisionamento automático de nó.
Identidade do usuário que cria o cluster com as permissões Microsoft.Authorization/policyAssignments/write e Microsoft.Authorization/policyAssignments/read no grupo de recursos. Para obter mais informações, consulte as permissões do Azure Policy.
Identidade do usuário acessando o cluster com Azure Kubernetes Service Cluster User Role e Azure Kubernetes Service RBAC Writer
Requisitos de rede Uma rede virtual com uma sub-rede dedicada para servidor de API de pelo menos */28 de tamanho, que é delegada a Microsoft.ContainerService/managedClusters
Se houver um NSG (Grupo de Segurança de Rede) anexado a sub-redes específicas, verifique se as regras permitem o seguinte tráfego entre os nós e o servidor de API, o Azure Load Balancer e o servidor de API, e a comunicação entre pods.
Se houver um Firewall do Azure ou outro método de restrição de saída ou dispositivo, verifique se as regras de rede de saída necessárias e os FQDNs são permitidos.

Limitações

  • Os clusters automáticos do AKS com redes virtuais personalizadas dão suporte apenas à identidade gerenciada atribuída pelo usuário.
  • Os clusters automáticos do AKS com redes virtuais personalizadas não dão suporte ao tipo de saída do Gateway de NAT Gerenciado.
  • Os clusters automáticos do AKS exigem implantação em regiões do Azure que dão suporte a pelo menos três zonas de disponibilidade e à integração da VNet do Servidor de API.

Importante

O AKS Automático tenta selecionar dinamicamente um tamanho de máquina virtual para o pool de nós system com base na capacidade disponível na assinatura. Verifique se sua assinatura tem cota para 16 vCPUs de qualquer um dos seguintes tamanhos na região em que você está implantando o cluster: Standard_D4pds_v5, Standard_D4lds_v5, Standard_D4ads_v5, Standard_D4ds_v5, Standard_D4d_v5, Standard_D4d_v4, Standard_DS3_v2, Standard_DS12_v2. Você pode ver as cotas para famílias de VM específicas e enviar solicitações de aumento de cota por meio do portal do Azure.

Instalar a extensão aks-preview da CLI do Azure

Importante

As funcionalidades em versão preliminar do AKS estão disponíveis de forma optativa e por autoatendimento. As versões prévias são fornecidas “no estado em que se encontram” e “conforme disponíveis” e são excluídas dos contratos de nível de serviço e da garantia limitada. As versões prévias do AKS são parcialmente cobertas pelo suporte ao cliente em uma base de melhor esforço. Dessa forma, esses recursos não são destinados ao uso em produção. Para obter mais informações, consulte os seguintes artigos:

Para instalar a extensão aks-preview, execute o seguinte comando:

az extension add --name aks-preview

Execute o seguinte comando para atualizar para a versão mais recente da extensão lançada:

az extension update --name aks-preview

Registrar os sinalizadores do recurso

Para usar o AKS Automatic na versão prévia, registre o sinalizador a seguir usando o comando az feature register .

az feature register --namespace Microsoft.ContainerService --name AutomaticSKUPreview

Verifique o status do registro usando o comando az feature show. Leva alguns minutos para que o status mostre Registrado:

az feature show --namespace Microsoft.ContainerService --name AutomaticSKUPreview

Quando o status reflete Registrado, atualize o registro do provedor de recursos Microsoft.ContainerService usando o comando az provider register:

az provider register --namespace Microsoft.ContainerService

Definir variáveis

Defina as variáveis a seguir que serão usadas nas etapas subsequentes.

RG_NAME=automatic-rg
VNET_NAME=automatic-vnet
CLUSTER_NAME=automatic
IDENTITY_NAME=automatic-uami
LOCATION=eastus
SUBSCRIPTION_ID=$(az account show --query id -o tsv)

Criar um grupo de recursos

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

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

az group create -n ${RG_NAME} -l ${LOCATION}

A amostra de resultado a seguir se parece com uma criação bem-sucedida do grupo de recursos:

{
  "id": "/subscriptions/<guid>/resourceGroups/automatic-rg",
  "location": "eastus",
  "managedBy": null,
  "name": "automatic-rg",
  "properties": {
    "provisioningState": "Succeeded"
  },
  "tags": null
}

Criar uma rede virtual

Criar uma rede virtual usando o comando az network vnet create. Crie uma sub-rede do servidor de API e uma sub-rede de cluster usando o az network vnet subnet create comando.

Ao usar uma rede virtual personalizada com o AKS Automático, você deve criar e delegar uma sub-rede de servidor de API para Microsoft.ContainerService/managedClusters, o que concede ao serviço AKS permissões para injetar os pods do servidor de API e o balanceador de carga interno nessa sub-rede. Você não pode usar a sub-rede para nenhuma outra carga de trabalho, mas pode usá-la para vários clusters do AKS localizados na mesma rede virtual. O tamanho mínimo com suporte da sub-rede do servidor de API é /28.

Aviso

Um cluster do AKS reserva pelo menos 9 IPs no espaço de endereço da sub-rede. O esgotamento de endereços IP pode impedir o dimensionamento do servidor de API e causar uma interrupção no servidor de API.

az network vnet create --name ${VNET_NAME} \
--resource-group ${RG_NAME} \
--location ${LOCATION} \
--address-prefixes 172.19.0.0/16

az network vnet subnet create --resource-group ${RG_NAME} \
--vnet-name ${VNET_NAME} \
--name apiServerSubnet \
--delegations Microsoft.ContainerService/managedClusters \
--address-prefixes 172.19.0.0/28

az network vnet subnet create --resource-group ${RG_NAME} \
--vnet-name ${VNET_NAME} \
--name clusterSubnet \
--address-prefixes 172.19.1.0/24

Regras de grupo de segurança de rede

Todo o tráfego dentro da rede virtual é permitido por padrão. Mas se você adicionou regras de NSG (Grupo de Segurança de Rede) para restringir o tráfego entre sub-redes diferentes, verifique se as regras de segurança do NSG permitem os seguintes tipos de comunicação:

Destino Fonte Protocolo Porto Utilização
CIDR de sub-rede do APIServer Sub-rede de cluster TCP 443 e 4443 Necessário para habilitar a comunicação entre nós e o servidor de API.
CIDR de sub-rede do APIServer Balanceador de Carga Azure TCP 9988 Necessário para habilitar a comunicação entre o Azure Load Balancer e o servidor de API. Você também pode habilitar toda a comunicação entre o Azure Load Balancer e o CIDR da Sub-rede do Servidor de API.
CIDR do nó CIDR do nó Todos os protocolos Todas as portas Necessário para habilitar a comunicação entre nós.
CIDR do nó CIDR do pod Todos os protocolos Todas as portas Necessário para o roteamento de tráfego de serviço.
CIDR do pod CIDR do pod Todos os protocolos Todas as portas Necessário para tráfego entre pods e de pod para serviço, incluindo o DNS.

Criar uma identidade gerenciada e conceder a ela permissões na rede virtual

Crie uma identidade gerenciada usando o comando az identity create e recupere a ID principal. Atribua a função Colaborador de Rede na rede virtual à identidade gerenciada usando o az role assignment create comando.

az identity create \
--resource-group ${RG_NAME} \
 --name ${IDENTITY_NAME} \
 --location ${LOCATION}

IDENTITY_PRINCIPAL_ID=$(az identity show --resource-group ${RG_NAME} --name ${IDENTITY_NAME} --query principalId -o tsv)

az role assignment create \
--scope "/subscriptions/${SUBSCRIPTION_ID}/resourceGroups/${RG_NAME}/providers/Microsoft.Network/virtualNetworks/${VNET_NAME}" \
--role "Network Contributor" \
--assignee ${IDENTITY_PRINCIPAL_ID}

Criar um cluster automático do AKS em uma rede virtual personalizada

Para criar um cluster do AKS Automático, use o comando az aks create.

az aks create \
--resource-group ${RG_NAME} \
--name ${CLUSTER_NAME} \
--location ${LOCATION} \
--apiserver-subnet-id "/subscriptions/${SUBSCRIPTION_ID}/resourceGroups/${RG_NAME}/providers/Microsoft.Network/virtualNetworks/${VNET_NAME}/subnets/apiServerSubnet" \
--vnet-subnet-id "/subscriptions/${SUBSCRIPTION_ID}/resourceGroups/${RG_NAME}/providers/Microsoft.Network/virtualNetworks/${VNET_NAME}/subnets/clusterSubnet" \
--assign-identity "/subscriptions/${SUBSCRIPTION_ID}/resourcegroups/${RG_NAME}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/${IDENTITY_NAME}" \
--sku automatic \
--no-ssh-key

Após alguns minutos, o comando será concluído e retornará informações no formato JSON sobre o cluster.

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ê usa o Azure Cloud Shell. Para instalar o kubectl localmente, use o comando az aks install-cli. Os clusters do AKS Automático são configurados com o Microsoft Entra ID para o controle de acesso baseado em função ( RBAC) do Kubernetes.

Quando você cria um cluster usando a CLI do Azure, funções integradas são atribuídas ao seu usuário para Azure Kubernetes Service 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 ${RG_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

A saída de exemplo a seguir mostra como é solicitado o logon.

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

Depois que você fizer logon, a saída de exemplo a seguir mostrará os pools de nós do sistema gerenciado. Verifique se que o status do nó é Pronto.

NAME                                STATUS   ROLES   AGE     VERSION
aks-nodepool1-13213685-vmss000000   Ready    agent   2m26s   v1.28.5
aks-nodepool1-13213685-vmss000001   Ready    agent   2m26s   v1.28.5
aks-nodepool1-13213685-vmss000002   Ready    agent   2m26s   v1.28.5

Criar um grupo de recursos

Um grupo de recursos do Azure é um grupo lógico no qual os recursos do Azure são implantados e gerenciados. Ao criar um grupo de recursos, você é solicitado a especificar um local. Essa é a localização na qual os metadados do grupo de recursos são armazenados e na qual os recursos são executados no Azure, caso você não especifique outra região durante a criação de recursos.

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

az group create --name <resource-group> --location <location>

A amostra de resultado a seguir se parece com uma criação bem-sucedida do grupo de recursos:

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

Criar uma rede virtual

Esse arquivo Bicep define uma rede virtual.

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

@description('The name of the virtual network.')
param vnetName string = 'aksAutomaticVnet'

@description('The address prefix of the virtual network.')
param addressPrefix string = '172.19.0.0/16'

@description('The name of the API server subnet.')
param apiServerSubnetName string = 'apiServerSubnet'

@description('The subnet prefix of the API server subnet.')
param apiServerSubnetPrefix string = '172.19.0.0/28'

@description('The name of the cluster subnet.')
param clusterSubnetName string = 'clusterSubnet'

@description('The subnet prefix of the cluster subnet.')
param clusterSubnetPrefix string = '172.19.1.0/24'

// Virtual network with an API server subnet and a cluster subnet
resource virtualNetwork 'Microsoft.Network/virtualNetworks@2023-09-01' = {
    name: vnetName
    location: location
    properties: {
        addressSpace: {
            addressPrefixes: [ addressPrefix ]
        }
        subnets: [
            {
                name: apiServerSubnetName
                properties: {
                    addressPrefix: apiServerSubnetPrefix
                }
            }
            {
                name: clusterSubnetName
                properties: {
                    addressPrefix: clusterSubnetPrefix
                }
            }
        ]
    }
}

output apiServerSubnetId string = resourceId('Microsoft.Network/virtualNetworks/subnets', vnetName, apiServerSubnetName)
output clusterSubnetId string = resourceId('Microsoft.Network/virtualNetworks/subnets', vnetName, clusterSubnetName)

Salve o arquivo Bicep virtualNetwork.bicep no computador local.

Importante

O arquivo Bicep define o vnetName parâmetro como aksAutomaticVnet, o addressPrefix param para 172.19.0.0/16, o apiServerSubnetPrefix parâmetro para 172.19.0.0/28 e o apiServerSubnetPrefix parâmetro para 172.19.1.0/24. Se você quiser usar valores diferentes, atualize as cadeias de caracteres para seus valores preferenciais.

Implante o arquivo Bicep usando a CLI do Azure.

az deployment group create --resource-group <resource-group> --template-file virtualNetwork.bicep

Todo o tráfego dentro da rede virtual é permitido por padrão. Mas se você adicionou regras de NSG (Grupo de Segurança de Rede) para restringir o tráfego entre sub-redes diferentes, verifique se as regras de segurança do NSG permitem os seguintes tipos de comunicação:

Destino Fonte Protocolo Porto Utilização
CIDR de sub-rede do APIServer Sub-rede de cluster TCP 443 e 4443 Necessário para habilitar a comunicação entre nós e o servidor de API.
CIDR de sub-rede do APIServer Balanceador de Carga Azure TCP 9988 Necessário para habilitar a comunicação entre o Azure Load Balancer e o servidor de API. Você também pode habilitar toda a comunicação entre o Azure Load Balancer e o CIDR da Sub-rede do Servidor de API.

Criar uma identidade gerenciada

Esse arquivo Bicep define uma identidade gerenciada atribuída pelo usuário.

param location string = resourceGroup().location
param uamiName string = 'aksAutomaticUAMI'

resource userAssignedManagedIdentity 'Microsoft.ManagedIdentity/userAssignedIdentities@2023-01-31' = {
  name: uamiName
  location: location
}

output uamiId string = userAssignedManagedIdentity.id
output uamiPrincipalId string = userAssignedManagedIdentity.properties.principalId
output uamiClientId string = userAssignedManagedIdentity.properties.clientId

Salve o arquivo Bicep uami.bicep no computador local.

Importante

O arquivo Bicep define o uamiName parâmetro como aksAutomaticUAMI. Se você quiser usar um nome de identidade diferente, atualize a cadeia de caracteres para seu nome preferido.

Implante o arquivo Bicep usando a CLI do Azure.

az deployment group create --resource-group <resource-group> --template-file uami.bicep

Atribuir a função Colaborador de rede na rede virtual

Esse arquivo Bicep define atribuições de função na rede virtual.

@description('The name of the virtual network.')
param vnetName string = 'aksAutomaticVnet'

@description('The principal ID of the user assigned managed identity.')
param uamiPrincipalId string

// Get a reference to the virtual network
resource virtualNetwork 'Microsoft.Network/virtualNetworks@2023-09-01' existing ={
  name: vnetName
}

// Assign the Network Contributor role to the user assigned managed identity on the virtual network
// '4d97b98b-1d4f-4787-a291-c67834d212e7' is the built-in Network Contributor role definition
// See: https://learn.microsoft.com/en-us/azure/role-based-access-control/built-in-roles/networking#network-contributor
resource networkContributorRoleAssignmentToVirtualNetwork 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
  name: guid(uamiPrincipalId, '4d97b98b-1d4f-4787-a291-c67834d212e7', resourceGroup().id, virtualNetwork.name)
  scope: virtualNetwork
  properties: {
      roleDefinitionId: resourceId('Microsoft.Authorization/roleDefinitions', '4d97b98b-1d4f-4787-a291-c67834d212e7')
      principalId: uamiPrincipalId
  }
}

Salve o arquivo Bicep roleAssignments.bicep no computador local.

Importante

O arquivo Bicep define o vnetName parâmetro como aksAutomaticVnet. Se você usou um nome de rede virtual diferente, atualize a cadeia de caracteres para seu nome de rede virtual preferido.

Implante o arquivo Bicep usando a CLI do Azure. Você precisa fornecer a ID da entidade de segurança da identidade atribuída pelo usuário.

az deployment group create --resource-group <resource-group> --template-file roleAssignments.bicep \
--parameters uamiPrincipalId=<user assigned identity prinicipal id>

Criar um cluster automático do AKS em uma rede virtual personalizada

Esse arquivo Bicep define o cluster do AKS Automático.

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

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

@description('The resource ID of the API server subnet.')
param apiServerSubnetId string

@description('The resource ID of the cluster subnet.')
param clusterSubnetId string

@description('The resource ID of the user assigned managed identity.')
param uamiId string

/// Create the AKS Automatic cluster using the custom virtual network and user assigned managed identity
resource aks 'Microsoft.ContainerService/managedClusters@2024-03-02-preview' = {
  name: clusterName
  location: location  
  sku: {
    name: 'Automatic'
  }
  properties: {
    agentPoolProfiles: [
      {
        name: 'systempool'
        mode: 'System'
          count: 3
        vnetSubnetID: clusterSubnetId
      }
    ]
    apiServerAccessProfile: {
        subnetId: apiServerSubnetId
    }
    networkProfile: {
      outboundType: 'loadBalancer'
    }
  }
  identity: {
    type: 'UserAssigned'
    userAssignedIdentities: {
      '${uamiId}': {}
    }
  }
}

Salve o arquivo Bicep aks.bicep no computador local.

Importante

O arquivo Bicep define o clusterName parâmetro como aksAutomaticCluster. Se você quiser um nome de cluster diferente, atualize a cadeia de caracteres para seu nome de cluster preferido.

Implante o arquivo Bicep usando a CLI do Azure. Você precisa fornecer o ID do recurso da sub-rede do servidor de API, o ID do recurso da sub-rede do cluster e o ID principal da identidade atribuída pelo usuário.

az deployment group create --resource-group <resource-group> --template-file aks.bicep \
--parameters apiServerSubnetId=<API server subnet resource id> \
--parameters clusterSubnetId=<cluster subnet resource id> \
--parameters uamiPrincipalId=<user assigned identity prinicipal id>

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ê usa o Azure Cloud Shell. Para instalar o kubectl localmente, use o comando az aks install-cli. Os clusters do AKS Automático são configurados com o Microsoft Entra ID para o controle de acesso baseado em função ( RBAC) do Kubernetes.

Importante

Ao criar um cluster usando o Bicep, você precisa atribuir uma das funções internas, como Azure Kubernetes Service RBAC Reader, Azure Kubernetes Service RBAC Writerou Azure Kubernetes Service RBAC AdminAzure Kubernetes Service RBAC Cluster Admin aos usuários, com escopo para o cluster ou um namespace específico, exemplo usando az role assignment create --role "Azure Kubernetes Service RBAC Cluster Admin" --scope <AKS cluster resource id> --assignee user@contoso.com. Além disso, certifique-se de que seus usuários tenham uma função integrada de Azure Kubernetes Service Cluster User para poderem executar az aks get-credentials e, a seguir, obter o kubeconfig do seu cluster do AKS usando o comando az aks get-credentials.

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 <resource-group> --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

A saída de exemplo a seguir mostra como é solicitado o logon.

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

Depois que você fizer logon, a saída de exemplo a seguir mostrará os pools de nós do sistema gerenciado. Verifique se que o status do nó é Pronto.

NAME                                STATUS   ROLES   AGE     VERSION
aks-nodepool1-13213685-vmss000000   Ready    agent   2m26s   v1.28.5
aks-nodepool1-13213685-vmss000001   Ready    agent   2m26s   v1.28.5
aks-nodepool1-13213685-vmss000002   Ready    agent   2m26s   v1.28.5

Implantar o aplicativo

A fim de implantar o aplicativo, use um arquivo de manifesto para criar todos os objetos necessários para executar o Aplicativo da Loja do AKS. 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:

Captura de tela da arquitetura de exemplo do Microsoft Azure Store.

  • Frente de loja: Aplicativo Web para clientes visualizarem produtos e fazerem pedidos.
  • Serviço do 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. Esses contêineres são usados aqui para simplificar, mas recomendamos o uso de serviços gerenciados, como o Azure Cosmos DB ou o Barramento de Serviço do Azure.

  1. Crie um namespace aks-store-demo onde você irá implantar os recursos do Kubernetes.

    kubectl create ns aks-store-demo

  2. Implante o aplicativo usando o comando kubectl apply no namespace aks-store-demo. O arquivo YAML que define a implantação está no 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.

  1. 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ê está implantando, pode levar alguns minutos para que o provisionamento automático de nó crie um pool de nós para executar os pods.

    kubectl get pods -n aks-store-demo

  2. 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

  3. 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

  4. Abra um navegador da web para o endereço IP externo da sua entrada para ver o aplicativo da Microsoft Azure Store em ação.

    Captura de tela do aplicativo de exemplo do AKS Store.

Excluir o cluster

Se você não planeja seguir o tutorial do AKS, limpe os recursos desnecessários para evitar cobranças do Azure. Execute o comando az group delete para remover o grupo de recursos, o serviço de contêiner e todos os recursos relacionados.

az group delete --name <resource-group> --yes --no-wait

Observação

O cluster do AKS foi criado com uma identidade gerenciada atribuída pelo usuário. Se você não precisar mais dessa identidade, poderá removê-la manualmente.

Próximas etapas

Neste início rápido, você implantou um cluster kubernetes usando o AKS Automatic dentro de uma rede virtual personalizada e, em seguida, implantou um aplicativo multi-contêiner simples nele. 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 Automático, prossiga para a introdução.

Introdução ao Serviço de Kubernetes do Azure (AKS) Automático (versão prévia)