Compute Engine, Cloud Run, GKE, Cloud Functions

Compute Engine : Machines Virtuelles à la Demande

Compute Engine est le service IaaS de Google Cloud permettant de créer et gérer des machines virtuelles. Il offre une flexibilité totale sur la configuration matérielle, l'OS et les applications installées.

• Types de machines : Prédéfinies (n1, n2, e2) ou personnalisées
• Images : Linux, Windows, ou images personnalisées
• Disques persistants : Standard, SSD, ou SSD local
• Mise à l'échelle : Instance groups avec autoscaling

Exemple pratique - Création d'une instance web :

gcloud compute instances create web-server \
    --image-family=ubuntu-2004-lts \
    --image-project=ubuntu-os-cloud \
    --machine-type=e2-medium \
    --zone=us-central1-a \
    --tags=http-server \
    --metadata=startup-script='#!/bin/bash
        apt-get update
        apt-get install -y apache2
        systemctl start apache2'

Cloud Run : Conteneurs Serverless

Cloud Run permet d'exécuter des conteneurs stateless de manière serverless. Il gère automatiquement la mise à l'échelle, y compris jusqu'à zéro instance.

• Facturation : Pay-per-use (CPU, mémoire, requêtes)
• Concurrence : Jusqu'à 1000 requêtes simultanées par instance
• Intégration : Cloud Build, Container Registry, Eventarc
• Révisions : Gestion des versions avec traffic splitting

Scénario - Déploiement d'une API Node.js :

# Build et push de l'image
docker build -t gcr.io/PROJECT_ID/api-service .
docker push gcr.io/PROJECT_ID/api-service

# Déploiement sur Cloud Run
gcloud run deploy api-service \
    --image=gcr.io/PROJECT_ID/api-service \
    --platform=managed \
    --region=us-central1 \
    --allow-unauthenticated \
    --set-env-vars="DB_HOST=127.0.0.1,DB_PORT=5432"

Google Kubernetes Engine (GKE)

GKE est le service Kubernetes managé de Google Cloud. Il simplifie le déploiement, la gestion et la mise à l'échelle d'applications conteneurisées.

• Modes de cluster : Standard (gestion des nœuds) vs Autopilot (fully managed)
• Node pools : Groupes de nœuds avec configurations identiques
• Mise à l'échelle : Cluster Autoscaler et Horizontal Pod Autoscaler
• Sécurité : Workload Identity, Binary Authorization, Pod Security Standards

Exemple - Création d'un cluster GKE :

# Création du cluster
gcloud container clusters create production-cluster \
    --num-nodes=3 \
    --machine-type=e2-standard-4 \
    --zone=us-central1-a \
    --enable-autoscaling \
    --min-nodes=1 \
    --max-nodes=10 \
    --enable-autorepair \
    --enable-autoupgrade

# Configuration de kubectl
gcloud container clusters get-credentials production-cluster --zone=us-central1-a

# Déploiement d'une application
kubectl create deployment nginx --image=nginx:1.21
kubectl expose deployment nginx --type=LoadBalancer --port=80

Cloud Functions : Fonctions Serverless

Cloud Functions exécute du code en réponse à des événements sans gestion de serveur. Idéal pour des tâches courtes et événementielles.

• Déclencheurs : HTTP, Cloud Storage, Pub/Sub, Firestore
• Runtimes : Node.js, Python, Go, Java, .NET, Ruby, PHP
• Limites : 9 minutes d'exécution max, 8GB de mémoire
• Génération 2 : Basé sur Cloud Run, performances améliorées

Scénario - Traitement d'images uploadées :

import functions_framework
from google.cloud import storage
from PIL import Image
import io

@functions_framework.cloud_event
def process_image(cloud_event):
    # Récupération des données de l'événement
    data = cloud_event.data
    bucket_name = data['bucket']
    file_name = data['name']
    
    # Traitement uniquement des images
    if not file_name.lower().endswith(('.png', '.jpg', '.jpeg')):
        return
    
    # Création du thumbnail
    storage_client = storage.Client()
    bucket = storage_client.bucket(bucket_name)
    blob = bucket.blob(file_name)
    
    # Téléchargement et redimensionnement
    image_data = blob.download_as_bytes()
    image = Image.open(io.BytesIO(image_data))
    image.thumbnail((200, 200))
    
    # Upload du thumbnail
    thumbnail_blob = bucket.blob(f"thumbnails/{file_name}")
    thumbnail_buffer = io.BytesIO()
    image.save(thumbnail_buffer, format='JPEG')
    thumbnail_blob.upload_from_string(thumbnail_buffer.getvalue())

Déploiement de la fonction :

gcloud functions deploy process-image \
    --gen2 \
    --runtime=python311 \
    --region=us-central1 \
    --source=. \
    --entry-point=process_image \
    --trigger-bucket=my-upload-bucket \
    --memory=512MB \
    --timeout=300s

Comparaison et Choix du Service

Le choix entre ces services dépend de vos besoins spécifiques :

• Compute Engine : Applications legacy, contrôle total, charges persistantes
• Cloud Run : APIs stateless, microservices, scaling rapide
• GKE : Applications complexes, orchestration, écosystème Kubernetes
• Cloud Functions : Traitement événementiel, intégrations, tâches courtes

Quiz de Révision

1. Quel service est le plus approprié pour une application web qui doit gérer des pics de trafic imprévisibles et redescendre à zéro durant les périodes creuses ?

2. Quelle commande permet de créer un cluster GKE avec autoscaling activé ?

3. Quelle est la durée maximale d'exécution d'une Cloud Function de 2ème génération ?