Cómo construir una pila de ingeniería de IA interna escalable y segura

ARTICULO

Introducción

Si tu equipo de DevOps necesita integrar IA en su flujo diario sin sacrificar seguridad ni escalabilidad, este artículo te muestra cómo Cloudflare implementó una pila completa de ingeniería de IA que hoy procesa 241 mil millones de tokens mensuales con 3.683 usuarios internos activos. La clave está en usar los mismos productos que ofrecés al mercado: AI Gateway para enrutamiento centralizado, Workers AI para inferencia low-latency y Cloudflare Access para autenticación Zero Trust.

Esta guía cubre el diseño real de su stack, con comandos exactos para replicar:

• Un proxy Worker que centraliza autenticación y enrutamiento a múltiples proveedores
• Configuración de AI Gateway para gestión de costos y BYOK (Bring Your Own Keys)
• Implementación de Workers AI con modelos open-source como Kimi K2.5
• Integración de MCP (Model Context Protocol) con autenticación OAuth2

Qué es y para qué sirve

Una pila de ingeniería de IA interna debe resolver cuatro problemas críticos:

1. Autenticación unificada: Todos los usuarios (desde desarrolladores hasta agentes automatizados) deben autenticarse mediante Zero Trust.
2. Enrutamiento inteligente: Cada request a un LLM debe pasar por un gateway que aplique políticas de costos, retención de datos y selección de proveedor.
3. Inferencia eficiente: Usar modelos open-source en Workers AI evita latencias cruzadas entre clouds y reduce costos en un 77% vs. modelos propietarios.
4. Sandboxing seguro: Ejecutar código generado por IA en entornos aislados (Durable Objects) para prevenir fugas de datos o ejecuciones maliciosas.

Cloudflare resolvió estos puntos con:

• AI Gateway: Un proxy que recibe requests desde clientes MCP (OpenCode, Windsurf) y los redirige a proveedores como Frontier Labs, Google AI Studio o Workers AI.
• Workers AI: Servidor de inferencia serverless que corre modelos open-source (como Kimi K2.5) en GPUs globales, evitando salidas de red.
• Cloudflare Access: Autenticación Zero Trust basada en JWT firmado por cloudflared, integrada con SSO corporativo.

El resultado es una arquitectura donde todos los componentes son productos oficiales de Cloudflare, lo que simplifica mantenimiento y escalado.

Prerequisitos

Para replicar este stack necesitarás:

• Administrator en tu cuenta Cloudflare (para crear Workers, AI Gateway y zonas DNS).
• Acceso a Cloudflare Access (requiere suscripción a Enterprise o Business).
• Permiso para crear Túneles Cloudflare (cloudflared tunnel create).

Guía paso a paso

1. Configurar autenticación Zero Trust con Cloudflare Access

Primero, creá un túnel para exponer tu dominio interno y configurá Cloudflare Access.

# Autenticá cloudflared con tu cuenta Cloudflare
cloudflared tunnel login

# Crear un túnel (ej: ai-internal-tunnel)
cloudflared tunnel create ai-internal-tunnel

# Asignar el túnel a tu dominio
cloudflared tunnel route dns ai-internal-tunnel ai.internal.tudominio.com

1. En el dashboard de Cloudflare, navegá a Access > Applications.
2. Hacé clic en Create Application.
3. Seleccioná Self-hosted y configurá:

– Domain: ai.internal.tudominio.com

– Session Duration: 24 hours

1. En Policies, agregá un rule que permita acceso solo a tu organización:

   {
     "include": [{"email_domain": {"domain": "tudominio.com"}}],
     "require": [{"any": [{"email_domain": {"domain": "tudominio.com"}}]}]
   }
   

1. Guardá la aplicación y anotá el Application ID (ej: 6b1e2c4-5d3f-1a7b-9c8d-0e1f2a3b4c5d).

Creá un Worker que sirva el endpoint /.well-known/opencode con la configuración de autenticación.

# Inicializar un nuevo Worker
wrangler init ai-discovery-worker --type=webpack
cd ai-discovery-worker

Edita src/index.ts:

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

const app = new Hono();

app.use('*', cors({
  origin: ['https://opencode.internal.tudominio.com'],
  allowMethods: ['GET'],
}));

app.get('/.well-known/opencode', async (c) => {
  return c.json({
    auth: {
      type: 'cloudflare_access',
      applicationId: '6b1e2c4-5d3f-1a7b-9c8d-0e1f2a3b4c5d',
    },
    config: {
      providers: {
        anthropic: {
          type: 'api',
          apiKey: '{anthropic_api_key}',
        },
        google: {
          type: 'api',
          apiKey: '{google_api_key}',
        },
        workersAI: {
          type: 'workers_ai',
        },
      },
      defaultModel: 'kimi-k2-5',
      mcpServers: {
        'cloudflare-tools': {
          command: 'npx',
          args: ['@cloudflare/workers-sdk', 'mcp-server'],
        },
      },
    },
  });
});

export default app;

# Configurar el Worker en wrangler.toml
name = "ai-discovery-worker"
compatibility_date = "2024-05-20"
account_id = "TU_ACCOUNT_ID"

# Asignar el dominio
routes = ["ai.internal.tudominio.com/.well-known/opencode"]

# Desplegar
wrangler deploy

• El endpoint https://ai.internal.tudominio.com/.well-known/opencode devuelve un JSON con la configuración de autenticación y proveedores.
• Los clientes MCP (como OpenCode) usarán este endpoint para descubrir cómo autenticarse.

2. Configurar AI Gateway para enrutamiento centralizado

AI Gateway actúa como proxy entre los clientes MCP y los proveedores de modelos, aplicando políticas de costos y BYOK.

1. En el dashboard de Cloudflare, navegá a AI Gateway > Create Gateway.
2. Configurá:

– Gateway URL: https://ai.internal.tudominio.com

– Providers: Agregá los proveedores que necesites (ej: Anthropic, Google AI Studio, Workers AI).

1. En Key Management, habilitá Bring Your Own Keys y agregá las claves API de cada proveedor.

Edita src/index.ts del Worker anterior para redirigir requests a AI Gateway:

app.post('/:provider/*', async (c) => {
  const provider = c.req.param('provider');
  const headers = new Headers(c.req.headers);
  headers.delete('cf-visitor');
  headers.delete('cf-connecting-ip');

  // Agregar el JWT de Cloudflare Access
  const accessJwt = c.req.header('Cf-Access-Jwt-Assertion');
  if (!accessJwt) {
    return c.json({ error: 'Unauthorized' }, 401);
  }
  headers.set('Authorization', `Bearer ${accessJwt}`);

  // Redirigir al proveedor correspondiente
  const providerMap = {
    anthropic: 'https://ai.internal.tudominio.com/anthropic/v1/messages',
    google: 'https://ai.internal.tudominio.com/google-ai-studio/v1beta',
    workersAI: 'https://ai.internal.tudominio.com/compat/v1/chat/completions',
  };

  const targetUrl = providerMap[provider];
  if (!targetUrl) {
    return c.json({ error: 'Provider not found' }, 404);
  }

  const response = await fetch(targetUrl, {
    method: 'POST',
    headers,
    body: c.req.body,
  });

  return response;
});

En el dashboard de AI Gateway, configurá:

• Token Limits: Límite diario de tokens por usuario (ej: 10M tokens/día).
• Data Retention: Zero Data Retention para cumplir con políticas de privacidad.
• Cost Tracking: Habilitá informes de costos por proveedor.

• Todos los requests a los proveedores pasan por el Worker.
• AI Gateway registra métricas de tokens y costos en el dashboard.

3. Implementar Workers AI con modelos open-source

Workers AI permite correr modelos open-source en tu propia red, evitando latencias cruzadas.

wrangler init kimi-worker --type=webpack
cd kimi-worker

Edita src/index.ts:

import { Ai } from '@cloudflare/ai';

export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    const ai = new Ai(env.AI);
    const body = await request.json();
    const messages = body.messages;

    const response = await ai.run('@cf/qwen/qwen1.5-14b-chat', {
      messages,
    });

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

1. En el dashboard de AI Gateway, agregá un provider de tipo Workers AI.
2. Configurá el endpoint:

   URL: https://kimi-worker.TU_SUBDOMINIO.workers.dev
   Model: kimi-k2-5
   

curl -X POST "https://ai.internal.tudominio.com/compat/v1/chat/completions" \
  -H "Content-Type: application/json" \
  -H "Cf-Access-Jwt-Assertion: TU_JWT" \
  -d '{"messages": [{"role": "user", "content": "Explicá cómo funciona un Durable Object en Cloudflare Workers"}]}'

• La response debe incluir texto generado por Kimi K2.5 con un costo <$0.01 por millón de tokens.

4. Integrar MCP Server Portal con autenticación OAuth

Para que los agentes de IA accedan a tus repositorios, configurá un MCP Server Portal con OAuth2.

1. En Access > Applications, creá una nueva aplicación de tipo OAuth2.
2. Configurá:

– Redirect URLs: https://mcp.internal.tudominio.com/auth/callback

– Scopes: Agregá read:repo, write:repo, repo:status.

1. Anotá el Client ID y Client Secret.

wrangler init mcp-portal-worker --type=hono
cd mcp-portal-worker

Edita src/index.ts:

import { Hono } from 'hono';
import { OAuth2Client } from '@cloudflare/workers-oauth2';

const app = new Hono();
const oauth = new OAuth2Client({
  clientId: 'TU_CLIENT_ID',
  clientSecret: 'TU_CLIENT_SECRET',
  authorizationEndpoint: 'https://ai.internal.tudominio.com/oauth/authorize',
  tokenEndpoint: 'https://ai.internal.tudominio.com/oauth/token',
});

app.get('/oauth/authorize', (c) => oauth.authorize(c.req));
app.get('/oauth/callback', async (c) => {
  const token = await oauth.callback(c.req);
  return c.json({ token });
});

app.get('/servers', async (c) => {
  const token = c.req.header('Authorization')?.split(' ')[1];
  if (!token) return c.json({ error: 'Unauthorized' }, 401);
  const user = await oauth.userinfo(token);
  return c.json({
    servers: {
      'cloudflare-tools': {
        command: 'npx',
        args: ['@cloudflare/workers-sdk', 'mcp-server'],
        env: { GITHUB_TOKEN: user.accessToken },
      },
    },
  });
});

export default app;

wrangler deploy

• Los clientes MCP pueden autenticarse via OAuth2 y recibir una lista de servidores disponibles (ej: cloudflare-tools).

Consideraciones y buenas prácticas

1. Seguridad en producción

• No expongas el Worker de discovery (/.well-known/opencode) públicamente. Restringilo a la IP de tu organización usando Cloudflare Firewall Rules.
• Rotá claves API cada 90 días. En AI Gateway, usa Key Rotation automático.
• Aisla Workers AI en un subdominio dedicado (ej: ai-inference.internal.tudominio.com) para aplicar políticas de WAF específicas.

2. Escalabilidad

• Workers AI tiene un límite de 100 req/seg por cuenta. Si superás este límite, implementá rate limiting en el proxy Worker:

  import { RateLimiter } from 'limiter';
  const limiter = new RateLimiter({ tokensPerInterval: 100, interval: 'second' });
  

• Para modelos propietarios (ej: Anthropic), configurá AI Gateway con caching para evitar duplicar requests idénticos.

3. Alternativas y trade-offs

• Metrics en Workers: Usá wrangler tail para debuggear requests:

  wrangler tail kimi-worker --format pretty
  

• AI Gateway Analytics: Configurá alertas para umbrales de tokens (ej: >80% del límite diario).
• SLOs: Definí un Service Level Objective para Workers AI: <200ms de latencia p95.

Conclusión

Replicar el stack de Cloudflare para ingeniería de IA interna requiere:

1. Un proxy Worker que centralice autenticación (Cloudflare Access) y enrutamiento (AI Gateway).
2. Workers AI para inferencia low-latency con modelos open-source (Kimi K2.5).
3. MCP Server Portal con OAuth2 para que los agentes accedan a tus repositorios de forma segura.

Este diseño te permite escalar desde cientos a miles de usuarios sin sacrificar seguridad ni aumentar costos. La clave está en centralizar el control (AI Gateway) y aislar la inferencia (Workers AI), dos principios que cualquier equipo de DevOps puede aplicar hoy mismo.

Fuentes

• Cloudflare Blog: Our Internal AI Engineering Stack
• Fastly: AI Gateway Architecture
• Istio Blog: AI Gateway Patterns