Cómo Usar la API de Heroku: Guía Completa de Integración (2026)

TL;DR

La API de Heroku permite a los desarrolladores automatizar la implementación, gestionar aplicaciones, configurar complementos y escalar la infraestructura de forma programática. Utiliza autenticación OAuth 2.0 y basada en tokens, puntos finales RESTful para aplicaciones, dynos, compilaciones y pipelines, con límites de tasa de 10,000 solicitudes por hora por cuenta. Esta guía cubre la configuración de la autenticación, los puntos finales principales, la integración de CI/CD y las estrategias de implementación en producción.

Prueba Apidog hoy

Introducción

Heroku impulsa más de 4 millones de aplicaciones en más de 170 países. Para los desarrolladores que crean automatización de implementaciones, pipelines de CI/CD o herramientas de gestión de múltiples aplicaciones, la integración de la API de Heroku no es opcional, es esencial.

Aquí está la realidad: los equipos que gestionan más de 10 aplicaciones de Heroku pierden entre 8 y 12 horas semanales en implementaciones manuales y cambios de configuración. Una sólida integración de la API de Heroku automatiza las implementaciones, escala los dynos según el tráfico y sincroniza la configuración entre entornos.

Esta guía detalla el proceso completo de integración de la API de Heroku. Aprenderá sobre la autenticación de tokens, la gestión de aplicaciones y dynos, los pipelines de compilación, el aprovisionamiento de complementos y la resolución de problemas. Al final, tendrá una integración de Heroku lista para producción.

💡 Tip: Apidog simplifica las pruebas de integración de API. Pruebe sus puntos finales de Heroku, valide los flujos de autenticación, inspeccione las respuestas de la API y depure los problemas de configuración en un solo espacio de trabajo. Importe especificaciones de API, simule respuestas y comparta escenarios de prueba con su equipo.

¿Qué es la API de Heroku?

Heroku proporciona una API de plataforma RESTful para gestionar aplicaciones e infraestructura en la plataforma Heroku. La API gestiona:

• Creación, configuración y eliminación de aplicaciones
• Escalado de Dyno y gestión de procesos
• Gestión de compilaciones y lanzamientos
• Aprovisionamiento y configuración de complementos (add-ons)
• Gestión de pipelines y promociones
• Gestión de dominios y certificados SSL
• Configuración de drenaje y monitoreo de logs
• Gestión de equipos y colaboradores

Características Clave

Característica	Descripción
Diseño RESTful	Métodos HTTP estándar con respuestas JSON
Autenticación por Token	Token Bearer con soporte OAuth 2.0
Solicitudes de Rango	Paginación para grandes conjuntos de resultados
Límite de Tasa	10,000 solicitudes por hora por cuenta
Creaciones Idempotentes	Comportamiento de reintento seguro para escrituras
Compresión Gzip	Compresión de respuestas para ahorrar ancho de banda

Visión General de la Arquitectura de la API

Heroku utiliza una estructura de API REST con versiones:

https://api.heroku.com/

La API sigue la especificación JSON:API con patrones y relaciones de recursos consistentes.

Versiones de API Comparadas

Versión	Estado	Autenticación	Caso de Uso
Platform API (v3)	Actual	Token Bearer	Todas las nuevas integraciones
GitHub Integration	Actual	OAuth 2.0	Aplicaciones conectadas a GitHub
Container Registry	Actual	Autenticación Docker	Implementaciones de contenedores

Primeros Pasos: Configuración de la Autenticación

Paso 1: Cree su Cuenta de Heroku

Antes de acceder a la API, necesita una cuenta de Heroku:

1. Visite el sitio web de Heroku
2. Haga clic en Sign Up (Registrarse) y cree una cuenta
3. Verifique su dirección de correo electrónico
4. Complete la configuración de la cuenta

Paso 2: Instale Heroku CLI

La CLI ayuda a generar tokens de API y probar comandos:

# macOS
brew tap heroku/brew && brew install heroku

# Windows
npm install -g heroku

# Linux
curl https://cli-assets.heroku.com/install.sh | sh

Paso 3: Genere el Token de la API

Autentíquese con Heroku CLI:

# Inicie sesión en Heroku
heroku login

# Esto abre un navegador para la autenticación
# Después de iniciar sesión, su token se almacena localmente

Recupere su token de la API:

# Ver su token de autorización actual
heroku authorizations:create --short-lived

# O cree un token de larga duración (para CI/CD)
heroku authorizations:create --description "CI/CD Pipeline" --expires-in "1 year"

Nota de seguridad: Almacene los tokens en variables de entorno, nunca en el código:

# archivo .env
HEROKU_API_KEY="su_clave_api_aquí"
HEROKU_APP_NAME="nombre_de_su_app"

Paso 4: Entender la Autenticación por Token

Heroku utiliza la autenticación por token Bearer:

Authorization: Bearer {api_key}
Accept: application/vnd.heroku+json; version=3

Cada solicitud a la API requiere estos encabezados.

Paso 5: Realice su Primera Llamada a la API

Pruebe su autenticación:

curl -n https://api.heroku.com/account \
  -H "Accept: application/vnd.heroku+json; version=3" \
  -H "Authorization: Bearer $HEROKU_API_KEY"

Respuesta esperada:

{
  "id": "user-id-here",
  "email": "[e-mail]",
  "name": "Developer Name",
  "created_at": "2024-01-15T10:30:00Z",
  "updated_at": "2026-03-20T14:22:00Z"
}

Paso 6: Implementar la Autenticación en el Código

Cree un cliente de API reutilizable:

const HEROKU_API_KEY = process.env.HEROKU_API_KEY;
const HEROKU_BASE_URL = 'https://api.heroku.com';

const herokuRequest = async (endpoint, options = {}) => {
  const response = await fetch(`${HEROKU_BASE_URL}${endpoint}`, {
    ...options,
    headers: {
      'Authorization': `Bearer ${HEROKU_API_KEY}`,
      'Accept': 'application/vnd.heroku+json; version=3',
      'Content-Type': 'application/json',
      ...options.headers
    }
  });

  if (!response.ok) {
    const error = await response.json();
    throw new Error(`Heroku API Error: ${error.message}`);
  }

  return response.json();
};

// Uso
const account = await herokuRequest('/account');
console.log(`Sesión iniciada como: ${account.email}`);

---

Gestión de Aplicaciones

Crear una Nueva Aplicación

Cree una aplicación de Heroku programáticamente:

const createApp = async (appName, region = 'us') => {
  const response = await herokuRequest('/apps', {
    method: 'POST',
    body: JSON.stringify({
      name: appName,
      region: region
    })
  });

  return response;
};

// Uso
const app = await createApp('mi-aplicacion-genial-2026');
console.log(`Aplicación creada: ${app.name}`);
console.log(`URL de Git: ${app.git_url}`);
console.log(`URL web: ${app.web_url}`);

Respuesta Esperada de la Aplicación

{
  "id": "uuid-de-app-aqui",
  "name": "mi-aplicacion-genial-2026",
  "region": { "name": "us" },
  "created_at": "2026-03-25T10:00:00Z",
  "updated_at": "2026-03-25T10:00:00Z",
  "git_url": "https://git.heroku.com/mi-aplicacion-genial-2026.git",
  "web_url": "https://mi-aplicacion-genial-2026.herokuapp.com",
  "owner": { "email": "[e-mail]" },
  "build_stack": { "name": "heroku-24" }
}

Listar sus Aplicaciones

Obtenga todas las aplicaciones de su cuenta:

const listApps = async (limit = 50) => {
  const response = await herokuRequest(`/apps?limit=${limit}`);
  return response;
};

// Uso
const apps = await listApps();
apps.forEach(app => {
  console.log(`${app.name} - ${app.web_url}`);
});

Obtener Detalles de la Aplicación

Recupere información detallada de la aplicación:

const getApp = async (appName) => {
  const response = await herokuRequest(`/apps/${appName}`);
  return response;
};

// Uso
const app = await getApp('mi-aplicacion-genial-2026');
console.log(`Stack: ${app.build_stack.name}`);
console.log(`Región: ${app.region.name}`);

Actualizar la Configuración de la Aplicación

Modifique la configuración de la aplicación:

const updateApp = async (appName, updates) => {
  const response = await herokuRequest(`/apps/${appName}`, {
    method: 'PATCH',
    body: JSON.stringify(updates)
  });

  return response;
};

// Uso - cambiar nombre de la aplicación
const updated = await updateApp('nombre-antiguo-app', {
  name: 'nombre-nuevo-app'
});

Eliminar una Aplicación

Elimine una aplicación de su cuenta:

const deleteApp = async (appName) => {
  await herokuRequest(`/apps/${appName}`, {
    method: 'DELETE'
  });

  console.log(`Aplicación ${appName} eliminada exitosamente`);
};

Gestión de Dynos

Escalado de Dynos

Escale su aplicación hacia arriba o hacia abajo:

const scaleDyno = async (appName, processType, quantity) => {
  const response = await herokuRequest(`/apps/${appName}/formation/${processType}`, {
    method: 'PATCH',
    body: JSON.stringify({
      quantity: quantity
    })
  });

  return response;
};

// Uso - escalar dynos web a 3
const formation = await scaleDyno('mi-app', 'web', 3);
console.log(`Escalado a ${formation.quantity} dynos de ${processType}`);

Obtener Formación de Dynos

Ver la configuración actual de los dynos:

const getFormation = async (appName, processType = null) => {
  const endpoint = processType
    ? `/apps/${appName}/formation/${processType}`
    : `/apps/${appName}/formation`;

  const response = await herokuRequest(endpoint);
  return response;
};

// Uso
const formation = await getFormation('mi-app');
formation.forEach(proc => {
  console.log(`${proc.type}: ${proc.quantity} dynos (en ${proc.size})`);
});

Tamaños de Dyno Disponibles

Tipo de Dyno	Caso de Uso	Costo/Mes
eco	Proyectos de hobby, demos	$5
basic	Aplicaciones producción pequeñas	$7
standard-1x	Cargas de trabajo estándar	$25
standard-2x	Aplicaciones alto rendimiento	$50
performance	Producción crítica	$250+
private	Aislamiento empresarial	Personalizado

Reiniciar Dynos

Reiniciar todos los dynos de una aplicación:

const restartDynos = async (appName, processType = null) => {
  const endpoint = processType
    ? `/apps/${appName}/formation/${processType}`
    : `/apps/${appName}/dynos`;

  await herokuRequest(endpoint, {
    method: 'DELETE'
  });

  console.log(`Dynos reiniciados para ${appName}`);
};

Ejecutar Dynos Únicos

Ejecute comandos en dynos aislados:

const runCommand = async (appName, command) => {
  const response = await herokuRequest(`/apps/${appName}/dynos`, {
    method: 'POST',
    body: JSON.stringify({
      command: command,
      size: 'standard-1x'
    })
  });

  return response;
};

// Uso - ejecutar migración de base de datos
const dyno = await runCommand('mi-app', 'npm run migrate');
console.log(`Dyno iniciado: ${dyno.id}`);

Variables de Configuración

Obtener Variables de Configuración

Recuperar variables de entorno:

const getConfigVars = async (appName) => {
  const response = await herokuRequest(`/apps/${appName}/config-vars`);
  return response;
};

// Uso
const config = await getConfigVars('mi-app');
console.log(`DATABASE_URL: ${config.DATABASE_URL}`);
console.log(`NODE_ENV: ${config.NODE_ENV}`);

Establecer Variables de Configuración

Actualizar variables de entorno:

const setConfigVars = async (appName, variables) => {
  const response = await herokuRequest(`/apps/${appName}/config-vars`, {
    method: 'PATCH',
    body: JSON.stringify(variables)
  });

  return response;
};

// Uso
const updated = await setConfigVars('mi-app', {
  NODE_ENV: 'production',
  API_SECRET: 'su-clave-secreta',
  LOG_LEVEL: 'info'
});

Mejores Prácticas para Variables de Configuración

1. Nunca incluya secretos en código – Use variables de entorno para datos sensibles.
2. Separe configuraciones por entorno – Variables diferentes para staging y producción.
3. Rote los secretos regularmente – Actualice claves de API y contraseñas cada trimestre.
4. Prefije las variables relacionadas – Ejemplo: STRIPE_SECRET_KEY, STRIPE_WEBHOOK_SECRET

Gestión de Compilaciones y Lanzamientos

Crear una Compilación

Implemente código a través de la API:

const createBuild = async (appName, sourceBlobUrl) => {
  const response = await herokuRequest(`/apps/${appName}/builds`, {
    method: 'POST',
    body: JSON.stringify({
      source_blob: {
        url: sourceBlobUrl
      }
    })
  });

  return response;
};

// Uso
const build = await createBuild('mi-app', 'https://storage.example.com/source.tar.gz');
console.log(`Compilación iniciada: ${build.id}`);
console.log(`Estado: ${build.status}`);

Obtener el Estado de la Compilación

Verificar el progreso de la compilación:

const getBuild = async (appName, buildId) => {
  const response = await herokuRequest(`/apps/${appName}/builds/${buildId}`);
  return response;
};

// Sondear hasta completar
const checkBuildStatus = async (appName, buildId, maxAttempts = 30) => {
  for (let i = 0; i < maxAttempts; i++) {
    const build = await getBuild(appName, buildId);

    if (build.status === 'succeeded') {
      console.log('¡Compilación exitosa!');
      return build;
    } else if (build.status === 'failed') {
      throw new Error(`Compilación fallida: ${build.output}`);
    }

    console.log(`Compilación en curso... intento ${i + 1}`);
    await new Promise(resolve => setTimeout(resolve, 5000));
  }

  throw new Error('Tiempo de espera de la compilación agotado');
};

Listar Lanzamientos

Ver historial de lanzamientos:

const listReleases = async (appName, limit = 10) => {
  const response = await herokuRequest(`/apps/${appName}/releases?limit=${limit}`);
  return response;
};

// Uso
const releases = await listReleases('mi-app');
releases.forEach(release => {
  console.log(`v${release.version} - ${release.description} - ${release.created_at}`);
});

Revertir a un Lanzamiento Anterior

Revierta a una versión anterior:

const rollback = async (appName, releaseId) => {
  const response = await herokuRequest(`/apps/${appName}/releases`, {
    method: 'POST',
    body: JSON.stringify({
      rollback: releaseId
    })
  });

  return response;
};

// Uso - revertir a la versión 42
const rollbackRelease = await rollback('mi-app', 42);
console.log(`Revertido a la v${rollbackRelease.version}`);

Gestión de Pipelines

Crear un Pipeline

Configure pipelines de CI/CD:

const createPipeline = async (pipelineName) => {
  const response = await herokuRequest('/pipelines', {
    method: 'POST',
    body: JSON.stringify({
      name: pipelineName
    })
  });

  return response;
};

// Uso
const pipeline = await createPipeline('mi-pipeline-app');
console.log(`Pipeline creado: ${pipeline.id}`);

Agregar Aplicaciones al Pipeline

Conecte aplicaciones a las etapas del pipeline:

const addAppToPipeline = async (pipelineId, appName, stage) => {
  const response = await herokuRequest('/pipeline-couplings', {
    method: 'POST',
    body: JSON.stringify({
      pipeline: pipelineId,
      app: appName,
      stage: stage // 'development', 'staging', 'production'
    })
  });

  return response;
};

// Uso
await addAppToPipeline(pipelineId, 'mi-app-dev', 'development');
await addAppToPipeline(pipelineId, 'mi-app-staging', 'staging');
await addAppToPipeline(pipelineId, 'mi-app-prod', 'production');

Promocionar Slug a la Siguiente Etapa

Mueva código a través del pipeline:

const promoteSlug = async (slugId, toApp) => {
  await herokuRequest('/promotions', {
    method: 'POST',
    body: JSON.stringify({
      from: toApp, // Aplicación de origen
      to: toApp,   // Aplicación de destino (siguiente etapa)
      slug: slugId
    })
  });

  console.log(`Slug ${slugId} promocionado a ${toApp}`);
};

Gestión de Complementos

Aprovisionamiento de Complementos (Add-Ons)

Instale complementos de Heroku:

const provisionAddon = async (appName, addonPlan, config = {}) => {
  const response = await herokuRequest('/addon-attachments', {
    method: 'POST',
    body: JSON.stringify({
      app: appName,
      plan: addonPlan,
      config: config
    })
  });

  return response;
};

// Uso - aprovisionar PostgreSQL
const db = await provisionAddon('mi-app', 'heroku-postgresql:mini', {});
console.log(`Base de datos aprovisionada: ${db.addon.name}`);
console.log(`DATABASE_URL: ${db.addon.config_vars.DATABASE_URL}`);

Complementos Populares

Complemento	Plan	Precio Inicial	Caso de Uso
heroku-postgresql	mini	$5/mes	Base de datos producción
heroku-redis	mini	$5/mes	Caché, sesiones
papertrail	choklad	$7/mes	Agregación de logs
sentry	developer	Gratis	Seguimiento de errores
mailgun	sandbox	Gratis	Entrega de correo
newrelic	lite	Gratis	Monitoreo de aplicaciones

Listar Complementos

Ver complementos instalados:

const listAddons = async (appName) => {
  const response = await herokuRequest(`/apps/${appName}/addons`);
  return response;
};

// Uso
const addons = await listAddons('mi-app');
addons.forEach(addon => {
  console.log(`${addon.plan.name} - $${addon.pricing.plan.price} - ${addon.state}`);
});

Eliminar Complementos

Desinstalar complementos:

const removeAddon = async (appName, addonId) => {
  await herokuRequest(`/apps/${appName}/addons/${addonId}`, {
    method: 'DELETE'
  });

  console.log(`Complemento ${addonId} eliminado de ${appName}`);
};

Gestión de Dominios y SSL

Agregar Dominios Personalizados

Configure dominios personalizados:

const addDomain = async (appName, domainName) => {
  const response = await herokuRequest(`/apps/${appName}/domains`, {
    method: 'POST',
    body: JSON.stringify({
      hostname: domainName
    })
  });

  return response;
};

// Uso
const domain = await addDomain('mi-app', 'api.example.com');
console.log(`Objetivo CNAME: ${domain.cname}`);

Configurar Certificados SSL

Agregue SSL a dominios personalizados:

const addSslCertificate = async (appName, domainId, certificateChain, privateKey) => {
  const response = await herokuRequest(`/apps/${appName}/domains/${domainId}/ssl_endpoint`, {
    method: 'PATCH',
    body: JSON.stringify({
      ssl_cert: {
        cert_chain: certificateChain,
        private_key: privateKey
      }
    })
  });

  return response;
};

SSL Automatizado con ACM

Habilite la Gestión Automática de Certificados:

const enableACM = async (appName, domainName) => {
  const response = await herokuRequest(`/apps/${appName}/domains/${domainName}/sni_endpoint`, {
    method: 'POST',
    body: JSON.stringify({
      kind: 'acm'
    })
  });

  return response;
};

Límite de Tasa y Cuotas

Comprensión de los Límites de Tasa

Heroku aplica límites de tasa para proteger la estabilidad de la API:

• Límite Estándar: 10,000 solicitudes por hora por cuenta
• Ventana: Ventana rodante de 60 minutos
• Restablecimiento: Automático después de que la ventana pase

Exceder los límites resulta en respuestas HTTP 429 (Demasiadas Solicitudes).

Implementación del Manejo de Límites de Tasa

Utilice retroceso exponencial para los reintentos:

const makeRateLimitedRequest = async (endpoint, options = {}, maxRetries = 3) => {
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      const response = await herokuRequest(endpoint, options);

      // Verificar encabezados de límite de tasa
      const remaining = response.headers.get('RateLimit-Remaining');
      const resetTime = response.headers.get('RateLimit-Reset');

      if (remaining < 100) {
        console.warn(`Cuota baja restante: ${remaining}, se restablece en ${resetTime}`);
      }

      return response;
    } catch (error) {
      if (error.message.includes('429') && attempt < maxRetries) {
        const delay = Math.pow(2, attempt) * 1000;
        console.log(`Límite de tasa alcanzado. Reintentando en ${delay}ms...`);
        await new Promise(resolve => setTimeout(resolve, delay));
      } else {
        throw error;
      }
    }
  }
};

Encabezados de Límite de Tasa

Heroku incluye estos encabezados en cada respuesta:

Encabezado	Descripción
RateLimit-Limit	Máximo de solicitudes por hora
RateLimit-Remaining	Solicitudes restantes en la ventana
RateLimit-Reset	Marca de tiempo Unix de reinicio

Resolución de Problemas Comunes

Problema: la autenticación falla con 401

Síntomas: Recibiendo errores de "Invalid credentials".

Soluciones:

1. Verifique que la clave API sea correcta: heroku authorizations
2. Asegúrese de que el token no haya expirado (los tokens de larga duración duran 1 año)
3. Verifique si hay espacios en blanco adicionales en la variable de entorno
4. Vuelva a generar el token si es necesario: heroku authorizations:create

Problema: el nombre de la aplicación ya está en uso

Síntomas: Recibiendo el error "name is already taken".

Soluciones:

1. Utilice nombres globalmente únicos - incluya el equipo o un sufijo aleatorio
2. Genere nombres basados en UUID: app-${Date.now()}
3. Utilice prefijos de espacio de nombres: nombredelequipo-nombreapp-entorno

const generateUniqueAppName = (baseName) => {
  const timestamp = Date.now().toString(36);
  const random = Math.random().toString(36).substring(2, 6);
  return `${baseName}-${timestamp}-${random}`;
};

Problema: la formación de Dyno falla

Síntomas: Las operaciones de escalado devuelven errores.

Soluciones:

1. Verifique que el tipo de proceso exista en el Procfile
2. Compruebe que la cuenta tenga cuota de dyno disponible
3. Asegúrese de que la aplicación no esté suspendida
4. Revise el uso de horas de dyno: heroku ps --app=mi-app

Problema: la compilación falla por tiempo de espera

Síntomas: Las compilaciones se cuelgan o agotan el tiempo de espera después de 30 minutos.

Soluciones:

1. Optimice la selección de buildpack para su lenguaje
2. Almacene las dependencias en caché correctamente
3. Divida las compilaciones grandes en implementaciones más pequeñas
4. Utilice slugs precompilados para una implementación más rápida

Problema: Límite de tasa excedido

Síntomas: Recibiendo respuestas HTTP 429.

Soluciones:

1. Implemente la cola de solicitudes
2. Use retroceso exponencial para los reintentos
3. Agrupe las solicitudes cuando sea posible
4. Monitoree los encabezados de límite de tasa de forma proactiva

// Limitador de tasa simple
class HerokuRateLimiter {
  constructor(requestsPerMinute = 150) {
    this.queue = [];
    this.interval = 60000 / requestsPerMinute;
    this.processing = false;
  }

  async add(requestFn) {
    return new Promise((resolve, reject) => {
      this.queue.push({ requestFn, resolve, reject });
      this.process();
    });
  }

  async process() {
    if (this.processing || this.queue.length === 0) return;

    this.processing = true;

    while (this.queue.length > 0) {
      const { requestFn, resolve, reject } = this.queue.shift();

      try {
        const result = await requestFn();
        resolve(result);
      } catch (error) {
        reject(error);
      }

      if (this.queue.length > 0) {
        await new Promise(r => setTimeout(r, this.interval));
      }
    }

    this.processing = false;
  }
}

Lista de Verificación de Implementación en Producción

Antes de salir a producción:

• [ ] Utilice tokens de API de larga duración para CI/CD
• [ ] Almacene los tokens en una gestión de secretos segura (Vault, AWS Secrets Manager)
• [ ] Implemente limitación de tasa y cola de solicitudes
• [ ] Agregue un manejo de errores exhaustivo
• [ ] Configure el registro para todas las llamadas a la API
• [ ] Monitoree el uso de horas de dyno
• [ ] Configure los drenajes de logs para el registro externo
• [ ] Configure promociones de pipeline para CI/CD
• [ ] Habilite la Gestión Automática de Certificados
• [ ] Configure la estrategia de respaldo para las bases de datos

Monitoreo y Alertas

Rastree estas métricas:

const metrics = {
  apiCalls: {
    total: 0,
    successful: 0,
    failed: 0,
    rateLimited: 0
  },
  dynoHours: {
    used: 0,
    quota: 1000
  },
  deployments: {
    successful: 0,
    failed: 0,
    avg_duration: 0
  }
};

// Alerta sobre alta tasa de fallos
const failureRate = metrics.apiCalls.failed / metrics.apiCalls.total;

if (failureRate > 0.05) {
  sendAlert('Tasa de fallos de la API de Heroku superior al 5%');
}

// Alerta sobre el uso de horas de dyno
if (metrics.dynoHours.used > metrics.dynoHours.quota * 0.8) {
  sendAlert('Uso de horas de Dyno superior al 80%');
}

Casos de Uso en el Mundo Real

Pipeline Automatizado de CI/CD

Un equipo de SaaS automatiza las implementaciones desde GitHub:

• Desafío: Las implementaciones manuales causaban errores y retrasos
• Solución: Integración de GitHub Actions + Heroku API
• Resultado: Implementaciones sin tiempo de inactividad, lanzamientos un 90% más rápidos

Flujo de implementación:

1. Un push a GitHub dispara el flujo de trabajo
2. Las pruebas se ejecutan en CI
3. La API de Heroku crea una compilación a partir del blob fuente
4. Promocionar a través de staging a producción
5. Notificar al equipo sobre el éxito/fallo

Gestión de Múltiples Entornos

Una consultora gestiona más de 50 aplicaciones de clientes:

• Desafío: Sincronización manual de la configuración entre entornos
• Solución: Gestión centralizada de la configuración con la API de Heroku
• Resultado: Configuraciones consistentes, 8 horas/semana ahorradas

Puntos clave de integración:

• Sincronización de variables de configuración entre desarrollo/staging/producción
• Aprovisionamiento automatizado de complementos
• Operaciones masivas para la incorporación de clientes

Autoescalado Basado en el Tráfico

Una plataforma de comercio electrónico maneja picos de tráfico:

• Desafío: Escalado manual durante eventos de ventas
• Solución: Autoescalado basado en carga con la API de Heroku
• Resultado: Cero tiempo de inactividad durante picos de tráfico de 10x

Lógica de autoescalado:

• Monitorear los tiempos de respuesta a través de la API de métricas
• Escalar hacia arriba cuando la latencia p95 > 500ms
• Escalar hacia abajo durante períodos de bajo tráfico
• Alertar sobre utilización alta sostenida

Conclusión

La API de Heroku proporciona acceso completo a la funcionalidad de la plataforma. Puntos clave:

• La autenticación por token Bearer requiere almacenamiento y rotación seguros
• El límite de tasa (10K/hora) requiere monitoreo proactivo
• La gestión de pipelines permite flujos de trabajo robustos de CI/CD
• El manejo adecuado de errores asegura la fiabilidad de la implementación
• Apidog agiliza las pruebas de API y la colaboración en equipo para las integraciones de Heroku

Sección de Preguntas Frecuentes

¿Para qué se utiliza la API de Heroku?

La API de Heroku permite la gestión programática de aplicaciones, dynos, complementos e infraestructura. Los casos de uso comunes incluyen la automatización de CI/CD, herramientas de gestión de múltiples aplicaciones, sistemas de autoescalado y paneles de monitoreo de infraestructura.

¿Cómo obtengo una clave API de Heroku?

Instale Heroku CLI, ejecute heroku login y luego cree una autorización con heroku authorizations:create. Almacene el token devuelto de forma segura en variables de entorno.

¿Es gratuita la API de Heroku?

Sí, la API de Heroku es gratuita. Sin embargo, usted paga por los recursos que aprovisiona (dynos, complementos, etc.). Los límites de tasa de la API son de 10,000 solicitudes por hora por cuenta.

¿Qué autenticación utiliza la API de Heroku?

Heroku utiliza autenticación por token Bearer. Incluya el encabezado Authorization: Bearer {api_key} en cada solicitud. Los tokens pueden ser de corta duración (1 hora) o de larga duración (hasta 1 año).

¿Cómo manejo los límites de tasa de la API de Heroku?

Monitoree el encabezado RateLimit-Remaining e implemente una cola de solicitudes. Utilice retroceso exponencial al recibir respuestas HTTP 429. Manténgase por debajo de 150 solicitudes por minuto para una operación segura.

¿Puedo implementar sin Git?

Sí. Utilice la API de Builds para implementar desde una URL de blob fuente. Cargue su código al almacenamiento en la nube (S3, GCS) y haga referencia a la URL en su solicitud de compilación.

¿Cómo automatizo las implementaciones?

Utilice la API de Pipeline para configurar CI/CD. Cree compilaciones, promocione slugs a través de etapas e integre con GitHub o sistemas de CI personalizados.

¿Cuál es la diferencia entre un lanzamiento (release) y una compilación (build)?

Una compilación compila su código fuente en un slug. Un lanzamiento combina un slug con variables de configuración para crear una versión implementable de su aplicación.

¿Cómo revierto una implementación fallida?

Utilice la API de Releases para listar los lanzamientos recientes, luego POST a /releases con rollback: <release_id>. Heroku crea un nuevo lanzamiento en la versión anterior.

¿Puedo gestionar varias cuentas de Heroku?

Sí. Utilice tokens de API separados para cada cuenta y alterne entre ellos cambiando la variable de entorno HEROKU_API_KEY.