So verwenden Sie den Terraform Kubernetes-Anbieter

Dieser Artikel setzt die Linux-, Kubernetes- und Terraform-Themen fort und hilft Ihnen zu lernen, wie Sie Anwendungen mit Terraform im Kubernetes-Cluster bereitstellen. Wir haben zwei verschiedene Ansätze dafür behandelt – Kubernetes- und Helm-Terraform-Anbieter. Zu diesem Zweck benötigen Sie keinen Kubernetes-Cluster, da wir Minikube verwenden, das Sie auf Ihrem Laptop installieren können.

Außerdem erfahren Sie in 10 Minuten, wie Sie mithilfe von Terraform funktionale N-Tier-Anwendungen bei Kubernetes bereitstellen.

Was ist Minikube

Der beste Weg, Kubernetes und seine Konzepte kennenzulernen, ist die Verwendung von Minikube. Mit Minikube brauchen Sie sich nicht um die Verwaltung virtueller Maschinen oder die Bereitstellung eines voll funktionsfähigen Kubernetes-Clusters zu kümmern.

Dieses Open-Source-Tool unterstützt Windows, macOS und Linux, sodass Sie einen Kubernetes-Cluster mit einem Knoten auf Ihrem lokalen Computer starten können. Diese virtuelle Maschine kann auf Virtualbox, KVM, Hyper-V oder Docker ausgeführt werden.

Minikube-Installation

Die Installation von Minikube ist ein unkomplizierter Vorgang. Es gibt jedoch nur eine Abhängigkeit, die Sie im Voraus installieren müssen – ein Befehlszeilentool namens kubectl .

kubectl ermöglicht Ihnen die Verwaltung von Kubernetes-Clustern. Sie können kubectl verwenden um Anwendungen bereitzustellen, Protokolle anzuzeigen und Cluster-Ressourcen zu verwalten.

Installation von kubectl

Unten sehen Sie ein Beispiel für den Installationsprozess von kubectl für Linux und macOS:

$ curl -LO "https://storage.googleapis.com/kubernetes-release/release/$(curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt)/bin/linux/amd64/kubectl"

$ chmod +x ./kubectl

$ sudo mv ./kubectl /usr/local/bin/kubectl

Um kubectl zu installieren Unter Windows können Sie den Chocolatey-Paketmanager verwenden:

choco install kubernetes-cli

Alternativ können Sie auch kubectl installieren unter Windows, indem Sie hier klicken.

Nachdem Sie kubectl installiert haben, ist der nächste Schritt die Installation von Minikube.

Minikube installieren

Hier sind die Standardbefehle, die Sie benötigen, um Minikube unter Ubuntu, CentOS und macOS zu installieren:

$ curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64

$ sudo install minikube-linux-amd64 /usr/local/bin/minikube

Wenn Sie sich auf brew verlassen Um Ihr macOS zu verwalten, verwenden Sie besser den folgenden Befehl:

$ brew install minikube

Wenn Sie minikube installieren Unter Windows ist es besser, Chocolatey zu verwenden:

choco install minikube

Wenn minikube während der Installation nicht gestartet wurde, können Sie dies mit dem folgenden Befehl tun:

$ minikube start

Terraform-Anbieter für die Kubernetes-Bereitstellung

Derzeit sind zwei Anbieter für die Verwaltung von Kubernetes-Anwendungen mit Terraform verfügbar:

• Kubernetes.
• Helm.

Kubernetes-Terraform-Provider

Als Beispiel behandeln wir in diesem Abschnitt die WordPress-Bereitstellung mit dem Kubernetes Terraform Provider.

WordPress-Bereitstellung mit Kubernetes-Provider definieren

Hier ist die endgültige Struktur des Projekts:

Wir verwenden wordpress Docker-Image für die Frontend-Ebene und mysql Docker-Image für DB-Tier in unserer Bereitstellung.

Lassen Sie uns kubernetes definieren Anbieter in provider.tf Datei:

provider "kubernetes" {
 config_context = "minikube"
}

Als Nächstes erstellen wir ein paar lokale Variablen für die Bezeichnung kubernetes_deployment und kubernetes_service :

locals {
 wordpress_labels = {
   App = "wordpress"
   Tier = "frontend"
 }
 mysql_labels = {
   App = "wordpress"
   Tier = "mysql"
 }
}

Sie können natürlich zusätzliche Labels erstellen, wenn Sie möchten. Der Zweck von Labels in Kubernetes besteht darin, Ihnen die Möglichkeit zu geben, Pods, Dienste, Bereitstellungen und andere Kubernetes-Entitäten auszuwählen.

Es gibt viele verschiedene Möglichkeiten, Passwörter in Ihrer Terraform-Konfiguration nicht hartzucodieren. Die Verwendung von Terraform-Parametern ist eine davon. Wir fahren mit einem fest codierten Passwort fort, um die Demo etwas einfacher zu halten.

Lassen Sie uns ein Geheimnis für MYSQL_ROOT_PASSWORD deklarieren Umgebungsvariable, die wir in kubernetes_deployment verwenden werden .

resource "kubernetes_secret" "mysql-pass" {
 metadata {
   name = "mysql-pass"
 }
 data = {
   password = "root"
 }
}

Jetzt können wir kubernetes_deployment definieren Ressource für die WordPress-Bereitstellung:

resource "kubernetes_deployment" "wordpress" {
 metadata {
   name = "wordpress"
   labels = local.wordpress_labels
 }
 spec {
   replicas = 1
   selector {
     match_labels = local.wordpress_labels
   }
   template {
     metadata {
       labels = local.wordpress_labels
     }
     spec {
       container {
         image = "wordpress:4.8-apache"
         name  = "wordpress"
         port {
           container_port = 80
         }
         env {
           name = "WORDPRESS_DB_HOST"
           value = "mysql-service"
         }
         env {
           name = "WORDPRESS_DB_PASSWORD"
           value_from {
             secret_key_ref {
               name = "mysql-pass"
               key = "password"
             }
           }
         }
       }
     }
   }
 }
}

Die gesamte Terraform-Konfiguration spiegelt die Kubernetes-Bereitstellungsspezifikation wider. Wir müssen die WordPress-Bereitstellung den externen Cluster-Netzwerken mithilfe des Kubernetes-Dienstes zugänglich machen, sobald wir sie deklariert haben.

Lassen Sie uns kubernetes_service definieren Terraform-Ressource für diesen Zweck:

resource "kubernetes_service" "wordpress-service" {
 metadata {
   name = "wordpress-service"
 }
 spec {
   selector = local.wordpress_labels
   port {
     port        = 80
     target_port = 80
     node_port = 32000
   }
   type = "NodePort"
 }
}

Hier weisen wir Kubernetes an, WordPress Pod für die Kommunikation über den Service verfügbar zu machen.

Für die Minikube-Entwicklungsumgebung stellen wir WordPress auf Port 32000 bereit .

Machen wir jetzt dasselbe für die MySQL-Bereitstellung:

resource "kubernetes_deployment" "mysql" {
 metadata {
   name = "mysql"
   labels = local.mysql_labels
 }
 spec {
   replicas = 1
   selector {
     match_labels = local.mysql_labels
   }
   template {
     metadata {
       labels = local.mysql_labels
     }
     spec {
       container {
         image = "mysql:5.6"
         name  = "mysql"
         port {
           container_port = 3306
         }
         env {
           name = "MYSQL_ROOT_PASSWORD"
           value_from {
             secret_key_ref {
               name = "mysql-pass"
               key = "password"
             }
           }
         }
       }
     }
   }
 }
}

Wie im vorherigen Beispiel machen wir die MySQL-DB-Bereitstellung für die WordPress-Bereitstellung zugänglich, indem wir den Kubernetes-Dienst verwenden, der über kubernetes_service konfiguriert wird Ressource:

resource "kubernetes_service" "mysql-service" {
 metadata {
   name = "mysql-service"
 }
 spec {
   selector = local.mysql_labels
   port {
     port        = 3306
     target_port = 3306
   }
   type = "NodePort"
 }
}

WordPress Kubernetes Terraform-Konfiguration bereitstellen

Sobald wir die Terraform-Konfiguration erstellt haben, können wir unser Demo-Beispiel bereitstellen.

Initialisieren Sie das Terraform-Projekt und wenden Sie die Konfiguration an:

$ terraform init

$ terraform apply

Nach dem Anwenden der Konfigurationen sehen Sie den Plan für die Ressourcen und die Berechtigung zum Ausführen der geplanten Aktivitäten.

Genehmigen Sie den Plan, indem Sie mit yes antworten .

Nach der Bereitstellung von Ressourcen können wir Zugriff auf die Anwendung erhalten.

Bereitstellung überprüfen

Lassen Sie uns unsere Bereitstellung im Cluster mit kubectl validieren .

$ kubectl get all

Wir möchten sicherstellen, dass alle von Terraform erstellten Ressourcen verfügbar sind.

Testen der Bereitstellung

Nachdem wir die Bereitstellung von WordPress- und MySQL-Ressourcen überprüft haben, können wir den Zugriff auf die App testen.

Um Zugriff auf unsere bereitgestellte Anwendung zu erhalten, müssen wir den folgenden Minikube-Befehl ausführen:

$ minikube service wordpress-service --url

Dieser Befehl zeigt Ihnen die von Minikube verfügbar gemachte WordPress-Dienst-URL.

Herzliche Glückwünsche! Unsere WordPress-Anwendung wurde erfolgreich bereitgestellt.

Helm-Terraform-Anbieter

In diesem Teil des Artikels wird der Terraform-Helm-Anbieter verwendet, um dieselbe WordPress-Anwendung im Kubernetes-Cluster bereitzustellen, aber anders – mithilfe von Helm-Diagrammen.

Wir müssen Helm auf dem Computer für die Bereitstellung über den Helm-Anbieter installieren, auf dem das Terraform-Skript ausgeführt wird.

Um mehr über Helm und den Prozess zum Erstellen von Helm-Diagrammen zu erfahren, empfehle ich Ihnen unseren Artikel Schnelle und einfache Einführung in [Kubernetes] [Helm]-Diagramme in 10 Minuten

Erstellen von Helm-Charts

In diesem Modul erstellen wir Helm-Diagramme für MySQL- und WordPress-Bereitstellungen.

Helm kann eine Basisvorlage generieren, die wir an unsere Bedürfnisse anpassen können. Weitere Informationen zum Erstellen von Helm-Diagrammen finden Sie im Artikel Schnelle und einfache Einführung in Kubernetes-Helm-Diagramme in 10 Minuten.

Hier ist unsere endgültige Projektstruktur:

Lassen Sie uns ein Verzeichnis für die Diagramme erstellen:

$ mkdir charts

$ cd charts

MySQL-Helm-Diagramm

Zuerst erstellen wir das Steuerdiagramm für MySQL.

$ helm create mysql-chart

Der obige Befehl erstellt ein Diagramm mit Standardkonfigurationen.

Zeigen Sie den Inhalt des mysql-chart an :

Löschen Sie die NOTES.txt , hpa.yaml , ingress.yaml, und serviceaccount.yaml Dateien aus dem Vorlagenverzeichnis.

Überschreiben Sie den Inhalt von MySQL deployment.yaml Datei mit folgendem:

apiVersion: apps/v1
kind: Deployment
metadata:
 name: {{ .Values.deployment.name }}
 labels:
   {{- include "mysql-chart.labels" . | nindent 4 }}
spec:
 replicas: {{ .Values.replicaCount }}
 selector:
   matchLabels:
     {{- include "mysql-chart.selectorLabels" . | nindent 6 }}
 template:
   metadata:
     labels:
       {{- include "mysql-chart.selectorLabels" . | nindent 8 }}
   spec:
     containers:
       - name: {{ .Chart.Name }}
         image: "{{ .Values.image.repository }}"
         imagePullPolicy: {{ .Values.image.pullPolicy }}
         ports:
           - name: http
             containerPort: {{ .Values.service.port }}
             protocol: TCP
         env:
           - name: MYSQL_ROOT_PASSWORD
             value: 'admin'

Hier sind die Inhalte für service.yaml für MySQL.

apiVersion: v1
kind: Service
metadata:
 name: {{ .Values.service.name }}
 labels:
   {{- include "mysql-chart.labels" . | nindent 4 }}
spec:
 type: {{ .Values.service.type }}
 ports:
   - port: {{ .Values.service.port }}
     targetPort: {{ .Values.service.port }}
     protocol: TCP
     name: http
 selector:
   {{- include "mysql-chart.selectorLabels" . | nindent 4 }}

Ersetzen Sie den Inhalt von values.yaml für die MySQL-Konfiguration.

replicaCount: 1

image:
 repository: mysql:5.6
 pullPolicy: IfNotPresent

deployment:
 name: mysql-deployment

service:
 name: mysql-service
 type: ClusterIP
 port: 3306

WordPress-Helm-Diagramm

Erstellen Sie ein Helm-Diagramm für WordPress.

$ helm create wordpress-chart

Löschen Sie die NOTES.txt , hpa.yaml , ingress.yaml, und serviceaccount.yaml Dateien aus dem Vorlagenverzeichnis.

Der Inhalt für deployment.yaml für WordPress lauten wie folgt:

apiVersion: apps/v1
kind: Deployment
metadata:
 name: {{ .Values.deployment.name }}
 labels:
   {{- include "wordpress-chart.labels" . | nindent 4 }}
spec:
 replicas: {{ .Values.replicaCount }}
 selector:
   matchLabels:
     {{- include "wordpress-chart.selectorLabels" . | nindent 6 }}
 template:
   metadata:
     labels:
       {{- include "wordpress-chart.selectorLabels" . | nindent 8 }}
   spec:
     containers:
       - name: {{ .Chart.Name }}
         image: {{ .Values.image.repository }}
         imagePullPolicy: {{ .Values.image.pullPolicy }}
         ports:
           - name: http
             containerPort: {{ .Values.service.port }}
             protocol: TCP
         env:
           - name: WORDPRESS_DB_HOST
             value: 'mysql-service'
           - name: WORDPRESS_DB_PASSWORD
             value: 'admin'

Der Inhalt für die service.yaml des WordPress-Diagramms sind wie folgt:

apiVersion: v1
kind: Service
metadata:
 name: {{ .Values.service.name }}
 labels:
   {{- include "wordpress-chart.labels" . | nindent 4 }}
spec:
 type: {{ .Values.service.type }}
 ports:
   - port: {{ .Values.service.port }}
     targetPort: {{ .Values.service.port }}
     protocol: TCP
     name: http
     nodePort: {{ .Values.service.nodePort }}
 selector:
   {{- include "wordpress-chart.selectorLabels" . | nindent 4 }}

Der Inhalt von values.yaml für WordPress lauten wie folgt:

replicaCount: 1

image:
 repository: wordpress:4.8-apache
 pullPolicy: IfNotPresent

deployment:
 name: wordpress-deployment

service:
 name: wordpress-service
 type: NodePort
 port: 80
 nodePort: 32000

Terraform-Konfiguration

Sobald wir Helm-Diagramme haben, müssen wir eine Terraform-Konfigurationsdatei erstellen, um unsere Anwendung in Kubernetes bereitzustellen.

Kehren wir zum Basisverzeichnis zurück und definieren helm.tf Terraform-Konfigurationsdatei mit folgendem Inhalt:

provider "helm" {
 kubernetes {
   config_context = "minikube"
 }
}

resource "helm_release" "mysql" {
 name  = "mysql"
 chart = "${abspath(path.root)}/charts/mysql-chart"
}

resource "helm_release" "wordpress" {
 name  = "wordpress"
 chart = "${abspath(path.root)}/charts/wordpress-chart"
}

Terraform-Konfiguration anwenden

Der letzte Schritt besteht darin, unsere Anwendung mit bereits bekannten Befehlen im Kubernetes-Cluster bereitzustellen:

$ terraform init

$ terraform apply

Genehmigen Sie den Plan zur Bereitstellung der Konfiguration.

Anwendungsbereitstellung überprüfen

Sie können die Bereitstellung mit dem helm überprüfen Befehl.

$ helm ls

Alternativ können Sie es auch mit kubectl überprüfen Befehl.

$ kubectl get all

Um auf unsere bereitgestellte Anwendung zuzugreifen, müssen wir den folgenden Minikube-Befehl ausführen:

$ minikube service wordpress-service --url

Dieser Befehl zeigt Ihnen die von Minikube verfügbar gemachte WordPress-Dienst-URL.

Herzliche Glückwünsche! Unsere WordPress-Anwendung wurde erfolgreich mit Helm-Charts und Terraform bereitgestellt.

Aufräumen

Um die Terraform-Bereitstellung zu bereinigen, verwenden Sie den üblichen Terraform-Zerstörungsbefehl in helm-provider oder kubernetes-provider Ordner:

$ terraform destroy

Zusammenfassung

In diesem Artikel haben wir gezeigt, wie Sie Anwendungen mithilfe von Terraform im Kubernetes-Cluster bereitstellen. Wir haben zwei verschiedene Ansätze dafür behandelt – Kubernetes- und Helm-Terraform-Anbieter. Für diese Demo haben wir Minikube als lokalen Kubernetes-Cluster verwendet.

Wir hoffen, dass Sie diesen Artikel nützlich finden! Wenn ja, helfen Sie uns bitte, es in der Welt zu verbreiten! Bitte teilen Sie uns im Kommentarbereich unten mit, wenn Sie Fragen haben.