Snabbstart: Distribuera en Azure Linux-containervärd för AKS-kluster med Terraform

Artikel
11/05/2024

Kom igång med Azure Linux Container Host med Terraform för att distribuera ett Azure Linux Container Host-kluster. När du har installerat förhandskraven implementerar du Terraform-koden, initierar Terraform och skapar och tillämpar en Terraform-körningsplan.

Terraform möjliggör definition, förhandsversion och distribution av molninfrastruktur. Med Terraform skapar du konfigurationsfiler med hjälp av HCL-syntax. Med HCL-syntaxen kan du ange molnleverantören och elementen som utgör din molninfrastruktur. När du har skapat konfigurationsfilerna skapar du en körningsplan som gör att du kan förhandsgranska ändringarna i infrastrukturen innan de distribueras. När du har verifierat ändringarna tillämpar du körningsplanen för att distribuera infrastrukturen.

Kommentar

Exempelkoden i den här artikeln finns på Microsoft Terraform GitHub-lagringsplatsen.

Förutsättningar

Om du inte har en Azure-prenumeration skapar du ett kostnadsfritt Azure-konto innan du börjar.
Om du inte redan har konfigurerat Terraform kan du göra det med något av följande alternativ:
Om du inte har ett Huvudnamn för Azure-tjänsten skapar du ett huvudnamn för tjänsten. Anteckna appId, , display_namepasswordoch tenant.
Du behöver kommandoradsverktyget kubectlKubernetes . Om du inte har den laddar du ned kubectl.

Skapa ett SSH-nyckelpar

För att få åtkomst till AKS-noder ansluter du med ett SSH-nyckelpar (offentligt och privat) som du genererar med kommandot ssh-keygen . Som standard skapas dessa filer i katalogen ~/.ssh . ssh-keygen När kommandot körs skrivs alla SSH-nyckelpar med samma namn som redan finns på den angivna platsen.

Gå till för att https://shell.azure.com öppna Cloud Shell i webbläsaren.
Kör kommandot ssh-keygen. I följande exempel skapas ett SSH-nyckelpar med RSA-kryptering och en bit längd på 4096:
```
ssh-keygen -t rsa -b 4096
```

Mer information om hur du skapar SSH-nycklar finns i Skapa och hantera SSH-nycklar för autentisering i Azure.

Implementera Terraform-koden

Skapa en katalog där du kan testa Terraform-exempelkoden och göra den till den aktuella katalogen.

Skapa en fil med namnet providers.tf och infoga följande kod:

    terraform {
      required_version = ">=1.0"

      required_providers {
        azurerm = {
          source  = "hashicorp/azurerm"
          version = "~>3.0"
        }
        random = {
          source  = "hashicorp/random"
          version = "~>3.0"
        }
      }
    }

    provider "azurerm" {
      features {}
    }

Skapa en fil med namnet main.tf och infoga följande kod:

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

På samma sätt kan du ange Azure Linux os_sku i azurerm_kubernetes_cluster_node_pool.

Skapa en fil med namnet variables.tf och infoga följande kod:

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

Skapa en fil med namnet outputs.tf och infoga följande kod:

    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
    }

Skapa en fil med namnet terraform.tfvars och infoga följande kod:

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

Initiera Terraform och skapa en körningsplan

Initiera Terraform och ladda ned de Azure-moduler som krävs för att hantera dina Azure-resurser med hjälp av terraform init kommandot .
```
terraform init
```
Skapa en Terraform-körningsplan med kommandot terraform plan .
```
terraform plan -out main.tfplan
```
Kommandot terraform plan skapar en körningsplan, men kör den inte. I stället avgör den vilka åtgärder som krävs för att skapa den konfiguration som anges i konfigurationsfilerna. Med det här mönstret kan du kontrollera om körningsplanen matchar dina förväntningar innan du gör några ändringar i faktiska resurser.

Med den valfria -out parametern kan du ange en utdatafil för planen. Med hjälp av parametern -out ser du till att planen du granskade är exakt vad som tillämpas.

Mer information om hur du bevarar körningsplaner och säkerhet finns i säkerhetsvarningarna.
Använd Terraform-körningsplanen med kommandot terraform apply .
```
terraform apply main.tfplan
```
Kommandot terraform apply ovan förutsätter att du tidigare körde terraform plan -out main.tfplan. Om du har angett ett annat filnamn för parametern -out använder du samma filnamn i anropet till terraform apply. Om du inte använde parametern -out anropar terraform apply du utan några parametrar.

Verifiera resultatet

Hämta resursgruppens namn med hjälp av följande echo kommando.
```
echo "$(terraform output resource_group_name)"
```
Bläddra till Azure-portalen.
Under Azure-tjänster väljer du Resursgrupper och letar upp den nya resursgruppen för att se följande resurser som skapats i den här demonstrationen:
- Lösning: Som standard namnger demonstrationen den här lösningen ContainerInsights. Portalen visar lösningens arbetsytenamn inom parentes.
- Kubernetes-tjänsten: Som standard namnger demonstrationen den här tjänsten k8stest. (Ett hanterat Kubernetes-kluster kallas även aks/Azure Kubernetes Service.)
- Log Analytics-arbetsyta: Som standard namnger demonstrationen den här arbetsytan med prefixet TestLogAnalyticsWorkspaceName följt av ett slumpmässigt tal.
Hämta Kubernetes-konfigurationen från Terraform-tillståndet och lagra den i en fil som kubectl kan läsa med hjälp av följande echo kommando.
```
echo "$(terraform output kube_config)" > ./azurek8s
```
Kontrollera att föregående kommando inte lade till ett ASCII EOT-tecken med hjälp av följande cat kommando.
```
cat ./azurek8s
```
Om du ser << EOT i början och EOT i slutet tar du bort dessa tecken från filen. Annars kan du få följande felmeddelande: error: error loading config file "./azurek8s": yaml: line 2: mapping values are not allowed in this context.
Ange en miljövariabel så att kubectl hämtar rätt konfiguration med hjälp av följande export kommando.
```
export KUBECONFIG=./azurek8s
```
Kontrollera hälsotillståndet för klustret med hjälp av kubectl get nodes kommandot .
```
kubectl get nodes
```
När Azure Linux Container Host-klustret skapades aktiverades övervakning för att samla in hälsomått för både klusternoderna och poddarna. De här hälsomåtten är tillgängliga i Azure-portalen. Mer information om övervakning av hälsotillstånd för containrar finns i Övervaka hälsotillstånd för Azure Kubernets Service.

Flera nyckelvärden var utdata när du tillämpade Terraform-körningsplanen. Värdadressen, användarnamnet för Azure Linux Container Host-klustret och Azure Linux Container Host-klusterlösenordet är till exempel utdata.

Om du vill visa alla utdatavärden kör du terraform output. Om du vill visa ett specifikt utdatavärde kör du echo "$(terraform output <output_value_name>)".

Rensa resurser

Ta bort AKS-resurser

När du inte längre behöver de resurser som skapats med Terraform kan du ta bort dem med hjälp av följande steg.

terraform plan Kör kommandot och ange destroy flaggan.
```
terraform plan -destroy -out main.destroy.tfplan
```
Ta bort körningsplanen med kommandot terraform apply .
```
terraform apply main.destroy.tfplan
```

Ta bort tjänstens huvudnamn

Varning

Ta bara bort tjänstens huvudnamn som du använde i den här demonstrationen om du inte använder det för något annat.

Hämta objekt-ID:t för tjänstens huvudnamn med kommandot az ad sp list

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

Ta bort tjänstens huvudnamn med kommandot az ad sp delete .
```
az ad sp delete --id <service_principal_object_id>
```

Felsöka Terraform i Azure

Felsöka vanliga problem när du använder Terraform i Azure.

Nästa steg

I den här snabbstarten distribuerade du ett Azure Linux Container Host-kluster. Om du vill veta mer om Azure Linux Container Host och gå igenom ett komplett exempel på klusterdistribution och hantering kan du fortsätta till självstudien Azure Linux Container Host.

Självstudie om Azure Linux Container Host

Dela via