Pentadbiran sistem

Cara Membina Gambar Docker Menggunakan Dockerfile

Cara Membina Gambar Docker Menggunakan Dockerfile

Kemahiran Docker sangat tinggi kerana, terima kasih kepada Docker Kami boleh mengautomasikan penggunaan aplikasi yang dipanggil bekas, mewujudkan persekitaran yang disesuaikan yang boleh direplikasi dengan mudah di mana sahaja Docker Teknologi disokong. Dalam tutorial ini kita akan melihat cara membuat a Imej Docker Dari awal, menggunakan a Dockerfile. Kami akan mempelajari arahan yang paling penting yang boleh kami gunakan untuk menyesuaikan imej kami, bagaimana membina imej, dan bagaimana untuk menjalankan bekas berdasarkannya.

Dalam tutorial ini anda akan belajar:

  • Cara membuat imej Docker menggunakan Dockerfile
  • Beberapa arahan dockerfile yang paling kerap digunakan
  • Cara mencapai kegigihan data dalam bekas


Keperluan perisian dan konvensyen yang digunakan

Keperluan Perisian dan Konvensyen Talian Perintah Linux
Kategori Keperluan, konvensyen atau versi perisian yang digunakan
Sistem OS-bebas
Perisian Docker
Yang lain
  • Daemon Docker Running
  • Utiliti baris arahan docker
  • Kebiasaan dengan antara muka baris arahan Linux
Konvensyen # - Memerlukan arahan Linux yang diberikan untuk dilaksanakan dengan keistimewaan akar sama ada secara langsung sebagai pengguna root atau dengan menggunakan sudo perintah
$ - Memerlukan arahan Linux yang diberikan sebagai pengguna yang tidak layak

Imej dan bekas

Sebelum kita memulakan, mungkin berguna untuk menentukan dengan jelas apa yang kita maksudkan ketika kita bercakap imej dan bekas dalam konteks Docker. Imej boleh dianggap sebagai blok bangunan dunia Docker. Mereka mewakili "cetak biru" yang digunakan untuk membuat bekas. Sesungguhnya, apabila bekas dicipta, ia mewakili contoh konkrit imej yang berdasarkannya.

Banyak bekas boleh dibuat dari gambar yang sama. Selebihnya artikel ini kita akan belajar bagaimana memberikan arahan yang diperlukan untuk membuat imej yang disesuaikan dengan keperluan kita di dalam Dockerfile, Cara Betul Membina Imej, Dan Cara Menjalankan Bekas Berdasarkannya.

Bina gambar kita sendiri menggunakan fail docker

Untuk membina imej kita sendiri, kita akan menggunakan a Dockerfile. Dockerfile mengandungi semua arahan yang diperlukan untuk membuat dan menyiapkan gambar. Sebaik sahaja Dockerfile kami siap, kami akan menggunakannya Docker membina perintah untuk benar -benar membina gambar.

Perkara pertama yang harus kita lakukan ialah membuat direktori baru untuk menjadi tuan rumah projek kami. Demi tutorial ini kita akan membina imej yang mengandungi Apache Pelayan web, jadi kami akan menamakan direktori root projek "dockerized-apache":

$ mkdir dockerized-apache

Direktori ini adalah apa yang kita panggil membina konteks. Semasa proses membina, semua fail dan direktori yang terkandung di dalamnya, termasuk Dockerfile Kami akan membuat, dihantar ke daemon docker supaya mereka dapat diakses dengan mudah, kecuali jika mereka disenaraikan ke dalam .DocKerignore fail.

Mari buat kita Dockerfile. Fail mesti dipanggil Dockerfile dan akan mengandungi, seperti yang kita katakan di atas, semua arahan yang diperlukan untuk membuat imej dengan ciri -ciri yang dikehendaki. Kami membakar editor teks kegemaran kami dan mulakan dengan menulis arahan berikut:

Dari Ubuntu: 18.10 Label Penyelenggara = "[email protected] "
Salinan

Arahan pertama yang mesti kami sediakan adalah Dari: dengan itu kita dapat menentukan imej yang ada yang akan kita gunakan sebagai pangkalan (ini dipanggil a imej asas), untuk mencipta sendiri. Dalam hal ini imej asas kita akan Ubuntu. Selain nama gambar, kami juga menggunakan tag, untuk menentukan versi imej yang ingin kami gunakan, dalam kes ini 18.10. Sekiranya tiada tag yang dinyatakan terkini Tag digunakan secara lalai: ini akan menyebabkan versi terkini imej asas yang akan digunakan. Sekiranya gambar belum ada di sistem kami, ia akan dimuat turun dari DockerHub.

Selepas Dari arahan, kami menggunakan Label. Arahan ini adalah pilihan, boleh diulang beberapa kali, dan digunakan untuk menambah metadata ke imej kami. Dalam kes ini kami menggunakannya untuk menentukan penyelenggara imej.

Arahan larian

Pada ketika ini, jika kita berlari Docker membina, Kami hanya akan menghasilkan imej yang sama dengan asas, kecuali metadata yang kami tambah. Ini tidak akan berguna untuk kita. Kami mengatakan bahawa kami mahu "dockerize" Apache pelayan web, jadi perkara seterusnya yang perlu dilakukan di kami Dockerfile, adalah untuk memberikan arahan untuk memasang pelayan web sebagai sebahagian daripada imej. Arahan yang membolehkan kita menyelesaikan tugas ini adalah Jalankan:

Dari Ubuntu: 18.10 Label Penyelenggara = "[email protected] "run apt-get update & apt-get -y install Apache2
Salinan

The Jalankan Arahan digunakan untuk melaksanakan arahan di atas gambar. Satu perkara yang sangat penting untuk diingat ialah untuk setiap Jalankan arahan yang kami gunakan, a lapisan baru dibuat dan ditambah pada timbunan. Mengenai hal ini Docker sangat pintar: Lapisan yang sudah dibina akan "di -cache": ini bermakna bahawa jika kita membina imej berdasarkan kita Dockerfile, Dan kemudian kami memutuskan, sebagai contoh, untuk menambah yang lain Jalankan Arahan (dan dengan itu lapisan baru) pada akhirnya, binaan tidak akan bermula dari awal, tetapi hanya akan menjalankan arahan baru.

Untuk ini berlaku, tentu saja, arahan yang telah dibina di atas Dockerfile tidak boleh diubah suai. Malah mungkin untuk mengelakkan tingkah laku ini sepenuhnya semasa membina imej, hanya menggunakan --tidak sakit Pilihan Docker membina perintah.

Dalam kes kami kami menggunakan Jalankan arahan untuk melaksanakan apt-get update & apt-get -y install Apache2 Perintah. Perhatikan bagaimana kita melewati -y pilihan untuk apt-get pemasangan Perintah: Pilihan ini dibuat supaya jawapan afirmatif diberikan secara automatik kepada semua pengesahan yang diperlukan oleh arahan. Ini perlu kerana kita memasang pakej yang tidak interaktif.

Mendedahkan port 80

Seperti yang kita ketahui, pelayan web Apache mendengarkan port 80 untuk sambungan standard. Kita mesti mengarahkan Docker untuk menjadikan pelabuhan itu boleh diakses di bekas. Untuk melaksanakan tugas kami menggunakan Dedahkan berfungsi dan berikan nombor port. Atas sebab keselamatan pelabuhan yang ditentukan hanya dibuka apabila bekas dilancarkan. Mari tambahkan arahan ini kepada kami Dockerfile:

Dari Ubuntu: 18.10 Label Penyelenggara = "[email protected] "run apt-get update & & apt-get -y install Apache2 dedahkan 80
Salinan

Membina imej

Pada ketika ini kita sudah dapat berusaha membina gambar kita. Dari dalam direktori akar projek kami, "dockerized-apache", kami menjalankan arahan berikut:

$ sudo docker binaan -t linuxconfig/dockerized -apache .

Mari kita periksa arahan. Pertama sekali, kami mengutamakan arahan dengan sudo, untuk menjalankannya dengan keistimewaan pentadbiran. Adalah mungkin untuk mengelakkan ini, dengan menambahkan pengguna ke Docker kumpulan, tetapi ini mewakili risiko keselamatan. The -t pilihan yang kami berikan, pendek untuk --tag, Marilah kita memohon nama repositori dan secara pilihan tag pada imej kita jika binaan berjaya.

Akhirnya, . mengarahkan Docker untuk mencari Dockerfile Dalam direktori semasa. Sebaik sahaja kami melancarkan arahan, proses binaan akan bermula. Perkembangan dan membina mesej akan dipaparkan di skrin:

Menghantar Konteks Membina ke Docker Daemon 2.048 KB Langkah 1/4: Dari Ubuntu: 18.10 cuba menarik Docker repositori.io/perpustakaan/ubuntu .. . [… .]
Salinan

Dalam beberapa minit imej kita mesti dibuat dengan jayanya. Untuk mengesahkannya, kita boleh menjalankan Imej Docker Perintah, yang mengembalikan senarai semua imej yang ada di repositori Docker tempatan kami:

$ sudo docker imej repositori tag imej ID dicipta saiz linuxconfig/dockerized-apache terbaru 7ab7b6873614 2 minit yang lalu 191 mb
Salinan

Seperti yang dijangkakan gambar muncul dalam senarai. Seperti yang dapat kita perhatikan, kerana kita tidak memberikan tag (hanya nama repositori, linuxconfig/dockerized-apache) terkini Tag telah digunakan secara automatik untuk gambar kami. An ID telah juga diberikan kepada IT, 7AB7B6873614: kita boleh menggunakannya untuk merujuk imej dalam arahan masa depan.

Melancarkan bekas berdasarkan gambar

Sekarang gambar kami sudah siap, kami boleh membuat dan melancarkan a bekas berdasarkannya. Untuk melaksanakan tugas kami menggunakan Docker Run Perintah:

$ sudo docker run --name = linuxconfig -apache -d -p 8080: 80 linuxconfig/dockerized -apache apachectl -d foreground

Mari kita periksa arahan di atas. Pilihan pertama yang kami berikan ialah --nama: Dengan itu, kami menentukan nama untuk bekas, dalam kes ini "Linuxconfig-Apache". Sekiranya kami menghilangkan pilihan ini, nama yang dihasilkan secara rawak akan diberikan kepada bekas kami.

The -d pilihan (pendek untuk --tanggalkan) menyebabkan bekas berjalan di latar belakang.

The -p pilihan, pendek untuk --menerbitkan, diperlukan untuk menerbitkan port kontena (atau pelbagai port) ke sistem tuan rumah. Sintaks pilihan adalah seperti berikut:

-p localhost_port: container_port

Dalam kes ini kami menerbitkan port 80 Kami sebelum ini terdedah di dalam bekas, ke tuan rumah pelabuhan 8080. Demi kesempurnaan kita mesti mengatakan bahawa ia juga mungkin untuk menggunakan -P pilihan (pendek untuk --menerbitkan-semua) sebaliknya, menyebabkan semua pelabuhan terdedah di dalam bekas rawak pelabuhan di tuan rumah.

Dua perkara terakhir yang kami tentukan dalam arahan di atas, adalah: gambar bekas harus berdasarkan, dan perintah untuk dijalankan ketika bekas dimulakan, yang merupakan pilihan. Gambar tentu saja linuxconfig/dockerized-apache, yang kami bina sebelum ini.

Perintah yang kami tentukan adalah Apachectl -d latar depan. Dengan arahan ini Apache Pelayan web dilancarkan di latar depan Mod: Ini adalah wajib untuk bekerja di bekas. The Docker Run Perintah menjalankan arahan yang ditentukan pada a baru bekas:

$ sudo docker run --name = linuxconfig -apache -d -p 8080: 80 linuxconfig/dockerized -apachectl -d foreground a51fc9a6dd66b02117f00235A341003A9BF0F0F90A0A0B10F90
Salinan

Berapakah nombor yang dicetak di skrin? Ia adalah ID dari bekas! Sebaik sahaja kita mempunyai bekas dan berjalan, kita sepatutnya dapat mengakses halaman yang disampaikan oleh lalai Apache Virtualhost di Localhost: 8080 alamat (port 8080 di tuan rumah dipetakan di pelabuhan 80 di bekas):



Indeks Apache lalai.Halaman HTML

Persediaan kami berfungsi dengan betul. Sekiranya kita menjalankan Docker PS Perintah, yang menyenaraikan semua bekas aktif dalam sistem, kita boleh mendapatkan maklumat mengenai bekas kami: id (versi pendek, lebih mudah untuk merujuk membentuk baris arahan untuk manusia), imej yang dikendalikannya, perintah yang digunakan, penciptaannya masa dan status semasa, pemetaan dan nama pelabuhan.

$ sudo docker ps container id image command created status port names a51fc9a6dd66 linuxconfig/dockerized -apache "apachectl -d fore ..." 28 saat yang lalu sehingga 28 saat 0.0.0.0: 8080-> 80/TCP linuxconfig-apache
Salinan

Untuk menghentikannya bekas yang perlu kita lakukan adalah merujuknya dengan id atau namanya, dan jalankan Docker berhenti perintah. Sebagai contoh:

$ sudo docker stop linuxconfig-apache

Untuk memulakannya lagi:

$ sudo docker mula linuxconfig-apache

Jalankan arahan secara langsung melalui Dockerfile

Sejak di sini kami membina imej asas, dan pada masa runtime, menggunakan Docker Run perintah, kami menetapkan arahan yang akan dilancarkan apabila bekas dimulakan. Kadang -kadang kita mahu menentukan yang terakhir terus di dalam fail docker. Kita boleh melakukannya dalam dua cara: menggunakan Cmd atau Entrypoint.

Kedua -dua arahan boleh digunakan untuk tujuan yang sama tetapi mereka berkelakuan berbeza apabila arahan juga ditentukan dari baris arahan. Mari kita lihat bagaimana.

Arahan CMD

The Cmd Arahan pada dasarnya boleh digunakan dalam dua bentuk. Yang pertama adalah EXEC Bentuk:

CMD ["/usr/sbin/apachectl", "-d", "latar depan"]

Yang lain adalah shell Bentuk:

CMD/USR/SBIN/APACHECTL -D FOREGREAT

The EXEC dari biasanya lebih disukai. Perlu diperhatikan bahawa apabila menggunakan borang EXEC, shell tidak dipanggil, oleh itu pengembangan berubah -ubah tidak akan berlaku. Sekiranya pengembangan berubah diperlukan, kita boleh menggunakan shell bentuk atau kita boleh menggunakan cangkang secara langsung di EXEC mod, sebagai:

Cmd ["sh", "-c", "echo", "$ home"]

The Cmd Arahan boleh ditentukan hanya sekali di Dockerfile. Jika berbilang Cmd pilihan disediakan, hanya yang terakhir akan berkuat kuasa. Tujuan arahan adalah untuk menyediakan a lalai Perintah yang akan dilancarkan apabila bekas bermula:

Dari Ubuntu: 18.10 Label Penyelenggara = "[email protected] "run apt-get update & & apt-get -y install Apache2 dedahkan 80 cmd ["/usr/sbin/apachectl "," -d "," latar depan "]
Salinan

Arahan yang ditentukan dengan Cmd di dalam Dockerfile, berfungsi sebagai lalai, dan akan ditindih jika arahan lain ditentukan dari baris arahan semasa melaksanakan Docker Run.

Arahan entrypoint

The Entrypoint arahan juga boleh digunakan untuk mengkonfigurasi arahan untuk digunakan apabila bekas dimulakan, dan suka Cmd, kedua -dua EXEC dan shell bentuk boleh digunakan dengannya. Perbezaan besar antara keduanya adalah bahawa arahan yang diluluskan dari baris arahan tidak akan mengatasi yang ditentukan Entrypoint: Sebaliknya ia akan menjadi dilampirkan kepadanya.

Dengan menggunakan arahan ini, kami dapat menentukan arahan asas dan mengubahnya dengan pilihan yang kami sediakan semasa menjalankan Docker-Run perintah, menjadikan bekas kita berkelakuan seperti boleh dilaksanakan. Mari lihat contoh dengan kita Dockerfile:

Dari Ubuntu: 18.10 Label Penyelenggara = "[email protected] "run apt-get update & & apt-get -y install Apache2 dedahkan 80 entrypoint ["/usr/sbin/apachectl "]
Salinan

Dalam kes ini kita menggantikannya Cmd arahan dengan Entrypoint dan juga mengeluarkan -D Foreground Pilihan dari format EXEC. Katakan kita sekarang membina semula imej, dan mencipta bekas menggunakan arahan berikut:

$ sudo docker run --name = linuxconfig -apache -d -p 8080: 80 linuxconfig/dockerized -apache -d foreground

Apabila bekas bermula, -D Foreground Argumen dilampirkan kepada arahan yang disediakan di Dockerfile dengan Entrypoint arahan, tetapi hanya jika menggunakan EXEC bentuk. Ini dapat disahkan dengan menjalankan Docker PS Perintah (di sini kami menambah beberapa pilihan kepada arahan, untuk memaparkan dan memformat outputnya dengan lebih baik, hanya memilih maklumat yang kami perlukan):

$ sudo docker ps --no-trunc --format ".Nama \ t .Perintah "Linuxconfig -APache"/usr/sbin/Apachectl -d foreground "
Salinan

Seperti Cmd, The Entrypoint Arahan boleh disediakan hanya satu masa. Sekiranya ia kelihatan berbilang masa di Dockerfile, hanya kejadian terakhir yang akan dipertimbangkan. Adalah mungkin untuk mengatasi lalai Entrypoint gambar dari baris arahan, dengan menggunakan --entrypoint Pilihan Docker Run perintah.

Menggabungkan CMD dan EntryPoint

Sekarang kita tahu keunikan Cmd dan Entrypoint Arahan Kami juga boleh menggabungkannya. Apa yang dapat kita peroleh dengan melakukannya? Kita boleh guna Entrypoint untuk menentukan arahan asas yang sah, dan Cmd Arahan untuk menentukan parameter lalai untuknya.

Perintah itu akan dijalankan dengan parameter lalai secara lalai, melainkan jika kita mengatasi mereka dari baris arahan semasa berjalan Docker Run. Melekat pada kami Dockerfile, kita boleh menulis:

Dari Ubuntu: 18.10 Label Penyelenggara = "[email protected] "run apt-get update & & apt-get -y install Apache2 dedahkan 80 entrypoint ["/usr/sbin/apachectl "] cmd [" -d "," foreground "]
Salinan

Sekiranya kita membina semula gambar dari ini Dockerfile, keluarkan bekas sebelumnya yang kami buat, dan melancarkan semula Docker Run perintah tanpa menentukan sebarang hujah tambahan, /usr/bin/apachectl -d latar depan Perintah akan dilaksanakan. Sekiranya kita memberikan beberapa hujah, mereka akan menimpa mereka yang dinyatakan dalam Dockerfile dengan Cmd arahan. Sebagai contoh, jika kita menjalankan:

$ sudo docker run --name = linuxconfig -apache -d -p 8080: 80 linuxconfig/dockerized -apache -x

Arahan yang akan dilaksanakan ketika memulakan bekas /usr/bin/apachectl -x. Mari sahkan:

$ sudo docker ps --no-trunc --format ".Nama \ t .Perintah "linuxconfig -apache"/usr/sbin/apachectl -x "
Salinan

Perintah yang dilancarkan, seperti yang diharapkan: -X pilihan, dengan cara, membuat supaya daemon httpd dilancarkan mod debug.

Menyalin fail ke dalam bekas

Pelayan Apache "Dockerized" kami berfungsi. Seperti yang kita lihat, jika kita menavigasi ke Localhost: 8080, Kami memvisualisasikan halaman selamat datang Apache lalai. Sekarang, katakan kami mempunyai laman web yang siap dihantar dengan bekas, bagaimana kami dapat "memuatkan" itu supaya Apache akan melayani?

Nah, demi tutorial ini, kami hanya akan mengganti indeks lalai.Fail HTML. Untuk melaksanakan tugas kita boleh menggunakan SALINAN arahan. Katakan kita mempunyai indeks alternatif.Fail HTML di dalam akar projek kami (konteks binaan kami) dengan kandungan ini:

  
Helo!
 
Fail ini telah disalin ke dalam bekas dengan arahan salinan!
Salinan

Kami mahu memuatkannya dan menyalinnya ke /var/www/html direktori di dalam bekas, oleh itu di dalam kami Dockerfile Kami menambah SALINAN Arahan:

Dari Ubuntu: 18.10 Label Penyelenggara = "[email protected] "run apt-get update &&p-get -y Pasang apache2 dedahkan 80 entrypoint ["/usr/sbin/Apachectl "] cmd [" -d "," foreground "].html/var/www/html/indeks.html
Salinan

Kami membina semula imej dan bekas. Sekiranya sekarang menavigasi ke Localhost: 8080, Kami akan melihat mesej baru:

# mesej baru

The SALINAN Arahan boleh digunakan untuk menyalin kedua -dua fail dan direktori. Apabila jalan destinasi tidak wujud, ia dibuat di dalam bekas. Semua fail dan direktori baru dibuat dengan Uid dan Gid dari 0.

Penyelesaian yang lain untuk menyalin fail di dalam bekas adalah menggunakan TAMBAH arahan, yang lebih kuat daripada SALINAN. Dengan arahan ini kita boleh menyalin fail, direktori tetapi juga URL. Di samping itu, jika kita menyalin tempatan Arkib tar Dengan format termampat yang diiktiraf, ia akan secara automatik tidak dikompresi dan disalin sebagai direktori di dalam bekas.

Strategi yang ideal adalah menggunakan SALINAN Kecuali ciri tambahan yang disediakan oleh TAMBAH sangat diperlukan.

Membuat kelantangan

Dalam contoh sebelumnya, untuk menunjukkan bagaimana SALINAN Arahan berfungsi, kami menggantikan indeks lalai.HTML Fail Apache Virtualhost lalai di dalam bekas.

Jika kita berhenti dan memulakan bekas, kita masih akan mencari pengubahsuaian yang kita buat, tetapi jika bekas atas sebab tertentu dikeluarkan, semua data yang terkandung pada lapisan yang boleh ditulis akan hilang dengannya. Cara menyelesaikan masalah ini? Satu pendekatan adalah menggunakan Kelantangan Arahan:

Dari Ubuntu: 18.10 Label Penyelenggara = "[email protected] "run apt-get update &&p-get -y Pasang apache2 dedahkan 80 entrypoint ["/usr/sbin/Apachectl "] cmd [" -d "," foreground "].html/var/www/html/indeks.HTML VOLUME/VAR/WWW/HTML
Salinan

The Kelantangan Arahan mengambil satu atau lebih direktori (dalam kes ini /var/www/html) dan menyebabkan mereka digunakan sebagai titik gunung untuk jumlah luaran yang dinamakan secara rawak yang dihasilkan apabila bekas dibuat.

Dengan cara ini, data yang kami masukkan ke dalam direktori yang digunakan sebagai titik gunung akan berterusan di dalam jumlah yang dipasang dan masih akan wujud walaupun bekas dimusnahkan. Sekiranya direktori ditetapkan untuk digunakan sebagai titik gunung sudah mengandungi data pada masa permulaan, data tersebut disalin di dalam kelantangan yang dipasang di atasnya.

Mari membina semula gambar dan bekas. Sekarang kita dapat mengesahkan bahawa jumlahnya telah dibuat dan digunakan dengan memeriksa bekas:

$ sudo docker periksa linuxconfig-apache [.. .] "Mounts": [  "Type": "volume", "Name": "8f24f75459c24c491b2a5e53265842068d7c44bf1b0ef54f98b85ad08e673e61", "Source": "/var/lib/docker/volumes/8f24f75459c24c491b2a5e53265842068d7c44bf1b0ef54f98b85ad08e673e61/_data", "Destination": "/var/ www/html "," pemandu ":" tempatan "," mod ":" "," rw ": benar," penyebaran ":" "], [.. .]
Salinan

Seperti yang telah dikatakan, jumlahnya akan bertahan walaupun selepas bekas dimusnahkan sehingga data kami tidak akan hilang.

The Kelantangan arahan di dalam DockeFile, Seperti yang dapat kita lihat dari output perintah periksa docker di atas, menjadikan jumlah yang dinamakan secara rawak dibuat. Untuk menentukan a Volume bernama, atau melancarkan jumlah yang sudah ada di dalam bekas, kita mesti menentukannya semasa runtime, ketika menjalankan Docker Run perintah, menggunakan -v pilihan (pendek untuk --kelantangan). Mari lihat contoh:

$ sudo docker run --name = linuxconfig -apache -d -p 8080: 80 -v myvolume:/var/www/html linuxconfig/dockerized -apache

Dalam perintah di atas, kami menggunakan -v pilihan yang menentukan Nama kelantangan (sangat penting: perhatikan bahawa ia bukan jalan, tetapi nama mudah) dan Mountpoint Di dalam bekas menggunakan sintaks berikut:

:

Apabila kita melakukan perintah sedemikian, jumlah yang dinamakan "myvolume" akan dipasang di laluan tertentu di dalam bekas (jumlahnya akan dibuat jika tidak ada). Seperti yang kita katakan sebelum ini, jika jumlahnya kosong, data yang sudah ada di Gunung Mount di dalam bekas akan disalin di dalamnya. Menggunakan Docker Volume LS Perintah, kami dapat mengesahkan jumlah dengan nama yang kami tentukan telah dibuat:

$ sudo docker volume ls nama volume pemacu myvolume tempatan
Salinan

Untuk mengeluarkan kelantangan yang kami gunakan Docker Volume RM perintah, dan berikan nama kelantangan untuk dibuang. Docker, bagaimanapun, tidak akan membiarkan kita mengeluarkan jumlah yang digunakan oleh bekas aktif:

$ $ sudo docker volume rm myvolume Response ralat dari daemon: tidak dapat mengeluarkan isipadu, isipadu yang masih digunakan: keluarkan myVolume: volume sedang digunakan - [95381B7B6003F6165DFE2E1912D2F827F7167AC26E2CF26CAB704A2
Salinan

Satu lagi pendekatan untuk ketahanan data, terutamanya berguna semasa pembangunan, adalah untuk Bind-mount direktori tuan rumah di dalam bekas. Pendekatan ini mempunyai kelebihan membiarkan kami bekerja pada kod kami secara tempatan dengan alat kegemaran kami dan melihat kesan perubahan yang segera dicerminkan di dalam bekas, tetapi mempunyai kelemahan yang besar: bekas menjadi bergantung kepada struktur direktori tuan rumah.

Atas sebab ini, kerana mudah alih adalah salah satu sasaran utama Docker, tidak mungkin untuk menentukan a Bind-mount Di dalam Dockerfile, tetapi hanya pada waktu runtime. Untuk melaksanakan tugas ini, kami menggunakan -v pilihan Docker Run perintah sekali lagi, tetapi kali ini kami menyediakan jalan direktori di dalam sistem fail tuan rumah dan bukannya nama kelantangan:

$ sudo docker run --name = linuxconfig -apache -d -p 8080: 80 -v/path/on/host:/var/www/html linuxconfig/dockerized -apache

Semasa melancarkan arahan di atas, Direktori/Path/On/Host host akan dipasang pada/var/www/html di dalam bekas. Sekiranya direktori pada tuan rumah tidak wujud, ia dibuat secara automatik. Dalam kes ini data dalam direktori Mountpoint di dalam bekas (/var/www/html dalam contoh kami) adalah tidak disalin ke direktori tuan rumah yang dipasang di atasnya, kerana ia berlaku untuk jumlahnya.

Kesimpulan

Dalam tutorial ini, kami mempelajari konsep asas yang diperlukan untuk membuat dan membina imej docker menggunakan Dockerfile dan cara menjalankan bekas berdasarkannya. Kami membina imej yang sangat mudah yang membolehkan kami menjalankan versi "dockerized" dari pelayan web Apache. Dalam proses itu, kita melihat cara menggunakan Dari arahan, yang wajib untuk menentukan imej asas untuk berfungsi, Label arahan untuk menambah metadata ke imej kami, Dedahkan Arahan untuk mengisytiharkan pelabuhan akan didedahkan di dalam bekas. Kami juga belajar bagaimana memetakan port tersebut ke port sistem tuan rumah.

Kami belajar bagaimana menggunakan
Jalankan arahan untuk menjalankan arahan pada imej, dan kami belajar bagaimana untuk menentukan arahan yang akan dilaksanakan apabila bekas dimulakan dari garis arahan dan di dalamnya Dockerfile. Kami melihat bagaimana untuk mencapai ini dengan menggunakan Cmd dan Entrypoint arahan, dan apakah perbezaan antara kedua -dua. Akhirnya, kita melihat bagaimana SALINAN data di dalam bekas, dan bagaimana untuk mencapai kegigihan data menggunakan jumlah. Dalam contoh kami, kami hanya membincangkan subset kecil arahan yang boleh digunakan dalam a Dockerfile.

Untuk senarai yang lengkap dan terperinci, sila rujuk dokumentasi Docker rasmi. Sementara itu, jika anda ingin tahu bagaimana membina keseluruhan Lampu Stack Menggunakan Docker dan Alat Kompos Docker, anda boleh melihat artikel kami tentang cara membuat timbunan lampu berasaskan docker menggunakan docker-compose pada Ubuntu 18.04 Bionic Beaver Linux.

Tutorial Linux Berkaitan:

  • Pengenalan kepada Automasi, Alat dan Teknik Linux
  • Perkara yang perlu dilakukan setelah memasang ubuntu 20.04 Focal Fossa Linux
  • Perkara yang hendak dipasang di Ubuntu 20.04
  • Cara Gunung ISO di Linux
  • Cara membuat sandaran sistem tambahan dengan timeshift pada ..
  • Kubernet vs docker, apa perbezaannya?
  • Cara mengubah saiz gambar cakera qcow2 di linux
  • Cara membuat timbunan lampu berasaskan Docker menggunakan Docker pada ..
  • Menguasai Gelung Skrip Bash
  • Perkara yang perlu dilakukan setelah memasang Ubuntu 22.04 Jur -ubur Jammy ..