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

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

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

Faça logon em sua conta do Azure

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

1. Crie um diretório que você possa usar para testar o código de exemplo do Terraform, depois transforme-o no diretório atual.

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

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

4. 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"
     }
   }
   

5. 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"
   }
   

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

1. Obtenha o nome do grupo de recursos do Azure usando o comando a seguir.

   resource_group_name=$(terraform output -raw resource_group_name)
   

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

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

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

5. Defina uma variável de ambiente para que kubectl pegue a configuração correta usando o comando a seguir.

   export KUBECONFIG=./azurek8s
   

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

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

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

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

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

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

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

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

2. Execute a aplicação do Terraform para aplicar o plano de execução.

   terraform apply main.destroy.tfplan
   

Excluir uma entidade de serviço

1. Obtenha a ID da entidade de serviço usando o seguinte comando.

   sp=$(terraform output -raw sp)
   

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

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

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

Entre na sua conta do Azure Cloud

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.

1. Entre em sua conta usando o comando azd auth login.

   azd auth login
   

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

3. Autentique-se com suas credenciais na página de entrada da sua organização.

4. Confirme se você está tentando se conectar por meio da CLI do Azure.

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

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

2. Copie o URL do localhost da página da Web que você recebeu depois de tentar entrar com azd auth login.

3. 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://zcusa.951200.xyz/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>
   

4. Feche o terminal atual e abra o terminal original. Você deverá ver uma lista JSON de suas assinaturas.

5. Copie o campo id da assinatura que você deseja usar.

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

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.

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

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

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

1. Defina seu namespace como o namespace de demonstração pets usando o comando kubectl set-context.

   kubectl config set-context --current --namespace=pets
   

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

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

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

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

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

1. Exclua todos os recursos criados no início rápido usando o comando azd down.

   azd down
   

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

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