Menyederhanakan autentikasi antar-layanan Cloud Run dengan Express Link

1. Ringkasan

Saat Anda membangun microservice atau aplikasi multi-agen di Cloud Run, layanan backend internal tidak boleh terbuka untuk internet publik. Sebagai gantinya, Anda mengonfigurasi setiap layanan backend untuk mewajibkan autentikasi (--no-allow-unauthenticated) dan memberikan peran IAM Cloud Run Invoker (roles/run.invoker) hanya kepada pemanggil yang diizinkan.

Secara tradisional, memanggil layanan Cloud Run yang diautentikasi mengharuskan aplikasi panggilan Anda melakukan injeksi token manual dalam kode. Sebelum mengirim permintaan HTTP, kode Anda akan mengkueri Server Metadata Compute untuk mendapatkan token ID OpenID Connect (OIDC) yang ditandatangani Google. Token tersebut dicakupkan ke URL audiens layanan tujuan, dan kode Anda melampirkannya ke header Authorization: Bearer. Menulis dan memelihara plumbing autentikasi di dalam kode aplikasi menimbulkan hambatan yang tidak perlu:

  • Hal ini menggabungkan logika bisnis Anda dengan library autentikasi Google Cloud, sehingga mengurangi keterbacaan dan portabilitas di berbagai lingkungan.
  • Logika akuisisi token bervariasi di berbagai jenis tujuan dan mode keamanan. Misalnya, Cloud Run memerlukan token ID OIDC, Google API memerlukan token akses OAuth 2.0, dan mTLS memerlukan token terikat.

Cloud Run Express Link (Pratinjau) menghapus injeksi token manual dari kode aplikasi Anda. Anda mengaktifkan Ambient Networking di layanan Cloud Run yang memanggil (sumber) dan membuat resource ExpressLink deklaratif yang mengikat layanan sumber ke layanan tujuan. Proxy sidecar yang dikelola Google mencegat permintaan HTTP teks biasa keluar ke tujuan, memasukkan token identitas layanan pemanggil secara otomatis, dan mengenkripsi koneksi ke tujuan.

Dalam codelab ini, Anda akan membandingkan kedua pendekatan terhadap layanan backend pribadi yang sama:

  1. Deploy layanan tujuan pribadi dan layanan pemanggil (caller-oidc) yang mengambil token ID OIDC dari Server Metadata Compute di Python. Langkah ini mengonfirmasi konektivitas menyeluruh ke backend dan menunjukkan kode autentikasi yang diperlukan tanpa Express Link.
  2. Deploy layanan pemanggil kedua (caller-express-link) dengan menghapus kode pengambilan token metadata, dan hubungkan ke layanan tujuan menggunakan Ambient Networking dan Express Link.
PART 1: WITHOUT EXPRESS LINK (caller-oidc)
+----------------------------------------------+          +-----------------+
| Caller Service (caller-oidc)                 |  HTTPS   | Destination     |
|                                              | + token  | (destination)   |
|  App Container                               | -------> |                 |
|   1. Parse audience URL with urllib.parse    |          | Verifies caller |
|   2. Fetch OIDC ID token via google-auth     |          | has IAM role    |
|   3. Set Authorization: Bearer header        |          | run.invoker     |
+----------------------------------------------+          +-----------------+

PART 2: WITH EXPRESS LINK (caller-express-link)
+----------------------------------------------+          +-----------------+
| Caller Service (caller-express-link)         |  HTTPS   | Destination     |
|  +----------------+      +----------------+  | + token  | (destination)   |
|  | App Container  | HTTP | Ambient        |  | -------> |                 |
|  | requests.get() | ---> | Sidecar Proxy  |  |          | Same service    |
|  | (no auth code) |      | (Express Link) |  |          | as Part 1       |
|  +----------------+      +----------------+  |          | (unchanged)     |
+----------------------------------------------+          +-----------------+

Prasyarat

  • Pemahaman dasar tentang Python dan layanan web HTTP
  • Pemahaman dasar tentang akun layanan IAM Google Cloud dan deployment Cloud Run

Yang akan Anda pelajari

  • Cara men-deploy layanan tujuan Cloud Run pribadi yang menerapkan autentikasi IAM
  • Cara mengautentikasi permintaan antar layanan secara manual di Python menggunakan token ID OIDC google-auth dari server metadata untuk memverifikasi konektivitas dasar
  • Cara menghapus kode pengambilan token manual dan men-deploy layanan pemanggil Cloud Run dengan Ambient Networking diaktifkan
  • Cara membuat Cloud Run Express Link agar layanan pemanggil Anda dapat memanggil layanan tujuan yang diautentikasi tanpa kode autentikasi

Yang akan Anda build

  • destination: Layanan Python Flask pribadi di Cloud Run yang mengekspos endpoint /ping
  • caller-oidc: Layanan Python Flask yang memanggil destination dengan mengambil dan memasukkan token ID OIDC secara manual dalam kode aplikasi
  • caller-express-link: Layanan Python Flask berdampingan tanpa kode injeksi token yang memanggil layanan destination yang sama melalui Express Link

Yang Anda butuhkan

  • Browser web, seperti Chrome
  • Project Google Cloud dengan penagihan yang diaktifkan dan izin untuk membuat akun layanan IAM, layanan Cloud Run, dan resource Network Services

2. Menyiapkan lingkungan Anda

Menyiapkan project Google Cloud

  1. Jika Anda belum memiliki Akun Google, Anda harus membuat Akun Google.
    • Gunakan akun pribadi, bukan akun kantor atau sekolah. Akun kantor dan sekolah mungkin memiliki batasan yang mencegah Anda mengaktifkan API yang diperlukan untuk lab ini.
  2. Login ke Konsol Google Cloud.
  3. Aktifkan penagihan di Konsol Cloud.
    • Menyelesaikan lab ini akan memerlukan biaya kurang dari $1 USD untuk resource Cloud.
    • Anda dapat mengikuti langkah-langkah di akhir lab ini untuk menghapus resource agar tidak dikenai biaya lebih lanjut.
    • Pengguna baru memenuhi syarat untuk mendapatkan Uji Coba Gratis senilai $300 USD.
  4. Buat project baru atau pilih untuk menggunakan kembali project yang sudah ada.
    • Jika Anda melihat error tentang kuota project, gunakan kembali project yang ada atau hapus project yang ada untuk membuat project baru.

Mulai Cloud Shell

Dalam codelab ini, Anda akan menggunakan Cloud Shell, yaitu lingkungan command line berbasis browser yang telah diinstal sebelumnya dengan Google Cloud CLI (gcloud), Python, dan curl.

  1. Di Konsol Google Cloud, klik Activate Cloud Shell di menu navigasi atas. Jika diminta, klik Authorize.
  2. Ekspor project ID dan region deployment Anda, lalu konfigurasi gcloud untuk menggunakan $PROJECT_ID. Ganti YOUR_PROJECT_ID dengan project ID Anda, dan secara opsional ganti us-west1 dengan region Cloud Run lain:
export PROJECT_ID="YOUR_PROJECT_ID"
export REGION="us-west1"
gcloud config set project "$PROJECT_ID"
  1. Ekspor nomor project dan akun Google Cloud aktif Anda, lalu pastikan keempat variabel telah diisi:
export PROJECT_NUMBER=$(gcloud projects describe "$PROJECT_ID" --format="value(projectNumber)")
export ACTIVE_ACCOUNT=$(gcloud config get-value account 2>/dev/null)
echo "PROJECT_ID: $PROJECT_ID | PROJECT_NUMBER: $PROJECT_NUMBER | ACCOUNT: $ACTIVE_ACCOUNT | REGION: $REGION"

Mengupdate gcloud dan mengaktifkan API

  1. Update komponen gcloud agar Anda memiliki perintah beta terbaru untuk Ambient Networking dan Express Link:
gcloud components update --quiet
  1. Aktifkan Google Cloud API yang diperlukan untuk deployment sumber Cloud Run, akun layanan IAM, Ambient Networking, dan Network Services Express Link:
gcloud services enable \
    iam.googleapis.com \
    run.googleapis.com \
    cloudbuild.googleapis.com \
    artifactregistry.googleapis.com \
    networkservices.googleapis.com \
    networksecurity.googleapis.com \
    trafficdirector.googleapis.com \
    cloudtrace.googleapis.com

Buat direktori ruang kerja

Buat direktori kerja untuk menyimpan tiga folder layanan yang akan Anda bangun dalam codelab ini:

mkdir -p ~/express-link-codelab
cd ~/express-link-codelab

3. Men-deploy layanan tujuan pribadi

Pertama, Anda akan men-deploy layanan Cloud Run pribadi bernama destination. Anda akan menggunakan kembali layanan tujuan tunggal ini untuk kedua bagian codelab:

  • Layanan tujuan tidak pernah melakukan injeksi token keluar.
  • Layanan tujuan tidak perlu mengaktifkan Ambient Networking untuk menerima traffic melalui Express Link.
  1. Buat akun layanan IAM khusus untuk layanan tujuan:
gcloud iam service-accounts create destination-identity \
    --display-name="Cloud Run destination service account"
  1. Buat folder destination dan pindah ke folder tersebut:
mkdir -p ~/express-link-codelab/destination
cd ~/express-link-codelab/destination
  1. Jalankan perintah berikut untuk membuat file requirements.txt dengan Flask dan Gunicorn:
cat << 'EOF' > requirements.txt
Flask==3.0.0
gunicorn==21.2.0
EOF
  1. Jalankan perintah berikut untuk membuat file main.py yang mengekspos endpoint /ping yang menampilkan nama layanan Cloud Run dari variabel lingkungan K_SERVICE:
cat << 'EOF' > main.py
import os
from flask import Flask

app = Flask(__name__)

@app.route("/ping")
def ping():
    service_name = os.environ.get("K_SERVICE", "unknown")
    return f"Hello from {service_name}"

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=int(os.environ.get("PORT", 8080)))
EOF
  1. Deploy destination dari sumber dengan --no-allow-unauthenticated agar Cloud Run menolak permintaan yang tidak diautentikasi:
gcloud run deploy destination \
    --source . \
    --region="$REGION" \
    --service-account="destination-identity@${PROJECT_ID}.iam.gserviceaccount.com" \
    --no-allow-unauthenticated
  1. Simpan URL deterministik dan URI resource lengkap layanan tujuan dalam variabel lingkungan:
export DESTINATION_URL="https://destination-${PROJECT_NUMBER}.${REGION}.run.app"
export DESTINATION_URI="//run.googleapis.com/projects/${PROJECT_NUMBER}/locations/${REGION}/services/destination"
echo "DESTINATION_URL: $DESTINATION_URL"
echo "DESTINATION_URI: $DESTINATION_URI"
  1. Berikan peran Cloud Run Invoker (roles/run.invoker) ke akun pengguna Anda di destination agar Anda dapat mengujinya langsung dari Cloud Shell:
gcloud run services add-iam-policy-binding destination \
    --member="user:$ACTIVE_ACCOUNT" \
    --role="roles/run.invoker" \
    --region="$REGION"
  1. Kirim permintaan yang diautentikasi ke /ping menggunakan token identitas Anda sendiri untuk mengonfirmasi bahwa destination sedang berjalan:
TOKEN=$(gcloud auth print-identity-token)
curl -H "Authorization: Bearer $TOKEN" "$DESTINATION_URL/ping"

Anda akan melihat respons berikut:

Hello from destination

4. Memanggil tujuan tanpa Express Link

Sebelum memperkenalkan Express Link, bangun caller-oidc untuk melihat apa yang diperlukan autentikasi layanan ke layanan saat ini dan verifikasi bahwa layanan panggilan dapat menjangkau destination. Untuk memanggil destination dengan aman tanpa Express Link, Anda harus mengonfigurasi dua lapisan:

  • Otorisasi IAM: Berikan peran roles/run.invoker kepada akun layanan caller-oidc di destination.
  • Injeksi token tingkat aplikasi: Tambahkan library google-auth ke caller-oidc dan uraikan URL target untuk mengekstrak audiens OIDC root. Kemudian, ambil token ID yang ditandatangani dari server metadata dan lampirkan Authorization: Bearer ID_TOKEN ke permintaan HTTPS keluar.

Ikuti langkah-langkah berikut untuk mengonfigurasi dan men-deploy caller-oidc:

  1. Buat akun layanan khusus untuk caller-oidc:
gcloud iam service-accounts create caller-oidc-identity \
    --display-name="Cloud Run OIDC caller service account"
  1. Izinkan caller-oidc-identity untuk memanggil destination:
gcloud run services add-iam-policy-binding destination \
    --member="serviceAccount:caller-oidc-identity@${PROJECT_ID}.iam.gserviceaccount.com" \
    --role="roles/run.invoker" \
    --region="$REGION"
  1. Buat direktori caller-oidc bersama dengan destination:
mkdir -p ~/express-link-codelab/caller-oidc
cd ~/express-link-codelab/caller-oidc
  1. Jalankan perintah berikut untuk membuat file requirements.txt. Perhatikan bahwa Anda harus menambahkan google-auth secara khusus untuk menangani pengambilan token di container aplikasi Anda:
cat << 'EOF' > requirements.txt
Flask==3.0.0
google-auth==2.23.0
requests==2.31.0
gunicorn==21.2.0
EOF
  1. Jalankan perintah berikut untuk membuat file main.py dengan injeksi token OIDC manual:
cat << 'EOF' > main.py
import os
from urllib.parse import urlparse
from flask import Flask, request
from google.auth.transport.requests import Request as GoogleAuthRequest
from google.oauth2 import id_token
import requests

app = Flask(__name__)

@app.route("/ping")
def ping():
    service_name = os.environ.get("K_SERVICE", "unknown")
    return f"Hello from {service_name}"

@app.route("/")
def call_destination():
    target_url = request.args.get("target_url")
    if not target_url:
        return "Error: target_url query parameter not set.", 400

    try:
        # 1. Extract the root service URL (scheme + host) for the OIDC audience claim
        parsed_url = urlparse(target_url)
        target_audience = f"{parsed_url.scheme}://{parsed_url.netloc}"

        # 2. Fetch a Google-signed OIDC ID token from the metadata server
        auth_req = GoogleAuthRequest()
        token = id_token.fetch_id_token(auth_req, target_audience)

        # 3. Inject the token as an HTTP Bearer header
        headers = {"Authorization": f"Bearer {token}"}
        response = requests.get(target_url, headers=headers, timeout=10)
        return f"I called the destination and it replied: '{response.text}'"
    except Exception as e:
        return f"Error calling destination: {str(e)}", 500

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=int(os.environ.get("PORT", 8080)))
EOF
  1. Deploy caller-oidc ke Cloud Run:
gcloud run deploy caller-oidc \
    --source . \
    --region="$REGION" \
    --service-account="caller-oidc-identity@${PROJECT_ID}.iam.gserviceaccount.com" \
    --no-allow-unauthenticated
  1. Berikan izin kepada akun pengguna Anda untuk memanggil caller-oidc:
gcloud run services add-iam-policy-binding caller-oidc \
    --member="user:$ACTIVE_ACCOUNT" \
    --role="roles/run.invoker" \
    --region="$REGION"
  1. Simpan URL deterministik caller-oidc dan panggil, dengan meneruskan URL HTTPS $DESTINATION_URL/ping sebagai target_url:
export CALLER_OIDC_URL="https://caller-oidc-${PROJECT_NUMBER}.${REGION}.run.app"
TOKEN=$(gcloud auth print-identity-token)
curl -H "Authorization: Bearer $TOKEN" "$CALLER_OIDC_URL/?target_url=$DESTINATION_URL/ping"

Anda akan menerima balasan yang berhasil dari destination:

I called the destination and it replied: 'Hello from destination'

5. Men-deploy layanan pemanggil untuk Express Link

Sekarang Anda akan membangun layanan pemanggil kedua bernama caller-express-link di direktori yang sama. Dengan Express Link, caller-express-link tidak memerlukan kode injeksi token—fungsi ini langsung memanggil requests.get(target_url, timeout=10).

  1. Buat akun layanan khusus untuk caller-express-link:
gcloud iam service-accounts create caller-express-link-identity \
    --display-name="Cloud Run Express Link caller service account"
  1. Beri caller-express-link-identity peran roles/trafficdirector.client agar sidecar Ambient Networking terkelola dapat mendownload konfigurasi keamanan dan pemilihan rute Express Link. Berikan juga roles/cloudtrace.agent agar sidecar dapat mengekspor span trace:
gcloud projects add-iam-policy-binding "$PROJECT_ID" \
    --member="serviceAccount:caller-express-link-identity@${PROJECT_ID}.iam.gserviceaccount.com" \
    --role="roles/trafficdirector.client"

gcloud projects add-iam-policy-binding "$PROJECT_ID" \
    --member="serviceAccount:caller-express-link-identity@${PROJECT_ID}.iam.gserviceaccount.com" \
    --role="roles/cloudtrace.agent"
  1. Buat direktori caller-express-link bersama dengan caller-oidc:
mkdir -p ~/express-link-codelab/caller-express-link
cd ~/express-link-codelab/caller-express-link
  1. Jalankan perintah berikut untuk membuat file requirements.txt tanpa google-auth:
cat << 'EOF' > requirements.txt
Flask==3.0.0
requests==2.31.0
gunicorn==21.2.0
EOF
  1. Jalankan perintah berikut untuk membuat file main.py dengan panggilan requests.get(target_url, timeout=10) biasa dan tanpa logika injeksi token:
cat << 'EOF' > main.py
import os
from flask import Flask, request
import requests

app = Flask(__name__)

@app.route("/ping")
def ping():
    service_name = os.environ.get("K_SERVICE", "unknown")
    return f"Hello from {service_name}"

@app.route("/")
def call_destination():
    target_url = request.args.get("target_url")
    if not target_url:
        return "Error: target_url query parameter not set.", 400

    try:
        response = requests.get(target_url, timeout=10)
        return f"I called the destination and it replied: '{response.text}'"
    except Exception as e:
        return f"Error calling destination: {str(e)}", 500

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=int(os.environ.get("PORT", 8080)))
EOF
  1. Jalankan diff terhadap ../caller-oidc/main.py untuk melihat boilerplate autentikasi yang Anda hapus:
diff -u ../caller-oidc/main.py main.py || true
  1. Deploy caller-express-link menggunakan gcloud beta run deploy dengan --ambient-networking dan --ambient-scope=global diaktifkan:
gcloud beta run deploy caller-express-link \
    --source . \
    --region="$REGION" \
    --service-account="caller-express-link-identity@${PROJECT_ID}.iam.gserviceaccount.com" \
    --no-allow-unauthenticated \
    --ambient-networking \
    --ambient-scope=global
  1. Pastikan Ambient Networking aktif di caller-express-link:
gcloud run services describe caller-express-link --region="$REGION"

Di akhir ringkasan revisi, pastikan Ambient Networking dan Ambient Scope muncul:

  Ambient Networking: Enabled
  Ambient Scope:     global
  1. Beri izin akun pengguna Anda untuk memanggil caller-express-link, dan beri otorisasi caller-express-link-identity untuk memanggil destination:
gcloud run services add-iam-policy-binding caller-express-link \
    --member="user:$ACTIVE_ACCOUNT" \
    --role="roles/run.invoker" \
    --region="$REGION"

gcloud run services add-iam-policy-binding destination \
    --member="serviceAccount:caller-express-link-identity@${PROJECT_ID}.iam.gserviceaccount.com" \
    --role="roles/run.invoker" \
    --region="$REGION"
  1. Simpan URL dan URI resource caller-express-link, beserta URL deterministik HTTP (http://) dari destination:
export CALLER_EL_URL="https://caller-express-link-${PROJECT_NUMBER}.${REGION}.run.app"
export CALLER_EL_URI="//run.googleapis.com/projects/${PROJECT_NUMBER}/locations/${REGION}/services/caller-express-link"
export DESTINATION_HTTP_URL="http://destination-${PROJECT_NUMBER}.${REGION}.run.app"
echo "CALLER_EL_URL: $CALLER_EL_URL"
echo "CALLER_EL_URI: $CALLER_EL_URI"
echo "DESTINATION_HTTP_URL: $DESTINATION_HTTP_URL"
  1. Uji panggilan destination melalui caller-express-link sebelum membuat Express Link:
TOKEN=$(gcloud auth print-identity-token)
curl -H "Authorization: Bearer $TOKEN" "$CALLER_EL_URL/?target_url=$DESTINATION_HTTP_URL/ping"

Seperti yang diperkirakan, panggilan gagal dengan 403 Forbidden karena belum ada Express Link untuk mengintersepsi permintaan dan memasukkan kredensial:

I called the destination and it replied: '
<html><head>
<meta http-equiv="content-type" content="text/html;charset=utf-8">
<title>403 Forbidden</title>
</head>
<body text=#000000 bgcolor=#ffffff>
<h1>Error: Forbidden</h1>
<h2>Your client does not have permission to get URL <code>/ping</code> from this server.</h2>
<h2></h2>
</body></html>
'

6. Menghubungkan layanan dengan Express Link

Sekarang Anda akan mendeklarasikan resource ExpressLink yang menghubungkan caller-express-link (layanan sumber) ke destination—tanpa mengubah satu baris kode pun atau men-deploy ulang salah satu layanan Cloud Run.

  1. Buat resource Express Link di lokasi global:
gcloud beta network-services express-links create caller-to-destination \
    --location=global \
    --description="Express Link from caller-express-link to destination" \
    --source-services="$CALLER_EL_URI" \
    --destination-services="$DESTINATION_URI"
  1. Cantumkan Express Link Anda untuk mengonfirmasi bahwa resource tersebut ada:
gcloud beta network-services express-links list --location=global

Output perintah:

NAME
caller-to-destination
  1. Periksa detail konfigurasi Express Link:
gcloud beta network-services express-links describe caller-to-destination --location=global

Output perintah:

createTime: '2026-10-27T19:30:04.492105068Z'
description: Express Link from caller-express-link to destination
destination:
  services:
  - //run.googleapis.com/projects/PROJECT_NUMBER/locations/us-west1/services/destination
etag: ...
name: projects/PROJECT_ID/locations/global/expressLinks/caller-to-destination
source:
  services:
  - //run.googleapis.com/projects/PROJECT_NUMBER/locations/us-west1/services/caller-express-link
updateTime: '2026-10-27T19:30:11.309054865Z'
  1. Jalankan kembali permintaan curl yang sama persis terhadap caller-express-link:
TOKEN=$(gcloud auth print-identity-token)
curl -H "Authorization: Bearer $TOKEN" "$CALLER_EL_URL/?target_url=$DESTINATION_HTTP_URL/ping"

Kali ini, sidecar Ambient mencegat permintaan HTTP ke destination, memasukkan token identitas untuk caller-express-link-identity, mengupgrade koneksi ke TLS, dan menampilkan respons tujuan:

I called the destination and it replied: 'Hello from destination'

Tabel berikut merangkum perubahan antara caller-oidc dan caller-express-link:

Dimensi

Tanpa Express Link (caller-oidc)

Dengan Express Link (caller-express-link)

Library Auth di requirements.txt

Memerlukan google-auth

Tidak ada (khusus Flask, requests, gunicorn)

Panggilan keluar di main.py

Mengurai URL audiens, memanggil id_token.fetch_id_token(), melampirkan header Authorization: Bearer

requests.get(target_url, timeout=10) Polos

Skema URL target di aplikasi

https://destination-PROJECT_NUMBER.REGION.run.app

http://destination-PROJECT_NUMBER.REGION.run.app (diupgrade ke TLS oleh sidecar Ambient)

Konfigurasi Cloud Run pemanggil

Deployment standar

--ambient-networking --ambient-scope=global + roles/trafficdirector.client di akun layanan pemanggil

Konfigurasi Cloud Run tujuan

--no-allow-unauthenticated + roles/run.invoker

Tidak berubah (--no-allow-unauthenticated + roles/run.invoker)

7. Pembersihan

Agar tidak menimbulkan biaya berkelanjutan pada akun Google Cloud Anda, hapus resource yang Anda buat selama codelab ini.

  1. Hapus resource Express Link:
gcloud beta network-services express-links delete caller-to-destination --location=global --quiet
  1. Hapus tiga layanan Cloud Run:
gcloud run services delete caller-express-link --region="$REGION" --quiet
gcloud run services delete caller-oidc --region="$REGION" --quiet
gcloud run services delete destination --region="$REGION" --quiet
  1. Hapus binding kebijakan IAM level project dan hapus tiga akun layanan:
gcloud projects remove-iam-policy-binding "$PROJECT_ID" \
    --member="serviceAccount:caller-express-link-identity@${PROJECT_ID}.iam.gserviceaccount.com" \
    --role="roles/trafficdirector.client" \
    --quiet

gcloud projects remove-iam-policy-binding "$PROJECT_ID" \
    --member="serviceAccount:caller-express-link-identity@${PROJECT_ID}.iam.gserviceaccount.com" \
    --role="roles/cloudtrace.agent" \
    --quiet

gcloud iam service-accounts delete "caller-express-link-identity@${PROJECT_ID}.iam.gserviceaccount.com" --quiet
gcloud iam service-accounts delete "caller-oidc-identity@${PROJECT_ID}.iam.gserviceaccount.com" --quiet
gcloud iam service-accounts delete "destination-identity@${PROJECT_ID}.iam.gserviceaccount.com" --quiet
  1. (Opsional) Jika Anda membuat project Google Cloud khusus hanya untuk codelab ini, Anda dapat menghapus seluruh project:
# Run only if you want to delete the entire project and all its resources
gcloud projects delete "$PROJECT_ID"

8. Selamat

Anda telah men-deploy layanan backend Cloud Run pribadi dan memanggilnya menggunakan injeksi token OIDC manual di Python. Kemudian, Anda mengganti semua kode autentikasi tingkat aplikasi dengan Cloud Run Express Link deklaratif.

Yang telah Anda pelajari

  • Alasan injeksi token OIDC manual menggabungkan logika bisnis aplikasi ke library autentikasi dan mode keamanan platform
  • Cara men-deploy layanan tujuan Cloud Run yang diautentikasi dan berfungsi tanpa perubahan, baik dengan maupun tanpa Express Link
  • Cara mengaktifkan Ambient Networking (--ambient-networking dengan --ambient-scope=global) dan memberikan izin klien Traffic Director (roles/trafficdirector.client) pada layanan Cloud Run yang memanggil
  • Cara membuat dan memeriksa resource ExpressLink Network Services yang otomatis memasukkan token identitas dan mengupgrade panggilan http:// teks biasa dari container Anda ke koneksi TLS terenkripsi

Langkah berikutnya