Partilhar via


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

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

Nota

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

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

Nota

O código de exemplo para este artigo está localizado no repositório GitHub do Azure Terraform. Você pode visualizar o arquivo de log que contém os resultados do teste das versões atual e anterior do Terraform.

Veja mais artigos e código de exemplo mostrando como usar o Terraform para gerenciar recursos do Azure

  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 = jsondecode(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 = jsondecode(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:

Captura de ecrã da arquitetura de exemplo da Loja Azure.

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

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

    Captura de ecrã da aplicação de exemplo AKS Store.

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
    

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:

Diagrama que mostra a arquitetura de exemplo da Loja Azure.

  • 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 Cosmos DB ou o Azure Service Bus.

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 pasta para pré-registrar, provisionar e implantar os serviços de azd-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 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
    
  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.

    Captura de ecrã da aplicação de exemplo AKS Store.

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.
    

Solucionar problemas do Terraform no Azure

Solucione problemas comuns ao usar o Terraform no Azure.

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.