Configurazione di Cloud Endpoints gRPC per Cloud Run for Anthos con ESPv2

Questa pagina mostra come configurare Cloud Endpoints per Cloud Run for Anthos. Endpoints utilizza Extensible Service Proxy V2 (ESPv2) come gateway API. Per fornire la gestione delle API per Cloud Run for Anthos, esegui il deployment del container ESPv2 predefinito su Cloud Run for Anthos in esecuzione su un cluster GKE.

Con questa configurazione, ESPv2 intercetta tutte le richieste ai tuoi servizi ed esegue tutti i controlli necessari (ad esempio l'autenticazione) prima di richiamare il servizio. Quando il servizio risponde, ESPv2 raccoglie e segnala la telemetria.

Per una panoramica di Endpoints, vedi Informazioni sugli endpoint e sull'architettura degli endpoint.

Elenco attività

Utilizza il seguente elenco di attività mentre esegui il tutorial. Per completare questo tutorial sono necessarie tutte le attività.

  1. Crea un progetto Google Cloud e, se non hai eseguito il deployment di Cloud Run for Anthos, esegui il deployment di un servizio di esempio. Vedi Prima di iniziare.

  2. Crea un cluster GKE con Cloud Run for Anthos abilitato.

  3. Esegui il deployment di un servizio Cloud Run for Anthos di esempio gRPC.

  4. Crea un documento di configurazione API gRPC che descriva l'API Endpoints e configura le route al tuo servizio Cloud Run for Anthos. Vedi Configurazione di Endpoints.

  5. Esegui il deployment del documento di configurazione dell'API gRPC per creare un servizio gestito. Vedi Deployment della configurazione di Endpoints.

  6. Crea una nuova immagine Docker ESPv2 con la configurazione del servizio Endpoints. Consulta la sezione Creazione di una nuova immagine ESPv2.

  7. Esegui il deployment della nuova immagine ESPv2 Cloud Run for Anthos. Vedi Deployment dell'immagine Cloud Run ESPv2.

  8. Crea una mappatura di dominio al servizio ESPv2 Cloud Run for Anthos.

  9. Testa la configurazione inviando una richiesta all'API.

  10. Monitora l'attività relativa ai tuoi servizi. Consulta Monitoraggio dell'attività dell'API.

  11. Pulizia.

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 possono essere idonei a una prova senza costi aggiuntivi.

Una volta completate le attività descritte in questo documento, puoi evitare la fatturazione continua eliminando le risorse che hai creato. Per ulteriori informazioni, consulta la pagina Pulizia.

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 gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.

  2. Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.

    Vai al selettore progetti

  3. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

  4. Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.

    Vai al selettore progetti

  5. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

  6. Prendi nota dell'ID progetto perché ti servirà in un secondo momento. Nel resto di questa pagina, questo ID progetto è indicato come ESP_PROJECT_ID.
  7. Scarica e installa gcloud CLI.

Configurazione della riga di comando gcloud

Per configurare gcloud CLI for Cloud Run for Anthos for Anthos:

  1. Assicurati che gcloud CLI sia autorizzato ad accedere ai tuoi dati e servizi.

    1. Accedi. 

      gcloud auth login

    2. Nella nuova scheda del browser che si apre, scegli un account con il ruolo Editor o Proprietario nel progetto Google Cloud che hai creato per il deployment di ESPv2 in Cloud Run for Anthos.

  2. Aggiorna i componenti di gcloud installati: 

    gcloud components update

  3. Imposta la piattaforma su gke e configura l'impostazione predefinita del progetto per gcloud su quella appena creata: 

    gcloud config set run/platform gke
gcloud config set project ESP_PROJECT_ID

    Sostituisci ESP_PROJECT_ID con l'ID del progetto che hai creato.

  4. Imposta la zona desiderata per il nuovo cluster. Puoi utilizzare qualsiasi zona in cui GKE è supportato, ad esempio: 

    gcloud config set compute/zone ZONE

    Sostituisci ZONE con la tua zona. Ad esempio, utilizza us-central1-a. Puoi utilizzare qualsiasi zona supportata da GKE.

  5. Abilita per il progetto le seguenti API, necessarie per creare un cluster, generare e pubblicare un container in Google Container Registry: 

    gcloud services enable container.googleapis.com containerregistry.googleapis.com cloudbuild.googleapis.com

Creazione di un cluster GKE con Cloud Run for Anthos abilitato

Per creare un cluster e abilitarlo per Cloud Run for Anthos su Google Cloud:

  1. Crea un nuovo cluster utilizzando il comando: 

    gcloud container clusters create CLUSTER_NAME \
  --addons=HttpLoadBalancing,CloudRun \
  --machine-type=n1-standard-4 \
  --num-nodes=3

    Sostituisci CLUSTER_NAME con il nome che preferisci per il cluster.

    Sebbene queste istruzioni non abilitino la scalabilità automatica dei cluster per ridimensionare i cluster per la domanda, Cloud Run for Anthos su Google Cloud scala automaticamente le istanze all'interno del cluster.

  2. Attendi il completamento della creazione del cluster. Durante il processo di creazione, dovresti vedere messaggi simili ai seguenti: 

    Creating cluster CLUSTER_NAME...done.
Created [https://container.googleapis.com/v1/projects/ESP_PROJECT_ID/zones/ZONE/clusters/CLUSTER_NAME].

    L'output mostra anche la versione del cluster nella colonna NODE_VERSION dell'output. Ad esempio, 1.15.11-gke.1 o 1.14.10-gke.27. Prendi nota della versione del cluster da utilizzare più avanti in questo documento.

  3. Configura i valori predefiniti di gcloud per utilizzare la nuova località del cluster e del cluster, per evitare di dover specificare questi valori quando utilizzi gcloud CLI: 

    gcloud config set run/cluster CLUSTER_NAME
gcloud config set run/cluster_location ZONE

  4. Utilizza questo comando per visualizzare i dettagli del nuovo cluster: 

    gcloud container clusters describe CLUSTER_NAME

  5. Utilizza questo comando per recuperare le credenziali per il cluster: 

    gcloud container clusters get-credentials CLUSTER_NAME

Deployment di un servizio Cloud Run gRPC di esempio

Per eseguire il deployment del container di esempio Cloud Run for Anthos "grpc-bookstore" nel cluster che hai appena creato:

  1. Segui i passaggi nella guida rapida di gRPC per Python per installare gli strumenti gRPC e gRPC.

  2. Questo esempio di server gRPC contiene un'immagine Docker precompilata per il "servizio grpc-bookstore" Python: gcr.io/endpointsv2/python-grpc-bookstore-server:2. Usa questo comando per eseguire il deployment di "grpc-bookstore" nel tuo cluster:

    gcloud run deploy GRPC_SERVICE \
  --image=gcr.io/endpointsv2/python-grpc-bookstore-server:2 \
  --platform=gke \
 --connectivity=internal \
  --use-http2

    Tieni presente che devi specificare questo servizio come interno, in modo che il servizio non sia accessibile dall'esterno.

    Sostituisci GRPC_SERVICE con il nome che vuoi assegnare al servizio. Ad esempio:

    gcloud run deploy grpc-bookstore \
  --image=gcr.io/endpointsv2/python-grpc-bookstore-server:2 \
  --platform=gke \
  --connectivity=internal \
  --use-http2

    Al termine, viene visualizzato il seguente messaggio:

    Service [grpc-bookstore] revision [grpc-bookstore-00001-nuk] has been deployed and is serving 100 percent of traffic at http://grpc-bookstore.default.svc.cluster.local

    Quando crei un servizio interno, GKE crea un nome DNS (grpc-bookstore.default.svc.cluster.local in questo esempio) che può essere risolto solo per le richieste provenienti dall'interno del cluster stesso, non per le richieste esterne. Non puoi accedere a questo DNS esternamente dal cluster. Per saperne di più, consulta Servizi Cloud Run.

  3. Per verificare che il servizio funzioni correttamente, esegui il deployment di un pod con la stessa immagine Docker nel tuo cluster. L'immagine contiene il codice client gRPC per "grpc-bookstore" che puoi utilizzare per testare il servizio interno.

    1. Utilizza il seguente comando kubectl per eseguire il deployment di un pod nello stesso cluster di cui hai eseguito il deployment sopra:

      kubectl run grpc --generator=run-pod/v1 \
  --image=gcr.io/endpointsv2/python-grpc-bookstore-server:2

      Questa immagine contiene lo script bookstore_client.py che puoi utilizzare per effettuare richieste del client dall'interno del cluster.

      Nota: per le versioni più recenti di kubectl, il comando potrebbe generare il seguente avviso:

      Flag --generator has been deprecated, has no effect and will be removed in the future".

      Puoi ignorare questo avviso.

    2. Ottieni il nome del pod "grpc-bookstore" creato nel tuo cluster quando hai eseguito il deployment dell'immagine Docker nel passaggio precedente:

      kubectl get pods

      Dovresti vedere l'output nel formato:

      NAME   READY    STATUS    RESTARTS   AGE
grpc   1/1      Running   0          23h

      Dove grp il nome del pod "grpc-bookstore". Prima di continuare, assicurati che lo stato del pod sia Running.

    3. Utilizza questo comando per inviare una richiesta del client al servizio "grpc-bookstore":

      kubectl exec grpc -ti -- python3 bookstore_client.py \
  --host grpc-bookstore.default.svc.cluster.local --port=80

      Questo comando esegue lo script bookstore_client.py internamente sul cluster per effettuare una richiesta gRPC al servizio "grpc-bookstore" sul nome host grpc-bookstore.default.svc.cluster.local.

      Se tutto funziona correttamente, dovresti visualizzare una risposta nel modulo:

      ListShelves: shelves {
  id: 1
  theme: "Fiction"
}
shelves {
  id: 2
  theme: "Fantasy"
}

Configurazione di Endpoints

Devi avere una specifica dell'API gRPC che descriva la superficie del servizio di backend ed eventuali requisiti di autenticazione.

Informazioni sull'impostazione del campo nome della specifica dell'API gRPC

Nel campo name della specifica dell'API gRPC, devi specificare il nome del servizio Endpoints utilizzato per accedere al servizio Cloud Run for Anthos. Il nome del servizio Endpoints ha il formato di un nome di dominio:

API_NAME.endpoints.ESP_PROJECT_ID.cloud.goog

Poiché il nome del servizio Endpoints corrisponde a un nome di dominio, il nome deve seguire le seguenti regole:

  • Deve contenere solo lettere minuscole, numeri, punti o trattini.
  • Non deve iniziare con un trattino.
  • Non deve contenere un trattino basso.

Ad esempio:

grpc-boostore-api.endpoints.ESP_PROJECT_ID.cloud.goog

Creazione della specifica dell'API gRPC

L'esempio bookstore-grpc contiene i file che devi copiare localmente e configurare.

  1. Crea una nuova directory per la specifica dell'API gRPC, ad esempio my-anthos-grpc. Quindi premi CD in questa directory.

  2. Clona il repository Git in cui è ospitato il codice client gRPC nella nuova directory:

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

  3. Cambia directory di lavoro:

    cd python-docs-samples/endpoints/bookstore-grpc/

    Tieni presente che questa directory contiene il file bookstore.proto. Questo file definisce l'API del servizio Bookstore.

  4. Crea un file descrittore protobuf autonomo dal file .proto di servizio:

    1. Crea la directory generated_pb2 sotto la directory di lavoro.

    2. Crea il file descrittore, api_descriptor.pb, utilizzando il compilatore dei buffer di protocollo protoc. Esegui questo comando nella directory contenente bookstore.proto:

      python3 -m grpc_tools.protoc \
--include_imports \
--include_source_info \
--proto_path=. \
--descriptor_set_out=api_descriptor.pb \
--python_out=generated_pb2 \
--grpc_python_out=generated_pb2 \
bookstore.proto

    Nel comando precedente, --proto_path è impostato sulla directory di lavoro corrente. Se utilizzi una directory diversa per i file di input .proto nel tuo ambiente di build gRPC, modifica --proto_path in modo che il compilatore cerchi nella directory in cui hai salvato bookstore.proto.

  5. Modifica il file api_config_anthos.yaml nella directory di lavoro corrente (la stessa directory che contiene bookstore.proto) per aggiungere il seguente contenuto al file: 

    type: google.api.Service
config_version: 3
#
# Name of the service configuration.
#
name: API_NAME.endpoints.ESP_PROJECT_ID.cloud.goog
#
# API title to appear in the user interface (Google Cloud console).
#
title: Bookstore gRPC API In Cloud Run Anthors
apis:
- name: endpoints.examples.bookstore.Bookstore
#
# Create a DNS record to map your service name to IP address
#
endpoints:
  - name: API_NAME.endpoints.ESP_PROJECT_ID.cloud.goog
    target: IP_ADDRESS
#
# Specify the backend address to route to
#
backend:
  rules:
    - selector: "*"
      address: grpc://GRPC_SERVICE.default.svc.cluster.local
      disable_auth: true
#
# API usage restrictions.
#
usage:
  rules:
  # ListShelves methods can be called without an API Key.
  - selector: endpoints.examples.bookstore.Bookstore.ListShelves
    allow_unregistered_calls: true

    Il rientro è importante per il formato YAML.

  6. Nel campo name, specifica il nome di dominio dell'API Endpoints utilizzata per accedere al servizio Cloud Run for Anthos nel formato:

    API_NAME.endpoints.ESP_PROJECT_ID.cloud.goog

    Ad esempio:

    grpc-bookstore-api.endpoints.ESP_PROJECT_ID.cloud.goog

  7. La sezione endpoints registra una voce DNS per il servizio Endpoints sul dominio cloud.goog, nel formato:

    endpoints:
  - name: API_NAME.endpoints.ESP_PROJECT_ID.cloud.goog
    target: IP_ADDRESS

    IP_ADDRESS è l'IP del servizio istio-ingress per il tuo cluster. Per determinare questo indirizzo IP:

    1. Vai alla pagina Google Kubernetes Engine nella console Cloud:

      Vai a Google Kubernetes Engine

    2. Fai clic su Services & Ingress (Servizi e Ingress) nel pannello di navigazione a sinistra per visualizzare un elenco di servizi.

    3. Se la versione del tuo cluster è 1.15.3-gke.19 o successiva, 1.14.3-gke.12 o successiva o 1.13.10-gke.8 o successiva, scorri verso il basso fino al servizio istio-ingress. Per tutte le altre versioni del cluster, scorri verso il basso fino al servizio istio-ingressgateway.

    4. Copia l'indirizzo IP esterno mostrato accanto al bilanciatore del carico, senza l'impostazione della porta, se presente. Ad esempio, se l'IP è XX.XXX.XX.XXX:15020, ometti :15020. Ignora gli altri indirizzi IP elencati.

  8. Il campo address nella sezione backend specifica il nome DNS interno del servizio Cloud Run "grpc-bookstore" con schema di protocollo grpc:// e disabilita l'autenticazione a questo servizio:

    address: grpc://GRPC_SERVICE.default.svc.cluster.local
disable_auth: true

    Ad esempio:

    address: grpc://grpc-bookstore.default.svc.cluster.local
disable_auth: true

    Ciò è necessario perché la chiamata da ESPv2 al servizio Cloud Run for Anthos viene effettuata come chiamata interna dall'interno del cluster, per cui l'autenticazione non è necessaria.

  9. Prendi nota del valore della proprietà title nel file api_config_authos.yaml:

    title: Bookstore gRPC API In Cloud Run Anthos

    Il valore della proprietà title diventa il nome del servizio Endpoints dopo che hai eseguito il deployment della configurazione.

  10. Salva il documento dell'API gRPC.

Per informazioni sui campi del documento OpenAPI richiesto da Endpoints, vedi Configurazione di Endpoints.

Eseguire il deployment della configurazione di Endpoints

Per eseguire il deployment della configurazione di Endpoints, utilizza il comando gcloud endpoints services deploy. Questo comando utilizza Service Management per creare un servizio gestito.

Per eseguire il deployment della configurazione di Endpoints:

  1. Assicurati di trovarti nella directory che contiene il documento gRPC.

  2. Carica la configurazione e crea un servizio gestito. 

    gcloud endpoints services deploy api_descriptor.pb api_config_anthos.yaml \
  --project ESP_PROJECT_ID

    Viene creato un nuovo servizio Endpoints con il nome specificato nel campo name del file api_config_anthos.yaml. Il servizio Endpoints è configurato in base al documento OpenAPI.

    Durante la creazione e la configurazione del servizio Endpoints, Service Management invia le informazioni al terminale. Al termine del deployment, viene visualizzato un messaggio simile al seguente: 

    Service Configuration [CONFIG_ID] uploaded for service [API_NAME.endpoints.ESP_PROJECT_ID.cloud.goog]

    CONFIG_ID è l'ID univoco di configurazione del servizio Endpoints creato dal deployment. Ad esempio: 

    Service Configuration [2019-02-01r0] uploaded for service [grpc-bookstore-api.endpoints.ESP_PROJECT_ID.cloud.goog]

    L'ID di configurazione del servizio è composto da un'indicazione della data seguita da un numero di revisione. Se esegui di nuovo il deployment di api_config_anthos.yaml nello stesso giorno, il numero di revisione viene incrementato nell'ID configurazione del servizio. Puoi visualizzare la configurazione del servizio e la cronologia del deployment nella pagina Endpoint > Servizi nella console Google Cloud.

    Se viene visualizzato un messaggio di errore, vedi Risoluzione dei problemi di deployment della configurazione di Endpoints.

Controllo dei servizi richiesti in corso...

Come minimo, Endpoints ed ESP richiedono che siano abilitati i seguenti servizi Google:
Nome Titolo
servicemanagement.googleapis.com API Service Management
servicecontrol.googleapis.com API Service Control
endpoints.googleapis.com Google Cloud Endpoints

Nella maggior parte dei casi, il comando gcloud endpoints services deploy abilita questi servizi richiesti. Tuttavia, il comando gcloud viene completato correttamente, ma non abilita i servizi richiesti nelle seguenti circostanze:

  • Se hai utilizzato un'applicazione di terze parti come Terraform e non includi questi servizi.

  • Hai eseguito il deployment della configurazione di Endpoints in un progetto Google Cloud esistente in cui questi servizi sono stati disabilitati esplicitamente.

Utilizza il comando seguente per confermare che i servizi richiesti siano abilitati:

gcloud services list

Se i servizi richiesti non sono elencati, attivali:

gcloud services enable servicemanagement.googleapis.com
gcloud services enable servicecontrol.googleapis.com
gcloud services enable endpoints.googleapis.com

Abilita anche il servizio Endpoints:

gcloud services enable ENDPOINTS_SERVICE_NAME

Per determinare i ENDPOINTS_SERVICE_NAME puoi:

  • Dopo aver eseguito il deployment della configurazione di Endpoints, vai alla pagina Endpoint nella console Cloud. L'elenco dei possibili ENDPOINTS_SERVICE_NAME è visualizzato nella colonna Nome servizio.

  • Per OpenAPI, il valore ENDPOINTS_SERVICE_NAME è quello specificato nel campo host della specifica OpenAPI. Per gRPC, il valore ENDPOINTS_SERVICE_NAME è quello specificato nel campo name della configurazione degli endpoint gRPC.

Per ulteriori informazioni sui comandi gcloud, consulta la pagina relativa ai servizi gcloud.

Creazione di una nuova immagine ESPv2 Cloud Run for Anthos

Crea la configurazione del servizio Endpoints in una nuova immagine Docker ESPv2. Dopo aver creato questa immagine, puoi eseguirne il deployment nel cluster.

Per creare la configurazione del servizio in una nuova immagine Docker ESPv2:

  1. Scarica questo script sulla macchina locale in cui è installato gcloud CLI ed eseguilo come:

    chmod +x gcloud_build_image
./gcloud_build_image -s API_NAME.endpoints.ESP_PROJECT_ID.cloud.goog \
-c CONFIG_ID -p ESP_PROJECT_ID

    Lo script utilizza il comando gcloud per scaricare la configurazione del servizio, creare la configurazione del servizio in una nuova immagine ESPv2 e caricare la nuova immagine nel registro dei container del progetto. Lo script utilizza automaticamente l'ultima release di ESPv2, indicata con ESP_VERSION nel nome dell'immagine di output. L'immagine di output viene caricata in:

    gcr.io/ESP_PROJECT_ID/endpoints-runtime-serverless:ESP_VERSION-API_NAME.endpoints.ESP_PROJECT_ID.cloud.goog-CONFIG_ID

Deployment dell'immagine ESPv2 Cloud Run for Anthos

Esegui il deployment dell'immagine del servizio ESPv2 Cloud Run for Anthos nel cluster:

  1. Esegui il deployment del servizio ESPv2 Cloud Run for Anthos con la nuova immagine: 

    gcloud run deploy ESP_V2_SERVICE_NAME \
  --image="gcr.io/ESP_PROJECT_ID/endpoints-runtime-serverless:API_NAME.endpoints.ESP_PROJECT_ID.cloud.goog-CONFIG_ID" \
  --platform gke \
  --use-http2 \
  --project=ESP_PROJECT_ID

    Per ESP_PROJECT_ID, specifica il nome che vuoi utilizzare per il servizio ESPv2. In questo esempio, imposta ESP_V2_SERVICE_NAME su espv2.

  2. Se vuoi configurare Endpoints in modo che utilizzi ulteriori opzioni di avvio ESPv2, ad esempio l'abilitazione di CORS, puoi passare gli argomenti nella variabile di ambiente ESPv2_ARGS: 

    gcloud run deploy ESP_V2_SERVICE_NAME \
  --image="gcr.io/ESP_PROJECT_ID/endpoints-runtime-serverless:API_NAME.endpoints.ESP_PROJECT_ID.cloud.goog-CONFIG_ID" \
  --set-env-vars=ESPv2_ARGS=--cors_preset=basic \
  --platform gke --use-http2 \
  --project ESP_PROJECT_ID

    Per ulteriori informazioni ed esempi sull'impostazione della variabile di ambiente ESPv2_ARGS, incluso l'elenco delle opzioni disponibili e informazioni su come specificare più opzioni, vedi Flag di Extensible Service Proxy V2.

Creazione di una mappatura di dominio al servizio ESPv2 Cloud Run for Anthos

Per poter omettere l'intestazione host quando effettui una richiesta, aggiungi una mappatura di dominio per il servizio ESPv2:

  1. Vai a Cloud Run

  2. Seleziona Gestisci domini personalizzati.

  3. Seleziona Aggiungi mappatura.

  4. Dal menu a discesa, seleziona Aggiungi mappatura del dominio di servizio.

  5. Nel campo Seleziona un servizio a cui mappare del popup Aggiungi mappatura, seleziona il tuo servizio ESPv2.

  6. Nel campo Inserisci il nome di dominio, specifica il nome di dominio che vuoi utilizzare per accedere al servizio Cloud Run for Anthos tramite Endpoints. Ad esempio, specifica: 

    API_NAME.endpoints.ESP_PROJECT_ID.cloud.goog

    Dove API_NAME è il nome dell'API Endpoints. Per questo esempio puoi utilizzare "hello-api": 

    grpc-bookstore-api.endpoints.ESP_PROJECT_ID.cloud.goog

  7. Fai clic su Continua. Viene visualizzato un riepilogo della mappatura.

  8. Seleziona Fine per salvare la mappatura.

Invia richieste all'API

Per inviare richieste all'API di esempio, puoi utilizzare un client gRPC di esempio scritto in Python.

  1. Assicurati di trovarti nella directory che contiene i documenti gRPC, ad esempio api_config_anthos.yaml.

  2. Installa le dipendenze:

    pip3 install virtualenv
virtualenv env
source env/bin/activate
pip3 install -r requirements.txt

  3. Invia una richiesta all'API di esempio:

    python3 bookstore_client.py --host API_NAME.endpoints.ESP_PROJECT_ID.cloud.goog --port 80

    Ad esempio:

    python3 bookstore_client.py --host grpc-bookstore-api.endpoints.ESP_PROJECT_ID.cloud.goog --port 80

    Se tutto funziona correttamente, dovresti visualizzare una risposta nel modulo:

    ListShelves: shelves {
  id: 1
  theme: "Fiction"
}
shelves {
  id: 2
  theme: "Fantasy"
}

Se non ricevi una risposta corretta, consulta la sezione Risoluzione dei problemi relativi agli errori di risposta.

Hai appena eseguito il deployment e il test di un'API in Endpoints.

Configurazione dell'API Endpoints per l'utilizzo di HTTPS

Il supporto TLS automatico è disabilitato per impostazione predefinita per Cloud Run for Anthos su Google Cloud. Pertanto, in questo esempio, quando accedi all'API Endpoints tramite ESPv2, effettuerai la chiamata utilizzando HTTP.

Puoi configurare ESPv2 in modo da supportare le richieste tramite HTTPS. Tieni presente che configuri il supporto HTTPS su ESPv2, il servizio esterno, non su "hello", il servizio di backend interno.

Per supportare HTTPS con ESPv2, devi:

  1. Possedere un dominio. Se non hai un dominio, puoi ottenerne uno da Google o da un altro fornitore di domini.

  2. Crea una mappatura di dominio per il tuo servizio ESPv2 e aggiorna il tuo record DNS di conseguenza seguendo le istruzioni riportate nella pagina di mappatura dei domini.

    Se hai ottenuto il tuo dominio da Google Domains, utilizzalo come server DNS. In caso contrario, utilizza Cloud DNS o un server DNS a tua scelta. L'utilizzo di un dominio di Google Domains è l'opzione più semplice.

  3. Nella specifica OpenAPI di Endpoints:

    1. Imposta il campo name in modo che faccia riferimento al tuo dominio anziché su *.cloud.goog.

    2. Rimuovi il tag endpoints e le due proprietà secondarie.

Per istruzioni complete e tutorial, vedi Abilitazione di HTTPS e dei certificati TLS automatici.

Monitora l'attività dell'API

  1. Visualizza i grafici delle attività per la tua API nella pagina Endpoint > Servizio nella console Google Cloud.

    Visualizzare i grafici delle attività di Endpoints

    Potrebbero essere necessari alcuni istanti prima che la richiesta venga riportata nei grafici.

  2. Esamina i log delle richieste per la tua API nella pagina Esplora log.

    Visualizzare i log delle richieste di Endpoints

Creazione di un portale per gli sviluppatori per l'API

Puoi utilizzare il portale Cloud Endpoints per creare un portale per gli sviluppatori, un sito web che puoi utilizzare per interagire con l'API di esempio. Per saperne di più, vedi Panoramica del portale Cloud Endpoints.

Esegui la pulizia

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questa pagina, segui questi passaggi.

Consulta Eliminazione di un'API e istanze API per informazioni sull'interruzione dei servizi utilizzati da questo tutorial.

Passaggi successivi