Comment Utiliser l'API Heroku: Guide d'Intégration Complet (2026)

En bref

L'API Heroku permet aux développeurs d'automatiser le déploiement, de gérer les applications, de configurer les add-ons et de faire évoluer l'infrastructure de manière programmatique. Elle utilise OAuth 2.0 et l'authentification par jeton, des points d'accès RESTful pour les applications, les dynos, les builds et les pipelines, avec des limites de débit de 10 000 requêtes par heure et par compte. Ce guide couvre la configuration de l'authentification, les points d'accès principaux, l'intégration CI/CD et les stratégies de déploiement en production.

Introduction

Heroku alimente plus de 4 millions d'applications dans plus de 170 pays. Pour les développeurs qui créent des outils d'automatisation de déploiement, des pipelines CI/CD ou des outils de gestion multi-applications, l'intégration de l'API Heroku n'est pas une option, c'est une nécessité.

Voici la réalité : les équipes gérant plus de 10 applications Heroku perdent 8 à 12 heures par semaine en déploiements manuels et en changements de configuration. Une solide intégration de l'API Heroku automatise les déploiements, adapte les dynos en fonction du trafic et synchronise la configuration entre les environnements.

Ce guide vous accompagne tout au long du processus complet d'intégration de l'API Heroku. Vous apprendrez l'authentification par jeton, la gestion des applications et des dynos, les pipelines de build, le provisionnement d'add-ons et le dépannage des erreurs. À la fin, vous disposerez d'une intégration Heroku prête pour la production.

Qu'est-ce que l'API Heroku ?

Heroku fournit une API de plateforme RESTful pour la gestion des applications et de l'infrastructure sur la plateforme Heroku. L'API gère :

• La création, la configuration et la suppression d'applications
• La mise à l'échelle des Dyno et la gestion des processus
• La gestion des builds et des versions
• Le provisionnement et la configuration des add-ons
• La gestion des pipelines et des promotions
• La gestion des domaines et des certificats SSL
• La configuration de la redirection des logs et de la surveillance
• La gestion des équipes et des collaborateurs

Fonctionnalités Clés

Vue d'Ensemble de l'Architecture API

Heroku utilise une structure d'API REST versionnée :

https://api.heroku.com/

L'API suit la spécification JSON:API avec des modèles et des relations de ressources cohérents.

Comparaison des Versions d'API

Démarrage : Configuration de l'Authentification

Étape 1 : Créer votre compte Heroku

Avant d'accéder à l'API, vous avez besoin d'un compte Heroku :

1. Visitez le site web Heroku
2. Cliquez sur Sign Up (S'inscrire) et créez un compte
3. Vérifiez votre adresse e-mail
4. Terminez la configuration du compte

Étape 2 : Installer l'interface de ligne de commande Heroku

L'interface de ligne de commande (CLI) aide à générer des jetons API et à tester des commandes :

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

# Windows
npm install -g heroku

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

Étape 3 : Générer un Jeton API

Authentifiez-vous avec l'interface de ligne de commande Heroku :

# Se connecter à Heroku
heroku login

# Cela ouvre un navigateur pour l'authentification
# Après la connexion, votre jeton est stocké localement

Récupérez votre jeton API :

# Afficher votre jeton d'autorisation actuel
heroku authorizations:create --short-lived

# Ou créer un jeton de longue durée (pour CI/CD)
heroku authorizations:create --description "CI/CD Pipeline" --expires-in "1 year"

Note de sécurité : Stockez les jetons dans des variables d'environnement, jamais dans le code :

# fichier .env
HEROKU_API_KEY="votre_clé_api_ici"
HEROKU_APP_NAME="votre-nom-d-app"

Étape 4 : Comprendre l'authentification par jeton

Heroku utilise l'authentification par jeton Bearer :

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

Chaque requête API nécessite ces en-têtes.

Étape 5 : Effectuer votre premier appel API

Testez votre authentification :

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

Réponse attendue :

{
  "id": "id-utilisateur-ici",
  "email": "developpeur@example.com",
  "name": "Nom du Développeur",
  "created_at": "2024-01-15T10:30:00Z",
  "updated_at": "2026-03-20T14:22:00Z"
}

Étape 6 : Implémenter l'authentification dans le code

Créez un client API réutilisable :

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

// Utilisation
const account = await herokuRequest('/account');
console.log(`Connecté en tant que : ${account.email}`);

Gestion des Applications

Création d'une Nouvelle Application

Créez une application Heroku par programme :

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

  return response;
};

// Utilisation
const app = await createApp('my-awesome-app-2026');
console.log(`Application créée : ${app.name}`);
console.log(`URL Git : ${app.git_url}`);
console.log(`URL Web : ${app.web_url}`);

Réponse Attendue de l'Application

{
  "id": "uuid-app-ici",
  "name": "my-awesome-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/my-awesome-app-2026.git",
  "web_url": "https://my-awesome-app-2026.herokuapp.com",
  "owner": { "email": "developpeur@example.com" },
  "build_stack": { "name": "heroku-24" }
}

Lister vos Applications

Récupérer toutes les applications de votre compte :

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

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

Obtenir les détails de l'application

Récupérer des informations détaillées sur l'application :

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

// Utilisation
const app = await getApp('my-awesome-app-2026');
console.log(`Pile : ${app.build_stack.name}`);
console.log(`Région : ${app.region.name}`);

Mise à jour de la configuration de l'application

Modifier les paramètres de l'application :

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

  return response;
};

// Utilisation - changer le nom de l'application
const updated = await updateApp('ancien-nom-app', {
  name: 'nouveau-nom-app'
});

Supprimer une application

Supprimer une application de votre compte :

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

  console.log(`L'application ${appName} a été supprimée avec succès`);
};

Gestion des Dynos

Mise à l'Échelle des Dynos

Augmenter ou réduire l'échelle de votre application :

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

  return response;
};

// Utilisation - mettre à l'échelle les dynos web à 3
const formation = await scaleDyno('my-app', 'web', 3);
console.log(`Mis à l'échelle à ${formation.quantity} dynos ${processType}`);

Obtenir la Formation de Dyno

Afficher la configuration actuelle des dynos :

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

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

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

Tailles de Dyno Disponibles

Redémarrage des Dynos

Redémarrer tous les dynos pour une application :

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

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

  console.log(`Dynos redémarrés pour ${appName}`);
};

Exécuter des Dynos Éphémères

Exécuter des commandes dans des dynos isolés :

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

  return response;
};

// Utilisation - exécuter une migration de base de données
const dyno = await runCommand('my-app', 'npm run migrate');
console.log(`Dyno démarré : ${dyno.id}`);

Variables de Configuration

Obtenir les Variables de Configuration

Récupérer les variables d'environnement :

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

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

Définition des Variables de Configuration

Mettre à jour les variables d'environnement :

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

  return response;
};

// Utilisation
const updated = await setConfigVars('my-app', {
  NODE_ENV: 'production',
  API_SECRET: 'votre-clé-secrète',
  LOG_LEVEL: 'info'
});

Bonnes pratiques pour les variables de configuration

1. Ne jamais commettre de secrets - Utilisez des variables d'environnement pour toutes les données sensibles
2. Utiliser des configurations séparées par environnement - Des variables différentes pour la préproduction par rapport à la production
3. Renouveler les secrets régulièrement - Mettre à jour les clés API et les mots de passe trimestriellement
4. Préfixer les variables liées - STRIPE_SECRET_KEY, STRIPE_WEBHOOK_SECRET

Gestion des Builds et des Versions

Création d'un Build

Déployer le code via l'API :

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

  return response;
};

// Utilisation
const build = await createBuild('my-app', 'https://storage.example.com/source.tar.gz');
console.log(`Build démarré : ${build.id}`);
console.log(`Statut : ${build.status}`);

Obtenir le Statut du Build

Vérifier la progression du build :

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

// Poll jusqu'à ce que ce soit terminé
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 réussi !');
      return build;
    } else if (build.status === 'failed') {
      throw new Error(`Build a échoué : ${build.output}`);
    }

    console.log(`Build en cours... tentative ${i + 1}`);
    await new Promise(resolve => setTimeout(resolve, 5000));
  }

  throw new Error('Délai d\'attente du build dépassé');
};

Lister les Versions

Afficher l'historique des versions :

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

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

Retour à la Version Précédente

Revenir à une version précédente :

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

  return response;
};

// Utilisation - retour à la version 42
const rollbackRelease = await rollback('my-app', 42);
console.log(`Revenu à la version v${rollbackRelease.version}`);

Gestion des Pipelines

Création d'un Pipeline

Mettre en place des pipelines CI/CD :

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

  return response;
};

// Utilisation
const pipeline = await createPipeline('mon-pipeline-app');
console.log(`Pipeline créé : ${pipeline.id}`);

Ajouter des applications au pipeline

Connecter des applications aux étapes du 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;
};

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

Promouvoir un Slug à l'Étape Suivante

Déplacer le code à travers le pipeline :

const promoteSlug = async (slugId, toApp) => {
  await herokuRequest('/promotions', {
    method: 'POST',
    body: JSON.stringify({
      from: toApp, // Application source
      to: toApp,   // Application cible (étape suivante)
      slug: slugId
    })
  });

  console.log(`Slug ${slugId} promu vers ${toApp}`);
};

Gestion des Add-Ons

Provisionnement d'Add-Ons

Installer des add-ons 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;
};

// Utilisation - provisionner PostgreSQL
const db = await provisionAddon('my-app', 'heroku-postgresql:mini', {});
console.log(`Base de données provisionnée : ${db.addon.name}`);
console.log(`DATABASE_URL: ${db.addon.config_vars.DATABASE_URL}`);

Add-Ons Populaires

Lister les Add-Ons

Afficher les add-ons installés :

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

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

Supprimer des Add-Ons

Désinstaller les add-ons :

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

  console.log(`L'Addon ${addonId} a été supprimé de ${appName}`);
};

Gestion des Domaines et SSL

Ajouter des Domaines Personnalisés

Configurer des domaines personnalisés :

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

  return response;
};

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

Configuration des Certificats SSL

Ajouter SSL aux domaines personnalisés :

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 Automatisé avec ACM

Activer la gestion automatique des certificats (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;
};

Limitation de Débit et Quotas

Comprendre les Limites de Débit

Heroku applique des limites de débit pour protéger la stabilité de l'API :

• Limite Standard : 10 000 requêtes par heure par compte
• Fenêtre : Fenêtre glissante de 60 minutes
• Réinitialisation : Automatique après l'expiration de la fenêtre

Dépasser les limites entraîne des réponses HTTP 429 (Trop de requêtes).

Implémentation de la Gestion des Limites de Débit

Utiliser une temporisation exponentielle pour les réessais :

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

      // Vérifier les en-têtes de limite de débit
      const remaining = response.headers.get('RateLimit-Remaining');
      const resetTime = response.headers.get('RateLimit-Reset');

      if (remaining < 100) {
        console.warn(`Quota faible restant : ${remaining}, réinitialisation à ${resetTime}`);
      }

      return response;
    } catch (error) {
      if (error.message.includes('429') && attempt < maxRetries) {
        const delay = Math.pow(2, attempt) * 1000;
        console.log(`Limite de débit atteinte. Réessai dans ${delay}ms...`);
        await new Promise(resolve => setTimeout(resolve, delay));
      } else {
        throw error;
      }
    }
  }
};

En-têtes de Limite de Débit

Heroku inclut ces en-têtes dans chaque réponse :

Dépannage des Problèmes Courants

Problème : Échec de l'Authentification avec 401

Symptômes : Obtention d'erreurs "Invalid credentials".

Solutions :

1. Vérifiez que la clé API est correcte : heroku authorizations
2. Assurez-vous que le jeton n'a pas expiré (les jetons de longue durée durent 1 an)
3. Vérifiez l'absence d'espaces supplémentaires dans la variable d'environnement
4. Regénérez le jeton si nécessaire : heroku authorizations:create

Problème : Nom d'application déjà pris

Symptômes : Obtention de l'erreur "name is already taken".

Solutions :

1. Utilisez des noms uniques à l'échelle mondiale - incluez le nom de l'équipe ou un suffixe aléatoire
2. Générez des noms basés sur des UUID : app-${Date.now()}
3. Utilisez des préfixes d'espace de noms : nom_equipe-nom_app-environnement

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

Problème : Échec de la formation des Dynos

Symptômes : Les opérations de mise à l'échelle renvoient des erreurs.

Solutions :

1. Vérifiez que le type de processus existe dans le Procfile
2. Vérifiez que le compte dispose du quota de dynos disponible
3. Assurez-vous que l'application n'est pas suspendue
4. Examinez l'utilisation des heures de dyno : heroku ps --app=my-app

Problème : Échec de la construction avec un dépassement de délai

Symptômes : Les constructions bloquent ou expirent après 30 minutes.

Solutions :

1. Optimisez la sélection du buildpack pour votre langage
2. Mettez correctement en cache les dépendances
3. Divisez les grosses constructions en déploiements plus petits
4. Utilisez des slugs pré-construits pour un déploiement plus rapide

Problème : Limite de Débit Dépassée

Symptômes : Réception de réponses HTTP 429.

Solutions :

1. Implémentez une file d'attente de requêtes
2. Utilisez une temporisation exponentielle pour les réessais
3. Regroupez les requêtes lorsque c'est possible
4. Surveillez proactivement les en-têtes de limite de débit

// Simple limiteur de débit
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;
  }
}

Liste de Contrôle pour le Déploiement en Production

Avant la mise en ligne :

• [ ] Utilisez des jetons API de longue durée pour le CI/CD
• [ ] Stockez les jetons dans un système de gestion de secrets sécurisé (Vault, AWS Secrets Manager)
• [ ] Implémentez la limitation de débit et la mise en file d'attente des requêtes
• [ ] Ajoutez une gestion complète des erreurs
• [ ] Configurez la journalisation pour tous les appels API
• [ ] Surveillez l'utilisation des heures de dyno
• [ ] Configurez des drains de log pour une journalisation externe
• [ ] Mettez en place des promotions de pipeline pour le CI/CD
• [ ] Activez la gestion automatique des certificats (ACM)
• [ ] Configurez une stratégie de sauvegarde pour les bases de données

Surveillance et Alertes

Suivez ces métriques :

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

// Alerte en cas de taux d'échec élevé
const failureRate = metrics.apiCalls.failed / metrics.apiCalls.total;

if (failureRate > 0.05) {
  sendAlert('Taux d\'échec de l\'API Heroku supérieur à 5%');
}

// Alerte sur l'utilisation des heures de dyno
if (metrics.dynoHours.used > metrics.dynoHours.quota * 0.8) {
  sendAlert('Utilisation des heures de Dyno supérieure à 80%');
}

Cas d'Utilisation Réels

Pipeline CI/CD Automatisé

Une équipe SaaS automatise les déploiements depuis GitHub :

• Défi : Les déploiements manuels causaient des erreurs et des retards
• Solution : Intégration GitHub Actions + API Heroku
• Résultat : Déploiements sans interruption, versions 90 % plus rapides

Flux d'implémentation :

1. Un push GitHub déclenche le workflow
2. Les tests s'exécutent en CI
3. L'API Heroku crée un build à partir du blob source
4. Promotion de la pré-production à la production
5. Notification de l'équipe en cas de succès/échec

Gestion Multi-Environnement

Un cabinet de conseil gère plus de 50 applications clientes :

• Défi : Synchronisation manuelle des configurations entre les environnements
• Solution : Gestion centralisée des configurations avec l'API Heroku
• Résultat : Configurations cohérentes, 8 heures/semaine économisées

Points d'intégration clés :

• Synchronisation des variables de configuration entre dev/staging/prod
• Provisionnement automatisé d'add-ons
• Opérations en masse pour l'intégration des clients

Mise à l'échelle automatique basée sur le trafic

Une plateforme e-commerce gère les pics de trafic :

• Défi : Mise à l'échelle manuelle lors des événements commerciaux
• Solution : Mise à l'échelle automatique basée sur la charge avec l'API Heroku
• Résultat : Zéro temps d'arrêt lors de pics de trafic 10x

Logique de mise à l'échelle automatique :

• Surveiller les temps de réponse via l'API de métriques
• Augmenter l'échelle lorsque la latence p95 > 500ms
• Diminuer l'échelle pendant les périodes de faible trafic
• Alerter en cas d'utilisation élevée prolongée

Conclusion

L'API Heroku offre un accès complet aux fonctionnalités de la plateforme. Principaux points à retenir :

• L'authentification par jeton Bearer nécessite un stockage et une rotation sécurisés
• La limitation de débit (10K/heure) exige une surveillance proactive
• La gestion des pipelines permet des workflows CI/CD robustes
• Une gestion appropriée des erreurs assure la fiabilité du déploiement
• Apidog simplifie les tests d'API et la collaboration d'équipe pour les intégrations Heroku

Section FAQ

À quoi sert l'API Heroku ?

L'API Heroku permet la gestion programmatique des applications, des dynos, des add-ons et de l'infrastructure. Les cas d'utilisation courants incluent l'automatisation CI/CD, les outils de gestion multi-applications, les systèmes de mise à l'échelle automatique et les tableaux de bord de surveillance de l'infrastructure.

Comment obtenir une clé API Heroku ?

Installez l'interface de ligne de commande Heroku (CLI), exécutez heroku login, puis créez une autorisation avec heroku authorizations:create. Stockez le jeton obtenu de manière sécurisée dans des variables d'environnement.

L'API Heroku est-elle gratuite ?

Oui, l'API Heroku est gratuite. Cependant, vous payez pour les ressources que vous provisionnez (dynos, add-ons, etc.). Les limites de débit de l'API sont de 10 000 requêtes par heure par compte.

Quelle authentification l'API Heroku utilise-t-elle ?

Heroku utilise l'authentification par jeton Bearer. Incluez l'en-tête Authorization: Bearer {clé_api} dans chaque requête. Les jetons peuvent être de courte durée (1 heure) ou de longue durée (jusqu'à 1 an).

Comment gérer les limites de débit de l'API Heroku ?

Surveillez l'en-tête RateLimit-Remaining et implémentez une file d'attente de requêtes. Utilisez une temporisation exponentielle en cas de réception de réponses HTTP 429. Restez en deçà de 150 requêtes par minute pour un fonctionnement sûr.

Puis-je déployer sans Git ?

Oui. Utilisez l'API Builds pour déployer à partir d'une URL de blob source. Téléchargez votre code vers un stockage cloud (S3, GCS) et référencez l'URL dans votre requête de build.

Comment automatiser les déploiements ?

Utilisez l'API Pipeline pour configurer le CI/CD. Créez des builds, promouvez des slugs à travers les étapes, et intégrez-vous avec GitHub ou des systèmes CI personnalisés.

Quelle est la différence entre une version (release) et une compilation (build) ?

Une compilation (build) transforme votre code source en un slug. Une version (release) combine un slug avec des variables de configuration pour créer une version déployable de votre application.

Comment annuler un déploiement échoué ?

Utilisez l'API Releases pour lister les versions récentes, puis effectuez une requête POST vers /releases avec rollback: <id_de_la_version>. Heroku créera une nouvelle version à la version précédente.

Puis-je gérer plusieurs comptes Heroku ?

Oui. Utilisez des jetons API distincts pour chaque compte et basculez entre eux en modifiant la variable d'environnement HEROKU_API_KEY.