Halaman ini diterjemahkan oleh Cloud Translation API.

Membuat cluster GKE dan men-deploy beban kerja menggunakan Terraform

Dalam panduan memulai ini, Anda akan mempelajari cara membuat cluster Autopilot Google Kubernetes Engine (GKE) dan men-deploy beban kerja menggunakan Terraform.

Infrastructure as Code (IaC) adalah praktik mengelola dan menyediakan resource infrastruktur software menggunakan kode. Terraform adalah alat IaC open source populer yang mendukung berbagai layanan Cloud, termasuk GKE. Sebagai administrator platform GKE, Anda dapat menggunakan Terraform untuk menstandarkan konfigurasi cluster Kubernetes dan menyederhanakan alur kerja DevOps Anda. Untuk mempelajari lebih lanjut, lihat Dukungan Terraform untuk GKE.

Tujuan

Membuat jaringan Virtual Private Cloud (VPC) IPv6
Membuat cluster GKE Autopilot
Men-deploy beban kerja di cluster Anda
Mengekspos beban kerja menggunakan Layanan

Sebelum memulai

Lakukan langkah-langkah berikut untuk mengaktifkan Kubernetes Engine API:

Login ke akun Google Cloud Anda. Jika Anda baru menggunakan Google Cloud, buat akun untuk mengevaluasi performa produk kami dalam skenario dunia nyata. Pelanggan baru juga mendapatkan kredit gratis senilai $300 untuk menjalankan, menguji, dan men-deploy workload.

Di konsol Google Cloud, pada halaman pemilih project, pilih atau buat project Google Cloud.

Buka pemilih project

Pastikan penagihan telah diaktifkan untuk project Google Cloud Anda.

Enable the GKE API.

Enable the API

Di konsol Google Cloud, pada halaman pemilih project, pilih atau buat project Google Cloud.

Buka pemilih project

Pastikan penagihan telah diaktifkan untuk project Google Cloud Anda.

Enable the GKE API.

Enable the API

Pastikan Anda memiliki peran berikut di project: roles/container.admin, roles/compute.networkAdmin, roles/iam.serviceAccountUser
Memeriksa peran
1. Di konsol Google Cloud, buka halaman IAM.
  Buka IAM
2. Pilih project.
3. Di kolom Akun utama, cari baris yang berisi alamat email Anda.
  
  Jika alamat email Anda tidak ada di kolom tersebut, berarti Anda tidak memiliki peran apa pun.
4. Di kolom Peran untuk baris yang berisi alamat email Anda, periksa apakah daftar peran menyertakan peran yang diperlukan.
Memberikan peran
1. Di konsol Google Cloud, buka halaman IAM.
  Buka IAM
2. Pilih project.
3. Klik Berikan akses.
4. Di kolom Akun utama baru, masukkan alamat email Anda.
5. Di daftar Pilih peran, pilih peran.
6. Untuk memberikan peran tambahan, klik Tambahkan peran lain, lalu tambahkan setiap peran tambahan.
7. Klik Simpan.

Anda harus memahami dasar-dasar Terraform. Anda dapat menggunakan referensi berikut:

Mulai Menggunakan Terraform (video)
Perintah Terraform

Menyiapkan lingkungan

Dalam tutorial ini, Anda menggunakan Cloud Shell untuk mengelola resource yang dihosting di Google Cloud. Cloud Shell telah diinstal dengan software yang Anda perlukan untuk tutorial ini, termasuk Terraform, kubectl, dan Google Cloud CLI.

Luncurkan sesi Cloud Shell dari Konsol Google Cloud dengan mengklik ikon aktivasi Cloud Shell Activate Cloud Shell . Tindakan ini akan meluncurkan sesi di panel bawah Konsol Google Cloud.

Kredensial layanan yang terkait dengan virtual machine ini bersifat otomatis, jadi Anda tidak perlu menyiapkan atau mendownload kunci akun layanan.
Sebelum menjalankan perintah, tetapkan project default Anda di gcloud CLI menggunakan perintah berikut:
```
gcloud config set project PROJECT_ID
```
Ganti PROJECT_ID dengan project ID Anda.

Buat clone repositori GitHub:

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

Ubah ke direktori kerja:

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

Meninjau file Terraform

Penyedia Google Cloud adalah plugin yang dapat Anda gunakan untuk mengelola dan menyediakan resource Google Cloud menggunakan Terraform, alat Infrastructure as Code (IaC) HashiCorp. Library ini berfungsi sebagai penghubung antara konfigurasi Terraform dan Google Cloud API, sehingga Anda dapat menentukan resource infrastruktur, seperti virtual machine dan jaringan, secara deklaratif.

Tinjau file cluster.tf:

cat cluster.tf

Outputnya mirip dengan berikut ini

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"

  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
}

File ini menjelaskan sumber daya berikut:

Jaringan VPC dengan IPv6 internal aktif.
Subnetwork stack ganda.
Cluster Autopilot dual stack yang terletak di us-central1.

Tinjau file app.tf:

cat app.tf

Outputnya mirip dengan hal berikut ini:

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 = false

          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 loadbalance
    }
  }

  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"
}

File ini menjelaskan sumber daya berikut:

Deployment dengan contoh image container.
Service jenis LoadBalancer. Layanan mengekspos Deployment pada port 80. Untuk mengekspos aplikasi Anda ke internet, konfigurasikan load balancer eksternal dengan menghapus anotasi networking.gke.io/load-balancer-type.

Membuat cluster dan men-deploy aplikasi

Di Cloud Shell, jalankan perintah ini untuk memverifikasi bahwa Terraform tersedia:

terraform

Outputnya akan mirip dengan berikut ini:

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

Lakukan inisialisasi Terraform:
```
terraform init
```
Rencanakan konfigurasi Terraform:
```
terraform plan
```
Menerapkan konfigurasi Terraform
```
terraform apply
```
Jika diminta, masukkan yes untuk mengonfirmasi tindakan. Perintah ini mungkin memakan waktu beberapa menit untuk diselesaikan. Outputnya mirip dengan hal berikut ini:
```
Apply complete! Resources: 6 added, 0 changed, 0 destroyed.
```

Memastikan cluster berfungsi

Lakukan hal berikut untuk mengonfirmasi cluster Anda berjalan dengan benar:

Buka halaman Workloads di konsol Google Cloud:

Buka Workloads
Klik beban kerja example-hello-app-deployment. Halaman detail Pod akan ditampilkan. Halaman ini menampilkan informasi tentang Pod, seperti anotasi, container yang berjalan di Pod, Layanan yang mengekspos Pod, dan metrik termasuk penggunaan CPU, Memori, dan Disk.
Buka halaman Services & Ingress di Konsol Google Cloud:

Buka Services & Ingress
Klik example-hello-app-loadbalancer LoadBalancer Service. Halaman Detail layanan akan ditampilkan. Halaman ini menampilkan informasi tentang Service, seperti Pod yang terkait dengan Service, dan Port yang digunakan Service.
Di bagian External endpoint, klik link IPv4 atau IPv6 link untuk melihat Service Anda di browser. Outputnya mirip dengan hal berikut ini:
```
Hello, world!
Version: 2.0.0
Hostname: example-hello-app-deployment-5df979c4fb-kdwgr
```

Pembersihan

Agar akun Google Cloud Anda tidak dikenakan biaya untuk resource yang digunakan pada halaman ini, ikuti langkah-langkah berikut.

Agar tidak menimbulkan biaya pada akun Google Cloud Anda untuk resource yang digunakan pada halaman ini, ikuti langkah-langkah berikut.

Di Cloud Shell, jalankan perintah berikut untuk menghapus resource Terraform:

terraform destroy --auto-approve

Jika Anda melihat pesan error yang mirip dengan The network resource 'projects/PROJECT_ID/global/networks/example-network' is already being used by 'projects/PROJECT_ID/global/firewalls/example-network-yqjlfql57iydmsuzd4ot6n5v', lakukan langkah berikut:

Hapus aturan Firewall:

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

Jalankan kembali perintah Terraform:
```
terraform destroy --auto-approve
```

Langkah selanjutnya

Pelajari referensi google_container_cluster dan google_container_node_pool dalam dokumentasi Penyedia Google Cloud. Halaman ini mendokumentasikan argumen dan atribut untuk cluster GKE dan konfigurasi node pool yang didukung Google di Terraform.
Lihat contoh konfigurasi opini di repositori GitHub modul GKE Terraform.

Membuat cluster GKE dan men-deploy beban kerja menggunakan Terraform

Tujuan

Sebelum memulai

Memeriksa peran

Memberikan peran

Menyiapkan lingkungan

Meninjau file Terraform

Membuat cluster dan men-deploy aplikasi

Memastikan cluster berfungsi

Pembersihan

Langkah selanjutnya