Déployer votre première fonction IA serverless avec Cloudflare Workers et Claude

Les fonctions serverless révolutionnent la manière dont nous construisons et déployons les applications. Combinées aux capacités d'IA comme Claude, elles deviennent des outils incroyablement puissants pour créer des services intelligents et évolutifs qui s'exécutent à la périphérie du réseau.

Dans ce tutoriel complet, vous apprendrez à construire une fonction IA serverless prête pour la production en utilisant Cloudflare Workers et l'API Claude d'Anthropic. À la fin, vous aurez une fonction déployée capable de gérer des requêtes IA avec une latence minimale, un auto-scaling et une distribution mondiale.

Pourquoi Cloudflare Workers + Claude ?

Cloudflare Workers exécute votre code sur le réseau mondial de centres de données de Cloudflare, ce qui signifie que votre fonction s'exécute près de vos utilisateurs partout dans le monde. Les avantages incluent :

• Zéro démarrage à froid – exécution instantanée
• Distribution mondiale – plus de 300 centres de données dans le monde
• Rentable – offre gratuite généreuse (100 000 requêtes/jour)
• Faible latence – l'edge computing réduit les temps de réponse
• Auto-scaling – gère automatiquement les pics de trafic

L'API Claude d'Anthropic fournit des capacités de modèle de langage de pointe :

• Raisonnement et analyse avancés
• Grandes fenêtres de contexte (jusqu'à 200K tokens)
• Garde-fous de sécurité solides
• Excellente capacité à suivre les instructions
• Temps de réponse rapides

Ensemble, ils créent une stack puissante pour construire des applications intelligentes qui évoluent globalement.

Ce que nous allons construire

Nous créerons un Analyseur de Contenu Intelligent – un endpoint API qui accepte du texte et retourne :

• Analyse de sentiment
• Extraction des sujets clés
• Génération de résumé
• Recommandations de contenu

Ce modèle peut être adapté pour les chatbots, la modération de contenu, le traitement de documents, et plus encore.

Prérequis

Avant de commencer, assurez-vous d'avoir :

1. Node.js 18+ installé (télécharger ici)
2. Un compte Cloudflare (l'offre gratuite fonctionne parfaitement)
3. Une clé API Anthropic (obtenir une ici)
4. Connaissances de base en JavaScript/TypeScript
5. Familiarité avec les API REST

Vous aurez également besoin d'environ 30 minutes pour compléter ce tutoriel.

Étape 1 : Configurer votre environnement de développement

D'abord, installez Wrangler, l'outil CLI de Cloudflare pour les Workers :

npm install -g wrangler

Vérifiez l'installation :

wrangler --version

Connectez-vous à votre compte Cloudflare :

wrangler login

Cela ouvre une fenêtre de navigateur pour l'authentification. Une fois connecté, vous êtes prêt à créer votre premier Worker.

Étape 2 : Créer un nouveau projet Worker

Créez un nouveau répertoire et initialisez le projet :

mkdir smart-analyzer-worker
cd smart-analyzer-worker
npm init -y

Créez le fichier de configuration Worker wrangler.toml :

name = "smart-analyzer"
main = "src/index.js"
compatibility_date = "2026-02-28"
 
[vars]
ENVIRONMENT = "production"

Créez le répertoire source :

mkdir src

Étape 3 : Écrire votre premier Worker

Créez src/index.js avec une structure Worker de base :

export default {
  async fetch(request, env, ctx) {
    // Gérer CORS pour les requêtes du navigateur
    if (request.method === 'OPTIONS') {
      return new Response(null, {
        headers: {
          'Access-Control-Allow-Origin': '*',
          'Access-Control-Allow-Methods': 'POST, OPTIONS',
          'Access-Control-Allow-Headers': 'Content-Type',
        },
      });
    }
 
    // Accepter uniquement les requêtes POST
    if (request.method !== 'POST') {
      return new Response('Méthode non autorisée', { status: 405 });
    }
 
    try {
      const { text } = await request.json();
 
      if (!text || text.trim().length === 0) {
        return new Response(
          JSON.stringify({ error: 'Le texte est requis' }),
          { status: 400, headers: { 'Content-Type': 'application/json' } }
        );
      }
 
      return new Response(
        JSON.stringify({
          message: 'Worker fonctionne !',
          textLength: text.length,
        }),
        {
          headers: {
            'Content-Type': 'application/json',
            'Access-Control-Allow-Origin': '*',
          },
        }
      );
    } catch (error) {
      return new Response(
        JSON.stringify({ error: 'JSON invalide' }),
        { status: 400, headers: { 'Content-Type': 'application/json' } }
      );
    }
  },
};

Testez localement :

wrangler dev

Votre Worker s'exécute maintenant sur http://localhost:8787. Testez-le :

curl -X POST http://localhost:8787 \
  -H "Content-Type: application/json" \
  -d '{"text":"Bonjour le monde !"}'

Vous devriez voir : {"message":"Worker fonctionne !","textLength":20}

Étape 4 : Intégrer l'API Claude

Maintenant ajoutons la magie de l'IA. D'abord, stockez votre clé API Anthropic comme secret :

wrangler secret put ANTHROPIC_API_KEY

Collez votre clé API lorsque demandé.

Mettez à jour src/index.js pour appeler Claude :

async function analyzeWithClaude(text, apiKey) {
  const response = await fetch('https://api.anthropic.com/v1/messages', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'x-api-key': apiKey,
      'anthropic-version': '2023-06-01',
    },
    body: JSON.stringify({
      model: 'claude-3-5-sonnet-20241022',
      max_tokens: 1024,
      messages: [
        {
          role: 'user',
          content: \`Analysez le texte suivant et fournissez :
1. Sentiment (positif/négatif/neutre avec score de confiance)
2. Top 3 des sujets clés
3. Un résumé concis (2 phrases maximum)
4. Recommandation de contenu (quelle action doit être prise)
 
Texte : "\${text}"
 
Retournez votre réponse en JSON valide avec cette structure :
{
  "sentiment": {"label": "positive", "confidence": 0.85},
  "topics": ["sujet1", "sujet2", "sujet3"],
  "summary": "Votre résumé ici",
  "recommendation": "Votre recommandation ici"
}\`,
        },
      ],
    }),
  });
 
  if (!response.ok) {
    throw new Error(\`Erreur API Claude : \${response.status}\`);
  }
 
  const data = await response.json();
  const content = data.content[0].text;
 
  // Extraire le JSON de la réponse de Claude
  const jsonMatch = content.match(/\{[\s\S]*\}/);
  if (!jsonMatch) {
    throw new Error('Échec de l\'analyse de la réponse Claude');
  }
 
  return JSON.parse(jsonMatch[0]);
}
 
export default {
  async fetch(request, env, ctx) {
    if (request.method === 'OPTIONS') {
      return new Response(null, {
        headers: {
          'Access-Control-Allow-Origin': '*',
          'Access-Control-Allow-Methods': 'POST, OPTIONS',
          'Access-Control-Allow-Headers': 'Content-Type',
        },
      });
    }
 
    if (request.method !== 'POST') {
      return new Response('Méthode non autorisée', { status: 405 });
    }
 
    try {
      const { text } = await request.json();
 
      if (!text || text.trim().length === 0) {
        return new Response(
          JSON.stringify({ error: 'Le texte est requis' }),
          { status: 400, headers: { 'Content-Type': 'application/json' } }
        );
      }
 
      // Limiter la longueur du texte pour prévenir les abus
      if (text.length > 10000) {
        return new Response(
          JSON.stringify({ error: 'Texte trop long (max 10 000 caractères)' }),
          { status: 400, headers: { 'Content-Type': 'application/json' } }
        );
      }
 
      const analysis = await analyzeWithClaude(text, env.ANTHROPIC_API_KEY);
 
      return new Response(
        JSON.stringify({
          success: true,
          analysis,
          processedAt: new Date().toISOString(),
        }),
        {
          headers: {
            'Content-Type': 'application/json',
            'Access-Control-Allow-Origin': '*',
          },
        }
      );
    } catch (error) {
      console.error('Erreur :', error);
      return new Response(
        JSON.stringify({
          error: 'Échec de l\'analyse',
          message: error.message,
        }),
        {
          status: 500,
          headers: { 'Content-Type': 'application/json' },
        }
      );
    }
  },
};

Étape 5 : Tester localement

Exécutez votre Worker avec le secret :

wrangler dev

Testez avec un texte d'exemple :

curl -X POST http://localhost:8787 \
  -H "Content-Type: application/json" \
  -d '{
    "text": "Les nouvelles fonctionnalités IA de notre produit ont été incroyablement bien accueillies. Les clients rapportent des gains de productivité de 40% et les retours ont été extrêmement positifs. Cela valide notre direction stratégique."
  }'

Vous devriez recevoir une analyse structurée avec sentiment, sujets, résumé et recommandations !

Étape 6 : Déployer en production

Une fois les tests satisfaisants, déployez sur le réseau mondial de Cloudflare :

wrangler deploy

Vous obtiendrez une URL comme https://smart-analyzer.YOUR-SUBDOMAIN.workers.dev

Votre fonction IA serverless est maintenant en ligne et distribuée sur plus de 300 centres de données dans le monde !

Étape 7 : Ajouter la limitation de débit (Optionnel mais recommandé)

Pour prévenir les abus, ajoutez une limitation de débit simple :

// En haut de votre Worker
const RATE_LIMIT = 10; // requêtes par minute
const rateLimitMap = new Map();
 
function checkRateLimit(ip) {
  const now = Date.now();
  const windowStart = now - 60000; // fenêtre d'une minute
 
  if (!rateLimitMap.has(ip)) {
    rateLimitMap.set(ip, [now]);
    return true;
  }
 
  const requests = rateLimitMap.get(ip).filter(time => time > windowStart);
  requests.push(now);
  rateLimitMap.set(ip, requests);
 
  return requests.length <= RATE_LIMIT;
}
 
// Dans votre gestionnaire fetch, avant le traitement :
const clientIP = request.headers.get('CF-Connecting-IP') || 'unknown';
if (!checkRateLimit(clientIP)) {
  return new Response(
    JSON.stringify({ error: 'Limite de débit dépassée. Réessayez plus tard.' }),
    { status: 429, headers: { 'Content-Type': 'application/json' } }
  );
}

Redéployez avec wrangler deploy.

Étape 8 : Surveiller et optimiser

Voir les analyses

Vérifiez les performances de votre Worker dans le tableau de bord Cloudflare :

1. Allez dans Workers & Pages
2. Sélectionnez votre Worker
3. Consultez les métriques : requêtes, erreurs, temps CPU, bande passante

Optimiser les performances

1. Utilisez le streaming pour les grandes réponses :

// Pour les tâches d'analyse plus longues
return new Response(stream, {
  headers: { 'Content-Type': 'text/event-stream' }
});

2. Mettez en cache les requêtes fréquentes :

const cache = caches.default;
const cacheKey = new Request(request.url, request);
let response = await cache.match(cacheKey);
 
if (!response) {
  response = await analyzeWithClaude(text, env.ANTHROPIC_API_KEY);
  ctx.waitUntil(cache.put(cacheKey, response.clone()));
}

3. Utilisez les modèles Claude plus rapides pour les tâches simples :

model: 'claude-3-5-haiku-20241022' // Plus rapide et moins cher

Bonnes pratiques

1. Sécurité

• N'exposez jamais votre clé API dans le code côté client
• Utilisez Cloudflare Access pour une authentification supplémentaire
• Implémentez la signature des requêtes pour les opérations sensibles
• Validez et nettoyez toutes les entrées

2. Gestion des erreurs

• Retournez toujours des réponses d'erreur structurées
• Enregistrez les erreurs pour le débogage (utilisez console.error)
• Fournissez des messages d'erreur utiles aux utilisateurs
• Définissez les codes de statut HTTP appropriés

3. Optimisation des coûts

• Définissez des limites de longueur de texte raisonnables
• Implémentez la mise en cache pour les requêtes identiques
• Utilisez les modèles Claude appropriés (Haiku pour les tâches simples, Sonnet pour les complexes)
• Surveillez l'utilisation via les tableaux de bord Cloudflare et Anthropic

4. Performance

• Gardez les Workers légers (moins de 1MB compressé)
• Minimisez les appels d'API externes
• Utilisez ctx.waitUntil() pour les opérations non bloquantes
• Profitez du réseau mondial de Cloudflare

Cas d'usage réels

Ce modèle peut alimenter :

1. Modération de contenu – Signaler automatiquement le contenu inapproprié
2. Support client – Analyser les tickets de support pour le routage et la priorité
3. Traitement de documents – Extraire des insights des documents téléchargés
4. Chatbots – Construire des interfaces conversationnelles avec faible latence mondiale
5. Analyse d'emails – Catégoriser et résumer les emails entrants
6. Surveillance des médias sociaux – Analyser les mentions de marque et le sentiment
7. Revue de code – Vérifications automatiques de la qualité et de la sécurité du code

Dépannage

Erreur : "Invalid API key"

• Vérifiez votre secret : wrangler secret list
• Recréez si nécessaire : wrangler secret put ANTHROPIC_API_KEY

Erreur : "Worker exceeded CPU time limit"

• Optimisez les prompts Claude pour être plus concis
• Utilisez des modèles Claude plus rapides
• Implémentez la gestion du timeout

Latence élevée

• Vérifiez si vous êtes sur l'offre gratuite (légers démarrages à froid possibles)
• Optimisez votre code Worker
• Envisagez d'implémenter la mise en cache

Limitation de débit d'Anthropic

• Implémentez une file d'attente de requêtes
• Utilisez le backoff exponentiel
• Mettez à niveau votre plan Anthropic si nécessaire

Prochaines étapes

Maintenant que vous avez une fonction IA serverless fonctionnelle, envisagez :

1. Ajouter l'authentification en utilisant Cloudflare Access ou des tokens JWT
2. Implémenter un frontend pour interagir avec votre API
3. Stocker les résultats dans Cloudflare D1 (base de données SQL serverless)
4. Ajouter des webhooks pour notifier les systèmes externes des résultats d'analyse
5. Construire un tableau de bord pour visualiser les analyses
6. Créer des analyseurs spécialisés pour différents types de contenu
7. Intégrer avec d'autres APIs (traduction, analyse d'image, etc.)

Conclusion

Vous avez réussi à construire et déployer une fonction alimentée par l'IA serverless qui s'exécute globalement avec une latence minimale. Cette architecture est prête pour la production et peut évoluer vers des millions de requêtes sans gestion d'infrastructure.

La combinaison de Cloudflare Workers et de l'API Claude ouvre des possibilités infinies pour construire des applications intelligentes. Que vous traitiez du contenu généré par les utilisateurs, construisiez des chatbots, ou créiez des outils d'analyse, cette stack fournit la performance, l'évolutivité et l'intelligence que les applications modernes exigent.

Prêt à aller plus loin ? Explorez nos autres tutoriels sur l'intégration IA, l'architecture serverless, et les stratégies de déploiement en production.

Besoin d'aide pour construire des systèmes IA en production ? Contactez Noqta pour des conseils d'experts en intégration IA, architecture serverless, et développement d'applications évolutives.