Configurare Cloud Endpoints gRPC per il servizio Knative con ESPv2
Questa pagina mostra come configurare Cloud Endpoints per Knative serving. Endpoints utilizza Extensible Service Proxy V2 (ESPv2) come gateway API. Per fornire la gestione delle API per Knative serving, esegui il deployment del contenitore ESPv2 predefinito in Knative serving 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 invocare il servizio. Quando il servizio risponde, ESPv2 raccoglie e registra la telemetria.
Per una panoramica di Endpoints, consulta Informazioni su Endpoints e Architettura di Endpoints.
Elenco attività
Utilizza il seguente elenco di attività man mano che svolgi il tutorial. Per completare questo tutorial, devi svolgere tutte le attività.
Crea un progetto Google Cloud e, se non hai eseguito il deployment del tuo servizio Knative, esegui il deployment di un servizio di esempio. Vedi Prima di iniziare.
Crea un cluster GKE con Knative serving abilitato.
Esegui il deployment di un servizio Knative serving gRPC di esempio.
Crea un documento di configurazione dell'API gRPC che descriva l'API Endpoints e configura le route per il servizio di pubblicazione Knative. Consulta Configurare Endpoints.
Esegui il deployment del documento di configurazione dell'API gRPC per creare un servizio gestito. Consulta Eseguire il deployment della configurazione di Endpoints.
Crea una nuova immagine Docker ESPv2 con la configurazione del servizio Endpoints. Consulta la sezione Creare una nuova immagine ESPv2.
Esegui il deployment della nuova immagine di Knative serving ESPv2. Consulta Eseguire il deployment dell'immagine Cloud Run ESPv2.
Crea una mappatura di dominio al servizio Knative serving ESPv2.
Testa la configurazione inviando una richiesta all'API.
Monitora l'attività nei tuoi servizi. Consulta Monitorare l'attività dell'API.
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.
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
- 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.
-
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.
-
Make sure that billing is enabled for your Google Cloud project.
- Prendi nota dell'ID progetto, perché ti servirà in seguito. Nel resto di questa pagina, questo ID progetto è indicato come ESP_PROJECT_ID.
- Scarica e installa gcloud CLI.
Configurazione della riga di comando gcloud
Per configurare lgcloud CLI per il servizio Knative per Anthos:
Assicurati che gcloud CLI sia autorizzata ad accedere ai tuoi dati e servizi.
Accedi.
gcloud auth login
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 nel servizio Knative.
Aggiorna i componenti
gcloud
installati:gcloud components update
Imposta la piattaforma su
gke
e imposta l'impostazione del progetto predefinito pergcloud
su quella che hai appena creato: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.
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, usa
us-central1-a
. Puoi utilizzare qualsiasi zona supportata da GKE.Abilita le seguenti API per il progetto, necessarie per creare un cluster, compilare e pubblicare un contenitore in Artifact Registry:
gcloud services enable container.googleapis.com artifactregistry.googleapis.com cloudbuild.googleapis.com
Creazione di un cluster GKE con Knative serving abilitato
Per creare un cluster e attivarlo per Knative serving su Google Cloud:
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 vuoi assegnare al cluster.
Sebbene queste istruzioni non consentano di utilizzare la scalabilità automatica dei cluster per ridimensionare i cluster in base alla domanda, Knative serving su Google Cloud scala automaticamente le istanze all'interno del cluster.
Attendi il completamento della creazione del cluster. Durante la procedura di creazione, dovresti visualizzare 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
. Ad esempio,1.15.11-gke.1
o1.14.10-gke.27
. Prendi nota della versione del cluster per utilizzarla in un secondo momento in questo documento.Imposta i valori predefiniti di
gcloud
in modo da utilizzare il nuovo cluster e la relativa posizione, per evitare di doverli specificare quando utilizzi gcloud CLI:gcloud config set run/cluster CLUSTER_NAME
gcloud config set run/cluster_location ZONE
Utilizza il seguente comando per visualizzare i dettagli del nuovo cluster:
gcloud container clusters describe CLUSTER_NAME
Utilizza il seguente comando per recuperare le credenziali per il cluster:
gcloud container clusters get-credentials CLUSTER_NAME
Eseguire il 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 appena creato:
Segui i passaggi descritti nella guida introduttiva di gRPC per Python per installare gRPC e gli strumenti gRPC.
Questo esempio di server gRPC contiene un'immagine Docker precompilata per il "servizio grpc-bookstore" Python:
gcr.io/endpointsv2/python-grpc-bookstore-server:2
. Utilizza il seguente 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 lo specifichi come servizio interno in modo che 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 dall'esterno del cluster. Per saperne di più, consulta i servizi Cloud Run.Per verificare che il servizio funzioni correttamente, esegui il deployment di un pod con la stessa immagine Docker nel cluster. L'immagine contiene il codice client gRPC per "grpc-bookstore" che puoi utilizzare per testare il servizio interno.
Utilizza il seguente comando
kubectl
per eseguire il deployment di un pod nello stesso cluster di cui hai eseguito il deployment in precedenza: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 client dall'interno del cluster.Nota: per le versioni più recenti di
kubectl
, il comando potrebbe emettere il seguente avviso:Flag --generator has been deprecated, has no effect and will be removed in the future".
Puoi ignorare questo avviso.
Ottieni il nome del pod "grpc-bookstore" creato nel cluster quando hai eseguito il deployment dell'immagine Docker nel passaggio precedente:
kubectl get pods
Dovresti vedere l'output nel seguente 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 In esecuzione.Utilizza il seguente comando per effettuare una richiesta 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 al cluster per effettuare una richiesta gRPC al servizio "grpc-bookstore" sul nome hostgrpc-bookstore.default.svc.cluster.local
.Se tutto funziona correttamente, dovresti visualizzare una risposta nel seguente formato:
ListShelves: shelves { id: 1 theme: "Fiction" } shelves { id: 2 theme: "Fantasy" }
Configurazione di Endpoints
Devi disporre di una specifica dell'API gRPC che descriva la piattaforma del tuo servizio di backend e gli eventuali requisiti di autenticazione.
Informazioni sull'impostazione del campo del nome della specifica dell'API gRPC
Nel campo name
della specifica dell'API gRPC, specifica il nome del servizio Endpoints utilizzato per accedere al servizio Cloud Run for Anthos. Il nome del servizio Endpoints è sotto forma di nome di dominio:
API_NAME.endpoints.ESP_PROJECT_ID.cloud.goog
Poiché il nome del servizio Endpoints corrisponde a un nome di dominio, deve rispettare 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 e configurare localmente.
Crea una nuova directory per la specifica dell'API gRPC, ad esempio
my-anthos-grpc
. Quindi vai a quella directory.Clona il repository Git in cui è ospitato il codice client gRPC nella nuova directory:
git clone https://github.com/GoogleCloudPlatform/python-docs-samples.git
Cambia la 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.
Crea un file descrittore protobuf autonomo dal file
.proto
del servizio:Crea la directory
generated_pb2
nella directory di lavoro.Crea il file descrittore
api_descriptor.pb
utilizzando il compilatore di buffer di protocolloprotoc
. Esegui questo comando nella directory contenentebookstore.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. Nell'ambiente di compilazione gRPC, se utilizzi una directory diversa per i file di input.proto
, modifica--proto_path
in modo che il compilatore cerchi nella directory in cui hai salvatobookstore.proto
.Modifica il file
api_config_anthos.yaml
nella directory di lavoro corrente (la stessa directory che contienebookstore.proto
) per aggiungere i seguenti contenuti 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.
Nel campo
name
, specifica il nome di dominio dell'API Endpoints utilizzata per accedere al servizio Cloud Run for Anthos, nel seguente formato:API_NAME.endpoints.ESP_PROJECT_ID.cloud.goog
Ad esempio:
grpc-bookstore-api.endpoints.ESP_PROJECT_ID.cloud.goog
La sezione
endpoints
registra una voce DNS per il servizio Endpoints nel dominiocloud.goog
, nel seguente 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:Vai alla pagina Google Kubernetes Engine nella console Cloud:
Fai clic su Servizi e ingress nel pannello di navigazione a sinistra per visualizzare un elenco di servizi.
Se la versione del cluster è
1.15.3-gke.19
o successiva,1.14.3-gke.12
o successiva o1.13.10-gke.8
o successiva, scorri verso il basso fino al servizioistio-ingress
. Per tutte le altre versioni del cluster, scorri verso il basso fino al servizioistio-ingressgateway
.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.
Il campo
address
nella sezionebackend
specifica il nome DNS interno del servizio Cloud Run "grpc-bookstore" con schema protogrpc://
e disattiva 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
Questo è necessario perché la chiamata da ESPv2 al servizio Cloud Run for Anthos viene eseguita come chiamata interna all'interno del cluster e quindi l'autenticazione non è necessaria.
Prendi nota del valore della proprietà
title
nel fileapi_config_authos.yaml
:title: Bookstore gRPC API In Cloud Run Anthos
Il valore della proprietà
title
diventa il nome del servizio Endpoints dopo il deployment della configurazione.Salva il documento dell'API gRPC.
Per informazioni sui campi nel documento OpenAPI richiesti da Endpoints, consulta Configurare Endpoints.
esegui 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:
Assicurati di essere nella directory che contiene il documento gRPC.
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 fileapi_config_anthos.yaml
. Il servizio Endpoints viene configurato in base al documento OpenAPI.Durante la creazione e la configurazione del servizio Endpoints, Service Management visualizza informazioni sul 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 della 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 configurazione del servizio è costituito da un timestamp seguito 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 di implementazione nella pagina Endpoints > Servizi della console Google Cloud.Se viene visualizzato un messaggio di errore, consulta la sezione Risoluzione dei problemi di deployment della configurazione di Endpoints.
Verifica dei servizi richiesti
Come minimo, Endpoints ed ESP richiedono l'attivazione dei seguenti servizi Google:Nome | Titolo |
---|---|
servicemanagement.googleapis.com |
API Service Management |
servicecontrol.googleapis.com |
API Service Control |
Nella maggior parte dei casi, il comando gcloud endpoints services deploy
attiva questi
servizi obbligatori. Tuttavia, il comando gcloud
viene completato correttamente, ma
non attiva 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 disattivati esplicitamente.
Utilizza il seguente comando per verificare che i servizi richiesti siano abilitati:
gcloud services list
Se non vedi i servizi richiesti nell'elenco, attivali:
gcloud services enable servicemanagement.googleapis.com
gcloud services enable servicecontrol.googleapis.com
Abilita anche il servizio Endpoints:
gcloud services enable ENDPOINTS_SERVICE_NAME
Per determinare ENDPOINTS_SERVICE_NAME, puoi:
Dopo aver eseguito il deployment della configurazione di Endpoints, vai alla pagina Endpoints nella console Cloud. L'elenco dei possibili ENDPOINTS_SERVICE_NAME è riportato nella colonna Nome servizio.
Per OpenAPI, ENDPOINTS_SERVICE_NAME è il valore specificato nel campo
host
della specifica OpenAPI. Per gRPC, ENDPOINTS_SERVICE_NAME è il valore specificato nel camponame
della configurazione degli endpoint gRPC.
Per ulteriori informazioni sui comandi gcloud
, consulta
Servizi gcloud
.
Creazione di una nuova immagine di pubblicazione Knative ESPv2
Crea la configurazione del servizio Endpoints in una nuova immagine Docker ESPv2. Dopo aver creato questa immagine, puoi eseguirne il deployment nel cluster.
Per compilare la configurazione del servizio in una nuova immagine Docker ESPv2:
Scarica questo script sulla tua macchina locale in cui è installata gcloud CLI ed eseguilo come segue:
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, compilarla in una nuova immagine ESPv2 e caricarla nel registry dei container del progetto. Lo script utilizza automaticamente la release più recente di ESPv2, indicata dal carattere 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
Eseguire il deployment dell'immagine Knative serving ESPv2
Esegui il deployment dell'immagine del servizio Knative serving ESPv2 nel tuo cluster:
Esegui il deployment del servizio ESPv2 Knative serving 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
.Se vuoi configurare Endpoints in modo da utilizzare opzioni di avvio ESPv2 aggiuntive, ad esempio l'attivazione 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, consulta Flag di Extensible Service Proxy 2.
Creazione di una mappatura di dominio al servizio Knative serving ESPv2
Per poter omettere l'intestazione host
quando effettui una richiesta, aggiungi una mappatura del dominio per il servizio ESPv2:
Seleziona Gestisci domini personalizzati.
Seleziona Aggiungi mappatura.
Nel menu a discesa, seleziona Aggiungi mappatura di dominio di servizio.
Nel campo Seleziona un servizio a cui eseguire la mappatura del popup Aggiungi mappatura, seleziona il servizio ESPv2.
Nel campo Inserisci il nome di dominio, specifica il nome di dominio che vuoi utilizzare per accedere al servizio di pubblicazione Knative 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
Fai clic su Continua. Viene visualizzato un riepilogo della mappatura.
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.
Assicurati di essere nella directory che contiene i tuoi documenti gRPC, ad esempio
api_config_anthos.yaml
.Installa le dipendenze:
pip3 install virtualenv
virtualenv env
source env/bin/activate
pip3 install -r requirements.txt
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 seguente formato:
ListShelves: shelves { id: 1 theme: "Fiction" } shelves { id: 2 theme: "Fantasy" }
Esamina i grafici delle attività della tua API nella pagina Endpoints > Servizi.
Vai alla pagina Servizi endpoint
La visualizzazione dei dati relativi alle richieste nei grafici può richiedere alcuni minuti.
Esamina i log delle richieste per la tua API nella pagina Esplora log.
Se non ricevi una risposta positiva, consulta la sezione Risoluzione dei problemi relativi alle risposte.
Hai eseguito il deployment e il test di un'API in Endpoints.
Configurare l'API Endpoints per l'utilizzo di HTTPS
Il supporto TLS automatico è disabilitato per impostazione predefinita per Knative serving su Google Cloud. Pertanto, in questo esempio, quando accedi all'API Endpoints tramite ESPv2, effettui la chiamata utilizzando HTTP.
Puoi configurare ESPv2 in modo che supporti le richieste che utilizzano HTTPS. Tieni presente che devi configurare il supporto di HTTPS su ESPv2, il servizio esterno, non su "hello", il servizio di backend interno.
Per supportare HTTPS con ESPv2, devi:
Possedere un dominio. Se non hai un dominio, puoi ottenerne uno da Google o da un altro fornitore di domini.
Crea una mappatura di dominio per il tuo servizio ESPv2 e aggiorna di conseguenza il record DNS 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.
Nella specifica OpenAPI di Endpoints:
Imposta il campo
name
in modo che rimandi al tuo dominio anziché a*.cloud.goog
.Rimuovi il tag
endpoints
e le sue due proprietà secondarie.
Per istruzioni e tutorial completi, vedi Attivare HTTPS e certificati TLS automatici.
monitora l'attività dell'API
Visualizza i grafici delle attività della tua API nella pagina Endpoints > Servizio nella console Google Cloud.
Visualizzare i grafici delle attività di Endpoints
La visualizzazione dei dati relativi alle richieste nei grafici può richiedere alcuni minuti.
Esamina i log delle richieste per la tua API nella pagina Esplora log.
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ù, consulta la 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 la sezione Eliminare un'API e le relative istanze per informazioni su come interrompere i servizi utilizzati da questo tutorial.