Hướng Dẫn Toàn Diện Sử Dụng Heroku API (2026)

Tóm tắt

API Heroku cho phép các nhà phát triển tự động hóa triển khai, quản lý ứng dụng, cấu hình tiện ích bổ sung và mở rộng hạ tầng theo chương trình. Nó sử dụng xác thực OAuth 2.0 và dựa trên token, các điểm cuối RESTful cho ứng dụng, dyno, bản dựng và quy trình, với giới hạn tốc độ 10.000 yêu cầu mỗi giờ cho mỗi tài khoản. Hướng dẫn này bao gồm thiết lập xác thực, các điểm cuối cốt lõi, tích hợp CI/CD và các chiến lược triển khai sản xuất.

Dùng thử Apidog ngay hôm nay

Giới thiệu

Heroku đang cung cấp sức mạnh cho hơn 4 triệu ứng dụng trên hơn 170 quốc gia. Đối với các nhà phát triển xây dựng tự động hóa triển khai, các quy trình CI/CD hoặc công cụ quản lý đa ứng dụng, tích hợp API Heroku không phải là tùy chọn—mà là thiết yếu.

Các nhóm quản lý hơn 10 ứng dụng Heroku thường tốn 8-12 giờ mỗi tuần cho việc triển khai thủ công và thay đổi cấu hình. Một tích hợp API Heroku tốt sẽ tự động hóa việc triển khai, mở rộng dyno dựa trên lưu lượng truy cập và đồng bộ cấu hình giữa các môi trường.

Bài viết này hướng dẫn toàn bộ quy trình tích hợp API Heroku: xác thực token, quản lý ứng dụng và dyno, xây dựng quy trình, cung cấp tiện ích bổ sung và xử lý lỗi—giúp bạn có một tích hợp Heroku sẵn sàng cho sản xuất.

💡Apidog đơn giản hóa việc kiểm thử tích hợp API. Kiểm tra các điểm cuối Heroku của bạn, xác thực luồng xác thực, kiểm tra phản hồi API và gỡ lỗi các vấn đề cấu hình trong một không gian làm việc duy nhất. Nhập thông số kỹ thuật API, tạo phản hồi giả và chia sẻ các tình huống kiểm thử với nhóm của bạn.

API Heroku là gì?

Heroku cung cấp API Nền tảng RESTful để quản lý các ứng dụng và hạ tầng trên nền tảng Heroku. API xử lý:

• Tạo, cấu hình và xóa ứng dụng
• Mở rộng dyno và quản lý quy trình
• Quản lý bản dựng và bản phát hành
• Cung cấp và cấu hình tiện ích bổ sung
• Quản lý quy trình và quảng bá
• Quản lý tên miền và chứng chỉ SSL
• Thiết lập thoát nhật ký và giám sát
• Quản lý nhóm và cộng tác viên

Các tính năng chính

Tính năng	Mô tả
Thiết kế RESTful	Các phương thức HTTP tiêu chuẩn với phản hồi JSON
Xác thực bằng Token	Token Bearer với hỗ trợ OAuth 2.0
Yêu cầu phạm vi	Phân trang cho các tập kết quả lớn
Giới hạn tốc độ	10.000 yêu cầu mỗi giờ cho mỗi tài khoản
Tạo Idempotent	Hành vi thử lại an toàn cho các thao tác ghi
Nén Gzip	Nén phản hồi để tiết kiệm băng thông

Tổng quan kiến trúc API

Heroku sử dụng cấu trúc API REST có phiên bản:

https://api.heroku.com/

API tuân theo đặc tả JSON:API với các mẫu tài nguyên và mối quan hệ nhất quán.

So sánh các phiên bản API

Phiên bản	Trạng thái	Xác thực	Trường hợp sử dụng
Platform API (v3)	Hiện tại	Bearer Token	Tất cả các tích hợp mới
Tích hợp GitHub	Hiện tại	OAuth 2.0	Ứng dụng kết nối GitHub
Container Registry	Hiện tại	Xác thực Docker	Triển khai Container

Bắt đầu: Thiết lập xác thực

Bước 1: Tạo tài khoản Heroku của bạn

Trước khi truy cập API, bạn cần có một tài khoản Heroku:

1. Truy cập trang web Heroku
2. Nhấp vào Đăng ký và tạo tài khoản
3. Xác minh email
4. Hoàn tất thiết lập tài khoản

Bước 2: Cài đặt Heroku CLI

CLI giúp tạo token API và kiểm tra các lệnh:

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

# Windows
npm install -g heroku

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

Bước 3: Tạo Token API

Đăng nhập với Heroku CLI:

heroku login
# Thao tác này mở trình duyệt để xác thực

Truy xuất token API của bạn:

# Xem token ủy quyền hiện tại
heroku authorizations:create --short-lived

# Hoặc token có thời hạn dài (cho CI/CD)
heroku authorizations:create --description "CI/CD Pipeline" --expires-in "1 year"

Bảo mật: Lưu trữ token trong biến môi trường, không commit vào mã:

# .env file
HEROKU_API_KEY="your_api_key_here"
HEROKU_APP_NAME="your-app-name"

Bước 4: Hiểu về xác thực Token

Heroku sử dụng Bearer token:

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

Mỗi request API đều yêu cầu các header này.

Bước 5: Thực hiện cuộc gọi API đầu tiên

Kiểm tra xác thực của bạn:

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

Phản hồi mẫu:

{
  "id": "user-id-here",
  "email": "[e-mail]",
  "name": "Developer Name",
  "created_at": "2024-01-15T10:30:00Z",
  "updated_at": "2026-03-20T14:22:00Z"
}

Bước 6: Triển khai xác thực trong mã

Tạo một client API tái sử dụng với Node.js:

const HEROKU_API_KEY = process.env.HEROKU_API_KEY;
const HEROKU_BASE_URL = 'https://api.heroku.com';

const herokuRequest = async (endpoint, options = {}) => {
  const response = await fetch(`${HEROKU_BASE_URL}${endpoint}`, {
    ...options,
    headers: {
      'Authorization': `Bearer ${HEROKU_API_KEY}`,
      'Accept': 'application/vnd.heroku+json; version=3',
      'Content-Type': 'application/json',
      ...options.headers
    }
  });

  if (!response.ok) {
    const error = await response.json();
    throw new Error(`Heroku API Error: ${error.message}`);
  }

  return response.json();
};

// Sử dụng
const account = await herokuRequest('/account');
console.log(`Đã đăng nhập với: ${account.email}`);

---

Quản lý ứng dụng

Tạo ứng dụng mới

Tạo một ứng dụng Heroku:

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

  return response;
};

// Sử dụng
const app = await createApp('my-awesome-app-2026');
console.log(`Ứng dụng đã tạo: ${app.name}`);
console.log(`URL Git: ${app.git_url}`);
console.log(`URL Web: ${app.web_url}`);

Phản hồi ứng dụng mẫu

{
  "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": "[e-mail]" },
  "build_stack": { "name": "heroku-24" }
}

Liệt kê các ứng dụng của bạn

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

// Sử dụng
const apps = await listApps();
apps.forEach(app => {
  console.log(`${app.name} - ${app.web_url}`);
});

Lấy thông tin chi tiết ứng dụng

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

// Sử dụng
const app = await getApp('my-awesome-app-2026');
console.log(`Stack: ${app.build_stack.name}`);
console.log(`Khu vực: ${app.region.name}`);

Cập nhật cấu hình ứng dụng

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

  return response;
};

// Sử dụng - đổi tên ứng dụng
const updated = await updateApp('old-app-name', {
  name: 'new-app-name'
});

Xóa ứng dụng

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

  console.log(`Ứng dụng ${appName} đã được xóa thành công`);
};

Quản lý Dyno

Mở rộng Dyno

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

  return response;
};

// Sử dụng - mở rộng dyno web lên 3
const formation = await scaleDyno('my-app', 'web', 3);
console.log(`Đã mở rộng lên ${formation.quantity} dyno ${processType}`);

Lấy cấu trúc Dyno

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

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

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

Các kích thước Dyno có sẵn

Loại Dyno	Trường hợp sử dụng	Chi phí/Tháng
eco	Dự án sở thích, demo	$5
basic	Ứng dụng sản xuất nhỏ	$7
standard-1x	Tải công việc tiêu chuẩn	$25
standard-2x	Ứng dụng hiệu suất cao	$50
performance	Ứng dụng quan trọng trong sản xuất	$250+
private	Cô lập cấp doanh nghiệp	Tùy chỉnh

Khởi động lại Dyno

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

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

  console.log(`Các dyno đã được khởi động lại cho ${appName}`);
};

Chạy Dyno một lần

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

  return response;
};

// Sử dụng - chạy di chuyển cơ sở dữ liệu
const dyno = await runCommand('my-app', 'npm run migrate');
console.log(`Dyno đã khởi động: ${dyno.id}`);

Biến cấu hình

Lấy biến cấu hình

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

// Sử dụng
const config = await getConfigVars('my-app');
console.log(`DATABASE_URL: ${config.DATABASE_URL}`);
console.log(`NODE_ENV: ${config.NODE_ENV}`);

Thiết lập biến cấu hình

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

  return response;
};

// Sử dụng
const updated = await setConfigVars('my-app', {
  NODE_ENV: 'production',
  API_SECRET: 'your-secret-key',
  LOG_LEVEL: 'info'
});

Các thực hành tốt nhất cho biến cấu hình

1. Không commit thông tin nhạy cảm – Dùng biến môi trường cho dữ liệu nhạy cảm
2. Cấu hình riêng cho từng môi trường – Biến khác nhau giữa test và production
3. Xoay vòng thông tin nhạy cảm thường xuyên – Thay đổi khóa API, mật khẩu định kỳ
4. Tiền tố biến liên quan – STRIPE_SECRET_KEY, STRIPE_WEBHOOK_SECRET

Quản lý bản dựng và bản phát hành

Tạo bản dựng

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

  return response;
};

// Sử dụng
const build = await createBuild('my-app', 'https://storage.example.com/source.tar.gz');
console.log(`Bản dựng đã bắt đầu: ${build.id}`);
console.log(`Trạng thái: ${build.status}`);

Lấy trạng thái bản dựng

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

// Lặp cho đến khi hoàn thành
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('Bản dựng thành công!');
      return build;
    } else if (build.status === 'failed') {
      throw new Error(`Bản dựng thất bại: ${build.output}`);
    }

    console.log(`Bản dựng đang tiến hành... lần thử ${i + 1}`);
    await new Promise(resolve => setTimeout(resolve, 5000));
  }

  throw new Error('Hết thời gian chờ bản dựng');
};

Liệt kê các bản phát hành

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

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

Quay lại bản phát hành trước

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

  return response;
};

// Sử dụng - quay lại phiên bản 42
const rollbackRelease = await rollback('my-app', 42);
console.log(`Đã quay lại phiên bản v${rollbackRelease.version}`);

Quản lý quy trình

Tạo quy trình

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

  return response;
};

// Sử dụng
const pipeline = await createPipeline('my-app-pipeline');
console.log(`Quy trình đã tạo: ${pipeline.id}`);

Thêm ứng dụng vào quy trình

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

// Sử dụng
await addAppToPipeline(pipelineId, 'my-app-dev', 'development');
await addAppToPipeline(pipelineId, 'my-app-staging', 'staging');
await addAppToPipeline(pipelineId, 'my-app-prod', 'production');

Đẩy Slug lên giai đoạn tiếp theo

const promoteSlug = async (slugId, toApp) => {
  await herokuRequest('/promotions', {
    method: 'POST',
    body: JSON.stringify({
      from: toApp, // Ứng dụng nguồn
      to: toApp,   // Ứng dụng đích (giai đoạn tiếp theo)
      slug: slugId
    })
  });

  console.log(`Đã đẩy slug ${slugId} đến ${toApp}`);
};

Quản lý tiện ích bổ sung

Cung cấp tiện ích bổ sung

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

// Sử dụng - cung cấp PostgreSQL
const db = await provisionAddon('my-app', 'heroku-postgresql:mini', {});
console.log(`Cơ sở dữ liệu đã được cung cấp: ${db.addon.name}`);
console.log(`DATABASE_URL: ${db.addon.config_vars.DATABASE_URL}`);

Các tiện ích bổ sung phổ biến

Tiện ích bổ sung	Gói	Giá khởi điểm	Trường hợp sử dụng
heroku-postgresql	mini	$5/tháng	Cơ sở dữ liệu sản xuất
heroku-redis	mini	$5/tháng	Bộ nhớ đệm, phiên
papertrail	choklad	$7/tháng	Tổng hợp nhật ký
sentry	developer	Miễn phí	Theo dõi lỗi
mailgun	sandbox	Miễn phí	Gửi email
newrelic	lite	Miễn phí	Giám sát ứng dụng

Liệt kê tiện ích bổ sung

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

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

Gỡ bỏ tiện ích bổ sung

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

  console.log(`Tiện ích bổ sung ${addonId} đã được gỡ khỏi ${appName}`);
};

Quản lý tên miền và SSL

Thêm tên miền tùy chỉnh

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

  return response;
};

// Sử dụng
const domain = await addDomain('my-app', 'api.example.com');
console.log(`Mục tiêu CNAME: ${domain.cname}`);

Cấu hình chứng chỉ SSL

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

Tự động hóa SSL với 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;
};

Giới hạn tốc độ và hạn mức

Hiểu về giới hạn tốc độ

Heroku áp dụng giới hạn tốc độ để bảo vệ sự ổn định của API:

• Giới hạn tiêu chuẩn: 10.000 yêu cầu mỗi giờ cho mỗi tài khoản
• Cửa sổ: 60 phút di động
• Đặt lại: Tự động sau một giờ

Vượt quá giới hạn nhận HTTP 429 (Quá nhiều yêu cầu).

Triển khai xử lý giới hạn tốc độ

Sử dụng lùi lũy thừa cho retry:

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

      // Kiểm tra các tiêu đề giới hạn tốc độ
      const remaining = response.headers.get('RateLimit-Remaining');
      const resetTime = response.headers.get('RateLimit-Reset');

      if (remaining < 100) {
        console.warn(`Hạn mức còn lại thấp: ${remaining}, đặt lại vào ${resetTime}`);
      }

      return response;
    } catch (error) {
      if (error.message.includes('429') && attempt < maxRetries) {
        const delay = Math.pow(2, attempt) * 1000;
        console.log(`Đã bị giới hạn tốc độ. Đang thử lại sau ${delay}ms...`);
        await new Promise(resolve => setTimeout(resolve, delay));
      } else {
        throw error;
      }
    }
  }
};

Tiêu đề giới hạn tốc độ

Heroku trả về các header sau:

Tiêu đề	Mô tả
RateLimit-Limit	Số yêu cầu tối đa mỗi giờ
RateLimit-Remaining	Số yêu cầu còn lại trong cửa sổ
RateLimit-Reset	Dấu thời gian Unix khi cửa sổ đặt lại

Khắc phục các sự cố thường gặp

Vấn đề: Xác thực thất bại với lỗi 401

Triệu chứng: Nhận lỗi “Thông tin đăng nhập không hợp lệ”.

Giải pháp:

1. Xác minh khóa API: heroku authorizations
2. Đảm bảo token chưa hết hạn
3. Kiểm tra biến môi trường không dư khoảng trắng
4. Tạo lại token nếu cần: heroku authorizations:create

Vấn đề: Tên ứng dụng đã được sử dụng

Triệu chứng: “Tên đã được sử dụng”.

Giải pháp:

1. Sử dụng tên duy nhất toàn cầu – thêm hậu tố ngẫu nhiên
2. Tạo tên dựa trên UUID: app-${Date.now()}
3. Dùng tiền tố nhóm: 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}`;
};

Vấn đề: Lỗi tạo Dyno

Triệu chứng: Mở rộng dyno bị lỗi.

Giải pháp:

1. Đảm bảo process type tồn tại trong Procfile
2. Kiểm tra hạn mức dyno khả dụng
3. Ứng dụng không bị tạm ngừng
4. Kiểm tra sử dụng giờ dyno: heroku ps --app=my-app

Vấn đề: Bản dựng hết thời gian

Triệu chứng: Build treo hoặc timeout sau 30 phút.

Giải pháp:

1. Chọn buildpack phù hợp
2. Cache phụ thuộc đúng cách
3. Chia nhỏ build lớn
4. Sử dụng slug dựng sẵn để triển khai nhanh

Vấn đề: Vượt quá giới hạn tốc độ

Triệu chứng: Nhận HTTP 429.

Giải pháp:

1. Dùng hàng đợi request
2. Lùi lũy thừa khi retry
3. Gộp các request nếu có thể
4. Theo dõi header rate limit

// Bộ giới hạn tốc độ đơn giản
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;
  }
}

Danh sách kiểm tra triển khai sản xuất

Trước khi đi vào hoạt động:

• [ ] Dùng token API có thời hạn dài cho CI/CD
• [ ] Lưu token trong hệ thống quản lý bí mật (Vault, AWS Secrets Manager)
• [ ] Triển khai giới hạn tốc độ & hàng đợi request
• [ ] Thêm xử lý lỗi toàn diện
• [ ] Ghi nhật ký các cuộc gọi API
• [ ] Giám sát sử dụng giờ dyno
• [ ] Cấu hình log drain cho logging bên ngoài
• [ ] Thiết lập quảng bá quy trình cho CI/CD
• [ ] Bật ACM tự động hóa SSL
• [ ] Sao lưu cơ sở dữ liệu định kỳ

Giám sát và cảnh báo

Theo dõi các chỉ số sau:

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

// Cảnh báo tỷ lệ lỗi
const failureRate = metrics.apiCalls.failed / metrics.apiCalls.total;

if (failureRate > 0.05) {
  sendAlert('Tỷ lệ lỗi API Heroku trên 5%');
}

// Cảnh báo giờ dyno
if (metrics.dynoHours.used > metrics.dynoHours.quota * 0.8) {
  sendAlert('Mức sử dụng giờ dyno trên 80%');
}

Các trường hợp sử dụng thực tế

Quy trình CI/CD tự động

Một nhóm SaaS tự động hóa triển khai từ GitHub:

• Thách thức: Triển khai thủ công dễ lỗi và chậm
• Giải pháp: GitHub Actions + Heroku API
• Kết quả: Triển khai liên tục, phát hành nhanh hơn 90%

Luồng triển khai:

1. Push GitHub trigger workflow
2. Kiểm thử CI
3. API Heroku tạo build từ source blob
4. Quảng bá từ staging sang production
5. Thông báo kết quả cho nhóm

Quản lý đa môi trường

Một công ty tư vấn quản lý 50+ ứng dụng khách hàng:

• Thách thức: Đồng bộ cấu hình thủ công giữa các môi trường
• Giải pháp: Quản lý cấu hình tập trung qua Heroku API
• Kết quả: Cấu hình nhất quán, tiết kiệm 8h/tuần

Tích hợp chính:

• Đồng bộ biến cấu hình dev/staging/prod
• Cung cấp tiện ích bổ sung tự động
• Hành động hàng loạt khi onboarding khách hàng

Tự động mở rộng dựa trên lưu lượng

Nền tảng thương mại điện tử xử lý tăng đột biến traffic:

• Thách thức: Mở rộng thủ công trong sự kiện sale
• Giải pháp: Tự động scale bằng Heroku API
• Kết quả: Không downtime khi traffic gấp 10 lần

Logic:

• Giám sát response time qua API metrics
• Scale lên khi p95 latency > 500ms
• Scale xuống khi traffic thấp
• Cảnh báo mức sử dụng cao kéo dài

Kết luận

API Heroku cung cấp quyền kiểm soát toàn diện các chức năng nền tảng. Lưu ý chính:

• Xác thực Bearer token cần lưu trữ & xoay vòng an toàn
• Giới hạn tốc độ (10K/giờ) cần giám sát chủ động
• Quản lý quy trình cho phép CI/CD mạnh mẽ
• Xử lý lỗi tốt đảm bảo triển khai ổn định
• Apidog tối ưu kiểm thử API & cộng tác cho tích hợp Heroku

Phần Câu hỏi thường gặp

API Heroku được sử dụng để làm gì?

API Heroku cho phép quản lý ứng dụng, dyno, tiện ích bổ sung và hạ tầng theo chương trình. Các trường hợp sử dụng phổ biến: tự động hóa CI/CD, quản lý đa ứng dụng, tự động mở rộng quy mô, dashboard giám sát.

Làm cách nào để lấy khóa API Heroku?

Cài đặt Heroku CLI, chạy heroku login, sau đó tạo ủy quyền với heroku authorizations:create. Lưu token an toàn trong biến môi trường.

API Heroku có miễn phí để sử dụng không?

Có, API Heroku miễn phí. Bạn trả tiền cho tài nguyên (dyno, addon...). Giới hạn API: 10.000 yêu cầu/giờ/tài khoản.

API Heroku sử dụng xác thực nào?

Bearer token. Thêm header Authorization: Bearer {api_key} vào mỗi request. Token có thể ngắn (1h) hoặc dài (tối đa 1 năm).

Làm cách nào để xử lý giới hạn tốc độ API Heroku?

Theo dõi header RateLimit-Remaining, triển khai hàng đợi request. Dùng lùi lũy thừa khi nhận HTTP 429. Giữ <150 request/phút để an toàn.

Tôi có thể triển khai mà không cần Git không?

Có. Sử dụng API Build để deploy từ URL source blob (S3, GCS...). Upload mã lên cloud, dán URL vào request build.

Làm cách nào để tự động hóa việc triển khai?

Dùng API Quy trình để thiết lập CI/CD. Tạo build, đẩy slug qua các giai đoạn, tích hợp với GitHub hoặc hệ thống CI tùy chỉnh.

Sự khác biệt giữa bản phát hành và bản dựng là gì?

Bản dựng: Biên dịch mã thành slug. Bản phát hành: Kết hợp slug với biến cấu hình thành một phiên bản ứng dụng có thể deploy.

Làm cách nào để khôi phục một triển khai thất bại?

Dùng API Release để liệt kê các bản phát hành, POST tới /releases với rollback: <release_id>. Heroku tạo bản phát hành mới ở phiên bản trước.

Tôi có thể quản lý nhiều tài khoản Heroku không?

Có. Dùng token API riêng cho từng tài khoản, chuyển đổi bằng cách thay đổi biến môi trường HEROKU_API_KEY.