Questa pagina è stata tradotta dall'API Cloud Translation.

Tutorial sulla protezione dei servizi Cloud Run

Questo tutorial illustra come creare un'applicazione sicura con due servizi in esecuzione su Cloud Run. Questa applicazione è un editor di Markdown che include un servizio "frontend" pubblico che chiunque può utilizzare per comporre testo Markdown e un servizio "backend" privato che esegue il rendering del testo Markdown in HTML.

Diagramma che mostra il flusso di richieste dall'editor frontend al renderer backend. — 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à di autenticazione di servizio a servizio basata su IAM integrata di Cloud Run, 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 scopi non previsti di questo tutorial

Questo tutorial non mostra l'autenticazione degli utenti finali, che utilizza Identity Platform o Firebase Authentication per generare token ID utente e verificare manualmente le identità degli utenti. Per saperne di più sull'autenticazione degli utenti finali, consulta il tutorial di Cloud Run sull'autenticazione degli utenti finali.
Questo tutorial non mostra la combinazione di metodi di autenticazione e token identificativo basati su IAM perché non è supportata.

Obiettivi

Crea un account di servizio dedicato con autorizzazioni minime per l'autenticazione servizio-a-servizio e l'accesso ai servizi per il resto di Google Cloud.
Scrivi, crea ed esegui il deployment di due servizi che interagiscono in Cloud Run.
Invia richieste tra un servizio Cloud Run pubblico e privato.

Costi

In questo documento utilizzi i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi basata sull'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud potrebbero essere idonei per una prova gratuita.

Prima di iniziare

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

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

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

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

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the Cloud Run API.
Enable the API

Installa e inizializza la gcloud CLI.
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:

Editor Cloud Build (roles/cloudbuild.builds.editor)
Amministratore Cloud Run (roles/run.admin)
Crea account di servizio (roles/iam.serviceAccountCreator)
Amministratore IAM del progetto (roles/resourcemanager.projectIamAdmin)
Utente account di servizio (roles/iam.serviceAccountUser)
Consumatore di utilizzo del servizio (roles/serviceusage.serviceUsageConsumer)
Amministratore archiviazione (roles/storage.admin)
Amministratore del repository Artifact Registry (roles/artifactregistry.repoAdmin)

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

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

Configurare i valori predefiniti di gcloud

Per configurare gcloud con i valori predefiniti per il servizio Cloud Run:

Imposta il progetto predefinito:
```
gcloud config set project PROJECT_ID
```
Sostituisci PROJECT_ID con il nome del progetto che hai creato per questo tutorial.
Configura gcloud per la regione scelta:
```
gcloud config set run/region REGION
```
Sostituisci REGION con la regione di Cloud Run supportata che preferisci.

Località Cloud Run

Cloud Run è un servizio a livello di regione, il che significa che l'infrastruttura che gestisce i tuoi servizi Cloud Run si trova in una regione specifica ed è gestita da Google in modo da essere disponibile in modo ridondante in tutte le zone all'interno della regione.

Soddisfare i requisiti di latenza, disponibilità o durabilità è uno dei fattori principali per selezionare la regione in cui vengono eseguiti i servizi Cloud Run. In genere puoi selezionare la regione più vicina ai tuoi utenti, ma devi prendere in considerazione la posizione degli altri prodotti Google Cloud utilizzati dal servizio Cloud Run. L'utilizzo combinato dei prodotti Google Cloud in più località può influire sulla latenza e sul costo del servizio.

Cloud Run è disponibile nelle seguenti regioni:

Soggetto ai prezzi di Livello 1

asia-east1 (Taiwan)
asia-northeast1 (Tokyo)
asia-northeast2 (Osaka)
asia-south1 (Mumbai, India)
europe-north1 (Finlandia) Bassi livelli di CO₂
europe-southwest1 (Madrid) Basso livello di CO₂
europe-west1 (Belgio) Bassi livelli di CO₂
europe-west4 (Paesi Bassi) Bassi livelli di CO₂
europe-west8 (Milano)
europe-west9 (Parigi) Bassi livelli di CO₂
me-west1 (Tel Aviv)
us-central1 (Iowa) Bassi livelli di CO₂
us-east1 (Carolina del Sud)
us-east4 (Virginia del Nord)
us-east5 (Columbus)
us-south1 (Dallas) Bassi livelli di CO₂
us-west1 (Oregon) Bassi livelli di CO₂

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)
europe-west10 (Berlino) Bassi livelli di CO₂
europe-west12 (Torino)
europe-west2 (Londra, Regno Unito) Bassi livelli di CO₂
europe-west3 (Francoforte, Germania) Bassi livelli di CO₂
europe-west6 (Zurigo, Svizzera) Bassi livelli di CO₂
me-central1 (Doha)
me-central2 (Dammam)
northamerica-northeast1 (Montreal) Bassi livelli di CO₂
northamerica-northeast2 (Toronto) Bassi livelli di CO₂
southamerica-east1 (San Paolo, Brasile) Bassi livelli di CO₂
southamerica-west1 (Santiago, Cile) Bassi livelli di CO₂
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 console Google Cloud.

Recupero dell'esempio di codice

Per recuperare l'esempio di codice da utilizzare:

Clona il repository dell'app di esempio in Cloud Shell o nella 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.
Vai
```
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.

Passa alla directory che contiene il codice di esempio di Cloud Run:

Node.js

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

Python

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

Vai

cd golang-samples/run/markdown-preview/

Java

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

C#

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

Revisione del servizio di rendering di Markdown privato

Dal punto di vista del frontend, esiste una semplice specifica dell'API per il servizio Markdown:

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

Ti consigliamo di esaminare tutto il codice per verificare la presenza di eventuali problemi di sicurezza o semplicemente per approfondire l'argomento esplorando la directory ./renderer/. Tieni presente che il tutorial non spiega il codice di trasformazione Markdown.

Pubblicazione del servizio di rendering Markdown privato

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

Passa alla directory renderer:

Node.js

cd renderer/

Python

cd renderer/

Vai

cd renderer/

Java

cd renderer/

C#

cd Samples.Run.MarkdownPreview.Renderer/

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 posizione 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.
Esegui il comando seguente 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 progetto Google Cloud e renderer è il nome che vuoi assegnare al servizio.

In caso di esito positivo, viene visualizzato un messaggio di successo contenente l'ID, l'ora di creazione e il nome dell'immagine. L'immagine è archiviata in Artifact Registry e, se lo desideri, può essere riutilizzata.
Python
```
gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/renderer
```
dove PROJECT_ID è l'ID progetto Google Cloud e renderer è il nome che vuoi assegnare al servizio.

In caso di esito positivo, viene visualizzato un messaggio di successo contenente l'ID, l'ora di creazione e il nome dell'immagine. L'immagine è archiviata in Artifact Registry e, se lo desideri, può essere riutilizzata.
Vai
```
gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/renderer
```
dove PROJECT_ID è l'ID progetto Google Cloud e renderer è il nome che vuoi assegnare al servizio.

In caso di esito positivo, viene visualizzato un messaggio di successo contenente l'ID, l'ora di creazione e il nome dell'immagine. L'immagine è archiviata in Artifact Registry e, se lo desideri, può essere riutilizzata.
Java

Questo esempio utilizza Jib per creare immagini Docker utilizzando strumenti Java comuni. Jib ottimizza le build dei container senza dover disporre di un Dockerfile o di Docker. Scopri di più sulla creazione di container Java con Jib.
1. Utilizza l'assistente per le credenziali gcloud per autorizzare Docker a eseguire il push nel tuo Artifact Registry.
  gcloud auth configure-docker
2. Utilizza il plug-in Maven Jib per compilare e eseguire il push del contenitore in Artifact Registry.
  mvn compile jib:build -Dimage=REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/renderer
dove PROJECT_ID è l'ID progetto Google Cloud e renderer è il nome che vuoi assegnare al servizio.

In caso di esito positivo, viene visualizzato il messaggio BUILD SUCCESS. L'immagine è archiviata in Artifact Registry e, se lo desideri, può essere riutilizzata.
C#
```
gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/renderer
```
dove PROJECT_ID è l'ID progetto Google Cloud e renderer è il nome che vuoi assegnare al servizio.

In caso di esito positivo, viene visualizzato un messaggio di successo contenente l'ID, l'ora di creazione e il nome dell'immagine. L'immagine è archiviata in Artifact Registry e, se lo desideri, può essere riutilizzata.
Esegui il deployment come servizio privato con accesso limitato.

Cloud Run fornisce funzionalità di controllo degli accessi e di identità del servizio pronte all'uso. Il controllo dell'accesso fornisce un livello di autenticazione che impedisce agli utenti e ad altri servizi di richiamare il servizio. L'identità di servizio consente di limitare l'accesso del servizio ad altre risorse Google Cloud creando un account di servizio dedicato con autorizzazioni limitate.
1. Crea un account di servizio che fungerà da "identità di calcolo" del servizio di rendering. Per impostazione predefinita, non ha 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 nessun altro elemento di Google Cloud. Non richiede ulteriori autorizzazioni.
2. Esegui il deployment con l'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 dell'account di servizio nel formato breve anziché l'indirizzo email completo se l'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 } }

Provare il servizio di rendering di Markdown privato

I servizi privati non possono essere caricati direttamente da un browser web. Utilizza invece curl o uno strumento CLI per le richieste HTTP simile che consenta di iniettare un'intestazione Authorization.

Per inviare al servizio del testo in grassetto e vedere la conversione degli asterischi Markdown in tag HTML <strong>:

Recupera l'URL dall'output del deployment.
Utilizza gcloud per ricavare un token di identità speciale solo per lo sviluppo per l'autenticazione:
```
TOKEN=$(gcloud auth print-identity-token)
```
Crea una richiesta curl che trasmetta il testo Markdown non elaborato come parametro di 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 aver eseguito il deployment del servizio di rendering Markdown.
La risposta deve essere uno snippet HTML:
```
 <strong>Hello Bold Text</strong>
```

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

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

Successivamente, esamina 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 visualizzatore privato. Utilizza il server di metadati di 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 dai server di Google.

const {GoogleAuth} = require('google-auth-library');
const got = require('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: 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 da JSON e invialo al servizio Renderer per la trasformazione 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 la trasformazione 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 di metadati di Google Cloud nell'ambiente Cloud Run per creare un token di identità e aggiungerlo alla richiesta HTTP nell'ambito di un'intestazione Authorization.

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 in 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 di metadati di Google Cloud nell'ambiente Cloud Run per creare un token di identità e aggiungerlo alla richiesta HTTP nell'ambito di un'intestazione Authorization.

In altri ambienti, makeAuthenticatedRequest richiede un token di identità dai 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 da JSON e invialo al servizio Renderer per la trasformazione 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 di metadati di Google Cloud nell'ambiente Cloud Run per creare un token di identità e aggiungerlo alla richiesta HTTP nell'ambito di un'intestazione Authorization.

In altri ambienti, GetAuthenticatedPostResponse richiede un token di identità dai 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 da JSON e invialo al servizio Renderer per la trasformazione 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);
}

Invio del servizio di editor pubblico

Per compilare ed eseguire il deployment del codice:

Passa alla directory editor:

Node.js

cd ../editor

Python

cd ../editor

Vai

cd ../editor

Java

cd ../editor

C#

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

Esegui il comando seguente 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 progetto Google Cloud e editor è il nome che vuoi assegnare al servizio.

In caso di esito positivo, viene visualizzato un messaggio di successo contenente l'ID, l'ora di creazione e il nome dell'immagine. L'immagine è archiviata in Container Registry e, se lo desideri, può essere riutilizzata.
Python
```
gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/editor
```
dove PROJECT_ID è l'ID progetto Google Cloud e editor è il nome che vuoi assegnare al servizio.

In caso di esito positivo, viene visualizzato un messaggio di successo contenente l'ID, l'ora di creazione e il nome dell'immagine. L'immagine è archiviata in Artifact Registry e, se lo desideri, può essere riutilizzata.
Vai
```
gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/editor
```
dove PROJECT_ID è l'ID progetto Google Cloud e editor è il nome che vuoi assegnare al servizio.

In caso di esito positivo, viene visualizzato un messaggio di successo contenente l'ID, l'ora di creazione e il nome dell'immagine. L'immagine è archiviata in Artifact Registry e, se lo desideri, può essere riutilizzata.
Java
Questo esempio utilizza Jib per creare immagini Docker utilizzando strumenti Java comuni. Jib ottimizza le build dei container senza dover disporre di un Dockerfile o di Docker. 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 progetto Google Cloud e editor è il nome che vuoi assegnare al servizio.

In caso di esito positivo, viene visualizzato il messaggio BUILD SUCCESS. L'immagine è archiviata in Artifact Registry e, se lo desideri, può essere riutilizzata.
C#
```
gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/editor
```
dove PROJECT_ID è l'ID progetto Google Cloud e editor è il nome che vuoi assegnare al servizio.

In caso di esito positivo, viene visualizzato un messaggio di successo contenente l'ID, l'ora di creazione e il nome dell'immagine. L'immagine è archiviata in Artifact Registry e, se lo desideri, può essere riutilizzata.

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

Crea un account di servizio che fungerà da "identità di calcolo" del servizio privato. Per impostazione predefinita, non ha 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 nessun altro elemento in Google Cloud, ad eccezione del servizio di rendering Markdown.
Concedi l'accesso all'identità di calcolo editor-identity per richiamare il servizio di rendering di Markdown. Qualsiasi servizio che lo utilizza come identità di calcolo 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 account viene assegnato il ruolo di invocatore nel contesto del servizio di rendering, il servizio di rendering è l'unico servizio Cloud Run privato che l'editor può invocare.

Esegui il deployment con l'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 del tuo progetto
SERVICE_URL con l'URL fornito dopo il deployment del servizio di rendering di Markdown.

Terraform

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

Esegui il deployment del servizio di 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 a allUsers l'autorizzazione a 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
}

Informazioni sul traffico HTTPS

Il rendering del markdown con 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 HTML all'editor. — Il servizio di frontend con `editor-identity` invoca il servizio di rendering. Sia `editor-identity` che `renderer-identity` hanno autorizzazioni limitate, pertanto qualsiasi exploit di sicurezza o attacco di inserimento di codice ha accesso limitato ad altre risorse Google Cloud.

Prova

Per provare l'applicazione completa con due servizi:

Apri il browser e vai all'URL fornito nel passaggio di implementazione precedente.
Prova a modificare il testo Markdown a sinistra e fai clic sul pulsante per visualizzarne l'anteprima a destra.

Dovrebbe avere il seguente aspetto:

Se scegli di continuare a sviluppare questi servizi, tieni presente che hanno accesso IAM limitato al resto di Google Cloud e dovranno essere assegnati 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 che hai creato per il tutorial.

Per eliminare il progetto:

Attenzione: l'eliminazione di un progetto ha i seguenti effetti:

L'intero contenuto del progetto viene eliminato. Se hai utilizzato un progetto esistente per le attività descritte in questo documento, quando lo elimini elimini anche tutto il lavoro svolto nel progetto.
Gli ID progetto personalizzati non sono più disponibili. Quando hai creato questo progetto, potresti aver creato un ID progetto personalizzato che vuoi utilizzare in futuro. Per conservare gli URL che utilizzano l'ID progetto, ad esempio un appspot.com URL, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.

Se intendi esplorare più architetture, tutorial o guide rapide, il riuso dei progetti può aiutarti a non superare i limiti di quota.

In the Google Cloud console, go to the Manage resources page.
Go to Manage resources
In the project list, select the project that you want to delete, and then click Delete.
In the dialog, type the project ID, and then click Shut down to delete the project.

Eliminazione delle risorse dei tutorial

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 anche eliminare i servizi Cloud Run dalla console Google Cloud.
Rimuovi le configurazioni predefinite di gcloud che hai aggiunto durante la configurazione del tutorial.
```
 gcloud config unset run/region
```
Rimuovi la configurazione del progetto:
```
 gcloud config unset project
```
Elimina le altre risorse Google Cloud create in questo tutorial:
- Elimina l'immagine del contenitore dell'editor denominata REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/editor da Artifact Registry
- Elimina l'immagine del contenitore di rendering denominata REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/renderer da Artifact Registry
- Eliminare l'account di servizio dell'editor editor-identity@PROJECT_ID.iam.gserviceaccount.com
- Elimina l'account di servizio di rendering renderer-identity@PROJECT_ID.iam.gserviceaccount.com

Passaggi successivi

Per proteggere ulteriormente il tuo progetto, consulta la checklist sull'utilizzo sicuro di IAM
Estendere questa applicazione di esempio per monitorare l'utilizzo di Markdown con le metriche personalizzate di Cloud Monitoring
Consulta il tutorial su Pub/Sub per un approccio ai microservizi sicuri e asincroni