GSP699

Ringkasan

Apa manfaat migrasi dari aplikasi monolitik ke arsitektur microservice? Pemecahan aplikasi menjadi beberapa microservice membawa keuntungan seperti di bawah, sebagian besar karena 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, Anda akan men-deploy aplikasi monolitik yang sudah ada ke cluster Google Kubernetes Engine, lalu memecahnya menjadi beberapa microservice. 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.

Diagram arsitektur microservice

Mulailah dengan secara bertahap memecah monolit menjadi tiga microservice, yaitu Orders, Products, dan Frontend. Bangun image Docker untuk setiap microservice menggunakan Cloud Build, lalu deploy dan ekspos microservice di Google Kubernetes Engine (GKE) dengan jenis layanan Kubernetes LoadBalancer. Anda akan melakukan hal ini untuk setiap layanan sambil melakukan refaktorisasi layanan tersebut dari monolit. Selama proses ini, Anda akan menjalankan monolit dan microservice hingga titik akhir saat Anda 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

Penyiapan dan persyaratan

Sebelum mengklik tombol Start Lab

Baca petunjuk ini. Lab memiliki timer dan Anda tidak dapat menjedanya. Timer yang dimulai saat Anda mengklik Start Lab akan menampilkan durasi ketersediaan resource Google Cloud untuk Anda.

Lab interaktif ini dapat Anda gunakan untuk melakukan aktivitas lab di lingkungan cloud sungguhan, bukan di lingkungan demo atau simulasi. Untuk mengakses lab ini, Anda akan diberi kredensial baru yang bersifat sementara dan dapat digunakan untuk login serta mengakses Google Cloud selama durasi lab.

Untuk menyelesaikan lab ini, Anda memerlukan:

• Akses ke browser internet standar (disarankan browser Chrome).

Catatan: Gunakan jendela Samaran (direkomendasikan) atau browser pribadi untuk menjalankan lab ini. Hal ini akan mencegah konflik antara akun pribadi Anda dan akun siswa yang dapat menyebabkan tagihan ekstra pada akun pribadi Anda.

• Waktu untuk menyelesaikan lab. Ingat, setelah dimulai, lab tidak dapat dijeda.

Catatan: Hanya gunakan akun siswa untuk lab ini. Jika Anda menggunakan akun Google Cloud yang berbeda, Anda mungkin akan dikenai tagihan ke akun tersebut.

Cara memulai lab dan login ke Google Cloud Console

1. Klik tombol Start Lab. Jika Anda perlu membayar lab, dialog akan terbuka untuk memilih metode pembayaran. Di sebelah kiri ada panel Lab Details yang berisi hal-hal berikut:

   • Tombol Open Google Cloud console
   • Waktu tersisa
   • Kredensial sementara yang harus Anda gunakan untuk lab ini
   • Informasi lain, jika diperlukan, untuk menyelesaikan lab ini

2. Klik Open Google Cloud console (atau klik kanan dan pilih Open Link in Incognito Window jika Anda menjalankan browser Chrome).

   Lab akan menjalankan resource, lalu membuka tab lain yang menampilkan halaman Sign in.

   Tips: Atur tab di jendela terpisah secara berdampingan.

   Catatan: Jika Anda melihat dialog Choose an account, klik Use Another Account.

3. Jika perlu, salin Username di bawah dan tempel ke dialog Sign in.

   {{{user_0.username | "Username"}}}

   Anda juga dapat menemukan Username di panel Lab Details.

4. Klik Next.

5. Salin Password di bawah dan tempel ke dialog Welcome.

   {{{user_0.password | "Password"}}}

   Anda juga dapat menemukan Password di panel Lab Details.

6. Klik Next.

   Penting: Anda harus menggunakan kredensial yang diberikan lab. Jangan menggunakan kredensial akun Google Cloud Anda. Catatan: Menggunakan akun Google Cloud sendiri untuk lab ini dapat dikenai biaya tambahan.

7. Klik halaman berikutnya:

   • Setujui persyaratan dan ketentuan.
   • Jangan tambahkan opsi pemulihan atau autentikasi 2 langkah (karena ini akun sementara).
   • Jangan mendaftar uji coba gratis.

Setelah beberapa saat, Konsol Google Cloud akan terbuka di tab ini.

Catatan: Untuk mengakses produk dan layanan Google Cloud, klik Navigation menu atau ketik nama layanan atau produk di kolom Search.

Mengaktifkan Cloud Shell

Cloud Shell adalah mesin virtual yang dilengkapi dengan berbagai alat pengembangan. Mesin virtual ini menawarkan direktori beranda persisten berkapasitas 5 GB dan berjalan di Google Cloud. Cloud Shell menyediakan akses command-line untuk resource Google Cloud Anda.

1. Klik Activate Cloud Shell di bagian atas Konsol Google Cloud.

2. Klik jendela berikut:

   • Lanjutkan melalui jendela informasi Cloud Shell.
   • Beri otorisasi ke Cloud Shell untuk menggunakan kredensial Anda guna melakukan panggilan Google Cloud API.

Setelah terhubung, Anda sudah diautentikasi, dan project ditetapkan ke Project_ID, . Output berisi baris yang mendeklarasikan Project_ID untuk sesi ini:

Project Cloud Platform Anda dalam sesi ini disetel ke {{{project_0.project_id | "PROJECT_ID"}}}

gcloud adalah alat command line untuk Google Cloud. Alat ini sudah terinstal di Cloud Shell dan mendukung pelengkapan command line.

3. (Opsional) Anda dapat menampilkan daftar nama akun yang aktif dengan perintah ini:

gcloud auth list

4. Klik Authorize.

Output:

ACTIVE: * ACCOUNT: {{{user_0.username | "ACCOUNT"}}} Untuk menetapkan akun aktif, jalankan: $ gcloud config set account `ACCOUNT`

5. (Opsional) Anda dapat menampilkan daftar ID project dengan perintah ini:

gcloud config list project

Output:

[core] project = {{{project_0.project_id | "PROJECT_ID"}}} Catatan: Untuk mendapatkan dokumentasi gcloud yang lengkap di Google Cloud, baca panduan ringkasan gcloud CLI.

Tetapkan konfigurasi project dan zona default:

gcloud config set compute/zone {{{project_0.default_zone | (zone)}}}

Tugas 1. Membuat clone repositori sumber

Anda akan 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. Anda juga akan menginstal dependensi NodeJS agar dapat menguji monolit sebelum di-deploy:

cd ~ git clone https://github.com/googlecodelabs/monolith-to-microservices.git cd ~/monolith-to-microservices ./setup.sh

Mungkin diperlukan waktu beberapa menit untuk menjalankan skrip ini.

Tugas 2. Membuat cluster GKE

Setelah memiliki lingkungan developer yang berfungsi, Anda memerlukan cluster Kubernetes untuk men-deploy monolit dan pada akhirnya nanti, microservice. Sebelum dapat membuat cluster, Anda perlu memastikan bahwa API yang tepat telah diaktifkan.

1. Jalankan perintah berikut untuk mengaktifkan Containers API agar Anda dapat menggunakan Google Kubernetes Engine:

gcloud services enable container.googleapis.com

2. Jalankan perintah di bawah untuk membuat cluster GKE bernama fancy-cluster dengan 3 node:

gcloud container clusters create fancy-cluster --num-nodes 3 --machine-type=e2-standard-4 Peringatan: Jika Anda mendapatkan error tentang region/zona yang tidak ditentukan, lihat bagian penyiapan lingkungan untuk memastikan Anda telah menetapkan zona komputasi default.

Mungkin diperlukan waktu beberapa menit untuk membuat cluster.

3. Setelah perintahnya selesai, jalankan perintah berikut untuk melihat 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 {{{project_0.default_zone | (zone)}}} e2-standard-4 10.150.0.7 XX.XX.XX.XX RUNNING gke-fancy-cluster-default-pool-ad92506d-4fvq {{{project_0.default_zone | (zone)}}} e2-standard-4 10.150.0.5 XX.XX.XX.XX RUNNING gke-fancy-cluster-default-pool-ad92506d-4zs3 {{{project_0.default_zone | (zone)}}} e2-standard-4 10.150.0.6 XX.XX.XX.XX RUNNING

Anda juga dapat melihat cluster Kubernetes Anda dan informasi terkaitnya di Konsol Cloud. Dari Navigation menu, 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.

Klik Periksa progres saya untuk memverifikasi tujuan. Membuat cluster GKE

Tugas 3. Men-deploy monolit yang sudah ada

Karena fokus lab ini adalah memecah monolit menjadi microservice, Anda perlu menjalankan aplikasi monolit.

• Jalankan skrip berikut untuk men-deploy aplikasi monolitik ke cluster GKE Anda:

cd ~/monolith-to-microservices ./deploy-monolith.sh

Mengakses monolit

1. Untuk mencari alamat IP eksternal aplikasi monolitik Anda, jalankan perintah berikut:

kubectl get service monolith

Anda akan melihat output yang mirip dengan yang berikut:

NAME CLUSTER-IP EXTERNAL-IP PORT(S) AGE monolith 10.3.251.122 203.0.113.0 80:30877/TCP 3d

2. Jika output Anda mencantumkan IP eksternal sebagai <pending>, tunggu sebentar lalu jalankan kembali perintahnya.

3. 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.

Catatan: Ingat alamat IP ini karena Anda akan terus menggunakannya nanti. Anda selalu dapat mencarinya lagi dengan perintah yang sama di atas.

Anda akan melihat halaman sambutan untuk situs monolitik Anda. Halaman sambutan adalah halaman statis yang nantinya akan disajikan oleh microservice Frontend. Sekarang, monolit Anda berjalan sepenuhnya di Kubernetes.

Klik Periksa progres saya untuk memverifikasi tujuan. Men-deploy monolit yang sudah ada

Tugas 4. Memigrasikan Orders ke microservice

Setelah Anda memiliki situs monolitik yang berjalan di GKE, mulailah memecah masing-masing layanan menjadi microservice. Umumnya, harus dilakukan perencanaan untuk menentukan layanan yang akan dipecah menjadi bagian yang lebih kecil, biasanya layanan yang terkait dengan bagian aplikasi spesifik seperti domain bisnis.

Untuk lab ini, Anda akan membuat contoh dan memisahkan masing-masing layanan yang terkait dengan domain bisnis: Orders, Products, dan Frontend. Kodenya sudah dimigrasikan untuk Anda, jadi Anda dapat berfokus membangun dan mendeploy layanan di Google Kubernetes Engine (GKE).

Membuat microservice Orders

Layanan pertama yang akan dipisahkan adalah layanan Orders. Manfaatkan codebase terpisah yang disediakan dan buat container Docker terpisah untuk layanan ini.

Membuat container Docker dengan Cloud Build

Karena codebase-nya sudah tersedia, langkah pertama Anda adalah membuat container Docker untuk layanan Orders menggunakan Cloud Build.

Biasanya, hal ini dilakukan dalam proses dua langkah, yaitu membuat container Docker dan mengirimnya ke registry untuk menyimpan image yang akan ditarik oleh GKE. Cloud Build dapat digunakan untuk membangun container Docker dan menempatkan image di Artifact Registry dengan satu perintah.

Google Cloud Build akan mengompresi file dari direktori dan memindahkannya ke bucket Cloud Storage. Proses build kemudian akan mengambil semua file dari bucket dan menggunakan Dockerfile untuk menjalankan proses build Docker. Flag --tag ditentukan dengan host untuk image Docker menjadi gcr.io, sehingga image Docker yang dihasilkan akan dikirim ke Artifact Registry.

1. Jalankan perintah berikut untuk membangun container Docker Anda dan mengirimnya ke Artifact 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 saat, 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://_cloudbuild/source/1567043793.94-abfd382011724422bf49af1558b894aa.tgz gcr.io//orders:1.0.0 SUCCESS

2. Untuk melihat histori build Anda, atau mengamati prosesnya secara real time, telusuri Cloud Build di konsol, lalu klik hasil Cloud Build.

3. Di halaman History, Anda dapat melihat daftar semua build Anda. 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.

4. Dari halaman detail build, untuk melihat image container yang dibuat, klik tab Execution Details di bagian kanan dan lihat Image.

Men-deploy container ke GKE

Setelah Anda membuat menempatkan situs ke dalam container dan mengirimnya ke Artifact Registry, kini saatnya melakukan deployment 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, buat resource Deployment. Deployment mengelola beberapa salinan aplikasi Anda, yang disebut replika, dan menjadwalkannya untuk dijalankan di node terpisah dalam cluster Anda. Untuk skenario ini, Deployment hanya akan menjalankan satu pod aplikasi Anda. Deployment memastikan hal ini dengan membuat ReplicaSet. ReplicaSet bertanggung jawab untuk memastikan bahwa 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 Catatan: Sebagai praktik terbaik, penggunaan file YAML direkomendasikan untuk mendeklarasikan perubahan pada cluster Kubernetes (misalnya, membuat atau memodifikasi deployment atau layanan) dan sistem kontrol sumber seperti GitHub untuk menyimpan perubahan tersebut. Anda dapat mempelajari lebih lanjut hal ini dari Dokumentasi Deployment Kubernetes.

Memverifikasi deployment

• Untuk memverifikasi bahwa Deployment berhasil dibuat, jalankan perintah berikut:

kubectl get all

Mungkin diperlukan waktu beberapa saat agar status pod menjadi Running.

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 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

Anda dapat melihat Deployment Anda yang aktif, yaitu replicaset dengan jumlah pod yang diinginkan sebanyak 1, dan pod yang sedang berjalan. Sepertinya semuanya berhasil dibuat.

Anda juga dapat melihat deployment Kubernetes di Konsol Cloud dari Navigation menu dengan membuka Kubernetes Engine > Workloads.

Mengekspos container GKE

Anda telah men-deploy aplikasi Anda 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 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.

Untuk tujuan lab ini, eksposur layanan telah disederhanakan. Biasanya, Anda akan menggunakan gateway API untuk mengamankan endpoint publik Anda.

Saat men-deploy layanan Orders, Anda mengeksposnya di port 8081 secara internal melalui deployment Kubernetes. Untuk mengekspos layanan ini secara eksternal, Anda perlu membuat layanan Kubernetes dengan jenis LoadBalancer untuk mengarahkan traffic dari port 80 secara eksternal ke port 8081 internal.

• 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.

• Untuk mengetahui IP eksternal yang disediakan GKE bagi aplikasi Anda, periksa 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 3s

Setelah Anda mengidentifikasi alamat IP eksternal untuk aplikasi Anda, salin alamat IP tersebut. Simpan alamatnya untuk langkah berikutnya saat Anda mengubah monolit agar mengarah ke layanan Orders yang baru.

Mengonfigurasi ulang monolit

Karena Anda telah menghapus layanan Orders dari monolit, Anda harus memodifikasi monolit agar mengarah ke microservice Orders eksternal yang baru.

Saat memecah monolit, Anda memindahkan potongan kode dari satu codebase ke beberapa microservice dan men-deploy-nya secara terpisah. Karena microservice berjalan di server yang berbeda, Anda tidak dapat lagi merujuk URL layanan Anda sebagai jalur absolut. Anda harus mengarahkannya ke alamat server microservice Orders. 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.

Anda perlu mengupdate file konfigurasi di monolit agar mengarah ke alamat IP microservice Orders yang baru.

1. Gunakan editor nano untuk mengganti URL lokal dengan alamat IP microservice Orders:

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

2. Alihkan 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

3. Tekan CTRL+O, tekan ENTER, lalu CTRL+X untuk menyimpan file di editor nano.

4. Uji microservice yang baru dengan membuka URL yang baru saja Anda tetapkan di file. Halaman web seharusnya menampilkan respons JSON dari microservice Orders Anda.

5. Selanjutnya, bangun ulang frontend monolit dan lakukan lagi proses build untuk membangun container bagi monolit dan melakukan deployment ulang ke cluster GKE:

npm run build:monolith

6. Buat container Docker dengan Cloud Build:

cd ~/monolith-to-microservices/monolith gcloud builds submit --tag gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:2.0.0 .

7. Deploy container ke GKE:

kubectl set image deployment/monolith monolith=gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:2.0.0

8. Verifikasi bahwa aplikasi sekarang mengakses microservice Orders dengan membuka aplikasi monolit di browser Anda dan membuka halaman Orders. Semua ID pesanan seharusnya memiliki akhiran -MICROSERVICE seperti yang ditunjukkan di bawah:

9. Klik Periksa progres saya untuk memverifikasi tujuan. Memigrasikan Orders ke microservice

Tugas 5. Memigrasikan Products ke microservice

Membuat microservice Products baru

Lanjutkan pemisahan layanan dengan memigrasikan layanan Products. Ikuti proses yang sama seperti sebelumnya. Jalankan perintah berikut untuk membangun container Docker, men-deploy container Anda, dan mengeksposnya melalui layanan Kubernetes.

1. Buat container Docker dengan Cloud Build:

cd ~/monolith-to-microservices/microservices/src/products gcloud builds submit --tag gcr.io/${GOOGLE_CLOUD_PROJECT}/products:1.0.0 .

2. Deploy container ke GKE:

kubectl create deployment products --image=gcr.io/${GOOGLE_CLOUD_PROJECT}/products:1.0.0

3. Ekspos container GKE:

kubectl expose deployment products --type=LoadBalancer --port 80 --target-port 8082

4. LIhat IP publik layanan Products dengan cara yang sama seperti yang Anda lakukan untuk layanan Orders:

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

Anda akan menggunakan alamat IP ini di langkah berikutnya saat mengonfigurasi ulang monolit agar mengarah ke microservice Products baru Anda.

Mengonfigurasi ulang monolit

1. Gunakan editor nano untuk mengganti URL lokal dengan alamat IP dari microservice Products yang baru:

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

2. Alihkan REACT_APP_PRODUCTS_URL ke format baru sambil menggantinya dengan alamat IP microservice Products 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

3. Tekan CTRL+O, tekan ENTER, lalu CTRL+X untuk menyimpan file.

4. Uji microservice yang baru dengan membuka URL yang baru saja Anda tetapkan di file. Halaman web seharusnya menampilkan respons JSON dari microservice Products.

5. Selanjutnya, bangun ulang frontend monolit dan lakukan lagi proses build untuk membangun container bagi monolit dan melakukan deployment ulang ke cluster GKE. Jalankan perintah berikut untuk menyelesaikan langkah-langkah ini:

6. Bangun ulang file konfigurasi monolit:

npm run build:monolith

7. Buat container Docker dengan Cloud Build:

cd ~/monolith-to-microservices/monolith gcloud builds submit --tag gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:3.0.0 .

8. Deploy container ke GKE:

kubectl set image deployment/monolith monolith=gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:3.0.0

9. Verifikasi 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:

10. Klik Periksa progres saya untuk memverifikasi tujuan. Memigrasikan Products ke microservice

Tugas 6. Memigrasikan Frontend ke microservice

Langkah terakhir dalam proses migrasi adalah memindahkan kode Frontend ke microservice dan mematikan monolit. Setelah langkah ini selesai, berarti Anda 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, Anda mengubah konfigurasinya agar mengarah ke monolit. Sekarang, Anda perlu menggunakan konfigurasi yang sama untuk microservice Frontend.

1. 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

2. Setelah selesai, ikuti proses yang sama seperti langkah sebelumnya. Jalankan perintah berikut untuk membangun container Docker, men-deploy container Anda, dan mengeksposnya melalui layanan Kubernetes.

3. Buat 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 .

4. Deploy container ke GKE:

kubectl create deployment frontend --image=gcr.io/${GOOGLE_CLOUD_PROJECT}/frontend:1.0.0

5. Ekspos container GKE:

kubectl expose deployment frontend --type=LoadBalancer --port 80 --target-port 8080

6. Klik Periksa progres saya untuk memverifikasi tujuan. Memigrasikan Frontend ke microservice

Menghapus monolit

Setelah semua layanan berjalan sebagai microservice, hapus aplikasi monolitiknya. Dalam migrasi sebenarnya, langkah ini juga akan melibatkan perubahan DNS, dll., agar nama domain yang ada mengarah ke microservice Frontend yang baru untuk aplikasi.

• Jalankan perintah berikut untuk menghapus monolit:

kubectl delete deployment monolith kubectl delete service monolith

Menguji hasil pekerjaan 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, jalankan 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 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 Anda memecah monolit menjadi microservice.

Selamat!

Anda telah berhasil memecah aplikasi monolitik menjadi microservice dan men-deploy-nya di Google Kubernetes Engine.

Langkah berikutnya / Referensi tambahan

• Dokumentasi Docker
• Dokumentasi Kubernetes
• Dokumentasi Google Kubernetes Engine (GKE)
• Dokumentasi Google Cloud Build
• Memigrasikan Monolit ke Microservice
• Praktik Terbaik Microservice
• Tonton video tentang Menghosting Aplikasi Web Statis di Google Cloud

Sertifikasi dan pelatihan Google Cloud

...membantu Anda mengoptimalkan teknologi Google Cloud. Kelas kami mencakup keterampilan teknis dan praktik terbaik untuk membantu Anda memahami dengan cepat dan melanjutkan proses pembelajaran. Kami menawarkan pelatihan tingkat dasar hingga lanjutan dengan opsi on demand, live, dan virtual untuk menyesuaikan dengan jadwal Anda yang sibuk. Sertifikasi membantu Anda memvalidasi dan membuktikan keterampilan serta keahlian Anda dalam teknologi Google Cloud.

Manual Terakhir Diperbarui pada 26 April 2024

Lab Terakhir Diuji pada 20 September 2023

Hak cipta 2026 Google LLC. Semua hak dilindungi undang-undang. Google dan logo Google adalah merek dagang dari Google LLC. Semua nama perusahaan dan produk lain mungkin adalah merek dagang masing-masing perusahaan yang bersangkutan.