Início Rápido: implantar um cluster do AKS (Serviço de Kubernetes do Azure) usando o Terraform

Artigo
08/02/2024

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ê:

Criar um cluster do AKS por meio do Terraform.
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.

Observação

Para começar a provisionar rapidamente um cluster do AKS, este artigo inclui etapas para implantar um cluster com configurações padrão somente 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 ele se alinha aos seus requisitos de negócios.

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).
Você precisa de uma conta do Azure com uma assinatura ativa. Se você não tiver, crie uma conta gratuita.
Siga as instruções com base na interface de linha de comando.

Para saber mais sobre como criar um pool de nós do Windows Server, confira Criar um cluster do AKS compatível com contêineres do Windows Server.

Observação

O pool de nós do Linux do Azure agora está em disponibilidade geral (GA). Para saber mais sobre os benefícios e as etapas de implantação, confira Introdução ao host de contêiner do Linux do Azure para AKS.

Instale e configure o Terraform.
Baixar kubectl.
Criar um valor aleatório para o nome do grupo de recursos do Azure usando random_pet.
Criar um grupo de recursos do Azure usando azurerm_resource_group.
Acesse a configuração do provedor do AzureRM para obter a ID de Objeto do Azure usando azurerm_client_config.
Crie um cluster do Kubernetes usando azurerm_kubernetes_cluster.
Crie um recurso AzAPI azapi_resource.
Crie um recurso AzAPI para gerar um par de chaves SSH usando azapi_resource_action.

Primeiro, faça logon em sua conta do Azure e autentique-se usando um dos métodos descritos na seção a seguir.

O Terraform só dá suporte à autenticação no Azure com a CLI do Azure. Não há suporte para a autenticação usando o Azure PowerShell. Portanto, embora possa usar o módulo do Azure PowerShell ao realizar seu trabalho do Terraform, primeiro você precisa se autenticar no Azure.

Implementar o código do Terraform

Observação

O código de exemplo deste artigo está localizado no repositório do GitHub do Azure Terraform. Você pode exibir o arquivo de log que contém os resultados do teste 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 que você possa usar para testar o código de exemplo do Terraform, depois transforme-o no diretório atual.

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

terraform {
  required_version = ">=1.0"

  required_providers {
    azapi = {
      source  = "azure/azapi"
      version = "~>1.5"
    }
    azurerm = {
      source  = "hashicorp/azurerm"
      version = "~>3.0"
    }
    random = {
      source  = "hashicorp/random"
      version = "~>3.0"
    }
    time = {
      source  = "hashicorp/time"
      version = "0.9.1"
    }
  }
}

provider "azurerm" {
  features {}
}

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

resource "random_pet" "ssh_key_name" {
  prefix    = "ssh"
  separator = ""
}

resource "azapi_resource_action" "ssh_public_key_gen" {
  type        = "Microsoft.Compute/sshPublicKeys@2022-11-01"
  resource_id = azapi_resource.ssh_public_key.id
  action      = "generateKeyPair"
  method      = "POST"

  response_export_values = ["publicKey", "privateKey"]
}

resource "azapi_resource" "ssh_public_key" {
  type      = "Microsoft.Compute/sshPublicKeys@2022-11-01"
  name      = random_pet.ssh_key_name.id
  location  = azurerm_resource_group.rg.location
  parent_id = azurerm_resource_group.rg.id
}

output "key_data" {
  value = azapi_resource_action.ssh_public_key_gen.output.publicKey
}

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

# Generate random resource group name
resource "random_pet" "rg_name" {
  prefix = var.resource_group_name_prefix
}

resource "azurerm_resource_group" "rg" {
  location = var.resource_group_location
  name     = random_pet.rg_name.id
}

resource "random_pet" "azurerm_kubernetes_cluster_name" {
  prefix = "cluster"
}

resource "random_pet" "azurerm_kubernetes_cluster_dns_prefix" {
  prefix = "dns"
}

resource "azurerm_kubernetes_cluster" "k8s" {
  location            = azurerm_resource_group.rg.location
  name                = random_pet.azurerm_kubernetes_cluster_name.id
  resource_group_name = azurerm_resource_group.rg.name
  dns_prefix          = random_pet.azurerm_kubernetes_cluster_dns_prefix.id

  identity {
    type = "SystemAssigned"
  }

  default_node_pool {
    name       = "agentpool"
    vm_size    = "Standard_D2_v2"
    node_count = var.node_count
  }
  linux_profile {
    admin_username = var.username

    ssh_key {
      key_data = azapi_resource_action.ssh_public_key_gen.output.publicKey
    }
  }
  network_profile {
    network_plugin    = "kubenet"
    load_balancer_sku = "standard"
  }
}

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

variable "resource_group_location" {
  type        = string
  default     = "eastus"
  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 "node_count" {
  type        = number
  description = "The initial quantity of nodes for the node pool."
  default     = 3
}

variable "msi_id" {
  type        = string
  description = "The Managed Service Identity ID. Set this value if you're running this example using Managed Identity as the authentication method."
  default     = null
}

variable "username" {
  type        = string
  description = "The admin username for the new cluster."
  default     = "azureadmin"
}

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

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

output "kubernetes_cluster_name" {
  value = azurerm_kubernetes_cluster.k8s.name
}

output "client_certificate" {
  value     = azurerm_kubernetes_cluster.k8s.kube_config[0].client_certificate
  sensitive = true
}

output "client_key" {
  value     = azurerm_kubernetes_cluster.k8s.kube_config[0].client_key
  sensitive = true
}

output "cluster_ca_certificate" {
  value     = azurerm_kubernetes_cluster.k8s.kube_config[0].cluster_ca_certificate
  sensitive = true
}

output "cluster_password" {
  value     = azurerm_kubernetes_cluster.k8s.kube_config[0].password
  sensitive = true
}

output "cluster_username" {
  value     = azurerm_kubernetes_cluster.k8s.kube_config[0].username
  sensitive = true
}

output "host" {
  value     = azurerm_kubernetes_cluster.k8s.kube_config[0].host
  sensitive = true
}

output "kube_config" {
  value     = azurerm_kubernetes_cluster.k8s.kube_config_raw
  sensitive = true
}

Inicializar Terraform

Execute terraform init para inicializar a implantação do Terraform. Esse comando baixa o provedor do Azure necessário para gerenciar seus recursos do Azure.

terraform init -upgrade

Pontos principais:

O parâmetro -upgrade atualiza os plug-ins do provedor necessários para a versão mais recente que esteja em conformidade com as restrições de versão da configuração.

Criar um plano de execução Terraform

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

terraform plan -out main.tfplan

Pontos principais:

O comando terraform plan cria um plano de execução, mas não o executa. Em vez disso, ele determina quais ações são necessárias para criar a configuração especificada em seus arquivos de configuração. Esse padrão permite que você verifique se o plano de execução corresponde às suas expectativas antes de fazer qualquer alteração nos recursos reais.
O parâmetro opcional -out permite que você especifique um arquivo de saída para o plano. Usar o parâmetro -out garante que o plano que você examinou seja exatamente o que é aplicado.

Aplicar um plano de execução do Terraform

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

terraform apply main.tfplan

Pontos principais:

O exemplo de comando do terraform apply pressupõe que você executou o terraform plan -out main.tfplan anteriormente.
Se você especificou um nome de arquivo diferente para o parâmetro -out, use esse mesmo nome de arquivo na chamada para terraform apply.
Se você não usou o parâmetro -out, chame terraform apply sem nenhum parâmetro.

Verifique os resultados

Obtenha o nome do grupo de recursos do Azure usando o comando a seguir.
```
resource_group_name=$(terraform output -raw resource_group_name)
```

Exiba o nome do novo cluster do Kubernetes usando o comando az aks list.

az aks list \
  --resource-group $resource_group_name \
  --query "[].{\"K8s cluster name\":name}" \
  --output table

Obtenha a configuração do Kubernetes do estado do Terraform e armazene-a em um arquivo que o kubectl possa ler usando o comando a seguir.
```
echo "$(terraform output kube_config)" > ./azurek8s
```
Verifique se o comando anterior não adicionou um caractere ASCII EOT usando o comando a seguir.
```
cat ./azurek8s
```
Pontos principais:
- Se você vir << EOT no início e EOT no final, remova esses caracteres do arquivo. Caso contrário, a seguinte mensagem de erro será exibida: error: error loading config file "./azurek8s": yaml: line 2: mapping values are not allowed in this context
Defina uma variável de ambiente para que kubectl pegue a configuração correta usando o comando a seguir.
```
export KUBECONFIG=./azurek8s
```
Verifique a integridade do cluster usando o comando kubectl get nodes.
```
kubectl get nodes
```

Pontos principais:

Quando você criou o cluster do AKS, o monitoramento foi habilitado para capturar métricas de integridade para os nós de cluster e os pods. Essas métricas de integridade estão disponíveis no portal do Azure. Para saber mais sobre o monitoramento de integridade do contêiner, confira Monitoramento da Integridade do Serviço de Kubernetes do Azure.
Vários valores de chave classificados como saúda quando você aplicou o plano de execução do Terraform. Por exemplo, o endereço do host, o nome de usuário do cluster do AKS e a senha do cluster do AKS são gerados.

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:

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.

Observação

Não é recomendável executar contêineres com 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 Barramento de Serviço do Azure.

Crie um arquivo chamado aks-store-quickstart.yaml e copie-o para o manifesto a seguir:

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.

Implante o aplicativo usando o comando kubectl apply e especifique o nome do 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 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. Faça com que todos os pods estejam Running antes de continuar.
```
kubectl get pods
```
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 service store-front --watch
```
A saída EXTERNAL-IP do serviço store-front será mostrada inicialmente 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 for alterado de pendente 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 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 serviço para conferir o aplicativo do Microsoft Azure Store em ação.

Limpar os recursos

Excluir recursos do AKS

Quando você não precisar mais dos recursos criados por meio o Terraform, execute as seguintes etapas:

Execute terraform plan e especifique o sinalizador destroy.
```
terraform plan -destroy -out main.destroy.tfplan
```
Pontos principais:
- O comando terraform plan cria um plano de execução, mas não o executa. Em vez disso, ele determina quais ações são necessárias para criar a configuração especificada em seus arquivos de configuração. Esse padrão permite que você verifique se o plano de execução corresponde às suas expectativas antes de fazer qualquer alteração nos recursos reais.
- O parâmetro opcional -out permite que você especifique um arquivo de saída para o plano. Usar o parâmetro -out garante que o plano que você examinou seja exatamente o que é aplicado.
Execute a aplicação do Terraform para aplicar o plano de execução.
```
terraform apply main.destroy.tfplan
```

Excluir uma entidade de serviço

Obtenha a ID da entidade de serviço usando o seguinte comando.
```
sp=$(terraform output -raw sp)
```
Exclua a entidade de serviço usando o comando az ad sp delete.
```
az ad sp delete --id $sp
```

Instale a Azure Developer CLI (AZD)
Instale e configure o Terraform.
Você pode revisar o código do aplicativo usado no repositório Azure-Samples/aks-store-demo.

Clonar o modelo do Azure Developer CLI

A Azure Developer CLI permite que você baixe rapidamente amostras do repositório Azure-Samples. Em nosso início rápido, você baixa o aplicativo aks-store-demo. Para obter mais informações sobre os casos de uso geral, consulte a azd visão geral.

Clone o modelo de demonstração do armazenamento do AKS do repositório Azure-Samples, usando o comando azd init com o parâmetro --template.
```
azd init --template Azure-Samples/aks-store-demo
```
Insira um nome de ambiente para seu projeto que use apenas caracteres alfanuméricos e hifens, como aks-terraform-1.
```
Enter a new environment name: aks-terraform-1
```

O modelo azd contém todo o código necessário para criar os serviços, mas é necessário entrar em sua conta do Azure para hospedar o aplicativo no AKS.

Entre em sua conta usando o comando azd auth login.
```
azd auth login
```
Copie o código do dispositivo que aparece na saída e pressione Enter para entrar.
```
Start by copying the next code: XXXXXXXXX
Then press enter and continue to log in from your browser...
```
Importante

Caso esteja usando uma máquina virtual fora da rede ou o Codespace do GitHub, determinadas políticas de segurança do Azure causarão conflitos quando usadas para entrar com azd auth login. Se você encontrar um problema aqui, poderá seguir a solução alternativa de autenticação do azd fornecida, que envolve o uso de uma solicitação curl para a URL de localhost para a qual você foi redirecionado depois de executar azd auth login.
Autentique-se com suas credenciais na página de entrada da sua organização.
Confirme se você está tentando se conectar por meio da CLI do Azure.
Verifique a mensagem "Autenticação de código do dispositivo concluída. Conectado ao Azure." aparece no seu terminal original.
```
Waiting for you to complete authentication in the browser...
Device code authentication completed.
Logged in to Azure.
```

solução alternativa de autenticação do azd

Esta solução alternativa exige que você tenha a CLI do Azure instalada.

Abra uma janela de terminal e faça logon com a CLI do Azure usando o comando az login com o parâmetro --scope definido como https://graph.microsoft.com/.default.
```
az login --scope https://graph.microsoft.com/.default
```
Você deverá ser redirecionado para uma página de autenticação em uma nova guia para criar um token de acesso do navegador, conforme mostrado no exemplo a seguir:
```
https://login.microsoftonline.com/organizations/oauth2/v2.0/authorize?clientid=<your_client_id>.
```
Copie o URL do localhost da página da Web que você recebeu depois de tentar entrar com azd auth login.

Em uma nova janela de terminal, use a solicitação curl a seguir para fazer logon. Substitua o espaço reservado <localhost> pelo URL do localhost copiado na etapa anterior.

curl <localhost>

Um logon bem-sucedido gera uma página da Web HTML, conforme mostrado no exemplo a seguir:

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8" />
    <meta http-equiv="refresh" content="60;url=https://docs.microsoft.com/cli/azure/">
    <title>Login successfully</title>
    <style>
        body {
            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
        }

        code {
            font-family: Consolas, 'Liberation Mono', Menlo, Courier, monospace;
            display: inline-block;
            background-color: rgb(242, 242, 242);
            padding: 12px 16px;
            margin: 8px 0px;
        }
    </style>
</head>
<body>
    <h3>You have logged into Microsoft Azure!</h3>
    <p>You can close this window, or we will redirect you to the <a href="https://docs.microsoft.com/cli/azure/">Azure CLI documentation</a> in 1 minute.</p>
    <h3>Announcements</h3>
    <p>[Windows only] Azure CLI is collecting feedback on using the <a href="https://learn.microsoft.com/windows/uwp/security/web-account-manager">Web Account Manager</a> (WAM) broker for the login experience.</p>
    <p>You may opt-in to use WAM by running the following commands:</p>
    <code>
        az config set core.allow_broker=true<br>
        az account clear<br>
        az login
    </code>
</body>
</html>

Feche o terminal atual e abra o terminal original. Você deverá ver uma lista JSON de suas assinaturas.
Copie o campo id da assinatura que você deseja usar.
Defina a assinatura usando o comando az account set.
```
az account set --subscription <subscription_id>
```

Criar e implantar recursos para o cluster

Para implantar o aplicativo, use o comando azd up para criar todos os objetos necessários para executar o aplicativo AKS Store.

Um arquivo azure.yaml define o estado desejado de um cluster, como quais imagens de contêiner buscar e 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.

Observação

Não é recomendável executar contêineres com estado, como o Rabbit MQ, sem armazenamento persistente para produção. Esses 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.

Implantar os recursos do aplicativo

O modelo azd para este início rápido cria um novo grupo de recursos com um cluster do AKS e um Azure Key Vault. O cofre de chaves armazena segredos do cliente e executa os serviços no namespace pets.

Crie todos os recursos do aplicativo usando o comando azd up.
```
azd up
```
azd up executa todos os ganchos dentro da azd-hooks pasta para pré-registro, provisionar e implantar os serviços de aplicativo.

Personalize ganchos para adicionar código personalizado aos estágios de fluxo de trabalho azd. Para obter mais informações, consulte a referência de azd ganchos.

Selecione uma assinatura do Azure para seu uso de cobrança.

? Select an Azure Subscription to use:  [Use arrows to move, type to filter]
> 1. My Azure Subscription (xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx)

Selecione uma região para a qual implantar seu aplicativo.

Select an Azure location to use:  [Use arrows to move, type to filter]
  1.  (South America) Brazil Southeast (brazilsoutheast)
  2.  (US) Central US (centralus)
  3.  (US) East US (eastus)
> 43. (US) East US 2 (eastus2)
  4.  (US) East US STG (eastusstg)
  5.  (US) North Central US (northcentralus)
  6.  (US) South Central US (southcentralus)

azd executa automaticamente os comandos de pré-provisionamento e pós-provisionamento, para criar os recursos para o aplicativo. A conclusão desse processo pode levar alguns minutos. Após a conclusão, você deverá visualizar uma saída semelhante ao seguinte exemplo:

SUCCESS: Your workflow to provision and deploy to Azure completed in 9 minutes 40 seconds.

Gerar planos do Terraform

No modelo do Desenvolvedor do Azure, a pasta /infra/terraform contém todo o código usado para gerar o plano do Terraform.

O Terraform implanta e executa comandos usando terraform apply como parte da etapa de provisionamento de azd. Após a conclusão, você deverá visualizar uma saída semelhante ao seguinte exemplo:

Plan: 5 to add, 0 to change, 0 to destroy.
...
Saved the plan to: /workspaces/aks-store-demo/.azure/aks-terraform-azd/infra/terraform/main.tfplan

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.

Defina seu namespace como o namespace de demonstração pets usando o comando kubectl set-context.
```
kubectl config set-context --current --namespace=pets
```
Verifique o status dos pods implantados usando o comando kubectl get pods. Garanta que todos os pods estejam Running, antes de continuar.
```
kubectl get pods
```
Verifique se há um endereço IP público para o aplicativo e monitore o progresso usando o comando kubectl get service com o argumento --watch.
```
kubectl get service store-front --watch
```
A saída EXTERNAL-IP do serviço store-front será mostrada inicialmente 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 for alterado de pendente 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          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 serviço para conferir o aplicativo do Microsoft Azure Store em ação.

Excluir o cluster

Após concluir o início rápido, limpe os recursos desnecessários para evitar encargos do Azure.

Exclua todos os recursos criados no início rápido usando o comando azd down.
```
azd down
```
Confirme sua decisão de remover todos os recursos usados de sua assinatura digitando y e pressionando Enter.
```
? Total resources to delete: 14, are you sure you want to continue? (y/N)
```

Permitir que a limpeza reutilize as variáveis de início rápido, se aplicável, digitando y e pressionando Enter.

[Warning]: These resources have soft delete enabled allowing them to be recovered for a period or time after deletion. During this period, their names can't be reused. In the future, you can use the argument --purge to skip this confirmation.

Solucionar problemas do Terraform no Azure

Solucionar problemas comuns ao usar o Terraform no Azure.

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.

Saiba mais sobre como usar o AKS.

Partilhar via

Início Rápido: implantar um cluster do AKS (Serviço de Kubernetes do Azure) usando o Terraform

Antes de começar

Implementar o código do Terraform

Inicializar Terraform

Criar um plano de execução Terraform

Aplicar um plano de execução do Terraform

Verifique os resultados

Implantar o aplicativo

Testar o aplicativo

Limpar os recursos

Excluir recursos do AKS

Excluir uma entidade de serviço

Clonar o modelo do Azure Developer CLI

solução alternativa de autenticação do azd

Criar e implantar recursos para o cluster

Implantar os recursos do aplicativo

Gerar planos do Terraform

Testar o aplicativo

Excluir o cluster

Solucionar problemas do Terraform no Azure

Próximas etapas

Recursos adicionais

Partilhar via

Início Rápido: implantar um cluster do AKS (Serviço de Kubernetes do Azure) usando o Terraform

Antes de começar

Faça logon em sua conta do Azure

Implementar o código do Terraform

Inicializar Terraform

Criar um plano de execução Terraform

Aplicar um plano de execução do Terraform

Verifique os resultados

Implantar o aplicativo

Testar o aplicativo

Limpar os recursos

Excluir recursos do AKS

Excluir uma entidade de serviço

Clonar o modelo do Azure Developer CLI

Entre na sua conta do Azure Cloud

solução alternativa de autenticação do azd

Criar e implantar recursos para o cluster

Implantar os recursos do aplicativo

Gerar planos do Terraform

Testar o aplicativo

Excluir o cluster

Solucionar problemas do Terraform no Azure

Próximas etapas

Recursos adicionais