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 เพื่อจัดเก็บข้อมูล Postgresql ข้อมูลสำคัญที่เหลือจะถูกจัดเก็บไว้ใน GlusterFS
หากต้องการปรับใช้ 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/redis05redis.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'] = "noreply@example.com"
gitlab_rails['smtp_password'] = "xxxxxxxxx"
gitlab_rails['smtp_domain'] = "example.com"
gitlab_rails['gitlab_email_from'] = 'noreply@example.com'
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
โครงการ ประมาณหกเดือนที่แล้วเนื่องจาก RedHat ซื้อมันมา ดังนั้นฉันจะไม่พูดถึงรายละเอียดเพิ่มเติมอีกต่อไป โดยรวมแล้วมันสร้างความประทับใจที่ดีมาก แต่เมื่อเทียบกับ Docker และโดยเฉพาะ Podman มันดูเหมือนเป็นการผสมผสานกัน นอกจากนี้ยังมีการกระจาย CoreOS ที่สร้างขึ้นบน rkt (แม้ว่าเดิมจะมี Docker) แต่สิ่งนี้ก็จบลงด้วยการสนับสนุนหลังจากการซื้อ RedHat
สาด
ขึ้น ผู้เขียนเพียงต้องการสร้างและเรียกใช้คอนเทนเนอร์ เมื่อพิจารณาจากเอกสารและรหัสผู้เขียนไม่ได้ปฏิบัติตามมาตรฐาน แต่เพียงตัดสินใจเขียนการดำเนินการของตนเองซึ่งโดยหลักการแล้วเขาทำ
ผลการวิจัย
สถานการณ์ของ Kubernetes นั้นน่าสนใจมาก: ในแง่หนึ่งด้วย Docker คุณสามารถสร้างคลัสเตอร์ (ในโหมดฝูง) ซึ่งคุณสามารถเรียกใช้สภาพแวดล้อมผลิตภัณฑ์สำหรับไคลเอนต์ได้ นี่เป็นเรื่องจริงโดยเฉพาะอย่างยิ่งสำหรับทีมขนาดเล็ก (3-5 คน) หรือมีภาระโดยรวมเพียงเล็กน้อย หรือขาดความปรารถนาที่จะเข้าใจความซับซ้อนของการตั้งค่า Kubernetes รวมถึงสำหรับภาระงานที่สูง
Podman ไม่ได้ให้ความเข้ากันได้อย่างสมบูรณ์ แต่มีข้อได้เปรียบที่สำคัญอย่างหนึ่ง - ความเข้ากันได้กับ Kubernetes รวมถึงเครื่องมือเพิ่มเติม (buildah และอื่น ๆ ) ดังนั้นฉันจะเข้าใกล้การเลือกเครื่องมือสำหรับการทำงานดังนี้: สำหรับทีมเล็ก ๆ หรือมีงบประมาณ จำกัด - นักเทียบท่า (พร้อมโหมดฝูงที่เป็นไปได้) เพื่อพัฒนาตัวเองบนโฮสต์ในพื้นที่ส่วนตัว - สหาย Podman และสำหรับคนอื่น ๆ - คูเบอร์เนทีส
ฉันไม่แน่ใจว่าสถานการณ์ของ Docker จะไม่เปลี่ยนแปลงในอนาคต ท้ายที่สุดแล้ว พวกเขาเป็นผู้บุกเบิกและยังค่อยๆ ได้รับมาตรฐานทีละขั้นตอน แต่ Podman สำหรับข้อบกพร่องทั้งหมด (ใช้งานได้บน Linux เท่านั้น ไม่มีการทำคลัสเตอร์ การประกอบและการดำเนินการอื่น ๆ เป็นวิธีแก้ปัญหาของบุคคลที่สาม) อนาคตจะชัดเจนยิ่งขึ้น ดังนั้นฉันจึงขอเชิญชวนให้ทุกคนหารือเกี่ยวกับข้อค้นพบเหล่านี้ในความคิดเห็น
PS วันที่ 3 สิงหาคม เราเปิดตัว “" ซึ่งคุณสามารถเรียนรู้เพิ่มเติมเกี่ยวกับงานของเขาได้ เราจะวิเคราะห์เครื่องมือทั้งหมดตั้งแต่นามธรรมพื้นฐานไปจนถึงพารามิเตอร์เครือข่ายความแตกต่างของการทำงานกับระบบปฏิบัติการและภาษาการเขียนโปรแกรมต่างๆ คุณจะคุ้นเคยกับเทคโนโลยีและเข้าใจว่าจะใช้ Docker ได้ที่ไหนและอย่างไรดีที่สุด เราจะแบ่งปันกรณีปฏิบัติที่ดีที่สุดด้วย
ราคาสั่งซื้อล่วงหน้าก่อนวางจำหน่าย: RUB 5000 คุณสามารถดูโปรแกรม Docker Video Course .
ที่มา: will.com
