TL;DR: බහාලුම්වල යෙදුම් ධාවනය සඳහා රාමු සංසන්දනය කිරීම සඳහා දළ විශ්ලේෂණයක්. Docker සහ අනෙකුත් සමාන පද්ධතිවල හැකියාවන් සලකා බලනු ඇත.
ඒ සියල්ල පැමිණියේ කොහෙන්ද යන්න පිළිබඳ කුඩා ඉතිහාසයක්
කතාව
යෙදුමක් හුදකලා කිරීම සඳහා පළමු සුප්රසිද්ධ ක්රමය chroot වේ. එකම නමේ ඇති පද්ධති ඇමතුම මූල නාමාවලිය වෙනස් කිරීම සහතික කරයි - එමගින් එය ඇමතූ වැඩසටහනට එම නාමාවලිය තුළ ඇති ගොනු වෙත පමණක් ප්රවේශය ඇති බව සහතික කරයි. නමුත් ක්රමලේඛයකට අභ්යන්තරව root වරප්රසාද ලබා දෙන්නේ නම්, එය chroot වෙතින් "පලා යාම" සහ ප්රධාන මෙහෙයුම් පද්ධතිය වෙත ප්රවේශය ලබා ගත හැක. එසේම, මූල නාමාවලිය වෙනස් කිරීමට අමතරව, අනෙකුත් සම්පත් (RAM, ප්රොසෙසරය), මෙන්ම ජාල ප්රවේශය, සීමා නොවේ.
මීළඟ ක්රමය වන්නේ මෙහෙයුම් පද්ධති කර්නලයේ යාන්ත්රණයන් භාවිතා කරමින් බහාලුමක් තුළ සම්පූර්ණ මෙහෙයුම් පද්ධතියක් දියත් කිරීමයි. මෙම ක්රමය විවිධ මෙහෙයුම් පද්ධතිවල වෙනස් ලෙස හැඳින්වේ, නමුත් සාරය එකම වේ - ස්වාධීන මෙහෙයුම් පද්ධති කිහිපයක් දියත් කිරීම, ඒ සෑම එකක්ම ප්රධාන මෙහෙයුම් පද්ධතිය ක්රියාත්මක වන එකම කර්නලය ධාවනය කරයි. Linux සඳහා FreeBSD Jails, Solaris Zones, OpenVZ සහ LXC ඇතුළත් වේ. හුදකලා වීම තැටි අවකාශයෙන් පමණක් නොව අනෙකුත් සම්පත් මගින්ද සහතික කෙරේ; විශේෂයෙන්ම, එක් එක් බහාලුම් ප්රොසෙසර කාලය, RAM සහ ජාල කලාප පළල මත සීමාවන් තිබිය හැක. chroot හා සසඳන විට, කන්ටේනරයෙන් පිටවීම වඩාත් අපහසු වේ, කන්ටේනරයේ ඇති සුපිරි පරිශීලකයාට බහාලුම්වල අන්තර්ගතයට පමණක් ප්රවේශය ඇත, කෙසේ වෙතත්, කන්ටේනරය තුළ ඇති මෙහෙයුම් පද්ධතිය යාවත්කාලීනව තබා ගැනීමේ අවශ්යතාවය සහ පැරණි අනුවාද භාවිතය හේතුවෙන්. කර්නල් වල (ලිනක්ස් සඳහා අදාළ, තරමක් දුරට FreeBSD), කර්නල් හුදකලා පද්ධතිය "බිඳගෙන" ප්රධාන මෙහෙයුම් පද්ධතියට ප්රවේශය ලබා ගැනීමේ ශුන්ය නොවන සම්භාවිතාවක් ඇත.
කන්ටේනරයක (ආරම්භක පද්ධතියක්, පැකේජ කළමණාකරු යනාදිය සමඟ) සම්පූර්ණ මෙහෙයුම් පද්ධතියක් දියත් කරනවා වෙනුවට, ඔබට වහාම යෙදුම් දියත් කළ හැකිය, ප්රධාන දෙය නම් යෙදුම් වලට එවැනි අවස්ථාවක් ලබා දීමයි (අවශ්ය පුස්තකාල තිබීම සහ අනෙකුත් ගොනු). මෙම අදහස බහාලුම් යෙදුම් අථත්යකරණය සඳහා පදනම ලෙස ක්රියා කළ අතර, එහි වඩාත්ම කැපී පෙනෙන සහ ප්රසිද්ධ නියෝජිතයා වන්නේ ඩොකර් ය. පෙර පද්ධති හා සසඳන විට, වඩාත් නම්යශීලී හුදකලා යාන්ත්රණ, බහාලුම් අතර අථත්ය ජාල සඳහා ගොඩනඟන ලද සහය සහ බහාලුම් තුළ යෙදුම් තත්ත්ව ලුහුබැඳීම, බහාලුම් ක්රියාත්මක කිරීම සඳහා භෞතික සේවාදායකයන් විශාල සංඛ්යාවකින් තනි සුසංයෝගී පරිසරයක් ගොඩනැගීමේ හැකියාව ඇති කළේය. අතින් සම්පත් කළමනාකරණයේ අවශ්යතාවයකින් තොරව.
Docker
Docker යනු වඩාත් ප්රසිද්ධ යෙදුම් බහාලුම් මෘදුකාංගයකි. Go භාෂාවෙන් ලියා ඇති එය Linux kernel හි සම්මත විශේෂාංග - cgroups, namespaces, capabilities, etc. මෙන්ම Aufs ගොනු පද්ධති සහ වෙනත් ඒවා තැටි ඉඩ ඉතිරි කර ගැනීමට භාවිතා කරයි.
මූලාශ්රය: wikimedia
ගෘහ නිර්මාණ ශිල්පය
1.11 අනුවාදයට පෙර, බහාලුම් සමඟ සියලුම මෙහෙයුම් සිදු කරන ලද තනි සේවාවක් ලෙස ඩොකර් ක්රියා කළේය: බහාලුම් සඳහා පින්තූර බාගත කිරීම, බහාලුම් දියත් කිරීම, API ඉල්ලීම් සැකසීම. 1.11 අනුවාදයෙන් පටන් ගෙන, Docker එකිනෙක සමඟ අන්තර් ක්රියා කරන කොටස් කිහිපයකට බෙදා ඇත: බහාලුම්, බහාලුම්වල සම්පූර්ණ ජීවන චක්රය සැකසීම සඳහා (තැටි ඉඩ වෙන් කිරීම, පින්තූර බාගත කිරීම, ජාලය සමඟ වැඩ කිරීම, බහාලුම්වල තත්ත්වය දියත් කිරීම, ස්ථාපනය කිරීම සහ අධීක්ෂණය කිරීම) සහ runC, cgroups භාවිතය සහ Linux කර්නලයේ අනෙකුත් විශේෂාංග මත පදනම් වූ බහාලුම් ක්රියාත්මක පරිසරය. ඩොකර් සේවාවම පවතී, නමුත් දැන් එය කන්ටේනර් වෙත පරිවර්තනය කරන ලද API ඉල්ලීම් සැකසීමට පමණක් සේවය කරයි.
ස්ථාපනය සහ වින්යාසය
ඩොකර් ස්ථාපනය කිරීමට මගේ ප්රියතම ක්රමය ඩොකර්-මැෂින් වේ, එය දුරස්ථ සේවාදායකයන් මත (විවිධ වලාකුළු ඇතුළුව) ඩොකර් සෘජුවම ස්ථාපනය කිරීමට සහ වින්යාස කිරීමට අමතරව, දුරස්ථ සේවාදායකයන්ගේ ගොනු පද්ධති සමඟ වැඩ කිරීමට හැකි වන අතර විවිධ විධාන ද ක්රියාත්මක කළ හැකිය.
කෙසේ වෙතත්, 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 ගොනු එවැනි පොකුරු සඳහා භාවිතා කළ හැක. විශාල පොකුරු සඳහා, කුබර්නෙටස් වඩාත් සුදුසු වන්නේ රංචු මාදිලියේ නඩත්තු වියදම් කුබර්නෙටේස් වලට වඩා වැඩි විය හැකි බැවිනි. RunC වලට අමතරව, ඔබට ස්ථාපනය කළ හැකිය, උදාහරණයක් ලෙස, බහාලුම් ක්රියාත්මක කිරීමේ පරිසරය ලෙස
ඩොකර් සමඟ වැඩ කිරීම
ස්ථාපනය සහ වින්යාස කිරීමෙන් පසුව, අපි සංවර්ධන කණ්ඩායම සඳහා GitLab සහ Docker Registry යොදවන පොකුරක් එකලස් කිරීමට උත්සාහ කරමු. මම සේවාදායකයන් ලෙස අතථ්ය යන්ත්ර තුනක් භාවිතා කරමි, ඊට අමතරව මම බෙදා හරින ලද FS GlusterFS යොදවන්නෙමි; මම එය ඩොකර් වෙළුම් ගබඩාවක් ලෙස භාවිතා කරමි, උදාහරණයක් ලෙස, ඩොකර් රෙජිස්ට්රියේ දෝෂ-ඉවසන අනුවාදයක් ධාවනය කිරීමට. ධාවනය කිරීමට ප්රධාන සංරචක: ඩොකර් රෙජිස්ට්රි, පෝස්ට්ග්රෙස්ක්ල්, රෙඩිස්, ගිට්ලැබ්, ස්වර්ම් මත ඇති ගිට්ලැබ් රනර් සඳහා සහය දක්වයි. අපි පොකුරු සමග 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
රංචු මාදිලිය එක් සේවාදායකයක් මත වින්යාස කර ඇත, එය නායකයා වනු ඇත, ඉතිරිය පොකුරට සම්බන්ධ වීමට සිදුවනු ඇත, එබැවින් පළමු සේවාදායකයේ විධානය ක්රියාත්මක කිරීමේ ප්රති result ලය අනෙක් ඒවා මත පිටපත් කර ක්රියාත්මක කිරීමට අවශ්ය වේ.
ආරම්භක පොකුරු සැකසුම, මම 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
මීලඟට, අපි Traefik සහ Stolon සඳහා අවශ්ය වන etcd දත්ත ගබඩා කිරීම, KV ගබඩා කිරීම සඳහා නාමාවලි සාදන්නෙමු. Postgresql හා සමානව, මේවා සේවාදායකයන් සමඟ බැඳ ඇති බහාලුම් වනු ඇත, එබැවින් අපි මෙම විධානය සියලුම සේවාදායකයන් මත ක්රියාත්මක කරමු:
# mkdir -p /srv/etcd
ඊළඟට, 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
Docker Registry එක් කරන්න:
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
වැඩිදියුණු කළ හැකි තවත් මොනවාද? https හරහා බහාලුම් ධාවනය කිරීමට Traefik වින්යාස කිරීමට වග බලා ගන්න, Postgresql සහ Redis සඳහා tls සංකේතනය එක් කරන්න. නමුත් පොදුවේ, එය දැනටමත් PoC ලෙස සංවර්ධකයින්ට ලබා දිය හැකිය. අපි දැන් Docker සඳහා විකල්ප බලමු.
පොඩ්මන්
කරල් මගින් කාණ්ඩගත කර ඇති බහාලුම් ධාවනය කිරීම සඳහා තවත් තරමක් ප්රසිද්ධ එන්ජිමක් (පොඩ්ස්, එකට යොදවා ඇති බහාලුම් කණ්ඩායම්). Docker මෙන් නොව, එයට බහාලුම් ධාවනය කිරීමට කිසිදු සේවාවක් අවශ්ය නොවේ; සියලුම වැඩ libpod පුස්තකාලය හරහා සිදු කෙරේ. Go හි ද ලියා ඇත, runC වැනි බහාලුම් ධාවනය කිරීමට OCI-අනුකූල ධාවන කාලයක් අවශ්ය වේ.
Podman සමඟ වැඩ කිරීම සාමාන්යයෙන් Docker සඳහා එය සිහිපත් කරයි, ඔබට එය මේ ආකාරයෙන් කළ හැකිය (මෙම ලිපියේ කතුවරයා ඇතුළුව එය උත්සාහ කළ බොහෝ දෙනෙක් ප්රකාශ කළ පරිදි):
$ alias docker=podman
සහ ඔබට දිගටම වැඩ කළ හැකිය. පොදුවේ ගත් කල, Podman සමඟ තත්වය ඉතා සිත්ගන්නා සුළුය, මන්ද Kubernetes හි මුල් අනුවාද Docker සමඟ වැඩ කළේ නම්, 2015 දී පමණ, බහාලුම් ලෝකය ප්රමිතිකරණය කිරීමෙන් (OCI - විවෘත බහාලුම් මුලපිරීම) සහ ඩොකර් බහාලුම් සහ ධාවන ලෙස බෙදීමෙන් පසුව, Kubernetes හි ධාවනය සඳහා Docker සඳහා විකල්පයක් සංවර්ධනය වෙමින් පවතී: CRI-O. මේ සම්බන්ධයෙන් Podman යනු ඩොකර් සඳහා විකල්පයක් වන අතර එය කන්ටේනර් කණ්ඩායම් කිරීම ඇතුළුව Kubernetes හි මූලධර්ම මත ගොඩනගා ඇත, නමුත් ව්යාපෘතියේ ප්රධාන අරමුණ වන්නේ අමතර සේවාවන් නොමැතිව ඩොකර් විලාසිතාවේ බහාලුම් දියත් කිරීමයි. පැහැදිලි හේතූන් මත, රංචු මාදිලියක් නොමැත, මන්ද සංවර්ධකයින් පැහැදිලිව පවසන්නේ ඔබට පොකුරක් අවශ්ය නම්, Kubernetes ගන්න.
ස්ථාපනය
Centos 7 මත ස්ථාපනය කිරීමට, Extras ගබඩාව සක්රිය කරන්න, ඉන්පසු විධානය සමඟ සියල්ල ස්ථාපනය කරන්න:
# yum -y install podman
වෙනත් විශේෂාංග
Podman හට systemd සඳහා ඒකක උත්පාදනය කළ හැකි අතර, සේවාදායකය නැවත ආරම්භ කිරීමෙන් පසු බහාලුම් ආරම්භ කිරීමේ ගැටළුව විසඳයි. මීට අමතරව, systemd බහාලුම්වල pid 1 ලෙස නිවැරදිව ක්රියා කරන බව ප්රකාශ කර ඇත. බහාලුම් තැනීම සඳහා වෙනම බිල්ඩ් මෙවලමක් ඇත, තුන්වන පාර්ශවීය මෙවලම් ද ඇත - ඩොකර්-කොම්පෝස් හි ප්රතිසමයන් ද කුබර්නෙටස් සමඟ අනුකූල වින්යාස ගොනු ජනනය කරයි, එබැවින් පොඩ්මන් සිට කුබර්නෙටස් දක්වා සංක්රමණය හැකි තරම් සරල කර ඇත.
Podman සමඟ වැඩ කිරීම
රංචු මාදිලියක් නොමැති බැවින් (පොකුරක් අවශ්ය නම් අපි 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 සඳහා ජනනය කරන්නේ කුමක්දැයි බලමු, මේ සඳහා අපි පොඩ් එකේ නම හෝ හැඳුනුම්පත සොයා ගත යුතුය:
# 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: {}
Systemd:
# 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 සමඟ තත්වය ඉතා සිත්ගන්නා සුළුය: එක් අතකින්, ඩොකර් සමඟ ඔබට පොකුරක් (රංචු ආකාරයෙන්) ගොඩනගා ගත හැකිය, එමඟින් ඔබට සේවාදායකයින් සඳහා නිෂ්පාදන පරිසරයන් පවා ධාවනය කළ හැකිය, මෙය කුඩා කණ්ඩායම් (3-5 පුද්ගලයින්) සඳහා විශේෂයෙන් සත්ය වේ. , හෝ කුඩා සමස්ත බරක් සමඟ , හෝ ඉහළ බරක් ඇතුළුව, Kubernetes පිහිටුවීමේ සංකීර්ණතා තේරුම් ගැනීමට ආශාවක් නොමැතිකම.
Podman පූර්ණ අනුකූලතාවයක් ලබා නොදේ, නමුත් එයට එක් වැදගත් වාසියක් ඇත - අමතර මෙවලම් (buildah සහ වෙනත්) ඇතුළුව Kubernetes සමඟ අනුකූලතාව. එමනිසා, මම පහත පරිදි වැඩ සඳහා මෙවලමක් තෝරා ගැනීමට ප්රවේශ වන්නෙමි: කුඩා කණ්ඩායම් සඳහා, හෝ සීමිත අයවැයක් සමඟ - ඩොකර් (හැකි රංචු මාදිලියක් සමඟ), පුද්ගලික දේශීය සත්කාරක සමාගමක මා වෙනුවෙන් සංවර්ධනය කිරීම සඳහා - පොඩ්මන් සහෝදරවරුනි, සහ අනෙක් සියල්ලන් සඳහා. - කුබර්නෙටස්.
ඩොකර් සමඟ තත්වය අනාගතයේදී වෙනස් නොවනු ඇතැයි මට විශ්වාස නැත, සියල්ලට පසු, ඔවුන් පුරෝගාමීන් වන අතර, ක්රමයෙන් පියවරෙන් පියවර ප්රමිතිකරණය වෙමින් පවතී, නමුත් Podman, එහි සියලු අඩුපාඩු සඳහා (ලිනක්ස් මත පමණක් ක්රියා කරයි, ක්ලස්ටරින් නොමැත, එකලස් කිරීම සහ අනෙකුත් ක්රියා තුන්වන පාර්ශ්ව විසඳුම් වේ) අනාගතය වඩා පැහැදිලිය, එබැවින් මෙම සොයාගැනීම් අදහස් දැක්වීමේදී සාකච්ඡා කිරීමට මම සැමට ආරාධනා කරමි.
ප්රාදේශීය සභා අගෝස්තු 3 වෙනිදා අපි දියත් කරනවා "
නිකුත් කිරීමට පෙර පෙර-ඇණවුම් මිල: RUB 5000. ඔබට ඩොකර් වීඩියෝ පාඨමාලා වැඩසටහන නැරඹිය හැකිය
මූලාශ්රය: www.habr.com