Cluster erstellen und Arbeitslast mit Terraform bereitstellen


Ein Kubernetes-Cluster, der Computing-, Speicher-, Netzwerk- und andere Dienste für Anwendungen bereitstellt, vergleichbar einem virtuellen Rechenzentrum. Anwendungen und zugehörige Dienste, die in Kubernetes ausgeführt werden, werden Arbeitslasten genannt.

In diesem Tutorial erhalten Sie einen schnellen Einblick in einen laufenden Google Kubernetes Engine-Cluster und eine Beispielarbeitslast, die beide mit Terraform eingerichtet wurden. Sie können sich die Arbeitslast dann in der Google Cloud -Konsole ansehen, bevor Sie mit unserem ausführlicheren Lernpfad fortfahren oder einen eigenen produktionsreifen Cluster planen und erstellen. In diesem Tutorial wird davon ausgegangen, dass Sie mit Terraform vertraut sind.

Wenn Sie Ihren Beispielcluster und Ihre Arbeitslast lieber in der Google Cloud Console einrichten möchten, lesen Sie Cluster in der Google Cloud Console erstellen.

Vorbereitung

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. Install the Google Cloud CLI.

  3. If you're using an external identity provider (IdP), you must first sign in to the gcloud CLI with your federated identity.

  4. To initialize the gcloud CLI, run the following command:

    gcloud init
  5. Create or select a Google Cloud project.

    • Create a Google Cloud project:

      gcloud projects create PROJECT_ID

      Replace PROJECT_ID with a name for the Google Cloud project you are creating.

    • Select the Google Cloud project that you created:

      gcloud config set project PROJECT_ID

      Replace PROJECT_ID with your Google Cloud project name.

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

  7. Enable the GKE API:

    gcloud services enable container.googleapis.com
  8. Install the Google Cloud CLI.

  9. If you're using an external identity provider (IdP), you must first sign in to the gcloud CLI with your federated identity.

  10. To initialize the gcloud CLI, run the following command:

    gcloud init
  11. Create or select a Google Cloud project.

    • Create a Google Cloud project:

      gcloud projects create PROJECT_ID

      Replace PROJECT_ID with a name for the Google Cloud project you are creating.

    • Select the Google Cloud project that you created:

      gcloud config set project PROJECT_ID

      Replace PROJECT_ID with your Google Cloud project name.

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

  13. Enable the GKE API:

    gcloud services enable container.googleapis.com
  14. Grant roles to your user account. Run the following command once for each of the following IAM roles: roles/container.admin, roles/compute.networkAdmin, roles/iam.serviceAccountUser

    gcloud projects add-iam-policy-binding PROJECT_ID --member="user:USER_IDENTIFIER" --role=ROLE
    • Replace PROJECT_ID with your project ID.
    • Replace USER_IDENTIFIER with the identifier for your user account. For example, user:myemail@example.com.

    • Replace ROLE with each individual role.

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 Schaltfläche zum Aktivieren von Cloud Shell. 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.
    • google_compute_subnetwork: ein Dual-Stack-Subnetzwerk.
    • google_container_cluster: ein Autopilot-Cluster im Dual-Stack-Modus in us-central1. Mit der Einstellung deletion_protection wird gesteuert, 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:

(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 im 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 bei Aufforderung zur Bestätigung von Aktionen yes ein. 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

Gehen Sie so vor, um zu prüfen, 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 „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 „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
    

Bereinigen

Löschen Sie das Google Cloud -Projekt mit den Ressourcen, damit Ihrem Google Cloud -Konto die auf dieser Seite verwendeten Ressourcen nicht in Rechnung gestellt werden.

Wenn Sie weitere Tutorials durchgehen oder Ihr Beispiel weiter untersuchen möchten, warten Sie mit diesem Bereinigungsschritt, bis Sie fertig sind.

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

    terraform destroy --auto-approve
    

Fehler bei der Bereinigung beheben

Wenn Sie eine Fehlermeldung 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