Autenticazione service-to-service

Se la tua architettura utilizza più servizi, è probabile che questi servizi debbano comunicare tra loro, utilizzando mezzi asincroni o sincroni. Molti di questi servizi potrebbero essere privati e quindi richiedere credenziali per l'accesso.

Per la comunicazione asincrona, puoi utilizzare i seguenti Google Cloud servizi:

  • Cloud Tasks per la comunicazione asincrona uno a uno
  • Pub/Sub per la comunicazione asincrona uno a molti, uno a uno e molti a uno
  • Cloud Scheduler per la comunicazione asincrona pianificata regolarmente
  • Eventarc per la comunicazione basata su eventi

In tutti questi casi, il servizio utilizzato gestisce l'interazione con il servizio ricevente, in base alla configurazione impostata.

Tuttavia, per la comunicazione sincrona, il servizio chiama direttamente un altro servizio tramite HTTP, utilizzando l'URL dell'endpoint. Per questo caso d'uso, devi assicurarti che ogni servizio sia in grado di effettuare richieste solo a servizi specifici. Ad esempio, se hai un servizio login, questo deve essere in grado di accedere al servizio user-profiles, ma non al servizio search.

In questa situazione, Google consiglia di utilizzare IAM e un'identità di servizio basata su un service account gestito dall'utente per ogni servizio a cui è stato concesso il set minimo di autorizzazioni necessarie per svolgere il proprio lavoro.

Inoltre, la richiesta deve presentare una prova dell'identità del servizio chiamante. Per farlo, configura il servizio chiamante in modo che aggiunga un token ID OpenID Connect firmato da Google come parte della richiesta.

Configurare il account di servizio

Per configurare un account di servizio, configura il servizio ricevente in modo che accetti le richieste del servizio chiamante rendendo il account di servizio del servizio chiamante un' entità sul servizio ricevente. Poi concedi a questo account di servizio il ruolo Cloud Run Invoker (roles/run.invoker). Per eseguire entrambe queste attività, segui le istruzioni nella scheda appropriata:

Interfaccia utente della console

  1. Vai alla Google Cloud console:

    Vai alla Google Cloud console

  2. Seleziona il servizio ricevente.

  3. Fai clic su Mostra riquadro Informazioni nell'angolo in alto a destra per visualizzare la scheda Autorizzazioni.

  4. Fai clic su Aggiungi entità.

    1. Inserisci l'identità del servizio chiamante. In genere si tratta di un indirizzo email, per impostazione predefinita PROJECT_NUMBER-compute@developer.gserviceaccount.com.

    2. Seleziona il ruolo Cloud Run Invoker dal menu a discesa Seleziona un ruolo.

    3. Fai clic su Salva.

gcloud

Utilizza il comando gcloud run services add-iam-policy-binding:

gcloud run services add-iam-policy-binding RECEIVING_SERVICE \
  --member='serviceAccount:CALLING_SERVICE_IDENTITY' \
  --role='roles/run.invoker'

dove RECEIVING_SERVICE è il nome del servizio ricevente e CALLING_SERVICE_IDENTITY è l'indirizzo email del account di servizio, per impostazione predefinita PROJECT_NUMBER-compute@developer.gserviceaccount.com.

Terraform

Per scoprire come applicare o rimuovere una configurazione Terraform, consulta Comandi Terraform di base.

Aggiungi quanto segue a una google_cloud_run_v2_service risorsa nella configurazione Terraform:

resource "google_cloud_run_v2_service" "public" {
  name     = "public-service"
  location = "us-central1"

  deletion_protection = false # set to "true" in production

  template {
    containers {
      # TODO<developer>: replace this with a public service container
      # (This service can be invoked by anyone on the internet)
      image = "us-docker.pkg.dev/cloudrun/container/hello"

      # Include a reference to the private Cloud Run
      # service's URL as an environment variable.
      env {
        name  = "URL"
        value = google_cloud_run_v2_service.private.uri
      }
    }
    # Give the "public" Cloud Run service
    # a service account's identity
    service_account = google_service_account.default.email
  }
}

Sostituisci us-docker.pkg.dev/cloudrun/container/hello con un riferimento all'immagine container.

Il seguente codice Terraform rende pubblico il servizio iniziale.

data "google_iam_policy" "public" {
  binding {
    role = "roles/run.invoker"
    members = [
      "allUsers",
    ]
  }
}

resource "google_cloud_run_service_iam_policy" "public" {
  location = google_cloud_run_v2_service.public.location
  project  = google_cloud_run_v2_service.public.project
  service  = google_cloud_run_v2_service.public.name

  policy_data = data.google_iam_policy.public.policy_data
}

Il seguente codice Terraform crea un secondo servizio Cloud Run destinato a essere privato.

resource "google_cloud_run_v2_service" "private" {
  name     = "private-service"
  location = "us-central1"

  deletion_protection = false # set to "true" in production

  template {
    containers {
      // TODO<developer>: replace this with a private service container
      // (This service should only be invocable by the public service)
      image = "us-docker.pkg.dev/cloudrun/container/hello"
    }
  }
}

Sostituisci us-docker.pkg.dev/cloudrun/container/hello con un riferimento all'immagine container.

Il seguente codice Terraform rende privato il secondo servizio.

data "google_iam_policy" "private" {
  binding {
    role = "roles/run.invoker"
    members = [
      "serviceAccount:${google_service_account.default.email}",
    ]
  }
}

resource "google_cloud_run_service_iam_policy" "private" {
  location = google_cloud_run_v2_service.private.location
  project  = google_cloud_run_v2_service.private.project
  service  = google_cloud_run_v2_service.private.name

  policy_data = data.google_iam_policy.private.policy_data
}

Il seguente codice Terraform crea un account di servizio.

resource "google_service_account" "default" {
  account_id   = "cloud-run-interservice-id"
  description  = "Identity used by a public Cloud Run service to call private Cloud Run services."
  display_name = "cloud-run-interservice-id"
}

Il seguente codice Terraform consente ai servizi collegati al account di servizio di richiamare il servizio Cloud Run privato iniziale.

data "google_iam_policy" "private" {
  binding {
    role = "roles/run.invoker"
    members = [
      "serviceAccount:${google_service_account.default.email}",
    ]
  }
}

resource "google_cloud_run_service_iam_policy" "private" {
  location = google_cloud_run_v2_service.private.location
  project  = google_cloud_run_v2_service.private.project
  service  = google_cloud_run_v2_service.private.name

  policy_data = data.google_iam_policy.private.policy_data
}

Acquisire e configurare il token ID

Dopo aver concesso il ruolo appropriato al account di servizio chiamante, segui questi passaggi:

  1. Recupera un token ID firmato da Google utilizzando uno dei metodi descritti nella sezione seguente. Imposta l'attestazione del pubblico (aud) sull'URL del servizio ricevente o su un segmento di pubblico personalizzato configurato. Se non utilizzi un segmento di pubblico personalizzato, il valore aud deve rimanere l' URL del servizio, anche quando effettui richieste a un tag di traffico specifico.

    .

  2. Aggiungi il token ID recuperato nel passaggio precedente a una delle seguenti intestazioni nella richiesta al servizio ricevente:

    • Un'intestazione Authorization: Bearer ID_TOKEN.
    • Un'intestazione X-Serverless-Authorization: Bearer ID_TOKEN. Puoi utilizzare questa intestazione se la tua applicazione utilizza già l'intestazione Authorization per l'autorizzazione personalizzata. In questo modo, la firma viene rimossa prima di passare il token al container utente.

Per altri modi per ottenere un token ID non descritti in questa pagina, consulta Metodi per ottenere un token ID.

Utilizzare le librerie di autenticazione

Un modo per acquisire e configurare il processo del token ID è utilizzare le librerie di autenticazione. Questo codice funziona in qualsiasi ambiente, anche al di fuori di Google Cloud, in cui le librerie possono ottenere le credenziali di autenticazione per un service account. Per utilizzare questo metodo, scarica un file della chiave del service account e imposta la variabile di ambiente GOOGLE_APPLICATION_CREDENTIALS sul percorso del file della chiave del account di servizio. Per saperne di più, consulta la sezione Chiave del service account.

Questo codice non accetta le credenziali di autenticazione per un account utente.

Node.js 

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// Example: https://my-cloud-run-service.run.app/books/delete/12345
// const url = 'https://TARGET_HOSTNAME/TARGET_URL';

// Example (Cloud Run): https://my-cloud-run-service.run.app/
// const targetAudience = 'https://TARGET_AUDIENCE/';

const {GoogleAuth} = require('google-auth-library');
const auth = new GoogleAuth();

async function request() {
  console.info(`request ${url} with target audience ${targetAudience}`);
  const client = await auth.getIdTokenClient(targetAudience);

  // Alternatively, one can use `client.idTokenProvider.fetchIdToken`
  // to return the ID Token.
  const res = await client.fetch(url);
  console.info(res.data);
}

request().catch(err => {
  console.error(err.message);
  process.exitCode = 1;
});

Python 

import urllib

import google.auth.transport.requests
import google.oauth2.id_token


def make_authorized_get_request(endpoint, audience):
    """
    make_authorized_get_request makes a GET request to the specified HTTP endpoint
    by authenticating with the ID token obtained from the google-auth client library
    using the specified audience value.
    """

    # Cloud Run uses your service's hostname as the `audience` value
    # audience = 'https://my-cloud-run-service.run.app/'
    # For Cloud Run, `endpoint` is the URL (hostname + path) receiving the request
    # endpoint = 'https://my-cloud-run-service.run.app/my/awesome/url'

    req = urllib.request.Request(endpoint)

    auth_req = google.auth.transport.requests.Request()
    id_token = google.oauth2.id_token.fetch_id_token(auth_req, audience)

    req.add_header("Authorization", f"Bearer {id_token}")
    response = urllib.request.urlopen(req)

    return response.read()

Go 


import (
	"context"
	"fmt"
	"io"

	"google.golang.org/api/idtoken"
)

// `makeGetRequest` makes a request to the provided `targetURL`
// with an authenticated client using audience `audience`.
func makeGetRequest(w io.Writer, targetURL string, audience string) error {
	// Example `audience` value (Cloud Run): https://my-cloud-run-service.run.app/
	// (`targetURL` and `audience` will differ for non-root URLs and GET parameters)
	ctx := context.Background()

	// client is a http.Client that automatically adds an "Authorization" header
	// to any requests made.
	client, err := idtoken.NewClient(ctx, audience)
	if err != nil {
		return fmt.Errorf("idtoken.NewClient: %w", err)
	}

	resp, err := client.Get(targetURL)
	if err != nil {
		return fmt.Errorf("client.Get: %w", err)
	}
	defer resp.Body.Close()
	if _, err := io.Copy(w, resp.Body); err != nil {
		return fmt.Errorf("io.Copy: %w", err)
	}

	return nil
}

Java 

import com.google.api.client.http.GenericUrl;
import com.google.api.client.http.HttpRequest;
import com.google.api.client.http.HttpResponse;
import com.google.api.client.http.HttpTransport;
import com.google.api.client.http.javanet.NetHttpTransport;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import com.google.auth.oauth2.IdTokenCredentials;
import com.google.auth.oauth2.IdTokenProvider;
import java.io.IOException;

public class Authentication {

  // makeGetRequest makes a GET request to the specified Cloud Run or
  // Cloud Functions endpoint `serviceUrl` (must be a complete URL), by
  // authenticating with an ID token retrieved from Application Default
  // Credentials using the specified `audience`.
  //
  // Example `audience` value (Cloud Run): https://my-cloud-run-service.run.app/
  public static HttpResponse makeGetRequest(String serviceUrl, String audience) throws IOException {
    GoogleCredentials credentials = GoogleCredentials.getApplicationDefault();
    if (!(credentials instanceof IdTokenProvider)) {
      throw new IllegalArgumentException("Credentials are not an instance of IdTokenProvider.");
    }
    IdTokenCredentials tokenCredential =
        IdTokenCredentials.newBuilder()
            .setIdTokenProvider((IdTokenProvider) credentials)
            .setTargetAudience(audience)
            .build();

    GenericUrl genericUrl = new GenericUrl(serviceUrl);
    HttpCredentialsAdapter adapter = new HttpCredentialsAdapter(tokenCredential);
    HttpTransport transport = new NetHttpTransport();
    HttpRequest request = transport.createRequestFactory(adapter).buildGetRequest(genericUrl);
    return request.execute();
  }
}

Utilizzare il server di metadati

Se per qualche motivo non puoi utilizzare le librerie di autenticazione, puoi recuperare un token ID dal server dei metadati Compute mentre il container è in esecuzione su Cloud Run. Tieni presente che questo metodo non funziona al di fuori di Google Cloud, inclusa la macchina locale.

curl "http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/default/identity?audience=[AUDIENCE]" \
     -H "Metadata-Flavor: Google"

Dove AUDIENCE è l'URL del servizio che stai richiamando o un segmento di pubblico personalizzato configurato.

La tabella seguente riassume le parti principali di una richiesta di query dei metadati:

Componenti Descrizione
URL di base

Tutti i valori dei metadati sono definiti come sotto-percorsi sotto il seguente URL di base:

http://metadata.google.internal/computeMetadata/v1
Intestazione della richiesta

La seguente intestazione deve essere presente in ogni richiesta:

Metadata-Flavor: Google

Questa intestazione indica che la richiesta è stata inviata con l'intenzione di recuperare valori dei metadati, piuttosto che involontariamente da un'origine non sicura, e consente al server dei metadati di restituire i dati richiesti. Se non fornisci questa intestazione, il server dei metadati nega la richiesta.

Per una procedura dettagliata end-to-end di un'applicazione che utilizza questa tecnica di autenticazione tra servizi, segui il tutorial Proteggere i servizi Cloud Run.

Utilizzare la federazione delle identità per i carichi di lavoro dall'esterno Google Cloud

Se il tuo ambiente utilizza un provider di identità supportato dalla federazione delle identità per i workload, puoi utilizzare il seguente metodo per eseguire l'autenticazione in modo sicuro al tuo servizio Cloud Run dall'esterno Google Cloud:

  1. Configura il account di servizio come descritto in Configurare il service account in questa pagina.

  2. Configura la federazione delle identità per i workload per il tuo provider di identità come descritto in Configurare la federazione delle identità per i workload.

  3. Segui le istruzioni riportate in Concedere alle identità esterne l'autorizzazione a rappresentare un service account.

  4. Utilizza l'API REST per acquisire un token di breve durata, ma anziché chiamare generateAccessToken per ottenere un token di accesso, chiama generateIdToken per ottenere un token ID.

    Ad esempio, utilizzando cURL:

    ID_TOKEN=$(curl -0 -X POST https://iamcredentials.googleapis.com/v1/projects/-/serviceAccounts/SERVICE_ACCOUNT:generateIdToken \
  -H "Content-Type: text/json; charset=utf-8" \
  -H "Authorization: Bearer $STS_TOKEN" \
  -d @- <<EOF | jq -r .token
  {
      "audience": "SERVICE_URL"
  }
EOF
)
echo $ID_TOKEN

    Dove SERVICE_ACCOUNT è l'indirizzo email del service account configurato per accedere al pool di identità del workload e SERVICE_URL è l'URL del servizio Cloud Run che stai richiamando. Questo valore deve rimanere l'URL del servizio, anche quando effettui richieste a un tag di traffico specifico. $STS_TOKEN è il token del servizio token di sicurezza che hai ricevuto nel passaggio precedente nelle istruzioni relative alla federazione delle identità per i workload.

Puoi includere il token ID del passaggio precedente nella richiesta al servizio utilizzando un'intestazione Authorization: Bearer ID_TOKEN o un'intestazione X-Serverless-Authorization: Bearer ID_TOKEN. Se vengono fornite entrambe le intestazioni, viene controllata solo l'intestazione X-Serverless-Authorization.

Utilizzare una chiave del account di servizio scaricata dall'esterno Google Cloud

Se la federazione delle identità per i workload non è appropriata per il tuo ambiente, puoi utilizzare una chiave account di servizio scaricata per eseguire l'autenticazione dall'esterno di Google Cloud. Aggiorna il codice client in modo che utilizzi le librerie di autenticazione come descritto in precedenza. Per saperne di più, consulta la sezione Chiave del service account.

Puoi acquisire un token ID firmato da Google utilizzando un JWT autofirmato, ma questa operazione è piuttosto complicata e potenzialmente soggetta a errori. I passaggi di base sono i seguenti:

  1. Firma autonomamente un JWT del account di servizio con l'attestazione target_audience impostata sull' URL del servizio ricevente o su un segmento di pubblico personalizzato configurato. Se non utilizzi domini personalizzati, il valore target_audience deve rimanere l' URL del servizio, anche quando effettui richieste a un tag di traffico specifico.

  2. Scambia il JWT autofirmato con un token ID firmato da Google, che deve avere l'attestazione aud impostata sull'URL precedente.

  3. Includi il token ID nella richiesta al servizio utilizzando un'intestazione Authorization: Bearer ID_TOKEN o un'intestazione X-Serverless-Authorization: Bearer ID_TOKEN. Se vengono fornite entrambe le intestazioni, viene controllata solo l'intestazione X-Serverless-Authorization.

Ricevere richieste autenticate

All'interno del servizio privato ricevente, puoi analizzare l'intestazione di autorizzazione per ricevere le informazioni inviate dal token portatore.

Python 

from flask import Request

from google.auth.exceptions import GoogleAuthError
from google.auth.transport import requests
from google.oauth2 import id_token


def receive_request_and_parse_auth_header(request: Request) -> str:
    """Parse the authorization header, validate the Bearer token
    and decode the token to get its information.

    Args:
        request: Flask request object.

    Returns:
        One of the following:
        a) The email from the request's Authorization header.
        b) A welcome message for anonymous users.
        c) An error description.
    """
    auth_header = request.headers.get("Authorization")
    if auth_header:
        # Split the auth type and value from the header.
        auth_type, creds = auth_header.split(" ", 1)

        if auth_type.lower() == "bearer":
            # Find more information about `verify_token` function here:
            # https://google-auth.readthedocs.io/en/master/reference/google.oauth2.id_token.html#google.oauth2.id_token.verify_token
            try:
                decoded_token = id_token.verify_token(creds, requests.Request())
                return f"Hello, {decoded_token['email']}!\n"
            except GoogleAuthError as e:
                return f"Invalid token: {e}\n"
        else:
            return f"Unhandled header format ({auth_type}).\n"

    return "Hello, anonymous user.\n"

Passaggi successivi