Esta página se ha traducido con Cloud Translation API.

Recibir eventos de Pub/Sub en un endpoint HTTP interno de una red de VPC

En este tutorial se explica cómo crear un endpoint HTTP interno en una red de nube privada virtual (VPC) que recibe eventos de mensajes de Pub/Sub mediante Eventarc. Para obtener más información sobre este destino de eventos, consulta Dirigir eventos a un endpoint HTTP interno en una red de VPC.

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

Crear una red 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 a las instancias de máquina virtual de Compute Engine.

Cuando se crea una red VPC en modo personalizado, no se crea ninguna subred automáticamente. Este tipo de red le ofrece un control total sobre sus subredes e intervalos de IP.

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

Sustituye NETWORK_NAME por el nombre de la red VPC.

Ten en cuenta lo siguiente:

Cada red que cree debe tener un nombre único en el mismo proyecto.
El modo de enrutamiento Border Gateway Protocol (BGP) controla el comportamiento de los routers de Cloud Router en la red y puede ser global o regional. El valor predeterminado es regional.
La unidad máxima de transmisión (MTU) es el tamaño de paquete más grande de la red. El valor de MTU puede ser cualquiera entre 1300 y 8896. El valor predeterminado es 1460. Antes de definir la MTU con un valor superior a 1460, consulta Unidad máxima de transmisión.

Para obtener más información, consulta Crear y gestionar redes de VPC.

Crear una subred solo IPv4

Una red debe tener al menos una subred para poder usarla.

Cuando creas una subred, le asignas un nombre, una región y al menos un intervalo de direcciones IPv4 principal de acuerdo con las reglas de las subredes. Ten en cuenta que no puedes crear instancias en una región que no tenga ninguna subred definida.

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

Sustituye SUBNET_NAME por el nombre de la nueva subred.

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

Crear reglas de cortafuegos de VPC

Las reglas de cortafuegos de VPC te permiten permitir o denegar el tráfico entre recursos de una red de VPC en función del número de puerto, la etiqueta o el protocolo.

Las reglas de cortafuegos 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 único en el proyecto.

Crea una regla de cortafuegos para tu red de VPC que permita el tráfico entrante de cualquier dirección IPv4 (0.0.0.0/0) a cualquier instancia de la red mediante el puerto 22. Esta regla no es obligatoria para la entrega de eventos. Sin embargo, para este tutorial, crea la regla de forma que puedas conectarte a la VM mediante 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 cortafuegos para tu red de VPC que permita el tráfico entrante desde un intervalo de direcciones IP específico a cualquier instancia de la red mediante el puerto 80 (ya que vas a implementar 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
```
Sustituye RULE_NAME_ONE y RULE_NAME_TWO por nombres únicos para tus reglas de firewall.

Ten en cuenta que el uso de --source-ranges es opcional e indica una lista de bloques de direcciones IP que pueden establecer conexiones entrantes que coincidan con la regla de cortafuegos a las instancias de la red. En este caso, el intervalo coincide con el intervalo usado en la subred que has creado anteriormente.

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

Para obtener más información, consulta Usar reglas de cortafuegos de VPC.

Crear un archivo adjunto de red

Una vinculación de red es un recurso que permite que una red de VPC de un productor inicie conexiones con una red de VPC de un consumidor a través de una interfaz de Private Service Connect.

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

Puedes crear una vinculación de red que acepte automáticamente las conexiones de cualquier interfaz de Private Service Connect que haga referencia a la vinculación de red. Crea el adjunto de red en la misma red y región que contenga el servicio de destino HTTP.

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

Sustituye ATTACHMENT_NAME por el nombre de la conexión de red.

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

Crear 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 indistintamente. Las instancias de máquina virtual incluyen clústeres de Google Kubernetes Engine (GKE), instancias del entorno flexible de App Engine y otros Google Cloud productos creados en máquinas virtuales de Compute Engine.

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

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

Sustituye INSTANCE_NAME por el nombre de la VM.

Para obtener más información, consulta Crear e iniciar una instancia de VM.

Desplegar un receptor de eventos en la VM

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

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

Una vez que se haya establecido una conexión con el servidor SSH, usa el terminal SSH en el navegador para ejecutar comandos en tu instancia de VM.

En el terminal SSH en el navegador, crea un archivo de texto con el nombre 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 funcionamiento durante los pasos restantes de este tutorial:
```
sudo python3 server.py
```

Crear un activador de Eventarc

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

Después de habilitar la API Compute Engine, la cuenta de servicio predeterminada es la cuenta de servicio predeterminada de Compute Engine (PROJECT_NUMBER-compute@developer.gserviceaccount.com). Para hacer pruebas, 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

Sustituye PROJECT_NUMBER por el número de tu proyecto. Google Cloud Puedes encontrar el número de tu proyecto en la página Bienvenido de la consola Google Cloud o ejecutando el siguiente comando:

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

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

Generar y ver un evento de tema de Pub/Sub

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

Busca y define el tema de Pub/Sub como 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 endpoint HTTP interno de tu red VPC. En la terminal SSH en el navegador, se muestra el cuerpo del evento. Debería ser similar a lo 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= de su formato Base64, se devuelve "Hello World".

Ha desplegado correctamente un servicio de receptor de eventos en un endpoint HTTP interno en una red VPC, ha creado un activador de Eventarc, ha generado un evento desde Pub/Sub y ha confirmado que el activador ha enrutado el evento al endpoint de destino según lo previsto.