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

Artikel
11/05/2024

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.

Notitie

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

Vereisten

Als u geen Azure-abonnement hebt, kunt u een gratis Azure-account maken 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, en passwordtenant.
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 opdracht ssh-keygen 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 waarin u de Terraform-voorbeeldcode wilt testen en de huidige map kunt maken.

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 terraform apply bovenstaande opdracht wordt ervan uitgegaan dat u eerder hebt uitgevoerd terraform plan -out main.tfplan. Als u een andere bestandsnaam voor de -out parameter hebt opgegeven, gebruikt u dezelfde bestandsnaam in de aanroep naar terraform apply. Als u de parameter niet hebt gebruikt, roept terraform apply u deze -out aan zonder parameters.

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-services resourcegroepen 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: de demo noemt deze service k8stest standaard. (Een beheerd Kubernetes-cluster wordt ook wel AKS/Azure Kubernetes Service genoemd.)
- Log Analytics-werkruimte: de demo noemt deze werkruimte standaard 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 ziet<< EOT, 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 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 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>)".

Resources 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

Let op

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.

Zelfstudie over Azure Linux Container Host

Delen via