Membuat cluster dan men-deploy workload menggunakan Terraform

Menyiapkan lingkungan

Dalam tutorial ini, Anda akan menggunakan Cloud Shell untuk mengelola resource yang dihosting di Cloud de Confiance by S3NS. Cloud Shell diprainstal dengan software yang Anda perlukan untuk tutorial ini, termasuk Terraform, kubectl, dan Google Cloud CLI.

1. Luncurkan sesi Cloud Shell dari Cloud de Confiance konsol, dengan mengklik ikon aktivasi Cloud Shell Aktifkan Cloud Shell . Tindakan ini akan meluncurkan sesi di panel bawah Cloud de Confiance konsol.

   Kredensial layanan yang terkait dengan mesin virtual ini bersifat otomatis, sehingga Anda tidak perlu menyiapkan atau mendownload kunci akun layanan.

2. 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.

3. Buat clone repositori GitHub:

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

4. Ubah ke direktori kerja:

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

Meninjau file Terraform

Provider adalah plugin yang memungkinkan Anda mengelola dan menyediakan Cloud de Confiance resource menggunakan Terraform.Cloud de Confiance by S3NS Plugin ini berfungsi sebagai jembatan antara konfigurasi Terraform dan Cloud de Confiance API, sehingga Anda dapat menentukan resource infrastruktur secara deklaratif, seperti mesin virtual dan jaringan.

Cluster dan aplikasi contoh untuk tutorial ini ditentukan dalam dua file Terraform yang menggunakan Cloud de Confiance by S3NS provider dan Kubernetes.

1. Tinjau file cluster.tf:

   cat cluster.tf
   

   Outputnya mirip dengan hal berikut

   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
   }

   File ini menjelaskan resource berikut:

   • google_compute_network: jaringan VPC dengan IPv6 internal diaktifkan.
   • google_compute_subnetwork: subnetwork dual-stack.
   • google_container_cluster: cluster mode Autopilot dual-stack yang berlokasi di us-central1. Setelan deletion_protection mengontrol apakah Anda dapat menggunakan Terraform untuk menghapus cluster ini. Jika Anda menetapkan nilai di kolom deletion_protection ke false, Terraform dapat menghapus cluster. Untuk mengetahui detailnya, lihat referensi google_container_cluster.

2. Tinjau file app.tf:

   cat app.tf
   

   Outputnya mirip dengan hal berikut:

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

   File ini menjelaskan resource berikut:

   • Deployment dengan image container contoh.
   • Service jenis LoadBalancer . Service mengekspos Deployment di port 80.

(Opsional) Mengekspos aplikasi ke internet

File Terraform untuk contoh ini menjelaskan aplikasi dengan alamat IP internal, yang hanya dapat diakses dari Virtual Private Cloud (VPC) yang sama dengan aplikasi contoh. Jika ingin mengakses antarmuka web aplikasi demo yang berjalan dari internet (misalnya, dari laptop Anda), ubah file Terraform untuk membuat alamat IP publik terlebih dahulu sebelum membuat cluster. Anda dapat melakukannya menggunakan editor teks langsung di Cloud Shell atau menggunakan Cloud Shell Editor.

Untuk mengekspos aplikasi demo ke internet:

1. Di cluster.tf, ubah ipv6_access_type dari INTERNAL menjadi EXTERNAL.

   ipv6_access_type = "EXTERNAL"
   

2. Di app.tf, konfigurasi load balancer eksternal dengan menghapus networking.gke.io/load-balancer-type anotasi.

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

Membuat cluster dan men-deploy aplikasi

1. Di Cloud Shell, jalankan perintah ini untuk memverifikasi bahwa Terraform sudah 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
   

2. Lakukan inisialisasi Terraform:

   terraform init
   

3. Rencanakan konfigurasi Terraform:

   terraform plan
   

4. Terapkan konfigurasi Terraform

   terraform apply
   

   Saat diminta, masukkan yes untuk mengonfirmasi tindakan. Perintah ini mungkin memerlukan waktu beberapa menit untuk diselesaikan. Outputnya mirip dengan hal berikut ini:

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

Memverifikasi bahwa cluster berfungsi

Lakukan hal berikut untuk mengonfirmasi bahwa cluster Anda berjalan dengan benar:

1. Buka halaman Workloads di Cloud de Confiance konsol:

   Buka Workloads

2. Klik workload 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.

3. Buka halaman Services & Ingress di Cloud de Confiance konsol:

   Buka Services &Ingress

4. Klik Layanan LoadBalancer example-hello-app-loadbalancer. Halaman detail Layanan akan ditampilkan. Halaman ini menampilkan informasi tentang Layanan, seperti Pod yang terkait dengan Layanan, dan Port yang digunakan Layanan.

5. Di bagian External endpoints, klik IPv4 link atau IPv6 link untuk melihat Layanan Anda di browser. Outputnya mirip dengan hal berikut:

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