MediRdv

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

services:
  # Joue le rôle de Cloud SQL. Aucun port n'est publié : comme une instance sans IP publique,
  # la base n'est joignable que depuis le réseau interne, pas depuis votre machine.
  base:
    image: postgres:16-alpine
    environment:
      POSTGRES_DB: medirdv
      POSTGRES_USER: medirdv_app
      POSTGRES_PASSWORD_FILE: /run/medirdv/db-password
    configs:
      - source: db-password
        target: /run/medirdv/db-password
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U medirdv_app -d medirdv"]
      interval: 3s
      retries: 20

  # Le code à déployer sur Cloud Run.
  api:
    build: ./api
    ports:
      - "8080:8080"
    environment:
      APP_VERSION: local
      DB_HOST: base
      DB_NAME: medirdv
      DB_USER: medirdv_app
      # Sur Cloud Run, le secret Secret Manager peut être monté comme fichier de la même façon.
      DB_PASSWORD_FILE: /run/medirdv/db-password
      POOL_MAX: "5"
    configs:
      - source: db-password
        target: /run/medirdv/db-password
    depends_on:
      base:
        condition: service_healthy

# Remplace Secret Manager en local. Ce mot de passe ne sert qu'ici.
configs:
  db-password:
    content: medirdv-local-uniquement

// Accès aux données de MediRdv. Trois modes, choisis par les variables d'environnement :
//   connecteur  INSTANCE_CONNECTION_NAME défini : Cloud SQL en IP privée via le connecteur Node.js
//               (l'identité du service a besoin de roles/cloudsql.client, l'API Cloud SQL Admin doit être active)
//   direct      DB_HOST défini : connexion PostgreSQL classique, utilisée par le docker compose local
//   memoire     DB_MODE=memoire : aucune base, pour essayer l'interface sans rien installer
import fs from 'node:fs';
import { appelGoogle } from './gcp.mjs';

const fictifs = [
  ['Patient fictif 1', 'Dr Exemple', 1, 9],
  ['Patient fictif 2', 'Dr Exemple', 1, 10],
  ['Patient fictif 3', 'Dr Démo', 2, 14],
  ['Patient fictif 4', 'Dr Démo', 3, 11],
  ['Patient fictif 5', 'Dr Exemple', 4, 16],
];
const fictif = ([patient, praticien, jours, heure]) => {
  const debut = new Date();
  debut.setDate(debut.getDate() + jours);
  debut.setHours(heure, 0, 0, 0);
  return { patient, praticien, debut: debut.toISOString() };
};

// Le mot de passe a trois sources possibles :
//   DB_PASSWORD_SECRET  le service lit lui-même la version du secret dans Secret Manager, avec son identité
//   DB_PASSWORD_FILE    un fichier : Cloud Run sait y monter un secret, le compose local fait de même
//   DB_PASSWORD         une variable, injectée par Cloud Run depuis Secret Manager ou écrite en clair
export function sourceMotDePasse(env = process.env) {
  if (env.DB_PASSWORD_SECRET) return 'secret';
  if (env.DB_PASSWORD_FILE) return 'fichier';
  if (env.DB_PASSWORD) return 'variable';
  return 'aucune';
}

export async function lireSecret(nom = process.env.DB_PASSWORD_SECRET) {
  const { status, body } = await appelGoogle(`https://secretmanager.googleapis.com/v1/${nom}:access`);
  if (status !== 200) throw Object.assign(new Error(`lecture du secret refusée (HTTP ${status || 'hors GCP'})`), { code: status === 403 ? 'PERMISSION_DENIED' : `SECRET_${status}` });
  return Buffer.from(body.payload.data, 'base64').toString('utf8').trim();
}

async function motDePasse() {
  const source = sourceMotDePasse();
  if (source === 'secret') return lireSecret();
  if (source === 'fichier') return fs.readFileSync(process.env.DB_PASSWORD_FILE, 'utf8').trim();
  return process.env.DB_PASSWORD;
}

export function choisirMode(env = process.env) {
  if (env.DB_MODE === 'memoire') return 'memoire';
  if (env.INSTANCE_CONNECTION_NAME) return 'connecteur';
  if (env.DB_HOST) return 'direct';
  return 'non configuré';
}

function stockageMemoire() {
  let id = 0;
  const rendezVous = fictifs.map(fictif).map((rdv) => ({ id: ++id, ...rdv, cree_le: new Date().toISOString() }));
  const reperes = [];
  let derniereEcriture = null;
  const ecrit = () => { derniereEcriture = new Date().toISOString(); };
  return {
    async lister() { return [...rendezVous].sort((a, b) => a.debut.localeCompare(b.debut)); },
    async creer(rdv) { const ligne = { id: ++id, ...rdv, cree_le: new Date().toISOString() }; rendezVous.push(ligne); ecrit(); return ligne; },
    async supprimer(cible) { const i = rendezVous.findIndex((rdv) => rdv.id === cible); if (i >= 0) rendezVous.splice(i, 1); ecrit(); return i >= 0; },
    async poserRepere(note) { const ligne = { id: reperes.length + 1, note, cree_le: new Date().toISOString() }; reperes.unshift(ligne); ecrit(); return ligne; },
    async reperes() { return reperes.slice(0, 20); },
    async limiter(max) { rendezVous.sort((a, b) => b.id - a.id).splice(max); reperes.splice(max); },
    async etat() {
      return { latence_ms: 0, pool: null, compteurs: { rendez_vous: rendezVous.length, reperes: reperes.length }, derniere_ecriture: derniereEcriture };
    },
  };
}

async function stockagePostgres(mode) {
  const { default: pg } = await import('pg');
  let options = { host: process.env.DB_HOST, port: Number(process.env.DB_PORT || 5432) };
  let connector = null;
  if (mode === 'connecteur') {
    const { Connector } = await import('@google-cloud/cloud-sql-connector');
    connector = new Connector();
    options = await connector.getOptions({ instanceConnectionName: process.env.INSTANCE_CONNECTION_NAME, ipType: 'PRIVATE' });
  }
  const max = Number(process.env.POOL_MAX || 5);
  const pool = new pg.Pool({
    ...options,
    user: process.env.DB_USER,
    // Une fonction plutôt qu'une valeur : le mot de passe est relu à chaque nouvelle connexion.
    password: motDePasse,
    database: process.env.DB_NAME,
    max,
    connectionTimeoutMillis: 5000,
  });
  // Une connexion inactive coupée (bascule, redémarrage) ne doit pas arrêter le processus.
  pool.on('error', (error) => console.log(JSON.stringify({ severity: 'ERROR', message: error.message, code: error.code })));

  try {
    await pool.query(`CREATE TABLE IF NOT EXISTS rendez_vous (
      id SERIAL PRIMARY KEY, patient TEXT NOT NULL, praticien TEXT NOT NULL,
      debut TIMESTAMPTZ NOT NULL, cree_le TIMESTAMPTZ NOT NULL DEFAULT now())`);
    await pool.query(`CREATE TABLE IF NOT EXISTS reperes (
      id SERIAL PRIMARY KEY, note TEXT NOT NULL, cree_le TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp())`);
    const { rows } = await pool.query('SELECT count(*)::int AS n FROM rendez_vous');
    if (rows[0].n === 0 && process.env.SEED_DEMO !== 'false') {
      for (const rdv of fictifs.map(fictif)) {
        await pool.query('INSERT INTO rendez_vous (patient, praticien, debut) VALUES ($1, $2, $3)', [rdv.patient, rdv.praticien, rdv.debut]);
      }
    }
  } catch (error) {
    await pool.end().catch(() => {});
    connector?.close();
    throw error;
  }

  return {
    async lister() {
      return (await pool.query('SELECT id, patient, praticien, debut, cree_le FROM rendez_vous ORDER BY debut LIMIT 100')).rows;
    },
    async creer({ patient, praticien, debut }) {
      const sql = 'INSERT INTO rendez_vous (patient, praticien, debut) VALUES ($1, $2, $3) RETURNING id, patient, praticien, debut, cree_le';
      return (await pool.query(sql, [patient, praticien, debut])).rows[0];
    },
    async supprimer(id) {
      return (await pool.query('DELETE FROM rendez_vous WHERE id = $1', [id])).rowCount > 0;
    },
    async poserRepere(note) {
      return (await pool.query('INSERT INTO reperes (note) VALUES ($1) RETURNING id, note, cree_le', [note])).rows[0];
    },
    async reperes() {
      return (await pool.query('SELECT id, note, cree_le FROM reperes ORDER BY id DESC LIMIT 20')).rows;
    },
    // Démo publique : seules les lignes les plus récentes sont gardées.
    async limiter(max) {
      await pool.query('DELETE FROM rendez_vous WHERE id NOT IN (SELECT id FROM rendez_vous ORDER BY id DESC LIMIT $1)', [max]);
      await pool.query('DELETE FROM reperes WHERE id NOT IN (SELECT id FROM reperes ORDER BY id DESC LIMIT $1)', [max]);
    },
    async etat() {
      const debut = performance.now();
      const { rows: [ligne] } = await pool.query(`SELECT
        (SELECT count(*)::int FROM rendez_vous) AS rendez_vous,
        (SELECT count(*)::int FROM reperes) AS reperes,
        greatest((SELECT max(cree_le) FROM rendez_vous), (SELECT max(cree_le) FROM reperes)) AS derniere_ecriture`);
      return {
        latence_ms: Math.round(performance.now() - debut),
        pool: { total: pool.totalCount, inactives: pool.idleCount, en_attente: pool.waitingCount, max },
        compteurs: { rendez_vous: ligne.rendez_vous, reperes: ligne.reperes },
        derniere_ecriture: ligne.derniere_ecriture,
      };
    },
    async fermer() {
      await pool.end();
      connector?.close();
    },
  };
}

// La connexion s'ouvre à la première demande et se retente ensuite : le service démarre même si la
// base est injoignable, et l'erreur exacte apparaît dans les journaux et dans l'interface.
let enCours = null;
export function stockage() {
  const mode = choisirMode();
  enCours ??= (async () => {
    if (mode === 'memoire') return stockageMemoire();
    if (mode === 'non configuré') throw Object.assign(new Error('définissez DB_HOST, INSTANCE_CONNECTION_NAME ou DB_MODE=memoire'), { code: 'CONFIG' });
    for (const nom of ['DB_NAME', 'DB_USER']) {
      if (!process.env[nom]) throw Object.assign(new Error(`variable ${nom} manquante`), { code: 'CONFIG' });
    }
    return stockagePostgres(mode);
  })().catch((error) => {
    enCours = null;
    throw error;
  });
  return enCours;
}

// API et agenda de démonstration pour MediRdv, à déployer sur Cloud Run.
// Données fictives uniquement. La configuration de la base est décrite dans stockage.mjs.
import http from 'node:http';
import fs from 'node:fs';
import os from 'node:os';
import { stockage, choisirMode } from './stockage.mjs';
import { carteDeploiement } from './deploiement.mjs';

const here = new URL('.', import.meta.url);
const version = process.env.APP_VERSION || 'dev';
const plateforme = process.env.K_SERVICE ? 'Cloud Run' : 'local';
const instance = process.env.K_REVISION || os.hostname();
// Démo publique : les noms sont générés par le serveur et le nombre de lignes est plafonné.
const demoPublique = process.env.DEMO_PUBLIQUE === 'true';
const praticiens = ['Dr Exemple', 'Dr Démo'];
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'],
};

// Chaque code d'erreur est rattaché à la couche qu'il faut vérifier en premier.
function couche(code = '') {
  if (['ETIMEDOUT', 'ECONNREFUSED', 'ENOTFOUND', 'EHOSTUNREACH', 'ECONNRESET'].includes(code)) return 'réseau';
  if (['28P01', '28000'].includes(code)) return 'authentification PostgreSQL';
  if (code === '3D000') return 'base de données absente';
  if (code === 'CONFIG') return 'configuration du service';
  if (/PERMISSION|403|401/.test(code)) return 'IAM';
  return 'à diagnostiquer dans les journaux';
}

function log(severity, message, extra = {}) {
  console.log(JSON.stringify({ severity, message, ...extra }));
}

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);
}

// Le détail de l'erreur reste dans les journaux ; le client ne reçoit que son code et la couche à vérifier.
function indisponible(res, error) {
  const code = String(error.code || error.status || 'INCONNU');
  log('ERROR', error.message, { code });
  send(res, 503, { statut: 'indisponible', code, couche: couche(code) });
}

async function lireJson(req) {
  let body = '';
  for await (const chunk of req) {
    body += chunk;
    if (body.length > 10_000) throw Object.assign(new Error('requête trop longue'), { http: 413 });
  }
  try {
    return JSON.parse(body || '{}');
  } catch {
    throw Object.assign(new Error('JSON invalide'), { http: 400 });
  }
}

const texte = (value) => typeof value === 'string' && value.trim().length > 0 && value.length < 200;

const server = http.createServer(async (req, res) => {
  const { pathname } = new URL(req.url, 'http://localhost');
  try {
    if (req.method === 'GET' && assets[pathname]) {
      const [file, type] = assets[pathname];
      return send(res, 200, fs.readFileSync(new URL(`public/${file}`, here)), type);
    }
    if (pathname === '/healthz') return send(res, 200, { statut: 'ok' });

    if (pathname === '/readyz' || pathname === '/api/etat') {
      const base = { plateforme, instance, version, mode: choisirMode(), demo_publique: demoPublique, heure_serveur: new Date().toISOString() };
      try {
        const etat = await (await stockage()).etat();
        return send(res, 200, { ...base, base: { statut: 'ok', ...etat } });
      } catch (error) {
        const code = String(error.code || 'INCONNU');
        log('ERROR', error.message, { code });
        return send(res, pathname === '/readyz' ? 503 : 200, { ...base, base: { statut: 'indisponible', code, couche: couche(code) } });
      }
    }

    if (pathname === '/api/deploiement') return send(res, 200, await carteDeploiement());

    if (pathname === '/api/rendez-vous' && req.method === 'GET') {
      return send(res, 200, await (await stockage()).lister());
    }
    if (pathname === '/api/rendez-vous' && req.method === 'POST') {
      let { patient, praticien, debut } = await lireJson(req);
      if (demoPublique) {
        // Aucune saisie libre en démo publique : personne ne peut y laisser une vraie donnée.
        patient = `Patient fictif ${100 + Math.floor(Math.random() * 900)}`;
        if (!praticiens.includes(praticien)) praticien = praticiens[0];
      }
      if (![patient, praticien, debut].every(texte) || Number.isNaN(Date.parse(debut))) {
        return send(res, 400, { erreur: 'patient, praticien et debut (date ISO) sont requis' });
      }
      const donnees = await stockage();
      const cree = await donnees.creer({ patient: patient.trim(), praticien: praticien.trim(), debut });
      if (demoPublique) await donnees.limiter(40);
      return send(res, 201, cree);
    }
    const suppression = pathname.match(/^\/api\/rendez-vous\/(\d+)$/);
    if (suppression && req.method === 'DELETE') {
      const supprime = await (await stockage()).supprimer(Number(suppression[1]));
      log('NOTICE', `rendez-vous ${suppression[1]} supprimé`);
      return send(res, supprime ? 200 : 404, { supprime });
    }

    // Les repères horodatés servent à mesurer la perte de données lors d'une restauration.
    if (pathname === '/api/reperes' && req.method === 'GET') {
      return send(res, 200, await (await stockage()).reperes());
    }
    if (pathname === '/api/reperes' && req.method === 'POST') {
      const { note } = await lireJson(req);
      const libelle = texte(note) && !demoPublique ? note.trim() : 'repère';
      const donnees = await stockage();
      const repere = await donnees.poserRepere(libelle);
      if (demoPublique) await donnees.limiter(40);
      return send(res, 201, repere);
    }

    send(res, 404, { erreur: 'route inconnue' });
  } catch (error) {
    if (error.http) return send(res, error.http, { erreur: error.message });
    indisponible(res, error);
  }
});

server.listen(Number(process.env.PORT || 8080), () => log('INFO', `API prête sur le port ${server.address().port}, mode ${choisirMode()}`));
process.on('SIGTERM', () => server.close(async () => {
  try { await (await stockage()).fermer?.(); } catch {}
  process.exit(0);
}));

# MediRdv, kit de démarrage

Une API de rendez-vous fictifs avec son agenda, prête à tourner sur Cloud Run et à rejoindre Cloud SQL en IP privée. L’interface montre aussi ce que voit l’infrastructure : le mode de connexion, la latence de la base, le remplissage du pool et la couche à vérifier quand quelque chose casse. Le kit est un démonstrateur : il sert à vérifier votre infrastructure, il n’est pas évalué.

N’utilisez que des données fictives, ici comme dans le laboratoire.

## Ce qu’il contient

```text
api/                  Le code à déployer sur Cloud Run
  server.mjs          Routes de l’API et de l’interface
  stockage.mjs        Accès à PostgreSQL : connecteur Cloud SQL, connexion directe ou mémoire
  public/             Interface : agenda, état de la connexion, repères horodatés
  package.json, package-lock.json, Dockerfile
docker-compose.yml    PostgreSQL et l’API, pour travailler en local
```

## Lancer en local

Avec Docker :

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

Puis ouvrez http://localhost:8080. La base démarre avec cinq rendez-vous fictifs.

Sans Docker ni base, pour voir l’interface seulement :

```sh
cd api
npm install
npm run demo
```

| Rôle | En local | Sur GCP |
| --- | --- | --- |
| Base de données | conteneur `base`, PostgreSQL sans port publié | Cloud SQL PostgreSQL sans IP publique |
| Chemin vers la base | réseau interne de Docker | Sortie VPC de Cloud Run et Private Service Access |
| Mot de passe | fichier monté depuis une config Compose | secret Secret Manager, monté comme fichier ou injecté en variable |
| API et interface | conteneur `api` | Cloud Run, avec son identité dédiée |

Pour voir l’interface réagir à une panne, arrêtez la base avec `docker compose stop base` : l’agenda affiche le code d’erreur et la couche à vérifier. `docker compose start base` rétablit tout.

## Passer sur GCP

Le code d’`api/` se déploie tel quel. Le réseau, la base, le secret, les identités et le service Cloud Run, c’est vous qui les écrivez en Terraform.

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

Le service attend ces variables sur Cloud Run :

| Variable | Rôle |
| --- | --- |
| `INSTANCE_CONNECTION_NAME` | `projet:region:instance`. Active le connecteur Cloud SQL en IP privée. |
| `DB_NAME`, `DB_USER` | Base et utilisateur applicatif, qui n’est pas un superutilisateur. |
| `DB_PASSWORD_FILE` ou `DB_PASSWORD` | Le mot de passe, fourni par Secret Manager. Jamais dans le code ni dans Terraform en clair. |
| `POOL_MAX` | Connexions maximales par instance, 5 par défaut. À multiplier par le nombre d’instances pour comparer à la limite de la base. |
| `APP_VERSION` | Version affichée dans l’interface. |
| `SEED_DEMO` | Mettre `false` pour ne pas créer les cinq rendez-vous de départ. |

Le connecteur appelle l’API Cloud SQL Admin : elle doit être activée, et l’identité du service a besoin de `roles/cloudsql.client`. Ce rôle ne crée pas de chemin réseau ; sans sortie VPC vers le réseau de la base, la connexion échoue avec une erreur réseau, et l’interface vous le dit.

Si le mot de passe est injecté en variable, il est lu au démarrage de l’instance : retirer l’accès au secret ne se voit qu’avec une nouvelle révision. Monté comme fichier, il est relu à chaque nouvelle connexion.

## Routes

| Route | Rôle |
| --- | --- |
| `GET /` | Interface |
| `GET /healthz` | Le processus tourne |
| `GET /readyz` | La base répond (503 sinon, avec le code d’erreur) |
| `GET /api/etat` | Mode, latence, pool, compteurs, dernière écriture |
| `GET, POST /api/rendez-vous` | Lire et créer des rendez-vous fictifs |
| `DELETE /api/rendez-vous/:id` | Supprimer, pour simuler l’erreur à rattraper |
| `GET, POST /api/reperes` | Repères horodatés pour mesurer le RPO |

## 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 MediRdv, le service lit lui-même :

| Bloc | Comment | Droit nécessaire |
| --- | --- | --- |
| Entrée du service | configuration Cloud Run : ingress et invocation publique ou non | `roles/run.viewer` sur le service, facultatif |
| Identité | serveur de métadonnées | aucun |
| Secret Manager | lecture du secret, si `DB_PASSWORD_SECRET` est utilisé | `roles/secretmanager.secretAccessor`, déjà nécessaire |
| Réseau et base | résultat de la connexion, avec la couche en cause | aucun |
| Exposition, sauvegardes, disponibilité | configuration de l’instance par l’API Cloud SQL Admin | couvert par `roles/cloudsql.client` |

Avec `DB_PASSWORD_SECRET=projects/PROJET/secrets/NOM/versions/latest`, le service lit le mot de passe directement dans Secret Manager à chaque nouvelle connexion : retirez-lui le droit d’accès et le bloc passe au rouge dans les secondes qui suivent.

## Démo publique

Avec `DEMO_PUBLIQUE=true`, le nom du patient est généré par le serveur et le nombre de lignes est plafonné à quarante. C’est le réglage des démos hébergées sur la VM du cours.

flowchart TB
 U["Client de démonstration"] --> IN["Entrée contrôlée
politique à justifier"]
 IN --> RUN["Cloud Run
identité dédiée"]
 RUN --> VPC["Sortie VPC
Direct VPC ou connecteur"]
 VPC --> PSA["Private Service Access"]
 PSA --> SQL["Cloud SQL PostgreSQL
IP privée"]
 RUN -->|"lecture autorisée"| SEC["Secret Manager"]
 SQL --> BK["Sauvegardes et PITR"]
 RUN -.-> MON["Logging et Monitoring"]
 SQL -.-> MON

• 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