Configura gRPC de Cloud Endpoints para Knative serving con ESPv2
En esta página, se muestra cómo configurar Cloud Endpoints para Knative serving. Endpoints usa el proxy de servicio extensible V2 (ESPv2) como una puerta de enlace de la API. Si deseas proporcionar administración de API para Knative serving, implementa el contenedor de ESPv2 precompilado en Knative serving que se ejecuta en un clúster de GKE.
Con esta configuración, el ESPv2 intercepta todas las solicitudes a tus servicios y realiza las verificaciones necesarias (como la autenticación) antes de invocar el servicio. Cuando el servicio responde, ESPv2 recopila y, luego, informa la telemetría.
Para obtener una descripción general de Endpoints, consulta Acerca de Endpoints y Arquitectura de Cloud Endpoints.
Lista de tareas
Usa la siguiente lista de tareas mientras trabajas en el instructivo. Todas las tareas son obligatorias para completar el instructivo.
Crea un proyecto de Google Cloud y, si no implementaste tu propio Knative serving, implementa un servicio de muestra. Consulta Antes de comenzar.
Crea un clúster de GKE con Knative serving habilitado.
Implementa una muestra de gRPC del servicio de Knative serving.
Crea un documento de configuración de la API de gRPC que describa tu API de Endpoints y configura las rutas a tu servicio de Knative serving. Consulta Cómo configurar Endpoints.
Implementa el documento de configuración de la API de gRPC a fin de crear un servicio administrado. Consulta Cómo implementar la configuración de Endpoints.
Compila una nueva imagen de Docker del ESPv2 con tu configuración de servicio de Endpoints. Consulta Compila una imagen de ESPv2 nueva.
Implementa la nueva imagen ESPv2 Knative serving. Consulta Implementa la imagen de ESPv2 de Cloud Run.
Crea una asignación de dominio al servicio ESPv2 Knative serving.
Prueba la configuración mediante el envío de una solicitud a la API.
Realiza un seguimiento de la actividad de tus servicios. Consulta Cómo realizar un seguimiento de la actividad de la API.
Costos
En este documento, usarás los siguientes componentes facturables de Google Cloud:
Para generar una estimación de costos en función del uso previsto, usa la calculadora de precios.
Cuando finalices las tareas que se describen en este documento, puedes borrar los recursos que creaste para evitar que continúe la facturación. Para obtener más información, consulta Cómo realizar una limpieza.
Antes de comenzar
- Accede a tu cuenta de Google Cloud. Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de nuestros productos en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.
-
In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
-
Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.
-
In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
-
Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.
- Toma nota del ID del proyecto, ya que lo necesitarás más tarde. En el resto de esta página, este ID del proyecto se denomina ESP_PROJECT_ID.
- Descarga e instala gcloud CLI.
Configura la línea de comandos de gcloud
Si deseas configurar gcloud CLI para Knative serving para Anthos, haz lo siguiente:
Asegúrate de que gcloud CLI esté autorizada para acceder a tus datos y servicios.
Accede.
gcloud auth login
En la nueva pestaña del navegador que se abre, elige una cuenta que tenga el rol de Editor o Propietario en el proyecto de Google Cloud que creaste para implementar ESPv2 en Knative serving.
Actualiza los componentes de
gcloud
instalados:gcloud components update
Configura la plataforma en
gke
y establece la configuración del proyecto predeterminado paragcloud
al que acabas de crear:gcloud config set run/platform gke
gcloud config set project ESP_PROJECT_ID
Reemplaza ESP_PROJECT_ID por el ID del proyecto que creaste.
Configura la zona deseada del clúster nuevo. Puedes usar cualquier zona que admita GKE, por ejemplo:
gcloud config set compute/zone ZONE
Reemplaza ZONE por la zona. Por ejemplo, usa
us-central1-a
. Puedes usar cualquier zona que admita GKEHabilita las siguientes API para el proyecto, que son necesarias a fin de crear un clúster, y compilar y publicar un contenedor en Google Container Registry:
gcloud services enable container.googleapis.com containerregistry.googleapis.com cloudbuild.googleapis.com
Crea un clúster de GKE con Knative serving habilitado
Si deseas crear un clúster y habilitarlo para Knative serving en Google Cloud, haz lo siguiente:
Crea un clúster nuevo mediante el siguiente comando:
gcloud container clusters create CLUSTER_NAME \ --addons=HttpLoadBalancing,CloudRun \ --machine-type=n1-standard-4 \ --num-nodes=3
Reemplaza CLUSTER_NAME por el nombre que deseas para el clúster.
Aunque estas instrucciones no habilitan el ajuste de escala automático del clúster para cambiar el tamaño de los clústeres según la demanda, Knative serving en Google Cloud ajusta automáticamente las instancias dentro del clúster.
Espera a que termine de crearse el clúster. Durante el proceso de creación, deberías ver mensajes similares a los siguientes:
Creating cluster CLUSTER_NAME...done. Created [https://container.googleapis.com/v1/projects/ESP_PROJECT_ID/zones/ZONE/clusters/CLUSTER_NAME].
En el resultado, también se muestra la versión del clúster en la columna
NODE_VERSION
del resultado. Por ejemplo,1.15.11-gke.1
o1.14.10-gke.27
. Toma nota de la versión del clúster para usarla más adelante en este documento.Establece los valores predeterminados de
gcloud
para usar el clúster nuevo y la ubicación del clúster, a fin de evitar tener que especificarlos cuando uses gcloud CLI:gcloud config set run/cluster CLUSTER_NAME
gcloud config set run/cluster_location ZONE
Usa el siguiente comando para ver los detalles del clúster nuevo:
gcloud container clusters describe CLUSTER_NAME
Usa el siguiente comando a fin de recuperar credenciales para tu clúster:
gcloud container clusters get-credentials CLUSTER_NAME
Implementa un servicio de gRPC Cloud Run de muestra
Para implementar el contenedor "grpc-bookstore" de muestra de Cloud Run for Anthos en el clúster que acabas de crear, haz lo siguiente:
Sigue los pasos en la Guía de inicio rápido de Python de gRPC para instalar gRPC y sus herramientas.
Este muestra del servidor de gRPC contiene una imagen de Docker compilada de forma previa para el “grpc-bookstore service” de Python:
gcr.io/endpointsv2/python-grpc-bookstore-server:2
. Usa el siguiente comando para implementar "grpc-bookstore" en tu clúster:gcloud run deploy GRPC_SERVICE \ --image=gcr.io/endpointsv2/python-grpc-bookstore-server:2 \ --platform=gke \ --connectivity=internal \ --use-http2
Ten en cuenta que especificas esto como un servicio interno para que el servicio no sea accesible de manera externa.
Reemplaza GRPC_SERVICE por el nombre que deseas usar para el servicio. Por ejemplo:
gcloud run deploy grpc-bookstore \ --image=gcr.io/endpointsv2/python-grpc-bookstore-server:2 \ --platform=gke \ --connectivity=internal \ --use-http2
Cuando finalices, aparecerá el siguiente mensaje:
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
Cuando creas un servicio interno, GKE crea un nombre de DNS (
grpc-bookstore.default.svc.cluster.local
en este ejemplo) que solo se puede resolver en las solicitudes que se originan dentro del mismo clúster, no en las solicitudes externas. No puedes acceder a este DNS de forma externa desde el clúster. Consulta los servicios de Cloud Run para obtener más información.Para verificar que tu servicio funcione de forma adecuada, implementa un pod con la misma imagen de Docker en tu clúster. La imagen contiene el código del cliente de gRPC para "grpc-bookstore" que puedes usar con el fin de probar el servicio interno.
Usa el siguiente comando de
kubectl
para implementar un pod en el mismo clúster que implementaste antes:kubectl run grpc --generator=run-pod/v1 \ --image=gcr.io/endpointsv2/python-grpc-bookstore-server:2
Esta imagen contiene la secuencia de comandos
bookstore_client.py
que puedes usar para realizar solicitudes de cliente desde el interior del clúster.Nota: Para las versiones más recientes de
kubectl
, el comando puede emitir la siguiente advertencia:Flag --generator has been deprecated, has no effect and will be removed in the future".
Puedes ignorar esta advertencia.
Obtén el nombre del pod "grpc-bookstore" que se creó en tu clúster cuando implementaste la imagen de Docker en el paso anterior:
kubectl get pods
Deberías ver un resultado como el siguiente:
NAME READY STATUS RESTARTS AGE grpc 1/1 Running 0 23h
En el que
grp
el nombre del pod "grpc-bookstore". Asegúrate de que el Estado del pod sea Activo antes de continuar.Usa el siguiente comando para realizar una solicitud de cliente al servicio "grpc-bookstore":
kubectl exec grpc -ti -- python3 bookstore_client.py \ --host grpc-bookstore.default.svc.cluster.local --port=80
Este comando ejecuta la secuencia de comandos
bookstore_client.py
de forma interna en el clúster para realizar una solicitud de gRPC al servicio "grpc-bookstore" en el nombre de hostgrpc-bookstore.default.svc.cluster.local
.Si todo funciona correctamente, deberías ver una respuesta con el siguiente formato:
ListShelves: shelves { id: 1 theme: "Fiction" } shelves { id: 2 theme: "Fantasy" }
Configura Endpoints
Debes tener una especificación de la API de gRPC en la que se describan la superficie de tu servicio de backend y cualquier requisito de autenticación.
Información sobre la configuración del campo de nombre de la especificación de la API de gRPC
En el campo name
de la especificación de la API de gRPC, debes especificar el nombre del servicio de Endpoints que se usó para acceder al servicio de Cloud Run for Anthos. El nombre del servicio de Endpoints tiene la forma de un nombre de dominio:
API_NAME.endpoints.ESP_PROJECT_ID.cloud.goog
Debido a que el nombre del servicio de Endpoints corresponde a un nombre de dominio, el nombre debe seguir estas reglas:
- Debe contener solo letras en minúscula, números, puntos o guiones.
- No debe comenzar con un guion.
- No debe contener un guion bajo.
Por ejemplo:
grpc-boostore-api.endpoints.ESP_PROJECT_ID.cloud.goog
Crea la especificación de la API de gRPC
La muestra de bookstore-grpc contiene los archivos que necesitas copiar de manera local y configurar.
Crea un directorio nuevo para la especificación de la API de gRPC, como
my-anthos-grpc
. Luego, aplica CD en ese directorio.Clona el repositorio de Git en el que se aloja el código del cliente de gRPC en tu directorio nuevo:
git clone https://github.com/GoogleCloudPlatform/python-docs-samples.git
Cambia tu directorio de trabajo:
cd python-docs-samples/endpoints/bookstore-grpc/
Ten en cuenta que este directorio contiene el archivo bookstore.proto. Este archivo define la API del servicio de Bookstore.
Crea un archivo descriptor protobuf autónomo desde tu archivo de servicio
.proto
:Crea el directorio
generated_pb2
en el directorio de trabajo.Crea
api_descriptor.pb
, el archivo descriptor, mediante el compilador de búferes de protocoloprotoc
. Ejecuta el siguiente comando en el directorio que contienebookstore.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
En el comando anterior,
--proto_path
se configura como el directorio de trabajo actual. En tu entorno de compilación de gRPC, si usas un directorio diferente para los archivos de entrada.proto
, cambia--proto_path
a fin de que el compilador busque el directorio donde guardastebookstore.proto
.Modifica el archivo
api_config_anthos.yaml
en tu directorio de trabajo actual (el mismo directorio que contienebookstore.proto
) para agregar el siguiente contenido al archivo: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
La sangría es importante para el formato yaml.
En el campo
name
, especifica el nombre de dominio de la API de Endpoints que se usa para acceder a tu servicio de Cloud Run for Anthos, de la siguiente manera:API_NAME.endpoints.ESP_PROJECT_ID.cloud.goog
Por ejemplo:
grpc-bookstore-api.endpoints.ESP_PROJECT_ID.cloud.goog
En la sección
endpoints
, se registra una entrada de DNS para tu servicio de Endpoints en el dominiocloud.goog
, de la siguiente manera:endpoints: - name: API_NAME.endpoints.ESP_PROJECT_ID.cloud.goog target: IP_ADDRESS
IP_ADDRESS es la IP del servicio
istio-ingress
para tu clúster. Para determinar esta dirección IP, sigue estos pasos:Ve a la página de Google Kubernetes Engine en la consola de Cloud:
Haz clic en Ingress y servicios en el panel de navegación izquierdo para ver una lista de servicios.
Si la versión del clúster es
1.15.3-gke.19
,1.14.3-gke.12
1.13.10-gke.8
o posteriores, desplázate hacia abajo hasta el servicioistio-ingress
. Para ver las demás versiones del clúster, desplázate hacia abajo hasta el servicioistio-ingressgateway
.Copia la dirección IP externa que se muestra junto al balanceador de cargas, sin la configuración de puerto, si la hay. Por ejemplo, si la IP es
XX.XXX.XX.XXX:15020
, omite el:15020
. Ignora las otras direcciones IP enumeradas.
El campo
address
en la secciónbackend
especifica el nombre de DNS interno del servicio "grpc-bookstore" de Cloud Run con el esquema de protocologrpc://
, y, luego, inhabilita la autenticación para este servicio:address: grpc://GRPC_SERVICE.default.svc.cluster.local disable_auth: true
Por ejemplo:
address: grpc://grpc-bookstore.default.svc.cluster.local disable_auth: true
Esto es necesario porque la llamada de ESPv2 al servicio de Cloud Run for Anthos se realiza como una llamada interna desde el clúster y, por lo tanto, no es necesaria la autenticación.
Ten en cuenta el valor de la propiedad
title
del archivoapi_config_authos.yaml
:title: Bookstore gRPC API In Cloud Run Anthos
El valor de la propiedad
title
se convierte en el nombre del servicio de Endpoints después de que implementas la configuración.Guarda el documento de tu API de gRPC.
Para obtener información sobre los campos del documento de OpenAPI que requiere Endpoints, consulta Configura Endpoints.
Implemente la configuración de Endpoints
Para implementar la configuración de Endpoints, usa el comando gcloud endpoints services deploy. Este comando usa la Administración de servicios para crear un servicio administrado.
Para implementar la configuración de Endpoints:
Asegúrate de estar en el directorio que contiene el documento de gRPC.
Sube la configuración y crea un servicio administrado.
gcloud endpoints services deploy api_descriptor.pb api_config_anthos.yaml \ --project ESP_PROJECT_ID
Con este proceso, se crea un servicio de Endpoints nuevo con el nombre que especificaste en el campo
name
del archivoapi_config_anthos.yaml
. El servicio de Endpoints se configura según tu documento de OpenAPI.Mientras se crea y configura el servicio de Endpoints, Service Management exporta la información a la terminal. Cuando se completa la implementación, aparece un mensaje similar al siguiente:
Service Configuration [CONFIG_ID] uploaded for service [API_NAME.endpoints.ESP_PROJECT_ID.cloud.goog]
CONFIG_ID es el ID de configuración único del servicio de Endpoints que creó la implementación. Por ejemplo:
Service Configuration [2019-02-01r0] uploaded for service [grpc-bookstore-api.endpoints.ESP_PROJECT_ID.cloud.goog]
El ID de configuración de servicio consiste en una marca de fecha seguida de un número de revisión. Si vuelves a implementar
api_config_anthos.yaml
el mismo día, se incrementa el número de revisión en el ID de configuración del servicio. Puedes ver la configuración del servicio y el historial de implementaciones en la página Endpoints > Servicios de la consola de Google Cloud.Si recibes un mensaje de error, consulta Cómo solucionar problemas en la implementación de la configuración de Endpoints.
Verifica los servicios requeridos
Como mínimo, Endpoints y ESP requieren que se habiliten los siguientes servicios de Google:Name | Cargo |
---|---|
servicemanagement.googleapis.com |
API de Administración de servicios |
servicecontrol.googleapis.com |
API de Control de servicios |
endpoints.googleapis.com |
Google Cloud Endpoints |
En la mayoría de los casos, el comando de gcloud endpoints services deploy
habilita estos servicios obligatorios. Sin embargo, el comando gcloud
se completa de manera correcta sin habilitar los servicios requeridos en las circunstancias siguientes:
Usaste una aplicación de terceros, como Terraform, y no incluiste estos servicios.
Si implementaste la configuración de Endpoints en un proyecto existente de Google Cloud en el que se inhabilitaron explícitamente estos servicios
Usa el siguiente comando para confirmar que los servicios requeridos están habilitados:
gcloud services list
Si no ves los servicios necesarios que se incluyeron en la lista, habilítalos:
gcloud services enable servicemanagement.googleapis.comgcloud services enable servicecontrol.googleapis.com
gcloud services enable endpoints.googleapis.com
También habilita el servicio de Endpoints:
gcloud services enable ENDPOINTS_SERVICE_NAME
Para determinar la variable ENDPOINTS_SERVICE_NAME, puedes hacer lo siguiente:
Después de implementar la configuración de Endpoints, ve a la página Extremos en la consola de Cloud. La lista de posibles ENDPOINTS_SERVICE_NAME se muestra en la columna Nombre del servicio.
Para OpenAPI, el ENDPOINTS_SERVICE_NAME es lo que especificaste en el campo
host
de tu especificación de OpenAPI. Para gRPC, el ENDPOINTS_SERVICE_NAME es lo que especificaste en el camponame
de tu configuración de Endpoints de gRPC.
Para obtener más información sobre los comandos gcloud
, consulta servicios de gcloud
.
Compila una nueva imagen de ESPv2 Knative serving
Compila la configuración de servicio de Endpoints en una nueva imagen de Docker del ESPv2. Después de crear esta imagen, puedes implementarla en tu clúster.
Si quieres compilar la configuración de servicio en una imagen de Docker de ESPv2 nueva, sigue estos pasos:
Descarga esta secuencia de comandos en la máquina local donde está instalada gcloud CLI y ejecútala de la siguiente manera:
chmod +x gcloud_build_image
./gcloud_build_image -s API_NAME.endpoints.ESP_PROJECT_ID.cloud.goog \ -c CONFIG_ID -p ESP_PROJECT_ID
La secuencia de comandos usa el comando de
gcloud
para descargar la configuración del servicio, compilarla en una imagen ESPv2 nueva y subir la imagen nueva al registro de contenedores del proyecto. La secuencia de comandos usa automáticamente la última versión del ESPv2, indicada por ESP_VERSION en el nombre de la imagen de salida. La imagen resultante se sube a la siguiente ubicación:gcr.io/ESP_PROJECT_ID/endpoints-runtime-serverless:ESP_VERSION-API_NAME.endpoints.ESP_PROJECT_ID.cloud.goog-CONFIG_ID
Implementa la imagen ESPv2 Knative serving
Implementa la imagen de servicio de Knative serving de ESPv2 en tu clúster:
Implementa el servicio ESPv2 Knative serving con la imagen nueva:
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
En ESP_PROJECT_ID, especifica el nombre que deseas usar para el servicio ESPv2. En este ejemplo, configura ESP_V2_SERVICE_NAME como
espv2
.Si quieres configurar Endpoints para usar opciones adicionales de inicio de ESPv2, como habilitar CORS, puedes pasar los argumentos en la variable de entorno
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
Para obtener más información y ejemplos sobre cómo configurar la variable de entorno ESPv2_ARGS, incluida la lista de opciones disponibles y la información sobre cómo especificar varias opciones, consulta Marcas del proxy de servicio extensible V2.
Crea una asignación de dominio al servicio ESPv2 Knative serving
Para poder omitir el encabezado host
cuando realices una solicitud, agrega una asignación de dominio para el servicio del ESPv2:
Selecciona Administrar dominios personalizados.
Selecciona Agregar asignación.
En el menú desplegable, seleccione Agregar asignación de dominio de servicio.
En el campo Selecciona un servicio al que asignar en la ventana emergente Agregar asignación, selecciona el servicio del ESPv2.
En el campo Ingresar nombre de dominio, especifica el nombre de dominio que quieres usar para acceder a tu servicio de Knative serving a través de Endpoints. Por ejemplo, especifica:
API_NAME.endpoints.ESP_PROJECT_ID.cloud.goog
En el ejemplo anterior, API_NAME es el nombre de tu API de Endpoints. En este ejemplo, puedes usar “hello-api”:
grpc-bookstore-api.endpoints.ESP_PROJECT_ID.cloud.goog
Haga clic en Continuar. Aparecerá un resumen de la asignación.
Selecciona Listo para guardar la asignación.
Envía solicitudes a la API
Para enviar solicitudes a la API de muestra, puedes usar un cliente gRPC de muestra escrito en Python.
Asegúrate de estar en el directorio que contiene tus documentos de gRPC, como
api_config_anthos.yaml
.Instale las dependencias:
pip3 install virtualenv
virtualenv env
source env/bin/activate
pip3 install -r requirements.txt
Envía una solicitud a la API de muestra:
python3 bookstore_client.py --host API_NAME.endpoints.ESP_PROJECT_ID.cloud.goog --port 80
Por ejemplo:
python3 bookstore_client.py --host grpc-bookstore-api.endpoints.ESP_PROJECT_ID.cloud.goog --port 80
Si todo funciona correctamente, deberías ver una respuesta con el siguiente formato:
ListShelves: shelves { id: 1 theme: "Fiction" } shelves { id: 2 theme: "Fantasy" }
Para ver los grafos de actividad de tu API, ve a la página Endpoints > Servicios.
Ir a la página Servicios de Endpoints
La solicitud puede tardar unos minutos en reflejarse en los gráficos.
Revisa los registros de solicitud de tu API en la página del visor de registros.
Si no obtienes una respuesta correcta, consulta Solucionar errores en las respuestas.
Acabas de implementar y probar una API en Endpoints.
Configura la API de Endpoints para usar HTTPS
La compatibilidad automática con TLS está inhabilitada de forma predeterminada para Knative serving en Google Cloud. Por lo tanto, en este ejemplo, cuando accedes a la API de Endpoints a través del ESPv2, debes realizar la llamada mediante HTTP.
Puedes configurar el ESPv2 para admitir solicitudes mediante HTTPS. Ten en cuenta que debes configurar la compatibilidad con HTTPS en el ESPv2, el servicio externo, no en “hello”, el servicio de backend interno.
Para obtener la compatibilidad de HTTPS con el ESPv2, debes hacer lo siguiente:
Tener un dominio. Si no tienes un dominio, puedes obtener uno de Google o de otro proveedor de dominios.
Crea una asignación de dominio para tu servicio ESPv2 y actualiza tu registro DNS de acuerdo con las instrucciones en la página de asignación de dominios.
Si obtuviste el dominio de Google Domains, úsalo como servidor DNS. De lo contrario, usa Cloud DNS o el servidor DNS que prefieras. Usar un dominio de Google Domains es la opción más fácil.
En la especificación de OpenAPI de Endpoints, haz lo siguiente:
Configura el campo
name
para que haga referencia a tu dominio en lugar de a*.cloud.goog
.Quita la etiqueta
endpoints
y sus dos propiedades secundarias.
Para obtener instrucciones y instructivos completos, consulta Cómo habilitar HTTPS y certificados TLS automáticos.
Realiza un seguimiento de la actividad de la API
Consulta los gráficos de actividad de tu API en Endpoints > Servicio en la consola de Google Cloud.
Ver los gráficos de actividad de Endpoints
La solicitud puede tardar unos minutos en reflejarse en los gráficos.
Consulta los registros de solicitud de tu API en la página Explorador de registros.
Crea un portal de desarrolladores para la API
Puedes utilizar el Portal de Cloud Endpoints para crear un portal de desarrolladores, un sitio web en el que puedes interactuar con la API de muestra. Para obtener más información, consulta Descripción general del Portal de Cloud Endpoints.
Limpia
Sigue estos pasos para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos que usaste en esta página.
Consulta Borrar una API y las instancias de la API para obtener información acerca de cómo detener los servicios que se usan en este instructivo.