Membuat cluster multi-tenant menggunakan Terraform

Cluster multi-tenant di edisi Enterprise Google Kubernetes Engine (GKE) adalah cluster Kubernetes yang digunakan bersama oleh beberapa tim atau pengguna yang berbeda, yang dikenal sebagai tenant. Setiap tenant biasanya memiliki kumpulan resource dan aplikasinya sendiri dalam cluster.

Tutorial Terraform ini memungkinkan Anda membuat cluster GKE Enterprise dengan cepat yang digunakan bersama oleh dua tim, backend dan frontend, yang dapat men-deploy workload khusus tim di cluster. Tutorial ini mengasumsikan bahwa Anda sudah memahami Terraform. Jika belum, Anda dapat menggunakan referensi berikut untuk mempelajari dasar-dasar Terraform:

Sebelum memulai

Lakukan langkah-langkah berikut untuk mengaktifkan Kubernetes Engine API:

  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. Di konsol Google Cloud, pada halaman pemilih project, pilih atau buat project Google Cloud.

    Buka pemilih project

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

  4. Aktifkan API GKE, GKE Hub, Cloud SQL, Resource Manager, IAM, Connect gateway.

    Mengaktifkan API

    5.

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

    Buka pemilih project

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

  7. Aktifkan API GKE, GKE Hub, Cloud SQL, Resource Manager, IAM, Connect gateway.

    Mengaktifkan API

    8.

  8. Make sure that you have the following role or roles on the project: roles/owner, roles/iam.serviceAccountTokenCreator

    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.

      Buka IAM
    2. Pilih project.
    3. Klik Berikan akses.

    4. Di kolom New principals, masukkan ID pengguna Anda. Ini biasanya adalah alamat email untuk Akun Google.

    5. Di daftar Pilih peran, pilih peran.
    6. Untuk memberikan peran tambahan, klik Tambahkan peran lain, lalu tambahkan setiap peran tambahan.
    7. Klik Simpan.

Menyiapkan lingkungan

Dalam tutorial ini, Anda akan 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.

  1. Luncurkan sesi Cloud Shell dari konsol Google Cloud, dengan mengklik ikon aktivasi Cloud Shell Activate Cloud Shell Tombol Activate Shell. Tindakan ini akan meluncurkan sesi di panel bawah konsol Google Cloud.

    Kredensial layanan yang terkait dengan virtual machine 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/multitenant

Meninjau file Terraform

Penyedia Google Cloud adalah plugin yang memungkinkan Anda mengelola dan menyediakan resource Google Cloud menggunakan Terraform. Terraform berfungsi sebagai jembatan antara konfigurasi Terraform dan Google Cloud API, sehingga Anda dapat menentukan resource infrastruktur secara deklaratif, seperti virtual machine dan jaringan.

  1. Tinjau file main.tf, yang menjelaskan resource cluster GKE Enterprise:

    cat main.tf

    Outputnya mirip dengan hal berikut ini:

    resource "google_container_cluster" "default" {
  name               = "gke-enterprise-cluster"
  location           = "us-central1"
  initial_node_count = 3
  fleet {
    project = data.google_project.default.project_id
  }
  workload_identity_config {
    workload_pool = "${data.google_project.default.project_id}.svc.id.goog"
  }
  security_posture_config {
    mode               = "BASIC"
    vulnerability_mode = "VULNERABILITY_ENTERPRISE"
  }
  depends_on = [
    google_gke_hub_feature.policycontroller,
    google_gke_hub_namespace.default
  ]
  # Set `deletion_protection` to `true` will ensure that one cannot
  # accidentally delete this instance by use of Terraform.
  deletion_protection = false
}

resource "google_gke_hub_membership_binding" "default" {
  for_each = google_gke_hub_scope.default

  project               = data.google_project.default.project_id
  membership_binding_id = each.value.scope_id
  scope                 = each.value.name
  membership_id         = google_container_cluster.default.fleet[0].membership_id
  location              = google_container_cluster.default.fleet[0].membership_location
}

Membuat cluster dan database SQL

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

  2. Lakukan inisialisasi Terraform:

    terraform init

  3. Opsional: Rencanakan konfigurasi Terraform:

    terraform plan

  4. Menerapkan konfigurasi Terraform

    terraform apply

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

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

Men-deploy aplikasi tim backend

  1. Tinjau file Terraform berikut:

    cat backend.yaml

    Outputnya akan mirip dengan berikut ini:

    apiVersion: v1
kind: ConfigMap
metadata:
  name: backend-configmap
  namespace: backend-team
  labels:
    app: backend
data:
  go.mod: |
    module multitenant

    go 1.22

    require github.com/go-sql-driver/mysql v1.8.1

    require filippo.io/edwards25519 v1.1.0 // indirect

  go.sum: |
    filippo.io/edwards25519 v1.1.0 h1:FNf4tywRC1HmFuKW5xopWpigGjJKiJSV0Cqo0cJWDaA=
    filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4=
    github.com/go-sql-driver/mysql v1.8.1 h1:LedoTUt/eveggdHS9qUFC1EFSa8bU2+1pZjSRpvNJ1Y=
    github.com/go-sql-driver/mysql v1.8.1/go.mod h1:wEBSXgmK//2ZFJyE+qWnIsVGmvmEKlqwuVSjsCm7DZg=

  backend.go: |
    package main

    import (
      "database/sql"
      "fmt"
      "log"
      "math/rand"
      "net/http"
      "os"

      _ "github.com/go-sql-driver/mysql"
    )

    func main() {
      mux := http.NewServeMux()
      mux.HandleFunc("/", frontend)

      port := "8080"

      log.Printf("Server listening on port %s", port)
      log.Fatal(http.ListenAndServe(":"+port, mux))
    }

    func frontend(w http.ResponseWriter, r *http.Request) {
      log.Printf("Serving request: %s", r.URL.Path)

      host, _ := os.Hostname()
      fmt.Fprintf(w, "Backend!\n")
      fmt.Fprintf(w, "Hostname: %s\n", host)

      // Open database using cloud-sql-proxy sidecar
      db, err := sql.Open("mysql", "multitenant-app@tcp/multitenant-app")
      if err != nil {
        fmt.Fprintf(w, "Error: %v\n", err)
        return
      }

      // Create metadata Table if not exists
      _, err = db.Exec("CREATE TABLE IF NOT EXISTS metadata (metadata_key varchar(255) NOT NULL, metadata_value varchar(255) NOT NULL, PRIMARY KEY (metadata_key))")
      if err != nil {
        fmt.Fprintf(w, "Error: %v\n", err)
        return
      }

      // Pick random primary color
      var color string
      randInt := rand.Intn(3) + 1
      switch {
      case randInt == 1:
        color = "red"
      case randInt == 2:
        color = "green"
      case randInt == 3:
        color = "blue"
      }

      // Set color in database
      _, err = db.Exec(fmt.Sprintf("REPLACE INTO metadata (metadata_key, metadata_value) VALUES ('color', '%s')", color))
      if err != nil {
        fmt.Fprintf(w, "Error: %v\n", err)
        return
      }

      fmt.Fprintf(w, "Set Color: %s\n", color)
    }

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: backendweb
  namespace: backend-team
  labels:
    app: backend
spec:
  selector:
    matchLabels:
      app: backend
      tier: web
  template:
    metadata:
      labels:
        app: backend
        tier: web
    spec:
      containers:
      - name: backend-container
        image: golang:1.22
        command: ["go"]
        args: ["run", "."]
        workingDir: "/tmp/backend"
        volumeMounts:
          - name: backend-configmap
            mountPath: /tmp/backend/
            readOnly: true
      - name: cloud-sql-proxy
        image: gcr.io/cloud-sql-connectors/cloud-sql-proxy:2.11.4
        args:
          - "--structured-logs"
          - "--port=3306"
          - "$(CONNECTION_NAME_KEY)"
        securityContext:
          runAsNonRoot: true
        env:
        - name: CONNECTION_NAME_KEY
          valueFrom:
            configMapKeyRef:
              name: database-configmap
              key: CONNECTION_NAME
      volumes:
        - name: backend-configmap
          configMap: { name: backend-configmap }
---
apiVersion: v1
kind: Service
metadata:
  name: backendweb
  namespace: backend-team
  labels:
    app: backend
  annotations:
    networking.gke.io/load-balancer-type: "Internal" # Remove to create an external loadbalancer
spec:
  selector:
    app: backend
    tier: web
  ports:
  - port: 80
    targetPort: 8080
  type: LoadBalancer

    File ini menjelaskan resource berikut:

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

  2. Di Cloud Shell, jalankan perintah berikut untuk meniru akun layanan tim backend:

    gcloud config set auth/impersonate_service_account backend@PROJECT_ID.

    Ganti PROJECT_ID dengan project ID Anda.

  3. Ambil kredensial cluster:

    gcloud container fleet memberships get-credentials gke-enterprise-cluster --location us-central1

  4. Terapkan manifes tim backend ke cluster:

    kubectl apply -f backend.yaml

Memverifikasi bahwa aplikasi backend berfungsi

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

  1. Buka halaman Workloads di konsol Google Cloud:

    Buka Workloads

  2. Klik workload backend. Halaman detail Pod akan ditampilkan. Halaman ini menampilkan informasi tentang Pod, seperti anotasi, penampung yang berjalan di Pod, Layanan yang mengekspos Pod, dan metrik termasuk penggunaan CPU, Memori, dan Disk.

  3. Klik Layanan LoadBalancer backend. Halaman Detail layanan akan ditampilkan. Halaman ini menampilkan informasi tentang Layanan, seperti Pod yang terkait dengan Layanan, dan port yang digunakan Layanan.

  4. Di bagian Endpoints, klik link IPv4 untuk melihat Layanan Anda di browser. Outputnya mirip dengan hal berikut ini:

    Backend!
Hostname: backendweb-765f6c4fc9-cl7jx
Set Color: green

    Setiap kali pengguna mengakses endpoint backend, Layanan akan memilih dan menyimpan warna secara acak dari merah, hijau, atau biru di database bersama.

Men-deploy aplikasi tim frontend

  1. Tinjau file Terraform berikut:

    cat frontend.yaml

    Outputnya akan mirip dengan berikut ini:

    apiVersion: v1
kind: ConfigMap
metadata:
  name: frontend-configmap
  namespace: frontend-team
  labels:
    app: frontend
data:
  go.mod: |
    module multitenant

    go 1.22

    require github.com/go-sql-driver/mysql v1.8.1

    require filippo.io/edwards25519 v1.1.0 // indirect

  go.sum: |
    filippo.io/edwards25519 v1.1.0 h1:FNf4tywRC1HmFuKW5xopWpigGjJKiJSV0Cqo0cJWDaA=
    filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4=
    github.com/go-sql-driver/mysql v1.8.1 h1:LedoTUt/eveggdHS9qUFC1EFSa8bU2+1pZjSRpvNJ1Y=
    github.com/go-sql-driver/mysql v1.8.1/go.mod h1:wEBSXgmK//2ZFJyE+qWnIsVGmvmEKlqwuVSjsCm7DZg=

  frontend.go: |
    package main

    import (
      "database/sql"
      "fmt"
      "log"
      "net/http"
      "os"

      _ "github.com/go-sql-driver/mysql"
    )

    func main() {
      mux := http.NewServeMux()
      mux.HandleFunc("/", frontend)

      port := "8080"

      log.Printf("Server listening on port %s", port)
      log.Fatal(http.ListenAndServe(":"+port, mux))
    }

    func frontend(w http.ResponseWriter, r *http.Request) {
      log.Printf("Serving request: %s", r.URL.Path)

      host, _ := os.Hostname()
      fmt.Fprintf(w, "Frontend!\n")
      fmt.Fprintf(w, "Hostname: %s\n", host)

      // Open database using cloud-sql-proxy sidecar
      db, err := sql.Open("mysql", "multitenant-app@tcp/multitenant-app")
      if err != nil {
        fmt.Fprint(w, "Error: %v\n", err)
        return
      }

      // Retrieve color from the database
      var color string
      err = db.QueryRow("SELECT metadata_value FROM metadata WHERE metadata_key='color'").Scan(&color)
      switch {
      case err == sql.ErrNoRows:
        fmt.Fprintf(w, "Error: color not found in database\n")
      case err != nil:
        fmt.Fprintf(w, "Error: %v\n", err)
      default:
        fmt.Fprintf(w, "Got Color: %s\n", color)
      }
    }

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: frontendweb
  namespace: frontend-team
  labels:
    app: frontend
spec:
  selector:
    matchLabels:
      app: frontend
      tier: web
  template:
    metadata:
      labels:
        app: frontend
        tier: web
    spec:
      containers:
      - name: frontend-container
        image: golang:1.22
        command: ["go"]
        args: ["run", "."]
        workingDir: "/tmp/frontend"
        volumeMounts:
          - name: frontend-configmap
            mountPath: /tmp/frontend/
            readOnly: true
      - name: cloud-sql-proxy
        image: gcr.io/cloud-sql-connectors/cloud-sql-proxy:2.11.4
        args:
          - "--structured-logs"
          - "--port=3306"
          - "$(CONNECTION_NAME_KEY)"
        securityContext:
          runAsNonRoot: true
        env:
        - name: CONNECTION_NAME_KEY
          valueFrom:
            configMapKeyRef:
              name: database-configmap
              key: CONNECTION_NAME
      volumes:
        - name: frontend-configmap
          configMap: { name: frontend-configmap }
---
apiVersion: v1
kind: Service
metadata:
  name: frontendweb
  namespace: frontend-team
  labels:
    app: frontend
  annotations:
    networking.gke.io/load-balancer-type: "Internal" # Remove to create an external loadbalancer
spec:
  selector:
    app: frontend
    tier: web
  ports:
  - port: 80
    targetPort: 8080
  type: LoadBalancer

    File ini menjelaskan resource berikut:

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

  2. Di Cloud Shell, jalankan perintah berikut untuk meniru akun layanan tim frontend:

    gcloud config set auth/impersonate_service_account frontend@PROJECT_ID.

    Ganti PROJECT_ID dengan project ID Anda.

  3. Ambil kredensial cluster:

    gcloud container fleet memberships get-credentials gke-enterprise-cluster --location us-central1

  4. Terapkan manifes tim frontend ke cluster:

    kubectl apply -f frontend.yaml

Memverifikasi bahwa aplikasi frontend berfungsi

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

  1. Buka halaman Workloads di konsol Google Cloud:

    Buka Workloads

  2. Klik workload frontend. Halaman detail Pod akan ditampilkan. Halaman ini menampilkan informasi tentang Pod, seperti anotasi, penampung yang berjalan di Pod, Layanan yang mengekspos Pod, dan metrik termasuk penggunaan CPU, Memori, dan Disk.

  3. Klik Layanan LoadBalancer frontend. Halaman Detail layanan akan ditampilkan. Halaman ini menampilkan informasi tentang Layanan, seperti Pod yang terkait dengan Layanan, dan port yang digunakan Layanan.

  4. Di bagian Endpoints, klik link IPv4 untuk melihat Layanan Anda di browser. Outputnya mirip dengan hal berikut ini:

    Frontend!
Hostname: frontendweb-5cd888d88f-gwwtc
Got Color: green

Pembersihan

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

  1. Di Cloud Shell, jalankan perintah ini untuk menghapus peniruan identitas akun layanan:

    gcloud config unset auth/impersonate_service_account

  2. Jalankan perintah berikut untuk menghapus resource Terraform:

    terraform destroy --auto-approve

Langkah selanjutnya