Início Rápido: implantar um cluster do AKS (Serviço de Kubernetes do Azure) usando o Terraform
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.
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.
Cenários de autenticação do Terraform e do Azure
O Terraform dá suporte à autenticação no Azure somente por meio da 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 usando a CLI do Azure.
Este artigo explica como autenticar o Terraform no Azure para os cenários a seguir. Para saber mais sobre as opções para autenticar o Terraform no Azure, confira Autenticando com a CLI do Azure.
- Autenticar por meio de uma conta Microsoft usando o Cloud Shell (com Bash ou PowerShell)
- Autenticar por meio de uma conta Microsoft usando o Windows (com Bash ou PowerShell)
- Autenticar por meio de uma entidade de serviço:
- Se você não tem uma entidade de serviço, crie uma.
- Autenticar no Azure usando variáveis de ambiente ou Autenticar no Azure usando o bloco do provedor do Terraform
Autenticar no Azure por meio de uma conta Microsoft
Uma conta da Microsoft é um nome de usuário (associado a um e-mail e suas credenciais) que é usado para entrar nos serviços da Microsoft, como o Azure. Uma conta Microsoft pode ser associada a uma ou mais assinaturas do Azure, com uma delas sendo a assinatura padrão.
As etapas a seguir mostram como fazer isso:
- Entre no Azure interativamente usando uma conta da Microsoft
- Listar as assinaturas associadas do Azure da conta (incluindo o padrão)
- Define a assinatura atual.
Abra uma linha de comando que tenha acesso à CLI do Azure.
Execute o az login sem nenhum parâmetro e siga as instruções para entrar no Azure.
az login
Pontos principais:
- Após o login bem-sucedido,
az login
exibe uma lista das assinaturas do Azure associadas à conta Microsoft conectada, incluindo a assinatura padrão.
- Após o login bem-sucedido,
Para confirmar a assinatura atual do Azure, execute az account show.
az account show
Para exibir todos os nomes e IDs de assinatura do Azure de uma conta Microsoft específica, execute az account list.
az account list --query "[?user.name=='<microsoft_account_email>'].{Name:name, ID:id, Default:isDefault}" --output Table
Pontos principais:
- Substitua o espaço reservado
<microsoft_account_email>
pelo endereço de email da conta Microsoft cujas assinaturas do Azure você deseja listar. - Com uma conta Live –por exemplo, do Hotmail ou Outlook–, talvez seja necessário especificar o endereço de email totalmente qualificado. Por exemplo, se o endereço de email for
admin@hotmail.com
, talvez seja necessário substituir o espaço reservado porlive.com#admin@hotmail.com
.
- Substitua o espaço reservado
Para usar uma assinatura do Azure específica, execute az account set.
az account set --subscription "<subscription_id_or_subscription_name>"
Pontos principais:
- Substitua o espaço reservado
<subscription_id_or_subscription_name>
pela ID ou pelo nome da assinatura que deseja usar. - A chamada a
az account set
não exibe os resultados da alternância para a assinatura especificada do Azure. No entanto, você pode usaraz account show
para confirmar se a assinatura atual do Azure foi alterada. - Se executar o comando
az account list
da etapa anterior, você verá que a assinatura do Azure padrão foi alterada para a assinatura especificada comaz account set
.
- Substitua o espaço reservado
Criar uma entidade de serviço
Ferramentas automatizadas que implantam ou usam os serviços do Azure, como o Terraform, sempre têm permissões restritas. Em vez de fazer com que os aplicativos entrem como um usuário totalmente privilegiado, o Azure oferece entidades de serviço.
O padrão mais comum é fazer login interativamente no Azure, criar uma entidade de serviço, testar a entidade de serviço e, em seguida, usar essa entidade de serviço para autenticação futura (interativamente ou a partir de seus scripts).
Para criar uma entidade de serviço, entre no Azure. Volte para este ponto após autenticar no Azure usando uma conta Microsoft.
Se estiver criando uma entidade de serviço do Git Bash, defina a variável de ambiente
MSYS_NO_PATHCONV
. (Essa etapa não é necessária se você estiver usando o Cloud Shell).export MSYS_NO_PATHCONV=1
Pontos principais:
- Você pode definir a variável de ambiente
MSYS_NO_PATHCONV
globalmente (para todas as sessões de terminal) ou localmente (apenas para a sessão atual). Como a criação de uma entidade de serviço não é algo que você faz com frequência, o exemplo define o valor para a sessão atual. Para definir essa variável de ambiente globalmente, adicione a configuração ao arquivo~/.bashrc
.
- Você pode definir a variável de ambiente
Para criar uma entidade de serviço, execute az ad sp create-for-rbac.
az ad sp create-for-rbac --name <service_principal_name> --role Contributor --scopes /subscriptions/<subscription_id>
Pontos principais:
- Você pode substituir
<service-principal-name>
por um nome personalizado para o ambiente ou omitir totalmente o parâmetro. Se você omitir o parâmetro, o nome da entidade de serviço será gerado com base na data e hora atuais. - Após a conclusão bem-sucedida,
az ad sp create-for-rbac
exibe vários valores. Os valoresappId
,password
etenant
são usados na próxima etapa. - Se for perdida, a senha não poderá ser recuperada. Por isso, você deve armazenar sua senha em um local seguro. Se esquecer a senha, redefina as credenciais da entidade de serviço.
- Para este artigo, uma entidade de serviço com a função de Colaborador está sendo usada. Para obter mais informações sobre as funções de Controle de acesso baseado em função (RBAC), consulte RBAC: funções internas.
- A saída da criação da entidade de serviço inclui credenciais confidenciais. Não inclua essas credenciais no código nem faça check-in delas no controle do código-fonte.
- Para obter mais informações sobre as opções ao criar uma entidade de serviço com a CLI do Azure, confira o artigo Criar uma entidade de serviço do Azure com a CLI do Azure.
- Você pode substituir
Especificar credenciais da entidade de serviço em variáveis de ambiente
Após criar uma entidade de serviço, você pode especificar as credenciais dela para o Terraform por meio de variáveis de ambiente.
Edite o arquivo
~/.bashrc
adicionando as variáveis de ambiente a seguir.export ARM_SUBSCRIPTION_ID="<azure_subscription_id>" export ARM_TENANT_ID="<azure_subscription_tenant_id>" export ARM_CLIENT_ID="<service_principal_appid>" export ARM_CLIENT_SECRET="<service_principal_password>"
Para executar o script
~/.bashrc
, executesource ~/.bashrc
(ou seu equivalente abreviado. ~/.bashrc
). Você também pode sair e reabrir o Cloud Shell para que o script seja executado automaticamente.. ~/.bashrc
Após as variáveis de ambiente terem sido definidas, você pode verificar os valores delas da seguinte forma:
printenv | grep ^ARM*
Pontos principais:
- Assim como ocorre com qualquer variável de ambiente, para acessar um valor de assinatura do Azure de dentro de um script do Terraform, use a seguinte sintaxe:
${env.<environment_variable>}
. Por exemplo, para acessar o valorARM_SUBSCRIPTION_ID
, especifique${env.ARM_SUBSCRIPTION_ID}
. - Criar e aplicar planos de execução do Terraform faz alterações na assinatura do Azure associada à entidade de serviço. Às vezes, isso pode ser confuso quanto você está conectado a uma assinatura do Azure e as variáveis de ambiente apontam para outra. Vejamos uma explicação no exemplo a seguir. Digamos que você tenha duas assinaturas do Azure: SubA e SubB. Se a assinatura atual do Azure é a SubA (determinada por meio de
az account show
) enquanto as variáveis de ambiente apontam para SubB, as alterações feitas pelo Terraform estão na SubB. Portanto, você precisaria fazer logon na assinatura SubB para executar comandos da CLI do Azure ou do Azure PowerShell para exibir as alterações.
Especificar credenciais de entidade de serviço em um bloco de provedor do Terraform
O bloco do provedor do Azure define a sintaxe que permite especificar as informações de autenticação de sua assinatura do Azure.
terraform {
required_providers {
azurerm = {
source = "hashicorp/azurerm"
version = "~>2.0"
}
}
}
provider "azurerm" {
features {}
subscription_id = "<azure_subscription_id>"
tenant_id = "<azure_subscription_tenant_id>"
client_id = "<service_principal_appid>"
client_secret = "<service_principal_password>"
}
# Your code goes here
Cuidado
A possibilidade de especificar as credenciais de assinatura do Azure em um arquivo de configuração do Terraform pode ser conveniente, especialmente ao fazer testes. No entanto, não é aconselhável armazenar credenciais em um arquivo de texto claro que possa ser visualizado por pessoas não confiáveis.
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 = jsondecode(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 = jsondecode(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 oterraform 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 paraterraform apply
. - Se você não usou o parâmetro
-out
, chameterraform 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 eEOT
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
- Se você vir
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 estejamRunning
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 dokubectl
.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.
- O comando
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
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.
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çãocurl
para a URL de localhost para a qual você foi redirecionado depois de executarazd 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 comohttps://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 daazd-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 deazd
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 comandokubectl 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 estejamRunning
, 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 dokubectl
.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 pressionandoEnter
.? 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 pressionandoEnter
.[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.