Início rápido: implantar um cluster do Host de Contêiner do Linux do Azure para AKS usando o Terraform

Artigo
10/16/2024

Comece a usar o Host de Contêiner do Linux do Azure por meio do Terraform a fim de implantar um cluster do Host de Contêiner do Linux do Azure. Depois de instalar os pré-requisitos, você implementa o código do Terraform, inicializa o Terraform e cria e aplica um plano de execução do Terraform.

O Terraform permite a definição, a visualização e a implantação da infraestrutura de nuvem. Com o Terraform, você cria arquivos de configuração usando sintaxe de HCL. A sintaxe da HCL permite que você especifique o provedor de nuvem e os elementos que compõem sua infraestrutura de nuvem. Depois de criar os arquivos de configuração, você cria um plano de execução que permite visualizar as alterações de infraestrutura antes de serem implantadas. Depois de verificar as alterações, aplique o plano de execução para implantar a infraestrutura.

Observação

O exemplo de código deste artigo está localizado no repositório do GitHub do Microsoft Terraform.

Pré-requisitos

Caso você não tenha uma assinatura do Azure, crie uma conta gratuita do Azure antes de começar.
Se você ainda não tiver configurado o Terraform, poderá fazer isso usando uma das seguintes opções:
Se você não tem uma entidade de serviço do Azure, crie uma. Anote o appId, display_name, password e tenant.
Você precisa da ferramenta de linha de comando do Kubernetes kubectl. Caso ainda não o tenha, baixe o kubectl.

Criar um par de chaves SSH

Para acessar os nós do AKS, você se conecta usando um par de chaves SSH (pública e privada), que você gera usando o comando ssh-keygen. Por padrão, esses arquivos são criados no diretório ~/.ssh. A execução do comando ssh-keygen substituirá qualquer par de chaves SSH com o mesmo nome já existente na localização especificada.

Acesse https://shell.azure.com para abrir o Cloud Shell no navegador.
Execute o comando ssh-keygen. O seguinte exemplo cria um par de chaves SSH usando a criptografia RSA e o tamanho de bit 4096:
```
ssh-keygen -t rsa -b 4096
```

Para obter mais informações sobre como criar chaves SSH, confira Criar e gerenciar chaves SSH para autenticação no Azure.

Implementar o código do Terraform

Crie um diretório em que você vai 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 {
        azurerm = {
          source  = "hashicorp/azurerm"
          version = "~>3.0"
        }
        random = {
          source  = "hashicorp/random"
          version = "~>3.0"
        }
      }
    }

    provider "azurerm" {
      features {}
    }

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_id" "log_analytics_workspace_name_suffix" {
      byte_length = 8
    }

    resource "azurerm_log_analytics_workspace" "test" {
      location            = var.log_analytics_workspace_location
      # The WorkSpace name has to be unique across the whole of azure;
      # not just the current subscription/tenant.
      name                = "${var.log_analytics_workspace_name}-${random_id.log_analytics_workspace_name_suffix.dec}"
      resource_group_name = azurerm_resource_group.rg.name
      sku                 = var.log_analytics_workspace_sku
    }

    resource "azurerm_log_analytics_solution" "test" {
      location              = azurerm_log_analytics_workspace.test.location
      resource_group_name   = azurerm_resource_group.rg.name
      solution_name         = "ContainerInsights"
      workspace_name        = azurerm_log_analytics_workspace.test.name
      workspace_resource_id = azurerm_log_analytics_workspace.test.id

      plan {
        product   = "OMSGallery/ContainerInsights"
        publisher = "Microsoft"
      }
    }

    resource "azurerm_kubernetes_cluster" "k8s" {
      location            = azurerm_resource_group.rg.location
      name                = var.cluster_name
      resource_group_name = azurerm_resource_group.rg.name
      dns_prefix          = var.dns_prefix
      tags                = {
        Environment = "Development"
      }

      default_node_pool {
        name       = "azurelinuxpool"
        vm_size    = "Standard_D2_v2"
        node_count = var.agent_count
        os_sku = "AzureLinux"
      }
      linux_profile {
        admin_username = "azurelinux"

        ssh_key {
          key_data = file(var.ssh_public_key)
        }
      }
      network_profile {
        network_plugin    = "kubenet"
        load_balancer_sku = "standard"
      }
      service_principal {
        client_id     = var.aks_service_principal_app_id
        client_secret = var.aks_service_principal_client_secret
      }
    }

Da mesma forma, você pode especificar o Linux do Azure os_sku em azurerm_kubernetes_cluster_node_pool.

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

    variable "agent_count" {
        default = 3
    }

    # The following two variable declarations are placeholder references.
    # Set the values for these variable in terraform.tfvars
    variable "aks_service_principal_app_id" {
      default = ""
    }

    variable "aks_service_principal_client_secret" {
      default = ""
    }

    variable "cluster_name" {
      default = "k8stest"
    }

    variable "dns_prefix" {
      default = "k8stest"
    }

    # Refer to https://azure.microsoft.com/global-infrastructure/services/?products=monitor for available Log Analytics regions.
    variable "log_analytics_workspace_location" {
      default = "eastus"
    }

    variable "log_analytics_workspace_name" {
      default = "testLogAnalyticsWorkspaceName"
    }

    # Refer to https://azure.microsoft.com/pricing/details/monitor/ for Log Analytics pricing
    variable "log_analytics_workspace_sku" {
      default = "PerGB2018"
    }

    variable "resource_group_location" {
      default     = "eastus"
      description = "Location of the resource group."
    }

    variable "resource_group_name_prefix" {
      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 "ssh_public_key" {
      default = "~/.ssh/id_rsa.pub"
    }

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

    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
    }

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

Crie um arquivo chamado terraform.tfvars e insira o seguinte código:

    aks_service_principal_app_id = "<service_principal_app_id>"
    aks_service_principal_client_secret = "<service_principal_password>"

Inicializar o Terraform e criar um plano de execução

Inicialize o Terraform e baixe os módulos do Azure necessários para gerenciar seus recursos do Azure usando o comando terraform init.
```
terraform init
```
Crie um plano de execução do Terraform usando o comando terraform plan.
```
terraform plan -out main.tfplan
```
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.

Para ler mais sobre a persistência de planos de execução e segurança, confira os avisos de segurança.
Aplique o plano de execução do Terraform usando o comando terraform apply.
```
terraform apply main.tfplan
```
O comando terraform apply acima pressupõe que você já executou terraform plan -out main.tfplan. Se você especificou um nome de arquivo diferente para o parâmetro -out, use esse mesmo nome de arquivo na chamada para terraform apply. Se você não usou o parâmetro -out, chame terraform apply sem nenhum parâmetro.

Verifique os resultados

Obtenha o nome do grupo de recursos usando o comando echo a seguir.
```
echo "$(terraform output resource_group_name)"
```
Navegue até o Portal do Azure.
Em Serviços do Azure, selecione Grupos de recursos e localize seu novo grupo de recursos para ver os seguintes recursos criados nesta demonstração:
- Solução: por padrão, a demonstração nomeia essa solução containerInsights. O portal mostra o nome do workspace da solução entre parênteses.
- Serviço do Kubernetes: por padrão, a demonstração nomeia esse serviço k8stest. (Um cluster do Kubernetes gerenciado também é conhecido como AKS/Serviço de Kubernetes do Azure.)
- Workspace do Log Analytics: por padrão, a demonstração nomeia esse workspace com um prefixo TestLogAnalyticsWorkspaceName- seguido por um número aleatório.
Obtenha a configuração do Kubernetes do estado do Terraform e armazene-a em um arquivo que o kubectl possa ler usando o comando echo a seguir.
```
echo "$(terraform output kube_config)" > ./azurek8s
```
Verifique se o comando anterior não adicionou um caractere ASCII EOT usando o comando cat a seguir.
```
cat ./azurek8s
```
Se você vir << EOT no início e EOT no final, remova esses caracteres do arquivo. Caso contrário, a seguinte mensagem de erro poderá ser exibida: error: error loading config file "./azurek8s": yaml: line 2: mapping values are not allowed in this context.
Defina uma variável de ambiente para que kubectl pegue a configuração correta usando o comando export a seguir.
```
export KUBECONFIG=./azurek8s
```
Verifique a integridade do cluster usando o comando kubectl get nodes.
```
kubectl get nodes
```
Quando o cluster do Host de Contêiner do Linux do Azure foi criado, 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 foram gerados 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 Host de Contêiner do Linux do Azure e a senha do cluster do Host de Contêiner do Linux do Azure são gerados.

Para exibir todos os valores de saída, execute terraform output. Para exibir um valor de saída específico, execute echo "$(terraform output <output_value_name>)".

Limpar os recursos

Excluir recursos do AKS

Quando você não precisar mais dos recursos criados com o Terraform, poderá removê-los usando as etapas a seguir.

Execute o comando terraform plan e especifique o sinalizador destroy.
```
terraform plan -destroy -out main.destroy.tfplan
```
Remova o plano de execução usando o comando terraform apply.
```
terraform apply main.destroy.tfplan
```

Excluir uma entidade de serviço

Cuidado

Exclua a entidade de serviço usada nesta demonstração somente se você não a estiver usando para mais nada.

Obtenha a ID de objeto da entidade de serviço usando o comando az ad sp list

az ad sp list --display-name "<display_name>" --query "[].{\"Object ID\":id}" --output table

Exclua a entidade de serviço usando o comando az ad sp delete.
```
az ad sp delete --id <service_principal_object_id>
```

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 Host de Contêiner do Linux do Azure. Para saber mais sobre o Host de Contêiner do Linux do Azure e conferir um exemplo completo de implantação e gerenciamento de cluster, prossiga para o tutorial do Host de Contêiner do Linux do Azure.

Tutorial do Host de Contêiner do Linux do Azure

Compartilhar via