हैड्स-ऑन लैब — PCA Google Cloud Professional Cloud Architect

अवलोकन

पूर्व-आवश्यकताएं

चरण

1. 1.प्रदाता, प्रोजेक्ट सेवाएँ, नामकरण

   कंप्यूट, GKE, क्लाउड SQL, सर्विस नेटवर्किंग (क्लाउड SQL निजी आईपी के लिए), और क्लाउड स्टोरेज एपीआई सक्षम करें।

   कॉपी

   terraform {
     required_version = ">= 1.5"
   
     required_providers {
       google = { source = "hashicorp/google", version = "~> 6.0" }
     }
   }
   
   provider "google" {
     project = "your-project-id" # REPLACE
     region  = "us-central1"
   }
   
   locals {
     labels = {
       project    = "certlabpro-pca"
       managed_by = "terraform"
     }
   }
   
   resource "google_project_service" "compute" {
     service            = "compute.googleapis.com"
     disable_on_destroy = false
   }
   
   resource "google_project_service" "container" {
     service            = "container.googleapis.com"
     disable_on_destroy = false
   }
   
   resource "google_project_service" "sqladmin" {
     service            = "sqladmin.googleapis.com"
     disable_on_destroy = false
   }
   
   resource "google_project_service" "servicenetworking" {
     service            = "servicenetworking.googleapis.com"
     disable_on_destroy = false
   }
   
   resource "google_project_service" "storage" {
     service            = "storage.googleapis.com"
     disable_on_destroy = false
   }

2. 2.आउटबाउंड-ओनली एग्रेस के लिए VPC + Cloud NAT बनाएँ

   प्रोविज़न:

   • VPC
   • Cloud NAT

   पीसीए-अनुशंसित पैटर्न: निजी VMs / पॉड्स में कोई बाहरी IP नहीं होता, लेकिन फिर भी उन्हें बाहरी निर्भरताओं (pip / docker / API कॉल) तक पहुंचने की आवश्यकता होती है। इसका उत्तर Cloud NAT है — एक प्रबंधित क्षेत्रीय NAT सेवा जो निजी संसाधनों को केवल आउटबाउंड एग्रेस देती है।

   हम GKE (पॉड्स + सेवाएँ) के लिए दो सेकेंडरी रेंज के साथ एक /20 सबनेट बनाते हैं, एक Cloud Router प्रोविज़न करते हैं, और उस पर एक Cloud NAT संलग्न करते हैं।

   कॉपी

   resource "google_compute_network" "main" {
     name                    = "certlabpro-pca-vpc"
     auto_create_subnetworks = false
   
     depends_on = [google_project_service.compute]
   }
   
   resource "google_compute_subnetwork" "main" {
     name                     = "certlabpro-pca-subnet"
     ip_cidr_range            = "10.10.0.0/20"
     region                   = "us-central1"
     network                  = google_compute_network.main.id
     private_ip_google_access = true
   
     secondary_ip_range {
       range_name    = "pods"
       ip_cidr_range = "10.20.0.0/14"
     }
   
     secondary_ip_range {
       range_name    = "services"
       ip_cidr_range = "10.24.0.0/20"
     }
   }
   
   resource "google_compute_router" "nat_router" {
     name    = "certlabpro-pca-router"
     region  = "us-central1"
     network = google_compute_network.main.id
   }
   
   resource "google_compute_router_nat" "nat" {
     name                               = "certlabpro-pca-nat"
     router                             = google_compute_router.nat_router.name
     region                             = "us-central1"
     nat_ip_allocate_option             = "AUTO_ONLY"
     source_subnetwork_ip_ranges_to_nat = "ALL_SUBNETWORKS_ALL_IP_RANGES"
   
     log_config {
       enable = true
       filter = "ERRORS_ONLY"
     }
   }

3. 3.VPC पर एक GKE ऑटोनॉमस क्लस्टर प्रोविज़न करें

   प्रोविज़न:

   • Google Kubernetes Engine

   GKE ऑटोनॉमस पीसीए-अनुशंसित GKE मोड है — गूगल नोड पूल का प्रबंधन करता है, आप प्रति पॉड-vCPU / पॉड-मेमोरी की खपत के अनुसार भुगतान करते हैं। GKE स्टैंडर्ड से तुलना करें जहाँ आप अपने नोड पूल का आकार स्वयं निर्धारित करते हैं और भुगतान करते हैं। पीसीए परीक्षा इस ऑटोनॉमस-बनाम-स्टैंडर्ड ट्रेड-ऑफ का परीक्षण आवर्ती प्रबंधित-बनाम-नियंत्रण आकार के रूप में करती है।

   हम VPC-नेटिव (उपनाम IP — पॉड्स को स्टेप 2 में सेकेंडरी रेंज से IP मिलते हैं, NAT से नहीं), निजी क्लस्टर (नोड IP निजी होते हैं; कंट्रोल प्लेन को भी एक निजी एंडपॉइंट मिलता है), और वर्कलोड आइडेंटिटी (पॉड → GCP-API प्रमाणीकरण के लिए पीसीए-अनुशंसित पैटर्न — कोई नोड-स्तरीय सेवा-खाता क्रेडेंशियल नहीं) सक्षम करते हैं।

   कॉपी

   resource "google_container_cluster" "main" {
     name     = "certlabpro-pca-cluster"
     location = "us-central1" # regional Autopilot
   
     enable_autopilot = true
   
     network    = google_compute_network.main.id
     subnetwork = google_compute_subnetwork.main.id
   
     ip_allocation_policy {
       cluster_secondary_range_name  = "pods"
       services_secondary_range_name = "services"
     }
   
     private_cluster_config {
       enable_private_nodes    = true
       enable_private_endpoint = false # public control plane for kubectl access
       master_ipv4_cidr_block  = "172.16.0.0/28"
     }
   
     deletion_protection = false # lab-only
   
     depends_on = [google_project_service.container]
   }

4. 4.केवल निजी IP के साथ क्लाउड SQL पोस्टग्रेस् स्थापित करें

   प्रोविज़न:

   • Cloud SQL

   पीसीए-अनुशंसित डेटाबेस कनेक्टिविटी: वीपीसी पीयरिंग के माध्यम से निजी IP — क्लाउड SQL एक गूगल-प्रबंधित वीपीसी के अंदर प्रोविज़न होता है जो आपके वीपीसी के साथ पीयर करता है, इंस्टेंस को एक निजी IP मिलता है, और पॉड्स निजी नेटवर्किंग पर उस तक पहुँचते हैं। पब्लिक-IP क्लाउड SQL एक एंटी-पैटर्न है जिसके खिलाफ पीसीए परीक्षा परीक्षण करती है।

   आकार: (1) सर्विस नेटवर्किंग के उपयोग के लिए अपने वीपीसी से एक /16 आवंटित करें, (2) servicenetworking.googleapis.com के साथ वीपीसी को पीयर करें, (3) ipv4_enabled = false + पीयर्ड नेटवर्क रेफरेंस के साथ क्लाउड SQL इंस्टेंस प्रोविज़न करें।

   कॉपी

   resource "google_compute_global_address" "private_ip_alloc" {
     name          = "certlabpro-pca-sql-peer"
     purpose       = "VPC_PEERING"
     address_type  = "INTERNAL"
     prefix_length = 16
     network       = google_compute_network.main.id
   }
   
   resource "google_service_networking_connection" "sql_peering" {
     network                 = google_compute_network.main.id
     service                 = "servicenetworking.googleapis.com"
     reserved_peering_ranges = [google_compute_global_address.private_ip_alloc.name]
   
     depends_on = [google_project_service.servicenetworking]
   }
   
   resource "google_sql_database_instance" "main" {
     name             = "certlabpro-pca-pg"
     database_version = "POSTGRES_15"
     region           = "us-central1"
   
     settings {
       tier              = "db-perf-optimized-N-2"
       availability_type = "ZONAL" # lab-only; production = REGIONAL
   
       ip_configuration {
         ipv4_enabled    = false
         private_network = google_compute_network.main.id
       }
   
       backup_configuration {
         enabled                        = true
         point_in_time_recovery_enabled = true
       }
     }
   
     deletion_protection = false # lab-only
   
     depends_on = [
       google_service_networking_connection.sql_peering,
       google_project_service.sqladmin,
     ]
   }

5. 5.एसेट्स के लिए एक क्लाउड स्टोरेज ऐप बकेट स्थापित करें

   प्रोविज़न:

   • Cloud Storage

   पीसीए संदर्भ वास्तुकला में हमेशा किसी चीज़ के लिए एक क्लाउड स्टोरेज बकेट शामिल होता है — अपलोड, एक्सपोर्ट, एमएल फीचर डेटा, स्टैटिक वेब एसेट्स। हम यहां एक जोड़ते हैं, यूनिफ़ॉर्म-बकेट-लेवल-एक्सेस चालू है, लाइफ़साइकिल डेटा को 30 दिनों के बाद नियरलाइन में ले जाती है।

   पांच ब्लॉक (VPC + NAT, ऑटोनॉमस GKE, निजी IP के साथ क्लाउड SQL, GCS बकेट) के स्थान पर, पीसीए संदर्भ आकार पूरा हो गया है: वर्कलोड GKE पर चलते हैं, निजी नेटवर्किंग पर पोस्टग्रेस् से बात करते हैं, GCS पर आर्टिफैक्ट लिखते हैं, क्लाउड NAT के माध्यम से एग्रेस करते हैं।

   कॉपी

   resource "random_id" "suffix" {
     byte_length = 4
   }
   
   resource "google_storage_bucket" "app" {
     name                        = "certlabpro-pca-app-${random_id.suffix.hex}"
     location                    = "US"
     uniform_bucket_level_access = true
     force_destroy               = true # lab-only
   
     lifecycle_rule {
       condition {
         age = 30
       }
       action {
         type          = "SetStorageClass"
         storage_class = "NEARLINE"
       }
     }
   
     labels = local.labels
   
     depends_on = [google_project_service.storage]
   }

क्लीनअप (Cleanup)