วิธีการปรับใช้คอนเทนเนอร์ Docker บนเซิร์ฟเวอร์ระยะไกล

การทำงานกับคอนเทนเนอร์ Docker บนเซิร์ฟเวอร์ระยะไกล มันกลายเป็นสิ่งสำคัญสำหรับทุกคนที่ต้องการใช้งานแอปพลิเคชันสมัยใหม่โดยไม่ต้องยุ่งยากกับเรื่องการพึ่งพาไลบรารี เวอร์ชันของไลบรารี และคำถามคลาสสิกที่ว่า "มันใช้งานได้บนเครื่องของฉัน" อย่างไรก็ตาม เมื่อเราเปลี่ยนจากการใช้งานแอปพลิเคชันแบบง่ายๆ ไปสู่การใช้งานที่ซับซ้อนขึ้น docker run จากเดิมที่ติดตั้งระบบใช้งานจริงจังบนเซิร์ฟเวอร์ Linux ในเครื่องของคุณเอง โดยใช้ Docker Compose, GitHub shares, Plesk, Portainer หรือแม้แต่แอปพลิเคชันแบบกราฟิกที่เข้าถึงได้ผ่านเบราว์เซอร์ ทุกอย่างก็จะซับซ้อนขึ้นเล็กน้อย

หากเป้าหมายของคุณคือการติดตั้งคอนเทนเนอร์ Docker บนเซิร์ฟเวอร์ระยะไกล (Ubuntu, Debian, Windows พร้อม WSL 2, เซิร์ฟเวอร์คลาวด์, Plesk ฯลฯ) และทำในลักษณะที่บำรุงรักษาได้ เป็นระบบอัตโนมัติ และปลอดภัย ในคู่มือนี้ คุณจะได้พบกับขั้นตอนที่ค่อนข้างครบถ้วน ตั้งแต่การใช้งาน Docker Compose ระยะไกลขั้นพื้นฐาน ไปจนถึงสภาพแวดล้อมการพัฒนาด้วย VS Code การปรับใช้จาก Plesk การบริหารจัดการด้วย Portainer และการเรียกใช้งานแอปพลิเคชันแบบกราฟิกจากระยะไกลโดยใช้ noVNC และ Caddy

แนวคิดพื้นฐาน: คอนเทนเนอร์ Docker และการปรับใช้งานจากระยะไกล

Docker คือแพลตฟอร์มคอนเทนเนอร์ มันจะบรรจุแอปพลิเคชันพร้อมกับทุกสิ่งที่จำเป็น (ไลบรารี, ส่วนประกอบที่จำเป็น, ไฟล์ไบนารี, การกำหนดค่าระบบขั้นต่ำ) เพื่อให้สามารถทำงานได้เหมือนกันบนเครื่องใดก็ได้ที่มีการติดตั้ง Docker Engine ความแตกต่างที่สำคัญเมื่อเทียบกับเครื่องเสมือนคือ คอนเทนเนอร์ไม่ได้รวมระบบปฏิบัติการแบบสมบูรณ์ แต่จะใช้เคอร์เนลของเครื่องโฮสต์ร่วมกัน ส่งผลให้ภาพมีขนาดเล็กกว่าและมีประสิทธิภาพดีกว่า

เพื่อปรับใช้คอนเทนเนอร์ Docker บนเซิร์ฟเวอร์ระยะไกล โดยทั่วไป คุณจะมีโฮสต์ (เช่น เซิร์ฟเวอร์ Ubuntu ในระบบคลาวด์) ที่ติดตั้ง Docker และอาจมี Docker Compose ด้วย จากนั้นจึงส่งโค้ดหรืออิมเมจไปยังโฮสต์นั้นเพื่อทำการรัน คุณสามารถทำได้ด้วยตนเองผ่าน SSH, ทำให้เป็นอัตโนมัติด้วย GitHub Actions หรือผสานรวมเข้ากับแผงควบคุมต่างๆ เช่น Plesk หรือเครื่องมืออย่าง Portainer

สถานการณ์จริงหลักๆ ที่คุณจะได้พบเจอ เมื่อพูดถึง "Docker ระยะไกล" จะมีสามแง่มุม ได้แก่ การพัฒนาในเครื่องเดียวกันแต่รันคอนเทนเนอร์บนเครื่องอื่น (หรือใน WSL 2) การปรับใช้บริการแบ็กเอนด์/ฟรอนต์เอนด์แบบอัตโนมัติ และการจัดการคอนเทนเนอร์ในสภาพแวดล้อมการผลิต (การตรวจสอบ การบันทึก การรีสตาร์ท นโยบายเครือข่าย ฯลฯ) เทคโนโลยีนั้นเหมือนกัน สิ่งที่เปลี่ยนไปคือวิธีการจัดการและควบคุม

นอกเหนือจากบริการแบ็กเอนด์แบบดั้งเดิมแล้วDocker ช่วยให้เราสามารถทำสิ่งที่ไม่ค่อยเป็นที่รู้จักแต่ทรงพลังมากได้ นั่นคือ การเรียกใช้แอปพลิเคชันแบบกราฟิก (เช่น โปรแกรมอีเมล, IDE, เครื่องมือวิเคราะห์ข้อมูล ฯลฯ) ภายในคอนเทนเนอร์ระยะไกล และเข้าถึงแอปพลิเคชันเหล่านั้นจากเบราว์เซอร์โดยใช้ VNC ผ่าน WebSocket นี่เป็นวิธีที่สะดวกในการใช้ประโยชน์จากเซิร์ฟเวอร์ที่มีประสิทธิภาพสูง เมื่อพีซีของคุณมีประสิทธิภาพไม่เพียงพอ

จากการรันคำสั่ง docker ไปยัง Docker Compose บนเซิร์ฟเวอร์ระยะไกล

รูปแบบการใช้งานแบบแมนนวลที่ค่อนข้างพบได้ทั่วไป ประกอบด้วยการมีที่เก็บโค้ดบน GitHub, เซิร์ฟเวอร์ Ubuntu ระยะไกลที่มี Docker ติดตั้งอยู่ และเวิร์กโฟลว์ CI/CD (เช่น GitHub Actions) ที่จะดำเนินการดังต่อไปนี้เมื่อคุณพุชไปยังสาขา เช่น development o main:

• เชื่อมต่อกับเซิร์ฟเวอร์ระยะไกลผ่าน SSH
• หยุดและลบคอนเทนเนอร์ที่กำลังทำงานอยู่
• ดาวน์โหลดอิมเมจใหม่จาก Docker Hub (หรือจากรีจิสทรีส่วนตัวของคุณ)
• วิ่ง docker run สำหรับแต่ละบริการ
• ให้ Nginx (หรือโปรแกรมพร็อกซีแบบย้อนกลับที่คุณใช้) ทำการส่งต่อทราฟฟิกไปยังพอร์ตของแต่ละคอนเทนเนอร์

เมื่อคุณเปลี่ยนมาใช้ Docker Compose กระบวนการทำงานง่ายขึ้นมาก เพราะแทนที่จะจัดการคอนเทนเนอร์ทีละตัว คุณสามารถกำหนดสแต็กทั้งหมดของคุณ (ฟรอนต์เอนด์ แบ็กเอนด์ ฐานข้อมูล แคช ฯลฯ) ได้ในคอนเทนเนอร์เดียว docker-compose.ymlโดยมีเครือข่าย ปริมาณ และตัวแปรด้านสิ่งแวดล้อมต่างๆ

วิธีใช้งาน GitHub Actions ที่ง่ายที่สุด (และค่อนข้างพบได้ทั่วไป) ขั้นตอนการทำงานควรดำเนินการดังนี้ cd ไปยังไดเร็กทอรีโครงการบนเซิร์ฟเวอร์ระยะไกล (ที่ซึ่งคุณ docker-compose.yml) และเรียกใช้คำสั่งต่างๆ เช่น:

• docker compose pull เพื่อนำเสนอภาพล่าสุด
• docker compose down เพื่อหยุดและนำภาชนะเก่าออก (อาจใช้ร่วมกับ...) --remove-orphans).
• docker compose up -d --build หากคุณสร้างอิมเมจจากตัวเซิร์ฟเวอร์เอง

วิธีการนี้ได้ผลดีและค่อนข้างแข็งแกร่งหากคุณสามารถควบคุมข้อมูลประจำตัว ตัวแปรสภาพแวดล้อม และวอลุ่มได้อย่างดี คุณสามารถปรับปรุงความปลอดภัยได้โดยการป้องกันไม่ให้ GitHub Actions เข้าถึงเซิร์ฟเวอร์ในฐานะผู้ใช้ root อย่างเต็มรูปแบบ จำกัดคีย์ SSH ใช้ผู้ใช้เฉพาะ หรือแม้กระทั่งเปิดเผย Docker เป็นบริการระยะไกลที่ปลอดภัยพร้อมใบรับรอง แทนที่จะใช้งานทุกอย่างผ่าน SSH

ไม่มี "วิธีมหัศจรรย์" ใดที่ดีไปกว่านี้แล้ว สำหรับสภาพแวดล้อมที่เรียบง่าย: หัวใจสำคัญคือการทำให้เป็นระบบอัตโนมัติและเขียนโปรแกรมให้ดี docker-compose.ymlใช้แท็กรูปภาพที่ไม่สามารถเปลี่ยนแปลงได้ (เช่น เวอร์ชันเฉพาะ) และมีกลไกการย้อนกลับ (เช่น การบันทึกเวอร์ชันก่อนหน้าขององค์ประกอบภาพหรือรูปภาพ)

สภาพแวดล้อมการพัฒนาแบบระยะไกลด้วย Docker, WSL 2 และ VS Code

บนระบบปฏิบัติการ Windows การพัฒนาโปรแกรมด้วย Docker โดยใช้ WSL 2 เป็นเรื่องปกติมากDocker Desktop สำหรับ Windows นำเสนอเอนจินที่ใช้ WSL 2 ซึ่งช่วยให้คุณสามารถเรียกใช้คอนเทนเนอร์ Linux และ Windows จากเครื่องเดียวกันได้ ในขณะที่แก้ไขโค้ดด้วย VS Code และทดสอบในเบราว์เซอร์ในเครื่อง

ขั้นตอนการทำงานทั่วไปสำหรับการตั้งค่าสภาพแวดล้อมการพัฒนาด้วยคอนเทนเนอร์ระยะไกลโดยใช้ WSL 2 คือต่อไปนี้:

1. ติดตั้ง WSL 2 และระบบปฏิบัติการ Linux (เช่น Ubuntu)
2. คุณติดตั้ง Docker Desktop บน Windows และเปิดใช้งานตัวเลือก "ใช้เอ็นจิ้นที่ใช้ WSL 2" ในการตั้งค่า > ทั่วไป
3. ในเมนู การตั้งค่า > ทรัพยากร > การรวม WSL คุณจะเลือกเวอร์ชัน WSL ที่คุณต้องการให้ Docker ทำงานด้วย
4. คุณตรวจสอบการติดตั้งด้วย docker --version และการวิ่ง docker run hello-world ภายในระบบปฏิบัติการ WSL

เพื่อพัฒนา "ภายใน" ภาชนะเหล่านั้น และอย่าใช้ Docker เป็นเพียงแค่เครื่องมือหลัก VS Code ก็สำคัญเช่นกัน ด้วยส่วนขยาย WSL, Dev Containers และ Docker คุณสามารถทำสิ่งต่างๆ ได้ เช่น:

• เปิดโฟลเดอร์โปรเจ็กต์ของคุณที่โฮสต์อยู่ภายใน WSL โดยตรงใน VS Code
• เปิดโฟลเดอร์นั้นอีกครั้ง “ในคอนเทนเนอร์สำหรับการพัฒนา” (Dev Container) โดยใช้ Dockerfile และ devcontainer.json ซึ่งอธิบายถึงสภาพแวดล้อมในอุดมคติของคุณ (เช่น เวอร์ชัน Python, Node.js เป็นต้น)
• ดีบักแอปพลิเคชันของคุณจาก VS Code ขณะที่แอปพลิเคชันกำลังทำงานอยู่ในคอนเทนเนอร์

ตัวอย่างที่พบได้บ่อยมาก วิธีการนี้ใช้ได้กับโปรเจ็กต์ Django หรือ Node.js: คุณโคลน repository ภายใน WSL แล้วเปิดโฟลเดอร์ด้วย code .คุณเลือกคำจำกัดความของ Dev Container (ตัวอย่างเช่น “Python 3”) แล้ว VS Code จะสร้างอิมเมจและเริ่มต้นคอนเทนเนอร์พร้อมกับส่วนประกอบที่จำเป็นทั้งหมด จากนั้น คุณสามารถรัน ดีบัก และตรวจสอบว่าโค้ดทำงานบน Linux ได้ แม้ว่าระบบโฮสต์ของคุณจะเป็น Windows ก็ตาม

วิธีการนี้ยังมีประโยชน์เมื่อเครื่องของคุณมีประสิทธิภาพไม่สูงมากนักเนื่องจากคุณสามารถย้ายภาระงานบางส่วนไปยังเซิร์ฟเวอร์ระยะไกลด้วย Docker และเชื่อมต่อกับเซิร์ฟเวอร์นั้นด้วย VS Code ผ่าน SSH และ Dev Containers ทำให้ทำงานได้เกือบเหมือนอยู่บนเครื่องโลคอล แต่ยังคงอาศัยทรัพยากรของเซิร์ฟเวอร์นั้นอยู่

การติดตั้งใช้งานแอปพลิเคชันบนเซิร์ฟเวอร์คลาวด์ด้วย Docker และ Docker Compose

ตั้งค่าเซิร์ฟเวอร์คลาวด์ด้วย Docker ให้พร้อมใช้งาน โดยทั่วไปแล้ว การติดตั้งจะรวดเร็วมากกับผู้ให้บริการส่วนใหญ่ คุณเพียงแค่เลือกอิมเมจระบบที่มี Docker ติดตั้งไว้ล่วงหน้า รอเพียงไม่กี่นาที เครื่องของคุณก็จะพร้อมรับคอนเทนเนอร์แล้ว

รูปแบบทั่วไปสำหรับการติดตั้งใช้งานแอปพลิเคชัน Node.js อย่างง่าย มันจะเป็นอย่างนี้:

1. สร้างโปรเจ็กต์ Node.js (ตัวอย่างเช่น โปรแกรม "Hello world" ด้วย Express) บนเครื่องคอมพิวเตอร์ของคุณ: โฟลเดอร์โปรเจ็กต์ หรือโฟลเดอร์ย่อย app, npm initการติดตั้งส่วนประกอบที่จำเป็น (เช่น express) และก index.js ซึ่งจะตั้งค่าเซิร์ฟเวอร์บนพอร์ต 3030 พร้อมข้อความพื้นฐาน
2. สร้าง Docker image สำหรับแอปด้วย ไฟล์นักเทียบท่า ซึ่งกำหนดภาพพื้นฐาน (ตัวอย่างเช่น) node:12), WORKDIRคัดลอกไฟล์แอปพลิเคชัน แล้วเรียกใช้งาน npm install และเปิดเผยพอร์ตภายใน
3. เพิ่ม .ด็อกเกอร์เพิกเฉย เพื่อหลีกเลี่ยงการวางสิ่งต่างๆ เช่น node_modules.
4. สร้าง นักเทียบท่า-compose.yml ในไดเร็กทอรีหลักของโปรเจ็กต์ ให้ระบุเวอร์ชัน (ตัวอย่างเช่น 3.8) และกำหนดบริการหลัก buildการแมปพอร์ต (3030:3030) และคำสั่ง (node index).

เมื่อคุณเตรียมโปรเจ็กต์และไฟล์เสียงพร้อมแล้วการติดตั้งบนเซิร์ฟเวอร์ระยะไกลมักมีขั้นตอนดังนี้:

• คุณเชื่อมต่อกับเซิร์ฟเวอร์ผ่านทาง SSH
• คุณสามารถโคลน repository หรืออัปโหลดไฟล์ (Git, SCP, rsync…) ได้
• คุณติดตั้ง นักเทียบท่า-เขียน หากยังไม่มีอยู่ (ในหลายๆ ดิสโทร คุณต้องติดตั้งแยกต่างหากจาก Docker เช่น โดยการดาวน์โหลดไฟล์ไบนารีจาก GitHub และให้สิทธิ์ในการเรียกใช้งาน)
• คุณดำเนินการ docker-compose up (o docker compose up (ขึ้นอยู่กับเวอร์ชัน) เพื่อให้รูปภาพถูกดาวน์โหลด สร้างอิมเมจแอปของคุณ และเริ่มต้นคอนเทนเนอร์

ประเด็นหนึ่งที่มักถูกมองข้ามคือไฟร์วอลล์ของผู้จำหน่ายหากบริการของคุณรับฟังการเชื่อมต่อที่พอร์ต 3030 คุณจะต้องเปิดพอร์ตดังกล่าวในกฎไฟร์วอลล์ หรือสร้างนโยบายเฉพาะและเชื่อมโยงกับเซิร์ฟเวอร์ มิเช่นนั้น คุณจะเห็นข้อความ "การเชื่อมต่อถูกปฏิเสธ" จากภายนอก แม้ว่าคอนเทนเนอร์จะทำงานได้อย่างถูกต้องก็ตาม

เมื่อระบบพร้อมใช้งานแล้ว คุณจะสามารถเข้าถึงแอปพลิเคชันได้ โดยใช้ที่อยู่ IP สาธารณะและพอร์ตที่เปิดเผยของเซิร์ฟเวอร์ (ตัวอย่างเช่น https://IP_DEL_SERVIDOR:3030หรือโดยการซ่อนพอร์ตนั้นไว้หลังพร็อกซีแบบย้อนกลับ เช่น Nginx/Traefik ที่รับฟังพอร์ต 80/443

การจัดการคอนเทนเนอร์ระยะไกลด้วย Plesk และ Docker

หากคุณใช้ Plesk เป็นแผงควบคุมของคุณนอกจากนี้ คุณยังสามารถใช้ส่วนขยาย Docker เพื่อจัดการคอนเทนเนอร์ได้โดยตรงจากเว็บอินเทอร์เฟซ ทั้งบนเซิร์ฟเวอร์เองและบนโฮสต์ Docker ระยะไกล

Plesk รองรับ Docker บนระบบปฏิบัติการหลากหลายประเภทCentOS 7, RHEL 7, Debian 10/11/12, Ubuntu เวอร์ชันต่างๆ (18.04, 20.04, 22.04, 24.04), AlmaLinux 8/9, Rocky Linux 8.x และ Virtuozzo 7 เวอร์ชันอัปเดต ใน Plesk สำหรับ Windows นั้น Docker ไม่ได้ทำงานบนเครื่องโลคอล แต่ทำงานบนเครื่องระยะไกลที่ทำหน้าที่เป็นโฮสต์ของ Docker

มีข้อจำกัดที่สำคัญบางประการที่ควรคำนึงถึง:

• คุณไม่สามารถใช้ส่วนขยาย Docker ได้หาก Plesk ถูกติดตั้งอยู่ภายในคอนเทนเนอร์ Docker
• ในการใช้งานบริการ Docker ระยะไกล (เช่น โฮสต์ภายนอก) คุณต้องมีใบอนุญาตเพิ่มเติมหรือแพ็กเกจเฉพาะ (Hosting Pack, Power Pack, Developer Pack)
• คอนเทนเนอร์ Docker ที่จัดการโดย Plesk นั้นไม่สามารถ "ย้าย" ได้โดยตรง แต่คุณสามารถสำรองข้อมูลที่ใช้ในคอนเทนเนอร์เหล่านั้นได้โดยใช้ Volume หรือ Snapshot

คุณสามารถค้นหารูปภาพได้จากหน้าจอ Plesk ทั้งในที่เก็บข้อมูลภายในเครื่อง (รูปภาพที่ดาวน์โหลดไปยังโฮสต์แล้ว) และใน Docker Hub แผงควบคุมจะแนะนำวิธีการเรียกใช้คอนเทนเนอร์ดังนี้:

1. เยี่ยม Docker > คอนเทนเนอร์ > เรียกใช้คอนเทนเนอร์.
2. ค้นหาอิมเมจที่ต้องการและตรวจสอบเอกสารประกอบบน Docker Hub (ถ้ามี)
3. สามารถเลือกป้ายกำกับ/เวอร์ชันของรูปภาพที่ต้องการได้ (ถ้าต้องการ)
4. กำหนดค่าพารามิเตอร์ของคอนเทนเนอร์ (ตัวแปรสภาพแวดล้อม พอร์ต วอลุ่ม หน่วยความจำ การเริ่มต้นอัตโนมัติ ฯลฯ) แล้วคลิก เรียกใช้

Plesk ยังช่วยให้คุณจัดการการตั้งค่าขั้นสูงได้อีกด้วย สำหรับแต่ละคอนเทนเนอร์: กำหนดพอร์ตใหม่ (อัตโนมัติหรือด้วยตนเอง), ตัดสินใจว่าพอร์ตนั้นสามารถเข้าถึงได้จากอินเทอร์เน็ตหรือเฉพาะจาก localhost เท่านั้น, จำกัดปริมาณ RAM ที่คอนเทนเนอร์สามารถใช้งานได้, กำหนดวอลุ่ม (เส้นทางบนโฮสต์และในคอนเทนเนอร์) หรือเพิ่มตัวแปรสภาพแวดล้อมได้มากเท่าที่คุณต้องการ

ในส่วนของแง่มุมการควบคุมจากระยะไกลPlesk สามารถทำงานร่วมกับ “บริการ Docker ระยะไกล” ได้ ซึ่งเกี่ยวข้องกับการกำหนดค่า Docker daemon บนโฮสต์ระยะไกล (ตัวอย่างเช่น การใช้ /etc/docker/daemon.json (รองรับ TLS และ TCP sockets) สร้างใบรับรอง .pem และลงทะเบียนโฮสต์นั้นใน Plesk จากนั้น Docker > สภาพแวดล้อม > เพิ่มเซิร์ฟเวอร์จากนั้นคุณสามารถกำหนดให้โหนด Docker นั้นเป็นโหนดที่ใช้งานอยู่ และสลับไปมาระหว่างเซิร์ฟเวอร์ต่างๆ ได้จากอินเทอร์เฟซเดียวกัน

ปรับใช้ Docker Compose stack จาก Plesk

หากคุณใช้งาน Docker Compose สำหรับโครงสร้างพื้นฐานของคุณอยู่แล้วคุณอาจสนใจให้ Plesk จัดการการติดตั้ง "สแต็ก" จากไฟล์ต่างๆ docker-compose.yml.

ขั้นตอนการทำงานสำหรับการปรับใช้ Compose ใน Plesk มันค่อนข้างตรงไปตรงมา:

1. ไปลง Docker > Stacks > เพิ่ม Stack.
2. กำหนดชื่อโปรเจ็กต์ให้กับสแต็ก
3. เลือกแหล่งที่มาของไฟล์เขียนข้อความ: ตัวแก้ไข (วางเนื้อหา), อัปโหลดไฟล์จากคอมพิวเตอร์ของคุณ หรือเลือกไฟล์ที่มีอยู่แล้วในพื้นที่เว็บของโดเมน
4. ยืนยันการตั้งค่าและอนุญาตให้ Plesk ประกาศและสร้างคอนเทนเนอร์ที่กำหนดไว้

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

Plesk ยังช่วยอำนวยความสะดวกในการจัดการอิมเมจในเครื่องอีกด้วย: จาก Docker > รูปภาพ คุณสามารถกรอง ตรวจสอบแท็กผลิตภัณฑ์ต่างๆ ดูพื้นที่ที่ใช้ไป และลบรูปภาพที่ล้าสมัยเพื่อเพิ่มพื้นที่ว่างในดิสก์ ซึ่งเป็นสิ่งสำคัญในสภาพแวดล้อมการทำงานระยะไกลที่มีพื้นที่จำกัด

หากคุณใช้ Nginx เป็นเว็บเซิร์ฟเวอร์ฝั่ง front-endPlesk ใช้กฎพร็อกซี (ตัวอย่างเช่น ใน nginx.conf (จากโดเมน) เพื่อกำหนดเส้นทางการรับส่งข้อมูลไปยังคอนเทนเนอร์ Docker ของคุณ แม้ในสถานการณ์ที่อยู่เบื้องหลัง NAT ซึ่งจะช่วยให้คุณไม่ต้องจัดการกับการกำหนดค่าพร็อกซีแบบย้อนกลับบนเซิร์ฟเวอร์ระยะไกลด้วยตนเอง

จัดการคอนเทนเนอร์ระยะไกลด้วย Portainer

Portainer เป็นเว็บอินเทอร์เฟซที่มีน้ำหนักเบา สำหรับ Docker นั้น ช่วยลดความซับซ้อนของงานประจำวันสำหรับผู้ที่ไม่ต้องการใช้งานบรรทัดคำสั่งเป็นประจำ มันทำงานเหมือนคอนเทนเนอร์ และสามารถจัดการโฮสต์ภายในเครื่องหรือโฮสต์ระยะไกลหลายเครื่องได้ (แม้กระทั่งใช้งานร่วมกับ Portainer Agent)

วิธีการติดตั้ง Portainer บนเซิร์ฟเวอร์ของคุณโดยใช้ Docker โดยปกติคุณจะทำตามขั้นตอนพื้นฐานเหล่านี้:

• สร้างวอลุ่มสำหรับข้อมูล Portainer: docker volume create portainer_data.
• เปิดใช้งานคอนเทนเนอร์ Portainer โดยการแมปพอร์ต 8000 และ 9000 และเชื่อมต่อซ็อกเก็ต Docker (/var/run/docker.sock) และปริมาณข้อมูล: docker run -d -p 8000:8000 -p 9000:9000 --name=portainer --restart=always -v /var/run/docker.sock:/var/run/docker.sock -v portainer_data:/data portainer/portainer.

การดำเนินการนี้จะทำให้ Portainer รับฟังการเชื่อมต่อที่พอร์ต 9000 ของเซิร์ฟเวอร์เช่นเคย คุณจะต้องเปิดพอร์ตในไฟร์วอลล์ของคุณหรือเปิดเผยผ่านพร็อกซีแบบ HTTPS ย้อนกลับ ครั้งแรกที่คุณเข้าถึงผ่านเบราว์เซอร์ Portainer จะขอให้คุณสร้างผู้ดูแลระบบ จากนั้นคุณสามารถเลือกได้ว่าจะจัดการ Docker ในเครื่องหรือโฮสต์ระยะไกลเพิ่มเติม

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

เรียกใช้งานแอปพลิเคชันแบบกราฟิกในคอนเทนเนอร์ระยะไกลและเข้าถึงแอปพลิเคชันเหล่านั้นผ่านทางเบราว์เซอร์

เมื่อคอมพิวเตอร์ของคุณมีทรัพยากรเหลือน้อย แต่ถ้าคุณจำเป็นต้องใช้แอปพลิเคชันกราฟิกที่ซับซ้อน (เช่น โปรแกรมอีเมล, IDE หรือเครื่องมือวิศวกรรมย้อนกลับ) วิธีแก้ปัญหาที่น่าสนใจมากคือการเรียกใช้แอปพลิเคชันเหล่านั้นในคอนเทนเนอร์ Docker บนเซิร์ฟเวอร์ที่มีประสิทธิภาพสูงและเข้าถึงผ่านทางเว็บ

กรณีศึกษาที่มีเอกสารหลักฐานครบถ้วนสมบูรณ์ แนวคิดคือการห่อหุ้ม Mozilla Thunderbird ไว้ในคอนเทนเนอร์ เปิดเผยส่วนติดต่อผู้ใช้แบบกราฟิกผ่าน TigerVNC/noVNC และรักษาความปลอดภัยในการเข้าถึงด้วย Caddy แนวคิดนี้สามารถนำไปใช้ซ้ำได้กับแอปพลิเคชัน GUI บน Linux เกือบทุกตัว

โครงสร้างพื้นฐานของคอนเทนเนอร์กราฟิกประเภทนี้โดยทั่วไปประกอบด้วย:

• เซิร์ฟเวอร์ VNC/X11 ขนาดเล็ก (TigerVNC) ที่ทำหน้าที่เป็นเซิร์ฟเวอร์แสดงผล
• โปรแกรมจัดการหน้าต่างแบบเรียบง่าย (OpenBox) สำหรับจัดการหน้าต่างต่างๆ
• เซิร์ฟเวอร์ขนาดเล็กที่ใช้งานง่าย easy-novnc ซึ่งจะเปิดเผย VNC ในรูปแบบของ WebSocket และสร้างหน้า HTML เพื่อเชื่อมต่อจากเบราว์เซอร์
• supervisord หรือวิธีการที่คล้ายกันเพื่อเริ่มต้นและตรวจสอบกระบวนการทั้งหมดภายในคอนเทนเนอร์
• ตัวแอปพลิเคชันเอง (Thunderbird, GIMP เป็นต้น) ที่ตั้งค่าให้แสดงผลบนจอแสดงผลระยะไกล (DISPLAY=:0).

ในทางปฏิบัติ จะมีการตั้งค่าไดเร็กทอรีสำหรับใช้งาน (ตัวอย่างเช่น ~/thunderbird) ณ ตำแหน่งที่วางไว้:

• Un Supervisord.conf ซึ่งกำหนดโปรแกรมที่จะเรียกใช้งาน ได้แก่ TigerVNC, easy-novnc, OpenBox และแอปพลิเคชันหลัก โดยกำหนดลำดับความสำคัญเพื่อให้เซิร์ฟเวอร์กราฟิกเริ่มต้นก่อนแอปพลิเคชัน
• Un menu.xml OpenBox จะกำหนดค่าเมนูเดสก์ท็อป (แอปพลิเคชันหลัก เทอร์มินัล โปรแกรมตรวจสอบกระบวนการทำงานด้วย htop เป็นต้น)
• Un Dockerfile หลายขั้นตอน ซึ่งในขั้นตอนแรกจะทำการคอมไพล์ easy-novnc โดยใช้ Go และในขั้นตอนที่สองจะสร้างอิมเมจสุดท้ายบน Debian โดยติดตั้ง openbox, tigervnc, supervisor, ยูทิลิตี้คอนโซล, แอปพลิเคชัน (Thunderbird ในตัวอย่าง) คัดลอกไบนารีและการกำหนดค่า สร้างผู้ใช้ที่ไม่ใช่ root และกำหนดวอลุ่มข้อมูลถาวรใน /data.

โดยปกติคำสั่งเริ่มต้นของคอนเทนเนอร์จะถูกส่งต่อไปยัง supervisordเริ่มต้นใช้งานเหมือนผู้ใช้ทั่วไปโดยใช้ gosuหลังจากปรับสิทธิ์การเข้าถึงไดรฟ์ข้อมูลแล้ว เมื่อคอนเทนเนอร์เริ่มต้นทำงาน VNC, noVNC, ตัวจัดการหน้าต่าง และแอปพลิเคชันต่างๆ จะถูกเปิดใช้งานโดยอัตโนมัติ และคุณเพียงแค่ต้องเข้าถึงพอร์ต HTTP ที่ easy-novnc เปิดเผยไว้เท่านั้น

เพื่อให้มีความเสถียรและใช้งานง่ายยิ่งขึ้นสำหรับอินเทอร์เน็ตควรติดตั้งเว็บเซิร์ฟเวอร์อย่าง Caddy ไว้ด้านหน้า โดยอยู่ในคอนเทนเนอร์เช่นกัน ซึ่งจะทำหน้าที่เป็นรีเวิร์สพร็อกซีสำหรับแอปพลิเคชันแบบกราฟิกของคุณ เพิ่มการตรวจสอบสิทธิ์ขั้นพื้นฐาน (ชื่อผู้ใช้และรหัสผ่านที่เข้ารหัส) และอาจเปิดใช้งาน WebDAV เพื่อเข้าถึงไฟล์ได้ /data จากเครื่องคอมพิวเตอร์ของคุณ

วางแผนและจัดการโซลูชันด้วยเครือข่าย ปริมาณข้อมูล และ Caddy

เพื่อให้การใช้งานประเภทนี้เป็นระเบียบเรียบร้อย วิธีการทั่วไปคือการสร้างเครือข่าย Docker ของคุณเอง และสร้างวอลุ่มข้อมูลอย่างน้อยหนึ่งวอลุ่ม:

• ตัวอย่างเช่น เครือข่าย thunderbird-netซึ่งจะถูกใช้ร่วมกันโดยคอนเทนเนอร์ที่เกี่ยวข้องทั้งหมด
• ปริมาณ thunderbird-data ซึ่งจะประกอบด้วยข้อมูลโปรไฟล์ผู้ใช้และข้อมูลถาวรของแอปพลิเคชันแบบกราฟิก

คอนเทนเนอร์ของแอปพลิเคชันกราฟิก คุณสามารถเรียกใช้งานได้ด้วยคำสั่งประมาณนี้:

• politica --restart=always เพื่อให้สามารถยืนหยัดได้ด้วยตัวเอง
• การประกอบปริมาตร thunderbird-data:/data.
• การเชื่อมต่อเครือข่าย thunderbird-net.
• ชื่อที่ระบุได้ (thunderbird-app(ตัวอย่างเช่น) ที่ Caddy จะใช้สำหรับพร็อกซีแบบย้อนกลับ

ในไดเร็กทอรีอื่น (ตัวอย่างเช่น ~/caddyภาพลักษณ์ของแคดดี้ถูกสร้างขึ้น พร้อมด้วยโมดูลที่จำเป็น (เช่น ปลั๊กอิน WebDAV) และ Caddyfile ซึ่งกำหนดไว้ว่า:

• เซิร์ฟเวอร์ที่พอร์ต 8080
• Un reverse_proxy ไปยัง thunderbird-app:8080 (หรือพอร์ตที่ noVNC เปิดเผย)
• เส้นทางเพิ่มเติมสำหรับการนำทางผ่านไฟล์ (/files) และสำหรับ WebDAV (/webdav) ทั้งสองส่วนทำหน้าที่รองรับเนื้อหาของปริมาณข้อมูล
• บล็อกของ basicauth ซึ่งจะปกป้องเส้นทางทั้งหมดด้วยชื่อผู้ใช้และรหัสผ่านที่เข้ารหัสซึ่งอ่านจากตัวแปรสภาพแวดล้อม

เมื่อสร้างคอนเทนเนอร์ Caddyมีการประกอบปริมาตรเท่ากัน thunderbird-data:/dataมันเชื่อมต่อกับเครือข่าย thunderbird-net และพอร์ตของมันถูกเผยแพร่ (ตัวอย่างเช่น -p 8080:8080) บนโฮสต์ ด้วยวิธีนี้ คุณเพียงแค่เข้าไปที่เบราว์เซอร์ของคุณ http://IP_DEL_SERVIDOR:8080ป้อนข้อมูลประจำตัวของคุณแล้วคลิกเชื่อมต่อเพื่อเริ่มใช้งานแอปพลิเคชันแบบกราฟิกจากระยะไกล

การบำรุงรักษาในระยะยาวนั้นง่ายเมื่อต้องการอัปเดต คุณสามารถหยุดและลบคอนเทนเนอร์ สร้างอิมเมจใหม่ด้วยเวอร์ชันใหม่ และเริ่มต้นใช้งานอีกครั้งได้ docker run รักษาระดับปริมาณข้อมูล เพื่อให้การตั้งค่าและไฟล์ของผู้ใช้ยังคงอยู่ครบถ้วน

ด้วยส่วนประกอบทั้งหมดเหล่านี้ (Docker Compose, Plesk, Portainer, VS Code, WSL 2, Caddy, noVNC…) เป็นไปได้ที่จะตั้งค่าทุกอย่าง ตั้งแต่การติดตั้งระบบแบ็กเอนด์แบบง่ายๆ ไปจนถึงเดสก์ท็อประยะไกลที่บรรจุอยู่ในคอนเทนเนอร์และสามารถเข้าถึงได้อย่างสมบูรณ์แบบผ่านเบราว์เซอร์ โดยใช้ประโยชน์จากเซิร์ฟเวอร์ที่มีประสิทธิภาพมากกว่าเครื่องของคุณ และยังคงควบคุมเครือข่าย ความปลอดภัย พื้นที่จัดเก็บ และการอัปเดตได้อย่างละเอียด