Node.js Backend Development Bootcamp · Lección

Configuración de gateways

Configure gateways de WebSocket en NestJS y gestione eventos de conexión, mensajes y salas.

Configuración de gateways es una lección gratuita de Node.js Backend Development Bootcamp en CoddyKit. Esta es la lección 4 de 6. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Node.js Backend Development Bootcamp, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Node.js Backend Development Bootcamp incluye 6 lecciones en total.

Partes de esta lección aún no han sido traducidas y se muestran en inglés.

Unlocking Real-time with Gateways

Welcome back! In the previous lesson, we learned about WebSockets. Now, let's dive into how NestJS makes real-time communication easy with Gateways.

Think of a Gateway as a special controller for WebSocket connections. It listens for messages from clients and sends responses back, enabling dynamic, two-way communication.

Creating Your First Gateway

To create a Gateway, we use the @WebSocketGateway() decorator. This decorator marks a class as a WebSocket gateway.

By default, NestJS uses Socket.IO. You can specify a port, namespace, or other options. Let's start with a basic gateway:

import { WebSocketGateway,
         WebSocketServer } from '@nestjs/websockets';
import { Server } from 'socket.io';

// src/events.gateway.ts
@WebSocketGateway(3001) // Listens on port 3001 for WS
export class EventsGateway {
  @WebSocketServer() server: Server;
}

// src/app.module.ts (minimal)
import { Module } from '@nestjs/common';
import { EventsGateway } from './events.gateway';

@Module({
  providers: [EventsGateway],
})
export class AppModule {}

// src/main.ts (minimal)
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  await app.listen(3000); // HTTP app, WS runs alongside
}
bootstrap();

Gateway Configuration Options

The @WebSocketGateway() decorator accepts an optional configuration object. This lets you customize how your WebSocket server behaves:

port: The port the WebSocket server listens on (e.g., 3001).
namespace: Group connections under a specific path (e.g., '/chat').
cors: Configure Cross-Origin Resource Sharing for browser clients.
adapter: Specify a custom WebSocket adapter (e.g., for `ws` instead of `socket.io`).

Handling Connections & Disconnections

Gateways can react to client connections and disconnections using lifecycle hooks. These are interfaces your gateway can implement:

OnGatewayInit: Called once the gateway is initialized.
OnGatewayConnection: Called when a client connects.
OnGatewayDisconnect: Called when a client disconnects.

Use these to perform setup or cleanup tasks.

import { WebSocketGateway,
         OnGatewayConnection,
         OnGatewayDisconnect,
         WebSocketServer } from '@nestjs/websockets';
import { Server, Socket } from 'socket.io';

// src/events.gateway.ts
@WebSocketGateway(3001)
export class EventsGateway
  implements OnGatewayConnection, OnGatewayDisconnect {
  @WebSocketServer() server: Server;

  handleConnection(client: Socket, ...args: any[]) {
    console.log(`Client connected: ${client.id}`);
  }

  handleDisconnect(client: Socket) {
    console.log(`Client disconnected: ${client.id}`);
  }
}

// src/app.module.ts (minimal)
import { Module } from '@nestjs/common';
import { EventsGateway } from './events.gateway';

@Module({
  providers: [EventsGateway],
})
export class AppModule {}

// src/main.ts (minimal)
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  await app.listen(3000);
}
bootstrap();

Subscribing to Client Messages

Clients send messages with an 'event name'. Your gateway listens for these specific events using the @SubscribeMessage() decorator.

The decorated method receives the client (Socket instance) and the payload (data sent by the client).

import { WebSocketGateway,
         SubscribeMessage,
         WebSocketServer } from '@nestjs/websockets';
import { Server, Socket } from 'socket.io';

// src/events.gateway.ts
@WebSocketGateway(3001)
export class EventsGateway {
  @WebSocketServer() server: Server;

  @SubscribeMessage('sendMessage')
  handleMessage(client: Socket, payload: string): void {
    console.log(`Message from ${client.id}: ${payload}`);
    // Process payload, then send response
  }
}

// src/app.module.ts (minimal)
import { Module } from '@nestjs/common';
import { EventsGateway } from './events.gateway';

@Module({
  providers: [EventsGateway],
})
export class AppModule {}

// src/main.ts (minimal)
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  await app.listen(3000);
}
bootstrap();

Sending Messages Back to Clients

Once your gateway receives a message, you'll often want to send a response. You can inject the WebSocketServer instance using @WebSocketServer().

To send a message to a specific client, use client.emit('eventName', data). To broadcast to all clients, use this.server.emit('eventName', data).

import { WebSocketGateway,
         SubscribeMessage,
         WebSocketServer } from '@nestjs/websockets';
import { Server, Socket } from 'socket.io';

// src/events.gateway.ts
@WebSocketGateway(3001)
export class EventsGateway {
  @WebSocketServer() server: Server;

  @SubscribeMessage('echo')
  handleEcho(client: Socket, payload: string): void {
    console.log(`Received: ${payload} from ${client.id}`);
    client.emit('echoResponse', `You said: ${payload}`);
  }

  @SubscribeMessage('broadcast')
  handleBroadcast(client: Socket, payload: string): void {
    this.server.emit(
      'broadcastMessage', 
      `${client.id} broadcasted: ${payload}`
    );
  }
}

// src/app.module.ts (minimal)
import { Module } from '@nestjs/common';
import { EventsGateway } from './events.gateway';

@Module({
  providers: [EventsGateway],
})
export class AppModule {}

// src/main.ts (minimal)
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  await app.listen(3000);
}
bootstrap();

Organizing Clients with Rooms

For more complex applications, you might not want to broadcast every message to every client. This is where rooms come in handy!

Rooms allow you to group specific clients together. Messages can then be sent only to clients within a particular room. This is perfect for chat channels, game lobbies, or specific user notifications.

Joining and Leaving Rooms

Socket.IO clients can join or leave rooms dynamically. You can manage this from your gateway methods using the client instance:

client.join(roomName): Adds the client to the specified room.
client.leave(roomName): Removes the client from the specified room.

A client can be in multiple rooms simultaneously.

import { WebSocketGateway,
         SubscribeMessage,
         WebSocketServer } from '@nestjs/websockets';
import { Server, Socket } from 'socket.io';

// src/events.gateway.ts
@WebSocketGateway(3001)
export class EventsGateway {
  @WebSocketServer() server: Server;

  @SubscribeMessage('joinRoom')
  handleJoinRoom(client: Socket, room: string): void {
    client.join(room);
    client.emit('joinedRoom', `You joined ${room}`);
    console.log(`${client.id} joined room: ${room}`);
  }

  @SubscribeMessage('leaveRoom')
  handleLeaveRoom(client: Socket, room: string): void {
    client.leave(room);
    client.emit('leftRoom', `You left ${room}`);
    console.log(`${client.id} left room: ${room}`);
  }
}

// src/app.module.ts (minimal)
import { Module } from '@nestjs/common';
import { EventsGateway } from './events.gateway';

@Module({
  providers: [EventsGateway],
})
export class AppModule {}

// src/main.ts (minimal)
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  await app.listen(3000);
}
bootstrap();

Sending Messages to Specific Rooms

Once clients are in rooms, you can send targeted messages. Use the server.to(roomName).emit('eventName', data) method.

This ensures only clients subscribed to that particular room receive the message, making your real-time updates efficient and relevant.

import { WebSocketGateway,
         SubscribeMessage,
         WebSocketServer } from '@nestjs/websockets';
import { Server, Socket } from 'socket.io';

// src/events.gateway.ts
@WebSocketGateway(3001)
export class EventsGateway {
  @WebSocketServer() server: Server;

  @SubscribeMessage('roomMessage')
  handleRoomMessage(
    client: Socket,
    payload: { room: string; message: string },
  ): void {
    const { room, message } = payload;
    this.server
      .to(room)
      .emit('roomUpdate',
            `[${room}] ${client.id}: ${message}`);
    console.log(
      `Message in ${room} from ${client.id}: ${message}`
    );
  }
}

// src/app.module.ts (minimal)
import { Module } from '@nestjs/common';
import { EventsGateway } from './events.gateway';

@Module({
  providers: [EventsGateway],
})
export class AppModule {}

// src/main.ts (minimal)
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  await app.listen(3000);
}
bootstrap();

Gateway Configuration Quiz

Which of the following statements about NestJS WebSocket Gateways and rooms are TRUE?

Recap: Master Your Gateway

Great job! You've learned how to configure NestJS Gateways for powerful real-time communication.

We defined gateways using @WebSocketGateway().
We explored configuration options like port and namespace.
We implemented lifecycle hooks for connections and disconnections.
We handled client messages with @SubscribeMessage().
We used @WebSocketServer() to broadcast and send targeted messages.
Finally, we mastered rooms for efficient client grouping and targeted messaging.

Next, we'll build a full real-time chat application!

Preguntas frecuentes

¿La lección «Configuración de gateways» es gratis?

Sí — el texto completo de «Configuración de gateways» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Node.js Backend Development Bootcamp, actualiza a CoddyKit PRO. El curso de Node.js Backend Development Bootcamp incluye 6 lecciones en total.

¿Qué aprenderé en «Configuración de gateways»?

Configure gateways de WebSocket en NestJS y gestione eventos de conexión, mensajes y salas. Practicas Node.js Backend Development Bootcamp con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Node.js Backend Development Bootcamp?

No se requiere experiencia previa. Node.js Backend Development Bootcamp en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 6.

¿Cuánto tiempo toma la lección «Configuración de gateways»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Node.js Backend Development Bootcamp?

Sí. Cada lección de Node.js Backend Development Bootcamp incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

Introducción a WebSockets
WebSockets con NestJS
Implementación de Socket.IO en Node.js
Configuración de gateways
Construcción de una aplicación de chat en tiempo real
Aplicación de chat en tiempo real

← Volver a Node.js Backend Development Bootcamp