Condividi tramite


Guida introduttiva: Distribuire un host contenitore Linux di Azure per un cluster del servizio Azure Kubernetes usando Terraform

Introduzione all'host contenitore Linux di Azure con Terraform per distribuire un cluster host contenitore Linux di Azure. Dopo aver installato i prerequisiti, si implementa il codice Terraform, si inizializza Terraform e si crea e si applica un piano di esecuzione Terraform.

Terraform consente di definire, visualizzare in anteprima e distribuire l'infrastruttura cloud. Con Terraform è possibile creare file di configurazione usando la sintassi HCL. La sintassi HCL consente di specificare il provider di servizi cloud e gli elementi che costituiscono l'infrastruttura cloud. Dopo aver creato i file di configurazione, è necessario creare un piano di esecuzione che consenta di visualizzare in anteprima le modifiche apportate all'infrastruttura prima che vengano distribuite. Dopo aver verificato le modifiche, è possibile applicare il piano di esecuzione per distribuire l'infrastruttura.

Nota

Il codice di esempio in questo articolo si trova nel repository GitHub di Microsoft Terraform.

Prerequisiti

Creare una coppia di chiavi SSH

Per accedere ai nodi del servizio Azure Kubernetes, connettersi usando una coppia di chiavi SSH (pubblica e privata), generata usando il comando ssh-keygen. Per impostazione predefinita, questi file vengono creati nella directory ~/.ssh. L'esecuzione del comando ssh-keygen sovrascrive qualsiasi coppia di chiavi SSH con lo stesso nome già esistente nella posizione specificata.

  1. Passare a https://shell.azure.com per aprire Cloud Shell nel browser.

  2. Eseguire il comando ssh-keygen. L'esempio seguente crea una coppia di chiavi SSH usando la crittografia RSA e una lunghezza in bit pari a 4096:

    ssh-keygen -t rsa -b 4096
    

Per altre informazioni su come creare le chiavi SSH, vedere Creare e gestire chiavi SSH per l'autenticazione in una macchina virtuale Linux in Azure.

Implementare il codice Terraform

  1. Creare una directory in cui testare il codice Terraform di esempio e impostarla come directory corrente.

  2. Creare un file denominato providers.tf e inserire il codice seguente:

        terraform {
          required_version = ">=1.0"
    
          required_providers {
            azurerm = {
              source  = "hashicorp/azurerm"
              version = "~>3.0"
            }
            random = {
              source  = "hashicorp/random"
              version = "~>3.0"
            }
          }
        }
    
        provider "azurerm" {
          features {}
        }
    
  3. Creare un file denominato main.tf e inserire il codice seguente:

        # 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
          }
        }
    

    Analogamente, è possibile specificare os_sku di Azure Linux in azurerm_kubernetes_cluster_node_pool.

  4. Creare un file denominato variables.tf e inserire il codice seguente:

        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"
        }
    
  5. Creare un file denominato outputs.tf e inserire il codice seguente:

        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
        }
    
  6. Creare un file denominato terraform.tfvars e inserire il codice seguente:

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

Inizializzare Terraform e creare un piano di esecuzione

  1. Inizializzare Terraform e scaricare i moduli di Azure necessari per gestire le risorse di Azure usando il comando terraform init.

    terraform init
    
  2. Creare un piano di esecuzione terraform usando il comando terraform plan.

    terraform plan -out main.tfplan
    

    Il comando terraform plan consente di creare un piano di esecuzione, ma non di eseguirlo. Determina invece le azioni necessarie per creare la configurazione specificata nei file di configurazione. Questo modello consente di verificare se il piano di esecuzione corrisponde alle aspettative prima di apportare modifiche alle risorse effettive.

    Il parametro -out facoltativo consente di specificare un file di output per il piano. L'uso del parametro -out garantisce che il piano esaminato sia esattamente quello che viene applicato.

    Per altre informazioni su come rendere persistenti i piani di esecuzione e la sicurezza, vedere gli avvisi di sicurezza.

  3. Applicare il piano di esecuzione terraform usando il comando terraform apply.

    terraform apply main.tfplan
    

    Il comando terraform apply precedente presuppone che sia stato eseguito in precedenza terraform plan -out main.tfplan. Se è stato specificato un nome di file diverso per il parametro -out, usare lo stesso nome file nella chiamata a terraform apply. Se non è stato usato il parametro -out, chiamare terraform apply senza parametri.

Verificare i risultati

  1. Ottenere il nome del gruppo di risorse usando il comando echo seguente.

    echo "$(terraform output resource_group_name)"
    
  2. Accedere al portale di Azure.

  3. In servizi di Azure selezionare Gruppi di risorse e individuare il nuovo gruppo di risorse per visualizzare le risorse seguenti create in questa demo:

    • Soluzione: per impostazione predefinita, la demo denomina questa soluzione ContainerInsights. Il portale mostra il nome dell'area di lavoro della soluzione tra parentesi.
    • Servizio Kubernetes: per impostazione predefinita, la demo denomina questo servizio k8stest. Un cluster Kubernetes gestito è noto anche come servizio Azure Kubernetes.
    • Area di lavoro Log Analytics: per impostazione predefinita, la demo assegna un nome all'area di lavoro con un prefisso di TestLogAnalyticsWorkspaceName, seguito da un numero casuale.
  4. Ottenere la configurazione di Kubernetes dallo stato terraform e archiviarla in un file che kubectl può leggere usando il comando echo seguente.

    echo "$(terraform output kube_config)" > ./azurek8s
    
  5. Verificare che il comando precedente non abbia aggiunto un carattere EOT ASCII usando il comando cat seguente.

    cat ./azurek8s
    

    Se viene visualizzato << EOT all'inizio e EOT alla fine, rimuovere questi caratteri dal file. In caso contrario, è possibile che venga visualizzato il messaggio di errore seguente: error: error loading config file "./azurek8s": yaml: line 2: mapping values are not allowed in this context.

  6. Impostare una variabile di ambiente in modo che kubectl rilevi la configurazione corretta usando il comando export seguente.

    export KUBECONFIG=./azurek8s
    
  7. Verificare l'integrità del cluster usando il comando kubectl get nodes.

    kubectl get nodes
    

    Quando è stato creato il cluster host contenitore Linux di Azure, il monitoraggio è stato abilitato per acquisire le metriche di integrità sia per i nodi del cluster che per i pod. Queste metriche di integrità sono disponibili nel portale di Azure. Per altre informazioni sul monitoraggio dell'integrità dei contenitori, vedere Monitorare l'integrità del servizio Azure Kubernetes.

    Quando è stato applicato il piano di esecuzione terraform, sono stati restituiti diversi valori chiave. Ad esempio, l'indirizzo host, il nome utente del cluster host del contenitore Linux di Azure e la password del cluster host Linux di Azure vengono restituiti.

    Per visualizzare tutti i valori di output, eseguire terraform output. Per visualizzare un valore di output specifico, eseguire echo "$(terraform output <output_value_name>)".

Pulire le risorse

Eliminare le risorse del servizio Azure Kubernetes

Quando le risorse create con Terraform non sono più necessarie, è possibile rimuoverle seguendo questa procedura.

  1. Eseguire il comando terraform plan e specificare il flag destroy.

    terraform plan -destroy -out main.destroy.tfplan
    
  2. Rimuovere il piano di esecuzione usando il comando terraform apply.

    terraform apply main.destroy.tfplan
    

Eliminare l'entità servizio

Attenzione

Eliminare l'entità servizio usata in questa demo solo se non viene usata per altri elementi.

  1. Ottenere l'ID oggetto dell'entità servizio ID usando il comando az ad sp list

    az ad sp list --display-name "<display_name>" --query "[].{\"Object ID\":id}" --output table
    
  2. Eliminare l'entità servizio usando il comando az ad sp delete.

    az ad sp delete --id <service_principal_object_id>
    

Risolvere i problemi di Terraform in Azure

Risolvere i problemi comuni relativi all'uso di Terraform in Azure.

Passaggi successivi

In questo avvio rapido è stato distribuito un cluster Host contenitore Linux di Azure. Per altre informazioni sull'host contenitore Linux di Azure ed eseguire un esempio completo di distribuzione e gestione del cluster, continuare con l'esercitazione sull'host contenitore Linux di Azure.