☁️ GCP – Google Cloud Platform (Écosystème Cloud)

1.1 Vue d’ensemble – Google Cloud Platform (GCP)

GCP en quelques points

Google Cloud Platform est la plateforme de cloud public de Google, construite sur la même infrastructure que Gmail, YouTube, Search, Maps, etc.

Architecture fortement orientée réseau global et data.
Mise en avant des services managés plutôt que des VM “brutes”.
Intégration native avec l’écosystème Google (Workspace, Android, Chrome, etc.).

Modèle de facturation

Pay-as-you-go avec facturation à la seconde pour Compute.
Remises par engagements (Committed Use Discounts) et Sustained Use.
Grilles de prix agressives sur BigQuery / stockage objet.

Forces vs limites

Forces :
- BigQuery & outils data/ML très avancés.
- Réseau global anycast et load balancing L7 mondial.
- Orientation multi-cloud / hybrid (Anthos).
Limites/perception :
- Catalogue légèrement moins vaste qu’AWS.
- Moins présent dans certains grands comptes historiques Microsoft.

Quand choisir GCP ?

Projet fortement orienté analytics / IA / streaming.
Besoin de load balancing global très simple à mettre en place.
Organisation déjà très “Google friendly” (Workspace, Android, etc.).

Concept clé : Organisation / Folder / Project

Organisation : racine de ton tenant (souvent ton domaine entreprise).
Folders : regroupement logique (par BU, pays, type d’environnement).
Projects :
- Unité de facturation, quotas & API.
- Contexte IAM (qui peut faire quoi sur ce projet).
- Conteneur des ressources (GCE, GCS, BigQuery, etc.).

Stratégies de découpage

Par environnement : app-dev, app-staging, app-prod.
Par domaine métier : data-prod, payments-prod, etc.
Mélange des deux : “folder Apps” → projets dev/stage/prod par app.

IAM et hiérarchie

Rôles IAM peuvent être appliqués à : Organisation, Folder, Project, Ressource.
Bon pattern :
- Admin & sécurité définis au niveau Organisation.
- Rôles “Ops” au niveau Folder ou Project.
- Rôles très fins (lecture seule, data-scientist, dev) au niveau Project.
Identity-Aware Proxy (IAP) pour exposer apps internes sans ouvrir le réseau.

Labels & organisation facturation

Utiliser des labels (env, team, cost_center) sur toutes les ressources.
Exporter la facturation vers BigQuery pour analyse fine FinOps.

Familles de services majeures

Famille	Exemples
Compute	Compute Engine, GKE, Cloud Run, App Engine, Batch.
Storage	Cloud Storage, Persistent Disk, Filestore, Archive.
Réseau	VPC, Cloud Load Balancing, Cloud CDN, Cloud DNS, Cloud Armor.
Data / Analytics	BigQuery, Pub/Sub, Dataflow, Dataproc, Dataform, Looker.
Bases de données	Cloud SQL, Spanner, Firestore, Memorystore, AlloyDB.
Ops & sécurité	Cloud Logging/Monitoring, IAM, KMS, SCC, Cloud Build/Deploy.

Compétences clés pour un profil GCP

Maîtriser au moins un stack “web” de référence :
- Cloud Run + Cloud SQL + Cloud Storage + Cloud CDN.
- ou GKE + Ingress + Cloud NAT + Cloud Armor.
Comprendre le modèle data :
- Data lake sur GCS.
- Entrepôt analytique BigQuery.
- Streaming Pub/Sub + Dataflow.
Être à l’aise avec gcloud, gsutil, Terraform, CI/CD Cloud Build.

Cas d’usage typiques

Analytics temps quasi réel : Pub/Sub → Dataflow → BigQuery → Looker.
Apps web/API :
- Cloud Run (HTTP) + Cloud SQL + Memorystore.
- Cloud Armor + Cloud CDN en front.
MLOps :
- Vertex AI pour training/serving de modèles.
- Stockage dataset sur GCS + BigQuery ML.
HPC / Simulation : Compute Engine + preemptible + GCS + Filestore.

Profils & rôles concernés

Cloud Architect : design des projets, réseaux, IAM, sécurité globale.
DevOps / SRE : CI/CD, Terraform, observabilité, fiabilité.
Data Engineer : pipelines Dataflow, Dataproc, BigQuery, Pub/Sub.
ML Engineer : Vertex AI, GPUs, orchestration training/serving.

Ton IDEO-Lab peut servir de vitrine sur ces 4 axes avec des mini-démos par type de profil (web, data, ML, ops).

1.2 Global Infrastructure – Régions, Zones, Organisation, VPC SC

Régions & disponibilité

Région = zone géographique (europe-west1, europe-west9, us-central1...).
Chaque région regroupe plusieurs zones (a, b, c) isolées.
Design haute dispo :
- Workloads “critiques” → multi-zones.
- Workloads “mission critical” → multi-régions.

Réseau privé Google

Backbone mondial qui interconnecte les DC Google.
Load balancer HTTP(S) global anycast :
- Une IP frontale → backends dans plusieurs régions.
- Routage vers la région la plus proche / disponible.
En pratique :
- Très utile pour apps IDEO-Lab multi-continents.
- Permet d’éviter du bricolage DNS ou GSLB on-prem.

Organisation & hiérarchie

Organisation (root) associée à ton domaine (ex: ideo-lab.com).
Folders pour structurer par BU, env, pays, type de workload.
Projects :
- Contexte de ressources.
- Unités de facturation & quotas.
- Frontière IAM (rôles, SA, etc.).

organisation: ideo-lab.com
  ├── folder: labs
  │     ├── project: ilab-gcp-sandbox
  │     └── project: ilab-gcp-data-playground
  ├── folder: nonprod
  │     └── project: ilab-gcp-staging
  └── folder: prod
        └── project: ilab-gcp-prod

Bonnes pratiques d’org

Isoler prod dans un folder dédié avec policies plus restrictives.
Avoir un projet “sécurité/logs” central pour :
- Cloud Logging/Monitoring.
- Security Command Center.
- Export billing (BigQuery).
Limiter les droits “Owner/Editor” aux équipes cloud core seulement.

VPC Service Controls

Permet de définir des périmètres de sécurité autour des services GCP.
But : limiter les risques d’exfiltration de données via identités compromises.
Fonctionne bien avec :
- BigQuery.
- Cloud Storage.
- Pub/Sub, Dataflow, etc.

Gouvernance & compliance

Org Policy pour interdire certains patterns (ex: IP publiques, régions non autorisées).
Cloud Asset Inventory pour inventory complet des ressources.
Security Command Center (SCC) pour consolider les findings sécurité.
Process :
- Définir baseline de rules niveau Org.
- Tester en nonprod, puis généraliser.

1.3 Compute GCP – Compute Engine, GKE, Cloud Run, App Engine

Compute Engine (VM)

Types de machines : e2 (généraliste), n2/n2d (perf), c2 (CPU), a2 (GPU), t2d (AMD).
Facturation à la seconde, remises Sustained/Committed Use.
Custom machine types = ajuster précisément CPU/RAM.
Disques : Standard, SSD, Balanced, Extreme + snapshots.

gcloud compute instances create ilab-vm \
  --zone=europe-west1-b \
  --machine-type=e2-standard-4 \
  --boot-disk-size=50GB \
  --image-family=debian-12 \
  --image-project=debian-cloud \
  --tags=http-server

Utiliser des instance templates + managed instance groups pour l’auto-scale.

GKE, Cloud Run & App Engine

GKE :
- Clusters Kubernetes managés.
- Node pools, autoscaling, auto-upgrade, auto-repair.
- Idéal pour microservices complexes / multi-teams.
Cloud Run :
- Containers HTTP serverless, “scale to zero”.
- Modèle simple : container + URL.
- Perfect pour microservices “stateless” IDEO-Lab.
App Engine :
- PaaS historique (standard/flexible).
- Peu de gestion infra, bonnes perfs pour apps web.

gcloud run deploy ilab-api \
  --source . \
  --region=europe-west1 \
  --platform=managed \
  --allow-unauthenticated

1.4 Storage GCP – Cloud Storage, Persistent Disk, Filestore

Cloud Storage (objet)

Buckets avec localisation (regional, multi-regional, dual-region).
Classes : Standard, Nearline, Coldline, Archive.
Versioning, lifecycle rules, encryption (Google-managed ou KMS).
Idéal pour :
- Backups et archives.
- Assets statiques web.
- Data-lake pour analytics BigQuery.

gsutil mb -c STANDARD -l EU gs://ideo-lab-demo
gsutil cp static/* gs://ideo-lab-demo/assets/

Persistent Disk & Filestore

Persistent Disk :
- Attaché à une VM ou un node GKE.
- Snapshots, redimensionnement à chaud.
- IOPS & throughput selon type.
Filestore :
- NFS managé, partagé entre instances.
- Typique pour héberger /var/lib/postgres, data science, etc.
Stratégie :
- OS & DB → PD.
- Assets & backups → GCS.
- FS partagé apps legacy → Filestore.

2.1 Réseau & Edge – VPC, Load Balancing global, Cloud CDN, DNS, Armor

VPC & sécurité réseau

VPC global au niveau organisation ou projet.
Subnets régionaux, firewall rules stateful (ingress/egress).
Cloud NAT pour accéder à internet sans IP publique.
VPN & (Partner/Dedicated) Interconnect pour le lien on-prem.

gcloud compute networks create ilab-vpc --subnet-mode=custom
gcloud compute networks subnets create ilab-subnet-eu \
  --network=ilab-vpc \
  --region=europe-west1 \
  --range=10.10.0.0/20

Edge : LB global, CDN & Armor

HTTP(S) Load Balancer global :
- Une IP anycast visible worldwide.
- Backends GCE/GKE/Run multi-régions.
Cloud CDN : cache contenu statique au plus proche des users.
Cloud DNS : zones publiques/privées DNS.
Cloud Armor :
- Protection DDoS & WAF.
- Règles OWASP, whitelists par pays/IP.
Pattern IDEO-Lab :
- LB global + CDN + Armor devant Cloud Run ou GKE.

2.2 Data & Analytics – BigQuery, Pub/Sub, Dataflow, Dataproc, Cloud SQL, Spanner

BigQuery & stockage analytique

Data warehouse colonne, serverless, quasi-illimité.
Mode on-demand (prix par TB scanné) ou slots réservés.
Support du partitionnement et clustering de tables.
Intégrations :
- GCS (load/extract).
- Pub/Sub (streaming ingestion).
- Dataflow, Dataproc, Dataform, Sheets, Looker, etc.

bq query --use_legacy_sql=false '
  SELECT user_id, COUNT(*) AS n
  FROM `ilab.logs.http`
  WHERE timestamp >= TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 7 DAY)
  GROUP BY user_id
  ORDER BY n DESC
  LIMIT 20;
'

Streaming / batch & bases de données

Pub/Sub : messaging global, at-least-once, idéal pour event-ingestion.
Dataflow : pipelines Apache Beam (batch & streaming).
Dataproc : Spark/Hadoop managé, clusters éphémères.
Cloud SQL : MySQL/Postgres/SQL Server managés.
Spanner : base SQL distribuée globale, forte cohérence, scale horizontal.

Exemple de pipeline possible pour IDEO-Lab : logs Nginx → Pub/Sub → Dataflow (enrichissement) → BigQuery → Dashboards Looker.

2.3 Serverless & Event-driven – Cloud Functions, Cloud Run, Eventarc, Pub/Sub, Workflows

Cloud Functions

Fonctions event-driven (Pub/Sub, GCS, HTTP, scheduler, Firebase...).
Parfait pour :
- Petits webhooks.
- Traitements sur upload GCS.
- Glue code entre services GCP.

def hello_gcs(event, context):
    print(f"[IDEO-LAB] New object: {event['name']} in bucket {event['bucket']}")

Cloud Run, Eventarc & Workflows

Cloud Run :
- Docker image → service HTTP serverless.
- Scale from 0 to N, concurrency configurables.
- Support des requests longues (jusqu’à 60 minutes).
Eventarc :
- Routage d’évènements GCP (GCS, Audit Logs…) vers Run/Functions.
Workflows :
- Orchestration serverless en YAML (call HTTP, Run, Functions...).
- Utile pour décrire des process multi-étapes.
Cloud Scheduler : CRON-as-a-service pour déclencher HTTP / Pub(Sub).

3.1 Sécurité GCP – IAM, KMS, SCC, Cloud Armor, VPC SC

IAM & identités

Rôles basés sur les principaux :
- Users (comptes humains).
- Service Accounts (pour workloads).
- Groupes Google.
Types de rôles :
- Primitive (viewer/editor/owner) → à proscrire en prod.
- Prédéfinis (roles/storage.admin, etc.).
- Custom pour un périmètre précis.
Bon pattern :
- Groupes Google = mapping métier (“dev-backend-prod”).
- Bindings IAM sur les groupes, pas sur users individuels.

gcloud projects add-iam-policy-binding ilab-prod \
  --member=serviceAccount:api-sa@ilab-prod.iam.gserviceaccount.com \
  --role=roles/storage.objectViewer

KMS, Security Command Center & Armor

Cloud KMS :
- Gestion des clés symétriques/asymétriques.
- Intégration avec GCS, PD, BigQuery, etc.
Security Command Center (SCC) :
- Vue agrégée des vulnérabilités, misconfig, menaces.
- Niveau Premium = intégration plus poussée.
Cloud Armor :
- Protection DDoS / WAF pour LB HTTP(S).
- WAF géré (OWASP), règles basées sur IP, pays, URI, etc.
Zero Trust :
- Identity-Aware Proxy (IAP) pour frontends internes.
- BeyondCorp Enterprise pour accès sans VPN.

3.2 Observabilité – Cloud Logging, Monitoring, Trace, Profiler, Error Reporting

Cloud Operations Suite

Cloud Logging : collecte des logs de toutes les ressources GCP.
Cloud Monitoring : métriques, dashboards, alertes.
Trace : latence des requêtes, traces distribuées.
Profiler : profiling CPU/mémoire continu.
Error Reporting : agrégation des exceptions applicatives.

Patterns & bonnes pratiques

Centraliser les logs de prod dans un projet “logging-securite”.
Standardiser les labels de ressources & métriques (env, app, version, region).
Créer des alertes sur :
- Erreur 5xx HTTP.
- Latence P95 supérieure à X ms.
- Échecs de jobs batch (Dataflow, Dataproc).
- Coûts BigQuery / GCS / Compute dépassant un seuil.
Exporter logs vers BigQuery pour investigations & capacity planning.

3.3 GCP & DevOps – Cloud Build, Cloud Deploy, Terraform, Config Connector

Infrastructure as Code

Terraform :
- Provider google & google-beta.
- State dans GCS + verrouillage via Cloud Storage ou Terraform Cloud.
- Modules pour VPC, GKE, Cloud Run, IAM…
Deployment Manager (historiquement) pour templates YAML/JSON.
Config Connector :
- CRD Kubernetes pour représenter les ressources GCP.
- GitOps natif depuis GKE.

Exemple Terraform simplifié

provider "google" {
  project = "ilab-gcp-prod"
  region  = "europe-west1"
}

resource "google_storage_bucket" "assets" {
  name          = "ideo-lab-assets-gcp"
  location      = "EU"
  force_destroy = true
  uniform_bucket_level_access = true
  lifecycle_rule {
    condition { age = 90 }
    action    { type = "SetStorageClass" storage_class = "COLDLINE" }
  }
}

Cloud Build

CI serverless : build, tests, lint, packaging, Terraform plan/apply.
Déclencheurs GitHub, GitLab, Cloud Source Repositories.
Artifacts stockés dans Artifact Registry.

steps:
- name: "gcr.io/cloud-builders/gcloud"
  args: ["builds","submit","--tag","eu.gcr.io/$PROJECT_ID/ilab-api:$COMMIT_SHA","."]

- name: "hashicorp/terraform"
  entrypoint: "sh"
  args:
  - "-c"
  - |
    terraform init
    terraform apply -auto-approve

images:
- "eu.gcr.io/$PROJECT_ID/ilab-api:$COMMIT_SHA"

Cloud Deploy & pipelines complets

Cloud Deploy : orchestrer les releases vers GKE / Cloud Run.
Stratégies de déploiement :
- canary, blue/green.
- approbations manuelles lors du passage staging → prod.
Intégrer tests smoke automatiques après déploiement.

GitOps sur GCP

Repos Git pour :
- Infra (Terraform).
- Manifests K8s (GKE).
- Code applicatif.
ArgoCD / Config Sync pour synchroniser manifests vers GKE.
Pipeline :
- PR → tests → merge → Cloud Build met à jour manifests / Terraform.
- ArgoCD applique sur clusters.

Gouvernance DevOps

Pas de création de ressources GCP “à la main” pour prod.
Review obligatoire pour toute PR modifiant l’infra.
Politique de secrets : Secret Manager + Workload Identity.
Documentation living : README par projet GCP avec :
- Architecture ASCII/diagramme.
- Commandes make ou scripts pour bootstrap.
- Runbook incidents (latence, budget burn, quotas).

4.1 Hybrid & Multi-cloud – Anthos, Interconnect, VPN, GKE Anywhere

Anthos & GKE Anywhere

Anthos : couche de gestion pour clusters K8s on-prem & multi-cloud.
Objectifs :
- Policies communes (sécurité, réseau, config).
- Observabilité unifiée.
- Déploiements GitOps cross-cloud.
GKE On-Prem / Anywhere :
- Clusters Kubernetes gérés depuis GCP mais exécutés on-prem/edge.

Connectivité & scénarios hybrides

Cloud VPN & Interconnect pour relier DC on-prem ↔ GCP.
Scénario “extension data” :
- Sources on-prem → ingestion vers GCS/PubSub → BigQuery.
- BI / analytics “cloud” sur données historisées.
Stratégies multi-cloud :
- Anthos pour exposer des services GKE sur AWS/Azure.
- Data lake GCS + BQ, compute certain workloads sur autre cloud.
Contexte défense/aéro (IDEO-Lab) :
- Gardes certaines couches “sensibles” on-prem (DB, secrets).
- Expose front/API & analytics sur GCP avec segmentation réseau stricte.

4.2 Cheat-sheet GCP – Services clés & commandes gcloud/gsutil

Services à maîtriser

Compute : Compute Engine, GKE, Cloud Run, Cloud Functions.
Storage : Cloud Storage, Persistent Disk, Filestore.
Réseau : VPC, LB global, Cloud CDN, Cloud DNS, Cloud Armor.
Data : BigQuery, Pub/Sub, Dataflow, Dataproc, Cloud SQL, Spanner.
Sécurité : IAM, KMS, SCC, VPC SC, IAP.
DevOps : Cloud Build, Cloud Deploy, Artifact Registry, Terraform.

Rappels design

Isoler prod/nonprod par projets/folders.
Activer logs & audit partout (Cloud Audit Logs).
Tagger/labeler toutes les ressources.
Tout ce qui touche prod passe par IaC + pipeline.

gcloud / gsutil : mémos rapides

# Auth & projet
gcloud auth login
gcloud config set project ilab-gcp-dev
gcloud config list

# Compute Engine
gcloud compute instances list
gcloud compute ssh ilab-vm --zone=europe-west1-b

# Cloud Run
gcloud run services list
gcloud run deploy ideo-lab-api --image=eu.gcr.io/$PROJECT_ID/ideo-lab-api:latest

# Cloud Storage
gsutil ls
gsutil rsync -r ./static gs://ideo-lab-assets-gcp

# BigQuery
bq ls
bq query --use_legacy_sql=false 'SELECT 1'

# IAM
gcloud projects get-iam-policy ilab-gcp-prod

Créer un petit script ilab-gcp-init.sh qui :
- Configure le projet + région par défaut.
- Crée bucket, service account, clé KMS de base.
Documenter dans IDEO-Lab la séquence “from zero to prod” pour GCP.

☁️ GCP – Google Cloud Platform (Écosystème & Services)

Vue d’ensemble GCP

Global Infrastructure

Compute (GCE, GKE, Cloud Run)

Storage (GCS, PD, Filestore)

Réseau & Edge

Data & Analytics

Serverless & Events

Sécurité, IAM & KMS

Supervision & Observabilité

DevOps & IaC

Hybrid & Multi-cloud

Cheat-sheet GCP