Claude Code & Cloudflare Workers: Edge-Funktionen mit KI entwickeln

Traditionelle Server-Infrastruktur hat ein grundlegendes Problem: Sie sitzt irgendwo. Ein Rechenzentrum in Frankfurt, einer in Ashburn, vielleicht ein drittes in Singapur — und alle anderen Nutzer weltweit warten auf die Antwort, die durch das halbe Internet reisen muss. Edge Computing löst das, indem der Code dort läuft, wo die Nutzer sind — in über 300 Rechenzentren gleichzeitig.

Cloudflare Workers ist die führende Plattform für dieses Paradigma. Der Code läuft in Millisekunden, skaliert automatisch auf null wenn niemand da ist, und kostet nichts für Anfragen die nicht kommen. Claude Code macht den Einstieg in Workers deutlich schneller: Konfigurationsdateien verstehen, Binding-Syntax korrekt hinschreiben, die richtige D1-Query generieren — das sind Aufgaben, bei denen Claude Code den entscheidenden Vorsprung bringt.

1. Warum Edge Computing?

Eine normale API-Anfrage von Tokio an einen Server in Frankfurt legt rund 9.000 Kilometer zurück. Selbst bei optimaler Netzwerkqualität addieren sich Latenz und Round-Trip-Time zu spürbaren Verzögerungen. Für interaktive Anwendungen, für APIs die von mobilen Endgeräten aufgerufen werden, für Geo-Routing und Personalisierung ist das ein strukturelles Problem.

Cloudflare Workers laufen stattdessen im nächstgelegenen Cloudflare-Rechenzentrum. Der Nutzer in Tokio trifft auf einen Worker in Tokio oder Osaka. Die Antwort kommt in unter 20 Millisekunden statt in 200. Das ist kein marginaler Unterschied — es ist der Unterschied zwischen einer Anwendung die sich responsiv anfühlt und einer die sich träge anfühlt.

Hinzu kommt das Preismodell: Workers haben ein großzügiges Free-Tier (100.000 Anfragen pro Tag), und der Paid-Plan kostet einen Bruchteil von klassischen Serverkosten bei vergleichbarer Last. Keine Server zu verwalten, kein Scaling zu konfigurieren, kein Cold-Start-Problem wie bei AWS Lambda.

2. Worker erstellen und deployen mit Wrangler

Der Einstieg in Cloudflare Workers läuft über Wrangler, das offizielle CLI-Tool. Mit Claude Code lässt sich das Setup beschleunigen — vor allem bei der wrangler.toml, die Workers, Bindings und Environments konfiguriert.

# Projekt initialisieren
npm create cloudflare@latest my-worker
cd my-worker

# Lokale Entwicklung starten
npx wrangler dev

# Deployment
npx wrangler deploy

Claude Code hilft besonders beim Schreiben der wrangler.toml. Die Konfigurationssyntax für Bindings — KV Namespaces, D1-Datenbanken, R2-Buckets, Queues — hat viele Felder und ist nicht immer selbsterklärend. Claude Code liest die bestehende Konfiguration und erweitert sie korrekt, ohne Tippfehler in Binding-Namen oder falsche Kompatibilitätsdaten.

# wrangler.toml
name = "my-worker"
main = "src/index.ts"
compatibility_date = "2024-09-23"

[[kv_namespaces]]
binding = "CACHE"
id = "abc123"

[[d1_databases]]
binding = "DB"
database_name = "my-database"
database_id = "def456"

3. Request/Response API

Workers basieren auf der Web Standards API — kein Node.js, kein Express, sondern die gleiche Request und Response API die im Browser verfügbar ist. Das macht Workers portabel und vorhersehbar, erfordert aber ein Umdenken für Entwickler die aus der Node-Welt kommen.

export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    const url = new URL(request.url);

    if (url.pathname === '/api/hello') {
      return new Response(
        JSON.stringify({ message: 'Hallo von der Edge!' }),
        { headers: { 'Content-Type': 'application/json' } }
      );
    }

    return new Response('Not Found', { status: 404 });
  }
};

Das env-Objekt enthält alle konfigurierten Bindings — KV-Namespaces, D1-Datenbanken, Secrets. Claude Code kennt die Typisierung und generiert korrekte TypeScript-Interfaces für das Env-Objekt, was Tippfehler beim Binding-Zugriff vermeidet.

4. KV Storage

Cloudflare KV ist ein globaler Key-Value-Speicher mit hoher Leseleistung — ideal für Caching, Session-Daten, Feature Flags und alles was oft gelesen aber selten geschrieben wird. Der Schreibvorgang repliziert sich innerhalb von Sekunden global, Lesezugriffe sind lokal im jeweiligen Edge-Standort.

// Lesen
const value = await env.CACHE.get('user:123');

// Schreiben mit TTL (in Sekunden)
await env.CACHE.put('user:123', JSON.stringify(userData), {
  expirationTtl: 3600
});

// Löschen
await env.CACHE.delete('user:123');

// JSON direkt lesen
const user = await env.CACHE.get('user:123', { type: 'json' });

5. D1 SQL-Datenbank

D1 ist Cloudflares SQLite-basierte Datenbank, die direkt am Edge läuft. Vollständiges SQL, Transaktionen, Joins — und direkt aus dem Worker ohne Netzwerk-Overhead erreichbar. Claude Code hilft beim Schreiben von Migrations-Skripten und beim Generieren von typsicheren Query-Wrappern.

// Schema-Migration erstellen
// migrations/0001_users.sql
CREATE TABLE users (
  id INTEGER PRIMARY KEY AUTOINCREMENT,
  email TEXT UNIQUE NOT NULL,
  name TEXT NOT NULL,
  created_at DATETIME DEFAULT CURRENT_TIMESTAMP
);

// Im Worker abfragen
const { results } = await env.DB.prepare(
  'SELECT * FROM users WHERE email = ?'
).bind(email).all();

// Einzelne Zeile
const user = await env.DB.prepare(
  'SELECT * FROM users WHERE id = ?'
).bind(userId).first();

// Einfügen
await env.DB.prepare(
  'INSERT INTO users (email, name) VALUES (?, ?)'
).bind(email, name).run();

Claude Code generiert aus einem SQL-Schema automatisch TypeScript-Typen für die Query-Ergebnisse — ein häufiger Zeitfresser bei D1-Projekten, der sich vollständig automatisieren lässt.

6. R2 Object Storage

R2 ist Cloudflares S3-kompatibler Object Storage — ohne Egress-Kosten, was bei großen Datenmengen erheblich günstiger ist als AWS S3. Ideal für Bilder, Videos, Backups und große Dateien die über den Worker ausgeliefert werden sollen.

// Datei hochladen
await env.BUCKET.put('images/profile-123.jpg', imageData, {
  httpMetadata: { contentType: 'image/jpeg' }
});

// Datei lesen
const object = await env.BUCKET.get('images/profile-123.jpg');
if (!object) return new Response('Not Found', { status: 404 });

return new Response(object.body, {
  headers: { 'Content-Type': object.httpMetadata?.contentType ?? 'application/octet-stream' }
});

// Datei löschen
await env.BUCKET.delete('images/profile-123.jpg');

7. Cron Triggers

Workers können auch ohne eingehende HTTP-Anfragen laufen — auf einem Zeitplan. Cron Triggers eignen sich für Cleanup-Jobs, Cache-Invalidierung, Reports und alle anderen wiederkehrenden Aufgaben die auf klassischen Servern in einem Crontab stünden.

# wrangler.toml
[triggers]
crons = ["0 * * * *", "0 0 * * *"]

# src/index.ts
export default {
  async scheduled(event: ScheduledEvent, env: Env): Promise<void> {
    if (event.cron === '0 * * * *') {
      // Stündlicher Job: Cache aufräumen
      await cleanExpiredCache(env);
    }
    if (event.cron === '0 0 * * *') {
      // Täglicher Job: Statistiken aggregieren
      await aggregateDailyStats(env);
    }
  }
};

8. Hono Framework für Workers

Für komplexere APIs mit mehreren Routen, Middleware und einheitlichem Error-Handling empfiehlt sich Hono — ein ultraleichtes Web-Framework das speziell für Edge-Runtimes wie Cloudflare Workers entwickelt wurde. Die API ist Express-ähnlich, der Bundle-Size minimal.

import { Hono } from 'hono'
import { cors } from 'hono/cors'
import { jwt } from 'hono/jwt'

const app = new Hono<{ Bindings: Env }>()

app.use('/api/*', cors())
app.use('/api/protected/*', jwt({ secret: (c) => c.env.JWT_SECRET }))

app.get('/api/users/:id', async (c) => {
  const id = c.req.param('id')
  const user = await c.env.DB.prepare(
    'SELECT * FROM users WHERE id = ?'
  ).bind(id).first()

  if (!user) return c.json({ error: 'Not found' }, 404)
  return c.json(user)
})

export default app

Claude Code versteht die Hono-Typen und generiert korrekte Handler mit TypeScript-Inference für Request-Parameter, Bindings und Response-Typen. Gerade bei JWT-Middleware und CORS-Konfiguration spart das erheblich Zeit.

9. Limits und Best Practices

Workers haben spezifische Einschränkungen, die man kennen muss — nicht als Hindernis, sondern als Designvorgaben:

• CPU-Limit: 10 ms pro Anfrage im Free-Plan, 30 Sekunden im Paid-Plan. Schwere Berechnungen gehören nicht in den Worker selbst, sondern in einen separaten Service.
• Memory: 128 MB pro Worker-Instanz. Große In-Memory-Caches sind nicht sinnvoll — dafür gibt es KV.
• Kein Node.js: Node-spezifische APIs (fs, path, crypto aus Node) funktionieren nicht. Web Crypto API ist verfügbar.
• Bundle-Size: Maximal 1 MB komprimiert. Große Abhängigkeiten (Prisma, Lodash) überdenken.
• Keine persistenten Verbindungen: Jede Worker-Instanz ist stateless. Geteilter Zustand gehört in KV, D1 oder Durable Objects.

Claude Code ist bei Workers besonders nützlich, weil es die Grenzen zwischen verfügbaren und nicht verfügbaren APIs kennt. Wenn du eine Node.js-Bibliothek in einen Worker portieren willst, analysiert Claude Code die Abhängigkeiten und identifiziert, welche Teile ersetzt werden müssen — und schlägt konkrete Alternativen vor.