Thanawat Wongchai

Posted on Mar 25 • Originally published at apidog.com

วิธีใช้ Heroku API ฉบับสมบูรณ์ คู่มือการเชื่อมต่อ (2026)

#api #automation #devops #tutorial

สรุปย่อ

Heroku API ช่วยให้นักพัฒนาสามารถปรับใช้ระบบอัตโนมัติ จัดการแอปพลิเคชัน กำหนดค่าส่วนเสริม และปรับขนาดโครงสร้างพื้นฐานได้โดยทางโปรแกรม API ใช้ OAuth 2.0 และการยืนยันตัวตนแบบโทเค็น มีปลายทาง RESTful สำหรับแอป ไดโน บิลด์ และไปป์ไลน์ โดยมีข้อจำกัดอัตราการส่งคำขอ 10,000 ครั้งต่อชั่วโมงต่อบัญชี คู่มือนี้ครอบคลุมการตั้งค่าการยืนยันตัวตน ปลายทางหลัก การรวม CI/CD และกลยุทธ์การปรับใช้ในการผลิต

ทดลองใช้ Apidog วันนี้

บทนำ

Heroku ขับเคลื่อนแอปพลิเคชันกว่า 4 ล้านรายการในกว่า 170 ประเทศ สำหรับนักพัฒนาที่สร้างระบบอัตโนมัติในการปรับใช้, ไพพ์ไลน์ CI/CD หรือเครื่องมือจัดการหลายแอป การรวม Heroku API ไม่ใช่ทางเลือก — แต่เป็นสิ่งจำเป็น

นี่คือความเป็นจริง: ทีมที่จัดการแอป Heroku มากกว่า 10 แอปเสียเวลา 8-12 ชั่วโมงต่อสัปดาห์ไปกับการปรับใช้และการเปลี่ยนแปลงการกำหนดค่าด้วยตนเอง การรวม Heroku API ที่มั่นคงจะช่วยให้การปรับใช้เป็นไปโดยอัตโนมัติ, ปรับขนาดไดโนตามปริมาณการใช้งาน และซิงโครไนซ์การกำหนดค่าในสภาพแวดล้อมต่างๆ

คู่มือนี้จะอธิบายกระบวนการรวม Heroku API ทั้งหมด คุณจะได้เรียนรู้การยืนยันตัวตนด้วยโทเค็น, การจัดการแอปและไดโน, การสร้างไพพ์ไลน์, การจัดหาส่วนเสริม และการแก้ไขปัญหาข้อผิดพลาด เมื่อจบหลักสูตรนี้ คุณจะมีการรวม Heroku ที่พร้อมใช้งานจริง

💡Apidog ทำให้การทดสอบการรวม API ง่ายขึ้น ทดสอบปลายทาง Heroku ของคุณ ตรวจสอบโฟลว์การยืนยันตัวตน ตรวจสอบการตอบสนองของ API และดีบักปัญหาการกำหนดค่าในพื้นที่ทำงานเดียว นำเข้าข้อกำหนด API จำลองการตอบสนอง และแบ่งปันสถานการณ์การทดสอบกับทีมของคุณ

Heroku API คืออะไร?

Heroku ให้ RESTful Platform API สำหรับการจัดการแอปพลิเคชันและโครงสร้างพื้นฐานบนแพลตฟอร์ม Heroku API จัดการสิ่งเหล่านี้:

การสร้าง การกำหนดค่า และการลบแอปพลิเคชัน
การปรับขนาด Dyno และการจัดการกระบวนการ
การจัดการ Build และ Release
การจัดหาส่วนเสริมและการกำหนดค่า
การจัดการ Pipeline และ Promotion
การจัดการโดเมนและใบรับรอง SSL
การตั้งค่า Log drain และการตรวจสอบ
การจัดการทีมและผู้ทำงานร่วมกัน

คุณสมบัติหลัก

คุณสมบัติ	คำอธิบาย
การออกแบบ RESTful	วิธีการ HTTP มาตรฐานพร้อมการตอบกลับแบบ JSON
การยืนยันตัวตนด้วยโทเค็น	โทเค็น Bearer พร้อมรองรับ OAuth 2.0
การร้องขอช่วง	การแบ่งหน้าสำหรับชุดผลลัพธ์ขนาดใหญ่
การจำกัดอัตรา	10,000 คำขอต่อชั่วโมงต่อบัญชี
การสร้างแบบ Idempotent	ลักษณะการลองใหม่ที่ปลอดภัยสำหรับการเขียน
การบีบอัดแบบ Gzip	การบีบอัดการตอบกลับเพื่อประหยัดแบนด์วิธ

ภาพรวมสถาปัตยกรรม API

Heroku ใช้โครงสร้าง REST API ที่มีการกำหนดเวอร์ชัน:

https://api.heroku.com/

API เป็นไปตามข้อกำหนด JSON:API พร้อมรูปแบบและความสัมพันธ์ของทรัพยากรที่สอดคล้องกัน

เปรียบเทียบเวอร์ชัน API

เวอร์ชัน	สถานะ	การยืนยันตัวตน	กรณีการใช้งาน
Platform API (v3)	ปัจจุบัน	โทเค็น Bearer	การรวมระบบใหม่ทั้งหมด
การรวม GitHub	ปัจจุบัน	OAuth 2.0	แอปที่เชื่อมต่อกับ GitHub
Container Registry	ปัจจุบัน	การยืนยันตัวตน Docker	การปรับใช้คอนเทนเนอร์

เริ่มต้นใช้งาน: การตั้งค่าการยืนยันตัวตน

ขั้นตอนที่ 1: สร้างบัญชี Heroku ของคุณ

ก่อนเข้าถึง API คุณต้องมีบัญชี Heroku:

เยี่ยมชม เว็บไซต์ Heroku
คลิก Sign Up และสร้างบัญชี
ยืนยันที่อยู่อีเมลของคุณ
ดำเนินการตั้งค่าบัญชีให้เสร็จสมบูรณ์

ขั้นตอนที่ 2: ติดตั้ง Heroku CLI

CLI ช่วยสร้างโทเค็น API และทดสอบคำสั่ง:

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

# Windows
npm install -g heroku

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

ขั้นตอนที่ 3: สร้างโทเค็น API

ยืนยันตัวตนด้วย Heroku CLI:

# Login to Heroku
heroku login

# This opens a browser for authentication
# After login, your token is stored locally

เรียกข้อมูลโทเค็น API ของคุณ:

# View your current authorization token
heroku authorizations:create --short-lived

# Or create a long-lived token (for CI/CD)
heroku authorizations:create --description "CI/CD Pipeline" --expires-in "1 year"

ข้อควรระวังด้านความปลอดภัย: จัดเก็บโทเค็นในตัวแปรสภาพแวดล้อม ห้ามเก็บในโค้ด:

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

ขั้นตอนที่ 4: ทำความเข้าใจการยืนยันตัวตนด้วยโทเค็น

Heroku ใช้การยืนยันตัวตนด้วยโทเค็น Bearer:

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

คำขอ API ทุกครั้งต้องใช้ส่วนหัวเหล่านี้

ขั้นตอนที่ 5: เรียกใช้ API ครั้งแรกของคุณ

ทดสอบการยืนยันตัวตนของคุณ:

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

การตอบสนองที่คาดไว้:

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

ขั้นตอนที่ 6: ใช้การยืนยันตัวตนในโค้ด

สร้างไคลเอนต์ API ที่นำกลับมาใช้ใหม่ได้:

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

// Usage
const account = await herokuRequest('/account');
console.log(`Logged in as: ${account.email}`);

การจัดการแอปพลิเคชัน

การสร้างแอปใหม่

สร้างแอป Heroku โดยโปรแกรม:

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

  return response;
};

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

การตอบสนองของแอปที่คาดไว้

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

การแสดงรายการแอปของคุณ

เรียกดูแอปทั้งหมดในบัญชีของคุณ:

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

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

การดูรายละเอียดแอป

เรียกดูข้อมูลแอปโดยละเอียด:

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

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

การอัปเดตการกำหนดค่าแอป

แก้ไขการตั้งค่าแอป:

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

  return response;
};

// Usage - change app name
const updated = await updateApp('old-app-name', {
  name: 'new-app-name'
});

การลบแอป

ลบแอปออกจากบัญชีของคุณ:

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

  console.log(`App ${appName} deleted successfully`);
};

การจัดการไดโน

การปรับขนาดไดโน

ปรับขนาดแอปพลิเคชันของคุณขึ้นหรือลง:

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

  return response;
};

// Usage - scale web dynos to 3
const formation = await scaleDyno('my-app', 'web', 3);
console.log(`Scaled to ${formation.quantity} ${processType} dynos`);

การดูการจัดรูปแบบ Dyno

ดูการกำหนดค่า dyno ปัจจุบัน:

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

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

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

ขนาด Dyno ที่มีอยู่

ประเภท Dyno	กรณีการใช้งาน	ค่าใช้จ่าย/เดือน
eco	โครงการอดิเรก, ตัวอย่าง	$5
basic	แอปพลิเคชันสำหรับใช้งานจริงขนาดเล็ก	$7
standard-1x	เวิร์กโหลดมาตรฐาน	$25
standard-2x	แอปพลิเคชันประสิทธิภาพสูง	$50
performance	แอปพลิเคชันที่สำคัญต่อการผลิต	$250+
private	การแยกส่วนสำหรับองค์กร	กำหนดเอง

การรีสตาร์ท Dyno

รีสตาร์ทไดโนทั้งหมดสำหรับแอป:

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

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

  console.log(`Dynos restarted for ${appName}`);
};

การรัน Dyno แบบครั้งเดียว

รันคำสั่งในไดโนที่แยกออกมา:

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

  return response;
};

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

ตัวแปรการกำหนดค่า

การเรียกดูตัวแปรการกำหนดค่า

เรียกดูตัวแปรสภาพแวดล้อม:

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

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

การตั้งค่าตัวแปรการกำหนดค่า

อัปเดตตัวแปรสภาพแวดล้อม:

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

  return response;
};

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

แนวทางปฏิบัติที่ดีที่สุดสำหรับตัวแปรการกำหนดค่า

ห้ามคอมมิตข้อมูลลับ - ใช้ตัวแปรสภาพแวดล้อมสำหรับข้อมูลที่ละเอียดอ่อนทั้งหมด
ใช้การกำหนดค่าแยกกันตามสภาพแวดล้อม - ตัวแปรที่แตกต่างกันสำหรับ staging vs production
หมุนเวียนข้อมูลลับเป็นประจำ - อัปเดตคีย์ API และรหัสผ่านทุกไตรมาส
เพิ่มคำนำหน้าตัวแปรที่เกี่ยวข้อง - STRIPE_SECRET_KEY, STRIPE_WEBHOOK_SECRET

การจัดการ Build และ Release

การสร้าง Build

ปรับใช้โค้ดผ่าน API:

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

  return response;
};

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

การตรวจสอบสถานะ Build

ตรวจสอบความคืบหน้าของบิลด์:

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

// Poll until complete
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 succeeded!');
      return build;
    } else if (build.status === 'failed') {
      throw new Error(`Build failed: ${build.output}`);
    }

    console.log(`Build in progress... attempt ${i + 1}`);
    await new Promise(resolve => setTimeout(resolve, 5000));
  }

  throw new Error('Build timeout');
};

การแสดงรายการ Release

ดูประวัติการเผยแพร่:

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

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

การย้อนกลับไปยัง Release ก่อนหน้า

ย้อนกลับไปยังเวอร์ชันก่อนหน้า:

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

  return response;
};

// Usage - rollback to version 42
const rollbackRelease = await rollback('my-app', 42);
console.log(`Rolled back to v${rollbackRelease.version}`);

การจัดการ Pipeline

การสร้าง Pipeline

ตั้งค่าไพพ์ไลน์ CI/CD:

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

  return response;
};

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

การเพิ่มแอปไปยัง 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;
};

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

การโปรโมต Slug ไปยังขั้นตอนถัดไป

ย้ายโค้ดผ่านไปป์ไลน์:

const promoteSlug = async (slugId, toApp) => {
  await herokuRequest('/promotions', {
    method: 'POST',
    body: JSON.stringify({
      from: toApp, // Source app
      to: toApp,   // Target app (next stage)
      slug: slugId
    })
  });

  console.log(`Promoted slug ${slugId} to ${toApp}`);
};

การจัดการส่วนเสริม

การจัดหาส่วนเสริม

ติดตั้งส่วนเสริม 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;
};

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

ส่วนเสริมยอดนิยม

ส่วนเสริม	แผน	ราคาเริ่มต้น	กรณีการใช้งาน
heroku-postgresql	mini	$5/เดือน	ฐานข้อมูลสำหรับใช้งานจริง
heroku-redis	mini	$5/เดือน	แคช, เซสชัน
papertrail	choklad	$7/เดือน	การรวมบันทึก
sentry	developer	ฟรี	การติดตามข้อผิดพลาด
mailgun	sandbox	ฟรี	การส่งอีเมล
newrelic	lite	ฟรี	การตรวจสอบแอปพลิเคชัน

การแสดงรายการส่วนเสริม

ดูส่วนเสริมที่ติดตั้ง:

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

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

การลบส่วนเสริม

ถอนการติดตั้งส่วนเสริม:

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

  console.log(`Addon ${addonId} removed from ${appName}`);
};

การจัดการโดเมนและ SSL

การเพิ่มโดเมนที่กำหนดเอง

กำหนดค่าโดเมนที่กำหนดเอง:

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

  return response;
};

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

การกำหนดค่าใบรับรอง SSL

เพิ่ม 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;
};

SSL อัตโนมัติด้วย 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;
};

การจำกัดอัตราและโควต้า

การทำความเข้าใจการจำกัดอัตรา

Heroku บังคับใช้การจำกัดอัตราเพื่อปกป้องความเสถียรของ API:

ขีดจำกัดมาตรฐาน: 10,000 คำขอต่อชั่วโมงต่อบัญชี
หน้าต่าง: หน้าต่าง 60 นาทีแบบเลื่อน
รีเซ็ต: อัตโนมัติหลังจากหน้าต่างผ่านไป

การเกินขีดจำกัดจะส่งผลให้เกิดการตอบสนอง HTTP 429 (Too Many Requests)

การจัดการการจำกัดอัตรา

ใช้ exponential backoff สำหรับการลองใหม่:

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

      // Check rate limit headers
      const remaining = response.headers.get('RateLimit-Remaining');
      const resetTime = response.headers.get('RateLimit-Reset');

      if (remaining < 100) {
        console.warn(`Low quota remaining: ${remaining}, resets at ${resetTime}`);
      }

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

ส่วนหัวการจำกัดอัตรา

Heroku มีส่วนหัวเหล่านี้ในการตอบกลับทุกครั้ง:

ส่วนหัว	คำอธิบาย
`RateLimit-Limit`	คำขอสูงสุดต่อชั่วโมง
`RateLimit-Remaining`	คำขอที่เหลืออยู่ในหน้าต่าง
`RateLimit-Reset`	การประทับเวลา Unix เมื่อหน้าต่างรีเซ็ต

การแก้ไขปัญหาทั่วไป

ปัญหา: การยืนยันตัวตนล้มเหลวด้วย 401

อาการ: ได้รับข้อผิดพลาด “Invalid credentials”

วิธีแก้ไข:

ตรวจสอบคีย์ API ว่าถูกต้อง: heroku authorizations
ตรวจสอบให้แน่ใจว่าโทเค็นยังไม่หมดอายุ (โทเค็นระยะยาวใช้งานได้ 1 ปี)
ตรวจสอบช่องว่างพิเศษในตัวแปรสภาพแวดล้อม
สร้างโทเค็นใหม่หากจำเป็น: heroku authorizations:create

ปัญหา: ชื่อแอปถูกใช้ไปแล้ว

อาการ: ได้รับข้อผิดพลาด “name is already taken”

วิธีแก้ไข:

ใช้ชื่อที่ไม่ซ้ำกันทั่วโลก - ใส่ชื่อทีมหรือคำต่อท้ายแบบสุ่ม
สร้างชื่อที่อ้างอิง UUID: app-${Date.now()}
ใช้คำนำหน้าเนมสเปซ: 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}`;
};

ปัญหา: การจัดรูปแบบ Dyno ล้มเหลว

อาการ: การดำเนินการปรับขนาดคืนค่าข้อผิดพลาด

วิธีแก้ไข:

ตรวจสอบว่าประเภทกระบวนการมีอยู่ใน Procfile
ตรวจสอบว่าบัญชีมีโควต้า dyno ว่างอยู่
ตรวจสอบให้แน่ใจว่าแอปไม่ได้ถูกระงับ
ตรวจสอบการใช้งาน dyno hour: heroku ps --app=my-app

ปัญหา: Build ล้มเหลวเนื่องจากหมดเวลา

อาการ: บิลด์ค้างหรือหมดเวลาหลังจาก 30 นาที

วิธีแก้ไข:

เพิ่มประสิทธิภาพการเลือก buildpack สำหรับภาษาของคุณ
แคชการพึ่งพาให้ถูกต้อง
แบ่งบิลด์ขนาดใหญ่เป็นการปรับใช้ที่เล็กลง
ใช้ slug ที่สร้างไว้ล่วงหน้าเพื่อการปรับใช้ที่เร็วขึ้น

ปัญหา: เกินขีดจำกัดอัตรา

อาการ: ได้รับการตอบกลับ HTTP 429

วิธีแก้ไข:

ใช้การจัดคิวคำขอ
ใช้ exponential backoff สำหรับการลองใหม่
รวมคำขอเมื่อทำได้
ตรวจสอบส่วนหัวการจำกัดอัตราล่วงหน้า

// Simple rate limiter
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;
  }
}

รายการตรวจสอบการปรับใช้ในการผลิต

ก่อนใช้งานจริง:

[ ] ใช้โทเค็น API ระยะยาวสำหรับ CI/CD
[ ] จัดเก็บโทเค็นในการจัดการความลับที่ปลอดภัย (Vault, AWS Secrets Manager)
[ ] ใช้การจำกัดอัตราและการจัดคิวคำขอ
[ ] เพิ่มการจัดการข้อผิดพลาดที่ครอบคลุม
[ ] ตั้งค่าการบันทึกสำหรับการเรียก API ทั้งหมด
[ ] ตรวจสอบการใช้งาน dyno hour
[ ] กำหนดค่า log drains สำหรับการบันทึกภายนอก
[ ] ตั้งค่าการโปรโมตไปป์ไลน์สำหรับ CI/CD
[ ] เปิดใช้งานการจัดการใบรับรองอัตโนมัติ
[ ] กำหนดค่ากลยุทธ์การสำรองข้อมูลสำหรับฐานข้อมูล

การตรวจสอบและการแจ้งเตือน

ติดตามเมตริกเหล่านี้:

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

// Alert on high failure rate
const failureRate = metrics.apiCalls.failed / metrics.apiCalls.total;

if (failureRate > 0.05) {
  sendAlert('Heroku API failure rate above 5%');
}

// Alert on dyno hour usage
if (metrics.dynoHours.used > metrics.dynoHours.quota * 0.8) {
  sendAlert('Dyno hour usage above 80%');
}

กรณีการใช้งานจริง

Pipeline CI/CD อัตโนมัติ

ทีม SaaS ทำการปรับใช้ระบบอัตโนมัติจาก GitHub:

ความท้าทาย: การปรับใช้ด้วยตนเองทำให้เกิดข้อผิดพลาดและความล่าช้า
วิธีแก้ไข: GitHub Actions + การรวม Heroku API
ผลลัพธ์: การปรับใช้แบบไม่มี Downtime, การเผยแพร่ที่เร็วขึ้น 90%

ขั้นตอนการใช้งาน:

การพุช GitHub ทริกเกอร์เวิร์กโฟลว์
เรียกใช้การทดสอบใน CI
Heroku API สร้างบิลด์จาก source blob
โปรโมตผ่าน staging ไปยัง production
แจ้งเตือนทีมเมื่อสำเร็จ/ล้มเหลว

การจัดการหลายสภาพแวดล้อม

บริษัทที่ปรึกษาจัดการแอปกว่า 50+ รายการสำหรับลูกค้า:

ความท้าทาย: การซิงค์การกำหนดค่าด้วยตนเองในสภาพแวดล้อมต่างๆ
วิธีแก้ไข: การจัดการการกำหนดค่าแบบรวมศูนย์ด้วย Heroku API
ผลลัพธ์: การกำหนดค่าที่สอดคล้องกัน ประหยัดเวลา 8 ชั่วโมง/สัปดาห์

จุดรวมที่สำคัญ:

ซิงค์ config vars ใน dev/staging/prod
การจัดหาส่วนเสริมอัตโนมัติ
การดำเนินการแบบกลุ่มสำหรับการนำลูกค้าใหม่เข้าระบบ

การปรับขนาดอัตโนมัติตามปริมาณการใช้งาน

แพลตฟอร์มอีคอมเมิร์ซจัดการกับปริมาณการใช้งานที่พุ่งสูงขึ้น:

ความท้าทาย: การปรับขนาดด้วยตนเองในระหว่างช่วงการขาย
วิธีแก้ไข: การปรับขนาดอัตโนมัติตามโหลดด้วย Heroku API
ผลลัพธ์: ไม่มีการหยุดทำงานในระหว่างปริมาณการใช้งานที่เพิ่มขึ้น 10 เท่า

ตรรกะการปรับขนาดอัตโนมัติ:

ตรวจสอบเวลาตอบสนองผ่าน Metrics API
ปรับขนาดขึ้นเมื่อ p95 latency > 500ms
ปรับขนาดลงในช่วงปริมาณการใช้งานต่ำ
แจ้งเตือนเมื่อมีการใช้งานสูงต่อเนื่อง

บทสรุป

Heroku API ให้การเข้าถึงฟังก์ชันการทำงานของแพลตฟอร์มอย่างครอบคลุม ประเด็นสำคัญ:

การยืนยันตัวตนด้วยโทเค็น Bearer ต้องมีการจัดเก็บที่ปลอดภัยและการหมุนเวียน
การจำกัดอัตรา (10K/ชั่วโมง) ต้องการการตรวจสอบเชิงรุก
การจัดการไปป์ไลน์ช่วยให้เวิร์กโฟลว์ CI/CD แข็งแกร่ง
การจัดการข้อผิดพลาดที่เหมาะสมช่วยให้การปรับใช้มีความน่าเชื่อถือ
Apidog ช่วยปรับปรุงการทดสอบ API และการทำงานร่วมกันในทีมสำหรับการรวม Heroku

ส่วนคำถามที่พบบ่อย

Heroku API ใช้สำหรับอะไร?

Heroku API ช่วยให้สามารถจัดการแอปพลิเคชัน ไดโน ส่วนเสริม และโครงสร้างพื้นฐานได้โดยโปรแกรม กรณีการใช้งานทั่วไป ได้แก่ ระบบอัตโนมัติ CI/CD เครื่องมือจัดการหลายแอป ระบบปรับขนาดอัตโนมัติ และแดชบอร์ดตรวจสอบโครงสร้างพื้นฐาน

ฉันจะรับ Heroku API key ได้อย่างไร?

ติดตั้ง Heroku CLI, รัน heroku login, จากนั้นสร้างการอนุญาตด้วย heroku authorizations:create จัดเก็บโทเค็นที่ได้รับคืนอย่างปลอดภัยในตัวแปรสภาพแวดล้อม

Heroku API ใช้งานฟรีหรือไม่?

ใช่ Heroku API ใช้งานฟรี อย่างไรก็ตาม คุณจะต้องจ่ายค่าทรัพยากรที่คุณจัดหา (ไดโน ส่วนเสริม ฯลฯ) การจำกัดอัตรา API คือ 10,000 คำขอต่อชั่วโมงต่อบัญชี

Heroku API ใช้การยืนยันตัวตนแบบใด?

Heroku ใช้การยืนยันตัวตนด้วยโทเค็น Bearer ใส่ส่วนหัว Authorization: Bearer {api_key} ในทุกคำขอ โทเค็นอาจมีอายุสั้น (1 ชั่วโมง) หรืออายุยาว (สูงสุด 1 ปี)

ฉันจะจัดการการจำกัดอัตราของ Heroku API ได้อย่างไร?

ตรวจสอบส่วนหัว RateLimit-Remaining และนำการจัดคิวคำขอมาใช้ ใช้ exponential backoff เมื่อได้รับคำตอบ HTTP 429 รักษาระดับการส่งคำขอไม่เกิน 150 ครั้งต่อนาทีเพื่อการทำงานที่ปลอดภัย

ฉันสามารถปรับใช้โดยไม่มี Git ได้หรือไม่?

ได้ ใช้ Builds API เพื่อปรับใช้จาก URL ของ source blob อัปโหลดโค้ดของคุณไปยังที่เก็บข้อมูลบนคลาวด์ (S3, GCS) และอ้างอิง URL ในคำขอบิลด์ของคุณ

ฉันจะปรับใช้ระบบอัตโนมัติได้อย่างไร?

ใช้ Pipeline API เพื่อตั้งค่า CI/CD สร้างบิลด์ โปรโมต slugs ผ่านขั้นตอนต่างๆ และรวมเข้ากับ GitHub หรือระบบ CI แบบกำหนดเอง

ความแตกต่างระหว่าง release และ build คืออะไร?

build คือการคอมไพล์ซอร์สโค้ดของคุณให้เป็น slug release คือการรวม slug เข้ากับตัวแปรการกำหนดค่าเพื่อสร้างเวอร์ชันที่สามารถปรับใช้ได้ของแอปของคุณ

ฉันจะย้อนการปรับใช้ที่ล้มเหลวได้อย่างไร?

ใช้ Releases API เพื่อแสดงรายการรีลีสล่าสุด จากนั้น POST ไปยัง /releases พร้อมกับ rollback: <release_id> Heroku จะสร้างรีลีสใหม่ในเวอร์ชันก่อนหน้า

ฉันสามารถจัดการบัญชี Heroku หลายบัญชีได้หรือไม่?

ได้ ใช้โทเค็น API แยกต่างหากสำหรับแต่ละบัญชีและสลับระหว่างกันโดยการเปลี่ยนตัวแปรสภาพแวดล้อม HEROKU_API_KEY