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

Anteprima

Questa funzionalità è soggetta ai "Termini delle Offerte pre-GA" nella sezione Termini di servizio generali dei Termini specifici dei servizi. Le funzionalità pre-GA sono disponibili "così come sono" e potrebbero avere un supporto limitato. Per saperne di più, consulta le descrizioni della fase di lancio.

Questo tutorial mostra come creare un endpoint HTTP interno in una rete VPC (Virtual Private Cloud) che riceve eventi di messaggi Pub/Sub utilizzando Eventarc. Per scoprire di più su questa destinazione di eventi, consulta Indirizzare gli eventi a un endpoint HTTP interno in una rete VPC.

Puoi eseguire i seguenti comandi utilizzando Google Cloud CLI nel terminale o in Cloud Shell.

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 di un 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 saperne di più, consulta la pagina Crea e gestisci le 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ù, consulta 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 degli eventi. Tuttavia, ai fini di questo tutorial, crea la regola in modo da poterti connettere alla VM tramite 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.

Nota: Eventarc riserva l'intervallo IP 240.0.0.0/20 CIDR della subnet. La subnet utilizzata per l'allegato di rete non deve sovrapporsi a questo intervallo.

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ù, consulta 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 saperne di più, 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 abilitato l'API Compute Engine, il account di servizio predefinito è il service account predefinito di Compute Engine ([e-mail]). A scopo di test, il trigger utilizza questo account di servizio predefinito per la sua identità.

Attenzione: per gli ambienti di produzione, ti consigliamo vivamente di creare un nuovo account di servizio e di concedergli uno o più ruoli IAM che contengano le autorizzazioni minime richieste. Non devi utilizzare il account di servizio predefinito, poiché gli viene concesso automaticamente il ruolo Editor di base con privilegi elevati.

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=[e-mail]

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.

Nota: la creazione del trigger potrebbe richiedere diversi minuti, dopodiché potrebbero essere necessari fino a due minuti prima che il trigger sia completamente funzionale.

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