Comment déployer API Node.js sur App Engine 2026

Introduction

Google App Engine est une plateforme PaaS serverless de Google Cloud qui gère l'infrastructure, le scaling et la haute disponibilité pour vos applications. En 2026, avec l'essor des workloads hybrides, App Engine Flexible Environment domine pour ses runtimes custom via Docker, support multi-régions et intégration native avec Cloud SQL, Secret Manager. Ce tutoriel avancé vous guide pas à pas pour déployer une API Node.js RESTful scalable, avec handlers avancés, dispatch.yaml pour multi-services et scaling automatique. Pourquoi c'est crucial ? App Engine réduit les ops de 80% tout en offrant 99.99% SLA, idéal pour APIs critiques. On couvre de la config app.yaml au monitoring Cloud Operations, avec code 100% fonctionnel. À la fin, votre app sera live en <5min, prête pour prod. (128 mots)

Prérequis

Compte Google Cloud activé avec facturation (crédit gratuit 300$)
gcloud CLI installé (v450+ en 2026)
Node.js 20+ et npm
Connaissances avancées en Docker, YAML et GCP IAM
Projet GCP existant ou nouveau via gcloud projects create

Initialiser le projet GCP et gcloud

terminal-init.sh

gcloud auth login
PROJET_ID=mon-api-appengine-2026
gcloud projects create $PROJET_ID --set-as-default
gcloud config set project $PROJET_ID
gcloud app create --region=us-central1
gcloud components install app-engine-java kubectl
mkdir mon-api-appengine && cd mon-api-appengine

Ces commandes authentifient, créent un projet GCP dédié, activent App Engine en région us-central1 (latence EU <100ms) et initialisent le dossier. Évitez les régions par défaut pour optimiser coûts/scaling ; app create déploie le squelette.

Structure du projet Node.js

Créez une API Express avec TypeScript pour robustesse. La structure inclut src/ pour code, app.yaml pour routing et Dockerfile pour Flexible Env (recommandé advanced : custom runtime Node 22).

Package.json et tsconfig.json

package.json

{
  "name": "api-appengine",
  "version": "1.0.0",
  "scripts": {
    "dev": "tsx watch src/index.ts",
    "build": "tsc",
    "start": "node dist/index.js"
  },
  "dependencies": {
    "express": "^4.19.2",
    "@google-cloud/secret-manager": "^5.16.0",
    "cors": "^2.8.5"
  },
  "devDependencies": {
    "@types/express": "^4.17.21",
    "@types/node": "^22.0.0",
    "tsx": "^4.7.0",
    "typescript": "^5.5.3"
  }
}

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "NodeNext",
    "moduleResolution": "NodeNext",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "outDir": "./dist",
    "rootDir": "./src"
  }
}

package.json intègre Secret Manager pour vars sensibles (advanced security). tsconfig active NodeNext pour ESM natif. tsx pour hot-reload dev ; build vers dist/ pour prod. Installez via npm i après.

API Express avec Secret Manager

src/index.ts

import express from 'express';
import {SecretManagerServiceClient} from '@google-cloud/secret-manager';

const app = express();
const client = new SecretManagerServiceClient();

app.use(express.json());
app.use((req, res, next) => {
  res.header('Access-Control-Allow-Origin', '*');
  res.header('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept');
  next();
});

app.get('/health', (req, res) => res.json({status: 'OK', timestamp: new Date().toISOString() }));

app.get('/secret/:name', async (req, res) => {
  try {
    const [version] = await client.accessSecretVersion({
      name: `projects/${process.env.GCLOUD_PROJECT}/secrets/${req.params.name}/versions/latest`
    });
    res.json({data: version.payload?.data?.toString()});
  } catch (error) {
    res.status(500).json({error: 'Secret access failed'});
  }
});

const port = process.env.PORT || 8080;
app.listen(port, () => console.log(`Server on port ${port}`));

export default app;

API expose /health et /secret/:name via GCP Secret Manager (zero-trust). CORS global pour frontend. Gestion async/errors robuste. PORT env pour App Engine. Compilez avec npm run build.

Configuration app.yaml Flexible

App Engine Flexible permet Docker custom, scaling horizontal infini et GPUs. Handlers routent URLs ; env: flex pour runtime libre.

app.yaml et Dockerfile

app.yaml

runtime: custom
env: flex

service: api-default

automatic_scaling:
  min_num_instances: 1
  max_num_instances: 100
  cpu_utilization:
    target_utilization: 0.7

resources:
  cpu: 2
  memory_gb: 2
  disk_size_gb: 10

env_variables:
  GCLOUD_PROJECT: "mon-api-appengine-2026"

readiness_check:
  path: "/health"
  check_interval: 5s
  timeout: 5s
  failure_threshold: 2
  success_threshold: 2

liveness_check:
  path: "/health"
  initial_delay: 60s

YAML définit scaling auto (70% CPU), ressources allouées et health checks (/health). service: api-default pour routing. readiness/liveness évitent cold starts excessifs. Créez secret via gcloud secrets create avant.

Dockerfile optimisé

Dockerfile

FROM node:22-alpine AS builder
WORKDIR /app
COPY package*.json tsconfig.json ./
RUN npm ci --only=production && npm run build

FROM node:22-alpine AS runtime
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/node_modules ./node_modules
COPY --from=builder /app/package*.json ./

EXPOSE 8080
USER node
CMD ["npm", "start"]

HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
  CMD wget --no-verbose --tries=1 --spider http://localhost:8080/health || exit 1

Multi-stage build minifie image (<200MB). Alpine pour sécurité/légereté. HEALTHCHECK mirror app.yaml. USER node évite root ; expose 8080 standard App Engine.

Multi-services avec dispatch.yaml

Pour APIs complexes, dispatch.yaml route /api/ vers service 'api' et /admin/ vers 'admin'. Advanced pour microservices sans API Gateway.

dispatch.yaml et déploiement

dispatch.yaml

dispatch:
  - url: "*/api/*"
    service: api-default
  - url: "*/admin/*"
    service: admin-service

# Déploiement bash (même fichier)
# gcloud secrets create api-key --data-file=- <<< "supersecret2026"
# gcloud app deploy app.yaml --project=mon-api-appengine-2026
# gcloud app deploy dispatch.yaml
# gcloud app browse

dispatch.yaml segmente trafic (api vs admin). Commentez déploiement : crée secret, déploie app+dispatch, browse URL live. Versionnez avec gcloud app versions list.

Scaling et monitoring via gcloud

terminal-scale.sh

gcloud app services update api-default --set-max-instances=200 --region=us-central1

gcloud app describe --service=api-default --region=us-central1

# Logs et métriques
LOG_ID=$(gcloud logging logs list --filter="resource.type=gae_app" --limit=1 --format="value(logName)" | tail -1)
gcloud logging read "${LOG_ID}" --limit=10 --format=table

# Traffic split (blue-green)
gcloud app services set-traffic api-default --split=v1=.3,v2=.7

Scale max instances à 200 ; describe vérifie config. Logs via Cloud Logging (auto). Traffic split pour zero-downtime deploys (v1 30%, v2 70%).

Bonnes pratiques

IAM minimal : Service Account avec rôles App Engine Flex + Secret Accessor seulement.
Health checks strictes : Toujours /healthz avec timeout <10s pour scaling rapide.
Multi-régions : gcloud app create --region=europe-west1 pour HA globale.
Secrets > env vars : Secret Manager rotation auto, audit logs.
Versions nommées : gcloud app deploy app.yaml --version=prod-v1.2 pour rollback instantané.

Erreurs courantes à éviter

Oublier runtime: custom + Dockerfile : Déploiement échoue en Standard (limité Node).
Pas de health checks : Instances killer par App Engine après 10min idle.
Scaling manuel : Toujours automatic_scaling ; min_instances=1 évite cold starts >5s.
Ignorer quotas : Vérifiez gcloud app describe avant peak ; Flexible coûte ~0.05$/h/instance.

Pour aller plus loin

Docs officielles : App Engine Flexible
Intégrez Cloud SQL : Ajoutez beta:app-engine flexible et Cloud SQL Proxy.
CI/CD : GitHub Actions avec gcloud auth + app deploy.
Découvrez nos formations Learni Dev sur GCP pour certif Professional Cloud Architect.

Comment déployer une API Node.js sur App Engine en 2026