Coolify คืออะไร? ทำ Vercel ส่วนตัวบน VPS แล้ว deploy เว็บแรกจาก GitHub

Vercel, Netlify และ Heroku ทำให้การขึ้นเว็บง่ายมาก push โค้ดขึ้น GitHub แล้วเว็บก็ออนไลน์ แต่พอโปรเจกต์เยอะขึ้น ต้องมีฐานข้อมูล หรือมีคนเข้าเยอะ ค่าใช้จ่ายและข้อจำกัดของแต่ละแพลตฟอร์มก็ตามมา อีกทางคือเช่า VPS มาเอง ซึ่งคุ้มกว่า แต่ต้องลง Docker ตั้ง reverse proxy ขอใบรับรอง HTTPS และเขียนสคริปต์ deploy เองทั้งหมด

Coolify อยู่ตรงกลางระหว่างสองทางนี้ครับ เราติดตั้งมันลงบนเซิร์ฟเวอร์ของเราเอง แล้วได้แดชบอร์ดที่ deploy แอปจาก GitHub ใส่โดเมน ออกใบรับรอง HTTPS ให้อัตโนมัติ และสร้างฐานข้อมูลพร้อมตั้งเวลาสำรองข้อมูลได้ในไม่กี่คลิก ตัว Coolify เป็น open source และใช้แบบติดตั้งเองได้ฟรี

จบบทความนี้คุณจะ:

• อธิบายได้ว่า Coolify ต่างจาก Vercel และการดูแล VPS เองทุกอย่างยังไง
• เตรียมเซิร์ฟเวอร์ เปิดพอร์ตที่จำเป็น และติดตั้ง Coolify ด้วยคำสั่งเดียว
• deploy แอปแรกจาก Docker image และเว็บจาก GitHub
• ใส่โดเมนของตัวเองพร้อม HTTPS และเพิ่มฐานข้อมูลที่สำรองข้อมูลอัตโนมัติ
• ดูแลเซิร์ฟเวอร์ให้ปลอดภัย และแก้ปัญหาที่เจอบ่อยได้เอง

Coolify คือผู้จัดการตึกของเซิร์ฟเวอร์เรา

ลองเทียบการขึ้นเว็บกับการหาที่อยู่ครับ แพลตฟอร์มสำเร็จรูปอย่าง Vercel เหมือนเช่าห้องในคอนโดที่มีนิติบุคคลดูแลครบ สะดวกมาก แต่ต้องทำตามกฎของตึก และค่าเช่าคิดตามจำนวนห้องและการใช้งาน ส่วนการเช่า VPS เปล่าเหมือนซื้อตึกเปล่ามาทั้งหลัง ถูกกว่าในระยะยาว แต่เราต้องเป็นทั้งช่าง ยาม และนิติบุคคลเอง

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

ข้อสุดท้ายสำคัญครับ ทุกอย่างที่ Coolify สร้างเป็น Docker container มาตรฐาน ไม่ได้ผูกกับระบบพิเศษของ Coolify เอกสารทางการบอกไว้ว่า ถ้าตัว Coolify ล่ม แอปที่รันอยู่แล้วยังรันต่อได้ เราแค่ใช้แดชบอร์ดและระบบอัตโนมัติไม่ได้จนกว่ามันจะกลับมา

ถ้ายังไม่คุ้นกับ Docker ดูคลิปสั้นนี้ก่อนได้ เพราะ Coolify ใช้ Docker เป็นพื้นฐานของทุกอย่าง

ศัพท์ที่ต้องรู้

เตรียมเซิร์ฟเวอร์

Coolify ทำงานบน Linux เท่านั้น ใช้ได้ทั้ง VPS ที่เช่าจากผู้ให้บริการ คอมเก่าที่ลง Linux และเข้าผ่าน SSH ได้ หรือ Raspberry Pi ที่ลง OS แบบ 64-bit ขั้นต่ำตามเอกสาร (ณ ตอนเขียน ต.ค. 2026) คือ

ตัวเลขนี้คือขั้นต่ำสำหรับรัน Coolify เอง การ build แอปกินแรงเครื่องพอสมควร ถ้าจะ build และรันหลายแอปบนเครื่องเดียว ยิ่ง RAM เยอะยิ่งสบาย และ ควรใช้เครื่องใหม่ที่ยังไม่ได้รันอะไร เพราะ Coolify ต้องใช้พอร์ต 80 กับ 443 เอง ถ้ามีเว็บเซิร์ฟเวอร์อื่นจองพอร์ตไว้แล้วจะชนกัน

ถ้าไม่อยากดูแลตัว Coolify เอง มี Coolify Cloud ให้ทีม Coolify ดูแลแดชบอร์ดแทน ส่วนแอปยังรันบนเซิร์ฟเวอร์ของเรา ราคาเริ่ม $5 ต่อเดือนสำหรับ 2 เซิร์ฟเวอร์ และ $3 ต่อเซิร์ฟเวอร์ที่เพิ่ม (ณ ตอนเขียน) บทความนี้ใช้แบบติดตั้งเองซึ่งฟรี

เข้าเซิร์ฟเวอร์ด้วย SSH

ผู้ให้บริการ VPS จะให้ IP กับรหัสผ่านหรือ SSH key มา macOS ใช้ Terminal ส่วน Windows 10/11 มีคำสั่ง ssh ใน PowerShell อยู่แล้ว เปลี่ยน 203.0.113.10 เป็น IP ของเรา

ssh root@203.0.113.10

ครั้งแรกจะถามว่า Are you sure you want to continue connecting (yes/no/[fingerprint])? ให้พิมพ์ yes เป็นการบอกว่าเชื่อเครื่องนี้ จากนั้นเช็กว่าเครื่องตรงตามขั้นต่ำ

grep PRETTY_NAME /etc/os-release
nproc
free -h
df -h /

PRETTY_NAME="Ubuntu 24.04.1 LTS"
2
               total        used        free
Mem:           3.8Gi       410Mi       3.1Gi
Filesystem      Size  Used Avail Use% Mounted on
/dev/sda1        38G  2.1G   34G   6% /

อ่านทีละบรรทัด บรรทัดแรกคือชื่อระบบ nproc บอกจำนวน CPU core free -h บอก RAM (ดูช่อง total) และ df -h / บอกพื้นที่ (ดูช่อง Avail)

เช็กว่าได้แล้ว: เข้า SSH ได้ และตัวเลขทุกตัวไม่ต่ำกว่าขั้นต่ำในตาราง

เปิดพอร์ตที่จำเป็น

เปิดพอร์ตในหน้า firewall ของผู้ให้บริการ VPS พอตั้งโดเมนให้แดชบอร์ดเสร็จ (หัวข้อโดเมนด้านล่าง) จะปิดพอร์ต 8000, 6001 และ 6002 จากภายนอกได้ เหลือแค่ 22, 80 และ 443

ทำไมแนะนำ firewall ของผู้ให้บริการ Docker เขียนกฎ iptables ของตัวเองตอนเปิดพอร์ตให้ container ทำให้ ufw ในเครื่องอาจกันพอร์ตเหล่านั้นไม่ได้อย่างที่คิด firewall ที่อยู่หน้าเครื่องในหน้าเว็บของผู้ให้บริการจึงชัวร์กว่า ถ้าผู้ให้บริการไม่มี เอกสารของ Coolify แนะนำให้ใช้ ufw-docker

ติดตั้ง Coolify

ติดตั้งด้วยคำสั่งเดียว สคริปต์จะลง Docker Engine ให้ถ้ายังไม่มี แล้วดึงส่วนต่างๆ ของ Coolify มารันเป็น container ใช้เวลาไม่กี่นาที

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

ถ้าเข้าด้วยผู้ใช้ธรรมดาที่ใช้ sudo ได้ ให้ใส่ sudo หน้า bash เพราะสคริปต์ต้องใช้สิทธิ์ root

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

curl -fsSL ดาวน์โหลดสคริปต์แบบเงียบๆ และหยุดถ้าดาวน์โหลดไม่สำเร็จ แล้ว | bash ส่งต่อให้ bash รันทันที ถ้าเคยลง Docker ผ่าน snap ไว้ ให้ลบออกก่อน เพราะ Coolify ต้องการ Docker Engine ตัวปกติ ติดตั้งเสร็จจะเห็นข้อความแสดงความยินดีพร้อมลิงก์แดชบอร์ด

Congratulations! Your Coolify instance is ready to use.
Please visit http://203.0.113.10:8000 to get started.

ระวัง สมัครแอดมินทันทีที่ติดตั้งเสร็จ หน้าแรกของ Coolify คือหน้าสมัครบัญชี และ ใครเข้าถึงหน้านี้ก่อนจะได้เป็นแอดมิน ซึ่งเท่ากับได้สิทธิ์ root ของเซิร์ฟเวอร์ไปด้วย อย่าปล่อยไว้ข้ามคืน เปิดลิงก์แล้วสมัครเลย

เช็กว่าส่วนต่างๆ ของ Coolify รันอยู่

docker ps --format '{{.Names}}'

coolify
coolify-realtime
coolify-db
coolify-redis
coolify-proxy

coolify คือตัวแดชบอร์ด coolify-db กับ coolify-redis เก็บข้อมูลของ Coolify เอง coolify-realtime ดูแลการอัปเดตแบบเรียลไทม์ และ coolify-proxy คือ Traefik ที่รับคนเข้าเว็บทุกเว็บ

สมัครแอดมินและเปิดแดชบอร์ด

เปิดเบราว์เซอร์ไปที่ http://203.0.113.10:8000 (เปลี่ยนเป็น IP ของเรา) กรอกชื่อ อีเมล และรหัสผ่านที่ยาวและไม่ซ้ำกับที่อื่น บัญชีนี้คือกุญแจทั้งเซิร์ฟเวอร์

เข้าแดชบอร์ดแล้วจะเห็นเซิร์ฟเวอร์ชื่อ localhost อยู่แล้ว นั่นคือเครื่องที่ติดตั้ง Coolify เอง เราจะ deploy ทุกอย่างลงเครื่องนี้ (ภายหลังเพิ่มเซิร์ฟเวอร์อื่นผ่าน SSH ได้) เปิดหน้าของเซิร์ฟเวอร์ localhost แล้วดูว่าสถานะขึ้น Proxy is running ถ้ายังหยุดอยู่ ให้กด Start Proxy

เช็กว่าได้แล้ว: ล็อกอินได้ และเซิร์ฟเวอร์ localhost ขึ้นว่า proxy กำลังทำงาน

แอปแรกจาก Docker image

เริ่มจากแอปที่ง่ายที่สุดก่อน คือเว็บเซิร์ฟเวอร์ nginx ที่มีคนทำ image ไว้แล้ว ไม่ต้องมีโค้ดของเราเลย เป้าหมายคือดูว่าทั้งระบบทำงานครบวง

1. กด New Project ตั้งชื่อ เช่น my-first-project แล้วกด Continue
2. เข้าโปรเจกต์ แล้วกด Create New Resource
3. เลือก Docker Image แล้วใส่ nginx:alpine
4. ในหน้าตั้งค่า ตั้ง Ports Exposes เป็น 80
5. ปล่อยโดเมนที่ Coolify สร้างให้ไว้ตามเดิม แล้วกด Deploy

Ports Exposes คือพอร์ตที่แอป ฟังอยู่ข้างใน container nginx ฟังที่พอร์ต 80 เราจึงใส่ 80 ถ้าใส่ไม่ตรง proxy จะหาแอปไม่เจอ ส่วนโดเมนที่ได้จะหน้าตาประมาณนี้

http://k8w2m1x9q4.203.0.113.10.sslip.io

sslip.io คือบริการ DNS ฟรีที่อ่าน IP จากชื่อโดเมนแล้วตอบ IP นั้นกลับไป เราจึงได้โดเมนใช้ทดสอบทันทีโดยไม่ต้องซื้อ ลองเช็กเองด้วย nslookup ได้ (อ่านเรื่อง DNS เพิ่มได้ที่ DNS คืออะไร)

nslookup my-app.203.0.113.10.sslip.io

Name:    my-app.203.0.113.10.sslip.io
Address: 203.0.113.10

deploy เสร็จแล้วเปิดลิงก์ของแอป ต้องเห็นหน้า Welcome to nginx!

เช็กว่าได้แล้ว: เปิดโดเมน sslip.io แล้วเห็นหน้าต้อนรับของ nginx แปลว่า Coolify ดึง image รัน container และต่อ proxy ได้ครบ

deploy เว็บจาก GitHub

ทีนี้มาลองแบบที่ใช้จริง คือดึงโค้ดจาก GitHub มา build เอง ใช้ repo ตัวอย่างของทีม Coolify ซึ่งมีโฟลเดอร์ static เป็นเว็บ HTML ล้วน

1. ในโปรเจกต์เดิม กด + New แล้วเลือก Public Repository
2. ใส่ URL https://github.com/coollabsio/coolify-examples แล้วกด Check Repository
3. เลือก Build pack เป็น Static และตั้ง Base Directory เป็น /static
4. ไปหน้าตั้งค่าของแอป แล้วกด Deploy
5. เปิด Deployment Logs ดูว่าดึง repo branch และ commit ถูกตัว

repo นี้ใช้ branch main ถ้าอยากได้ branch อื่นให้ต่อท้าย URL แบบ .../coolify-examples/tree/next deploy เสร็จแล้วเปิดโดเมนของแอป จะเห็นข้อความทดสอบที่ขึ้นต้นว่า It works.

เช็กว่าได้แล้ว: Deployment Logs จบโดยไม่มี error และเปิดเว็บแล้วเห็นข้อความ It works.

Build pack เลือกแบบไหน

ใช้กับโปรเจกต์ของตัวเอง

• repo ส่วนตัว เชื่อม GitHub ผ่าน GitHub App หรือให้ deploy key (กุญแจที่อ่าน repo เดียวได้อย่างเดียว)
• deploy เองทุกครั้งที่ push แอปที่สร้างผ่าน GitHub App จะตั้ง Deploy on push (webhooks) ไว้ให้แล้ว ดูหรือเปลี่ยนได้ที่ Advanced แล้วไปที่ Deployment ส่วน repo สาธารณะที่ไม่ได้ผ่าน GitHub App ใช้ repository webhook หรือ GitHub Actions สั่ง deploy แทน
• พอร์ตต้องตรง แอป Node ที่ฟังพอร์ต 3000 ต้องตั้ง Ports Exposes เป็น 3000
• ฟังที่ 0.0.0.0 แอปใน container ต้องรับการเชื่อมต่อจากทุก network ถ้าฟังแค่ 127.0.0.1 proxy จะเข้าไม่ถึง
• ค่าลับใส่ใน Environment Variables ของแอป ห้ามเขียนรหัสผ่านลงในโค้ด

build ที่ล้มจะไม่ทำให้เว็บเดิมพัง เพราะ Coolify build ให้เสร็จก่อนค่อยสลับ container และถ้าตั้ง health check ไว้ มันจะรอให้ container ใหม่พร้อมก่อนค่อยปิดตัวเก่า คนเข้าเว็บจึงไม่เห็นช่วงที่เว็บดับ

ใส่โดเมนจริงและ HTTPS

โดเมน sslip.io ใช้ทดสอบได้ แต่เป็น http:// เท่านั้น อย่าเปลี่ยนเป็น https:// เพราะเป็นโดเมนที่คนทั้งโลกใช้ร่วมกัน Let's Encrypt (ผู้ออกใบรับรองฟรี) จำกัดจำนวนการขอไว้ ใช้งานจริงต้องมีโดเมนของเราเอง

1. ตั้ง DNS ที่ผู้ให้บริการโดเมน (หรือ Cloudflare) เพิ่ม A record ชื่อ app ชี้ไปที่ IP ของเซิร์ฟเวอร์
2. เช็กว่า DNS ชี้ถูกแล้ว ด้วย nslookup app.example.com ต้องได้ IP ของเซิร์ฟเวอร์
3. ใส่โดเมนใน Coolify เปิดแอป ไปที่ Domains กด Add domain แล้วใส่ https://app.example.com
4. กด Redeploy เพราะ Coolify ผูกโดเมนกับ proxy ตอน deploy

https://app.example.com

ใส่ https:// นำหน้าเมื่อไร proxy จะขอใบรับรองจาก Let's Encrypt และต่ออายุให้เองอัตโนมัติ เงื่อนไขมีสามข้อ คือโดเมนต้องชี้มาที่เซิร์ฟเวอร์นี้ พอร์ต 80 และ 443 ต้องเปิด และโดเมนต้องอยู่ในช่อง Domains ของแอป

ถ้าเห็นโดเมนเขียนแบบ https://app.example.com:3000 ตัวเลขท้ายคือ พอร์ตข้างใน container ไม่ได้เปิดพอร์ต 3000 สู่ภายนอก คนเข้าเว็บยังเข้าทางพอร์ต 443 ตามปกติ

ตั้งโดเมนให้แดชบอร์ดด้วย ทำแบบเดียวกันกับตัว Coolify เช่น ชี้ coolify.example.com มาที่เซิร์ฟเวอร์ แล้วใส่โดเมนนี้ในหน้า Settings ของ instance พอเปิดแดชบอร์ดผ่าน https://coolify.example.com ได้แล้ว ให้ปิดพอร์ต 8000, 6001 และ 6002 จากภายนอก แดชบอร์ดจะเข้าผ่าน HTTPS อย่างเดียว

เช็กว่าได้แล้ว: เปิด https://app.example.com แล้วเห็นเว็บ และเบราว์เซอร์ไม่เตือนเรื่องใบรับรอง

เพิ่มฐานข้อมูลและสำรองข้อมูล

Coolify สร้างฐานข้อมูลได้หลายแบบ ได้แก่ PostgreSQL, MySQL, MariaDB, MongoDB, Redis, Dragonfly, KeyDB, ClickHouse และ SQLite (ทดลอง) ลองสร้าง PostgreSQL

1. ในโปรเจกต์ กด Create New Resource แล้วเลือก PostgreSQL
2. ดูรหัสผ่านที่ Coolify สร้างให้ในหน้า General แล้วกด Start
3. คัดลอก Internal URL ไปใส่ใน Environment Variables ของแอป เช่น ตั้งชื่อว่า DATABASE_URL
4. Redeploy แอป เพื่อให้แอปได้ค่าใหม่

postgres://postgres:รหัสผ่าน@q0w9e8r7t6y5:5432/postgres

ตรง q0w9e8r7t6y5 คือชื่อ container ของฐานข้อมูล แอปที่อยู่ใน network เดียวกันเรียกหากันด้วยชื่อนี้ได้เลย อย่าเปลี่ยนเป็น IP ของเซิร์ฟเวอร์ เพราะฐานข้อมูลไม่ได้เปิดพอร์ตสู่ภายนอก ซึ่งเป็นค่าเริ่มต้นที่ปลอดภัยที่สุด เปิด Public access เฉพาะตอนจำเป็นจริงๆ และถ้าเปิดควรจำกัด IP ด้วย firewall

ตั้งเวลาสำรองข้อมูล

1. เปิดฐานข้อมูล ไปที่ Backups แล้วกด + Add
2. ใส่ตารางเวลาเป็น daily หรือ cron 5 ช่อง เช่น 0 3 * * * คือทุกวันตีสาม (ตามเขตเวลาของเซิร์ฟเวอร์)
3. ตั้งจำนวนหรือจำนวนวันที่จะเก็บ (0 คือไม่จำกัด)
4. กด Back up now หนึ่งครั้ง แล้วดูว่าสถานะสำเร็จ และไฟล์มีขนาดมากกว่า 0

ไฟล์สำรองเก็บไว้ที่ /data/coolify/backups บนเครื่องเดียวกัน ถ้าเครื่องพังก็หายไปด้วย จึงควรส่งไปที่ S3 ด้วย (ใช้ที่เก็บแบบ S3 ของเจ้าไหนก็ได้ เช่น Cloudflare R2 ซึ่งมีเล่าไว้ใน บทความ Cloudflare) โดยเพิ่ม S3 Storage ใน Coolify ก่อน (bucket ต้องมีอยู่แล้ว) แล้วเปิด S3 ในตารางสำรองข้อมูล

backup ที่ไม่เคยลองกู้ ยังไม่ใช่ backup กู้ข้อมูลได้จาก Import Backup ของฐานข้อมูลที่รันอยู่ แต่ Coolify ไม่ได้ตรวจให้ว่าไฟล์กู้ได้จริง ลองกู้ใส่ฐานข้อมูลทดสอบสักครั้ง ส่วน Redis, Dragonfly และ KeyDB ไม่มีระบบตั้งเวลาสำรองข้อมูลในตัว

ดูแลให้ปลอดภัย

• สมัครแอดมินทันทีหลังติดตั้ง และใช้รหัสผ่านที่ยาว ไม่ซ้ำกับที่อื่น
• ปิดพอร์ตที่ไม่ใช้ เหลือ 22, 80 และ 443 หลังตั้งโดเมนให้แดชบอร์ดแล้ว
• เข้า SSH ด้วย key แทนรหัสผ่าน ถ้าผู้ให้บริการให้เลือก
• อัปเดตอยู่เสมอ อัปเดต Coolify ได้ที่ Settings แล้วไปที่ Updates และเปิด Automatic updates พร้อมตั้งความถี่ได้ (ค่าเริ่มต้นคือทุกวันตอนเที่ยงคืน) ส่วนแพ็กเกจของระบบปฏิบัติการ Coolify มีหน้า Server Patching ให้ตรวจและอัปเดต
• เก็บแดชบอร์ดไว้ใน network ส่วนตัว ถ้าไม่อยากเปิดแดชบอร์ดสู่อินเทอร์เน็ตเลย ใช้ Tailscale เข้าผ่าน IP ส่วนตัวได้ อ่านวิธีได้ที่ Tailscale

เจอปัญหา ลองเช็กตามนี้

ถ้ายังไม่รู้สาเหตุ เปิด Deployment Logs ของรอบที่มีปัญหา และ Logs ของ container ในหน้าแอป สาเหตุเกือบทุกอย่างจะอยู่ในสองที่นี้

ไปต่อ

• Services แบบคลิกเดียว Coolify มีแม่แบบซอฟต์แวร์สำเร็จรูปกว่า 300 ตัว (ณ ตอนเขียน) ลองเริ่มจาก Umami ที่ใช้ดูสถิติคนเข้าเว็บ ตามคู่มือ Deploy your first service
• Preview deployments ให้ทุก pull request ได้เว็บทดสอบของตัวเองก่อน merge
• เพิ่มเซิร์ฟเวอร์ ให้ Coolify ตัวเดียวคุมหลายเครื่องผ่าน SSH หรือแยกเครื่อง build ออกไป
• เอกสารทางการ coolify.io/docs และ คู่มือ firewall

สรุป

• Coolify คือ PaaS แบบ open source ที่ติดตั้งบนเซิร์ฟเวอร์ของเราเอง ได้แดชบอร์ดแบบ Vercel แต่ทุกอย่างเป็น Docker container ธรรมดา ย้ายไปที่อื่นได้
• ใช้ Linux ขั้นต่ำ 2 core, RAM 2 GB, พื้นที่ 10 GB ติดตั้งด้วย curl -fsSL https://cdn.coollabs.io/coolify/install.sh | bash แล้วสมัครแอดมินที่ :8000 ทันที
• deploy ได้ทั้ง Docker image และโค้ดจาก GitHub Ports Exposes ต้องตรงกับพอร์ตที่แอปฟังข้างใน container
• โดเมนจริงต้องชี้ DNS มาที่เซิร์ฟเวอร์ เปิดพอร์ต 80/443 ใส่ https:// ในช่อง Domains แล้ว Redeploy
• ฐานข้อมูลใช้ Internal URL ไม่เปิดพอร์ตสู่ภายนอก ตั้งเวลาสำรองข้อมูลส่งไป S3 และลองกู้จริงสักครั้ง

พร้อมแล้วก็ไปทำ Quiz ท้ายบทด้านล่างเพื่อรับ XP ได้เลยครับ