Melakukan Pengembangan ke Prod dalam Tiga Langkah Mudah dengan Cloud Run

1. Pengantar

Mengapa mengelola aplikasi begitu sulit?

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

Aku tidak tahu denganmu, tapi semua ini tidak perlu kukhawatirkan! Yang benar-benar ingin saya pikirkan adalah logika aplikasi saya:

Intinya adalah 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 meningkatkan dan menyempurnakan keterampilan mereka di domain 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, pustaka dukungan, penerjemah atau compiler bahasa, konfigurasi perangkat keras, dan banyak faktor lainnya.
• Distribusi - Peralihan dari inkarnasi lokal aplikasi ke aplikasi yang dibagikan secara luas di internet sering kali memerlukan perubahan lingkungan runtime, lompatan kuantum dalam kompleksitas, dan kurva pembelajaran yang curam.

Cloud Run akan menangani hal ini dan banyak masalah lainnya untuk Anda. Alih-alih begitu saja, mari kita buat aplikasi bersama dan lihat betapa mudahnya bertransisi dari lingkungan pengembangan lokal ke aplikasi cloud tingkat produksi hanya dengan beberapa langkah sederhana.

Yang akan Anda lakukan ...

• Anda akan membangun aplikasi web sederhana dan memverifikasi bahwa aplikasi tersebut berjalan seperti yang diharapkan di lingkungan pengembangan Anda.
• Selanjutnya, Anda akan berpindah ke versi dalam container dari aplikasi yang sama. Dalam materi ini, Anda akan mempelajari apa arti containerization dan mengapa containerization 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 memaketkan aplikasi Anda ke dalam container Docker yang berjalan di mana saja
• Cara men-deploy aplikasi Anda ke cloud agar siapa saja dapat mencoba kreasi baru Anda
• Cara menyederhanakan langkah-langkah di atas lebih jauh menggunakan Buildpacks
• Cara menggunakan alat command line Google Cloud dan UI web Cloud Console

Yang Anda butuhkan ...

• {i>Browser<i} internet
• Akun Google

Lab ini ditujukan bagi developer dari semua level, termasuk para pemula. Meskipun akan menggunakan Python, Anda tidak harus familier dengan pemrograman Python untuk memahami apa yang terjadi 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

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.

Mulai Cloud Shell

Di lab ini, Anda akan mengerjakan sesi Cloud Shell, yang merupakan penafsir perintah yang dihosting oleh virtual machine yang berjalan di cloud Google. Anda dapat dengan mudah menjalankan bagian ini secara lokal di komputer sendiri, tetapi menggunakan Cloud Shell akan memberi semua orang akses ke pengalaman yang dapat diproduksi ulang dalam lingkungan yang konsisten. Setelah lab ini, Anda dapat mencoba lagi bagian ini di komputer Anda sendiri.

Saat pertama kali mengajukan permintaan di Cloud Shell yang memerlukan otorisasi, Anda akan melihat pesan "Authorize Cloud Shell" seperti yang ditampilkan di bawah ini, yang dapat dengan aman mengklik tombol "Authorize" tombol.

Mengaktifkan Cloud Shell

1. 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 Lanjutkan (dan Anda tidak akan pernah melihatnya lagi). Berikut tampilan layar sekali-tampil tersebut:

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

Mesin virtual ini dimuat dengan semua alat pengembangan yang Anda butuhkan. 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.

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

Catatan: Alat command-line gcloud adalah alat command-line yang canggih dan terpadu di Google Cloud. Alat ini sudah diinstal lebih dulu di Cloud Shell. Anda akan melihat dukungannya untuk penyelesaian tab. Untuk mengetahui informasi selengkapnya, baca ringkasan alat command line gcloud.

3. 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 proses pada 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 selanjutnya, Anda akan melihat di mana layanan ini diperlukan (dan alasannya). Namun, untuk saat ini, jalankan perintah ini agar project Anda dapat mengakses 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. Bangun Aplikasi Web Sederhana

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

Lalu 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 terlalu sempit, Anda dapat memperluas atau mengecilkan garis pemisah antara konsol dan jendela edit/terminal dengan menarik kolom horizontal di antara dua area tersebut, yang disorot di sini:

Anda dapat beralih antara Editor dan Terminal dengan mengklik tombol Open Editor dan Open Terminal. Coba beralih antara dua lingkungan ini sekarang.

Ada juga opsi "Buka di jendela baru" yang terlihat seperti ini: , yang memisahkan Konsol Cloud dan Terminal/Editor menjadi jendela terpisah. Anda tidak perlu menggunakannya untuk lab ini, tetapi hal ini adalah hal yang baik untuk diketahui.

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

Sekarang, buat file requirements.txt. Ini memberi tahu Python library mana yang diandalkan aplikasi Anda. Untuk aplikasi web sederhana ini, Anda akan menggunakan modul Python populer untuk membangun server web bernama Flask dan framework server web bernama 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 berakhir di folder project hello.

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

Flask
gunicorn

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

Versi 1: Halo dunia!

Dengan 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 berakhir 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)

Baca komentar inline (teks setelah karakter '#') untuk memahami apa yang dilakukan setiap baris kode Python.

Pindah kembali ke terminal dan ubah ke folder project dengan perintah ini:

cd hello

Jika Anda menemukan ada yang tidak berfungsi di Cloud Shell, mungkin karena perangkat dimulai ulang dan akhirnya kembali ke direktori utama (utama). Anda dapat memeriksanya dengan memasukkan pwd (direktori kerja cetak) untuk melihat apakah Anda saat ini berada di direktori utama. Jika demikian, jalankan perintah cd hello untuk beralih ke folder project Anda.

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. Cloud Shell mencakup 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:

Tindakan ini akan membuka tab browser web ke aplikasi yang sedang berjalan, yang akan terlihat seperti ini:

Versi 2: Menggemakan Jalur URL

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

Perhatikan baris yang ditandai dengan komentar BARU dan DIUBAH. Ini adalah perubahan dari versi sebelumnya. Anda dapat melakukan perubahan tersebut secara selektif, atau mengganti seluruh konten main.py dengan kode di bawah 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 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)

Kembali ke Terminal (melalui tombol Open Terminal) dan masukkan control-C (tahan tombol kontrol sambil menekan ‘C') untuk menghentikan aplikasi yang 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 lagi pesan "Hello world!" tetapi sekarang ganti teks URL setelah karakter garis miring dengan string pilihan Anda (misalnya /your-name) dan verifikasi bahwa Anda melihat yang seperti ini:

Versi 3: Random Colors

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

Perhatikan baris yang ditandai dengan komentar BARU dan DIUBAH. Ini adalah perubahan dari versi sebelumnya. Anda dapat melakukan perubahan tersebut secara selektif, atau mengganti seluruh konten main.py dengan kode di bawah 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.

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

Kembali ke Terminal (melalui tombol Open Terminal) dan masukkan control-C (tahan tombol kontrol sambil menekan ‘C') untuk menghentikan aplikasi yang 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 teks yang dihasilkan, dengan akhiran yang ditentukan atau teks default "Hello world!" string, yang 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.

Dan dengan itu, aplikasi Anda telah selesai - selamat! Pada langkah berikutnya, Anda akan mempelajari cara memaketkan aplikasi ke dalam container, dan alasan hal tersebut berguna untuk dilakukan.

4. Memasukkan Aplikasi ke dalam Container

Apa itu Container?

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

Berbicara tentang 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 elemen penyusun 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 di mana saja yang Anda inginkan, dan memindahkan aplikasi dari satu penyedia layanan ke penyedia layanan lainnya, atau dari lokal ke Cloud.

Container membantu aplikasi Anda:

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

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

Sudah cukup - mari kita buat sebuah container! Anda akan menggunakan teknologi khusus untuk membuat penampung yang disebut Docker.

Di Cloud Editor, buat file baru bernama Dockerfile. File ini adalah cetak biru untuk menyusun 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

Baca komentar inline (teks setelah karakter '#') untuk memahami tindakan yang dilakukan setiap baris Dockerfile ini.

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

gcloud builds submit --tag $TAG

Cloud Build adalah layanan yang membangun image container dan menyimpan hasilnya di Cloud Registry, sehingga Anda dapat mengakses image container dari mana saja di internet.

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 sekarang disimpan di Google Container Registry dan dapat digunakan kembali kapan pun dan di mana pun Anda mau.

Anda dapat menampilkan daftar 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

Jika perintah docker tidak dapat mengambil image container jarak jauh, coba jalankan ini:

gcloud auth configure-docker

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 Anda karena kode server yang Anda tulis dan nomor port eksternal yang Anda hubungkan saat menguji aplikasi akan sama (8080), tetapi Anda dapat dengan mudah menggunakan opsi -p untuk memetakan port eksternal arbitrer apa pun pada host ke port internal yang diinginkan di dalam container.

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

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

Hasilnya akan terlihat familier - 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.

Sebelum melanjutkan ke bagian berikutnya, di Terminal Cloud Shell, masukkan control-C (tahan tombol kontrol sambil menekan 'C') untuk menghentikan aplikasi yang berjalan.

Selamat! Anda kini telah menjalankan versi dalam container dari aplikasi Anda. Di bagian berikutnya, tanpa menyentuh baris kode, Anda akan mengubah image container menjadi aplikasi web kualitas produksi.

5. Ke Cloud...

Sekarang setelah Anda memasukkan aplikasi ke dalam container, Anda ingin membagikan sedikit kehebatan ini kepada seluruh dunia, jadi saatnya untuk men-deploy-nya ke Cloud. Tetapi Anda benar-benar ingin melakukan lebih dari sekadar membagikannya. Anda ingin memastikannya:

• berjalan dengan andal - Anda mendapatkan fault tolerance otomatis jika komputer yang menjalankan aplikasi Anda error
• melakukan penskalaan secara otomatis - aplikasi Anda akan dapat mengikuti tingkat traffic yang luas, dan otomatis mengurangi jejaknya saat tidak digunakan
• meminimalkan biaya Anda, dengan tidak mengenakan biaya untuk resource yang tidak digunakan - Anda hanya dikenai biaya untuk resource yang dikonsumsi 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 menyesuaikannya dengan menentukan konfigurasi instance minimum
• mendukung enkripsi end-to-end menggunakan keamanan web SSL/TLS standar - saat Anda menerapkan layanan, Anda akan mendapatkan enkripsi web standar, dan sertifikat terkait yang diperlukan, secara gratis dan otomatis

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

Men-deploy Aplikasi ke Cloud Run

Pertama, mari kita modifikasi aplikasi agar Anda dapat membedakan antara revisi baru dengan yang lama. Lakukan dengan memodifikasi 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 baris ini:

def say_hello(name="world"):

menjadi ini:

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

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

Untuk mengetahui daftar region yang saat ini didukung, lihat lokasi Cloud Run (terkelola sepenuhnya).

Bangun ulang image container Anda dan deploy aplikasi dalam container 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 untuk publik. Untuk menghindari permintaan yang tidak diautentikasi, gunakan --no-allow-unauthenticated.

Untuk mempelajari opsi yang tersedia lebih lanjut, masukkan gcloud run deploy --help.

Image yang ditentukan di sini adalah image Docker yang Anda bangun di langkah terakhir. Berkat layanan Cloud Build, yang menyimpan image yang dihasilkan di Google Container Registry, layanan Cloud Run dapat menemukan 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. VM ini tidak menggunakan mekanisme proxy Cloud Shell yang disebutkan sebelumnya, yang bergantung pada virtual machine sementara.

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

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

Tapi kupikir proses ini bisa lebih mudah...

6. Membuat Container Secara Otomatis

Semua ini cukup bagus, tetapi bagaimana jika saya tidak ingin memikirkan Dockerfile dan container. Bagaimana jika, seperti kebanyakan developer, saya hanya ingin fokus pada penulisan kode aplikasi dan membiarkan orang lain mengkhawatirkannya dalam container. Anda beruntung karena Cloud Run mendukung standar open source yang disebut Buildpacks, yang ada karena alasan berikut: mengotomatiskan proses pembuatan container dari sekumpulan file sumber.

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

Pertama, mari kita modifikasi aplikasi agar Anda dapat membedakan antara revisi baru dengan yang lama. Lakukan dengan memodifikasi 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 baris ini:

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

menjadi ini:

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 dan sisipkan satu baris teks ini:

web: python3 main.py

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

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

Ini mirip dengan perintah yang Anda jalankan untuk men-deploy aplikasi di langkah sebelumnya, tetapi kali ini Anda telah mengganti opsi --image dengan opsi --source .. Ini memberi tahu perintah gcloud bahwa Anda ingin menggunakan buildpack untuk membuat image container, berdasarkan file sumber yang ditemukannya dalam direktori saat ini (dot di --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, pastikan deployment ini berhasil 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 memproduksi Dockerfile, Anda pada dasarnya telah mengurangi tiga langkah mudah menjadi dua:

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

7. Apakah Saya Harus Menggunakan Command Line?

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

• Alat command line gcloud, yang baru saja Anda lihat.
• Antarmuka pengguna web yang lengkap, 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 Anda, seperti ini:

Klik "Create Service" untuk memulai proses deployment:

Masukkan "halo-lagi" sebagai nama layanan, gunakan platform dan region deployment default, lalu klik "Next".

Masukkan URL ini untuk image penampung: gcr.io/cloudrun/hello, yang merupakan penampung yang dibuat oleh Google untuk tujuan pengujian, lalu klik "Setelan Lanjutan" untuk melihat beberapa dari berbagai setelan konfigurasi yang tersedia bagi Anda. Untuk menunjukkan beberapa hal yang dapat Anda sesuaikan:

• nomor port dan titik entri container (yang akan menggantikan titik entri yang ditentukan saat mem-build container)
• perangkat keras: memori dan jumlah CPU
• penskalaan: instance minimum dan maksimum
• variabel lingkungan
• lainnya: setelan waktu tunggu permintaan, jumlah permintaan maks per penampung, HTTP/2

Klik tombol "Berikutnya" untuk melanjutkan dialog. Dialog berikutnya memungkinkan Anda menentukan cara layanan dipicu. Untuk "Ingress", pilih "allow all traffic", dan untuk "Authentication", pilih "Allow unauthenticated traffic".

Setelan ini merupakan setelan yang paling liberal, karena mengizinkan siapa saja mengakses aplikasi Cloud Run Anda, dari mana saja di internet publik, tanpa menentukan kredensial autentikasi. Anda mungkin ingin setelan yang lebih ketat untuk aplikasi, tetapi jangan membuatnya sederhana untuk latihan pembelajaran ini.

Sekarang klik tombol Create untuk membuat layanan Cloud Run Anda. Setelah beberapa detik, Anda akan melihat layanan baru muncul di 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 perincian 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 sesuatu seperti ini:

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

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

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

Pada dialog yang muncul, temukan aplikasi web sederhana yang Anda deploy dari Cloud Build menggunakan Buildpacks sebelumnya, lalu klik select. 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 untuk aplikasi. Untuk memverifikasi, kunjungi kembali URL layanan Anda dan pastikan sekarang Anda melihat tulisan "Hello from Cloud Run with Buildpacks!" yang berwarna-warni. aplikasi web Anda.

Seperti yang dapat Anda lihat, tab revisi memberikan ringkasan setiap revisi yang telah di-deploy, dan kini Anda akan melihat dua revisi untuk layanan ini. Anda dapat memilih revisi yang diberikan dengan mengklik tombol pilihan di sebelah kiri nama revisi, yang akan menampilkan ringkasan detail revisi di sisi kanan layar. Dengan memilih tombol-tombol tersebut, Anda dapat melihat bahwa kedua revisi berasal dari dua gambar container 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 ini memungkinkan beberapa kasus penggunaan yang berharga:

• canary menguji 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:

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

Sekarang klik tombol SAVE dan verifikasi pemisahan 50/50 dengan mengunjungi URL layanan Anda berulang kali dan pastikan bahwa, rata-rata, separuh permintaan Anda dilayani oleh revisi saat ini ("Hello from Cloud Run with Buildpacks!") dan separuhnya dilayani oleh revisi sebelumnya ("Sudah berjalan!").

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

Antarmuka Terprogram

Seperti yang telah 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 sudah pasti merupakan cara 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 bagaimana skalanya terhadap permintaan yang masuk. Anda akan menggunakan alat bernama hey yang sudah terinstal di Cloud Shell dan memberi kita kemampuan untuk menjalankan uji beban dan menyajikan hasilnya.

Menjalankan Pengujian

Di Terminal Cloud Shell, 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 - mencoba mendorong beban dengan sekitar 1.000 permintaan per detik
• -c 200 - alokasikan 200 pekerja paralel
• -z 30s - menjalankan uji beban selama 30 detik
• pastikan untuk menggunakan URL layanan sebagai argumen terakhir dalam 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 memberitahukan beberapa item yang menarik:

• 32.918 permintaan dikirim dengan kecepatan sekitar 1 ribu/per detik selama 30-an.
• Tidak ada error (hanya 200 respons HTTP).
• 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 memeriksa tab METRICS di konsol Cloud Run, Anda dapat melihat sisi server dari kisah performa:

9. Membersihkan

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

Anda dapat menghapus project GCP Anda untuk menghindari timbulnya biaya, yang akan menghentikan penagihan untuk semua resource yang digunakan dalam project tersebut, atau cukup hapus image container Anda menggunakan perintah ini:

gcloud container images delete $TAG

Untuk menghapus layanan Cloud Run Anda, 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. Dalam prosesnya, Anda telah mempelajari container dan cara membangun container Anda sendiri. Dan Anda melihat betapa mudahnya men-deploy aplikasi dengan Cloud Run, menggunakan alat command line gcloud dan Konsol Cloud. Kini Anda tahu cara membagikan kreasi brilian Anda ke seluruh dunia.

Saya ingin memberi Anda satu pertanyaan penting:

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

Jawabannya, tentu saja, adalah nol. :)

Untuk memulai Cloud Run, ada banyak bahasa lain yang didokumentasikan. Anda dapat menemukan petunjuk untuk skrip Go, Node.js, Java, C#, PHP, Ruby, Shell, dan lainnya di sini: https://cloud.google.com/run/docs/quickstarts/build-and-deploy

Codelab untuk dilihat...

• Membangun Bot Slack dengan Node.js di Cloud Run
• Memicu Cloud Run dengan peristiwa dari Eventarc
• Codelab Cloud Run for Anthos
• Men-deploy dan menjalankan container dengan Cloud Run di Node.js
• Codelab Cloud Run Lainnya

Fitur keren lainnya untuk dipelajari...

• Deployment berkelanjutan dari Git menggunakan Cloud Build
• Menggunakan secret dari Secret Manager
• Memperkenalkan streaming dua arah WebSockets, HTTP/2, dan gRPC untuk Cloud Run
• Instance min Cloud Run: Meminimalkan cold start serverless
• Melayani traffic dari beberapa region

Dokumen referensi ...

• Mengembangkan layanan Cloud Run
• Mem-build Container
• Dokumen Cloud Run
• FAQ Cloud Run Tidak resmi
• Harga Cloud Run

11. Pesan Ajakan

Jika Anda menikmati codelab ini dan kemungkinan akan menghabiskan lebih banyak waktu langsung dengan Google Cloud, Anda harus Bergabung dengan Google Cloud Innovators sekarang juga.

Google Cloud Innovators Gratis dan mencakup:

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

Klik di sini untuk mendaftar!