Atelier pratique — PCA Google Cloud Professional Cloud Architect

Présentation

Prérequis

Étapes

1. 1.Fournisseur, services de projet, nommage

   Activez les API Compute, GKE, Cloud SQL, Service Networking (pour l'IP privée de Cloud SQL) et Cloud Storage.

   Copier

   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.Construire le VPC + Cloud NAT pour un trafic sortant uniquement

   Déploie :

   • VPC
   • Cloud NAT

   Modèle recommandé par le PCA : les VM/pods privés n'ont pas d'IP externes, mais doivent néanmoins atteindre des dépendances externes (appels pip / docker / API). La solution est Cloud NAT — un service NAT régional géré qui fournit aux ressources privées un trafic sortant uniquement.

   Nous découpons un sous-réseau /20 avec deux plages secondaires pour GKE (pods + services), provisionnons un Cloud Router et y attachons un Cloud NAT.

   Copier

   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.Provisionner un cluster GKE Autopilot sur le VPC

   Déploie :

   • Google Kubernetes Engine

   GKE Autopilot est le mode GKE recommandé par le PCA — Google gère le pool de nœuds, vous payez par vCPU de pod / mémoire de pod consommée. Comparez à GKE Standard où vous dimensionnez et payez vous-même le pool de nœuds. L'examen PCA teste ce compromis Autopilot-vs-Standard comme la forme récurrente géré-vs-contrôle.

   Nous activons le VPC-natif (alias IP — les pods obtiennent des IP de la plage secondaire de l'étape 2, et non de NAT), le cluster privé (les IP des nœuds sont privées ; le plan de contrôle obtient également un point de terminaison privé), et Workload Identity (le modèle recommandé par le PCA pour l'authentification pod → GCP-API — sans identifiants de compte de service au niveau des nœuds).

   Copier

   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.Mettre en place Cloud SQL Postgres avec IP privée uniquement

   Déploie :

   • Cloud SQL

   Connectivité de base de données recommandée par le PCA : IP privée via peering VPC — Cloud SQL est provisionné dans un VPC géré par Google qui est en peering avec le vôtre, l'instance obtient une IP privée, et les pods y accèdent via le réseau privé. Cloud SQL avec IP publique est l'anti-pattern testé par l'examen PCA.

   La forme : (1) allouer un /16 depuis votre VPC pour que Service Networking l'utilise, (2) peer le VPC avec servicenetworking.googleapis.com, (3) provisionner l'instance Cloud SQL avec ipv4_enabled = false + la référence du réseau en peering.

   Copier

   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.Déposer un bucket d'application Cloud Storage pour les actifs

   Déploie :

   • Cloud Storage

   Les architectures de référence PCA incluent toujours un bucket Cloud Storage pour quelque chose — téléchargements, exportations, données de fonctionnalités ML, actifs web statiques. Nous en ajoutons un ici, avec accès uniforme au niveau du bucket activé, et un cycle de vie déplaçant les données vers Nearline après 30 jours.

   Avec les cinq blocs en place (VPC + NAT, GKE Autopilot, Cloud SQL avec IP privée, bucket GCS), la forme de référence PCA est complète : les charges de travail s'exécutent sur GKE, communiquent avec Postgres via le réseau privé, écrivent des artefacts dans GCS, et sortent via Cloud NAT.

   Copier

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

Nettoyage