Início Rápido: Implantar um cluster do AKS (Serviço de Kubernetes do Azure) usando a extensão de Kubernetes do Bicep (versão prévia)

O AKS (Serviço de Kubernetes do Azure) é um serviço de Kubernetes gerenciado que permite implantar e gerenciar clusters rapidamente. Neste início rápido, você:

• Implantar um cluster do AKS usando a extensão do Kubernetes do Bicep (versão prévia).
• Executar 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.

{
 "experimentalFeaturesEnabled": {
   "extensibility": true,
 }
}

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, confira Principais conceitos do Kubernetes para o AKS (Serviço de Kubernetes do Azure).

• Caso você não tenha uma assinatura do Azure, crie uma conta gratuita do Azure antes de começar.
• Verifique se a identidade usada para criar seu cluster tem as permissões mínimas apropriadas. Para obter mais detalhes sobre acesso e identidade do AKS, consulte Opções de acesso e identidade para o AKS (Serviço de Kubernetes do Azure).

O Bicep é um DSL (linguagem específica de domínio) que usa sintaxe declarativa para implantar recursos do Azure. Ele fornece sintaxe concisa, segurança de tipos confiável e suporte para reutilização de código. O Bicep oferece a melhor experiência de criação para suas soluções de infraestrutura como código no Azure.

• Para configurar seu ambiente para o desenvolvimento do Bicep, confira Instalar ferramentas do Bicep. Após a conclusão das etapas, você terá o Visual Studio Code e a extensão Bicep. Você também terá a versão da CLI do Azure mais recente ou o módulo do Azure PowerShell mais recente.
• Para criar um cluster do AKS usando um arquivo Bicep, forneça uma chave pública SSH. Se você precisar desse recurso, consulte a seção a seguir. Caso contrário, vá para Examinar o arquivo Bicep.
• Para implantar um arquivo Bicep, é necessário ter acesso de gravação aos recursos que você implanta e acesso a todas as operações no tipo de recurso Microsoft.Resources/deployments. Por exemplo, para implantar uma máquina virtual, você precisa Microsoft.Compute/virtualMachines/write e permissões Microsoft.Resources/deployments/*. Para ver uma lista de funções e permissões, consulte Funções interna do Azure.

Criar um par de chaves SSH

1. Acesse https://shell.azure.com para abrir o Cloud Shell no navegador.

2. Crie um par de chaves SSH usando o az sshkey create comando da CLI do Azure ou o comando ssh-keygen.

   # Create an SSH key pair using Azure CLI
   az sshkey create --name "mySSHKey" --resource-group "myResourceGroup"
   
   # Create an SSH key pair using ssh-keygen
   ssh-keygen -t rsa -b 4096
   

Para obter mais informações sobre como criar chaves SSH, confira Criar e gerenciar chaves SSH para autenticação no Azure.

Examinar o arquivo Bicep

O arquivo Bicep usado para criar um cluster do AKS é proveniente de Modelos de Início Rápido do Azure. Para obter mais amostras do AKS, confira os modelos de início rápido do AKS.

@description('The name of the Managed Cluster resource.')
param clusterName string = 'aks101cluster'

@description('The location of the Managed Cluster resource.')
param location string = resourceGroup().location

@description('Optional DNS prefix to use with hosted Kubernetes API server FQDN.')
param dnsPrefix string

@description('Disk size (in GB) to provision for each of the agent pool nodes. This value ranges from 0 to 1023. Specifying 0 will apply the default disk size for that agentVMSize.')
@minValue(0)
@maxValue(1023)
param osDiskSizeGB int = 0

@description('The number of nodes for the cluster.')
@minValue(1)
@maxValue(50)
param agentCount int = 3

@description('The size of the Virtual Machine.')
param agentVMSize string = 'standard_d2s_v3'

@description('User name for the Linux Virtual Machines.')
param linuxAdminUsername string

@description('Configure all linux machines with the SSH RSA public key string. Your key should include three parts, for example \'ssh-rsa AAAAB...snip...UcyupgH azureuser@linuxvm\'')
param sshRSAPublicKey string

resource aks 'Microsoft.ContainerService/managedClusters@2024-02-01' = {
  name: clusterName
  location: location
  identity: {
    type: 'SystemAssigned'
  }
  properties: {
    dnsPrefix: dnsPrefix
    agentPoolProfiles: [
      {
        name: 'agentpool'
        osDiskSizeGB: osDiskSizeGB
        count: agentCount
        vmSize: agentVMSize
        osType: 'Linux'
        mode: 'System'
      }
    ]
    linuxProfile: {
      adminUsername: linuxAdminUsername
      ssh: {
        publicKeys: [
          {
            keyData: sshRSAPublicKey
          }
        ]
      }
    }
  }
}

output controlPlaneFQDN string = aks.properties.fqdn

O recurso definido no arquivo Bicep é Microsoft.ContainerService/managedClusters.

Salve uma cópia do arquivo como main.bicep no computador local.

Adicione a definição de 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:

• 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 de uma fila de pedidos.

1. Crie um arquivo chamado aks-store-quickstart.yaml na mesma pasta que main.bicep e copie no seguinte manifesto:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: rabbitmq
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: rabbitmq
     template:
       metadata:
         labels:
           app: rabbitmq
       spec:
         nodeSelector:
           "kubernetes.io/os": linux
         containers:
         - name: rabbitmq
           image: mcr.microsoft.com/mirror/docker/library/rabbitmq:3.10-management-alpine
           ports:
           - containerPort: 5672
             name: rabbitmq-amqp
           - containerPort: 15672
             name: rabbitmq-http
           env:
           - name: RABBITMQ_DEFAULT_USER
             value: "username"
           - name: RABBITMQ_DEFAULT_PASS
             value: "password"
           resources:
             requests:
               cpu: 10m
               memory: 128Mi
             limits:
               cpu: 250m
               memory: 256Mi
           volumeMounts:
           - name: rabbitmq-enabled-plugins
             mountPath: /etc/rabbitmq/enabled_plugins
             subPath: enabled_plugins
         volumes:
         - name: rabbitmq-enabled-plugins
           configMap:
             name: rabbitmq-enabled-plugins
             items:
             - key: rabbitmq_enabled_plugins
               path: enabled_plugins
   ---
   apiVersion: v1
   data:
     rabbitmq_enabled_plugins: |
       [rabbitmq_management,rabbitmq_prometheus,rabbitmq_amqp1_0].
   kind: ConfigMap
   metadata:
     name: rabbitmq-enabled-plugins            
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: rabbitmq
   spec:
     selector:
       app: rabbitmq
     ports:
       - name: rabbitmq-amqp
         port: 5672
         targetPort: 5672
       - name: rabbitmq-http
         port: 15672
         targetPort: 15672
     type: ClusterIP
   ---
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: order-service
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: order-service
     template:
       metadata:
         labels:
           app: order-service
       spec:
         nodeSelector:
           "kubernetes.io/os": linux
         containers:
         - name: order-service
           image: ghcr.io/azure-samples/aks-store-demo/order-service:latest
           ports:
           - containerPort: 3000
           env:
           - name: ORDER_QUEUE_HOSTNAME
             value: "rabbitmq"
           - name: ORDER_QUEUE_PORT
             value: "5672"
           - name: ORDER_QUEUE_USERNAME
             value: "username"
           - name: ORDER_QUEUE_PASSWORD
             value: "password"
           - name: ORDER_QUEUE_NAME
             value: "orders"
           - name: FASTIFY_ADDRESS
             value: "0.0.0.0"
           resources:
             requests:
               cpu: 1m
               memory: 50Mi
             limits:
               cpu: 75m
               memory: 128Mi
         initContainers:
         - name: wait-for-rabbitmq
           image: busybox
           command: ['sh', '-c', 'until nc -zv rabbitmq 5672; do echo waiting for rabbitmq; sleep 2; done;']
           resources:
             requests:
               cpu: 1m
               memory: 50Mi
             limits:
               cpu: 75m
               memory: 128Mi    
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: order-service
   spec:
     type: ClusterIP
     ports:
     - name: http
       port: 3000
       targetPort: 3000
     selector:
       app: order-service
   ---
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: product-service
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: product-service
     template:
       metadata:
         labels:
           app: product-service
       spec:
         nodeSelector:
           "kubernetes.io/os": linux
         containers:
         - name: product-service
           image: ghcr.io/azure-samples/aks-store-demo/product-service:latest
           ports:
           - containerPort: 3002
           resources:
             requests:
               cpu: 1m
               memory: 1Mi
             limits:
               cpu: 1m
               memory: 7Mi
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: product-service
   spec:
     type: ClusterIP
     ports:
     - name: http
       port: 3002
       targetPort: 3002
     selector:
       app: product-service
   ---
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: store-front
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: store-front
     template:
       metadata:
         labels:
           app: store-front
       spec:
         nodeSelector:
           "kubernetes.io/os": linux
         containers:
         - name: store-front
           image: ghcr.io/azure-samples/aks-store-demo/store-front:latest
           ports:
           - containerPort: 8080
             name: store-front
           env: 
           - name: VUE_APP_ORDER_SERVICE_URL
             value: "http://order-service:3000/"
           - name: VUE_APP_PRODUCT_SERVICE_URL
             value: "http://product-service:3002/"
           resources:
             requests:
               cpu: 1m
               memory: 200Mi
             limits:
               cpu: 1000m
               memory: 512Mi
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: store-front
   spec:
     ports:
     - port: 80
       targetPort: 8080
     selector:
       app: store-front
     type: LoadBalancer
   

   Para obter um detalhamento dos arquivos de manifesto YAML, confira Implantações e manifestos YAML.

   Se você criar e salvar o arquivo YAML localmente, poderá carregar o arquivo de manifesto no diretório padrão no CloudShell selecionando o botão Carregar/Baixar arquivos e selecionando o arquivo no sistema de arquivos local.

2. Abra main.bicep no Visual Studio Code.

3. Pressione Ctrl+Shift+P para abrir a Paleta de Comandos.

4. Pesquise bicep e selecione Bicep: importar manifesto do Kubernetes.

   

5. Selecione aks-store-quickstart.yaml no prompt. Esse processo cria um arquivo aks-store-quickstart.bicep na mesma pasta.

6. Abra main.bicep e adicione o Bicep a seguir no final do arquivo para fazer referência ao módulo aks-store-quickstart.bicep recém-criado:

   module kubernetes './aks-store-quickstart.bicep' = {
     name: 'buildbicep-deploy'
     params: {
       kubeConfig: aks.listClusterAdminCredential().kubeconfigs[0].value
     }
   }
   

7. Salve main.bicep e aks-store-quickstart.bicep.

Implante o arquivo Bicep

Forneça os seguintes valores nos comandos:

• Nome do cluster: insira um nome exclusivo para o cluster do AKS, como myAKSCluster.
• Prefixo DNS: insira um prefixo DNS exclusivo para seu cluster, como myakscluster.
• Nome do Usuário Administrador do Linux: insira um nome de usuário para se conectar usando SSH, como azureuser.
• Chave pública RSA SSH: copie e cole a parte pública do seu par de chaves SSH (por padrão, o conteúdo de ~/.ssh/id_rsa.pub).

Leva alguns minutos para o cluster do AKS ser criado. Aguarde até que o cluster seja implantado com êxito antes de seguir para a próxima etapa.

Validar a implantação do Bicep

1. Entre no portal do Azure.

2. No menu do portal do Azure ou na Home page, navegue até o cluster do AKS.

3. Em Recursos do Kubernetes, selecione Serviços e entradas.

4. Localize o serviço store-front e copie o valor para IP externo.

5. Abra um navegador da Web no endereço IP externo do serviço para conferir o aplicativo do Microsoft Azure Store em ação.

   

Excluir o cluster

Se você não planeja seguir o tutorial do AKS, limpe os recursos desnecessários para evitar cobranças do Azure.

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

Remove-AzResourceGroup -Name myResourceGroup

Próximas etapas

Neste início rápido, você implantou um cluster do Kubernetes e um simples aplicativo 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 e percorrer um código completo de exemplo de implantação, prossiga para o tutorial de cluster do Kubernetes.