Laboratorio práctico — PCA Google Cloud Professional Cloud Architect

Descripción general

Requisitos previos

Pasos

1. 1.Proveedor, servicios del proyecto, nomenclatura

   Habilite las API de Compute, GKE, Cloud SQL, Service Networking (para IP privada de Cloud SQL) y Cloud Storage.

   Copiar

   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.Construya la VPC + Cloud NAT para egreso de solo salida

   Aprovisiona:

   • VPC
   • Cloud NAT

   Patrón recomendado por PCA: las VM/pods privados no tienen IP externas, pero aún necesitan alcanzar dependencias externas (llamadas a pip / docker / API). La respuesta es Cloud NAT — un servicio NAT regional gestionado que proporciona egreso de solo salida a los recursos privados.

   Creamos una subred /20 con dos rangos secundarios para GKE (pods + servicios), aprovisionamos un Cloud Router y le adjuntamos un Cloud NAT.

   Copiar

   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.Aprovisione un clúster GKE Autopilot en la VPC

   Aprovisiona:

   • Google Kubernetes Engine

   GKE Autopilot es el modo GKE recomendado por PCA — Google gestiona el grupo de nodos, usted paga por vCPU/memoria de pod consumida. Compare con GKE Standard donde usted mismo dimensiona y paga por el grupo de nodos. El examen de PCA evalúa esta disyuntiva Autopilot vs. Standard como la forma recurrente gestionado vs. control.

   Habilitamos VPC-nativa (IPs alias — los pods obtienen IPs del rango secundario en el Paso 2, no de NAT), clúster privado (las IPs de los nodos son privadas; el plano de control también obtiene un endpoint privado) e Identidad de Carga de Trabajo (el patrón recomendado por PCA para la autenticación de pod → GCP-API — sin credenciales de cuenta de servicio a nivel de nodo).

   Copiar

   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.Implemente Cloud SQL Postgres solo con IP privada

   Aprovisiona:

   • Cloud SQL

   Conectividad de base de datos recomendada por PCA: IP privada a través de emparejamiento de VPC — Cloud SQL se aprovisiona dentro de una VPC gestionada por Google que se empareja con la suya, la instancia obtiene una IP privada y los pods la alcanzan a través de la red privada. Cloud SQL con IP pública es el antipatrón que se evalúa en el examen de PCA.

   La forma: (1) asigne un /16 de su VPC para que lo use Service Networking, (2) empareje la VPC con servicenetworking.googleapis.com, (3) aprovisione la instancia de Cloud SQL con ipv4_enabled = false + la referencia de red emparejada.

   Copiar

   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.Cree un bucket de aplicación de Cloud Storage para activos

   Aprovisiona:

   • Cloud Storage

   Las arquitecturas de referencia de PCA siempre incluyen un bucket de Cloud Storage para algo — cargas, exportaciones, datos de características de ML, activos web estáticos. Añadimos uno aquí, con acceso uniforme a nivel de bucket activado, ciclo de vida que mueve los datos a Nearline después de 30 días.

   Con los cinco bloques en su lugar (VPC + NAT, GKE Autopilot, Cloud SQL con IP privada, bucket de GCS), la forma de referencia de PCA está completa: las cargas de trabajo se ejecutan en GKE, se comunican con Postgres a través de redes privadas, escriben artefactos en GCS, y egresan a través de Cloud NAT.

   Copiar

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

Limpieza