Cluster erstellen und Arbeitslast mit Terraform bereitstellen

Umgebung vorbereiten

In dieser Anleitung verwenden Sie Cloud Shell zum Verwalten von Ressourcen, die inGoogle Cloudgehostet 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 Symbol zum Aktivieren von Cloud Shell 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 -Anbieter ist ein Plug-in, mit dem Sie Google Cloud -Ressourcen mit Terraform verwalten und bereitstellen können. Es dient als Bindeglied zwischen Terraform-Konfigurationen und Google Cloud APIs, sodass Sie Infrastrukturressourcen wie virtuelle Maschinen und Netzwerke deklarativ definieren können.

Der Cluster und die Beispielanwendung für dieses Tutorial werden in zwei Terraform-Dateien angegeben, die den Google Cloud - und Kubernetes-Anbieter verwenden.

1. Prüfen Sie die Datei cluster.tf.

   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:

   • google_compute_network: ein VPC-Netzwerk mit aktivierter interner IPv6-Adresse.
   • google_compute_subnetwork: Ein Dual-Stack-Subnetzwerk.
   • google_container_cluster: Ein Dual-Stack-Cluster im Autopilot-Modus in us-central1. Mit der Einstellung deletion_protection wird festgelegt, ob Sie diesen Cluster mit Terraform löschen können. Wenn Sie den Wert im Feld deletion_protection auf false festlegen, kann Terraform den Cluster löschen. Weitere Informationen finden Sie in der google_container_cluster-Referenz.

2. Prüfen Sie die Datei app.tf.

   cat app.tf
   

   Die Ausgabe sieht 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 Bereitstellung mit einem Beispiel-Container-Image.
   • Einen Dienst vom Typ „LoadBalancer“ Der Dienst gibt das Deployment über Port 80 frei.

(Optional) Anwendung im Internet freigeben

Die Terraform-Dateien für das Beispiel beschreiben eine Anwendung mit einer internen IP-Adresse, die nur über dieselbe Virtual Private Cloud (VPC) wie die Beispielanwendung abgerufen werden kann. Wenn Sie über das Internet (z. B. von Ihrem Laptop) auf die Weboberfläche der laufenden Demoanwendung zugreifen möchten, ändern Sie die Terraform-Dateien, um vor dem Erstellen des Clusters eine öffentliche IP-Adresse zu erstellen. Dazu können Sie einen Texteditor direkt in Cloud Shell oder den Cloud Shell-Editor verwenden.

So geben Sie die Demoanwendung für das Internet frei:

1. Ändern Sie in cluster.tf den Wert für ipv6_access_type von INTERNAL in EXTERNAL.

   ipv6_access_type = "EXTERNAL"
   

2. Konfigurieren Sie in app.tf einen externen Load Balancer, indem Sie die Annotation networking.gke.io/load-balancer-type entfernen.

    annotations = {
      "networking.gke.io/load-balancer-type" = "Internal" # Remove this line
    }
   

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 yes ein, wenn Sie aufgefordert werden, die 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 der 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 Servicedetails 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