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.

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.

Thực tế là: các nhóm quản lý hơn 10 ứng dụng Heroku mất 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 vững chắc 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ộ hóa cấu hình giữa các môi trường.

Hướng dẫn này trình bày toàn bộ quy trình tích hợp API Heroku. Bạn sẽ học cách 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. Cuối cùng, bạn sẽ có một tích hợp Heroku sẵn sàng cho sản xuất.

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ổ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

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 địa chỉ email của bạn
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

Xác thực với Heroku CLI:

# Đăng nhập vào Heroku
heroku login

# Thao tác này mở trình duyệt để xác thực
# Sau khi đăng nhập, token của bạn được lưu trữ cục bộ

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

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

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

Lưu ý bảo mật: Lưu trữ token trong các biến môi trường, không bao giờ trong mã:

# tệp .env
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 xác thực Bearer token:

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

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

Bước 5: Thực hiện cuộc gọi API đầu tiên của bạ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 dự kiến:

{
  "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"
}

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

Tạo một ứng dụng khách API có thể tái sử dụng:

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

// Cách 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 theo chương trình:

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

  return response;
};

// Cách 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 dự kiến

{
  "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" }
}

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

Truy xuất tất cả các ứng dụng trong tài khoản của bạn:

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

// Cách 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

Truy xuất thông tin chi tiết về ứng dụng:

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

// Cách 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

Sửa đổi cài đặt ứng dụng:

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

  return response;
};

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

Xóa ứng dụng

Xóa một ứng dụng khỏi tài khoản của bạn:

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

Mở rộng ứng dụng của bạn lên hoặc xuống:

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

  return response;
};

// Cách 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

Xem cấu hình dyno hiện tại:

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

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

// Cách 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

Khởi động lại Dyno

Khởi động lại tất cả các dyno cho một ứng dụng:

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

Thực thi các lệnh trong các dyno bị cô lập:

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

  return response;
};

// Cách 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

Truy xuất các biến môi trường:

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

// Cách 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

Cập nhật các biến môi trường:

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

  return response;
};

// Cách 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 bao giờ commit thông tin nhạy cảm - Sử dụng biến môi trường cho tất cả dữ liệu nhạy cảm
2. Sử dụng cấu hình riêng cho từng môi trường - Các biến khác nhau cho môi trường thử nghiệm so với môi trường sản xuất
3. Xoay vòng thông tin nhạy cảm thường xuyên - Cập nhật khóa API và mật khẩu hàng quý
4. Tiền tố các 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

Triển khai mã thông qua API:

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

  return response;
};

// Cách 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

Kiểm tra tiến độ 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

Xem lịch sử bản phát hành:

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

// Cách 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

Khôi phục về một phiên bản trước:

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

  return response;
};

// Cách 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

Thiết lập các quy trình CI/CD:

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

  return response;
};

// Cách 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

Kết nối ứng dụng với các giai đoạn 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;
};

// Cách 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

Chuyển mã qua quy trình:

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

Cài đặt tiện ích bổ sung 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;
};

// Cách 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

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

Xem các tiện ích bổ sung đã cài đặt:

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

// Cách 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

Gỡ cài đặt 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

Cấu hình 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;
};

// Cách 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

Thêm SSL vào tên miền tùy chỉnh:

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

Bật Quản lý Chứng chỉ Tự động:

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
• Thời gian: Cửa sổ 60 phút di động
• Đặt lại: Tự động sau khi hết thời gian

Vượt quá giới hạn sẽ dẫn đến phản hồi 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 các lần thử lại:

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 bao gồm các tiêu đề này trong mỗi phản hồ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 là chính xác: heroku authorizations
2. Đảm bảo token chưa hết hạn (token có thời hạn dài có giá trị 1 năm)
3. Kiểm tra khoảng trắng thừa trong biến môi 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: Nhận lỗi “tên đã được sử dụng”.

Giải pháp:

1. Sử dụng tên duy nhất toàn cầu - bao gồm tên nhóm hoặc hậu tố ngẫu nhiên
2. Tạo tên dựa trên UUID: app-${Date.now()}
3. Sử dụng tiền tố không gian tên: 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: Các hoạt động mở rộng trả về lỗi.

Giải pháp:

1. Xác minh loại quy trình tồn tại trong Procfile
2. Kiểm tra xem tài khoản có hạn mức dyno khả dụng không
3. Đảm bảo ứng dụng không bị tạm ngừng
4. Xem lại mức sử dụng giờ dyno: heroku ps --app=my-app

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

Triệu chứng: Bản dựng bị treo hoặc hết thời gian sau 30 phút.

Giải pháp:

1. Tối ưu hóa lựa chọn buildpack cho ngôn ngữ của bạn
2. Bộ nhớ đệm các phụ thuộc đúng cách
3. Chia các bản dựng lớn thành các triển khai nhỏ hơn
4. Sử dụng các slug được dựng sẵn để triển khai nhanh hơn

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

Triệu chứng: Nhận phản hồi HTTP 429.

Giải pháp:

1. Triển khai hàng đợi yêu cầu
2. Sử dụng lùi lũy thừa cho các lần thử lại
3. Gộp các yêu cầu nếu có thể
4. Theo dõi tiêu đề giới hạn tốc độ một cách chủ động

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

• [ ] Sử dụng token API có thời hạn dài cho CI/CD
• [ ] Lưu trữ token trong hệ thống quản lý bí mật an toàn (Vault, AWS Secrets Manager)
• [ ] Triển khai giới hạn tốc độ và hàng đợi yêu cầu
• [ ] Thêm xử lý lỗi toàn diện
• [ ] Thiết lập ghi nhật ký cho tất cả các cuộc gọi API
• [ ] Giám sát mức sử dụng giờ dyno
• [ ] Cấu hình thoát nhật ký cho ghi nhật ký bên ngoài
• [ ] Thiết lập quảng bá quy trình cho CI/CD
• [ ] Bật Quản lý Chứng chỉ Tự động
• [ ] Cấu hình chiến lược sao lưu cho cơ sở dữ liệu

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

Theo dõi các chỉ số này:

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 về tỷ lệ lỗi cao
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 về mức sử dụng 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 gây ra lỗi và chậm trễ
• Giải pháp: GitHub Actions + tích hợp Heroku API
• Kết quả: Triển khai không gián đoạn, phát hành nhanh hơn 90%

Luồng triển khai:

1. Push GitHub kích hoạt quy trình làm việc
2. Kiểm thử chạy trong CI
3. API Heroku tạo bản dựng từ source blob
4. Quảng bá từ staging sang production
5. Thông báo cho nhóm về thành công/thất bại

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

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

• Thách thức: Đồng bộ hóa 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 với Heroku API
• Kết quả: Cấu hình nhất quán, tiết kiệm 8 giờ/tuần

Các điểm tích hợp chính:

• Đồng bộ hóa biến cấu hình giữa dev/staging/prod
• Cung cấp tiện ích bổ sung tự động
• Các hoạt động hàng loạt cho việc giới thiệu khách hàng

Tự động mở rộng quy mô dựa trên lưu lượng truy cập

Một nền tảng thương mại điện tử xử lý các đợt tăng đột biến lưu lượng truy cập:

• Thách thức: Mở rộng thủ công trong các sự kiện bán hàng
• Giải pháp: Tự động mở rộng quy mô dựa trên tải với Heroku API
• Kết quả: Không có thời gian chết trong các đợt tăng đột biến lưu lượng truy cập gấp 10 lần

Logic tự động mở rộng quy mô:

• Giám sát thời gian phản hồi qua API chỉ số
• Mở rộng quy mô khi độ trễ p95 > 500ms
• Thu hẹp quy mô trong các giai đoạn lưu lượng truy cập thấp
• Cảnh báo về mức sử dụng cao kéo dài

Kết luận

API Heroku cung cấp quyền truy cập toàn diện vào các chức năng của nền tảng. Những điểm chính cần lưu ý:

• Xác thực bằng Bearer token yêu cầu lưu trữ và xoay vòng an toàn
• Giới hạn tốc độ (10K/giờ) yêu cầu giám sát chủ động
• Quản lý quy trình cho phép các quy trình CI/CD mạnh mẽ
• Xử lý lỗi đúng cách đảm bảo độ tin cậy của việc triển khai
• Apidog tối ưu hóa việc kiểm thử API và cộng tác nhóm cho các 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 bao gồm tự động hóa CI/CD, công cụ quản lý đa ứng dụng, hệ thống tự động mở rộng quy mô và bảng điều khiển giám sát hạ tầng.

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 trữ token được trả về một cách an toàn trong các biến môi trường.

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

Có, API Heroku là miễn phí. Tuy nhiên, bạn phải trả tiền cho các tài nguyên bạn cung cấp (dyno, tiện ích bổ sung, v.v.). Giới hạn tốc độ API là 10.000 yêu cầu mỗi giờ cho mỗi tài khoản.

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

Heroku sử dụng xác thực Bearer token. Bao gồm tiêu đề Authorization: Bearer {api_key} trong mỗi yêu cầu. Token có thể có thời hạn ngắn (1 giờ) 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?

Giám sát tiêu đề RateLimit-Remaining và triển khai hàng đợi yêu cầu. Sử dụng lùi lũy thừa khi nhận phản hồi HTTP 429. Duy trì dưới 150 yêu cầu mỗi phút để hoạt động an toàn.

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

Có. Sử dụng API Bản dựng để triển khai từ URL source blob. Tải mã của bạn lên bộ lưu trữ đám mây (S3, GCS) và tham chiếu URL trong yêu cầu bản dựng của bạn.

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

Sử dụng API Quy trình để thiết lập CI/CD. Tạo bản dựng, đẩy slug qua các giai đoạn và tích hợp với GitHub hoặc cá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ì?

Một bản dựng biên dịch mã nguồn của bạn thành một slug. Một bản phát hành kết hợp một slug với các biến cấu hình để tạo một phiên bản ứng dụng có thể triển khai được.

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

Sử dụng API Bản phát hành để liệt kê các bản phát hành gần đây, sau đó POST đến /releases với rollback: <release_id>. Heroku tạo một 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ó. Sử dụng các token API riêng biệt cho mỗi tài khoản và chuyển đổi giữa chúng bằng cách thay đổi biến môi trường HEROKU_API_KEY.