Cara Menggunakan Heroku API: Panduan Integrasi Lengkap (2026)

TL;DR

Heroku API memungkinkan pengembang untuk mengotomatiskan deployment, mengelola aplikasi, mengkonfigurasi add-on, dan menskalakan infrastruktur secara terprogram. Ini menggunakan OAuth 2.0 dan otentikasi berbasis token, endpoint RESTful untuk aplikasi, dyno, build, dan pipeline, dengan batas laju 10.000 permintaan per jam per akun. Panduan ini mencakup pengaturan otentikasi, endpoint inti, integrasi CI/CD, dan strategi deployment produksi.

Pendahuluan

Heroku mendukung lebih dari 4 juta aplikasi di 170+ negara. Bagi pengembang yang membangun otomatisasi deployment, pipeline CI/CD, atau alat manajemen multi-aplikasi, integrasi Heroku API bukan pilihan—tetapi penting.

Inilah kenyataannya: tim yang mengelola 10+ aplikasi Heroku kehilangan 8-12 jam setiap minggu untuk deployment manual dan perubahan konfigurasi. Integrasi Heroku API yang solid mengotomatiskan deployment, menskalakan dyno berdasarkan lalu lintas, dan menyinkronkan konfigurasi di berbagai lingkungan.

Panduan ini memandu Anda melalui proses integrasi Heroku API yang lengkap. Anda akan mempelajari otentikasi token, manajemen aplikasi dan dyno, pembangunan pipeline, penyediaan add-on, dan pemecahan masalah. Pada akhirnya, Anda akan memiliki integrasi Heroku yang siap produksi.

💡

Apidog menyederhanakan pengujian integrasi API. Uji endpoint Heroku Anda, validasi alur otentikasi, periksa respons API, dan debug masalah konfigurasi dalam satu ruang kerja. Impor spesifikasi API, respons mock, dan bagikan skenario pengujian dengan tim Anda.

Apa Itu Heroku API?

Heroku menyediakan Platform API RESTful untuk mengelola aplikasi dan infrastruktur di platform Heroku. API menangani:

Pembuatan, konfigurasi, dan penghapusan aplikasi
Skala dyno dan manajemen proses
Manajemen build dan rilis
Penyediaan dan konfigurasi add-on
Manajemen pipeline dan promosi
Manajemen domain dan sertifikat SSL
Pengaturan penguras log dan pemantauan
Manajemen tim dan kolaborator

Fitur Utama

Fitur	Deskripsi
Desain RESTful	Metode HTTP standar dengan respons JSON
Otentikasi Token	Token Bearer dengan dukungan OAuth 2.0
Permintaan Rentang	Paginasi untuk kumpulan hasil besar
Pembatasan Laju	10.000 permintaan per jam per akun
Pembuatan Idempoten	Perilaku percobaan ulang yang aman untuk penulisan
Kompresi Gzip	Kompresi respons untuk penghematan bandwidth

Gambaran Umum Arsitektur API

Heroku menggunakan struktur REST API yang berversi:

https://api.heroku.com/

API mengikuti spesifikasi JSON:API dengan pola dan hubungan sumber daya yang konsisten.

Perbandingan Versi API

Versi	Status	Otentikasi	Kasus Penggunaan
Platform API (v3)	Saat Ini	Token Bearer	Semua integrasi baru
Integrasi GitHub	Saat Ini	OAuth 2.0	Aplikasi yang terhubung GitHub
Registri Kontainer	Saat Ini	Otentikasi Docker	Deployment kontainer

Memulai: Pengaturan Otentikasi

Langkah 1: Buat Akun Heroku Anda

Sebelum mengakses API, Anda memerlukan akun Heroku:

Kunjungi situs web Heroku
Klik Daftar dan buat akun
Verifikasi alamat email Anda
Selesaikan pengaturan akun

Langkah 2: Instal Heroku CLI

CLI membantu menghasilkan token API dan menguji perintah:

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

# Windows
npm install -g heroku

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

Langkah 3: Hasilkan Token API

Otentikasi dengan Heroku CLI:

# Login ke Heroku
heroku login

# Ini membuka browser untuk otentikasi
# Setelah login, token Anda disimpan secara lokal

Ambil token API Anda:

# Lihat token otorisasi Anda saat ini
heroku authorizations:create --short-lived

# Atau buat token jangka panjang (untuk CI/CD)
heroku authorizations:create --description "CI/CD Pipeline" --expires-in "1 year"

Catatan keamanan: Simpan token dalam variabel lingkungan, jangan pernah dalam kode:

# file .env
HEROKU_API_KEY="kunci_api_anda_di_sini"
HEROKU_APP_NAME="nama-aplikasi-anda"

Langkah 4: Pahami Otentikasi Token

Heroku menggunakan otentikasi token Bearer:

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

Setiap permintaan API memerlukan header ini.

Langkah 5: Lakukan Panggilan API Pertama Anda

Uji otentikasi Anda:

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

Respons yang diharapkan:

{
  "id": "user-id-here",
  "email": "developer@example.com",
  "name": "Developer Name",
  "created_at": "2024-01-15T10:30:00Z",
  "updated_at": "2026-03-20T14:22:00Z"
}

Langkah 6: Implementasikan Otentikasi dalam Kode

Buat klien API yang dapat digunakan kembali:

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

// Penggunaan
const account = await herokuRequest('/account');
console.log(`Login sebagai: ${account.email}`);

Manajemen Aplikasi

Membuat Aplikasi Baru

Buat aplikasi Heroku secara terprogram:

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

  return response;
};

// Penggunaan
const app = await createApp('my-awesome-app-2026');
console.log(`Aplikasi dibuat: ${app.name}`);
console.log(`URL Git: ${app.git_url}`);
console.log(`URL Web: ${app.web_url}`);

Respons Aplikasi yang Diharapkan

{
  "id": "app-uuid-here",
  "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": "developer@example.com" },
  "build_stack": { "name": "heroku-24" }
}

Mencantumkan Aplikasi Anda

Ambil semua aplikasi di akun Anda:

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

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

Mendapatkan Detail Aplikasi

Ambil informasi aplikasi terperinci:

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

// Penggunaan
const app = await getApp('my-awesome-app-2026');
console.log(`Stack: ${app.build_stack.name}`);
console.log(`Wilayah: ${app.region.name}`);

Memperbarui Konfigurasi Aplikasi

Ubah pengaturan aplikasi:

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

  return response;
};

// Penggunaan - ubah nama aplikasi
const updated = await updateApp('old-app-name', {
  name: 'new-app-name'
});

Menghapus Aplikasi

Hapus aplikasi dari akun Anda:

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

  console.log(`Aplikasi ${appName} berhasil dihapus`);
};

Manajemen Dyno

Menskalakan Dyno

Skalakan aplikasi Anda naik atau turun:

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

  return response;
};

// Penggunaan - skalakan dyno web ke 3
const formation = await scaleDyno('my-app', 'web', 3);
console.log(`Diskalakan ke ${formation.quantity} dyno ${processType}`);

Mendapatkan Formasi Dyno

Lihat konfigurasi dyno saat ini:

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

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

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

Ukuran Dyno yang Tersedia

Jenis Dyno	Kasus Penggunaan	Biaya/Bulan
eco	Proyek hobi, demo	$5
basic	Aplikasi produksi kecil	$7
standard-1x	Beban kerja standar	$25
standard-2x	Aplikasi berkinerja tinggi	$50
performance	Aplikasi kritis produksi	$250+
private	Isolasi perusahaan	Kustom

Memulai Ulang Dyno

Mulai ulang semua dyno untuk suatu aplikasi:

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

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

  console.log(`Dyno dimulai ulang untuk ${appName}`);
};

Menjalankan Dyno Sekali Pakai

Jalankan perintah dalam dyno yang terisolasi:

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

  return response;
};

// Penggunaan - jalankan migrasi database
const dyno = await runCommand('my-app', 'npm run migrate');
console.log(`Dyno dimulai: ${dyno.id}`);

Variabel Konfigurasi

Mendapatkan Variabel Konfigurasi

Ambil variabel lingkungan:

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

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

Mengatur Variabel Konfigurasi

Perbarui variabel lingkungan:

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

  return response;
};

// Penggunaan
const updated = await setConfigVars('my-app', {
  NODE_ENV: 'production',
  API_SECRET: 'kunci-rahasia-anda',
  LOG_LEVEL: 'info'
});

Praktik Terbaik untuk Variabel Konfigurasi

Jangan pernah menyimpan rahasia - Gunakan variabel lingkungan untuk semua data sensitif
Gunakan konfigurasi terpisah per lingkungan - Variabel yang berbeda untuk staging vs produksi
Rotasi rahasia secara teratur - Perbarui kunci API dan kata sandi setiap kuartal
Beri awalan variabel terkait - STRIPE_SECRET_KEY, STRIPE_WEBHOOK_SECRET

Manajemen Build dan Rilis

Membuat Build

Deploy kode melalui API:

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

  return response;
};

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

Mendapatkan Status Build

Periksa kemajuan build:

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

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

    console.log(`Build sedang berjalan... percobaan ${i + 1}`);
    await new Promise(resolve => setTimeout(resolve, 5000));
  }

  throw new Error('Waktu build habis');
};

Mencantumkan Rilis

Lihat riwayat rilis:

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

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

Mengembalikan ke Rilis Sebelumnya

Kembali ke versi sebelumnya:

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

  return response;
};

// Penggunaan - mengembalikan ke versi 42
const rollbackRelease = await rollback('my-app', 42);
console.log(`Mengembalikan ke v${rollbackRelease.version}`);

Manajemen Pipeline

Membuat Pipeline

Siapkan pipeline CI/CD:

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

  return response;
};

// Penggunaan
const pipeline = await createPipeline('my-app-pipeline');
console.log(`Pipeline dibuat: ${pipeline.id}`);

Menambahkan Aplikasi ke Pipeline

Hubungkan aplikasi ke tahap 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;
};

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

Mempromosikan Slug ke Tahap Berikutnya

Pindahkan kode melalui pipeline:

const promoteSlug = async (slugId, toApp) => {
  await herokuRequest('/promotions', {
    method: 'POST',
    body: JSON.stringify({
      from: toApp, // Aplikasi Sumber
      to: toApp,   // Aplikasi Target (tahap berikutnya)
      slug: slugId
    })
  });

  console.log(`Slug ${slugId} dipromosikan ke ${toApp}`);
};

Manajemen Add-On

Menyediakan Add-On

Instal add-on 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;
};

// Penggunaan - menyediakan PostgreSQL
const db = await provisionAddon('my-app', 'heroku-postgresql:mini', {});
console.log(`Database disediakan: ${db.addon.name}`);
console.log(`DATABASE_URL: ${db.addon.config_vars.DATABASE_URL}`);

Add-On Populer

Add-On	Paket	Harga Mulai	Kasus Penggunaan
heroku-postgresql	mini	$5/bln	Basis data produksi
heroku-redis	mini	$5/bln	Caching, sesi
papertrail	choklad	$7/bln	Agregasi log
sentry	developer	Gratis	Pelacakan kesalahan
mailgun	sandbox	Gratis	Pengiriman email
newrelic	lite	Gratis	Pemantauan aplikasi

Mencantumkan Add-On

Lihat add-on yang terinstal:

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

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

Menghapus Add-On

Copot pemasangan add-on:

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

  console.log(`Addon ${addonId} dihapus dari ${appName}`);
};

Manajemen Domain dan SSL

Menambahkan Domain Kustom

Konfigurasi domain kustom:

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

  return response;
};

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

Mengkonfigurasi Sertifikat SSL

Tambahkan SSL ke domain kustom:

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 Otomatis dengan ACM

Aktifkan Manajemen Sertifikat Otomatis:

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

  return response;
};

Pembatasan Laju dan Kuota

Memahami Batas Laju

Heroku menerapkan batas laju untuk melindungi stabilitas API:

Batas Standar: 10.000 permintaan per jam per akun
Jendela: Jendela bergerak 60 menit
Reset: Otomatis setelah jendela berlalu

Melebihi batas akan menghasilkan respons HTTP 429 (Terlalu Banyak Permintaan).

Mengimplementasikan Penanganan Batas Laju

Gunakan backoff eksponensial untuk percobaan ulang:

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

      // Periksa header batas laju
      const remaining = response.headers.get('RateLimit-Remaining');
      const resetTime = response.headers.get('RateLimit-Reset');

      if (remaining < 100) {
        console.warn(`Kuota rendah tersisa: ${remaining}, direset pada ${resetTime}`);
      }

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

Header Batas Laju

Heroku menyertakan header ini di setiap respons:

Header	Deskripsi
`RateLimit-Limit`	Permintaan maksimum per jam
`RateLimit-Remaining`	Permintaan yang tersisa dalam jendela
`RateLimit-Reset`	Stempel waktu Unix saat jendela direset

Pemecahan Masalah Umum

Masalah: Otentikasi Gagal dengan 401

Gejala: Mendapatkan kesalahan “Invalid credentials”.

Solusi:

Verifikasi kunci API sudah benar: heroku authorizations
Pastikan token belum kedaluwarsa (token jangka panjang berlaku 1 tahun)
Periksa spasi tambahan dalam variabel lingkungan
Hasilkan ulang token jika diperlukan: heroku authorizations:create

Masalah: Nama Aplikasi Sudah Digunakan

Gejala: Mendapatkan kesalahan “name is already taken”.

Solusi:

Gunakan nama unik secara global - sertakan tim atau sufiks acak
Hasilkan nama berbasis UUID: app-${Date.now()}
Gunakan awalan namespace: 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}`;
};

Masalah: Formasi Dyno Gagal

Gejala: Operasi penskalaan mengembalikan kesalahan.

Solusi:

Verifikasi jenis proses ada di Procfile
Periksa akun memiliki kuota dyno yang tersedia
Pastikan aplikasi tidak ditangguhkan
Tinjau penggunaan jam dyno: heroku ps --app=my-app

Masalah: Build Gagal dengan Batas Waktu

Gejala: Build menggantung atau batas waktu setelah 30 menit.

Solusi:

Optimalkan pemilihan buildpack untuk bahasa Anda
Cache dependensi dengan benar
Bagi build besar menjadi deployment yang lebih kecil
Gunakan slug yang sudah dibuat sebelumnya untuk deployment yang lebih cepat

Masalah: Batas Laju Terlampaui

Gejala: Menerima respons HTTP 429.

Solusi:

Implementasikan antrean permintaan
Gunakan backoff eksponensial untuk percobaan ulang
Batch permintaan jika memungkinkan
Pantau header batas laju secara proaktif

// Pembatas laju sederhana
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;
  }
}

Daftar Periksa Deployment Produksi

Sebelum tayang:

[ ] Gunakan token API jangka panjang untuk CI/CD
[ ] Simpan token dalam manajemen rahasia yang aman (Vault, AWS Secrets Manager)
[ ] Implementasikan pembatasan laju dan antrean permintaan
[ ] Tambahkan penanganan kesalahan yang komprehensif
[ ] Siapkan pencatatan untuk semua panggilan API
[ ] Pantau penggunaan jam dyno
[ ] Konfigurasi penguras log untuk pencatatan eksternal
[ ] Siapkan promosi pipeline untuk CI/CD
[ ] Aktifkan Manajemen Sertifikat Otomatis
[ ] Konfigurasi strategi cadangan untuk basis data

Pemantauan dan Peringatan

Lacak metrik ini:

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

// Peringatan pada tingkat kegagalan tinggi
const failureRate = metrics.apiCalls.failed / metrics.apiCalls.total;

if (failureRate > 0.05) {
  sendAlert('Tingkat kegagalan Heroku API di atas 5%');
}

// Peringatan pada penggunaan jam dyno
if (metrics.dynoHours.used > metrics.dynoHours.quota * 0.8) {
  sendAlert('Penggunaan jam dyno di atas 80%');
}

Kasus Penggunaan Dunia Nyata

Pipeline CI/CD Otomatis

Tim SaaS mengotomatiskan deployment dari GitHub:

Tantangan: Deployment manual menyebabkan kesalahan dan penundaan
Solusi: GitHub Actions + integrasi Heroku API
Hasil: Deployment tanpa downtime, rilis 90% lebih cepat

Alur implementasi:

Push GitHub memicu alur kerja
Pengujian berjalan di CI
Heroku API membuat build dari blob sumber
Promosikan melalui staging ke produksi
Beri tahu tim tentang keberhasilan/kegagalan

Manajemen Multi-Lingkungan

Sebuah firma konsultan mengelola 50+ aplikasi klien:

Tantangan: Sinkronisasi konfigurasi manual di berbagai lingkungan
Solusi: Manajemen konfigurasi pusat dengan Heroku API
Hasil: Konfigurasi yang konsisten, 8 jam/minggu dihemat

Poin integrasi kunci:

Sinkronkan variabel konfigurasi di dev/staging/prod
Penyediaan add-on otomatis
Operasi massal untuk orientasi klien

Penskalaan Otomatis Berdasarkan Lalu Lintas

Platform e-commerce menangani lonjakan lalu lintas:

Tantangan: Penskalaan manual selama acara penjualan
Solusi: Penskalaan otomatis berbasis beban dengan Heroku API
Hasil: Nol downtime selama lonjakan lalu lintas 10x

Logika penskalaan otomatis:

Pantau waktu respons melalui API metrik
Skala naik saat latensi p95 > 500ms
Skala turun selama periode lalu lintas rendah
Peringatan pada penggunaan tinggi yang berkelanjutan

Kesimpulan

Heroku API menyediakan akses komprehensif ke fungsionalitas platform. Poin-poin penting:

Otentikasi token Bearer memerlukan penyimpanan dan rotasi yang aman
Pembatasan laju (10K/jam) memerlukan pemantauan proaktif
Manajemen pipeline memungkinkan alur kerja CI/CD yang kuat
Penanganan kesalahan yang tepat memastikan keandalan deployment
Apidog menyederhanakan pengujian API dan kolaborasi tim untuk integrasi Heroku

button

Bagian FAQ

Untuk apa Heroku API digunakan?

Heroku API memungkinkan manajemen aplikasi, dyno, add-on, dan infrastruktur secara terprogram. Kasus penggunaan umum termasuk otomatisasi CI/CD, alat manajemen multi-aplikasi, sistem penskalaan otomatis, dan dasbor pemantauan infrastruktur.

Bagaimana cara mendapatkan kunci API Heroku?

Instal Heroku CLI, jalankan heroku login, lalu buat otorisasi dengan heroku authorizations:create. Simpan token yang dikembalikan dengan aman di variabel lingkungan.

Apakah Heroku API gratis untuk digunakan?

Ya, Heroku API gratis. Namun, Anda membayar untuk sumber daya yang Anda sediakan (dyno, add-on, dll.). Batas laju API adalah 10.000 permintaan per jam per akun.

Otentikasi apa yang digunakan Heroku API?

Heroku menggunakan otentikasi token Bearer. Sertakan header Authorization: Bearer {api_key} di setiap permintaan. Token bisa berumur pendek (1 jam) atau berumur panjang (hingga 1 tahun).

Bagaimana cara menangani batas laju Heroku API?

Pantau header RateLimit-Remaining dan implementasikan antrean permintaan. Gunakan backoff eksponensial saat menerima respons HTTP 429. Tetap di bawah 150 permintaan per menit untuk operasi yang aman.

Bisakah saya melakukan deployment tanpa Git?

Ya. Gunakan API Builds untuk melakukan deployment dari URL blob sumber. Unggah kode Anda ke penyimpanan cloud (S3, GCS) dan referensikan URL dalam permintaan build Anda.

Bagaimana cara mengotomatiskan deployment?

Gunakan API Pipeline untuk menyiapkan CI/CD. Buat build, promosikan slug melalui tahapan, dan integrasikan dengan GitHub atau sistem CI kustom.

Apa perbedaan antara rilis dan build?

Sebuah build mengkompilasi kode sumber Anda menjadi slug. Sebuah rilis menggabungkan slug dengan variabel konfigurasi untuk membuat versi aplikasi Anda yang dapat dideploy.

Bagaimana cara mengembalikan deployment yang gagal?

Gunakan API Releases untuk mencantumkan rilis terbaru, lalu lakukan POST ke /releases dengan rollback: <release_id>. Heroku membuat rilis baru pada versi sebelumnya.

Bisakah saya mengelola beberapa akun Heroku?

Ya. Gunakan token API terpisah untuk setiap akun dan beralih di antaranya dengan mengubah variabel lingkungan HEROKU_API_KEY.