วิธีติดตั้ง Rakazo บน VPS ด้วยตัวเองแบบครบวงจร
เรียนรู้วิธีติดตั้ง Rakazo บน VPS ด้วย Docker Compose พร้อมตั้งค่า Node 22, pnpm, Postgres และ Graphile Worker รวมถึงคำแนะนำการเลือก Sandbox และการจัดการคีย์สำหรับบอท AI ของคุณ
สิ่งที่ Rakazo ที่คุณโฮสต์เองทำงานอยู่จริง
การโฮสต์ Rakazo ด้วยตนเองหมายถึงการรัน 5 ส่วนประกอบบนเซิร์ฟเวอร์ Linux เครื่องเดียว ได้แก่ PostgreSQL, กระบวนการ Graphile Worker, API, เว็บแอป และคอนเทนเนอร์ sandbox ที่ทำหน้าที่เป็นคอมพิวเตอร์สำหรับบอท Rakazo เป็นทางเลือกโอเพนซอร์สแทน Grok Bot ซึ่งเผยแพร่โดย elie222 ภายใต้สัญญาอนุญาต Apache 2.0 บอทแต่ละตัวจะมีบทสนทนา หน่วยความจำ กิจวัตร และประวัติเป็นของตัวเอง โดยจะใช้ Team Computer ร่วมกับบอทตัวอื่นในพื้นที่ทำงานเดียวกัน เว้นแต่จะได้รับ Private Computer แยกต่างหาก และสามารถสร้าง peer หรือ subagent ที่มีอายุการใช้งานสั้นได้ หากคำอย่างหน่วยความจำ, subagent และการเรียกใช้เครื่องมือ (tool call) เป็นคำที่ไม่คุ้นเคยในประโยคข้างต้น เส้นทางที่จัดลำดับไว้เพื่อทำความเข้าใจว่าเอเจนต์ทำงานอย่างไร เป็นสิ่งที่ควรใช้เวลาศึกษาในช่วงบ่ายก่อน เพราะการตั้งค่าส่วนใหญ่ด้านล่างนี้จะเข้าใจได้ก็ต่อเมื่อคุณเห็นภาพว่าบอทกำลังทำอะไรเมื่อมันตื่นขึ้นมา
เหตุผลข้างต้นคือสาเหตุที่งานนี้ควรอยู่บน VPS (virtual private server) ไม่ใช่บนเดสก์ท็อป บอทที่เก็บหน่วยความจำและรันงานตามกำหนดการจำเป็นต้องเข้าถึงได้ในขณะที่คุณหลับ แล็ปท็อปที่เข้าสู่โหมดพักเครื่องจะทำให้คิวงานหลุดไป
Rakazo ยังคงระบุว่าตนเองอยู่ในสถานะเบต้า ณ เดือนตุลาคม 2026 แม้ว่าจะมีการเผยแพร่เวอร์ชันที่มีเลขเวอร์ชันเสถียรแล้วก็ตาม ดังนั้นให้ถือว่านี่เป็นการตั้งค่าที่ใช้งานได้จริงมากกว่าจะเป็นผลิตภัณฑ์สำเร็จรูป Stack ทั้งหมดเป็น TypeScript: ใช้ React 19 และ Vite สำหรับเว็บแอป, Hono สำหรับ API, Postgres ร่วมกับ Prisma, Better Auth สำหรับบัญชีผู้ใช้ และ Graphile Worker สำหรับงานเบื้องหลัง Graphile Worker จะจัดเก็บคิวไว้ใน Postgres ดังนั้นจึงไม่มี Redis และไม่มีที่เก็บข้อมูลที่สองให้ต้องรัน .env.example ตั้งค่า WAKEUP_DRIVER=graphile ซึ่งหมายความว่าการที่บอทตื่นขึ้นมาคือการทำงานของงานที่สนับสนุนโดย Postgres หากคุณหยุด Postgres การทำงานของบอทตามกำหนดการทั้งหมดจะหยุดลงตามไปด้วย หากคุณต้องการประกอบเอเจนต์จากชิ้นส่วนต่างๆ แทนที่จะรันผลิตภัณฑ์ของผู้อื่น การสร้างเอเจนต์ของคุณเองจากส่วนประกอบ คืออีกเส้นทางหนึ่งที่คุณเลือกได้
เหตุใดแผน 1 GB จึงรองรับงานนี้ไม่ได้
นับจำนวน process: Postgres เป็นหนึ่ง process, API เป็น process ของ Node, worker เป็น process ที่สอง, web app เป็น process ที่สาม และ sandbox supervisor เป็น process ที่สี่ จากนั้นยังมีคอมพิวเตอร์ของ bots: โดยค่าเริ่มต้นคือ Team Computer container ที่ใช้ร่วมกันหนึ่งชุด ซึ่งมี graphical Linux desktop, X display แยกต่างหาก และ Chrome process แยกสำหรับ bot แต่ละตัวที่กำลังทำงานอยู่
เอกสาร self-host ของโปรเจกต์นี้ไม่ระบุขนาด host อีกต่อไป เอกสารที่ v0.3.5 ซึ่งตรวจสอบเมื่อ 27 October 2026 ระบุเฉพาะข้อกำหนดด้านซอฟต์แวร์ สิ่งที่เอกสารระบุคือเพดานต่อคอมพิวเตอร์: เมื่อใช้ Docker sandboxes ค่าเริ่มต้นของ RAKAZO_COMPUTER_MEMORY คือ 2g และของ RAKAZO_COMPUTER_CPUS คือ 2 เพดานนี้ใช้กับคอมพิวเตอร์แต่ละเครื่อง ไม่ใช่ bot แต่ละตัว โดยค่าเริ่มต้นแต่ละ workspace จะได้รับ Team Computer หนึ่งเครื่อง และ Team bot ที่กำลังทำงานทุกตัวจะรัน desktop กับ browser ของตนภายในเครื่องนั้น ดังนั้นทั้งหมดจึงใช้ memory ขนาด 2 GB และ 2 cores ร่วมกัน เฉพาะ bot ที่ย้ายไปยัง Private Computer เท่านั้นที่จะได้ container และเพดานเป็นของตนเอง ตั้งค่า SANDBOX_PROVIDER=docker แล้ว desktop เหล่านี้จะย้ายไปรันบน VPS ของคุณ และใช้ทรัพยากรเพิ่มเติมจาก control plane ดังนั้น 4 GB จึงเป็นเพียงขั้นต่ำ ไม่ใช่ขนาดเป้าหมาย หากวางแผนจะเปิด bot ไว้มากกว่าหนึ่งตัว ให้เริ่มที่ 8 GB เพิ่มค่า RAKAZO_COMPUTER_MEMORY เพื่อให้คอมพิวเตอร์ที่ใช้ร่วมกันสามารถใช้ memory นั้นได้จริง และวัดจำนวนจริงด้วย docker stats ขณะที่ bots กำลังทำงาน สิ่งที่ทำให้การใช้ memory เพิ่มขึ้นคือ browser ภายใน sandbox ดังนั้น spec sheet จึงบอกตัวเลขนี้ไม่ได้ หากต้องการป้องกันไม่ให้เครื่องขนาดเล็กรัน browser มากเกินไปพร้อมกัน ให้ตั้งค่า SANDBOX_TEAM_SCREEN_LIMIT เป็นค่าบวก ซึ่งจะจำกัดจำนวน desktop ที่ active บน Docker Team Computer ค่า 0 ที่มากับระบบจะไม่จำกัดจำนวนดังกล่าว หาก memory โดยรวมมีจำกัด RAKAZO_COMPUTER_MEMORY ก็รับค่าที่น้อยลงได้ เช่น 1536m สำหรับวิธีทั่วไปในการกำหนดขนาดเครื่องให้เหมาะกับงานของ agent โปรดดู จำนวน RAM และ CPU ที่ VPS สำหรับ agent ต้องใช้จริง ซึ่งอธิบายวิธีวัดอย่างละเอียด
มีการตั้งค่าหนึ่งที่ช่วยไม่ให้ปัญหานี้รุนแรงขึ้น .env.example มากับค่า SANDBOX_IDLE_MS=600000 และ comment ระบุว่าคอมพิวเตอร์จะถูก pause หรือ stop หลังจากไม่มีการใช้งานเป็นจำนวน milliseconds ดังกล่าว เมื่อไม่มีการใช้งาน 10 minutes คอมพิวเตอร์จะหยุดทำงาน ค่าต่ำสุดที่ยอมรับได้คือ 30000 และ 0 จะปิดการ sleep เมื่อไม่มีการใช้งาน comment เดียวกันแนะนำให้ใช้ 0 สำหรับ Docker self-hosts ซึ่งคอมพิวเตอร์ที่ไม่มีการใช้งานไม่เสียค่าใช้จ่าย แต่ยังคงใช้ memory ดังนั้น long-running apps และ sessions จึงยังทำงานต่อไป ข้อนี้เป็นเรื่องค่าใช้จ่าย ไม่ใช่เรื่อง memory บน VPS ขนาดเล็ก ควรเปิดใช้ timer นี้ไว้ เพราะหากไม่มี timer คอมพิวเตอร์ทุกเครื่องที่คุณเคยเริ่มใช้งาน รวมถึง browser ทุกตัวภายในเครื่องเหล่านั้น จะยังคงทำงานต่อไป
Disk ก็มีผลเช่นกัน sandbox image, Node modules และ Postgres volume ใช้ disk เดียวกันร่วมกัน ดังนั้น 40 GB จึงเป็นจุดเริ่มต้นที่เหมาะสม
ตรึงเวอร์ชันก่อนทำการ clone
Rakazo มีการพัฒนาอย่างรวดเร็วและ main ไม่ใช่เวอร์ชันที่ปล่อยออกมาอย่างเป็นทางการ ณ วันที่ 9 พฤศจิกายน 2026 v0.8.0 ซึ่งเผยแพร่เมื่อวันที่ 4 พฤศจิกายน 2026 คือเวอร์ชันที่ถูกระบุว่าเป็น Latest คู่มือนี้ยังคงตรึงไว้ที่ v0.3.5 ซึ่งเผยแพร่เมื่อวันที่ 25 ตุลาคม 2026
git clone https://github.com/elie222/rakazo.git
cd rakazo
git checkout f31e3c0699f086d663637c4107858c238a086fb3
git log -1 --format='%H %ci'commit ดังกล่าวคือจุดที่ v0.3.5 อ้างถึง ให้ตรึงที่ commit แทนการใช้ branch หรือ tag เพราะ branch จะเปลี่ยนไปเมื่อคุณทำ git pull ครั้งถัดไป และ tag เป็นป้ายกำกับที่ผู้ดูแลสามารถย้ายตำแหน่งได้ ทั้งสองอย่างจึงไม่สามารถระบุสถานะของซอร์สโค้ดที่คุณจะย้อนกลับมาใช้งานได้แน่นอน แต่ตัวระบุ commit จะไม่มีวันเปลี่ยนแปลง ให้จดบันทึกค่านี้ไว้พร้อมกับข้อมูลเซิร์ฟเวอร์อื่นๆ ของคุณ เพราะเมื่อการอัปเกรดทำให้ระบบพัง วิธีแก้ไขที่ง่ายที่สุดคือ git checkout <old commit> แล้วติดตั้งใหม่ ซึ่งจะทำได้ก็ต่อเมื่อคุณทราบว่า commit ใดที่ใช้งานได้ปกติ README ที่ตรึงไว้ระบุว่า Rakazo ยังเป็นรุ่น beta ดังนั้นการตรึงเวอร์ชันให้แม่นยำจึงคุ้มค่ากับความพยายาม สำหรับโปรเจกต์ที่มีประวัติการปล่อยเวอร์ชันที่ชัดเจน คุณอาจเลือกใช้ tag ที่เผยแพร่แล้วแทนได้ ซึ่งเป็นวิธีที่ stack ขนาดเล็กที่โฮสต์เองอย่าง openGym เลือกใช้
ข้อกำหนด: Node 22, pnpm 9 และ Docker
node -v
pnpm -v
docker --versionpackage.json ประกาศใช้ "engines": { "node": "^22.22.2 || ^24.0.0 || >=26.0.0" } และ "packageManager": "pnpm@9.15.0" ดังนั้น node -v จะต้องแสดงผลเป็น v22.22.2 หรือเวอร์ชัน 22.x ที่ใหม่กว่า, v24 ใดๆ หรือ v26 ขึ้นไป หาก v22 เก่ากว่า 22.22.2 จะถือว่าอยู่นอกช่วงที่รองรับ และไฟล์ README ระบุไว้อย่างชัดเจนว่าไม่รองรับ Node.js 23.x และ 25.x ให้ติดตั้ง Node เวอร์ชันที่รองรับผ่าน NodeSource หรือ nvm โดย Corepack จะมาพร้อมกับ Node 22 และ 24 สำหรับ Node 26 ขึ้นไป ให้ติดตั้งก่อนด้วย npm install -g corepack จากนั้นจึงเปิดใช้งาน pnpm:
corepack enable
corepack prepare pnpm@9.15.0 --activateDocker Engine และปลั๊กอิน compose จะครอบคลุมส่วนที่เหลือ เอกสารการ self-host กำหนดให้ใช้ Docker Engine 26 หรือใหม่กว่า และ API 1.45 หรือใหม่กว่า เพื่อรองรับ subpath ของ volume สำหรับ bot home รวมถึงต้องมี curl และ OpenSSL นอกจากนี้ ผู้ใช้ของคุณจะต้องสามารถเข้าถึง daemon ได้ หาก docker ps ตอบกลับมาว่า permission denied while trying to connect to the Docker daemon socket at unix:///var/run/docker.sock ให้เพิ่มผู้ใช้ของคุณเข้าในกลุ่ม docker แล้วเปิด login shell ใหม่ โปรดทราบถึงสิทธิ์ที่ได้รับก่อนดำเนินการ: การเป็นสมาชิกในกลุ่ม docker เทียบเท่ากับการมีสิทธิ์ root บนเครื่อง เนื่องจากทุกคนในกลุ่มนี้สามารถเริ่ม container ที่ mount ระบบไฟล์ของโฮสต์ได้
กำหนดค่า .env แล้วเริ่มการทำงานของ Postgres
cp .env.example .env
chmod 600 .envจำเป็นต้องเปลี่ยนค่าหลายรายการก่อนที่จะเริ่มการทำงานใดๆ .env.example มาพร้อมกับ BETTER_AUTH_SECRET=replace-with-32-plus-character-secret, ENCRYPTION_KEY=replace-with-64-random-hex-characters, SCREEN_PROXY_SECRET=replace-with-32-plus-character-screen-proxy-secret และ SANDBOX_SUPERVISOR_TOKEN=replace-with-32-plus-character-supervisor-token โดยปล่อยให้ POSTGRES_PASSWORD และ POSTGRES_APP_PASSWORD ว่างไว้ ตัวแทนค่าเหล่านี้ทั้งหมดถูกเผยแพร่อยู่ใน repository ดังนั้นการ deploy ที่ยังคงค่าเดิมไว้จะทำให้ระบบทำงานด้วยความลับที่ใครก็สามารถอ่านได้ ให้กำหนดค่าสุ่มเฉพาะสำหรับแต่ละรายการ ENCRYPTION_KEY ต้องเป็นอักขระเลขฐานสิบหกแบบสุ่มจำนวน 64 ตัว ซึ่งเป็นสิ่งที่ openssl rand -hex 32 แสดงผลออกมาพอดี สำหรับความลับอื่นๆ ให้ใช้อักขระ 32 ตัวขึ้นไป ดังนั้นให้รันคำสั่ง base64 หนึ่งครั้งสำหรับแต่ละรายการ สำหรับรหัสผ่าน Postgres สองชุดที่เอกสารการ self-host กำหนดให้ใช้ค่าที่ปลอดภัยสำหรับ URL ซึ่งบรรทัดสุดท้ายจะสร้างให้คุณ ดังนั้นให้รันคำสั่งดังกล่าวหนึ่งครั้งสำหรับแต่ละรหัสผ่านเช่นกัน ฐานข้อมูลมีบัญชีผู้ใช้สองชุด DATABASE_MIGRATION_URL มาพร้อมกับ postgres://rakazo:REPLACE_WITH_POSTGRES_PASSWORD@127.0.0.1:5433/rakazo ซึ่งเป็นเจ้าของที่ทำหน้าที่รัน migrations และ DATABASE_URL ในฐานะ postgres://rakazo_app:REPLACE_WITH_POSTGRES_APP_PASSWORD@127.0.0.1:5433/rakazo ซึ่งเป็นบัญชีผู้ใช้ของแอปพลิเคชันเอง โดยไม่มีสิทธิ์ superuser และถูกจำกัดด้วย row-level security ให้นำรหัสผ่านแต่ละชุดไปใส่ใน URL ของตนเอง pnpm db:migrate จะสร้างบัญชีผู้ใช้ rakazo_app พร้อมกับรหัสผ่านที่คุณกำหนด
openssl rand -base64 48
openssl rand -hex 32
openssl rand -hex 24จากนั้นให้เริ่มการทำงานของฐานข้อมูลแยกต่างหากและรัน migrations
docker compose --env-file .env -f infra/compose/docker-compose.yml -f infra/compose/docker-compose.postgres-host.yml up postgres -d
pnpm install
pnpm db:generate
pnpm db:migrate
pnpm sandbox:buildpnpm sandbox:build จะสร้าง image ของ bot computer ตามที่ระบุไว้ใน package.json ว่าเป็น docker build -t rakazo/computer:local infra/sandboxes/computer เนื่องจากเป็น image แบบกราฟิก การ build ครั้งแรกจึงต้องดึงข้อมูลจำนวนมากและใช้เวลา ตรวจสอบว่า image ถูกสร้างสำเร็จด้วย docker image ls rakazo/computer ซึ่งควรแสดงผลออกมาหนึ่งแถว
ไฟล์ compose พื้นฐานไม่ได้เปิดพอร์ต Postgres ไว้เลย การใช้ overlay docker-compose.postgres-host.yml ในคำสั่งนั้นจะเปิดพอร์ตเป็น 127.0.0.1:5433 ซึ่งจำกัดเฉพาะ loopback เท่านั้น เพื่อให้เครื่องมือฝั่ง host อย่าง pnpm db:migrate และ pnpm dev สามารถเข้าถึงได้ ให้คงค่าไว้เช่นนั้น Compose จะปฏิเสธการเริ่ม Postgres หากไม่มี POSTGRES_PASSWORD ใน .env แต่การเปิดพอร์ต Postgres ให้เข้าถึงได้จากอินเทอร์เน็ตจะเสี่ยงต่อการถูกโจมตีด้วยการสุ่มรหัสผ่าน ไฟล์ compose สำหรับ production จะอ่านตัวแปรเดียวกันนี้และจะไม่เปิดพอร์ตฐานข้อมูลใดๆ ออกไปภายนอก
การรันครั้งแรก
pnpm devคำสั่งนั้นจะเริ่มการทำงาน 4 ส่วน ได้แก่ API บนพอร์ต 3100, Graphile Worker, เว็บแอป Vite บนพอร์ต 5173 และ sandbox supervisor บนพอร์ต 7091 ตามค่าเริ่มต้น หากพอร์ตเหล่านี้ถูกใช้งานอยู่ pnpm dev จะเลือกช่วงพอร์ตว่างอื่นให้และแสดง URL ออกมา ที่พอร์ตเริ่มต้น แอปจะอยู่ที่ http://127.0.0.1:5173 และคุณควรจะเห็นหน้าเข้าสู่ระบบ
บน VPS คุณไม่ได้นั่งอยู่หน้าเครื่องนั้นโดยตรง และไม่ควรเปิดพอร์ต 5173 สู่สาธารณะเพื่อเข้าใช้งาน ให้ใช้วิธี forward พอร์ตผ่าน SSH (secure shell) จากเครื่องของคุณแทน
ssh -L 5173:127.0.0.1:5173 -L 3100:127.0.0.1:3100 you@your-serverโปรดระวังความแตกต่างระหว่างวิธีการรันเหล่านี้ pnpm dev จะรัน Vite บนโฮสต์โดยผูกไว้กับ localhost เท่านั้น ไฟล์ compose สำหรับการพัฒนาจะมีบริการ web ที่เปิดพอร์ต 127.0.0.1:5173:5173 และบริการ api ที่เปิดพอร์ต 127.0.0.1:3100:3100 ซึ่งทั้งคู่ผูกไว้กับ loopback เท่านั้น ดังนั้นคุณจึงใช้ tunnel เดียวกันได้ ในไฟล์สำหรับการใช้งานจริง (production) เว็บแอปจะไม่เปิดพอร์ตบนโฮสต์และจะเปิดเผยพอร์ต 5173 ให้เฉพาะคอนเทนเนอร์ในเครือข่ายเดียวกันเท่านั้น โดยมี Caddy ทำหน้าที่เปิดพอร์ต 80 และ 443 เพียงตัวเดียว ดังนั้นให้ใช้ไฟล์ production และ reverse proxy ของมันสำหรับบริการที่คุณต้องการรันค้างไว้
ผู้ให้บริการ sandbox รายใดที่ปลอดภัยบนเซิร์ฟเวอร์?
นี่คือการตั้งค่าเพียงหนึ่งเดียวที่ต้องทำให้ถูกต้อง SANDBOX_PROVIDER ใน .env ถูกตั้งค่าเป็น docker โดยค่าเริ่มต้น และ pinned checkout ยังรองรับ Railway ควบคู่ไปกับผู้ให้บริการที่ระบุไว้ในเอกสาร self-host
dockerเป็นค่าเริ่มต้น คอมพิวเตอร์ของบอทจะทำงานเป็นคอนเทนเนอร์บนเครื่องของคุณ ซึ่งสร้างจากอิมเมจที่pnpm sandbox:buildผลิตขึ้นและรันภายใต้ supervisor โดยปกติแล้วบอทของ workspace จะใช้ Team Computer ร่วมกัน และบอทจะได้รับคอนเทนเนอร์แยกเฉพาะเมื่ออยู่บน Private Computer เท่านั้น ไม่จำเป็นต้องมีบัญชี E2Be2bรันคอมพิวเตอร์ของบอทบน E2B และจำเป็นต้องมีE2B_API_KEYที่v0.3.5factory จะยอมรับการใช้งานใน production เมื่อมีการระบุคีย์ โดยไม่มีข้อจำกัดNODE_ENVเอกสาร self-host ระบุว่าวิธีนี้เหมาะสำหรับ production แบบสาธารณะหรือแบบหลายผู้ใช้ เพราะช่วยแยกคอมพิวเตอร์ของบอทออกจากโฮสต์ที่รัน API และฐานข้อมูลของคุณdaytona,createosและboatเป็นผู้ให้บริการระยะไกลเพิ่มเติม ซึ่งแต่ละรายการต้องใช้คีย์ของตนเอง ได้แก่DAYTONA_API_KEY,CREATEOS_SANDBOX_API_KEYหรือBOAT_API_KEYrailwayรันคอมพิวเตอร์บน Railway และจำเป็นต้องมีRAILWAY_API_TOKENรวมถึงการเลือกRAILWAY_ENVIRONMENT_IDที่ระบุไว้อย่างชัดเจนบน API และ worker ควรใช้โปรเจกต์หรือ environment ของ Railway แยกต่างหากสำหรับ sandboxdesktopรันคำสั่งของบอทโดยตรงบนโฮสต์ของ API และ worker ตามที่เอกสารระบุไว้ ที่v0.3.5API และ worker จะปฏิเสธการใช้งานเว้นแต่NODE_ENVจะเป็นdevelopmentหรือtestแต่เนื่องจาก.env.exampleจัดส่งNODE_ENV=developmentมาด้วย เซิร์ฟเวอร์ที่รันpnpm devจึงยังคงยอมรับการตั้งค่านี้ ห้ามเปิดใช้งานบนบริการสาธารณะหรือบริการที่ใช้ร่วมกันfakeเป็นโปรแกรมจำลองสำหรับการตรวจสอบเท่านั้น ไม่ใช่ runtimenoneเริ่มต้นผลิตภัณฑ์โดยไม่มีโฮสต์คอมพิวเตอร์เลย
โปรดทำความเข้าใจตามตัวอักษร ในโหมด desktop จะไม่มีขอบเขตการแยกส่วนใดๆ เลย ดังนั้นบอทจะรันคำสั่ง shell ในฐานะผู้ใช้ที่รันกระบวนการ API โดยใช้ home directory, SSH keys, cloud credentials และ .env ของผู้ใช้คนนั้น ข้อความในหน้าเว็บที่บอทอ่านจะกลายเป็นคำสั่งบนเซิร์ฟเวอร์ของคุณ โหมด desktop บนเซิร์ฟเวอร์คือสาเหตุที่ทำให้บอทเข้าถึงข้อมูลรับรองของคุณได้ ควรใช้บนเครื่องที่คุณใช้งานอยู่เท่านั้น หรือไม่ควรใช้เลย การเปลี่ยนผู้ให้บริการจะเป็นเพียงการนำคอนเทนเนอร์มาครอบเส้นทางของหน้าเว็บนั้นแทนที่จะปิดการใช้งาน และ การให้บอทใช้ SearXNG search backend ของตัวเอง จะช่วยจัดการพื้นผิวการโจมตีเดียวกันจากฝั่งการค้นหา
docker เป็นขอบเขตที่แท้จริงระหว่างบอทกับโฮสต์ของคุณ แต่เป็นขอบเขตที่อ่อนแอระหว่างบอทด้วยกันเอง โดยค่าเริ่มต้นบอทจะใช้ Team Computer ร่วมกัน และเอกสาร runtime ของคอมพิวเตอร์ระบุว่าบอทในทีมจะใช้ OS user, workspace, browser profiles รวมถึง shell และ X11 access ร่วมกัน โดยโฟลเดอร์ของบอทแต่ละตัวจะช่วยจัดระเบียบงานเท่านั้นแต่ไม่ใช่ขอบเขตด้านความปลอดภัย ดังนั้นบอทในทีมตัวใดตัวหนึ่งจึงสามารถอ่านไฟล์ของบอทตัวอื่นได้ บอทที่ต้องการการป้องกันแยกต่างหากควรอยู่บน Private Computer ซึ่งผู้ให้บริการ docker จะรันเป็นคอนเทนเนอร์พี่น้องแยกต่างหากบนเครือข่ายของตนเอง อย่างไรก็ตาม supervisor ที่สร้างคอนเทนเนอร์เหล่านั้นจะทำการ mount /var/run/docker.sock และเอกสาร self-host ระบุไว้อย่างชัดเจนว่า: การเข้าถึง socket นั้นเทียบเท่ากับการควบคุม Docker host ดังนั้นควรเก็บ supervisor ไว้เป็นส่วนตัว .env.example ปฏิบัติต่อ SANDBOX_SUPERVISOR_TOKEN เป็นข้อมูลรับรองเฉพาะ ซึ่งแยกต่างหากจาก BETTER_AUTH_SECRET ที่ Docker sandbox ต้องการนอกเหนือจากการพัฒนาในเครื่อง และมันมาพร้อมกับค่า placeholder ที่ทุกคนสามารถอ่านได้บน GitHub ควรตั้งค่าเป็นค่าสุ่มของคุณเอง สำหรับการแยกส่วนที่แข็งแกร่งที่สุดที่มีให้ที่นี่ ให้ใช้ e2b หรือมอบเครื่องที่ไม่มีข้อมูลอื่นใดให้ Rakazo นี่คือเหตุผลเดียวกันเบื้องหลัง การรัน coding agents ใน VM ที่ทิ้งได้: วิธีที่ประหยัดที่สุดในการรับมือกับ agent ที่ทำงานผิดพลาดคือการทำให้เครื่องที่มันรันอยู่ไม่มีมูลค่าใดๆ
API key ของโมเดลควรเก็บไว้ที่ไหน?
ระบบเรียกเก็บเงินตามเครดิตโมเดลที่เป็นตัวเลือกเสริมของ Rakazo จะไม่ทำงานจนกว่าจะมีการตั้งค่า Stripe secret ทั้งสองรายการ คุณต้องเป็นผู้จัดเตรียม API key เอง .env.example จะตั้งค่า PI_DEFAULT_PROVIDER=openrouter ดังนั้น OPENROUTER_API_KEY จึงเป็นตำแหน่งมาตรฐานที่ใช้ และ key ของผู้ให้บริการรายอื่นก็ทำงานผ่านการตั้งค่าเดียวกันนี้
เก็บ key ไว้ใน .env และอย่าใส่ไว้ในไฟล์ใดก็ตามที่คุณ commit ลงใน repository คำสั่ง compose ทั้งหมดใน repository จะส่งค่าผ่าน --env-file .env ทำให้ค่าต่างๆ เข้าถึง container ได้โดยไม่ต้องเขียนลงในไฟล์ YAML ที่ git ติดตาม นอกจากนี้คุณยังสามารถเว้นว่าง OPENROUTER_API_KEY ไว้แล้วเชื่อมต่อโมเดลในแอปหลังจากลงทะเบียนได้ ซึ่งเป็นอีกเหตุผลหนึ่งที่ ENCRYPTION_KEY จำเป็นต้องใช้ค่าสุ่มที่แท้จริงแทนค่าเริ่มต้นที่มากับซอฟต์แวร์
กำหนดวงเงินการใช้งานสำหรับ key นั้นที่ฝั่งผู้ให้บริการก่อนที่บอทจะเริ่มใช้งาน บอทที่ทำงานวนลูปคือบอทที่ใช้จ่ายเงิน Rakazo ยังมี MAX_TOOL_CALLS_PER_TURN ให้ใช้งาน โดยให้กำหนดเป็นจำนวนเต็มบวกเพื่อหยุดการทำงานของ turn นั้นๆ เมื่อเกินงบประมาณการเรียกใช้เครื่องมือ (tool-call) โดยที่ยังคงสร้างข้อความตอบกลับสุดท้ายของ assistant ได้ หากไม่ตั้งค่า, ปล่อยว่าง หรือตั้งเป็น 0 ระบบจะไม่มีการจำกัดจำนวน การตั้งค่านี้เป็นการนับจำนวนการเรียกใช้เครื่องมือ ไม่ใช่จำนวนเงิน จึงไม่สามารถใช้แทนการจำกัดวงเงินของผู้ให้บริการได้ ควรตั้งชื่อเฉพาะให้กับ key นี้เพื่อให้คุณสามารถเพิกถอนสิทธิ์ได้โดยไม่กระทบส่วนอื่น หากคุณกำลังตั้งค่านี้สำหรับทีมแทนที่จะใช้คนเดียว OneCLI's one gateway in front of everyone's agent คือคำตอบที่แตกต่างสำหรับปัญหาเดียวกัน เนื่องจากเป็นการรวม key ของผู้ให้บริการไว้ที่จุดเดียวแทนที่จะใช้หนึ่ง key ต่อหนึ่งคน
การเปลี่ยนจากโหมดพัฒนาไปสู่การใช้งานจริง
Repository นี้มีไฟล์ compose สำหรับการใช้งานจริงมาให้ ซึ่งจะรัน Postgres, API, worker, web app และ Caddy สำหรับจัดการใบรับรอง TLS (transport layer security) ที่ได้รับมาโดยอัตโนมัติ Caddy เป็นบริการเดียวในชุดนี้ที่เปิดพอร์ตสู่ภายนอก โดยค่าเริ่มต้นจะตั้งค่าเป็น E2B สำหรับ bot computers ส่วน overlay แบบเลือกใช้ได้คือ infra/compose/docker-compose.prod.docker.yml จะรัน local Docker computers บน stack เดียวกันแทน ซึ่งเอกสารได้เตือนไว้ว่า supervisor ที่เพิ่มเข้ามานั้นมีสิทธิ์ระดับ root บนโฮสต์
sudo --preserve-env=SSH_CONNECTION DEPLOY_USER=deploy bash infra/compose/harden-host.sh
docker compose --env-file .env -f infra/compose/docker-compose.prod.yml \
build --build-arg GIT_SHA=$(git rev-parse HEAD)
docker compose --env-file .env -f infra/compose/docker-compose.prod.yml \
up -d --wait --pull never
curl --fail https://app.example.com/healthสร้างบัญชี deploy แบบใช้ key เท่านั้น และตรวจสอบให้แน่ใจว่าคุณสามารถล็อกอินได้ก่อนที่จะรันสคริปต์ harden-host.sh จะปิดการล็อกอินด้วยรหัสผ่าน SSH และ root, จำกัดอัตราการเชื่อมต่อ SSH, เพิ่มกฎอนุญาต SSH, HTTP และ HTTPS ผ่าน UFW (uncomplicated firewall) โดยยังคงกฎเครือข่ายส่วนตัวเดิมไว้ รวมถึงเปิดใช้งาน fail2ban, การอัปเดตความปลอดภัยอัตโนมัติ, AppArmor และกฎ audit สคริปต์นี้จะไม่ทำงานหากไม่มี SSH_CONNECTION ซึ่งเป็นเหตุผลว่าทำไมคำสั่งจึงส่งผ่าน sudo และสคริปต์จะยกเลิกการเปลี่ยนแปลง firewall หากคุณไม่ยืนยันผ่าน session SSH ใหม่ภายในสามนาที โปรดอ่านสคริปต์ก่อนใช้งานจริงเพราะมันจะเปลี่ยนวิธีการล็อกอินและโหลด SSH ใหม่ ให้เปิด console ของผู้ให้บริการเซิร์ฟเวอร์ของคุณทิ้งไว้จนกว่าจะล็อกอินผ่าน SSH ใหม่ได้สำเร็จ
.env สำหรับการใช้งานจริงต้องการทรัพยากรมากกว่าโหมดพัฒนา เอกสารการติดตั้งด้วยตนเองได้ระบุค่าขั้นต่ำนี้ไว้ รวมถึงข้อมูลลับต่างๆ
NODE_ENV=production
RAKAZO_HOST=app.example.com
BETTER_AUTH_URL=https://app.example.com
WEB_ORIGIN=https://app.example.com
API_URL=https://app.example.com
SIGNUPS_ENABLED=true
SIGNUP_ALLOWLIST=you@example.com
SANDBOX_PROVIDER=e2b
AGENT_RUNTIME=pi
WAKEUP_DRIVER=graphile
DATA_DIR=/data
RAKAZO_DEPLOY_DIR=/srv/rakazo
RAKAZO_IMAGE_TAG=local
POSTGRES_PASSWORD=<random, URL-safe>
POSTGRES_APP_PASSWORD=<random, URL-safe>
BETTER_AUTH_SECRET=<random>
ENCRYPTION_KEY=<64 random hex characters>
SCREEN_PROXY_SECRET=<random>
E2B_API_KEY=<your key>
OPENROUTER_API_KEY=<your key>ชี้ A record มาที่เซิร์ฟเวอร์ก่อนที่จะรัน up ครั้งแรก Caddy จะร้องขอใบรับรองสำหรับชื่อที่ระบุใน RAKAZO_HOST โดยชื่อนั้นต้องชี้มาที่เครื่องนี้ และต้องสามารถเข้าถึงพอร์ต 80 สำหรับการตรวจสอบ HTTP หรือพอร์ต 443 สำหรับการตรวจสอบ TLS-ALPN จากภายนอกได้ ทั้งสองวิธีเปิดใช้งานเป็นค่าเริ่มต้น ดังนั้นการปิดพอร์ต 80 เพียงอย่างเดียวจะไม่ขัดขวางการออกใบรับรองผ่านพอร์ต 443
ตั้งค่า SIGNUP_ALLOWLIST ให้เป็นที่อยู่ของคุณเองตั้งแต่เริ่มต้น .env.example มาพร้อมกับ SIGNUPS_ENABLED=true และการตั้งค่าทั้งสองจะถูกอ่านจาก environment ทุกครั้งที่ API เริ่มทำงาน ดังนั้น instance ที่รันบนชื่อโดเมนสาธารณะโดยเปิดให้สมัครสมาชิกและไม่มี allowlist จะยอมรับการลงทะเบียนจากใครก็ตามที่พบเว็บไซต์นี้ allowlist ที่ไม่ว่างเปล่าจะถูกนำไปใช้ทุกครั้งที่เริ่มระบบและจะแทนที่รายการที่บันทึกไว้ การสมัครสมาชิกผ่าน allowlist จำเป็นต้องมีการยืนยันผ่านอีเมลสำหรับบัญชีแรกที่เพิ่มเข้าไป ดังนั้นควรตั้งค่าการส่งอีเมลก่อนที่คุณจะลงทะเบียน หากไม่มีอีเมล เส้นทางที่เอกสารแนะนำคือการเริ่มด้วย SIGNUPS_ENABLED=false และสร้างบัญชีของคุณด้วยคำสั่ง bootstrap ฝั่งเซิร์ฟเวอร์ที่ให้มา ซึ่งจะสร้างบัญชีที่ผ่านการยืนยันปกติโดยไม่มีสิทธิ์ระดับเซิร์ฟเวอร์ ควรตั้งค่า allowlist ก่อน แล้วค่อยผ่อนปรนในภายหลังหากต้องการ หากคุณรันหลายบริการบนเครื่องเดียวกันและต้องการจัดการรายชื่อผู้ใช้เพียงรายการเดียวแทนที่จะเป็น allowlist แยกรายแอป การ ติดตั้ง Authentik ไว้ด้านหน้า จะย้ายการตัดสินใจนั้นไปไว้ที่ proxy แม้ว่ามันจะอยู่หน้าบัญชี Better Auth ของ Rakazo เองแทนที่จะมาแทนที่ก็ตาม
ให้ถือว่า docs/self-host.md ใน repository เป็นแหล่งข้อมูลอ้างอิงหลักสำหรับการตั้งค่าการใช้งานจริง เนื่องจากมันเปลี่ยนแปลงไปตามโค้ดในขณะที่คู่มือนี้ไม่ได้เปลี่ยนตาม เนื่องจาก Compose เป็นตัวจัดการงาน กฎทั่วไปจึงยังคงมีผล และ พื้นฐาน Docker Compose สำหรับ VPS จะอธิบายว่าเหตุใด --env-file และ named volumes จึงมีความสำคัญมากขึ้นเมื่อ stack นั้นเป็นสิ่งที่คุณปล่อยให้รันไปเรื่อยๆ เป็นเวลาหลายเดือน
การสำรองข้อมูล
Postgres และไดเรกทอรี data/ เป็นที่เก็บข้อมูลของอินสแตนซ์ในการตั้งค่านี้ การกู้คืนข้อมูลยังจำเป็นต้องใช้ ENCRYPTION_KEY และกุญแจหลัก (master keys) ของเนื้อหาที่กำหนดค่าไว้ด้วย ดังนั้นควรเก็บสำเนาไว้ภายนอกเซิร์ฟเวอร์
./scripts/backup.sh
./scripts/restore.sh backups/BACKUP_TIMESTAMPbackup.sh จะทำการ dump ข้อมูล Postgres และจัดเก็บ data/ ไว้ในรูปแบบไฟล์บีบอัด restore.sh ทำงานบน Compose stack สำหรับการพัฒนา โดยจะเขียนลงในฐานข้อมูลเปล่าขณะที่บริการแอปพลิเคชันหยุดทำงานอยู่ และไม่ได้อ่านไฟล์สำรองข้อมูลจากระบบผลิต สำหรับเครื่องที่คุณใช้งานจริง ให้ติดตั้ง infra/compose/backup-prod.sh ในฐานะ /usr/local/sbin/rakazo-backup โดยใช้ timer ที่มาพร้อมกับ repository เครื่องมือนี้จะเขียนไฟล์ dump ที่ผ่านการตรวจสอบแล้วและไฟล์บีบอัดข้อมูลแอปพลิเคชันไปยัง /var/backups/rakazo โดยจะเก็บ snapshot ที่ตรวจสอบแล้วไว้สูงสุด 3 รายการตามค่าเริ่มต้น ซึ่งกำหนดโดย RAKAZO_BACKUP_KEEP ภายใต้ขีดจำกัด 50 GiB ที่กำหนดโดย RAKAZO_BACKUP_MAX_GB และจะล้าง snapshot ที่ไม่สมบูรณ์รวมถึงประวัติส่วนเกินก่อนการทำงานแต่ละครั้ง เพื่อให้การหมุนเวียนไฟล์ (rotation) เกิดขึ้นโดยอัตโนมัติ นอกจากนี้ยังสามารถเข้ารหัสไฟล์สำรองแต่ละไฟล์ด้วย age ให้กับผู้รับสาธารณะที่คุณระบุไว้ใน /etc/rakazo/backup.env เพื่อให้เซิร์ฟเวอร์เขียนไฟล์สำรองที่ตัวมันเองไม่สามารถอ่านได้ ให้สร้างคู่กุญแจดังกล่าวบนเครื่องที่คุณควบคุมและเก็บกุญแจส่วนตัว (private key) ไว้นอกเซิร์ฟเวอร์ หากไม่มีผู้รับ ไฟล์สำรองจะยังคงเป็นข้อความธรรมดา (plaintext) และระบบจะบันทึกคำเตือนไว้ แต่หลังจากมีการสำรองข้อมูลแบบเข้ารหัสครั้งแรก การทำงานโดยไม่มีผู้รับจะล้มเหลว เว้นแต่คุณจะอนุญาตให้ใช้ plaintext อย่างชัดเจนด้วย RAKAZO_BACKUP_ALLOW_PLAINTEXT=1 การสำรองข้อมูลที่วางอยู่บนดิสก์เดียวกับฐานข้อมูลไม่ใช่การสำรองข้อมูลที่แท้จริง ดังนั้นควรคัดลอกไฟล์ออกไปไว้ที่อื่น และควรทดสอบการกู้คืนข้อมูลบนเซิร์ฟเวอร์สำรองอย่างน้อยหนึ่งครั้งก่อนที่คุณจะมีความจำเป็นต้องใช้งานจริง
สาเหตุที่ทำให้ล้มเหลวและสิ่งที่คุณจะพบ
pnpm db:migrate ไม่สามารถเชื่อมต่อกับฐานข้อมูลได้ การทำ migration รายงานว่าไม่สามารถเข้าถึงเซิร์ฟเวอร์ฐานข้อมูลที่ 127.0.0.1:5433 ได้ สาเหตุอาจเกิดจากคอนเทนเนอร์ Postgres ยังไม่ทำงาน, กำลังทำงานอยู่แต่ยังไม่พร้อมใช้งาน หรือถูกเริ่มโดยไม่มี docker-compose.postgres-host.yml overlay ซึ่งเป็นส่วนที่ทำหน้าที่เผยแพร่พอร์ต 5433 ไปยังโฮสต์ ให้รันคำสั่ง docker compose --env-file .env -f infra/compose/docker-compose.yml ps และตรวจสอบว่าบริการ postgres รายงานสถานะเป็น healthy หรือไม่ เนื่องจากไฟล์ compose มีการกำหนด health check ที่ทำงานทุกๆ 3 วินาที หากคอนเทนเนอร์รีสตาร์ทวนซ้ำ ให้ตรวจสอบ log ของมัน: Compose stack ที่ถูกล็อกเวอร์ชันไว้จะไม่ยอมเริ่มทำงานบน volume ของ Postgres 16 รุ่นเก่า จนกว่าจะถูก migrate ไปเป็น Postgres 18 เสียก่อน คำสั่ง docker compose ... down -v จะล้างค่าดังกล่าวและลบข้อมูลทิ้งไปพร้อมกัน
พอร์ตถูกใช้งานอยู่แล้ว การเริ่ม Postgres จะล้มเหลวด้วยข้อความ bind: address already in use เมื่อมีโปรเซสอื่นใช้งานพอร์ต 5433 อยู่ ซึ่งมักเกิดจาก Rakazo stack รุ่นก่อนหน้าที่คุณลืมหยุดการทำงาน ให้ใช้ sudo ss -lntp | grep 5433 เพื่อระบุชื่อโปรเซสที่เกี่ยวข้อง overlay จะอ่านพอร์ตโฮสต์จาก POSTGRES_HOST_PORT ดังนั้นคุณสามารถย้ายพอร์ตได้ ตราบใดที่ DATABASE_URL และ DATABASE_MIGRATION_URL ถูกย้ายตามไปด้วย
บอทไม่ได้รับคอมพิวเตอร์ หากไม่มีอิมเมจ rakazo/computer:local ในขณะที่ใช้ SANDBOX_PROVIDER=docker ก็จะไม่มีสิ่งใดให้เริ่มทำงาน คำสั่ง docker image ls rakazo/computer จะแสดงคำตอบในบรรทัดเดียว และ pnpm sandbox:build จะแก้ไขปัญหานี้ หาก supervisor ไม่สามารถเข้าถึง Docker socket ได้ มันก็จะไม่สามารถสร้างคอนเทนเนอร์ได้เช่นกัน โดยข้อความจะระบุ path ไว้คือ permission denied while trying to connect to the Docker daemon socket at unix:///var/run/docker.sock
คำสั่งที่ใช้เวลานานหยุดทำงานกลางคัน .env.example ได้กำหนดค่า SANDBOX_COMMAND_TIMEOUT_MS=300000 ไว้ ทำให้คำสั่งเดียวภายในคอมพิวเตอร์ของบอทถูกตัดการทำงานหลังจากผ่านไป 5 นาที ให้เพิ่มค่านี้สำหรับการ build ที่ใช้เวลานาน แทนที่จะสันนิษฐานว่า sandbox เกิดการ crash
pnpm install ทำงานผิดพลาดอย่างไม่ชัดเจน ให้ตรวจสอบ node -v ก่อนเป็นอันดับแรก workspace ได้ประกาศ ^22.22.2 || ^24.0.0 || >=26.0.0 ไว้ ดังนั้นเวอร์ชัน 23.x, 25.x และ 22.x ใดๆ ที่เก่ากว่า 22.22.2 จึงอยู่นอกเหนือเงื่อนไขที่รองรับ ค่า .npmrc ที่ถูกล็อกไว้จะกำหนด engine-strict=true ดังนั้น pnpm install จะปฏิเสธ Node เวอร์ชันที่ไม่รองรับด้วยข้อผิดพลาด engine/version ก่อนที่โค้ด dependency ของแอปพลิเคชันจะเริ่มทำงาน
การลงชื่อเข้าใช้ทำงานได้ในเครื่อง แต่ใช้งานผ่านโดเมนไม่ได้ BETTER_AUTH_URL, WEB_ORIGIN และ API_URL จะต้องมีค่า public origin เดียวกันกับที่ปรากฏในแถบที่อยู่ของเบราว์เซอร์ รวมถึง scheme ด้วย ค่า http://127.0.0.1:5173 ที่ตกค้างอยู่ในที่ใดที่หนึ่งมักเป็นสาเหตุหลักที่ทำให้ session ไม่สามารถคงอยู่ได้
การอัปเดต checkout ที่ระบุเวอร์ชันไว้
ขั้นตอนการอัปเกรดในเอกสารสำหรับผู้ที่ self-host โดยใช้ Compose stack ที่สร้างจาก checkout ของคุณนั้นทำได้ง่าย: ให้ดึง source ใหม่ จากนั้นทำการ build และ restart ตัว API, worker และ web app ใหม่ การทำ migrations จะเกิดขึ้นเมื่อ API เริ่มทำงาน เนื่องจากคำสั่งเริ่มต้นของ API จะดำเนินการส่วนนี้ก่อนที่จะเริ่มให้บริการ
sudo /usr/local/sbin/rakazo-backup
git fetch --all --tags
git checkout NEW_COMMIT_SHA
export GIT_SHA=$(git rev-parse HEAD)
docker compose --env-file .env -f infra/compose/docker-compose.prod.yml \
up -d --wait --pull never --build api worker webให้สำรองข้อมูลก่อนเสมอ การทำ migrations จะเป็นการเปลี่ยนแปลงไปข้างหน้า และเวอร์ชันเบต้าไม่มีเส้นทางย้อนกลับที่คุณสามารถวางใจได้ หาก checkout ของคุณเก่ากว่าวันที่ 30 สิงหาคม 2026 ซึ่งรวมถึง commit v0.1.0-beta ให้คุณอ่านหมายเหตุในเอกสารเกี่ยวกับ migration 20260830200000_space_scope_names_and_user_credentials ก่อนทำการอัปเกรด นี่เป็นการเปลี่ยนผ่านที่ต้องประสานงานกัน ดังนั้นให้หยุดการทำงานของ API และ worker ตัวเก่าก่อน แล้วจึงรันการตรวจสอบ Space privacy-boundary ตามที่เอกสารระบุไว้ เมื่ออัปเกรดจาก checkout ที่เก่ากว่าการแยก app login ให้ตั้งค่า POSTGRES_APP_PASSWORD ใน .env ก่อนทำการ build ใหม่ เนื่องจากไฟล์ production compose จะไม่ยอมเริ่มทำงานหากไม่มีค่านี้ นอกจากนี้ source-checkout และไฟล์ production Compose ยังใช้งาน Postgres 18 ดังนั้นการติดตั้ง Postgres 16 ที่มีอยู่เดิมจำเป็นต้องผ่านขั้นตอน infra/compose/upgrade-postgres.sh ในเอกสารก่อนจึงจะสามารถเริ่มทำงานบนโครงสร้างใหม่ได้ ให้ตรวจสอบ commit ระหว่าง SHA ที่คุณระบุไว้กับ SHA ใหม่ก่อนที่จะนำมาใช้งาน เนื่องจากโปรเจกต์ที่ยังใหม่อยู่นี้อาจมีการเปลี่ยนชื่อ environment variable โดยไม่มีการแจ้งเตือนล่วงหน้า และหากขาดตัวแปรใดไป บริการจะเริ่มทำงานแล้วปิดตัวลงทันที หากคุณยังตัดสินใจไม่ได้ว่า Rakazo เป็นสิ่งที่เหมาะสมสำหรับคุณหรือไม่ บทสรุปของ AI agents แบบ self-hosted ได้รวบรวมข้อมูลเกี่ยวกับตัวเลือกอื่นในหมวดหมู่นี้และค่าใช้จ่ายในการดูแลรักษาของแต่ละตัวไว้แล้ว
FAQ
ฉันสามารถรัน Rakazo บน VPS ขนาด 1 GB ได้หรือไม่?
ไม่ได้ Postgres, API, worker, sandbox supervisor และเว็บแอปทั้งหมดทำงานพร้อมกัน และเมื่อใช้ SANDBOX_PROVIDER=docker คอมพิวเตอร์ของบอทจะเพิ่มคอนเทนเนอร์ที่มีหน้าจอเดสก์ท็อปแบบกราฟิก พร้อมด้วย X display และกระบวนการ Chrome แยกต่างหากสำหรับบอทแต่ละตัวที่ทำงานอยู่ ทั้งหมดนี้อยู่ภายใต้ขีดจำกัดหน่วยความจำ 2 GB และ CPU 2 คอร์ตามค่าเริ่มต้น เอกสารการโฮสต์เองที่ v0.3.5 ไม่ได้ระบุขนาดโฮสต์ขั้นต่ำ ให้ถือว่า 4 GB เป็นมาตรฐานขั้นต่ำสำหรับ control plane และควรใช้สเปกที่สูงกว่าหากรันเดสก์ท็อปบนเครื่องของคุณ
ผู้ให้บริการ desktop sandbox ปลอดภัยบนเซิร์ฟเวอร์หรือไม่?
ไม่ เอกสารการโฮสต์เองระบุว่า desktop รันคำสั่งโดยตรงบนโฮสต์ของ API และ worker ดังนั้นบอทจะทำหน้าที่เป็นผู้ใช้ที่รันกระบวนการนั้น ซึ่งสามารถเข้าถึงไฟล์และข้อมูลรับรองของผู้ใช้รายนั้นได้ ที่ v0.3.5 ระบบ API และ worker จะปฏิเสธการทำงานนี้หากไม่อยู่ในโหมดพัฒนาหรือทดสอบ แต่เซิร์ฟเวอร์ที่รัน pnpm dev จะถือว่าอยู่ในโหมดพัฒนาและยอมรับการทำงานนี้ หลีกเลี่ยงการรันบนเซิร์ฟเวอร์สาธารณะหรือเซิร์ฟเวอร์ที่ใช้ร่วมกับผู้อื่น ให้ใช้ docker เพื่อให้บอทมี Private Computer เมื่อไม่ต้องการให้แชร์ไฟล์กับบอทตัวอื่นใน workspace หรือใช้ e2b เมื่อมีการเข้าสู่ระบบมากกว่าหนึ่งคน
ฉันควรติดตั้ง Rakazo เวอร์ชันใด?
ณ วันที่ 9 พฤศจิกายน 2026 เวอร์ชันล่าสุดคือ v0.8.0 ซึ่งเผยแพร่เมื่อวันที่ 4 พฤศจิกายน 2026 และระบุว่าเป็น Latest เพื่อให้เป็นไปตามคู่มือนี้ ให้เลือกใช้ commit ที่ตรึงไว้คือ v0.3.5 ซึ่งก็คือ f31e3c0699f086d663637c4107858c238a086fb3 แทนการติดตาม main หรือเวอร์ชันทดสอบของเดือนสิงหาคมอย่าง v0.1.0-beta เพราะ branch จะเปลี่ยนไปเรื่อยๆ และ tag สามารถถูกย้ายตำแหน่งได้ ทั้งสองอย่างจึงไม่สามารถระบุสถานะของซอร์สโค้ดที่คุณจะย้อนกลับมาใช้งานได้ ให้จดบันทึก commit ไว้ เพราะการย้อนกลับจะทำได้ก็ต่อเมื่อคุณทราบว่า commit ใดที่ใช้งานได้ปกติ
ฉันจะใส่ OpenRouter API key ได้ที่ไหน?
ใส่ใน .env ในรูปแบบ OPENROUTER_API_KEY และห้ามใส่ในไฟล์ compose ที่คุณ commit ขึ้น repository คำสั่ง compose ทั้งสองแบบใน repository จะส่งผ่าน --env-file .env ดังนั้นค่าดังกล่าวจะถูกส่งไปยังคอนเทนเนอร์โดยไม่ต้องเขียนลงในไฟล์ YAML ที่ถูกติดตาม คุณสามารถเว้นว่างไว้และเชื่อมต่อโมเดลในแอปหลังจากลงทะเบียนแล้วก็ได้ กำหนดวงเงินการใช้งานบนคีย์ที่ผู้ให้บริการ เพราะบอทที่ทำงานวนลูปจะเรียกใช้โมเดลไปเรื่อยๆ จนกว่าจะมีสิ่งมาหยุดมัน
ฉันจำเป็นต้องมีชื่อโดเมนและ TLS หรือไม่?
สำหรับการใช้งานจริงนอกเหนือจากการทดสอบครั้งแรก จำเป็น ไฟล์ compose สำหรับ production จะรัน Caddy และขอใบรับรองโดยอัตโนมัติ ให้ตั้งค่า RAKAZO_HOST เป็นชื่อโฮสต์สาธารณะ และตั้งค่า BETTER_AUTH_URL, WEB_ORIGIN และ API_URL ให้เป็น HTTPS origin สาธารณะเดียวกัน สำหรับการทดสอบครั้งแรกคุณสามารถข้ามเรื่องโดเมนได้โดยรัน pnpm dev และ forward พอร์ต 5173 ผ่าน SSH แทนการเปิดพอร์ตสาธารณะ