Serverless
AWS Lambda
Cloudflare Workers
Cloud Computing
Arquitetura de Software

Développer des applications sans serveur avec AWS Lambda et Cloudflare Workers en 2025

Développer des applications sans serveur avec AWS Lambda et Cloudflare Workers en 2025

Près d’une décennie après sa popularisation, l’architecture sans serveur est passée d’une tendance expérimentale à une approche courante du développement d’applications. En 2025, deux plateformes se démarquent dans ce scénario : AWS Lambda, le pionnier qui continue de dominer le marché, et Cloudflare Workers, qui a gagné en popularité grâce à son approche innovante basée sur les standards du Web.

Cet article explore comment développer des applications sans serveur modernes à l'aide de ces deux plates-formes, en analysant leurs différences architecturales, leurs cas d'utilisation idéaux et comment les organisations les combinent pour créer des solutions robustes.

L'état actuel du sans serveur en 2025

Evolution au-delà des limites initiales

Lorsque l’informatique sans serveur a fait son apparition, elle a été confrontée au scepticisme en raison de limitations telles que les démarrages à froid, les limites d’exécution et la complexité du débogage. D’ici 2025, bon nombre de ces barrières auront été supprimées :

  • Démarrages à froid : réduit de secondes à millisecondes sur les deux plates-formes
  • State Persistence : nouvelles abstractions pour maintenir l'état entre les exécutions
  • Observabilité : Outils intégrés de surveillance et de diagnostic
  • Intégrations : écosystèmes robustes permettant des architectures hybrides

Croissance et adoption du marché

Selon les données de la Cloud Native Computing Foundation, d'ici 2025, 78 % des organisations utiliseront une forme d'informatique sans serveur en production, soit une augmentation significative par rapport aux 35 % de 2021. Les facteurs à l'origine de cette adoption comprennent :

  • 40 % de réduction des coûts opérationnels pour des charges de travail adaptées
  • Temps de lancement moyen 65 % plus rapide pour les nouvelles fonctionnalités
  • Capacité d'évoluer instantanément pour répondre aux pics de demande

AWS Lambda et Cloudflare Workers : comparaison architecturale

Modèle d'exécution et de performances

AWS Lambda en 2025

AWS a considérablement fait évoluer Lambda depuis son lancement :

  • Architecture SnapStart : désormais disponible pour tous les environnements d'exécution, réduisant les démarrages à froid jusqu'à 90 %
  • Lambda ƛ2 : La deuxième génération complète de la plateforme, offrant des performances CPU et réseau améliorées
  • Lambda Graviton4 : processeurs ARM personnalisés avec le meilleur rapport coût-bénéfice
  • Unified Runtime : un nouveau modèle qui permet de changer de langue sans redéploiement

La latence moyenne est tombée à 10-50 ms pour les invocations à chaud, avec des démarrages à froid compris entre 100 et 300 ms selon la configuration.

Travailleurs de Cloudflare en 2025

Cloudflare a continué de miser sur son architecture basée sur des isolats V8 :

  • Isolates 2.0 : version optimisée avec une meilleure isolation et une surcharge réduite
  • Computing Edge universel : exécuté dans plus de 500 emplacements dans le monde
  • WebAssembly en tant que citoyen de première classe : prise en charge multilingue avec des performances quasi natives
  • Advanced Durable Objects : solution robuste pour l'état distribué avec des garanties de cohérence

Les travailleurs bénéficient désormais de latences constantes de 5 à 15 ms à l'échelle mondiale, avec des démarrages à froid pratiquement nuls.

Modèle de tarification et d'économie

Les structures de coûts ont évolué vers des modèles plus granulaires et prévisibles :

####AWS Lambda

  • Charge par milliseconde d'exécution (auparavant par 100 ms)
  • Tarification basée sur le processeur virtuel et la mémoire, avec mise à l'échelle linéaire
  • Remises sur volume automatiques sans engagement préalable
  • Niveau gratuit étendu à 2 millions d'exécutions mensuelles

Travailleurs Cloudflare

  • Modèle de double tarification : par requête ou par durée CPU
  • Aucun frais de réseau au sein de l'écosystème Cloudflare
  • KV Stockage et Objets Durables avec des prix réduits de 40% depuis 2023
  • Plan gratuit généreux pour les développeurs et les startups

Limites et restrictions

Les deux plates-formes ont étendu leurs limites pour s'adapter à des charges de travail plus complexes :

####AWS Lambda

  • Durée maximale de course : 30 minutes (auparavant 15)
  • Mémoire configurable : jusqu'à 32 Go (auparavant 10 Go)
  • Taille du package déployé : jusqu'à 10 Go
  • Concurrence par région : 3000 par défaut, extensible à la demande

Travailleurs Cloudflare

  • Durée maximale du processeur : 60 secondes (auparavant 30)
  • Limite de mémoire : 2 Go par travailleur
  • Prise en charge des demandes et des réponses en streaming
  • Persistance entre les requêtes via Durable Objects et D1 Database

Cas d'utilisation et modèles architecturaux émergents

Applications Web et API

Modèle : API Gateway + Lambda (AWS)

Le modèle API Gateway traditionnel connecté aux fonctions Lambda a évolué avec de nouvelles fonctionnalités :

// Exemplo: Lambda com API Gateway v3 usando TypeScript
import { APIGatewayProxyHandlerV3 } from 'aws-lambda';

export const handler: APIGatewayProxyHandlerV3 = async (event) => {
  // Suporte integrado a validação de esquema JSON
  const { body } = event;
  
  // Conexão simplificada com outros serviços AWS
  const result = await dynamoDB.query({
    TableName: 'Users',
    KeyConditionExpression: 'id = :id',
    ExpressionAttributeValues: { ':id': body.userId }
  });
  
  // Novo formato de resposta simplificado
  return {
    statusCode: 200,
    body: { user: result.Items[0] }  // Serialização automática para JSON
  };
};

Par défaut : Sites de travail (Cloudflare)

Cloudflare a développé un écosystème complet pour les applications web :

// Exemplo: Cloudflare Worker moderno com composição
import { Router } from '@cloudflare/router';
import { db } from '@cloudflare/d1';

export default {
  async fetch(request, env) {
    const router = new Router();
    
    // Roteamento declarativo com middleware
    router.get('/api/users/:id', withAuth, async ({ params, db }) => {
      const user = await db.prepare('SELECT * FROM users WHERE id = ?')
                          .bind(params.id)
                          .first();
      
      return Response.json({ user });
    });
    
    return router.handle(request, { db: env.DB });
  }
};

// Middleware de autenticação
async function withAuth(request, ctx) {
  const token = request.headers.get('Authorization');
  if (!await verifyToken(token)) {
    return new Response('Unauthorized', { status: 401 });
  }
  return ctx.next();
}

Traitement des données et ETL

Par défaut : ETL piloté par les événements (AWS)

AWS a développé une norme robuste pour le traitement des données sans serveur :

// Exemplo: Pipeline ETL com Step Functions e Lambda
export const extractHandler = async (event) => {
  const sourceId = event.sourceId;
  console.log(`Extracting data from source ${sourceId}`);
  
  // Novo cliente S3 com suporte a streaming
  const dataStream = await s3.getObject({
    Bucket: 'data-lake',
    Key: `sources/${sourceId}/latest.json`
  }).transformToByteStream();
  
  // Processing stream in chunks com operadores async
  const records = [];
  for await (const chunk of dataStream) {
    const data = JSON.parse(chunk);
    records.push(...data.records);
  }
  
  return { records, sourceId };
};

export const transformHandler = async (event) => {
  const { records } = event;
  
  // Paralelização automática com o novo runtime
  const transformed = await Promise.allSettled(
    records.map(async record => {
      // Processamento complexo
      return enrichAndTransform(record);
    })
  );
  
  return { transformed: transformed.map(r => r.value) };
};

Par défaut : Traitement Edge (Cloudflare)

Cloudflare a créé de nouvelles primitives pour le traitement distribué des données :

// Exemplo: Processamento de dados na borda com Workers e Queues
export default {
  async fetch(request, env) {
    // Endpoint para ingestão de dados
    if (request.method === 'POST') {
      const data = await request.json();
      
      // Envio para processamento assíncrono via filas
      await env.PROCESSING_QUEUE.send({
        data,
        timestamp: Date.now()
      });
      
      return new Response('Accepted', { status: 202 });
    }
    
    return new Response('Method not allowed', { status: 405 });
  },
  
  // Manipulador de mensagens da fila
  async queue(batch, env) {
    // Processamento em lote com transações atômicas
    const db = env.DB;
    const operations = batch.messages.map(msg => {
      const { data } = msg.body;
      return processRecord(data, db);
    });
    
    const results = await Promise.all(operations);
    console.log(`Processed ${results.length} records`);
  }
};

async function processRecord(data, db) {
  // Transação atômica no banco D1
  return db.batch([
    db.prepare('INSERT INTO processed (id, data) VALUES (?, ?)')
      .bind(data.id, JSON.stringify(data)),
    db.prepare('UPDATE metrics SET count = count + 1 WHERE type = ?')
      .bind(data.type)
  ]);
}

Intégrations et architectures multicloud

Avec une maturité supplémentaire, les entreprises mettent désormais en œuvre en 2025 des architectures combinant les atouts des deux plateformes :

Standard : Edge-to-Core (Cloudflare + AWS)

Un modèle devenu populaire utilise Cloudflare Workers à la périphérie pour le routage, la mise en cache et le traitement initial, déléguant des charges de travail plus lourdes à AWS Lambda :

// Exemplo: Worker na borda que roteia para AWS conforme necessário
export default {
  async fetch(request, env) {
    // Análise de requisição na borda
    const url = new URL(request.url);
    const userAgent = request.headers.get('User-Agent');
    const geo = request.cf.country;
    
    // Cache e acesso rápido para conteúdo estático
    if (url.pathname.startsWith('/assets/')) {
      return env.ASSETS.fetch(request);
    }
    
    // Decisões inteligentes na borda
    if (needsIntensiveProcessing(request)) {
      // Encaminhamento para AWS Lambda via API Gateway
      const awsResponse = await fetch(`https://api.example.com/process`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          'X-Origin-Geo': geo,
          'X-Request-ID': env.requestId
        },
        body: JSON.stringify({
          path: url.pathname,
          query: Object.fromEntries(url.searchParams),
          // Dados adicionais necessários
        })
      });
      
      // Processamento da resposta do Lambda
      const result = await awsResponse.json();
      return Response.json(result);
    }
    
    // Processamento leve direto na borda
    return handleAtEdge(request, env);
  }
};

Modèle : Lambda@Edge pour une migration progressive

Les organisations ayant investi de manière significative dans AWS Lambda utilisent Lambda@Edge et Cloudflare Workers pour une stratégie de migration progressive :

// Exemplo: Estratégia de migração usando Lambda@Edge como ponte
export const handler = async (event) => {
  const request = event.Records[0].cf.request;
  const headers = request.headers;
  
  // Decisão de roteamento baseada em regras de negócio
  if (shouldRouteToWorkers(request)) {
    // Reescrever para apontar para a implementação do Cloudflare Worker
    request.origin = {
      custom: {
        domainName: 'workers.example.com',
        port: 443,
        protocol: 'https',
        path: '/api/v2',
        sslProtocols: ['TLSv1.2'],
        readTimeout: 5,
        keepaliveTimeout: 5,
        customHeaders: {
          'x-route-from': [{ key: 'X-Route-From', value: 'lambda-edge' }]
        }
      }
    };
  }
  
  return request;
};

Meilleures pratiques et optimisations en 2025

Optimisation du démarrage à froid

Les stratégies visant à minimiser l’impact des démarrages à froid ont considérablement évolué :

####AWS Lambda

  • Utilisation de la concurrence provisionnée pour les charges critiques
  • Lambda SnapStart pour tous les langages (pas seulement Java)
  • Dépendances en couches pour la réutilisation du code entre les fonctions
  • Planification intelligente pour le préchauffage en fonction des modèles de trafic

Travailleurs Cloudflare

  • Algorithmes de prévision du trafic pour le maintien de l'isolement
  • Distribution géographique des demandes pour les ressources mondiales
  • Regroupement sélectif pour minimiser la taille du code
  • Connexions persistantes avec les backends

Conception pour la résilience et la stabilité

Les meilleures pratiques en matière de résilience dans serverless ont mûri :

Disjoncteurs et tentatives

// Exemplo: Padrão circuit-breaker moderno em Lambda
import { CircuitBreaker } from '@aws-lambda/circuit-breaker';

export const handler = async (event) => {
  // Configuração do circuit breaker
  const breaker = new CircuitBreaker({
    failureThreshold: 0.3,     // 30% de falhas abrem o circuito
    recoveryTime: 10000,       // 10 segundos até tentar recuperar
    timeout: 2500,             // Timeout individual de 2.5 segundos
    volumeThreshold: 10,       // Após 10 requisições
  });
  
  try {
    // Execução protegida da chamada a serviço externo
    const result = await breaker.execute(async () => {
      return await externalService.call(event.parameters);
    });
    
    return { success: true, data: result };
  } catch (error) {
    if (error.isCircuitBreakerError) {
      // Tratamento específico para falhas de circuit breaker
      return { success: false, fallbackData: getDefaultResponse() };
    }
    throw error;
  }
};

Conception pour l'idempotence

// Exemplo: Garantia de idempotência em Cloudflare Worker
export default {
  async fetch(request, env) {
    if (request.method === 'POST') {
      const body = await request.json();
      const idempotencyKey = request.headers.get('Idempotency-Key');
      
      if (!idempotencyKey) {
        return new Response('Idempotency-Key header required', { status: 400 });
      }
      
      // Verificar se já processamos esta operação
      const existingResult = await env.KV.get(`op:${idempotencyKey}`);
      if (existingResult) {
        return new Response(existingResult, {
          headers: { 'X-Served-From-Cache': 'true' }
        });
      }
      
      // Processar a operação
      const result = await processOperation(body);
      
      // Armazenar o resultado para idempotência
      await env.KV.put(`op:${idempotencyKey}`, JSON.stringify(result), {
        expirationTtl: 86400 // 24 horas
      });
      
      return Response.json(result);
    }
    
    return new Response('Method not allowed', { status: 405 });
  }
};

Observabilité et surveillance

D’ici 2025, l’observabilité n’est plus une réflexion secondaire, mais intégrée dès le départ aux systèmes :

OpenTelemetry intégré

// Exemplo: Tracing distribuído em Lambda com OTel
import { OTelTracer } from '@aws-lambda/opentelemetry';

// Inicialização automática do tracer
const tracer = new OTelTracer();

export const handler = async (event) => {
  // Criação de span para a operação principal
  return tracer.withSpan('process-order', async (span) => {
    span.setAttribute('order.id', event.orderId);
    
    // Sub-spans para operações específicas
    const paymentResult = await tracer.withSpan('process-payment', async (paymentSpan) => {
      paymentSpan.setAttribute('payment.amount', event.amount);
      return processPayment(event);
    });
    
    span.addEvent('payment_processed', { success: paymentResult.success });
    
    if (paymentResult.success) {
      await tracer.withSpan('send-confirmation', async () => {
        return sendConfirmation(event.customer, event.orderId);
      });
    }
    
    return { orderId: event.orderId, success: paymentResult.success };
  });
};

Analyse des performances en temps réel

// Exemplo: Monitoramento de performance em Cloudflare Workers
import { metrics } from '@cloudflare/metrics';

export default {
  async fetch(request, env) {
    // Iniciar timer para métricas
    const requestTimer = metrics.timer('request_duration');
    
    try {
      // Incrementar contador de requisições
      metrics.increment('requests_total', 1, {
        method: request.method,
        path: new URL(request.url).pathname
      });
      
      // Processar requisição
      const response = await handleRequest(request, env);
      
      // Métricas de sucesso
      metrics.increment('responses_total', 1, { 
        status: response.status,
        success: response.ok
      });
      
      return response;
    } catch (error) {
      // Métricas de erro
      metrics.increment('errors_total', 1, { 
        type: error.name,
        message: error.message.substring(0, 100)
      });
      
      // Registro detalhado do erro no sistema de observabilidade
      console.error('Request processing error', {
        url: request.url,
        method: request.method,
        error: {
          name: error.name,
          message: error.message,
          stack: error.stack
        }
      });
      
      return new Response('Internal Server Error', { status: 500 });
    } finally {
      // Finalizar timer de requisição
      requestTimer.end();
    }
  }
};

L'avenir du sans serveur au-delà de 2025

Tendances émergentes

Au-delà des capacités actuelles, quelques tendances façonnent l'avenir du sans serveur :

1. Composition et chorégraphie des fonctions

La nouvelle génération d'outils d'orchestration rend la composition des fonctions plus intuitive et déclarative :

// Exemplo: Composição declarativa de funções (conceitual)
const orderProcessingFlow = compose({
  name: 'ProcessOrder',
  
  steps: {
    validateOrder: {
      function: validateOrderFn,
      next: 'checkInventory'
    },
    
    checkInventory: {
      function: checkInventoryFn,
      next: {
        condition: 'result.available',
        true: 'processPayment',
        false: 'notifyOutOfStock'
      }
    },
    
    processPayment: {
      function: processPaymentFn,
      next: {
        condition: 'result.success',
        true: 'fulfillOrder',
        false: 'handlePaymentFailure'
      },
      retry: {
        maxAttempts: 3,
        backoff: 'exponential'
      }
    },
    
    fulfillOrder: {
      function: fulfillOrderFn,
      end: true
    },
    
    notifyOutOfStock: {
      function: notifyOutOfStockFn,
      end: true
    },
    
    handlePaymentFailure: {
      function: handlePaymentFailureFn,
      end: true
    }
  }
});

2. IA assistée pour l'optimisation des fonctions

Les outils d'IA analysent les modèles d'utilisation et optimisent automatiquement les paramètres des ressources :

// Exemplo: Configuração assistida por IA (conceitual)
export const handler = withOptimizer(async (event) => {
  // Lógica de negócio normal
  return processData(event);
}, {
  memoryOptimization: true,    // Otimização automática de memória
  coldStartReduction: true,    // Redução de cold starts
  costEfficiency: 'balanced',  // Equilibra custo vs. performance
  scalingPrediction: true      // Prevê necessidades de escala
});

3. Le sans serveur à la périphérie de l'informatique

La prochaine frontière est celle de l'informatique encore plus proche des appareils finaux :

// Exemplo: Worker executando em provedores de rede 5G (conceitual)
export default {
  async fetch(request, env) {
    // Acesso a capacidades específicas de rede
    const networkInfo = request.cf.networkInsights;
    const latency = networkInfo.estimatedLatency;
    const bandwidth = networkInfo.availableBandwidth;
    
    // Processamento adaptável baseado em condições de rede
    if (bandwidth < 5 && latency > 100) {
      return generateLightweightResponse();
    }
    
    return generateRichResponse();
  },
  
  // Executado diretamente em pontos de presença 5G
  async mobileEdge(deviceContext, env) {
    // Acesso a métricas de dispositivo específicas
    const batteryLevel = deviceContext.batteryLevel;
    const connectionType = deviceContext.connectionType;
    
    // Lógica adaptável às condições do dispositivo
    return customizeResponseForDevice(batteryLevel, connectionType);
  }
};

Défis et considérations futures

À mesure que les architectures sans serveur continuent d’évoluer, de nouveaux défis apparaissent :

Consommation d'énergie et impact environnemental

Le débat sur l’efficacité énergétique des différentes approches sans serveur a pris de l’importance :

  • AWS Lambda a introduit des métriques carbone pour les fonctions
  • Cloudflare a étendu son infrastructure alimentée à 100 % par des énergies renouvelables
  • Les outils d'analyse comparative de l'efficacité font désormais partie des pipelines CI/CD

Souveraineté des données et réglementation

Avec la prolifération mondiale des réglementations en matière de confidentialité :

  • Contrôles granulaires de résidence des données pour les charges de travail sans serveur]
  • Certifications de conformité automatisées
  • Limites régionales configurables pour l'exécution du code

Stratégies de migration et de portabilité

Les préoccupations concernant le verrouillage ont conduit au développement de :

  • Frameworks d'abstraction pour plusieurs cloud (Serverless Framework 4.0)
  • Les conteneurs comme mécanisme de portabilité des fonctions
  • Adaptateurs pour différents fournisseurs sans serveur

Conclusion : Choisir la bonne approche

Il n’existe pas de solution unique adaptée à tous les cas. En 2025, le choix entre AWS Lambda et Cloudflare Workers (ou une combinaison des deux) dépend de plusieurs facteurs :

  • Latence critique mondiale : Cloudflare Workers présente un avantage grâce à son réseau de périphérie mondial
  • Intégration approfondie avec les services AWS : Lambda offre une intégration supérieure avec l'écosystème AWS
  • Coût pour les charges de travail prévisibles : Cloudflare propose généralement des tarifs plus prévisibles
  • Exigences intensives en calcul : Lambda prend en charge une allocation de mémoire et de processeur plus élevée
  • Persistance et état : Lambda est intégré à davantage de services de persistance, mais Durable Objects offre une expérience plus intégrée.

La vraie compétence est de savoir quand et comment utiliser chaque outil, éventuellement en les combinant dans une architecture qui tire parti du meilleur de chaque monde.

Comment utilisez-vous les architectures sans serveur dans vos projets ? Quelle plateforme a le mieux répondu à vos besoins ? Partagez vos expériences dans les commentaires ci-dessous.

A lire aussi

GitHub
LinkedIn
X
youtube