Docker Tips: សម្អាតម៉ាស៊ីនរបស់ Junk

សួស្តី ហាប! ខ្ញុំសូមបង្ហាញជូនអ្នកនូវការបកប្រែអត្ថបទ "គន្លឹះ Docker: សម្អាតម៉ាស៊ីនក្នុងស្រុករបស់អ្នក" អ្នកនិពន្ធ Luc Juggery.

ថ្ងៃនេះយើងនឹងនិយាយអំពីរបៀបដែល Docker ប្រើទំហំថាសរបស់ម៉ាស៊ីនម៉ាស៊ីន ហើយយើងក៏នឹងស្វែងយល់ពីរបៀបដកទំហំនេះចេញពីសំណល់នៃរូបភាព និងធុងដែលមិនបានប្រើផងដែរ។

ការប្រើប្រាស់សរុប

Docker គឺជារឿងដ៏ត្រជាក់មួយ ប្រហែលជាមានមនុស្សតិចណាស់ដែលសង្ស័យវាសព្វថ្ងៃនេះ។ កាលពីប៉ុន្មានឆ្នាំមុន ផលិតផលនេះបានផ្តល់ឱ្យយើងនូវវិធីថ្មីទាំងស្រុងក្នុងការសាងសង់ ចែកចាយ និងដំណើរការបរិស្ថានណាមួយ ដែលអនុញ្ញាតឱ្យយើងរក្សាទុកធនធាន CPU និង RAM យ៉ាងច្រើន។ បន្ថែមពីលើនេះ (ហើយសម្រាប់មួយចំនួននេះនឹងក្លាយជារឿងសំខាន់បំផុត) Docker បានអនុញ្ញាតឱ្យយើងធ្វើឱ្យមានភាពសាមញ្ញ និងបង្រួបបង្រួមការគ្រប់គ្រងវដ្តជីវិតនៃបរិស្ថានផលិតកម្មរបស់យើង។

ទោះជាយ៉ាងណាក៏ដោយ ភាពរីករាយទាំងអស់នៃជីវិតសម័យទំនើបនេះមកក្នុងតម្លៃមួយ។ នៅពេលដែលយើងដំណើរការកុងតឺន័រ ទាញយក ឬបង្កើតរូបភាពផ្ទាល់ខ្លួនរបស់យើង ហើយដាក់ពង្រាយប្រព័ន្ធអេកូស្មុគ្រស្មាញ យើងត្រូវបង់ប្រាក់។ ហើយ​យើង​បង់​ក្នុង​ចំណោម​របស់​ផ្សេង​ទៀត​ជាមួយ​នឹង​ទំហំ​ថាស។

ប្រសិនបើអ្នកមិនធ្លាប់គិតថាតើ Docker ពិតជាយកទំហំប៉ុនណានៅលើម៉ាស៊ីនរបស់អ្នក អ្នកប្រហែលជាភ្ញាក់ផ្អើលដោយលទ្ធផលនៃពាក្យបញ្ជានេះ៖

$ docker system df

វាបង្ហាញពីការប្រើប្រាស់ថាសរបស់ Docker ក្នុងបរិបទផ្សេងៗគ្នា៖

• រូបភាព - ទំហំរូបភាពសរុបដែលត្រូវបានទាញយកពីឃ្លាំងរូបភាព និងបង្កើតនៅលើប្រព័ន្ធរបស់អ្នក។
• ធុង - ចំនួនសរុបនៃទំហំថាសដែលប្រើដោយកុងតឺន័រដែលកំពុងដំណើរការ (មានន័យថាបរិមាណសរុបនៃស្រទាប់អានសរសេរនៃធុងទាំងអស់);
• បរិមាណក្នុងស្រុក - បរិមាណនៃការផ្ទុកមូលដ្ឋានដែលបានម៉ោនទៅធុង;
• បង្កើតឃ្លាំងសម្ងាត់ - ឯកសារបណ្តោះអាសន្នដែលបង្កើតដោយដំណើរការបង្កើតរូបភាព (ដោយប្រើឧបករណ៍ BuildKit ដែលមានចាប់ផ្តើមជាមួយ Docker កំណែ 18.09)។

ខ្ញុំភ្នាល់ថាបន្ទាប់ពីការផ្ទេរដ៏សាមញ្ញនេះ អ្នកពិតជាចង់សម្អាតថាសសំរាមរបស់អ្នក ហើយធ្វើឱ្យជីហ្គាបៃដ៏មានតម្លៃមានជីវិតឡើងវិញ (ចំណាំ៖ ជាពិសេសប្រសិនបើអ្នកបង់ថ្លៃជួលសម្រាប់ជីហ្គាបៃទាំងនេះជារៀងរាល់ខែ)។

ការប្រើប្រាស់ថាសដោយធុង

រាល់ពេលដែលអ្នកបង្កើតកុងតឺន័រនៅលើម៉ាស៊ីនមេ ឯកសារ និងថតឯកសារជាច្រើនត្រូវបានបង្កើតនៅក្នុងថត /var/lib/docker ដែលក្នុងនោះមានដូចខាងក្រោមគួរកត់សម្គាល់៖

• ថត /var/lib/docker/containers/container_ID – នៅពេលប្រើកម្មវិធីបញ្ជាកំណត់ហេតុស្តង់ដារ នេះគឺជាកន្លែងដែលកំណត់ហេតុព្រឹត្តិការណ៍ត្រូវបានរក្សាទុកជាទម្រង់ JSON ។ កំណត់ហេតុលម្អិតពេក ក៏ដូចជាកំណត់ហេតុដែលគ្មាននរណាម្នាក់អាន ឬដំណើរការផ្សេងទៀត ជារឿយៗបណ្តាលឱ្យថាសពេញ។
• ថតឯកសារ /var/lib/docker/overlay2 មានផ្ទុកស្រទាប់អាន-សរសេរ (ជាន់លើ2 គឺជាកម្មវិធីបញ្ជាដែលពេញចិត្តក្នុងការចែកចាយលីនុចភាគច្រើន)។ ប្រសិនបើកុងតឺន័ររក្សាទុកទិន្នន័យនៅក្នុងប្រព័ន្ធឯកសាររបស់វា នោះវាស្ថិតនៅក្នុងថតនេះដែលវានឹងត្រូវបានដាក់។

ចូរយើងស្រមៃមើលប្រព័ន្ធដែល Docker ដ៏មានតម្លៃមួយត្រូវបានដំឡើង ដែលមិនធ្លាប់មានពាក់ព័ន្ធនឹងការបើកដំណើរការកុងតឺន័រ ឬរូបភាពសាងសង់។ របាយការណ៍ការប្រើប្រាស់ទំហំថាសរបស់វានឹងមើលទៅដូចនេះ៖

$ docker system df
TYPE           TOTAL      ACTIVE     SIZE       RECLAIMABLE
Images         0          0          0B         0B
Containers     0          0          0B         0B
Local Volumes  0          0          0B         0B
Build Cache    0          0          0B         0B

តោះចាប់ផ្តើមកុងតឺន័រមួយចំនួនឧទាហរណ៍ NGINX៖

$ docker container run --name www -d -p 8000:80 nginx:1.16

តើមានអ្វីកើតឡើងចំពោះថាស៖

• រូបភាពកាន់កាប់ 126 មេកាបៃ នេះគឺជា NGINX ដូចគ្នាដែលយើងបានដាក់ឱ្យដំណើរការនៅក្នុងកុងតឺន័រ។
• ធុងផ្ទុក 2 បៃគួរឱ្យអស់សំណើច។

$ docker system df
TYPE           TOTAL      ACTIVE     SIZE       RECLAIMABLE
Images         1          1          126M       0B (0%)
Containers     1          1          2B         0B (0%)
Local Volumes  0          0          0B         0B
Build Cache    0          0          0B         0B

ការវិនិច្ឆ័យដោយការសន្និដ្ឋាន យើងមិនទាន់មានកន្លែងណាដែលយើងអាចដោះលែងបានទេ។ ចាប់តាំងពី 2 បៃគឺមិនសមហេតុសមផលទាំងស្រុង ចូរយើងស្រមៃថា NGINX របស់យើងមិនបានរំពឹងទុកនៅកន្លែងណាមួយនៃទិន្នន័យ 100 មេហ្គាបៃ ហើយបានបង្កើតឯកសារ test.img ដែលមានទំហំពិតប្រាកដនៅក្នុងខ្លួនវា។

$ docker exec -ti www 
  dd if=/dev/zero of=test.img bs=1024 count=0 seek=$[1024*100]

ចូរយើងពិនិត្យមើលការប្រើប្រាស់ទំហំថាសនៅលើម៉ាស៊ីនម្តងទៀត។ យើងនឹងឃើញថាកុងតឺន័រ (កុងតឺន័រ) កាន់កាប់ 100 មេហ្គាបៃនៅទីនោះ។

$ docker system df
TYPE           TOTAL      ACTIVE     SIZE       RECLAIMABLE
Images         1          1          126M       0B (0%)
Containers     1          1          104.9MB    0B (0%)
Local Volumes  0          0          0B         0B
Build Cache    0          0          0B         0B

ខ្ញុំគិតថាខួរក្បាលដែលចង់ដឹងចង់ឃើញរបស់អ្នកកំពុងតែងឿងឆ្ងល់ថាតើឯកសារ test.img របស់យើងនៅឯណា។ តោះរកមើលវា៖

$ find /var/lib/docker -type f -name test.img
/var/lib/docker/overlay2/83f177...630078/merged/test.img
/var/lib/docker/overlay2/83f177...630078/diff/test.img

ដោយមិនចាំបាច់ចូលទៅក្នុងព័ត៌មានលម្អិត យើងអាចកត់សម្គាល់ថាឯកសារ test.img មានទីតាំងនៅយ៉ាងងាយស្រួលនៅកម្រិតអាន-សរសេរ ដែលគ្រប់គ្រងដោយកម្មវិធីបញ្ជា overlay2 ។ ប្រសិនបើយើងបញ្ឈប់កុងតឺន័ររបស់យើង ម្ចាស់ផ្ទះនឹងប្រាប់យើងថា ជាគោលការណ៍ កន្លែងនេះអាចត្រូវបានដោះលែងឡើង៖

# Stopping the www container
$ docker stop www

# Visualizing the impact on the disk usage
$ docker system df
TYPE           TOTAL      ACTIVE     SIZE       RECLAIMABLE
Images         1          1          126M       0B (0%)
Containers     1          0          104.9MB    104.9MB (100%)
Local Volumes  0          0          0B         0B
Build Cache    0          0          0B         0B

តើ​យើង​អាច​ធ្វើ​បែប​នេះ​ដោយ​របៀប​ណា? ដោយការលុបកុងតឺន័រ ដែលនឹងរួមបញ្ចូលការសម្អាតចន្លោះដែលត្រូវគ្នានៅកម្រិតអាន-សរសេរ។

ដោយប្រើពាក្យបញ្ជាខាងក្រោម អ្នកអាចដកកុងតឺន័រដែលបានដំឡើងទាំងអស់ចេញហើយលុបថាសរបស់អ្នកនៃឯកសារអានសរសេរទាំងអស់ដែលបង្កើតឡើងដោយពួកវា៖

$ docker container prune
WARNING! This will remove all stopped containers.
Are you sure you want to continue? [y/N] y
Deleted Containers:
5e7f8e5097ace9ef5518ebf0c6fc2062ff024efb495f11ccc89df21ec9b4dcc2

Total reclaimed space: 104.9MB

ដូច្នេះ យើងបានរំដោះ 104,9 មេកាបៃដោយលុបកុងតឺន័រ។ ប៉ុន្តែ​ដោយសារ​យើង​លែង​ប្រើ​រូបភាព​ដែល​បាន​ទាញ​យក​ពី​មុន វា​ក៏​ក្លាយ​ជា​បេក្ខភាព​សម្រាប់​ការ​លុប និង​រំដោះ​ធនធាន​របស់​យើង៖

$ docker system df
TYPE           TOTAL      ACTIVE     SIZE       RECLAIMABLE
Images         1          0          126M       126M (100%)
Containers     0          0          0B         0B
Local Volumes  0          0          0B         0B
Build Cache    0          0          0B         0B

ចំណាំ៖ ដរាបណារូបភាពត្រូវបានប្រើប្រាស់ដោយយ៉ាងហោចណាស់ធុងមួយ អ្នកនឹងមិនអាចប្រើល្បិចនេះបានទេ។

ពាក្យ​បញ្ជា​រង​ដែល​យើង​បាន​ប្រើ​ខាង​លើ​មាន​ឥទ្ធិពល​លើ​កុងតឺន័រ​ដែល​បាន​បញ្ឈប់​ប៉ុណ្ណោះ។ ប្រសិនបើយើងចង់លុបមិនត្រឹមតែឈប់ប៉ុណ្ណោះទេ ប៉ុន្តែក៏ដំណើរការកុងតឺន័រផងដែរ យើងគួរប្រើពាក្យបញ្ជាមួយក្នុងចំណោមពាក្យបញ្ជាទាំងនេះ៖

# Historical command
$ docker rm -f $(docker ps –aq)

# More recent command
$ docker container rm -f $(docker container ls -aq)

ចំណាំចំហៀង៖ ប្រសិនបើអ្នកប្រើប៉ារ៉ាម៉ែត្រ -rm នៅពេលចាប់ផ្តើមកុងតឺន័រ នោះនៅពេលដែលវាឈប់ នោះទំហំថាសទាំងអស់ដែលវាកាន់កាប់នឹងត្រូវបានដោះលែង។

ការប្រើប្រាស់រូបភាពឌីស

កាលពីប៉ុន្មានឆ្នាំមុន ទំហំរូបភាពជាច្រើនរយមេកាបៃគឺធម្មតាទាំងស្រុង៖ រូបភាពអ៊ូប៊ុនទូមានទម្ងន់ 600 មេកាបៃ ហើយរូបភាព Microsoft .Net មានទម្ងន់ជាច្រើនជីហ្គាបៃ។ នៅក្នុងថ្ងៃដ៏ក្រៀមក្រំទាំងនោះ ការទាញយករូបភាពតែមួយអាចចំណាយច្រើនលើទំហំថាសទំនេររបស់អ្នក ទោះបីជាអ្នកកំពុងចែករំលែកកម្រិតរវាងរូបភាពក៏ដោយ។ ថ្ងៃនេះ - សូមសរសើរដល់អ្នកដ៏អស្ចារ្យ - រូបភាពមានទម្ងន់តិច ប៉ុន្តែទោះបីជាដូច្នេះក៏ដោយ អ្នកអាចបំពេញធនធានដែលមានបានយ៉ាងឆាប់រហ័ស ប្រសិនបើអ្នកមិនប្រុងប្រយ័ត្នខ្លះ។

មានរូបភាពជាច្រើនប្រភេទ ដែលអ្នកប្រើប្រាស់មិនអាចមើលឃើញដោយផ្ទាល់៖

• រូបភាពកម្រិតមធ្យម ដោយផ្អែកលើរូបភាពផ្សេងទៀតត្រូវបានប្រមូល - ពួកវាមិនអាចលុបបានទេ ប្រសិនបើអ្នកប្រើកុងតឺន័រដោយផ្អែកលើរូបភាព "ផ្សេងទៀត" ទាំងនេះ។
• រូបភាព dangling គឺជារូបភាពកម្រិតមធ្យមដែលមិនត្រូវបានយោងដោយកុងតឺន័រដែលកំពុងដំណើរការណាមួយឡើយ - ពួកគេអាចលុបបាន។
• ដោយ​ប្រើ​ពាក្យ​បញ្ជា​ខាង​ក្រោម​នេះ អ្នក​អាច​ពិនិត្យ​មើល​រូបភាព​ដែល​ជាប់​ក្នុង​ប្រព័ន្ធ​របស់​អ្នក៖

$ docker image ls -f dangling=true
REPOSITORY  TAG      IMAGE ID         CREATED             SIZE
none      none   21e658fe5351     12 minutes ago      71.3MB

អ្នកអាចយកពួកវាចេញតាមវិធីខាងក្រោម៖

$ docker image rm $(docker image ls -f dangling=true -q)

យើងក៏អាចប្រើពាក្យបញ្ជារង prune:

$ docker image prune
WARNING! This will remove all dangling images.
Are you sure you want to continue? [y/N] y
Deleted Images:
deleted: sha256:143407a3cb7efa6e95761b8cd6cea25e3f41455be6d5e7cda
deleted: sha256:738010bda9dd34896bac9bbc77b2d60addd7738ad1a95e5cc
deleted: sha256:fa4f0194a1eb829523ecf3bad04b4a7bdce089c8361e2c347
deleted: sha256:c5041938bcb46f78bf2f2a7f0a0df0eea74c4555097cc9197
deleted: sha256:5945bb6e12888cf320828e0fd00728947104da82e3eb4452f

Total reclaimed space: 12.9kB

ប្រសិនបើភ្លាមៗយើងចង់លុបរូបភាពទាំងអស់ទាំងស្រុង (ហើយមិនគ្រាន់តែ dangling) ដោយប្រើពាក្យបញ្ជាមួយនោះ យើងអាចធ្វើដូចនេះបាន៖

$ docker image rm $(docker image ls -q)

ការប្រើប្រាស់ថាសតាមបរិមាណ

បរិមាណត្រូវបានប្រើដើម្បីរក្សាទុកទិន្នន័យនៅខាងក្រៅប្រព័ន្ធឯកសាររបស់កុងតឺន័រ។ ឧទាហរណ៍ ប្រសិនបើយើងចង់រក្សាទុកលទ្ធផលនៃកម្មវិធី ដើម្បីប្រើប្រាស់វាតាមវិធីផ្សេង។ ឧទាហរណ៍ទូទៅគឺមូលដ្ឋានទិន្នន័យ។

តោះបើកដំណើរការកុងតឺន័រ MongoDB ភ្ជាប់ភាគខាងក្រៅទៅកុងតឺន័រ ហើយស្ដារការបម្រុងទុកមូលដ្ឋានទិន្នន័យពីវា (យើងមានវានៅក្នុងឯកសារ bck.json)៖

# Running a mongo container
$ docker run --name db -v $PWD:/tmp -p 27017:27017 -d mongo:4.0

# Importing an existing backup (from a huge bck.json file)
$ docker exec -ti db mongoimport 
  --db 'test' 
  --collection 'demo' 
  --file /tmp/bck.json 
  --jsonArray

ទិន្នន័យនឹងមានទីតាំងនៅលើម៉ាស៊ីនមេនៅក្នុងថត /var/lib/docker/volumes ។ ប៉ុន្តែហេតុអ្វីបានជាមិននៅកម្រិតអាន-សរសេរនៃធុង? ដោយសារតែនៅក្នុង Dockerfile នៃរូបភាព MongoDB ថត /data/db (ដែល MongoDB រក្សាទុកទិន្នន័យរបស់វាតាមលំនាំដើម) ត្រូវបានកំណត់ជាភាគ។

ចំណាំចំហៀង៖ រូបភាពជាច្រើនដែលត្រូវតែបង្កើតទិន្នន័យប្រើប្រាស់បរិមាណដើម្បីរក្សាទុកទិន្នន័យនោះ។

នៅពេលដែលយើងលេងឱ្យបានគ្រប់គ្រាន់ជាមួយ MongoDB ហើយបញ្ឈប់ (ឬប្រហែលជាលុប) កុងតឺន័រ កម្រិតសំឡេងនឹងមិនត្រូវបានលុបឡើយ។ វានឹងបន្តយកទំហំថាសដ៏មានតម្លៃរបស់យើងរហូតដល់យើងលុបវាយ៉ាងច្បាស់ដោយប្រើពាក្យបញ្ជាដូចនេះ៖

$ docker volume rm $(docker volume ls -q)

ឬយើងអាចប្រើពាក្យបញ្ជារង prune ដែលធ្លាប់ស្គាល់យើងរួចហើយ៖

$ docker volume prune
WARNING! This will remove all local volumes not used by at least one container.
Are you sure you want to continue? [y/N] y
Deleted Volumes:
d50b6402eb75d09ec17a5f57df4ed7b520c448429f70725fc5707334e5ded4d5
8f7a16e1cf117cdfddb6a38d1f4f02b18d21a485b49037e2670753fa34d115fc
599c3dd48d529b2e105eec38537cd16dac1ae6f899a123e2a62ffac6168b2f5f
...
732e610e435c24f6acae827cd340a60ce4132387cfc512452994bc0728dd66df
9a3f39cc8bd0f9ce54dea3421193f752bda4b8846841b6d36f8ee24358a85bae
045a9b534259ec6c0318cb162b7b4fca75b553d4e86fc93faafd0e7c77c79799
c6283fe9f8d2ca105d30ecaad31868410e809aba0909b3e60d68a26e92a094da

Total reclaimed space: 25.82GB
luc@saturn:~$

ប្រើថាសសម្រាប់បង្កើតឃ្លាំងសម្ងាត់រូបភាព

នៅក្នុង Docker 18.09 ដំណើរការបង្កើតរូបភាពបានឆ្លងកាត់ការផ្លាស់ប្តូរមួយចំនួន ដោយសារឧបករណ៍ BuildKit ។ រឿងនេះបង្កើនល្បឿនដំណើរការ និងបង្កើនប្រសិទ្ធភាពការផ្ទុកទិន្នន័យ និងការគ្រប់គ្រងសុវត្ថិភាព។ នៅទីនេះយើងនឹងមិនពិចារណាលម្អិតទាំងអស់នៃឧបករណ៍ដ៏អស្ចារ្យនេះទេ យើងនឹងផ្តោតតែលើរបៀបដែលវាដោះស្រាយបញ្ហានៃការប្រើប្រាស់ទំហំថាសប៉ុណ្ណោះ។

ចូរនិយាយថាយើងមានកម្មវិធី Node.Js សាមញ្ញទាំងស្រុង៖

• ឯកសារ index.js ចាប់ផ្តើមម៉ាស៊ីនមេ HTTP សាមញ្ញដែលឆ្លើយតបជាមួយបន្ទាត់ទៅនឹងសំណើនីមួយៗដែលទទួលបាន៖
• ឯកសារ package.json កំណត់ភាពអាស្រ័យ ដែលមានតែ expressjs ប៉ុណ្ណោះដែលត្រូវបានប្រើដើម្បីដំណើរការម៉ាស៊ីនមេ HTTP៖

$ cat index.js
var express = require('express');
var util    = require('util');
var app = express();
app.get('/', function(req, res) {
  res.setHeader('Content-Type', 'text/plain');
  res.end(util.format("%s - %s", new Date(), 'Got Request'));
});
app.listen(process.env.PORT || 80);

$ cat package.json
    {
      "name": "testnode",
      "version": "0.0.1",
      "main": "index.js",
      "scripts": {
        "start": "node index.js"
      },
      "dependencies": {
        "express": "^4.14.0"
      }
    }

Dockerfile សម្រាប់បង្កើតរូបភាពមើលទៅដូចនេះ៖

FROM node:13-alpine
COPY package.json /app/package.json
RUN cd /app && npm install
COPY . /app/
WORKDIR /app
EXPOSE 80
CMD ["npm", "start"]

តោះបង្កើតរូបភាពតាមរបៀបធម្មតា ដោយមិនប្រើ BuildKit៖

$ docker build -t app:1.0 .

ប្រសិនបើយើងពិនិត្យមើលការប្រើប្រាស់ទំហំថាស យើងអាចឃើញថាមានតែរូបភាពមូលដ្ឋាន (node:13-alpine) និងរូបភាពទិសដៅ (app:1.0) ប៉ុណ្ណោះដែលកំពុងយកទំហំផ្ទុក៖

TYPE           TOTAL      ACTIVE     SIZE       RECLAIMABLE
Images         2          0          109.3MB    109.3MB (100%)
Containers     0          0          0B         0B
Local Volumes  0          0          0B         0B
Build Cache    0          0          0B         0B

តោះបង្កើតកំណែទីពីរនៃកម្មវិធីរបស់យើង ដោយប្រើ BuildKit ។ ដើម្បីធ្វើដូចនេះយើងគ្រាន់តែត្រូវកំណត់អថេរ DOCKER_BUILDKIT ទៅ 1៖

$ DOCKER_BUILDKIT=1 docker build -t app:2.0 .

ប្រសិនបើឥឡូវនេះយើងពិនិត្យមើលការប្រើប្រាស់ថាស យើងនឹងឃើញថា ឃ្លាំងសម្ងាត់សាងសង់ (buid-cache) ឥឡូវនេះពាក់ព័ន្ធនៅទីនោះ៖

$ docker system df
TYPE           TOTAL      ACTIVE     SIZE       RECLAIMABLE
Images         2          0          109.3MB    109.3MB (100%)
Containers     0          0          0B         0B
Local Volumes  0          0          0B         0B
Build Cache    11         0          8.949kB    8.949kB

ដើម្បីជម្រះវា ប្រើពាក្យបញ្ជាខាងក្រោម៖

$ docker builder prune
WARNING! This will remove all dangling build cache.
Are you sure you want to continue? [y/N] y
Deleted build cache objects:
rffq7b06h9t09xe584rn4f91e
ztexgsz949ci8mx8p5tzgdzhe
3z9jeoqbbmj3eftltawvkiayi

Total reclaimed space: 8.949kB

លុបចេញ​ទាំងអស់!

ដូច្នេះ យើងបានពិនិត្យមើលការសម្អាតទំហំថាសដែលកាន់កាប់ដោយធុង រូបភាព និងបរិមាណ។ ពាក្យបញ្ជារង prune ជួយយើងជាមួយនេះ។ ប៉ុន្តែវាក៏អាចប្រើនៅកម្រិតប្រព័ន្ធ docker ហើយវានឹងសម្អាតអ្វីៗគ្រប់យ៉ាងដែលវាអាចធ្វើបាន៖

$ docker system prune
WARNING! This will remove:
  - all stopped containers
  - all networks not used by at least one container
  - all dangling images
  - all dangling build cache

Are you sure you want to continue? [y/N]

ប្រសិនបើសម្រាប់ហេតុផលមួយចំនួនដែលអ្នកកំពុងសន្សំទំហំថាសនៅលើម៉ាស៊ីនដែលកំពុងដំណើរការ Docker បន្ទាប់មកការដំណើរការពាក្យបញ្ជានេះជាទៀងទាត់គួរតែក្លាយជាទម្លាប់។

ប្រភព: www.habr.com