StreamBox

# StreamBox en local : docker compose up --build, puis http://localhost:8080
name: streambox-local

services:
  # Génère les vidéos de test une seule fois, dans ./bucket/media.
  medias:
    image: alpine:3.20
    command: ["sh", "/scripts/medias.sh"]
    volumes:
      - ./local/medias.sh:/scripts/medias.sh:ro
      - ./bucket:/bucket

  # Le code à déployer sur Cloud Run.
  catalogue:
    build: ./catalogue
    environment:
      APP_VERSION: local

  # Joue le rôle du Load Balancer, de Cloud CDN et du bucket.
  edge:
    image: nginx:stable-alpine
    ports:
      - "8080:80"
    volumes:
      - ./local/edge.conf:/etc/nginx/conf.d/default.conf:ro
      - ./bucket:/bucket:ro
    depends_on:
      catalogue:
        condition: service_started
      medias:
        condition: service_completed_successfully

// API catalogue et interface de démonstration pour StreamBox.
// Node.js 22 ou plus récent, sans dépendance. Écoute sur $PORT (8080 par défaut).
// Sur GCP, ce service tourne sur Cloud Run derrière le Load Balancer : /api/* et la page d'accueil
// arrivent ici, /media/* part vers le backend bucket et Cloud CDN.
import http from 'node:http';
import fs from 'node:fs';
import os from 'node:os';
import { metadata, bloc, blocCloudRun, blocIdentite, enCache } from './gcp.mjs';

const here = new URL('.', import.meta.url);
const catalogue = JSON.parse(fs.readFileSync(new URL('catalogue.json', here), 'utf8'));
const version = process.env.APP_VERSION || 'dev';
const assets = {
  '/': ['index.html', 'text/html; charset=utf-8'],
  '/app.js': ['app.js', 'text/javascript; charset=utf-8'],
  '/kit.css': ['kit.css', 'text/css; charset=utf-8'],
  '/carte.js': ['carte.js', 'text/javascript; charset=utf-8'],
};

// Sur Cloud Run, K_SERVICE et K_REVISION sont fournis, et le serveur de métadonnées donne la région.
const plateforme = process.env.K_SERVICE ? 'Cloud Run' : 'local';
const region = (await metadata('instance/region'))?.split('/').pop() || 'local';
const instance = process.env.K_REVISION || os.hostname();

// La part de la carte que le serveur peut établir seul. Le navigateur ajoute ensuite ce qu'il observe
// lui-même : le passage par le Load Balancer, le routage des médias et le cache.
const deploiement = enCache(async () => ({
  plateforme,
  blocs: [
    blocCloudRun('API sur Cloud Run'),
    await blocIdentite(),
    bloc('obs', 'Logging et Monitoring', 'manuel', 'logs du Load Balancer, dashboard et alertes : invisibles depuis l’application, montrez-les dans la console'),
  ],
}));

function send(res, status, body, type = 'application/json; charset=utf-8') {
  res.writeHead(status, { 'Content-Type': type, 'Cache-Control': 'no-store' });
  res.end(type.startsWith('application/json') ? JSON.stringify(body) : body);
}

const server = http.createServer((req, res) => {
  const { pathname } = new URL(req.url, 'http://localhost');
  // Une ligne JSON par requête : Cloud Logging la lit comme un journal structuré.
  console.log(JSON.stringify({ severity: 'INFO', message: `${req.method} ${pathname}` }));

  if (req.method !== 'GET' && req.method !== 'HEAD') return send(res, 405, { erreur: 'méthode non autorisée' });
  if (pathname === '/healthz') return send(res, 200, { statut: 'ok', version });
  if (pathname === '/api/catalogue') return send(res, 200, { version, plateforme, region, instance, videos: catalogue });
  if (pathname === '/api/deploiement') return deploiement().then((carte) => send(res, 200, carte));

  const route = pathname.match(/^\/api\/catalogue\/([a-z0-9-]+)$/);
  if (route) {
    const video = catalogue.find((item) => item.id === route[1]);
    return video ? send(res, 200, video) : send(res, 404, { erreur: 'vidéo inconnue' });
  }
  if (assets[pathname]) {
    const [file, type] = assets[pathname];
    return send(res, 200, fs.readFileSync(new URL(`public/${file}`, here)), type);
  }
  if (pathname.startsWith('/media/')) {
    // Si une vidéo arrive ici, c'est que le routage vers le bucket ne s'est pas fait.
    return send(res, 404, { erreur: 'les médias ne sont pas servis par Cloud Run : passez par le Load Balancer', chemin: pathname });
  }
  send(res, 404, { erreur: 'route inconnue', chemin: pathname });
});

server.listen(Number(process.env.PORT || 8080), () => {
  console.log(JSON.stringify({ severity: 'INFO', message: `catalogue prêt sur le port ${server.address().port}, version ${version}` }));
});
process.on('SIGTERM', () => server.close(() => process.exit(0)));

# Émulation locale de l'Application Load Balancer, de Cloud CDN et du bucket.
# Ce fichier ne se déploie jamais : sur GCP, ces rôles reviennent à l'URL map,
# au backend bucket avec Cloud CDN et à Cloud Storage.

proxy_cache_path /var/cache/nginx/cdn levels=1:2 keys_zone=cdn:10m max_size=200m inactive=10m use_temp_path=off;

# Le faux bucket Cloud Storage : il sert les objets tels qu'ils sont rangés dans ./bucket.
# Le débit est volontairement bridé pour que la différence avec le cache se voie.
server {
    listen 8081;
    root /bucket;
    location /media/ {
        limit_rate 256k;
        add_header Cache-Control "public, max-age=60";
    }
}

# Le point d'entrée : l'équivalent de l'URL map.
server {
    listen 80;

    # /media/* : backend bucket derrière le CDN.
    location /media/ {
        proxy_pass http://127.0.0.1:8081;
        proxy_cache cdn;
        proxy_cache_key $uri;
        proxy_cache_valid 200 60s;
        add_header X-Cache-Status $upstream_cache_status always;
    }

    # Tout le reste, API et page d'accueil : backend service vers Cloud Run.
    location / {
        proxy_pass http://catalogue:8080;
        proxy_set_header Host $host;
    }
}

# StreamBox, kit de démarrage

Une petite API catalogue avec son interface, prête à tourner sur Cloud Run, et de quoi tout faire fonctionner sur votre machine avant de toucher à GCP. Le kit est un démonstrateur : il sert à vérifier votre infrastructure, il n’est pas évalué.

## Ce qu’il contient

```text
catalogue/            Le code à déployer sur Cloud Run
  server.mjs          API (/api/catalogue) et page d’accueil, sans dépendance
  catalogue.json      Les trois vidéos de démonstration
  public/             Interface : lecteur, chemin de l’API, chemin des médias
  Dockerfile
local/                Ce qui remplace GCP en local, jamais déployé
  edge.conf           nginx dans le rôle du Load Balancer, de Cloud CDN et du bucket
  medias.sh           Fabrique les vidéos de test avec ffmpeg
docker-compose.yml
```

## Lancer en local

Il faut Docker avec Compose. Le premier lancement télécharge les images et fabrique les vidéos, ce qui prend une minute.

```sh
docker compose up --build
```

Ouvrez ensuite http://localhost:8080. Cliquez sur « Télécharger la vidéo » plusieurs fois : le premier essai est un `MISS`, les suivants des `HIT`, et le temps chute. Les vidéos sont rangées dans `bucket/media/`, exactement comme les objets du futur bucket.

| Rôle | En local | Sur GCP |
| --- | --- | --- |
| Point d’entrée et routage | nginx, `local/edge.conf` | Application Load Balancer et URL map |
| Cache | cache nginx et en-tête `X-Cache-Status` | Cloud CDN sur le backend bucket |
| Stockage des vidéos | dossier `bucket/media` | Bucket Cloud Storage, objets `media/...` |
| API et interface | conteneur `catalogue` | Cloud Run, derrière un serverless NEG |

Le cache local n’est qu’une imitation : il montre le principe, pas le comportement exact de Cloud CDN.

## Passer sur GCP

Le code de `catalogue/` se déploie tel quel. Ce qui l’entoure, vous l’écrivez en Terraform : c’est le cœur du TP.

1. Construire et pousser l’image, puis noter son digest :

```sh
REGION=europe-west9
PROJECT_ID=votre-projet
IMAGE="$REGION-docker.pkg.dev/$PROJECT_ID/streambox/catalogue:v1"
gcloud builds submit --tag "$IMAGE" catalogue
gcloud artifacts docker images describe "$IMAGE" --format='value(image_summary.digest)'
```

2. Copier les vidéos dans le bucket, en gardant le préfixe `media/` :

```sh
gcloud storage cp bucket/media/*.mp4 gs://VOTRE_BUCKET/media/
```

3. Dans votre URL map, `/media/*` va vers le backend bucket. L’API et la page d’accueil vont vers le backend du catalogue : faites-en la route par défaut, ou servez la page autrement et justifiez ce choix.

4. Pour que l’interface affiche le statut du cache comme en local, ajoutez au backend bucket l’en-tête de réponse personnalisé `X-Cache-Status: {cdn_cache_status}`. Sans lui, la page se rabat sur l’en-tête `Age`.

Ouvert directement par son URL `run.app`, le service affiche le catalogue mais pas les vidéos : c’est normal, elles ne passent pas par Cloud Run.

## Variables

| Variable | Rôle |
| --- | --- |
| `PORT` | Port d’écoute, fourni par Cloud Run (8080 par défaut). |
| `APP_VERSION` | Version affichée dans l’interface, pratique pour prouver quelle révision répond. |

## La carte du déploiement

En haut de l’interface, l’architecture cible est dessinée bloc par bloc. Chaque bloc s’allume selon ce que l’application constate elle-même, avec la preuve affichée dessous :

| Couleur | Sens |
| --- | --- |
| vert, « prouvé » | l’application l’a vérifié elle-même |
| orange, « à revoir » | ça fonctionne, mais c’est un anti-pattern connu |
| rouge, « en échec » | l’application a essayé et ça ne marche pas |
| pointillés, « pas encore détecté » | rien de visible pour l’instant |
| gris, « à prouver vous-même » | invisible depuis l’application : montrez-le dans la console |
| violet, « simulé en local » | l’équivalent local, en attendant le déploiement |

La carte constate, elle ne note pas : un bloc vert ne dit pas que votre choix est le bon, seulement qu’il est en place.

Pour StreamBox, le serveur vérifie Cloud Run et son identité ; le navigateur vérifie le passage par le Load Balancer, la route des médias, le cache et l’origine Cloud Storage. Aucun droit supplémentaire n’est nécessaire.

flowchart TB
 U["Spectateur"] --> LB["Application Load Balancer externe
URL map"]
 LB -->|"/api/*"| NEG["Serverless NEG"]
 NEG --> RUN["Cloud Run
API catalogue"]
 LB -->|"/media/*"| CDN["Cloud CDN
backend bucket"]
 CDN -->|"cache miss"| GCS["Cloud Storage
objets vidéo"]
 SA["Identité de l’API
moindre privilège"] -.-> RUN
 LB -.-> OBS["Logging et Monitoring"]
 RUN -.-> OBS

• L’hypothèse et le résultat attendu.
• Le périmètre, la charge, l’heure de début et l’heure de fin.
• Ce que vous avez observé avant, pendant et après, et l’impact sur le parcours utilisateur.
• Les pistes de diagnostic, les vérifications faites et la cause retenue.
• La correction, la preuve du retour au service et les limites de votre conclusion.

Cette liste est un point de départ et votre architecture demandera d’autres ressources. Chaque lien ouvre la page du provider Google, avec ses arguments et ses exemples.

google_project_service active les API nécessaires, et google_service_account crée une identité dédiée. Donnez à chaque identité les permissions dont elle a besoin, au bon niveau, plutôt qu’un rôle Owner ou Editor sur tout le projet.

Pour l’observabilité, il vous faudra un dashboard, une politique d’alerte et un canal de notification. Vérifiez que la notification arrive réellement.

terraform {
  required_providers {
    google = {
      source  = "hashicorp/google"
      version = "8.6.0"
    }
  }
}

provider "google" {
  project = var.project_id
  region  = var.region
}

Cette version est un exemple, vérifié lors de la préparation du support. Contrôlez la dernière version publiée avant le TP. Déclarez vos variables et commitez .terraform.lock.hcl. Si votre projet utilise déjà une autre version, n’en changez pas sans relire le plan et les notes de migration. En local, utilisez ADC ; en CI, une identité fédérée. Jamais de clé JSON dans le code.

Documentation du provider Google