Melakukan Pengembangan ke Prod dalam Tiga Langkah Mudah dengan Cloud Run

1. Pengantar

Mengapa sulit mengelola aplikasi?

Salah satu alasan utamanya adalah developer sering kali harus menjadi administrator sistem paruh waktu. Pertimbangkan daftar (sebagian) masalah ini untuk mengembangkan, men-deploy, dan mengelola aplikasi web tingkat produksi modern :

Saya tidak tahu bagaimana dengan Anda, tetapi semua hal ini adalah hal-hal yang tidak ingin saya khawatirkan. Yang ingin saya pikirkan adalah logika aplikasi saya:

Singkatnya, inilah yang ditawarkan Cloud Run – memberi Anda kemampuan untuk berfokus pada aplikasi, dan menyerahkan semua administrasi dan pemeliharaan kepada orang lain, yaitu Google, yang telah menginvestasikan jutaan jam untuk menyempurnakan dan meningkatkan keahlian mereka di bidang ini.

Selain tantangan administratif yang disebutkan di atas, Anda juga harus menghadapi:

Dependensi - Lingkungan tempat aplikasi Anda berjalan harus, jika memungkinkan, sama persis dengan lingkungan tempat aplikasi diuji. Hal ini dapat mencakup beberapa dimensi, termasuk sistem operasi, library dukungan, interpreter atau compiler bahasa, konfigurasi hardware, dan banyak faktor lainnya.
Distribusi - Beralih dari inkarnasi lokal aplikasi ke aplikasi yang dibagikan secara luas di internet sering kali memerlukan perubahan lingkungan runtime, lompatan kompleksitas yang signifikan, dan kurva pembelajaran yang curam.

Cloud Run menangani masalah ini dan banyak masalah lainnya untuk Anda. Namun, daripada mempercayai kata-kata saya, mari kita bangun aplikasi bersama-sama dan lihat betapa mudahnya bertransisi dari lingkungan pengembangan lokal ke aplikasi cloud tingkat produksi hanya dalam beberapa langkah sederhana.

Yang akan Anda lakukan ...

Anda akan membuat aplikasi web sederhana dan memverifikasi bahwa aplikasi tersebut berjalan sesuai harapan di lingkungan pengembangan Anda.
Kemudian, Anda akan beralih ke aplikasi yang sama dalam versi yang di-container. Selama proses ini, Anda akan mempelajari arti containerisasi dan alasan mengapa containerisasi sangat berguna.
Terakhir, Anda akan men-deploy aplikasi ke cloud, dan Anda akan melihat betapa mudahnya mengelola layanan Cloud Run menggunakan command line dan Konsol Google Cloud.

Yang akan Anda pelajari ...

Cara membuat aplikasi server web sederhana di Python
Cara mengemas aplikasi Anda ke dalam container Docker yang dapat berjalan di mana saja
Cara men-deploy aplikasi Anda ke cloud sehingga siapa pun dapat mencoba kreasi baru Anda
Cara menyederhanakan langkah-langkah di atas lebih lanjut menggunakan Buildpack
Cara menggunakan alat command line Google Cloud dan UI web Konsol Cloud

Yang Anda butuhkan ...

Browser web
Akun Google

Lab ini ditujukan bagi developer dari semua level, termasuk para pemula. Meskipun Anda akan menggunakan Python, Anda tidak harus familier dengan pemrograman Python untuk memahami maksudnya karena kami akan menjelaskan semua kode yang Anda gunakan.

2. Memulai Persiapan

Bagian ini membahas semua hal yang perlu Anda lakukan untuk memulai lab ini.

Penyiapan lingkungan mandiri

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

Ingat project ID, nama unik di semua project Google Cloud (maaf, nama di atas telah digunakan dan tidak akan berfungsi untuk Anda!) Project ID tersebut selanjutnya akan dirujuk di codelab ini sebagai PROJECT_ID.

Selanjutnya, Anda harus mengaktifkan penagihan di 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.

Mulai Cloud Shell

Dalam lab ini, Anda akan bekerja di sesi Cloud Shell, yang merupakan interpreter perintah yang dihosting oleh mesin virtual yang berjalan di cloud Google. Anda dapat menjalankan bagian ini dengan mudah secara lokal di komputer Anda sendiri, tetapi menggunakan Cloud Shell memberi semua orang akses ke pengalaman yang dapat direproduksi dalam lingkungan yang konsisten. Setelah menyelesaikan lab ini, Anda dapat mencoba kembali bagian ini di komputer Anda sendiri.

Mengaktifkan Cloud Shell

Dari Cloud Console, klik Aktifkan Cloud Shell .

Jika belum pernah memulai Cloud Shell, Anda akan melihat layar perantara (di paruh bawah) yang menjelaskan apa itu Cloud Shell. Jika demikian, klik Continue (dan Anda tidak akan pernah melihatnya lagi). Berikut tampilan layar sekali-tampil tersebut:

Perlu waktu beberapa saat untuk menyediakan dan terhubung ke Cloud Shell.

Virtual machine ini dimuat dengan semua alat pengembangan yang Anda perlukan. Layanan ini menawarkan direktori beranda tetap sebesar 5 GB dan beroperasi di Google Cloud, sehingga sangat meningkatkan performa dan autentikasi jaringan. Sebagian besar pekerjaan Anda dalam codelab ini dapat dilakukan hanya dengan browser atau Chromebook.

Setelah terhubung ke Cloud Shell, Anda akan melihat bahwa Anda sudah diautentikasi dan project sudah ditetapkan ke project ID Anda.

Jalankan perintah berikut di Cloud Shell untuk mengonfirmasi bahwa Anda telah diautentikasi:

gcloud auth list

Output perintah

 Credentialed Accounts
ACTIVE  ACCOUNT
*       <my_account>@<my_domain.com>

To set the active account, run:
    $ gcloud config set account `ACCOUNT`

Jalankan perintah berikut di Cloud Shell untuk mengonfirmasi bahwa perintah gcloud mengetahui project Anda:

gcloud config list project

Output perintah

[core]
project = <PROJECT_ID>

Jika tidak, Anda dapat menyetelnya dengan perintah ini:

gcloud config set project <PROJECT_ID>

Output perintah

Updated property [core/project].

Tetapkan beberapa variabel lingkungan di terminal Anda yang akan mempermudah langkah-langkah berikutnya:

export PROJ=$GOOGLE_CLOUD_PROJECT 
export APP=hello 
export PORT=8080
export REGION="us-central1"
export TAG="gcr.io/$PROJ/$APP"

Mengaktifkan API

Pada langkah-langkah selanjutnya, Anda akan melihat tempat layanan ini diperlukan (dan alasannya), tetapi untuk saat ini, jalankan perintah ini untuk memberi project Anda akses ke layanan Cloud Build, Container Registry, dan Cloud Run:

gcloud services enable cloudbuild.googleapis.com         \
                       containerregistry.googleapis.com  \
                       run.googleapis.com

Perintah di atas akan menampilkan pesan seperti berikut yang menandakan bahwa proses berhasil:

Operation "operations/acf.cc11852d-40af-47ad-9d59-477a12847c9e" finished successfully.

3. Membangun Aplikasi Web Sederhana

Mulai dengan mengklik tombol Open Editor di bagian atas panel Cloud Shell. Tampilannya terlihat seperti ini:

Kemudian, Anda akan berada di lingkungan IDE yang mirip dengan Visual Studio Code, tempat Anda dapat membuat project, mengedit kode sumber, menjalankan program, dll. Jika layar Anda terlalu sempit, Anda dapat memperluas atau memperkecil garis pemisah antara konsol dan jendela pengeditan/terminal dengan menarik panel horizontal di antara kedua area tersebut, yang ditandai di sini:

Anda dapat beralih antara Editor dan Terminal dengan mengklik tombol Open Editor dan Open Terminal. Sekarang, coba beralih di antara kedua lingkungan ini.

Selanjutnya, buat folder untuk menyimpan pekerjaan Anda untuk lab ini dengan memilih File->New Folder, masukkan hello, lalu klik OK. Semua file yang Anda buat di lab ini, dan semua pekerjaan yang Anda lakukan di Cloud Shell, akan berada di folder ini.

Sekarang, buat file requirements.txt. Hal ini memberi tahu Python library mana yang menjadi dependensi aplikasi Anda. Untuk aplikasi web sederhana ini, Anda akan menggunakan modul Python populer untuk membangun server web yang disebut Flask dan framework server web yang disebut gunicorn. Di jendela Cloud Editor, klik menu File->New File untuk membuat file baru. Saat diminta untuk memasukkan nama file baru, masukkan requirements.txt, lalu tekan tombol OK. Pastikan file baru berada di folder project hello.

Masukkan baris berikut di file baru untuk menentukan bahwa aplikasi Anda bergantung pada paket Flask Python dan server web gunicorn.

Flask
gunicorn

Anda tidak perlu menyimpan file ini secara eksplisit karena Cloud Editor akan menyimpan perubahan secara otomatis untuk Anda.

Versi 1: Hello world!

Dengan menggunakan teknik yang sama, buat file baru lainnya bernama main.py. Ini akan menjadi file sumber Python utama (dan satu-satunya) aplikasi Anda. Sekali lagi, pastikan file baru berada di folder project hello.

Masukkan kode berikut ke dalam file ini:

from flask import Flask
import os
import random

app = Flask(__name__)  # Create a Flask object.
PORT = os.environ.get("PORT")  # Get PORT setting from the environment.

# The app.route decorator routes any GET requests sent to the root path
# to this function, which responds with a "Hello world!" HTML document.
@app.route("/", methods=["GET"])
def say_hello():
    html = "<h1>Hello world!</h1>"
    return html


# This code ensures that your Flask app is started and listens for
# incoming connections on the local interface and port 8080.
if __name__ == "__main__":
    app.run(host="0.0.0.0", port=PORT)

Beralih kembali ke terminal dan pindah ke folder project dengan perintah ini:

cd hello

Jalankan perintah berikut untuk menginstal dependensi project Anda:

pip3 install -r requirements.txt

Sekarang luncurkan aplikasi Anda dengan menjalankan perintah ini di terminal:

python3 main.py

Pada tahap ini, aplikasi Anda berjalan di virtual machine yang dikhususkan untuk sesi Cloud Shell Anda. Cloud Shell menyertakan mekanisme proxy yang memungkinkan Anda mengakses server web (seperti yang baru saja Anda mulai) yang berjalan di virtual machine Anda dari mana saja di internet global.

Klik tombol web preview, lalu item menu Preview on Port 8080 seperti ini:

Tab browser akan terbuka ke aplikasi yang sedang berjalan, yang akan terlihat seperti ini:

Versi 2: Menggema Jalur URL

Kembali ke Cloud Editor (melalui tombol Open Editor) dan tambahkan dukungan untuk mengulang akhiran URL opsional dengan memperbarui file main.py sebagai berikut:

from flask import Flask
import os
import random

app = Flask(__name__)  # Create a Flask object.
PORT = os.environ.get("PORT")  # Get PORT setting from environment.

# The app.route decorator routes any GET requests sent to the root path
# to this function, which responds with a "Hello world!" HTML document.
# If something is specified as the URL path (after the '/'), say_hello()
# responds with "Hello X", where X is the string at the end of the URL.
@app.route("/", methods=["GET"])
@app.route("/<name>", methods=["GET"])     # ← NEW
def say_hello(name="world"):               # ← MODIFIED
    html = f"<h1>Hello {name}!</h1>"       # ← MODIFIED
    return html


# This code ensures that your Flask app is started and listens for
# incoming connections on the local interface and port 8080.
if __name__ == "__main__":
    app.run(host="0.0.0.0", port=PORT)

Beralih kembali ke Terminal (melalui tombol Open Terminal) dan masukkan control-C (tahan tombol control sambil menekan 'C') untuk menghentikan aplikasi yang sedang berjalan, lalu mulai ulang dengan memasukkan:

python3 main.py

Sekali lagi, klik tombol web preview, lalu item menu Preview on Port 8080 untuk membuka tab browser web ke aplikasi yang sedang berjalan. Anda akan melihat pesan "Hello world!" lagi, tetapi sekarang ganti teks URL setelah karakter garis miring dengan string pilihan Anda (misalnya, /your-name) dan verifikasi bahwa Anda melihat sesuatu seperti ini:

Versi 3: Warna Acak

Sekarang, tambahkan dukungan untuk warna latar belakang acak dengan kembali ke Cloud Editor (melalui tombol Open Editor) dan memperbarui file main.py Anda sebagai berikut:

from flask import Flask
import os
import random

app = Flask(__name__)  # Create a Flask object.
PORT = os.environ.get("PORT")  # Get PORT setting from the environment.

# This function decides whether foreground text should be
# displayed in black or white, to maximize fg/bg contrast.
def set_text_color(rgb):                      # ← NEW
    sum = round(                              # ← NEW
        (int(rgb[0]) * 0.299)                 # ← NEW
        + (int(rgb[1]) * 0.587)               # ← NEW
        + (int(rgb[2]) * 0.114)               # ← NEW
    )                                         # ← NEW
    return "black" if sum > 186 else "white"  # ← NEW


# The app.route decorator routes any GET requests sent to the root path
# to this function, which responds with a "Hello world!" HTML document.
# If something is specified as the URL path (after the '/'), say_hello()
# responds with "Hello X", where X is the string at the end of the URL.
# To verify each new invocation of these requests, the HTML document
# includes CSS styling to produce a randomly colored background.
@app.route("/", methods=["GET"])
@app.route("/<name>", methods=["GET"])
def say_hello(name="world"):
    bg = random.sample(range(1, 255), 3)                       # ← NEW
    hex = (int(bg[0]) * 256) + (int(bg[1]) * 16) + int(bg[2])  # ← NEW
    fg_color = set_text_color(bg)                              # ← NEW
    bg_color = f"#{hex:06x}"                                   # ← NEW
    style = f"color:{fg_color}; background-color:{bg_color}"   # ← NEW
    html = f'<h1 style="{style}">Hello {name}!</h1>'           # ← MODIFIED
    return html


# This code ensures that your Flask app is started and listens for
# incoming connections on the local interface and port 8080.
if __name__ == "__main__":
    app.run(host="0.0.0.0", port=PORT)

python3 main.py

Sekali lagi, klik tombol web preview, lalu item menu Preview on Port 8080 untuk membuka tab browser web ke aplikasi yang sedang berjalan. Anda akan melihat teks yang dihasilkan, dengan akhiran yang ditentukan atau string "Hello world!" default, ditampilkan di depan latar belakang berwarna acak, seperti ini:

Muat ulang halaman beberapa kali untuk melihat bahwa warna latar belakang acak berubah setiap kali Anda membuka aplikasi.

Dengan demikian, aplikasi Anda sudah selesai - selamat! Pada langkah berikutnya, Anda akan mempelajari cara mengemas aplikasi ke dalam container, dan alasan hal tersebut berguna.

4. Memasukkan Aplikasi Anda ke dalam Container

What's a Container?

Container secara umum, dan Docker khususnya, memberi kita kemampuan untuk membuat kotak modular tempat menjalankan aplikasi dengan semua dependensinya yang digabungkan. Kami menyebut hasilnya sebagai image container. Di bagian ini, Anda akan membuat image container yang akan digunakan untuk mengapsulasi aplikasi dan semua dependensinya.

Mengenai dependensi, pada langkah sebelumnya, saat menjalankan aplikasi di lingkungan developer, Anda harus menjalankan pip3 install -r requirements.txt, dan memastikan file requirements.txt berisi semua library dependen dan versi yang sesuai. Dengan container, Anda menginstal persyaratan tersebut saat membuat image container, sehingga konsumen container tidak perlu khawatir menginstal apa pun.

Image container ini akan membentuk blok bangunan dasar untuk men-deploy aplikasi Anda di Cloud Run. Karena container dapat digunakan di hampir semua server virtual atau nyata, hal ini memberi kita cara untuk men-deploy aplikasi Anda di mana pun Anda inginkan, dan untuk memindahkan aplikasi Anda dari satu penyedia layanan ke penyedia layanan lain, atau dari lokal ke Cloud.

Container membantu membuat aplikasi Anda:

dapat direproduksi - container bersifat mandiri dan lengkap
portabel - container adalah blok penyusun lintas industri, yang memungkinkan portabilitas aplikasi di seluruh penyedia dan lingkungan cloud

Singkatnya, container menawarkan kemampuan untuk, akhirnya, "menulis sekali dan menjalankan di mana saja". Satu pengecualian untuk aturan tersebut adalah bahwa penampung yang dihasilkan dibatasi untuk berjalan pada jenis prosesor tempat Anda membuatnya, tetapi ada cara untuk menghasilkan versi penampung untuk konfigurasi hardware lainnya juga.

Cukup sudah - mari kita buat penampung. Anda akan menggunakan teknologi khusus untuk membuat container yang disebut Docker.

Di Cloud Editor, buat file baru bernama Dockerfile. File ini adalah blueprint untuk membangun image Anda. File ini memberi tahu Docker tentang lingkungan operasi dan kode sumber Anda, cara menginstal dependensi, membangun aplikasi, dan menjalankan kode Anda.

# Use an official lightweight Python image.
FROM python:3.9-slim

# Copy local code to the container image.
WORKDIR /app
COPY main.py .
COPY requirements.txt .

# Install dependencies into this container so there's no need to 
# install anything at container run time.
RUN pip install -r requirements.txt

# Service must listen to $PORT environment variable.
# This default value facilitates local development.
ENV PORT 8080

# Run the web service on container startup. Here you use the gunicorn
# server, with one worker process and 8 threads. For environments 
# with multiple CPU cores, increase the number of workers to match 
# the number of cores available.
CMD exec gunicorn --bind 0.0.0.0:$PORT --workers 1 --threads 8 --timeout 0 main:app

Di Terminal Cloud, bangun image container Anda menggunakan Cloud Build dengan menjalankan perintah berikut:

gcloud builds submit --tag $TAG

Setelah dikirimkan ke registry, Anda akan melihat pesan SUCCESS yang berisi nama image, yang akan terlihat seperti ini: gcr.io/<project-id>/hello. Image tersebut kini disimpan di Google Container Registry dan dapat digunakan kembali kapan pun dan di mana pun Anda inginkan.

Anda dapat mencantumkan semua image container yang terkait dengan project saat ini menggunakan perintah berikut:

gcloud container images list

Sekarang jalankan dan uji aplikasi secara lokal dari Cloud Shell, menggunakan perintah docker ini:

docker run -p $PORT:$PORT -e PORT=$PORT $TAG

Opsi -p $PORT:$PORT memberi tahu Docker untuk memetakan port eksternal $PORT (ditetapkan ke 8080 di atas) di lingkungan host ke nomor port yang sama di dalam container yang sedang berjalan. Hal ini mempermudah karena kode server yang Anda tulis dan nomor port eksternal yang Anda hubungkan saat menguji aplikasi akan sama (8080), tetapi Anda juga dapat dengan mudah menggunakan opsi -p untuk memetakan port eksternal arbitrer di host ke port internal yang diinginkan di dalam container.

Opsi -e PORT=$PORT memberi tahu Docker untuk membuat variabel lingkungan $PORT (ditetapkan ke 8080 di atas) tersedia untuk aplikasi Anda yang berjalan di dalam container.

Sekarang Anda siap menguji aplikasi dengan mengarahkan browser web ke kode Python yang berjalan di dalam penampung. Di jendela Cloud Shell, klik ikon "Web preview" dan pilih "Preview on port 8080", seperti yang Anda lakukan pada langkah sebelumnya.

Hasilnya akan terlihat familiar - Anda akan melihat teks yang dihasilkan di depan latar belakang berwarna acak, seperti yang Anda lakukan saat menjalankan aplikasi langsung di terminal Cloud Shell. Muat ulang halaman beberapa kali untuk melihat bahwa warna latar belakang acak berubah setiap kali Anda membuka aplikasi.

Selamat! Sekarang Anda telah menjalankan aplikasi versi yang di-container. Di bagian berikutnya, tanpa menyentuh satu baris kode pun, Anda akan mengubah image container menjadi aplikasi web berkualitas produksi.

5. Ke Cloud...

Setelah membuat container untuk aplikasi, Anda pasti ingin membagikan kehebatan ini kepada seluruh dunia, jadi sekarang saatnya men-deploy-nya ke Cloud. Namun, Anda ingin melakukan lebih dari sekadar membagikannya. Anda ingin memastikan bahwa:

berjalan dengan andal - Anda mendapatkan toleransi fault otomatis jika komputer yang menjalankan aplikasi Anda mengalami error
melakukan penskalaan otomatis - aplikasi Anda akan terus menangani tingkat traffic yang besar, dan secara otomatis mengurangi jejaknya saat tidak digunakan
meminimalkan biaya Anda, dengan tidak mengenakan biaya untuk resource yang tidak Anda gunakan - Anda hanya dikenai biaya untuk resource yang digunakan saat merespons traffic
dapat diakses melalui nama domain kustom - Anda memiliki akses ke solusi sekali klik untuk menetapkan nama domain kustom ke layanan Anda
menawarkan waktu respons yang sangat baik - cold start cukup responsif, tetapi Anda dapat menyempurnakannya dengan menentukan konfigurasi instance minimum
mendukung enkripsi end-to-end menggunakan keamanan web SSL/TLS standar - saat Anda men-deploy layanan, Anda akan mendapatkan enkripsi web standar, dan sertifikat yang diperlukan yang sesuai, secara gratis dan otomatis

Dengan men-deploy aplikasi ke Google Cloud Run, Anda akan mendapatkan semua hal di atas dan banyak lagi.

Men-deploy Aplikasi ke Cloud Run

Pertama, mari kita ubah aplikasi Anda agar Anda dapat membedakan revisi baru dari revisi lama. Lakukan hal itu dengan mengubah file main.py sehingga pesan default berubah dari "Hello world!" menjadi "Hello from Cloud Run!". Dengan kata lain, ubah baris ini di main.py dari:

def say_hello(name="world"):

menjadi:

def say_hello(name="from Cloud Run"):

Cloud Run bersifat regional, berarti infrastruktur yang menjalankan layanan Cloud Run Anda terletak di region tertentu dan dikelola oleh Google agar tersedia secara redundan di semua zona dalam region tersebut. Di bagian "Siapkan" di atas, Anda menentukan region default melalui variabel lingkungan REGION.

Bangun kembali image container Anda dan deploy aplikasi dalam container Anda ke Cloud Run dengan perintah berikut:

gcloud builds submit --tag $TAG
gcloud run deploy "$APP"   \
  --image "$TAG"           \
  --platform "managed"     \
  --region "$REGION"       \
  --allow-unauthenticated

Anda juga dapat menentukan region default dengan gcloud config set run/region $REGION.
Opsi --allow-unauthenticated membuat layanan tersedia secara publik. Untuk menghindari permintaan yang tidak diautentikasi, gunakan --no-allow-unauthenticated sebagai gantinya.

Image yang ditentukan di sini adalah image Docker yang Anda buat pada langkah terakhir. Berkat layanan Cloud Build, yang menyimpan image yang dihasilkan di Google Container Registry, layanan Cloud Run dapat menemukannya dan men-deploy-nya untuk Anda.

Tunggu sebentar sampai proses deployment selesai. Jika berhasil, command line akan menampilkan URL layanan:

Deploying container to Cloud Run service [hello] in project [PROJECT_ID...
✓ Deploying new service... Done.                                   
  ✓ Creating Revision... Revision deployment finished. Waiting for health check...
  ✓ Routing traffic...
  ✓ Setting IAM Policy...
Done.
Service [hello] revision [hello-...] has been deployed and is serving 100 percent of traffic.
Service URL: https://hello-....a.run.app

Anda juga dapat mengambil URL layanan dengan perintah ini:

gcloud run services describe hello  \
  --platform managed                \
  --region $REGION                  \
  --format "value(status.url)"

Tampilannya akan terlihat seperti:

https://hello-....a.run.app

Link ini adalah URL khusus, dengan keamanan TLS, untuk layanan Cloud Run Anda. Link ini bersifat permanen (selama Anda tidak menonaktifkan layanan) dan dapat digunakan di mana saja di internet. Tidak menggunakan mekanisme proxy Cloud Shell yang disebutkan sebelumnya, yang bergantung pada virtual machine sementara.

Klik Service URL yang ditandai untuk membuka tab browser web ke aplikasi yang sedang berjalan. Hasilnya akan menampilkan pesan "Hello from Cloud Run!" di depan latar belakang berwarna acak.

Selamat! Aplikasi Anda kini berjalan di Cloud Google. Tanpa perlu memikirkannya, aplikasi Anda tersedia untuk publik, dengan enkripsi TLS (HTTPS), dan penskalaan otomatis ke tingkat traffic yang luar biasa.

Namun, menurut saya proses ini bisa lebih mudah...

6. Membuat Container Secara Otomatis

Semua ini cukup keren, tetapi bagaimana jika saya tidak ingin memikirkan Dockerfile dan container. Bagaimana jika, seperti kebanyakan developer, saya hanya ingin berfokus pada penulisan kode aplikasi dan membiarkan orang lain mengkhawatirkan pembuatan kontainernya. Nah, Anda beruntung karena Cloud Run mendukung standar open source yang disebut Buildpacks, yang ada karena alasan ini: untuk mengotomatiskan proses pembuatan container dari kumpulan file sumber.

Perhatikan bahwa ada beberapa kasus ketika developer mungkin lebih memilih untuk menggunakan Dockerfile eksplisit, misalnya jika mereka menginginkan tingkat penyesuaian yang tinggi dalam cara container mereka dibuat. Namun, untuk kasus umum seperti latihan ini, buildpack berfungsi dengan baik dan tidak perlu membuat Dockerfile secara manual. Mari kita ubah kode Anda untuk menggunakan buildpack.

Pertama, mari kita ubah aplikasi Anda agar Anda dapat membedakan revisi baru dari revisi lama. Lakukan hal itu dengan mengubah file main.py sehingga pesan default berubah dari "Hello from Cloud Run!" menjadi "Hello from Cloud Run with Buildpacks!". Dengan kata lain, ubah baris ini di main.py dari:

def say_hello(name="from Cloud Run"):

menjadi:

def say_hello(name="from Cloud Run with Buildpacks"):

Sekarang, mari kita manfaatkan buildpack dengan membuat file baru bernama Procfile. Lanjutkan dan buat file tersebut di Cloud Editor, lalu masukkan satu baris teks ini:

web: python3 main.py

Hal ini memberi tahu sistem buildback cara menjalankan aplikasi Anda di container yang dibuat otomatis. Dengan sedikit petunjuk tersebut, Anda tidak lagi memerlukan Dockerfile. Untuk memverifikasinya, hapus Dockerfile Anda dan jalankan perintah berikut di Terminal Cloud Shell:

gcloud beta run deploy "$APP"  \
    --source .                 \
    --platform "managed"       \
    --region "$REGION"         \
    --allow-unauthenticated

Hal ini mirip dengan perintah yang Anda jalankan untuk men-deploy aplikasi pada langkah terakhir, tetapi kali ini Anda telah mengganti opsi --image dengan opsi --source .. Perintah ini memberi tahu perintah gcloud bahwa Anda ingin perintah tersebut menggunakan buildpack untuk membuat image container, berdasarkan file sumber yang ditemukan di direktori saat ini (dot dalam --source . adalah singkatan untuk direktori saat ini). Karena layanan menangani image container secara implisit, Anda tidak perlu menentukan image pada perintah gcloud ini.

Sekali lagi, verifikasi bahwa deployment ini berfungsi dengan mengklik Service URL yang ditandai untuk membuka tab browser web ke aplikasi yang sedang berjalan dan pastikan layanan Anda menampilkan "Hello from Cloud Run with Buildpacks!" di depan latar belakang berwarna acak.

Perhatikan bahwa dengan menggunakan buildpack untuk membuat Dockerfile, Anda pada dasarnya telah mengurangi tiga langkah mudah menjadi dua:

Buat aplikasi di lingkungan pengembangan Anda.
Deploy kode yang sama persis ke cloud dengan satu perintah.

7. Apakah Saya Harus Menggunakan Command Line?

Tidak! Seperti hampir semua layanan Google Cloud, ada tiga cara untuk berinteraksi dengan Cloud Run:

Alat command line gcloud, yang baru saja Anda lihat.
Antarmuka pengguna web yang kaya, melalui Konsol Cloud, yang mendukung gaya interaksi tunjuk dan klik yang intuitif.
Secara terprogram, menggunakan library klien Google yang tersedia untuk banyak bahasa populer, termasuk Java, C#, Python, Go, Javascript, Ruby, C/C++, dan lainnya.

Mari kita deploy instance tambahan aplikasi Cloud Run Anda menggunakan UI konsol. Buka halaman landing Cloud Run Service melalui menu kiri atas:

Kemudian, Anda akan melihat ringkasan Layanan Cloud Run, seperti ini:

Klik link "Buat Layanan" untuk memulai proses deployment:

Masukkan "hello-again" sebagai nama layanan, pilih platform dan region deployment default, lalu klik "Next".

Masukkan URL ini untuk image container: gcr.io/cloudrun/hello, yang merupakan container yang dibuat oleh Google untuk tujuan pengujian, dan klik drop-down "Setelan Lanjutan" untuk melihat beberapa dari banyak setelan konfigurasi yang tersedia untuk Anda. Berikut beberapa hal yang dapat Anda sesuaikan:

nomor port dan titik entri container (yang akan menggantikan titik entri yang ditentukan saat membangun container)
hardware: memori dan jumlah CPU
penskalaan: instance minimum dan maksimum
variabel lingkungan
lainnya: setelan waktu tunggu permintaan, jumlah maksimum permintaan per container, HTTP/2

Klik tombol "Berikutnya" untuk melanjutkan dialog. Dialog berikutnya memungkinkan Anda menentukan cara layanan dipicu. Untuk "Ingress", pilih "izinkan semua traffic", dan untuk "Authentication", pilih "Izinkan traffic yang tidak diautentikasi".

Ini adalah setelan yang paling bebas, karena memungkinkan siapa saja mengakses aplikasi Cloud Run Anda, dari mana saja di internet publik, tanpa menentukan kredensial autentikasi. Anda mungkin menginginkan setelan yang lebih ketat untuk aplikasi Anda, tetapi mari kita buat sederhana untuk latihan pembelajaran ini.

Sekarang klik tombol Create untuk membuat layanan Cloud Run. Setelah beberapa detik, Anda akan melihat layanan baru muncul dalam daftar ringkasan layanan Cloud Run. Baris ringkasan memberikan deployment terbaru (tanggal/waktu dan oleh siapa) beserta beberapa setelan konfigurasi utama. Klik link nama layanan untuk melihat detail tentang layanan baru Anda.

Untuk memverifikasi layanan Anda, klik URL yang ditampilkan di dekat bagian atas halaman ringkasan seperti yang ditandai dalam contoh di bawah:

Anda akan melihat yang seperti ini:

Setelah men-deploy layanan Cloud Run baru, pilih tab REVISIONS untuk melihat beberapa cara mengelola beberapa deployment.

Untuk men-deploy revisi baru langsung dari konsol, Anda dapat mengklik tombol EDIT & DEPLOY NEW REVISION, seperti yang ditandai pada contoh screenshot di bawah:

Klik tombol tersebut sekarang untuk membuat revisi baru. Di dekat URL penampung, klik tombol SELECT, seperti yang ditunjukkan di bawah:

Dalam dialog yang muncul, temukan aplikasi web sederhana yang Anda deploy dari Cloud Build menggunakan Buildpack sebelumnya, lalu klik pilih. Pastikan Anda memilih image container di bagian

gcr.io/<project>/cloud-run-source-deploy

folder , seperti ini:

Setelah dipilih, scroll ke bagian bawah, lalu klik tombol DEPLOY. Anda kini telah men-deploy revisi baru aplikasi. Untuk memverifikasi, buka kembali URL layanan Anda dan verifikasi bahwa Anda kini melihat aplikasi web "Hello from Cloud Run with Buildpacks!" yang berwarna-warni.

Seperti yang dapat Anda lihat, tab revisi memberikan ringkasan setiap revisi yang telah Anda deploy, dan sekarang Anda akan melihat dua revisi untuk layanan ini. Anda dapat memilih revisi tertentu dengan mengklik tombol pilihan di sebelah kiri nama revisi, yang akan menampilkan ringkasan detail revisi di sisi kanan layar. Dengan memilih tombol tersebut, Anda dapat melihat bahwa dua revisi Anda berasal dari dua image penampung yang berbeda.

Tombol MANAGE TRAFFIC memungkinkan Anda mengubah distribusi permintaan masuk yang dikirim ke revisi tertentu. Kemampuan untuk menyesuaikan jumlah traffic yang dikirim ke revisi tertentu memungkinkan beberapa kasus penggunaan yang berharga:

pengujian canary versi baru aplikasi Anda dengan sebagian kecil traffic masuk
mengembalikan traffic dari rilis yang bermasalah ke revisi sebelumnya
Pengujian A/B

Temukan tombol MANAGE TRAFFIC di sini:

Konfigurasi pemisahan traffic 50/50 antara dua revisi Anda dengan menentukan pemisahan traffic 50/50 seperti ini:

Sekarang klik tombol SIMPAN dan verifikasi pembagian 50/50 dengan membuka URL layanan Anda berulang kali dan periksa apakah, rata-rata, setengah dari permintaan Anda ditayangkan oleh revisi saat ini ("Hello from Cloud Run with Buildpacks!") dan setengahnya ditayangkan oleh revisi sebelumnya ("It's running!").

Tab lain di halaman Detail Layanan menawarkan kemampuan untuk memantau performa, traffic, dan log, yang memberikan insight berharga tentang seberapa keras dan seberapa baik layanan Anda bekerja. Anda juga dapat menyesuaikan akses ke layanan Anda melalui tab "Izin". Luangkan waktu beberapa saat untuk menjelajahi tab di halaman ini guna memahami kemampuan yang tersedia di sini.

Antarmuka Terprogram

Seperti yang disebutkan sebelumnya, Anda juga memiliki opsi untuk membuat, men-deploy, dan mengelola layanan Cloud Run secara terprogram. Untuk tugas manual, opsi ini lebih canggih daripada command line atau konsol web, tetapi opsi ini adalah cara yang tepat untuk mengotomatiskan layanan Cloud Run. Anda memiliki opsi untuk menggunakan library klien Google dalam beberapa bahasa pemrograman populer.

8. Menguji Aplikasi

Pada langkah terakhir ini, Anda akan menjalankan uji beban buatan untuk menguji daya tahan aplikasi dan mengamati cara aplikasi menskalakan dengan permintaan yang masuk. Anda akan menggunakan alat bernama hey, yang sudah diinstal di Cloud Shell dan memberi kita kemampuan untuk menjalankan uji beban dan menampilkan hasilnya.

Menjalankan Pengujian

Di Cloud Shell Terminal, jalankan perintah ini untuk menjalankan uji beban:

hey -q 1000 -c 200 -z 30s https://hello-...run.app

Argumen perintah ditafsirkan sebagai berikut:

-q 1000 - coba dorong beban sekitar 1.000 permintaan per detik
-c 200 - mengalokasikan 200 pekerja paralel
-z 30s - jalankan pengujian beban selama 30 detik
pastikan untuk menggunakan URL layanan Anda sebagai argumen terakhir di command line ini

Hasil pengujian Anda akan terlihat seperti ini:

 Summary:
 Total:        30.2767 secs
 Slowest:      3.3633 secs
 Fastest:      0.1071 secs
 Average:      0.1828 secs
 Requests/sec: 1087.2387
 Total data:   3028456 bytes
 Size/request: 92 bytes

Response time histogram:
 0.107 [1]     |
 0.433 [31346] |■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
 0.758 [1472]  |■■
 1.084 [82]    |
 1.410 [4]     |
...

Latency distribution:
...
 50% in 0.1528 secs
 75% in 0.1949 secs
 90% in 0.2442 secs
 95% in 0.4052 secs
 99% in 0.7062 secs

Details (average, fastest, slowest):
...
 req write:    0.0000 secs, 0.0000 secs, 0.0232 secs
 resp wait:    0.1824 secs, 0.1070 secs, 3.2953 secs
 resp read:    0.0000 secs, 0.0000 secs, 0.0010 secs
Status code distribution:
 [200] 32918 responses

Ringkasan ini memberi tahu kita beberapa item yang menarik:

32.918 permintaan dikirimkan dengan kecepatan sekitar 1.000/per detik selama 30 detik.
Tidak ada error (hanya respons HTTP 200).
Latensi rata-rata adalah 180 md.
Latensi minimum adalah 107 md, kasus terburuk adalah 3,3 dtk
Latensi persentil ke-90 adalah 244 md.

Jika Anda memeriksa tab METRICS di konsol Cloud Run, Anda dapat melihat sisi performa server:

9. Membersihkan

Meskipun Cloud Run tidak mengenakan biaya selama layanannya tidak digunakan, Anda mungkin akan tetap ditagih atas penyimpanan image container yang telah dibuat.

Anda dapat menghapus project GCP Anda untuk menghentikan tagihan, yang artinya akan menghentikan penagihan atas semua resource yang digunakan dalam project tersebut, atau cukup hapus image container Anda dengan perintah ini:

gcloud container images delete $TAG

Untuk menghapus layanan Cloud Run, gunakan perintah berikut:

gcloud run services delete hello --platform managed --region $REGION --quiet
gcloud run services delete hello-again --platform managed --region $REGION --quiet

10. Anda Berhasil!

Selamat - Anda telah berhasil membangun dan men-deploy aplikasi Cloud Run produksi. Selama proses ini, Anda mempelajari container dan cara membangun container Anda sendiri. Anda juga telah melihat betapa mudahnya men-deploy aplikasi dengan Cloud Run, menggunakan alat command line gcloud dan Konsol Cloud. Sekarang Anda tahu cara membagikan kreasi cemerlang Anda kepada seluruh dunia.

Saya ingin mengajukan satu pertanyaan penting kepada Anda:

Setelah aplikasi Anda berfungsi di lingkungan developer, berapa baris kode yang harus Anda ubah untuk men-deploy-nya ke cloud, dengan semua atribut tingkat produksi yang ditawarkan oleh Cloud Run?

Jawabannya tentu saja adalah nol. :)

Codelab untuk dipelajari...

Fitur keren lainnya yang bisa dijelajahi...

Dokumen referensi ...

11. Pesan Ajakan

Jika Anda menikmati codelab ini dan cenderung menghabiskan lebih banyak waktu untuk berinteraksi langsung dengan Google Cloud, Anda harus Bergabung dengan Google Cloud Innovators sekarang.

Google Cloud Innovators Gratis dan mencakup:

Diskusi live, AMA, dan sesi roadmap untuk mempelajari hal terbaru langsung dari karyawan Google
Berita Google Cloud terbaru langsung di kotak masuk Anda
Badge digital dan latar belakang konferensi video
500 kredit lab dan pembelajaran di Skills Boost

Klik di sini untuk mendaftar.