วิธีติดตั้ง OpenBot AI บน VPS พร้อมตั้งค่า Supervisor
เรียนรู้วิธีติดตั้ง OpenBot บน VPS โดยใช้ Supervisor แยก Container และ Browser ให้กับ AI แต่ละตัว พร้อมคำอธิบายการทำงานของ Gateway และการคำนวณการใช้ RAM ที่จำเป็นต่อการรันโปรเจกต์
สิ่งที่คุณจะได้รับเมื่อโฮสต์ OpenBot AI coworkers ด้วยตนเอง
คุณสามารถโฮสต์ OpenBot AI coworkers ด้วยตนเองได้โดยการรัน gateway server บนฮาร์ดแวร์ที่คุณควบคุม พร้อมกับ supervisor ที่จะจัดสรร container แยกเฉพาะให้บอทแต่ละตัว container สำหรับบอทแต่ละตัวจะถูกสร้างขึ้นก็ต่อเมื่อมีการตั้งค่า COMPUTER_SUPERVISOR_URL เท่านั้น หากไม่มีการตั้งค่านี้ บอททุกตัวจะใช้ทรัพยากรคอมพิวเตอร์ร่วมกันที่ AGENT_COMPUTER_URL เมื่อมี supervisor คอยดูแล container ของบอทแต่ละตัวจะมี Chromium browser และพื้นที่จัดเก็บข้อมูล (workspace volume) เป็นของตัวเอง พร้อมด้วยโปรไฟล์เบราว์เซอร์ที่คงอยู่ระหว่างเซสชัน ทุกการกระทำที่บอทดำเนินการบนคอมพิวเตอร์, ไฟล์, MCP (model context protocol) server หรือ UI component จะต้องผ่าน gateway ดังกล่าว ซึ่งจะตรวจสอบการกระทำนั้นกับนโยบายก่อนที่จะดำเนินการจริงและบันทึกผลลัพธ์ไว้หลังจากนั้น หากคุณยังไม่คุ้นเคยกับ agent loop ที่ gateway นี้ครอบคลุมอยู่ เส้นทางการเรียนรู้ใน การเรียนรู้ AI agents ตั้งแต่เริ่มต้น จะแนะนำให้คุณเขียนโค้ดขนาดเล็กด้วยตัวเองก่อนที่จะมอบสิทธิ์การเข้าถึงเบราว์เซอร์และข้อมูลล็อกอินให้กับบอท
OpenBot เผยแพร่โดย CopilotKit ภายใต้สัญญาอนุญาต MIT ที่ github.com/CopilotKit/openbot รุ่นแรกที่มีการติดแท็กคือ v0.0.1 ซึ่งเผยแพร่เมื่อวันที่ 17 สิงหาคม 2026 และตามมาด้วย v0.2.0 ในวันที่ 12 ตุลาคม 2026 ณ วันที่ 10 พฤศจิกายน 2026 รุ่นล่าสุดคือ v1.0.0 ซึ่งเผยแพร่เมื่อวันที่ 9 พฤศจิกายน 2026 หลังจาก v0.3.0 เพียงสามวัน และไฟล์ README บน main ไม่ได้ระบุสถานะเบต้าอีกต่อไป โปรดถือว่านี่เป็นการออกแบบที่จริงจังซึ่งอาจยังมีข้อบกพร่องในช่วงเริ่มต้น การติดตั้งที่อธิบายด้านล่างนี้จะใช้เวอร์ชัน v0.2.0 และทุกขั้นตอนจะอ้างอิงตามรุ่นดังกล่าว ทั้งนี้ v0.3.0 ได้มีการเปลี่ยนแปลงเกี่ยวกับการอนุมัติ, การแชร์เบราว์เซอร์ และค่าเริ่มต้นของ Helm chart ดังนั้นโปรดอ่านบันทึกประจำรุ่นของ v0.3.0 และ v1.0.0 ก่อนที่คุณจะเริ่มติดตั้งจากแท็กที่ใหม่กว่า รุ่นปัจจุบัน main จะจัดสรร container ให้กับผู้ใช้แต่ละคน และจัดสรร container แยกต่างหากให้กับบอทที่ระบุสถานะเป็น Isolated
ส่วนที่น่าสนใจของสถาปัตยกรรมนี้คือส่วนที่มีค่าใช้จ่ายสูงเช่นกัน การรันเบราว์เซอร์สำหรับ agent แต่ละตัวเป็นต้นทุนด้านหน่วยความจำที่หลายคนมักลืมวางแผน ดังนั้นการคำนวณขนาดทรัพยากรจึงต้องทำก่อนการติดตั้งในขั้นตอนถัดไป
วิธีที่เกตเวย์ตัดสินใจในทุกการกระทำ
API server บนพอร์ต 3001 คือเส้นทางหลักที่ถูกควบคุมเพื่อเข้าถึงคอมพิวเตอร์ของบอท นอกจากนี้คอมพิวเตอร์ยังเปิดเผย service endpoint ระดับต่ำที่ได้รับการป้องกันด้วยโทเค็น โครงการระบุให้เก็บข้อมูลเหล่านี้ไว้เป็นส่วนตัวและห้ามนำไปใช้เพื่อข้ามผ่านเกตเวย์ ดังนั้นเกตเวย์จึงเป็นเส้นทางเดียวที่ใช้งานได้ตราบเท่าที่ endpoint เหล่านั้นไม่สามารถเข้าถึงได้ ก่อนที่การกระทำของเบราว์เซอร์จะเริ่มทำงาน เกตเวย์จะระบุเป้าหมายจากภาพรวมของหน้าเว็บ ประเมินกฎนโยบาย CEL (common expression language) เทียบกับบริบท เขียนแถวบันทึกการตรวจสอบ (audit row) ที่เก็บการตัดสินใจไว้ และจึงเรียกใช้คอนเทนเนอร์ หากการดำเนินการล้มเหลวหลังจากนั้น ระบบจะเขียนแถวที่สอง เอกสารระบุขอบเขตไว้อย่างชัดเจนว่า คอมพิวเตอร์ไม่ได้เป็นผู้ตัดสินใจนโยบาย แต่เกตเวย์ของเซิร์ฟเวอร์คือขอบเขตของการกระทำ การแบ่งส่วนนี้มีชื่อเรียกภายนอก OpenBot เนื่องจากลูป, คำจำกัดความของเครื่องมือ, การตรวจสอบสิทธิ์ และสถานะของเซสชันถูกรวมไว้ด้วยกันเป็น ชุดคำสั่งที่ครอบโมเดลไว้ และเกตเวย์นี้คือส่วนของการจัดการสิทธิ์ของชุดคำสั่งดังกล่าว
การประเมินนโยบายจะยึดหลักการปฏิเสธไว้ก่อน (fails closed) และกฎการปฏิเสธ (deny rules) จะถูกประเมินก่อนกฎการอนุญาต (allow rules) ทิศทางของความล้มเหลวมีความสำคัญมากกว่าไวยากรณ์ของกฎ นโยบายที่ขาดหายไปหรือว่างเปล่าจะไม่อนุญาตให้ทำสิ่งใดเลย และกฎที่ผิดพลาดจะส่งผลให้เกิดการบล็อกไม่ว่าจะเป็นกฎการปฏิเสธหรือกฎการอนุญาต ดังนั้นความผิดพลาดในนโยบายของคุณจะทำให้บอทติดขัดแทนที่จะปล่อยให้บอทเข้าถึงบัญชีของคุณได้ นโยบายที่มาพร้อมกับ OpenBot นั้นเป็นอีกเรื่องหนึ่ง ค่าเริ่มต้นเมื่อเริ่มระบบคือ deny: [] พร้อมกับ allow: ["true"] ซึ่งอนุญาตทุกการกระทำจนกว่า AGENT_COMPUTER_POLICY หรือนโยบายของผู้ดูแลระบบที่บันทึกไว้จะเข้ามาแทนที่ ดังนั้นควรเขียนนโยบายของคุณเองก่อนที่บอทจะเข้าถึงข้อมูลจริง เลเยอร์นั้นจะควบคุมสิ่งที่บอททำไม่ใช่สิ่งที่บอทอ่าน ดังนั้นหน้าเว็บที่มีคำสั่งสำหรับเอเจนต์จึงยังคงเป็นปัญหาแยกต่างหาก ซึ่งเป็นพื้นผิวการโจมตีแบบ prompt injection เดียวกันกับที่คุณต้องเผชิญเมื่อคุณ ส่งผลลัพธ์จากอินสแตนซ์ SearXNG ของคุณเองให้กับเอเจนต์
บันทึกการตรวจสอบ (audit trail) จัดเก็บอยู่ใน PostgreSQL จึงยังคงอยู่หลังจากการรีสตาร์ท การส่งมอบการควบคุมจะถูกบันทึกเป็น computer.help_requested, computer.control_taken และ computer.control_released ซึ่งเป็นวิธีที่คุณจะเห็นบอทขอความช่วยเหลือจากมนุษย์และเห็นมนุษย์ส่งคืนการควบคุม ความลับจะถูกบันทึกเป็นจำนวนอักขระ ไม่ใช่ค่าจริง การอ่าน การเขียน และการแสดงรายการไฟล์จะปรากฏในแท็บ Activity โดยไฟล์ที่บันทึกไว้จะแสดงเป็นพาธและขนาด ไม่ใช่เนื้อหา มุมมองนั้นถูกเก็บไว้ในเบราว์เซอร์และไม่ใช่บันทึกการตรวจสอบ หากคุณต้องการขอบเขตการควบคุมเดียวกันโดยไม่มีเบราว์เซอร์รองรับ การจำกัดการกระทำของเอเจนต์ AI ด้วยการอนุมัติ จะครอบคลุมกรณีที่เฉพาะเจาะจงกว่านั้น
ต้นทุน RAM และ Disk ต่อหนึ่ง Bot
โครงการได้เผยแพร่ตัวเลขการวัดผลสำหรับ Bot หนึ่งตัวบนสถาปัตยกรรม arm64 ตัวเลขเหล่านี้คือขนาดที่ระบุไว้ในเอกสารการติดตั้ง ซึ่งอธิบายถึง Bot หนึ่งตัวบนสถาปัตยกรรมเดียว ดังนั้นให้ถือว่าเป็นจุดเริ่มต้นมากกว่าที่จะเป็นแผนการรองรับปริมาณงานจริง
ข้อมูลเบื้องหลังแผนภูมินี้
[
{
"label": "Measured, one Bot",
"memory_gb": 0.55,
"disk_gb": 1.4,
"vcpu": 0.06
},
{
"label": "Documented minimum",
"memory_gb": 2,
"disk_gb": 4,
"vcpu": 1
},
{
"label": "Documented recommended",
"memory_gb": 4,
"disk_gb": 8,
"vcpu": 2
}
]หน่วยความจำสูงสุดที่วัดได้อยู่ที่ 0.55 GB ต่อหนึ่ง Bot ในขณะที่ขั้นต่ำตามเอกสารคือ 2 GB และค่าที่แนะนำคือ 4 GB ช่องว่างระหว่างค่าที่วัดได้กับค่าขั้นต่ำคือพื้นที่เผื่อให้ Chromium ขยายตัวเมื่อมีโหลด เนื่องจากหน่วยความจำที่เบราว์เซอร์ใช้จะแปรผันตามจำนวนหน้าเว็บที่เปิดอยู่ ไม่ใช่สถานะขณะไม่ได้ใช้งาน เอกสารระบุว่าการเปิดหน้าเว็บเพิ่มแต่ละหน้าจะใช้หน่วยความจำประมาณ 100 ถึง 200 MB การใช้งาน CPU ขณะไม่ได้ใช้งานนั้นแทบจะเป็นศูนย์ โดยอยู่ที่ 0.06 ของคอร์ในระดับสูงสุดของช่วงที่วัดได้ ดังนั้น CPU จึงไม่ใช่ปัจจัยหลักที่คุณต้องกังวล อิมเมจมีขนาด 1.4 GB เทียบกับขนาดพื้นที่จัดเก็บที่แนะนำคือ 8 GB โดยส่วนต่างที่เหลือคือพื้นที่สำหรับ /workspace ซึ่งเป็นที่ที่ Bot ใช้เก็บไฟล์ของตน อิมเมจนี้บรรจุเฉพาะเบราว์เซอร์ตระกูล Chromium เท่านั้น โดยไม่ได้รวม Firefox และ WebKit ของ Playwright ไว้ด้วย
ข้อมูลข้างต้นไม่ได้ระบุถึงต้นทุนเมื่อใช้งาน Bot หลายตัวพร้อมกัน และโครงการก็ไม่ได้เผยแพร่ตัวเลขสำหรับกรณีดังกล่าว ค่าขั้นต่ำที่ระบุในเอกสารเป็นตัวเลขที่โครงการมั่นใจในการเผยแพร่มากกว่าตัวเลขที่ผ่านการสังเกตการณ์ภายใต้โหลดจริง ซึ่งเป็นเหตุผลว่าทำไม การเลือกระหว่าง PhotoPrism กับ Immich จึงขึ้นอยู่กับค่า RAM ขั้นต่ำที่วัดได้จริงมากกว่าค่าที่ประกาศไว้ คุณควรวัดค่าด้วยตนเอง โดยเริ่มจากรัน Bot หนึ่งตัว มอบหมายงานจริงที่มีการเปิดหน้าเว็บ แล้วคอยตรวจสอบ container ขณะที่มันทำงาน
docker stats --no-stream
free -mให้ใช้ค่าในคอลัมน์ MEM USAGE ของ container สำหรับ Bot เป็นตัวเลขต่อหนึ่งหน่วย จากนั้นบวกค่าของ gateway และ PostgreSQL เข้าไป แล้วจึงคูณตัวเลขต่อ Bot ด้วยจำนวน Bot ที่คุณคาดว่าจะรันพร้อมกัน Bot ที่ไม่ได้ใช้งานจะยังคงเปิดเบราว์เซอร์ค้างไว้จนกว่าจะถึงเวลา idle timeout ซึ่งค่าเริ่มต้นคือ 30 นาที ดังนั้นต้องรวมเบราว์เซอร์ที่ไม่ได้ใช้งานเข้าไปในการคำนวณด้วย วิธีการคำนวณนี้เป็นแบบเดียวกับที่ใช้สำหรับ การคำนวณขนาด RAM และ CPU สำหรับ coding agent บน VPS และส่วนที่เกี่ยวข้องกับเบราว์เซอร์ได้อธิบายไว้ใน การรัน headless browser สำหรับ agent บน VPS
รายละเอียดของ Chromium หนึ่งประการส่งผลต่อแผนการใช้งานขนาดเล็ก OpenBot จะเปิดใช้งาน Chromium ด้วย --disable-dev-shm-usage ทำให้เบราว์เซอร์เขียนข้อมูลลงใน /tmp แทนที่จะเป็น /dev/shm วิธีนี้ช่วยป้องกันการ crash บนโฮสต์ที่มี /dev/shm ขนาดเล็ก และเป็นการย้ายภาระไปไว้ที่ root filesystem ของคุณ ซึ่งเป็นอีกเหตุผลหนึ่งที่ทำให้ขนาด disk ที่แนะนำมีขนาดใหญ่กว่าตัวอิมเมจเอง
วิธีการ self-host OpenBot บน VPS
คุณจำเป็นต้องมี Docker, Bun 1.3 หรือใหม่กว่า, โปรเจกต์และไลเซนส์ของ CopilotKit Intelligence รวมถึงการเข้าถึงโมเดลผ่าน API key หรือการลงชื่อเข้าใช้ผ่านผู้ให้บริการที่รองรับ v0.2.0 README ระบุว่าต้องใช้ Bun 1.3+ สำหรับแอปและ API server แต่ main ในปัจจุบันได้ปรับขึ้นเป็น 1.4+ ดังนั้นโปรดอ่าน README ของแท็กที่คุณ clone มา การลงชื่อเข้าใช้ผ่านผู้ให้บริการสามารถใช้แทน API key ได้ตั้งแต่ v0.0.15 เอกสารสำหรับการพัฒนาคาดหวังว่าจะมี lsof, openssl และ curl อยู่บนเครื่อง รวมถึง npx จาก Node สำหรับการจัดเตรียม Intelligence ควร clone เวอร์ชันที่ระบุแท็กแทนการใช้ main เพราะ main ในโปรเจกต์ที่ยังใหม่อยู่มีการเปลี่ยนแปลงโดยไม่มีการแจ้งเตือน หากคุณใช้งานการติดตั้ง v0.1.x อยู่แล้ว โปรดอ่านบันทึกประจำรุ่น v0.2.0 ก่อนที่จะอัปเกรด เนื่องจากการอัปเกรดจะคัดลอกการเชื่อมต่อ Composio ที่จัดเก็บไว้ไปยังตารางใหม่ และการย้อนกลับไปใช้ v0.1.2 หลังจากนั้นจะทำให้บัญชีที่เชื่อมต่อหลังการอัปเกรดไม่แสดงผล
git clone --branch v0.2.0 https://github.com/CopilotKit/openbot.git
cd openbot
cp .env.example .env
bun installจัดเตรียมโปรเจกต์ Intelligence สองคำสั่งแรกจะให้คุณลงชื่อเข้าใช้และเลือกโปรเจกต์ จากนั้นสคริปต์ตัวช่วยจะจัดเตรียม runtime key ของโปรเจกต์นั้น สร้างหรือนำคอนเทนเนอร์ openbot Learning กลับมาใช้ใหม่ และเขียนการตั้งค่าทั้งสองลงในไฟล์ environment ของคุณ
npx --yes copilotkit@latest login
npx --yes copilotkit@latest project select
bun scripts/setup-learning.tsสร้างคีย์สำหรับเข้ารหัสข้อมูลรับรองที่จัดเก็บไว้ และใส่ผลลัพธ์ลงใน .env ในชื่อ KEY_ENCRYPTION_KEY เพิ่ม OPENAI_API_KEY ของคุณลงในไฟล์เดียวกัน Bot ที่เป็น proof-of-concept ใช้ OpenAI สำหรับ LangGraph Bot คุณสามารถตั้งค่า BOT_PROVIDER เป็น anthropic หรือ google และเพิ่มคีย์ที่ตรงกัน หากต้องการใช้การลงชื่อเข้าใช้โมเดลแทนการใช้คีย์ v0.2.0 .env.example จะรับค่า CLAUDE_CODE_OAUTH_TOKEN, โทเค็นจาก claude setup-token และ CHATGPT_AUTH_FILE ซึ่งเป็นไฟล์ที่เขียนโดยแผน ChatGPT ที่ลงชื่อเข้าใช้ไว้ API server จะอ่านค่าเหล่านี้สำหรับเอเจนต์ในตัว และ compose จะส่งค่าเหล่านี้ไปยัง Bot harness ที่คุณเลือก
openssl rand -base64 32ในขณะที่ .env เปิดอยู่ ให้ตรวจสอบการตั้งค่าคอมพิวเตอร์ .env.example จะปล่อยให้ COMPUTER_SUPERVISOR_URL และ SUPERVISOR_TOKEN ว่างไว้ และชี้ AGENT_COMPUTER_URL ไปที่คอมพิวเตอร์เครื่องเดียวที่แชร์กันบนพอร์ต 4100 ไฟล์ compose จะรวม supervisor ไว้ด้วย และ scripts/start.sh จะเปิดใช้งานคอมพิวเตอร์แยกตาม bot โดยค่าเริ่มต้นผ่านการระบุ COMPUTER_SUPERVISOR_URL และ SUPERVISOR_TOKEN ให้กับเซิร์ฟเวอร์ หากคุณเปิดใช้งานเซิร์ฟเวอร์ด้วยตนเอง ให้ตั้งค่าทั้งสองค่านี้ หากไม่มี URL ของ supervisor บอททุกตัวจะแชร์เบราว์เซอร์เครื่องเดียวกันและข้อมูลการลงชื่อเข้าใช้ร่วมกัน
จากนั้นจึงเริ่มการทำงาน
bash scripts/start.shscripts/start.sh จะเริ่มบริการ Docker, ทำการย้ายฐานข้อมูล (database migrations), เริ่มเซิร์ฟเวอร์, routine worker และแอป พร้อมทั้งตรวจสอบสถานะสุขภาพของบริการเหล่านั้น เมื่อเสร็จสิ้น แอปจะตอบสนองที่พอร์ต 3010 และ API ที่พอร์ต 3001 สคริปต์จะรายงานหากเกิดความขัดแย้งของพอร์ตและจะไม่ยุ่งกับบริการที่ทำงานอยู่แล้ว ดังนั้นการรันซ้ำจึงมีความปลอดภัย
ตรวจสอบจากตัวเซิร์ฟเวอร์เองก่อนที่จะเปิดเผยบริการใดๆ ออกสู่ภายนอก
curl -sS -o /dev/null -w '%{http_code}\n' http://127.0.0.1:3010
ss -ltnp | grep -E ':(3010|3001|4100|4500|5432)'200 จากคำสั่งแรกหมายความว่าแอปกำลังให้บริการอยู่ คำสั่งที่สองแสดงที่อยู่ (address) ที่พอร์ตเหล่านั้นผูกอยู่ ซึ่งเป็นคำตอบที่สำคัญบน VPS บรรทัดที่อ่านว่า 127.0.0.1:3001 เป็นการเข้าถึงแบบส่วนตัวภายในเครื่องเท่านั้น บรรทัดที่อ่านว่า 0.0.0.0:3001 หมายความว่าทุกคนที่สามารถเชื่อมต่อมายังเซิร์ฟเวอร์ได้จะสามารถเข้าถึงบริการนั้นได้
อิมเมจคอนเทนเนอร์เดี่ยว
เอกสารการติดตั้งยังมีการจัดส่งอิมเมจเดี่ยวที่รวมแอปพลิเคชัน, API และ Chromium ไว้ด้วยกัน โดยให้บริการผ่านพอร์ต 3001 อิมเมจนี้ถูกเผยแพร่ในชื่อ ghcr.io/copilotkit/openbot พร้อมแท็กเวอร์ชัน หรือคุณสามารถสร้างอิมเมจเองได้จากซอร์สโค้ดที่คุณโคลนมา
docker build -t openbot .
docker run -p 127.0.0.1:3001:3001 --env-file .env \
-e EMBEDDED_POSTGRES=on -v openbot-data:/var/lib/postgresql openbotEMBEDDED_POSTGRES=on จะรัน PostgreSQL ไว้ภายในคอนเทนเนอร์และดำเนินการ migration เมื่อเริ่มต้นระบบ การใช้ named volume จะช่วยเก็บรักษาประวัติการตรวจสอบ (audit history) ไว้ได้แม้จะมีการ redeploy หากไม่มี volume นี้ การสร้างคอนเทนเนอร์ใหม่ทุกครั้งจะทำให้ประวัติเหล่านั้นสูญหาย ให้ mount volume ไว้ที่ไดเรกทอรีหลักคือ /var/lib/postgresql แทนที่จะ mount ที่ไดเรกทอรีข้อมูลโดยตรง เอกสารระบุคำเตือนว่าการ mount ที่ไดเรกทอรีข้อมูลอาจทำให้คลัสเตอร์ไม่ถูกเริ่มต้นใช้งาน และแอปพลิเคชันจะตอบกลับด้วยข้อผิดพลาด 502 หากคุณชี้ DATABASE_URL ไปยังฐานข้อมูลที่มีการจัดการ (managed database) คุณจะต้องเปิดใช้งานส่วนขยาย vector บนฐานข้อมูลนั้น บริการที่มีการจัดการอย่าง RDS, Cloud SQL และ Azure Database รองรับส่วนขยายนี้ แต่ไม่มีบริการใดเปิดใช้งานให้คุณโดยอัตโนมัติ นอกจากนี้ กระบวนการ migration ยังคาดหวังให้ role ที่ใช้รัน migration เป็นเจ้าของส่วนขยายดังกล่าว ดังนั้นหากส่วนขยายถูกสร้างขึ้นภายใต้ role อื่น กระบวนการจะหยุดทำงานพร้อมข้อผิดพลาด must be owner of extension vector
ให้รัน migration เป็นขั้นตอนหนึ่งของการ release เมื่อใช้ฐานข้อมูลภายนอก
docker run --rm --env-file .env --entrypoint sh openbot \
-c "cd /app/server && bun scripts/migrate.ts"ให้ใช้ scripts/migrate.ts แทนการใช้ drizzle-kit migrate เนื่องจาก drizzle-kit CLI เป็น dependency สำหรับการพัฒนาซึ่งไม่ได้รวมอยู่ในอิมเมจสำหรับ production และต้องเก็บ --entrypoint sh ไว้ เพราะหากไม่มีคำสั่งนี้ API จะเริ่มทำงานก่อนที่การ migration จะเสร็จสิ้น
อิมเมจดังกล่าวจงใจไม่เปิดพอร์ตของเบราว์เซอร์ไว้ และไม่ได้รวม supervisor ไว้ด้วย เนื่องจาก supervisor จำเป็นต้องเข้าถึง Docker socket ซึ่งแพลตฟอร์มแบบ serverless ไม่มีให้ หากไม่มี supervisor บอททุกตัวจะใช้เบราว์เซอร์ร่วมกันและใช้ชุดข้อมูลล็อกอินเดียวกัน ซึ่งเป็นการทำลายการแยกส่วน (isolation) ที่ทำให้การรันคอนเทนเนอร์แยกต่อบอทมีความคุ้มค่า แนวทางการใช้คอนเทนเนอร์เดี่ยวนี้เป็นวิธีเดียวที่จะไม่ให้บอทมีคอนเทนเนอร์เป็นของตัวเอง หากเหตุผลที่คุณมาที่นี่คือต้องการการล็อกอินแยกสำหรับบอทแต่ละตัว ให้รัน compose stack โดยตั้งค่า COMPUTER_SUPERVISOR_URL และ SUPERVISOR_TOKEN บนโฮสต์ที่คุณยอมรับข้อแลกเปลี่ยนนี้ได้ กระบวนการที่สามารถสื่อสารกับ Docker socket ได้นั้นสามารถเริ่มคอนเทนเนอร์ที่มีสิทธิ์สูงได้ ดังนั้นในทางปฏิบัติจึงถือเป็น root บนโฮสต์ นี่เป็นเหตุผลที่ดีในการรัน OpenBot บนเครื่องของตัวเอง เช่นเดียวกับแนวคิดเรื่อง การให้ coding agent ใช้ VM แบบใช้แล้วทิ้ง
เหตุผลที่ OPENBOT_SINGLE_USER เป็นการตั้งค่าสำหรับแล็ปท็อป
.env.example มาพร้อมกับ OPENBOT_SINGLE_USER=true การตั้งค่านี้จะยอมรับทุกคำขอในฐานะผู้ดูแลระบบที่กำหนดไว้เพียงหนึ่งเดียวและข้ามขั้นตอนการลงชื่อเข้าใช้ไปโดยสิ้นเชิง บนแล็ปท็อปถือเป็นความสะดวกสบาย เพราะไคลเอนต์เดียวที่เข้าถึงพอร์ตนี้ได้คือตัวคุณเอง แต่บน VPS หมายความว่าใครก็ตามที่เข้าถึงพอร์ต 3010 จะกลายเป็นผู้ดูแลระบบนั้นทันที บนระบบที่จัดเก็บข้อมูลประจำตัวที่เข้ารหัสและควบคุมเบราว์เซอร์ที่ลงชื่อเข้าใช้บัญชีของคุณไว้แล้ว
ปัจจุบันเซิร์ฟเวอร์ได้เพิ่มการป้องกันในส่วนนี้ หากตั้งค่า OPENBOT_SINGLE_USER=true ไว้และมีการกำหนดเส้นทางรายการ OPENBOT_PUBLIC_URL, OPENBOT_APP_URL หรือ TRUSTED_ORIGINS แบบสาธารณะ เซิร์ฟเวอร์จะปฏิเสธการเริ่มทำงานและระบุที่อยู่นั้นออกมา หากเป็นที่อยู่ส่วนตัวจะเริ่มทำงานพร้อมคำเตือน การตรวจสอบนี้จะอ่าน URL ในการตั้งค่าของคุณ ไม่ใช่อินเทอร์เฟซที่ Docker เปิดใช้งาน ดังนั้นค่าเริ่มต้น localhost จึงผ่านการตรวจสอบแม้ว่าพอร์ตจะเปิดสู่สาธารณะก็ตาม การผูกพอร์ต (binding) ยังคงเป็นหน้าที่ของคุณ
มีสองวิธีที่เหมาะสมในการใช้งาน: คงค่า OPENBOT_SINGLE_USER=true ไว้ ผูกทุกพอร์ตเข้ากับ 127.0.0.1 และเข้าถึงแอปผ่าน SSH tunnel หรืออินเทอร์เฟซเครือข่ายส่วนตัวเท่านั้น
ssh -N -L 3010:127.0.0.1:3010 -L 3001:127.0.0.1:3001 you@your-vpsจากนั้นแอปจะอยู่ที่ http://localhost:3010 ในเบราว์เซอร์ของคุณ Chrome และ Firefox จะถือว่าที่อยู่นั้นเป็นบริบทที่ปลอดภัย (secure context) และเก็บคุกกี้การลงชื่อเข้าใช้ Secure ไว้ที่นั่น Safari เป็นข้อยกเว้น: แม้จะรายงานว่า localhost เป็นบริบทที่ปลอดภัย แต่ ณ วันที่ 10 พฤศจิกายน 2026 ก็ยังปฏิเสธที่จะจัดเก็บคุกกี้ Secure ที่ตั้งค่าผ่าน http://localhost แบบธรรมดา ซึ่งเป็นบั๊กของ WebKit ที่ยังไม่ได้รับการแก้ไข ดังนั้นให้เปิด tunnel ใน Chrome หรือ Firefox หรือติดตั้ง TLS ไว้ด้านหน้า หน้าจอการทำงานจริงไม่จำเป็นต้องใช้บริบทที่ปลอดภัย เอกสารการติดตั้งระบุว่าแอปไม่ได้ขึ้นอยู่กับ API ของเบราว์เซอร์ใดๆ ที่ http:// แบบธรรมดาจำกัดไว้ อีกวิธีหนึ่งคือการปิดโหมดผู้ใช้คนเดียวและกำหนดค่าผู้ให้บริการระบุตัวตน (identity provider) จริงๆ โดยรองรับ Google, Microsoft Entra, Okta, SAML และ OIDC สำหรับ Google, Entra และ Okta ให้ตั้งค่าใน environment ส่วน SAML และ OIDC ให้ลงทะเบียนภายใต้ Admin, Identity providers หลังจากที่การติดตั้งเริ่มทำงานแล้ว ผู้ให้บริการทุกรายยังต้องการ BETTER_AUTH_SECRET ที่มีความยาว 32 ตัวอักษรขึ้นไป, BETTER_AUTH_URL ที่ตั้งค่าเป็น URL ฐานของ API สาธารณะสำหรับ OAuth callbacks และ INITIAL_ADMIN_EMAILS แม้ TRUSTED_ORIGINS จะไม่อยู่ในรายการที่จำเป็น แต่เป็นส่วนที่เก็บต้นทางของแอปที่ API ยอมรับ รวมถึงโฮสต์ทุกแห่งในเอกสารการค้นพบของผู้ให้บริการ OIDC ที่ลงทะเบียนไว้ และ OPENBOT_APP_URL จะใช้ค่าเริ่มต้นเป็นรายการแรก ดังนั้นควรตั้งค่าให้เป็นต้นทางของแอปสาธารณะของคุณ ข้อมูลประจำตัวของผู้ให้บริการต้องครบถ้วน เพราะหากกำหนดค่าผู้ให้บริการไม่สมบูรณ์จะทำให้การเริ่มทำงานหยุดลงแทนที่จะกลับไปใช้การเข้าถึงแบบเปิด หากเหตุผลที่คุณเพิ่มบัญชีผู้ใช้เป็นเพราะทุกคนในทีมต้องการเอเจนต์ของตนเองแทนที่จะใช้เบราว์เซอร์ของตนเอง OneCLI ถูกสร้างขึ้นมาเพื่อรองรับรูปแบบนั้นตั้งแต่ต้น โดยมีเอเจนต์แบบ sandboxed หนึ่งตัวต่อหนึ่งคน และเก็บคีย์ของโมเดลไว้ในเกตเวย์เดียว
หากแอปสามารถเข้าถึงได้ผ่านชื่อสาธารณะ ให้ติดตั้ง TLS (transport layer security) ไว้ด้านหน้า หน้าเว็บที่ให้บริการผ่าน http:// แบบธรรมดาบนโฮสต์อื่นที่ไม่ใช่ localhost จะไม่ถือเป็นบริบทที่ปลอดภัย ดังนั้นคุกกี้ที่ทำเครื่องหมาย Secure จะไม่ถูกจัดเก็บ และการลงชื่อเข้าใช้จะล้มเหลวในลักษณะที่ดูเหมือนเป็นบั๊กของ OpenBot
การจำกัดการเข้าถึงพอร์ตระดับล่างด้วยไฟร์วอลล์
บันทึกความปลอดภัยของ OpenBot ระบุว่า service endpoint ระดับล่างได้รับการป้องกันด้วย token ซึ่งคุณควรเก็บไว้เป็นความลับและไม่ควรนำมาใช้เพื่อข้ามผ่าน gateway โดย token เป็นการป้องกันชั้นที่สอง ส่วนการป้องกันชั้นแรกคือการทำให้ไม่สามารถเข้าถึงพอร์ตดังกล่าวได้เลย
agent-computer จะฟังการเชื่อมต่อที่พอร์ต 4100 และต้องการ COMPUTER_TOKEN ส่วน bot endpoint จะฟังที่พอร์ต 4200 และ 4201 และ agent harness จะฟังที่พอร์ต 4202 สำหรับ supervisor จะฟังที่พอร์ต 4500 บนโฮสต์และ 4300 ภายในคอนเทนเนอร์ โดยไฟล์ compose จะผูกพอร์ตนี้ไว้กับ 127.0.0.1:4500 ในขณะที่ PostgreSQL จะฟังที่พอร์ต 5432 พอร์ตเหล่านี้ไม่ควรเปิดรับการเชื่อมต่อจากอินเทอร์เน็ตสาธารณะ และสำหรับการติดตั้งใช้งานแบบผู้ใช้คนเดียว พอร์ตของแอปและ API ก็ไม่ควรเปิดเช่นกัน
sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow 22/tcp
sudo ufw enable
sudo ufw status verboseมีกับดักที่มักทำให้ผู้ใช้เข้าใจผิดว่าการตั้งค่าไฟร์วอลล์เพียงอย่างเดียวนั้นเพียงพอ การเผยแพร่พอร์ตคอนเทนเนอร์ด้วย -p 3001:3001 จะทำให้ Docker ติดตั้งกฎ DNAT ซึ่งส่งผลให้ traffic ถูกจัดการในเส้นทาง FORWARD และไม่ผ่าน chain INPUT ที่กฎ default deny ของ ufw ควบคุมอยู่ พอร์ตจะยังคงเปิดอยู่แม้ว่า ufw status จะแสดงผลเป็น Status: active ก็ตาม คุณควรผูกพอร์ตที่เผยแพร่ไว้กับ loopback ในการทำ mapping โดยตรง เช่น -p 127.0.0.1:3001:3001 หรือกำหนด host address ในไฟล์ compose ของคุณ ให้ตรวจสอบผลลัพธ์ด้วย ss -ltnp แทนการใช้ ufw status กับดักนี้ไม่ได้จำกัดอยู่แค่ OpenBot เท่านั้น ดังนั้นคุณควรตรวจสอบคอนเทนเนอร์อื่นทั้งหมดที่คุณเผยแพร่ไว้บนเซิร์ฟเวอร์ด้วยวิธีเดียวกัน รวมถึงบริการใดก็ตามที่กำลังให้บริการ คลังสื่อ Jellyfin ที่ปรับแต่งให้เหมือนร้านเช่าวิดีโอในยุค 90
OpenBot สามารถทำงานแบบออฟไลน์ด้วย Intelligence ที่โฮสต์เองได้
โปรดพิจารณาข้อมูลนี้ก่อนวางแผนการติดตั้ง OpenBot มีการพึ่งพาโปรเจกต์ CopilotKit Intelligence ซึ่งทำหน้าที่เก็บรักษาเธรดและประวัติการสนทนาไว้บนบริการที่โฮสต์ไว้หรือบนโครงสร้างพื้นฐานของคุณเอง เซิร์ฟเวอร์ v0.2.0 ที่ถูกปักหมุดไว้จะตรวจสอบ INTELLIGENCE_API_URL, INTELLIGENCE_GATEWAY_WS_URL และ INTELLIGENCE_API_KEY ในขณะเริ่มทำงาน โดยจะตรวจสอบทั้งสามค่านี้เป็นชุดและปฏิเสธที่จะเริ่มทำงานหากขาดค่าใดค่าหนึ่งไป ส่วน COPILOTKIT_LICENSE_TOKEN เป็นค่าทางเลือกและจะใช้เฉพาะกับ Intelligence ที่โฮสต์เองและมีใบอนุญาตเป็นของตนเองเท่านั้น ณ วันที่ 10 พฤศจิกายน 2026 บริการ Intelligence แบบโฮสต์ฟรีจะรวมโควตาการใช้งาน 1,000 ครั้งต่อองค์กรในแต่ละเดือน แต่เนื่องจาก v0.1.0 OpenBot จะแสดงแบนเนอร์สำหรับการโฮสต์เอง เว้นแต่ว่าการติดตั้งนั้นจะมีแผน Intelligence แบบชำระเงินหรือมีการตั้งค่า OPENBOT_SELF_HOST_BANNER=false ไว้ ตัว Intelligence เองสามารถโฮสต์ได้ ดังนั้นการติดตั้งแบบโลคัลทั้งหมดจึงเป็นไปได้แม้จะต้องใช้ความพยายามมากกว่าที่ระบุไว้ในคู่มือเริ่มต้นใช้งานฉบับย่อ การติดตั้งเพื่อใช้งานจริงแบบออฟไลน์จำเป็นต้องใช้แผน Annual ส่วนการโฮสต์เองแบบจ่ายตามการใช้งานจริงจะต้องเชื่อมต่ออินเทอร์เน็ตเพื่อรายงานการใช้งานสำหรับการเรียกเก็บเงิน รุ่น Developer Edition แบบฟรีรองรับการประเมินผลในสภาพแวดล้อมโลคัลที่ไม่ใช่การใช้งานจริงด้วยใบอนุญาต 30 วันที่ต่ออายุได้ โดยการติดตั้งและการต่ออายุจำเป็นต้องมีการเชื่อมต่ออินเทอร์เน็ต CLI ของ Intelligence ในเครื่องจะเขียนคีย์ไว้ที่ CPK_INTELLIGENCE_API_KEY ในขณะที่รุ่น v0.2.0 ที่ถูกปักหมุดไว้จะอ่านเฉพาะ INTELLIGENCE_API_KEY เท่านั้น ดังนั้นให้คัดลอกค่าดังกล่าวข้ามมาสำหรับรุ่นนี้ ค่า main ในปัจจุบันยอมรับคีย์จาก CLI โดยตรงและจะให้ความสำคัญกับค่านั้นก่อน
โมเดลเป็นส่วนประกอบที่ต้องพึ่งพาเป็นลำดับที่สอง โดยไม่มีโมเดลใดๆ มาพร้อมกับตัวซอฟต์แวร์ BOT_PROVIDER รองรับ openai, anthropic หรือ google สำหรับ LangGraph Bot และ OPENAI_BASE_URL จะชี้เส้นทางของ OpenAI ไปยัง endpoint ใดๆ ที่เข้ากันได้ ซึ่งเป็นจุดที่ การรัน Ollama บน VPS เพื่อโฮสต์ LLM เอง เข้ามามีบทบาทหากคุณต้องการให้โทเค็นยังคงอยู่บนฮาร์ดแวร์ของคุณเอง การควบคุมเบราว์เซอร์ต้องการประสิทธิภาพจากโมเดลสูง ดังนั้นควรทดสอบโมเดลในเครื่องกับงานจริงก่อนตัดสินใจเลือกใช้
การขยายระบบเกินกว่าหนึ่ง replica
Gateway จะทำการแก้ไขการอ้างอิง element โดยเทียบกับ snapshot ของหน้าเว็บ ปัจจุบัน snapshot ดังกล่าวถูกจัดเก็บไว้ใน PostgreSQL ทำให้ replica ตัวที่สองสามารถทำงานต่อจาก snapshot ที่ replica ตัวแรกสร้างไว้ได้ Helm chart อย่างเป็นทางการจะรัน API replica สองตัวเป็นค่าเริ่มต้น และเก็บทุกสิ่งที่ replica จำเป็นต้องใช้เพื่อความอยู่รอดไว้ใน PostgreSQL นอกจากนี้ยังมีการปิดใช้งาน embedded computer และปฏิเสธการติดตั้งหากมี replica มากกว่าหนึ่งตัว เบราว์เซอร์ที่อยู่ภายใน API pod จะเก็บข้อมูลการเข้าสู่ระบบของบอทไว้ และการขยายขนาด API จะทำให้ข้อมูลเหล่านี้ถูกคัดลอกซ้ำไปมา กรณีที่ต้องระวังคือ single image เนื่องจาก replica แต่ละตัวจะมีเบราว์เซอร์ของตนเอง ทำให้ข้อมูลการเข้าสู่ระบบของบอทจะค้างอยู่เฉพาะบน instance ที่ให้บริการบอทตัวนั้นๆ ในกรณีของ VPS หนึ่งเครื่อง เบราว์เซอร์ของบอททุกตัวยังคงรันอยู่บนโฮสต์เดียวกัน ดังนั้นการขยายระบบจึงทำได้โดยการเพิ่มทรัพยากรให้กับเครื่องนั้นๆ การแยกส่วนระหว่างบอทแต่ละตัวยังคงใช้ container แยกตามบอท เช่นเดียวกับที่ self-hosted agent sandboxes ป้องกันไม่ให้ข้อผิดพลาดของ agent ตัวหนึ่งส่งผลกระทบต่อตัวอื่น
รูปแบบความล้มเหลวและสิ่งที่คุณจะพบ
การเริ่มต้นทำงานหยุดลงทันทีหลังจากที่คุณกรอก .env เซิร์ฟเวอร์จะตรวจสอบความถูกต้องของค่าคอนฟิกูเรชันก่อนที่จะเริ่มให้บริการ ข้อผิดพลาดแต่ละรายการต่อไปนี้จะทำให้การเริ่มต้นหยุดทำงานแทนที่จะทำงานต่อไปแบบลดประสิทธิภาพ: บล็อก Intelligence ที่ไม่สมบูรณ์, การขาดหายไปของ KEY_ENCRYPTION_KEY, ผู้ให้บริการ OAuth ที่มี client ID แต่ไม่มี secret หรือการใช้โหมด single-user ร่วมกับ public URL ให้คุณอ่านข้อผิดพลาดบรรทัดแรก แก้ไขฟิลด์นั้น แล้วเริ่มการทำงานใหม่อีกครั้ง
การทำ Migration ล้มเหลวบนฐานข้อมูลที่มีการจัดการ มีสาเหตุที่เป็นไปได้สองประการ ประการแรกคือส่วนขยาย vector อาจยังไม่ได้เปิดใช้งานและ role ที่ใช้ทำ migration ไม่สามารถสร้างส่วนขยายดังกล่าวได้ ทำให้การ migration พบกับประเภทคอลัมน์ที่ PostgreSQL ไม่รู้จัก ประการที่สองคือส่วนขยายถูกสร้างขึ้นภายใต้ role อื่น ทำให้การ migration หยุดทำงานพร้อมกับข้อผิดพลาด must be owner of extension vector ให้คุณสร้างส่วนขยายด้วย role เดียวกับที่ใช้รัน migration จากนั้นจึงรันขั้นตอนการ migration ใหม่อีกครั้ง
แอปโหลดขึ้นมาได้แต่การลงชื่อเข้าใช้ไม่คงอยู่ คุณกำลังให้บริการผ่าน http:// แบบธรรมดาบนที่อยู่สาธารณะ ซึ่งไม่ใช่บริบทที่ปลอดภัย ทำให้คุกกี้ Secure ถูกปฏิเสธ ให้คุณติดตั้ง TLS ไว้ด้านหน้า หรือใช้ SSH tunnel เพื่อให้เบราว์เซอร์มองเห็นเป็น localhost ในกรณีที่ใช้ tunnel ให้ใช้ Chrome หรือ Firefox เนื่องจาก Safari ยังคงปฏิเสธคุกกี้ Secure ที่ตั้งค่าผ่าน http://localhost แบบธรรมดา
บอทใช้ข้อมูลการลงชื่อเข้าใช้ร่วมกันในขณะที่คุณคาดว่ามันควรจะแยกจากกัน คุณไม่ได้ใช้งาน supervisor ทำให้ไม่มีการแยกคอมพิวเตอร์สำหรับบอทแต่ละตัว และบอททุกตัวใช้เบราว์เซอร์ร่วมกันที่ AGENT_COMPUTER_URL ให้ตรวจสอบว่ามีการตั้งค่า COMPUTER_SUPERVISOR_URL แล้ว และ supervisor สามารถเข้าถึง Docker socket ได้
บอทหยุดทำงานและขอความช่วยเหลือ นั่นคือการทำงานตามการออกแบบ ระบบ audit trail จะบันทึก computer.help_requested ไว้ คุณสามารถเข้าควบคุมผ่านหน้าจอสด และการส่งมอบงานจะถูกบันทึกไว้ทั้งสองฝั่ง
FAQ
การเปิดใช้งาน OPENBOT_SINGLE_USER สำหรับการติดตั้งบน VPS ปลอดภัยหรือไม่?
ปลอดภัยเฉพาะในกรณีที่ gateway ไม่สามารถเข้าถึงได้จากอินเทอร์เน็ต OPENBOT_SINGLE_USER=true จะยอมรับทุกคำขอในฐานะผู้ดูแลระบบที่กำหนดไว้เพียงหนึ่งเดียวโดยไม่ต้องลงชื่อเข้าใช้ ดังนั้นใครก็ตามที่สามารถเปิดพอร์ตได้จะถือเป็นเจ้าของระบบการติดตั้ง ข้อมูลประจำตัวที่จัดเก็บไว้ และเบราว์เซอร์ที่ลงชื่อเข้าใช้ไว้ ในโหมดนี้เซิร์ฟเวอร์จะปฏิเสธการเริ่มทำงานเมื่อมีการกำหนดค่า public URL หรือ trusted origin ที่ถูก routing ออกสู่สาธารณะ แต่การตรวจสอบนั้นไม่สามารถมองเห็นได้ว่าพอร์ตของคุณถูกเผยแพร่อย่างไร การใช้งานนี้เป็นที่ยอมรับได้เมื่อทุกพอร์ตถูกผูกไว้กับ 127.0.0.1 และคุณเข้าถึงแอปผ่าน SSH tunnel หรือ private network interface หากอยู่บน public interface ให้ปิดการใช้งานนี้และกำหนดค่า Google, Microsoft Entra, Okta หรือ OIDC ร่วมกับ BETTER_AUTH_SECRET, BETTER_AUTH_URL และ INITIAL_ADMIN_EMAILS พร้อมทั้งตั้งค่า TRUSTED_ORIGINS ให้เป็น public app origin ของคุณ
OpenBot หนึ่งตัวต้องการ RAM เท่าไร?
ตัวเลขที่เผยแพร่โดยโครงการสำหรับ Bot ตัวเดียวบน arm64 ระบุว่ามีการใช้หน่วยความจำสูงสุดที่ 0.55 GB โดยมี 2 GB เป็นค่าขั้นต่ำตามเอกสาร และแนะนำที่ 4 GB ทั้งนี้ไม่มีตัวเลขที่เผยแพร่สำหรับการรันหลายบอทพร้อมกัน เนื่องจากบอทแต่ละตัวจะถือครอง Chromium ของตนเอง ให้รันบอทหนึ่งตัวในงานจริง อ่านค่าหน่วยความจำของ container นั้นใน docker stats รวมค่า gateway และฐานข้อมูลเข้าด้วยกัน จากนั้นคูณด้วยจำนวนบอทที่คุณคาดว่าจะรันพร้อมกัน
ฉันจำเป็นต้องมีบัญชี CopilotKit เพื่อ self-host OpenBot หรือไม่?
จำเป็น OpenBot ขึ้นอยู่กับโครงการ CopilotKit Intelligence สำหรับการจัดการ thread และหน่วยความจำที่คงทน และเซิร์ฟเวอร์ v0.2.0 ที่ถูกกำหนดไว้จะปฏิเสธการเริ่มทำงานหากไม่ได้ตั้งค่า Intelligence API URL, gateway WebSocket URL และ API key ไว้ ทั้งนี้มีแผนบริการฟรีให้ใช้งาน ณ วันที่ 10 พฤศจิกายน 2026 และรองรับการติดตั้งใช้งานจริงแบบออฟไลน์ด้วยการ self-host Intelligence ในแผน Annual และโมเดลภายในเครื่อง นอกจากนี้คุณต้องจัดเตรียมการเข้าถึงโมเดล, API key ของโมเดล หรือการลงชื่อเข้าใช้ของผู้ให้บริการที่รองรับด้วยตนเอง เนื่องจากไม่มีโมเดลใดมาพร้อมกับ OpenBot
ทำไมบอทแต่ละตัวถึงต้องมีเบราว์เซอร์ของตัวเองแทนที่จะแชร์กัน?
เพราะโปรไฟล์เบราว์เซอร์คือตัวตน การแชร์เบราว์เซอร์หมายถึงการแชร์คุกกี้และเซสชัน ดังนั้นบอทตัวหนึ่งที่ลงชื่อเข้าใช้บัญชีหนึ่งจะส่งผลให้ทุกบอทลงชื่อเข้าใช้บัญชีนั้นด้วย การใช้ container แยกต่อบอทช่วยให้เพื่อนร่วมงานแต่ละคนมีโปรไฟล์และการลงชื่อเข้าใช้เป็นของตัวเอง แต่จะเกิดขึ้นได้ก็ต่อเมื่อ COMPUTER_SUPERVISOR_URL ชี้เซิร์ฟเวอร์ไปยัง supervisor เท่านั้น หากไม่มีสิ่งนี้ บอททุกตัวจะแชร์เบราว์เซอร์เดียวกัน ต้นทุนที่ต้องแลกคือหน่วยความจำ เนื่องจาก Chromium ต่อบอทเป็นส่วนประกอบที่ใช้ทรัพยากรมากที่สุดในการคำนวณขนาดระบบ
พอร์ตใดของ OpenBot ที่ควรเปิดบน firewall?
ไม่ต้องเปิดพอร์ตระดับล่างใดๆ ทั้งสิ้น ทั้ง agent-computer บน 4100, bot endpoints บน 4200 และ 4201, agent harness บน 4202, supervisor บน 4500 และ PostgreSQL บน 5432 ควรเป็นส่วนตัวทั้งหมด โครงการปกป้องพอร์ตเหล่านี้ด้วยโทเค็นและขอให้คุณเก็บไว้ในสถานะที่ไม่สามารถเข้าถึงได้อยู่ดี ให้เผยแพร่เฉพาะสิ่งที่จำเป็นต้องเปิดให้บุคคลเข้าถึงเท่านั้น และโปรดจำไว้ว่าพอร์ตของ container ที่ถูกเผยแพร่ด้วย -p 3001:3001 จะสามารถเข้าถึงได้โดยไม่คำนึงถึงกฎ ufw default-deny เนื่องจากกฎ DNAT ของ Docker จะนำ traffic นั้นเข้าสู่เส้นทาง FORWARD แทนที่จะเป็น INPUT