Anleitung zum Erstellen eines WebSocket-Chatdienstes für Cloud Run

gcloud-Standardeinstellungen einrichten

So konfigurieren Sie gcloud mit Standardeinstellungen für den Cloud Run-Dienst:

1. Legen Sie ein Standardprojekt fest:

   gcloud config set project PROJECT_ID

   Ersetzen Sie PROJECT_ID durch den Namen des Projekts, das Sie für diese Anleitung erstellt haben.

2. Konfigurieren Sie gcloud für die von Ihnen ausgewählte Region:

   gcloud config set run/region REGION

   Ersetzen Sie REGION durch die unterstützte Cloud Run-Region Ihrer Wahl.

Codebeispiel abrufen

So rufen Sie das gewünschte Codebeispiel ab:

1. Klonen Sie das Beispiel-Repository auf Ihren lokalen Computer:

   Node.js

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

   Sie können auch das Beispiel als ZIP-Datei herunterladen und extrahieren.

2. Wechseln Sie in das Verzeichnis, das den Cloud Run-Beispielcode enthält:

   Node.js

   cd nodejs-docs-samples/run/websockets/

Code verstehen

Socket.io ist eine Bibliothek, die eine bidirektionale Echtzeitkommunikation zwischen Browser und Server ermöglicht. Obwohl Socket.io keine WebSocket-Implementierung ist, umfasst es die Funktion, eine einfachere API für mehrere Kommunikationsprotokolle mit zusätzlichen Features, wie verbesserter Zuverlässigkeit, automatischer Neuverbindung sowie Broadcasting an einen oder alle Clients, bereitzustellen.

Clientseitige Integration

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

Der Client instanziiert eine neue Socket-Instanz für jede Verbindung. Da dieses Beispiel serverseitig gerendert wird, muss die Server-URL nicht definiert werden. Die Socket-Instanz kann Ereignisse ausgeben und abhören.

// 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');
});

Serverseitige Integration

Auf der Serverseite wird der Socket.io-Server initialisiert und mit dem HTTP-Server verbunden. Ähnlich wie auf der Clientseite wird nach dem Herstellen einer Verbindung zum Client mit Socket.io eine Socket-Instanz für jede Verbindung erstellt, mit Nachrichten ausgegeben und überwacht werden können. Socket.io bietet auch eine einfache Schnittstelle zum Erstellen von "Chatrooms" oder einem beliebigen Kanal, dem Sockets beitreten und ihn verlassen können.

// 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 stellt auch einen Redis-Adapter bereit, um Ereignisse an alle Clients zu senden, unabhängig davon, welcher Server den Socket bereitstellt. Socket.io verwendet ausschließlich den Pub/Sub-Mechanismus von Redis und speichert keine Daten.

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

Der Redis-Adapter von Socket.io kann den Redis-Client wiederverwenden, der zum Speichern des Nachrichtenverlaufs des Chatrooms verwendet wird. Jeder Container erstellt eine Verbindung zur Redis-Instanz und Cloud Run kann eine große Anzahl von Instanzen erstellen. Das sind deutlich weniger als die 65.000 Verbindungen, die Redis unterstützen kann. Wenn Sie diese Menge an Traffic unterstützen müssen, müssen Sie auch den Durchsatz des Connectors für den serverlosen VPC-Zugriff auswerten.

Verbindung wiederherstellen

Cloud Run hat eine maximale Zeitüberschreitung von 60 Minuten. Daher müssen Sie eine erneute Verbindungslogik für mögliche Zeitlimits hinzufügen. In einigen Fällen versucht Socket.io automatisch, die Verbindung nach einem Verbindungs- oder Verbindungsfehler wiederherzustellen. Es gibt keine Garantie dafür, dass der Client wieder eine Verbindung zur selben Instanz herstellt.

// 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);
  }
});

Instanzen bleiben bei einer aktiven Verbindung bestehen, bis alle Anfragen geschlossen oder das Zeitlimit überschritten werden. Auch wenn Sie die Sitzungsaffinität von Cloud Run verwenden, können neue Anfragen mit Load-Balancing auf aktive Container verteilt werden, sodass Container herunterskaliert werden können. Wenn Sie befürchten, dass eine große Anzahl von Containern nach einer Traffic-Spitze bestehen bleibt, können Sie den maximalen Zeitüberschreitungswert verringern, damit nicht verwendete Sockets häufiger bereinigt werden.

Dienst versenden

1. Erstellen einer Instanz von Memorystore for Redis:

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

   Ersetzen Sie INSTANCE_ID durch den Namen der Instanz, z. B. my-redis-instance, und REGION_ID durch die Region für alle Ihre Ressourcen und Dienste, z. B. us-central1.

   Der Instanz wird automatisch ein IP-Bereich aus dem Standarddienstnetzwerkbereich zugewiesen. In dieser Anleitung wird für den lokalen Cache von Nachrichten in der Redis-Instanz 1 GB Arbeitsspeicher verwendet. Weitere Informationen zum Bestimmen der anfänglichen Größe einer Memorystore-Instanz für Ihren Anwendungsfall.

2. Richten Sie einen Connector für serverlosen VPC-Zugriff ein.

   Zum Herstellen einer Verbindung zu Ihrer Redis-Instanz benötigt Ihr Cloud Run-Dienst Zugriff auf das autorisierte VPC-Netzwerk der Redis-Instanz.

   Jeder VPC-Connector benötigt ein eigenes /28-Subnetz, um Connector-Instanzen zu platzieren. Dieser IP-Bereich darf sich nicht mit vorhandenen IP-Adressreservierungen im VPC-Netzwerk überschneiden. 10.8.0.0 (/28) funktioniert beispielsweise in den meisten neuen Projekten oder Sie können einen anderen nicht verwendeten benutzerdefinierten IP-Bereich wie 10.9.0.0 angeben (/28). Sie können in der Google Cloud Console sehen, welche IP-Bereiche derzeit reserviert sind.

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

   Ersetzen Sie CONNECTOR_NAME durch den Namen des Connectors.

   Dieser Befehl erstellt einen Connector im Standard-VPC-Netzwerk, genauso wie die Redis-Instanz, mit der Maschinengröße e2-micro. Wenn Sie die Maschinengröße des Connectors erhöhen, kann dadurch der Durchsatz erhöht werden, allerdings steigen auch die Kosten. Der Connector muss sich außerdem in derselben Region wie die Redis-Instanz befinden. Serverlosen VPC-Zugriff konfigurieren

3. Definieren Sie eine Umgebungsvariable mit der IP-Adresse des autorisierten Netzwerks der Redis-Instanz:

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

4. Erstellen Sie ein Dienstkonto, das als Dienstidentität dient. Standardmäßig hat dieses keine anderen Berechtigungen als die Projektmitgliedschaft.

   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. Erstellen Sie das Container-Image und stellen Sie es in Cloud Run bereit:

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

   Beantworten Sie die Aufforderungen, die erforderlichen APIs zu installieren, indem Sie nach Aufforderung y antworten. Dies ist nur einmal für ein Projekt erforderlich. Antworten Sie auf andere Aufforderungen, indem Sie die Plattform und Region angeben, sofern Sie diese nicht wie auf der Einrichtungsseite beschrieben eingerichtet haben. Weitere Informationen zum Aus Quellcode bereitstellen.

Testen

So testen Sie den gesamten Dienst:

1. Rufen Sie im Browser die URL auf, die Sie im oben beschriebenen Bereitstellungsschritt erhalten haben.

2. Geben Sie Ihren Namen und einen Chatroom ein, um sich anzumelden.

3. Nachricht an den Chatroom senden.

Wenn Sie sich dafür entscheiden, mit der Entwicklung dieser Dienste fortzufahren, denken Sie daran, dass diese nur eingeschränkten IAM-Zugriff (Identity and Access Management) auf den Rest von Google Cloud haben und ihnen zusätzliche IAM-Rollen zugewiesen werden müssen, um auf viele andere Dienste zugreifen zu können.