Menghosting dan menskalakan aplikasi web di Google Cloud dengan Compute Engine

1. Pengantar

Ada banyak cara untuk men-deploy situs di Google Cloud dengan setiap solusi yang menawarkan fitur, kapabilitas, dan tingkat kontrol yang berbeda-beda. Compute Engine menawarkan level kontrol yang mendalam atas infrastruktur yang digunakan untuk menjalankan situs. Namun, solusi ini memerlukan agak lebih banyak pengelolaan operasional dibandingkan dengan solusi seperti Google Kubernetes Engine, App Engine, atau lainnya. Dengan Compute Engine, Anda memiliki kontrol menyeluruh atas berbagai aspek infrastruktur, termasuk virtual machine, load balancer, dan lainnya. Hari ini, Anda akan men-deploy aplikasi contoh—situs e-commerce Fancy Store—untuk menunjukkan cara men-deploy dan menskalakan situs 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 melakukan caching

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 tentang konsep yang akan kita gunakan dalam lab ini, lihat materi di bawah:
• Selamat datang di Google Cloud Platform - Dasar-Dasar GCP
• Mulai Menggunakan Google Cloud Compute Engine
• Memulai 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 Konsol Cloud 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: Anda harus 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 ini.

Mengaktifkan Compute Engine API

Selanjutnya, Anda perlu mengaktifkan Compute Engine API. Untuk mengaktifkan API, Anda harus 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 dari jarak jauh menggunakan laptop Anda, dalam codelab ini, Anda akan menggunakan Cloud Shell, lingkungan command line yang berjalan di Cloud.

Mesin virtual berbasis Debian ini memuat semua alat pengembangan yang akan Anda perlukan. Layanan ini menawarkan direktori beranda tetap sebesar 5 GB dan beroperasi di Google Cloud, sehingga sangat meningkatkan performa dan autentikasi jaringan. Ini berarti bahwa semua yang Anda perlukan untuk codelab ini adalah browser (ya, ini berfungsi di Chromebook).

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 kita buat, serta skrip startup kita. 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 nama objek bersifat unik. Mengingat semua ID project Google Cloud harus unik, penambahan ID juga akan membuat nama lain menjadi unik.

3. Membuat clone repositori sumber

Anda akan menggunakan situs e-commerce Fancy Store yang sudah ada berdasarkan repositori monolith-to-microservices sebagai dasar untuk situs Anda. Anda akan membuat clone kode sumber dari repositori sehingga dapat berfokus pada aspek deployment ke Compute Engine. Nanti, Anda akan melakukan update kecil pada kode untuk menunjukkan kemudahan melakukan update di Compute Engine.

Anda dapat secara otomatis meng-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 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 dijalankan 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, lalu pilih "Preview on port 8080".

Tindakan ini akan membuka jendela baru tempat Anda dapat melihat frontend Fancy Store beraksi.

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

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

4. Membuat instance Compute Engine

Setelah memiliki lingkungan developer yang berfungsi, Anda dapat men-deploy beberapa instance Compute Engine. Dalam 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 toolbar Cloud Shell untuk membuka editor kode.

Buka folder monolith-to-microservices. Klik File > New File, lalu buat file bernama startup-script.sh.

Di file baru, tempel kode berikut, yang sebagian 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, cari teks [DEVSHELL_PROJECT_ID] dan ganti dengan output dari perintah berikut:

echo $DEVSHELL_PROJECT_ID

Contoh output:

my-gce-codelab-253520

Baris kode di startup-script.sh sekarang harus sama dengan yang berikut:

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

Catatan: Jika Anda menggunakan editor kode di Cloud Shell, pastikan "End of Line Sequence" disetel ke "LF", bukan "CRLF". Anda dapat memeriksanya dengan melihat bagian kanan bawah editor kode:

Jika disetel ke CRLF, klik CRLF, lalu pilih "LF" di drop-down.

Skrip startup akan melakukan tugas-tugas berikut:

• Penginstalan agen Logging, yang otomatis mengumpulkan log dari syslog
• Penginstalan Node.js dan Supervisor, yang menjalankan aplikasi sebagai daemon
• Meng-clone kode sumber aplikasi dari bucket Cloud Storage dan menginstal dependensi
• Konfigurasi Supervisor, yang menjalankan aplikasi, memastikan bahwa aplikasi dimulai ulang jika tertutup secara tidak terduga atau dihentikan oleh admin atau proses, dan mengirimkan stdout dan stderr aplikasi ke syslog untuk dikumpulkan oleh Agen logging

Sekarang salin file startup-script.sh yang dibuat ke bucket Cloud Storage yang Anda buat sebelumnya:

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

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

Menyalin kode ke bucket Cloud Storage

Saat diluncurkan, instance mengambil kode dari bucket Cloud Storage sehingga Anda dapat menyimpan beberapa variabel konfigurasi dalam file '.env' kode tersebut.

Catatan: Anda juga dapat membuat kode ini untuk mengambil variabel lingkungan dari tempat lain. Namun untuk tujuan demonstrasi, ini adalah metode sederhana untuk menangani konfigurasi. Dalam produksi, variabel lingkungan kemungkinan 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 direktori dependensi 'node_modules' untuk memastikan kode berjalan secepat dan seefisien mungkin. Direktori ini dibuat ulang di instance saat instance dimulai.

Men-deploy instance backend

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

Catatan: Dalam lingkungan produksi, sebaiknya pisahkan tiap microservice ke dalam instance dan grup instance-nya masing-masing agar skalanya dapat disesuaikan sendiri-sendiri. Untuk tujuan demonstrasi, kedua microservice backend (pesanan dan produk) akan berada di instance dan grup instance yang sama.

Jalankan perintah berikut di Cloud Shell untuk membuat instance f1-micro yang dikonfigurasi untuk menggunakan skrip startup yang Anda buat sebelumnya dan diberi tag sebagai instance backend sehingga Anda dapat menerapkan aturan firewall tertentu padanya 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-langkah sebelumnya, alat command line gcloud akan menanyakan, "Would you like to enable and retry (this will take a few minutes)?" 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 perlu mengubah konfigurasinya supaya diarahkan ke backend yang Anda deploy.

Ambil alamat IP eksternal backend, yang dapat dilihat dari perintah berikut di 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 > Toggle Hidden Files untuk melihat file .env.

Edit file .env agar terkoneksi 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 kembali 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 instance frontend

Sekarang setelah kode dikonfigurasi, Anda dapat men-deploy instance frontend. Jalankan perintah berikut untuk men-deploy instance frontend dengan perintah serupa seperti sebelumnya, tetapi instance ini ditandai sebagai "frontend" untuk keperluan firewall.

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 ini dilakukan untuk mempermudah dan karena kode dikonfigurasi untuk meluncurkan semua microservice secara default. Oleh karena itu, dalam contoh ini, semua microservice berjalan di frontend dan backend. Namun, dalam lingkungan produksi, Anda hanya akan menjalankan microservice yang Anda perlukan pada tiap komponen.

Mengonfigurasi jaringan

Buat aturan firewall untuk mengizinkan akses ke port 8080 untuk frontend, dan port 8081 dan 8082 untuk backend. Perintah firewall ini menggunakan tag yang ditetapkan dalam 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

Situsnya sekarang seharusnya sudah berfungsi. Tentukan alamat IP eksternal frontend. Alamat dapat ditentukan dengan mencari EXTERNAL_IP instance frontend:

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 perintah berikut untuk memantau kesiapan aplikasi:

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

Setelah Anda melihat hasil yang serupa dengan contoh berikut, situs seharusnya sudah siap. Tekan Control+C (Command+C di Macintosh) pada command prompt untuk membatalkan perintah watch.

Buka 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 seharusnya juga berfungsi.

Catatan: Jika Anda berhenti di titik 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 agar redundansi dan pemulihan otomatis 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 satu entity 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 frontend dan backend instance guna menyediakan autohealing, load balancing, penskalaan otomatis, dan update berkelanjutan.

Membuat template instance dari instance sumber

Sebelum Anda dapat membuat grup instance terkelola, Anda harus membuat template instance yang akan menjadi fondasi grup tersebut. Dengan template instance, Anda dapat menentukan jenis mesin, boot disk image atau image container, jaringan, dan properti instance lainnya 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 terpisah.

Untuk membuat template instance, gunakan instance yang sudah 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

Konfirmasi bahwa 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 masing-masing dua instance dalam tiap grup sebagai awalnya. Instance akan otomatis diberi nama berdasarkan "base-instance-name" yang ditentukan dengan penambahan 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, dan microservice backend berjalan di port 8081 untuk pesanan dan port 8082 untuk produk. Karena ini adalah port nonstandar, Anda akan menentukan port bernama untuk mengidentifikasinya. Port bernama adalah metadata pasangan nilai kunci yang mewakili nama layanan dan port tempatnya dijalankan. 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 itu sendiri dan memverifikasi bahwa aplikasi responsif, Anda dapat mengonfigurasi kebijakan autohealing untuk grup instance terkelola.

Kebijakan autohealing bergantung pada health check berbasis aplikasi untuk memverifikasi bahwa aplikasi memberikan respons sesuai yang diharapkan. Memeriksa respons aplikasi lebih tepat dibanding hanya memverifikasi bahwa suatu instance berstatus RUNNING, yang merupakan perilaku default.

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

Buat health check yang akan memperbaiki instance jika menampilkan status 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 pada 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: Mungkin perlu waktu 15 menit sebelum autohealing mulai memantau instance dalam grup.

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

6. Buat load balancer

Untuk melengkapi grup instance terkelola, Anda akan menggunakan Load Balancing HTTP(S) untuk menyajikan traffic ke microservice frontend dan backend, serta menggunakan pemetaan untuk mengirim traffic ke layanan backend yang sesuai berdasarkan aturan penetapan jalur. Hal ini akan mengekspos satu alamat IP yang di-load balance untuk semua layanan.

Untuk mengetahui 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 membandingkan tiap permintaan dengan peta URL guna menentukan layanan backend yang sesuai untuk permintaan tersebut.
3. Layanan backend mengarahkan tiap permintaan ke backend yang sesuai berdasarkan kapasitas penyajian, zona, dan kondisi 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 saat dikirimkan 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 di layanan backend harus memiliki sertifikat SSL.

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

Buat health check yang akan digunakan untuk menentukan instance yang mampu menyajikan traffic untuk tiap 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 pengalihan traffic dari load balancer. Tindakan 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 layanan backend tujuan bagi masing-masing URL.

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

Buat path matcher agar jalur /api/orders dan /api/products diarahkan 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 terikat ke peta URL yang dibuat.

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

Buat aturan penerusan global yang mengikat 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 Anda memiliki alamat IP statis baru, Anda perlu mengupdate kode di frontend agar terkoneksi ke alamat baru ini, bukan alamat sementara sebelumnya yang terkoneksi ke instance backend.

Di Cloud Shell, ganti ke folder react-app, yang berisi file .env yang menyimpan konfigurasi.

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

Cari 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 instance backend.

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

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

Bangun kembali 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 instance frontend di grup instance terkelola mengambil kode baru. Instance Anda mengambil kode saat sistem dimulai, sehingga Anda dapat memberikan perintah mulai ulang yang berkelanjutan.

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

Catatan: Dalam contoh mulai ulang bertahap tersebut, Anda secara spesifik menyatakan bahwa semua mesin dapat segera dimulai ulang melalui parameter –max-unavailable. Tanpa parameter tersebut, perintah di atas akan menyisakan satu instance yang tetap berjalan sambil memulai ulang instance lainnya. Untuk tujuan pengujian, tentukan untuk segera memulai ulang semua instance guna mempercepat prosesnya.

Menguji situs

Tunggu sekitar 30 detik setelah mengeluarkan perintah rolling-action restart untuk memberikan waktu bagi instance 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).

Konfirmasi 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+C (Command+C di Macintosh).

Aplikasi kemudian akan dapat diakses 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

7. Menskalakan Compute Engine

Sejauh ini, Anda telah membuat dua grup instance terkelola, masing-masing dengan dua instance. Konfigurasi ini berfungsi penuh, tetapi merupakan konfigurasi statis terlepas dari bebannya. Sekarang, Anda akan membuat kebijakan penskalaan otomatis berdasarkan penggunaan untuk secara otomatis menskalakan tiap grup instance terkelola.

Mengubah ukuran secara otomatis berdasarkan penggunaan

Untuk membuat kebijakan penskalaan otomatis, jalankan perintah berikut di Cloud Shell. Mereka akan membuat autoscaler pada grup instance terkelola yang secara otomatis menambahkan instance saat penggunaan load balancer lebih tinggi dari 60% dan menghapus instance saat penggunaan 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

Mengaktifkan jaringan penayangan konten

Cara lain yang dapat membantu penskalaan adalah mengaktifkan Cloud CDN—layanan jaringan penayangan konten—untuk menyediakan penyimpanan cache bagi layanan frontend. Untuk melakukannya, Anda dapat menjalankan perintah berikut di layanan frontend:

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

Sekarang, saat pengguna meminta konten dari load balancer, permintaan tersebut akan tiba di frontend Google, yang pertama-tama akan mencari respons atas permintaan pengguna di cache Cloud CDN. Jika menemukan respons yang di-cache, frontend akan mengirimkan respons yang di-cache tersebut kepada pengguna. Hal ini disebut cache ditemukan.

Jika tidak, jika frontend tidak dapat menemukan respons yang di-cache untuk permintaan tersebut, 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. Memperbarui situs

Mengupdate template instance

Template instance yang 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 setelan template image intinya. Sekarang, Anda akan membuat perubahan sederhana untuk menggunakan jenis mesin yang lebih besar dan menerapkannya.

Perbarui instance frontend, yang bertindak sebagai dasar untuk template instance. Selama update berlangsung, masukkan file pada versi terbaru image template instance, lalu update template instance tersebut, luncurkan template baru, dan konfirmasi bahwa file tersebut ada pada instance grup instance terkelola.

Anda akan mengubah jenis mesin template instance dengan beralih dari jenis mesin standar f1-micro ke 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 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 Anda memiliki lebih dari 1 instance dengan status RUNNING, ACTION ditetapkan ke None, dan INSTANCE_TEMPLATE ditetapkan sebagai nama template baru (fancy-fe-new), salin nama salah satu mesin yang tercantum untuk digunakan pada perintah berikutnya.

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

Jalankan perintah berikut untuk melihat apakah virtual machine tersebut menggunakan jenis mesin baru (custom-4-3840), dengan [VM_NAME] sebagai 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 telah meminta Anda mengubah halaman beranda situs Anda. Menurut mereka, halaman ini harus lebih informatif terkait apa perusahaan Anda dan apa yang sebenarnya Anda jual. Di bagian ini, Anda akan menambahkan teks ke beranda untuk memenuhi permintaan tim pemasaran. Sepertinya salah satu developer Anda telah membuat perubahan itu dengan nama file index.js.new. Anda dapat menyalin file ke index.js dan perubahan Anda akan diterapkan. Ikuti petunjuk di bawah ini untuk melakukan perubahan yang sesuai.

Jalankan perintah berikut, salin file yang telah diperbarui itu ke nama file yang benar, lalu cetak kontennya 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 menyalinnya ke direktori publik monolith:

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

Kemudian, kirim kode ke bucket Cloud Storage Anda lagi.

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

Memaksakan perubahan dengan update bertahap

Anda kini dapat memaksa semua instance untuk memulai ulang guna mengambil update.

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

Catatan: Dalam contoh mulai ulang bertahap ini, Anda secara spesifik menyatakan bahwa semua mesin dapat segera dimulai ulang melalui parameter --max-unavailable. Tanpa parameter tersebut, perintah di atas akan menyisakan satu instance yang tetap berjalan sambil memulai ulang instance lainnya. Untuk tujuan pengujian ini, Anda menyatakan bahwa semua instance dapat segera dimulai ulang guna mempercepat prosesnya. Dalam produksi, Anda bisa menyediakan buffer untuk memungkinkan situs terus menyediakan layanan saat di-update.

Tunggu sekitar 30 detik setelah mengeluarkan perintah rolling-action restart untuk memberikan waktu bagi instance 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 healthy:

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 menginvalidasi konten yang di-cache dalam jaringan penayangan konten dan memastikan konten baru ditampilkan, jalankan perintah berikut:

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

Jelajahi 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 baru untuk situs sekarang seharusnya terlihat.

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

Menyimulasikan kegagalan

Untuk mengonfirmasi bahwa health check berfungsi, login ke sebuah instance dan hentikan layanan. Untuk menemukan nama instance, jalankan perintah berikut:

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

Dari sana, masuk ke salah satu instance melalui protokol secure shell, dengan INSTANCE_NAME adalah salah satu instance dari daftar:

gcloud compute ssh [INSTANCE_NAME]

Di instance, gunakan supervisorctl untuk menghentikan aplikasi.

sudo supervisorctl stop nodeapp; sudo killall node

Keluar dari instance.

exit

Pantau 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 terlihat, tekan Control+C (Command+S di Macintosh) untuk keluar dari perintah watch. Pada titik ini, grup instance terkelola membuat ulang instance untuk memperbaikinya.

9. Pembersihan

Setelah siap, cara termudah untuk membersihkan semua aktivitas yang dilakukan adalah dengan menghapus project. Menghapus project akan menghapus load balancer, instance, template, dan lainnya yang dibuat selama codelab untuk memastikan tidak ada biaya berulang yang tidak terduga. Jalankan perintah berikut di Cloud Shell, dengan PROJECT_ID adalah project ID lengkap, bukan hanya nama project.

gcloud projects delete [PROJECT_ID]

Konfirmasi penghapusan dengan memasukkan "Y" saat diminta.

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

10. Selamat!

Anda telah men-deploy, menskalakan, dan mengupdate situs Anda di Compute Engine. Anda kini sudah memiliki pengalaman menggunakan Compute Engine, grup instance terkelola, load balancing, dan health check.