Jeff Bruchado
Retour au blog

Serverless en 2025 : Pourquoi Node.js Domine (Et Comment l'Utiliser)

Salut HaWkers, vous souvenez-vous quand "serverless" semblait n'être qu'un simple effet de mode ? En 2025, serverless n'est plus une tendance — c'est le mainstream. Et il y a une raison claire pour laquelle Node.js est devenu le langage dominant dans cet écosystème : cold start rapide, runtime léger, et écosystème massif.

Des entreprises comme Netflix traitent des milliards de requests serverless par jour. Coca-Cola a réduit ses coûts d'infrastructure de 65% en migrant vers serverless. Et des développeurs individuels créent des applications qui scalent automatiquement de 0 à des millions d'utilisateurs — sans toucher un seul serveur.

Mais comment construisez-vous réellement des applications serverless robustes avec Node.js ? Explorons du basique aux patterns avancés utilisés en production.

Qu'est-ce que Serverless et Pourquoi Utiliser Node.js

Serverless ne signifie pas "sans serveurs" — cela signifie que vous ne gérez pas les serveurs. Vous écrivez des fonctions, vous déployez, et le provider s'occupe de tout : scaling, disponibilité, sécurité, patches.

Node.js domine serverless pour des raisons techniques solides :

  1. Cold start rapide : ~100-200ms vs secondes en Python/Java
  2. Runtime léger : Moins de mémoire = coûts moindres
  3. Event-driven natif : Parfait pour l'architecture serverless
  4. Écosystème npm : Des millions de packages prêts
  5. JavaScript universel : Même code en front et backend

Votre Première Fonction Serverless avec AWS Lambda

Commençons par le basique — une fonction Lambda simple :

// handler.js - Fonction Lambda basique
export const handler = async (event) => {
  console.log('Événement reçu:', JSON.stringify(event, null, 2));

  // Parse du body s'il vient de l'API Gateway
  const body = event.body ? JSON.parse(event.body) : event;

  // Logique de la fonction
  const response = {
    message: 'Bonjour depuis Lambda !',
    input: body,
    timestamp: new Date().toISOString()
  };

  // Retourner la réponse pour API Gateway
  return {
    statusCode: 200,
    headers: {
      'Content-Type': 'application/json',
      'Access-Control-Allow-Origin': '*'
    },
    body: JSON.stringify(response)
  };
};

// Pour tester localement
if (process.env.LOCAL_TEST) {
  const testEvent = {
    body: JSON.stringify({ name: 'Jeff', action: 'test' })
  };

  handler(testEvent).then(result => {
    console.log('Résultat:', result);
  });
}

Déploiement avec Serverless Framework

Le Serverless Framework simplifie drastiquement le processus de déploiement :

# serverless.yml
service: my-api

provider:
  name: aws
  runtime: nodejs20.x
  region: us-east-1
  memorySize: 256
  timeout: 10
  environment:
    STAGE: ${opt:stage, 'dev'}
    DB_CONNECTION: ${env:DB_CONNECTION}

functions:
  hello:
    handler: handler.handler
    events:
      - http:
          path: /hello
          method: POST
          cors: true

  processUser:
    handler: users.process
    events:
      - http:
          path: /users/{id}
          method: GET
          cors: true
      - sns:
          topicName: user-updates
          displayName: User Updates Topic

  scheduledTask:
    handler: tasks.scheduled
    events:
      - schedule:
          rate: rate(5 minutes)
          enabled: true

plugins:
  - serverless-offline
  - serverless-webpack

custom:
  webpack:
    webpackConfig: './webpack.config.js'
    includeModules: true
// users.js - Fonction plus complexe
import AWS from 'aws-sdk';

const dynamodb = new AWS.DynamoDB.DocumentClient();
const TABLE_NAME = process.env.USERS_TABLE || 'users';

export const process = async (event) => {
  const userId = event.pathParameters?.id;

  if (!userId) {
    return {
      statusCode: 400,
      body: JSON.stringify({ error: 'ID utilisateur requis' })
    };
  }

  try {
    // Récupérer l'utilisateur depuis DynamoDB
    const result = await dynamodb.get({
      TableName: TABLE_NAME,
      Key: { userId }
    }).promise();

    if (!result.Item) {
      return {
        statusCode: 404,
        body: JSON.stringify({ error: 'Utilisateur non trouvé' })
      };
    }

    // Traiter les données de l'utilisateur
    const processedUser = {
      ...result.Item,
      lastAccessed: new Date().toISOString(),
      processedBy: 'lambda'
    };

    // Mettre à jour le timestamp d'accès
    await dynamodb.update({
      TableName: TABLE_NAME,
      Key: { userId },
      UpdateExpression: 'SET lastAccessed = :timestamp',
      ExpressionAttributeValues: {
        ':timestamp': processedUser.lastAccessed
      }
    }).promise();

    return {
      statusCode: 200,
      headers: {
        'Content-Type': 'application/json',
        'Cache-Control': 'max-age=300'
      },
      body: JSON.stringify(processedUser)
    };

  } catch (error) {
    console.error('Erreur lors du traitement de l\'utilisateur:', error);

    return {
      statusCode: 500,
      body: JSON.stringify({
        error: 'Erreur serveur interne',
        message: error.message
      })
    };
  }
};

Déploiement serverless

Patterns Avancés : Architecture Serverless en Production

Les applications serverless réelles nécessitent des patterns robustes. Explorons-en quelques-uns :

1. Connection Pooling pour les Bases de Données

Une erreur courante : créer une nouvelle connexion DB à chaque invocation. La solution ? Connection pooling global :

// db.js - Connection pooling optimisé
import mysql from 'mysql2/promise';

let pool = null;

export const getPool = () => {
  if (!pool) {
    pool = mysql.createPool({
      host: process.env.DB_HOST,
      user: process.env.DB_USER,
      password: process.env.DB_PASSWORD,
      database: process.env.DB_NAME,
      waitForConnections: true,
      connectionLimit: 2, // Lambda: peu de connexions !
      queueLimit: 0,
      enableKeepAlive: true,
      keepAliveInitialDelay: 0
    });

    console.log('Pool de base de données créé');
  }

  return pool;
};

// Handler Lambda avec pool réutilisable
export const handler = async (event) => {
  const pool = getPool(); // Réutilise la connexion entre les invocations !

  try {
    const [rows] = await pool.execute(
      'SELECT * FROM users WHERE id = ?',
      [event.userId]
    );

    return {
      statusCode: 200,
      body: JSON.stringify(rows[0])
    };

  } catch (error) {
    console.error('Erreur de base de données:', error);
    throw error;
  }

  // NE PAS fermer le pool - réutiliser à la prochaine invocation !
};

2. Pattern Middleware pour Fonctions Lambda

Le middleware rend les fonctions plus propres et réutilisables :

// middleware.js - Système de middleware pour Lambda
export class LambdaMiddleware {
  constructor(handler) {
    this.handler = handler;
    this.middlewares = [];
  }

  use(middleware) {
    this.middlewares.push(middleware);
    return this;
  }

  async execute(event, context) {
    let index = 0;

    const next = async () => {
      if (index < this.middlewares.length) {
        const middleware = this.middlewares[index++];
        await middleware(event, context, next);
      } else {
        return this.handler(event, context);
      }
    };

    try {
      return await next();
    } catch (error) {
      console.error('Erreur middleware:', error);
      throw error;
    }
  }
}

// Middlewares utiles
export const jsonBodyParser = async (event, context, next) => {
  if (event.body && typeof event.body === 'string') {
    try {
      event.body = JSON.parse(event.body);
    } catch (error) {
      return {
        statusCode: 400,
        body: JSON.stringify({ error: 'Corps JSON invalide' })
      };
    }
  }
  return next();
};

export const cors = (origins = '*') => {
  return async (event, context, next) => {
    const result = await next();

    return {
      ...result,
      headers: {
        ...result.headers,
        'Access-Control-Allow-Origin': origins,
        'Access-Control-Allow-Credentials': true,
        'Access-Control-Allow-Methods': 'GET,POST,PUT,DELETE,OPTIONS',
        'Access-Control-Allow-Headers': 'Content-Type,Authorization'
      }
    };
  };
};

export const errorHandler = async (event, context, next) => {
  try {
    return await next();
  } catch (error) {
    console.error('Erreur non gérée:', error);

    return {
      statusCode: error.statusCode || 500,
      body: JSON.stringify({
        error: error.message || 'Erreur serveur interne',
        requestId: context.requestId
      })
    };
  }
};

export const logging = async (event, context, next) => {
  const start = Date.now();

  console.log('Requête démarrée:', {
    requestId: context.requestId,
    path: event.path,
    method: event.httpMethod
  });

  const result = await next();

  const duration = Date.now() - start;
  console.log('Requête terminée:', {
    requestId: context.requestId,
    duration: `${duration}ms`,
    statusCode: result.statusCode
  });

  return result;
};

// Usage des middlewares
import { LambdaMiddleware, jsonBodyParser, cors, errorHandler, logging } from './middleware.js';

const mainHandler = async (event, context) => {
  // Logique principale de la fonction
  const { name, email } = event.body;

  if (!name || !email) {
    const error = new Error('Nom et email sont requis');
    error.statusCode = 400;
    throw error;
  }

  // Traiter les données
  return {
    statusCode: 200,
    body: JSON.stringify({
      message: 'Utilisateur créé',
      user: { name, email }
    })
  };
};

// Composer le handler avec les middlewares
const middleware = new LambdaMiddleware(mainHandler);

middleware
  .use(logging)
  .use(jsonBodyParser)
  .use(cors('https://myapp.com'))
  .use(errorHandler);

export const handler = (event, context) => middleware.execute(event, context);

3. Step Functions pour Workflows Complexes

Pour les processus à plusieurs étapes, Step Functions est essentiel :

// workflow-functions.js - Fonctions pour Step Functions
import AWS from 'aws-sdk';

const s3 = new AWS.S3();
const sns = new AWS.SNS();

// Étape 1: Valider l'input
export const validateInput = async (event) => {
  const { userId, fileKey } = event;

  if (!userId || !fileKey) {
    throw new Error('userId et fileKey sont requis');
  }

  // Vérifier si le fichier existe
  try {
    await s3.headObject({
      Bucket: process.env.BUCKET_NAME,
      Key: fileKey
    }).promise();

    return {
      ...event,
      validated: true,
      timestamp: new Date().toISOString()
    };

  } catch (error) {
    if (error.code === 'NotFound') {
      throw new Error(`Fichier non trouvé: ${fileKey}`);
    }
    throw error;
  }
};

// Étape 2: Traiter le fichier
export const processFile = async (event) => {
  const { fileKey } = event;

  // Télécharger le fichier depuis S3
  const file = await s3.getObject({
    Bucket: process.env.BUCKET_NAME,
    Key: fileKey
  }).promise();

  const content = file.Body.toString('utf-8');
  const lines = content.split('\n');

  // Traiter chaque ligne
  const processed = lines.map(line => {
    // Logique de traitement
    return line.trim().toUpperCase();
  });

  // Sauvegarder le résultat traité
  const resultKey = `processed/${fileKey}`;
  await s3.putObject({
    Bucket: process.env.BUCKET_NAME,
    Key: resultKey,
    Body: processed.join('\n'),
    ContentType: 'text/plain'
  }).promise();

  return {
    ...event,
    processed: true,
    resultKey,
    lineCount: lines.length
  };
};

// Étape 3: Notifier l'utilisateur
export const notifyUser = async (event) => {
  const { userId, resultKey, lineCount } = event;

  const message = `
    Traitement du fichier terminé !

    Utilisateur: ${userId}
    Résultat: ${resultKey}
    Lignes traitées: ${lineCount}
  `;

  await sns.publish({
    TopicArn: process.env.SNS_TOPIC_ARN,
    Subject: 'Traitement du Fichier Terminé',
    Message: message
  }).promise();

  return {
    ...event,
    notified: true,
    completedAt: new Date().toISOString()
  };
};

// Étape 4: Cleanup (erreur ou succès)
export const cleanup = async (event) => {
  const { fileKey } = event;

  // Supprimer le fichier original
  await s3.deleteObject({
    Bucket: process.env.BUCKET_NAME,
    Key: fileKey
  }).promise();

  return {
    ...event,
    cleaned: true
  };
};

Providers Modernes : Au-Delà d'AWS

En 2025, il existe d'excellentes alternatives à AWS Lambda :

Cloudflare Workers

// Cloudflare Worker - Edge computing ultra-rapide
export default {
  async fetch(request, env, ctx) {
    const url = new URL(request.url);

    // Routage
    if (url.pathname === '/api/users') {
      return handleUsers(request, env);
    }

    if (url.pathname.startsWith('/api/data')) {
      return handleData(request, env);
    }

    return new Response('Non trouvé', { status: 404 });
  }
};

async function handleUsers(request, env) {
  // Cache dans Cloudflare KV
  const cached = await env.KV_STORE.get('users', 'json');

  if (cached) {
    return new Response(JSON.stringify(cached), {
      headers: {
        'Content-Type': 'application/json',
        'Cache-Control': 'max-age=60'
      }
    });
  }

  // Récupérer depuis l'origine
  const users = await fetchUsersFromOrigin();

  // Mettre en cache pour 5 minutes
  await env.KV_STORE.put('users', JSON.stringify(users), {
    expirationTtl: 300
  });

  return new Response(JSON.stringify(users), {
    headers: {
      'Content-Type': 'application/json'
    }
  });
}

async function fetchUsersFromOrigin() {
  // Implémentation réelle
  return [
    { id: 1, name: 'Alice' },
    { id: 2, name: 'Bob' }
  ];
}

Vercel Functions

// api/hello.js - Vercel Serverless Function
export default async function handler(request, response) {
  const { method, body } = request;

  if (method !== 'POST') {
    return response.status(405).json({ error: 'Méthode non autorisée' });
  }

  try {
    const data = typeof body === 'string' ? JSON.parse(body) : body;

    // Traiter la requête
    const result = {
      message: 'Succès',
      processed: data,
      timestamp: new Date().toISOString()
    };

    return response.status(200).json(result);

  } catch (error) {
    return response.status(500).json({ error: error.message });
  }
}

// Config Edge (optionnel)
export const config = {
  runtime: 'edge', // Ou 'nodejs' pour le runtime Node.js
};

Performance et Coûts : Optimisation Critique

Le serverless peut devenir cher si mal optimisé. Stratégies essentielles :

1. Minimiser les Cold Starts

// Pré-charger les dépendances dans le scope global
import AWS from 'aws-sdk';
import database from './db.js';

const dynamodb = new AWS.DynamoDB.DocumentClient();
const pool = database.getPool();

// Warm-up des connexions
if (process.env.WARMUP) {
  console.log('Warming up...');
  pool.execute('SELECT 1').catch(console.error);
}

export const handler = async (event) => {
  // Connexions déjà prêtes - zéro overhead !
  // Code du handler...
};

2. Monitoring et Alertes

// monitoring.js - Monitoring intégré
import AWS from 'aws-sdk';

const cloudwatch = new AWS.CloudWatch();

export class MetricsCollector {
  constructor(namespace = 'MonApp') {
    this.namespace = namespace;
    this.metrics = [];
  }

  record(name, value, unit = 'None') {
    this.metrics.push({
      MetricName: name,
      Value: value,
      Unit: unit,
      Timestamp: new Date()
    });
  }

  async flush() {
    if (this.metrics.length === 0) return;

    await cloudwatch.putMetricData({
      Namespace: this.namespace,
      MetricData: this.metrics
    }).promise();

    this.metrics = [];
  }
}

// Usage dans le handler
export const handler = async (event, context) => {
  const metrics = new MetricsCollector();
  const start = Date.now();

  try {
    // Logique de la fonction
    const result = await processEvent(event);

    // Enregistrer le succès
    metrics.record('FunctionSuccess', 1, 'Count');
    metrics.record('ProcessingTime', Date.now() - start, 'Milliseconds');

    await metrics.flush();

    return result;

  } catch (error) {
    // Enregistrer l'erreur
    metrics.record('FunctionError', 1, 'Count');
    await metrics.flush();

    throw error;
  }
};

Le Futur du Serverless et Node.js

En 2025, le serverless est mature. Les prochaines évolutions incluent :

  • WebAssembly à l'edge : Performance native sur Cloudflare/Vercel
  • Containers serverless : AWS Fargate et Cloud Run
  • Fonctions AI-optimized : GPUs serverless pour le ML
  • Orchestration multi-cloud : Terraform Cloud et Pulumi
  • Observability native : OpenTelemetry intégré

Node.js continuera de dominer parce que JavaScript est omniprésent et l'écosystème npm est imbattable. En tant que développeur, maîtriser le serverless avec Node.js vous place dans une position privilégiée pour construire la prochaine génération d'applications scalables.

Si vous voulez explorer davantage les architectures modernes, je recommande de lire mon article sur Microservices avec Node.js : Architecture Moderne en 2025 où je discute des patterns complémentaires au serverless.

C'est parti !

Commentaires (0)

Cet article n'a pas encore de commentaires. Soyez le premier!

Ajouter des commentaires