Se usó la API de Cloud Translation para traducir esta página.
Switch to English

Comienza a usar Endpoints para Cloud Run for Anthos con el ESPv2

En esta página, se muestra cómo configurar Cloud Endpoints para Cloud Run for Anthos. 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 Cloud Run for Anthos, implementa el contenedor de ESPv2 antes compilado en Cloud Run for Anthos 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.

  1. Crea un proyecto de Google Cloud y, si no has implementado tu propio Cloud Run for Anthos, implementa un servicio de muestra. Consulta Antes de comenzar.

  2. Crea un clúster de GKE con Cloud Run for Anthos habilitado.

  3. Implementa una muestra de gRPC del servicio de Cloud Run for Anthos.

  4. 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 Cloud Run for Anthos. Consulta Cómo configurar Endpoints.

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

  6. Compila una nueva imagen de Docker del ESPv2 con tu configuración de servicio de Endpoints. Consulta Compila una imagen de ESPv2 nueva.

  7. Implementa la nueva imagen de ESPv2 de Cloud Run for Anthos. Consulta Implementa la imagen de ESPv2 de Cloud Run.

  8. Crea una asignación de dominio al servicio de ESPv2 de Cloud Run for Anthos.

  9. Prueba la configuración mediante el envío de una solicitud a la API.

  10. Realiza un seguimiento de la actividad de tus servicios. Consulta Cómo realizar un seguimiento de la actividad de la API.

  11. Realiza una limpieza.

Antes de comenzar

  1. Accede a tu Cuenta de Google.

    Si todavía no tienes una cuenta, regístrate para obtener una nueva.

  2. En la página del selector de proyectos de Google Cloud Console, selecciona o crea un proyecto de Google Cloud.

    Ir a la página del selector de proyectos

  3. Asegúrate de que la facturación esté habilitada para tu proyecto de Cloud. Descubre cómo confirmar que tienes habilitada la facturación en un proyecto.

  4. 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.
  5. Descarga y, luego, instala el SDK de Cloud.

Configura la línea de comandos de gcloud

Para configurar la línea de comandos de gcloud de Cloud Run for Anthos, sigue estos pasos:

  1. Asegúrate de que el SDK de Cloud esté autorizado para acceder a tus datos y servicios.

    1. Accede.

      gcloud auth login

    2. En la nueva pestaña del navegador que se abre, elige una cuenta que tenga la función Editor o Propietario en el proyecto de Google Cloud que creaste para implementar ESPv2 en Cloud Run for Anthos.

  2. Actualiza los componentes de gcloud instalados:

    gcloud components update
  3. Configura la plataforma en gke y establece la configuración del proyecto predeterminado para gcloud 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.

  4. 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 GKE

  5. Habilita 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 Cloud Run for Anthos habilitado

Para crear un clúster y habilitarlo en Cloud Run for Anthos en Google Cloud, haz lo siguiente:

  1. 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 \
      --enable-stackdriver-kubernetes

    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, Cloud Run for Anthos en Google Cloud realiza el ajuste de escala automático de las instancias dentro del clúster.

  2. 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 o 1.14.10-gke.27. Toma nota de la versión del clúster para usarla más adelante en este documento.

  3. Configura 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 la línea de comandos de gcloud:

    gcloud config set run/cluster CLUSTER_NAME
    gcloud config set run/cluster_location ZONE
  4. Usa el siguiente comando para ver los detalles del clúster nuevo:

    gcloud container clusters describe CLUSTER_NAME
  5. 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:

  1. Sigue los pasos en la Guía de inicio rápido de Python de gRPC para instalar gRPC y sus herramientas.

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

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

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

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

    3. 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 host grpc-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.

  1. Crea un directorio nuevo para la especificación de la API de gRPC, como my-anthos-grpc. Luego, aplica CD en ese directorio.

  2. 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
  3. 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.

  4. Crea un archivo descriptor protobuf autónomo desde tu archivo de servicio .proto:

    1. Crea el directorio generated_pb2 en el directorio de trabajo.

    2. Crea api_descriptor.pb, el archivo descriptor, mediante el compilador de búferes de protocolo protoc. Ejecuta el siguiente comando en el directorio que contiene 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

    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 guardaste bookstore.proto.

  5. Modifica el archivo api_config_anthos.yaml en tu directorio de trabajo actual (el mismo directorio que contiene bookstore.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.

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

  7. En la sección endpoints, se registra una entrada de DNS para tu servicio de Endpoints en el dominio cloud.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:

    1. Ve a la página de Google Kubernetes Engine en Cloud Console:

      Ir a Google Kubernetes Engine

    2. Haz clic en Ingress y servicios en el panel de navegación izquierdo para ver una lista de servicios.

    3. Si la versión del clúster es 1.15.3-gke.191.14.3-gke.121.13.10-gke.8 o posteriores, desplázate hacia abajo hasta el servicio istio-ingress. Para ver las demás versiones del clúster, desplázate hacia abajo hasta el servicio istio-ingressgateway.

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

  8. El campo address en la sección backend especifica el nombre de DNS interno del servicio "grpc-bookstore" de Cloud Run con el esquema de protocolo grpc://, 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.

  9. Ten en cuenta el valor de la propiedad title del archivo api_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.

  10. 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:

  1. Asegúrate de estar en el directorio que contiene el documento de gRPC.

  2. 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 archivo api_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 Cloud Console.

    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.com
gcloud 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 Endpoints en Cloud Console. 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 campo name 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 de Cloud Run for Anthos

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:

  1. Descarga esta secuencia de comandos a tu máquina local donde está instalado el SDK de gcloud y ejecútala como:

    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 de ESPv2 de Cloud Run for Anthos

Implementa la imagen de servicio de ESPv2 de Cloud Run for Anthos en tu clúster:

  1. Implementa el servicio ESPv2 de Cloud Run for Anthos con la nueva imagen:

    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.

  2. 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 de ESPv2 de Cloud Run for Anthos

Para poder omitir el encabezado host cuando realices una solicitud, agrega una asignación de dominio para el servicio del ESPv2:

  1. Ir a Cloud Run

  2. Selecciona Administrar dominios personalizados.

  3. Selecciona Agregar asignación.

  4. En el menú desplegable, seleccione Agregar asignación de dominio de servicio.

  5. En el campo Selecciona un servicio al que asignar en la ventana emergente Agregar asignación, selecciona el servicio del ESPv2.

  6. En el campo Ingresar nombre de dominio, especifica el nombre de dominio que deseas usar para acceder a tu servicio de Cloud Run for Anthos 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. Para este ejemplo, puedes usar “hello-api”:

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

  7. Haga clic en Continuar. Aparecerá un resumen de la asignación.

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

  1. Asegúrate de estar en el directorio que contiene tus documentos de gRPC, como api_config_anthos.yaml.

  2. Instale las dependencias:

    pip3 install virtualenv
    virtualenv env
    source env/bin/activate
    pip3 install -r requirements.txt
  3. 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"
    }

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 Cloud Run for Anthos 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:

  1. Tener un dominio. Si no tienes un dominio, puedes obtener uno de Google o de otro proveedor de dominios.

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

  3. En la especificación de OpenAPI de Endpoints, haz lo siguiente:

    1. Configura el campo name para que haga referencia a tu dominio en lugar de a *.cloud.goog.

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

  1. Consulta los gráficos de actividad de tu API en la página Endpoints > Servicios de Cloud Console.

    Ver los gráficos de actividad de Endpoints

    La solicitud puede tardar unos minutos en reflejarse en los gráficos.

  2. Consulta los registros de solicitud de tu API en la página Visor de registros.

    Ver los registros de solicitud de Endpoints

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.

Realiza una limpieza

Sigue estos pasos para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos que usaste en esta guía de inicio rápido.

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.

¿Qué sigue?