Praxislabor — PCA Google Cloud Professional Cloud Architect

Übersicht

Voraussetzungen

Schritte

1. 1.Provider, Projektdienste, Benennung

   Aktivieren Sie die APIs für Compute, GKE, Cloud SQL, Service Networking (für die private IP von Cloud SQL) und Cloud Storage.

   Kopieren

   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.Erstellen Sie die VPC + Cloud NAT für ausschließlich ausgehenden Datenverkehr

   Ressourcen:

   • VPC
   • Cloud NAT

   Von der PCA empfohlenes Muster: Private VMs/Pods haben keine externen IPs, müssen aber dennoch externe Abhängigkeiten erreichen können (pip / docker / API-Aufrufe). Die Antwort ist Cloud NAT – ein verwalteter regionaler NAT-Dienst, der privaten Ressourcen ausschließlich ausgehenden Datenverkehr ermöglicht.

   Wir erstellen ein /20-Subnetz mit zwei sekundären Bereichen für GKE (Pods + Dienste), stellen einen Cloud Router bereit und fügen eine Cloud NAT daran an.

   Kopieren

   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.Stellen Sie einen GKE Autopilot-Cluster in der VPC bereit

   Ressourcen:

   • Google Kubernetes Engine

   GKE Autopilot ist der von der PCA empfohlene GKE-Modus – Google verwaltet den Knotenpool, Sie zahlen pro genutzter Pod-vCPU / Pod-Arbeitsspeicher. Vergleichen Sie dies mit GKE Standard, wo Sie den Knotenpool selbst dimensionieren und bezahlen. Die PCA-Prüfung testet diesen Autopilot-vs-Standard-Kompromiss als wiederkehrendes managed-vs-control-Schema.

   Wir aktivieren VPC-native (Alias-IPs – die Pods erhalten IPs aus dem sekundären Bereich in Schritt 2, nicht von NAT), private cluster (Knoten-IPs sind privat; die Steuerungsebene erhält ebenfalls einen privaten Endpunkt) und Workload Identity (das von der PCA empfohlene Muster für die Pod → GCP-API-Authentifizierung – keine Dienstkonten-Anmeldeinformationen auf Knotenebene).

   Kopieren

   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.Richten Sie Cloud SQL Postgres nur mit privater IP ein

   Ressourcen:

   • Cloud SQL

   Von der PCA empfohlene Datenbankkonnektivität: private IP über VPC-Peering – Cloud SQL wird in einer von Google verwalteten VPC bereitgestellt, die mit Ihrer VPC verbunden ist. Die Instanz erhält eine private IP, und Pods erreichen sie über private Netzwerke. Cloud SQL mit öffentlicher IP ist das Anti-Muster, das in der PCA-Prüfung abgefragt wird.

   Die Struktur: (1) weisen Sie einen /16-Block aus Ihrer VPC zu, den Service Networking verwenden kann, (2) verbinden Sie die VPC über Peering mit servicenetworking.googleapis.com, (3) stellen Sie die Cloud SQL-Instanz mit ipv4_enabled = false + der Referenz des gepeerten Netzwerks bereit.

   Kopieren

   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.Erstellen Sie einen Cloud Storage-Anwendungsbucket für Assets

   Ressourcen:

   • Cloud Storage

   PCA-Referenzarchitekturen enthalten immer einen Cloud Storage-Bucket für irgendetwas – Uploads, Exporte, ML-Feature-Daten, statische Web-Assets. Wir fügen hier einen hinzu, mit aktivierter einheitlicher Bucket-Zugriffssteuerung, wobei der Lebenszyklus Daten nach 30 Tagen nach Nearline verschiebt.

   Mit den fünf Blöcken (VPC + NAT, Autopilot GKE, Cloud SQL mit privater IP, GCS-Bucket) ist die PCA-Referenzstruktur vollständig: Workloads laufen auf GKE, kommunizieren mit Postgres über private Netzwerke, schreiben Artefakte in GCS, und der ausgehende Verkehr erfolgt über Cloud NAT.

   Kopieren

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

Bereinigung