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

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

• Instale e configure o Terraform.
• Baixar kubectl.
• Crie um valor aleatório para o nome do grupo de recursos do Azure usando random_pet.
• Crie um grupo de recursos do Azure usando azurerm_resource_group.
• Acesse a configuração do provedor AzureRM para obter a ID de Objeto do Azure usando azurerm_client_config.
• Crie um cluster 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.

Iniciar sessão na 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 autenticação usando o Azure PowerShell. Portanto, embora você possa usar o módulo do Azure PowerShell ao fazer seu trabalho Terraform, primeiro precisa se autenticar no Azure.

Implementar o código Terraform

1. Crie um diretório que você pode usar para testar o código Terraform de exemplo e torná-lo seu 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 o Terraform

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

terraform init -upgrade

Pontos principais:

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

Criar um plano de execução do Terraform

Execute o plano de terraforma para criar um plano de execução.

terraform plan -out main.tfplan

Pontos principais:

• O terraform plan comando 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 quaisquer alterações nos recursos reais.
• O parâmetro opcional -out permite especificar um arquivo de saída para o plano. O uso do -out parâmetro garante que o plano revisado seja exatamente o que é aplicado.

Aplicar um plano de execução Terraform

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

terraform apply main.tfplan

Pontos principais:

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

Verificar 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 seu novo cluster 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 a partir do estado Terraform e armazene-a em um arquivo que kubectl possa ser lido 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, poderá receber a seguinte mensagem de erro: 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 kubectl que possa pegar a configuração correta usando o comando a seguir.

   export KUBECONFIG=./azurek8s
   

6. Verifique a integridade do cluster usando o kubectl get nodes comando.

   kubectl get nodes
   

Pontos principais:

• Quando você criou o cluster AKS, o monitoramento foi habilitado para capturar métricas de integridade para os nós e pods do cluster. Estas métricas de estado de funcionamento estão disponíveis no portal do Azure. Para obter mais informações sobre a monitorização do estado de funcionamento dos contentores, veja Monitorizar o estado de funcionamento do Azure Kubernetes Service.
• Vários valores-chave classificados como saída quando você aplicou o plano de execução Terraform. Por exemplo, o endereço do host, o nome de usuário do cluster AKS e a senha do cluster AKS são a saída.

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.

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

2. Implante o aplicativo usando o kubectl apply comando 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.

1. Verifique o status dos pods implantados usando o kubectl get pods comando. Faça com que todos os pods estejam Running antes de prosseguir.

   kubectl get pods
   

2. Verifique se há um endereço IP público para o aplicativo de vitrine. Monitore o progresso usando o kubectl get service comando 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
   

3. Quando o endereço EXTERNAL-IP mudar de pendentemonitoramento.

   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
   

4. Abra um navegador da Web no endereço IP externo do seu serviço para ver o aplicativo da Loja Azure em ação.

   

Clean up resources (Limpar recursos)

Excluir recursos do AKS

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

1. Execute o plano de terraforma e especifique o destroy sinalizador.

   terraform plan -destroy -out main.destroy.tfplan
   

   Pontos principais:

   • O terraform plan comando 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 quaisquer alterações nos recursos reais.
   • O parâmetro opcional -out permite especificar um arquivo de saída para o plano. O uso do -out parâmetro garante que o plano revisado seja exatamente o que é aplicado.

2. Execute terraform apply para aplicar o plano de execução.

   terraform apply main.destroy.tfplan
   

Excluir 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
   

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

Clone o modelo da CLI do Azure Developer

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

1. Clone o modelo de demonstração da loja AKS do repositório Azure-Samples usando o azd init comando com o --template parâmetro.

   azd init --template Azure-Samples/aks-store-demo
   

2. Insira um nome de ambiente para seu projeto que use apenas caracteres alfanuméricos e hífenes, como aks-terraform-1.

   Enter a new environment name: aks-terraform-1
   

Iniciar sessão na sua conta do Azure Cloud

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

1. Inicie sessão na sua conta utilizando o azd auth login comando.

   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

   Se você estiver usando uma máquina virtual fora da rede ou o GitHub Codespace, determinadas políticas de segurança do Azure causarão conflitos quando usadas para entrar com azd auth logino . Se você tiver um problema aqui, você pode seguir a solução alternativa azd auth fornecida, que envolve o uso de uma curl solicitação para a URL localhost para a qual você foi redirecionado após a execução azd auth login.

3. Autentique-se com as suas credenciais na página de início de sessão da sua organização.

4. Confirme se você está tentando se conectar a partir da CLI do Azure.

5. Verifique a mensagem "Autenticação do 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.
   

AZD Auth Solução alternativa

Esta solução alternativa requer 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 az login comando com o --scope parâmetro definido como https://graph.microsoft.com/.default.

   az login --scope https://graph.microsoft.com/.default
   

   Você deve 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 localhost da página da Web que você recebeu depois de tentar entrar com azd auth logino .

3. Numa nova janela do terminal, utilize o seguinte curl pedido para iniciar sessão. Certifique-se de substituir o espaço reservado <localhost> pelo URL do host local copiado na etapa anterior.

   curl <localhost>
   

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

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

5. Copie o id campo da subscrição que pretende utilizar.

6. Defina sua assinatura usando o az account set comando.

   az account set --subscription <subscription_id>
   

Criar e implantar recursos para seu cluster

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

• Um azure.yaml arquivo 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:

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

Implantar recursos do aplicativo

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

1. Crie todos os recursos do aplicativo usando o azd up comando.

   azd up
   

   azd upExecuta todos os ganchos dentro da pastaazd-hooks aplicativo.

   Personalize ganchos para adicionar código personalizado aos estágios do azd fluxo de trabalho. Para obter mais informações, consulte a azd referência de 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 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 ganchos de pré-provisionamento e pós-provisionamento para criar os recursos para seu aplicativo. Este processo pode demorar alguns minutos a concluir. Depois de concluído, você verá uma saída semelhante ao exemplo a seguir:

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

Gerar planos Terraform

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

O Terraform implanta e executa comandos usando terraform apply como parte da etapa de provisionamento do azd. Depois de concluído, você verá uma saída semelhante ao exemplo a seguir:

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

1. Defina seu namespace como o namespace pets demo usando o kubectl set-context comando.

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

2. Verifique o status dos pods implantados usando o kubectl get pods comando. Certifique-se de que todos os pods estão Running antes de prosseguir.

   kubectl get pods
   

3. Verifique se há um endereço IP público para o aplicativo de vitrine e monitore o progresso usando o kubectl get service comando 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
   

4. Quando o endereço EXTERNAL-IP mudar de pendentemonitoramento.

   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
   

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

Quando terminar o início rápido, limpe recursos desnecessários para evitar cobranças do Azure.

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

   azd down
   

2. Confirme sua decisão de remover todos os recursos usados da sua assinatura digitando y e pressionando Enter.

   ? Total resources to delete: 14, are you sure you want to continue? (y/N)
   

3. Permita limpar para reutilizar 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.