# Coolify และ Claude Code: ปรับใช้โปรเจกต์บน VPS ของคุณเอง

> การติดตั้ง Coolify การเชื่อมต่อ GitHub การปรับใช้ Next.js การตั้งค่าโดเมนและ HTTPS, MCP, ข้อกำหนด VPS และการแก้ไขปัญหา ราคาเทคนิคที่ระบุเป็นดอลลาร์และข้อจำกัดตามต้นฉบับ

Source: https://ailoot.ai/blog/th/coolify-claude-code-deploy/
Canonical: https://ailoot.ai/blog/th/coolify-claude-code-deploy/
Language: th
Publisher: Ailoot (https://ailoot.ai/)
Translation: guide-087
Revision: sha256-4e8fde02ee3296cf5db19fcea21a69541b7b0210e8751c0b7ea76bda7c993419


<div class="aside" data-semantic="editorial-reference" role="note" aria-label="Ailoot Documentation">

[เอกสารประกอบ Ailoot](https://ailoot.ai/docs/) — เอกสารอ้างอิงสำหรับการใช้งานบริการ

</div>

## ข้อจำกัดของแพลตฟอร์มและเงื่อนไขการชำระเงินในปี 2026

<div class="aside" data-semantic="key-takeaway" role="note" aria-label="Section highlights">

ประเด็นสำคัญ

แพ็กเกจฟรีใช้ได้จนกว่าจะเกินขีดจำกัดเป็นครั้งแรก หลังจากนั้นต้องใช้บัตรที่รองรับการชำระเงินระหว่างประเทศ Heroku ปิดแพ็กเกจฟรีสำหรับทุกคนในปี 2022 และเข้าสู่โหมดดูแลระบบในเดือนกุมภาพันธ์ 2026 เมื่อใช้ Coolify แบบโฮสต์เอง เซิร์ฟเวอร์เป็นของคุณ ไม่มีการคิดค่าบริการต่อที่นั่งและไม่มีการผูกติดกับผู้ให้บริการ

</div>

สถานการณ์ทั่วไปของนักพัฒนาแบบ vibe ในปี 2026: คุณสร้าง MVP ด้วย Cursor หรือ Claude Code ภายในคืนเดียว ย้ายไปยังรีโพซิทอรี GitHub เปิด vercel.com → เชื่อมต่อรีโพซิทอรี → ไปถึงหน้าสมัครสมาชิก → กรอกข้อมูลบัตร → ได้รับข้อความ `Transaction declined`

นี่ไม่ใช่ข้อบกพร่องหรือการหยุดให้บริการชั่วคราว

Railway, Render, Heroku — ก็เป็นเรื่องเดียวกัน Heroku ปิดแพ็กเกจฟรีสำหรับทุกคนในปี 2022 จริง ๆ และในเดือนกุมภาพันธ์ 2026 โครงการเข้าสู่โหมดดูแลระบบ — ไม่มีฟีเจอร์ใหม่และไม่มีสัญญา Enterprise ใหม่ สำหรับผู้ใช้ที่มีบัตรที่ไม่รองรับ นี่หมายความว่า “ประตูปิดแล้ว ต้องอ้อมผ่านตัวกลางที่คิดค่าคอมมิชชัน 20%”

คุณชำระเงินผ่านบัตร Visa เสมือนในคาซัคสถาน หรือบริการชำระเงินสำหรับองค์กรได้ แต่ก็หมายถึงราคาที่เพิ่มขึ้น 20% ใช้เวลาเพิ่ม 30 นาทีต่อธุรกรรม และเสี่ยงที่บัญชีจะถูกบล็อกเมื่อผู้ประมวลผลการชำระเงินพบว่าประเทศไม่ตรงกัน

ตัวอย่างต้นฉบับมีการลองสามครั้ง — บน Vercel Pro, Railway และ Render

## Coolify คืออะไร และแพลตฟอร์มแบบโฮสต์เองทำงานอย่างไร

<div class="aside" data-semantic="key-takeaway" role="note" aria-label="Section highlights">

ประเด็นสำคัญ

Coolify คือ PaaS แบบโอเพนซอร์สที่โฮสต์เองได้ และเป็นทางเลือกโดยตรงแทน Heroku, Vercel และ Netlify ติดตั้งด้วยคำสั่ง curl เพียงคำสั่งเดียวบน VPS ใดก็ได้ที่ใช้ Ubuntu เบื้องหลังใช้ Docker + Traefik สำหรับ reverse proxy และ Let's Encrypt สำหรับ HTTPS รองรับการเชื่อมต่อ GitHub, webhook สำหรับปรับใช้อัตโนมัติ, การสำรองข้อมูลไปยัง S3 และบริการกว่า 280 รายการที่ติดตั้งได้ด้วยคลิกเดียว (PostgreSQL, Redis, MinIO) เวอร์ชันโฮสต์เองใช้ฟรีตลอดไปโดยไม่มีข้อจำกัด มีดาวบน GitHub 55,800 ดวงและใช้สัญญาอนุญาต Apache-2.0

</div>

Coolify เป็นโครงการโอเพนซอร์สที่สร้างด้วย Laravel + Docker ซึ่งเปลี่ยน VPS เปล่าให้เป็นแพลตฟอร์มปรับใช้แอปพลิเคชัน ติดตั้ง Coolify เพียงครั้งเดียว จากนั้นทำทุกอย่างผ่านเว็บอินเทอร์เฟซ: เชื่อมต่อ GitHub เลือกรีโพซิทอรี แล้วคลิก Deploy

เอกสารทางการอธิบายไว้อย่างสั้นและชัดเจนว่า:

<figure>
<blockquote>
<p>Coolify เป็นทางเลือกแบบโอเพนซอร์สและโฮสต์เองได้แทน Heroku / Netlify / Vercel เป็นต้น</p>
</blockquote>
<figcaption>— README ของ Coolify บน GitHub, https://github.com/coollabsio/coolify</figcaption>
</figure>

เบื้องหลัง Coolify ประกอบด้วยสี่ส่วน:

1. **เว็บอินเทอร์เฟซที่สร้างด้วย Laravel 12 + Livewire 3 + Tailwind v4** — แดชบอร์ดสำหรับจัดการแอปพลิเคชันของคุณ
2. **Docker + Docker Compose** — แต่ละแอปพลิเคชันทำงานในคอนเทนเนอร์ที่แยกจากกัน
3. **Reverse proxy (Traefik หรือ Caddy)** — รับทราฟฟิก HTTP/HTTPS ที่เข้ามาและส่งต่อไปยังคอนเทนเนอร์
4. **การเชื่อมต่อกับ Let's Encrypt** — ออกและต่ออายุใบรับรอง SSL สำหรับทุกโดเมนโดยอัตโนมัติ

ฟีเจอร์สำคัญที่ทำให้ Coolify มีความสามารถใกล้เคียงกับ Vercel:

| ฟีเจอร์ | Vercel | Coolify |
|----|----|----|
| ปรับใช้เมื่อ push ไปยัง git อัตโนมัติ | ✅ | ✅ (ผ่าน webhook ของ GitHub) |
| HTTPS ฟรี | ✅ | ✅ (Let's Encrypt) |
| การปรับใช้ตัวอย่างสำหรับ PR | ✅ | ✅ (ผ่าน GitHub App) |
| UI สำหรับตัวแปรสภาพแวดล้อม | ✅ | ✅ |
| การสำรองฐานข้อมูล | ❌ (ไม่มีฐานข้อมูลของตัวเอง) | ✅ (ไปยังพื้นที่จัดเก็บที่เข้ากันได้กับ S3) |
| PostgreSQL / Redis / MongoDB | \$20+/เดือนต่อรายการ | ✅ ติดตั้งด้วยคลิกเดียว ฟรี |
| งานตามกำหนดเวลา (cron) | ❌ | ✅ (ไวยากรณ์ cron) |
| คิดค่าบริการต่อที่นั่ง | \$20/ที่นั่ง/เดือน | ไม่มี |
| การผูกติดกับผู้ให้บริการ | สูง (Edge Functions, ISR) | ไม่มี (Docker ของคุณเอง) |
| CDN ทั่วโลก | ✅ | ❌ (เฉพาะ VPS ของคุณ) |

CDN ทั่วโลกเป็นสิ่งเดียวที่ Coolify ไม่มีมาให้ตั้งแต่ต้น นี่คือคำตอบอย่างตรงไปตรงมา หากโปรเจกต์ของคุณมีผู้ชมทั่วโลกและต้องการลดเวลาแฝงสำหรับผู้ใช้ในสหรัฐฯ และยุโรป ให้วาง Cloudflare ไว้ข้างหน้า โดยใช้ฟรีสำหรับเนื้อหาแบบสแตติก

ราคา: **เวอร์ชันโฮสต์เองใช้ฟรีตลอดไป** โดยไม่จำกัดจำนวนแอปพลิเคชัน เซิร์ฟเวอร์ หรือการปรับใช้ มี Coolify Cloud ให้ใช้ในราคา \$5/เดือนสำหรับเซิร์ฟเวอร์ 2 เครื่อง + \$3 สำหรับแต่ละเครื่องเพิ่มเติม — แต่เซิร์ฟเวอร์ยังเป็นของคุณ Coolify Cloud เพียงโฮสต์แดชบอร์ดให้เท่านั้น

รุ่นล่าสุดคือ **v4.1.0 จากวันที่ 18 พฤษภาคม 2026** ฟีเจอร์ใหม่ประกอบด้วย build pack Railpack รุ่นเบตา การบันทึกการตรวจสอบ ความแตกต่างของการตั้งค่าระหว่างการปรับใช้ และ MCP endpoint แบบเนทีฟ (อ่านอย่างเดียว) แหล่งที่มา: [รุ่นบน GitHub](https://github.com/coollabsio/coolify/releases)

## ควรเลือก VPS แบบไหนสำหรับ Coolify ในปี 2026

<div class="aside" data-semantic="key-takeaway" role="note" aria-label="Section highlights">

ประเด็นสำคัญ

Coolify ต้องการอย่างน้อย 2 vCPU, RAM 2 GB, SSD 30 GB และ Ubuntu LTS (20.04, 22.04 หรือ 24.04) VPS ในระดับนี้รองรับโปรเจกต์ที่เขียนโค้ดแบบ vibe พร้อมกัน 3–5 โปรเจกต์ได้อย่างสบาย

</div>

ข้อกำหนดขั้นต่ำของ Coolify มาจาก[เอกสารทางการ](https://coolify.io/docs/get-started/installation)โดยตรง:

| พารามิเตอร์ | ขั้นต่ำ | แนะนำ |
|-------------|----------------------------------|---------------------------|
| CPU | 2 คอร์ | 2–4 คอร์ |
| RAM | 2 GB | 4 GB (เผื่อพื้นที่สำหรับการ build) |
| พื้นที่จัดเก็บ | 30 GB | 50–80 GB (สำหรับอิมเมจและฐานข้อมูล) |
| สถาปัตยกรรม | AMD64 หรือ ARM64 (64-bit) | AMD64 |
| ระบบปฏิบัติการ | Ubuntu LTS 20.04 / 22.04 / 24.04 | 22.04 LTS |
| Root | จำเป็น | ใช้ SSH key ไม่ใช่รหัสผ่าน |

ขั้นต่ำ — RAM 2 GB — เป็น **ขีดจำกัดล่างที่ตายตัว** หากมี 1 GB ตัวติดตั้งจะไปถึงขั้น Docker แล้วพบ OOM (หน่วยความจำไม่เพียงพอ) และค้าง อย่าประหยัด RAM

แหล่งราคาคือ [Timeweb Cloud](https://timeweb.cloud/services/vds-vps), [FirstVDS](https://firstvds.ru/products/vds_vps_hosting) และ [Selectel](https://selectel.ru/services/cloud/vps-vds/)

หากต้องการพลังประมวลผลมากขึ้น (ฐานข้อมูล 100 GB, Postgres หลายอินสแตนซ์) ให้เลือก Aeza Dedicated

สิ่งที่ไม่ควรเลือก:

- **Shared VPS ที่มี RAM 512 MB–1 GB** — ไม่เพียงพอแม้แต่สำหรับ Coolify เหมาะกับเว็บไซต์สแตติกบน nginx ไม่ใช่ PaaS



## วิธีติดตั้ง Coolify ใน 5 นาที

<div class="aside" data-semantic="key-takeaway" role="note" aria-label="Section highlights">

ประเด็นสำคัญ

การติดตั้งใช้คำสั่ง curl เพียงคำสั่งเดียวจากเอกสาร เมื่อเริ่มทำงาน เว็บอินเทอร์เฟซจะปรากฏที่พอร์ต 8000 จากนั้นสร้างผู้ดูแลระบบคนแรกและจะเห็นแดชบอร์ดว่าง เวลาจริงตั้งแต่ Ubuntu ที่ติดตั้งใหม่จน Coolify ทำงานคือ 5–7 นาที โดย 3–4 นาทีใช้กับ `apt-get install docker` สคริปต์ดาวน์โหลดทรัพยากรที่จำเป็นและตั้งค่า Docker ให้เอง สิ่งที่คุณต้องทำมีเพียงรอจนเสร็จ

</div>

**ขั้นตอนที่ 1. เชื่อมต่อ VPS ผ่าน SSH**

หลังสร้าง VPS กับผู้ให้บริการแล้ว ที่อยู่ IP ของเซิร์ฟเวอร์และรหัสผ่าน root จะปรากฏในอีเมลหรือแผงควบคุม เชื่อมต่อจากเครื่องของคุณ:

```bash
ssh root@1.2.3.4
```

หากผู้ให้บริการให้ SSH key มาแทนรหัสผ่าน ให้เชื่อมต่อด้วย `-i path/to/key` จากนี้ไปสมมติว่าคุณติดตั้ง Ubuntu 22.04 หรือ 24.04 LTS ใหม่ไว้แล้ว

**ขั้นตอนที่ 2. เรียกใช้คำสั่งติดตั้ง Coolify**

คำสั่งเดียวจาก[เอกสารทางการ](https://coolify.io/docs/get-started/installation):

```bash
curl -fsSL https://cdn.coollabs.io/coolify/install.sh | sudo bash
```

สคริปต์ทำสามอย่าง:

1. ตรวจสอบระบบ (Ubuntu LTS? root? AMD64?)
2. ติดตั้ง Docker และ Docker Compose หากยังไม่ได้ติดตั้ง
3. ดาวน์โหลดอิมเมจ Coolify (`coolify/coolify`, `coolify/realtime`, `traefik`) และรันในเบื้องหลังผ่าน docker-compose

ใช้เวลา 3–5 นาที คุณจะเห็นบันทึก `apt-get` เลื่อนผ่าน ตามด้วย `docker pull` เมื่อเห็น `Coolify v4.1.0 is now running` ให้ไปขั้นตอนที่ 3

**ขั้นตอนที่ 3. เปิดเว็บอินเทอร์เฟซ**

เปิดที่อยู่นี้ในเบราว์เซอร์:

```
http://1.2.3.4:8000
```

Coolify จะแสดงตัวช่วยตั้งค่า — แบบฟอร์มสำหรับสร้างผู้ใช้คนแรก กรอกอีเมลและรหัสผ่านแล้วบันทึก ผู้ใช้นี้จะเป็นผู้ดูแลระบบโดยอัตโนมัติ ตอนนี้ยังไม่ต้องมีผู้ใช้อื่น

หลังบันทึก คุณจะเข้าสู่แดชบอร์ดว่าง: แถบด้านซ้ายมี Resources / Projects / Servers / Sources / Notifications / Settings และข้อความแจ้งตรงกลางว่า “Add your first resource.”

**ขั้นตอนที่ 4. เปิดพอร์ตในไฟร์วอลล์ของผู้ให้บริการ (ไม่ใช่ UFW)**

Coolify ทำงานแล้ว แต่จากภายนอกเข้าถึงได้เฉพาะพอร์ต 8000 (แดชบอร์ด) หากต้องการให้ผู้ใช้เข้าถึงแอปพลิเคชัน ต้องเปิดพอร์ต 80 (HTTP) และ 443 (HTTPS):

| พอร์ต | จุดประสงค์ |
|----|----|
| 22 | การเข้าถึงเซิร์ฟเวอร์ผ่าน SSH |
| 80 | รับทราฟฟิก HTTP และจำเป็นสำหรับการตรวจสอบของ Let's Encrypt |
| 443 | รับทราฟฟิก HTTPS จากผู้ใช้ |
| 8000 | แดชบอร์ด Coolify (เราจะปิดพอร์ตนี้หลังตั้งค่าโดเมนเฉพาะสำหรับแดชบอร์ด) |

ข้อควรระวังสำคัญจากเอกสารทางการ:

<figure>
<blockquote>
<p>Docker ใช้กฎ iptables ที่อาศัย NAT ซึ่งอาจข้ามไฟร์วอลล์ Linux แบบดั้งเดิม เช่น UFW ได้</p>
</blockquote>
<figcaption>— เอกสาร Coolify (ไฟร์วอลล์), https://coolify.io/docs/knowledge-base/server/firewall</figcaption>
</figure>

นั่นหมายความว่า แม้คุณเปิดใช้ UFW และปิดทุกพอร์ต Docker ก็ยังเปิดเผยคอนเทนเนอร์ผ่าน iptables ได้ ในกรณีนี้ UFW ไม่มีประโยชน์ วิธีแก้คือ **เปิดและปิดพอร์ตในแผงควบคุมของผู้ให้บริการ** ไม่ใช่ผ่าน UFW สำหรับ Timeweb / Selectel / Aeza ให้ทำในส่วน “Network → Firewall” ของคอนโซลเว็บ

**ขั้นตอนที่ 5 (ไม่บังคับ). ผูกแดชบอร์ดกับโดเมนของคุณ**

หากต้องการเข้า `https://coolify.example.com` แทน `http://1.2.3.4:8000` ให้สร้างระเบียน DNS A `coolify.example.com → 1.2.3.4` ไปที่ **Settings → Instance Settings → Instance Domain** ใน Coolify กรอกซับโดเมนแล้วบันทึก Coolify จะขอใบรับรอง Let's Encrypt และอีกหนึ่งนาทีต่อมาจะโหลดแดชบอร์ดใหม่ผ่าน HTTPS

หลังจากนั้น คุณปิดพอร์ต 8000 ในไฟร์วอลล์ได้ — แดชบอร์ดจะเข้าถึงได้ผ่าน HTTPS ที่พอร์ตมาตรฐาน 443

## วิธีเชื่อมต่อ GitHub: App หรือ PAT?

<div class="aside" data-semantic="key-takeaway" role="note" aria-label="Section highlights">

ประเด็นสำคัญ

Coolify รองรับการเชื่อมต่อ GitHub สองวิธี: **GitHub App** (แนะนำ) และ **Personal Access Token (PAT)** ใช้ GitHub App: ตั้งค่าด้วยตัวช่วยใช้เวลา 5 นาที ใช้ PR preview ได้ และกำหนดสิทธิ์อย่างละเอียดในระดับรีโพซิทอรี PAT เป็นตัวเลือกเก่าที่ล้าสมัยสำหรับกรณีเดิม ไม่มีการปรับใช้ตัวอย่าง และเสี่ยงที่จะเปิดให้เข้าถึงรีโพซิทอรีทั้งหมดแบบทั่วถึง เอกสารทางการระบุชัดเจนว่า “สำหรับผู้ใช้ 95% แล้ว GitHub App คือคำตอบที่เหมาะสม”

</div>

ใน Coolify ไปที่ **Sources → + Add → GitHub App** Coolify จะแสดงตัวช่วยสามหน้าจอ:

1. **ชื่อและคำอธิบาย** — ตั้งชื่อแหล่งที่มา (กรอก `github-main`) และเพิ่มคำอธิบายได้ตามต้องการ
2. **ตั้งค่าบน GitHub** — ปุ่มนี้จะพาคุณไป GitHub.com และเปิดแบบฟอร์มสร้าง GitHub App พร้อมสิทธิ์ที่ถูกต้องโดยอัตโนมัติ
3. **ยืนยัน** — หลังกลับจาก GitHub ให้คลิก “Save.”

ในขั้นตอนที่สอง GitHub จะขอให้ยืนยันสิทธิ์ที่ Coolify ร้องขอ:

| สิทธิ์ | ระดับ | จุดประสงค์ |
|-----------------|------------|----------------------------------------------|
| Contents | อ่านอย่างเดียว | โคลนรีโพซิทอรี |
| Pull Requests | อ่านและเขียน | สร้างการปรับใช้ตัวอย่างและแสดงความคิดเห็นบน PR |
| Email addresses | อ่านอย่างเดียว | ระบุ commit |
| Metadata | อ่านอย่างเดียว | แสดงรายการรีโพซิทอรี |

นี่คือ **สิทธิ์ขั้นต่ำ** — GitHub App มองไม่เห็น private key ของคุณ เขียนไปยัง `main` ไม่ได้ และเข้าถึงรีโพซิทอรีที่คุณไม่ได้เชื่อมต่อไว้อย่างชัดเจนไม่ได้

จากเอกสารทางการ:



Personal Access Token (PAT) เป็นวิธีเก่า ฉัน **แนะนำว่าอย่าใช้** ข้อเสีย:

- PAT ให้สิทธิ์เข้าถึงรีโพซิทอรีทั้งหมดของคุณ (รวมถึงรีโพซิทอรีส่วนตัว)
- PR preview ใช้ไม่ได้ — ฟีเจอร์นี้มีเฉพาะ GitHub App
- โทเค็นมีอายุนาน (90 วัน หนึ่งปี หรือตลอดไป) — หากรั่วไหลจะเป็นปัญหา

ใช้ PAT เฉพาะเมื่อคุณทำงานกับรีโพซิทอรีขององค์กรที่นโยบายความปลอดภัยห้ามใช้ GitHub Apps และไม่มีทางเลี่ยงเท่านั้น

หลังบันทึกแหล่งที่มาใน Coolify คุณจะเห็น GitHub App ในแดชบอร์ดพร้อมรายการรีโพซิทอรีที่เชื่อมต่อ เมื่อสร้างแอปพลิเคชันใหม่ คุณจะเลือกรีโพซิทอรีใดก็ได้ด้วยคลิกเดียว

## วิธีปรับใช้โปรเจกต์ Next.js จาก Claude Code ใน 6 ขั้นตอน

<div class="aside" data-semantic="key-takeaway" role="note" aria-label="Section highlights">

ประเด็นสำคัญ

เส้นทางครบตั้งแต่เริ่มใช้ Claude Code ไปจนถึงเว็บไซต์ที่เปิดใช้งาน: 1) รัน `claude` ในโฟลเดอร์ว่าง อธิบายโปรเจกต์ แล้ว Claude สร้างโค้ด; 2) รัน `git init && git remote add` (Claude ทำเองได้ผ่านคำสั่ง slash); 3) push ไปยัง GitHub; 4) ใน Coolify เลือก “+ New Resource → Application” แล้วเลือกรีโพซิทอรี; 5) เพิ่มตัวแปรสภาพแวดล้อม; 6) คลิก Deploy Coolify จะตรวจพบว่าเป็น Next.js เลือก build pack Nixpacks สร้างอิมเมจ Docker ใน 3–5 นาที และให้โดเมนชั่วคราวพร้อม HTTPS ตั้งแต่ต้น

</div>

**ขั้นตอนที่ 1. อธิบายโปรเจกต์ให้ Claude Code ในโฟลเดอร์ว่าง**

```bash
mkdir my-vibe-app
cd my-vibe-app
git init
claude
```

ในเซสชัน:

```
สร้างโปรเจกต์ Next.js 14 แบบ app router:
- หน้าแรกที่มีรายชื่อผู้ใช้
- endpoint /api/users ส่งคืนอาร์เรย์จากฐานข้อมูล
- Postgres ผ่าน Prisma
- Tailwind สำหรับสไตล์
- .env.example ที่มี DATABASE_URL
- README.md พร้อมคำแนะนำในการรันโปรเจกต์
```

Claude จะสร้างโครงสร้างไฟล์ package.json, prisma/schema.prisma และ .env.example ขอเพิ่มด้วยว่า:

```
สร้าง Dockerfile สำหรับบิลด์โปรดักชันและไฟล์ .dockerignore
```

ขั้นตอนนี้ไม่บังคับ — Coolify สร้างบิลด์ด้วย Nixpacks ได้แม้ไม่มี Dockerfile แต่ Dockerfile ช่วยให้คุณควบคุมกระบวนการได้ และทำงานได้เร็วกว่าในโปรเจกต์ขนาดใหญ่

**ขั้นตอนที่ 2. สร้างรีโพซิทอรี GitHub แล้ว push โค้ด**

คุณทำเองผ่าน UI ของ GitHub และ `git remote add origin ...` ได้ แต่ Claude Code ก็ทำให้ได้เช่นกัน:

```
/commit-push-pr Initial Next.js app generated with Claude Code
```

หรือพูดว่า: “คอมมิตทุกอย่างแล้วพุชไปยังรีโพซิทอรีใหม่ชื่อ `my-vibe-app` ในบัญชีของฉัน” Claude จะใช้ CLI `gh` เพื่อสร้างรีโพซิทอรีส่วนตัว (หรือสาธารณะ) และ push ครั้งแรก แหล่งที่มา: [คำสั่ง Claude Code อย่างเป็นทางการ](https://github.com/anthropics/claude-code/blob/main/.claude/commands/commit-push-pr.md)

**ขั้นตอนที่ 3. สร้าง Application ใน Coolify**

ในแดชบอร์ด Coolify คลิก **+ New → Application** แบบฟอร์มจะเปิดขึ้น:

1. **Source** — เลือก `github-main` (GitHub App ที่เชื่อมต่อไว้ใน H2 ก่อนหน้า)
2. **Repository** — เลือก `my-vibe-app` จากรายการ
3. **Branch** — `main`
4. **Build Pack** — Coolify จะตรวจหาให้อัตโนมัติ หากมี Dockerfile ก็จะใช้ `dockerfile` มิฉะนั้นจะใช้ `nixpacks` คุณเปลี่ยนเองได้
5. **Domain** — ใช้โดเมนชั่วคราวที่ระบบแนะนำไปก่อน แล้วเปลี่ยนเป็นโดเมนของตัวเองภายหลัง
6. **Port** — `3000` เป็นค่าเริ่มต้นสำหรับ Next.js

บันทึก

**ขั้นตอนที่ 4. เพิ่มตัวแปรสภาพแวดล้อม**

เปิดแท็บ **Environment Variables** ในแอปพลิเคชันที่สร้างขึ้น เพิ่มตัวแปรทีละรายการ:

```
DATABASE_URL=postgresql://user:pass@db-host:5432/mydb
NODE_ENV=production
ANTHROPIC_API_KEY=sk-ant-...
```

หากยังไม่มีฐานข้อมูล ให้สร้างใน Coolify ได้โดยตรง: **+ New → Database → PostgreSQL** Coolify จะเปิดคอนเทนเนอร์ Postgres ภายใน 30 วินาทีและให้ DATABASE_URL ภายในรูปแบบ `postgresql://postgres@postgres-xyz:5432/postgres` — นำไปใส่ในแอปพลิเคชัน

ตัวแปรทั้งหมดได้รับการเข้ารหัสในฐานข้อมูล Coolify และไม่แสดงในบันทึกการ build

**ขั้นตอนที่ 5. คลิก Deploy**

มุมขวาบนมีปุ่ม Deploy สีน้ำเงิน บันทึกแบบเรียลไทม์จะแสดงในแท็บ Logs:

```
[stage: clone]   Cloning '<repository-url-from-github>'
[stage: build]   Detected Next.js, using Nixpacks
[stage: build]   Installing Node 20, npm 10
[stage: build]   npm install (245s)
[stage: build]   npm run build (87s)
[stage: deploy]  Creating container my-vibe-app-xyz
[stage: deploy]  Container started, health check passed
[stage: proxy]   Traefik routing configured for the temporary domain
[stage: ssl]     Let's Encrypt cert issued for the temporary domain
```

การ build ครั้งแรกใช้เวลา 3–5 นาที (ดึงอิมเมจพื้นฐานของ Node และติดตั้ง dependencies) ครั้งถัดไปใช้เวลา 60–90 วินาทีด้วยการแคชเลเยอร์ Docker

เมื่อสถานะเป็น **Running** ให้คัดลอก URL แอปจากช่อง **Domains** ของ Coolify แล้วเปิด URL นั้นจริง ใช้ค่านี้แทน `<app-url-from-coolify>` ด้านล่าง ข้อความในวงเล็บมุมเป็น placeholder ไม่ใช่ที่อยู่จริง หน้าแรกของคุณควรปรากฏพร้อม HTTPS ที่ตั้งค่าไว้แล้ว Coolify ใช้บริการ DNS wildcard ฟรีสำหรับโดเมนชั่วคราว เพื่อให้คุณเปิดเว็บไซต์ได้ทันทีโดยไม่ต้องตั้งค่า DNS ของตัวเอง

**ขั้นตอนที่ 6. ตรวจสอบว่าทุกอย่างทำงาน**

เปิด URL แอปจากขั้นก่อนแล้วเติม `/api/users` เช่น `<app-url-from-coolify>/api/users` โดยไม่ซ้ำ slash นี่คือ endpoint JSON ที่สร้างในขั้น 1 ส่วน URL รูทเป็นหน้าแรก หากเกิดข้อผิดพลาด 500 คุณจะเห็น stack trace ในแท็บ Logs ปัญหาที่พบบ่อยที่สุดในการปรับใช้ครั้งแรกคือ DATABASE_URL ชี้ไปยังฐานข้อมูลที่ไม่มีอยู่ แก้โดยสร้างอินสแตนซ์ PostgreSQL ใน Coolify (ดูขั้นตอนที่ 4 ด้านบน) แล้วเปลี่ยน DATABASE_URL

15 นาที นับจากเวลาที่สั่งซื้อ VPS ในตัวอย่างต้นฉบับ กระบวนการนี้ใช้เวลา 12–18 นาทีบนเซิร์ฟเวอร์ที่เพิ่งติดตั้งใหม่

## วิธีตั้งค่าโดเมนแบบกำหนดเองและ HTTPS

<div class="aside" data-semantic="key-takeaway" role="note" aria-label="Section highlights">

ประเด็นสำคัญ

เชื่อมต่อโดเมนแบบกำหนดเองใน 3 ขั้นตอน: สร้างระเบียน DNS A ที่ชี้ไปยัง IP ของเซิร์ฟเวอร์ กรอกโดเมนใน Configuration ของ Coolify แทนโดเมนชั่วคราว เปิด Automatic HTTPS แล้วคลิก Redeploy Let's Encrypt จะออกใบรับรอง SSL โดยอัตโนมัติ 2–3 นาทีหลัง DNS เผยแพร่ (โดยทั่วไป 5–30 นาที) ข้อกำหนดสำคัญคือ DNS ต้อง resolve ได้แล้วเมื่อคลิก Redeploy มิฉะนั้นการตรวจสอบของ Let's Encrypt จะล้มเหลวและคุณต้องรอ 12 นาทีก่อนลองครั้งต่อไป

</div>

**ขั้นตอนที่ 1. สร้างระเบียน DNS A ในแผงควบคุมของผู้รับจดทะเบียนโดเมน**

ตัวอย่างต้นฉบับใช้โดเมนที่โฮสต์กับ Reg.ru, Beget หรือ Timeweb ขั้นตอนเหมือนกัน:

| ประเภทระเบียน | ชื่อ | ค่า |
|------------|---------------------------|------------------------|
| A | `app` (หรือ `@` สำหรับโดเมนหลัก) | `1.2.3.4` (IP เซิร์ฟเวอร์) |

บันทึก เปิดคอนโซล แล้วตรวจสอบ:

```bash
dig app.example.com +short
# ควรส่งคืน 1.2.3.4
```

หากไม่มีผลลัพธ์หรือได้ IP อื่น แสดงว่า DNS ยังไม่เผยแพร่ รอ 5–30 นาที

**ขั้นตอนที่ 2. กรอกโดเมนใน Coolify**

ในแอปพลิเคชัน เปิดแท็บ **Configuration → General** ในช่อง **Domains** ให้เปลี่ยน URL แอปชั่วคราวที่คัดจาก Coolify เป็น `https://app.example.com` โดยใช้โดเมนของคุณที่ตั้งแล้ว เปิด **Automatic HTTPS** (โดยปกติเปิดไว้เป็นค่าเริ่มต้นแล้ว)

บันทึกแล้วคลิก **Redeploy**

**ขั้นตอนที่ 3. รอใบรับรอง Let's Encrypt**

บันทึกการ build จะแสดงว่า:

```
[stage: ssl]  Requesting Let's Encrypt cert for app.example.com
[stage: ssl]  HTTP challenge sent to /.well-known/acme-challenge/xxx
[stage: ssl]  Validation passed, cert issued
[stage: ssl]  Cert installed, HTTPS enabled
```

ภายใน 2–3 นาที เว็บไซต์จะพร้อมใช้งานที่ `https://app.example.com` พร้อมรูปแม่กุญแจสีเขียวในแถบที่อยู่

สิ่งที่อาจผิดพลาดกับ Let's Encrypt (3 ปัญหาหลักจาก[คู่มือแก้ไขปัญหาอย่างเป็นทางการ](https://coolify.io/docs/troubleshoot/dns-and-domains/lets-encrypt-not-working)):

1. **พอร์ต 80 ปิดอยู่ในไฟร์วอลล์** Let's Encrypt ตรวจสอบด้วย HTTP challenge — ส่งคำขอไปที่ `http://app.example.com/.well-known/acme-challenge/xxx` หากไม่มีพอร์ต 80 การตรวจสอบจะไม่ผ่าน เปิดพอร์ตนี้ในไฟร์วอลล์ของผู้ให้บริการ
2. **เปิดใช้ proxy ของ Cloudflare (เมฆสีส้ม)** ระบบจะดักคำขอ Let's Encrypt แล้วส่งหน้า placeholder ของตัวเองกลับมา ทำให้การตรวจสอบล้มเหลว วิธีแก้คือเปลี่ยนเป็น “DNS only” (เมฆสีเทา) หรือตั้งค่า DNS-01 challenge ผ่าน Cloudflare API
3. **DNS ยังเผยแพร่ไม่เสร็จ** หากคุณสร้างระเบียน A เมื่อ 30 วินาทีก่อนแล้วคลิก Redeploy ทันที Let's Encrypt จะยังไม่เห็นโดเมนของคุณ รอ 5–30 นาทีให้ DNS เผยแพร่ไปยังเซิร์ฟเวอร์ต่าง ๆ

อัตราจำกัดของ Let's Encrypt: **การลองที่ล้มเหลว 5 ครั้งต่อชั่วโมงสำหรับหนึ่งโดเมน** โดยฟื้นคืนสิทธิ์ในอัตรา 1 ครั้งทุก 12 นาที หากชนขีดจำกัด อย่าคลิก Redeploy 10 ครั้งติดกัน ตรวจสอบบันทึก แก้ปัญหา แล้วลองอีกครั้งใน 12 นาที

## Claude Code จัดการ Coolify ผ่าน MCP ได้อย่างไร

<div class="aside" data-semantic="key-takeaway" role="note" aria-label="Section highlights">

ประเด็นสำคัญ

ผ่าน Model Context Protocol, Claude Code จะเข้าถึง Coolify API ได้โดยตรง — คุณสั่งว่า “ปรับใช้แอปพลิเคชันนี้” เพื่อเริ่ม build ตรวจสอบสถานะ อ่านบันทึก หรืออัปเดตตัวแปรสภาพแวดล้อมได้ มีสามตัวเลือก: forsonny/Coolify-MCP-Server (พื้นฐาน มีการทำงาน 7 หมวด), dazeb/coolify-mcp-enhanced (มีเครื่องมือเพิ่มเติมกว่า 15 รายการพร้อมปรับใช้ฐานข้อมูลได้ในคลิกเดียว) และ ajmcclary/Coolify-Manager (Claude Skill ที่สร้างขึ้นโดยใช้ CLI ทางการ) ตั้งแต่ v4.1.0 (18 พฤษภาคม 2026) Coolify มี MCP endpoint ในตัวโดยไม่ต้องใช้เซิร์ฟเวอร์บุคคลที่สาม — แต่ตอนนี้อ่านได้อย่างเดียว

</div>

Model Context Protocol (MCP) เป็นมาตรฐานจาก Anthropic ที่ช่วยให้ Claude Code สื่อสารกับระบบภายนอกได้ (ดูเพิ่มเติมใน[คู่มือเซิร์ฟเวอร์ MCP](https://ailoot.ai/blog/th/mcp-servers-claude-code/)) เชื่อมต่อเซิร์ฟเวอร์ MCP แล้ว Claude จะได้รับชุดเครื่องมือที่เรียกใช้ได้ มีเซิร์ฟเวอร์ที่พร้อมใช้งานสำหรับ Coolify สามตัว และตัวเลือกเนทีฟอีกหนึ่งแบบ

**ตัวเลือกที่ 1. forsonny/Coolify-MCP-Server-for-Claude-Code — พื้นฐาน**



ทำอะไรได้บ้าง:

- **แอปพลิเคชัน:** สร้าง เริ่ม หยุด และเริ่มใหม่
- **บริการ:** แสดงรายการ สร้าง เริ่ม/หยุด/เริ่มใหม่
- **การปรับใช้:** ดูรายการที่กำลังทำงาน และดึงข้อมูลด้วย UUID
- **ทีมและสมาชิก:** แสดงรายการและดูข้อมูล
- **SSH Keys:** แสดงรายการและสร้าง
- **ตัวแปรสภาพแวดล้อม:** CRUD ครบชุดสำหรับแอปและบริการ
- **ข้อมูลเชิงลึกของเซิร์ฟเวอร์:** โดเมนต่อเซิร์ฟเวอร์ สถานะสุขภาพ เวอร์ชัน

การติดตั้ง:

```bash
git clone '<OFFICIAL_URL>'
cd Coolify-MCP-Server-for-Claude-Code
npm install
npm run build
# In .env:
#   COOLIFY_BASE_URL=https://coolify.example.com
#   COOLIFY_API_TOKEN=[from Coolify Settings → API Tokens]
npm run setup  # automatically configures Claude Code
```

หลังจากนั้น เขียนข้อความนี้ใน Claude Code ได้:

```
แสดงสถานะของแอปพลิเคชัน my-vibe-app ใน Coolify และการปรับใช้ล่าสุด 3 รายการ
```

Claude จะส่งคืนตาราง

**ตัวเลือกที่ 2. dazeb/coolify-mcp-enhanced — รุ่นเพิ่มความสามารถ (แนะนำ)**



สิ่งที่เพิ่มจากชุดพื้นฐาน:

- **ปรับใช้ PostgreSQL / Redis / MinIO ได้ในคลิกเดียว** ผ่าน AI — ขอว่า “ตั้งค่า Postgres ให้ฉันหน่อย” แล้วระบบจะสร้างคอนเทนเนอร์และส่ง DATABASE_URL กลับมา
- **การตรวจติดตามแบบเรียลไทม์ + การใช้ทรัพยากร** — CPU/RAM ของแต่ละแอปพลิเคชันแบบเรียลไทม์
- **อัปเดตการตั้งค่า env หลายรายการ** — อัปเดต 20 ตัวแปรด้วยคำสั่งเดียว
- **รองรับ Docker Compose** — ปรับใช้แอปพลิเคชันที่มีหลายบริการ

การกำหนดค่าสำหรับ Claude Code (`.mcp.json` ที่รูทโปรเจกต์):

```json
{
  "mcpServers": {
    "coolify-enhanced": {
      "command": "node",
      "args": ["/path/to/coolify-mcp-enhanced/dist/index.js"],
      "env": {
        "COOLIFY_ACCESS_TOKEN": "your-token-here",
        "COOLIFY_BASE_URL": "https://coolify.example.com"
      }
    }
  }
}
```

**ตัวเลือกที่ 3. ajmcclary/Coolify-Manager — Claude Skill ที่สร้างรอบ CLI**



นี่ไม่ใช่เซิร์ฟเวอร์ MCP แต่เป็น Claude Code Skill ที่ครอบ CLI ทางการของ Coolify ไว้ ประกอบด้วย:

- การวินิจฉัยสุขภาพบริการและคอนเทนเนอร์
- การวินิจฉัยใบรับรอง SSL
- รองรับหลายอินสแตนซ์ (หากคุณมีเซิร์ฟเวอร์ Coolify หลายเครื่อง)
- แนวทางแก้ไขปัญหา

การติดตั้ง: ดาวน์โหลด skill แล้ววางไว้ที่ `~/.claude/skills/coolify-manager/` Claude Code จะตรวจพบและเสนอให้ใช้กับงานที่เกี่ยวข้อง

**ตัวเลือกที่ 4 (ใหม่ในเดือนพฤษภาคม 2026). MCP เนทีฟใน Coolify v4.1.0**

บันทึกการเปลี่ยนแปลงของ v4.1.0 ลงวันที่ 18 พฤษภาคม 2026 ระบุว่า:

> เพิ่มการรองรับ MCP ระดับอินสแตนซ์ พร้อมเครื่องมืออ่านอย่างเดียวสำหรับทรัพยากร Coolify และ API/UI

ตอนนี้ Coolify มี MCP endpoint ของตัวเอง — คุณเชื่อมต่อ Claude Code ได้โดยตรงโดยไม่ต้องใช้เซิร์ฟเวอร์บุคคลที่สาม ขณะนี้ **อ่านได้อย่างเดียว** (รายการแอปพลิเคชัน สถานะ และการกำหนดค่า) ไม่มีคำสั่งแก้ไข แต่ก็เพียงพอสำหรับงานส่วนใหญ่ เช่น “บอกฉันเกี่ยวกับโครงสร้างพื้นฐาน”

เชื่อมต่อผ่าน `.mcp.json`:

```json
{
  "mcpServers": {
    "coolify-native": {
      "url": "https://coolify.example.com/api/v1/mcp",
      "headers": {
        "Authorization": "Bearer <your-api-token>"
      }
    }
  }
}
```

รอให้ MCP เนทีฟรองรับการเขียนเต็มรูปแบบใน v4.2 หรือ v4.3 — ทีม Coolify รับปากว่าจะมีภายในสิ้นปี 2026

## 5 ข้อผิดพลาดในการปรับใช้ครั้งแรก — และวิธีหลีกเลี่ยง

<div class="aside" data-semantic="key-takeaway" role="note" aria-label="Section highlights">

ประเด็นสำคัญ

ข้อผิดพลาดที่พบบ่อยที่สุดในการปรับใช้ครั้งแรกคือ RAM ไม่พอ พอร์ต 80 ปิดอยู่ proxy ของ Cloudflare ทำให้ Let's Encrypt ใช้ไม่ได้ UFW ป้องกัน Docker ไม่ได้ และเลือก PAT แทน GitHub App ทั้งหมดมีอธิบายไว้ในเอกสารทางการ แต่หากไม่มีประสบการณ์จริงก็พบปัญหาเหล่านี้ได้ง่าย ด้านล่างคือรายการตรวจสอบ 5 ข้อจากประสบการณ์ต้นฉบับในการติดตั้ง Coolify ครั้งแรก

</div>

**ข้อผิดพลาดที่ 1: RAM น้อยกว่า 2 GB — การติดตั้งล้มเหลวด้วย OOM**

อาการ: `curl install.sh` ไปถึง `docker pull coolify/coolify` ค้างที่ 70% แล้วกระบวนการถูกยุติด้วย `Killed (signal 9)` บันทึกจาก `dmesg | tail` แสดง `Out of memory: Killed process`

วิธีแก้:

```bash
# สร้างไฟล์ swap ขนาด 4 GB เพื่อแก้ปัญหาชั่วคราว
sudo fallocate -l 4G /swapfile
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile
echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab
```

ในระยะยาวให้อัปเกรดเป็น RAM 4 GB Coolify ทำงานร่วมกับ swap ได้ แต่การ build โปรเจกต์ Next.js ขนาดใหญ่อาจล้มเหลว

**ข้อผิดพลาดที่ 2: เปิด UFW แล้ว แต่ Docker ยังเปิดพอร์ตอยู่**

อาการ: คุณเปิด UFW และปิดทุกพอร์ตยกเว้น 22 แล้ว แต่ยังเข้าถึงแอปพลิเคชันจากอินเทอร์เน็ตได้ผ่านพอร์ตสุ่มบางพอร์ต (เช่น 3000)

สาเหตุตาม[เอกสารทางการ](https://coolify.io/docs/knowledge-base/server/firewall):

<figure>
<blockquote>
<p>Coolify ทำงานบน Docker ซึ่งใช้กฎ iptables ที่อาศัย NAT และอาจข้ามไฟร์วอลล์ Linux แบบดั้งเดิม เช่น UFW ได้</p>
</blockquote>
<figcaption>— เอกสาร Coolify (ไฟร์วอลล์), https://coolify.io/docs/knowledge-base/server/firewall</figcaption>
</figure>

วิธีแก้: ใช้**ไฟร์วอลล์ในแผงควบคุมของผู้ให้บริการ** ไม่ใช่ UFW Timeweb / Selectel / Aeza มีส่วน “Firewall” หรือ “Network → Firewall” สำหรับตั้งกฎในระดับเครือข่ายเสมือน ซึ่งทำงานก่อนที่แพ็กเก็ตจะถึง Docker

อีกทางเลือกคือ ufw-docker ซึ่งเป็นสคริปต์ที่ปรับ UFW ให้ทำงานร่วมกับ Docker ได้ แต่ซับซ้อนกว่าการคลิกในแผงควบคุม

**ข้อผิดพลาดที่ 3: proxy ของ Cloudflare (เมฆสีส้ม) ทำให้ Let's Encrypt ใช้ไม่ได้**

อาการ: หลัง Redeploy บันทึกแสดง `Let's Encrypt validation failed - challenge returned 403`

สาเหตุ: Cloudflare ทำ proxy คำขอ HTTP ของ Let's Encrypt และส่งหน้าเว็บของตัวเองกลับมาแทนไฟล์ challenge ของคุณ

วิธีแก้ — เลือกหนึ่งในสองตัวเลือก:

1. **เปลี่ยนเป็น “DNS only”** (เมฆสีเทาใน Cloudflare) ข้อเสีย: คุณจะเสีย CDN และการป้องกันของ Cloudflare
2. **ตั้งค่า DNS-01 challenge ผ่าน Cloudflare API** ใน Coolify ไปที่ Settings → SSL Configuration เลือกผู้ให้บริการ Cloudflare แล้วกรอก API token ที่มีสิทธิ์ Zone:Read และ DNS:Edit จากนั้น Let's Encrypt จะตรวจสอบผ่านระเบียน TXT แทน HTTP

ตัวเลือกที่สองตั้งค่ายุ่งยากกว่า แต่ยังคงใช้ proxy ของ Cloudflare ได้

**ข้อผิดพลาดที่ 4: ใช้ PAT แทน GitHub App — PR preview ใช้ไม่ได้**

อาการ: คุณเชื่อมต่อ GitHub ด้วย Personal Access Token ทุกอย่างทำงาน แต่ไม่มีการสร้าง preview deployment สำหรับ PR คุณเปิด PR ใน GitHub แล้ว แต่ไม่มีอะไรปรากฏใน Coolify

สาเหตุ: PR preview เป็นฟีเจอร์เฉพาะของ GitHub App ส่วน PAT ไม่ได้รับอีเวนต์ `pull_request` ผ่าน webhook

วิธีแก้: เชื่อมต่อ GitHub ใหม่ผ่าน App: Sources → Add → GitHub App → ทำตามขั้นตอนของตัวช่วย คุณลบแหล่ง PAT เก่าได้

**ข้อผิดพลาดที่ 5: “Coolify == Vercel” ไม่จริงทั้งหมด**

สิ่งที่ Coolify **ทำไม่ได้** ตั้งแต่ต้น:

| Vercel | Coolify | สิ่งที่ควรทำ |
|----|----|----|
| CDN ทั่วโลก | ไม่มี | วาง Cloudflare ไว้ข้างหน้า (ฟรีสำหรับเนื้อหาสแตติก) |
| Incremental Static Regeneration | ไม่มี | `revalidatePath` ใช้ได้เฉพาะบนเซิร์ฟเวอร์ของคุณ |
| การปรับแต่งรูปภาพ | ไม่มี | ใช้ `next/image` กับ local loader หรือ Cloudflare Images |
| ปรับขนาดอัตโนมัติเมื่อมีโหลดสูง | ไม่มี | ปรับขนาดด้วยตนเองหรืออัปเกรด VPS |
| Edge Functions | ไม่มี | ใช้ API routes ปกติ |

หากโปรเจกต์ของคุณเป็น SaaS ที่มีทราฟฟิกสูง มีผู้ชมทั่วโลก และต้องการเวลาแฝง \< 100 ms ทั่วโลก Coolify ไม่เหมาะ ให้เลือก Vercel Enterprise หากคุณเป็นนักพัฒนาแบบ vibe ที่กำลังทดสอบ MVP กับผู้ใช้ 100–1,000 คนต่อวัน Coolify รองรับทุกอย่างที่จำเป็น

จากบทวิเคราะห์การโฮสต์เองอย่างตรงไปตรงมา:



15 นาทีในชื่อคู่มือนี้หมายถึงเส้นทางที่ราบรื่นสำหรับการปรับใช้โปรเจกต์เดียวครั้งแรก การตั้งค่าโครงสร้างพื้นฐานครบถ้วนพร้อมการตรวจติดตาม การสำรองข้อมูล และการแจ้งเตือนใช้เวลาหนึ่งหรือสองคืน พิจารณาตามจริง

## หนึ่งปีจะประหยัดได้เท่าไรเมื่อเทียบกับ Vercel



ตัวเลข Vercel ด้านล่างเป็นค่าประมาณสถานการณ์เดือนพฤษภาคม 2026 ของบทความ ไม่ใช่ใบเสนอราคาปัจจุบัน และเป็นเพียงฝั่งเดียว Coolify โฮสต์เองไม่มีค่า license แต่ VPS สำรอง storage ทราฟฟิก และการดูแลยังมีค่าใช้จ่าย ต้องขอราคาตามความต้องการข้างต้น สถานการณ์นี้ไม่มีราคา VPS เป็นตัวเลข จึงอ้างประหยัดตายตัวไม่ได้

ให้ **C** เป็นบิลโครงสร้างพื้นฐานรายเดือนรวม VPS ที่เลือก storage สำรอง ทราฟฟิกเกิน monitoring และ dashboard เสียเงินถ้ามี นับแต่ละค่าเพียงครั้งเดียว ให้ **r** เป็นต้นทุนงานดูแลต่อชั่วโมง โดยใช้สกุลเดียวกันตลอด เวลาตามบทความคือเริ่ม 5–10 ชั่วโมง บวกเดือนละ 1–2 รวม **17–34 ชั่วโมงปีแรก** และ **12–24 ชั่วโมงปีถัดไป**

| สถานการณ์ | Vercel ประมาณต่อเดือน | Vercel ต่อปี | Coolify โครงสร้างต่อเดือน | TCO ปีแรก Coolify รวมแรงงาน | ประหยัดปีแรกเทียบ Vercel |
|----|----|----|----|----|----|
| ต้นแบบเดียว 100,000 เข้าชมต่อเดือน | ฐาน $20 + bandwidth ~$5 = $25 | $300 | C | 12C + (17–34)r | $300 − 12C − (17–34)r |
| 5 โปรเจกต์บน VPS เดียว | ฐาน $20 + bandwidth/functions $30 = $50 | $600 | C | 12C + (17–34)r | $600 − 12C − (17–34)r |
| นักพัฒนา 3 คน 5 โปรเจกต์ | ที่นั่ง $60 + bandwidth $30 = $90 | $1,080 | C | 12C + (17–34)r | $1,080 − 12C − (17–34)r |

ใช้ C ต่างกันหากแต่ละโหลดต้องขนาดเซิร์ฟเวอร์ต่างกัน เทียบรายเดือนโดยเฉลี่ยเวลาเริ่มใน 12 เดือน: ปีแรกเทียบเท่า **C + (17–34)r/12** ส่วนปีถัดไป TCO คือ **12C + (12–24)r** สูตรเทียบค่าประมาณ Vercel กับค่าโฮสต์เอง ต้องใส่ต้นทุนดูแลที่เทียบกันได้ฝั่ง Vercel ด้วย ประหยัดติดลบแปลว่าโฮสต์เองแพงกว่าตามค่าที่ใส่ อย่านับเงินเดือนวิศวกรซ้ำหาก r รวมแล้ว

ก่อนย้าย ใส่ C จากใบเสนอราคาจริงกับแผนสำรอง เลือก r แล้วเทียบการใช้จริงหนึ่งเดือน หากไม่มีข้อมูลนี้ บทความให้แบบคำนวณต้นทุน ไม่ใช่คำอ้างประหยัดเป็นดอลลาร์


ประโยชน์หลักไม่ใช่เรื่องเงิน เมื่อย้ายมาใช้ Coolify **หมวด “ต้องพึ่งพานโยบายการชำระเงินของผู้อื่น” จะหายไป** ไม่ต้องใช้บัตรตัวกลางเสมือนที่คิดค่าคอมมิชชัน 20% อีกต่อไป

Coolify ไม่ใช่ Vercel เวอร์ชันราคาถูกกว่า แต่เป็นผลิตภัณฑ์คนละประเภท: คุณเป็นเจ้าของโครงสร้างพื้นฐาน รับผิดชอบดูแล และประหยัดเงินด้วยการยอมรับความซับซ้อนของมัน



<div class="section" role="doc-bibliography" aria-label="Sources">

### แหล่งที่มา

- [เอกสาร Coolify อย่างเป็นทางการ: บทนำ](https://coolify.io/docs/get-started/introduction)
- [คู่มือติดตั้ง Coolify](https://coolify.io/docs/get-started/installation)
- [ภาพรวม Build pack ของ Coolify](https://coolify.io/docs/applications/build-packs/overview)
- [ฐานความรู้ Coolify เรื่องไฟร์วอลล์](https://coolify.io/docs/knowledge-base/server/firewall)
- [การแก้ไขปัญหา Let's Encrypt ของ Coolify](https://coolify.io/docs/troubleshoot/dns-and-domains/lets-encrypt-not-working)
- [ราคา Coolify](https://coolify.io/pricing)
- [Coolify บน GitHub: รุ่น v4.1.0](https://github.com/coollabsio/coolify/releases)
- [ภาพรวม Claude Code](https://code.claude.com/docs/en/overview)
- [Timeweb Cloud VPS](https://timeweb.cloud/services/vds-vps)
- [FirstVDS VPS](https://firstvds.ru/products/vds_vps_hosting)
- [Selectel VPS/VDS](https://selectel.ru/services/cloud/vps-vds/)
- [ราคา Vercel](https://vercel.com/pricing)

</div>





ดูเนื้อหาเพิ่มเติมได้ที่ [Ailoot](https://ailoot.ai/).

## คำถามที่พบบ่อย

### หลัง deploy URL ใดควรตอบ JSON?

คัด URL แอปในช่อง Domains ของ Coolify แล้วเปิด path /api/users รูทเป็นหน้าแรก ส่วน /api/users เป็น endpoint JSON ตามโปรเจกต์ตัวอย่าง

### คำนวณว่าโฮสต์เองประหยัดหรือไม่อย่างไร?

รวม VPS สำรอง storage ทราฟฟิก monitoring และ dashboard ทางเลือกต่อเดือนเป็น C TCO ปีแรกคือ 12C บวกแรงงาน 17–34 ชั่วโมงตามราคาต่อชั่วโมง เทียบ Vercel รายปีในสถานการณ์และรวมค่าดูแลที่เทียบกันได้ทั้งสองฝั่ง


## Ailoot · บริษัทและพอร์ตโฟลิโอโครงการของบริษัท

Ailoot อาศัยประสบการณ์การดำเนินงานที่สั่งสม ฐานลูกค้าขนาดใหญ่ บริการที่เสถียร และการติดตาม KPI อย่างต่อเนื่อง

บริษัทและพอร์ตโฟลิโอโครงการของบริษัท: ลูกค้าหลายล้านราย; ยอดขายระดับหลายพันล้านต่อเดือน.

Ailoot นำประสบการณ์การดำเนินงานนี้มาใช้เพื่อให้เข้าถึงฟังก์ชัน AI ผ่าน API ในผลิตภัณฑ์ของลูกค้า เอเจนต์ แอปพลิเคชัน และระบบอัตโนมัติ