Tutorial sulla creazione di un servizio di chat WebSocket per Cloud Run

Questo tutorial mostra come creare un servizio di chat in tempo reale multiroom utilizzando WebSocket con una connessione permanente per la comunicazione bidirezionale. Con WebSocket, sia il client che il server possono eseguire il push dei messaggi l'uno all'altro senza eseguire il polling del server per verificare gli aggiornamenti.

Sebbene sia possibile configurare Cloud Run per utilizzare affinità sessione, fornisce un' di affinità best effort, il che significa che ogni nuova richiesta può comunque potenzialmente instradato a un'altra istanza. Di conseguenza, i messaggi per gli utenti nel servizio chat devono essere sincronizzati in tutte le istanze, non tra i client connessi a un'istanza.

Panoramica del design

Questo servizio di chat di esempio utilizza un'istanza Memorystore for Redis per archiviare e sincronizzare i messaggi degli utenti in tutte le istanze. Redis utilizza un meccanismo Pub/Sub, da non confondere con il prodotto Cloud Pub/Sub, per eseguire il push dei dati ai client sottoscritti collegati a qualsiasi istanza, in modo da eliminare il polling HTTP per gli aggiornamenti.

Tuttavia, anche con gli aggiornamenti push, ogni istanza generata riceverà solo i nuovi messaggi inviati al container. Per caricare i messaggi precedenti, la cronologia dei messaggi deve essere archiviata e recuperata da una soluzione di archiviazione permanente. Questo esempio utilizza la funzionalità convenzionale di un archivio di oggetti di Redis per memorizzare nella cache e recuperare la cronologia dei messaggi.

Diagramma dell'architettura
. Il diagramma mostra più connessioni client a ogni istanza Cloud Run. Ogni istanza si connette a un'istanza Memorystore for Redis tramite un connettore di accesso VPC serverless.

L'istanza Redis è protetta da internet tramite IP privati con accesso controllato e limitato ai servizi in esecuzione sulla stessa rete privata virtuale dell'istanza Redis. pertanto è necessario un connettore di accesso VPC serverless affinché il servizio Cloud Run possa connettersi a Redis. Scopri di più sull'accesso VPC serverless.

Limitazioni

  • Questo tutorial non mostra l'autenticazione dell'utente finale o la memorizzazione nella cache delle sessioni. Per saperne di più sull'autenticazione degli utenti finali, consulta il tutorial di Cloud Run per l'autenticazione degli utenti finali.

  • Questo tutorial non implementa un database come Firestore per l'archiviazione e il recupero indefinito della cronologia dei messaggi di chat.

  • Affinché questo servizio di esempio sia pronto per la produzione, sono necessari elementi aggiuntivi. Ti consigliamo di utilizzare un'istanza Redis di livello Standard per fornire un'alta disponibilità utilizzando la replica e il failover automatico.

Obiettivi

  • Scrivi, crea ed esegui il deployment di un servizio Cloud Run che utilizza WebSockets.

  • Connettiti a un'istanza Memorystore for Redis per pubblicare e sottoscrivere nuovi messaggi tra le istanze.

  • Connetti il servizio Cloud Run con Memorystore utilizzando un connettore di accesso VPC serverless.

Costi

In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi basata sull'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud potrebbero essere idonei per una prova gratuita.

Prima di iniziare

  1. Accedi al tuo account Google Cloud. Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.

  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  3. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

  4. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  5. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

  6. Abilita le API Cloud Run, Memorystore for Redis, Serverless VPC Access, Artifact Registry, and Cloud Build .

    Abilita le API

  7. Installa e inizializza gcloud CLI.

Ruoli obbligatori

Per ottenere le autorizzazioni necessarie per completare il tutorial: chiedi all'amministratore di concederti i seguenti ruoli IAM sul tuo progetto:

Per saperne di più sulla concessione dei ruoli, consulta Gestire l'accesso.

Potresti anche riuscire a ottenere le autorizzazioni richieste tramite la ruoli o altri ruoli predefiniti ruoli.

Configurazione dei valori predefiniti di gcloud in corso...

Per configurare gcloud con i valori predefiniti per il tuo servizio Cloud Run:

  1. Imposta il progetto predefinito:

    gcloud config set project PROJECT_ID

    Sostituisci PROJECT_ID con il nome del progetto per cui hai creato questo tutorial.

  2. Configura gcloud per la regione scelta:

    gcloud config set run/region REGION

    Sostituisci REGION con il Cloud Run supportato regione di tua scelta.

Località Cloud Run

Cloud Run è regionale, il che significa che l'infrastruttura dei tuoi servizi Cloud Run si trova in una regione specifica gestiti da Google affinché siano disponibili in modo ridondante tutte le zone all'interno di quella regione.

Soddisfare i requisiti di latenza, disponibilità o durabilità è fondamentale i fattori necessari per selezionare la regione in cui vengono eseguiti i servizi Cloud Run. Generalmente puoi selezionare la regione più vicina ai tuoi utenti, ma devi considerare la località dell'altro account Google Cloud prodotti utilizzati dal tuo servizio Cloud Run. L'utilizzo combinato dei prodotti Google Cloud in più località può influire nonché la latenza del tuo servizio.

Cloud Run è disponibile nelle regioni seguenti:

Soggetto ai prezzi di Livello 1

Soggetto ai prezzi di Livello 2

Se hai già creato un servizio Cloud Run, puoi visualizzare nella dashboard di Cloud Run all'interno Console Google Cloud.

Recupero dell'esempio di codice in corso

Per recuperare l'esempio di codice da utilizzare:

  1. Clona il repository di esempio sulla tua macchina locale:

    Node.js 

    git clone https://github.com/GoogleCloudPlatform/nodejs-docs-samples.git

    In alternativa, puoi scarica l'esempio . come file ZIP ed estrarlo.

  2. Passa alla directory che contiene l'esempio di Cloud Run codice:

    Node.js 

    cd nodejs-docs-samples/run/websockets/

Nozioni di base sul codice

Socket.io è una libreria che consente la comunicazione bidirezionale in tempo reale tra il browser e il server. Sebbene Socket.io non sia un'implementazione WebSocket, aggrega la funzionalità per fornire un'API più semplice per più protocolli di comunicazione con funzionalità aggiuntive come l'affidabilità migliorata, la riconnessione automatica e la trasmissione a tutti o a un sottoinsieme di client.

Integrazione lato client

<script src="/socket.io/socket.io.js"></script>

Il client crea un'istanza per una nuova istanza Socket per ogni connessione. Poiché il rendering di questo esempio è lato server, non è necessario definire l'URL del server. L'istanza socket può emettere e rimanere in ascolto di eventi.

// Initialize Socket.io
const socket = io('', {
  transports: ['websocket'],
});
// Emit "sendMessage" event with message
socket.emit('sendMessage', msg, error => {
  if (error) {
    console.error(error);
  } else {
    // Clear message
    $('#msg').val('');
  }
});
// Listen for new messages
socket.on('message', msg => {
  log(msg.user, msg.text);
});

// Listen for notifications
socket.on('notification', msg => {
  log(msg.title, msg.description);
});

// Listen connect event
socket.on('connect', () => {
  console.log('connected');
});

Integrazione lato server

Sul lato server, il server Socket.io è inizializzato e collegato al server HTTP. Analogamente al lato client, una volta che il server Socket.io stabilisce una connessione al client, viene creata un'istanza socket per ogni connessione che può essere utilizzata per emettere e ascoltare messaggi. Socket.io offre inoltre un'interfaccia semplice per la creazione di "stanze virtuali". o un canale arbitrario a cui i socket possono unirsi e uscire.

// Initialize Socket.io
const server = require('http').Server(app);
const io = require('socket.io')(server);

const {createAdapter} = require('@socket.io/redis-adapter');
// Replace in-memory adapter with Redis
const subClient = redisClient.duplicate();
io.adapter(createAdapter(redisClient, subClient));
// Add error handlers
redisClient.on('error', err => {
  console.error(err.message);
});

subClient.on('error', err => {
  console.error(err.message);
});

// Listen for new connection
io.on('connection', socket => {
  // Add listener for "signin" event
  socket.on('signin', async ({user, room}, callback) => {
    try {
      // Record socket ID to user's name and chat room
      addUser(socket.id, user, room);
      // Call join to subscribe the socket to a given channel
      socket.join(room);
      // Emit notification event
      socket.in(room).emit('notification', {
        title: "Someone's here",
        description: `${user} just entered the room`,
      });
      // Retrieve room's message history or return null
      const messages = await getRoomFromCache(room);
      // Use the callback to respond with the room's message history
      // Callbacks are more commonly used for event listeners than promises
      callback(null, messages);
    } catch (err) {
      callback(err, null);
    }
  });

  // Add listener for "updateSocketId" event
  socket.on('updateSocketId', async ({user, room}) => {
    try {
      addUser(socket.id, user, room);
      socket.join(room);
    } catch (err) {
      console.error(err);
    }
  });

  // Add listener for "sendMessage" event
  socket.on('sendMessage', (message, callback) => {
    // Retrieve user's name and chat room  from socket ID
    const {user, room} = getUser(socket.id);
    if (room) {
      const msg = {user, text: message};
      // Push message to clients in chat room
      io.in(room).emit('message', msg);
      addMessageToCache(room, msg);
      callback();
    } else {
      callback('User session not found.');
    }
  });

  // Add listener for disconnection
  socket.on('disconnect', () => {
    // Remove socket ID from list
    const {user, room} = deleteUser(socket.id);
    if (user) {
      io.in(room).emit('notification', {
        title: 'Someone just left',
        description: `${user} just left the room`,
      });
    }
  });
});

Inoltre, Socket.io fornisce un adattatore Redis per trasmettere eventi a tutti i client, indipendentemente dal server che gestisce il socket. Socket.io utilizza solo il meccanismo Pub/Sub di Redis e non archivia alcun dato.

const {createAdapter} = require('@socket.io/redis-adapter');
// Replace in-memory adapter with Redis
const subClient = redisClient.duplicate();
io.adapter(createAdapter(redisClient, subClient));

L'adattatore Redis di Socket.io può riutilizzare il client Redis utilizzato per archiviare la cronologia dei messaggi della stanza. Ogni container creerà una connessione all'istanza Redis e Cloud Run può creare un numero elevato di istanze. Si tratta di ben al di sotto delle 65.000 connessioni che Redis può supportare. Se devi supportare questa quantità di traffico, devi anche valutare la velocità effettiva del connettore di accesso VPC serverless.

Riconnessione

Cloud Run ha un timeout massimo di 60 minuti. Devi quindi aggiungere la logica di riconnessione per possibili timeout. In alcuni casi, Socket.io tenta automaticamente di riconnettersi dopo eventi di disconnessione o errore di connessione. Non vi è alcuna garanzia che il client si ricolleghi alla stessa istanza.

// Listen for reconnect event
socket.io.on('reconnect', () => {
  console.log('reconnected');
  // Emit "updateSocketId" event to update the recorded socket ID with user and room
  socket.emit('updateSocketId', {user, room}, error => {
    if (error) {
      console.error(error);
    }
  });
});
// Add listener for "updateSocketId" event
socket.on('updateSocketId', async ({user, room}) => {
  try {
    addUser(socket.id, user, room);
    socket.join(room);
  } catch (err) {
    console.error(err);
  }
});

Le istanze rimarranno invariate se è presente una connessione attiva fino alla chiusura o al timeout di tutte le richieste. Anche se utilizzi l'affinità sessione di Cloud Run, è possibile che le nuove richieste vengano bilanciate in container attivi, in modo da consentire lo scale in dei container. Se temi che un numero elevato di container continui a essere mantenuto dopo un picco di traffico, puoi ridurre il valore di timeout massimo, in modo che i socket inutilizzati vengano ripuliti più spesso.

Spedizione del servizio

  1. Crea un'istanza Memorystore for Redis:

    gcloud redis instances create INSTANCE_ID --size=1 --region=REGION

    Sostituisci INSTANCE_ID con il nome dell'istanza, ad esempio my-redis-instance, e REGION_ID con la regione per tutti i servizi e le risorse, ad esempio us-central1.

    All'istanza verrà allocato automaticamente un intervallo IP dall'intervallo di rete di servizi predefinito. Questo tutorial utilizza 1 GB di memoria per la cache locale dei messaggi nell'istanza Redis. Scopri di più su come determinare la dimensione iniziale di un'istanza Memorystore per il tuo caso d'uso.

  2. Configura un connettore di accesso VPC serverless:

    Per connettersi all'istanza Redis, il servizio Cloud Run deve accedere alla rete VPC autorizzata dell'istanza Redis.

    Ogni connettore VPC richiede la propria subnet /28 in cui posizionare il connettore di Compute Engine. Questo intervallo IP non deve sovrapporsi ad alcuna nelle prenotazioni di indirizzi IP esistenti nella tua rete VPC. Ad esempio, 10.8.0.0 (/28) funzionerà nella maggior parte dei nuovi progetti oppure puoi specifica un altro intervallo IP personalizzato inutilizzato, ad esempio 10.9.0.0 (/28). Puoi per vedere quali intervalli IP sono attualmente prenotati nella console Google Cloud.

    gcloud compute networks vpc-access connectors create CONNECTOR_NAME \
  --region REGION \
  --range "10.8.0.0/28"

    Sostituisci CONNECTOR_NAME con il nome del connettore.

    Questo comando crea un connettore nella rete VPC predefinita, uguale all'istanza Redis, con dimensione macchina e2-micro. L'aumento delle dimensioni della macchina del connettore può migliorare la velocità effettiva del connettore, ma anche un aumento dei costi. Il connettore deve inoltre trovarsi nella stessa regione dell'istanza Redis. Scopri di più sulla configurazione dell'accesso VPC serverless.

  3. Definisci una variabile di ambiente con l'indirizzo IP della rete autorizzata dell'istanza Redis:

     export REDISHOST=$(gcloud redis instances describe INSTANCE_ID --region REGION --format "value(host)")

  4. Creare un account di servizio da utilizzare come identità di servizio. Per impostazione predefinita, non ha privilegi diversi dall'appartenenza al progetto.

    gcloud iam service-accounts create chat-identity
gcloud projects add-iam-policy-binding PROJECT_ID \
--member=serviceAccount:chat-identity@PROJECT_ID.iam.gserviceaccount.com \
--role=roles/serviceusage.serviceUsageConsumer

  5. Crea ed esegui il deployment dell'immagine container su Cloud Run:

    gcloud run deploy chat-app --source . \
    --vpc-connector CONNECTOR_NAME \
    --allow-unauthenticated \
    --timeout 3600 \
    --service-account chat-identity \
    --update-env-vars REDISHOST=$REDISHOST

    Rispondere a eventuali richieste di installazione delle API richieste rispondendo y quando richiesto. Devi eseguire questa operazione una sola volta per un progetto. Rispondi ad altri prompt indicando la piattaforma e la regione, se non hai impostato valori predefiniti per queste impostazioni, come descritto nella pagina di configurazione. Scopri di più sul deployment da codice sorgente.

Prova

Per provare il servizio completo:

  1. Passa nel browser all'URL fornito nel passaggio di deployment riportato sopra.

  2. Aggiungi il tuo nome e una stanza virtuale per accedere.

  3. Invia un messaggio alla stanza virtuale.

Se scegli di continuare a sviluppare questi servizi, ricorda che sono limitato l'accesso IAM (Identity and Access Management) al resto di Google Cloud e dovranno disporre di ruoli IAM aggiuntivi per accedere a molti altri i servizi di machine learning.

Esegui la pulizia

Se hai creato un nuovo progetto per questo tutorial, elimina il progetto. Se hai utilizzato un progetto esistente e vuoi mantenerlo senza l'aggiunta delle modifiche In questo tutorial, elimina le risorse create per il tutorial.

Elimina il progetto

Il modo più semplice per eliminare la fatturazione creato per il tutorial.

Per eliminare il progetto:

  1. Nella console Google Cloud, vai alla pagina Gestisci risorse.

    Vai a Gestisci risorse

  2. Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
  3. Nella finestra di dialogo, digita l'ID del progetto e fai clic su Chiudi per eliminare il progetto.

Eliminazione delle risorse del tutorial in corso...

  1. Elimina il servizio Cloud Run di cui hai eseguito il deployment in questo tutorial:

    gcloud run services delete SERVICE-NAME

    Dove SERVICE-NAME è il nome del servizio che hai scelto.

    I servizi Cloud Run possono essere eliminati anche Console Google Cloud.

  2. Rimuovi la configurazione predefinita della regione gcloud che hai aggiunto durante il tutorial configurazione:

     gcloud config unset run/region

  3. Rimuovi la configurazione del progetto:

     gcloud config unset project

  4. Elimina altre risorse Google Cloud create in questo tutorial:

Passaggi successivi