API Zombie

Definición

Una API Zombie es un endpoint API que continúa operando en producción a pesar de estar abandonada, deprecada o ya no mantenida activamente. A diferencia de las Shadow APIs (que nunca fueron documentadas), las APIs Zombie fueron alguna vez endpoints oficiales y documentados que han perdido a sus propietarios y responsables.

Estas APIs son peligrosas porque parecen legítimas—están en tu documentación, siguen funcionando e incluso podrían tener cobertura de pruebas—pero nadie las está monitoreando, parcheando o actualizando activamente. Cuando se descubren vulnerabilidades, no hay nadie responsable de arreglarlas.

Las APIs Zombie típicamente surgen a través de cambios organizacionales: desarrolladores dejan la empresa, equipos se reorganizan, productos se descontinúan pero sus APIs permanecen ejecutándose “por si acaso”. Son la deuda técnica del mundo de las APIs.

Ejemplo

Escenario: El API de Login v1

En 2018, tu empresa lanza una app móvil con un endpoint de login:

// POST /api/v1/auth/login - Creado en 2018
app.post('/api/v1/auth/login', (req, res) => {
  const { username, password } = req.body;
  // Usa hashing MD5 (débil para estándares de 2018)
  const hash = md5(password);
  const user = db.findUser(username, hash);
  res.json({ token: generateToken(user) });
});

En 2020, lanzas v2 con hashing bcrypt. En 2022, el equipo móvil migra a v2. Pero v1 nunca se apaga porque “algunos clientes legacy podrían seguir usándola.”

2024: El desarrollador original se fue en 2021. Nadie recuerda que v1 existe. Sigue procesando 5,000 logins/día desde integraciones olvidadas. Un investigador de seguridad encuentra que todavía usa hashing MD5. No hay propietario a quien notificar, ningún equipo de seguridad monitoreándola, ninguna línea de tiempo de deprecación.

Resultado: Tienes una API Zombie—documentada, funcional, pero abandonada y vulnerable.

Analogía

La Casa Abandonada: Imagina una casa cuyo propietario se mudó pero no la vendió ni demolió. Los servicios públicos siguen conectados, el correo sigue llegando, pero nadie vive allí ni la mantiene. Con el tiempo, el techo gotea, las tuberías se corroen y okupas se mudan. Los vecinos asumen que alguien la posee porque las luces siguen encendidas. Una API Zombie es esta casa en tu infraestructura—todavía encendida, todavía respondiendo, pero nadie está en casa.

El Puente Sin Mantener: Un puente construido hace décadas sigue llevando tráfico diariamente. Pero los ingenieros originales se jubilaron, la empresa constructora quebró y ninguna agencia gubernamental asumió la propiedad. Cuando los inspectores encuentran grietas, no hay nadie a quien llamar. Funciona hasta que no lo hace—catastróficamente. Las APIs Zombie son estos puentes en tu paisaje de APIs.

Código de Ejemplo

Cómo se crean las APIs Zombie:

// 2018: Implementación original
app.post('/api/v1/users/create', createUser);
// Propietaria: Alice ([email protected])

// 2020: Nueva versión lanzada
app.post('/api/v2/users/register', createUserV2);
// Propietario: Bob ([email protected])

// 2021: Alice deja la empresa
// 2022: Bob se mueve a otro equipo
// 2023: v1 sigue procesando 2K requests/día
// 2024: CVE descubierto en dependencia de v1
// Problema: Nadie sabe quién es dueño de v1 ahora

Detección: Encontrando APIs Zombie

// Cruzar inventario de APIs con base de datos de empleados
const apiInventory = await getAPIs();
const currentEmployees = await getEmployees();

const zombieCandidates = apiInventory.filter(api => {
  const owner = api.metadata.owner;
  const isActive = currentEmployees.includes(owner);
  const lastUpdated = api.metadata.lastUpdated;
  const isStale = Date.now() - lastUpdated > 365 * 24 * 60 * 60 * 1000; // 1 año

  return !isActive || isStale;
});

console.log(`Encontradas ${zombieCandidates.length} APIs Zombie potenciales`);
// Salida: Encontradas 23 APIs Zombie potenciales

// Analizar tráfico para determinar si todavía se usan
zombieCandidates.forEach(async api => {
  const traffic = await analyzeTraffic(api.path, { days: 30 });
  console.log(`${api.path}: ${traffic.requests} requests/mes`);
  console.log(`  Propietario: ${api.metadata.owner} (dejó la empresa)`);
  console.log(`  Última actualización: ${api.metadata.lastUpdated}`);
  console.log(`  Riesgo: ${traffic.requests > 1000 ? 'ALTO' : 'MEDIO'}`);
});

Diagrama

graph TB
    A[API Creada 2018] -->|Desarrolladora Alice| B[Documentada & Mantenida]
    B -->|2020: v2 Lanzada| C[Deprecada pero Ejecutándose]
    C -->|2021: Alice Se Va| D[Sin Propietario]
    D -->|2022: v2 Por Defecto| E[Sigue Procesando Tráfico]
    E -->|2024: CVE Encontrado| F[API Zombie]
    F -->|Problema| G[Nadie para Parchear]
    F -->|Problema| H[Todavía Tiene Usuarios]
    F -->|Problema| I[Riesgo de Seguridad]
    style A fill:#c8e6c9
    style B fill:#c8e6c9
    style C fill:#fff9c4
    style D fill:#ffcc80
    style E fill:#ffcc80
    style F fill:#ffcdd2
    style G fill:#ff6b6b
    style H fill:#ff6b6b
    style I fill:#ff6b6b

Notas de Seguridad

Mejores Prácticas

1. Propiedad obligatoria: Cada API debe tener un empleado actual como propietario. Cuando empleados se van, reasignar o descontinuar sus APIs
2. Fechas de sunset automáticas: Todas las APIs obtienen una expiración predeterminada de 3 años a menos que se renueve
3. Monitoreo de tráfico: Alertar si APIs deprecadas reciben tráfico
4. Forzar deprecación: Después de 6 meses de aviso, realmente apagar las APIs deprecadas (no dejarlas ejecutándose indefinidamente)
5. Disciplina de documentación: Mantener actualizada la metadata del catálogo de APIs (propietario, estado, última actualización)
6. Entrevistas de salida: Cuando desarrolladores se van, auditar sus APIs

Errores Comunes

Error 1: “No podemos apagarla, alguien podría estar usándola” Si no sabes quién está usando una API deprecada después de 6+ meses de aviso, eso es un problema de gobernanza. Clientes desconocidos usando endpoints no documentados es peor que una interrupción temporal.

Error 2: Mantener APIs Zombie “por si acaso” Cada API ejecutándose cuesta dinero (infraestructura, monitoreo de seguridad, cumplimiento) y crea riesgo. Si nadie está dispuesto a ser su dueño, debería apagarse.

Error 3: Asumir que clientes de v2 migraron Solo porque lanzaste v2 no significa que todos los clientes actualizaron. Mide explícitamente el tráfico a v1 y contacta usuarios de alto volumen antes de la deprecación.

Error 4: Sin plan de comunicación de deprecación Anunciar deprecación en notas de release no es suficiente. Envía emails a clientes registrados, agrega headers de deprecación a respuestas de la API y registra qué clientes todavía usan endpoints deprecados.

API Zombie vs Shadow API

Ambas requieren remediación similar: Identificar propietarios, evaluar uso, planear migración o sunset.

Proceso de Deprecación

Deprecación Saludable de API:

// 1. Anunciar deprecación con línea de tiempo (6-12 meses)
app.use('/api/v1/*', (req, res, next) => {
  res.set('Sunset', 'Sat, 31 Dec 2024 23:59:59 GMT');
  res.set('Deprecation', 'true');
  res.set('Link', '<https://api.example.com/v2>; rel="successor-version"');
  next();
});

// 2. Registrar qué clientes todavía usan endpoints deprecados
app.use('/api/v1/*', (req, res, next) => {
  logDeprecatedUsage({
    endpoint: req.path,
    client: req.headers['user-agent'],
    timestamp: Date.now()
  });
  next();
});

// 3. Contactar clientes de alto volumen directamente
// 4. Después de la fecha de sunset, devolver 410 Gone
app.use('/api/v1/*', (req, res) => {
  res.status(410).json({
    error: 'API versión 1 fue descontinuada el 31 Dic 2024',
    migration: 'https://docs.example.com/migration/v1-to-v2'
  });
});

Herramientas Relacionadas

Gestión del Ciclo de Vida de APIs:

• Postman: Seguir versiones de APIs y estado de deprecación
• SwaggerHub: Documentar líneas de tiempo de deprecación
• Azure API Center: Inventario centralizado de APIs con seguimiento de propiedad

Monitoreo:

• Datadog: Alertar sobre tráfico a endpoints deprecados
• New Relic: Seguir qué clientes usan qué versiones de API
• Akto: Detectar APIs sin mantener mediante análisis de metadata

Evaluación: Usa la Herramienta de Detección de Shadow APIs - también detecta APIs Zombie analizando metadata de propiedad.

Lectura Adicional

📚 Libro: “Cómo Identificar Shadow APIs Con Herramientas Open Source”

Aunque enfocado en Shadow APIs, este libro cubre gobernanza completa de APIs incluyendo detección de APIs Zombie y estrategias de deprecación.

• 🇬🇧 Edición en Inglés
• 🇪🇸 Edición en Español

Capítulos relevantes:

• Capítulo 4: Descubrimiento de APIs y Gestión de Inventario
• Capítulo 6: Marcos de Gobernanza para el Ciclo de Vida de APIs
• Capítulo 8: Estrategias de Deprecación y Sunset

Términos Relacionados