ວິທີການຈັດການບັນຈຸ ນຳ ໃຊ້ Podman ແລະ Skopeo ໃນ RHEL 8
ໜຶ່ງ ໃນບັນດາສິ່ງທ້າທາຍທີ່ນັກພັດທະນາປະສົບໃນໄລຍະຜ່ານມາແມ່ນການເຮັດໃຫ້ແອັບພລິເຄຊັນສາມາດ ນຳ ໃຊ້ໄດ້ຢ່າງ ໜ້າ ເຊື່ອຖືໃນສະພາບແວດລ້ອມຄອມພິວເຕີ້ຫຼາຍໆຄອມພິວເຕີ້. ໂດຍປົກກະຕິແລ້ວ, ຄຳ ຮ້ອງສະ ໝັກ ບໍ່ໄດ້ ດຳ ເນີນການຕາມທີ່ຄາດຫວັງຫຼືປະສົບກັບຂໍ້ຜິດພາດແລະລົ້ມເຫລວ. ແລະນັ້ນແມ່ນບ່ອນທີ່ແນວຄວາມຄິດຂອງບັນຈຸບັນຈຸເກີດ.
ຮູບພາບບັນຈຸແມ່ນຫຍັງ?
ຮູບພາບບັນຈຸແມ່ນເອກະສານຄົງທີ່ທີ່ສົ່ງດ້ວຍລະຫັດທີ່ສາມາດປະຕິບັດໄດ້ເຊິ່ງແລ່ນໃນສະພາບແວດລ້ອມທີ່ໂດດດ່ຽວ. ຮູບພາບບັນຈຸມີຫ້ອງສະມຸດຂອງລະບົບ, ການເພິ່ງພາອາໄສ & ການຕັ້ງຄ່າເວທີອື່ນໆທີ່ ຈຳ ເປັນໂດຍແອັບພລິເຄຊັນເພື່ອ ດຳ ເນີນການໃນສະພາບແວດລ້ອມທີ່ຫຼາກຫຼາຍ.
Red Hat Linux ສະ ໜອງ ຊຸດເຄື່ອງມືບັນຈຸທີ່ມີປະໂຫຍດທີ່ທ່ານສາມາດຜັກດັນໃຫ້ເຮັດວຽກໂດຍກົງກັບບັນຈຸ Linux ໂດຍໃຊ້ ຄຳ ສັ່ງ docker. ເຫຼົ່ານີ້ລວມມີ:
- Podman - ນີ້ແມ່ນເຄື່ອງຈັກໃນການເກັບມ້ຽນຂອງ daemon ໜ້ອຍ ສຳ ລັບເຮັດວຽກແລະຈັດການກັບຕູ້ຄອນເທນເນີ OCI ທັງໃນຮູບແບບທີ່ບໍ່ມີຮາກຫລືບໍ່ມີຮາກ. Podman ແມ່ນຄ້າຍຄືກັບ Docker ແລະມີຕົວເລືອກ ຄຳ ສັ່ງດຽວກັນຍົກເວັ້ນວ່າ Docker ແມ່ນ daemon. ທ່ານສາມາດດຶງ, ແລ່ນແລະຈັດການຮູບພາບບັນຈຸໂດຍໃຊ້ podman ໃນແບບດຽວກັນກັບທ່ານກັບ Docker. Podman ມາພ້ອມກັບຄຸນລັກສະນະຂັ້ນສູງຫຼາຍຢ່າງ, ສົມບູນກັບລະບົບຕ່າງໆແລະໃຫ້ການສະ ໜັບ ສະ ໜູນ ຜູ້ໃຊ້ Namespace ເຊິ່ງປະກອບມີຕູ້ຄອນເທັນເນີທີ່ແລ່ນໂດຍບໍ່ຕ້ອງໃຊ້ຜູ້ໃຊ້ຮາກ.
- Skopeo: ນີ້ແມ່ນເຄື່ອງມືທີ່ບັນຈຸ ຄຳ ສັ່ງໃຊ້ ສຳ ລັບ ສຳ ເນົາຮູບພາບບັນຈຸຈາກບ່ອນ ໜຶ່ງ ລົງທະບຽນໄປຍັງບ່ອນອື່ນ. ທ່ານສາມາດໃຊ້ Skopeo ເພື່ອ ສຳ ເນົາຮູບພາບໄປຫາແລະຈາກເຈົ້າພາບໂດຍສະເພາະພ້ອມທັງ ສຳ ເນົາຮູບພາບໄປຍັງທະບຽນຫຼືສະພາບແວດລ້ອມຂອງພາຊະນະອື່ນ. ນອກເຫນືອຈາກການຄັດລອກຮູບພາບ, ທ່ານສາມາດໃຊ້ມັນເພື່ອກວດກາຮູບພາບຈາກທະບຽນຕ່າງໆແລະໃຊ້ລາຍເຊັນເພື່ອສ້າງແລະກວດສອບຮູບພາບຕ່າງໆ.
- Buildah: ນີ້ແມ່ນຊຸດຂອງເຄື່ອງມືບັນຊາການໃຊ້ ຄຳ ສັ່ງທີ່ໃຊ້ໃນການສ້າງແລະຈັດການຮູບພາບບັນຈຸ OCI ໂດຍໃຊ້ໄຟລ໌ Docker.
ໃນບົດຂຽນນີ້, ພວກເຮົາຈະສຸມໃສ່ການຈັດການບັນຈຸ ນຳ ໃຊ້ podman ແລະ Skopeo.
ຄົ້ນຫາຮູບພາບບັນຈຸຈາກທະບຽນຫ່າງໄກສອກຫຼີກ
ຄໍາສັ່ງຄົ້ນຫາ podman ຊ່ວຍໃຫ້ທ່ານສາມາດຄົ້ນຫາທະບຽນທີ່ຢູ່ຫ່າງໄກສອກຫຼີກທີ່ເລືອກໄວ້ ສຳ ລັບຮູບພາບບັນຈຸ. ບັນຊີລາຍຊື່ເລີ່ມຕົ້ນຂອງການລົງທະບຽນແມ່ນຖືກ ກຳ ນົດໄວ້ໃນແຟ້ມຈົດທະບຽນ.
ການລົງທະບຽນຖືກ ກຳ ນົດໂດຍ 3 ພາກ.
- [registries.search] - ສ່ວນນີ້ລະບຸການລົງທະບຽນເລີ່ມຕົ້ນທີ່ podman ສາມາດຄົ້ນຫາຮູບພາບບັນຈຸ. ມັນຄົ້ນຫາຮູບພາບທີ່ຖືກຮຽກຮ້ອງໃນການຈົດທະບຽນ .access.redhat.com, ການລົງທະບຽນ.
- [registries.insecure] - ສ່ວນນີ້ ກຳ ນົດການລົງທະບຽນທີ່ບໍ່ປະຕິບັດການເຂົ້າລະຫັດຂອງ TLS i.e ບໍ່ປອດໄພ. ໂດຍຄ່າເລີ່ມຕົ້ນ, ບໍ່ມີການລະບຸລາຍການໃດໆ.
- [registries.block] - ສິ່ງນີ້ຈະປະຕິເສດຫຼືປະຕິເສດການເຂົ້າເຖິງການລົງທະບຽນທີ່ລະບຸຈາກລະບົບທ້ອງຖິ່ນຂອງທ່ານ. ໂດຍຄ່າເລີ່ມຕົ້ນ, ບໍ່ມີການລະບຸລາຍການໃດໆ.
ໃນຖານະເປັນຜູ້ ນຳ ໃຊ້ທີ່ບໍ່ປົກກະຕິ (ບໍ່ແມ່ນຮາກ) ທີ່ໃຊ້ ຄຳ ສັ່ງ podman, ທ່ານສາມາດ ກຳ ນົດເອກະສານທີ່ລົງທະບຽນເອງ.
ໃນຂະນະທີ່ທ່ານລະບຸການລົງທະບຽນ, ຈົ່ງຈື່ໄວ້ຕໍ່ໄປນີ້:
- ທຸກໆການຈົດທະບຽນຄວນຈະຖືກປິດດ້ວຍ ຄຳ ອ້າງອີງດຽວ.
- ບັນດາກະຊວງຕ່າງໆສາມາດລະບຸໄດ້ໂດຍໃຊ້ຊື່ໂຮດຫລືທີ່ຢູ່ IP.
- ຖ້າມີການລົງທະບຽນຫລາຍລາຍການ, ພວກມັນຄວນຈະແຍກດ້ວຍເຄື່ອງ ໝາຍ ຈຸດ.
- ຖ້າການລົງທະບຽນໃຊ້ພອດທີ່ບໍ່ໄດ້ມາດຕະຖານ - ທັງພອດ TCP port 443 ເພື່ອຄວາມປອດໄພແລະ 80 ທີ່ບໍ່ປອດໄພ, - ໝາຍ ເລກພອດຄວນລະບຸຢູ່ຄຽງຄູ່ກັບຊື່ທະບຽນເຊັ່ນ: registry.example.com:5566.
ເພື່ອຄົ້ນຫາການລົງທະບຽນ ສຳ ລັບຮູບພາບບັນຈຸໂດຍໃຊ້ syntax:
# podman search registry/container_image
ຍົກຕົວຢ່າງ, ເພື່ອຄົ້ນຫາຮູບພາບ Redis ໃນການຈົດທະບຽນຂອງລີຈິດຊີ Registry.redhat.io, ຂໍ ຄຳ ສັ່ງ:
# podman search registry.redhat.io/redis
ເພື່ອຄົ້ນຫາຊຸດພາບບັນຈຸ MariaDB.
# podman search registry.redhat.io/mariadb
ເພື່ອໃຫ້ມີລາຍລະອຽດກ່ຽວກັບຮູບພາບບັນຈຸ, ໃຫ້ໃຊ້ຕົວເລືອກ --no-trunc
ກ່ອນຊື່ຂອງຮູບພາບບັນຈຸຈາກຜົນໄດ້ຮັບທີ່ທ່ານໄດ້ຮັບ. ຍົກຕົວຢ່າງ, ພວກເຮົາຈະພະຍາຍາມໃຫ້ມີລາຍລະອຽດກ່ຽວກັບຮູບພາບບັນຈຸ MariaDB ດັ່ງທີ່ສະແດງ:
# podman search --no-trunc registry.redhat.io/rhel8/mariadb-103
ດຶງຮູບພາບບັນຈຸ
ການດຶງຫລືເກັບເອົາຮູບພາບບັນຈຸຈາກທະບຽນຫ່າງໄກສອກຫຼີກຮຽກຮ້ອງໃຫ້ທ່ານກວດສອບຄວາມຖືກຕ້ອງກ່ອນອື່ນ. ຍົກຕົວຢ່າງ, ເພື່ອດຶງຮູບພາບບັນຈຸ MariaDB, ທຳ ອິດເຂົ້າສູ່ທະບຽນ Redhat:
# podman login
ໃສ່ຊື່ຜູ້ໃຊ້ແລະລະຫັດຜ່ານຂອງທ່ານແລະກົດປຸ່ມ 'Enter' ເທິງແປ້ນພິມຂອງທ່ານ. ຖ້າທຸກຢ່າງດີ, ທ່ານຄວນໄດ້ຮັບຂໍ້ຄວາມຢືນຢັນວ່າການເຂົ້າສູ່ລະບົບລົງທະບຽນແມ່ນປະສົບຜົນ ສຳ ເລັດ.
Login Succeeded!
ຕອນນີ້, ທ່ານສາມາດດຶງພາບໂດຍໃຊ້ syntax ທີ່ສະແດງ:
# podman pull <registry>[:<port>]/[<namespace>/]<name>:<tag>
<registry>
ໝາຍ ເຖິງເຈົ້າພາບຫລືລີຈິດຊີທີ່ຢູ່ຫ່າງໄກສອກຫຼີກທີ່ໃຫ້ການເກັບຮັກສາຮູບພາບບັນຈຸຢູ່ໃນ TCP <port>
. ລະຫັດ <namespace>
ແລະລະຫັດ <name>
ລວມ ກຳ ນົດຮູບພາບບັນຈຸໂດຍອີງໃສ່ <namespace>
ທີ່ທະບຽນ. ສຸດທ້າຍ, ຕົວເລືອກ <tag>
ລະບຸສະບັບຂອງຮູບພາບບັນຈຸ. ຖ້າບໍ່ມີລະບຸ, ແທັກເລີ່ມຕົ້ນ - ລ້າສຸດ - ຖືກໃຊ້.
ມັນຖືກແນະ ນຳ ໃຫ້ເພີ່ມການລົງທະບຽນທີ່ເຊື່ອຖືໄດ້, ນັ້ນແມ່ນບັນດາຕົວເລກທີ່ໃຫ້ການເຂົ້າລະຫັດແລະບໍ່ອະນຸຍາດໃຫ້ຜູ້ໃຊ້ທີ່ບໍ່ລະບຸຊື່ສາມາດລົງບັນຊີທີ່ມີຊື່ແບບສຸ່ມ.
ເພື່ອດຶງພາບ MariaDB, ດຳ ເນີນການ ຄຳ ສັ່ງ:
# podman pull registry.redhat.io/rhel8/mariadb-103
- The
<registry>
- registry.redhat.io - The
<namespace>
- rhel8 - ຊື່
<name>
- MariaDB - ລະຫັດ
<tag>
- 103
ສຳ ລັບການດຶງເອົາຮູບພາບບັນຈຸຕໍ່ໄປ, ບໍ່ ຈຳ ເປັນຕ້ອງມີການເຂົ້າສູ່ລະບົບອີກຕໍ່ໄປຕັ້ງແຕ່ທ່ານໄດ້ຖືກກວດສອບແລ້ວ ເພື່ອດຶງຮູບພາບບັນຈຸ Redis, ພຽງແຕ່ ດຳ ເນີນການ:
# podman pull registry.redhat.io/rhscl/redis-5-rhel7
ບັນຈຸຮູບພາບບັນຈຸ
ເມື່ອທ່ານ ສຳ ເລັດການດຶງຮູບພາບ, ທ່ານສາມາດເບິ່ງຮູບພາບທີ່ມີຢູ່ໃນປະຈຸບັນຂອງເຈົ້າຂອງເຈົ້າໂດຍການໃຊ້ ຄຳ ສັ່ງ podman images.
# podman images
ກວດກາຮູບພາບບັນຈຸ
ກ່ອນທີ່ຈະແລ່ນຕູ້ຄອນເທນເນີ, ມັນຄວນຈະມີຄວາມຄິດທີ່ດີທີ່ຈະສືບສວນຮູບພາບແລະເຂົ້າໃຈສິ່ງທີ່ມັນເຮັດ. ຜູ້ບັນຊາການກວດກາ podman ພິມທະເລເມຕາດາລາກ່ຽວກັບພາຊະນະເຊັ່ນ: OS ແລະຖາປັດຕະຍະ.
ເພື່ອກວດກາຮູບພາບ, ດຳ ເນີນການກວດກາ ຄຳ ສັ່ງ podman ຕາມດ້ວຍບັດປະ ຈຳ ຕົວຫລືຫໍສະມຸດພາບ.
# podman inspect IMAGE ID OR # podman inspect REPOSITORY
ໃນຕົວຢ່າງຂ້າງລຸ່ມນີ້, ພວກເຮົາ ກຳ ລັງກວດກາຕູ້ຄອນເທນເນີ MariaDB.
# podman inspect registry.redhat.io/rhel8/mariadb-103
ເພື່ອດຶງຂໍ້ມູນ metadata ສະເພາະ ສຳ ລັບພາຊະນະທີ່ຜ່ານທາງເລືອກ --format
ຕິດຕາມດ້ວຍເມຕາເດຕາແລະຕົວຕົນຂອງພາຊະນະ (ID ຮູບພາບຫຼືຊື່).
ໃນຕົວຢ່າງຂ້າງລຸ່ມນີ້, ພວກເຮົາ ກຳ ລັງດຶງເອົາຂໍ້ມູນກ່ຽວກັບສະຖາປັດຕະຍະ ກຳ ແລະ ຄຳ ອະທິບາຍກ່ຽວກັບພາຊະນະ RHEL 8 ທີ່ຢູ່ໃນຫົວຂໍ້ 'ປ້າຍຊື່'.
# podman inspect --format=’{{.Labels.architecture}}’ image ID # podman inspect --format=’{{.Labels.description}}’ image ID
ເພື່ອກວດກາຮູບພາບຈາກໄລຍະໄກຈາກທະບຽນອື່ນ, ໃຫ້ໃຊ້ ຄຳ ສັ່ງ skopeo ກວດກາ. ໃນຕົວຢ່າງຂ້າງລຸ່ມນີ້, ພວກເຮົາ ກຳ ລັງກວດກາຮູບພາບ RHEL 8 init ທີ່ຢູ່ Docker.
# skopeo inspect docker://registry.redhat.io/rhel8-beta/rhel-init
Tagging ຮູບພາບບັນຈຸ
ດັ່ງທີ່ທ່ານອາດຈະໄດ້ລະບຸໄວ້, ຊື່ຮູບພາບໂດຍທົ່ວໄປແມ່ນມີລັກສະນະທົ່ວໄປ. ຍົກຕົວຢ່າງ, the redis image is labeled:
registry.redhat.io/rhscl/redis-5-rhel7
ການຕິດປ້າຍໃສ່ຮູບພາບເຮັດໃຫ້ພວກເຂົາມີຊື່ທີ່ມີຄວາມເຂົ້າໃຈຫລາຍຂຶ້ນເພື່ອໃຫ້ພວກເຂົາເຂົ້າໃຈດີຂຶ້ນກ່ຽວກັບສິ່ງທີ່ພວກມັນມີ. ໂດຍໃຊ້ ຄຳ ສັ່ງແທັກ podman, ທ່ານສາມາດສ້າງແທັກຮູບພາບທີ່ ສຳ ຄັນໃສ່ຊື່ນາມສະກຸນເຊິ່ງປະກອບດ້ວຍສ່ວນຕ່າງໆ.
ພວກນີ້ແມ່ນ:
registry/username/NAME:tag
ຕົວຢ່າງ, ເພື່ອປ່ຽນຊື່ທົ່ວໄປຂອງຮູບພາບ Redis ເຊິ່ງມີ ID ຂອງ 646f2730318c, ພວກເຮົາຈະປະຕິບັດ ຄຳ ສັ່ງດັ່ງນີ້:
# podman tag 646f2730318c myredis
ເພື່ອເພີ່ມໂຄດ ຄຳ ສັ່ງຢູ່ປາຍສຸດທ້າຍເພີ່ມຈໍ້າສອງເມັດເຕັມຕາມດ້ວຍ ໝາຍ ເລກ tag:
# podman tag 646f2730318c myredis:5.0
ໂດຍບໍ່ຕ້ອງເພີ່ມ ຈຳ ນວນແທັກ, ມັນພຽງແຕ່ຈະຖືກມອບ ໝາຍ ໃຫ້ຄຸນລັກສະນະລ້າສຸດ.
ຮູບພາບບັນຈຸແລ່ນ
ເພື່ອແລ່ນຕູ້ຄອນເທນເນີ, ໃຫ້ໃຊ້ ຄຳ ສັ່ງ podman run. ຍົກຕົວຢ່າງ:
# podman run image_id
ເພື່ອໃຊ້ຕູ້ຄອນເທນເນີໃນພື້ນຫລັງຢ່າງງຽບໆເປັນບໍລິການ daemon ໂດຍໃຊ້ຕົວເລືອກ -d
ຕາມທີ່ສະແດງ.
# podman run -d image_id
ຍົກຕົວຢ່າງ, ເພື່ອ ດຳ ເນີນການແກ້ໄຂຮູບພາບຄືນ ໃໝ່ ດ້ວຍບັດປະ ຈຳ ຕົວ 646f2730318c, ພວກເຮົາຈະຂໍ ຄຳ ສັ່ງ:
# podman run -d 646f2730318c
ຖ້າທ່ານ ກຳ ລັງແລ່ນຕູ້ຄອນເທນເນີໂດຍອີງໃສ່ລະບົບປະຕິບັດການເຊັ່ນ: ຮູບພາບພື້ນຖານ RHEL 8, ທ່ານສາມາດເຂົ້າໄປໃນຫອຍໄດ້ໂດຍໃຊ້ ຄຳ ສັ່ງ -it
. ຕົວເລືອກ -i
ສ້າງແບບໂຕ້ຕອບກັນໃນຂະນະທີ່ -t
ສ້າງຊ່ວງເວລາຢູ່ປາຍຍອດ. ຕົວເລືອກ --name
ຕັ້ງຊື່ບັນຈຸໃສ່ mybash ໃນຂະນະທີ່ id ຮູບພາບ ecbc6f53bba0 ຂອງຮູບພາບພື້ນຖານ.
# podman run -it --name=mybash ecbc6f53bba0
ຫລັງຈາກນັ້ນ, ທ່ານສາມາດ ດຳ ເນີນການ ຄຳ ສັ່ງຫອຍໃດໆ. ໃນຕົວຢ່າງຂ້າງລຸ່ມນີ້, ພວກເຮົາ ກຳ ລັງກວດສອບເວີຊັ່ນ OS ຂອງຮູບພາບບັນຈຸ.
# cat /etc/os-release
ເພື່ອອອກຈາກຖັງ, ພຽງແຕ່ຮຽກຮ້ອງ ຄຳ ສັ່ງອອກ.
# exit
ເມື່ອຕູ້ຄອນເທນເນີຖືກອອກ, ມັນຈະຢຸດໂດຍອັດຕະໂນມັດ. ເພື່ອເລີ່ມຕົ້ນຖັງອີກຄັ້ງ, ໃຊ້ ຄຳ ສັ່ງ podman ເລີ່ມຕົ້ນດ້ວຍທຸງ -ai
ຕາມທີ່ສະແດງ.
# podman start -ai mybash
ອີກເທື່ອ ໜຶ່ງ, ສິ່ງນີ້ຊ່ວຍໃຫ້ທ່ານສາມາດເຂົ້າເຖິງຫອຍໄດ້.
ລົງບັນຊີຮູບພາບບັນຈຸແລ່ນ
ເພື່ອລົງບັນຈຸບັນຈຸທີ່ ກຳ ລັງແລ່ນຢູ່, ໃຫ້ໃຊ້ ຄຳ ສັ່ງ podman ps ດັ່ງທີ່ສະແດງໄວ້.
# podman ps
ເພື່ອເບິ່ງບັນຈຸທັງ ໝົດ ລວມທັງເຄື່ອງບັນຈຸທີ່ອອກຈາກການແລ່ນແລ້ວ, ໃຫ້ໃຊ້ ຄຳ ສັ່ງ:
# podman ps -a
ຕັ້ງຄ່າຮູບພາບບັນຈຸເພື່ອເລີ່ມຕົ້ນໂດຍອັດຕະໂນມັດພາຍໃຕ້ການບໍລິການຂອງລະບົບ
ໃນພາກນີ້, ພວກເຮົາສຸມໃສ່ວິທີການບັນຈຸຕູ້ຄອນເທນເນີສາມາດ ກຳ ຫນົດຄ່າເພື່ອ ດຳ ເນີນການໂດຍກົງໃສ່ລະບົບ RHEL ເປັນການບໍລິການລະບົບ.
ກ່ອນອື່ນ ໝົດ, ໄດ້ຮັບຮູບພາບທີ່ທ່ານຕ້ອງການ. ໃນກໍລະນີນີ້, ພວກເຮົາໄດ້ດຶງຮູບພາບ Redis ຈາກສູນ docker:
# podman pull docker.io/redis
ຖ້າທ່ານມີ SELinux ເຮັດວຽກຢູ່ໃນລະບົບຂອງທ່ານ, ທ່ານຕ້ອງເປີດໃຊ້ boolean container_manage_cgroup ເພື່ອເຮັດວຽກບັນຈຸກັບ systemd.
# setsebool -p container_manage_cgroup on
ຫລັງຈາກນັ້ນ, ດຳ ເນີນຮູບພາບບັນຈຸໃນພື້ນຫລັງແລະ ກຳ ນົດມັນໃສ່ຊື່ຮູບທີ່ທ່ານຕ້ອງການ. ໃນຕົວຢ່າງນີ້, ພວກເຮົາໄດ້ຕັ້ງຊື່ຮູບພາບຂອງພວກເຮົາ redis_server ແລະວາງແຜນທີ່ Port 6379 ຈາກຕູ້ຄອນເທນເນີໄປເປັນເຈົ້າພາບ RHEL 8 ຂອງພວກເຮົາ.
# podman run -d --name redis_server -p 6379:6379 redis
ຕໍ່ໄປ, ພວກເຮົາ ກຳ ລັງຈະສ້າງເອກະສານການຕັ້ງຄ່າຂອງ systemd system ສຳ ລັບການກວດສອບ ໃໝ່ ໃນ/etc/systemd/system/directory.
# vim /etc/systemd/system/redis-container.service
ວາງເນື້ອໃນຂ້າງລຸ່ມນີ້ໃສ່ໃນເອກະສານ.
[Unit] Description=Redis container [Service] Restart=always ExecStart=/usr/bin/podman start -a redis_server ExecStop=/usr/bin/podman stop -t 2 redis_server [Install] WantedBy=local.target
ບັນທຶກແລະອອກຈາກແຟ້ມ.
ຕໍ່ໄປ, ຕັ້ງຄ່າພາຊະນະເພື່ອເລີ່ມຕົ້ນໂດຍອັດຕະໂນມັດໃນການບູດເຄື່ອງ.
# systemctl enable redis-container.service
ຕໍ່ໄປ, ເລີ່ມຕົ້ນຖັງບັນຈຸແລະກວດສອບສະຖານະການແລ່ນຂອງມັນ.
# systemctl start redis-container.service # systemctl status redis-container.service
ຕັ້ງຄ່າການເກັບຂໍ້ມູນທີ່ທົນທານ ສຳ ລັບຮູບພາບບັນຈຸ
ໃນເວລາທີ່ ກຳ ລັງແລ່ນບັນຈຸ, ມັນຄວນລະວັງໃນການຕັ້ງຄ່າບ່ອນເກັບຂໍ້ມູນພາຍນອກທີ່ທົນທານຢູ່ໃນເວັບ. ນີ້ສະ ໜອງ ການ ສຳ ຮອງໃນກໍລະນີທີ່ຕູ້ຄອນເທນເນີຕົກຫລືຖືກຍ້າຍອອກໂດຍບັງເອີນ.
ເພື່ອສືບຕໍ່ເກັບ ກຳ ຂໍ້ມູນ, ພວກເຮົາ ກຳ ລັງຈະວາງແຜນທີ່ໄດເລກະທໍລີທີ່ຕັ້ງຢູ່ໃນໂຮດກັບບ່ອນເກັບຂໍ້ມູນພາຍໃນພາຊະນະ.
$ podman run --privileged -it -v /var/lib/containers/backup_storage:/mnt registry.redhat.io/ubi8/ubi /bin/bash
ຕົວເລືອກ - ທີ່ບໍ່ມີປະສິດຕິພາບ
ຖືກຜ່ານເມື່ອ SELinux ກຳ ນົດບັງຄັບໃຊ້. ຕົວເລືອກ -v
ລະບຸປະລິມານພາຍນອກເຊິ່ງຕັ້ງຢູ່ໃນໂຮດ. ປະລິມານການບັນຈຸຢູ່ທີ່ນີ້ແມ່ນໄດເລກະທໍລີ/mnt.
ເມື່ອພວກເຮົາໄດ້ເຂົ້າໃຊ້ຫອຍ, ພວກເຮົາຈະສ້າງຕົວຢ່າງເອກະສານ test.txt ໃນໄດເລກະທໍລີ/mnt ດັ່ງທີ່ສະແດງໄວ້.
$ echo "This tests persistent external storage" > /mnt/testing.txt
ຈາກນັ້ນພວກເຮົາຈະອອກຈາກຖັງເກັບມ້ຽນແລະກວດເບິ່ງວ່າມີເອກະສານມີຢູ່ໃນບ່ອນເກັບຂໍ້ມູນພາຍນອກທີ່ອາໄສຢູ່ໃນເຈົ້າຂອງບໍ?
# exit # cat /var/lib/containers/backup_storage/testing.txt
ຜົນໄດ້ຮັບ⇒ການທົດສອບນີ້ຄົງທົນຕໍ່ບ່ອນເກັບຂໍ້ມູນພາຍນອກ.
ການຢຸດເຊົາແລະ ກຳ ຈັດຖັງ
ເມື່ອທ່ານເຮັດ ສຳ ເລັດກັບການແລ່ນຕູ້ຄອນເທນເນີຂອງທ່ານ, ທ່ານສາມາດຢຸດມັນໄດ້ໂດຍໃຊ້ ຄຳ ສັ່ງຢຸດ podman ຕິດຕາມດ້ວຍ id-container ທີ່ທ່ານສາມາດຫາໄດ້ຈາກ ຄຳ ສັ່ງ podman ps.
# podman stop container-id
ເພື່ອ ກຳ ຈັດພາຊະນະບັນຈຸທີ່ທ່ານບໍ່ຕ້ອງການ, ກ່ອນອື່ນ ໝົດ, ຮັບປະກັນວ່າທ່ານຢຸດມັນແລະຫຼັງຈາກນັ້ນຮຽກຮ້ອງເອົາ ຄຳ ສັ່ງ podman rm ຕາມດ້ວຍ id ຫຼືຊື່ຂອງພາຊະນະທີ່ເປັນຕົວເລືອກ.
# podman rm container-id
ເພື່ອ ກຳ ຈັດຖັງບັນຈຸຫຼາຍຊະນິດໃນເວລາດຽວໃນ ໜຶ່ງ ຄຳ ສັ່ງ, ໃຫ້ລະບຸຊ່ອງໃສ່ພາຊະນະທີ່ແຍກອອກຈາກບ່ອນຫວ່າງ.
# podman rm container-id-1 container-id-2 container-id-3
ເພື່ອລ້າງຖັງທັງ ໝົດ ຂອງທ່ານ, ໃຫ້ ດຳ ເນີນການ ຄຳ ສັ່ງ:
# podman rm -a
ການ ກຳ ຈັດຮູບພາບ
ເພື່ອ ກຳ ຈັດຮູບພາບ, ກ່ອນອື່ນ ໝົດ, ຕ້ອງຮັບປະກັນວ່າບັນຈຸທັງ ໝົດ ທີ່ປົ່ງອອກຈາກຮູບພາບຖືກຢຸດແລະຖອດອອກຕາມທີ່ໄດ້ສົນທະນາໃນຫົວຂໍ້ຍ່ອຍກ່ອນ ໜ້າ ນີ້.
ຕໍ່ໄປ, ດໍາເນີນການແລະດໍາເນີນການຄໍາສັ່ງ podman -rmi
ຕິດຕາມດ້ວຍ ID ຂອງຮູບດັ່ງທີ່ສະແດງ:
# podman -rmi image-id
ສະຫຼຸບ
ບົດນີ້ຈະຂຽນບົດນີ້ກ່ຽວກັບການຄຸ້ມຄອງແລະເຮັດວຽກກັບບັນຈຸໃນ RHEL 8. ພວກເຮົາຫວັງວ່າຄູ່ມືນີ້ໄດ້ໃຫ້ຄວາມເຂົ້າໃຈທີ່ ເໝາະ ສົມກ່ຽວກັບພາຊະນະບັນຈຸແລະວິທີທີ່ທ່ານສາມາດພົວພັນແລະຈັດການກັບພວກມັນໃນລະບົບ RHEL ຂອງທ່ານໂດຍໃຊ້ podman ແລະ Skopeo.