Tutorial sui servizi Cloud Run sicuri

Cloud Run ti consente di proteggere i workload interni esponendo al contempo le funzionalità rivolte ai client in un'architettura multi-servizio. In questo tutorial creerai un'applicazione sicura a due servizi con un editor Markdown di frontend pubblico e un servizio di backend privato che esegue il rendering del testo Markdown in HTML.

Diagramma che mostra il flusso di richieste dal frontend "editor" al backend "renderer".
Il backend "Renderer" è un servizio privato. In questo modo è possibile garantire uno standard di trasformazione del testo in un'organizzazione senza monitorare le modifiche nelle librerie in più lingue.

Il servizio di backend è privato e utilizza la funzionalità integrata di Cloud Run per l'autenticazione service-to-service basata su IAM, che limita chi può chiamare il servizio. Entrambi i servizi sono basati sul principio del privilegio minimo, senza accesso al resto di Google Cloud , tranne dove necessario.

Limitazioni o non obiettivi di questo tutorial

Obiettivi

  • Crea un account di servizio dedicato con autorizzazioni minime per l'autenticazione service-to-service e l'accesso del servizio al resto di Google Cloud.
  • Scrivere, creare ed eseguire il deployment di due servizi su Cloud Run che interagiscono.
  • Effettua richieste tra un servizio Cloud Run pubblico e uno privato.

Costi

In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il Calcolatore prezzi.

I nuovi utenti di Google Cloud potrebbero avere diritto a una prova senza costi.

Prima di iniziare

  1. Accedi al tuo account Google Cloud . Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti senza costi per l'esecuzione, il test e il deployment dei workload.

  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  3. Verify that billing is enabled for your Google Cloud project.

  4. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  5. Verify that billing is enabled for your Google Cloud project.

  6. Abilita l'API Cloud Run, se non è già abilitata.

    Ruoli richiesti per abilitare le API

    Per abilitare le API, devi disporre dell'autorizzazione serviceusage.services.enable. Se hai creato il progetto, probabilmente hai già questa autorizzazione tramite il ruolo Proprietario (roles/owner). In caso contrario, puoi ottenere questa autorizzazione tramite il ruolo Amministratore Service Usage (roles/serviceusage.serviceUsageAdmin). Scopri come concedere i ruoli.

    Abilitare l'API

  7. Installa e inizializza gcloud CLI.
  8. Installa curl per provare il servizio

Ruoli obbligatori

Per ottenere le autorizzazioni necessarie per completare il tutorial, chiedi all'amministratore di concederti i seguenti ruoli IAM nel progetto:

Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

Potresti anche riuscire a ottenere le autorizzazioni richieste tramite i ruoli personalizzati o altri ruoli predefiniti.

Configura i valori predefiniti di gcloud CLI

Per configurare Google Cloud CLI con i valori predefiniti per il tuo servizio Cloud Run:

  1. Imposta il progetto predefinito:

    gcloud config set project PROJECT_ID

    Sostituisci PROJECT_ID con il nome del progetto che hai creato per questo tutorial.

  2. Configura Google Cloud CLI per la regione scelta:

    gcloud config set run/region REGION

    Sostituisci REGION con la regione Cloud Run supportata che preferisci.

Località di Cloud Run

Cloud Run è regionale, il che significa che l'infrastruttura che esegue i tuoi servizi Cloud Run si trova in una regione specifica ed è gestita da Google per essere disponibile in modo ridondante in tutte le zone all'interno di quella regione.

La soddisfazione dei requisiti di latenza, disponibilità o durabilità è un fattore principale per la selezione della regione in cui vengono eseguiti i servizi Cloud Run. In genere puoi selezionare la regione più vicina ai tuoi utenti, ma devi considerare la posizione degli altri prodotti Google Cloud utilizzati dal tuo servizio Cloud Run. L'utilizzo di prodotti Google Cloud in sinergia in più località può influire sulla latenza del servizio e sui costi.

Cloud Run è disponibile nelle seguenti regioni:

Soggetto ai prezzi di Livello 1

Soggetto ai prezzi di Livello 2

  • africa-south1 (Johannesburg)
  • asia-east2 (Hong Kong)
  • asia-northeast3 (Seul, Corea del Sud)
  • asia-southeast1 (Singapore)
  • asia-southeast2 (Giacarta)
  • asia-south2 (Delhi, India)
  • australia-southeast1 (Sydney)
  • australia-southeast2 (Melbourne)
  • europe-central2 (Varsavia, Polonia) icona foglia Bassi livelli di CO2
  • europe-west10 (Berlino)
  • europe-west12 (Torino) icona foglia Bassi livelli di CO2
  • europe-west2 (Londra, Regno Unito) icona foglia Bassi livelli di CO2
  • europe-west3 (Francoforte, Germania)
  • europe-west6 (Zurigo, Svizzera) icona foglia A basse emissioni di CO2
  • me-central1 (Doha)
  • me-central2 (Dammam)
  • northamerica-northeast1 (Montreal) icona foglia Bassi livelli di CO2
  • northamerica-northeast2 (Toronto) icona foglia Bassi livelli di CO2
  • southamerica-east1 (San Paolo, Brasile) icona foglia Bassi livelli di CO2
  • southamerica-west1 (Santiago, Cile) icona foglia Bassi livelli di CO2
  • us-west2 (Los Angeles)
  • us-west3 (Salt Lake City)
  • us-west4 (Las Vegas)

Se hai già creato un servizio Cloud Run, puoi visualizzare la regione nella dashboard di Cloud Run nella consoleGoogle Cloud .

Recupera l'esempio di codice

Per recuperare l'esempio di codice da utilizzare:

  1. Clona il repository dell'app di esempio in Cloud Shell o sulla tua macchina locale:

    Node.js 

    git clone https://github.com/GoogleCloudPlatform/nodejs-docs-samples.git

    In alternativa puoi scaricare l'esempio come file ZIP ed estrarlo.

    Python 

    git clone https://github.com/GoogleCloudPlatform/python-docs-samples.git

    In alternativa puoi scaricare l'esempio come file ZIP ed estrarlo.

    Go 

    git clone https://github.com/GoogleCloudPlatform/golang-samples.git

    In alternativa puoi scaricare l'esempio come file ZIP ed estrarlo.

    Java 

    git clone https://github.com/GoogleCloudPlatform/java-docs-samples.git

    In alternativa puoi scaricare l'esempio come file ZIP ed estrarlo.

    C# 

    git clone https://github.com/GoogleCloudPlatform/dotnet-docs-samples.git

    In alternativa puoi scaricare l'esempio come file ZIP ed estrarlo.

  2. Passa alla directory che contiene il codice campione di Cloud Run:

    Node.js 

    cd nodejs-docs-samples/run/markdown-preview/

    Python 

    cd python-docs-samples/run/markdown-preview/

    Go 

    cd golang-samples/run/markdown-preview/

    Java 

    cd java-docs-samples/run/markdown-preview/

    C# 

    cd dotnet-docs-samples/run/markdown-preview/

Esamina il servizio di rendering Markdown privato

Dal punto di vista del frontend, il servizio Markdown ha la seguente specifica API:

  • Un endpoint a /
  • Prevede richieste POST
  • Il corpo della richiesta POST è un testo Markdown

Puoi esaminare tutto il codice per verificare la presenza di eventuali problemi di sicurezza o semplicemente per saperne di più esplorando la directory ./renderer/. Tieni presente che il tutorial non spiega il codice di trasformazione Markdown.

Invia il servizio di rendering Markdown privato

Per inviare il codice, crealo con Cloud Build, caricalo su Artifact Registry ed eseguine il deployment in Cloud Run:

  1. Passa alla directory renderer:

    Node.js 

    cd renderer/

    Python 

    cd renderer/

    Go 

    cd renderer/

    Java 

    cd renderer/

    C# 

    cd Samples.Run.MarkdownPreview.Renderer/

  2. Crea un Artifact Registry:

    gcloud artifacts repositories create REPOSITORY \
    --repository-format docker \
    --location REGION

    Sostituisci:

    • REPOSITORY con un nome univoco per il repository. Per ogni località del repository in un progetto, i nomi dei repository devono essere univoci.
    • REGION con la regione Google Cloud da utilizzare per il repository Artifact Registry.

  3. Esegui questo comando per creare il container e pubblicarlo su Artifact Registry.

    Node.js 

    gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/renderer

    Dove PROJECT_ID è l'ID del tuo progetto Google Cloud e renderer è il nome che vuoi assegnare al tuo servizio.

    In caso di esito positivo, vedrai un messaggio SUCCESS contenente l'ID, l'ora di creazione e il nome dell'immagine. L'immagine è archiviata in Artifact Registry e, se necessario, può essere riutilizzata.

    Python 

    gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/renderer

    Dove PROJECT_ID è l'ID del tuo progetto Google Cloud e renderer è il nome che vuoi assegnare al tuo servizio.

    In caso di esito positivo, vedrai un messaggio SUCCESS contenente l'ID, l'ora di creazione e il nome dell'immagine. L'immagine è archiviata in Artifact Registry e, se necessario, può essere riutilizzata.

    Vai 

    gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/renderer

    Dove PROJECT_ID è l'ID del tuo progetto Google Cloud e renderer è il nome che vuoi assegnare al tuo servizio.

    In caso di esito positivo, vedrai un messaggio SUCCESS contenente l'ID, l'ora di creazione e il nome dell'immagine. L'immagine è archiviata in Artifact Registry e, se necessario, può essere riutilizzata.

    Java

    Questo esempio utilizza Jib per creare immagini Docker utilizzando strumenti Java comuni. Jib ottimizza le build dei container senza la necessità di un Dockerfile o di avere Docker installato. Scopri di più sulla creazione di container Java con Jib.

    1. Utilizza l'helper per le credenziali gcloud per autorizzare Docker a eseguire il push su Artifact Registry. 

      gcloud auth configure-docker

    2. Utilizza il plug-in Jib Maven per creare il container ed eseguirne il push ad Artifact Registry. 

      mvn compile jib:build -Dimage=REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/renderer

    Dove PROJECT_ID è l'ID del tuo progetto Google Cloud e renderer è il nome che vuoi assegnare al tuo servizio.

    Se l'operazione va a buon fine, vedrai un messaggio BUILD SUCCESS. L'immagine è archiviata in Artifact Registry e, se necessario, può essere riutilizzata.

    C# 

    gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/renderer

    Dove PROJECT_ID è l'ID del tuo progetto Google Cloud e renderer è il nome che vuoi assegnare al tuo servizio.

    In caso di esito positivo, vedrai un messaggio SUCCESS contenente l'ID, l'ora di creazione e il nome dell'immagine. L'immagine è archiviata in Artifact Registry e, se necessario, può essere riutilizzata.

  4. Esegui il deployment come servizio privato con accesso limitato.

    Cloud Run fornisce funzionalità pronte all'uso di controllo degli accessi e identità di servizio. Il controllo degli accessi fornisce un livello di autenticazione che impedisce agli utenti e ad altri servizi di richiamare il servizio. L'identità del servizio consente di limitare l'accesso del servizio ad altre risorseGoogle Cloud creando un account di servizio dedicato con autorizzazioni limitate.

    1. Crea un account di servizio che funga da "identità di computing" del servizio di rendering. Per impostazione predefinita, non dispone di privilegi diversi dall'appartenenza al progetto.

      Riga di comando

      gcloud iam service-accounts create renderer-identity

      Terraform

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

      resource "google_service_account" "renderer" {
  account_id   = "renderer-identity"
  display_name = "Service identity of the Renderer (Backend) service."
}

      Il servizio di rendering Markdown non si integra direttamente con nient'altro in Google Cloud. Non richiede ulteriori autorizzazioni.

    2. Esegui il deployment con il account di servizio renderer-identity e nega l'accesso non autenticato.

      Riga di comando

      gcloud run deploy renderer \
--image REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/renderer \
--service-account renderer-identity \
--no-allow-unauthenticated

      Cloud Run può utilizzare il nome del account di servizio in formato breve anziché l'indirizzo email completo se il account di servizio fa parte dello stesso progetto.

      Terraform

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

      resource "google_cloud_run_v2_service" "renderer" {
  name     = "renderer"
  location = "us-central1"

  deletion_protection = false # set to "true" in production

  template {
    containers {
      # Replace with the URL of your Secure Services > Renderer image.
      #   gcr.io/<PROJECT_ID>/renderer
      image = "us-docker.pkg.dev/cloudrun/container/hello"
    }
    service_account = google_service_account.renderer.email
  }
}

Prova il servizio di rendering privato di Markdown

I servizi privati non possono essere caricati direttamente da un browser web. Utilizza invece curl o uno strumento simile di interfaccia a riga di comando per le richieste HTTP che consente di inserire un'intestazione Authorization.

Per inviare del testo in grassetto al servizio e vedere come converte gli asterischi di Markdown in tag HTML <strong>:

  1. Recupera l'URL dall'output del deployment.

  2. Utilizza gcloud per ricavare un token di identità speciale solo per lo sviluppo per l'autenticazione:

    TOKEN=$(gcloud auth print-identity-token)

  3. Crea una richiesta curl che passi il testo Markdown non elaborato come parametro della stringa di query con escape URL:

    curl -H "Authorization: Bearer $TOKEN" \
   -H 'Content-Type: text/plain' \
   -d '**Hello Bold Text**' \
   SERVICE_URL

    Sostituisci SERVICE_URL con l'URL fornito dopo il deployment del servizio di rendering Markdown.

  4. La risposta deve essere uno snippet HTML:

     <strong>Hello Bold Text</strong>

Esamina l'integrazione tra i servizi di editor e di rendering

Il servizio editor fornisce un'interfaccia utente per l'inserimento di testo e uno spazio per visualizzare l'anteprima HTML. Prima di continuare, esamina il codice recuperato in precedenza aprendo la directory ./editor/.

Successivamente, esplora le seguenti sezioni di codice che integrano in modo sicuro i due servizi.

Node.js

Il modulo render.js crea richieste autenticate al servizio di rendering privato. Utilizza il server dei metadati Google Cloud nell'ambiente Cloud Run per creare un token di identità e aggiungerlo alla richiesta HTTP come parte di un'intestazione Authorization.

In altri ambienti, render.js utilizza le Credenziali predefinite dell'applicazione per richiedere un token ai server di Google.

import {GoogleAuth} from 'google-auth-library';
import got from 'got';
const auth = new GoogleAuth();

let client, serviceUrl;

// renderRequest creates a new HTTP request with IAM ID Token credential.
// This token is automatically handled by private Cloud Run (fully managed) and Cloud Functions.
const renderRequest = async markdown => {
  if (!process.env.EDITOR_UPSTREAM_RENDER_URL)
    throw Error('EDITOR_UPSTREAM_RENDER_URL needs to be set.');
  serviceUrl = process.env.EDITOR_UPSTREAM_RENDER_URL;

  // Build the request to the Renderer receiving service.
  const serviceRequestOptions = {
    method: 'POST',
    headers: {
      'Content-Type': 'text/plain',
    },
    body: markdown,
    timeout: {
      request: 3000,
    },
  };

  try {
      // Create a Google Auth client with the Renderer service url as the target audience.
      if (!client) client = await auth.getIdTokenClient(serviceUrl);
      // Fetch the client request headers and add them to the service request headers.
      // The client request headers include an ID token that authenticates the request.
      const clientHeaders = await client.getRequestHeaders();
      serviceRequestOptions.headers['Authorization'] =
        clientHeaders['Authorization'];
  } catch (err) {
    throw Error('could not create an identity token: ' + err.message);
  }

  try {
    // serviceResponse converts the Markdown plaintext to HTML.
    const serviceResponse = await got(serviceUrl, serviceRequestOptions);
    return serviceResponse.body;
  } catch (err) {
    throw Error('request to rendering service failed: ' + err.message);
  }
};

Analizza il Markdown dal JSON e invialo al servizio Renderer per trasformarlo in HTML.

app.post('/render', async (req, res) => {
  try {
    const markdown = req.body.data;
    const response = await renderRequest(markdown);
    res.status(200).send(response);
  } catch (err) {
    console.error('Error rendering markdown:', err);
    res.status(500).send(err);
  }
});

Python

Il metodo new_request crea richieste autenticate ai servizi privati. Utilizza il server di metadati Google Cloud nell'ambiente Cloud Run per creare un token di identità e aggiungerlo alla richiesta HTTP come parte di un'intestazione Authorization.

In altri ambienti, new_request richiede un token di identità ai server di Google autenticandosi con le Credenziali predefinite dell'applicazione.

import os
import urllib

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


def new_request(data):
    """Creates a new HTTP request with IAM ID Token credential.

    This token is automatically handled by private Cloud Run and Cloud Functions.

    Args:
        data: data for the authenticated request

    Returns:
        The response from the HTTP request
    """
    url = os.environ.get("EDITOR_UPSTREAM_RENDER_URL")
    if not url:
        raise Exception("EDITOR_UPSTREAM_RENDER_URL missing")

    req = urllib.request.Request(url, data=data.encode())
    auth_req = google.auth.transport.requests.Request()
    target_audience = url

    id_token = google.oauth2.id_token.fetch_id_token(auth_req, target_audience)
    req.add_header("Authorization", f"Bearer {id_token}")

    response = urllib.request.urlopen(req)
    return response.read()

Analizza il Markdown da JSON e invialo al servizio Renderer per trasformarlo in HTML.

@app.route("/render", methods=["POST"])
def render_handler():
    """Parse the markdown from JSON and send it to the Renderer service to be
    transformed into HTML.
    """
    body = request.get_json(silent=True)
    if not body:
        return "Error rendering markdown: Invalid JSON", 400

    data = body["data"]
    try:
        parsed_markdown = render.new_request(data)
        return parsed_markdown, 200
    except Exception as err:
        return f"Error rendering markdown: {err}", 500

Vai

RenderService crea richieste autenticate ai servizi privati. Utilizza il server dei metadati Google Cloud nell'ambiente Cloud Run per creare un token di identità e aggiungerlo alla richiesta HTTP come parte di un'intestazioneAuthorization.

In altri ambienti, RenderService richiede un token di identità ai server di Google autenticandosi con le Credenziali predefinite dell'applicazione.

import (
	"bytes"
	"context"
	"fmt"
	"io"
	"net/http"
	"time"

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

// RenderService represents our upstream render service.
type RenderService struct {
	// URL is the render service address.
	URL string
	// tokenSource provides an identity token for requests to the Render Service.
	tokenSource oauth2.TokenSource
}

// NewRequest creates a new HTTP request to the Render service.
// If authentication is enabled, an Identity Token is created and added.
func (s *RenderService) NewRequest(method string) (*http.Request, error) {
	req, err := http.NewRequest(method, s.URL, nil)
	if err != nil {
		return nil, fmt.Errorf("http.NewRequest: %w", err)
	}

	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
	defer cancel()

	// Create a TokenSource if none exists.
	if s.tokenSource == nil {
		s.tokenSource, err = idtoken.NewTokenSource(ctx, s.URL)
		if err != nil {
			return nil, fmt.Errorf("idtoken.NewTokenSource: %w", err)
		}
	}

	// Retrieve an identity token. Will reuse tokens until refresh needed.
	token, err := s.tokenSource.Token()
	if err != nil {
		return nil, fmt.Errorf("TokenSource.Token: %w", err)
	}
	token.SetAuthHeader(req)

	return req, nil
}

La richiesta viene inviata al servizio Renderer dopo aver aggiunto il testo Markdown da trasformare in HTML. Gli errori di risposta vengono gestiti per distinguere i problemi di comunicazione dalla funzionalità di rendering.


var renderClient = &http.Client{Timeout: 30 * time.Second}

// Render converts the Markdown plaintext to HTML.
func (s *RenderService) Render(in []byte) ([]byte, error) {
	req, err := s.NewRequest(http.MethodPost)
	if err != nil {
		return nil, fmt.Errorf("RenderService.NewRequest: %w", err)
	}

	req.Body = io.NopCloser(bytes.NewReader(in))
	defer req.Body.Close()

	resp, err := renderClient.Do(req)
	if err != nil {
		return nil, fmt.Errorf("http.Client.Do: %w", err)
	}

	out, err := io.ReadAll(resp.Body)
	if err != nil {
		return nil, fmt.Errorf("ioutil.ReadAll: %w", err)
	}

	if resp.StatusCode != http.StatusOK {
		return out, fmt.Errorf("http.Client.Do: %s (%d): request not OK", http.StatusText(resp.StatusCode), resp.StatusCode)
	}

	return out, nil
}

Java

makeAuthenticatedRequest crea richieste autenticate ai servizi privati. Utilizza il server dei metadati Google Cloud nell'ambiente Cloud Run per creare un token di identità e aggiungerlo alla richiesta HTTP come parte di un'intestazione Authorization.

In altri ambienti, makeAuthenticatedRequest richiede un token di identità ai server di Google autenticandosi con le Credenziali predefinite dell'applicazione.

// makeAuthenticatedRequest creates a new HTTP request authenticated by a JSON Web Tokens (JWT)
// retrievd from Application Default Credentials.
public String makeAuthenticatedRequest(String url, String markdown) {
  String html = "";
  try {
    // Retrieve Application Default Credentials
    GoogleCredentials credentials = GoogleCredentials.getApplicationDefault();
    IdTokenCredentials tokenCredentials =
        IdTokenCredentials.newBuilder()
            .setIdTokenProvider((IdTokenProvider) credentials)
            .setTargetAudience(url)
            .build();

    // Create an ID token
    String token = tokenCredentials.refreshAccessToken().getTokenValue();
    // Instantiate HTTP request
    MediaType contentType = MediaType.get("text/plain; charset=utf-8");
    okhttp3.RequestBody body = okhttp3.RequestBody.create(markdown, contentType);
    Request request =
        new Request.Builder()
            .url(url)
            .addHeader("Authorization", "Bearer " + token)
            .post(body)
            .build();

    Response response = ok.newCall(request).execute();
    html = response.body().string();
  } catch (IOException e) {
    logger.error("Unable to get rendered data", e);
  }
  return html;
}

Analizza il Markdown dal JSON e invialo al servizio Renderer per trasformarlo in HTML.

// '/render' expects a JSON body payload with a 'data' property holding plain text
// for rendering.
@PostMapping(value = "/render", consumes = "application/json")
public String render(@RequestBody Data data) {
  String markdown = data.getData();

  String url = System.getenv("EDITOR_UPSTREAM_RENDER_URL");
  if (url == null) {
    String msg =
        "No configuration for upstream render service: "
            + "add EDITOR_UPSTREAM_RENDER_URL environment variable";
    logger.error(msg);
    throw new IllegalStateException(msg);
  }

  String html = makeAuthenticatedRequest(url, markdown);
  return html;
}

C#

GetAuthenticatedPostResponse crea richieste autenticate ai servizi privati. Utilizza il server dei metadati Google Cloud nell'ambiente Cloud Run per creare un token di identità e aggiungerlo alla richiesta HTTP come parte di un'intestazione Authorization.

In altri ambienti, GetAuthenticatedPostResponse richiede un token di identità ai server di Google autenticandosi con le Credenziali predefinite dell'applicazione.

private async Task<string> GetAuthenticatedPostResponse(string url, string postBody)
{
    // Get the OIDC access token from the service account via Application Default Credentials
    GoogleCredential credential = await GoogleCredential.GetApplicationDefaultAsync();  
    OidcToken token = await credential.GetOidcTokenAsync(OidcTokenOptions.FromTargetAudience(url));
    string accessToken = await token.GetAccessTokenAsync();

    // Create request to the upstream service with the generated OAuth access token in the Authorization header
    var upstreamRequest = new HttpRequestMessage(HttpMethod.Post, url);
    upstreamRequest.Headers.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
    upstreamRequest.Content = new StringContent(postBody);

    var upstreamResponse = await _httpClient.SendAsync(upstreamRequest);
    upstreamResponse.EnsureSuccessStatusCode();

    return await upstreamResponse.Content.ReadAsStringAsync();
}

Analizza il Markdown dal JSON e invialo al servizio Renderer per trasformarlo in HTML.

public async Task<IActionResult> Index([FromBody] RenderModel model)
{
    var markdown = model.Data ?? string.Empty;
    var renderedHtml = await GetAuthenticatedPostResponse(_editorUpstreamRenderUrl, markdown);
    return Content(renderedHtml);
}

Pubblica il servizio di editor pubblico

Per creare ed eseguire il deployment del codice:

  1. Passa alla directory editor:

    Node.js 

    cd ../editor

    Python 

    cd ../editor

    Go 

    cd ../editor

    Java 

    cd ../editor

    C# 

    cd ../Samples.Run.MarkdownPreview.Editor/

  2. Esegui questo comando per creare il container e pubblicarlo su Artifact Registry.

    Node.js 

    gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/editor

    Dove PROJECT_ID è l'ID del tuo progetto Google Cloud e editor è il nome che vuoi assegnare al tuo servizio.

    In caso di esito positivo, vedrai un messaggio SUCCESS contenente l'ID, l'ora di creazione e il nome dell'immagine. L'immagine è archiviata in Container Registry e, se necessario, può essere riutilizzata.

    Python 

    gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/editor

    Dove PROJECT_ID è l'ID del tuo progetto Google Cloud e editor è il nome che vuoi assegnare al tuo servizio.

    In caso di esito positivo, vedrai un messaggio SUCCESS contenente l'ID, l'ora di creazione e il nome dell'immagine. L'immagine è archiviata in Artifact Registry e, se necessario, può essere riutilizzata.

    Vai 

    gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/editor

    Dove PROJECT_ID è l'ID del tuo progetto Google Cloud e editor è il nome che vuoi assegnare al tuo servizio.

    In caso di esito positivo, vedrai un messaggio SUCCESS contenente l'ID, l'ora di creazione e il nome dell'immagine. L'immagine è archiviata in Artifact Registry e, se necessario, può essere riutilizzata.

    Java

    Questo esempio utilizza Jib per creare immagini Docker utilizzando strumenti Java comuni. Jib ottimizza le build dei container senza la necessità di un Dockerfile o di avere Docker installato. Scopri di più sulla creazione di container Java con Jib.

    mvn compile jib:build -Dimage=REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/editor

    Dove PROJECT_ID è l'ID del tuo progetto Google Cloud e editor è il nome che vuoi assegnare al tuo servizio.

    Se l'operazione va a buon fine, vedrai un messaggio BUILD SUCCESS. L'immagine è archiviata in Artifact Registry e, se necessario, può essere riutilizzata.

    C# 

    gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/editor

    Dove PROJECT_ID è l'ID del tuo progetto Google Cloud e editor è il nome che vuoi assegnare al tuo servizio.

    In caso di esito positivo, vedrai un messaggio SUCCESS contenente l'ID, l'ora di creazione e il nome dell'immagine. L'immagine è archiviata in Artifact Registry e, se necessario, può essere riutilizzata.

  3. Esegui il deployment come servizio privato con accesso speciale al servizio di rendering.

    1. Crea un account di servizio che funga da "identità di computing" del servizio privato. Per impostazione predefinita, non dispone di privilegi diversi dall'appartenenza al progetto.

      Riga di comando

      gcloud iam service-accounts create editor-identity

      Terraform

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

      resource "google_service_account" "editor" {
  account_id   = "editor-identity"
  display_name = "Service identity of the Editor (Frontend) service."
}

      Il servizio Editor non deve interagire con nient'altro in Google Cloud , ad eccezione del servizio di rendering Markdown.

    2. Concedi l'accesso all'identità di computing editor-identity per richiamare il servizio di rendering Markdown. Qualsiasi servizio che utilizza questo account come identità di computing avrà questo privilegio.

      Riga di comando

      gcloud run services add-iam-policy-binding renderer \
--member serviceAccount:editor-identity@PROJECT_ID.iam.gserviceaccount.com \
--role roles/run.invoker

      Terraform

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

      resource "google_cloud_run_service_iam_member" "editor_invokes_renderer" {
  location = google_cloud_run_v2_service.renderer.location
  service  = google_cloud_run_v2_service.renderer.name
  role     = "roles/run.invoker"
  member   = "serviceAccount:${google_service_account.editor.email}"
}

      Poiché a questo viene assegnato il ruolo Invoker nel contesto del servizio di rendering, il servizio di rendering è l'unico servizio Cloud Run privato che l'editor può richiamare.

    3. Esegui il deployment con il account di servizio editor-identity e consenti l'accesso pubblico non autenticato.

      Riga di comando

      gcloud run deploy editor --image REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/editor \
--service-account editor-identity \
--set-env-vars EDITOR_UPSTREAM_RENDER_URL=SERVICE_URL \
--allow-unauthenticated

      Sostituisci:

      • PROJECT_ID con l'ID progetto
      • SERVICE_URL con l'URL fornito dopo il deployment del servizio di rendering Markdown.

      Terraform

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

      Esegui il deployment del servizio editor:

      resource "google_cloud_run_v2_service" "editor" {
  name     = "editor"
  location = "us-central1"

  deletion_protection = false # set to "true" in production

  template {
    containers {
      # Replace with the URL of your Secure Services > Editor image.
      #   gcr.io/<PROJECT_ID>/editor
      image = "us-docker.pkg.dev/cloudrun/container/hello"
      env {
        name  = "EDITOR_UPSTREAM_RENDER_URL"
        value = google_cloud_run_v2_service.renderer.uri
      }
    }
    service_account = google_service_account.editor.email

  }
}

      Concedi l'autorizzazione allUsers per richiamare il servizio:

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

resource "google_cloud_run_service_iam_policy" "noauth" {
  location = google_cloud_run_v2_service.editor.location
  project  = google_cloud_run_v2_service.editor.project
  service  = google_cloud_run_v2_service.editor.name

  policy_data = data.google_iam_policy.noauth.policy_data
}

Comprendi il traffico HTTPS

Il rendering di Markdown utilizzando questi servizi prevede tre richieste HTTP.

Diagramma che mostra il flusso di richieste dall'utente all'editor, dall'editor per ottenere un token dal server di metadati, dall'editor per effettuare una richiesta al servizio di rendering, dal servizio di rendering per restituire l'HTML all'editor.
Il servizio di frontend con editor-identity richiama il servizio di rendering. Sia editor-identity che renderer-identity hanno autorizzazioni limitate, pertanto qualsiasi exploit di sicurezza o code injection ha accesso limitato ad altre risorse Google Cloud .

Provalo

Per provare l'applicazione completa con due servizi:

  1. Vai nel browser all'URL fornito dal passaggio di deployment precedente.

  2. Prova a modificare il testo Markdown a sinistra e fai clic sul pulsante per visualizzarne l'anteprima a destra.

    Dovrebbe avere il seguente aspetto: L'interfaccia utente dell'editor Markdown mostra il testo Markdown a sinistra e l'HTML visualizzato a destra.

Se scegli di continuare a sviluppare questi servizi, ricorda che hanno un accesso limitato di Identity and Access Management (IAM) al resto di Google Cloud e dovranno ricevere ruoli IAM aggiuntivi per accedere a molti altri servizi.

Esegui la pulizia

Se hai creato un nuovo progetto per questo tutorial, eliminalo. Se hai utilizzato un progetto esistente e vuoi conservarlo senza le modifiche aggiunte in questo tutorial, elimina le risorse create per il tutorial.

Elimina il progetto

Il modo più semplice per eliminare la fatturazione è eliminare il progetto creato per il tutorial.

Per eliminare il progetto:

  1. Nella console Google Cloud , vai alla pagina Gestisci risorse.

    Vai a Gestisci risorse

  2. Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
  3. Nella finestra di dialogo, digita l'ID progetto, quindi fai clic su Chiudi per eliminare il progetto.

Elimina le risorse del tutorial

  1. Elimina i servizi Cloud Run di cui hai eseguito il deployment in questo tutorial:

    gcloud 

    gcloud run services delete editor
gcloud run services delete renderer

    Puoi eliminare i servizi Cloud Run anche dalla consoleGoogle Cloud .

  2. Rimuovi le configurazioni predefinite di Google Cloud CLI che hai aggiunto durante la configurazione del tutorial.

     gcloud config unset run/region

  3. Rimuovi la configurazione del progetto:

     gcloud config unset project

  4. Elimina le altre risorse Google Cloud create in questo tutorial:

Passaggi successivi