Prasyarat
Untuk mengikuti artikel ini, Anda perlu:

Akses ke mesin lokal Ubuntu 20.04 atau server pengembangan sebagai pengguna non-root dengan hak sudo. Jika Anda menggunakan server jarak jauh, disarankan untuk menginstal firewall aktif. Untuk mengatur ini, silakan merujuk ke Panduan Pengaturan Server Awal kami untuk Ubuntu 20.04 .
Docker diinstal di server atau mesin lokal Anda, mengikuti Langkah 1 dan 2 dari Cara Menginstal dan Menggunakan Docker di Ubuntu 20.04 .
Langkah 1 — Memasang Docker Compose
Untuk memastikan kami mendapatkan versi stabil terbaru dari Docker Compose, kami akan mengunduh perangkat lunak ini dari repositori Github resminya .

Pertama, konfirmasikan versi terbaru yang tersedia di halaman rilis mereka . Pada saat penulisan ini, versi stabil terbaru adalah 1.27.4.

Perintah berikut akan mengunduh 1.27.4rilis dan menyimpan file yang dapat dieksekusi di /usr/local/bin/docker-compose, yang akan membuat perangkat lunak ini dapat diakses secara global sebagai docker-compose:

sudo curl -L "https://github.com/docker/compose/releases/download/1.27.4/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
 
Selanjutnya, atur izin yang benar sehingga docker-composeperintah dapat dieksekusi:

sudo chmod +x /usr/local/bin/docker-compose
 
Untuk memverifikasi bahwa instalasi berhasil, Anda dapat menjalankan:

docker-compose --version
 
Anda akan melihat output yang mirip dengan ini:

Output
docker-compose version 1.27.4, build 40524192
Docker Compose sekarang berhasil diinstal pada sistem Anda. Di bagian berikutnya, kita akan melihat cara menyiapkan docker-compose.ymlfile dan menjalankan lingkungan kemas dengan alat ini.

Langkah 2 — Menyiapkan docker-compose.ymlFile
Untuk mendemonstrasikan cara menyiapkan docker-compose.ymlfile dan bekerja dengan Docker Compose, kami akan membuat lingkungan server web menggunakan gambar Nginx resmi dari Docker Hub , registri Docker publik. Lingkungan kemas ini akan menyajikan satu file HTML statis.

Mulailah dengan membuat direktori baru di folder rumah Anda, lalu pindah ke dalamnya:

mkdir ~/compose-demo
cd ~/compose-demo
 
Di direktori ini, siapkan folder aplikasi untuk dijadikan sebagai root dokumen untuk lingkungan Nginx Anda:

mkdir app
 
Menggunakan editor teks pilihan Anda, buat index.htmlfile baru di dalam appfolder:

nano app/index.html
 
Tempatkan konten berikut ke dalam file ini:

~/compose-demo/app/index.html
<!doctype html>
<html lang="en">
<head>
    <meta charset="utf-8">
    <title>Docker Compose Demo</title>
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/gh/kognise/water.css@latest/dist/dark.min.css">
</head>
<body>

    <h1>This is a Docker Compose Demo Page.</h1>
    <p>This content is being served by an Nginx container.</p>

</body>
</html>
 
Simpan dan tutup file setelah selesai. Jika Anda menggunakan nano, Anda dapat melakukannya dengan mengetik CTRL+X, lalu Ydan ENTERuntuk mengonfirmasi.

Selanjutnya, buat docker-compose.ymlfile:

nano docker-compose.yml
 
Masukkan konten berikut di docker-compose.ymlfile Anda :

docker-compose.yml
version: '3.7'
services:
  web:
    image: nginx:alpine
    ports:
      - "8000:80"
    volumes:
      - ./app:/usr/share/nginx/html
 
The docker-compose.ymlberkas biasanya dimulai dengan versiondefinisi. Ini akan memberi tahu Docker Compose versi konfigurasi mana yang kami gunakan.

Kami kemudian memiliki servicesblok, di mana kami mengatur layanan yang merupakan bagian dari lingkungan ini. Dalam kasus kami, kami memiliki satu layanan yang disebut web. Layanan ini menggunakan nginx:alpinegambar dan mengatur pengalihan port dengan portsarahan. Semua permintaan pada port 8000dari tuan rumah mesin (sistem dari mana Anda menjalankan Docker Compose) akan diarahkan ke webkontainer di pelabuhan 80, di mana Nginx akan berjalan.

The volumesdirektif akan membuat volume yang dibagi antara mesin host dan wadah. Ini akan membagikan appfolder lokal dengan wadah, dan volume akan ditempatkan di /usr/share/nginx/htmldalam wadah, yang kemudian akan menimpa root dokumen default untuk Nginx.

Simpan dan tutup file.

Kami telah menyiapkan halaman demo dan docker-compose.ymlfile untuk membuat lingkungan server web kemas yang akan melayaninya. Pada langkah berikutnya, kami akan membawa lingkungan ini dengan Docker Compose.

Langkah 3 — Menjalankan Docker Compose
Dengan docker-compose.ymlfile di tempat, kita sekarang dapat menjalankan Docker Compose untuk meningkatkan lingkungan kita. Perintah berikut akan mengunduh gambar Docker yang diperlukan, membuat wadah untuk weblayanan, dan menjalankan lingkungan dalam wadah dalam mode latar belakang:

docker-compose up -d
 
Docker Compose pertama-tama akan mencari gambar yang ditentukan di sistem lokal Anda, dan jika tidak dapat menemukan gambar, itu akan mengunduh gambar dari Docker Hub. Anda akan melihat output seperti ini:

Output
Creating network "compose-demo_default" with the default driver
Pulling web (nginx:alpine)...
alpine: Pulling from library/nginx
cbdbe7a5bc2a: Pull complete
10c113fb0c77: Pull complete
9ba64393807b: Pull complete
c829a9c40ab2: Pull complete
61d685417b2f: Pull complete
Digest: sha256:57254039c6313fe8c53f1acbf15657ec9616a813397b74b063e32443427c5502
Status: Downloaded newer image for nginx:alpine
Creating compose-demo_web_1 ... done
Lingkungan Anda sekarang aktif dan berjalan di latar belakang. Untuk memverifikasi bahwa penampung aktif, Anda dapat menjalankan:

docker-compose ps
 
Perintah ini akan menunjukkan kepada Anda informasi tentang container yang sedang berjalan dan statusnya, serta pengalihan port apa pun yang saat ini ada:

Output
       Name Command State Ports        
----------------------------------------------------------------------------------
compose-demo_web_1 /docker-entrypoint.sh ngin ... Up 0.0.0.0:8000->80/tcp
Anda sekarang dapat mengakses aplikasi demo dengan mengarahkan browser Anda ke localhost:8000apakah Anda menjalankan demo ini di komputer lokal Anda, atau your_server_domain_or_IP:8000jika Anda menjalankan demo ini di server jauh.

Anda akan melihat halaman seperti ini:

Halaman Demo Tulis Docker

Karena volume bersama yang telah Anda siapkan di dalam docker-compose.ymlfile membuat appfile folder Anda tetap sinkron dengan root dokumen penampung. Jika Anda membuat perubahan apa pun pada index.htmlfile, mereka akan secara otomatis diambil oleh wadah dan dengan demikian tercermin di browser Anda saat Anda memuat ulang halaman.

Pada langkah berikutnya, Anda akan melihat cara mengelola lingkungan kemas dengan perintah Docker Compose.

Langkah 4 — Mengenal Docker Compose Commands
Anda telah melihat cara menyiapkan docker-compose.ymlfile dan menghidupkan lingkungan Anda dengan docker-compose up. Sekarang Anda akan melihat cara menggunakan perintah Docker Compose untuk mengelola dan berinteraksi dengan lingkungan kemas Anda.

Untuk memeriksa log yang dihasilkan oleh wadah Nginx Anda, Anda dapat menggunakan logsperintah:

docker-compose logs
 
Anda akan melihat output yang mirip dengan ini:

Output
Attaching to compose-demo_web_1
web_1 | /docker-entrypoint.sh: /docker-entrypoint.d/ is not empty, will attempt to perform configuration
web_1 | /docker-entrypoint.sh: Looking for shell scripts in /docker-entrypoint.d/
web_1 | /docker-entrypoint.sh: Launching /docker-entrypoint.d/10-listen-on-ipv6-by-default.sh
web_1 | 10-listen-on-ipv6-by-default.sh: Getting the checksum of /etc/nginx/conf.d/default.conf
web_1 | 10-listen-on-ipv6-by-default.sh: Enabled listen on IPv6 in /etc/nginx/conf.d/default.conf
web_1 | /docker-entrypoint.sh: Launching /docker-entrypoint.d/20-envsubst-on-templates.sh
web_1 | /docker-entrypoint.sh: Configuration complete; ready for start up
web_1 | 172.22.0.1 - - [02/Jun/2020:10:47:13 +0000] "GET / HTTP/1.1" 200 353 "-" "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.61 Safari/537.36" "-"
Jika Anda ingin menjeda eksekusi lingkungan tanpa mengubah status wadah Anda saat ini, Anda dapat menggunakan:

docker-compose pause
 
Output
Pausing compose-demo_web_1 ... done
Untuk melanjutkan eksekusi setelah mengeluarkan jeda:

docker-compose unpause
 
Output
Unpausing compose-demo_web_1 ... done
The stopperintah akan mengakhiri eksekusi kontainer, tetapi tidak akan menghancurkan data yang terkait dengan kontainer Anda:

docker-compose stop
 
Output
Stopping compose-demo_web_1 ... done
Jika Anda ingin menghapus container, jaringan, dan volume yang terkait dengan lingkungan container ini, gunakan downperintah:

docker-compose down
 
Output
Removing compose-demo_web_1 ... done
Removing network compose-demo_default
Perhatikan bahwa ini tidak akan menghapus gambar dasar yang digunakan oleh Docker Compose untuk meningkatkan lingkungan Anda (dalam kasus kami, nginx:alpine). Dengan cara ini, setiap kali Anda menghidupkan kembali lingkungan Anda dengan docker-compose up, prosesnya akan jauh lebih cepat karena gambar sudah ada di sistem Anda.

Jika Anda juga ingin menghapus gambar dasar dari sistem Anda, Anda dapat menggunakan:

docker image rm nginx:alpine
 
Output
Untagged: nginx:alpine
Untagged: nginx@sha256:b89a6ccbda39576ad23fd079978c967cecc6b170db6e7ff8a769bf2259a71912
Deleted: sha256:7d0cdcc60a96a5124763fddf5d534d058ad7d0d8d4c3b8be2aefedf4267d0270
Deleted: sha256:05a0eaca15d731e0029a7604ef54f0dda3b736d4e987e6ac87b91ac7aac03ab1
Deleted: sha256:c6bbc4bdac396583641cb44cd35126b2c195be8fe1ac5e6c577c14752bbe9157
Deleted: sha256:35789b1e1a362b0da8392ca7d5759ef08b9a6b7141cc1521570f984dc7905eb6
Deleted: sha256:a3efaa65ec344c882fe5d543a392a54c4ceacd1efd91662d06964211b1be4c08
Deleted: sha256:3e207b409db364b595ba862cdc12be96dcdad8e36c59a03b7b3b61c946a5741a
Catatan : Silakan merujuk ke panduan kami tentang Cara Menginstal dan Menggunakan Docker untuk referensi lebih rinci tentang perintah Docker.

Kesimpulan
Dalam panduan ini, kita telah melihat cara menginstal Docker Compose dan menyiapkan lingkungan kemas berdasarkan citra server web Nginx. Kami juga telah melihat bagaimana mengelola lingkungan ini menggunakan perintah Compose

Prasyarat

Pertama, kita perlu menginstal docker-compose di mesin kita hanya dengan menjalankan docker-compose -v. Jika belum terinstal di mesin kita, kita perlu menginstalnya terlebih dahulu.

Buat Compose File 

Selanjutnya, kita perlu membuat docker-compose.ymlfile baru dan mengisinya dengan setup wordpress dan mysql. Nama file sebenarnya bisa apa saja, tetapi jika kita menggunakan nama lain, kita perlu menentukan file saat menjalankan perintah compose.

Versi: "3" 
layanan: 
  wordpress: 
    container_name: my_wordpress 
    image: wordpress 
    port: 
      - "8080: 80" 
    link: 
      - mysql 
    lingkungan: 
      WORDPRESS_DB_HOST: mysql 
      WORDPRESS_DB_USER: root 
      WORDPRESS_DB_PASSWORD: "12345" 
      WORDPRESS_DB_NAME: wordpress 
  mysql: 
    container_name: my_mysql 
    image: "mysql:5.7" 
    volume: 
      - ./.mysql:/var/lib/mysql 
    lingkungan: 
      MYSQL_DATABASE: wordpress 
      MYSQL_ROOT_PASSWORD: "12345"

Ada banyak hal yang terjadi pada file itu, mari kita bedah satu per satu. Kolom pertama adalah versionyang memberi tahu Compose format file apa yang kita gunakan. Bidang tertentu mungkin tidak dikenali oleh versi Compose tertentu, jadi periksa versi mana yang didukung oleh Compose yang diinstal pada mesin Anda .

Bidang kedua kami adalah servicesyang menggambarkan layanan apa yang ingin kami jalankan. Dalam hal ini, kita akan menjalankan wadah wordpress dan mysql. Di setiap layanan, kami memiliki container_namebidang opsional yang akan digunakan sebagai nama wadah. Jika kita tidak menentukan nama container, Compose akan membuatnya secara otomatis.

Selanjutnya, kami memiliki imagebidang yang memberi tahu Compose gambar buruh pelabuhan mana yang ingin kami gunakan. Karena kami ingin wordpress dapat diakses di luar wadah, kami membuka pemetaan port dari 8080host kami ke 80port wadah dengan mendefinisikannya di portsbidang.

Kami belajar di artikel sebelumnya bahwa kami perlu menghubungkan wadah wordpress dan mysql agar mereka dapat berkomunikasi satu sama lain. Dalam hal ini, kami biasa linksmelakukannya dengan hanya menentukan wadah lain yang ingin kami hubungkan dengan layanan ini.

Kami menggunakan environmentbidang untuk mendaftar semua variabel lingkungan yang perlu diatur di setiap wadah. Terakhir, dalam layanan mysql, kami memasang volume ke dalamnya di volumelapangan. Kami menautkan .mysqlfolder di Host ke /var/lib/mysqlwadah mysql sehingga data basis data dapat bertahan bahkan jika kami mematikan wadah. Jika kita belum memiliki .mysqlfolder di host, Docker akan membuatnya untuk kita.

Menjalankan Compose

Untuk menjalankan layanan, kita hanya perlu menjalankan satu perintah. Perhatikan bahwa -dflag akan membuat layanan berjalan di latar belakang.

$ docker-compose up -d

Sedikit catatan, kita perlu menentukan nama file compose jika kita menggunakan nama yang tidak standar, misalnya some-compose.yml.

$ docker-compose up -f some-compose.yml -d

Meskipun, kita menjalankan container secara deklaratif, kita masih dapat menggunakan dockerperintah untuk melakukan operasi pada container ini. Misalnya, jika kita ingin masuk ke dalam database, kita dapat menggunakan perintah yang sama seperti sebelumnya.

$ docker exec -it my_mysql mysql -u root -p

Untuk mematikan container ini, kita tidak perlu menghapusnya satu per satu. Kita cukup menjalankan:

$ docker-compose down

Dengan cara ini, kita dapat menghidupkan dan mematikan pengaturan dengan satu perintah. Keuntungan lain dari ini adalah bahwa file penulisan dapat dipindahkan ke komputer lain dan kami akan menjalankan pengaturan yang sama di dalamnya. Ini dapat memudahkan pengembangan dalam tim serta penerapan ke mesin pengujian atau produksi.




Mengelola Data di Docker, secara default semua file yang dibuat dalam container tidak akan tersimpan secara persistent, ketika container dihentikan file akan hilang, dan ketika anda menjalakan kembali container tersebut akan kembali ke sedia kala.

Untuk menangani hal ini docker memiliki 2 opsi yaitu volumes dan bind mounts yang dapat diterapkan pada container untuk menyimpan data pada host, sehingga file akan tersimpan secara persistent ketika container dihentikan, dan jika anda menjalankan docker di linux anda juga bisa menggunakan tmpfs mount

Disini kita akan coba mendemokan bagaiman cara bind mount laravel-app pada docker dekstop OS windows


Bind mounts

Bisa disimpan dimana saja pada sistem host, host sistem dan container dapat menulis, membaca dan mengubah file kapanpun. jika dibandingkan dengan volumes bind mounts memiliki fungsional yang terbatas.

Ketika anda menggunakan bind mount file atau direktori pada host di mount ke container, file atau direktori direferensikan secara full path pada host, dan untuk host docker tujuan direktori tidak perlu ada, jika tidak ada akan dibuat secara otomatis.

Untuk penggunaan bind mount gunakan parameter -v atau –volume, contoh demo penggunaan

docker container run -d --name laravel2 -p 8182:8181 -v /Users/ilhamAziz/app/laravel-vol:/srv/app laravel-app


pada perintah diatas  /Users/ilhamAziz/app/laravel-vol merupakan direktori full path yang berada di host yang akan di mount ke /srv/www yang berada di container, seperti yang disebutkan di atas direktori /srv/app ini tidak perlu ada pada docker host, jika tidak ada akan dibuat secara otomatis, dan ketika anda melakukan perubahan di container file/direktori akan berubah juga di host, begitupun sebaliknya

Kita akan coba melihat mount pada container laravel2 dengan menggunakan perintah berikut 

docker container inspect laravel2



ekarang kita akan coba menjalankan 












Docker adalah sebuah aplikasi yang bersifat open source yang berfungsi sebagai wadah/container untuk mengepak/memasukkan sebuah software secara lengkap beserta semua hal lainnya yang dibutuhkan oleh software tersebut dapat berfungsi.


Jadi dengan docker kita sudah tidak perlu menjalankan aplikasi selalu pada lokal komputer kita. Langsung saja kita mulai proses konfigurasi docker untuk laravel. Tapi sebelum memulai tutorial ini pastikan kita telah meng-install docker dekstop di komputer


Install Composer

Pastikan download composer terlebih dahulu di https://getcomposer.org/download/ lalu install. Selajutnya pastikan composer terinstall di komputer dengan cara ketikan composer di CMD



Install Laravel

Untuk meng-install laravel ketikan perintah dibawah dan tunggu proses installasi selesai

 composer create-project --prefer-dist laravel/laravel laravel-app



Buat file dockerfile

Buat file baru dengan nama dockerfile dan simpan di projek laravel yang telah di download




Konfigurasi dockerfile

# download imgage php dari docker hub https://hub.docker.com/_/php
FROM php:8.0.3-fpm

# install depedensi yang dibutuhkan 
RUN apt-get update -y && apt-get install -y openssl zip unzip git

#install composer
RUN curl -sS https://getcomposer.org/installer | php -- --install-dir=/usr/local/bin --filename=composer

# set work directory
WORKDIR /app

# copy semua files dan simpan ke work dir
COPY . /app

# install composer dependensi
RUN composer install

# run laravel server 
CMD ["php", "artisan", "serve", "--host=0.0.0.0", "--port=8181"]

# expose port agar bisa diakses di local 
EXPOSE 8181




Build image

Buat dan import image laravel-app dengan ketikan perintah dibawah (masuk ke direktori laravel-app di CMD)

docker image build -t laravel-app 



Lihat image yang barusan dibuild dengan perintah dibawah

docker image ls



Jalankan Container

Agar image diatas bisa digunakan kita harus menjalankan terlebih dahulu image- nya sebagai container. Dengan ketikan perintah seperti dibawah



Buka di browser dengan http://localhost:8181/



Push image ke dokcer hub

Sebelum melakukan push image ke docker hub pastikan terlebih dahulu kita telah memiliki akun docker hub, seperti dibawah ini.



Login ke Docker Hub melalui CMD, lalu copas Container ID untuk melakukan perintah selanjutnya
 

Melakukan commit images 



Setelah tahapan diatas berhasil, selanjutnya kita akan melakukan push image ke docker hub, dengan ketikan perintah seperti dibawah.

docker image push ilhmahub/laravel-app:latest











Containerization didefinisikan sebagai bentuk virtualisasi sistem operasi, di mana aplikasi dijalankan di ruang pengguna yang terisolasi yang disebut wadah, semua menggunakan sistem operasi (OS) bersama yang sama. Wadah pada dasarnya adalah lingkungan komputasi yang dikemas penuh dan portabel:
  1. Semua yang dibutuhkan aplikasi untuk dijalankan - biner, pustaka, file konfigurasi, dan dependensinya - dienkapsulasi dan diisolasi dalam penampungnya.
  2. Container itu sendiri dipisahkan dari OS host, dengan hanya akses terbatas ke resource yang mendasarinya - seperti mesin virtual (VM) ringan.
  3. Hasilnya, aplikasi dalam container dapat dijalankan di berbagai jenis infrastruktur — di bare metal, di dalam VM, dan di cloud — tanpa perlu melakukan refactor untuk setiap lingkungan.
Itu karena ada lebih sedikit overhead selama startup dan tidak perlu menyiapkan OS tamu terpisah untuk setiap aplikasi karena semuanya berbagi kernel OS yang sama. Karena efisiensi tinggi ini, penampung biasanya digunakan untuk mengemas banyak layanan mikro individual yang membentuk aplikasi modern. Citrix menggunakan containerization dengan CPX, pengontrol pengiriman aplikasi (ADC) yang mendukung pengiriman aplikasi yang lebih skalabel, gesit, dan portabel.

Bagaimana Sebenarnya Containerization Bekerja?
Setiap penampung adalah paket perangkat lunak yang dapat dieksekusi, berjalan di atas OS host. Sebuah host dapat mendukung banyak kontainer (puluhan, ratusan atau bahkan ribuan) secara bersamaan, seperti dalam kasus arsitektur layanan mikro kompleks yang menggunakan banyak ADC dalam kontainer. Penyiapan ini berfungsi karena semua kontainer menjalankan proses minimal sumber daya yang terisolasi yang tidak dapat diakses orang lain.
Pikirkan aplikasi dalam kemasan sebagai lapisan atas kue multi-tingkat:
  • Di bagian bawah, terdapat perangkat keras infrastruktur yang dimaksud, termasuk CPU, penyimpanan disk, dan antarmuka jaringannya.
  • Di atas itu, ada OS host dan kernelnya - yang terakhir berfungsi sebagai jembatan antara perangkat lunak OS dan perangkat keras sistem yang mendasarinya.
  • Mesin kontainer dan OS tamu minimalnya, yang khusus untuk teknologi kontainerisasi yang digunakan, berada di atas OS host.
  • Di bagian paling atas adalah binari dan pustaka (bins / libs) untuk setiap aplikasi dan aplikasi itu sendiri, berjalan di ruang pengguna yang terisolasi (wadah).

Cgroups dan LXC

Containerization seperti yang kita tahu itu berevolusi dari cgroups, sebuah fitur untuk mengisolasi dan mengontrol penggunaan sumber daya (misalnya, berapa banyak CPU dan RAM dan berapa banyak thread yang dapat diakses oleh suatu proses) di dalam kernel Linux. Cgroup menjadi wadah Linux (LXC), dengan fitur yang lebih canggih untuk isolasi namespace komponen, seperti tabel perutean dan sistem file. Kontainer LXC dapat melakukan hal-hal seperti:
     ● Pasang sistem file.
● Jalankan perintah sebagai root.
● Dapatkan alamat IP.
Itu melakukan tindakan ini di ruang pengguna pribadinya sendiri. Meskipun menyertakan bins / lib khusus untuk setiap aplikasi, container LXC tidak mengemas kernel OS atau perangkat keras apa pun, yang berarti ini sangat ringan dan dapat dijalankan dalam jumlah besar bahkan pada mesin yang relatif terbatas.
Docker dan OCI

LXC berfungsi sebagai dasar untuk Docker, yang diluncurkan pada tahun 2013 dan dengan cepat menjadi teknologi peti kemas paling populer - secara efektif merupakan standar industri, meskipun spesifikasi yang ditetapkan oleh Open Container Initiative (OCI) sejak itu menjadi pusat peti kemas. Docker adalah kontributor spesifikasi OCI, yang menetapkan standar untuk format gambar dan runtime yang digunakan mesin kontainer.

Seseorang yang mem-boot container, Docker atau lainnya, dapat mengharapkan pengalaman yang sama terlepas dari lingkungan komputasi. Kumpulan wadah yang sama dapat dijalankan dan diskalakan apakah pengguna menggunakan distribusi Linux atau bahkan Microsoft Windows. Kompatibilitas lintas platform ini penting untuk ruang kerja digital saat ini, di mana pekerja mengandalkan banyak perangkat, OS, dan antarmuka untuk menyelesaikan pekerjaan.
Apa yang Membedakan Containerization dari Virtualization?
Fitur containerisasi yang paling khas adalah terjadi di tingkat OS, dengan semua container berbagi satu kernel. Tidak demikian halnya dengan virtualisasi melalui mesin virtual (VM):
  • VM berjalan di atas hypervisor, yang merupakan perangkat keras, perangkat lunak, atau firmware khusus untuk mengoperasikan VM pada mesin host, seperti server atau laptop.
  • Melalui hypervisor, setiap VM ditetapkan tidak hanya pada bin / lib penting, tetapi juga tumpukan perangkat keras tervirtualisasi termasuk CPU, penyimpanan, dan adaptor jaringan.
  • Untuk menjalankan semua itu, setiap VM mengandalkan OS tamu yang lengkap. Hypervisor itu sendiri dapat dijalankan dari OS mesin host atau sebagai aplikasi bare-metal.
Seperti containerization, virtualisasi tradisional memungkinkan isolasi penuh aplikasi sehingga mereka berjalan secara independen satu sama lain menggunakan sumber daya aktual dari infrastruktur yang mendasarinya. Tetapi perbedaannya lebih penting:
  • Ada overhead yang signifikan yang terlibat, karena semua VM membutuhkan OS tamu dan kernel virtual mereka sendiri, ditambah kebutuhan akan lapisan ekstra yang berat (hypervisor) antara mereka dan host.
  • Hypervisor juga dapat menyebabkan masalah kinerja tambahan, terutama saat dijalankan pada OS host, misalnya di Ubuntu.
  • Karena keseluruhan resource overhead yang tinggi, mesin host yang mungkin dapat menjalankan 10 container atau lebih dengan nyaman dapat kesulitan untuk mendukung satu VM.
Namun, menjalankan banyak VM dari perangkat keras yang relatif kuat masih merupakan paradigma umum dalam pengembangan dan penerapan aplikasi. Ruang kerja digital biasanya menampilkan virtualisasi dan penampung, menuju tujuan umum untuk membuat aplikasi tersedia dan skalabel mungkin bagi karyawan.
Apa Manfaat Utama Containerization?
Aplikasi dalam kontainer dapat dengan mudah dikirimkan ke pengguna di ruang kerja digital. Lebih khusus lagi, memasukkan aplikasi berbasis layanan mikro, satu set Citrix ADC atau database (di antara kemungkinan lainnya) memiliki spektrum manfaat yang luas, mulai dari ketangkasan yang unggul selama pengembangan perangkat lunak hingga pengendalian biaya yang lebih mudah.

Bagaimana Container Bekerja


Containerization melibatkan penggabungan aplikasi bersama dengan semua file konfigurasi terkait, library, dan dependensi yang diperlukan untuk menjalankannya dengan cara yang efisien dan bebas bug di lingkungan komputasi yang berbeda.
Implementasi containerisasi paling populer adalah Docker dan Kubernetes.



Aplikasi dan dependensinya berada dalam container di atas 'lingkungan runtime container' yang dapat berfungsi pada sistem operasi host dan infrastruktur pilihan.


Kontainer versus Mesin Virtual


Container sering dibandingkan dengan Mesin Virtual (VM), karena keduanya memungkinkan beberapa jenis perangkat lunak dijalankan di lingkungan yang terkandung.
Penampung adalah abstraksi dari lapisan aplikasi (artinya setiap penampung mensimulasikan aplikasi perangkat lunak yang berbeda). Meskipun setiap penampung menjalankan proses yang terisolasi, beberapa penampung berbagi Sistem Operasi yang sama.
VM adalah abstraksi dari lapisan perangkat keras (artinya setiap VM mensimulasikan mesin fisik yang dapat menjalankan perangkat lunak). Teknologi VM dapat menggunakan satu server fisik untuk menjalankan server yang setara dengan banyak server (masing-masing disebut VM). Jadi, sementara beberapa VM berjalan pada satu mesin fisik, setiap VM memiliki salinan Sistem Operasi, aplikasi, dan file terkait, pustaka, dan dependensinya sendiri.

Menjalankan perangkat lunak di lingkungan dalam kontainer umumnya menggunakan lebih sedikit ruang dan memori daripada menjalankan perangkat lunak dalam VM yang berbeda, karena yang terakhir memerlukan salinan terpisah dari Sistem Operasi untuk dijalankan di setiap VM.

Pengembangan perangkat lunak berorientasi DevOps yang lebih gesit
Dibandingkan dengan VM, penampung lebih mudah disiapkan, baik tim menggunakan OS mirip UNIX atau Windows. Alat pengembang yang diperlukan bersifat universal dan mudah digunakan, memungkinkan pengembangan, pengemasan, dan penerapan aplikasi dalam container dengan cepat di seluruh OS. Teknisi dan tim DevOps dapat (dan memang) memanfaatkan teknologi containerization untuk mempercepat alur kerja mereka.
Overhead lebih sedikit dan biaya lebih rendah daripada VM
Penampung tidak memerlukan OS tamu penuh atau hypervisor. Pengurangan overhead itu berarti lebih dari sekadar waktu boot yang lebih cepat, jejak memori yang lebih kecil, dan performa yang secara umum lebih baik. Ini juga membantu memangkas biaya, karena organisasi dapat mengurangi beberapa server dan biaya lisensi mereka, yang seharusnya mendukung penerapan yang lebih berat dari beberapa VM. Dengan cara ini, kontainer memungkinkan efisiensi server dan efektivitas biaya yang lebih besar.

Portabilitas yang sangat baik di seluruh ruang kerja digital

Wadah membuat ide "tulis sekali, jalankan di mana saja" menjadi kenyataan. Setiap penampung telah diambil dari OS host dan akan berjalan sama di lokasi mana pun. Dengan demikian, ini dapat ditulis untuk satu lingkungan host dan kemudian di-porting dan disebarkan ke yang lain, selama host baru mendukung teknologi container dan OS yang dipermasalahkan. Kontainer Linux menyumbang sebagian besar dari semua kontainer yang diterapkan dan dapat di-porting di berbagai OS berbasis Linux baik itu di lokasi atau di cloud. Di Windows, container Linux dapat dijalankan dengan andal di dalam VM Linux atau melalui isolasi Hyper-V. Kompatibilitas seperti itu mendukung ruang kerja digital, di mana banyak awan, perangkat, dan alur kerja berpotongan.

Isolasi kesalahan untuk aplikasi dan layanan mikro

Jika satu wadah gagal, yang lain berbagi kernel OS tidak terpengaruh, berkat isolasi ruang pengguna di antara mereka. Itu menguntungkan aplikasi berbasis layanan mikro, di mana banyak komponen yang berpotensi mendukung program yang lebih besar. Layanan mikro dalam wadah tertentu dapat diperbaiki, diterapkan ulang, dan diskalakan tanpa menyebabkan waktu henti aplikasi

Pengelolaan yang lebih mudah melalui orkestrasi

Orkestrasi container melalui solusi seperti platform Kubernetes membuatnya praktis untuk mengelola aplikasi dan layanan dalam container dalam skala besar. Dengan menggunakan Kubernetes, dimungkinkan untuk mengotomatiskan peluncuran dan rollback, mengatur sistem penyimpanan, melakukan load balancing, dan memulai ulang container yang gagal. Kubernetes kompatibel dengan banyak mesin kontainer termasuk yang kompatibel dengan Docker dan OCI.

Aplikasi dan Layanan Apa yang Biasanya Dimasukkan?

Sebuah wadah dapat mendukung hampir semua jenis aplikasi yang di era sebelumnya akan secara tradisional divirtualisasikan atau dijalankan secara native di mesin. Pada saat yang sama, ada beberapa paradigma komputasi yang sangat cocok untuk containerization, termasuk:

  • Layanan mikro : Arsitektur layanan mikro dapat dikonfigurasi secara efisien sebagai sekumpulan kontainer yang beroperasi bersama-sama dan berputar serta dinonaktifkan sesuai kebutuhan.
  • Database : Pecahan database dapat dimasukkan ke dalam container dan setiap aplikasi diberi database khusus, bukan perlu menghubungkan semuanya ke database monolitik.
  • Server web : Menjalankan server web dalam wadah hanya memerlukan beberapa input baris perintah untuk memulai, ditambah lagi, ini menghindari kebutuhan untuk menjalankan server secara langsung di host.
  • Penampung dalam VM : Penampung dapat dijalankan dalam VM, biasanya untuk memaksimalkan pemanfaatan perangkat keras, berbicara dengan layanan tertentu di VM dan / atau meningkatkan keamanan.
  • Citrix ADCs : ADC mengelola kinerja dan keamanan aplikasi. Saat dimasukkan ke dalam container , itu membuat layanan L4-L7 lebih mudah tersedia di lingkungan DevOps.

Bagaimana Kontainerisasi Terkait dengan Layanan Mikro dan Orkestrasi Kontainer?

Layanan mikro

Layanan mikro yang terdiri dari aplikasi dapat dikemas dan disebarkan dalam wadah dan dikelola pada infrastruktur awan yang dapat diskalakan. Manfaat utama containerization layanan mikro mencakup overhead yang minimal, penskalaan independen, dan pengelolaan yang mudah melalui orkestrator container seperti Kubernetes.

Citrix ADC dapat membantu transisi dari aplikasi berbasis monolitik ke layanan mikro . Lebih khusus lagi, ini membantu admin, pengembang, dan insinyur keandalan situs dengan masalah jaringan seperti manajemen lalu lintas dan pergeseran dari arsitektur berbasis monolitik ke layanan mikro.

Jika layanan mikro dikemas dalam wadah yang diterapkan dalam skala besar, platform orkestrasi wadah diperlukan untuk mengelola siklus hidup wadah.

Orkestrasi Penampung

Kubernetes adalah platform orkestrasi container yang paling menonjol. Awalnya dikembangkan oleh Google, ini terlihat bersumber terbuka dan sekarang dikelola oleh Cloud Native Computing Foundation.

Meskipun ini bukan satu-satunya solusi seperti itu, rangkaian fiturnya menunjukkan kemampuan orkestrator container modern, karena dapat:

  • Buka wadah dengan nama DNS atau alamat IP.
  • Tangani load balancing dan distribusi lalu lintas untuk kontainer.
  • Pasang penyimpanan lokal dan berbasis cloud secara otomatis.
  • Alokasikan sumber daya CPU dan RAM tertentu ke container, lalu paskan ke node.
  • Ganti atau matikan container yang bermasalah tanpa mengganggu kinerja dan waktu kerja aplikasi.
  • Kelola informasi sensitif seperti kata sandi dan token tanpa membangun kembali wadah.
  • Ubah status wadah dan kembalikan wadah lama untuk menggantinya dengan yang baru.