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

Aplica-se a: ✔️ AKS Automático

AKS (Serviço de Kubernetes do Azure) Automatic fornece a experiência mais fácil gerenciada do Kubernetes 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. O AKS Automatic também inclui um [SLA de preparação para pod] 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. 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).

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ê não tiver uma conta Azure, crie uma conta free.

Pré-requisitos

• 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ós.
• Identidade do usuário acessando o cluster com Serviço de Kubernetes do Azure Cluster User Role e Serviço de Kubernetes do Azure RBAC Writer.
• Uma rede virtual com uma sub-rede dedicada ao servidor de API, de tamanho mínimo */28, delegada a Microsoft.ContainerService/managedClusters.
  • Se houver um NSG (Grupo de Segurança de Rede) anexado a sub-redes, verifique se as regras de segurança do NSG permitem os tipos necessários de comunicação entre componentes de cluster. Para obter requisitos detalhados, consulte os requisitos de rede virtual personalizados.
  • 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 requeridas e os FQDNs necessários são permitidos.
• O recurso AKS Automatic habilitará a Política do Azure em seu cluster do AKS, mas é recomendável registrar previamente o provedor de recursos Microsoft.PolicyInsights em sua assinatura para facilitar o processo. Consulte provedores de recursos e tipos do Azure para obter mais informações.

Limitações

• O nodepool do sistema de clusters automáticos do AKS exige a implantação em regiões Azure que dão suporte a pelo menos três zonas de disponibilidade, o disco de sistema operacional efêmero e o Azure Linux OS.
• O AKS Automatic está disponível nas seguintes regiões: australiaeast, austriaeast, belgiumcentral, brazilsouth, canadacentral, centralindia, centralus, chilecentral, denmarkeast, eastasia, eastus, eastus2, francecentral, germanywestcentral, indonesiacentral, israelcentral, italynorth, japaneast, japanwest, koreacentral, malaysiawest, mexicocentral, newzealandnorth, northcentralus, northeurope, norwayeast, polandcentral, southafricanorth, southcentralus, southeastasia, spaincentral, swedencentral, switzerlandnorth, uaenorth, uksouth, westeurope, westus, westus2, westus3.
• O cluster automático do AKS possui o "node resource group lockdown" pré-configurado, que não permite alterações no grupo de recursos MC_, impedindo links de rede virtual na zona de DNS privado 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.

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

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

A saída de exemplo a seguir é semelhante à 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
}

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

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}

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

az aks get-credentials --resource-group ${RG_NAME} --name ${CLUSTER_NAME}

kubectl get nodes

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

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

@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)

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

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

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

@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
  }
}

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

@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}': {}
    }
  }
}

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 uamiId=<user assigned identity id>

az aks get-credentials --resource-group <resource-group> --name <cluster-name>

kubectl get nodes

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

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

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:

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

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

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

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.