Unlimited WordPress themes, graphics, videos & courses! Unlimited asset downloads! From $16.50/m
Advertisement
  1. Code
  2. Web Development
Code

Mudah Menyebarkan Redis Didukung Aplikasi Web Dengan Docker

by
Difficulty:IntermediateLength:LongLanguages:

Indonesian (Bahasa Indonesia) translation by Yusuf Samin (you can also view the original English article)

Orang-orang yang membuat Docker suka menggambarkannya menggunakan metafora untuk teknologi yang cukup kuno: wadah pengiriman.

Meskipun kita bahkan tidak memikirkan atau memperhatikan mereka sekarang, kontainer pengiriman sebenarnya adalah teknologi yang cukup revolusioner pada masanya. Tidak peduli apa bentuk atau ukuran barang aslinya, dengan menggunakan wadah standar, pemilik kapal/pesawat/truk apa pun yang Anda miliki, dapat dengan mudah mengetahui berapa banyak sumber daya yang mereka butuhkan untuk dialokasikan.

Docker mencoba untuk mengambil tingkat kenyamanan yang sama dan membawanya ke dunia server. Ini adalah ekstensi alami dari alat-alat seperti Vagrant yang memungkinkan Anda untuk menyebarkan mesin virtual yang sama yang Anda gunakan dalam pengembangan ke lingkungan produksi. Mesin virtual gaya gelandangan memang bagus, tetapi mereka kelas berat. Mereka membutuhkan banyak sumber daya untuk dijalankan, banyak yang berlebihan: image Vagrant memuat seluruh salinan baru Linux di dalam yang sudah ada. Bukankah lebih baik jika Anda dapat menggunakan kenyamanan dan keseragaman Vagrant tetapi tidak harus memuat ulang seluruh sistem operasi? Nah, itulah yang dilakukan Docker.

Pengenalan

Dalam tutorial ini, saya akan memandu Anda melalui seluruh alur kerja Docker. Kami pertama-tama akan melalui langkah-langkah untuk mendapatkan aplikasi web Python sederhana yang memiliki beberapa dependensi Python dan bergantung pada database Redis untuk  berjalan. Kemudian kita akan menginstal Docker dan menginstal semua persyaratan aplikasi web (Redis, Python, dan dependensi Python) menjadi satu image Docker. Kami kemudian akan menggunakan image itu dan menyebarkannya ke server yang berbeda.

Kami hanya akan menggunakan aplikasi contoh mainan, tetapi langkah-langkah untuk menyebarkan aplikasi nyata Anda sendiri akan sangat mirip.

Untuk memulai, Anda memerlukan Linux box yang menjalankan versi terbaru Ubuntu atau mesin virtual yang menjalankan versi terbaru Ubuntu. Jika Anda ingin sepenuhnya mengikuti tutorial dan menggunakan aplikasi, maka Anda juga akan membutuhkan mesin kedua (atau mesin virtual kedua) untuk digunakan.

Menginstal Docker

Langkah pertama adalah menginstal Docker sendiri. Docker sedang dalam pengembangan yang sangat cepat, sehingga cara termudah untuk menginstalnya sering berubah dengan sangat cepat. Periksa bagian memulai Docker jika Anda ingin memeriksa ujung tombak.

Jika tidak, ikuti langkah-langkah di bawah ini dan kami akan menyiapkan pemasangan Docker berbasis mesin virtual Vagrant yang akan bekerja pada salah satu sistem operasi utama. Pertama pergilah ke situs web Vagrant dan instal Vagrant dan VirtualBox terbaru untuk OS Anda.

Setelah Vagrant diinstal, buat folder baru, buka command prompt di sana dan lakukan hal berikut:

Vagrant baru saja membuat mesin virtual yang menjalankan Ubuntu 12,04 untuk Anda dan Anda sekarang sudah siap dengan SSH. Kita sekarang dapat mengikuti petunjuk instalasi Ubuntu Docker. Periksa situs web jika ada perubahan sejak ini ditulis, tetapi kemungkinan besar, Anda dapat langsung paste perintah berikut ke terminal:

Anda akan kembali ke prompt mesin lokal Anda ketika VM di reboot, jadi tunggu beberapa saat dan lakukan yang lain:

... untuk SSH kembali ke VM Anda. Sekarang prasyarat Docker telah terinstal dengan sukses, kita harus melanjutkan dan menginstal Docker sendiri. Paste perintah berikut:

... yang akan mengambil skrip instalasi Docker sederhana dari situs Docker dan menjalankannya. Docker sekarang harus diinstal dengan sukses, jadi mari kita mulai bermain dengannya.

Memulai dengan Docker

Setelah apt-get menyelesaikan keajaibannya, lakukan hal berikut:

... untuk memeriksa dan melihat bahwa pemasangan berhasil. Jika berhasil, Docker akan melanjutkan untuk mengunduh image Ubuntu Docker dan setelah beberapa waktu, Anda akan berakhir pada apa yang tampak seperti permintaan root. Jangan ragu untuk bermain-main sebentar, Anda akan melihat bahwa Anda berada di lingkungan yang benar-benar terpisah dari mesin host Anda. Anda mungkin memperhatikan root dan tanda # pada prompt. Anda menjalankan sebagai pengguna root di lingkungan virtual baru. Jika Anda mengeluarkan perintah users, Anda akan melihat bahwa pengguna Anda yang lain sudah tidak ada lagi.

Sebaiknya luangkan waktu sebentar untuk menjelaskan apa yang dilakukan perintah docker yang baru saja Anda ketik dan bagaimana keajaiban ini terjadi.

Perintah run

Utilitas Docker tampaknya telah mengambil banyak inspirasi dari antarmuka baris perintah git dan sebagai hasilnya, ia menggunakan sub-perintah. Dalam hal ini, kami menjalankan perintah sub run. Perintah run membutuhkan dua argumen: image dan perintah.

Ini juga pintar, jadi jika (seperti dalam kasus ini) Anda tidak menginstal image itu, itu akan meminta repositori Docker pusat dan unduh satu untuk Anda. Di sini kami menyuruhnya untuk menjalankan image ubuntu dan memberi tahu Docker bahwa itu harus mulai /bin/bash di dalam image itu. -t dan -i memberi tahu Docker untuk menetapkan TTY dan menjalankan dalam "mode interaktif", dengan kata lain, untuk memberi Anda perintah cepat. Alasannya adalah karena Docker bekerja sedikit berbeda dari perangkat lunak virtualisasi lain yang mungkin Anda kenal. image Docker tidak "boot", mereka hanya berjalan. Mereka menggunakan instalasi Linux yang ada, jadi memulai gambar Docker bisa langsung dilakukan. Dalam beberapa hal Docker lebih dekat dengan perintah chroot Linux daripada alat virtualisasi yang lebih tradisional seperti VMWare atau VirtualBox.

Ada beberapa perbedaan utama lainnya dari alat virtualisasi standar. Mari kita lakukan percobaan cepat dan buat file dan cetak isinya:

Sekarang ketika Anda melakukan:

Ini akan dengan senang hati mencetak:

Sejauh ini bagus, percobaan konyol kami bekerja persis seperti yang diharapkan. Mari kita keluar dari Docker dan kembali ke command prompt mesin host kami:

Jika Anda me-restart Docker dengan perintah yang sama yang Anda gunakan sebelumnya:

... Anda akan melihat bahwa segala sesuatu tidak lagi berperilaku seperti yang Anda harapkan. Jika Anda mencoba menyimpan file yang kami buat terakhir kali, Anda sekarang mendapatkan pesan kesalahan:

Jadi apa yang terjadi? Perubahan pada image Docker tidak bertahan secara default. Untuk menyimpan perubahan Anda ke image Docker, Anda harus mengkomitnya, git style. Ini mungkin memerlukan sedikit waktu untuk membiasakan diri, tetapi ini cukup kuat karena itu berarti Anda juga dapat "branch" dengan git style (lebih lanjut tentang itu nanti).

Menyimpan Imgae baru

Untuk saat ini, mari kita lakukan sesuatu yang sedikit lebih berguna. Mari kita instal python, redis dan beberapa utilitas lain yang akan kita gunakan untuk menjalankan aplikasi demo kita segera. Setelah itu, kami akan commit untuk mempertahankan perubahan kami. Mulai salinan Docker di atas pada image Ubuntu terbaru:

Image dasar Ubuntu mungkin tidak termasuk Python, jadi periksa apakah Anda sudah mendapatkan salinan dengan mengetikkan python saat diminta. Jika Anda mendapatkan pesan kesalahan, maka mari kita instal:

Sejauh ini baik. Mungkin nanti kita ingin membuat proyek lain yang menggunakan Python, jadi mari kita lanjutkan dan simpan perubahan ini. Buka prompt perintah lain (jika Anda menggunakan instalasi Vagrant yang direkomendasikan di atas, Anda harus melakukan vagrant ssh dari prompt yang terpisah) dan lakukan hal berikut:

Anda akan mendapatkan daftar seperti di bawah ini, dari semua container Docker yang sedang berjalan:

Nomor di bawah kolom ID penting: ini adalah ID container Anda. Ini unik, jika Anda keluar dari container dan menjalankan image yang sama lagi, Anda akan melihat nomor baru di sana.

Jadi sekarang kita telah menginstal Python, mari kita simpan perubahan kita. Untuk melakukan ini, Anda menggunakan perintah commit yang mengambil dua argumen: container yang perubahannya ingin Anda simpan dan nama image. Konvensi Docker adalah untuk menggunakan userid diikuti dengan / dan nama pendek gambar. Jadi dalam hal ini, sebut saja tuts/python. Keluarkan perintah berikut untuk menyimpan instalasi Python Anda, pastikan untuk mengganti ID untuk wadah Anda dari langkah terakhir

Setelah beberapa detik, itu akan kembali dengan serangkaian huruf dan angka. Ini adalah ID dari gambar yang baru saja Anda simpan. Anda dapat menjalankan gambar ini kapan pun Anda inginkan dan merujuknya dengan nomor ID ini atau dengan nama tuts/python yang lebih mudah diingat yang kami tetapkan untuknya.

Mari kita jalankan salinan image yang baru saja kita buat:

Pada titik ini, Anda harus memiliki dua terminal windows terbuka menjalankan dua sesi Docker terpisah.

Sekarang Anda akan melihat bahwa jika Anda mengetikkan python di salah satunya, Anda tidak akan mendapatkan pesan kesalahan lagi. Coba buat file di jendela kedua:

Sekarang kembali ke jendela Docker asli Anda dan cobalah untuk melihat file:

Anda akan mendapatkan pesan kesalahan. Ini karena Anda menjalankan "mesin virtual" yang sama sekali berbeda berdasarkan gambar yang Anda buat dengan perintah docker commit. Sistem file Anda sepenuhnya terpisah.

Jika Anda membuka terminal lain (sekali lagi, Anda harus menjalankan vagrant ssh jika menggunakan Vagrant) dan lakukan hal berikut:

... Anda akan melihat docker itu sekarang mencantumkan dua image yang sedang berjalan, bukan hanya satu. Anda dapat secara terpisah berkomitmen untuk masing-masing gambar tersebut. Untuk melanjutkan dengan metafora git, Anda sekarang bekerja dengan dua branch dan mereka bebas untuk "menyimpang".

Ayo maju dan tutup jendela terakhir yang kami buka. Jika Anda menjalankan docker ps lagi, sekarang hanya akan ada satu ID yang terdaftar. Tetapi bagaimana jika Anda ingin kembali ke container sebelumnya? Jika Anda mengetik:

Docker juga akan mencantumkan semua container sebelumnya. Anda tidak dapat menjalankan container yang telah keluar, tetapi Anda dapat menggunakan ID kontainer sebelumnya untuk membuat image baru. Menjalankan image baru akan secara efektif membuat Anda kembali ke keadaan container sebelumnya.

Mari kita tutup jendela baru yang kita buka dan kembali ke terminal untuk sesi Docker pertama yang kita mulai. Setelah kembali, silakan dan instal beberapa alat lainnya untuk aplikasi kecil kami. Dalam hal ini, kita perlu menginstal manajer paket Python, dua modul Python untuk membiarkan Python bertindak sebagai server web dan berinteraksi dengan redis, dan server Redis itu sendiri.

Setelah ini selesai, mari kita komit image ini. Dari jendela terminal lain, jalankan perintah berikut:

... dan catat ID dan komit dengan nama tuts/pyredis:

Jadi sekarang kita memiliki image Docker yang berisi alat yang diperlukan untuk menjalankan aplikasi web Python kecil dengan Redis yang berfungsi sebagai backend. Jika Anda memiliki proyek masa depan yang akan menggunakan stack yang sama, yang harus Anda lakukan untuk memulainya adalah: docker run -t -i tuts/pyredis /bin/bash dan komit setelah Anda menambahkan kode sumber.

Ok, jadi backend kita sudah diatur. Sekarang untuk mengatur aplikasi itu sendiri!

Membuat Aplikasi Sumber Anda Menjadi Image

Saya telah membuat aplikasi sampel kecil yang menggunakan modul Redis dan Python yang telah kami instal sejauh ini. Aplikasi ini cukup sederhana, yang dilakukannya hanyalah menampilkan daftar tombol Redis dan menyediakan antarmuka yang belum sempurna untuk menambah dan mengeditnya. Mari kita dapatkan kode sumber ke mesin host Anda (sesi vargrant ssh) terlebih dahulu:

Di direktori home mesin host Anda sekarang Anda akan memiliki folder pyredis yang berisi skrip Python yang akan kita gunakan. Jadi, bagaimana kita menyalin aplikasi ini ke image Docker kita?

Yah, Docker memiliki fitur bagus yang memungkinkan Anda memasang direktori lokal di dalam container Anda. Mari kita jalankan image Docker lain dan mount folder:

Ini seperti perintah run kami dari sebelumnya, dengan penambahan parameter -v.

Akibatnya, perintah ini memungkinkan Anda berbagi folder antara Docker dan mesin host Anda. Tanda : menunjukkan path untuk dibagikan. Dalam kasus kami, kami membagikan folder pyredis kami, yang terletak di ~/pyredis di mesin kami, dan memasangnya di /tuts di dalam image Docker. rw pada akhirnya adalah untuk 'read-write' dan berarti bahwa perubahan yang dibuat pada image Docker juga akan ditampilkan di mesin kami.

Pada prompt Docker Anda, sekarang Anda dapat melakukan:

... dan lihat isi folder ~/pyredis di komputer Anda.

Namun pembagian ini bersifat sementara, jika Anda menjalankan image Docker ini di komputer lain atau menjalankan kembali image ini tanpa opsi -v, image tidak akan lagi memiliki akses ke sana. Mari salin ke lokasi lain di dalam image Docker yang sebenarnya:

Karena perubahan pada sistem file Docker bersifat sementara, mari kita simpan ini ke image dengan melakukan lagi docker ps untuk mendapatkan ID kontainer kami dan melakukan perubahan kami:

Anda akan melihat di sini kami komit untuk nama image yang sama dengan yang kami komit sebelumnya, tuts/pyredis. Docker akan memperbarui image dan itu akan menyimpan semua perubahan Anda untuk Anda. Seperti halnya git, jika Anda kacau, Anda dapat kembali ke versi yang bagus hanya dengan docker run ID-nya. Untuk melihat riwayat image, coba yang berikut ini:

Anda akan melihat sesuatu seperti ini:

Ini adalah riwayat semua komitmen yang kami buat dalam proses pembuatan image tuts/pyredis, termasuk yang kami komit dengan nama berbeda seperti tuts/python. Jika Anda ingin kembali ke komit tepat sebelum kami menyalin aplikasi pyredis kami ke /pyredis, Anda dapat mencoba (mengubah ID agar sesuai dengan yang Anda tunjukkan):

... dan Anda akan menemukan tidak ada direktori /pyredis.

Menjalankan Aplikasi

Jadi sekarang kita memiliki semua bagian. Langkah selanjutnya adalah menjalankan aplikasi dari dalam kontainernya. Karena kami menggunakan aplikasi web, kami juga perlu menentukan cara untuk mengakses aplikasi melalui web. Perintah run telah membuat Anda tertutup (lagi). Perintah jalankan Docker mendukung opsi -p yang memungkinkan Anda menentukan bagaimana port akan dipetakan.

Jika Anda menggunakan Vagrant untuk menjalankan Docker, Anda harus menyiapkan port forwarding Vagrant sebelum kami dapat melakukan tes yang berarti. Jika Anda tidak menggunakan Vagrant, lewati saja langkah ini.

Menyiapkan Port Forward Vagrant

Jika Anda menggunakan Vagrant untuk menguji ini, Anda harus mengatur port forwarding sehingga browser web mesin lokal Anda dapat mengakses port pada Vagrant VM, yang pada gilirannya akan meneruskan ke port instance Docker. Jadi dalam kasus kami, kami akan mengatur port mesin lokal kami 9000 untuk meneruskan ke Vagrant VM 9000 kami, yang pada gilirannya ke port 8080 instance tuts/pyredis kami.

Di mesin lokal Anda, kembali ke folder tempat Anda pertama kali mengetik vagrant init. Anda akan menemukan file teks yang disebut hanya Vagrantfile. Buka di editor teks favorit Anda dan cari bagian berikut:

Batalkan komentar pada baris terakhir dan ubah port dari 80 dan 8080 menjadi 8080 dan 9000. Hasilnya akan terlihat seperti ini:

Sekarang jalankan:

... yang akan menyebabkan VM Vagrant memulai kembali dengan port forward yang benar. Setelah ini selesai, Anda dapat menjalankan vagrant ssh lagi dan melanjutkan tutorial.

Aplikasi pyredis kecil kami secara default, membuka server web kecil di port 8080. Perintah berikut akan memungkinkan Anda mengakses port 8080 melalui port 9000 di mesin host Anda:

Anda akan mendapatkan prompt root Docker, jadi mari kita mulai aplikasi kami:

Jika semuanya berjalan dengan baik, Anda akan melihat yang berikut:

Ini berarti server sedang berjalan. Di mesin lokal Anda, jalankan browser web dan arahkan ke localhost:9000 (jika Anda melakukan tutorial ini pada server remote, maka pastikan Anda memiliki akses jaringan ke port 9000 dan ganti localhost dengan alamat server web Anda ).

Dengan sedikit keberuntungan, Anda akan melihat layar utama untuk aplikasi kecil kami. Teruskan dan tambahkan beberapa tombol dan ubah beberapa nilai. Data harus bertahan. Namun, jika Anda keluar dari prompt Docker dan me-restart Docker, basis data akan kosong lagi yang perlu diingat jika Anda berencana untuk meng-host database Anda di dalam kointainer Docker.

Menyimpan Konfigurasi Run Anda

Jadi ini semua bagus untuk pengujian, tetapi tujuannya di sini adalah untuk dapat menggunakan aplikasi Anda. Anda tidak ingin harus mengetikkan perintah untuk memulai aplikasi secara manual setiap kali.

Docker kembali datang untuk menyelamatkan. Saat Anda komit, Docker dapat secara otomatis menyimpan beberapa info yang dijalankan, seperti port mana yang akan dipetakan dan perintah apa yang harus dijalankan saat image dimulai. Dengan cara ini, yang harus Anda lakukan adalah mengetikkan docker <image_name> dan Docker akan mengurus sisanya. Kontainerisasi sejati.

Untuk skrip kami, kami hanya memiliki dua perintah untuk dijalankan saat startup:

Cara termudah untuk melakukannya adalah dengan membuat skrip peluncuran kecil yang menjalankan kedua perintah ini. Mari mulai tuts/pyredis kami lagi dan tambahkan skrip peluncuran kecil (langsung salin dan tempel di bawah ini, ke prompt Docker):

Ini menyimpan perintah yang kami gunakan untuk meluncurkan server Python kami ke skrip bash kecil bernama launch.sh dan menetapkan sedikit yang dapat dieksekusi sehingga lebih mudah untuk dijalankan.

Sekarang skrip berhasil dalam image, dari terminal lain, komit sehingga skrip akan bertahan (ingat untuk melakukan docker ps untuk mendapatkan ID kontainer terbaru Anda terlebih dahulu):

Mari kita coba ini. Jika Anda keluar dari prompt Docker dan menjalankannya lagi dengan perintah berikut, Anda harus dapat mengakses aplikasi web pyredis di localhost:9000, seperti yang terakhir kali.

Ok, jadi sekarang kita bisa menjalankan aplikasi kecil kita dengan satu perintah. Tapi masih ada lagi! Docker memungkinkan Anda menyimpan beberapa informasi konfigurasi default dengan komit Anda. Dengan begitu, kita tidak harus ingat untuk mengetik pemetaan port kami dan meluncurkan informasi perintah setiap kali dan Anda bisa memberikan image Docker kepada orang lain. Mereka kemudian dapat menjalankannya dengan menjalankan docker run <image_name> dan Docker mengurus sisanya.

Untuk mengkonfigurasi ini, Anda perlu mengirimkan beberapa informasi JSON ke perintah commit. Ada banyak parameter yang dapat Anda gunakan, tetapi untuk saat ini kami hanya akan memusatkan perhatian pada pemetaan port dan skrip inisialisasi. Jalankan editor teks favorit Anda dan rekatkan pada yang berikut ini:

Ini merepresentasikan informasi yang kita ketikkan dalam opsi -p serta path ke skrip peluncuran. Satu bit penting untuk dicatat adalah bahwa untuk opsi cmd, setiap tempat di mana Anda biasanya menggunakan spasi sebenarnya dilewatkan sebagai parameter terpisah.

Simpan snippet JSON itu ke file bernama runconfig.json dan mari perbarui Docker untuk menggunakannya.

Sekarang jika Anda lakukan:

Anda akan melihat bottle memulai dan Anda dapat mengakses aplikasi melalui browser.

Menyebarkan Gambar Publik ke Server Melalui Public Docker Registry

Pembuat Docker telah membuat registri publik yang dapat mendorong dan menarik gambar Docker dari siapa pun. Ini berarti bahwa menyebarkan aplikasi baru Anda ke server remote semudah mendorongnya ke registri pusat Docker dan kemudian menariknya dari server di mana Anda memiliki Docker diinstal.

Ini cukup mudah, jadi saya akan merujuk Anda ke dokumentasi Docker sendiri. Jika Anda ingin menggunakan secara pribadi, baca terus ke bagian selanjutnya.

Menyebarkan Gambar Pribadi ke Server (dengan Cara Mudah)

Hebat, jadi sekarang kita punya image Docker yang mudah digunakan untuk berjalan di mesin Anda. Langkah selanjutnya adalah menyebarkannya ke server!

Bagian ini agak rumit. Model distribusi Docker didasarkan pada gagasan tentang repositori. Anda dapat mendorong dan menarik gambar Docker ke repositori Docker sebanyak yang Anda inginkan dan server yang berbeda dapat dengan senang hati menarik image yang berbeda. Ini bagus, tapi sayangnya sedikit pekerjaan diperlukan untuk meng-host repositori Anda sendiri. Jika Anda meng-hosting atau membuat perangkat lunak sumber terbuka, maka Anda dapat menggunakan repositori Docker publik secara langsung untuk menyimpan image Anda. Namun, jika Anda menyebarkan kode hak milik, Anda mungkin tidak ingin melakukannya. Ini memberi Anda dua pilihan:

  1. Anda dapat mem-bypass fitur repositori Docker sepenuhnya dan secara manual mentransfer image.
  2. Anda dapat membuat repositori Anda sendiri.

Yang pertama lebih sederhana, tetapi kehilangan banyak fitur keren Docker seperti menjaga riwayat image Anda dan kemampuan untuk menyimpan pemetaan port dan menjalankan konfigurasi di dalam image. Jika ini penting bagi Anda, maka lewati ke bagian berikutnya untuk mempelajari cara mengatur repositori Docker (pribadi) Anda sendiri. Jika Anda hanya ingin dapat menyebarkan image Anda ke server Anda, maka Anda dapat menggunakan metode ini.

Langkah pertama adalah mengekspor kontainer Anda ke arsip .tar. Anda dapat melakukan ini melalui perintah export Docker. Untuk menggunakan contoh aplikasi yang telah kami gunakan dalam tutorial ini, Anda akan melakukan sesuatu seperti ini:

Docker akan duduk dan memproses selama beberapa waktu, tetapi setelah itu Anda akan memiliki file pyredis.tar yang berisi image yang Anda buat. Anda kemudian dapat menyalin pyredis.tar ke server Anda dan menjalankan yang berikut ini:

Docker lagi akan duduk sebentar dan akhirnya mengeluarkan ID dari gambar baru yang telah dibuat. Anda dapat melakukan commit ke nama yang lebih mudah diingat dengan melakukan ini:

Aplikasi tutorial kami sekarang disebarkan dan Anda dapat menjalankannya dengan perintah run yang sama seperti sebelumnya:

Menyebarkan Gambar Pribadi ke Server (Cara Keren)

Cara paling keren untuk menyebarkan aplikasi Anda adalah meng-host repositori Docker Anda sendiri. Dapatkan Docker diinstal pada mesin dan jalankan perintah berikut:

Tunggu sebentar untuk mengunduh bagian dan Anda akan segera melihat beberapa pesan tentang memulai unicorn dan mem-boot pekerja.

Ini berarti registri Docker Anda sudah aktif dan berjalan (di dalam kontainer Dockernya sendiri), dan dapat diakses oleh mesin lokal Anda di port 5000. Sedikit membengkokkan pikiran, tetapi mengagumkan. Mari kita atur kredensial login kita terlebih dahulu dan kemudian dorong image Docker yang kita buat sebelumnya dalam tutorial ke registri baru kita. Di terminal baru, jalankan yang berikut ini

Silakan dan masukkan username, kata sandi dan email yang ingin Anda gunakan dengan repositori Docker Anda.

Untuk mendorong aplikasi tuts/pyredis ke dalam repo, pertama-tama kita harus "memberi tag" dengan informasi alamat repositori pribadi seperti:

Ini memberitahu Docker untuk membuat "tag" baru dari tuts/pyredis dan mengaitkannya dengan repo yang berjalan di localhost:5000. Anda dapat menganggap tag ini sebagai nama image ini di repositori. Untuk konsistensi, saya telah menyimpan nama-nama yang sama dan memberi tag localhost:5000/tuts/pyredis, tetapi nama ini dapat dengan mudah menjadi sesuatu yang sangat berbeda (seperti localhost:5000/pyredis_prod.)

Jika Anda menjalankan docker images sekarang, Anda akan melihat bahwa ada image baru yang terdaftar dengan nama localhost:5000/tuts/pyredis. Mekanisme Docker untuk menentukan repositori terkait erat dengan mekanismenya untuk penamaan (atau penandaan sebagaimana Docker katakan), jadi ini yang Anda butuhkan.

Untuk mendorong gambar yang telah kami buat ke dalam repositori kami, lakukan saja docker push dan nama gambar dengan tag lengkap (termasuk alamat):

Docker akan terhubung ke repositori Anda yang berjalan di localhost:5000 dan mulai mendorong perubahan Anda. Anda akan melihat banyak pesan tentang berbagai permintaan HTTP yang terlibat muncul di jendela terminal lain (yang menjalankan samalba/docker-registry), dan informasi tentang pengunggahan akan lewat di sini. Ini akan mengambil beberapa waktu, sehingga Anda mungkin ingin ambil kopi.

Satu peringatan, karena repositori Docker kami sendiri berjalan di dalam kontainer Docker, kita perlu mengkomit image repositori setelah kita selesai mendorong. Jika tidak, karena perubahan sistem file Docker bersifat sementara, secara default image yang kami dorong ke repo akan hilang segera setelah kami menutup kontainer Docker samalba/docker-registry lokal kami.

Untuk melakukan ini, lakukan docker ps biasa untuk mendapatkan ID dari kontainer samalba/docker-registry berjalan dan kemudian komit ke kontainer baru. Ini tidak ideal, jika melakukan ini dalam produksi Anda ingin mengkonfigurasi volume Docker atau menggunakan opsi -v dari atas untuk menyimpan file repo langsung ke server, bukan di dalam kontainer, tapi itu di luar lingkup tutorial ini .

Sekarang untuk bagian yang menyenangkan: menyebarkan image Docker baru kami di server baru. Karena pada saat penulisan ini, repositori Docker tidak memiliki mekanisme keamanan atau otentikasi, kami akan melakukan pekerjaan kami melalui SSH tunnel yang aman. Dari mesin virtual tempat Anda mengatur tutorial tuts/pyredis, ssh ke server produksi Anda dan forward port 5000 seperti:

Flag -R ke ssh berarti bahwa ketika Anda terhubung ke localhost:5000 pada server produksi Anda, SSH akan meneruskan koneksi kembali ke port 5000 pada mesin virtual Anda, yang pada gilirannya akan diteruskan ke kontainer samalba/docker-registry tempat repo kami hidup.

Jika Docker tidak diinstal pada server ini, silakan dan instal sesuai dengan petunjuk instalasi. Setelah Anda menjalankan Docker, menyebarkan image Anda sesederhana:

Karena kami membuat tunnel melalui SSH, Docker akan menganggapnya menarik dari serve remote localhost:5000, tetapi ini sebenarnya akan disalurkan ke VM lokal localhost:5000, yang pada gilirannya akan dialihkan ke Docker. Berikan waktu untuk mengunduh, tetapi setelah selesai Anda harus dapat menjalankan aplikasi pyredis kami dengan cara yang sama persis dengan kami menjalankannya di VM asli, termasuk konfigurasi run yang tersimpan dan port:

Wrap-Up & Langkah Selanjutnya

Jadi itulah dasar-dasar Docker. Dengan informasi ini, Anda sekarang dapat membuat dan mengelola image Docker, mendorong dan menariknya ke repo publik dan pribadi dan menyebarkannya ke server terpisah.

Ini adalah tutorial intro, jadi ada banyak fitur Docker yang tidak dibahas di sini. Dua yang paling terkenal adalah Dockerfiles dan volume.

File Docker adalah file teks yang dapat dijalankan Docker untuk diinisialisasi dan menyediakan image Docker. Mereka dapat membuat proses pembuatan banyak image Docker secara signifikan lebih cepat, tetapi karena fokus di sini adalah bagaimana cara membuat dan menggunakan satu image tunggal, mereka tidak dibahas. Jika Anda ingin mempelajari lebih lanjut tentang mereka, lihat dokumentasi Docker sendiri.

Fitur kedua adalah volume. Volume berfungsi sedikit seperti folder bersama yang kita bahas dengan opsi -v, karena mereka memungkinkan kontainer Docker untuk menyimpan data mereka. Tidak seperti berbagi folder dengan -v, mereka tidak berbagi dengan sistem host, tetapi mereka dapat dibagi di antara gambar. Anda bisa melihat tutorial ini untuk pengantar yang bagus.

Advertisement
Advertisement
Advertisement
Advertisement
Looking for something to help kick start your next project?
Envato Market has a range of items for sale to help get you started.