Snabbstart: Skapa ett Kubernetes-kluster med Azure Kubernetes Service med Terraform

Artikel
06/06/2023

Azure Kubernetes Service (AKS) hanterar din värdbaserade Kubernetes-miljö. Med AKS kan du distribuera och hantera containerbaserade program utan expertkunskaper om containerorkestrering. Med AKS kan du också utföra många vanliga underhållsåtgärder utan att koppla från din app. Dessa åtgärder omfattar etablering, uppgradering och skalning av resurser på begäran.

Den här artikeln visar hur du skapar ett Kubernetes-kluster med Azure Kubernetes Service (AKS) med Terraform. Exempelkoden är helt kapslad så att den automatiskt skapar ett tjänsthuvudnamn och SSH-nyckelpar (med AzAPI-providern).

I den här artikeln kan du se hur du:

Skapa ett slumpmässigt värde för Namnet på Azure-resursgruppen med hjälp av random_pet.
Skapa en Azure-resursgrupp med hjälp av azurerm_resource_group.
Få åtkomst till konfigurationen av AzureRM-providern för att hämta Azure-objekt-ID: t med hjälp av azurerm_client_config.
Skapa ett Kubernetes-kluster med azurerm_kubernetes_cluster.
Skapa en AzAPI-resurs azapi_resource.
Skapa en AzAPI-resurs för att generera ett SSH-nyckelpar med hjälp av azapi_resource_action.

Anteckning

Den här artikeln skapades delvis med hjälp av AI. Innan publiceringen granskade och ändrade en författare innehållet efter behov. Se Våra principer för att använda AI-genererat innehåll i Microsoft Learn.

Förutsättningar

Konfigurera Terraform: Om du inte redan har gjort det konfigurerar du Terraform med något av följande alternativ:

Kubernetes kommandoradsverktyg (kubectl):Ladda ned kubectl.

Implementera Terraform-koden

Anteckning

Exempelkoden för den här artikeln finns på Azure Terraform GitHub-lagringsplatsen. Du kan visa loggfilen som innehåller testresultaten från aktuella och tidigare versioner av Terraform.

Se fler artiklar och exempelkod som visar hur du använder Terraform för att hantera Azure-resurser

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

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

resource "random_pet" "ssh_key_name" {
  prefix    = "ssh"
  separator = ""
}

resource "azapi_resource" "ssh_public_key" {
  type      = "Microsoft.Compute/sshPublicKeys@2022-11-01"
  name      = random_pet.ssh_key_name.id
  location  = "westus3"
  parent_id = azurerm_resource_group.rg.id
}

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

output "key_data" {
  value     = azapi_resource.ssh_public_key.body
  sensitive = true
}

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_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 = "ubuntu"

    ssh_key {
      key_data = jsondecode(azapi_resource_action.ssh_public_key_gen.output).publicKey
    }
  }
  network_profile {
    network_plugin    = "kubenet"
    load_balancer_sku = "standard"
  }
}

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

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
}

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

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
}

Initiera Terraform

Kör terraform init för att initiera Terraform-distributionen. Det här kommandot laddar ned den Azure-provider som krävs för att hantera dina Azure-resurser.

terraform init -upgrade

Viktiga punkter:

Parametern -upgrade uppgraderar nödvändiga provider-plugin-program till den senaste versionen som uppfyller konfigurationens versionsbegränsningar.

Skapa en Terraform-körningsplan

Kör terraform-planen för att skapa en körningsplan.

terraform plan -out main.tfplan

Viktiga punkter:

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 konfigurationen 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 den plan som du har granskat är exakt det som tillämpas.
Mer information om beständiga körningsplaner och säkerhet finns i avsnittet säkerhetsvarning.

Tillämpa en Terraform-körningsplan

Kör terraform apply för att tillämpa körningsplanen på din molninfrastruktur.

terraform apply main.tfplan

Viktiga punkter:

terraform apply Exempelkommandot 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 resultaten

Azure CLI

Hämta namnet på Azure-resursgruppen.

resource_group_name=$(terraform output -raw resource_group_name)

Kör az aks list för att visa namnet på det nya Kubernetes-klustret.

az aks list \
  --resource-group $resource_group_name \
  --query "[].{\"K8s cluster name\":name}" \
  --output table

Hämta Kubernetes-konfigurationen från Terraform-tillståndet och lagra den i en fil som kubectl kan läsa.
```
echo "$(terraform output kube_config)" > ./azurek8s
```
Kontrollera att föregående kommando inte lade till något ASCII EOT-tecken.
```
cat ./azurek8s
```
Viktiga punkter:
- Om du ser << EOT i början och EOT 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 korrekt konfiguration.
```
export KUBECONFIG=./azurek8s
```
Kontrollera klustrets hälsotillstånd.
```
kubectl get nodes
```

Viktiga punkter:

När AKS-klustret skapades aktiverades övervakning för att registrera 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 genererades när du tillämpade Terraform-körningsplanen. Värdadressen, AKS-klustrets användarnamn och AKS-klusterlösenordet matas till exempel ut.

Rensa resurser

Ta bort AKS-resurser

Gör följande när du inte längre behöver de resurser som skapats via Terraform:

Kör terraform-planen och ange destroy flaggan .
```
terraform plan -destroy -out main.destroy.tfplan
```
Viktiga punkter:
- 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 konfigurationen 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 den plan som du har granskat är exakt det som tillämpas.
- Mer information om beständiga körningsplaner och säkerhet finns i avsnittet säkerhetsvarning.
Kör terraform apply för att tillämpa körningsplanen.
```
terraform apply main.destroy.tfplan
```

Ta bort tjänstens huvudnamn

Hämta tjänstens huvudnamns-ID.
```
sp=$(terraform output -raw sp)
```
Kör az ad sp delete för att ta bort tjänstens huvudnamn.
```
az ad sp delete --id $sp
```

Felsöka Terraform på Azure

Felsöka vanliga problem när du använder Terraform på Azure

Nästa steg

Läs mer om hur du använder AKS

Snabbstart: Skapa ett Kubernetes-kluster med Azure Kubernetes Service med Terraform

Förutsättningar

Implementera Terraform-koden

Initiera Terraform

Skapa en Terraform-körningsplan

Tillämpa en Terraform-körningsplan

Verifiera resultaten

Rensa resurser

Ta bort AKS-resurser

Ta bort tjänstens huvudnamn

Felsöka Terraform på Azure

Nästa steg

Ytterligare resurser

Ytterligare resurser