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

Configurazione delle impostazioni predefinite per 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 che hai creato per questo tutorial.

2. Configura gcloud per la regione scelta:

   gcloud config set run/region REGION

   Sostituisci REGION con un'area geografica Cloud Run supportata a tua scelta.

Recupero dell'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 di esempio di Cloud Run:

   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 le funzionalità per fornire un'API più semplice per più protocolli di comunicazione con funzionalità aggiuntive come una maggiore affidabilità, una 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 un'istanza di una nuova istanza Socket per ogni connessione. Poiché questo esempio viene visualizzato sul lato server, non è necessario definire l'URL del server. L'istanza 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. Come nel caso del lato client, una volta che il server Socket.io stabilisce una connessione al client, per ogni connessione viene creata un'istanza socket che può essere utilizzata per inviare messaggi e ascoltarli. Socket.io fornisce anche un'interfaccia semplice per la creazione di "stanze virtuali" o un canale arbitrario a cui le prese possono entrare 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`,
      });
    }
  });
});

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 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 virtuale. Ogni container creerà una connessione all'istanza Redis e Cloud Run può creare un numero elevato di istanze. Questo rientra 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 c'è alcuna garanzia che il client si riconnetterà 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 continueranno a esistere 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 con i container attivi, in modo da consentire lo scale in dei container. Se temi che un numero elevato di container persiste dopo un picco di traffico, puoi abbassare il valore di timeout massimo in modo che i socket inutilizzati vengano puliti 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, ovvero my-redis-instance, e REGION_ID con la regione per tutte le risorse e i servizi, 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 una propria subnet /28 in cui inserire le istanze del connettore. Questo intervallo IP non deve sovrapporsi ad alcuna prenotazione di indirizzi IP esistenti nella tua rete VPC. Ad esempio, 10.8.0.0 (/28) funzionerà nella maggior parte dei nuovi progetti oppure puoi specificare un altro intervallo IP personalizzato inutilizzato, come 10.9.0.0 (/28). Puoi 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 dimensioni della macchina pari a e2-micro. Aumenta le dimensioni della macchina del connettore per migliorare la velocità effettiva del connettore, ma anche i costi. Inoltre, il connettore deve 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. Crea un account di servizio da utilizzare come identità di servizio. Per impostazione predefinita, non sono previsti 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
   

5. Crea ed esegui il deployment dell'immagine container in 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 alle richieste di installare le API richieste rispondendo y quando richiesto. Per un progetto, devi eseguire questa operazione una sola volta. Rispondi ad altri prompt specificando la piattaforma e la regione, se non hai impostato valori predefiniti per queste richieste come descritto nella pagina di setup. Scopri di più sul deployment da codice sorgente.

Provalo

Per provare il servizio completo:

1. Vai 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 questi hanno un accesso limitato di Identity and Access Management (IAM) al resto di Google Cloud e che dovranno disporre di ruoli IAM aggiuntivi per accedere a molti altri servizi.