1. Pengantar
Apa manfaat migrasi dari aplikasi monolitik ke arsitektur microservice? Menguraikan aplikasi menjadi beberapa microservice memiliki keuntungan berikut; sebagian besar hal ini berasal dari fakta bahwa microservice dikaitkan secara longgar.
- Microservice dapat diuji dan di-deploy secara mandiri. Makin kecil unit deployment, makin mudah deployment-nya.
- Microservice dapat diterapkan dalam berbagai bahasa dan framework. Untuk setiap microservice, Anda bebas memilih teknologi terbaik untuk kasus penggunaan khususnya.
- Microservice dapat dikelola oleh tim yang berbeda-beda. Batasan antara masing-masing microservice memudahkan Anda mendedikasikan tim untuk satu atau beberapa microservice.
- Dengan berpindah ke microservice, Anda melonggarkan dependensi antartim. Masing-masing tim hanya perlu memperhatikan API microservice yang mereka perlukan. Mereka tidak perlu memikirkan cara microservice tersebut diterapkan, siklus rilisnya, dan sebagainya.
- Anda dapat lebih mudah membuat desain untuk mengantisipasi kegagalan. Dengan batasan yang jelas antara masing-masing layanan, akan lebih mudah untuk menentukan tindakan yang harus dilakukan saat operasi layanan terhenti.
Beberapa kerugian microservice jika dibandingkan dengan monolit adalah:
- Karena aplikasi berbasis microservice membentuk jaringan yang terdiri dari berbagai layanan yang interaksinya sering kali tidak jelas, secara keseluruhan, sistemnya cenderung menjadi lebih kompleks.
- Tidak seperti bagian internal monolit, microservice berkomunikasi melalui jaringan. Dalam situasi tertentu, hal ini dapat dianggap sebagai masalah keamanan. Istio mengatasi masalah ini dengan mengenkripsi traffic antar-microservice secara otomatis.
- Mungkin sulit untuk mencapai tingkat performa yang sama seperti pendekatan monolitik, karena latensi antara masing-masing layanan.
- Perilaku sistemnya tidak hanya dipengaruhi oleh satu layanan, tetapi oleh banyak layanan dan interaksinya. Oleh karena itu, perilaku sistem di lingkungan produksi (kemampuan observasinya) lebih sulit dipahami. Istio adalah solusi untuk masalah ini juga.
Di lab ini, kita akan menjalankan microservice di Google Kubernetes Engine (GKE). Kubernetes adalah platform untuk mengelola, menghosting, menskalakan, dan men-deploy container. Container adalah cara portabel untuk memaketkan dan menjalankan kode. Container sangat cocok dengan pola microservice, yang memungkinkan masing-masing microservice berjalan di container-nya sendiri.
Untuk lab ini, kita akan men-deploy aplikasi monolitik yang sudah ada ke cluster Google Kubernetes Engine, lalu memecahnya menjadi beberapa microservice.
Diagram Arsitektur Microservice Kami
Kita akan mulai dengan memecah monolit menjadi tiga microservice, satu per satu. yaitu Orders, Products, dan Frontend. Kita membangun image Docker untuk setiap microservice menggunakan Cloud Build, yang kita picu dari dalam Cloud Shell. Kemudian, kita akan men-deploy dan mengekspos microservice di Google Kubernetes Engine (GKE) dengan jenis layanan Kubernetes LoadBalancer. Kita akan melakukan hal ini untuk setiap layanan sambil melakukan refaktorisasi layanan tersebut dari monolit. Selama proses ini, kita akan menjalankan monolit dan microservice hingga titik akhir saat kita dapat menghapus monolit.
Yang akan Anda pelajari
- Cara memecah Monolit menjadi Microservice
- Cara membuat cluster Google Kubernetes Engine
- Cara membuat image Docker
- Cara men-deploy image Docker ke Kubernetes
Prasyarat
- Akun Google Cloud Platform dengan akses administratif untuk membuat project atau project dengan peran Pemilik Project
- Pemahaman dasar tentang Docker dan Kubernetes
2. Penyiapan Lingkungan
Penyiapan lingkungan mandiri
Jika belum memiliki Akun Google (Gmail atau Google Apps), Anda harus membuatnya. Login ke Google Cloud Platform console ( console.cloud.google.com) dan buat project baru:
Ingat project ID, nama unik di semua project Google Cloud (maaf, nama di atas telah digunakan dan tidak akan berfungsi untuk Anda!) Project ID tersebut selanjutnya akan dirujuk di codelab ini sebagai PROJECT_ID.
Selanjutnya, Anda harus mengaktifkan penagihan di Developers Console untuk menggunakan resource Google Cloud dan mengaktifkan Container Engine API.
Menjalankan melalui codelab ini tidak akan menghabiskan biaya lebih dari beberapa dolar, tetapi bisa lebih jika Anda memutuskan untuk menggunakan lebih banyak resource atau jika Anda membiarkannya berjalan (lihat bagian "pembersihan" di akhir dokumen ini). Harga Google Kubernetes Engine didokumentasikan di sini.
Pengguna baru Google Cloud Platform memenuhi syarat untuk mendapatkan uji coba gratis senilai$300.
Google Cloud Shell
Meskipun Google Cloud dan Kubernetes dapat dioperasikan dari jarak jauh menggunakan laptop Anda, dalam codelab ini, kita akan menggunakan Google Cloud Shell, lingkungan command line yang berjalan di Cloud.
Mesin virtual berbasis Debian ini memuat semua alat pengembangan yang akan Anda perlukan. Layanan ini menawarkan direktori beranda tetap sebesar 5 GB dan beroperasi di Google Cloud, sehingga sangat meningkatkan performa dan autentikasi jaringan. Ini berarti bahwa semua yang Anda perlukan untuk codelab ini adalah browser (ya, ini berfungsi di Chromebook).
- Untuk mengaktifkan Cloud Shell dari Cloud Console, cukup klik Aktifkan Cloud Shell
(hanya perlu beberapa saat untuk melakukan penyediaan dan terhubung ke lingkungan).
Setelah terhubung ke Cloud Shell, Anda akan melihat bahwa Anda sudah diautentikasi dan project sudah ditetapkan ke PROJECT_ID.
gcloud auth list
Output perintah
Credentialed accounts: - <myaccount>@<mydomain>.com (active)
gcloud config list project
Output perintah
[core] project = <PROJECT_ID>
Jika, untuk beberapa alasan, project belum disetel, cukup jalankan perintah berikut:
gcloud config set project <PROJECT_ID>
Mencari PROJECT_ID Anda? Periksa ID yang Anda gunakan di langkah-langkah penyiapan atau cari di dasbor Cloud Console:
Cloud Shell juga menetapkan beberapa variabel lingkungan secara default, yang mungkin berguna saat Anda menjalankan perintah di masa mendatang.
echo $GOOGLE_CLOUD_PROJECT
Output perintah
<PROJECT_ID>
- Terakhir, tetapkan zona dan konfigurasi project default.
gcloud config set compute/zone us-central1-f
Anda dapat memilih berbagai zona yang berbeda. Untuk informasi selengkapnya, lihat Region & Zona.
3. Membuat Clone Repositori Sumber
Kita menggunakan aplikasi monolitik yang sudah ada dari sebuah situs e-commerce fiktif yang memiliki halaman sambutan sederhana, halaman produk, dan halaman histori pesanan. Kita hanya perlu membuat clone sumber dari repositori git kita agar dapat berfokus memecahnya menjadi microservice dan men-deploy-nya ke Google Kubernetes Engine (GKE).
Jalankan perintah berikut untuk membuat clone repositori git ke instance Cloud Shell Anda dan beralih ke direktori yang sesuai. Kita juga akan menginstal dependensi NodeJS agar dapat menguji monolit sebelum di-deploy. Mungkin diperlukan waktu beberapa menit untuk menjalankan skrip ini.
cd ~ git clone https://github.com/googlecodelabs/monolith-to-microservices.git cd ~/monolith-to-microservices ./setup.sh
Tindakan ini akan meng-clone repo GitHub kita, mengubah ke direktori, dan menginstal dependensi yang diperlukan untuk menjalankan aplikasi kita secara lokal. Mungkin diperlukan waktu beberapa menit untuk menjalankan skrip ini.
4. Membuat Cluster GKE
Setelah memiliki lingkungan developer yang berfungsi, kita memerlukan cluster Kubernetes untuk men-deploy monolit dan pada akhirnya nanti, microservice. Sebelum dapat membuat cluster, kita perlu memastikan bahwa API yang tepat telah diaktifkan. Jalankan perintah berikut untuk mengaktifkan Containers API agar kita dapat menggunakan Google Kubernetes Engine:
gcloud services enable container.googleapis.com
Sekarang kita siap membuat cluster. Jalankan perintah di bawah untuk membuat cluster GKE bernama fancy-cluster dengan 3 node.
gcloud container clusters create fancy-cluster --num-nodes 3
Mungkin diperlukan waktu beberapa menit untuk membuat cluster. Setelah perintahnya selesai, jalankan perintah berikut dan lihat ketiga instance worker VM cluster:
gcloud compute instances list
Output:
NAME ZONE MACHINE_TYPE PREEMPTIBLE INTERNAL_IP EXTERNAL_IP STATUS gke-fancy-cluster-default-pool-ad92506d-1ng3 us-east4-a n1-standard-1 10.150.0.7 XX.XX.XX.XX RUNNING gke-fancy-cluster-default-pool-ad92506d-4fvq us-east4-a n1-standard-1 10.150.0.5 XX.XX.XX.XX RUNNING gke-fancy-cluster-default-pool-ad92506d-4zs3 us-east4-a n1-standard-1 10.150.0.6 XX.XX.XX.XX RUNNING
Anda juga dapat melihat cluster Kubernetes dan informasi terkaitnya di Konsol Google Cloud. Klik tombol menu di kiri atas, scroll ke bawah ke Kubernetes Engine, lalu klik Clusters. Anda akan melihat cluster Anda yang bernama fancy-cluster.
Selamat! Anda baru saja membuat cluster Kubernetes pertama Anda.
5. Men-deploy Monolit yang Ada
Karena fokus lab ini adalah membahas cara memecah monolit menjadi microservice, kita perlu menjalankan aplikasi monolit. Jalankan skrip berikut untuk men-deploy aplikasi monolitik ke cluster GKE kita untuk tujuan lab ini:
cd ~/monolith-to-microservices ./deploy-monolith.sh
Mengakses Monolit
Untuk menemukan alamat IP eksternal aplikasi monolitik kita, jalankan perintah berikut.
kubectl get service monolith
Anda akan melihat output yang mirip dengan berikut ini:
NAME CLUSTER-IP EXTERNAL-IP PORT(S) AGE monolith 10.3.251.122 203.0.113.0 80:30877/TCP 3d
CATATAN: Load balancer dan IP eksternal harus disediakan untuk hal ini, sehingga akan memerlukan waktu beberapa saat. Jika output Anda mencantumkan IP eksternal sebagai
<pending> tunggu beberapa menit dan coba lagi.
Setelah Anda mengidentifikasi alamat IP eksternal untuk monolit Anda, salin alamat IP tersebut. Buka URL ini (seperti http://203.0.113.0) browser Anda untuk memeriksa apakah monolit Anda dapat diakses.
Anda akan melihat halaman sambutan untuk situs monolitik seperti gambar di atas. Halaman sambutan adalah halaman statis yang nantinya akan disajikan oleh microservice Frontend. Sekarang, monolit Anda berjalan sepenuhnya di Kubernetes.
6. Memigrasikan Orders ke Microservice
Setelah situs monolitik yang ada berjalan di GKE, kita dapat mulai memecah setiap layanan menjadi microservice. Biasanya, upaya perencanaan harus dilakukan untuk menentukan layanan mana yang akan dipecah menjadi bagian yang lebih kecil. Ini umumnya terkait bagian tertentu dari aplikasi, misalnya domain bisnis. Untuk tujuan demonstrasi, kami telah membuat contoh sederhana dan memisahkan setiap layanan yang terkait dengan domain bisnis, Orders, Products, dan Frontend. Kodenya sudah dimigrasikan dan kita akan berfokus membangun serta men-deploy layanan di Google Kubernetes Engine (GKE).
Membuat Microservice Pesanan Baru
Layanan pertama yang akan kita pisahkan adalah layanan Orders. Kita akan memanfaatkan codebase terpisah yang disediakan dan membuat container Docker terpisah untuk layanan ini.
Membuat Container Docker dengan Google Cloud Build
Karena kami telah memigrasikan codebase untuk Anda, langkah pertama kita adalah membuat container Docker untuk layanan Orders menggunakan Google Cloud Build.
Biasanya, Anda harus mengambil pendekatan dua langkah yang mencakup pembuatan container docker dan mendorongnya ke registry untuk menyimpan image agar dapat ditarik dari GKE. Namun, kita dapat mempermudah proses ini dengan menggunakan Google Cloud Build untuk membangun container Docker dan menempatkan image di Google Cloud Container Registry dengan satu perintah. Dengan demikian, kita dapat mengeluarkan satu perintah untuk membangun dan memindahkan image ke container registry. Untuk melihat proses manual pembuatan file docker dan pengirimannya, Anda dapat membuka di sini.
Google Cloud Build akan mengompresi file dari direktori dan memindahkannya ke bucket Google Cloud Storage. Proses build kemudian akan mengambil semua file dari bucket dan menggunakan Dockerfile untuk menjalankan proses build Docker. Karena kita menentukan flag --tag dengan host sebagai gcr.io untuk image Docker, image Docker yang dihasilkan akan dikirim ke Google Cloud Container Registry.
Jalankan perintah berikut untuk membangun container Docker Anda dan mengirimnya ke Google Container Registry:
cd ~/monolith-to-microservices/microservices/src/orders
gcloud builds submit --tag gcr.io/${GOOGLE_CLOUD_PROJECT}/orders:1.0.0 .
Proses ini akan memakan waktu beberapa menit, tetapi setelah selesai, akan ada output di terminal yang mirip dengan yang berikut:
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ID CREATE_TIME DURATION SOURCE IMAGES STATUS 1ae295d9-63cb-482c-959b-bc52e9644d53 2019-08-29T01:56:35+00:00 33S gs://<PROJECT_ID>_cloudbuild/source/1567043793.94-abfd382011724422bf49af1558b894aa.tgz gcr.io/<PROJECT_ID>/orders:1.0.0 SUCCESS
Untuk melihat histori build atau mengamati prosesnya secara real time, Anda dapat membuka Konsol Google Cloud. Klik tombol menu di kiri atas, lalu scroll ke bawah ke Tools → Cloud Build, lalu klik History. Di sini Anda dapat melihat daftar semua build sebelumnya. Seharusnya hanya ada 1 build yang baru saja Anda buat.
Jika Anda mengklik ID build, Anda dapat melihat semua detail untuk build tersebut, termasuk output lognya.
Dari halaman detail build, Anda dapat melihat image container yang dibuat dengan mengklik nama image di bagian informasi build.
Men-deploy Container ke GKE
Setelah membuat container untuk situs dan mengirim container ke Google Container Registry, sekarang saatnya men-deploy ke Kubernetes.
Kubernetes merepresentasikan aplikasi sebagai Pod, yaitu unit yang merepresentasikan sebuah container (atau sekelompok container yang terkait erat). Pod adalah unit terkecil yang dapat di-deploy di Kubernetes. Dalam tutorial ini, masing-masing Pod hanya berisi container microservice Anda.
Untuk men-deploy dan mengelola aplikasi di cluster GKE, Anda harus berkomunikasi dengan sistem pengelolaan cluster Kubernetes. Hal ini biasanya dilakukan menggunakan alat command line kubectl dari dalam Cloud Shell.
Pertama, kita akan membuat resource Deployment. Deployment mengelola beberapa salinan aplikasi Anda, yang disebut replika, dan menjadwalkannya untuk berjalan di node individual dalam cluster Anda. Dalam hal ini, Deployment hanya akan menjalankan satu Pod aplikasi Anda. Deployment memastikan hal ini dengan membuat ReplicaSet. ReplicaSet bertanggung jawab untuk memastikan jumlah replika yang ditentukan selalu berjalan.
Perintah kubectl create deployment di bawah ini menyebabkan Kubernetes membuat Deployment bernama orders di cluster Anda dengan 1 replika.
Jalankan perintah berikut untuk men-deploy aplikasi Anda:
kubectl create deployment orders --image=gcr.io/${GOOGLE_CLOUD_PROJECT}/orders:1.0.0
Memverifikasi Deployment
Untuk memverifikasi bahwa Deployment berhasil dibuat, jalankan perintah berikut. Mungkin diperlukan waktu beberapa saat agar status pod menjadi Running:
kubectl get all
Output:
NAME READY STATUS RESTARTS AGE pod/monolith-779c8d95f5-dxnzl 1/1 Running 0 15h pod/orders-5bc6969d76-kdxkk 1/1 Running 0 21s NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE service/kubernetes ClusterIP 10.39.240.1 <none> 443/TCP 19d service/monolith LoadBalancer 10.39.241.130 34.74.209.57 80:30412/TCP 15h NAME READY UP-TO-DATE AVAILABLE AGE deployment.apps/monolith 1/1 1 1 15h deployment.apps/orders 1/1 1 1 21s NAME DESIRED CURRENT READY AGE replicaset.apps/monolith-779c8d95f5 1 1 1 15h replicaset.apps/orders-5bc6969d76 1 1 1 21s
Output ini menunjukkan beberapa hal. Kita dapat melihat Deployment yang aktif, ReplicaSet dengan jumlah pod yang diinginkan sebanyak 1, dan Pod yang sedang berjalan. Sepertinya semuanya berhasil dibuat.
Mengekspos Container GKE
Kami telah men-deploy aplikasi kami di GKE, tetapi kami tidak memiliki cara untuk mengaksesnya di luar cluster. Secara default, container yang Anda jalankan di GKE tidak dapat diakses dari Internet karena tidak memiliki alamat IP eksternal. Anda harus secara eksplisit mengekspos aplikasi Anda ke traffic dari Internet melalui resource Service. Service menyediakan dukungan networking dan IP untuk Pod aplikasi Anda. GKE membuat IP eksternal dan Load Balancer ( bergantung pada penagihan) untuk aplikasi Anda.
Saat men-deploy layanan Orders, kita mengeksposnya di port 8081 secara internal melalui deployment Kubernetes. Untuk mengekspos layanan ini secara eksternal, kita perlu membuat layanan Kubernetes dengan jenis LoadBalancer untuk merutekan traffic dari port 80 secara eksternal ke port 8081 internal untuk layanan Orders. Jalankan perintah berikut untuk mengekspos situs Anda ke Internet:
kubectl expose deployment orders --type=LoadBalancer --port 80 --target-port 8081
Mengakses Layanan
GKE menetapkan alamat IP eksternal ke resource Service, bukan Deployment. Jika Anda ingin mengetahui IP eksternal yang disediakan GKE untuk aplikasi Anda, Anda dapat memeriksa Service dengan perintah kubectl get service:
kubectl get service orders
Output:
NAME CLUSTER-IP EXTERNAL-IP PORT(S) AGE orders 10.3.251.122 203.0.113.0 80:30877/TCP 3d
Setelah Anda mengidentifikasi alamat IP eksternal untuk aplikasi Anda, salin alamat IP tersebut. Simpan alamatnya untuk langkah berikutnya saat kita mengubah monolit agar mengarah ke layanan Orders yang baru.
Mengonfigurasi Ulang Monolit
Karena kita telah menghapus layanan Orders dari monolit, kita harus memodifikasi monolit agar mengarah ke microservice Orders eksternal yang baru.
Saat memecah monolit, kita memindahkan potongan kode dari satu codebase ke beberapa codebase dan men-deploy-nya secara terpisah. Karena microservice berjalan di server yang berbeda, kita tidak dapat lagi merujuk URL layanan kita sebagai jalur absolut. Kita harus mengarahkannya ke alamat server baru microservice Orders. Perhatikan bahwa langkah ini akan memerlukan waktu non-operasional untuk layanan monolitik guna memperbarui URL untuk setiap layanan yang telah dipisahkan. Hal ini harus diperhitungkan dalam perencanaan pemindahan microservice dan monolit Anda ke produksi selama proses migrasi microservice.
Kita perlu mengupdate file konfigurasi di monolit agar mengarah ke alamat IP microservice Orders yang baru. Gunakan editor nano untuk mengganti URL lokal dengan alamat IP microservice Orders baru kami. Jalankan perintah berikut untuk mengedit
cd ~/monolith-to-microservices/react-app nano .env.monolith
Saat editor terbuka, file Anda akan terlihat seperti ini:
REACT_APP_ORDERS_URL=/service/orders REACT_APP_PRODUCTS_URL=/service/products
Ganti REACT_APP_ORDERS_URL ke format baru sambil menggantinya dengan alamat IP microservice Orders Anda sehingga sesuai dengan yang di bawah ini:
REACT_APP_ORDERS_URL=http://<ORDERS_IP_ADDRESS>/api/orders REACT_APP_PRODUCTS_URL=/service/products
Tekan CTRL+O, tekan ENTER, lalu CTRL+X untuk menyimpan file di editor nano.
Anda dapat menguji microservice baru dengan membuka URL yang baru saja Anda tetapkan di file ini. Halaman web seharusnya menampilkan respons JSON dari microservice Orders kami.
Selanjutnya, kita perlu membangun ulang frontend monolit dan mengulangi proses build untuk membangun container bagi monolit dan melakukan deployment ulang ke cluster GKE. Jalankan perintah berikut untuk menyelesaikan langkah-langkah ini:
Membangun Ulang File Konfigurasi Monolit
npm run build:monolith
Membuat Container Docker dengan Google Cloud Build
cd ~/monolith-to-microservices/monolith
gcloud builds submit --tag gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:2.0.0 .
Men-deploy Container ke GKE
kubectl set image deployment/monolith monolith=gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:2.0.0
Anda dapat memverifikasi bahwa aplikasi Anda sekarang mengakses microservice Orders yang baru dengan membuka aplikasi monolit di browser Anda dan membuka halaman Orders. Semua ID pesanan seharusnya memiliki akhiran -MICROSERVICE seperti yang ditunjukkan di bawah:
7. Memigrasikan Produk ke Microservice
Membuat Microservice Produk Baru
Kita dapat melanjutkan pemisahan layanan dengan memigrasikan layanan Products. Kita akan mengikuti proses yang sama seperti langkah sebelumnya. Jalankan perintah berikut untuk membangun container Docker, men-deploy container Anda, dan mengeksposnya melalui layanan Kubernetes.
Membuat Container Docker dengan Google Cloud Build
cd ~/monolith-to-microservices/microservices/src/products
gcloud builds submit --tag gcr.io/${GOOGLE_CLOUD_PROJECT}/products:1.0.0 .
Men-deploy Container ke GKE
kubectl create deployment products --image=gcr.io/${GOOGLE_CLOUD_PROJECT}/products:1.0.0
Mengekspos Container GKE
kubectl expose deployment products --type=LoadBalancer --port 80 --target-port 8082
Temukan IP publik layanan Produk kami dengan cara yang sama seperti yang kami lakukan untuk layanan Pesanan kami dengan perintah berikut:
kubectl get service products
Output:
NAME CLUSTER-IP EXTERNAL-IP PORT(S) AGE products 10.3.251.122 203.0.113.0 80:30877/TCP 3d
Simpan alamat IP untuk langkah berikutnya saat kita mengonfigurasi ulang monolit agar mengarah ke microservice Products baru.
Mengonfigurasi Ulang Monolit
Gunakan editor nano untuk mengganti URL lokal dengan alamat IP microservice Products baru kami:
cd ~/monolith-to-microservices/react-app nano .env.monolith
Saat editor terbuka, file Anda akan terlihat seperti ini:
REACT_APP_ORDERS_URL=http://<ORDERS_IP_ADDRESS>/api/orders REACT_APP_PRODUCTS_URL=/service/products
Ganti REACT_APP_PRODUCTS_URL ke format baru sambil menggantinya dengan alamat IP microservice Product Anda sehingga sesuai dengan yang di bawah ini:
REACT_APP_ORDERS_URL=http://<ORDERS_IP_ADDRESS>/api/orders REACT_APP_PRODUCTS_URL=http://<PRODUCTS_IP_ADDRESS>/api/products
Tekan CTRL+O, tekan ENTER, lalu CTRL+X untuk menyimpan file di editor nano.
Anda dapat menguji microservice baru dengan membuka URL yang baru saja Anda tetapkan di file ini. Halaman web seharusnya menampilkan respons JSON dari microservice Products kami.
Selanjutnya, kita perlu membangun ulang frontend monolit dan mengulangi proses build untuk membangun container bagi monolit dan melakukan deployment ulang ke cluster GKE. Jalankan perintah berikut untuk menyelesaikan langkah-langkah ini:
Membangun Ulang File Konfigurasi Monolit
npm run build:monolith
Membuat Container Docker dengan Google Cloud Build
cd ~/monolith-to-microservices/monolith
gcloud builds submit --tag gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:3.0.0 .
Men-deploy Container ke GKE
kubectl set image deployment/monolith monolith=gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:3.0.0
Anda dapat memverifikasi bahwa aplikasi Anda sekarang mengakses microservice Products yang baru dengan membuka aplikasi monolit di browser Anda dan membuka halaman Products. Semua nama produk seharusnya memiliki awalan MS- seperti yang ditunjukkan di bawah ini:
8. Memigrasikan Frontend ke Microservice
Langkah terakhir dalam proses migrasi adalah memindahkan kode Frontend ke microservice dan mematikan monolit. Setelah langkah ini selesai, berarti kita berhasil memigrasikan monolit ke arsitektur microservice.
Membuat Microservice Frontend Baru
Ikuti prosedur yang sama seperti dua langkah terakhir untuk membuat microservice Frontend baru.
Sebelumnya, saat membangun ulang monolit, kita memperbarui konfigurasi agar mengarah ke monolit, tetapi sekarang kita perlu menggunakan konfigurasi yang sama untuk microservice Frontend. Jalankan perintah berikut untuk menyalin file konfigurasi URL microservice kami ke codebase microservice Frontend:
cd ~/monolith-to-microservices/react-app cp .env.monolith .env npm run build
Setelah selesai, kita akan mengikuti proses yang sama seperti langkah sebelumnya. Jalankan perintah berikut untuk membangun container Docker, men-deploy container Anda, dan mengeksposnya melalui layanan Kubernetes.
Membuat Container Docker dengan Google Cloud Build
cd ~/monolith-to-microservices/microservices/src/frontend
gcloud builds submit --tag gcr.io/${GOOGLE_CLOUD_PROJECT}/frontend:1.0.0 .
Men-deploy Container ke GKE
kubectl create deployment frontend --image=gcr.io/${GOOGLE_CLOUD_PROJECT}/frontend:1.0.0
Mengekspos Container GKE
kubectl expose deployment frontend --type=LoadBalancer --port 80 --target-port 8080
Menghapus Monolit
Setelah semua layanan berjalan sebagai microservice, kita dapat menghapus aplikasi monolitik. Perhatikan, dalam migrasi sebenarnya, langkah ini juga akan melibatkan perubahan DNS, dll., agar nama domain yang ada mengarah ke microservice Frontend yang baru untuk aplikasi kita. Jalankan perintah berikut untuk menghapus monolit kita:
kubectl delete deployment monolith kubectl delete service monolith
Menguji Hasil Kerja Anda
Untuk memverifikasi bahwa semuanya berfungsi, pastikan bahwa sekarang alamat IP lama dari layanan monolit Anda tidak berfungsi dan alamat IP baru dari layanan frontend Anda menghosting aplikasi yang baru. Untuk melihat daftar semua layanan dan alamat IP, gunakan perintah berikut:
kubectl get services
Output Anda akan terlihat mirip seperti berikut:
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE frontend LoadBalancer 10.39.246.135 35.227.21.154 80:32663/TCP 12m kubernetes ClusterIP 10.39.240.1 <none> 443/TCP 18d orders LoadBalancer 10.39.243.42 35.243.173.255 80:32714/TCP 31m products LoadBalancer 10.39.250.16 35.243.180.23 80:32335/TCP 21m
Setelah Anda mengidentifikasi alamat IP eksternal untuk microservice Frontend Anda, salin alamat IP tersebut. Buka URL ini (seperti http://203.0.113.0) di browser Anda untuk memeriksa apakah frontend Anda dapat diakses. Situs Anda seharusnya tetap sama seperti sebelum kami memecah monolit menjadi microservice.
9. Pembersihan
Setelah siap, cara termudah untuk membersihkan semua aktivitas yang dilakukan adalah dengan menghapus Project. Menghapus project akan menghapus semua resource yang dibuat dalam Codelab ini untuk memastikan tidak ada biaya berulang yang tidak terduga. Jalankan perintah berikut di Cloud Shell, dengan PROJECT_ID adalah Project ID lengkap, bukan hanya Nama Project.
gcloud projects delete [PROJECT_ID]
Konfirmasi penghapusan dengan memasukkan "Y" saat diminta.
10. Selamat!
Anda telah berhasil memecah aplikasi monolitik menjadi microservice dan men-deploy-nya di Google Kubernetes Engine.
Langkah Berikutnya
Lihat codelab berikut untuk mempelajari Kubernetes lebih lanjut:
- Men-deploy, Menskalakan, dan Mengupdate Situs Anda di Google Kubernetes Engine
- Membuat Slack Bot dengan Node.js di Kubernetes
- Continuous Delivery ke Kubernetes Menggunakan Spinnaker
- Men-deploy aplikasi Java ke Kubernetes di Google Kubernetes Engine
Referensi Tambahan
- Docker - https://docs.docker.com/
- Kubernetes - https://kubernetes.io/docs/home/
- Google Kubernetes Engine (GKE) - https://cloud.google.com/kubernetes-engine/docs/
- Google Cloud Build - https://cloud.google.com/cloud-build/docs/
- Google Container Registry - https://cloud.google.com/container-registry/docs/
- Memigrasikan Monolit ke Microservice - https://cloud.google.com/solutions/migrating-a-monolithic-app-to-microservices-gke