GKE-Cluster erstellen und Arbeitslast mit Terraform bereitstellen

GKE-Cluster erstellen und Arbeitslast mit Terraform bereitstellen

Autopilot

---

In dieser Kurzanleitung erfahren Sie, wie Sie einen GKE-Autopilot-Cluster (Google Kubernetes Engine) erstellen und eine Arbeitslast mit Terraform bereitstellen.

Infrastruktur als Code (IaC) ist eine Methode zum Verwalten und Bereitstellen von Softwareinfrastrukturressourcen mithilfe von Code. Terraform ist ein beliebtes Open-Source-IaC-Tool, das eine Vielzahl von Cloud-Diensten unterstützt, einschließlich GKE. Als GKE-Plattformadministrator können Sie mit Terraform die Konfiguration Ihrer Kubernetes-Cluster standardisieren und Ihre DevOps-Workflows optimieren. Weitere Informationen finden Sie unter Terraform-Unterstützung für GKE.

Lernziele

• IPv6-VPC-Netzwerk (Virtual Private Cloud) erstellen
• Einen GKE Autopilot-Cluster erstellen
• Arbeitslast auf Ihrem Cluster bereitstellen
• Arbeitslast mit einem Dienst freigeben

Hinweise

Führen Sie folgende Schritte aus, um die Kubernetes Engine API zu aktivieren:

1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

3. Make sure that billing is enabled for your Google Cloud project.

4. Enable the GKE API.

   Enable the API

5. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

6. Make sure that billing is enabled for your Google Cloud project.

7. Enable the GKE API.

   Enable the API

8. Make sure that you have the following role or roles on the project: roles/container.admin, roles/compute.networkAdmin, roles/iam.serviceAccountUser

   Check for the roles

   1. In the Google Cloud console, go to the IAM page.

      Go to IAM
   2. Select the project.

   3. In the Principal column, find all rows that identify you or a group that you're included in. To learn which groups you're included in, contact your administrator.

   4. For all rows that specify or include you, check the Role colunn to see whether the list of roles includes the required roles.

   Grant the roles

   1. In the Google Cloud console, go to the IAM page.

      Zu IAM
   2. Wählen Sie das Projekt aus.
   3. Klicken Sie auf Zugriff erlauben.

   4. Geben Sie im Feld Neue Hauptkonten Ihre Nutzer-ID ein. Dies ist in der Regel die E-Mail-Adresse eines Google-Kontos.

   5. Wählen Sie in der Liste Rolle auswählen eine Rolle aus.
   6. Wenn Sie weitere Rollen hinzufügen möchten, klicken Sie auf Weitere Rolle hinzufügen und fügen Sie weitere Rollen hinzu.
   7. Klicken Sie auf Speichern.

   Sie sollten mit den Grundlagen von Terraform vertraut sein. Sie können die folgenden Ressourcen verwenden:

   • Erste Schritte mit Terraform (Video)
   • Terraform-Befehle

Umgebung vorbereiten

In dieser Anleitung verwenden Sie Cloud Shell zum Verwalten von Ressourcen, die in Google Cloud gehostet werden. Die Software, die Sie für diese Anleitung benötigen, ist in Cloud Shell vorinstalliert, einschließlich Terraform, kubectl und der Google Cloud CLI.

1. Starten Sie eine Cloud Shell-Sitzung über die Google Cloud Console. Klicken Sie dazu auf das Cloud Shell-Aktivierungssymbol Cloud Shell aktivieren . Dadurch wird im unteren Bereich der Google Cloud Console eine Sitzung gestartet.

   Die Dienstanmeldedaten, die dieser virtuellen Maschine zugeordnet sind, werden automatisch verwendet. Daher müssen Sie keinen Dienstkontoschlüssel einrichten oder herunterladen.

2. Bevor Sie Befehle ausführen, legen Sie Ihr Standardprojekt in der gcloud CLI mit dem folgenden Befehl fest:

   gcloud config set project PROJECT_ID
   

   Ersetzen Sie dabei PROJECT_ID durch Ihre Projekt-ID.

3. Klonen Sie das GitHub-Repository:

   git clone https://github.com/terraform-google-modules/terraform-docs-samples.git --single-branch
   

4. Wechseln Sie in das Arbeitsverzeichnis:

   cd terraform-docs-samples/gke/quickstart/autopilot
   

Terraform-Dateien prüfen

Der Google Cloud Provider ist ein Plug-in, mit dem Sie Google Cloud-Ressourcen mit Terraform, dem IaC-Tool (Infrastructure as Code) von HashiCorp, verwalten und bereitstellen können. Es dient als Brücke zwischen Terraform-Konfigurationen und den Google Cloud APIs, sodass Sie Infrastrukturressourcen wie virtuelle Maschinen und Netzwerke deklarativ definieren können.

1. Sehen Sie sich die Datei cluster.tf an:

   cat cluster.tf
   

   Die Ausgabe sieht etwa so aus:

   resource "google_compute_network" "default" {
     name = "example-network"
   
     auto_create_subnetworks  = false
     enable_ula_internal_ipv6 = true
   }
   
   resource "google_compute_subnetwork" "default" {
     name = "example-subnetwork"
   
     ip_cidr_range = "10.0.0.0/16"
     region        = "us-central1"
   
     stack_type       = "IPV4_IPV6"
     ipv6_access_type = "INTERNAL" # Change to "EXTERNAL" if creating an external loadbalancer
   
     network = google_compute_network.default.id
     secondary_ip_range {
       range_name    = "services-range"
       ip_cidr_range = "192.168.0.0/24"
     }
   
     secondary_ip_range {
       range_name    = "pod-ranges"
       ip_cidr_range = "192.168.1.0/24"
     }
   }
   
   resource "google_container_cluster" "default" {
     name = "example-autopilot-cluster"
   
     location                 = "us-central1"
     enable_autopilot         = true
     enable_l4_ilb_subsetting = true
   
     network    = google_compute_network.default.id
     subnetwork = google_compute_subnetwork.default.id
   
     ip_allocation_policy {
       stack_type                    = "IPV4_IPV6"
       services_secondary_range_name = google_compute_subnetwork.default.secondary_ip_range[0].range_name
       cluster_secondary_range_name  = google_compute_subnetwork.default.secondary_ip_range[1].range_name
     }
   
     # Set `deletion_protection` to `true` will ensure that one cannot
     # accidentally delete this instance by use of Terraform.
     deletion_protection = false
   }

   In dieser Datei werden die folgenden Ressourcen beschrieben:

   • Ein VPC-Netzwerk mit aktiviertem internem IPv6. Ändern Sie ipv6_access_type in EXTERNAL, um Ihre Anwendung im Internet freizugeben. Wenn Sie diese Änderung vornehmen, müssen Sie im nächsten Schritt auch die Annotation networking.gke.io/load-balancer-type in der Datei app.tf entfernen.
   • Ein Dual-Stack-Subnetzwerk.
   • Ein Dual-Stack-Autopilot-Cluster in us-central1.

2. Sehen Sie sich die Datei app.tf an:

   cat app.tf
   

   Die Ausgabe sieht in etwa so aus:

   data "google_client_config" "default" {}
   
   provider "kubernetes" {
     host                   = "https://${google_container_cluster.default.endpoint}"
     token                  = data.google_client_config.default.access_token
     cluster_ca_certificate = base64decode(google_container_cluster.default.master_auth[0].cluster_ca_certificate)
   
     ignore_annotations = [
       "^autopilot\\.gke\\.io\\/.*",
       "^cloud\\.google\\.com\\/.*"
     ]
   }
   
   resource "kubernetes_deployment_v1" "default" {
     metadata {
       name = "example-hello-app-deployment"
     }
   
     spec {
       selector {
         match_labels = {
           app = "hello-app"
         }
       }
   
       template {
         metadata {
           labels = {
             app = "hello-app"
           }
         }
   
         spec {
           container {
             image = "us-docker.pkg.dev/google-samples/containers/gke/hello-app:2.0"
             name  = "hello-app-container"
   
             port {
               container_port = 8080
               name           = "hello-app-svc"
             }
   
             security_context {
               allow_privilege_escalation = false
               privileged                 = false
               read_only_root_filesystem  = false
   
               capabilities {
                 add  = []
                 drop = ["NET_RAW"]
               }
             }
   
             liveness_probe {
               http_get {
                 path = "/"
                 port = "hello-app-svc"
   
                 http_header {
                   name  = "X-Custom-Header"
                   value = "Awesome"
                 }
               }
   
               initial_delay_seconds = 3
               period_seconds        = 3
             }
           }
   
           security_context {
             run_as_non_root = true
   
             seccomp_profile {
               type = "RuntimeDefault"
             }
           }
   
           # Toleration is currently required to prevent perpetual diff:
           # https://github.com/hashicorp/terraform-provider-kubernetes/pull/2380
           toleration {
             effect   = "NoSchedule"
             key      = "kubernetes.io/arch"
             operator = "Equal"
             value    = "amd64"
           }
         }
       }
     }
   }
   
   resource "kubernetes_service_v1" "default" {
     metadata {
       name = "example-hello-app-loadbalancer"
       annotations = {
         "networking.gke.io/load-balancer-type" = "Internal" # Remove to create an external loadbalancer
       }
     }
   
     spec {
       selector = {
         app = kubernetes_deployment_v1.default.spec[0].selector[0].match_labels.app
       }
   
       ip_family_policy = "RequireDualStack"
   
       port {
         port        = 80
         target_port = kubernetes_deployment_v1.default.spec[0].template[0].spec[0].container[0].port[0].name
       }
   
       type = "LoadBalancer"
     }
   
     depends_on = [time_sleep.wait_service_cleanup]
   }
   
   # Provide time for Service cleanup
   resource "time_sleep" "wait_service_cleanup" {
     depends_on = [google_container_cluster.default]
   
     destroy_duration = "180s"
   }

   In dieser Datei werden die folgenden Ressourcen beschrieben:

   • Ein Deployment mit einem Beispiel-Container-Image.
   • Ein Dienst vom Typ LoadBalancer. Der Dienst stellt das Deployment an Port 80 bereit. Konfigurieren Sie einen externen Load-Balancer, um Ihre Anwendung im Internet freizugeben. Entfernen Sie dazu die Annotation networking.gke.io/load-balancer-type.

Cluster erstellen und Anwendung bereitstellen

1. Führen Sie in Cloud Shell den folgenden Befehl aus, um zu prüfen, ob Terraform verfügbar ist:

   terraform
   

   Die Ausgabe sollte in etwa so aussehen:

   Usage: terraform [global options] <subcommand> [args]
   
   The available commands for execution are listed below.
   The primary workflow commands are given first, followed by
   less common or more advanced commands.
   
   Main commands:
     init          Prepare your working directory for other commands
     validate      Check whether the configuration is valid
     plan          Show changes required by the current configuration
     apply         Create or update infrastructure
     destroy       Destroy previously-created infrastructure
   

2. Initialisieren Sie Terraform:

   terraform init
   

3. Planen Sie die Terraform-Konfiguration:

   terraform plan
   

4. Wenden Sie die Terraform-Konfiguration an:

   terraform apply
   

   Geben Sie bei Aufforderung yes ein, um Aktionen zu bestätigen. Die Ausführung dieses Befehls kann mehrere Minuten dauern. Die Ausgabe sieht in etwa so aus:

   Apply complete! Resources: 6 added, 0 changed, 0 destroyed.
   

Cluster prüfen

So prüfen Sie, ob Ihr Cluster ordnungsgemäß ausgeführt wird:

1. Rufen Sie in der Google Cloud Console die Seite Arbeitslasten auf.

   Zu Arbeitslasten

2. Klicken Sie auf die Arbeitslast example-hello-app-deployment. Die Seite mit den Pod-Details wird angezeigt. Diese Seite enthält Informationen zum Pod, z. B. Annotationen, auf dem Pod ausgeführte Container, Dienste, die den Pod verfügbar machen, und Messwerte, darunter CPU-, Arbeitsspeicher- und Laufwerknutzung.

3. Rufen Sie in der Google Cloud Console die Seite Dienste und Ingress auf.

   Zu "Dienste & Ingress"

4. Klicken Sie auf den LoadBalancer-Dienst example-hello-app-loadbalancer. Die Seite mit den Dienstdetails wird angezeigt. Auf dieser Seite werden Informationen zum Dienst angezeigt, z. B. die mit dem Dienst verknüpften Pods und die von den Diensten verwendeten Ports.

5. Klicken Sie im Abschnitt Externe Endpunkte auf den IPv4-Link oder den IPv6-Link, um Ihren Dienst im Browser aufzurufen. Die Ausgabe sieht in etwa so aus:

   Hello, world!
   Version: 2.0.0
   Hostname: example-hello-app-deployment-5df979c4fb-kdwgr
   

Erfolg: Sie haben erfolgreich einen Cluster erstellt und mit Terraform eine Arbeitslast in GKE bereitgestellt.

Bereinigen

Mit den folgenden Schritten vermeiden Sie, dass Ihrem Google Cloud-Konto die in dieser Anleitung verwendeten Ressourcen in Rechnung gestellt werden:

Mit den folgenden Schritten vermeiden Sie, dass Ihrem Google Cloud-Konto die in dieser Anleitung verwendeten Ressourcen in Rechnung gestellt werden:

Führen Sie in Cloud Shell den folgenden Befehl aus, um die Terraform-Ressourcen zu löschen:

terraform destroy --auto-approve

Wenn Sie eine Fehlermeldung ähnlich wie The network resource 'projects/PROJECT_ID/global/networks/example-network' is already being used by 'projects/PROJECT_ID/global/firewalls/example-network-yqjlfql57iydmsuzd4ot6n5v' erhalten, gehen Sie so vor:

1. Löschen Sie die Firewallregeln:

   gcloud compute firewall-rules list --filter="NETWORK:example-network" --format="table[no-heading](name)" | xargs gcloud --quiet compute firewall-rules delete
   

2. Führen Sie den Terraform-Befehl noch einmal aus:

   terraform destroy --auto-approve
   

Nächste Schritte

• Sehen Sie sich die Ressourcen google_container_cluster und google_container_node_pool in der Dokumentation zum Google Cloud-Anbieter an. Auf diesen Seiten werden die Argumente und Attribute für die Konfiguration von GKE-Clustern und Knotenpools dokumentiert, die Google bei Terraform unterstützt.
• Im GitHub-Repository für Terraform GKE-Module finden Sie zielgerichtete Konfigurationsbeispiele.