ວິທີການຈັດການບັນຈຸ ນຳ ໃຊ້ 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.