Quickstart: Een Azure Linux-containerhost voor AKS-cluster implementeren met behulp van Terraform

Ga aan de slag met de Azure Linux-containerhost met behulp van Terraform om een Azure Linux Container Host-cluster te implementeren. Nadat u de vereisten hebt geïnstalleerd, implementeert u de Terraform-code, initialiseert u Terraform en maakt en past u een Terraform-uitvoeringsplan toe.

Terraform maakt de definitie, preview en implementatie van de cloudinfrastructuur mogelijk. Met Terraform maakt u configuratiebestanden met behulp van de HCL-syntaxis. Met de HCL-syntaxis kunt u de cloudprovider en elementen opgeven 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.

Note

De voorbeeldcode in dit artikel bevindt zich in de Microsoft Terraform GitHub-opslagplaats.

Belangrijk

Vanaf 30 november 2025 biedt AKS geen ondersteuning meer voor beveiligingsupdates voor Azure Linux 2.0. Vanaf 31 maart 2026 worden knooppuntbeelden verwijderd en kunt u uw knooppuntenpools niet schalen. Migreer naar een ondersteunde Versie van Azure Linux door uw knooppuntgroepen te upgraden naar een ondersteunde Kubernetes-versie of naar osSku AzureLinux3te migreren. Zie [Buitengebruikstelling] Azure Linux 2.0-knooppuntgroepen in AKS voor meer informatie.

Prerequisites

Als u geen Azure-account hebt, maak dan een gratis account aan voordat u begint.
Als u Terraform nog niet hebt geconfigureerd, kunt u dit doen met een van de volgende opties:
Als u geen Azure-service-principal hebt, maakt u een service-principal. Noteer de appId, display_name, password, en tenant.
U hebt het kubernetes-opdrachtregelprogramma kubectlnodig. Als u deze niet hebt, downloadt u kubectl.

Een SSH-sleutelpaar maken

Voor toegang tot AKS-knooppunten maakt u verbinding met behulp van een SSH-sleutelpaar (openbaar en privé) dat u genereert met behulp van de ssh-keygen opdracht. Deze bestanden worden standaard gemaakt in de map ~/.ssh . Als u de ssh-keygen opdracht uitvoert, overschrijft u een SSH-sleutelpaar met dezelfde naam die al bestaat op de opgegeven locatie.

Ga naar https://shell.azure.com om Cloud Shell in uw browser te openen.
Voer de ssh-keygen opdracht uit. In het volgende voorbeeld wordt een SSH-sleutelpaar gemaakt met RSA-versleuteling en een bitlengte van 4096:
```
ssh-keygen -t rsa -b 4096
```

Zie SSH-sleutels maken en beheren voor verificatie in Azure voor meer informatie over het maken van SSH-sleutels.

De Terraform-code implementeren

Maak een map om de Terraform-voorbeeldcode te testen en maak deze map de huidige werkmap.

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

    terraform {
      required_version = ">=1.0"

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

    provider "azurerm" {
      features {}
    }

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

Op dezelfde manier kunt u azure Linux os_sku opgeven in azurerm_kubernetes_cluster_node_pool.

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

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

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

    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
    }

Maak een bestand met de naam terraform.tfvars en voeg de volgende code in:

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

Terraform initialiseren en een uitvoeringsplan maken

Initialiseer Terraform en download de Azure-modules die nodig zijn om uw Azure-resources te beheren met behulp van de terraform init opdracht.
```
terraform init
```
Maak een Terraform-uitvoeringsplan met behulp van de terraform plan opdracht.
```
terraform plan -out main.tfplan
```
De terraform plan opdracht maakt een uitvoeringsplan, maar voert het niet uit. 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. Door de -out parameter te gebruiken, zorgt u ervoor dat het plan dat u hebt gecontroleerd precies wordt toegepast.

Zie de beveiligingswaarschuwingen voor meer informatie over het persistent maken van uitvoeringsplannen en beveiliging.
Pas het Terraform-uitvoeringsplan toe met behulp van de terraform apply opdracht.
```
terraform apply main.tfplan
```
In de bovenstaande opdracht terraform apply wordt ervan uitgegaan dat u terraform plan -out main.tfplan eerder hebt uitgevoerd. Als u een andere bestandsnaam voor de -out parameter hebt opgegeven, gebruikt u dezelfde bestandsnaam in de aanroep naar terraform apply. Als u de -out-parameter niet hebt gebruikt, roep terraform apply dan zonder parameters aan.

De resultaten controleren

Haal de naam van de resourcegroep op met behulp van de volgende echo opdracht.
```
echo "$(terraform output resource_group_name)"
```
Blader naar Azure Portal.
Selecteer onder Azure-servicesresourcegroepen en zoek uw nieuwe resourcegroep om de volgende resources te bekijken die in deze demo zijn gemaakt:
- Oplossing: De demo noemt deze oplossing standaard ContainerInsights. In de portal ziet u de naam van de werkruimte van de oplossing tussen haakjes.
- Kubernetes-service: Standaard verwijst de demo naar deze service k8stest. (Een beheerd Kubernetes-cluster wordt ook wel AKS/Azure Kubernetes Service genoemd.)
- Log Analytics-werkruimte: De demo noemt deze werkruimte standaard met een voorvoegsel van TestLogAnalyticsWorkspaceName, gevolgd door een willekeurig getal.
Haal de Kubernetes-configuratie op uit de Terraform-status en sla deze op in een bestand dat kubectl kan lezen met behulp van de volgende echo opdracht.
```
echo "$(terraform output kube_config)" > ./azurek8s
```
Controleer of de vorige opdracht geen ASCII EOT-teken heeft toegevoegd met behulp van de volgende cat opdracht.
```
cat ./azurek8s
```
Als u aan het begin en << EOT aan het einde zietEOT, verwijdert u deze tekens uit het bestand. Anders zou u het volgende foutbericht kunnen ontvangen: error: error loading config file "./azurek8s": yaml: line 2: mapping values are not allowed in this context.
Stel een omgevingsvariabele in, zodat kubectl de juiste configuratie ophaalt met behulp van de volgende export opdracht.
```
export KUBECONFIG=./azurek8s
```
Controleer de status van het cluster met behulp van de kubectl get nodes opdracht.
```
kubectl get nodes
```
Toen het Azure Linux Container Host-cluster werd gemaakt, is bewaking ingeschakeld voor het vastleggen van metrische statusgegevens voor zowel de clusterknooppunten als pods. Deze gezondheidsstatistieken zijn beschikbaar in de Azure portal. Zie Status van Azure Kubernetes Service bewaken voor meer informatie over containerstatuscontrole.

Er werden verschillende sleutelwaarden gegenereerd bij het toepassen van het Terraform-uitvoeringsplan. Het hostadres, de gebruikersnaam van het Azure Linux Container Host-cluster en het azure Linux Container Host-clusterwachtwoord worden bijvoorbeeld uitgevoerd.

Als u alle uitvoerwaarden wilt weergeven, voert u het volgende uit terraform output. Als u een specifieke uitvoerwaarde wilt weergeven, voert u het volgende uit echo "$(terraform output <output_value_name>)".

De hulpbronnen opschonen

AKS-resources verwijderen

Wanneer u de resources die zijn gemaakt met Terraform niet meer nodig hebt, kunt u ze verwijderen met behulp van de volgende stappen.

Voer de terraform plan opdracht uit en geef de destroy vlag op.
```
terraform plan -destroy -out main.destroy.tfplan
```
Verwijder het uitvoeringsplan met behulp van de terraform apply opdracht.
```
terraform apply main.destroy.tfplan
```

Service-principal verwijderen

Caution

Verwijder de service-principal die u in deze demo hebt gebruikt, alleen als u deze niet voor iets anders gebruikt.

De object-id van de service-principal ophalen met behulp van de az ad sp list opdracht

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

Verwijder de service-principal met behulp van de az ad sp delete opdracht.
```
az ad sp delete --id <service_principal_object_id>
```

Problemen met Terraform in Azure oplossen

Veelvoorkomende problemen bij het gebruik van Terraform in Azure oplossen.

Volgende stappen

In deze quickstart hebt u een Azure Linux Container Host-cluster geïmplementeerd. Als u meer wilt weten over de Azure Linux Container Host en een volledig voorbeeld van clusterimplementatie en -beheer doorloopt, gaat u verder met de zelfstudie over Azure Linux Container Host.

Azure Linux Container Host handleiding

Feedback

Is deze pagina nuttig?

Last updated on 2025-09-11