TL; DR: คู่มือภาพรวมเพื่อเปรียบเทียบเฟรมเวิร์กสำหรับการรันแอปพลิเคชันในคอนเทนเนอร์ จะพิจารณาความสามารถของ Docker และระบบอื่นๆ ที่คล้ายคลึงกัน
ประวัติเล็กๆ น้อยๆ ว่ามันมาจากไหน
เรื่องราว
วิธีแรกที่รู้จักกันดีในการแยกแอปพลิเคชันคือ chroot การเรียกระบบที่มีชื่อเดียวกันช่วยให้แน่ใจว่าไดเร็กทอรีรากมีการเปลี่ยนแปลง - ดังนั้นจึงทำให้มั่นใจได้ว่าโปรแกรมที่เรียกนั้นมีสิทธิ์เข้าถึงเฉพาะไฟล์ภายในไดเร็กทอรีนั้นเท่านั้น แต่หากโปรแกรมได้รับสิทธิ์รูทภายใน โปรแกรมอาจ "หลบหนี" chroot และเข้าถึงระบบปฏิบัติการหลักได้ นอกจากนี้ นอกเหนือจากการเปลี่ยนไดเร็กทอรีรากแล้ว ทรัพยากรอื่นๆ (RAM, โปรเซสเซอร์) รวมถึงการเข้าถึงเครือข่ายก็ไม่จำกัดอีกด้วย
วิธีต่อไปคือการเปิดตัวระบบปฏิบัติการเต็มรูปแบบภายในคอนเทนเนอร์โดยใช้กลไกของเคอร์เนลของระบบปฏิบัติการ วิธีการนี้เรียกว่าแตกต่างกันในระบบปฏิบัติการที่แตกต่างกัน แต่สาระสำคัญเหมือนกัน - เปิดตัวระบบปฏิบัติการอิสระหลายระบบ ซึ่งแต่ละระบบปฏิบัติการรันเคอร์เนลเดียวกันกับที่ระบบปฏิบัติการหลักทำงาน ซึ่งรวมถึง FreeBSD Jails, Solaris Zones, OpenVZ และ LXC สำหรับ Linux การแยกส่วนไม่เพียงทำให้มั่นใจได้จากพื้นที่ดิสก์เท่านั้น แต่ยังรวมถึงทรัพยากรอื่นๆ ด้วย โดยเฉพาะอย่างยิ่ง แต่ละคอนเทนเนอร์อาจมีข้อจำกัดเกี่ยวกับเวลาโปรเซสเซอร์, RAM และแบนด์วิดท์เครือข่าย เมื่อเปรียบเทียบกับ chroot การออกจากคอนเทนเนอร์นั้นยากกว่า เนื่องจาก superuser ในคอนเทนเนอร์สามารถเข้าถึงเฉพาะเนื้อหาของคอนเทนเนอร์เท่านั้น เนื่องจากจำเป็นต้องรักษาระบบปฏิบัติการภายในคอนเทนเนอร์ให้ทันสมัยอยู่เสมอและการใช้เวอร์ชันเก่ากว่า ของเคอร์เนล (เกี่ยวข้องกับ Linux ในระดับที่น้อยกว่า FreeBSD) มีความเป็นไปได้ที่ไม่เป็นศูนย์ที่จะ "เจาะทะลุ" ระบบการแยกเคอร์เนลและเข้าถึงระบบปฏิบัติการหลัก
แทนที่จะเปิดตัวระบบปฏิบัติการเต็มรูปแบบในคอนเทนเนอร์ (ด้วยระบบการเริ่มต้นตัวจัดการแพ็คเกจ ฯลฯ ) คุณสามารถเปิดแอปพลิเคชันได้ทันทีสิ่งสำคัญคือการให้โอกาสแก่แอปพลิเคชันดังกล่าว (การมีไลบรารีที่จำเป็น และไฟล์อื่นๆ) แนวคิดนี้ทำหน้าที่เป็นพื้นฐานสำหรับการจำลองเสมือนของแอปพลิเคชันแบบคอนเทนเนอร์ ซึ่งตัวแทนที่โดดเด่นและเป็นที่รู้จักมากที่สุดคือ Docker เมื่อเปรียบเทียบกับระบบก่อนหน้านี้ กลไกการแยกที่ยืดหยุ่นมากขึ้น ควบคู่ไปกับการรองรับเครือข่ายเสมือนในตัวระหว่างคอนเทนเนอร์และการติดตามสถานะแอปพลิเคชันภายในคอนเทนเนอร์ ส่งผลให้สามารถสร้างสภาพแวดล้อมที่สอดคล้องกันเดียวจากเซิร์ฟเวอร์กายภาพจำนวนมากสำหรับการรันคอนเทนเนอร์ - โดยไม่จำเป็นต้องจัดการทรัพยากรด้วยตนเอง
นักเทียบท่า
Docker เป็นซอฟต์แวร์คอนเทนเนอร์แอปพลิเคชันที่มีชื่อเสียงที่สุด เขียนในภาษา Go โดยจะใช้คุณสมบัติมาตรฐานของเคอร์เนล Linux - กลุ่ม c, เนมสเปซ, ความสามารถ ฯลฯ รวมถึงระบบไฟล์ Aufs และอื่นๆ ที่คล้ายกันเพื่อประหยัดพื้นที่ดิสก์
ที่มา: วิกิมีเดีย
สถาปัตยกรรม
ก่อนเวอร์ชัน 1.11 Docker ทำงานเป็นบริการเดียวที่ดำเนินการทั้งหมดกับคอนเทนเนอร์: การดาวน์โหลดรูปภาพสำหรับคอนเทนเนอร์ การเปิดใช้คอนเทนเนอร์ การประมวลผลคำขอ API เริ่มต้นด้วยเวอร์ชัน 1.11 Docker ถูกแบ่งออกเป็นหลายส่วนที่โต้ตอบซึ่งกันและกัน: คอนเทนเนอร์สำหรับการประมวลผลวงจรชีวิตทั้งหมดของคอนเทนเนอร์ (การจัดสรรพื้นที่ดิสก์ การดาวน์โหลดรูปภาพ การทำงานร่วมกับเครือข่าย การเปิดตัว การติดตั้งและการตรวจสอบสถานะของคอนเทนเนอร์) และ runC ซึ่งเป็นสภาพแวดล้อมการดำเนินการคอนเทนเนอร์ โดยอิงตามการใช้ cgroups และคุณสมบัติอื่นๆ ของเคอร์เนล Linux บริการนักเทียบท่ายังคงอยู่ แต่ตอนนี้ให้บริการเฉพาะเพื่อประมวลผลคำขอ API ที่แปลเป็นคอนเทนเนอร์เท่านั้น
การติดตั้งและการกำหนดค่า
วิธีที่ฉันชื่นชอบในการติดตั้ง docker คือ docker-machine ซึ่งนอกเหนือจากการติดตั้งและกำหนดค่า docker โดยตรงบนเซิร์ฟเวอร์ระยะไกล (รวมถึงคลาวด์ต่างๆ) ทำให้สามารถทำงานกับระบบไฟล์ของเซิร์ฟเวอร์ระยะไกลและยังสามารถเรียกใช้คำสั่งต่างๆ ได้อีกด้วย
อย่างไรก็ตาม ตั้งแต่ปี 2018 โปรเจ็กต์นี้แทบจะไม่ได้รับการพัฒนาเลย ดังนั้นเราจะติดตั้งด้วยวิธีมาตรฐานสำหรับลีนุกซ์ส่วนใหญ่ - เพิ่มพื้นที่เก็บข้อมูลและติดตั้งแพ็คเกจที่จำเป็น
วิธีนี้ยังใช้สำหรับการติดตั้งอัตโนมัติด้วย เช่น การใช้ Ansible หรือระบบอื่นที่คล้ายคลึงกัน แต่ฉันจะไม่พิจารณาในบทความนี้
การติดตั้งจะดำเนินการบน Centos 7 ฉันจะใช้เครื่องเสมือนเป็นเซิร์ฟเวอร์ เพื่อติดตั้ง เพียงรันคำสั่งด้านล่าง:
# yum install -y yum-utils
# yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
# yum install docker-ce docker-ce-cli containerd.io
หลังจากการติดตั้ง คุณจะต้องเริ่มบริการและเริ่มต้น:
# systemctl enable docker
# systemctl start docker
# firewall-cmd --zone=public --add-port=2377/tcp --permanent
นอกจากนี้ คุณสามารถสร้างกลุ่มนักเทียบท่า ซึ่งผู้ใช้จะสามารถทำงานกับนักเทียบท่าได้โดยไม่ต้องใช้ sudo ตั้งค่าการบันทึก เปิดใช้งานการเข้าถึง API จากภายนอก และอย่าลืมกำหนดค่าไฟร์วอลล์ให้แม่นยำยิ่งขึ้น (ทุกสิ่งที่ไม่ได้รับอนุญาต เป็นสิ่งต้องห้ามในตัวอย่างด้านบนและด้านล่าง - ฉันละเว้นสิ่งนี้เพื่อความเรียบง่ายและชัดเจน) แต่ฉันจะไม่ลงรายละเอียดเพิ่มเติมที่นี่
คุณสมบัติอื่น ๆ
นอกจากเครื่องนักเทียบท่าที่กล่าวมาข้างต้นแล้ว ยังมีรีจิสทรีนักเทียบท่าซึ่งเป็นเครื่องมือสำหรับจัดเก็บรูปภาพสำหรับคอนเทนเนอร์ เช่นเดียวกับนักเทียบท่าเขียน ซึ่งเป็นเครื่องมือสำหรับการปรับใช้แอปพลิเคชันในคอนเทนเนอร์โดยอัตโนมัติ ไฟล์ YAML ใช้ในการสร้างและกำหนดค่าคอนเทนเนอร์ และสิ่งอื่นๆ ที่เกี่ยวข้อง (เช่น เครือข่าย ระบบไฟล์ถาวรสำหรับจัดเก็บข้อมูล)
นอกจากนี้ยังสามารถใช้เพื่อจัดระเบียบสายพานลำเลียงสำหรับ CICD ได้อีกด้วย คุณสมบัติที่น่าสนใจอีกประการหนึ่งคือการทำงานในโหมดคลัสเตอร์หรือที่เรียกว่าโหมดฝูง (ก่อนเวอร์ชัน 1.12 จะเรียกว่ากลุ่มนักเทียบท่า) ซึ่งช่วยให้คุณสามารถรวบรวมโครงสร้างพื้นฐานเดียวจากเซิร์ฟเวอร์หลายตัวเพื่อใช้งานคอนเทนเนอร์ มีการรองรับเครือข่ายเสมือนที่ด้านบนของเซิร์ฟเวอร์ทั้งหมด มีโหลดบาลานเซอร์ในตัว เช่นเดียวกับการรองรับความลับสำหรับคอนเทนเนอร์
ไฟล์ YAML จากนักเทียบท่าเขียนพร้อมการแก้ไขเล็กน้อยสามารถใช้สำหรับคลัสเตอร์ดังกล่าวทำให้การบำรุงรักษาคลัสเตอร์ขนาดเล็กและขนาดกลางอัตโนมัติโดยสมบูรณ์เพื่อวัตถุประสงค์ต่างๆ สำหรับคลัสเตอร์ขนาดใหญ่ Kubernetes เป็นตัวเลือกที่ดีกว่า เนื่องจากค่าบำรุงรักษาของโหมด Swarm อาจสูงกว่า Kubernetes ได้ นอกจาก runC แล้ว คุณยังสามารถติดตั้ง เช่น เป็นสภาพแวดล้อมการดำเนินการคอนเทนเนอร์ได้
การทำงานร่วมกับนักเทียบท่า
หลังจากการติดตั้งและกำหนดค่า เราจะพยายามรวบรวมคลัสเตอร์โดยเราจะปรับใช้ GitLab และ Docker Registry สำหรับทีมพัฒนา ฉันจะใช้เครื่องเสมือนสามเครื่องเป็นเซิร์ฟเวอร์ ซึ่งฉันจะปรับใช้ FS GlusterFS แบบกระจายเพิ่มเติม ฉันจะใช้เป็นที่จัดเก็บวอลุ่มนักเทียบท่า เพื่อเรียกใช้รีจิสทรีนักเทียบท่าเวอร์ชันที่ทนทานต่อข้อผิดพลาด ส่วนประกอบสำคัญในการรัน: Docker Registry, Postgresql, Redis, GitLab พร้อมรองรับ GitLab Runner ที่ด้านบนของ Swarm เราจะเปิดตัว Postgresql พร้อมการทำคลัสเตอร์
หากต้องการปรับใช้ GlusterFS บนเซิร์ฟเวอร์ทั้งหมด (เรียกว่า node1, node2, node3) คุณจะต้องติดตั้งแพ็คเกจ เปิดใช้งานไฟร์วอลล์ และสร้างไดเร็กทอรีที่จำเป็น:
# yum -y install centos-release-gluster7
# yum -y install glusterfs-server
# systemctl enable glusterd
# systemctl start glusterd
# firewall-cmd --add-service=glusterfs --permanent
# firewall-cmd --reload
# mkdir -p /srv/gluster
# mkdir -p /srv/docker
# echo "$(hostname):/docker /srv/docker glusterfs defaults,_netdev 0 0" >> /etc/fstab
หลังการติดตั้ง งานในการกำหนดค่า GlusterFS จะต้องดำเนินการต่อจากโหนดเดียว เช่น node1:
# gluster peer probe node2
# gluster peer probe node3
# gluster volume create docker replica 3 node1:/srv/gluster node2:/srv/gluster node3:/srv/gluster force
# gluster volume start docker
จากนั้นคุณจะต้องเมานต์โวลุ่มผลลัพธ์ (คำสั่งจะต้องดำเนินการบนเซิร์ฟเวอร์ทั้งหมด):
# mount /srv/docker
โหมดฝูงได้รับการกำหนดค่าบนเซิร์ฟเวอร์ตัวใดตัวหนึ่ง ซึ่งจะเป็นผู้นำ ส่วนที่เหลือจะต้องเข้าร่วมคลัสเตอร์ ดังนั้นผลลัพธ์ของการดำเนินการคำสั่งบนเซิร์ฟเวอร์แรกจะต้องถูกคัดลอกและดำเนินการกับเซิร์ฟเวอร์อื่น
การตั้งค่าคลัสเตอร์เริ่มต้น ฉันรันคำสั่งบน node1:
# docker swarm init
Swarm initialized: current node (a5jpfrh5uvo7svzz1ajduokyq) is now a manager.
To add a worker to this swarm, run the following command:
docker swarm join --token SWMTKN-1-0c5mf7mvzc7o7vjk0wngno2dy70xs95tovfxbv4tqt9280toku-863hyosdlzvd76trfptd4xnzd xx.xx.xx.xx:2377
To add a manager to this swarm, run 'docker swarm join-token manager' and follow the instructions.
# docker swarm join-token manager
เราคัดลอกผลลัพธ์ของคำสั่งที่สองและดำเนินการบน node2 และ node3:
# docker swarm join --token SWMTKN-x-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx-xxxxxxxxx xx.xx.xx.xx:2377
This node joined a swarm as a manager.
ณ จุดนี้ การกำหนดค่าเบื้องต้นของเซิร์ฟเวอร์เสร็จสมบูรณ์ เรามาดำเนินการตั้งค่าบริการกันดีกว่า คำสั่งที่จะดำเนินการจะถูกเรียกใช้จาก node1 เว้นแต่จะระบุไว้เป็นอย่างอื่น
ก่อนอื่น มาสร้างเครือข่ายสำหรับคอนเทนเนอร์กันก่อน:
# docker network create --driver=overlay etcd
# docker network create --driver=overlay pgsql
# docker network create --driver=overlay redis
# docker network create --driver=overlay traefik
# docker network create --driver=overlay gitlab
จากนั้นเราทำเครื่องหมายเซิร์ฟเวอร์ซึ่งจำเป็นในการผูกบริการบางอย่างเข้ากับเซิร์ฟเวอร์:
# docker node update --label-add nodename=node1 node1
# docker node update --label-add nodename=node2 node2
# docker node update --label-add nodename=node3 node3
ต่อไป เราจะสร้างไดเร็กทอรีสำหรับจัดเก็บข้อมูล ฯลฯ พื้นที่จัดเก็บ KV ซึ่งจำเป็นสำหรับ Traefik และ Stolon เช่นเดียวกับ Postgresql สิ่งเหล่านี้จะเป็นคอนเทนเนอร์ที่เชื่อมโยงกับเซิร์ฟเวอร์ ดังนั้นเราจึงรันคำสั่งนี้บนเซิร์ฟเวอร์ทั้งหมด:
# mkdir -p /srv/etcd
จากนั้นสร้างไฟล์เพื่อกำหนดค่า ฯลฯ และใช้งาน:
00etcd.yml
version: '3.7'
services:
etcd1:
image: quay.io/coreos/etcd:latest
hostname: etcd1
command:
- etcd
- --name=etcd1
- --data-dir=/data.etcd
- --advertise-client-urls=http://etcd1:2379
- --listen-client-urls=http://0.0.0.0:2379
- --initial-advertise-peer-urls=http://etcd1:2380
- --listen-peer-urls=http://0.0.0.0:2380
- --initial-cluster=etcd1=http://etcd1:2380,etcd2=http://etcd2:2380,etcd3=http://etcd3:2380
- --initial-cluster-state=new
- --initial-cluster-token=etcd-cluster
networks:
- etcd
volumes:
- etcd1vol:/data.etcd
deploy:
replicas: 1
placement:
constraints: [node.labels.nodename == node1]
etcd2:
image: quay.io/coreos/etcd:latest
hostname: etcd2
command:
- etcd
- --name=etcd2
- --data-dir=/data.etcd
- --advertise-client-urls=http://etcd2:2379
- --listen-client-urls=http://0.0.0.0:2379
- --initial-advertise-peer-urls=http://etcd2:2380
- --listen-peer-urls=http://0.0.0.0:2380
- --initial-cluster=etcd1=http://etcd1:2380,etcd2=http://etcd2:2380,etcd3=http://etcd3:2380
- --initial-cluster-state=new
- --initial-cluster-token=etcd-cluster
networks:
- etcd
volumes:
- etcd2vol:/data.etcd
deploy:
replicas: 1
placement:
constraints: [node.labels.nodename == node2]
etcd3:
image: quay.io/coreos/etcd:latest
hostname: etcd3
command:
- etcd
- --name=etcd3
- --data-dir=/data.etcd
- --advertise-client-urls=http://etcd3:2379
- --listen-client-urls=http://0.0.0.0:2379
- --initial-advertise-peer-urls=http://etcd3:2380
- --listen-peer-urls=http://0.0.0.0:2380
- --initial-cluster=etcd1=http://etcd1:2380,etcd2=http://etcd2:2380,etcd3=http://etcd3:2380
- --initial-cluster-state=new
- --initial-cluster-token=etcd-cluster
networks:
- etcd
volumes:
- etcd3vol:/data.etcd
deploy:
replicas: 1
placement:
constraints: [node.labels.nodename == node3]
volumes:
etcd1vol:
driver: local
driver_opts:
type: none
o: bind
device: "/srv/etcd"
etcd2vol:
driver: local
driver_opts:
type: none
o: bind
device: "/srv/etcd"
etcd3vol:
driver: local
driver_opts:
type: none
o: bind
device: "/srv/etcd"
networks:
etcd:
external: true
# docker stack deploy --compose-file 00etcd.yml etcd
หลังจากนั้นสักระยะหนึ่ง เราจะตรวจสอบว่าคลัสเตอร์ etcd พร้อมใช้งานแล้ว:
# docker exec $(docker ps | awk '/etcd/ {print $1}') etcdctl member list
ade526d28b1f92f7: name=etcd1 peerURLs=http://etcd1:2380 clientURLs=http://etcd1:2379 isLeader=false
bd388e7810915853: name=etcd3 peerURLs=http://etcd3:2380 clientURLs=http://etcd3:2379 isLeader=false
d282ac2ce600c1ce: name=etcd2 peerURLs=http://etcd2:2380 clientURLs=http://etcd2:2379 isLeader=true
# docker exec $(docker ps | awk '/etcd/ {print $1}') etcdctl cluster-health
member ade526d28b1f92f7 is healthy: got healthy result from http://etcd1:2379
member bd388e7810915853 is healthy: got healthy result from http://etcd3:2379
member d282ac2ce600c1ce is healthy: got healthy result from http://etcd2:2379
cluster is healthy
เราสร้างไดเร็กทอรีสำหรับ Postgresql รันคำสั่งบนเซิร์ฟเวอร์ทั้งหมด:
# mkdir -p /srv/pgsql
จากนั้นสร้างไฟล์เพื่อกำหนดค่า Postgresql:
01pgsql.yml
version: '3.7'
services:
pgsentinel:
image: sorintlab/stolon:master-pg10
command:
- gosu
- stolon
- stolon-sentinel
- --cluster-name=stolon-cluster
- --store-backend=etcdv3
- --store-endpoints=http://etcd1:2379,http://etcd2:2379,http://etcd3:2379
- --log-level=debug
networks:
- etcd
- pgsql
deploy:
replicas: 3
update_config:
parallelism: 1
delay: 30s
order: stop-first
failure_action: pause
pgkeeper1:
image: sorintlab/stolon:master-pg10
hostname: pgkeeper1
command:
- gosu
- stolon
- stolon-keeper
- --pg-listen-address=pgkeeper1
- --pg-repl-username=replica
- --uid=pgkeeper1
- --pg-su-username=postgres
- --pg-su-passwordfile=/run/secrets/pgsql
- --pg-repl-passwordfile=/run/secrets/pgsql_repl
- --data-dir=/var/lib/postgresql/data
- --cluster-name=stolon-cluster
- --store-backend=etcdv3
- --store-endpoints=http://etcd1:2379,http://etcd2:2379,http://etcd3:2379
networks:
- etcd
- pgsql
environment:
- PGDATA=/var/lib/postgresql/data
volumes:
- pgkeeper1:/var/lib/postgresql/data
secrets:
- pgsql
- pgsql_repl
deploy:
replicas: 1
placement:
constraints: [node.labels.nodename == node1]
pgkeeper2:
image: sorintlab/stolon:master-pg10
hostname: pgkeeper2
command:
- gosu
- stolon
- stolon-keeper
- --pg-listen-address=pgkeeper2
- --pg-repl-username=replica
- --uid=pgkeeper2
- --pg-su-username=postgres
- --pg-su-passwordfile=/run/secrets/pgsql
- --pg-repl-passwordfile=/run/secrets/pgsql_repl
- --data-dir=/var/lib/postgresql/data
- --cluster-name=stolon-cluster
- --store-backend=etcdv3
- --store-endpoints=http://etcd1:2379,http://etcd2:2379,http://etcd3:2379
networks:
- etcd
- pgsql
environment:
- PGDATA=/var/lib/postgresql/data
volumes:
- pgkeeper2:/var/lib/postgresql/data
secrets:
- pgsql
- pgsql_repl
deploy:
replicas: 1
placement:
constraints: [node.labels.nodename == node2]
pgkeeper3:
image: sorintlab/stolon:master-pg10
hostname: pgkeeper3
command:
- gosu
- stolon
- stolon-keeper
- --pg-listen-address=pgkeeper3
- --pg-repl-username=replica
- --uid=pgkeeper3
- --pg-su-username=postgres
- --pg-su-passwordfile=/run/secrets/pgsql
- --pg-repl-passwordfile=/run/secrets/pgsql_repl
- --data-dir=/var/lib/postgresql/data
- --cluster-name=stolon-cluster
- --store-backend=etcdv3
- --store-endpoints=http://etcd1:2379,http://etcd2:2379,http://etcd3:2379
networks:
- etcd
- pgsql
environment:
- PGDATA=/var/lib/postgresql/data
volumes:
- pgkeeper3:/var/lib/postgresql/data
secrets:
- pgsql
- pgsql_repl
deploy:
replicas: 1
placement:
constraints: [node.labels.nodename == node3]
postgresql:
image: sorintlab/stolon:master-pg10
command: gosu stolon stolon-proxy --listen-address 0.0.0.0 --cluster-name stolon-cluster --store-backend=etcdv3 --store-endpoints http://etcd1:2379,http://etcd2:2379,http://etcd3:2379
networks:
- etcd
- pgsql
deploy:
replicas: 3
update_config:
parallelism: 1
delay: 30s
order: stop-first
failure_action: rollback
volumes:
pgkeeper1:
driver: local
driver_opts:
type: none
o: bind
device: "/srv/pgsql"
pgkeeper2:
driver: local
driver_opts:
type: none
o: bind
device: "/srv/pgsql"
pgkeeper3:
driver: local
driver_opts:
type: none
o: bind
device: "/srv/pgsql"
secrets:
pgsql:
file: "/srv/docker/postgres"
pgsql_repl:
file: "/srv/docker/replica"
networks:
etcd:
external: true
pgsql:
external: true
เราสร้างความลับและใช้ไฟล์:
# </dev/urandom tr -dc 234567890qwertyuopasdfghjkzxcvbnmQWERTYUPASDFGHKLZXCVBNM | head -c $(((RANDOM%3)+15)) > /srv/docker/replica
# </dev/urandom tr -dc 234567890qwertyuopasdfghjkzxcvbnmQWERTYUPASDFGHKLZXCVBNM | head -c $(((RANDOM%3)+15)) > /srv/docker/postgres
# docker stack deploy --compose-file 01pgsql.yml pgsql
หลังจากนั้นครู่หนึ่ง (ดูผลลัพธ์ของคำสั่ง บริการนักเทียบท่า lsบริการทั้งหมดพร้อมใช้งาน) เราเริ่มต้นคลัสเตอร์ Postgresql:
# docker exec $(docker ps | awk '/pgkeeper/ {print $1}') stolonctl --cluster-name=stolon-cluster --store-backend=etcdv3 --store-endpoints=http://etcd1:2379,http://etcd2:2379,http://etcd3:2379 init
การตรวจสอบความพร้อมของคลัสเตอร์ Postgresql:
# docker exec $(docker ps | awk '/pgkeeper/ {print $1}') stolonctl --cluster-name=stolon-cluster --store-backend=etcdv3 --store-endpoints=http://etcd1:2379,http://etcd2:2379,http://etcd3:2379 status
=== Active sentinels ===
ID LEADER
26baa11d false
74e98768 false
a8cb002b true
=== Active proxies ===
ID
4d233826
9f562f3b
b0c79ff1
=== Keepers ===
UID HEALTHY PG LISTENADDRESS PG HEALTHY PG WANTEDGENERATION PG CURRENTGENERATION
pgkeeper1 true pgkeeper1:5432 true 2 2
pgkeeper2 true pgkeeper2:5432 true 2 2
pgkeeper3 true pgkeeper3:5432 true 3 3
=== Cluster Info ===
Master Keeper: pgkeeper3
===== Keepers/DB tree =====
pgkeeper3 (master)
├─pgkeeper2
└─pgkeeper1
เรากำหนดค่า traefik เพื่อเปิดการเข้าถึงคอนเทนเนอร์จากภายนอก:
03traefik.yml
version: '3.7'
services:
traefik:
image: traefik:latest
command: >
--log.level=INFO
--providers.docker=true
--entryPoints.web.address=:80
--providers.providersThrottleDuration=2
--providers.docker.watch=true
--providers.docker.swarmMode=true
--providers.docker.swarmModeRefreshSeconds=15s
--providers.docker.exposedbydefault=false
--accessLog.bufferingSize=0
--api=true
--api.dashboard=true
--api.insecure=true
networks:
- traefik
ports:
- 80:80
volumes:
- /var/run/docker.sock:/var/run/docker.sock
deploy:
replicas: 3
placement:
constraints:
- node.role == manager
preferences:
- spread: node.id
labels:
- traefik.enable=true
- traefik.http.routers.traefik.rule=Host(`traefik.example.com`)
- traefik.http.services.traefik.loadbalancer.server.port=8080
- traefik.docker.network=traefik
networks:
traefik:
external: true
# docker stack deploy --compose-file 03traefik.yml traefik
เราเปิดตัว Redis Cluster เพื่อดำเนินการนี้ เราจึงสร้างไดเร็กทอรีพื้นที่เก็บข้อมูลบนโหนดทั้งหมด:
# mkdir -p /srv/redis
05redis.yml
version: '3.7'
services:
redis-master:
image: 'bitnami/redis:latest'
networks:
- redis
ports:
- '6379:6379'
environment:
- REDIS_REPLICATION_MODE=master
- REDIS_PASSWORD=xxxxxxxxxxx
deploy:
mode: global
restart_policy:
condition: any
volumes:
- 'redis:/opt/bitnami/redis/etc/'
redis-replica:
image: 'bitnami/redis:latest'
networks:
- redis
ports:
- '6379'
depends_on:
- redis-master
environment:
- REDIS_REPLICATION_MODE=slave
- REDIS_MASTER_HOST=redis-master
- REDIS_MASTER_PORT_NUMBER=6379
- REDIS_MASTER_PASSWORD=xxxxxxxxxxx
- REDIS_PASSWORD=xxxxxxxxxxx
deploy:
mode: replicated
replicas: 3
update_config:
parallelism: 1
delay: 10s
restart_policy:
condition: any
redis-sentinel:
image: 'bitnami/redis:latest'
networks:
- redis
ports:
- '16379'
depends_on:
- redis-master
- redis-replica
entrypoint: |
bash -c 'bash -s <<EOF
"/bin/bash" -c "cat <<EOF > /opt/bitnami/redis/etc/sentinel.conf
port 16379
dir /tmp
sentinel monitor master-node redis-master 6379 2
sentinel down-after-milliseconds master-node 5000
sentinel parallel-syncs master-node 1
sentinel failover-timeout master-node 5000
sentinel auth-pass master-node xxxxxxxxxxx
sentinel announce-ip redis-sentinel
sentinel announce-port 16379
EOF"
"/bin/bash" -c "redis-sentinel /opt/bitnami/redis/etc/sentinel.conf"
EOF'
deploy:
mode: global
restart_policy:
condition: any
volumes:
redis:
driver: local
driver_opts:
type: 'none'
o: 'bind'
device: "/srv/redis"
networks:
redis:
external: true
# docker stack deploy --compose-file 05redis.yml redis
เพิ่มรีจิสทรีนักเทียบท่า:
06registry.yml
version: '3.7'
services:
registry:
image: registry:2.6
networks:
- traefik
volumes:
- registry_data:/var/lib/registry
deploy:
replicas: 1
placement:
constraints: [node.role == manager]
restart_policy:
condition: on-failure
labels:
- traefik.enable=true
- traefik.http.routers.registry.rule=Host(`registry.example.com`)
- traefik.http.services.registry.loadbalancer.server.port=5000
- traefik.docker.network=traefik
volumes:
registry_data:
driver: local
driver_opts:
type: none
o: bind
device: "/srv/docker/registry"
networks:
traefik:
external: true
# mkdir /srv/docker/registry
# docker stack deploy --compose-file 06registry.yml registry
และสุดท้าย - GitLab:
08gitlab-runner.yml
version: '3.7'
services:
gitlab:
image: gitlab/gitlab-ce:latest
networks:
- pgsql
- redis
- traefik
- gitlab
ports:
- 22222:22
environment:
GITLAB_OMNIBUS_CONFIG: |
postgresql['enable'] = false
redis['enable'] = false
gitlab_rails['registry_enabled'] = false
gitlab_rails['db_username'] = "gitlab"
gitlab_rails['db_password'] = "XXXXXXXXXXX"
gitlab_rails['db_host'] = "postgresql"
gitlab_rails['db_port'] = "5432"
gitlab_rails['db_database'] = "gitlab"
gitlab_rails['db_adapter'] = 'postgresql'
gitlab_rails['db_encoding'] = 'utf8'
gitlab_rails['redis_host'] = 'redis-master'
gitlab_rails['redis_port'] = '6379'
gitlab_rails['redis_password'] = 'xxxxxxxxxxx'
gitlab_rails['smtp_enable'] = true
gitlab_rails['smtp_address'] = "smtp.yandex.ru"
gitlab_rails['smtp_port'] = 465
gitlab_rails['smtp_user_name'] = "[email protected]"
gitlab_rails['smtp_password'] = "xxxxxxxxx"
gitlab_rails['smtp_domain'] = "example.com"
gitlab_rails['gitlab_email_from'] = '[email protected]'
gitlab_rails['smtp_authentication'] = "login"
gitlab_rails['smtp_tls'] = true
gitlab_rails['smtp_enable_starttls_auto'] = true
gitlab_rails['smtp_openssl_verify_mode'] = 'peer'
external_url 'http://gitlab.example.com/'
gitlab_rails['gitlab_shell_ssh_port'] = 22222
volumes:
- gitlab_conf:/etc/gitlab
- gitlab_logs:/var/log/gitlab
- gitlab_data:/var/opt/gitlab
deploy:
mode: replicated
replicas: 1
placement:
constraints:
- node.role == manager
labels:
- traefik.enable=true
- traefik.http.routers.gitlab.rule=Host(`gitlab.example.com`)
- traefik.http.services.gitlab.loadbalancer.server.port=80
- traefik.docker.network=traefik
gitlab-runner:
image: gitlab/gitlab-runner:latest
networks:
- gitlab
volumes:
- gitlab_runner_conf:/etc/gitlab
- /var/run/docker.sock:/var/run/docker.sock
deploy:
mode: replicated
replicas: 1
placement:
constraints:
- node.role == manager
volumes:
gitlab_conf:
driver: local
driver_opts:
type: none
o: bind
device: "/srv/docker/gitlab/conf"
gitlab_logs:
driver: local
driver_opts:
type: none
o: bind
device: "/srv/docker/gitlab/logs"
gitlab_data:
driver: local
driver_opts:
type: none
o: bind
device: "/srv/docker/gitlab/data"
gitlab_runner_conf:
driver: local
driver_opts:
type: none
o: bind
device: "/srv/docker/gitlab/runner"
networks:
pgsql:
external: true
redis:
external: true
traefik:
external: true
gitlab:
external: true
# mkdir -p /srv/docker/gitlab/conf
# mkdir -p /srv/docker/gitlab/logs
# mkdir -p /srv/docker/gitlab/data
# mkdir -p /srv/docker/gitlab/runner
# docker stack deploy --compose-file 08gitlab-runner.yml gitlab
สถานะสุดท้ายของคลัสเตอร์และบริการ:
# docker service ls
ID NAME MODE REPLICAS IMAGE PORTS
lef9n3m92buq etcd_etcd1 replicated 1/1 quay.io/coreos/etcd:latest
ij6uyyo792x5 etcd_etcd2 replicated 1/1 quay.io/coreos/etcd:latest
fqttqpjgp6pp etcd_etcd3 replicated 1/1 quay.io/coreos/etcd:latest
hq5iyga28w33 gitlab_gitlab replicated 1/1 gitlab/gitlab-ce:latest *:22222->22/tcp
dt7s6vs0q4qc gitlab_gitlab-runner replicated 1/1 gitlab/gitlab-runner:latest
k7uoezno0h9n pgsql_pgkeeper1 replicated 1/1 sorintlab/stolon:master-pg10
cnrwul4r4nse pgsql_pgkeeper2 replicated 1/1 sorintlab/stolon:master-pg10
frflfnpty7tr pgsql_pgkeeper3 replicated 1/1 sorintlab/stolon:master-pg10
x7pqqchi52kq pgsql_pgsentinel replicated 3/3 sorintlab/stolon:master-pg10
mwu2wl8fti4r pgsql_postgresql replicated 3/3 sorintlab/stolon:master-pg10
9hkbe2vksbzb redis_redis-master global 3/3 bitnami/redis:latest *:6379->6379/tcp
l88zn8cla7dc redis_redis-replica replicated 3/3 bitnami/redis:latest *:30003->6379/tcp
1utp309xfmsy redis_redis-sentinel global 3/3 bitnami/redis:latest *:30002->16379/tcp
oteb824ylhyp registry_registry replicated 1/1 registry:2.6
qovrah8nzzu8 traefik_traefik replicated 3/3 traefik:latest *:80->80/tcp, *:443->443/tcp
มีอะไรอีกที่สามารถปรับปรุงได้? อย่าลืมกำหนดค่า Traefik ให้เรียกใช้คอนเทนเนอร์ผ่าน https เพิ่มการเข้ารหัส tls สำหรับ Postgresql และ Redis แต่โดยทั่วไปแล้ว นักพัฒนาสามารถมอบ PoC ให้กับนักพัฒนาได้แล้ว ตอนนี้เรามาดูทางเลือกอื่นแทน Docker
พอดแมน
เอ็นจิ้นที่รู้จักกันดีอีกตัวหนึ่งสำหรับการรันคอนเทนเนอร์ที่จัดกลุ่มตามพ็อด (พ็อด กลุ่มของคอนเทนเนอร์ที่ใช้งานร่วมกัน) ต่างจาก Docker ตรงที่ไม่ต้องใช้บริการใดๆ ในการรันคอนเทนเนอร์ งานทั้งหมดเสร็จสิ้นผ่านไลบรารี libpod เขียนด้วยภาษา Go เช่นกัน ต้องใช้รันไทม์ที่เข้ากันได้กับ OCI เพื่อรันคอนเทนเนอร์ เช่น runC
โดยทั่วไปแล้ว การทำงานกับ Podman นั้นชวนให้นึกถึงสิ่งนั้นสำหรับ Docker จนถึงจุดที่คุณสามารถทำได้เช่นนี้ (ดังที่หลายคนได้ลองใช้แล้ว รวมถึงผู้เขียนบทความนี้ด้วย):
$ alias docker=podman
และคุณสามารถทำงานต่อไปได้ โดยทั่วไปสถานการณ์ของ Podman นั้นน่าสนใจมากเพราะหาก Kubernetes เวอร์ชันก่อนหน้าทำงานร่วมกับ Docker ประมาณปี 2015 หลังจากการสร้างมาตรฐานของโลกของคอนเทนเนอร์ (OCI - Open Container Initiative) และการแบ่ง Docker ออกเป็นคอนเทนเนอร์และ runC ทางเลือกอื่นสำหรับ Docker สำหรับการทำงานใน Kubernetes ได้รับการพัฒนา: CRI-O Podman ในเรื่องนี้เป็นอีกทางเลือกหนึ่งของ Docker ที่สร้างขึ้นบนหลักการของ Kubernetes รวมถึงการจัดกลุ่มคอนเทนเนอร์ แต่วัตถุประสงค์หลักของโครงการคือการเปิดตัวคอนเทนเนอร์สไตล์ Docker โดยไม่มีบริการเพิ่มเติม ด้วยเหตุผลที่ชัดเจน จึงไม่มีโหมดกลุ่ม เนื่องจากนักพัฒนาระบุอย่างชัดเจนว่าหากคุณต้องการคลัสเตอร์ ให้ใช้ Kubernetes
การติดตั้ง
หากต้องการติดตั้งบน Centos 7 เพียงเปิดใช้งานพื้นที่เก็บข้อมูล Extras จากนั้นติดตั้งทุกอย่างด้วยคำสั่ง:
# yum -y install podman
คุณสมบัติอื่น ๆ
Podman สามารถสร้างหน่วยสำหรับ systemd ได้ ซึ่งจะช่วยแก้ปัญหาในการเริ่มคอนเทนเนอร์หลังจากรีบูตเซิร์ฟเวอร์ นอกจากนี้ systemd ได้รับการประกาศว่าทำงานอย่างถูกต้องเป็น pid 1 ในคอนเทนเนอร์ มีเครื่องมือ buildah แยกต่างหากสำหรับการสร้างคอนเทนเนอร์ นอกจากนี้ยังมีเครื่องมือของบุคคลที่สาม - อะนาล็อกของนักเทียบท่าเขียนซึ่งสร้างไฟล์การกำหนดค่าที่เข้ากันได้กับ Kubernetes ดังนั้นการเปลี่ยนจาก Podman เป็น Kubernetes จึงง่ายขึ้นมากที่สุดเท่าที่จะเป็นไปได้
ร่วมงานกับพ็อดแมน
เนื่องจากไม่มีโหมดฝูง (เราควรจะเปลี่ยนไปใช้ Kubernetes หากจำเป็นต้องใช้คลัสเตอร์) เราจะรวบรวมมันไว้ในคอนเทนเนอร์ที่แยกจากกัน
ติดตั้ง podman-compose:
# yum -y install python3-pip
# pip3 install podman-compose
ไฟล์การกำหนดค่าผลลัพธ์สำหรับ podman จะแตกต่างออกไปเล็กน้อย ตัวอย่างเช่น เราต้องย้ายส่วนวอลุ่มแยกต่างหากไปยังส่วนที่มีบริการโดยตรง
gitlab-podman.yml
version: '3.7'
services:
gitlab:
image: gitlab/gitlab-ce:latest
hostname: gitlab.example.com
restart: unless-stopped
environment:
GITLAB_OMNIBUS_CONFIG: |
gitlab_rails['gitlab_shell_ssh_port'] = 22222
ports:
- "80:80"
- "22222:22"
volumes:
- /srv/podman/gitlab/conf:/etc/gitlab
- /srv/podman/gitlab/data:/var/opt/gitlab
- /srv/podman/gitlab/logs:/var/log/gitlab
networks:
- gitlab
gitlab-runner:
image: gitlab/gitlab-runner:alpine
restart: unless-stopped
depends_on:
- gitlab
volumes:
- /srv/podman/gitlab/runner:/etc/gitlab-runner
- /var/run/docker.sock:/var/run/docker.sock
networks:
- gitlab
networks:
gitlab:
# podman-compose -f gitlab-runner.yml -d up
ผลลัพธ์:
# podman ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
da53da946c01 docker.io/gitlab/gitlab-runner:alpine run --user=gitlab... About a minute ago Up About a minute ago 0.0.0.0:22222->22/tcp, 0.0.0.0:80->80/tcp root_gitlab-runner_1
781c0103c94a docker.io/gitlab/gitlab-ce:latest /assets/wrapper About a minute ago Up About a minute ago 0.0.0.0:22222->22/tcp, 0.0.0.0:80->80/tcp root_gitlab_1
มาดูกันว่ามันสร้างอะไรสำหรับ systemd และ kubernetes ด้วยเหตุนี้เราจึงต้องค้นหาชื่อหรือ id ของพ็อด:
# podman pod ls
POD ID NAME STATUS CREATED # OF CONTAINERS INFRA ID
71fc2b2a5c63 root Running 11 minutes ago 3 db40ab8bf84b
คูเบอร์เนเตส:
# podman generate kube 71fc2b2a5c63
# Generation of Kubernetes YAML is still under development!
#
# Save the output of this file and use kubectl create -f to import
# it into Kubernetes.
#
# Created with podman-1.6.4
apiVersion: v1
kind: Pod
metadata:
creationTimestamp: "2020-07-29T19:22:40Z"
labels:
app: root
name: root
spec:
containers:
- command:
- /assets/wrapper
env:
- name: PATH
value: /opt/gitlab/embedded/bin:/opt/gitlab/bin:/assets:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
- name: TERM
value: xterm
- name: HOSTNAME
value: gitlab.example.com
- name: container
value: podman
- name: GITLAB_OMNIBUS_CONFIG
value: |
gitlab_rails['gitlab_shell_ssh_port'] = 22222
- name: LANG
value: C.UTF-8
image: docker.io/gitlab/gitlab-ce:latest
name: rootgitlab1
ports:
- containerPort: 22
hostPort: 22222
protocol: TCP
- containerPort: 80
hostPort: 80
protocol: TCP
resources: {}
securityContext:
allowPrivilegeEscalation: true
capabilities: {}
privileged: false
readOnlyRootFilesystem: false
volumeMounts:
- mountPath: /var/opt/gitlab
name: srv-podman-gitlab-data
- mountPath: /var/log/gitlab
name: srv-podman-gitlab-logs
- mountPath: /etc/gitlab
name: srv-podman-gitlab-conf
workingDir: /
- command:
- run
- --user=gitlab-runner
- --working-directory=/home/gitlab-runner
env:
- name: PATH
value: /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
- name: TERM
value: xterm
- name: HOSTNAME
- name: container
value: podman
image: docker.io/gitlab/gitlab-runner:alpine
name: rootgitlab-runner1
resources: {}
securityContext:
allowPrivilegeEscalation: true
capabilities: {}
privileged: false
readOnlyRootFilesystem: false
volumeMounts:
- mountPath: /etc/gitlab-runner
name: srv-podman-gitlab-runner
- mountPath: /var/run/docker.sock
name: var-run-docker.sock
workingDir: /
volumes:
- hostPath:
path: /srv/podman/gitlab/runner
type: Directory
name: srv-podman-gitlab-runner
- hostPath:
path: /var/run/docker.sock
type: File
name: var-run-docker.sock
- hostPath:
path: /srv/podman/gitlab/data
type: Directory
name: srv-podman-gitlab-data
- hostPath:
path: /srv/podman/gitlab/logs
type: Directory
name: srv-podman-gitlab-logs
- hostPath:
path: /srv/podman/gitlab/conf
type: Directory
name: srv-podman-gitlab-conf
status: {}
ระบบ:
# podman generate systemd 71fc2b2a5c63
# pod-71fc2b2a5c6346f0c1c86a2dc45dbe78fa192ea02aac001eb8347ccb8c043c26.service
# autogenerated by Podman 1.6.4
# Thu Jul 29 15:23:28 EDT 2020
[Unit]
Description=Podman pod-71fc2b2a5c6346f0c1c86a2dc45dbe78fa192ea02aac001eb8347ccb8c043c26.service
Documentation=man:podman-generate-systemd(1)
Requires=container-781c0103c94aaa113c17c58d05ddabf8df4bf39707b664abcf17ed2ceff467d3.service container-da53da946c01449f500aa5296d9ea6376f751948b17ca164df438b7df6607864.service
Before=container-781c0103c94aaa113c17c58d05ddabf8df4bf39707b664abcf17ed2ceff467d3.service container-da53da946c01449f500aa5296d9ea6376f751948b17ca164df438b7df6607864.service
[Service]
Restart=on-failure
ExecStart=/usr/bin/podman start db40ab8bf84bf35141159c26cb6e256b889c7a98c0418eee3c4aa683c14fccaa
ExecStop=/usr/bin/podman stop -t 10 db40ab8bf84bf35141159c26cb6e256b889c7a98c0418eee3c4aa683c14fccaa
KillMode=none
Type=forking
PIDFile=/var/run/containers/storage/overlay-containers/db40ab8bf84bf35141159c26cb6e256b889c7a98c0418eee3c4aa683c14fccaa/userdata/conmon.pid
[Install]
WantedBy=multi-user.target
# container-da53da946c01449f500aa5296d9ea6376f751948b17ca164df438b7df6607864.service
# autogenerated by Podman 1.6.4
# Thu Jul 29 15:23:28 EDT 2020
[Unit]
Description=Podman container-da53da946c01449f500aa5296d9ea6376f751948b17ca164df438b7df6607864.service
Documentation=man:podman-generate-systemd(1)
RefuseManualStart=yes
RefuseManualStop=yes
BindsTo=pod-71fc2b2a5c6346f0c1c86a2dc45dbe78fa192ea02aac001eb8347ccb8c043c26.service
After=pod-71fc2b2a5c6346f0c1c86a2dc45dbe78fa192ea02aac001eb8347ccb8c043c26.service
[Service]
Restart=on-failure
ExecStart=/usr/bin/podman start da53da946c01449f500aa5296d9ea6376f751948b17ca164df438b7df6607864
ExecStop=/usr/bin/podman stop -t 10 da53da946c01449f500aa5296d9ea6376f751948b17ca164df438b7df6607864
KillMode=none
Type=forking
PIDFile=/var/run/containers/storage/overlay-containers/da53da946c01449f500aa5296d9ea6376f751948b17ca164df438b7df6607864/userdata/conmon.pid
[Install]
WantedBy=multi-user.target
# container-781c0103c94aaa113c17c58d05ddabf8df4bf39707b664abcf17ed2ceff467d3.service
# autogenerated by Podman 1.6.4
# Thu Jul 29 15:23:28 EDT 2020
[Unit]
Description=Podman container-781c0103c94aaa113c17c58d05ddabf8df4bf39707b664abcf17ed2ceff467d3.service
Documentation=man:podman-generate-systemd(1)
RefuseManualStart=yes
RefuseManualStop=yes
BindsTo=pod-71fc2b2a5c6346f0c1c86a2dc45dbe78fa192ea02aac001eb8347ccb8c043c26.service
After=pod-71fc2b2a5c6346f0c1c86a2dc45dbe78fa192ea02aac001eb8347ccb8c043c26.service
[Service]
Restart=on-failure
ExecStart=/usr/bin/podman start 781c0103c94aaa113c17c58d05ddabf8df4bf39707b664abcf17ed2ceff467d3
ExecStop=/usr/bin/podman stop -t 10 781c0103c94aaa113c17c58d05ddabf8df4bf39707b664abcf17ed2ceff467d3
KillMode=none
Type=forking
PIDFile=/var/run/containers/storage/overlay-containers/781c0103c94aaa113c17c58d05ddabf8df4bf39707b664abcf17ed2ceff467d3/userdata/conmon.pid
[Install]
WantedBy=multi-user.target
น่าเสียดายที่นอกเหนือจากการเปิดตัวคอนเทนเนอร์แล้ว หน่วยที่สร้างขึ้นสำหรับ systemd ไม่ได้ทำอะไรอย่างอื่นอีก (เช่น การล้างคอนเทนเนอร์เก่าเมื่อบริการดังกล่าวถูกรีสตาร์ท) ดังนั้นคุณจะต้องเขียนสิ่งเหล่านี้ด้วยตัวเอง
ตามหลักการแล้ว Podman ก็เพียงพอที่จะลองใช้คอนเทนเนอร์ใด ถ่ายโอนการกำหนดค่าเก่าสำหรับการเขียนนักเทียบท่า จากนั้นย้ายไปยัง Kubernetes หากคุณต้องการคลัสเตอร์ หรือรับทางเลือกที่ง่ายกว่าสำหรับ Docker
RKT
โครงการ
สาด
ขึ้น
ผลการวิจัย
สถานการณ์ของ Kubernetes นั้นน่าสนใจมาก: ในแง่หนึ่งด้วย Docker คุณสามารถสร้างคลัสเตอร์ (ในโหมดฝูง) ซึ่งคุณสามารถเรียกใช้สภาพแวดล้อมผลิตภัณฑ์สำหรับไคลเอนต์ได้ นี่เป็นเรื่องจริงโดยเฉพาะอย่างยิ่งสำหรับทีมขนาดเล็ก (3-5 คน) หรือมีภาระโดยรวมเพียงเล็กน้อย หรือขาดความปรารถนาที่จะเข้าใจความซับซ้อนของการตั้งค่า Kubernetes รวมถึงสำหรับภาระงานที่สูง
Podman ไม่ได้ให้ความเข้ากันได้อย่างสมบูรณ์ แต่มีข้อได้เปรียบที่สำคัญอย่างหนึ่ง - ความเข้ากันได้กับ Kubernetes รวมถึงเครื่องมือเพิ่มเติม (buildah และอื่น ๆ ) ดังนั้นฉันจะเข้าใกล้การเลือกเครื่องมือสำหรับการทำงานดังนี้: สำหรับทีมเล็ก ๆ หรือมีงบประมาณ จำกัด - นักเทียบท่า (พร้อมโหมดฝูงที่เป็นไปได้) เพื่อพัฒนาตัวเองบนโฮสต์ในพื้นที่ส่วนตัว - สหาย Podman และสำหรับคนอื่น ๆ - คูเบอร์เนทีส
ฉันไม่แน่ใจว่าสถานการณ์ของ Docker จะไม่เปลี่ยนแปลงในอนาคต ท้ายที่สุดแล้ว พวกเขาเป็นผู้บุกเบิกและยังค่อยๆ ได้รับมาตรฐานทีละขั้นตอน แต่ Podman สำหรับข้อบกพร่องทั้งหมด (ใช้งานได้บน Linux เท่านั้น ไม่มีการทำคลัสเตอร์ การประกอบและการดำเนินการอื่น ๆ เป็นวิธีแก้ปัญหาของบุคคลที่สาม) อนาคตจะชัดเจนยิ่งขึ้น ดังนั้นฉันจึงขอเชิญชวนให้ทุกคนหารือเกี่ยวกับข้อค้นพบเหล่านี้ในความคิดเห็น
PS วันที่ 3 สิงหาคม เราเปิดตัว “
ราคาสั่งซื้อล่วงหน้าก่อนวางจำหน่าย: RUB 5000 คุณสามารถดูโปรแกรม Docker Video Course
ที่มา: will.com