Quickstart: Een AKS-cluster (Azure Kubernetes Service) maken met behulp van Terraform

Artikel
06/16/2023

Azure Kubernetes Service (AKS) is een beheerde Kubernetes-service waarmee u snel clusters kunt implementeren en beheren. In deze snelstart, gaat u het volgende doen:

Implementeer een AKS-cluster met behulp van Terraform. De voorbeeldcode is volledig ingekapseld, zodat er automatisch een service-principal en een SSH-sleutelpaar worden gemaakt (met behulp van de AzAPI-provider).
Voer een voorbeeldtoepassing met meerdere containers uit met een web-front-end en een Redis-exemplaar in het cluster.

Preview van Azure Vote-voorbeeldtoepassing.

Terraform maakt de definitie, preview en implementatie van cloudinfrastructuur mogelijk. Met Terraform maakt u configuratiebestanden met behulp van de HCL-syntaxis. Met de HCL-syntaxis kunt u de cloudprovider opgeven, zoals Azure, en de elementen waaruit uw cloudinfrastructuur bestaat. Nadat u uw configuratiebestanden hebt gemaakt, maakt u een uitvoeringsplan waarmee u een voorbeeld van uw infrastructuurwijzigingen kunt bekijken voordat ze worden geïmplementeerd. Zodra u de wijzigingen hebt gecontroleerd, past u het uitvoeringsplan toe om de infrastructuur te implementeren.

In dit artikel leert u het volgende:

Maak een willekeurige waarde voor de naam van de Azure-resourcegroep met behulp van random_pet.
Maak een Azure-resourcegroep met behulp van azurerm_resource_group.
Open de configuratie van de AzureRM-provider om de Azure-object-id op te halen met behulp van azurerm_client_config.
Maak een Kubernetes-cluster met behulp van azurerm_kubernetes_cluster.
Maak een AzAPI-resource azapi_resource.
Maak een AzAPI-resource om een SSH-sleutelpaar te genereren met behulp van azapi_resource_action.

Vereisten

Terraform installeren en configureren
Kubernetes-opdrachtregelprogramma (kubectl):Kubectl downloaden.

De Terraform-code implementeren

Notitie

De voorbeeldcode voor dit artikel bevindt zich in de Azure Terraform GitHub-opslagplaats. U kunt het logboekbestand met de testresultaten van de huidige en eerdere versies van Terraform weergeven.

Zie meer artikelen en voorbeeldcode voor het gebruik van Terraform voor het beheren van Azure-resources

Maak een map waarin u de Terraform-voorbeeldcode wilt testen en maak er de huidige map van.

Maak een bestand met de naam providers.tf en voeg de volgende code in:

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

Maak een bestand met de naam ssh.tf en voeg de volgende code in:

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

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

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

output "key_data" {
  value = jsondecode(azapi_resource_action.ssh_public_key_gen.output).publicKey
}

Maak een bestand met de naam main.tf en voeg de volgende code in:

# 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 = var.username

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

Maak een bestand met de naam variables.tf en voeg de volgende code in:

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
}

variable "username" {
  type        = string
  description = "The admin username for the new cluster."
  default     = "azureadmin"
}

Maak een bestand met de naam outputs.tf en voeg de volgende code in:

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
}

Terraform initialiseren

Voer terraform init uit om de Terraform-implementatie te initialiseren. Met deze opdracht downloadt u de Azure-provider die is vereist voor het beheren van uw Azure-resources.

terraform init -upgrade

Belangrijkste punten:

Met de -upgrade parameter worden de benodigde providerinvoegtoepassingen bijgewerkt naar de nieuwste versie die voldoet aan de versiebeperkingen van de configuratie.

Een Terraform-uitvoeringsplan maken

Voer het terraform-plan uit om een uitvoeringsplan te maken.

terraform plan -out main.tfplan

Belangrijkste punten:

Met de terraform plan opdracht wordt een uitvoeringsplan gemaakt, maar niet uitgevoerd. In plaats daarvan wordt bepaald welke acties nodig zijn om de configuratie te maken die is opgegeven in uw configuratiebestanden. Met dit patroon kunt u controleren of het uitvoeringsplan aan uw verwachtingen voldoet voordat u wijzigingen aanbrengt in de werkelijke resources.
Met de optionele -out parameter kunt u een uitvoerbestand voor het plan opgeven. Als u de -out parameter gebruikt, zorgt u ervoor dat het plan dat u hebt gecontroleerd, precies is wat wordt toegepast.
Zie de sectie Beveiligingswaarschuwing voor meer informatie over permanente uitvoeringsplannen en beveiliging.

Een Terraform-uitvoeringsplan toepassen

Voer terraform apply uit om het uitvoeringsplan toe te passen op uw cloudinfrastructuur.

terraform apply main.tfplan

Belangrijkste punten:

In de voorbeeldopdracht terraform apply wordt ervan uitgegaan dat u eerder hebt uitgevoerd terraform plan -out main.tfplan.
Als u een andere bestandsnaam hebt opgegeven voor de -out parameter, gebruikt u diezelfde bestandsnaam in de aanroep van terraform apply.
Als u de -out parameter niet hebt gebruikt, roept terraform apply u aan zonder parameters.

De resultaten controleren

Azure-CLI

Haal de naam van de Azure-resourcegroep op.

resource_group_name=$(terraform output -raw resource_group_name)

Voer az aks list uit om de naam van het nieuwe Kubernetes-cluster weer te geven.

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

Haal de Kubernetes-configuratie op uit de Terraform-status en sla deze op in een bestand dat door kubectl kan worden gelezen.
```
echo "$(terraform output kube_config)" > ./azurek8s
```
Controleer of met de vorige opdracht geen ASCII EOT-teken is toegevoegd.
```
cat ./azurek8s
```
Belangrijkste punten:
- Als u aan het begin en EOT aan het einde ziet<< EOT, verwijdert u deze tekens uit het bestand. Anders kan het volgende foutbericht worden weergegeven: error: error loading config file "./azurek8s": yaml: line 2: mapping values are not allowed in this context
Stel een omgevingsvariabele in zodat de juiste configuratie wordt opgehaald door kubectl.
```
export KUBECONFIG=./azurek8s
```
Controleer de status van het cluster.
```
kubectl get nodes
```

Belangrijkste punten:

Toen het AKS-cluster werd gemaakt, werd controleren ingeschakeld om metrische gegevens over de status van de clusterknooppunten en -pods vast te leggen. Deze metrische gegevens over de status zijn in de Azure-portal beschikbaar. Zie Status van Azure Kubernetes Service controleren voor meer informatie over het controleren van de status van de container.
Er zijn verschillende sleutelwaarden uitgevoerd toen u het Terraform-uitvoeringsplan toepaste. Het hostadres, de gebruikersnaam van het AKS-cluster en het AKS-clusterwachtwoord worden bijvoorbeeld uitgevoerd.

De toepassing implementeren

Een Kubernetes-manifestbestand definieert de gewenste status van een cluster, zoals welke containerinstallatiekopieën moeten worden uitgevoerd.

In deze quickstart gebruikt u een manifest om alle objecten te maken die nodig zijn om de Azure Vote-toepassing uit te voeren. Dit manifest bevat twee Kubernetes-implementaties:

De Azure Vote Python-voorbeeldtoepassingen.
Een Redis-exemplaar.

Er worden twee Kubernetes-services gemaakt:

Een interne service voor het Redis-exemplaar.
Een externe service voor toegang tot de Azure Vote-toepassing vanaf internet.

Maak een bestand met de naam azure-vote.yaml en voeg de volgende code in:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: azure-vote-back
spec:
  replicas: 1
  selector:
    matchLabels:
      app: azure-vote-back
  template:
    metadata:
      labels:
        app: azure-vote-back
    spec:
      nodeSelector:
        "kubernetes.io/os": linux
      containers:
      - name: azure-vote-back
        image: mcr.microsoft.com/oss/bitnami/redis:6.0.8
        env:
        - name: ALLOW_EMPTY_PASSWORD
          value: "yes"
        resources:
          requests:
            cpu: 100m
            memory: 128Mi
          limits:
            cpu: 250m
            memory: 256Mi
        ports:
        - containerPort: 6379
          name: redis
---
apiVersion: v1
kind: Service
metadata:
  name: azure-vote-back
spec:
  ports:
  - port: 6379
  selector:
    app: azure-vote-back
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: azure-vote-front
spec:
  replicas: 1
  selector:
    matchLabels:
      app: azure-vote-front
  template:
    metadata:
      labels:
        app: azure-vote-front
    spec:
      nodeSelector:
        "kubernetes.io/os": linux
      containers:
      - name: azure-vote-front
        image: mcr.microsoft.com/azuredocs/azure-vote-front:v1
        resources:
          requests:
            cpu: 100m
            memory: 128Mi
          limits:
            cpu: 250m
            memory: 256Mi
        ports:
        - containerPort: 80
        env:
        - name: REDIS
          value: "azure-vote-back"
---
apiVersion: v1
kind: Service
metadata:
  name: azure-vote-front
spec:
  type: LoadBalancer
  ports:
  - port: 80
  selector:
    app: azure-vote-front

Belangrijkste punten:

Zie Implementaties en YAML-manifesten voor meer informatie over YAML-manifestbestanden.

Voer kubectl apply uit om de toepassing te implementeren.
```
kubectl apply -f azure-vote.yaml
```

De toepassing testen

Wanneer de toepassing wordt uitgevoerd, maakt een Kubernetes-service de front-end van de toepassing beschikbaar op internet. Dit proces kan enkele minuten duren. Voer kubectl get service uit met het argument om de --watch voortgang te bewaken.
```
kubectl get service azure-vote-front --watch
```
De EXTERNAL-IP-uitvoer voor de azure-vote-front service wordt in eerste instantie weergegeven als in behandeling. Zodra het EXTERNAL-IP-adres een IP-adres weergeeft, gebruikt CTRL-C u om het kubectl watch proces te stoppen.
Als u de Azure Vote-app in actie wilt zien, opent u een webbrowser naar het externe IP-adres van uw service.

Resources opschonen

AKS-resources verwijderen

Wanneer u de resources die via Terraform zijn gemaakt niet meer nodig hebt, voert u de volgende stappen uit:

Voer het terraform-plan uit en geef de vlag op destroy .
```
terraform plan -destroy -out main.destroy.tfplan
```
Belangrijkste punten:
- Met de terraform plan opdracht wordt een uitvoeringsplan gemaakt, maar niet uitgevoerd. In plaats daarvan wordt bepaald welke acties nodig zijn om de configuratie te maken die is opgegeven in uw configuratiebestanden. Met dit patroon kunt u controleren of het uitvoeringsplan aan uw verwachtingen voldoet voordat u wijzigingen aanbrengt in de werkelijke resources.
- Met de optionele -out parameter kunt u een uitvoerbestand voor het plan opgeven. Als u de -out parameter gebruikt, zorgt u ervoor dat het plan dat u hebt gecontroleerd, precies is wat wordt toegepast.
- Zie de sectie Beveiligingswaarschuwing voor meer informatie over permanente uitvoeringsplannen en beveiliging.
Voer terraform apply uit om het uitvoeringsplan toe te passen.
```
terraform apply main.destroy.tfplan
```

Service-principal verwijderen

Haal de service-principal-id op.
```
sp=$(terraform output -raw sp)
```
Voer az ad sp delete uit om de service-principal te verwijderen.
```
az ad sp delete --id $sp
```

Problemen met Terraform in Azure oplossen

Veelvoorkomende problemen bij het gebruik van Terraform in Azure oplossen

Volgende stappen

Meer informatie over het gebruik van AKS

Quickstart: Een AKS-cluster (Azure Kubernetes Service) maken met behulp van Terraform

Vereisten

De Terraform-code implementeren

Terraform initialiseren

Een Terraform-uitvoeringsplan maken

Een Terraform-uitvoeringsplan toepassen

De resultaten controleren

De toepassing implementeren

De toepassing testen

Resources opschonen

AKS-resources verwijderen

Service-principal verwijderen

Problemen met Terraform in Azure oplossen

Volgende stappen

Aanvullende resources

Aanvullende resources