Heroku API nutzen: Komplette Integrationsanleitung (2026)

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.

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 Sie durch den gesamten Heroku-API-Integrationsprozess. Sie lernen die Token-Authentifizierung, die App- und Dyno-Verwaltung, Build-Pipelines, Add-on-Bereitstellung und Fehlerbehebung kennen. Am Ende verfügen Sie über eine produktionsreife Heroku-Integration.

Was ist die Heroku-API?

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

• 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

Übersicht der API-Architektur

Heroku verwendet eine versionierte REST-API-Struktur:

https://api.heroku.com/

Die API folgt der JSON:API-Spezifikation mit konsistenten Ressourcenmustern und -beziehungen.

API-Versionen im Vergleich

Erste Schritte: Authentifizierung einrichten

Schritt 1: Erstellen Sie Ihr Heroku-Konto

Bevor Sie auf die API zugreifen können, benötigen Sie ein Heroku-Konto:

1. Besuchen Sie die Heroku-Website
2. Klicken Sie auf Registrieren und erstellen Sie ein Konto
3. Bestätigen Sie Ihre E-Mail-Adresse
4. Schließen Sie die Kontoeinrichtung ab

Schritt 2: Heroku CLI installieren

Die 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

Authentifizieren Sie sich mit der Heroku CLI:

# Bei Heroku anmelden
heroku login

# Dies öffnet einen Browser zur Authentifizierung
# Nach der Anmeldung wird Ihr Token lokal gespeichert

Rufen Sie Ihr API-Token ab:

# Zeigen Sie Ihr aktuelles Autorisierungstoken an
heroku authorizations:create --short-lived

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

Sicherheitshinweis: Speichern Sie 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:

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

Jede API-Anfrage erfordert diese Header.

Schritt 5: Ihren ersten API-Aufruf tätigen

Testen Sie Ihre 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

Einen wiederverwendbaren API-Client erstellen:

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

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

Anwendungsverwaltung

Eine neue App erstellen

Eine Heroku-App programmatisch erstellen:

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

  return response;
};

// Verwendung
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" }
}

Ihre Apps auflisten

Alle Apps in Ihrem Konto abrufen:

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

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

App-Details abrufen

Detaillierte App-Informationen abrufen:

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

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

App-Konfiguration aktualisieren

App-Einstellungen ändern:

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

  return response;
};

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

Eine App löschen

Eine App aus Ihrem Konto entfernen:

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

  console.log(`App ${appName} erfolgreich gelöscht`);
};

Dyno-Verwaltung

Dynos skalieren

Skalieren Sie Ihre Anwendung hoch oder runter:

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

  return response;
};

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

Dyno-Formation abrufen

Aktuelle Dyno-Konfiguration anzeigen:

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

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

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

Verfügbare Dyno-Größen

Dynos neu starten

Alle Dynos einer App 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

Befehle in isolierten 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;
};

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

Konfigurationsvariablen

Konfigurationsvariablen abrufen

Umgebungsvariablen abrufen:

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

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

Konfigurationsvariablen einstellen

Umgebungsvariablen aktualisieren:

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

  return response;
};

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

Best Practices für Konfigurationsvariablen

1. Niemals Geheimnisse committen - Verwenden Sie Umgebungsvariablen für alle sensiblen Daten
2. Verwenden Sie separate Konfigurationen pro Umgebung - Unterschiedliche Variablen für Staging vs. Produktion
3. Geheimnisse regelmäßig rotieren - API-Schlüssel und Passwörter vierteljährlich aktualisieren
4. Verwandte Variablen präfixen - STRIPE_SECRET_KEY, STRIPE_WEBHOOK_SECRET

Build- und Release-Management

Einen Build erstellen

Code über die API bereitstellen:

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

  return response;
};

// Verwendung
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

Build-Fortschritt prüfen:

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

// Abfragen, bis abgeschlossen
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

Release-Historie anzeigen:

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

// Verwendung
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

Auf eine frühere Version zurücksetzen:

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

  return response;
};

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

Pipeline-Verwaltung

Eine Pipeline erstellen

CI/CD-Pipelines einrichten:

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

  return response;
};

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

Apps zur Pipeline hinzufügen

Apps mit Pipeline-Phasen verbinden:

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

// Verwendung
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

Code durch die Pipeline bewegen:

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

Heroku-Add-ons installieren:

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

// Verwendung - 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-Ons auflisten

Installierte Add-ons anzeigen:

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

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

Add-Ons entfernen

Add-ons deinstallieren:

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

Benutzerdefinierte Domains konfigurieren:

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

  return response;
};

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

SSL-Zertifikate konfigurieren

SSL zu benutzerdefinierten Domains hinzufügen:

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

Automatische Zertifikatsverwaltung aktivieren:

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 des Fensters

Das Überschreiten der Limits führt zu HTTP 429 (Too Many Requests) Antworten.

Umgang mit Ratenbegrenzungen implementieren

Verwenden Sie 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

Heroku fügt diese Header in jede Antwort ein:

Behebung häufiger Probleme

Problem: Authentifizierung schlägt mit 401 fehl

Symptome: Erhalten von „Ungültige Anmeldeinformationen“-Fehlern.

Lösungen:

1. Überprüfen Sie, ob der API-Schlüssel korrekt ist: heroku authorizations
2. Stellen Sie sicher, dass das Token nicht abgelaufen ist (langlebige Tokens halten 1 Jahr)
3. Überprüfen Sie Umgebungsvariablen auf zusätzliche Leerzeichen
4. Generieren Sie das Token bei Bedarf neu: heroku authorizations:create

Problem: App-Name bereits vergeben

Symptome: Erhalten der Fehlermeldung „Name ist bereits vergeben“.

Lösungen:

1. Verwenden Sie global eindeutige Namen – fügen Sie Team- oder zufälliges Suffix hinzu
2. UUID-basierte Namen generieren: app-${Date.now()}
3. Namespace-Präfixe verwenden: 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:

1. Überprüfen Sie, ob der Prozesstyp in der Procfile existiert
2. Überprüfen Sie, ob das Konto über ein verfügbares Dyno-Kontingent verfügt
3. Stellen Sie sicher, dass die App nicht gesperrt ist
4. Überprüfen Sie die Dyno-Stundennutzung: heroku ps --app=meine-app

Problem: Build schlägt mit Timeout fehl

Symptome: Builds hängen oder treten nach 30 Minuten in einen Timeout.

Lösungen:

1. Optimieren Sie die Buildpack-Auswahl für Ihre Sprache
2. Abhängigkeiten ordnungsgemäß cachen
3. Teilen Sie große Builds in kleinere Bereitstellungen auf
4. Verwenden Sie vorgefertigte Slugs für schnellere Bereitstellung

Problem: Ratenbegrenzung überschritten

Symptome: Empfangen von HTTP 429-Antworten.

Lösungen:

1. Implementieren Sie Request-Queuing
2. Verwenden Sie exponentielles Backoff für Wiederholungsversuche
3. Fassen Sie Anfragen wo möglich zusammen
4. Überwachen Sie Ratenbegrenzungs-Header proaktiv

// 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 Live-Gang:

• [ ] Verwenden Sie langlebige API-Tokens für CI/CD
• [ ] Speichern Sie Tokens in einer sicheren Geheimnisverwaltung (Vault, AWS Secrets Manager)
• [ ] Implementieren Sie Ratenbegrenzung und Request-Queuing
• [ ] Fügen Sie eine umfassende Fehlerbehandlung hinzu
• [ ] Richten Sie Logging für alle API-Aufrufe ein
• [ ] Überwachen Sie die Dyno-Stundennutzung
• [ ] Konfigurieren Sie Log-Drains für externes Logging
• [ ] Richten Sie Pipeline-Promotions für CI/CD ein
• [ ] Aktivieren Sie die automatische Zertifikatsverwaltung
• [ ] Konfigurieren Sie eine Backup-Strategie für Datenbanken

Überwachung und Alarmierung

Verfolgen Sie 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

Implementierungsablauf:

1. GitHub Push löst Workflow aus
2. Tests laufen in CI
3. Heroku API erstellt Build aus Source Blob
4. Promotion von Staging nach Produktion
5. Team bei Erfolg/Misserfolg benachrichtigen

Multi-Umgebungsverwaltung

Eine Beratungsfirma verwaltet über 50 Kunden-Apps:

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

Wichtige Integrationspunkte:

• Konfigurationsvariablen über Dev/Staging/Prod synchronisieren
• Automatisierte Add-on-Bereitstellung
• Massenoperationen für das Client-Onboarding

Automatische Skalierung basierend auf dem Datenverkehr

Eine E-Commerce-Plattform bewältigt Verkehrsspitzen:

• Herausforderung: Manuelle Skalierung während Verkaufsereignissen
• Lösung: Lastbasierte automatische Skalierung mit Heroku API
• Ergebnis: Keine Ausfallzeiten bei 10-fachen Verkehrsspitzen

Auto-Skalierungslogik:

• Antwortzeiten über Metrik-API überwachen
• Hochskalieren, wenn p95 Latenz > 500ms
• Herunterskalieren in verkehrsarmen Zeiten
• Alarm bei anhaltend hoher Auslastung

Fazit

Die Heroku API bietet umfassenden Zugang zur Plattformfunktionalität. Wichtige Erkenntnisse:

• Die Bearer-Token-Authentifizierung erfordert eine sichere Speicherung und Rotation
• Ratenbegrenzung (10K/Stunde) erfordert proaktive Überwachung
• Pipeline-Management ermöglicht robuste CI/CD-Workflows
• Eine ordnungsgemäße Fehlerbehandlung gewährleistet die Zuverlässigkeit der Bereitstellung
• Apidog optimiert das API-Testen und die Teamzusammenarbeit 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. Häufige Anwendungsfälle sind CI/CD-Automatisierung, Tools zur Verwaltung mehrerer Anwendungen, Auto-Skalierungssysteme und Dashboards zur Infrastrukturüberwachung.

Wie erhalte ich einen Heroku API-Schlüssel?

Installieren Sie die Heroku CLI, führen Sie heroku login aus und erstellen Sie dann eine Autorisierung mit heroku authorizations:create. Speichern Sie das zurückgegebene Token sicher in Umgebungsvariablen.

Ist die Heroku API kostenlos nutzbar?

Ja, die Heroku API ist kostenlos. Sie zahlen jedoch für die von Ihnen bereitgestellten Ressourcen (Dynos, Add-ons usw.). Die API-Ratenbegrenzungen betragen 10.000 Anfragen pro Stunde und Konto.

Welche Authentifizierung verwendet die Heroku API?

Heroku verwendet Bearer-Token-Authentifizierung. Fügen Sie den Header Authorization: Bearer {api_key} in jede Anfrage ein. Tokens können kurzlebig (1 Stunde) oder langlebig (bis zu 1 Jahr) sein.

Wie gehe ich mit Heroku API-Ratenbegrenzungen um?

Überwachen Sie den RateLimit-Remaining-Header und implementieren Sie Request-Queuing. Verwenden Sie exponentielles Backoff, wenn Sie HTTP 429-Antworten erhalten. Bleiben Sie unter 150 Anfragen pro Minute für einen sicheren Betrieb.

Kann ich ohne Git bereitstellen?

Ja. Verwenden Sie die Builds API, um von einer Quell-Blob-URL bereitzustellen. Laden Sie Ihren Code in Cloud-Speicher (S3, GCS) hoch und referenzieren Sie die URL in Ihrer Build-Anfrage.

Wie automatisiere ich Bereitstellungen?

Verwenden Sie die Pipeline API, um CI/CD einzurichten. Erstellen Sie Builds, befördern Sie Slugs durch Phasen und integrieren Sie sich mit GitHub oder benutzerdefinierten CI-Systemen.

Was ist der Unterschied zwischen einem Release und einem Build?

Ein Build kompiliert Ihren Quellcode zu einem Slug. Ein Release kombiniert einen Slug mit Konfigurationsvariablen, um eine bereitstellbare Version Ihrer App zu erstellen.

Wie setze ich eine fehlgeschlagene Bereitstellung zurück?

Verwenden Sie die Releases API, um die letzten Releases aufzulisten, und POSTen Sie dann an /releases mit rollback: <release_id>. Heroku erstellt ein neues Release mit der vorherigen Version.

Kann ich mehrere Heroku-Konten verwalten?

Ja. Verwenden Sie separate API-Tokens für jedes Konto und wechseln Sie zwischen ihnen, indem Sie die Umgebungsvariable HEROKU_API_KEY ändern.