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 WebSockets con una connessione permanente per la comunicazione bidirezionale. Con WebSockets, sia il client che il server possono inviarsi messaggi senza eseguire il polling del server per gli aggiornamenti.

Sebbene tu possa configurare Cloud Run in modo che utilizzi l'affinità di sessione, questa fornisce un'affinità best effort, il che significa che qualsiasi nuova richiesta può comunque essere potenzialmente indirizzata a un'istanza diversa. Di conseguenza, i messaggi degli utenti nel servizio di chat devono essere sincronizzati tra tutte le istanze, non solo tra i client connessi a un'istanza.

Progettazione di un servizio di chat in tempo reale

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 iscritti connessi a qualsiasi istanza, in modo da eliminare il polling HTTP per gli aggiornamenti.

Tuttavia, anche con gli aggiornamenti push, qualsiasi istanza avviata 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 Redis di un archivio di oggetti per memorizzare nella cache e recuperare la cronologia dei messaggi.

L'istanza Redis è protetta da internet utilizzando IP privati con accesso controllato e limitato ai servizi in esecuzione sulla stessa rete privata virtuale dell'istanza Redis. Ti consigliamo di utilizzare il traffico VPC diretto in uscita.

Limitazioni

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

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

  • Perché questo servizio di esempio sia pronto per la produzione, sono necessari elementi aggiuntivi. Per fornire l'alta affidabilità utilizzando la replica e il failover automatico, è consigliata un'istanza Redis di livello Standard.

Obiettivi

  • Scrivere, creare ed eseguire il deployment di un servizio Cloud Run che utilizza WebSocket.

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

  • Connetti il servizio Cloud Run a Memorystore utilizzando il traffico VPC diretto in uscita.

Costi

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

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il Calcolatore prezzi.

I nuovi utenti di Google Cloud potrebbero avere diritto a una prova senza costi.

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 senza costi per l'esecuzione, il test e il deployment dei workload.

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

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  3. Verify that billing is enabled for your Google Cloud project.

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

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  5. Verify that billing is enabled for your Google Cloud project.

  6. Abilita le API Cloud Run, Memorystore for Redis, Artifact Registry e Cloud Build, se non sono già abilitate.

    Ruoli richiesti per abilitare le API

    Per abilitare le API, devi disporre dell'autorizzazione serviceusage.services.enable. Se hai creato il progetto, probabilmente hai già questa autorizzazione tramite il ruolo Proprietario (roles/owner). In caso contrario, puoi ottenere questa autorizzazione tramite il ruolo Amministratore Service Usage (roles/serviceusage.serviceUsageAdmin). Scopri come concedere i ruoli.

    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 nel progetto:

Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

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

Configura le impostazioni predefinite di gcloud

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 che hai creato per questo tutorial.

  2. Configura gcloud per la regione scelta:

    gcloud config set run/region REGION

    Sostituisci REGION con la regione Cloud Run supportata che preferisci.

Località di Cloud Run

Cloud Run è regionale, il che significa che l'infrastruttura che esegue i tuoi servizi Cloud Run si trova in una regione specifica ed è gestita da Google per essere disponibile in modo ridondante in tutte le zone all'interno di quella regione.

La soddisfazione dei requisiti di latenza, disponibilità o durabilità è un fattore principale per la selezione della regione in cui vengono eseguiti i servizi Cloud Run. In genere puoi selezionare la regione più vicina ai tuoi utenti, ma devi considerare la posizione degli altri prodotti Google Cloud utilizzati dal tuo servizio Cloud Run. L'utilizzo di prodotti Google Cloud in sinergia in più località può influire sulla latenza del servizio e sui costi.

Cloud Run è disponibile nelle seguenti regioni:

Soggetto ai prezzi di Livello 1

Soggetto ai prezzi di Livello 2

  • africa-south1 (Johannesburg)
  • asia-east2 (Hong Kong)
  • asia-northeast3 (Seul, Corea del Sud)
  • asia-southeast1 (Singapore)
  • asia-southeast2 (Giacarta)
  • asia-south2 (Delhi, India)
  • australia-southeast1 (Sydney)
  • australia-southeast2 (Melbourne)
  • europe-central2 (Varsavia, Polonia) icona foglia Bassi livelli di CO2
  • europe-west10 (Berlino)
  • europe-west12 (Torino) icona foglia Bassi livelli di CO2
  • europe-west2 (Londra, Regno Unito) icona foglia Bassi livelli di CO2
  • europe-west3 (Francoforte, Germania)
  • europe-west6 (Zurigo, Svizzera) icona foglia A basse emissioni di CO2
  • me-central1 (Doha)
  • me-central2 (Dammam)
  • northamerica-northeast1 (Montreal) icona foglia Bassi livelli di CO2
  • northamerica-northeast2 (Toronto) icona foglia Bassi livelli di CO2
  • southamerica-east1 (San Paolo, Brasile) icona foglia Bassi livelli di CO2
  • southamerica-west1 (Santiago, Cile) icona foglia Bassi livelli di CO2
  • us-west2 (Los Angeles)
  • us-west3 (Salt Lake City)
  • us-west4 (Las Vegas)

Se hai già creato un servizio Cloud Run, puoi visualizzare la regione nella dashboard di Cloud Run nella consoleGoogle Cloud .

Recupera l'esempio di codice

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 scaricare l'esempio come file ZIP ed estrarlo.

  2. Passa alla directory che contiene il codice campione di Cloud Run:

    Node.js 

    cd nodejs-docs-samples/run/websockets/

Comprendi il codice WebSocket

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 di WebSocket, ne racchiude la funzionalità per fornire un'API più semplice per più protocolli di comunicazione con funzionalità aggiuntive, come una maggiore affidabilità, la riconnessione automatica e la trasmissione a tutti i client o a un sottoinsieme di client.

Integrazione lato client

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

Il client crea una nuova istanza Socket per ogni connessione. Poiché questo esempio viene visualizzato lato server, non è necessario definire l'URL del server. L'istanza del socket può emettere e ascoltare 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 viene 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 inviare e ascoltare i messaggi. Socket.io fornisce anche un'interfaccia per la creazione di "stanze" o di un canale arbitrario a cui i socket possono partecipare e da cui possono 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`,
      });
    }
  });
});

Socket.io fornisce anche 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 dati.

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. Questo valore è ben al di sotto delle 65.000 connessioni che Redis può supportare.

Riconnessione

Cloud Run ha un timeout massimo di 60 minuti. Pertanto, devi aggiungere una logica di riconnessione per i possibili timeout. In alcuni casi, Socket.io tenta automaticamente di riconnettersi dopo eventi di disconnessione o errore di connessione. Non è garantito che il client si riconnetta 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 attive se esiste una connessione attiva finché tutte le richieste non vengono chiuse o non scadono. Anche se utilizzi l'affinità di sessione di Cloud Run, è possibile che le nuove richieste vengano bilanciate in base al carico sui container attivi, il che consente lo scale in dei container. Se temi che un numero elevato di container persista dopo un picco di traffico, puoi ridurre il valore di timeout massimo in modo che i socket inutilizzati vengano eliminati più di frequente.

Spedisci il servizio

  1. Crea un'istanza di Memorystore for Redis:

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

    Sostituisci quanto segue:

    • INSTANCE_ID: il nome dell'istanza, ad esempio my-redis-instance.
    • REGION_ID: la regione per tutte le risorse e i servizi, ad esempio europe-west1.

    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 le dimensioni iniziali di un'istanza Memorystore per il tuo caso d'uso.

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

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

  3. Crea un account di servizio da utilizzare come identità del servizio. Per impostazione predefinita, non ha altri privilegi oltre all'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

  4. Trova il nome della rete VPC autorizzata per l'istanza Redis eseguendo questo comando:

      gcloud redis instances describe INSTANCE_ID --region REGION --format "value(authorizedNetwork)"

    Sostituisci quanto segue:

    • INSTANCE_ID: il nome dell'istanza, ad esempio my-redis-instance.
    • REGION_ID: la regione per tutte le risorse e i servizi, ad esempio europe-west1.

    Prendi nota del nome della rete VPC.

  5. Crea l'immagine container ed eseguine il deployment in Cloud Run:

    gcloud run deploy chat-app --source . \
    --allow-unauthenticated \
    --timeout 3600 \
    --service-account chat-identity \
    --network NETWORK \
    --subnet SUBNET \
    --update-env-vars REDISHOST=$REDISHOST

    Sostituisci quanto segue:

    • NETWORK è il nome della rete VPC autorizzata a cui è collegata l'istanza Redis.
    • SUBNET è il nome della subnet. La subnet deve essere /26 o superiore. Il traffico in uscita VPC diretto supporta gli intervalli IPv4 RFC 1918, RFC 6598 e Classe E.

    Rispondi a eventuali prompt per installare le API richieste digitando y quando richiesto. Devi eseguire questa operazione una sola volta per un progetto. Rispondi agli altri prompt fornendo la piattaforma e la regione, se non hai impostato i valori predefiniti per queste come descritto nella pagina di configurazione. Scopri di più sul deployment dal codice sorgente.

Prova il servizio

Per provare il servizio completo:

  1. Vai all'URL fornito dal passaggio di deployment.

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

  3. Invia un messaggio alla stanza.

Se scegli di continuare a sviluppare questi servizi, ricorda che hanno un accesso limitato di Identity and Access Management (IAM) al resto di Google Cloud e dovranno ricevere ruoli IAM aggiuntivi per accedere a molti altri servizi.

Esegui la pulizia

Per evitare che al tuo account Google Cloud vengano addebitati costi aggiuntivi, elimina tutte le risorse di cui hai eseguito il deployment con questo tutorial.

Elimina il progetto

Se hai creato un nuovo progetto per questo tutorial, eliminalo. Se hai utilizzato un progetto esistente e vuoi conservarlo senza le modifiche aggiunte in questo tutorial, elimina le risorse create per il tutorial.

Il modo più semplice per eliminare la fatturazione è eliminare il progetto 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 progetto, quindi fai clic su Chiudi per eliminare il progetto.

Elimina le risorse del tutorial

  1. Elimina il servizio Cloud Run di cui hai eseguito il deployment in questo tutorial. I servizi Cloud Run non comportano costi finché non ricevono richieste.

    Per eliminare il servizio Cloud Run, esegui questo comando:

    gcloud run services delete SERVICE-NAME

    Sostituisci SERVICE-NAME con il nome del servizio.

    Puoi eliminare i servizi Cloud Run anche dalla consoleGoogle Cloud .

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

     gcloud config unset run/region

  3. Rimuovi la configurazione del progetto:

     gcloud config unset project

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

Passaggi successivi