วิธีตั้งค่าความปลอดภัย Ollama API ป้องกันพอร์ต 11434
เซิร์ฟเวอร์ Ollama ไม่มีการยืนยันตัวตนผ่านพอร์ต 11434 ทำให้ผู้ที่เข้าถึงได้สามารถรันหรือลบโมเดลของคุณได้ทันที เรียนรู้วิธีแก้ไขปัญหาความปลอดภัยนี้ด้วย 3 ขั้นตอนที่ทำได้จริง
Ollama API ไม่มีรหัสผ่าน
Ollama API ไม่มีการตรวจสอบสิทธิ์ (authentication) ไม่มีการกำหนดผู้ใช้ ไม่มีรหัสผ่าน และไม่มีการตรวจสอบ API key สำหรับไคลเอนต์ที่เชื่อมต่อเข้ามา ทุกสิ่งที่สามารถเปิดการเชื่อมต่อ TCP ไปยังพอร์ต 11434 สามารถแสดงรายการโมเดล สั่งรันโมเดล ดาวน์โหลดโมเดลใหม่ และลบโมเดลที่คุณมีอยู่ได้
เอกสารอย่างเป็นทางการระบุไว้อย่างชัดเจนว่า: "Local API ที่ http://localhost:11434 ไม่ต้องการการตรวจสอบสิทธิ์" คำว่า local คือรูปแบบความปลอดภัยทั้งหมดของระบบนี้ โดยปกติ Ollama จะผูก (bind) อยู่กับ 127.0.0.1 ดังนั้นบนแล็ปท็อป อินเทอร์เฟซ loopback จึงทำหน้าที่เป็นตัวควบคุมการเข้าถึง หากคุณย้าย listener นี้ไปยัง public address การควบคุมการเข้าถึงจะหายไปทันที เพราะไม่มีกลไกอื่นมาทดแทน
นี่คือเหตุผลว่าทำไมเรื่องนี้จึงสำคัญบน VPS (virtual private server) ค่าเริ่มต้นนั้นปลอดภัย แต่การเปลี่ยนแปลงแรกที่คนส่วนใหญ่มักทำ คือการเปิด listener เพื่อให้เครื่องอื่นสามารถใช้งานโมเดลได้ ซึ่งเป็นการเปลี่ยนแปลงที่ลบการป้องกันทั้งหมดออกไปในคราวเดียว
สิ่งที่พอร์ต 11434 ที่เปิดทิ้งไว้เปิดเผยออกมา
ทุก endpoint ของระบบไม่มีโหมดอ่านอย่างเดียวและไม่มีพอร์ตสำหรับผู้ดูแลระบบแยกต่างหาก คำขอเหล่านี้คือคำขอจริงที่มุ่งตรงไปยังที่อยู่ของเซิร์ฟเวอร์แทนที่จะเป็น localhost:
# List every model on the box
curl http://SERVER_IP:11434/api/tags
# See what is loaded into memory right now
curl http://SERVER_IP:11434/api/ps
# Run a prompt on your hardware
curl http://SERVER_IP:11434/api/generate -d '{"model":"llama3.2","prompt":"Why is the sky blue?"}'
# Write several gigabytes to your disk
curl http://SERVER_IP:11434/api/pull -d '{"model":"llama3.2"}'
# Remove a model
curl -X DELETE http://SERVER_IP:11434/api/delete -d '{"model":"llama3.2"}'ในมุมมองของผู้ดูแลระบบ มี 4 สิ่งที่จะเกิดความผิดพลาด:
- CPU หรือ GPU ของคุณจะประมวลผล inference ให้กับผู้อื่น หากคุณใช้แผนบริการที่มีการจำกัดการใช้งาน CPU (fair-use) ภาระงานที่เกิดขึ้นอย่างต่อเนื่องหมายความว่าโควตาของคุณกำลังถูกคนแปลกหน้าใช้ไป และการ ควบคุมค่าใช้จ่ายของ AI workload บน VPS จะทำได้ยากขึ้นมากเมื่อคุณไม่ใช่ผู้เรียกใช้งานเพียงคนเดียว
/api/pullจะเขียนข้อมูลลงบนดิสก์ของคุณ ขนาดของโมเดลมีความแตกต่างกัน แม้แต่llama3.2:1bก็มีขนาดถึง 1.3 GB การวนลูปสั่ง pull โมเดลจะทำให้พื้นที่จัดเก็บข้อมูลเต็ม และเมื่อดิสก์เต็มก็จะทำให้บริการอื่นๆ ทั้งหมดบนเครื่องหยุดทำงาน ไม่ใช่แค่ Ollama เท่านั้น- คำขอจะเข้ามาภายในกระบวนการทำงานของคุณและถูกบันทึกลง log โดยค่าเริ่มต้นของ log level ใน Ollama จะบันทึกเฉพาะ metadata เท่านั้น ดังนั้นคุณจะได้ข้อมูล endpoint, สถานะ, latency และที่อยู่ของไคลเอนต์ แต่ไม่ใช่ข้อความ prompt อย่างไรก็ตาม ข้อมูลเหล่านี้ยังคงเป็นบันทึกว่าใครใช้งานเครื่องของคุณและใช้งานเพื่ออะไร ซึ่งข้อมูลนี้จะค้างอยู่ใน journal ของคุณโดยที่คุณไม่ได้เป็นผู้เลือกที่จะจัดเก็บมัน
/api/deleteจะลบโมเดลทิ้ง การจะนำโมเดลกลับมาหมายถึงการต้องดาวน์โหลดใหม่ผ่านแบนด์วิดท์ของคุณเอง
ทั้งหมดนี้ไม่จำเป็นต้องอาศัยช่องโหว่ใดๆ นี่คือการทำงานของ API ตามเอกสารที่ออกแบบมาอย่างถูกต้องทุกประการ
กุญแจ Ed25519 ไม่ใช่การควบคุมการเข้าถึง
เมื่อค้นหาคำว่า "Ollama API key" คุณจะพบกับสองสิ่งที่แตกต่างกัน ซึ่งทั้งสองอย่างไม่ใช่รหัสผ่านสำหรับเซิร์ฟเวอร์ของคุณ การแยกแยะความแตกต่างเหล่านี้จะช่วยลดความสับสนได้เป็นส่วนใหญ่
อย่างแรกคือคู่กุญแจระบุตัวตน (identity key pair) Ollama จะสร้างคู่กุญแจ Ed25519 ขึ้นมาในการรันครั้งแรก บน Linux สคริปต์ติดตั้งจะสร้างผู้ใช้ระบบชื่อ ollama โดยมีไดเรกทอรีหลักอยู่ที่ /usr/share/ollama ดังนั้นคู่กุญแจจึงอยู่ที่นี่:
/usr/share/ollama/.ollama/id_ed25519
/usr/share/ollama/.ollama/id_ed25519.pubกุญแจนี้ชี้ออกไปยังภายนอก ollama signin จะลงทะเบียนกุญแจสาธารณะเข้ากับบัญชี ollama.com ของคุณ ซึ่งเป็นสิ่งที่อนุญาตให้คุณ push โมเดลไปยัง registry หรือ pull โมเดลส่วนตัวออกมาได้ มันทำหน้าที่ยืนยันตัวตนเครื่องของคุณกับ ollama.com และไม่ได้ร้องขอสิ่งใดจากไคลเอนต์ที่เชื่อมต่อเข้ามายังเครื่องของคุณ การลบ การหมุนเวียนกุญแจ หรือการไม่สร้างกุญแจนี้ขึ้นมาเลย ไม่ส่งผลใดๆ ต่อผู้ที่สามารถเรียกใช้งาน API ของคุณได้
อย่างที่สองคือ OLLAMA_API_KEY ตัวแปรนี้เก็บกุญแจที่คุณสร้างขึ้นที่ https://ollama.com/settings/keys และไคลเอนต์ของคุณจะส่งกุญแจนี้ในรูปแบบ Authorization: Bearer $OLLAMA_API_KEY เมื่อเรียกใช้งาน API ที่โฮสต์ไว้ที่ https://ollama.com/api มันเป็นข้อมูลรับรองสำหรับบริการของพวกเขา ซึ่งคุณใช้ในฐานะไคลเอนต์ ส่วน ollama serve ของคุณเองนั้นไม่ได้ใช้กุญแจนี้ในการตรวจสอบสิทธิ์คำขอที่เข้ามา การตั้งค่า OLLAMA_API_KEY บน VPS ของคุณไม่ได้เป็นการใส่รหัสผ่านให้กับ VPS ของคุณ
ดังนั้นจึงไม่มีการตั้งค่าใดให้เปิดใช้งาน มาตรการป้องกันทั้งสามประการด้านล่างนี้ทำงานในลักษณะเดียวกัน คือการทำให้พอร์ตไม่สามารถเข้าถึงได้จากภายนอก และวางระบบอื่นไว้ด้านหน้าเพื่อทำหน้าที่ตรวจสอบสิทธิ์แทน
ตรวจสอบว่าเซิร์ฟเวอร์ของคุณกำลังฟังพอร์ตใดอยู่บ้างในขณะนี้
sudo ss -tlnp | grep 11434ผลลัพธ์ที่ปลอดภัยจะแสดงที่อยู่ loopback:
LISTEN 0 4096 127.0.0.1:11434 0.0.0.0:* users:(("ollama",pid=812,fd=3))ผลลัพธ์ที่เปิดเผยต่อสาธารณะจะแสดงทุกอินเทอร์เฟซ:
LISTEN 0 4096 0.0.0.0:11434 0.0.0.0:* users:(("ollama",pid=812,fd=3))0.0.0.0 หมายถึงที่อยู่ IPv4 ทั้งหมดบนเครื่อง รวมถึงที่อยู่สาธารณะด้วย ส่วน *:11434 และ [::]:11434 คือการฟังแบบ wildcard บนที่อยู่ IPv6 ทั้งหมด การที่มันจะยอมรับ IPv4 ด้วยหรือไม่นั้นขึ้นอยู่กับตัวเลือก IPV6_V6ONLY ของซ็อกเก็ต ซึ่งโดยปกติ Linux จะปิดไว้เป็นค่าเริ่มต้น (net.ipv6.bindv6only=0) ดังนั้นให้ถือว่าทั้งสามกรณีนี้เป็นการเปิดเผยต่อสาธารณะ
จากนั้นให้ตรวจสอบจากภายนอก โดยรันคำสั่งนี้บนแล็ปท็อปของคุณ ไม่ใช่บนเซิร์ฟเวอร์:
curl -m 5 http://YOUR_SERVER_IP:11434/api/versioncurl: (28) Connection timed out after 5001 milliseconds คือคำตอบที่คุณต้องการ เช่นเดียวกับ curl: (7) Failed to connect ... Connection refused หากได้รับออบเจกต์ JSON ที่มีฟิลด์ version แสดงว่า API ทั้งหมดสามารถเข้าถึงได้โดยใครก็ตามที่เรียกเข้ามา การทดสอบด้วย curl บนตัวเซิร์ฟเวอร์เองไม่สามารถยืนยันได้ว่าเครื่องอื่นจะเข้าถึงบริการนั้นได้หรือไม่ หากเซิร์ฟเวอร์มีที่อยู่ IPv6 ให้ทำการทดสอบซ้ำด้วย curl -6 -m 5 http://[YOUR_SERVER_IPV6]:11434/api/version เพราะพอร์ต IPv4 ที่ปิดอยู่ไม่ได้บ่งบอกถึงสถานะของตัวฟัง IPv6
การเปิดเผยบริการต่อสาธารณะมักเกิดขึ้นจากสองสาเหตุหลัก สาเหตุแรกคือการแก้ไขไฟล์โดยเจตนา เนื่องจากมีความจำเป็นต้องให้เครื่องอื่นเข้าถึงโมเดลได้:
sudo systemctl edit ollama.service[Service]
Environment="OLLAMA_HOST=0.0.0.0:11434"บรรทัดเดียวนั้นคือสาเหตุทั้งหมดของการเปิดเผยบริการ ส่วนสาเหตุที่สองคือ Docker ซึ่งไม่จำเป็นต้องให้คุณแก้ไขไฟล์ใดๆ เลย และเรื่องนั้นจะมีส่วนอธิบายแยกต่างหากด้านล่างนี้
การป้องกันชั้นที่ 1: จำกัดไว้ที่ localhost และใช้งานผ่าน tunnel
ให้ใช้วิธีนี้เป็นอันดับแรก เนื่องจากไม่ต้องติดตั้งซอฟต์แวร์ใหม่และไม่สร้าง credential ที่อาจรั่วไหลได้ พอร์ตจะไม่ปรากฏบนอินเทอร์เฟซสาธารณะ ทำให้การสแกนหาพอร์ตไม่พบ
ให้กำหนด bind address อย่างชัดเจนแทนการพึ่งพาค่าเริ่มต้น:
sudo systemctl edit ollama.service[Service]
Environment="OLLAMA_HOST=127.0.0.1:11434"คำสั่งนี้จะเขียนไฟล์ /etc/systemd/system/ollama.service.d/override.conf ให้ใช้การตั้งค่าและตรวจสอบดังนี้:
sudo systemctl daemon-reload
sudo systemctl restart ollama
sudo ss -tlnp | grep 11434ss ควรแสดงผลเป็น 127.0.0.1:11434 หากยังแสดงเป็น 0.0.0.0 แสดงว่ามีไฟล์ drop-in อื่นที่ทำงานทับอยู่ ให้รัน systemctl cat ollama.service เพื่อแสดงรายการ unit และไฟล์ drop-in ทั้งหมดพร้อมพาธ จากนั้นให้ลบไฟล์ที่ไม่ได้ใช้งานออก
หากต้องการใช้งานโมเดลจากแล็ปท็อปของคุณ ให้ส่งต่อพอร์ตผ่าน SSH:
ssh -N -L 11434:127.0.0.1:11434 you@your-server-L 11434:127.0.0.1:11434 จะเปิดพอร์ต 11434 บนแล็ปท็อปของคุณและส่งข้อมูลทั้งหมดที่เข้ามายัง 127.0.0.1:11434 ตามที่มองเห็นจากฝั่งเซิร์ฟเวอร์ -N เป็นการสั่งให้ SSH ไม่ต้องรันคำสั่งบนรีโมท เพื่อให้กระบวนการคงสถานะ tunnel ไว้ ในขณะที่ tunnel ทำงานอยู่ คุณสามารถใช้งานบนแล็ปท็อปได้ดังนี้:
curl -s http://localhost:11434/api/tagsคุณอาจพบความล้มเหลว 2 รูปแบบ: bind [127.0.0.1]:11434: Address already in use หมายความว่าที่อยู่และพอร์ตในเครื่องถูกใช้งานไปแล้ว ไม่ว่าจะโดย Ollama, SSH tunnel อื่น หรือโปรแกรมอื่น ให้เลือกพอร์ตในเครื่องใหม่ด้วย -L 11500:127.0.0.1:11434 แล้วชี้ไคลเอนต์ของคุณไปที่ 11500 หากคำขอที่ผ่าน tunnel ได้รับการตอบกลับที่ว่างเปล่า ให้ตรวจสอบ ss บนเซิร์ฟเวอร์และข้อความแสดงข้อผิดพลาดของ SSH ก่อนตัดสินใจว่าบริการใดล้มเหลว
สำหรับเครื่องไคลเอนต์หลายเครื่อง การใช้เครือข่ายส่วนตัว (private network) จะดีกว่าการทำ tunnel แยกรายบุคคล ให้เชื่อมต่อเครื่องเหล่านั้นเข้ากับ WireGuard หรือ Tailscale จากนั้น bind Ollama เข้ากับที่อยู่บนเครือข่ายนั้นแทนที่จะเป็น 0.0.0.0:
[Service]
Environment="OLLAMA_HOST=10.8.0.1:11434"พอร์ตจะปรากฏเฉพาะบนอินเทอร์เฟซที่ต้องใช้คีย์ในการเข้าถึงเท่านั้น วิธีนี้ยังช่วยป้องกันความผิดพลาดจากการตั้งค่าไฟร์วอลล์ เพราะกฎที่อนุญาตให้คนภายนอกเข้าถึงโดยไม่ตั้งใจ ก็ยังไม่สามารถเปิดเผย listener ที่ไม่ได้อยู่บนอินเทอร์เฟซสาธารณะได้
การป้องกันที่ 2: การใช้ reverse proxy เพื่อตรวจสอบ bearer token
เมื่อบริการบนอินเทอร์เน็ตสาธารณะจำเป็นต้องเรียกใช้งานโมเดล ให้คงการตั้งค่า Ollama ไว้ที่ loopback และวาง proxy ไว้ด้านหน้าเพื่อทำหน้าที่แทน โดย proxy จะทำหน้าที่ยุติการเชื่อมต่อ TLS (transport layer security) และปฏิเสธคำขอที่ไม่มี header ที่ถูกต้อง ในขณะที่ Ollama จะยังคงยอมรับการเชื่อมต่อจาก 127.0.0.1 เท่านั้น ดังนั้น proxy จึงเป็นเส้นทางเดียวที่เข้าถึงได้
ขั้นแรกให้สร้าง token จริงขึ้นมา ห้ามสร้างขึ้นเองด้วยมือ:
openssl rand -base64 36ตัวอย่างการตั้งค่า nginx เพื่อตรวจสอบ token:
map $http_authorization $ollama_ok {
default 0;
"Bearer PASTE_YOUR_GENERATED_TOKEN_HERE" 1;
}
server {
listen 443 ssl;
server_name llm.example.com;
ssl_certificate /etc/letsencrypt/live/llm.example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/llm.example.com/privkey.pem;
location = /api/pull { return 403; }
location = /api/delete { return 403; }
location = /api/push { return 403; }
location / {
if ($ollama_ok = 0) { return 401; }
proxy_pass http://127.0.0.1:11434;
proxy_set_header Host 127.0.0.1:11434;
proxy_buffering off;
proxy_read_timeout 600s;
}
}มี 5 บรรทัดที่ทำหน้าที่สำคัญ และแต่ละบรรทัดช่วยป้องกันความล้มเหลวที่คุณอาจพบได้หากไม่ได้ตั้งค่าไว้
การใช้ if ภายในบล็อก location มักไม่ใช่ความคิดที่ดีใน nginx แต่การใช้ body ที่มีขนาด return พอดีเป็นหนึ่งในสองรูปแบบที่ทำงานได้อย่างคาดการณ์ได้ ดังนั้นการใช้งานนี้จึงปลอดภัย
location = /api/pull เป็นการจับคู่แบบตรงตัว (exact match) และ nginx จะจัดลำดับความสำคัญของการจับคู่แบบตรงตัวไว้สูงกว่า prefix แบบ location / ดังนั้น endpoint ทั้งสามนี้จะถูกปฏิเสธก่อนที่จะมีการตรวจสอบ token เสียอีก อย่างไรก็ตาม token ที่ถูกต้องยังคงสามารถเข้าถึง endpoint อื่นๆ สำหรับการจัดการโมเดลได้ รวมถึง /api/create และ /api/blobs/:digest ดังนั้นบล็อกทั้งสามนี้จึงไม่ได้ป้องกันการเขียนข้อมูลลงดิสก์ได้ทั้งหมด
proxy_set_header Host 127.0.0.1:11434; มีความสำคัญเนื่องจาก Ollama จะตรวจสอบ header Host และ Origin ที่เข้ามา การส่ง hostname สาธารณะของ proxy ผ่านไปโดยตรงอาจทำให้เกิด 403 Forbidden ที่มาจาก Ollama แทนที่จะมาจาก nginx ซึ่งจะทำให้การตรวจสอบปัญหาทำได้ยาก ส่วน OLLAMA_ORIGINS เป็นอีกส่วนที่สำคัญสำหรับไคลเอนต์เบราว์เซอร์ที่ต้องการอนุญาต origin เฉพาะเจาะจง
proxy_buffering off; มีความสำคัญเพราะ Ollama จะส่งข้อมูลแบบ streaming ทีละ token หากเปิดใช้งาน buffering ไว้ nginx จะกักเก็บข้อมูลตอบกลับไว้ก่อนที่จะส่งต่อ ซึ่งจะทำให้การส่งข้อมูลแบบ streaming ล่าช้าออกไป
proxy_read_timeout 600s; มีความสำคัญเนื่องจากค่าเริ่มต้นของ nginx คือ 60 วินาที และตัวจับเวลานี้จะทำงานระหว่างการอ่านข้อมูลสองครั้งที่ต่อเนื่องกันจาก Ollama ไม่ใช่ตลอดทั้งการตอบกลับ การตอบกลับแบบ streaming ที่มีการส่งข้อมูลออกมาเรื่อยๆ จะรีเซ็ตตัวจับเวลานี้ทุกครั้ง แต่หากเป็นคำขอที่ Ollama ไม่ส่งข้อมูลออกมาเลยเป็นเวลา 60 วินาที ตัวจับเวลานี้จะทำงาน เช่น คำขอที่ส่งด้วย "stream": false ซึ่งจะส่งคำตอบทั้งหมดกลับมาในคราวเดียวเมื่อเสร็จสิ้น หรือกรณีที่มีความเงียบยาวนานก่อนที่ token แรกจะมาถึง ไคลเอนต์จะได้รับ 504 Gateway Time-out และ /var/log/nginx/error.log จะบันทึก upstream timed out (110: Connection timed out) while reading response header from upstream ทั้งที่จริงแล้วคำขอยังคงทำงานอยู่ แต่ nginx ได้ยกเลิกการเชื่อมต่อไปแล้ว
โหลดการตั้งค่าใหม่และทดสอบทั้งสองเส้นทาง:
sudo nginx -t && sudo systemctl reload nginx
curl -s -o /dev/null -w '%{http_code}\n' https://llm.example.com/api/tags
curl -s -H "Authorization: Bearer YOUR_TOKEN" https://llm.example.com/api/tagsคำสั่งแรกควรแสดงผลเป็น 401 ส่วนคำสั่งที่สองควรแสดงรายการโมเดลของคุณ หากคำสั่งแรกส่งคืนรายการโมเดลกลับมาด้วย ให้ตรวจสอบว่า server และ location ใดเป็นผู้จัดการคำขอนั้น และการโหลดการตั้งค่าใหม่สำเร็จหรือไม่ บล็อก map ที่อยู่ในขอบเขต (scope) ที่ไม่ถูกต้องจะทำให้การตั้งค่าใช้งานไม่ได้ โดยบล็อกนี้ต้องอยู่ที่ระดับ http ดังนั้นให้วางไว้ในไฟล์ภายใต้ /etc/nginx/conf.d/ หรือเหนือบล็อก server และห้ามวางไว้ภายใน server โดยเด็ดขาด
Caddy สามารถทำงานแบบเดียวกันด้วยการตรวจสอบสิทธิ์แบบ basic authentication โดยใช้เพียง 4 บรรทัด ซึ่งเหมาะกับไคลเอนต์เบราว์เซอร์มากกว่าการใช้ bearer token:
llm.example.com {
basic_auth {
apiuser PASTE_BCRYPT_HASH_HERE
}
reverse_proxy 127.0.0.1:11434
}ให้รันคำสั่ง caddy hash-password เพื่อสร้าง bcrypt hash ที่ต้องการ ข้อควรทราบเรื่องการตั้งชื่อ: directive นี้เคยใช้ชื่อ basicauth ก่อน Caddy v2.8 และเปลี่ยนเป็น basic_auth ในปัจจุบัน Caddy ยังคงยอมรับชื่อเดิมในฐานะ alias ที่เลิกใช้งานแล้ว (deprecated) ดังนั้นการคัดลอกการตั้งค่าจากคู่มือเก่าจะยังคงโหลดได้ แต่ Caddy จะแจ้งเตือนว่า basicauth นั้นเลิกใช้งานแล้วและขอให้คุณใช้ basic_auth แทน ให้เปลี่ยนชื่อเมื่อคุณเห็นคำเตือนดังกล่าว
ไม่ว่าคุณจะเลือกใช้ proxy ตัวใด นี่คือความลับร่วม (shared secret) สำหรับทุกคน ไคลเอนต์ทุกรายที่มี token นี้จะมีสิทธิ์เข้าถึงเท่ากัน และการเพิกถอนสิทธิ์หมายถึงการต้องแก้ไขไฟล์การตั้งค่าและอัปเดตไคลเอนต์ทุกรายพร้อมกัน
การป้องกันชั้นที่ 3: เกตเวย์ที่ออกคีย์แยกตามไคลเอนต์
เมื่อมีผู้ใช้หรือแอปพลิเคชันมากกว่าหนึ่งรายเรียกใช้งานโมเดล การใช้โทเค็นร่วมกันจะเริ่มมีข้อจำกัด คุณจะไม่สามารถระบุได้ว่าไคลเอนต์ใดเป็นผู้สร้างภาระงาน และไม่สามารถตัดการเชื่อมต่อไคลเอนต์รายใดรายหนึ่งได้โดยไม่ส่งผลกระทบต่อรายอื่นทั้งหมด เกตเวย์จะทำหน้าที่แทนที่พร็อกซี โดยรองรับ API ที่เข้ากันได้กับ OpenAI ทำหน้าที่ออกคีย์แยกตามไคลเอนต์ และบันทึกปริมาณการใช้งานของแต่ละคีย์ เกตเวย์ LiteLLM แบบ self-hosted เป็นคำตอบที่นิยมใช้ ซึ่งจะช่วยเพิ่มฟีเจอร์การกำหนดงบประมาณต่อคีย์และบันทึก log ของคำขอเพิ่มเติมจากการควบคุมการเข้าถึง
กฎจากการป้องกันชั้นที่ 1 ยังคงเดิม Ollama ต้องผูกกับ 127.0.0.1 โดยให้เกตเวย์เป็นกระบวนการเดียวที่ติดต่อกับ Ollama และเกตเวย์ต้องเป็นบริการเดียวที่เปิดรับการเชื่อมต่อจากภายนอก การติดตั้งเกตเวย์บนเครื่องที่ยังเปิดพอร์ต 11434 สู่สาธารณะถือว่าไม่มีประโยชน์ เพราะผู้เรียกใช้งานสามารถข้ามเกตเวย์ไปโดยตรงได้
กับดักของไฟร์วอลล์: พอร์ตของคอนเทนเนอร์ที่ถูก publish จะข้ามการทำงานของ UFW
นี่คือสาเหตุที่ทำให้เกิด instance ที่เปิดเผยต่อสาธารณะบนเซิร์ฟเวอร์ที่เจ้าของตั้งค่าไฟร์วอลล์ไว้อย่างถูกต้องแล้ว
UFW (uncomplicated firewall) จะเขียนกฎลงใน chain INPUT ของตาราง filter ในระดับเคอร์เนล และ INPUT จะจัดการแพ็กเก็ตที่ส่งถึงตัวโฮสต์โดยตรง แต่ flag -p ของ Docker จะเขียนกฎ destination NAT (network address translation) ลงใน chain PREROUTING ของตาราง nat ซึ่งเคอร์เนลจะประเมินกฎนี้ก่อนที่จะตัดสินใจว่าแพ็กเก็ตจะไปที่ใด เมื่อถึงขั้นตอนการตัดสินใจเรื่องเส้นทาง (routing decision) ปลายทางจะถูกเปลี่ยนเป็นที่อยู่ของคอนเทนเนอร์ไปแล้ว แพ็กเก็ตจึงถูกส่งต่อ (forward) แทนที่จะถูกส่งไปยังโฮสต์โดยตรง และมันจะผ่าน chain FORWARD แทนที่จะเป็น INPUT กฎของ UFW ใน chain INPUT จึงไม่ถูกนำมาพิจารณา ส่งผลให้แพ็กเก็ตเลี่ยงไฟร์วอลล์ไปแทนที่จะผ่านมัน
นี่คือเหตุผลที่ลำดับคำสั่งนี้ทำให้พอร์ต 11434 เปิดต่ออินเทอร์เน็ต:
sudo ufw default deny incoming
sudo ufw enable
docker run -d -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollamaและ sudo ufw status ยังคงรายงานว่าไฟร์วอลล์ทำงานอยู่โดยมีนโยบายปฏิเสธการเชื่อมต่อเริ่มต้น (default deny) ทั้งสองสถานะนี้ถูกต้องพร้อมกัน ซึ่งเป็นเหตุผลว่าทำไมผู้ใช้ถึงเชื่อถือข้อมูลที่ผิด คุณสามารถตรวจสอบกฎที่ทำให้เกิดปัญหานี้ได้ด้วยคำสั่ง:
sudo iptables -t nat -L DOCKER -nวิธีแก้ไขคือการระบุที่อยู่ (address) ใน flag สำหรับ publish:
docker rm -f ollama
docker run -d -v ollama:/root/.ollama -p 127.0.0.1:11434:11434 --name ollama ollama/ollama-p 11434:11434 ไม่ได้ระบุที่อยู่ของโฮสต์ Docker จึง publish พอร์ตบนทุกที่อยู่ของโฮสต์ ทั้ง IPv4 (0.0.0.0) และ IPv6 ([::]) การระบุ 127.0.0.1 จะเป็นการผูกฝั่งโฮสต์ของการแมปพอร์ตไว้กับ loopback ทำให้ SSH tunnel และ reverse proxy ของคุณยังคงเข้าถึงบริการได้ แต่ฝั่งอินเทอร์เน็ตไม่สามารถเข้าถึงได้ Docker เวอร์ชันที่เก่ากว่า 28.0.0 มีข้อยกเว้นคือ เครื่องที่อยู่ใน network segment เดียวกันจะสามารถเข้าถึงพอร์ตที่ publish ไว้ที่ localhost ได้ ดังนั้นควรอัปเกรดก่อนที่จะพึ่งพาการป้องกันนี้ การสร้างคอนเทนเนอร์ใหม่ในกรณีนี้มีความปลอดภัยเนื่องจากโมเดลถูกเก็บไว้ใน volume ollama ไม่ได้อยู่ภายในตัวคอนเทนเนอร์
ตรวจสอบให้แน่ใจว่าทั้งสองมุมมองตรงกัน:
docker port ollama
sudo ss -tlnp | grep 11434docker port ollama ควรแสดงผลเป็น 11434/tcp -> 127.0.0.1:11434 หากแสดงผลเป็น 0.0.0.0:11434 หรือ [::]:11434 แสดงว่าคุณยังคงเปิดเผยบริการต่อสาธารณะ เมื่อเข้าใจกลไกนี้แล้ว คุณจะสามารถนำไปใช้กับทุกคอนเทนเนอร์ที่คุณ publish ได้: เหตุผลที่พอร์ตของ Docker ที่ถูก publish ถึงข้าม UFW จะอธิบายเกี่ยวกับ chain DOCKER-USER และกฎที่ยังคงอยู่หลังจาก Docker รีสตาร์ท หากคุณกำลังสร้างนโยบายสำหรับโฮสต์ กฎ UFW ที่ VPS ใหม่จำเป็นต้องมี จะครอบคลุมถึงพื้นฐานที่จำเป็น สำหรับ Rocky หรือ AlmaLinux จะไม่มี UFW ให้ตั้งค่า ดังนั้น นโยบายพื้นฐานเดียวกันที่เขียนด้วย firewalld คือจุดเริ่มต้นที่ควรศึกษาแทน
กระบวนการทำงานภายใต้สิทธิ์ของผู้ใช้ใด
สคริปต์ติดตั้งบน Linux จะสร้างบัญชีผู้ใช้เฉพาะขึ้นมาและรันบริการภายใต้บัญชีนั้น:
useradd -r -s /bin/false -U -m -d /usr/share/ollama ollamaไฟล์ unit ที่ /etc/systemd/system/ollama.service จะกำหนดค่า User=ollama และ Group=ollama ไว้แล้ว ไม่ควรแก้ไขส่วนนี้ การรัน ollama serve ด้วยตนเองใน terminal จะรันภายใต้สิทธิ์ของผู้ใช้ที่ล็อกอินอยู่ หากผู้ใช้ดังกล่าวคือ root จะส่งผลให้ API ที่ไม่มีการตรวจสอบสิทธิ์เขียนไฟล์ด้วยสิทธิ์ root ให้ตรวจสอบสถานะดังนี้:
ps -o user= -C ollamaผลลัพธ์ควรเป็น ollama หากเป็นค่าอื่น แสดงว่ามีกระบวนการที่รันด้วยตนเองทำงานควบคู่ไปกับหรือแทนที่ unit หลัก แนวคิดเดียวกันนี้ใช้ได้กับ daemon ทุกตัวที่คุณเพิ่มในภายหลัง และเนื้อหาใน การรันบริการด้วยสิทธิ์ผู้ใช้ที่จำกัด จะอธิบายรายละเอียดเรื่องนี้ไว้อย่างครบถ้วน
วิธีตรวจสอบความปลอดภัยของ Ollama API endpoint
ไม่ว่าคุณจะเลือกวิธีใด การทดสอบหนึ่งอย่างจะช่วยยืนยันผลได้ โดยต้องรันคำสั่งจากเครื่องอื่น:
curl -m 5 http://YOUR_SERVER_IP:11434/api/version
curl -m 5 http://YOUR_SERVER_IP:11434/api/tagsทั้งสองคำสั่งควรแสดงผลว่าหมดเวลา (time out) หรือถูกปฏิเสธการเชื่อมต่อ หากคุณสร้าง proxy ขึ้นมา ทั้งสอง path เดียวกันบน hostname ของ proxy ควรส่งค่า 401 กลับมาหากไม่มีข้อมูลยืนยันตัวตน และส่ง JSON จริงกลับมาหากมีข้อมูลยืนยันตัวตนที่ถูกต้อง
จากนั้นให้อ่าน access log สำหรับคำขอที่เกิดขึ้นในช่วงที่พอร์ตยังเปิดอยู่:
journalctl -u ollama --since "-30 days" | grep GINOllama จะเขียน log หนึ่งบรรทัดต่อหนึ่งคำขอและระบุที่อยู่ของ client ไว้ด้วย:
[GIN] 2026/08/12 - 14:01:10 | 200 | 103.965898ms | 127.0.0.1 | POST "/api/generate"ที่อยู่นั้นมาจาก ClientIP() ของ Gin ซึ่งจะตรวจสอบ header X-Forwarded-For และ X-Real-IP จาก proxy ที่เชื่อถือได้ด้วย ดังนั้น คำขอที่ผ่าน reverse proxy แบบ loopback อาจแสดงที่อยู่ client เป็นสาธารณะได้ในขณะที่ Ollama ถูก bind ไว้ที่ 127.0.0.1 อย่างถูกต้อง การเห็นที่อยู่สาธารณะในคอลัมน์นั้นไม่ได้พิสูจน์ว่ามีการเข้าถึงพอร์ต 11434 โดยตรง และการไม่พบ log ที่ตรงกันก็ไม่ได้พิสูจน์ว่าไม่มีใครเข้าถึงได้ ให้เปรียบเทียบ timestamp กับ log และการตั้งค่าของ proxy ของคุณ และใช้การทดสอบการเชื่อมต่อจากภายนอกเพื่อตรวจสอบการเปิดเผยพอร์ตในปัจจุบัน หากเรื่องโมเดลเป็นสิ่งใหม่สำหรับคุณ การรัน Ollama บน VPS จะครอบคลุมเนื้อหาการติดตั้ง การเลือกขนาดโมเดล และขีดจำกัดหน่วยความจำที่กำหนดว่าโมเดลใดจะโหลดขึ้นมาใช้งานได้จริง
FAQ
Ollama มี API key หรือรหัสผ่านหรือไม่
ไม่มี เซิร์ฟเวอร์ที่คุณรันไม่มีระบบยืนยันตัวตนใดๆ ทั้งสิ้น และเอกสารอย่างเป็นทางการระบุว่า API ในเครื่องไม่ต้องการการยืนยันตัวตน สิ่งที่เรียกว่า "Ollama API key" ทั้งสองอย่างนั้นมีจุดประสงค์อื่น คู่กุญแจ Ed25519 ใน /usr/share/ollama/.ollama/ ใช้เพื่อยืนยันเครื่องของคุณกับ ollama.com เพื่อให้คุณสามารถ push โมเดลและ pull โมเดลส่วนตัวได้ ส่วน OLLAMA_API_KEY คือข้อมูลประจำตัวที่ไคลเอนต์ของคุณส่งไปยัง API ที่โฮสต์ไว้ที่ https://ollama.com/api ตัว ollama serve ของคุณเองไม่ได้ใช้ทั้งสองอย่างนี้ในการยืนยันตัวตนไคลเอนต์ที่เข้ามา ดังนั้นการควบคุมการเข้าถึงจึงต้องมาจากระดับเครือข่ายหรือจากพร็อกซีที่อยู่ด้านหน้า
OLLAMA_HOST=0.0.0.0 ปลอดภัยหรือไม่หากฉันมีไฟร์วอลล์
ปลอดภัยก็ต่อเมื่อไฟร์วอลล์บล็อกการเข้าถึง listener นั้นได้อย่างถูกต้องเท่านั้น การตั้งค่า 0.0.0.0 หมายความว่า listener นั้นมีอยู่จริงบนอินเทอร์เฟซสาธารณะ และคุณกำลังเชื่อใจเพียงแค่ไฟร์วอลล์ว่าจะป้องกันไม่ให้เข้าถึงได้ พอร์ต Ollama ที่เผยแพร่ผ่าน Docker ต้องการความใส่ใจเป็นพิเศษ เนื่องจากกฎ DNAT ที่ Docker เพิ่มเข้าไปในตาราง nat จะถูกประเมินก่อนที่แพ็กเก็ตจะไปถึงเชน INPUT ซึ่งเป็นที่ที่ UFW ทำงานอยู่ ดังนั้นแพ็กเก็ตจะถูกส่งต่อและกฎ INPUT ของ UFW จะมองไม่เห็นแพ็กเก็ตนั้น การผูก (bind) ไว้ที่ 127.0.0.1 หรือที่อยู่ของไพรเวททันเนลจะช่วยลบ listener ออกจากอินเทอร์เฟซสาธารณะ ทำให้ความผิดพลาดของไฟร์วอลล์ไม่มีช่องทางให้เปิดเผยข้อมูลได้อีก
ฉันจะตรวจสอบได้อย่างไรว่าพอร์ต Ollama ของฉันเปิดสู่สาธารณะหรือไม่
ให้รัน sudo ss -tlnp | grep 11434 บนเซิร์ฟเวอร์ และรัน curl -m 5 http://YOUR_SERVER_IP:11434/api/version จากเครื่องอื่น ผลลัพธ์ที่แสดง 127.0.0.1:11434 ใน ss และการที่คำสั่ง curl จากระยะไกลหมดเวลา (timeout) คือคำตอบที่คุณต้องการ หาก ss แสดง 0.0.0.0:11434 หรือ *:11434 ในขณะที่คำสั่ง curl จากระยะไกลส่งค่า JSON กลับมา แสดงว่า API ทั้งหมดสามารถเข้าถึงได้ การทดสอบด้วย curl บนเซิร์ฟเวอร์เองไม่สามารถยืนยันได้ว่าเครื่องอื่นจะเข้าถึงได้หรือไม่
ฉันสามารถเปลี่ยนพอร์ตจาก 11434 ไปเป็นพอร์ตอื่นแบบสุ่มได้หรือไม่
ไม่ได้ และเหตุผลนั้นสำคัญที่ต้องกล่าวถึง การเปลี่ยนพอร์ตไม่ได้ช่วยชะลอสิ่งใดเลยนอกจากแค่การสแกนพอร์ตเดียวเท่านั้น เครื่องมือสแกนจะไล่ตรวจสอบตลอดช่วงพอร์ตทั้งหมด และการส่งคำขอเพียงครั้งเดียวไปยัง /api/tags ก็สามารถระบุบริการได้ไม่ว่าจะมาทางพอร์ตใด การเปลี่ยนพอร์ตยังทำให้ค่าเริ่มต้นของไคลเอนต์ทั้งหมดใช้งานไม่ได้และทำให้การตั้งค่าของคุณเองเข้าใจได้ยากขึ้นในภายหลัง ให้ผูกไว้ที่ loopback แทน ซึ่งเป็นการลบ listener ออกไปเลยดีกว่าการย้ายตำแหน่ง
มีคนเข้าถึง Ollama ที่เปิดไว้ของฉันได้ ฉันควรตรวจสอบอะไรบ้าง
ให้ผูกบริการไว้ที่ 127.0.0.1 และรีสตาร์ทบริการก่อน เพื่อหยุดการเปิดเผยข้อมูลก่อนที่คุณจะเริ่มตรวจสอบ จากนั้นให้รัน journalctl -u ollama --since "-30 days" | grep GIN เพื่อดูที่อยู่ของไคลเอนต์, endpoint และเวลาที่เข้าถึง Gin ยังอ่าน header ของที่อยู่ไคลเอนต์ที่ถูกส่งต่อมาด้วย ดังนั้นให้เปรียบเทียบรายการเหล่านั้นกับ log ของพร็อกซีของคุณก่อนที่จะสรุปว่าที่อยู่นั้นเป็นหลักฐานของการเข้าถึงโดยตรง เปรียบเทียบ ollama list กับโมเดลที่คุณตั้งใจจะมีไว้ เนื่องจาก /api/pull ไม่มีการยืนยันตัวตน และโมเดลที่คุณไม่ได้ pull มาเองนั้นถือเป็นการใช้พื้นที่ดิสก์และเป็นหลักฐานอย่างหนึ่ง ตรวจสอบพื้นที่ว่างด้วย df -h โดยค่าเริ่มต้น access log จะบันทึกเพียง metadata ของคำขอเท่านั้น ไม่ได้บันทึกชื่อโมเดล, ข้อความ prompt หรือคำตอบที่สร้างขึ้น