1. Pengantar
Mengapa bermigrasi dari aplikasi monolitik ke arsitektur microservice? Memecah aplikasi menjadi beberapa microservice memiliki keuntungan berikut; sebagian besar berasal dari fakta bahwa microservice dikaitkan secara longgar.
- Microservice dapat diuji dan di-deploy secara mandiri. Makin kecil unit deployment, makin mudah deployment.
- Microservice dapat diterapkan dalam berbagai bahasa dan framework. Untuk setiap microservice, Anda bebas memilih teknologi terbaik untuk kasus penggunaan tertentu.
- Microservice dapat dikelola oleh tim yang berbeda. Batas antar-microservice memudahkan dalam mendedikasikan tim untuk satu atau beberapa microservice.
- Dengan beralih ke microservice, Anda melonggarkan dependensi antartim. Setiap tim hanya perlu memperhatikan API microservice yang diandalkan. Tim tidak perlu memikirkan cara implementasi microservice tersebut, siklus rilisnya, dan sebagainya.
- Anda dapat lebih mudah mendesain untuk kegagalan. Dengan memiliki batasan yang jelas antarlayanan, akan lebih mudah untuk menentukan tindakan yang harus dilakukan jika layanan sedang tidak aktif.
Beberapa kelemahan jika dibandingkan dengan monolit adalah:
- Karena aplikasi berbasis microservice adalah jaringan dari berbagai layanan yang sering berinteraksi dengan cara yang tidak jelas, kompleksitas keseluruhan sistem cenderung meningkat.
- Tidak seperti 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 dengan pendekatan monolitik karena latensi antarlayanan.
- Perilaku sistem Anda tidak disebabkan oleh satu layanan, tetapi oleh banyak layanan dan interaksinya. Oleh karena itu, lebih sulit untuk memahami perilaku sistem Anda dalam produksi (kemampuan observasinya). 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 merupakan cara portabel untuk mengemas dan menjalankan kode. Pola ini sangat cocok dengan pola microservice, di mana setiap microservice dapat berjalan di container-nya sendiri.
Untuk lab ini, kita akan men-deploy aplikasi monolitik yang sudah ada ke cluster Google Kubernetes Engine, lalu menguraikannya menjadi beberapa microservice.
Diagram Arsitektur Microservice Kami
Kita akan mulai dengan memecah monolit menjadi tiga microservice, satu per satu. Microservice mencakup Pesanan, Produk, dan Frontend. Kami membangun image Docker untuk setiap microservice menggunakan Cloud Build, yang kami picu dari dalam Cloud Shell. Kemudian, kita akan men-deploy dan mengekspos microservice di Google Kubernetes Engine (GKE) dengan LoadBalancer jenis layanan Kubernetes. Kita akan melakukan ini untuk setiap layanan sambil memfaktorkan ulang layanan dari monolit secara bersamaan. Selama proses ini, kami akan menjalankan monolit dan microservice hingga akhir, ketika kami dapat menghapus monolit.
Yang akan Anda pelajari
- Cara menguraikan 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 Project Owner
- 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 konsol Google Cloud Platform ( 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 secara jarak jauh dari laptop Anda, dalam codelab ini kita akan menggunakan Google Cloud Shell, yakni 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. Meng-clone Repositori Sumber
Kami menggunakan aplikasi monolitik yang sudah ada untuk situs e-commerce fiktif, dengan halaman sambutan sederhana, halaman produk, dan halaman histori pesanan. Kita hanya perlu meng-clone sumber dari repo git, agar dapat berfokus untuk memecahnya menjadi microservice dan men-deploy ke Google Kubernetes Engine (GKE).
Jalankan perintah berikut untuk meng-clone repo git ke instance Cloud Shell Anda dan beralih ke direktori yang sesuai. Kita juga akan menginstal dependensi NodeJS sehingga kita dapat menguji monolit sebelum melakukan deployment. Mungkin perlu waktu beberapa menit untuk menjalankan skrip ini.
cd ~ git clone https://github.com/googlecodelabs/monolith-to-microservices.git cd ~/monolith-to-microservices ./setup.sh
Ini akan meng-clone repo GitHub kita, mengubah ke direktori, dan menginstal dependensi yang diperlukan untuk menjalankan aplikasi kita secara lokal. Mungkin perlu waktu beberapa menit untuk menjalankan skrip ini.
4. Membuat Cluster GKE
Setelah Anda memiliki lingkungan developer yang aktif, kita memerlukan cluster Kubernetes untuk men-deploy monolit dan akhirnya microservice kita. Sebelum dapat membuat cluster, kita perlu memastikan API yang tepat diaktifkan. Jalankan perintah berikut untuk mengaktifkan container API agar kita dapat menggunakan Google Kubernetes Engine:
gcloud services enable container.googleapis.com
Sekarang kita siap untuk membuat cluster. Jalankan perintah di bawah ini untuk membuat cluster GKE bernama fancy-cluster dengan 3 node.
gcloud container clusters create fancy-cluster --num-nodes 3
Mungkin perlu waktu beberapa menit untuk membuat cluster. Setelah perintah selesai, jalankan perintah berikut dan lihat tiga instance VM worker di 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 terkait di konsol Google Cloud. Klik tombol menu di kiri atas, scroll ke bawah ke Kubernetes Engine, lalu klik Clusters. Anda akan melihat cluster yang bernama fancy-cluster.
Selamat! Anda baru saja berhasil membuat cluster Kubernetes pertama Anda.
5. Men-deploy Monolit yang Sudah Ada
Karena fokus lab ini adalah memandu memecah monolit menjadi beberapa microservice, kita perlu mengaktifkan dan menjalankan aplikasi monolit. Jalankan skrip berikut untuk men-deploy aplikasi monolit ke cluster GKE untuk tujuan lab ini:
cd ~/monolith-to-microservices ./deploy-monolith.sh
Mengakses Monolit
Untuk menemukan alamat IP eksternal aplikasi monolit, 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 eksternal dan IP perlu disediakan untuk hal ini, sehingga proses ini memerlukan waktu. Jika output Anda mencantumkan IP eksternal sebagai
<pending> beri waktu beberapa menit dan coba lagi.
Setelah menentukan alamat IP eksternal untuk monolit Anda, salin alamat IP tersebut. Arahkan browser Anda ke URL ini (seperti http://203.0.113.0) untuk memeriksa apakah monolit Anda dapat diakses.
Anda akan melihat halaman sambutan untuk situs monolitik seperti gambar di atas. Halaman selamat datang adalah halaman statis yang nantinya akan disalurkan oleh microservice Frontend. Sekarang monolit Anda sudah berjalan sepenuhnya di Kubernetes.
6. Memigrasikan Pesanan ke Microservice
Setelah menjalankan situs monolit di GKE, kita dapat mulai memecah setiap layanan menjadi microservice. Biasanya, upaya perencanaan harus dilakukan pada layanan mana yang akan dibagi menjadi potongan-potongan yang lebih kecil, biasanya seputar bagian tertentu dari aplikasi seperti domain bisnis. Untuk tujuan demonstrasi, kami telah membuat contoh sederhana dan menguraikan setiap layanan di seputar domain bisnis, Pesanan, Produk, dan Frontend. Kode telah dimigrasikan dan kita akan berfokus pada pembangunan dan deployment layanan di Google Kubernetes Engine (GKE).
Buat Microservice Pesanan Baru
Layanan pertama yang akan kita pisahkan adalah layanan Pesanan. Kami akan menggunakan 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 kami adalah membuat container Docker dari layanan Pesanan menggunakan Google Cloud Build.
Biasanya Anda harus mengambil pendekatan dua langkah yang berarti membangun container docker dan mengirimkannya ke registry untuk menyimpan image yang dapat diambil GKE. Namun kita dapat membuat hidup lebih mudah. Kita dapat menggunakan Google Cloud Build untuk membangun container Docker dan menempatkan image di Google Cloud Container Registry dengan satu perintah. Dengan begitu, kita dapat mengeluarkan satu perintah untuk membangun dan memindahkan image ke container registry. Untuk melihat proses manual pembuatan file Docker dan mendorongnya, Anda dapat membuka di sini.
Google Cloud Build akan mengompresi file dari direktori dan memindahkannya ke bucket Google Cloud Storage. Selanjutnya, proses build 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 dan mengirimkannya 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 berikut ini:
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 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 menonton prosesnya secara real time, Anda dapat membuka konsol Google Cloud. Klik tombol menu di kiri atas dan 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 mengklik ID build, Anda dapat melihat semua detail build tersebut, termasuk output log.
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 kita memasukkan situs ke dalam container dan mengirimkan container ke Google Container Registry, sekarang saatnya men-deploy ke Kubernetes.
Kubernetes merepresentasikan aplikasi sebagai Pod, yang merupakan unit yang mewakili sebuah container (atau grup container yang terkait erat). Pod adalah unit terkecil yang dapat di-deploy di Kubernetes. Dalam tutorial ini, setiap Pod hanya berisi container microservice.
Untuk men-deploy dan mengelola aplikasi di cluster GKE, Anda harus berkomunikasi dengan sistem pengelolaan cluster Kubernetes. Biasanya, Anda dapat melakukannya dengan menggunakan alat command line kubectl dari dalam Cloud Shell.
Pertama-tama, kita akan membuat resource Deployment. Deployment mengelola beberapa salinan aplikasi Anda, yang disebut replika, dan menjadwalkannya untuk dijalankan pada setiap node di 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 orders bernama Deployment 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
Agar Deployment berhasil dibuat, jalankan perintah berikut. Mungkin perlu waktu beberapa saat sampai status pod berjalan:
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 sedang berjalan, ReplicaSet dengan jumlah pod yang diinginkan 1, dan Pod yang sedang berjalan. Sepertinya semuanya berhasil dibuat.
Mengekspos Container GKE
Kita telah men-deploy aplikasi di GKE, tetapi tidak memiliki cara untuk mengaksesnya di luar cluster. Secara default, container yang Anda jalankan di GKE tidak dapat diakses dari Internet, karena container tersebut tidak memiliki alamat IP eksternal. Anda harus secara eksplisit mengekspos aplikasi ke traffic dari Internet melalui resource Service. Service menyediakan dukungan jaringan dan IP untuk Pod aplikasi Anda. GKE membuat IP eksternal dan Load Balancer ( tunduk kepada penagihan) untuk aplikasi Anda.
Saat men-deploy layanan Orders, kami mengeksposnya pada port 8081 secara internal melalui deployment Kubernetes. Untuk mengekspos layanan ini secara eksternal, kita perlu membuat layanan Kubernetes jenis LoadBalancer untuk mengarahkan traffic dari port 80 secara eksternal ke port internal 8081 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 ke Deployment. Jika 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 menentukan alamat IP eksternal untuk aplikasi Anda, salin alamat IP tersebut. Simpan untuk langkah berikutnya saat kita mengubah monolit agar mengarah ke layanan Orders yang baru.
Mengonfigurasi ulang Monolit
Karena kita menghapus layanan Orders dari monolit, kita harus memodifikasi monolit agar mengarah ke microservice Pesanan eksternal yang baru.
Saat memecah monolit, kami menghapus potongan kode dari satu codebase ke beberapa codebase dan men-deploy-nya secara terpisah. Karena microservice berjalan di server yang berbeda, kami tidak dapat lagi mereferensikan URL layanan sebagai jalur absolut. Oleh karena itu, kami perlu merutekan ke alamat server baru pesanan microservice kami. Perlu diperhatikan bahwa tindakan ini akan memerlukan periode nonaktif pada service monolit untuk memperbarui URL setiap service yang dirusak. Hal ini harus diperhitungkan saat berencana memindahkan microservice dan monolit ke lingkungan production selama proses migrasi microservice.
Kita perlu memperbarui file konfigurasi di monolit agar mengarah ke alamat IP microservice Pesanan yang baru. Gunakan editor nano untuk mengganti URL lokal dengan alamat IP microservice Pesanan baru kita. 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 mengganti dengan alamat IP microservice Pesanan Anda agar cocok di bawah:
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 ditetapkan dalam file ini. Halaman web akan menampilkan respons JSON dari microservice Pesanan kami.
Selanjutnya, kita perlu membangun ulang frontend monolit dan mengulangi proses build untuk membangun container monolit dan men-deploy ulang ke cluster GKE. Jalankan perintah berikut untuk menyelesaikan langkah-langkah ini:
Membuat 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 mencapai microservice Orders baru dengan membuka aplikasi monolit di browser dan membuka halaman Orders. Semua ID pesanan harus diakhiri dengan akhiran -MICROSERVICE seperti yang ditunjukkan di bawah ini:
7. Memigrasikan Produk ke Microservice
Buat Microservice Produk Baru
Kami dapat terus mengelompokkan layanan kami dengan memigrasikan layanan Produk berikutnya. Kita akan mengikuti proses yang sama seperti langkah sebelumnya. Jalankan perintah berikut untuk membangun container Docker, men-deploy container, 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 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 mengonfigurasi ulang monolit agar mengarah ke microservice Produk baru.
Mengonfigurasi ulang Monolit
Gunakan editor nano untuk mengganti URL lokal dengan alamat IP microservice Produk 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 mengganti dengan alamat IP Microservice produk Anda sehingga cocok 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 ditetapkan dalam file ini. Halaman web akan menampilkan respons JSON dari microservice Produk kami.
Selanjutnya, kita perlu membangun ulang frontend monolit dan mengulangi proses build untuk membangun container monolit dan men-deploy ulang ke cluster GKE. Jalankan perintah berikut untuk menyelesaikan langkah-langkah ini:
Membuat 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 memasuki microservice Produk baru dengan membuka aplikasi monolit di browser lalu membuka halaman Produk. Semua nama produk harus diawali dengan MS- seperti yang ditunjukkan di bawah ini:
8. Memigrasikan Frontend ke Microservice
Langkah terakhir dalam proses migrasi adalah memindahkan kode Frontend ke microservice dan menonaktifkan monolit. Setelah langkah ini selesai, kita akan berhasil memigrasikan monolit ke arsitektur microservice.
Buat Microservice Frontend Baru
Mari 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 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, 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
Hapus Monolit
Setelah semua layanan berjalan sebagai microservice, kita dapat menghapus aplikasi monolit. Perhatikan bahwa dalam migrasi yang sebenarnya, hal ini juga akan memerlukan perubahan DNS, dll. agar nama domain yang sudah ada mengarah ke microservice frontend baru untuk aplikasi kita. Jalankan perintah berikut untuk menghapus monolit:
kubectl delete deployment monolith kubectl delete service monolith
Uji Pekerjaan Anda
Untuk memverifikasi bahwa semuanya berfungsi, alamat IP lama dari service monolit tidak akan berfungsi, dan alamat IP baru dari layanan frontend harus menghosting aplikasi baru. Untuk melihat daftar semua layanan dan alamat IP, gunakan perintah berikut:
kubectl get services
Output Anda akan terlihat 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 menentukan alamat IP eksternal untuk microservice Frontend, salin alamat IP tersebut. Arahkan browser Anda ke URL ini (seperti http://203.0.113.0) untuk memeriksa apakah frontend Anda dapat diakses. Situs Anda harus 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 tagihan berulang yang tidak terduga. Jalankan perintah berikut dalam 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 berhasil memecah aplikasi monolitik menjadi beberapa microservice dan men-deploy-nya di Google Kubernetes Engine.
Langkah Berikutnya
Lihat codelab berikut untuk mempelajari Kubernetes lebih lanjut:
- Men-deploy, Menskalakan, dan Memperbarui Situs di Google Kubernetes Engine
- Membangun Bot Slack dengan Node.js di Kubernetes
- Continuous Delivery ke Kubernetes Menggunakan Spinnaker
- Men-deploy aplikasi Java ke Kubernetes pada 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 Microservices - https://cloud.google.com/solutions/migrating-a-monolithic-app-to-microservices-gke