DevOpsFacile
AccueilParcours de formationCertificationsModulesCheat SheetÀ Propos
DevOpsFacile

Une plateforme d'apprentissage complète pour maîtriser les pratiques DevOps modernes, du débutant à l'expert.

contact@devopsfacile.fr

Formation

  • Parcours de formation
  • Modules

Informations

  • À Propos
  • Conditions d'utilisation
  • Confidentialité
  • Mentions légales

© 2026 DevOps Facile. Tous droits réservés.

Fait avec pour la communauté DevOps

ModulesGCP - Intermédiaire : VPC, Cloud SQL, Cloud Run et Cloud Build

Module

Maîtrisez le réseau GCP avec les VPCs personnalisés, les bases de données avec Cloud SQL, le serverless avec Cloud Run et le CI/CD avec Cloud Build.

  • 2h30
  • Intermédiaire
  • 3 exercices
Voir les exercices

Formation 100 % Linux

Tous les modules nécessitent un environnement Linux. Si vous êtes sur Windows, installez d'abord WSL (Windows Subsystem for Linux) avant de continuer.

GCP - Intermédiaire : VPC, Cloud SQL, Cloud Run et Cloud Build

🎯 Objectifs

  • ✅ Concevoir des VPCs personnalisés avec sous-réseaux et règles de pare-feu
  • ✅ Déployer et accéder à une base de données Cloud SQL
  • ✅ Déployer des applications conteneurisées avec Cloud Run
  • ✅ Automatiser le CI/CD avec Cloud Build et Artifact Registry
  • ✅ Orchestrer des conteneurs avec GKE

📋 Prérequis

  • GCP Débutant (Cloud IAM, Compute Engine, Cloud Storage, gcloud CLI)
  • Docker Débutant (images, conteneurs, Dockerfile)
  • Kubernetes Débutant (pods, services, kubectl)

🌐 VPC Personnalisé

Mode Auto vs Mode Personnalisé

GCP crée automatiquement un VPC default en mode auto : un sous-réseau par région, avec des plages prédéfinies. En production, créez un VPC personnalisé pour contrôler totalement les plages d'adresses.

CritèreVPC AutoVPC Personnalisé
Sous-réseauxCréés automatiquement dans chaque régionVous les créez manuellement
Plages IPPrédéfinies par GoogleVous les choisissez
Recommandé pourDev rapideProduction

Créer un VPC Personnalisé

bash
# Créer le VPC sans sous-réseaux automatiques
gcloud compute networks create mon-vpc \
  --subnet-mode custom \
  --bgp-routing-mode regional

# Créer des sous-réseaux
gcloud compute networks subnets create subnet-europe \
  --network mon-vpc \
  --region europe-west9 \
  --range 10.0.1.0/24

gcloud compute networks subnets create subnet-us \
  --network mon-vpc \
  --region us-central1 \
  --range 10.1.1.0/24

Cloud NAT - Accès Internet Sortant pour les VMs Privées

Les VMs sans IP publique ne peuvent pas accéder à Internet par défaut. Cloud NAT permet l'accès sortant sans exposer les VMs :

bash
# Créer un Cloud Router (nécessaire pour Cloud NAT)
gcloud compute routers create mon-router \
  --network mon-vpc \
  --region europe-west9

# Créer le Cloud NAT
gcloud compute routers nats create mon-nat \
  --router mon-router \
  --region europe-west9 \
  --auto-allocate-nat-external-ips \
  --nat-all-subnet-ip-ranges

VPC Peering

Connecte deux VPCs (même projet ou projets différents) pour communiquer via IP internes :

bash
# VPC Peering entre vpc-a et vpc-b
gcloud compute networks peerings create peering-a-vers-b \
  --network vpc-a \
  --peer-network vpc-b \
  --auto-create-routes

# Dans le sens inverse (obligatoire)
gcloud compute networks peerings create peering-b-vers-a \
  --network vpc-b \
  --peer-network vpc-a \
  --auto-create-routes

🗄️ Cloud SQL

Concept

Cloud SQL est le service de bases de données relationnelles managées de GCP. Il supporte PostgreSQL, MySQL et SQL Server.

Google gère les sauvegardes, les mises à jour, la réplication et le failover. Vous gérez le schéma, les données et les connexions.

Créer une Instance Cloud SQL

bash
# Créer une instance PostgreSQL 15
gcloud sql instances create ma-db \
  --database-version POSTGRES_15 \
  --region europe-west9 \
  --tier db-f1-micro \
  --availability-type REGIONAL \
  --storage-type SSD \
  --storage-size 10GB \
  --backup-start-time 03:00

# Créer une base de données
gcloud sql databases create mon-schema --instance ma-db

# Créer un utilisateur
gcloud sql users create mon-user \
  --instance ma-db \
  --password MonMotDePasse123!

# Se connecter (via Cloud SQL Auth Proxy ou IP autorisée)
gcloud sql connect ma-db --user mon-user --database mon-schema

Cloud SQL Auth Proxy - Connexion Sécurisée

Le Cloud SQL Auth Proxy établit une connexion chiffrée vers Cloud SQL sans exposer l'instance à Internet ni ouvrir de port de base de données.

bash
# Télécharger le proxy
curl -o cloud-sql-proxy \
  https://storage.googleapis.com/cloud-sql-connectors/cloud-sql-proxy/v2.12.0/cloud-sql-proxy.linux.amd64
chmod +x cloud-sql-proxy

# Lancer le proxy (remplacez par votre connection name)
./cloud-sql-proxy mon-projet:europe-west9:ma-db \
  --port 5432 &

# Connexion depuis votre app ou psql
psql -h 127.0.0.1 -p 5432 -U mon-user -d mon-schema

Haute Disponibilité et Réplicas

bash
# Activer la haute disponibilité (failover automatique)
gcloud sql instances patch ma-db \
  --availability-type REGIONAL

# Créer un read replica (pour la scalabilité des lectures)
gcloud sql instances create ma-db-replica \
  --master-instance-name ma-db \
  --region europe-west1    # peut être dans une autre région

⚡ Cloud Run

Concept

Cloud Run exécute des conteneurs Docker sans serveur (serverless). Vous déployez une image, Google gère l'infrastructure, le scaling (y compris scale-to-zero) et la haute disponibilité.

💡 Différence avec les fonctions Lambda/Cloud Functions : Cloud Run exécute n'importe quel conteneur. Cloud Functions exécute une fonction dans un runtime géré. Cloud Run offre plus de flexibilité (dépendances, port d'écoute libre).

Déployer sur Cloud Run

bash
# Méthode 1 : depuis une image déjà dans Artifact Registry
gcloud run deploy mon-service \
  --image europe-west9-docker.pkg.dev/mon-projet/mon-repo/mon-app:v1.0 \
  --region europe-west9 \
  --platform managed \
  --allow-unauthenticated \
  --port 8080 \
  --memory 512Mi \
  --cpu 1 \
  --min-instances 0 \
  --max-instances 10

# Méthode 2 : depuis les sources (Cloud Buildpacks - sans Dockerfile)
gcloud run deploy mon-service \
  --source . \
  --region europe-west9

# Voir l'URL du service
gcloud run services describe mon-service \
  --region europe-west9 \
  --format 'value(status.url)'

# Lister les révisions
gcloud run revisions list --service mon-service --region europe-west9

Traffic Splitting (Déploiement Canary)

Cloud Run permet de diviser le trafic entre plusieurs révisions - utile pour les déploiements progressifs :

bash
# Déployer une nouvelle version sans envoyer de trafic
gcloud run deploy mon-service \
  --image europe-west9-docker.pkg.dev/mon-projet/mon-repo/mon-app:v2.0 \
  --region europe-west9 \
  --no-traffic

# Envoyer 10% du trafic sur la v2 (canary)
gcloud run services update-traffic mon-service \
  --region europe-west9 \
  --to-revisions mon-service-v2=10,mon-service-v1=90

# Si la v2 est satisfaisante, basculer tout le trafic
gcloud run services update-traffic mon-service \
  --region europe-west9 \
  --to-latest

Variables d'Environnement et Secrets

bash
# Variables d'environnement directes
gcloud run services update mon-service \
  --region europe-west9 \
  --set-env-vars NODE_ENV=production,LOG_LEVEL=info

# Secrets depuis Secret Manager (recommandé pour les données sensibles)
gcloud secrets create db-password --data-file password.txt

gcloud run services update mon-service \
  --region europe-west9 \
  --set-secrets DB_PASSWORD=db-password:latest

🏗️ Cloud Build et Artifact Registry

Artifact Registry

Artifact Registry est le gestionnaire d'artefacts de GCP. Il remplace l'ancien Container Registry et supporte Docker, Maven, npm, Python, etc.

bash
# Créer un repository Docker
gcloud artifacts repositories create mon-repo \
  --repository-format docker \
  --location europe-west9 \
  --description "Images Docker de production"

# Authentifier Docker
gcloud auth configure-docker europe-west9-docker.pkg.dev

# Tagger et pousser une image
docker tag mon-app:v1.0 europe-west9-docker.pkg.dev/mon-projet/mon-repo/mon-app:v1.0
docker push europe-west9-docker.pkg.dev/mon-projet/mon-repo/mon-app:v1.0

Cloud Build

Cloud Build est le service CI/CD serverless de GCP. Il s'exécute sur des workers managés et se déclenche sur des événements Git.

Le fichier cloudbuild.yaml décrit les étapes du pipeline :

yaml
# cloudbuild.yaml
substitutions:
  _IMAGE_NAME: europe-west9-docker.pkg.dev/${PROJECT_ID}/mon-repo/mon-app

steps:
  # Étape 1 : Tests
  - name: 'node:20'
    entrypoint: 'npm'
    args: ['ci']
    id: 'install'

  - name: 'node:20'
    entrypoint: 'npm'
    args: ['test']
    id: 'test'
    waitFor: ['install']

  # Étape 2 : Build de l'image Docker
  - name: 'gcr.io/cloud-builders/docker'
    args:
      - build
      - '-t'
      - '${_IMAGE_NAME}:${SHORT_SHA}'
      - '-t'
      - '${_IMAGE_NAME}:latest'
      - '.'
    id: 'build'
    waitFor: ['test']

  # Étape 3 : Push vers Artifact Registry
  - name: 'gcr.io/cloud-builders/docker'
    args: ['push', '--all-tags', '${_IMAGE_NAME}']
    id: 'push'
    waitFor: ['build']

  # Étape 4 : Déploiement Cloud Run
  - name: 'gcr.io/google.com/cloudsdktool/cloud-sdk'
    entrypoint: gcloud
    args:
      - run
      - deploy
      - mon-service
      - '--image=${_IMAGE_NAME}:${SHORT_SHA}'
      - '--region=europe-west9'
      - '--platform=managed'
    id: 'deploy'
    waitFor: ['push']

# Tags sur l'image finale
images:
  - '${_IMAGE_NAME}:${SHORT_SHA}'
  - '${_IMAGE_NAME}:latest'

options:
  logging: CLOUD_LOGGING_ONLY
bash
# Créer un déclencheur Cloud Build sur push vers main
gcloud builds triggers create github \
  --repo-name mon-repo-github \
  --repo-owner mon-organisation \
  --branch-pattern '^main$' \
  --build-config cloudbuild.yaml \
  --name trigger-main

# Lancer un build manuellement
gcloud builds submit \
  --config cloudbuild.yaml \
  --substitutions SHORT_SHA=local .

# Suivre les logs d'un build
gcloud builds log BUILD_ID --stream

☸️ GKE - Google Kubernetes Engine

Standard vs Autopilot

CritèreGKE StandardGKE Autopilot
Gestion des noeudsVous gérez les node poolsGoogle gère entièrement
FlexibilitéTotale (OS, GPU, taille...)Limitée aux types de charge standardisés
FacturationPar noeud (VM)Par pod (CPU/mémoire réservés)
SécuritéÀ configurerRenforcée par défaut
Cas d'usageWorkloads spéciaux, contrôle totalLa plupart des applications

Créer un Cluster GKE

bash
# Cluster Autopilot (recommandé pour débuter)
gcloud container clusters create-auto mon-cluster \
  --region europe-west9

# Cluster Standard
gcloud container clusters create mon-cluster-standard \
  --num-nodes 3 \
  --machine-type e2-standard-2 \
  --zone europe-west9-a

# Configurer kubectl
gcloud container clusters get-credentials mon-cluster \
  --region europe-west9

# Vérifier les noeuds (Autopilot n'en affiche pas jusqu'au premier déploiement)
kubectl get nodes

# Supprimer le cluster (important : stoppe la facturation)
gcloud container clusters delete mon-cluster --region europe-west9

📌 Points Clés

  • VPC personnalisé en production : contrôle total sur les plages IP et les sous-réseaux
  • Cloud SQL Auth Proxy = connexion sécurisée sans exposer la base sur Internet
  • Cloud Run : scale-to-zero automatique, idéal pour les charges variables ; le traffic splitting permet les déploiements canary
  • cloudbuild.yaml décrit votre pipeline en étapes parallélisables ; les substitutions injectent les variables
  • GKE Autopilot = Kubernetes sans gérer de VMs, facturation à la granularité du pod

📚 Ressources

  • Documentation VPC
  • Documentation Cloud SQL
  • Documentation Cloud Run
  • Documentation Cloud Build
  • Documentation GKE
  • Cloud Run Pricing

🚀 Prochaines étapes

Vous maîtrisez les services intermédiaires de GCP. Passez au niveau avancé :

  1. GCP Avancé : GKE Autopilot, BigQuery et architecture multi-projet - orchestration avancée, analytics et architecture d'entreprise

Exercices Pratiques

3 exercices pour mettre en pratique

01

02 - Déployer une application containerisée sur Cloud Run

45 minutesIntermédiaire
02

06 - Base de données managée avec Cloud SQL

40 minutesIntermédiaire
03

07 - Pipeline CI/CD avec Cloud Build

40 minutesIntermédiaire
Retour aux modules

Sur cette page

  • 🎯 Objectifs
  • 📋 Prérequis
  • 🌐 VPC Personnalisé
  • Mode Auto vs Mode Personnalisé
  • Créer un VPC Personnalisé
  • Cloud NAT - Accès Internet Sortant pour les VMs Privées
  • VPC Peering
  • 🗄️ Cloud SQL
  • Concept
  • Créer une Instance Cloud SQL
  • Cloud SQL Auth Proxy - Connexion Sécurisée
  • Haute Disponibilité et Réplicas
  • ⚡ Cloud Run
  • Concept
  • Déployer sur Cloud Run
  • Traffic Splitting (Déploiement Canary)
  • Variables d'Environnement et Secrets
  • 🏗️ Cloud Build et Artifact Registry
  • Artifact Registry
  • Cloud Build
  • ☸️ GKE - Google Kubernetes Engine
  • Standard vs Autopilot
  • Créer un Cluster GKE
  • 📌 Points Clés
  • 📚 Ressources
  • 🚀 Prochaines étapes