Tutorial sulla protezione dei servizi Cloud Run

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

Diagramma che mostra il flusso di richieste dall'editor del frontend al backend "renderer".
. Il renderer è un servizio privato. Ciò consente di garantire che un testo di trasformazione in un'organizzazione senza tenere traccia delle modifiche librerie in più linguaggi.

Il servizio di backend è privato usando Cloud Run spazio di archiviazione Autenticazione service-to-service basata su IAM che limita chi può chiamare il servizio. Entrambi i servizi sono basati principio del privilegio minimo, senza accesso al resto di Google Cloud, eccetto dove necessario.

Limitazioni o non obiettivi di questo tutorial

Obiettivi

  • Crea un account di servizio dedicato con autorizzazioni minime per service-to-service autenticazione e accesso ai servizi al resto di Google Cloud.
  • Scrivi, crea ed esegui il deployment in Cloud Run di due servizi che interagiscono tra loro.
  • Effettuare 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

  1. 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.

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

    Go to project selector

  3. Make sure 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.

    Go to project selector

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

  6. Enable the Cloud Run API.

    Enable the 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 sul tuo progetto:

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 la ruoli o altri ruoli predefiniti ruoli.

Configurazione dei valori predefiniti di gcloud

Per configurare gcloud 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 per cui hai creato questo tutorial.

  2. Configura gcloud per la regione scelta:

    gcloud config set run/region REGION

    Sostituisci REGION con il Cloud Run supportato regione a tua scelta.

Località Cloud Run

Cloud Run è regionale, il che significa che l'infrastruttura dei tuoi servizi Cloud Run si trova in una regione specifica gestiti da Google in modo che siano disponibili in modo ridondante tutte le zone all'interno di quella regione.

Soddisfare i requisiti di latenza, disponibilità o durabilità è fondamentale i fattori necessari per selezionare la regione in cui vengono eseguiti i servizi Cloud Run. Generalmente puoi selezionare la regione più vicina ai tuoi utenti, ma devi considerare la località dell'altro account Google Cloud prodotti utilizzati dal tuo servizio Cloud Run. L'utilizzo combinato dei prodotti Google Cloud in più località può influire nonché la latenza del tuo servizio.

Cloud Run è disponibile nelle regioni seguenti:

Soggetto ai prezzi di Livello 1

Soggetto ai prezzi di Livello 2

Se hai già creato un servizio Cloud Run, puoi visualizzare nella dashboard di Cloud Run all'interno Console Google Cloud.

Recupero dell'esempio di codice in corso

Per recuperare l'esempio di codice da utilizzare:

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

    Node.js 

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

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

    Python 

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

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

    Vai 

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

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

    Java 

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

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

    C# 

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

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

  2. Passa alla directory che contiene l'esempio di Cloud Run codice:

    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 Markdown privato

Dal punto di vista del frontend c'è una semplice specifica API per il servizio Markdown:

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

Ti consigliamo di rivedere tutto il codice per qualsiasi problema di sicurezza o anche solo per scopri di più esplorando la directory ./renderer/. Tieni presente che non spiega il codice di trasformazione Markdown.

Spedizione del servizio di rendering Markdown privato

Per distribuire il codice, crea con Cloud Build, carica su Artifact Registry ed eseguire il deployment su Cloud Run:

  1. Passa alla directory renderer:

    Node.js 

    cd renderer/

    Python 

    cd renderer/

    Vai 

    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 posizione del repository in un progetto, i nomi dei repository devono essere univoci.
    • REGION con la regione Google Cloud da utilizzare per nel 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 progetto Google Cloud e renderer è l'ID che vuoi assegnare al servizio.

    Se l'operazione riesce, verrà visualizzato il messaggio SUCCESS contenente l'ID, la creazione ora e nome dell'immagine. L'immagine è archiviata in Artifact Registry e può essere riutilizzate, se necessario.

    Python 

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

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

    Se l'operazione riesce, verrà visualizzato il messaggio SUCCESS contenente l'ID, la creazione ora e nome dell'immagine. L'immagine è archiviata in Artifact Registry e può essere riutilizzate, se necessario.

    Vai 

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

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

    Se l'operazione riesce, verrà visualizzato il messaggio SUCCESS contenente l'ID, la creazione ora e nome dell'immagine. L'immagine è archiviata in Artifact Registry e può essere se lo desideri,

    Java

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

    1. Utilizza gcloud credentials helper per autorizzare Docker a eseguire il push in Artifact Registry. 

      gcloud auth configure-docker

    2. Usa 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 progetto Google Cloud e renderer è l'ID che vuoi assegnare al servizio.

    Se l'operazione riesce, verrà visualizzato un messaggio BUILD SUCCESS. L'immagine è archiviata in Artifact Registry e può essere riutilizzato, se lo si desidera.

    C# 

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

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

    Se l'operazione riesce, verrà visualizzato il messaggio SUCCESS contenente l'ID, la creazione ora e nome dell'immagine. L'immagine è archiviata in Artifact Registry e può essere se lo desideri,

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

    Cloud Run offre un controllo dell'accesso pronto all'uso e le funzionalità di identità dei servizi. Il controllo dell'accesso fornisce che impedisce agli utenti e ad altri servizi di richiamare il metodo completamente gestito di Google Cloud. L'identità del servizio consente di limitare l'accesso del servizio ad altre alle risorse Google Cloud creando un account di servizio dedicato con autorizzazioni aggiuntive.

    1. Creare un account di servizio da utilizzare come "identità computing" del rendering completamente gestito di Google Cloud. 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" {
  provider     = google-beta
  account_id   = "renderer-identity"
  display_name = "Service identity of the Renderer (Backend) service."
}

      Il servizio di rendering Markdown non si integra direttamente con in Google Cloud. Non sono necessarie ulteriori autorizzazioni.

    2. Esegui il deployment con l'account di servizio renderer-identity e rifiuta le richieste non autenticate l'accesso.

      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 breve dell'account di servizio 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" {
  provider = google-beta
  name     = "renderer"
  location = "us-central1"
  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 del servizio di rendering privato di Markdown

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

Per inviare del testo in grassetto al servizio e vedere che converte gli asterischi markdown in Tag HTML <strong>:

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

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

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

  3. Crea una richiesta curl che passa 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 dell'elemento Servizio di rendering Markdown.

  4. La risposta deve essere uno snippet HTML:

     <strong>Hello Bold Text</strong>

Revisione dell'integrazione tra i servizi di editor e rendering

Il servizio di modifica fornisce una semplice interfaccia utente per l'inserimento di testo e uno spazio per visualizzare il codice HTML l'anteprima. Prima di continuare, controlla il codice recuperato in precedenza aprendo il Directory ./editor/.

Quindi, esplora le seguenti sezioni di codice che integra i due servizi.

Node.js

Il modulo render.js crea richieste autenticate al renderer privato completamente gestito di Google Cloud. Utilizza il server di metadati di Google Cloud nell'ambiente Cloud Run per creare un token di identità e aggiungere 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 in modo che 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 di Google Cloud in 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à all'account server mediante l'autenticazione 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 in modo che 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 come parte di un Intestazione Authorization.

In altri ambienti, RenderService richiede un token di identità all'account server mediante l'autenticazione con le Credenziali predefinite dell'applicazione.

import (
	"bytes"
	"context"
	"fmt"
	"io/ioutil"
	"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 di rendering dopo aver aggiunto il markup del testo da trasformare in HTML. Gli errori di risposta vengono gestiti per differenziare problemi di comunicazione dovuti alla 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 = ioutil.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 := ioutil.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 come private i servizi di machine learning. Utilizza il server di metadati di Google Cloud dell'ambiente Cloud Run per creare un token di identità e aggiungerlo Richiesta HTTP come parte di un'intestazione Authorization.

In altri ambienti, makeAuthenticatedRequest richiede un token di identità dai server di Google mediante l'autenticazione 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 in modo che 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 come private i servizi di machine learning. Utilizza il server di metadati di Google Cloud dell'ambiente Cloud Run per creare un token di identità e aggiungerlo Richiesta HTTP come parte di un'intestazione Authorization.

In altri ambienti, GetAuthenticatedPostResponse richiede un token di identità dai server di Google mediante l'autenticazione 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 in modo che 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 editor pubblico

Per creare ed eseguire il deployment del codice:

  1. Passa alla directory editor:

    Node.js 

    cd ../editor

    Python 

    cd ../editor

    Vai 

    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 progetto Google Cloud e editor è l'ID che vuoi assegnare al servizio.

    Se l'operazione riesce, verrà visualizzato il messaggio SUCCESS contenente l'ID, la creazione ora e nome dell'immagine. L'immagine è archiviata in Container Registry e può essere se lo desideri,

    Python 

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

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

    Se l'operazione riesce, verrà visualizzato il messaggio SUCCESS contenente l'ID, la creazione ora e nome dell'immagine. L'immagine è archiviata in Artifact Registry e può essere se lo desideri,

    Vai 

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

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

    Se l'operazione riesce, verrà visualizzato il messaggio SUCCESS contenente l'ID, la creazione ora e nome dell'immagine. L'immagine è archiviata in Artifact Registry e può essere se lo desideri,

    Java

    Questo esempio utilizza Jib per creare utilizzando strumenti Java comuni. Jib ottimizza le build di 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 progetto Google Cloud e editor è l'ID che vuoi assegnare al servizio.

    Se l'operazione riesce, verrà visualizzato un messaggio BUILD SUCCESS. L'immagine è archiviata in Artifact Registry e può essere riutilizzato, se necessario.

    C# 

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

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

    Se l'operazione riesce, verrà visualizzato il messaggio SUCCESS contenente l'ID, la creazione ora e nome dell'immagine. L'immagine è archiviata in Artifact Registry e può essere se lo desideri,

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

    1. Creare un account di servizio da utilizzare come "identità computing" dei privati completamente gestito di Google Cloud. 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" {
  provider     = google-beta
  account_id   = "editor-identity"
  display_name = "Service identity of the Editor (Frontend) service."
}

      Il servizio Editor non deve interagire con altri elementi in Google Cloud diversi dal servizio di rendering Markdown.

    2. Concedi l'accesso all'identità Compute editor-identity per richiamare Markdown di Google Cloud. Qualsiasi servizio che lo utilizza come identità di computing dispongono di 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" {
  provider = google-beta
  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 richiamar nel contesto del servizio di rendering, Il servizio di rendering è l'unico servizio Cloud Run privato dell'editor richiamare.

    3. Esegui il deployment con l'account di servizio editor-identity e autorizza il deployment di accesso 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 il tuo 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 di modifica:

      resource "google_cloud_run_v2_service" "editor" {
  provider = google-beta
  name     = "editor"
  location = "us-central1"
  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 per richiamare il servizio:

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

resource "google_cloud_run_service_iam_policy" "noauth" {
  provider = google-beta
  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

Sono tre le richieste HTTP coinvolte nel rendering markdown utilizzando questi servizi.

Diagramma che mostra il flusso di richieste dall&#39;utente all&#39;editor, editor per ottenere un token dal server metadati, editor per effettuare la richiesta di rendering del servizio, rendering del servizio per restituire l&#39;HTML all&#39;editor.
. Il servizio di frontend con editor-identity richiama il metodo di Google Cloud. Sia editor-identity che renderer-identity hanno autorizzazioni limitate, quindi qualsiasi l'exploit o l'inserimento di codice ha accesso limitato ad altre risorse Google Cloud.

Prova

Per provare l'applicazione completa per due servizi:

  1. Passa nel browser all'URL fornito nel passaggio di deployment riportato sopra.

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

    Dovrebbe avere il seguente aspetto:

    Screenshot dell&#39;interfaccia utente dell&#39;editor Markdown

Se scegli di continuare a sviluppare questi servizi, ricorda che sono limitato l'accesso IAM (Identity and Access Management) al resto di Google Cloud e dovranno disporre di ruoli IAM aggiuntivi per accedere a molti altri i servizi di machine learning.

Esegui la pulizia

Se hai creato un nuovo progetto per questo tutorial, elimina il progetto. Se hai utilizzato un progetto esistente e vuoi mantenerlo senza l'aggiunta delle modifiche In questo tutorial, elimina le risorse create per il tutorial.

Elimina il progetto

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

Per eliminare il progetto:

  1. In the Google Cloud console, go to the Manage resources page.

    Go to Manage resources

  2. In the project list, select the project that you want to delete, and then click Delete.
  3. In the dialog, type the project ID, and then click Shut down to delete the project.

Eliminazione delle risorse del tutorial in corso...

  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

    I servizi Cloud Run possono essere eliminati anche Console Google Cloud.

  2. Rimuovi le configurazioni predefinite di gcloud 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 altre risorse Google Cloud create in questo tutorial:

Passaggi successivi