Menghosting dan menskalakan aplikasi web di Google Cloud dengan Compute Engine

1. Pengantar

Ada banyak cara untuk men-deploy situs di Google Cloud, dan masing-masing solusi menawarkan fitur, kemampuan, dan tingkat kontrol yang berbeda. Compute Engine menawarkan tingkat kontrol mendalam atas infrastruktur yang digunakan untuk menjalankan situs web, tetapi juga memerlukan pengelolaan operasional yang lebih sedikit dibandingkan solusi seperti Google Kubernetes Engine, App Engine, dan lainnya. Dengan Compute Engine, Anda memiliki kontrol terperinci atas berbagai aspek infrastruktur, termasuk virtual machine, load balancer, dan banyak lagi. Hari ini, Anda akan men-deploy aplikasi contoh, yaitu situs e-commerce Fancy Store, untuk menunjukkan bagaimana situs dapat di-deploy dan diskalakan dengan mudah menggunakan Compute Engine.

Yang akan Anda pelajari

• Cara membuat instance Compute Engine
• Cara membuat template instance dari instance sumber
• Cara membuat grup instance terkelola
• Cara menyiapkan health check dan autohealing
• Cara membuat Load Balancing HTTP(S)
• Cara membuat health check untuk load balancer
• Cara menggunakan jaringan penayangan konten untuk penyimpanan cache

Di akhir codelab, Anda akan memiliki instance di dalam grup instance terkelola untuk menyediakan autohealing, load balancing, penskalaan otomatis, dan update berkelanjutan untuk situs Anda.

Prasyarat

• Untuk ringkasan pengantar konsep yang akan kita gunakan di lab ini, silakan lihat materi di bawah ini:
• Selamat datang di Google Cloud Platform - Hal-hal Penting dalam GCP
• Mulai Menggunakan Google Cloud Compute Engine
• Mulai Menggunakan Google Cloud Storage
• Memulai: Cloud Shell

2. Penyiapan lingkungan

Penyiapan lingkungan mandiri

1. Login ke Cloud Console lalu buat project baru atau gunakan kembali project yang sudah ada. Jika belum memiliki akun Gmail atau Google Workspace, Anda harus membuatnya.

Catatan: Anda dapat mengakses Cloud Console dengan mudah dengan mengingat URL-nya, yaitu console.cloud.google.com.

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.

Catatan: Jika menggunakan akun Gmail, Anda dapat menyetel lokasi default ke Tidak ada organisasi. Jika Anda menggunakan akun Google Workspace, pilih lokasi yang sesuai untuk organisasi Anda.

2. Selanjutnya, Anda harus mengaktifkan penagihan di Cloud Console untuk menggunakan resource Google Cloud.

Menjalankan operasi dalam codelab ini seharusnya tidak memerlukan banyak biaya, bahkan mungkin tidak sama sekali. Pastikan untuk mengikuti petunjuk yang ada di bagian "Membersihkan" yang memberi tahu Anda cara menonaktifkan resource sehingga tidak menimbulkan penagihan di luar tutorial ini. Pengguna baru Google Cloud memenuhi syarat untuk mengikuti program Uji Coba Gratis senilai$300 USD.

Catatan: Penting untuk membuat project baru dan tidak menggunakan kembali project yang sudah ada, karena Anda akan menghapus project tersebut untuk membersihkan semua aktivitas yang dilakukan dalam codelab.

Mengaktifkan Compute Engine API

Selanjutnya, Anda harus mengaktifkan Compute Engine API. Mengaktifkan API mengharuskan Anda menyetujui persyaratan layanan dan tanggung jawab penagihan untuk API tersebut.

Di Cloud Shell, jalankan perintah berikut untuk mengaktifkan Compute Engine API:

gcloud services enable compute.googleapis.com

Cloud Shell

Meskipun Google Cloud dapat dioperasikan secara jarak jauh dari laptop Anda, dalam codelab ini Anda akan menggunakan 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).

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

Catatan: Alat command-line gcloud sudah terinstal di Cloud Shell dan Anda pasti akan menikmati dukungannya untuk penyelesaian tab. Untuk informasi selengkapnya, lihat ringkasan alat command line gcloud.

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>

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

Catatan: Saat menjalankan gcloud di komputer Anda sendiri, setelan konfigurasi akan tetap ada di seluruh sesi. Namun di Cloud Shell, Anda perlu menyetelnya untuk setiap sesi atau sambungan ulang baru.

Membuat bucket Cloud Storage

Kita akan menggunakan bucket Cloud Storage untuk menampung kode yang telah dibangun, serta skrip startup. Di Cloud Shell, jalankan perintah berikut untuk membuat bucket Cloud Storage baru:

gsutil mb gs://fancy-store-$DEVSHELL_PROJECT_ID

Catatan: Anda akan menggunakan variabel lingkungan $DEVSHELL_PROJECT_ID di Cloud Shell untuk memastikan bahwa nama objek bersifat unik. Mengingat bahwa semua ID project Google Cloud harus unik, menambahkan ID tersebut juga harus membuat nama lain menjadi unik.

3. Membuat clone repositori sumber

Anda akan menggunakan situs e-commerce Fancy Store yang sudah ada berdasarkan repositori monolit-to-microservice sebagai dasar untuk situs Anda. Anda akan meng-clone kode sumber dari repositori agar Anda dapat berfokus pada aspek deployment ke Compute Engine. Kemudian, Anda akan melakukan update kecil pada kode untuk menunjukkan kemudahan update di Compute Engine.

Anda dapat otomatis membuat clone repositori kode ke dalam project, serta membuka Cloud Shell dan editor kode bawaan, melalui link berikut: Open in Cloud Shell.

Atau, Anda dapat membuat clone repositori secara manual dengan perintah di bawah ini di dalam Cloud Shell:

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

Pada command prompt Cloud Shell, jalankan build awal kode agar aplikasi dapat berjalan secara lokal. Mungkin perlu waktu beberapa menit untuk menjalankan skrip.

./setup.sh

Lakukan uji tuntas dan uji aplikasi Anda. Jalankan perintah berikut untuk memulai server web Anda:

cd microservices
npm start

Output:

Products microservice listening on port 8082!
Frontend microservice listening on port 8080!
Orders microservice listening on port 8081!

Lihat pratinjau aplikasi Anda dengan mengklik ikon pratinjau web dan memilih "Preview on port 8080".

Tindakan itu akan membuka jendela baru tempat Anda dapat melihat frontend Fancy Store yang sedang beraksi!

Anda dapat menutup jendela ini setelah melihat situs. Untuk menghentikan proses server web, tekan Control+C (Command+C pada Macintosh) di jendela terminal.

Catatan: Dalam opsi pratinjau, Anda dapat melihat frontend. Namun, fungsi produk dan pesanan tidak berfungsi, karena layanan tersebut belum diekspos dalam metode ini.

4. Membuat instance Compute Engine

Setelah memiliki lingkungan developer kerja, Anda dapat men-deploy beberapa instance Compute Engine. Pada langkah-langkah berikut, Anda akan:

1. Membuat skrip startup untuk mengonfigurasi instance.
2. Buat clone kode sumber dan upload ke Cloud Storage.
3. Men-deploy instance Compute Engine untuk menghosting microservice backend.
4. Mengonfigurasi ulang kode frontend untuk memanfaatkan instance microservice backend.
5. Men-deploy instance Compute Engine untuk menghosting microservice frontend.
6. Mengonfigurasi jaringan untuk memungkinkan komunikasi.

Membuat skrip startup

Skrip startup akan memberikan instruksi ke instance tentang hal yang harus dilakukan setiap kali instance dimulai. Dengan cara ini, instance akan dikonfigurasi secara otomatis.

Klik ikon pensil di pita Cloud Shell untuk membuka editor kode.

Buka folder monolith-to-microservices. Klik File > File Baru dan buat file bernama startup-script.sh.

Pada file baru, tempel kode berikut, yang beberapa di antaranya akan Anda edit setelah menempelkannya:

#!/bin/bash

# Install logging monitor. The monitor will automatically pick up logs sent to
# syslog.
curl -s "https://storage.googleapis.com/signals-agents/logging/google-fluentd-install.sh" | bash
service google-fluentd restart &

# Install dependencies from apt
apt-get update
apt-get install -yq ca-certificates git build-essential supervisor psmisc

# Install nodejs
mkdir /opt/nodejs
curl https://nodejs.org/dist/v8.12.0/node-v8.12.0-linux-x64.tar.gz | tar xvzf - -C /opt/nodejs --strip-components=1
ln -s /opt/nodejs/bin/node /usr/bin/node
ln -s /opt/nodejs/bin/npm /usr/bin/npm

# Get the application source code from the Google Cloud Storage bucket.
mkdir /fancy-store
gsutil -m cp -r gs://fancy-store-[DEVSHELL_PROJECT_ID]/monolith-to-microservices/microservices/* /fancy-store/

# Install app dependencies.
cd /fancy-store/
npm install

# Create a nodeapp user. The application will run as this user.
useradd -m -d /home/nodeapp nodeapp
chown -R nodeapp:nodeapp /opt/app

# Configure supervisor to run the node app.
cat >/etc/supervisor/conf.d/node-app.conf << EOF
[program:nodeapp]
directory=/fancy-store
command=npm start
autostart=true
autorestart=true
user=nodeapp
environment=HOME="/home/nodeapp",USER="nodeapp",NODE_ENV="production"
stdout_logfile=syslog
stderr_logfile=syslog
EOF

supervisorctl reread
supervisorctl update

Sekarang, di editor kode, temukan teks [DEVSHELL_PROJECT_ID] dan ganti dengan output dari perintah berikut:

echo $DEVSHELL_PROJECT_ID

Contoh output:

my-gce-codelab-253520

Baris kode dalam startup-script.sh sekarang akan terlihat seperti berikut:

gs://fancy-store-my-gce-codelab-253520/monolith-to-microservices/microservices/* /fancy-store/

Catatan: Jika Anda menggunakan editor kode di Cloud Shell, pastikan "Akhir Urutan Baris" diatur ke "LF," bukan "CRLF." Anda dapat memeriksanya dengan melihat bagian kanan bawah editor kode:

Jika diatur ke CRLF, klik CRLF lalu pilih "LF" pada menu {i>drop down<i}.

Skrip startup akan melakukan tugas-tugas berikut:

• Penginstalan agen Logging, yang secara otomatis mengumpulkan log dari syslog
• Penginstalan Node.js dan Supervisor, yang menjalankan aplikasi sebagai daemon
• Cloning kode sumber aplikasi dari bucket Cloud Storage dan penginstalan dependensi
• Konfigurasi Supervisor, yang menjalankan aplikasi, memastikan bahwa aplikasi dimulai ulang jika tiba-tiba keluar atau dihentikan oleh admin atau proses, dan mengirimkan stdout dan stderr aplikasi ke syslog untuk dikumpulkan oleh agen Logging

Selanjutnya, salin file startup-script.sh yang telah dibuat ke bucket Cloud Storage yang telah dibuat sebelumnya:

gsutil cp ~/monolith-to-microservices/startup-script.sh gs://fancy-store-$DEVSHELL_PROJECT_ID

Library tersebut kini dapat diakses di https://storage.googleapis.com/[BUCKET_NAME]/startup-script.sh. [BUCKET_NAME] mewakili nama bucket Cloud Storage. Tampilan ini hanya dapat dilihat oleh pengguna yang diberi otorisasi dan akun layanan secara default, sehingga tidak dapat diakses melalui browser web. Instance Compute Engine secara otomatis dapat mengaksesnya melalui akun layanannya.

Salin kode ke dalam bucket Cloud Storage

Saat diluncurkan, instance akan mengambil kode dari bucket Cloud Storage sehingga Anda dapat menyimpan beberapa variabel konfigurasi di file ‘.env' {i>file<i} kode.

Catatan: Anda juga dapat mengodekannya untuk mengambil variabel lingkungan dari tempat lain, tetapi untuk tujuan demonstrasi, ini adalah metode sederhana untuk menangani konfigurasi. Dalam produksi, variabel lingkungan kemungkinan besar akan disimpan di luar kode.

Salin kode yang di-clone ke dalam bucket Cloud Storage:

cd ~
rm -rf monolith-to-microservices/*/node_modules
gsutil -m cp -r monolith-to-microservices gs://fancy-store-$DEVSHELL_PROJECT_ID/

Catatan: Hapus ‘node_modules' dependensi untuk memastikan bahwa kode itu secepat dan seefisien mungkin. Instance dibuat ulang pada instance saat dimulai.

Men-deploy instance backend

Instance pertama yang akan Anda deploy akan menjadi backend instance, yang akan menampung pesanan dan produk microservice.

Catatan: Dalam lingkungan produksi, sebaiknya pisahkan setiap microservice ke dalam instance dan grup instance-nya sendiri agar dapat diskalakan secara independen. Untuk tujuan demonstrasi, kedua microservice backend (pesanan dan produk) akan berada dalam instance dan grup instance yang sama.

Jalankan perintah berikut di Cloud Shell untuk membuat instance f1-micro yang dikonfigurasi agar dapat menggunakan skrip startup yang telah dibuat sebelumnya dan diberi tag sebagai backend instance, sehingga Anda dapat menerapkan aturan firewall tertentu ke dalamnya nanti:

gcloud compute instances create backend \
    --machine-type=f1-micro \
    --image=debian-9-stretch-v20190905 \
    --image-project=debian-cloud \
    --tags=backend \
    --metadata=startup-script-url=https://storage.googleapis.com/fancy-store-$DEVSHELL_PROJECT_ID/startup-script.sh

Catatan: Jika Compute Engine API tidak diaktifkan pada langkah sebelumnya, alat command line gcloud akan menanyakan, "Apakah Anda ingin mengaktifkan dan mencoba lagi (proses ini memerlukan waktu beberapa menit)?" Pilih 'y' untuk mengaktifkan Compute Engine API.

Catatan: Jika Anda diminta untuk menentukan zona, pastikan zona default telah dikonfigurasi sebelumnya di bagian penyiapan lingkungan.

Mengonfigurasi koneksi ke backend

Sebelum men-deploy frontend aplikasi, Anda harus memperbarui konfigurasi agar mengarah ke backend yang telah di-deploy.

Ambil alamat IP eksternal backend, yang dapat dilihat dari perintah berikut di bawah tab EXTERNAL_IP untuk backend instance:

gcloud compute instances list

Contoh output:

NAME     ZONE           MACHINE_TYPE  PREEMPTIBLE  INTERNAL_IP  EXTERNAL_IP   STATUS
backend  us-central1-a  f1-micro                   10.128.0.2   34.68.223.88  RUNNING

Di editor kode Cloud Shell, buka folder monolith-to-microservices > react-app. Dari menu Code Editor, pilih View > Aktifkan/nonaktifkan File Tersembunyi untuk melihat file .env.

Edit file .env agar mengarah ke alamat IP eksternal backend. [BACKEND_ADDRESS] di bawah mewakili alamat IP eksternal dari backend instance yang ditentukan dari perintah sebelumnya di alat gcloud.

REACT_APP_ORDERS_URL=http://[BACKEND_ADDRESS]:8081/api/orders
REACT_APP_PRODUCTS_URL=http://[BACKEND_ADDRESS]:8082/api/products

Simpan file.

Gunakan perintah berikut untuk membangun ulang React-app, yang akan mengupdate kode frontend:

cd ~/monolith-to-microservices/react-app
npm install && npm run-script build

Salin kode aplikasi ke dalam bucket Cloud Storage:

cd ~
rm -rf monolith-to-microservices/*/node_modules
gsutil -m cp -r monolith-to-microservices gs://fancy-store-$DEVSHELL_PROJECT_ID/

Men-deploy frontend instance

Setelah kode dikonfigurasi, Anda dapat men-deploy frontend instance. Jalankan perintah berikut untuk men-deploy frontend instance dengan perintah yang sama seperti sebelumnya, tetapi instance ini diberi tag sebagai "frontend" untuk tujuan {i>firewall<i}.

gcloud compute instances create frontend \
    --machine-type=f1-micro \
    --image=debian-9-stretch-v20190905 \
    --image-project=debian-cloud \
    --tags=frontend \
    --metadata=startup-script-url=https://storage.googleapis.com/fancy-store-$DEVSHELL_PROJECT_ID/startup-script.sh 

Catatan: Anda menggunakan perintah deployment dan skrip startup yang serupa untuk instance frontend dan backend. Hal itu demi kemudahan dan karena kode dikonfigurasi untuk meluncurkan semua microservice secara default. Akibatnya, semua microservice berjalan di frontend dan backend dalam sampel. Namun, dalam lingkungan produksi, Anda hanya akan menjalankan microservice yang diperlukan di setiap komponen.

Konfigurasi jaringan

Buat aturan firewall guna mengizinkan akses ke port 8080 untuk frontend, serta port 8081 dan 8082 untuk backend. Perintah firewall menggunakan tag yang ditetapkan selama pembuatan instance untuk aplikasi.

gcloud compute firewall-rules create fw-fe \
    --allow tcp:8080 \
    --target-tags=frontend

gcloud compute firewall-rules create fw-be \
    --allow tcp:8081-8082 \
    --target-tags=backend

Kini, situs telah berfungsi. Tentukan alamat IP eksternal frontend. Alamat dapat ditentukan dengan mencari EXTERNAL_IP dari frontend instance:

gcloud compute instances list

Contoh output:

NAME      ZONE           MACHINE_TYPE  PREEMPTIBLE  INTERNAL_IP  EXTERNAL_IP      STATUS
backend   us-central1-a  f1-micro                   10.128.0.2   104.198.235.171  RUNNING
frontend  us-central1-a  f1-micro                   10.128.0.3   34.69.141.9      RUNNING

Mungkin perlu waktu beberapa menit untuk memulai dan mengonfigurasi instance. Jalankan hal berikut untuk memantau kesiapan aplikasi:

watch -n 5 curl http://[EXTERNAL_IP]:8080 

Setelah Anda melihat output yang mirip dengan berikut ini, berarti situs sudah siap. Tekan Control+C (Command+C di Macintosh) pada command prompt untuk membatalkan perintah smartwatch.

Jelajahi http://[FRONTEND_ADDRESS]:8080 dengan tab browser web baru untuk mengakses situs, dengan [FRONTEND_ADDRESS] adalah EXTERNAL_IP yang ditentukan di atas.

Coba buka halaman Produk dan Pesanan, yang juga akan berfungsi.

Catatan: Jika Anda berhenti di tahap ini dan memilih untuk tidak menskalakan lingkungan, instance harus dikonfigurasi untuk menggunakan alamat IP statis. Anda harus terus membuat grup instance terkelola dan load balancer meskipun skala tinggi tidak diperlukan sehingga redundansi dan autohealing dapat diterapkan.

5. Membuat grup instance terkelola

Agar aplikasi Anda dapat diskalakan, grup instance terkelola akan dibuat dan akan menggunakan instance frontend dan backend sebagai template instance.

Grup instance terkelola berisi instance identik yang dapat Anda kelola sebagai entitas tunggal dalam satu zona. Grup instance terkelola menjaga ketersediaan tinggi aplikasi Anda dengan secara proaktif memastikan instance Anda terus tersedia, yaitu dalam status RUNNING. Anda akan menggunakan grup instance terkelola untuk instance frontend dan backend guna menyediakan autohealing, load balancing, penskalaan otomatis, dan update berkelanjutan.

Membuat template instance dari instance sumber

Sebelum dapat membuat grup instance terkelola, Anda perlu membuat template instance yang akan menjadi dasar untuk grup. Template instance memungkinkan Anda menentukan jenis mesin, boot disk image atau image container, jaringan, dan properti instance lain yang akan digunakan saat membuat instance virtual machine (VM) baru. Anda dapat menggunakan template instance untuk membuat instance dalam grup instance terkelola atau bahkan membuat instance secara individual.

Untuk membuat template instance, gunakan instance yang sudah ada yang Anda buat.

Pertama, Anda harus menghentikan kedua instance.

gcloud compute instances stop frontend

gcloud compute instances stop backend

Sekarang, buat template instance dari instance sumber.

gcloud compute instance-templates create fancy-fe \
    --source-instance=frontend

gcloud compute instance-templates create fancy-be \
    --source-instance=backend

Pastikan template instance telah dibuat:

gcloud compute instance-templates list

Contoh output:

NAME      MACHINE_TYPE  PREEMPTIBLE  CREATION_TIMESTAMP
fancy-be  f1-micro                   2019-09-12T07:52:57.544-07:00
fancy-fe  f1-micro                   2019-09-12T07:52:48.238-07:00

Membuat grup instance terkelola

Anda akan membuat dua grup instance terkelola, satu untuk frontend dan satu lagi untuk backend. Grup instance terkelola tersebut akan menggunakan template instance yang dibuat sebelumnya dan dikonfigurasi untuk memulai dua instance di setiap grup. Instance akan otomatis diberi nama berdasarkan "base-instance-name" yang ditentukan dengan menambahkan karakter acak.

gcloud compute instance-groups managed create fancy-fe-mig \
    --base-instance-name fancy-fe \
    --size 2 \
    --template fancy-fe

gcloud compute instance-groups managed create fancy-be-mig \
    --base-instance-name fancy-be \
    --size 2 \
    --template fancy-be

Untuk aplikasi Anda, microservice frontend berjalan di port 8080, sedangkan microservice backend berjalan di port 8081 untuk pesanan dan port 8082 untuk produk. Mengingat ini adalah porta non-standar, Anda perlu menentukan porta bernama untuk mengidentifikasinya. Port bernama adalah metadata pasangan nilai kunci yang mewakili nama layanan dan port yang menjalankannya. Port bernama dapat ditetapkan ke grup instance, yang menunjukkan bahwa layanan tersedia di semua instance dalam grup. Informasi tersebut digunakan oleh load balancer, yang akan Anda konfigurasi nanti.

gcloud compute instance-groups set-named-ports fancy-fe-mig \ 
    --named-ports frontend:8080

gcloud compute instance-groups set-named-ports fancy-be-mig \
    --named-ports orders:8081,products:8082

Mengonfigurasi autohealing

Untuk meningkatkan ketersediaan aplikasi dan memastikan bahwa aplikasi merespons, Anda dapat mengonfigurasi kebijakan autohealing untuk grup instance terkelola.

Kebijakan pemulihan otomatis bergantung pada health check berbasis aplikasi untuk memverifikasi bahwa aplikasi merespons seperti yang diharapkan. Memeriksa apakah aplikasi merespons lebih tepat daripada hanya memverifikasi bahwa instance berada dalam status RUNNING, yang merupakan perilaku default.

Catatan: Anda akan menggunakan health check terpisah untuk load balancer dan autohealing. Health check untuk load balancer bisa dan harus lebih agresif karena health check tersebut menentukan apakah sebuah instance menerima traffic pengguna atau tidak. Anda ingin dengan cepat menangkap instance yang tidak responsif, sehingga Anda dapat mengalihkan traffic, jika perlu. Sebaliknya, health check untuk autohealing menyebabkan Compute Engine mengganti instance yang gagal secara proaktif, sehingga health check harus lebih konservatif daripada health check untuk load balancer.

Buat health check yang memperbaiki instance tersebut jika ditampilkan sebagai tidak responsif tiga kali berturut-turut untuk frontend dan backend:

gcloud compute health-checks create http fancy-fe-hc \
    --port 8080 \
    --check-interval 30s \
    --healthy-threshold 1 \
    --timeout 10s \
    --unhealthy-threshold 3

gcloud compute health-checks create http fancy-be-hc \
    --port 8081 \
    --request-path=/api/orders \
    --check-interval 30s \
    --healthy-threshold 1 \
    --timeout 10s \
    --unhealthy-threshold 3

Buat aturan firewall untuk mengizinkan pemeriksaan health check terhubung ke microservice di port 8080 dan 8081:

gcloud compute firewall-rules create allow-health-check \
    --allow tcp:8080-8081 \
    --source-ranges 130.211.0.0/22,35.191.0.0/16 \
    --network default

Terapkan health check pada layanan masing-masing:

gcloud compute instance-groups managed update fancy-fe-mig \
    --health-check fancy-fe-hc \
    --initial-delay 300

gcloud compute instance-groups managed update fancy-be-mig \
    --health-check fancy-be-hc \
    --initial-delay 300

Catatan: Diperlukan waktu 15 menit sebelum pemulihan otomatis memulai instance pemantauan dalam grup.

Lanjutkan codelab untuk memberikan waktu bagi autohealing guna memantau instance dalam grup. Nantinya, Anda akan menyimulasikan kegagalan untuk menguji autohealing.

6. Buat load balancer

Untuk melengkapi grup instance terkelola kami, Anda akan menggunakan Load Balancing HTTP(S) untuk menyalurkan traffic ke microservice frontend dan backend, serta menggunakan pemetaan untuk mengirimkan traffic ke layanan backend yang tepat berdasarkan aturan jalur. Cara ini akan mengekspos satu alamat IP yang di-load balanced untuk semua layanan.

Untuk informasi selengkapnya tentang opsi load balancing yang tersedia di Google Cloud, lihat Ringkasan Load Balancing.

Membuat Load Balancing HTTP(S)

Google Cloud menawarkan berbagai jenis load balancing, tetapi Anda akan menggunakan Load Balancing HTTP(S) untuk traffic Anda. Load Balancing HTTP(S) disusun sebagai berikut:

1. Aturan penerusan mengarahkan permintaan masuk ke proxy HTTP target.
2. Proxy HTTP target memeriksa tiap permintaan di peta URL guna menentukan layanan backend yang sesuai untuk permintaan.
3. Layanan backend mengarahkan tiap permintaan ke backend yang sesuai berdasarkan kapasitas penyajian, zona, dan responsivitas instance dari backend yang terkait. Respons tiap backend instance diverifikasi menggunakan health check HTTP. Jika layanan backend dikonfigurasi untuk menggunakan health check HTTPS atau HTTP/2, permintaan akan dienkripsi dalam perjalanan ke backend instance.
4. Sesi antara load balancer dan instance dapat menggunakan protokol HTTP, HTTPS, atau HTTP/2. Jika Anda menggunakan HTTPS atau HTTP/2, setiap instance dalam layanan backend harus memiliki sertifikat SSL.

Catatan: Untuk menghindari kompleksitas sertifikat SSL, Anda akan menggunakan HTTP, bukan HTTPS. Untuk produksi, disarankan menggunakan HTTPS untuk enkripsi jika memungkinkan.

Membuat health check yang akan digunakan untuk menentukan instance mana yang dapat menyalurkan traffic untuk setiap layanan.

gcloud compute http-health-checks create fancy-fe-frontend-hc \
  --request-path / \
  --port 8080

gcloud compute http-health-checks create fancy-be-orders-hc \
  --request-path /api/orders \
  --port 8081

gcloud compute http-health-checks create fancy-be-products-hc \
  --request-path /api/products \
  --port 8082

Catatan: Health check ditujukan untuk load balancer dan hanya menangani pengarahan traffic dari load balancer. Perintah ini tidak menyebabkan grup instance terkelola membuat ulang instance.

Buat layanan backend yang menjadi target untuk traffic yang di-load balance. Layanan backend akan menggunakan health check dan port bernama yang Anda buat.

gcloud compute backend-services create fancy-fe-frontend \
  --http-health-checks fancy-fe-frontend-hc \
  --port-name frontend \
  --global

gcloud compute backend-services create fancy-be-orders \
  --http-health-checks fancy-be-orders-hc \
  --port-name orders \
  --global

gcloud compute backend-services create fancy-be-products \
  --http-health-checks fancy-be-products-hc \
  --port-name products \
  --global

Tambahkan layanan backend.

gcloud compute backend-services add-backend fancy-fe-frontend \
  --instance-group fancy-fe-mig \
  --instance-group-zone us-central1-f \
  --global

gcloud compute backend-services add-backend fancy-be-orders \
  --instance-group fancy-be-mig \
  --instance-group-zone us-central1-f \
  --global

gcloud compute backend-services add-backend fancy-be-products \
  --instance-group fancy-be-mig \
  --instance-group-zone us-central1-f \
  --global

Buat peta URL. Peta URL menentukan URL yang akan diarahkan ke layanan backend.

gcloud compute url-maps create fancy-map \
  --default-service fancy-fe-frontend

Buat pencocok jalur agar jalur /api/orders dan /api/products dapat dirutekan ke layanannya masing-masing.

gcloud compute url-maps add-path-matcher fancy-map \
   --default-service fancy-fe-frontend \
   --path-matcher-name orders \
   --path-rules "/api/orders=fancy-be-orders,/api/products=fancy-be-products"

Buat proxy yang terkait dengan peta URL yang dibuat.

gcloud compute target-http-proxies create fancy-proxy \
  --url-map fancy-map

Buat aturan penerusan global yang mengaitkan alamat IP publik dan port ke proxy.

gcloud compute forwarding-rules create fancy-http-rule \
  --global \
  --target-http-proxy fancy-proxy \
  --ports 80

Update konfigurasi

Setelah memiliki alamat IP statis baru, Anda harus mengupdate kode di frontend agar mengarah ke alamat baru, bukan alamat sementara yang digunakan sebelumnya yang mengarah ke instance backend.

Di Cloud Shell, ubah ke folder React-app, yang menampung file .env yang menyimpan konfigurasi.

cd ~/monolith-to-microservices/react-app/

Temukan alamat IP untuk load balancer:

gcloud compute forwarding-rules list --global

Contoh output:

NAME                    REGION  IP_ADDRESS     IP_PROTOCOL  TARGET
fancy-http-rule          34.102.237.51  TCP          fancy-proxy

Edit file .env dengan editor teks pilihan Anda (seperti GNU nano) agar mengarah ke alamat IP publik load balancer. [LB_IP] mewakili alamat IP eksternal dari backend instance.

REACT_APP_ORDERS_URL=http://[LB_IP]/api/orders
REACT_APP_PRODUCTS_URL=http://[LB_IP]/api/products

Catatan: Port akan dihapus di alamat baru karena load balancer dikonfigurasi guna menangani penerusan untuk Anda.

Build ulang React-app, yang akan mengupdate kode frontend.

cd ~/monolith-to-microservices/react-app
npm install && npm run-script build

Salin kode aplikasi ke dalam bucket GCS.

cd ~
rm -rf monolith-to-microservices/*/node_modules
gsutil -m cp -r monolith-to-microservices gs://fancy-store-$DEVSHELL_PROJECT_ID/

Mengupdate frontend instance

Sekarang Anda ingin agar frontend instance dalam grup instance terkelola mengambil kode baru. Instance Anda menarik kode saat startup, sehingga Anda dapat mengeluarkan perintah mulai ulang berkelanjutan.

gcloud compute instance-groups managed rolling-action restart fancy-fe-mig \
    --max-unavailable 100%

Catatan: Dalam contoh mulai ulang berkelanjutan tersebut, Anda secara khusus menyatakan bahwa semua mesin dapat segera dimulai ulang melalui parameter –max-unavailable. Tanpa itu, perintah akan membuat instance tetap aktif saat memulai ulang instance lainnya. Untuk tujuan pengujian, tentukan untuk segera memulai ulang semua demi kecepatan.

Menguji situs

Tunggu sekitar 30 detik setelah mengeluarkan perintah rolling-action restart agar instance memiliki waktu untuk diproses. Kemudian, periksa status grup instance terkelola hingga instance muncul dalam daftar.

watch -n 5 gcloud compute instance-groups list-instances fancy-fe-mig

Setelah item muncul dalam daftar, keluar dari perintah watch dengan menekan Control+C (Command+C di Macintosh).

Pastikan layanan tercantum sebagai responsif.

watch -n 5 gcloud compute backend-services get-health fancy-fe-frontend --global

Contoh output:

---
backend: https://www.googleapis.com/compute/v1/projects/my-gce-codelab/zones/us-central1-a/instanceGroups/fancy-fe-mig
status:
  healthStatus:
  - healthState: HEALTHY
    instance: https://www.googleapis.com/compute/v1/projects/my-gce-codelab/zones/us-central1-a/instances/fancy-fe-x151
    ipAddress: 10.128.0.7
    port: 8080
  - healthState: HEALTHY
    instance: https://www.googleapis.com/compute/v1/projects/my-gce-codelab/zones/us-central1-a/instances/fancy-fe-cgrt
    ipAddress: 10.128.0.11
    port: 8080
  kind: compute#backendServiceGroupHealth

Setelah item muncul dalam daftar, keluar dari perintah watch dengan menekan Control+C (Command+C di Macintosh).

Aplikasi kemudian dapat diakses melalui http://[LB_IP], dengan [LB_IP] adalah IP_ADDRESS yang ditentukan untuk penyeimbang beban, yang dapat ditemukan dengan perintah berikut:

gcloud compute forwarding-rules list --global

7. Menskalakan Compute Engine

Sejauh ini, Anda sudah membuat dua grup instance terkelola, masing-masing dengan dua instance. Konfigurasi berfungsi sepenuhnya, tetapi konfigurasi statis terlepas dari bebannya. Sekarang, Anda akan membuat kebijakan penskalaan otomatis berdasarkan pemakaian untuk menskalakan setiap grup instance terkelola secara otomatis.

Mengubah ukuran secara otomatis berdasarkan penggunaan

Untuk membuat kebijakan penskalaan otomatis, jalankan perintah berikut di Cloud Shell. Mereka akan membuat autoscaler di grup instance terkelola yang secara otomatis menambahkan instance saat pemakaian load balancer lebih tinggi dari 60% dan menghapus instance saat pemakaian load balancer lebih rendah dari 60%.

gcloud compute instance-groups managed set-autoscaling \
  fancy-fe-mig \
  --max-num-replicas 5 \
  --target-load-balancing-utilization 0.60

gcloud compute instance-groups managed set-autoscaling \
  fancy-be-mig \
  --max-num-replicas 5 \
  --target-load-balancing-utilization 0.60

Aktifkan jaringan penayangan konten

Fitur lain yang dapat membantu penskalaan adalah mengaktifkan Cloud CDN, layanan jaringan penayangan konten, untuk menyediakan caching untuk layanan frontend. Untuk melakukannya, Anda dapat menjalankan perintah berikut di layanan frontend:

gcloud compute backend-services update fancy-fe-frontend \
    --enable-cdn --global

Sekarang, ketika pengguna meminta konten dari load balancer, permintaan tersebut akan masuk di frontend Google, yang pertama-tama mencari respons terhadap permintaan pengguna di cache Cloud CDN. Jika frontend menemukan respons yang di-cache, frontend akan mengirimkan respons yang di-cache kepada pengguna. Hal itu disebut cache ditemukan.

Atau, jika frontend tidak dapat menemukan respons yang di-cache untuk permintaan, frontend akan membuat permintaan langsung ke backend. Jika respons terhadap permintaan tersebut dapat di-cache, frontend akan menyimpan respons tersebut di cache Cloud CDN sehingga cache dapat digunakan untuk permintaan berikutnya.

8. Perbarui situs

Mengupdate template instance

Template instance yang sudah ada tidak dapat diedit. Namun, mengingat instance Anda bersifat stateless dan semua konfigurasi dilakukan melalui skrip startup, Anda hanya perlu mengubah template instance jika ingin mengubah image inti setelan template itu sendiri. Sekarang, Anda akan membuat perubahan sederhana dengan menggunakan jenis mesin yang lebih besar dan menerapkannya.

Update frontend instance, yang bertindak sebagai dasar untuk template instance. Selama update, Anda akan menempatkan file di gambar template instance versi terbaru, lalu mengupdate template instance, meluncurkan template baru, dan mengonfirmasi bahwa file tersebut ada di instance grup instance terkelola.

Anda akan memodifikasi jenis mesin template instance dengan beralih dari jenis mesin standar f1-micro menjadi jenis mesin kustom dengan 4 vCPU dan RAM 3840 MiB.

Di Cloud Shell, jalankan perintah berikut untuk mengubah jenis mesin instance frontend:

gcloud compute instances set-machine-type frontend --machine-type custom-4-3840

Buat template instance baru:

gcloud compute instance-templates create fancy-fe-new \
    --source-instance=frontend \
    --source-instance-zone=us-central1-a

Luncurkan template instance yang telah diupdate ke grup instance terkelola:

gcloud compute instance-groups managed rolling-action start-update fancy-fe-mig \
    --version template=fancy-fe-new

Pantau status update:

watch -n 2 gcloud compute instance-groups managed list-instances fancy-fe-mig

Setelah memiliki lebih dari 1 instance dalam status RUNNING, ACTION ditetapkan ke None, dan dengan INSTANCE_TEMPLATE ditetapkan sebagai nama template baru (fancy-fe-new), salin nama salah satu mesin yang tercantum untuk digunakan dalam perintah berikutnya.

Control+S (Command+S di Macintosh) untuk keluar dari proses smartwatch.

Jalankan perintah berikut untuk melihat apakah virtual machine menggunakan jenis mesin baru (custom-4-3840), dengan [VM_NAME] adalah instance yang baru dibuat:

gcloud compute instances describe [VM_NAME] | grep machineType

Contoh output yang diharapkan:

machineType: https://www.googleapis.com/compute/v1/projects/project-name/zones/us-central1-f/machineTypes/custom-4-3840

Membuat perubahan pada situs

Tim pemasaran meminta Anda mengubah halaman beranda untuk situs. Menurut mereka, halaman ini harus lebih informatif terkait apa perusahaan Anda dan apa yang sebenarnya Anda jual. Di bagian ini, Anda akan menambahkan beberapa teks ke halaman beranda untuk membuat tim pemasaran senang. Sepertinya salah satu developer Anda sudah membuat perubahan dengan nama file index.js.new. Anda dapat menyalin file ke index.js dan perubahan Anda akan terlihat. Ikuti petunjuk di bawah ini untuk melakukan perubahan yang sesuai.

Jalankan perintah berikut, salin file yang diperbarui ke nama file yang benar, lalu cetak isinya untuk memverifikasi perubahan:

cd ~/monolith-to-microservices/react-app/src/pages/Home
mv index.js.new index.js
cat ~/monolith-to-microservices/react-app/src/pages/Home/index.js

Kode yang dihasilkan akan terlihat seperti ini:

/*
Copyright 2019 Google LLC

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    https://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

import React from "react";
import { makeStyles } from "@material-ui/core/styles";
import Paper from "@material-ui/core/Paper";
import Typography from "@material-ui/core/Typography";
const useStyles = makeStyles(theme => ({
  root: {
    flexGrow: 1
  },
  paper: {
    width: "800px",
    margin: "0 auto",
    padding: theme.spacing(3, 2)
  }
}));
export default function Home() {
  const classes = useStyles();
  return (
    <div className={classes.root}>
      <Paper className={classes.paper}>
        <Typography variant="h5">
          Fancy Fashion &amp; Style Online
        </Typography>
        <br />
        <Typography variant="body1">
          Tired of mainstream fashion ideas, popular trends and societal norms?
          This line of lifestyle products will help you catch up with the Fancy trend and express your personal style.
          Start shopping Fancy items now!
        </Typography>
      </Paper>
    </div>
  );
}

Anda telah mengupdate komponen React, tetapi Anda perlu membangun aplikasi React untuk menghasilkan file statis. Jalankan perintah berikut untuk membangun aplikasi React dan salin ke direktori publik monolit:

cd ~/monolith-to-microservices/react-app
npm install && npm run-script build

Kemudian, kirim kode lagi ke bucket Cloud Storage Anda.

cd ~
rm -rf monolith-to-microservices/*/node_modules
gsutil -m cp -r monolith-to-microservices gs://fancy-store-$DEVSHELL_PROJECT_ID/

Menerapkan perubahan dengan update berkelanjutan

Anda kini dapat memaksa semua instance untuk dimulai ulang guna menarik update.

gcloud compute instance-groups managed rolling-action restart fancy-fe-mig \
    --max-unavailable=100%

Catatan: Dalam contoh mulai ulang berkelanjutan ini, Anda secara khusus menyatakan bahwa semua mesin dapat segera dimulai ulang melalui parameter --max-unavailable. Tanpa itu, perintah akan membuat instance tetap aktif saat memulai ulang instance lainnya. Untuk tujuan pengujian, Anda menetapkan untuk segera memulai ulang semua demi kecepatan. Dalam produksi, membiarkan buffer akan memungkinkan situs untuk terus menyajikan kontennya sambil diupdate.

Tunggu sekitar 30 detik setelah mengeluarkan perintah mulai ulang tindakan berkelanjutan agar instance memiliki waktu untuk diproses, lalu periksa status grup instance terkelola hingga instance muncul dalam daftar.

watch -n 5 gcloud compute instance-groups list-instances fancy-fe-mig

Setelah item muncul dalam daftar, keluar dari perintah watch dengan menekan Control+S (Command+S di Macintosh).

Jalankan perintah berikut untuk mengonfirmasi bahwa layanan tercantum sebagai sehat:

watch -n 5 gcloud compute backend-services get-health fancy-fe-frontend --global

Contoh output:

---
backend: https://www.googleapis.com/compute/v1/projects/my-gce-codelab/zones/us-central1-a/instanceGroups/fancy-fe-mig
status:
  healthStatus:
  - healthState: HEALTHY
    instance: https://www.googleapis.com/compute/v1/projects/my-gce-codelab/zones/us-central1-a/instances/fancy-fe-x151
    ipAddress: 10.128.0.7
    port: 8080
  - healthState: HEALTHY
    instance: https://www.googleapis.com/compute/v1/projects/my-gce-codelab/zones/us-central1-a/instances/fancy-fe-cgrt
    ipAddress: 10.128.0.11
    port: 8080
  kind: compute#backendServiceGroupHealth

Setelah item muncul dalam daftar, keluar dari perintah watch dengan menekan Control+S (Command+S di Macintosh).

Untuk membatalkan konten yang di-cache dalam jaringan penayangan konten dan memastikan bahwa konten baru ditampilkan, jalankan perintah berikut:

gcloud compute url-maps invalidate-cdn-cache fancy-map \
    --path "/*"

Buka situs melalui http://[LB_IP] dengan [LB_IP] adalah IP_ADDRESS yang ditentukan untuk load balancer, yang dapat ditemukan dengan perintah berikut:

gcloud compute forwarding-rules list --global

Perubahan situs yang baru sekarang akan terlihat.

Catatan: Jika konten baru tidak ditampilkan, muat ulang halaman web dengan Control+F5 (Command+Shift+R di Macintosh) di Google Chrome untuk memastikan bahwa konten yang disimpan dalam cache akan didownload lagi.

Menyimulasikan kegagalan

Untuk memastikan bahwa health check berfungsi, login ke instance, lalu hentikan layanan tersebut. Untuk menemukan nama instance, jalankan perintah berikut:

gcloud compute instance-groups list-instances fancy-fe-mig

Dari sana, amankan shell ke salah satu instance, dengan INSTANCE_NAME adalah salah satu instance dari daftar:

gcloud compute ssh [INSTANCE_NAME]

Dalam instance tersebut, gunakan supervisorctl untuk menghentikan aplikasi.

sudo supervisorctl stop nodeapp; sudo killall node

Keluar dari instance.

exit

Memantau operasi perbaikan.

watch -n 5 gcloud compute operations list \
--filter='operationType~compute.instances.repair.*'

Cari contoh output berikut:

NAME                                                  TYPE                                       TARGET                                 HTTP_STATUS  STATUS  TIMESTAMP
repair-1568314034627-5925f90ee238d-fe645bf0-7becce15  compute.instances.repair.recreateInstance  us-central1-a/instances/fancy-fe-1vqq  200          DONE    2019-09-12T11:47:14.627-07:00

Setelah perbaikan diketahui, Control+C (Command+S di Macintosh) untuk keluar dari perintah smartwatch. Pada tahap ini, grup instance terkelola akan membuat ulang instance untuk memperbaikinya.

9. Pembersihan

Setelah siap, cara termudah untuk membersihkan semua aktivitas yang dilakukan adalah dengan menghapus project. Dengan menghapus project, load balancer, instance, template, dan lainnya yang dibuat selama codelab akan dihapus untuk memastikan tidak ada tagihan 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.

Jika tidak yakin dengan project ID-nya, Anda bisa mendapatkannya dengan menjalankan gcloud config list | grep project di Cloud Shell.

10. Selamat!

Anda telah men-deploy, menskalakan, dan memperbarui situs di Compute Engine. Anda kini telah berpengalaman dalam menggunakan Compute Engine, grup instance terkelola, load balancing, dan health check.