DEV Community

Cover image for Comment Utiliser l'API Heroku: Guide d'Intégration Complet (2026)
Antoine Laurent
Antoine Laurent

Posted on • Originally published at apidog.com

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.

Essayez Apidog dès aujourd'hui

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.

💡 Astuce : Apidog simplifie les tests d'intégration d'API. Testez vos points d'accès Heroku, validez les flux d'authentification, inspectez les réponses API et déboguez les problèmes de configuration dans un seul espace de travail. Importez les spécifications API, simulez les réponses et partagez les scénarios de test avec votre équipe.

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

Fonctionnalité Description
Conception RESTful Méthodes HTTP standard avec réponses JSON
Authentification par Jeton Jeton Bearer avec prise en charge d'OAuth 2.0
Requêtes par Plage Pagination pour les grands ensembles de résultats
Limitation de Débit 10 000 requêtes par heure par compte
Créations Idempotentes Comportement de réessai sécurisé pour les écritures
Compression Gzip Compression des réponses pour économiser la bande passante

Vue d'Ensemble de l'Architecture API

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

https://api.heroku.com/
Enter fullscreen mode Exit fullscreen mode

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

Comparaison des Versions d'API

Version Statut Authentification Cas d'utilisation
API de Plateforme (v3) Actuelle Jeton Bearer Toutes les nouvelles intégrations
Intégration GitHub Actuelle OAuth 2.0 Applications connectées à GitHub
Registre de Conteneurs Actuelle Authentification Docker Déploiements de conteneurs

Démarrage : Configuration de l'Authentification

Étape 1 : Créer votre compte Heroku

Avant d'accéder à l'API, créez un compte Heroku :

Capture d'écran de la page d'inscription de Heroku avec le formulaire de création de compte.

  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
Enter fullscreen mode Exit fullscreen mode

É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
Enter fullscreen mode Exit fullscreen mode

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"
Enter fullscreen mode Exit fullscreen mode

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"
Enter fullscreen mode Exit fullscreen mode

É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
Enter fullscreen mode Exit fullscreen mode

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"
Enter fullscreen mode Exit fullscreen mode

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"
}
Enter fullscreen mode Exit fullscreen mode

É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}`);
Enter fullscreen mode Exit fullscreen mode

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}`);
Enter fullscreen mode Exit fullscreen mode

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" }
}
Enter fullscreen mode Exit fullscreen mode

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}`);
});
Enter fullscreen mode Exit fullscreen mode

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}`);
Enter fullscreen mode Exit fullscreen mode

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'
});
Enter fullscreen mode Exit fullscreen mode

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`);
};
Enter fullscreen mode Exit fullscreen mode

Gestion des Dynos

Mise à l'Échelle des Dynos

Ajuster le nombre de dynos 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}`);
Enter fullscreen mode Exit fullscreen mode

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})`);
});
Enter fullscreen mode Exit fullscreen mode

Tailles de Dyno Disponibles

Type de Dyno Cas d'utilisation Coût/Mois
eco Projets de loisir, démos 5 $
basic Petites applications de production 7 $
standard-1x Charges de travail standard 25 $
standard-2x Applications haute performance 50 $
performance Applications critiques 250 $+
private Isolation d'entreprise Personnalisé

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}`);
};
Enter fullscreen mode Exit fullscreen mode

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}`);
Enter fullscreen mode Exit fullscreen mode

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}`);
Enter fullscreen mode Exit fullscreen mode

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'
});
Enter fullscreen mode Exit fullscreen mode

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 et la production.
  3. Renouveler les secrets régulièrement : Mettez à jour les clés API et les mots de passe tous les trimestres.
  4. Préfixer les variables liées : STRIPE_SECRET_KEY, STRIPE_WEBHOOK_SECRET, etc.

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}`);
Enter fullscreen mode Exit fullscreen mode

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é');
};
Enter fullscreen mode Exit fullscreen mode

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}`);
});
Enter fullscreen mode Exit fullscreen mode

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}`);
Enter fullscreen mode Exit fullscreen mode

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}`);
Enter fullscreen mode Exit fullscreen mode

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');
Enter fullscreen mode Exit fullscreen mode

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}`);
};
Enter fullscreen mode Exit fullscreen mode

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}`);
Enter fullscreen mode Exit fullscreen mode

Add-Ons Populaires

Add-On Plan Prix de Départ Cas d'Utilisation
heroku-postgresql mini 5 $/mois Base de données production
heroku-redis mini 5 $/mois Mise en cache, sessions
papertrail choklad 7 $/mois Agrégation de journaux
sentry developer Gratuit Suivi des erreurs
mailgun sandbox Gratuit Envoi d'e-mails
newrelic lite Gratuit Surveillance d'applications

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}`);
});
Enter fullscreen mode Exit fullscreen mode

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}`);
};
Enter fullscreen mode Exit fullscreen mode

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}`);
Enter fullscreen mode Exit fullscreen mode

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;
};
Enter fullscreen mode Exit fullscreen mode

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;
};
Enter fullscreen mode Exit fullscreen mode

Limitation de Débit et Quotas

Comprendre les Limites de Débit

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

En cas de dépassement, l'API retourne HTTP 429 (Trop de requêtes).

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

Utilisez la 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;
      }
    }
  }
};
Enter fullscreen mode Exit fullscreen mode

En-têtes de Limite de Débit

En-tête Description
RateLimit-Limit Nombre maximum de requêtes par heure
RateLimit-Remaining Requêtes restantes dans la fenêtre
RateLimit-Reset Horodatage Unix de réinitialisation

Dépannage des Problèmes Courants

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

Symptômes : Erreurs "Invalid credentials".

Solutions :

  1. Vérifiez la clé API : heroku authorizations
  2. Vérifiez l'expiration du jeton (1 an max)
  3. Vérifiez l'absence d'espaces dans la variable d'environnement
  4. Régénérez le jeton si nécessaire : heroku authorizations:create

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

Symptômes : Erreur "name is already taken".

Solutions :

  1. Utilisez des noms uniques à l'échelle mondiale (ex: suffixe aléatoire)
  2. Générez des noms basés sur des UUID : 
const generateUniqueAppName = (baseName) => {
  const timestamp = Date.now().toString(36);
  const random = Math.random().toString(36).substring(2, 6);
  return `${baseName}-${timestamp}-${random}`;
};
Enter fullscreen mode Exit fullscreen mode
  1. Utilisez des préfixes d'espace de noms (nom_equipe-nom_app-environnement)

Problème : Échec de la formation des Dynos

Symptômes : Les mises à l'échelle échouent.

Solutions :

  1. Vérifiez que le type de processus existe dans le Procfile
  2. Vérifiez le quota de dynos disponible
  3. L'application ne doit pas être suspendue
  4. Vérifiez 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 : Builds bloqués ou expirés après 30 minutes.

Solutions :

  1. Optimisez le buildpack pour votre langage
  2. Mettez en cache les dépendances
  3. Divisez les builds volumineux
  4. Utilisez des slugs pré-construits

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

Symptômes : Réponses HTTP 429.

Solutions :

  1. Implémentez une file d'attente de requêtes
  2. Utilisez la temporisation exponentielle pour les réessais
  3. Groupez les requêtes
  4. Surveillez 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;
  }
}
Enter fullscreen mode Exit fullscreen mode

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

Avant la mise en ligne, vérifiez :

  • [ ] Jetons API de longue durée pour le CI/CD
  • [ ] Stockage sécurisé des secrets (Vault, AWS Secrets Manager)
  • [ ] Limitation de débit et file d'attente des requêtes
  • [ ] Gestion complète des erreurs
  • [ ] Journalisation de tous les appels API
  • [ ] Surveillance de l'utilisation des heures de dyno
  • [ ] Drains de log pour journalisation externe
  • [ ] Promotions de pipeline pour CI/CD
  • [ ] ACM activé pour SSL auto
  • [ ] Stratégie de sauvegarde pour les bases de données

Surveillance et Alertes

Surveillez 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%');
}
Enter fullscreen mode Exit fullscreen mode

Cas d'Utilisation Réels

Pipeline CI/CD Automatisé

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

  • Défi : Déploiements manuels sources d'erreurs
  • Solution : GitHub Actions + API Heroku
  • Résultat : Déploiements 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 depuis le blob source
  4. Promotion de la préproduction à la production
  5. Notification de l'équipe

Gestion Multi-Environnement

Exemple : Un cabinet de conseil gère plus de 50 applications.

  • Défi : Synchronisation manuelle des configurations
  • Solution : Gestion centralisée via l'API Heroku
  • Résultat : 8 heures/semaine économisées

Points d'intégration clés :

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

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

Exemple : Plateforme e-commerce.

  • Défi : Mise à l'échelle manuelle lors de pics
  • Solution : Autoscaling via l'API Heroku
  • Résultat : Zéro downtime lors des pics x10

Logique de scaling :

  • Surveiller la latence via l'API de métriques
  • Échelle up si latence p95 > 500ms
  • Échelle down en période creuse
  • Alerte en cas d'utilisation élevée prolongée

Conclusion

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

  • Authentification par jeton Bearer : stockage et rotation sécurisés
  • Limitation de débit (10K/heure) : surveillez proactivement
  • Pipelines : workflows CI/CD robustes
  • Gestion des erreurs : fiabilité du déploiement
  • Apidog simplifie les tests d'API et la collaboration 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. Cas courants : automatisation CI/CD, outils de gestion multi-applications, autoscaling, dashboards de monitoring.

Comment obtenir une clé API Heroku ?

Installez la CLI Heroku, exécutez heroku login, puis heroku authorizations:create. Stockez le jeton dans des variables d'environnement.

L'API Heroku est-elle gratuite ?

Oui, l'API est gratuite. Vous payez uniquement les ressources provisionnées (dynos, add-ons, ...). Limite : 10 000 requêtes/heure/compte.

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

Jeton Bearer. Ajoutez Authorization: Bearer {clé_api} dans chaque requête. Jetons de courte (1h) ou longue durée (1 an).

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

Surveillez RateLimit-Remaining et implémentez une file d'attente. Utilisez la temporisation exponentielle sur HTTP 429. Restez sous 150 requêtes/minute.

Puis-je déployer sans Git ?

Oui. Utilisez l'API Builds avec une URL de blob source. Uploadez le code sur un stockage cloud et référencez l'URL dans la requête de build.

Comment automatiser les déploiements ?

Utilisez l'API Pipeline : créez des builds, promouvez des slugs, intégrez GitHub ou CI personnalisés.

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

Un build transforme le code source en slug. Une release associe un slug à une configuration pour déployer l'application.

Comment annuler un déploiement échoué ?

Listez les releases, puis faites un POST sur /releases avec rollback: <id_version>. Heroku créera une nouvelle release sur la version précédente.

Puis-je gérer plusieurs comptes Heroku ?

Oui. Utilisez des jetons API séparés pour chaque compte et changez la variable d'environnement HEROKU_API_KEY.

Top comments (0)