Skip to content
Learni
Voir tous les tutoriels
Google Cloud Platform

Comment déployer Cloud Functions Gen2 sur GCP en 2026

18 minEXPERT
TypeScriptServerlessGoogle CloudCloud FunctionsPubSub
Read in English

Introduction

Les Cloud Functions de 2e génération (Gen2) sur Google Cloud Platform (GCP) représentent l'évolution serverless en 2026, avec un runtime Cloud Run sous le capot pour une scalabilité infinie, des cold starts réduits de 40% et une intégration native aux services GCP comme Firestore, Pub/Sub et Secret Manager. Contrairement à la Gen1, Gen2 supporte les VPC natives, les concurrents jusqu'à 1000 par instance et des timeouts jusqu'à 60 minutes, idéal pour les microservices critiques ou les ETL complexes.

Ce tutoriel expert vous guide pas à pas pour déployer des fonctions TypeScript production-ready : d'une API HTTP basique à des triggers event-driven sécurisés. Vous apprendrez à optimiser les coûts (pay-per-request), gérer les IAM granulaire et éviter les pièges comme les cold starts excessifs. À la fin, vous maîtriserez des déploiements zéro-downtime, bookmarkables pour tout architecte cloud. Prêt à scaler sans infrastructure ? (128 mots)

Prérequis

  • Compte GCP avec billing activé et quotas Cloud Functions augmentés (via console).
  • gcloud CLI v450+ installée (gcloud version).
  • Node.js 20.10+ et npm 10+.
  • TypeScript 5.4+ et connaissances avancées en async/await, GCP IAM et VPC.
  • Projet GCP existant ou nouveau (gcloud projects create mon-projet).

Initialiser le projet local

terminal
mkdir cloud-functions-gen2 && cd cloud-functions-gen2
npm init -y
npm install typescript @types/node firebase-admin @google-cloud/pubsub @google-cloud/firestore
npm install -D ts-node @types/firebase-admin
npx tsc --init --target es2022 --module commonjs --outDir dist --rootDir src --strict true --esModuleInterop true
mkdir src

Ce script crée un projet Node.ts structuré avec les libs GCP essentielles (Firestore, PubSub). Le tsconfig.json strict active les checks avancés pour éviter les runtime errors. Notez l'outDir 'dist' pour les builds compatibles Cloud Run.

Structure du projet prête

Votre workspace est maintenant prêt : src/ pour le code source, dist/ pour les builds. Les dépendances incluent Firebase Admin pour Firestore (SDK officiel GCP) et PubSub. Prochainement, nous codons une fonction HTTP qui interroge Firestore, simulant une API users scalable.

Fonction HTTP avec Firestore

src/httpFunction.ts
import { onRequest } from 'firebase-functions/v2/https';
import { initializeApp } from 'firebase-admin/app';
import { getFirestore, Firestore } from 'firebase-admin/firestore';

initializeApp();
const db: Firestore = getFirestore();

export const getUsers = onRequest(
  { memory: '256MiB', maxInstances: 10 },
  async (req, res) => {
    res.set('Access-Control-Allow-Origin', '*');
    if (req.method === 'OPTIONS') {
      res.status(204).send('');
      return;
    }
    try {
      const snapshot = await db.collection('users').limit(10).get();
      const users = snapshot.docs.map(doc => ({ id: doc.id, ...doc.data() }));
      res.json({ users, count: users.length });
    } catch (error) {
      console.error('Erreur Firestore:', error);
      res.status(500).json({ error: 'Interne serveur' });
    }
  }
);

Cette fonction Gen2 utilise firebase-functions/v2/https pour un handler HTTP asynchrone. Elle initialise Firestore une fois, query 10 users avec pagination native, et gère CORS/OPTIONS. Les flags memory et maxInstances optimisent cold starts et concurrency (jusqu'à 100 req/s).

Package.json complet

package.json
{
  "name": "cloud-functions-gen2",
  "version": "1.0.0",
  "main": "dist/index.js",
  "scripts": {
    "build": "tsc",
    "serve": "ts-node src"
  },
  "dependencies": {
    "firebase-admin": "^12.5.0",
    "firebase-functions": "^5.1.1",
    "@google-cloud/pubsub": "^4.0.2",
    "@google-cloud/firestore": "^8.3.1"
  },
  "devDependencies": {
    "@types/node": "^22.7.4",
    "typescript": "^5.6.3",
    "ts-node": "^10.9.2"
  },
  "engines": {
    "node": "20"
  }
}

Ce package.json lock les versions 2026-compatibles, définit engines pour forcer Node20 sur GCP, et scripts build/deploy. Firebase-functions v5+ est requis pour Gen2 ; évitez les upgrades breaking sans tests.

Déployer la fonction HTTP

terminal
gcloud config set project mon-projet
npm run build
gcloud functions deploy getUsers \
  --gen2 \
  --runtime=nodejs20 \
  --region=europe-west1 \
  --source=. \
  --entry-point=getUsers \
  --trigger-http \
  --allow-unauthenticated \
  --memory=256MB \
  --max-instances=10 \
  --timeout=30s

Ce déploiement Gen2 active Cloud Run sous-jacent avec --gen2. --allow-unauthenticated pour tests ; en prod, remplacez par IAM. La région europe-west1 minimise latence EU. URL de sortie : https://...-ew1.a.run.app/getUsers.

Test et scaling observé

Testez via curl $(gcloud functions describe getUsers --format='value(serviceConfig.uri)'). Surveillez logs avec gcloud functions logs read getUsers --limit=50. Gen2 auto-scale à 0 instances idle, cold start <200ms avec memory 256MB.

Fonction Pub/Sub trigger

src/pubsubFunction.ts
import { onMessagePublished } from 'firebase-functions/v2/pubsub';
import { initializeApp } from 'firebase-admin/app';
import { getFirestore } from 'firebase-admin/firestore';

initializeApp();
const db = getFirestore();

export const processUserEvent = onMessagePublished(
  { topic: 'user-events' },
  async (event) => {
    const message = event.data.message.data
      ? Buffer.from(event.data.message.data, 'base64').toString()
      : '';
    try {
      const userData = JSON.parse(message);
      await db.collection('processed-users').add({
        ...userData,
        processedAt: new Date(),
        eventId: event.data.message.messageId
      });
      console.log('User processed:', userData.id);
    } catch (error) {
      console.error('PubSub error:', error);
      throw error;
    }
  }
);

Trigger Pub/Sub Gen2 pour ETL : parse message base64, stocke en Firestore avec idempotence via messageId. Pas de res HTTP ; erreurs retry auto (exponential backoff). Créez topic : gcloud pubsub topics create user-events.

Déployer Pub/Sub et créer topic

terminal
gcloud pubsub topics create user-events
gcloud functions deploy processUserEvent \
  --gen2 \
  --runtime=nodejs20 \
  --region=europe-west1 \
  --source=. \
  --entry-point=processUserEvent \
  --trigger-topic=user-events \
  --memory=512MB \
  --max-instances=20 \
  --timeout=60s \
  --ingress=internal-only

Déploiement event-driven avec --trigger-topic et --ingress=internal-only pour sécurité (uniquement GCP-internal). Memory up pour ETL lourds ; timeout 60s pour Gen2 max.

Intégrer Secret Manager et VPC

terminal
gcloud secrets create db-password --data-file=/path/to/secret.txt
gcloud functions deploy getUsersSecure \
  --gen2 \
  --runtime=nodejs20 \
  --region=europe-west1 \
  --source=. \
  --entry-point=getUsersSecure \
  --trigger-http \
  --allow-unauthenticated=false \
  --set-secrets=db-password=projects/mon-projet/secrets/db-password:latest \
  --vpc-connector=my-vpc-connector \
  --egress-settings=all-traffic

Sécurise avec Secret Manager (--set-secrets) et VPC Connector pour accès DB privée. Créez connector avant : gcloud vpc-connectors create my-vpc-connector --region=europe-west1 --subnet=my-subnet. IAM auto-mount secrets en env.

Bonnes pratiques

  • Optimisez cold starts : Fixez --min-instances=1 pour workloads constants, utilisez --cpu=2 pour burst.
  • Sécurité IAM : gcloud functions add-iam-policy-binding getUsers --member='allUsers' --role='roles/cloudfunctions.invoker' granulaire.
  • Logging structuré : functions.logger.log(data, { severity: 'INFO' }) pour Cloud Logging queries.
  • Coûts : --concurrency=80 par instance pour max throughput/invocation.
  • CI/CD : Intégrez Cloud Build avec cloudbuild.yaml pour zero-downtime (--update-on-redeploy).

Erreurs courantes à éviter

  • Oublier --gen2 : Déploie en Gen1 obsolète (no VPC, scale limité).
  • Pas d'auth gcloud : gcloud auth application-default login avant deploy.
  • Secrets mal montés : Utilisez process.env.DB_PASSWORD dans code ; rotatez via gcloud secrets versions.
  • Timeouts Firestore : Batch writes avec db.batch() pour >500 ops.

Pour aller plus loin

Approfondissez avec les formations Learni sur GCP Serverless. Docs officielles : Cloud Functions Gen2. Explorez Eventarc pour 100+ triggers ou Artifact Registry pour images custom.