Ir al contenido principal
Versión: 4.x

Inicialización del servidor

Una vez que hayas instalado la biblioteca del servidor Socket.IO, ahora puedes inicializar el servidor. La lista completa de opciones se puede encontrar aquí.

consejo

Para usuarios de TypeScript, es posible proporcionar sugerencias de tipo para los eventos. Por favor revisa esto.

Inicialización​

Independiente​

const { Server } = require("socket.io");

const io = new Server({ /* opciones */ });

io.on("connection", (socket) => {
  // ...
});

io.listen(3000);

También puedes pasar el puerto como primer argumento:

const { Server } = require("socket.io");

const io = new Server(3000, { /* opciones */ });

io.on("connection", (socket) => {
  // ...
});

Esto inicia implícitamente un servidor HTTP de Node.js, al cual se puede acceder a través de io.httpServer.

Con un servidor HTTP​

const { createServer } = require("http");
const { Server } = require("socket.io");

const httpServer = createServer();
const io = new Server(httpServer, { /* opciones */ });

io.on("connection", (socket) => {
  // ...
});

httpServer.listen(3000);

Con un servidor HTTPS​

const { readFileSync } = require("fs");
const { createServer } = require("https");
const { Server } = require("socket.io");

const httpsServer = createServer({
  key: readFileSync("/path/to/my/key.pem"),
  cert: readFileSync("/path/to/my/cert.pem")
});

const io = new Server(httpsServer, { /* opciones */ });

io.on("connection", (socket) => {
  // ...
});

httpsServer.listen(3000);

Ver también: documentación de Node.js

Con autenticación de certificado de cliente:

Servidor

import { readFileSync } from "fs";
import { createServer } from "https";
import { Server } from "socket.io";

const httpsServer = createServer({
  key: readFileSync("/path/to/server-key.pem"),
  cert: readFileSync("/path/to/server-cert.pem"),
  requestCert: true,
  ca: [
    readFileSync("/path/to/client-cert.pem")
  ]
});

const io = new Server(httpsServer, { /* opciones */ });

io.engine.on("connection", (rawSocket) => {
  // si necesitas los detalles del certificado (ya no está disponible una vez completado el handshake)
  rawSocket.peerCertificate = rawSocket.request.client.getPeerCertificate();
});

io.on("connection", (socket) => {
  console.log(socket.conn.peerCertificate);
  // ...
});

httpsServer.listen(3000);

Cliente

import { readFileSync } from "fs";
import { io } from "socket.io-client";

const socket = io("https://example.com", {
  key: readFileSync("/path/to/client-key.pem"),
  cert: readFileSync("/path/to/client-cert.pem"),
  ca: [
    readFileSync("/path/to/server-cert.pem")
  ]
});

Con un servidor HTTP/2​

const { readFileSync } = require("fs");
const { createSecureServer } = require("http2");
const { Server } = require("socket.io");

const httpServer = createSecureServer({
  allowHTTP1: true,
  key: readFileSync("/path/to/my/key.pem"),
  cert: readFileSync("/path/to/my/cert.pem")
});

const io = new Server(httpServer, { /* opciones */ });

io.on("connection", (socket) => {
  // ...
});

httpServer.listen(3000);

Ver también: documentación de Node.js

Con Express​

const express = require("express");
const { createServer } = require("http");
const { Server } = require("socket.io");

const app = express();
const httpServer = createServer(app);
const io = new Server(httpServer, { /* opciones */ });

io.on("connection", (socket) => {
  // ...
});

httpServer.listen(3000);
precaución

Usar app.listen(3000) no funcionará aquí, ya que crea un nuevo servidor HTTP.

Más información aquí.

Con Koa​

const Koa = require("koa");
const { createServer } = require("http");
const { Server } = require("socket.io");

const app = new Koa();
const httpServer = createServer(app.callback());
const io = new Server(httpServer, { /* opciones */ });

io.on("connection", (socket) => {
  // ...
});

httpServer.listen(3000);

Más información aquí.

Con Nest​

Ver la documentación aquí.

precaución

NestJS v7 y anteriores dependen de Socket.IO v2, mientras que NestJS v8 depende de Socket.IO v4. Por favor usa un cliente compatible.

Con Fastify​

Necesitas registrar el plugin fastify-socket.io:

const fastify = require("fastify");
const fastifyIO = require("fastify-socket.io");

const server = fastify();
server.register(fastifyIO);

server.get("/", (req, reply) => {
  server.io.emit("hello");
});

server.ready().then(() => {
  // necesitamos esperar a que el servidor esté listo, de lo contrario `server.io` es undefined
  server.io.on("connection", (socket) => {
    // ...
  });
});

server.listen({ port: 3000 });

Con µWebSockets.js​

import { App } from "uWebSockets.js";
import { Server } from "socket.io";

const app = App();
const io = new Server();

io.attachApp(app);

io.on("connection", (socket) => {
  // ...
});

app.listen(3000, (token) => {
  if (!token) {
    console.warn("puerto ya en uso");
  }
});

Referencia: https://github.com/uNetworking/uWebSockets.js

Con Hono (Node.js)​

const { Hono } = require("hono");
const { serve } = require("@hono/node-server");
const { Server } = require("socket.io");

const app = new Hono();

const httpServer = serve({
    fetch: app.fetch,
    port: 3000,
});

const io = new Server(httpServer, {
    /* opciones */
});

io.on("connection", (socket) => {
    // ...
});

Referencia: https://hono.dev/docs/

Con Hono & Bun​

import { Server as Engine } from "@socket.io/bun-engine";
import { Server } from "socket.io";
import { Hono } from "hono";

const io = new Server();

const engine = new Engine();

io.bind(engine);

io.on("connection", (socket) => {
  // ...
});

const app = new Hono();

const { websocket } = engine.handler();

export default {
  port: 3000,
  idleTimeout: 30, // debe ser mayor que la opción "pingInterval" del motor, que por defecto es 25 segundos

  fetch(req, server) {
    const url = new URL(req.url);

    if (url.pathname === "/socket.io/") {
      return engine.handleRequest(req, server);
    } else {
      return app.fetch(req, server);
    }
  },

  websocket
}

Referencia: https://hono.dev/docs/

Opciones​

La lista completa de opciones disponibles se puede encontrar aquí.