Emre Demir

Posted on Mar 25 • Originally published at apidog.com

Heroku API nutzen: Komplette Integrationsanleitung (2026)

#api #automation #devops #tutorial

Kurz gesagt

Die Heroku API ermöglicht Entwicklern die programmatische Automatisierung der Bereitstellung, Verwaltung von Anwendungen, Konfiguration von Add-ons und Skalierung der Infrastruktur. Sie verwendet OAuth 2.0 und token-basierte Authentifizierung, RESTful-Endpunkte für Apps, Dynos, Builds und Pipelines, mit Ratenbegrenzungen von 10.000 Anfragen pro Stunde und Konto. Dieser Leitfaden behandelt die Einrichtung der Authentifizierung, Kern-Endpunkte, CI/CD-Integration und Strategien für die Produktionsbereitstellung.

Teste Apidog noch heute

Einleitung

Heroku betreibt über 4 Millionen Anwendungen in mehr als 170 Ländern. Für Entwickler, die Bereitstellungsautomatisierung, CI/CD-Pipelines oder Tools zur Verwaltung mehrerer Anwendungen entwickeln, ist die Heroku-API-Integration nicht optional – sie ist unerlässlich.

Hier ist die Realität: Teams, die mehr als 10 Heroku-Apps verwalten, verlieren wöchentlich 8-12 Stunden durch manuelle Bereitstellungen und Konfigurationsänderungen. Eine solide Heroku-API-Integration automatisiert Bereitstellungen, skaliert Dynos basierend auf dem Datenverkehr und synchronisiert die Konfiguration über Umgebungen hinweg.

Dieser Leitfaden führt dich durch den gesamten Heroku-API-Integrationsprozess – von der Authentifizierung über App- und Dyno-Verwaltung bis zu Build-Pipelines, Add-on-Bereitstellung und Fehlerbehebung. Am Ende hast du eine produktionsreife Heroku-Integration.

💡 Tipp: Apidog vereinfacht das Testen der API-Integration. Teste deine Heroku-Endpunkte, validiere Authentifizierungsabläufe, prüfe API-Antworten und debugge Konfigurationsprobleme in einem Arbeitsbereich. Importiere API-Spezifikationen, modelliere Antworten und teile Testszenarien mit deinem Team.

Was ist die Heroku-API?

Heroku bietet eine RESTful-Plattform-API zur Verwaltung von Anwendungen und Infrastruktur auf der Heroku-Plattform. Die API unterstützt:

Erstellung, Konfiguration und Löschung von Anwendungen
Dyno-Skalierung und Prozessverwaltung
Build- und Release-Management
Add-on-Bereitstellung und -Konfiguration
Pipeline- und Promotion-Management
Domain- und SSL-Zertifikatsverwaltung
Log-Drain- und Überwachungseinrichtung
Team- und Kollaborationsverwaltung

Hauptmerkmale

Funktion	Beschreibung
RESTful-Design	Standard-HTTP-Methoden mit JSON-Antworten
Token-Authentifizierung	Bearer-Token mit OAuth 2.0-Unterstützung
Bereichsanfragen	Paginierung für große Ergebnismengen
Ratenbegrenzung	10.000 Anfragen pro Stunde und Konto
Idempotente Erstellungen	Sicheres Wiederholungsverhalten für Schreibvorgänge
Gzip-Komprimierung	Antwortkomprimierung zur Bandbreiteneinsparung

Übersicht der API-Architektur

Heroku verwendet eine versionierte REST-API-Struktur:

https://api.heroku.com/

Die API hält sich an die JSON:API-Spezifikation mit konsistenten Ressourcen und Beziehungen.

API-Versionen im Vergleich

Version	Status	Authentifizierung	Anwendungsfall
Plattform-API (v3)	Aktuell	Bearer-Token	Alle neuen Integrationen
GitHub-Integration	Aktuell	OAuth 2.0	Mit GitHub verbundene Apps
Container-Registrierung	Aktuell	Docker-Authentifizierung	Container-Bereitstellungen

Erste Schritte: Authentifizierung einrichten

Schritt 1: Heroku-Konto erstellen

Bevor du auf die API zugreifst, benötigst du ein Heroku-Konto:

Besuche die Heroku-Website
Klicke auf Registrieren und erstelle dein Konto
Bestätige deine E-Mail-Adresse
Schließe die Kontoeinrichtung ab

Schritt 2: Heroku CLI installieren

Die Heroku CLI hilft beim Generieren von API-Tokens und Testbefehlen:

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

# Windows
npm install -g heroku

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

Schritt 3: API-Token generieren

Authentifiziere dich mit der Heroku CLI:

# Bei Heroku anmelden
heroku login

Nach der Anmeldung wird dein Token lokal gespeichert. Rufe dein API-Token ab:

# Kurzlebiges Token anzeigen
heroku authorizations:create --short-lived

# Langlebiges Token (für CI/CD) erstellen
heroku authorizations:create --description "CI/CD Pipeline" --expires-in "1 year"

Sicherheit: Speichere Tokens in Umgebungsvariablen – niemals im Code.

# .env-Datei
HEROKU_API_KEY="ihr_api_schlüssel_hier"
HEROKU_APP_NAME="ihre-app-name"

Schritt 4: Token-Authentifizierung verstehen

Heroku verwendet Bearer-Token-Authentifizierung. Jeder Request benötigt:

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

Schritt 5: Ersten API-Aufruf tätigen

Teste die Authentifizierung:

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

Erwartete Antwort:

{
  "id": "benutzer-id-hier",
  "email": "entwickler@example.com",
  "name": "Entwickler Name",
  "created_at": "2024-01-15T10:30:00Z",
  "updated_at": "2026-03-20T14:22:00Z"
}

Schritt 6: Authentifizierung im Code implementieren

Erstelle einen wiederverwendbaren API-Client, z.B. in JavaScript/Node.js:

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 Fehler: ${error.message}`);
  }

  return response.json();
};

// Beispiel
const account = await herokuRequest('/account');
console.log(`Angemeldet als: ${account.email}`);

Anwendungsverwaltung

Neue App erstellen

Programmatisch eine App anlegen:

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

// Beispiel
const app = await createApp('meine-super-app-2026');
console.log(`App erstellt: ${app.name}`);
console.log(`Git URL: ${app.git_url}`);
console.log(`Web URL: ${app.web_url}`);

Erwartete App-Antwort

{
  "id": "app-uuid-hier",
  "name": "meine-super-app-2026",
  "region": { "name": "us" },
  "created_at": "2026-03-25T10:00:00Z",
  "updated_at": "2026-03-25T10:00:00Z",
  "git_url": "https://git.heroku.com/meine-super-app-2026.git",
  "web_url": "https://meine-super-app-2026.herokuapp.com",
  "owner": { "email": "entwickler@example.com" },
  "build_stack": { "name": "heroku-24" }
}

Apps auflisten

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

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

App-Details abrufen

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

// Beispiel
const app = await getApp('meine-super-app-2026');
console.log(`Stack: ${app.build_stack.name}`);
console.log(`Region: ${app.region.name}`);

App-Konfiguration aktualisieren

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

// Beispiel: App-Namen ändern
const updated = await updateApp('alter-app-name', {
  name: 'neuer-app-name'
});

App löschen

const deleteApp = async (appName) => {
  await herokuRequest(`/apps/${appName}`, {
    method: 'DELETE'
  });
  console.log(`App ${appName} erfolgreich gelöscht`);
};

Dyno-Verwaltung

Dynos skalieren

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

// Beispiel: Web-Dynos auf 3 skalieren
const formation = await scaleDyno('meine-app', 'web', 3);
console.log(`Skaliert auf ${formation.quantity} ${processType} Dynos`);

Dyno-Formation abrufen

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

// Beispiel
const formation = await getFormation('meine-app');
formation.forEach(proc => {
  console.log(`${proc.type}: ${proc.quantity} Dynos (@ ${proc.size})`);
});

Verfügbare Dyno-Größen

Dyno-Typ	Anwendungsfall	Kosten/Monat
eco	Hobbyprojekte, Demos	5 $
basic	Kleine Produktionsanwendungen	7 $
standard-1x	Standard-Workloads	25 $
standard-2x	Hochleistungsanwendungen	50 $
performance	Produktionskritische Apps	250 $+
private	Unternehmensisolation	Benutzerdefiniert

Dynos neu starten

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

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

  console.log(`Dynos für ${appName} neu gestartet`);
};

Einmalige Dynos ausführen

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

  return response;
};

// Beispiel: Datenbankmigration ausführen
const dyno = await runCommand('meine-app', 'npm run migrate');
console.log(`Dyno gestartet: ${dyno.id}`);

Konfigurationsvariablen

Konfigurationsvariablen abrufen

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

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

Konfigurationsvariablen setzen

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

// Beispiel
const updated = await setConfigVars('meine-app', {
  NODE_ENV: 'production',
  API_SECRET: 'ihr-geheimschlüssel',
  LOG_LEVEL: 'info'
});

Best Practices für Konfigurationsvariablen

Niemals Geheimnisse committen – Nutze Umgebungsvariablen für sensible Daten.
Separate Konfigurationen pro Umgebung – Staging vs. Produktion trennen.
Geheimnisse regelmäßig rotieren – API-Schlüssel vierteljährlich aktualisieren.
Verwandte Variablen präfixen – z.B. STRIPE_SECRET_KEY.

Build- und Release-Management

Build erstellen

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

  return response;
};

// Beispiel
const build = await createBuild('meine-app', 'https://storage.example.com/source.tar.gz');
console.log(`Build gestartet: ${build.id}`);
console.log(`Status: ${build.status}`);

Build-Status abrufen

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

// Status polling
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('Build erfolgreich!');
      return build;
    } else if (build.status === 'failed') {
      throw new Error(`Build fehlgeschlagen: ${build.output}`);
    }

    console.log(`Build läuft... Versuch ${i + 1}`);
    await new Promise(resolve => setTimeout(resolve, 5000));
  }
  throw new Error('Build-Timeout');
};

Releases auflisten

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

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

Zurücksetzen auf früheres Release

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

  return response;
};

// Beispiel: auf Version 42 zurücksetzen
const rollbackRelease = await rollback('meine-app', 42);
console.log(`Zurückgesetzt auf v${rollbackRelease.version}`);

Pipeline-Verwaltung

Pipeline erstellen

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

  return response;
};

// Beispiel
const pipeline = await createPipeline('meine-app-pipeline');
console.log(`Pipeline erstellt: ${pipeline.id}`);

Apps zur Pipeline hinzufügen

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;
};

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

Slug zur nächsten Phase befördern

const promoteSlug = async (slugId, toApp) => {
  await herokuRequest('/promotions', {
    method: 'POST',
    body: JSON.stringify({
      from: toApp, // Quell-App
      to: toApp,   // Ziel-App (nächste Phase)
      slug: slugId
    })
  });

  console.log(`Slug ${slugId} zu ${toApp} befördert`);
};

Add-On-Verwaltung

Add-Ons bereitstellen

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;
};

// Beispiel: PostgreSQL bereitstellen
const db = await provisionAddon('meine-app', 'heroku-postgresql:mini', {});
console.log(`Datenbank bereitgestellt: ${db.addon.name}`);
console.log(`DATABASE_URL: ${db.addon.config_vars.DATABASE_URL}`);

Beliebte Add-Ons

Add-On	Plan	Startpreis	Anwendungsfall
heroku-postgresql	mini	5 $/Monat	Produktionsdatenbank
heroku-redis	mini	5 $/Monat	Caching, Sessions
papertrail	choklad	7 $/Monat	Log-Aggregation
sentry	developer	Kostenlos	Fehlerverfolgung
mailgun	sandbox	Kostenlos	E-Mail-Zustellung
newrelic	lite	Kostenlos	Anwendungsüberwachung

Add-Ons auflisten

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

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

Add-Ons entfernen

const removeAddon = async (appName, addonId) => {
  await herokuRequest(`/apps/${appName}/addons/${addonId}`, {
    method: 'DELETE'
  });
  console.log(`Add-on ${addonId} von ${appName} entfernt`);
};

Domain- und SSL-Verwaltung

Benutzerdefinierte Domains hinzufügen

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

  return response;
};

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

SSL-Zertifikate konfigurieren

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;
};

Automatisches SSL mit ACM

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

  return response;
};

Ratenbegrenzung und Quoten

Ratenbegrenzungen verstehen

Heroku setzt Ratenbegrenzungen durch, um die API-Stabilität zu schützen:

Standardlimit: 10.000 Anfragen pro Stunde und Konto
Fenster: Rollierendes 60-Minuten-Fenster
Zurücksetzen: Automatisch nach Ablauf

Überschreitungen führen zu HTTP 429 (Too Many Requests).

Umgang mit Ratenbegrenzungen implementieren

Exponentielles Backoff für Wiederholungsversuche:

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

      // Ratenbegrenzungs-Header prüfen
      const remaining = response.headers.get('RateLimit-Remaining');
      const resetTime = response.headers.get('RateLimit-Reset');

      if (remaining < 100) {
        console.warn(`Niedriges Restkontingent: ${remaining}, Rücksetzung um ${resetTime}`);
      }

      return response;
    } catch (error) {
      if (error.message.includes('429') && attempt < maxRetries) {
        const delay = Math.pow(2, attempt) * 1000;
        console.log(`Ratenbegrenzung erreicht. Wiederhole in ${delay}ms...`);
        await new Promise(resolve => setTimeout(resolve, delay));
      } else {
        throw error;
      }
    }
  }
};

Ratenbegrenzungs-Header

Header	Beschreibung
`RateLimit-Limit`	Maximale Anfragen pro Stunde
`RateLimit-Remaining`	Verbleibende Anfragen im Fenster
`RateLimit-Reset`	Unix-Zeitstempel für das Zurücksetzen

Behebung häufiger Probleme

Problem: Authentifizierung schlägt mit 401 fehl

Symptome: „Ungültige Anmeldeinformationen“-Fehler.

Lösungen:

Prüfe, ob der API-Schlüssel korrekt ist: heroku authorizations
Stelle sicher, dass das Token nicht abgelaufen ist
Umgebungsvariablen auf Leerzeichen prüfen
Token ggf. neu generieren: heroku authorizations:create

Problem: App-Name bereits vergeben

Symptome: „Name ist bereits vergeben“.

Lösungen:

Globale, eindeutige Namen verwenden (Suffix/Präfix)
UUID-basierte Namen generieren: app-${Date.now()}
Namensschema wie teamname-appname-env

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

Problem: Dyno-Formation schlägt fehl

Symptome: Skalierungsvorgänge geben Fehler zurück.

Lösungen:

Prüfe, ob der Prozesstyp in der Procfile existiert
Dyno-Kontingent prüfen
App darf nicht gesperrt sein
Dyno-Stundennutzung prüfen: heroku ps --app=meine-app

Problem: Build schlägt mit Timeout fehl

Symptome: Builds laufen in Timeout (>30 Min).

Lösungen:

Buildpacks optimieren
Dependencies cachen
Große Builds aufteilen
Vorgefertigte Slugs nutzen

Problem: Ratenbegrenzung überschritten

Symptome: HTTP 429-Antworten.

Lösungen:

Request-Queuing implementieren
Exponentielles Backoff bei Fehlern
Anfragen bündeln, wo möglich
Ratenbegrenzungs-Header überwachen

// Einfacher Ratenbegrenzer
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;
  }
}

Checkliste für die Produktionsbereitstellung

Vor dem Go-Live:

[ ] Langlebige API-Tokens für CI/CD verwenden
[ ] Tokens sicher speichern (z.B. Vault, AWS Secrets Manager)
[ ] Ratenbegrenzung und Request-Queuing implementieren
[ ] Fehlerbehandlung hinzufügen
[ ] Logging für API-Aufrufe einrichten
[ ] Dyno-Stundennutzung überwachen
[ ] Log-Drains für externes Logging konfigurieren
[ ] Pipeline-Promotions für CI/CD einrichten
[ ] Automatische Zertifikatsverwaltung aktivieren
[ ] Backup-Strategie für Datenbanken einrichten

Überwachung und Alarmierung

Verfolge diese Metriken:

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

// Alarm bei hoher Fehlerrate
const failureRate = metrics.apiCalls.failed / metrics.apiCalls.total;

if (failureRate > 0.05) {
  sendAlert('Heroku API-Fehlerrate über 5%');
}

// Alarm bei Dyno-Stundennutzung
if (metrics.dynoHours.used > metrics.dynoHours.quota * 0.8) {
  sendAlert('Dyno-Stundennutzung über 80%');
}

Praktische Anwendungsfälle

Automatisierte CI/CD-Pipeline

Ein SaaS-Team automatisiert Bereitstellungen von GitHub:

Herausforderung: Manuelle Bereitstellungen verursachten Fehler und Verzögerungen
Lösung: GitHub Actions + Heroku API-Integration
Ergebnis: Bereitstellungen ohne Ausfallzeiten, 90% schnellere Releases

Implementierung:

GitHub Push löst Workflow aus
Tests laufen in CI
Heroku API erstellt Build aus Source Blob
Promotion von Staging nach Produktion
Team wird benachrichtigt

Multi-Umgebungsverwaltung

Eine Beratungsfirma verwaltet 50+ Kunden-Apps:

Herausforderung: Manueller Konfigurationsabgleich
Lösung: Zentrale Konfigurationsverwaltung mit Heroku API
Ergebnis: Konsistente Konfigurationen, 8 Stunden/Woche gespart

Integrationspunkte:

Konfigurationsvariablen über Umgebungen synchronisieren
Automatisierte Add-on-Bereitstellung
Massenoperationen für Client-Onboarding

Automatische Skalierung nach Verkehr

Eine E-Commerce-Plattform meistert Verkehrsspitzen:

Herausforderung: Manuelle Skalierung bei Events
Lösung: Metrikbasierte Auto-Skalierung mit Heroku API
Ergebnis: Keine Ausfallzeiten bei 10x Traffic

Auto-Skalierungslogik:

Antwortzeiten über Metrik-API überwachen
Hochskalieren bei p95-Latenz > 500ms
Herunterskalieren bei geringer Last
Alarm bei anhaltend hoher Auslastung

Fazit

Die Heroku API bietet umfassenden Zugang zur Plattformfunktionalität. Die wichtigsten Punkte:

Bearer-Token-Authentifizierung erfordert sichere Speicherung und Rotation
Ratenbegrenzung (10K/h) muss proaktiv überwacht werden
Pipeline-Management ermöglicht robuste CI/CD-Workflows
Fehlerbehandlung ist kritisch für Zuverlässigkeit
Apidog optimiert API-Testing und Teamwork für Heroku-Integrationen

FAQ-Bereich

Wofür wird die Heroku API verwendet?

Die Heroku API ermöglicht die programmatische Verwaltung von Anwendungen, Dynos, Add-ons und Infrastruktur. Typische Anwendungsfälle: CI/CD-Automatisierung, Multi-App-Management, Auto-Skalierung, Infrastruktur-Dashboards.

Wie erhalte ich einen Heroku API-Schlüssel?

Installiere die Heroku CLI, führe heroku login aus, dann heroku authorizations:create. Speichere das Token in Umgebungsvariablen.

Ist die Heroku API kostenlos nutzbar?

Ja, die Heroku API ist kostenlos. Du bezahlst nur für bereitgestellte Ressourcen (Dynos, Add-ons). Limit: 10.000 Anfragen/Stunde/Konto.

Welche Authentifizierung verwendet die Heroku API?

Bearer-Token-Authentifizierung. Header: Authorization: Bearer {api_key}. Tokens sind kurzlebig (1h) oder langlebig (bis zu 1 Jahr).

Wie gehe ich mit Heroku API-Ratenbegrenzungen um?

Überwache den RateLimit-Remaining-Header und implementiere Request-Queuing. Verwende exponentielles Backoff bei HTTP 429. Bleibe unter 150 Anfragen/Minute.

Kann ich ohne Git bereitstellen?

Ja, nutze die Builds API und bereitstelle über eine Source Blob URL (z.B. aus S3/GCS).

Wie automatisiere ich Bereitstellungen?

Mit der Pipeline API. Erstelle Builds, befördere Slugs und integriere mit GitHub oder CI-Systemen.

Was ist der Unterschied zwischen einem Release und einem Build?

Build: Kompiliert den Code zu einem Slug.

Release: Kombiniert Slug + Konfiguration für die Bereitstellung.

Wie setze ich eine fehlgeschlagene Bereitstellung zurück?

List Releases via API, dann POST an /releases mit rollback: <release_id> – erzeugt ein neues Release mit der alten Version.

Kann ich mehrere Heroku-Konten verwalten?

Ja, nutze separate API-Tokens und setze jeweils die Umgebungsvariable HEROKU_API_KEY.