Guia de início rápido: implantar um host de contêiner Linux do Azure para cluster AKS usando o Terraform

Artigo
11/05/2024

Introdução ao Host de Contêiner Linux do Azure usando o Terraform para implantar um cluster de Host de Contêiner Linux do Azure. Depois de instalar os pré-requisitos, você implementa o código Terraform, inicializa Terraform e cria e aplica um plano de execução Terraform.

Terraform permite a definição, visualização e implantação de infraestrutura em nuvem. Com o Terraform, você cria arquivos de configuração usando a sintaxe HCL. A sintaxe HCL permite especificar 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 na infraestrutura antes que elas sejam implantadas. Depois de verificar as alterações, você aplica o plano de execução para implantar a infraestrutura.

Nota

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

Pré-requisitos

Se não tiver uma subscrição do Azure, crie uma conta gratuita do Azure antes de começar.
Se você ainda não configurou o Terraform, você pode fazê-lo usando uma das seguintes opções:
Se você não tiver uma entidade de serviço do Azure, crie uma entidade de serviço. Anote o appId, display_name, password, e tenant.
Você precisa da ferramenta kubectlde linha de comando Kubernetes . Se você não tem, baixe kubectl.

Criar um par de chaves SSH

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

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

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

Implementar o código Terraform

Crie um diretório no qual testar o código Terraform de exemplo e torná-lo o 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 Azure Linux os_sku no 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 terraform init comando.
```
terraform init
```
Crie um plano de execução Terraform usando o terraform plan comando.
```
terraform plan -out main.tfplan
```
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.

Para ler mais sobre planos de execução persistentes e segurança, consulte os avisos de segurança.
Aplique o plano de execução Terraform usando o terraform apply comando.
```
terraform apply main.tfplan
```
O terraform apply comando acima 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

Obtenha o nome do grupo de recursos usando o seguinte echo comando.
```
echo "$(terraform output resource_group_name)"
```
Navegue para 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 como ContainerInsights. O portal mostra o nome do espaço de trabalho da solução entre parênteses.
- Serviço Kubernetes: Por padrão, a demonstração nomeia esse serviço como k8stest. (Um cluster Kubernetes gerenciado também é conhecido como um Serviço Kubernetes AKS/Azure.)
- Espaço de trabalho do Log Analytics: por padrão, a demonstração nomeia esse espaço de trabalho com um prefixo de TestLogAnalyticsWorkspaceName- seguido por um número aleatório.
Obtenha a configuração do Kubernetes do estado Terraform e armazene-a em um arquivo que o kubectl pode ler usando o seguinte echo comando.
```
echo "$(terraform output kube_config)" > ./azurek8s
```
Verifique se o comando anterior não adicionou um caractere ASCII EOT usando o comando a seguir cat .
```
cat ./azurek8s
```
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.
Defina uma variável de ambiente para que o kubectl pegue a configuração correta usando o comando a seguir export .
```
export KUBECONFIG=./azurek8s
```
Verifique a integridade do cluster usando o kubectl get nodes comando.
```
kubectl get nodes
```
Quando o cluster do Host de Contêiner Linux do Azure foi criado, 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 foram gerados quando você aplicou o plano de execução Terraform. Por exemplo, o endereço do host, o nome de usuário do cluster do Host do Contêiner do Azure Linux e a senha do cluster do Host do Contêiner do Azure Linux são a saída.

Para visualizar 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>)".

Clean up resources (Limpar 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 terraform plan comando e especifique o destroy sinalizador.
```
terraform plan -destroy -out main.destroy.tfplan
```
Remova o plano de execução usando o terraform apply comando.
```
terraform apply main.destroy.tfplan
```

Excluir entidade de serviço

Atenção

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

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

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

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

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

Tutorial do Azure Linux Container Host

Partilhar via