Uproszczenie uwierzytelniania między usługami Cloud Run za pomocą połączenia błyskawicznego

1. Przegląd

Gdy tworzysz mikroserwisy lub aplikacje z wieloma agentami w Cloud Run, wewnętrzne usługi backendu nie powinny być dostępne z internetu publicznego. Zamiast tego skonfiguruj każdą usługę backendu tak, aby wymagała uwierzytelniania (--no-allow-unauthenticated), i przyznaj rolę uprawnień wywołującego Cloud Run (roles/run.invoker) tylko autoryzowanym elementom wywołującym.

Tradycyjnie wywołanie uwierzytelnionej usługi Cloud Run wymaga, aby aplikacja wywołująca wykonała ręczne wstrzykiwanie tokena w kodzie. Przed wysłaniem żądania HTTP kod wysyła do serwera metadanych Compute zapytanie o token identyfikacji OpenID Connect (OIDC) podpisany przez Google. Ten token jest ograniczony do adresu URL odbiorców usługi docelowej, a Twój kod dołącza go do nagłówka Authorization: Bearer. Pisanie i utrzymywanie kodu uwierzytelniania w kodzie aplikacji powoduje niepotrzebne problemy:

  • Łączy logikę biznesową z bibliotekami uwierzytelniania Google Cloud, co zmniejsza czytelność i przenośność między środowiskami.
  • Logika pozyskiwania tokenów różni się w zależności od typu miejsca docelowego i trybu zabezpieczeń. Na przykład Cloud Run oczekuje tokenów identyfikatora OIDC, interfejsy API Google oczekują tokenów dostępu OAuth 2.0, a mTLS wymaga powiązanych tokenów.

Połączenie błyskawiczne Cloud Run (wersja testowa) eliminuje ręczne wstrzykiwanie tokenów z kodu aplikacji. Włączasz sieć środowiskową w wywołującej (źródłowej) usłudze Cloud Run i tworzysz deklaratywny zasób ExpressLink, który wiąże usługę źródłową z usługą docelową. Zarządzane przez Google pomocnicze proxy przechwytuje wychodzące żądania HTTP w postaci zwykłego tekstu do miejsca docelowego, automatycznie wstrzykuje token tożsamości usługi wywołującej i szyfruje połączenie z miejscem docelowym.

W tym ćwiczeniu porównasz oba podejścia do tej samej prywatnej usługi backendu:

  1. Wdróż usługę prywatnego miejsca docelowego i usługę wywołującą (caller-oidc), która pobiera token identyfikatora OIDC z serwera metadanych Compute w Pythonie. Ten krok potwierdza połączenie między punktami końcowymi z backendem i pokazuje kod uwierzytelniający wymagany bez połączenia błyskawicznego.
  2. Wdróż drugą usługę elementu wywołującego (caller-express-link) z usuniętym kodem pobierania tokena metadanych i połącz ją z usługą docelową za pomocą sieci środowiskowej i połączenia błyskawicznego.
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)     |
+----------------------------------------------+          +-----------------+

Wymagania wstępne

  • podstawowa znajomość Pythona i usług internetowych HTTP;
  • podstawowa znajomość kont usługi Google Cloud IAM i wdrożeń Cloud Run.

Czego się nauczysz

  • Jak wdrożyć prywatną usługę docelową Cloud Run, która wymusza uwierzytelnianie IAM
  • Jak ręcznie uwierzytelniać żądania między usługami w Pythonie za pomocą tokenów identyfikatora OIDC google-auth z serwera metadanych, aby zweryfikować podstawowe połączenie.
  • Jak usunąć kod ręcznego pobierania tokenów i wdrożyć usługę wywołującą Cloud Run z włączoną siecią środowiskową
  • Jak utworzyć połączenie błyskawiczne Cloud Run, aby usługa wywołująca mogła wywołać uwierzytelnioną usługę docelową bez kodu uwierzytelniającego

Co utworzysz

  • destination: prywatna usługa Python Flask w Cloud Run, która udostępnia punkt końcowy /ping.
  • caller-oidc: usługa Python Flask, która wywołuje destination przez ręczne pobieranie i wstrzykiwanie tokenów identyfikatora OIDC w kodzie aplikacji.
  • caller-express-link: usługa Python Flask działająca równolegle, bez kodu wstrzykiwania tokenów, która wywołuje tę samą usługę destination za pomocą połączenia błyskawicznego.

Czego potrzebujesz

  • przeglądarkę, np. Chrome;
  • projekt Google Cloud z włączonymi rozliczeniami i uprawnieniami do tworzenia kont usługi uprawnień, usług Cloud Run i zasobów usług sieciowych;

2. Konfigurowanie środowiska

Konfigurowanie projektu Google Cloud

  1. Jeśli nie masz jeszcze konta Google, musisz je utworzyć.
    • Użyj konta osobistego zamiast służbowego lub szkolnego. Konta służbowe i szkolne mogą mieć ograniczenia, które uniemożliwiają włączenie interfejsów API potrzebnych w tym module.
  2. Zaloguj się w konsoli Google Cloud.
  3. Włącz płatności w konsoli Cloud.
  4. Utwórz nowy projekt lub wybierz istniejący projekt.
    • Jeśli pojawi się błąd dotyczący limitu projektów, użyj istniejącego projektu lub usuń istniejący projekt, aby utworzyć nowy.

Uruchamianie Cloud Shell

W tym ćwiczeniu użyjesz Cloud Shell, czyli środowiska wiersza poleceń działającego w przeglądarce, w którym są już zainstalowane Google Cloud CLI (gcloud), Python i curl.

  1. W konsoli Google Cloud kliknij Aktywuj Cloud Shell na górnym pasku nawigacyjnym. Jeśli pojawi się pytanie o autoryzację, kliknij Autoryzuj.
  2. Wyeksportuj identyfikator projektu i region wdrożenia, a następnie skonfiguruj gcloud, aby używać $PROJECT_ID. Zastąp YOUR_PROJECT_ID identyfikatorem projektu i opcjonalnie zastąp us-west1 innym regionem Cloud Run:
export PROJECT_ID="YOUR_PROJECT_ID"
export REGION="us-west1"
gcloud config set project "$PROJECT_ID"
  1. Wyeksportuj numer projektu i aktywne konto Google Cloud, a następnie sprawdź, czy wszystkie 4 zmienne są wypełnione:
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"

Aktualizowanie gcloud i włączanie interfejsów API

  1. Zaktualizuj komponenty gcloud, aby mieć najnowsze polecenia beta dotyczące sieci środowiskowej i połączenia błyskawicznego:
gcloud components update --quiet
  1. Włącz wymagane interfejsy Google Cloud API na potrzeby wdrożeń źródłowych Cloud Run, kont usługi uprawnień, sieci środowiskowej i połączenia błyskawicznego usług sieciowych:
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

Tworzenie katalogu obszaru roboczego

Utwórz katalog roboczy, w którym będą przechowywane 3 foldery usług utworzone w tym ćwiczeniu:

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

3. Wdrażanie usługi prywatnego miejsca docelowego

Najpierw wdrożysz prywatną usługę Cloud Run o nazwie destination. Tę pojedynczą usługę docelową wykorzystasz w obu częściach ćwiczenia:

  • Usługa docelowa nigdy nie wykonuje wstrzykiwania tokena wychodzącego.
  • Usługa docelowa nie musi mieć włączonej sieci środowiskowej, aby otrzymywać ruch przez połączenie błyskawiczne.
  1. Utwórz dedykowane konto usługi uprawnień dla usługi docelowej:
gcloud iam service-accounts create destination-identity \
    --display-name="Cloud Run destination service account"
  1. Utwórz folder destination i przejdź do niego:
mkdir -p ~/express-link-codelab/destination
cd ~/express-link-codelab/destination
  1. Uruchom to polecenie, aby utworzyć plik requirements.txt z Flask i Gunicorn:
cat << 'EOF' > requirements.txt
Flask==3.0.0
gunicorn==21.2.0
EOF
  1. Uruchom to polecenie, aby utworzyć plik main.py, który udostępnia punkt końcowy /ping zwracający nazwę usługi Cloud Run ze zmiennej środowiskowej 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. Wdróż destination ze źródła za pomocą --no-allow-unauthenticated, aby Cloud Run odrzucał nieuwierzytelnione żądania:
gcloud run deploy destination \
    --source . \
    --region="$REGION" \
    --service-account="destination-identity@${PROJECT_ID}.iam.gserviceaccount.com" \
    --no-allow-unauthenticated
  1. Zapisz deterministyczny adres URL usługi docelowej i pełny identyfikator URI zasobu w zmiennych środowiskowych:
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. Przypisz do swojego konta użytkownika rolę wywołującego Cloud Run (roles/run.invoker) w usłudze destination, aby móc przetestować ją bezpośrednio z Cloud Shell:
gcloud run services add-iam-policy-binding destination \
    --member="user:$ACTIVE_ACCOUNT" \
    --role="roles/run.invoker" \
    --region="$REGION"
  1. Wyślij uwierzytelnione żądanie do /ping, używając własnego tokena tożsamości, aby potwierdzić, że usługa destination działa:
TOKEN=$(gcloud auth print-identity-token)
curl -H "Authorization: Bearer $TOKEN" "$DESTINATION_URL/ping"

Powinna pojawić się taka odpowiedź:

Hello from destination

4. Wywołaj miejsce docelowe bez połączenia błyskawicznego

Zanim wprowadzimy połączenie błyskawiczne, utwórz caller-oidc, aby zobaczyć, czego wymaga obecnie uwierzytelnianie między usługami, i sprawdzić, czy usługa wywołująca może połączyć się z destination. Aby bezpiecznie wywołać destination bez połączenia błyskawicznego, musisz skonfigurować 2 warstwy:

  • Autoryzacja uprawnień: przypisz do konta usługi caller-oidc rolę roles/run.invoker w destination.
  • Wstrzykiwanie tokena na poziomie aplikacji: dodaj bibliotekę google-auth do caller-oidc i przeanalizuj docelowy adres URL, aby wyodrębnić główną grupę odbiorców OIDC. Następnie pobierz podpisany token identyfikacji z serwera metadanych i dołącz go Authorization: Bearer ID_TOKEN do wychodzącego żądania HTTPS.

Aby skonfigurować i wdrożyć caller-oidc, wykonaj te czynności:

  1. Utwórz dedykowane konto usługi dla caller-oidc:
gcloud iam service-accounts create caller-oidc-identity \
    --display-name="Cloud Run OIDC caller service account"
  1. Autoryzuj caller-oidc-identity, aby wywołać 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. Utwórz katalog caller-oidc obok katalogu destination:
mkdir -p ~/express-link-codelab/caller-oidc
cd ~/express-link-codelab/caller-oidc
  1. Uruchom to polecenie, aby utworzyć plik requirements.txt. Zwróć uwagę, że musisz dodać google-auth, aby obsłużyć pobieranie tokena w kontenerze aplikacji:
cat << 'EOF' > requirements.txt
Flask==3.0.0
google-auth==2.23.0
requests==2.31.0
gunicorn==21.2.0
EOF
  1. Uruchom to polecenie, aby utworzyć plik main.py z ręcznym wstrzykiwaniem tokena OIDC:
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. Wdróż caller-oidc w Cloud Run:
gcloud run deploy caller-oidc \
    --source . \
    --region="$REGION" \
    --service-account="caller-oidc-identity@${PROJECT_ID}.iam.gserviceaccount.com" \
    --no-allow-unauthenticated
  1. Przyznaj swojemu kontu użytkownika uprawnienia do wywoływania caller-oidc:
gcloud run services add-iam-policy-binding caller-oidc \
    --member="user:$ACTIVE_ACCOUNT" \
    --role="roles/run.invoker" \
    --region="$REGION"
  1. Zapisz deterministyczny adres URL caller-oidc i wywołaj go, przekazując adres URL HTTPS $DESTINATION_URL/ping jako 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"

Powinna pojawić się odpowiedź od destination:

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

5. Wdrażanie usługi wywołującej na potrzeby połączenia błyskawicznego

Teraz utworzysz drugą usługę wywołującą o nazwie caller-express-link w katalogu nadrzędnym. Dzięki połączeniu błyskawicznemu usługa caller-express-link nie potrzebuje żadnego kodu wstrzykiwania tokenów – wywołuje usługę requests.get(target_url, timeout=10) bezpośrednio.

  1. Utwórz dedykowane konto usługi dla caller-express-link:
gcloud iam service-accounts create caller-express-link-identity \
    --display-name="Cloud Run Express Link caller service account"
  1. Przyznaj użytkownikowi caller-express-link-identity rolę roles/trafficdirector.client, aby zarządzany kontener pomocniczy sieci środowiskowej mógł pobrać konfigurację routingu i zabezpieczeń połączenia błyskawicznego. Przyznaj też uprawnienie roles/cloudtrace.agent, aby usługa pomocnicza mogła eksportować zakresy logów czasu:
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. Utwórz katalog caller-express-link obok katalogu caller-oidc:
mkdir -p ~/express-link-codelab/caller-express-link
cd ~/express-link-codelab/caller-express-link
  1. Uruchom to polecenie, aby utworzyć plik requirements.txt bez google-auth:
cat << 'EOF' > requirements.txt
Flask==3.0.0
requests==2.31.0
gunicorn==21.2.0
EOF
  1. Uruchom to polecenie, aby utworzyć plik main.py z prostym wywołaniem requests.get(target_url, timeout=10) i bez logiki wstrzykiwania tokena:
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. Uruchom diff na ../caller-oidc/main.py, aby zobaczyć wyeliminowany szablon uwierzytelniania:
diff -u ../caller-oidc/main.py main.py || true
  1. Wdróż caller-express-link za pomocą gcloud beta run deploy z włączonymi --ambient-networking i --ambient-scope=global:
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. Sprawdź, czy sieć środowiskowa jest aktywna na urządzeniu caller-express-link:
gcloud run services describe caller-express-link --region="$REGION"

Na końcu podsumowania wersji sprawdź, czy wyświetlają się te informacje: Ambient Networking i Ambient Scope:

  Ambient Networking: Enabled
  Ambient Scope:     global
  1. Przyznaj swojemu kontu użytkownika uprawnienia do wywoływania caller-express-link i autoryzuj caller-express-link-identity do wywoływania 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. Zapisz adres URL i identyfikator URI zasobu caller-express-link oraz deterministyczny adres URL HTTP (http://) zasobu 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. Przed utworzeniem połączenia błyskawicznego przetestuj wywoływanie destination przez caller-express-link:
TOKEN=$(gcloud auth print-identity-token)
curl -H "Authorization: Bearer $TOKEN" "$CALLER_EL_URL/?target_url=$DESTINATION_HTTP_URL/ping"

Zgodnie z oczekiwaniami wywołanie nie powiedzie się i pojawi się błąd 403 Forbidden, ponieważ nie ma jeszcze połączenia błyskawicznego, które mogłoby przechwycić żądanie i wstrzyknąć dane logowania:

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. Łączenie usług za pomocą połączenia błyskawicznego

Teraz zadeklarujesz zasób ExpressLink łączący caller-express-link (usługę źródłową) z destination – bez zmiany ani jednej linii kodu i bez ponownego wdrażania żadnej z usług Cloud Run.

  1. Utwórz zasób połączenia błyskawicznego w lokalizacji 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. Wyświetl listę połączeń błyskawicznych, aby potwierdzić, że zasób istnieje:
gcloud beta network-services express-links list --location=global

Wynik polecenia:

NAME
caller-to-destination
  1. Sprawdź szczegóły konfiguracji połączenia błyskawicznego:
gcloud beta network-services express-links describe caller-to-destination --location=global

Wynik polecenia:

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. Ponownie wyślij dokładnie to samo żądanie curl do caller-express-link:
TOKEN=$(gcloud auth print-identity-token)
curl -H "Authorization: Bearer $TOKEN" "$CALLER_EL_URL/?target_url=$DESTINATION_HTTP_URL/ping"

Tym razem usługa pomocnicza Ambient przechwytuje żądanie HTTP do destination, wstrzykuje token tożsamości dla caller-express-link-identity, uaktualnia połączenie do TLS i zwraca odpowiedź miejsca docelowego:

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

W tej tabeli podsumowano zmiany między caller-oidc a caller-express-link:

Wymiar

Bez połączenia błyskawicznego (caller-oidc)

Z połączeniem błyskawicznym (caller-express-link)

Biblioteki uwierzytelniania w requirements.txt

Wymagana kolumna google-auth

Brak (tylko Flask, requests, gunicorn)

Połączenie wychodzące w main.py

Przeanalizuj adres URL odbiorców, wywołaj id_token.fetch_id_token(), dołącz nagłówek Authorization: Bearer

Zwykły requests.get(target_url, timeout=10)

Schemat URI adresu URL w aplikacji

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

http://destination-PROJECT_NUMBER.REGION.run.app (uaktualniono do TLS przez proxy pomocnicze Ambient)

Konfiguracja Cloud Run elementu wywołującego

Wdrożenie standardowe

--ambient-networking --ambient-scope=global + roles/trafficdirector.client na koncie usługi wywołującej

Konfiguracja docelowej usługi Cloud Run

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

Bez zmian (--no-allow-unauthenticated + roles/run.invoker)

7. Czyszczenie danych

Aby uniknąć obciążenia konta Google Cloud bieżącymi opłatami, usuń zasoby utworzone podczas tego ćwiczenia.

  1. Usuń zasób połączenia błyskawicznego:
gcloud beta network-services express-links delete caller-to-destination --location=global --quiet
  1. Usuń 3 usługi 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. Usuń powiązania zasad uprawnień na poziomie projektu i 3 konta usługi:
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. (Opcjonalnie) Jeśli utworzono dedykowany projekt w chmurze Google Cloud ściśle na potrzeby tego ćwiczenia, możesz usunąć cały projekt:
# Run only if you want to delete the entire project and all its resources
gcloud projects delete "$PROJECT_ID"

8. Gratulacje

Wdrożono prywatną usługę backendu Cloud Run i wywołano ją za pomocą ręcznego wstrzykiwania tokena OIDC w Pythonie. Następnie zastąpiono cały kod uwierzytelniania na poziomie aplikacji deklaratywnym połączeniem błyskawicznym Cloud Run.

Czego się nauczyliśmy

  • Dlaczego ręczne wstrzykiwanie tokena OIDC łączy logikę biznesową aplikacji z bibliotekami uwierzytelniania platformy i trybami zabezpieczeń.
  • Jak wdrożyć uwierzytelnioną usługę docelową Cloud Run, która działa bez zmian z połączeniem błyskawicznym lub bez niego
  • Jak włączyć sieć środowiskową (--ambient-networking z --ambient-scope=global) i przyznać uprawnienia klienta Traffic Director (roles/trafficdirector.client) w wywołującej usłudze Cloud Run
  • Jak utworzyć i sprawdzić zasób ExpressLink usług sieciowych, który automatycznie wstrzykuje tokeny tożsamości i uaktualnia wywołania http:// w postaci zwykłego tekstu z kontenera do zaszyfrowanych połączeń TLS

Dalsze kroki