Guia de início rápido: implantar um cluster do Serviço Kubernetes do Azure (AKS) usando o Bicep

Artigo
04/28/2024

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

Implante um cluster AKS usando o Bicep.
Execute 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.

Nota

Para começar a provisionar rapidamente um cluster AKS, este artigo inclui etapas para implantar um cluster com configurações padrão apenas para fins de avaliação. Antes de implantar um cluster pronto para produção, recomendamos que você se familiarize com nossa arquitetura de referência de linha de base para considerar como ela se alinha aos seus requisitos de negócios.

Antes de começar

Este guia de introdução parte do princípio de que possui conhecimentos básicos dos conceitos do Kubernetes. Para obter mais informações, consulte Conceitos principais do Kubernetes para o Serviço Kubernetes do Azure (AKS).
Você precisa de uma conta do Azure com uma assinatura ativa. Se você não tiver uma, crie uma conta gratuitamente.
Para saber mais sobre como criar um pool de nós do Windows Server, consulte Criar um cluster AKS que ofereça suporte a contêineres do Windows Server.
O Bicep é uma linguagem específica do domínio que utiliza sintaxe declarativa para implementar recursos do Azure. Fornece sintaxe concisa, segurança de tipos fiá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.

CLI do Azure
Azure PowerShell

Use o ambiente Bash no Azure Cloud Shell. Para obter mais informações, consulte Guia de início rápido para Bash no Azure Cloud Shell.
Se preferir executar comandos de referência da CLI localmente, instale a CLI do Azure. Se estiver a utilizar o Windows ou macOS, considere executar a CLI do Azure num contentor Docker. Para obter mais informações, consulte Como executar a CLI do Azure em um contêiner do Docker.
- Se estiver a utilizar uma instalação local, inicie sessão no CLI do Azure ao utilizar o comando az login. Para concluir o processo de autenticação, siga os passos apresentados no seu terminal. Para outras opções de entrada, consulte Entrar com a CLI do Azure.
- Quando solicitado, instale a extensão da CLI do Azure na primeira utilização. Para obter mais informações sobre as extensões, veja Utilizar extensões com o CLI do Azure.
- Execute o comando az version para localizar a versão e as bibliotecas dependentes instaladas. Para atualizar para a versão mais recente, execute o comando az upgrade.

Este artigo requer a CLI do Azure versão 2.0.64 ou posterior. Se você estiver usando o Azure Cloud Shell, a versão mais recente já está instalada lá.
Este artigo requer um grupo de recursos do Azure existente. Se você precisar criar um, você pode usar o comando az group create .

Se você estiver executando o PowerShell localmente, instale o Az PowerShell módulo. Se você estiver usando o Azure Cloud Shell, a versão mais recente já está instalada lá.
Você precisa da CLI do Bíceps. Para obter mais informações, consulte Azure PowerShell.
Este artigo requer um grupo de recursos do Azure existente. Se precisar criar um, você pode usar o cmdlet New-AzAksCluster .

Para criar um cluster 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, pule para Revisar o arquivo Bicep.
Verifique se a identidade usada para criar o cluster tem as permissões mínimas apropriadas. Para obter mais detalhes sobre acesso e identidade para AKS, consulte Opções de acesso e identidade para o Serviço Kubernetes do Azure (AKS).
Para implantar um arquivo Bicep, você precisa de acesso de gravação nos recursos criados e acesso a todas as operações no Microsoft.Resources/deployments tipo de recurso. Por exemplo, para criar uma máquina virtual, você precisa de Microsoft.Compute/virtualMachines/write permissões Microsoft.Resources/deployments/* . Para obter uma lista de funções e permissões, veja Funções incorporadas do Azure.

Criar um par de chaves SSH

Vá para https://shell.azure.com abrir o Cloud Shell no seu navegador.

Crie um par de chaves SSH usando o comando az sshkey create Azure CLI ou o ssh-keygencomando.

# 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, consulte Criar e gerenciar chaves SSH para autenticação no Azure.

Revise o arquivo Bicep

O arquivo Bicep usado neste início rápido é de Modelos de Início Rápido do Azure.

@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

Para obter mais exemplos do AKS, consulte o site de modelos de início rápido do AKS.

Implantar o arquivo Bicep

Salve o arquivo Bicep como main.bicep em seu computador local.

Importante

O arquivo Bicep define o clusterName param para a string aks101cluster. Se você quiser usar um nome de cluster diferente, atualize a cadeia de caracteres para o nome do cluster preferido antes de salvar o arquivo no computador.

Implante o arquivo Bicep usando a CLI do Azure ou o Azure PowerShell.
- CLI do Azure
- Azure PowerShell
```
az deployment group create --resource-group myResourceGroup --template-file main.bicep --parameters dnsPrefix=<dns-prefix> linuxAdminUsername=<linux-admin-username> sshRSAPublicKey='<ssh-key>'
```
```
New-AzResourceGroup -Name myResourceGroup -Location eastus
New-AzResourceGroupDeployment -ResourceGroupName myResourceGroup -TemplateFile ./main.bicep -dnsPrefix=<dns-prefix> -linuxAdminUsername=<linux-admin-username> -sshRSAPublicKey="<ssh-key>"
```
Forneça os seguintes valores nos comandos:
- Prefixo DNS: insira um prefixo DNS exclusivo para seu cluster, como myakscluster.
- Linux Admin Username: 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).
A criação do cluster do AKS demora alguns minutos. Aguarde até que o cluster seja implantado com êxito antes de passar para a próxima etapa.

Validar a implantação do Bicep

Ligar ao cluster

Para gerenciar um cluster Kubernetes, use o cliente de linha de comando Kubernetes, kubectl. kubectl já está instalado se você usar o Azure Cloud Shell.

CLI do Azure
Azure PowerShell

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

Verifique a conexão com seu cluster usando o comando kubectl get . Este comando retorna uma lista dos nós do cluster.

kubectl get nodes

A saída de exemplo seguinte mostra o nó único criado nos passos anteriores. Verifique se o status do nó é Pronto.

NAME                       STATUS   ROLES   AGE     VERSION
aks-agentpool-41324942-0   Ready    agent   6m44s   v1.12.6
aks-agentpool-41324942-1   Ready    agent   6m46s   v1.12.6
aks-agentpool-41324942-2   Ready    agent   6m45s   v1.12.6

Instale kubectl localmente usando o cmdlet Install-AzAksKubectl .
```
Install-AzAksKubectl
```
Configure kubectl para se conectar ao cluster do Kubernetes usando o cmdlet Import-AzAksCredential . Este comando baixa credenciais e configura a CLI do Kubernetes para usá-las.
```
Import-AzAksCredential -ResourceGroupName myResourceGroup -Name myAKSCluster
```

Verifique a conexão com seu cluster usando o comando kubectl get . Este comando retorna uma lista dos nós do cluster.

kubectl get nodes

A saída de exemplo a seguir mostra os três nós criados nas etapas anteriores. Verifique se o status do nó é Pronto.

NAME                       STATUS   ROLES   AGE     VERSION
aks-agentpool-41324942-0   Ready    agent   6m44s   v1.12.6
aks-agentpool-41324942-1   Ready    agent   6m46s   v1.12.6
aks-agentpool-41324942-2   Ready    agent   6m45s   v1.12.6

Implementar a aplicação

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, como quais imagens de contêiner devem ser executadas. O manifesto inclui as seguintes implantações e serviços do Kubernetes:

Vitrine: aplicativo Web para que os clientes visualizem produtos e façam pedidos.
Serviço do produto: Mostra as informações do produto.
Serviço de pedidos: Faz pedidos.
Rabbit MQ: Fila de mensagens para uma fila de pedidos.

Nota

Não recomendamos a execução de contêineres com monitoração de estado, como o Rabbit MQ, sem armazenamento persistente para produção. Eles são usados aqui para simplificar, mas recomendamos o uso de serviços gerenciados, como o Azure CosmosDB ou o Azure Service Bus.

Crie um arquivo nomeado aks-store-quickstart.yaml 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, consulte Implantações e manifestos YAML.

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

Implante o aplicativo usando o comando kubectl apply e especifique o nome do seu manifesto YAML.

kubectl apply -f aks-store-quickstart.yaml

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

deployment.apps/rabbitmq 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

Testar a aplicação

Quando o aplicativo é executado, um serviço Kubernetes expõe o front-end do aplicativo à Internet. Este processo pode demorar alguns minutos a concluir.

Verifique o status dos pods implantados usando o comando kubectl get pods . Faça com que todos os pods estejam Running antes de prosseguir.
```
kubectl get pods
```
Verifique se há um endereço IP público para o aplicativo de vitrine. Monitore o progresso usando o comando kubectl get service com o --watch argumento.
```
kubectl get service store-front --watch
```
A saída EXTERNAL-IP para o store-front serviço inicialmente mostra como pendente:
```
NAME          TYPE           CLUSTER-IP    EXTERNAL-IP   PORT(S)        AGE
store-front   LoadBalancer   10.0.100.10   <pending>     80:30025/TCP   4h4m
```
Quando o endereço EXTERNAL-IP mudar de pendente para um endereço IP público real, use CTRL-C para interromper o kubectl processo de monitoramento.

A saída de exemplo a seguir mostra um endereço IP público válido atribuído ao serviço:
```
NAME          TYPE           CLUSTER-IP    EXTERNAL-IP    PORT(S)        AGE
store-front   LoadBalancer   10.0.100.10   20.62.159.19   80:30025/TCP   4h5m
```
Abra um navegador da Web no endereço IP externo do seu serviço para ver o aplicativo da Loja Azure em ação.

Eliminar o cluster

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

CLI do Azure
Azure PowerShell

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

Nota

O cluster AKS foi criado com uma identidade gerenciada atribuída ao 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.

Próximos passos

Neste início rápido, você implantou um cluster Kubernetes e, em seguida, implantou um aplicativo simples de vários contêineres nele. Este aplicativo de exemplo é apenas para fins de demonstração e não representa todas as práticas recomendadas para aplicativos Kubernetes. Para obter orientação sobre como criar soluções completas com o AKS para produção, consulte Orientação de solução AKS.

Para saber mais sobre o AKS e percorrer um exemplo completo de código para implantação, continue para o tutorial do cluster do Kubernetes.

Tutorial do AKS

Share via

Guia de início rápido: implantar um cluster do Serviço Kubernetes do Azure (AKS) usando o Bicep

Antes de começar

Criar um par de chaves SSH

Revise o arquivo Bicep

Implantar o arquivo Bicep

Validar a implantação do Bicep

Ligar ao cluster

Implementar a aplicação

Testar a aplicação

Eliminar o cluster

Próximos passos

Recursos adicionais