Siarhei - stock.adobe.com
So verwenden Sie Kubernetes und Terraform zusammen in Azure
Kubernetes und Terraform bieten viele Vorteile bei der Verwaltung von Container-Clustern – und besonders praktisch sind sie in Kombination. Wir erklären, wie das geht.
Jeweils für sich genommen, sind Kubernetes und Terraform leistungsstarke und beliebte Tools für IT-Betriebsteams. Gemeinsam bringen sie noch mehr Vorteile für die Verwaltung von Container-Clustern.
Bevor wir lernen, wie man ein Kubernetes-Cluster auf Azure Kubernetes Service (AKS) mit der Azure Befehlszeile (Azure CLI) und Terraform erstellt, müssen wir ein wenig über beide Tool wissen und was wir brauchen, um sie gemeinsam zu implementieren. Am Ende dieser Anleitung sollten Sie in der Lage sein, ein Kubernetes-Cluster bereitzustellen und eine Anwendung darauf zu implementieren, und zwar vollständig automatisiert über Terraform.
Was ist Terraform?
Terraform ist ein Open-Source-Infrastruktur-as-Code-Werkzeug von HashiCorp für die Verwaltung von Cloud-Diensten. Mit Terraform erstellen IT-Teams einen Infrastruktur- und Anwendungsbereitstellungsplan und prüfen Änderungen, bevor sie diese auf den Cloud-Anbieter ihrer Wahl anwenden.
Zu den Vorteilen von Terraform für das Einrichten und Verwalten von Clustern gehören
- Lebenszyklusmanagement. Kontrolle des gesamten Lebenszyklus eines Clusters, vom Erstellen und Aktualisieren bis hin zum Löschen von Ressourcen, auch in einer Multi-Cloud-Infrastruktur.
- Infrastruktur als Code (IaC). Verwenden Sie Code und Konfigurationsdateien, um Ressourcen zu verwalten und zu pflegen. Dies erleichtert das Nachvollziehen von Versionen und, wenn nötig, das Rollback.
- Automatisierte Infrastrukturimplementierungen und reduzierter Zeit- und Arbeitsaufwand. Mit Terraform-Konfigurationsdateien stellen Sie Ressourcen wiederholt konsistent bereit. Sie sparen Zeit durch einfaches Anpassen von Variablen oder Parametern.
Voraussetzungen
Bevor wir uns an die Arbeit machen, sollten wir sicherstellen, dass alle Voraussetzungen erfüllt sind. Um der Anleitung zu folgen und Ihr eigenes AKS-Cluster mit Terraform zu erstellen, müssen Sie zunächst die folgenden Schritte durchführen:
- Erstellen Sie ein Azure-Konto und melden Sie sich im Azure-Portal an.
- Erstellen Sie ein Abonnement mit Eigentümerrechten.
- Installieren Sie die Azure CLI, das neueste Terraform-Image und das neueste kubectl-Image.
Einrichten und Initialisieren Ihres Terraform-Projekts
Nachdem wir nun verstanden haben, was Terraform bei der AKS- und Kubernetes-Bereitstellung bringt und alle wichtigen Tools installiert haben, richten wir im nächsten Schritt ein Terraform-Projekt ein. Zu diesem Zweck habe ich ein GitHub-Repository erstellt, das alle erforderlichen Dateien enthält.
Klonen Sie zunächst das folgende GitHub-Repository:
git clone https://github.com/PrateekKumarSingh/aks-cluster-terraform
Ändern Sie dann das Verzeichnis in den folgenden Ordner:
cd aks-cluster-terraform
Dadurch gewähren Sie Zugriff auf alle Terraform-Dateien auf Ihrem lokalen System. Ihre Liste lautet folgendermaßen:
- main.tf
- variables.tf
- versions.tf
- outputs.tf
- terraform.tfvars
Main.tf ist der primäre Einstiegspunkt von Terraform. Sie erstellt die Azure-Ressourcengruppe und den Kubernetes-Cluster, wie im folgenden Code-Schnipsel zu sehen ist, der in der domänenspezifischen deklarativen Konfigurationssprache HashiCorp Configuration Language geschrieben wurde.
provider "azurerm" {
features {}
}
resource "azurerm_resource_group" "default" {
name = "demo-aks-terraform-rg"
location = "West US 2"
tags = {
environment = "demo"
}
}
resource "azurerm_kubernetes_cluster" "default" {
name = "demo-aks-cluster"
location = azurerm_resource_group.default.location
resource_group_name = azurerm_resource_group.default.name
dns_prefix = "demo-aks-cluster-dns"
default_node_pool {
name = "default"
node_count = 2
vm_size = "Standard_D2_v2"
os_disk_size_gb = 30
}
service_principal {
client_id = var.appId
client_secret = var.passwort
}
role_based_access_control {
enabled = true
}
tags = {
environment = "demo"
}
}
In der Datei variables.tf deklarieren Sie alle Variablen, die Sie verwenden – in diesem Fall appId und passwort. Geben Sie eine Beschreibung dieser Variablen an, damit Sie sie innerhalb der Terraform-Module verwenden können.
variable "appId" {
description = "Azure Kubernetes Service Cluster Dienstprinzipal"
}
variable "passwort" {
description = "Azure Kubernetes Service Cluster Passwort"
}
Die Datei terraform.tfvars definiert die Werte für diese Variablen und speichert Geheimnisse, wie die ID und das Passwort Ihres Azure-Dienstprinzipals. Bearbeiten Sie diese Datei und geben Sie die entsprechenden Werte für die appId- und passwort-Variablen des Dienstprinzipals an, der diese Ressourcen in Azure bereitstellen wird.
appId = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
passwort = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
In der Datei versions.tf definieren und listen Sie die Anbieter und ihre jeweiligen Versionen auf, die für den Terraform-Einsatz erforderlich sind. Zum Beispiel definieren wir hashicorp/azurerm als den erforderlichen Anbieter für alle Azure-Bereitstellungen.
terraform {
required_providers {
azurerm = {
source = "hashicorp/azurerm"
version = "2.66.0"
}
}
required_version = ">= 0.14"
}
Die Datei outputs.tf enthält die Namen und Werte der Variablen, die in der Befehlszeile verfügbar sind, wenn die Terraform-Bereitstellung abgeschlossen ist. Beispiele dafür sind der Name der Ressourcengruppe und der Kubernetes-Cluster.
output "resource_group_name" {
value = azurerm_resource_group.default.name
}
output "kubernetes_cluster_name" {
value = azurerm_kubernetes_cluster.default.name
}
Sobald wir diese Dateien lokal eingerichtet haben, können wir mit Terraform unser erstes AKS-Cluster bereitstellen.
Wie man ein AKS-Cluster mit Terraform bereitstellt
Wechseln Sie zunächst in die Befehlszeile, und melden Sie sich mit dem folgenden Befehl bei Azure an:
az Login
Nun erhalten Sie eine JSON-Ausgabe in der Konsole. Diese Ausgabe enthält Mandanten- und Abonnementdetails, wie in Abbildung 1 dargestellt.
Als Nächstes verwenden Sie den folgenden Befehl, um einen Azure Dienstprinzipal zu erstellen, damit Terraform Zugriff auf die Bereitstellung von Ressourcen in Azure erhält. Geben Sie eine gültige Azure-Abonnement-ID im folgenden Befehl unter dem Parameter --scopes an.
az ad sp create-for-rbac --role="Contributor" --scopes="/subscriptions/<Ihre Abonnement-ID>"
Sobald der Service Principal erstellt ist, sehen wir appId und password als Ausgaben in der Kommandozeile. Verwenden Sie diese in der Datei terraform.tfvars, um Variablen zu deklarieren, wie gerade beschrieben, damit Terraform Azure-Einsätze authentifizieren und autorisieren kann.
Wenn Sie mehrere Abonnements haben, verwenden Sie den folgenden Befehl, um das Abonnement anzugeben. Dies setzt den richtigen Kontext für Terraform, so dass es das Ziel-Azure-Abonnement versteht, auf dem es die Ressourcen bereitstellen und verteilen soll.
az account set --subscription <Ihre Abonnement-ID>
Geben Sie anschließend den folgenden Befehl ein, um Provider-Plugins zu initialisieren und eine Sperrdatei für alle externen Abhängigkeiten zu erstellen:
terraform init
Um eine Vorschau der Änderungen zu erhalten, die Terraform in Azure vornehmen wird, führen Sie den diesen Befehl aus, mit dem Sie einen Ausführungsplan erstellen:
terraform plan
Sobald Sie mit Ihrem Plan zufrieden sind, geben Sie den nächsten Befehl ein, um ihn anzuwenden und Ihre Azure-Ressourcen bereitzustellen:
Sobald die Bereitstellung abgeschlossen ist, erscheint Apply Complete in der Befehlszeile und gibt Variablen aus, die wir im Zusammenhang mit der outputs.tf-Datei bereits erläutert haben, wie den Namen des Kubernetes-Clusters und die Azure-Ressourcengruppe. Sie können diese Informationen auch über das Azure-Portal einsehen, indem Sie die Ressourcengruppe besuchen, wo Sie einen bereitgestellten Kubernetes-Dienst sehen, wie in Abbildung 5 dargestellt.
Testen Sie das Cluster mit einer einfachen Anwendung
Da unser Kubernetes-Cluster nun bereitgestellt ist, müssen wir kubectl so konfigurieren, dass es auf dieses verweist. Geben Sie dazu den folgenden Befehl ein:
az aks get-credentials --resource-group demo-aks-terraform-rg --name demo-aks-cluster
Führen Sie nun den untenstehenden Befehl aus, um eine Nginx-Bereitstellung zu erstellen und so zu testen, ob die Pods gestartet oder in Betrieb sind:
kubectl create deployment nginx --image=nginx
kubectl get pods
Alternativ können Sie das Azure-Portal aufrufen und die Bereitstellung unter dem Abschnitt Workloads des Kubernetes-Clusters finden.
Wenn wir die spezifische Bereitstellung aufschlüsseln, sehen wir zusätzlich die Container.
Um zu überprüfen, ob der Nginx-Server läuft, leiten Sie die Ports mit diesem Befehl an Ihren lokalen Rechner weiter:
kubectl port-forward nginx-6799fc88d8-4kn75 8080:80
Wenn Sie http://localhost:8080 in Ihrem Webbrowser aufrufen, sollten Sie sehen, dass Ihr Webserver online ist.
