יצירת אשכול ופריסת עומס עבודה באמצעות Terraform

הכנת הסביבה

במדריך הזה תשתמשו ב-Cloud Shell כדי לנהל משאבים שמתארחים ב-Cloud de Confiance by S3NS. ב-Cloud Shell מותקן מראש התוכנה שדרושה למדריך הזה, כולל Terraform,‏ kubectl ו-Google Cloud CLI.

1. מפעילים סשן Cloud Shell מהמסוף על ידי לחיצה על סמל ההפעלה של Cloud Shell‏ Activate Cloud Shell‏ . Cloud de Confiance הפעולה הזו תפעיל סשן בחלונית התחתונה של Cloud de Confiance המסוף.

   פרטי הכניסה לשירות שמשויכים למכונה הווירטואלית נוצרים אוטומטית, כך שלא צריך ליצור או להוריד מפתח לחשבון שירות.

2. לפני שמריצים פקודות, מגדירים את פרויקט ברירת המחדל ב-CLI של gcloud באמצעות הפקודה הבאה:

   gcloud config set project PROJECT_ID
   

   מחליפים את PROJECT_ID במזהה הפרויקט.

3. משכפלים את המאגר ב-GitHub:

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

4. עוברים לספריית העבודה:

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

סקירת קובצי Terraform

‫Cloud de Confiance by S3NS פלאגין שמתממשק עם שירותים חיצוניים הוא פלאגין שמאפשר לכם לנהל ולהקצות Cloud de Confiance משאבים באמצעות Terraform. הוא משמש כגשר בין ההגדרות של Terraform לבין ממשקי API של Cloud de Confiance , ומאפשר להגדיר באופן הצהרתי משאבי תשתית, כמו מכונות וירטואליות ורשתות.

האשכול ואפליקציית הדוגמה במדריך הזה מוגדרים בשני קובצי Terraform שמשתמשים בספקי Cloud de Confiance by S3NS ובספקי Kubernetes.

1. בודקים את הקובץ cluster.tf:

   cat cluster.tf
   

   הפלט אמור להיראות כך:

   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
   }

   בקובץ הזה מתוארים המשאבים הבאים:

   • ‫google_compute_network: רשת VPC עם IPv6 פנימי מופעל.
   • ‫google_compute_subnetwork: רשת משנה עם תמיכה ב-dual-stack.
   • ‫google_container_cluster: a dual-stack Autopilot mode cluster located in us-central1. ההגדרה deletion_protection קובעת אם אפשר להשתמש ב-Terraform כדי למחוק את האשכול הזה. אם מגדירים את הערך בשדה deletion_protection ל-false, ‏ Terraform יכול למחוק את האשכול. לפרטים נוספים, אפשר לעיין במקור המידע google_container_cluster.

2. בודקים את הקובץ app.tf:

   cat app.tf
   

   הפלט אמור להיראות כך:

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

   בקובץ הזה מתוארים המשאבים הבאים:

   • פריסה עם תמונה לדוגמה של קונטיינר.
   • שירות מסוג LoadBalancer. השירות חושף את הפריסה ביציאה 80.

(אופציונלי) חשיפת האפליקציה לאינטרנט

קובצי ה-Terraform לדוגמה מתארים אפליקציה עם כתובת IP פנימית, שאפשר לגשת אליה רק מאותו ענן וירטואלי פרטי (VPC) כמו אפליקציית הדוגמה. אם רוצים לגשת לממשק האינטרנט של אפליקציית ההדגמה הפועלת מהאינטרנט (לדוגמה, מהמחשב הנייד), צריך לשנות את קובצי ה-Terraform כדי ליצור כתובת IP ציבורית לפני שיוצרים את האשכול. אפשר לעשות את זה באמצעות עורך טקסט ישירות ב-Cloud Shell או באמצעות Cloud Shell Editor.

כדי לחשוף את אפליקציית ההדגמה לאינטרנט:

1. ב-cluster.tf, משנים את ipv6_access_type מ-INTERNAL ל-EXTERNAL.

   ipv6_access_type = "EXTERNAL"
   

2. ב-app.tf, מסירים את ההערה networking.gke.io/load-balancer-type כדי להגדיר מאזן עומסים חיצוני.

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

יצירת אשכול ופריסת אפליקציה

1. ב-Cloud Shell, מריצים את הפקודה הבאה כדי לוודא ש-Terraform זמין:

   terraform
   

   הפלט אמור להיראות כך:

   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. מאתחלים את Terraform:

   terraform init
   

3. מתכננים את ההגדרות של Terraform:

   terraform plan
   

4. החלת ההגדרות של Terraform

   terraform apply
   

   כשמופיעה בקשה, מזינים yes כדי לאשר את הפעולות. יכול להיות שיחלפו כמה דקות עד שהפקודה הזו תושלם. הפלט אמור להיראות כך:

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

אימות הפעולה התקינה של האשכול

כדי לוודא שהאשכול פועל בצורה תקינה:

1. נכנסים לדף Workloads במסוף Cloud de Confiance :

   כניסה לדף Workloads

2. לוחצים על עומס העבודה example-hello-app-deployment. יוצג הדף 'פרטי ה-Pod'. בדף הזה מוצג מידע על ה-Pod, כמו הערות, קונטיינרים שפועלים ב-Pod, שירותים שחושפים את ה-Pod ומדדים, כולל שימוש ב-CPU, בזיכרון ובדיסק.

3. נכנסים לדף Services & Ingress במסוף Cloud de Confiance :

   כניסה אל Services & Ingress

4. לוחצים על example-hello-app-loadbalancer LoadBalancer Service. יוצג דף הפרטים של השירות. בדף הזה מוצג מידע על השירות, כמו ה-Pods שמשויכים לשירות והיציאות שבהן השירות משתמש.

5. בקטע External endpoints (נקודות קצה חיצוניות), לוחצים על IPv4 link (קישור IPv4) או על IPv6 link (קישור IPv6) כדי להציג את השירות בדפדפן. הפלט אמור להיראות כך:

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