Skip to content
Learni
Voir tous les tutoriels
Edge Computing

Comment déployer des Workers Cloudflare avancés en 2026

22 minEXPERT
ServerlessCloudflareWorkers
Read in English

Introduction

Cloudflare Workers permet d'exécuter du code JavaScript aux edge locations mondiaux avec une latence minimale. En 2026, les Workers sont devenus essentiels pour les architectures serverless haute performance. Ce tutoriel expert couvre l'implémentation avancée incluant Durable Objects pour la synchronisation d'état, l'intégration KV pour le caching distribué et les stratégies d'optimisation du cold start. Vous apprendrez à structurer un projet TypeScript complet et à déployer en production avec monitoring avancé.

Prérequis

  • Node.js 20+ et npm
  • Compte Cloudflare avec Workers Unbound activé
  • Connaissances solides en TypeScript et HTTP
  • Wrangler CLI installé
  • Accès à Cloudflare KV et Durable Objects

Initialisation du projet

terminal
npm create cloudflare@latest my-worker -- --yes
cd my-worker
npm install --save-dev @cloudflare/workers-types
npx wrangler login

Cette commande initialise un projet Workers avec TypeScript et installe les types officiels. Wrangler gère l'authentification et la configuration pour les déploiements directs vers l'edge Cloudflare.

Configuration avancée wrangler

wrangler.toml
name = "my-advanced-worker"
main = "src/index.ts"
compatibility_date = "2026-01-01"
compatibility_flags = ["nodejs_compat"]

[vars]
ENVIRONMENT = "production"

[[kv_namespaces]]
binding = "CACHE"
id = "your_kv_id"
preview_id = "your_preview_kv_id"

[durable_objects]
bindings = [{ name = "COUNTER", class_name = "Counter" }]

[[migrations]]
tag = "v1"
new_classes = ["Counter"]

Le fichier wrangler.toml configure les bindings KV et Durable Objects. Le flag nodejs_compat permet l'utilisation de modules Node standards et la date de compatibilité assure le support des dernières APIs Workers.

Worker principal TypeScript

src/index.ts
import { Counter } from './counter';

export interface Env {
  CACHE: KVNamespace;
  COUNTER: DurableObjectNamespace;
  ENVIRONMENT: string;
}

export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    const url = new URL(request.url);
    if (url.pathname === '/counter') {
      const id = env.COUNTER.idFromName('global');
      const obj = env.COUNTER.get(id);
      return obj.fetch(request);
    }
    const cached = await env.CACHE.get(url.pathname);
    if (cached) return new Response(cached);
    const response = new Response('Hello from Edge 2026');
    await env.CACHE.put(url.pathname, response.body as any, { expirationTtl: 3600 });
    return response;
  }
};

Ce worker route les requêtes vers un Durable Object pour le compteur global et utilise KV pour le caching avec TTL. La structure TypeScript garantit la sécurité des types pour les bindings.

Implémentation Durable Object

src/counter.ts
export class Counter {
  state: DurableObjectState;
  constructor(state: DurableObjectState) {
    this.state = state;
  }
  async fetch(request: Request): Promise<Response> {
    let count = (await this.state.storage.get<number>('count')) || 0;
    count++;
    await this.state.storage.put('count', count);
    return new Response(JSON.stringify({ count }), {
      headers: { 'Content-Type': 'application/json' }
    });
  }
}

Le Durable Object maintient un état persistant via storage. Chaque instance est unique par nom et assure la cohérence des données sans base externe pour les cas d'usage simples comme les compteurs distribués.

Tests unitaires avec Miniflare

src/index.test.ts
import { env } from 'cloudflare:test';
import { describe, it, expect } from 'vitest';

describe('Worker', () => {
  it('returns cached response', async () => {
    const response = await env.CACHE.put('/test', 'cached');
    const req = new Request('https://example.com/test');
    const res = await (await import('./index')).default.fetch(req, env);
    expect(await res.text()).toBe('cached');
  });
});

Les tests utilisent l'environnement Miniflare intégré à Wrangler pour simuler KV et Durable Objects localement. Cela permet des tests rapides et fiables avant déploiement.

Bonnes pratiques

  • Toujours définir des compatibility_date récentes et tester les flags
  • Utiliser des Durable Objects uniquement pour l'état partagé critique
  • Implémenter des stratégies de retry et circuit breaker pour les dépendances externes
  • Surveiller les cold starts avec Real-time Logs
  • Limiter la taille des bundles à moins de 1MB pour des déploiements optimaux

Erreurs courantes à éviter

  • Oublier de déclarer les migrations Durable Objects dans wrangler.toml
  • Utiliser des variables globales mutables sans coordination
  • Ignorer les limites de 100ms CPU sur les Workers Free
  • Ne pas versionner les KV keys lors des mises à jour de schéma

Pour aller plus loin

Approfondissez avec nos formations dédiées aux architectures edge : https://learni-group.com/formations. Explorez les Workers AI et l'intégration avec D1 pour des bases SQL distribuées.