Ricevere eventi Pub/Sub in un endpoint HTTP interno in una rete VPC

Crea una rete VPC in modalità personalizzata

Una rete VPC è una versione virtuale di una rete fisica implementata all'interno della rete di produzione di Google. Fornisce connettività per le tue istanze VM di Compute Engine.

Quando viene creata una rete VPC in modalità personalizzata, non vengono create automaticamente subnet. Questo tipo di rete ti offre il controllo completo sulle subnet e sugli intervalli IP corrispondenti.

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

Sostituisci NETWORK_NAME con un nome per la rete VPC.

Tieni presente quanto segue:

• Ogni nuova rete che crei deve avere un nome univoco all'interno dello stesso progetto.
• La modalità di routing Border Gateway Protocol (BGP) controlla il comportamento dei router Cloud nella rete e può essere global o regional. Il valore predefinito è regional.
• L'unità massima di trasmissione (MTU) è la dimensione massima del pacchetto della rete. L'MTU può essere impostata su qualsiasi valore compreso tra 1300 e 8896. Il valore predefinito è 1460. Prima di impostare l'MTU su un valore superiore a 1460, consulta Unità massima di trasmissione.

Per scoprire di più, consulta la pagina Creare e gestire reti VPC.

Crea una subnet solo IPv4

Per poter essere usata, una rete deve avere almeno una subnet.

Quando crei una subnet, imposti un nome, una regione e almeno un intervallo di indirizzi IPv4 principale in base alle regole della subnet. Tieni presente che non puoi creare istanze in una regione in cui non è definita alcuna subnet.

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

Sostituisci SUBNET_NAME con un nome per la nuova subnet.

Per saperne di più, vedi Subnet.

Crea regole firewall VPC

Le regole firewall VPC consentono o negano il traffico tra le risorse in una rete VPC in base al numero di porta, al tag o al protocollo.

Le regole firewall VPC sono definite a livello di rete e si applicano solo alla rete in cui vengono create; tuttavia, il nome scelto per una regola deve essere univoco per il progetto.

1. Crea una regola firewall per la tua rete VPC che consenta il traffico in entrata da qualsiasi indirizzo IPv4 (0.0.0.0/0) a qualsiasi istanza sulla rete utilizzando la porta 22. Questa regola non è obbligatoria per la pubblicazione di eventi. Tuttavia, ai fini di questo tutorial, crea la regola in modo da poterti connettere alla VM utilizzando SSH e confermare la distribuzione dell'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

2. Crea una regola firewall per la tua rete VPC che consenta il traffico in entrata da un intervallo di indirizzi IP specifico a qualsiasi istanza sulla rete utilizzando la porta 80 (in quanto verrà eseguito il deployment di un server web sulla tua VM che è in ascolto sulla porta 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

   Sostituisci RULE_NAME_ONE e RULE_NAME_TWO con nomi univoci per le regole firewall.

   Tieni presente che l'utilizzo di --source-ranges è facoltativo e indica un elenco di blocchi di indirizzi IP autorizzati a stabilire connessioni in entrata che corrispondono alla regola firewall alle istanze sulla rete. In questo caso, l'intervallo corrisponde a quello utilizzato nella subnet creata in precedenza.

   Ti consigliamo di utilizzare il flag per applicare la regola firewall in modo specifico al traffico Eventarc. Se non vengono specificati né --source-ranges né --source-tags, --source-ranges viene impostato per impostazione predefinita su 0.0.0.0/0, il che significa che la regola si applica a tutte le connessioni IPv4 in entrata dall'interno o dall'esterno della rete.

Per saperne di più, consulta Utilizzare le regole firewall VPC.

Crea un collegamento di rete

Un collegamento di rete è una risorsa che consente a una rete VPC producer di avviare connessioni a una rete VPC consumer tramite un'interfaccia Private Service Connect.

Per pubblicare eventi, Eventarc utilizza il collegamento di rete per stabilire una connessione all'endpoint HTTP interno ospitato in una rete VPC.

Puoi creare un collegamento di rete che accetta automaticamente le connessioni da qualsiasi interfaccia Private Service Connect che fa riferimento al collegamento di rete. Crea il collegamento di rete nella stessa rete e regione contenente il servizio di destinazione HTTP.

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

Sostituisci ATTACHMENT_NAME con un nome per l'allegato di rete.

Per saperne di più, vedi Informazioni sui collegamenti di rete.

Crea un'istanza VM in una subnet specificata

Un'istanza VM di Compute Engine è una macchina virtuale ospitata sull'infrastruttura di Google. I termini istanza Compute Engine, istanza VM e VM sono sinonimi e vengono utilizzati in modo intercambiabile. Le istanze VM includono cluster Google Kubernetes Engine (GKE), istanze dell'ambiente flessibile App Engine e altri prodotti Google Cloud basati su VM di Compute Engine.

Crea un'istanza VM di Compute Engine nella rete VPC in cui puoi eseguire il deployment di un servizio di ricezione eventi.

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

Sostituisci INSTANCE_NAME con un nome per la VM.

Per ulteriori informazioni, consulta Crea e avvia un'istanza VM.

Esegui il deployment di un ricevitore di eventi sulla VM

Esegui il deployment di un server web sulla tua VM che ascolta sulla porta 80 e riceve e registra gli eventi.

1. Stabilisci una connessione SSH alla tua istanza VM utilizzando il pulsante SSH nella console Google Cloud per connetterti alla VM.

   Una volta stabilita una connessione al server SSH, utilizza il terminale SSH nel browser per eseguire i comandi sull'istanza VM.

2. Nel terminale SSH in-browser, crea un file di testo con il nome file server.py che contenga il seguente codice 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()

3. Avvia il server e mantienilo in esecuzione per i passaggi rimanenti di questo tutorial:

   sudo python3 server.py
   

Crea un trigger Eventarc

Crea un trigger Eventarc che crea un nuovo argomento Pub/Sub e indirizza gli eventi al ricevitore di eventi di cui è stato eseguito il deployment sulla VM quando viene pubblicato un messaggio nell'argomento Pub/Sub.

Dopo aver attivato l'API Compute Engine, il service account predefinito è l'account di servizio predefinito di Compute Engine (PROJECT_NUMBER-compute@developer.gserviceaccount.com). A scopo di test, il trigger utilizza questo service account predefinito per la sua identità.

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

Sostituisci PROJECT_NUMBER con il numero del tuo progetto Google Cloud. Puoi trovare il numero di progetto nella pagina Benvenuto della console Google Cloud o eseguendo questo comando:

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

Per ulteriori informazioni sulla configurazione del trigger, consulta Instradare gli eventi a un endpoint HTTP interno in una rete VPC.

Generare e visualizzare un evento dell'argomento Pub/Sub

Puoi generare un evento pubblicando un messaggio in un argomento Pub/Sub.

1. Trova e imposta l'argomento Pub/Sub come variabile di ambiente:

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

2. Pubblica un messaggio nell'argomento Pub/Sub per generare un evento:

   gcloud pubsub topics publish $MY_TOPIC --message "Hello World"

   Il trigger Eventarc indirizza l'evento all'endpoint HTTP interno nella tua rete VPC. Nel terminale SSH nel browser, viene visualizzato il corpo dell'evento. Dovrebbe essere simile al seguente:

   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 -
   

   Tieni presente che se decodifichi il valore data di SGVsbG8gV29ybGQ= dal formato Base64, viene restituito "Hello World".

Hai eseguito correttamente il deployment di un servizio di ricezione eventi in un endpoint HTTP interno in una rete VPC, creato un trigger Eventarc, generato un evento da Pub/Sub e confermato che l'evento è stato indirizzato come previsto dal trigger all'endpoint di destinazione.