Recibe eventos de Pub/Sub en un extremo HTTP interno en una red de VPC

En este instructivo, se muestra cómo crear un extremo HTTP interno en una red de nube privada virtual (VPC) que recibe eventos de mensajes de Pub/Sub con Eventarc. Para obtener más información sobre este destino del evento, consulta Enruta eventos a un extremo HTTP interno en una red de VPC.

Puedes ejecutar los siguientes comandos con Google Cloud CLI en la terminal o en Cloud Shell.

Objetivos

En este instructivo, podrás:

Crear una red de VPC para proporcionar herramientas de redes para tus recursos y servicios basados en la nube. Una red de VPC está aislada de forma lógica de otras redes en Google Cloud.
Crea una subred. Cada red de VPC consta de uno o más rangos de direcciones IP llamados subredes. Las subredes son recursos regionales y tienen rangos de direcciones IP asociados.
Crear reglas de firewall de VPC para permitir o denegar tráfico hacia o desde las instancias de VM (máquina virtual) en la red de VPC.
Crear un adjunto de red que permita a una red de VPC del productor iniciar conexiones a una red de VPC del consumidor.
Crear una instancia de VM de Compute Engine en la red de VPC.
Implementar un servidor web como un servicio del receptor de eventos en la instancia de VM.
Crear un activador de Eventarc que enrute los eventos de Pub/Sub al receptor de eventos en tu instancia de VM.
Establecer una conexión SSH a la instancia de VM.
Publicar un mensaje en un tema de Pub/Sub para generar un evento y visualizar el cuerpo del evento en la herramienta SSH en el navegador.

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. Es posible que los usuarios nuevos de Google Cloud califiquen para obtener una prueba gratuita.

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.

Instala Google Cloud CLI.

Para inicializar la CLI de gcloud, ejecuta el siguiente comando:

gcloud init

Crea o selecciona un proyecto de Google Cloud.

Crea un proyecto de Google Cloud:
```
gcloud projects create PROJECT_ID
```
Reemplaza PROJECT_ID por un nombre para el proyecto de Google Cloud que estás creando.
Selecciona el proyecto de Google Cloud que creaste:
```
gcloud config set project PROJECT_ID
```
Reemplaza PROJECT_ID por el nombre del proyecto de Google Cloud.

Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

Habilita las APIs de Compute Engine, Eventarc, and Pub/Sub:

gcloud services enable compute.googleapis.com eventarc.googleapis.com pubsub.googleapis.com

Instala Google Cloud CLI.

Para inicializar la CLI de gcloud, ejecuta el siguiente comando:

gcloud init

Crea o selecciona un proyecto de Google Cloud.

Crea un proyecto de Google Cloud:
```
gcloud projects create PROJECT_ID
```
Reemplaza PROJECT_ID por un nombre para el proyecto de Google Cloud que estás creando.
Selecciona el proyecto de Google Cloud que creaste:
```
gcloud config set project PROJECT_ID
```
Reemplaza PROJECT_ID por el nombre del proyecto de Google Cloud.

Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

Habilita las APIs de Compute Engine, Eventarc, and Pub/Sub:

gcloud services enable compute.googleapis.com eventarc.googleapis.com pubsub.googleapis.com

Actualiza los componentes de Google Cloud CLI:
```
gcloud components update
```
Accede con tu cuenta:
```
gcloud auth login
```
Establece las variables de configuración que se usan en esta guía de inicio rápido:
```
REGION=us-central1
ZONE=us-central1-a
```
Si eres el creador del proyecto, se te otorga el rol de propietario básico (roles/owner). De forma predeterminada, este rol de Identity and Access Management (IAM) incluye los permisos necesarios para obtener acceso completo a la mayoría de los recursos de Google Cloud, pero puedes omitir este paso.

Si no eres el creador del proyecto, se deben otorgar los permisos necesarios en el proyecto a la principal correspondiente. Por ejemplo, una principal puede ser una Cuenta de Google (para usuarios finales) o una cuenta de servicio (para aplicaciones y cargas de trabajo de procesamiento). Para obtener más información, consulta la página Roles y permisos para el destino del evento.
Permisos necesarios

Si quieres obtener los permisos que necesitas para completar esta guía de inicio rápido, pídele a tu administrador que te otorgue los siguientes roles de IAM en tu proyecto:
- Administrador de la red de Compute (roles/compute.networkAdmin)
- Administrador de seguridad de Compute (roles/compute.securityAdmin)
- Administrador de Eventarc (roles/eventarc.admin)
- Descriptor de acceso de vista de registros (roles/logging.viewAccessor)
- Administrador de IAM de proyecto (roles/resourcemanager.projectIamAdmin)
- Publicador de Pub/Sub (roles/pubsub.publisher)
- Administrador de cuenta de servicio (roles/iam.serviceAccountAdmin)
- Usuario de cuenta de servicio (roles/iam.serviceAccountUser)
- Administrador de Service Usage (roles/serviceusage.serviceUsageAdmin)
Si quieres obtener más información para otorgar funciones, consulta Administra el acceso.

También puedes obtener los permisos necesarios a través de roles personalizados o cualquier otro rol predefinido.
Si habilitaste el agente de servicio de Cloud Pub/Sub el 8 de abril de 2021 o antes de esa fecha, para admitir las solicitudes de envío de Pub/Sub autenticadas, otorga el rol Creador de tokens de cuenta de servicio (roles/iam.serviceAccountTokenCreator) a la cuenta de servicio administrada por Google. De lo contrario, este rol se otorga de forma predeterminada:
```
gcloud projects add-iam-policy-binding PROJECT_ID \
    --member=serviceAccount:service-PROJECT_NUMBER@gcp-sa-pubsub.iam.gserviceaccount.com \
    --role=roles/iam.serviceAccountTokenCreator
```
Reemplaza lo siguiente:
- PROJECT_ID: El ID del proyecto de Google Cloud.
- PROJECT_NUMBER: el número de tu proyecto de Google Cloud. Para encontrar el número del proyecto, ve a la página de bienvenida de la consola de Google Cloud o ejecuta el siguiente comando:
```
gcloud projects describe PROJECT_ID --format='value(projectNumber)'
```

Crea una red de VPC en modo personalizado.

Una red de VPC es una versión virtual de una red física que se implementa en la red de producción de Google. Proporciona conectividad para las instancias de VM de Compute Engine.

Cuando se crea una red de VPC de modo personalizado, no se crean subredes automáticamente. Este tipo de red te proporciona control total sobre sus subredes y rangos de IP.

gcloud compute networks create NETWORK_NAME \
    --subnet-mode=custom \
    --bgp-routing-mode=regional \
    --mtu=1460

Reemplaza NETWORK_NAME por un nombre para la red de VPC.

Ten en cuenta lo siguiente:

Cada red nueva que crees debe tener un nombre único dentro del mismo proyecto.
El modo de enrutamiento del protocolo de puerta de enlace de frontera (BGP) controla el comportamiento de Cloud Routers en la red y puede ser global o regional. El valor predeterminado es regional.
La unidad de transmisión máxima (MTU) es el tamaño de paquete más grande de la red. La MTU se puede establecer en cualquier valor entre 1300 y 8896. El valor predeterminado es 1460. Antes de configurar la MTU en un valor superior a 1460, revisa la Unidad de transmisión máxima.

Para obtener más información, consulta Crea y administra redes de VPC.

Crea una subred de solo IPv4

Una red debe tener, al menos, una subred para que puedas usarla.

Cuando creas una subred, estableces un nombre, una región y, al menos, un rango de direcciones IPv4 principal según las reglas de subredes. Ten en cuenta que no puedes crear instancias en una región que no tenga una subred definida.

gcloud compute networks subnets create SUBNET_NAME \
    --region=$REGION \
    --network=NETWORK_NAME \
    --range=10.10.10.0/24

Reemplaza SUBNET_NAME por un nombre para la subred nueva.

Para obtener más información, consulta Subredes.

Crea reglas de firewall de VPC

Las reglas de firewall de VPC permiten o rechazan el tráfico entre recursos en una red de VPC según el número de puerto, la etiqueta o el protocolo.

Las reglas de firewall de VPC se definen a nivel de red y solo se aplican a la red en la que se crean; sin embargo, el nombre que elijas para una regla debe ser exclusivo del proyecto.

Crea una regla de firewall para tu red de VPC que permita el tráfico de entrada de cualquier dirección IPv4 (0.0.0.0/0) a cualquier instancia en la red que usa el puerto 22. Esta regla no es necesaria para la entrega de eventos. Sin embargo, a los fines de este instructivo, crea la regla para que puedas conectarte a la VM con SSH y confirmar la entrega del evento:
```
gcloud compute firewall-rules create RULE_NAME_ONE \
    --network=projects/PROJECT_ID/global/networks/NETWORK_NAME \
    --direction=INGRESS \
    --priority=65534 \
    --action=ALLOW \
    --source-ranges=0.0.0.0/0 \
    --rules=tcp:22
```
Crea una regla de firewall para tu red de VPC que permita el tráfico de entrada desde un rango de direcciones IP específico a cualquier instancia de la red con el puerto 80 (ya que implementarás un servidor web en tu VM que escucha en el puerto 80):
```
gcloud compute firewall-rules create RULE_NAME_TWO \
    --network=projects/PROJECT_ID/global/networks/NETWORK_NAME \
    --direction=INGRESS \
    --priority=1000 \
    --action=ALLOW \
    --source-ranges=10.10.10.0/24 \
    --rules=tcp:80
```
Reemplaza RULE_NAME_ONE y RULE_NAME_TWO por nombres únicos para tus reglas de firewall.

Ten en cuenta que usar --source-ranges es opcional y, además, indica una lista de bloques de direcciones IP que pueden realizar conexiones entrantes que coincidan con la regla de firewall en las instancias de la red. En este caso, el rango coincide con el rango que se usa en la subred que creaste antes.

Te recomendamos que uses la marca para aplicar tu regla de firewall específicamente al tráfico de Eventarc. Si no se especifican --source-ranges ni --source-tags, el valor predeterminado de --source-ranges es 0.0.0.0/0, lo que significa que la regla se aplica a todas las conexiones IPv4 entrantes dentro o fuera de la red.

Para obtener más información, consulta Reglas de firewall de VPC.

Crea un adjunto de red

Un adjunto de red es un recurso que permite que una red de VPC del productor inicie conexiones a una red de VPC del consumidor a través de una interfaz de Private Service Connect.

Para publicar eventos, Eventarc usa el adjunto de red para establecer una conexión con el extremo HTTP interno alojado en una red de VPC.

Puedes crear un adjunto de red que acepte conexiones de forma automática desde cualquier interfaz de Private Service Connect que haga referencia al adjunto de red. Crea el adjunto de red en la misma red y región que contiene el servicio de destino HTTP.

gcloud compute network-attachments create ATTACHMENT_NAME \
    --region=$REGION \
    --subnets=SUBNET_NAME \
    --connection-preference=ACCEPT_AUTOMATIC

Reemplaza ATTACHMENT_NAME por un nombre para el adjunto de red.

Para obtener más información, consulta Acerca de los adjuntos de red.

Crea una instancia de VM en una subred específica

Una instancia de VM de Compute Engine es una máquina virtual alojada en la infraestructura de Google. Los términos instancia de Compute Engine, instancia de VM y VM son sinónimos y se usan de manera intercambiable. Las instancias de VM incluyen clústeres de Google Kubernetes Engine (GKE), instancias del entorno flexible de App Engine y otros productos de Google Cloud compilados en VMs de Compute Engine.

Crea una instancia de VM de Compute Engine en la red de VPC en la que puedas implementar un servicio del receptor de eventos.

gcloud compute instances create INSTANCE_NAME \
      --zone=$ZONE \
      --machine-type=e2-medium \
      --subnet=SUBNET_NAME

Reemplaza INSTANCE_NAME por un nombre para la VM.

Para obtener más información, consulta Crea y, luego, inicia una instancia de VM.

Implementa un receptor de eventos en la VM

Implementa un servidor web en la VM que escuche en el puerto 80 y reciba y registre eventos.

Establece una conexión SSH a tu instancia de VM con el botón SSH en la consola de Google Cloud para conectarte a tu VM.

Después de establecer una conexión al servidor SSH, usa la terminal SSH en el navegador para ejecutar comandos en la instancia de VM.

En la terminal SSH del navegador, crea un archivo de texto con el nombre de archivo server.py que contenga el siguiente código de Python:

#!/usr/bin/env python3
from http.server import BaseHTTPRequestHandler, HTTPServer
import logging

class S(BaseHTTPRequestHandler):
    def _set_response(self):
        self.send_response(200)
        self.send_header('Content-type', 'text/html')
        self.end_headers()

    def do_GET(self):
        logging.info("GET request,\nPath: %s\nHeaders:\n%s\n", str(self.path), str(self.headers))
        self._set_response()
        self.wfile.write("GET request for {}".format(self.path).encode('utf-8'))

    def do_POST(self):
        content_length = int(self.headers['Content-Length'])
        post_data = self.rfile.read(content_length)
        logging.info("POST request,\nPath: %s\nHeaders:\n%s\n\nBody:\n%s\n",
                str(self.path), str(self.headers), post_data.decode('utf-8'))

        self._set_response()
        self.wfile.write("POST request for {}".format(self.path).encode('utf-8'))

def run(server_class=HTTPServer, handler_class=S, port=80):
    logging.basicConfig(level=logging.INFO)
    server_address = ('', port)
    http_server = server_class(server_address, handler_class)
    logging.info('Starting HTTP Server at port %d...\n', port)
    try:
        http_server.serve_forever()
    except KeyboardInterrupt:
        pass
    http_server.server_close()
    logging.info('Stopping HTTP Server...\n')

if __name__ == '__main__':
    from sys import argv

    if len(argv) == 2:
        run(port=int(argv[1]))
    else:
        run()

Inicia el servidor y mantenlo en ejecución para los pasos restantes de este instructivo:
```
sudo python3 server.py
```

Crea un activador de Eventarc

Crea un activador de Eventarc que cree un nuevo tema de Pub/Sub y enrute eventos al receptor de eventos implementado en la VM cuando se publique un mensaje en el tema de Pub/Sub.

Después de habilitar la API de Compute Engine, la cuenta de servicio predeterminada es la cuenta de servicio predeterminada de Compute Engine (PROJECT_NUMBER-compute@developer.gserviceaccount.com). Para fines de prueba, el activador usa esta cuenta de servicio predeterminada para su identidad.

gcloud eventarc triggers create TRIGGER_NAME \
    --location=$REGION \
    --destination-http-endpoint-uri=http://INSTANCE_NAME.$ZONE.c.PROJECT_ID.internal \
    --network-attachment="projects/PROJECT_ID/regions/$REGION/networkAttachments/ATTACHMENT_NAME" \
    --event-filters="type=google.cloud.pubsub.topic.v1.messagePublished" \
    --service-account=PROJECT_NUMBER-compute@developer.gserviceaccount.com

Reemplaza PROJECT_NUMBER por el número de proyecto de Google Cloud. Para encontrar el número del proyecto, ve a la página de bienvenida de la consola de Google Cloud o ejecuta el siguiente comando:

gcloud projects describe PROJECT_ID --format='value(projectNumber)'

Para obtener más información sobre cómo configurar el activador, consulta Enruta eventos a un extremo HTTP interno en una red de VPC.

Genera y visualiza un evento de tema de Pub/Sub

Puedes generar un evento si publicas un mensaje en un tema de Pub/Sub.

Busca y establece el tema Pub/Sub como una variable de entorno:

export MY_TOPIC=$(gcloud eventarc triggers describe TRIGGER_NAME \
    --location=$REGION \
    --format='value(transport.pubsub.topic)')

Publica un mensaje en el tema de Pub/Sub para generar un evento:
```
gcloud pubsub topics publish $MY_TOPIC --message "Hello World"
```
El activador de Eventarc enruta el evento al extremo HTTP interno en la red de VPC. En la terminal SSH del navegador, el cuerpo del evento es el resultado. Debería ser similar al siguiente:
```
Body:
{
    "message": {
        "data": "SGVsbG8gV29ybGQ=",
        "messageId": "8795720366614192",
        "publishTime": "2023-08-26T13:09:48Z"
    }
}

10.10.10.3 - - [26/Aug/2023 13:09:49] "POST / HTTP/1.1" 200 -
```
Ten en cuenta que, si decodificas el valor data de SGVsbG8gV29ybGQ= desde el formato Base64, se muestra "Hello World".

Implementaste un servicio del receptor de eventos en un extremo HTTP interno en una red de VPC de forma correcta, creaste un activador de Eventarc, generaste un evento de Pub/Sub y confirmaste que el activador enrutó el evento al extremo objetivo según lo esperado.

Limpia

Para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos usados en este instructivo, borra el proyecto que contiene los recursos o conserva el proyecto y borra los recursos individuales.

Borra el proyecto

Precaución: Borrar un proyecto tiene estas consecuencias:

Se borra todo en el proyecto. Si usaste un proyecto existente para las tareas de este documento, cuando lo borres, también se borrará cualquier otro trabajo que hayas realizado en el proyecto.
Se pierden los ID personalizados de proyectos. Cuando creaste este proyecto, es posible que hayas creado un ID del proyecto personalizado que desees utilizar en el futuro. Para conservar las URL que utilizan el ID del proyecto, como una URL appspot.com, borra los recursos seleccionados dentro del proyecto en lugar de borrar todo el proyecto.

Si planeas explorar varias infraestructuras, instructivos y guías de inicio rápido la reutilización de proyectos puede ayudarte a evitar exceder los límites de las cuotas del proyecto.

Borra un proyecto de Google Cloud:

gcloud projects delete PROJECT_ID

Borra los recursos individuales

Borrar el activador de Eventarc:

gcloud eventarc triggers delete TRIGGER_NAME --location=$REGION

Borra la instancia:

gcloud compute instances delete INSTANCE_NAME

Borra el adjunto de red:

gcloud compute network-attachments delete ATTACHMENT_NAME --region=$REGION

Borra las reglas de firewall:

gcloud compute firewall-rules delete RULE_NAME_ONE
gcloud compute firewall-rules delete RULE_NAME_TWO

Borra la subred:

gcloud compute networks subnets delete SUBNET_NAME --region=$REGION

Borra la red de VPC:

gcloud compute networks delete NETWORK_NAME