AYUDA DE PYTHON

deepstream io (Cómo Funciona para Desarrolladores)

Name: IronPDF
Brand: Iron Software
Availability: InStock
Rating: 4.87 (307 reviews)

Actualizado:junio 22, 2025

Un servidor en tiempo real está diseñado para responder a los datos instantáneamente, haciéndolo instantáneamente responsivo a cada interacción del usuario o evento del sistema. A diferencia de los servidores convencionales de solicitud-respuesta que introducen demoras, los servidores en tiempo real utilizan tecnologías y protocolos para asegurar un intercambio de información continuo y actualizaciones instantáneas. Es porque un servidor en tiempo real es crítico para varias aplicaciones que requieren comunicaciones en vivo: sistemas de mensajería, juegos en línea, plataformas de comercio financiero y herramientas de colaboración. En este artículo, vamos a aprender cómo usar el servidor en tiempo real abierto deepstream e IronPDF para generar PDFs.

deepstream.io es un servidor en tiempo real escalable para la sincronización de datos y mensajería de muchos a muchos. Puede manejar datos con facilidad y mantener a muchos clientes sincronizados con una latencia muy baja, soportando la transferencia de datos binarios. deepstream.io está diseñado para estar detrás de otros balanceadores de carga y ofrece una manera eficiente de sincronizar datos y mantener los archivos de recursos actualizados, lo que lo hace perfectamente adecuado para aplicaciones que actualizan datos en tiempo real y que buscan una solución de servidor escalable.

deepstream io (Cómo Funciona para Desarrolladores): Figura 1 - deepstream.io

La implementación de deepstream.io por parte de desarrolladores puede permitir fácilmente actualizaciones en vivo, aplicaciones colaborativas y experiencias interactivas en tiempo real, sin comenzar desde cero. Ha sido arquitecturado para cargas elevadas y escalado eficiente, convirtiéndolo en el software de elección para aplicaciones de alta concurrencia. deepstream.io es flexible y puede resultar ser la adición perfecta a tu pila de tecnología de múltiples formas diferentes. Proporciona una solución completa para permitir a los usuarios crear aplicaciones web y móviles en tiempo real, responsivas e interactivas.

Para crear un nuevo directorio de Node.js ingrese los siguientes comandos en la consola:

mkdir deepstream-project
cd deepstream-project
npm init -y

mkdir deepstream-project
cd deepstream-project
npm init -y

SHELL

Instalar el paquete deepstream.io

Primero que todo, necesita instalar deepstream.io. Puede usar NPM para instalarlo o descargar los binarios desde el sitio web oficial.

npm install @deepstream/server

npm install @deepstream/server

SHELL

Configuración básica de deepstream.io

const { Deepstream } = require('@deepstream/server');

// Create a new Deepstream server instance
const server = new Deepstream({});

// Start the server to listen for client connections
server.start();

const { Deepstream } = require('@deepstream/server');

// Create a new Deepstream server instance
const server = new Deepstream({});

// Start the server to listen for client connections
server.start();

JAVASCRIPT

El fragmento de código anterior demuestra cómo configurar y comenzar un servidor deepstream.io usando el paquete @deepstream/server en Node.js. Primero importa la clase Deepstream del paquete, luego crea una nueva instancia. Al llamar server.start(), el servidor se inicia y está listo para aceptar conexiones entrantes para manejar la unión de datos en tiempo real, mensajería o servicios de backend de presencia.

Conexión de Deepstream con el cliente

const { DeepstreamClient } = require('@deepstream/client');

// Connect to a local deepstream server
const client = new DeepstreamClient('127.0.0.1:6020');

// Log in to the server without credentials (suitable for servers without authentication)
client.login(null);

const { DeepstreamClient } = require('@deepstream/client');

// Connect to a local deepstream server
const client = new DeepstreamClient('127.0.0.1:6020');

// Log in to the server without credentials (suitable for servers without authentication)
client.login(null);

JAVASCRIPT

El código anterior demuestra cómo conectar a deepstream usando la biblioteca @deepstream/client. Este script importa la clase DeepstreamClient, crea una instancia y la conecta a un servidor deepstream que corre localmente en la dirección IP 127.0.0.1 en el puerto 6020. Se inicia sesión sin credenciales, lo que es suficiente si el servidor no usa autenticación o si se utiliza para casos de prueba. Esta configuración inicializa un cliente capaz de sincronización y comunicación de datos en tiempo real.

Una vez establecida la conexión con el nodo del servidor, aparecerá un mensaje similar al siguiente en la consola del servidor.

deepstream io (Cómo Funciona para Desarrolladores): Figura 2 - Mensaje de Consola

Uso de Listener con deepstream.io

A continuación hay un código de muestra que se puede usar para crear listeners, uno de los conceptos principales de deepstream.

const { DeepstreamClient } = require("@deepstream/client");

// Connect to the Deepstream server
const client = new DeepstreamClient("127.0.0.1:6020");

// Log in to the server
client.login(null, (success, clientData) => {
  if (success) {
    const event = client.event;
    // Publish a custom event
    event.publish("custom-event", { message: "Hello, Deepstream!" });
  }
});

const { DeepstreamClient } = require("@deepstream/client");

// Connect to the Deepstream server
const client = new DeepstreamClient("127.0.0.1:6020");

// Log in to the server
client.login(null, (success, clientData) => {
  if (success) {
    const event = client.event;
    // Publish a custom event
    event.publish("custom-event", { message: "Hello, Deepstream!" });
  }
});

JAVASCRIPT

En el código anterior, el cliente inicia sesión en un servidor deepstream alojado en 127.0.0.1:6020 utilizando la biblioteca @deepstream/client. Tras la autenticación exitosa, publica un evento personalizado llamado "custom-event" con una carga { message: "Hello, Deepstream!" }.

Presentando IronPDF

Use IronPDF, un paquete de Node.js increíblemente fuerte, para crear, editar, convertir y editar documentos PDF. Es una herramienta utilizada en la mayoría de los procesos basados en programación en PDFs, y procesos backend como modificar PDFs preexistentes y convertir HTML en PDFs. En aplicaciones donde la creación dinámica y el manejo de PDFs son necesarios, IronPDF se convierte en una gran ayuda. Proporciona una manera amigable para el usuario y flexible de generar documentos PDF de calidad.

deepstream io (Cómo Funciona para Desarrolladores): Figura 3 - IronPDF

Instalar el paquete IronPDF

Use npm para descargar e instalar paquetes que habiliten la capacidad de IronPDF en Node.js.

npm install @ironsoftware/ironpdf

npm install @ironsoftware/ironpdf

SHELL

Función de generación de PDF

Cree una función que use IronPDF para generar PDFs:

const IronPdf = require('@ironsoftware/ironpdf');
const { PdfDocument } = IronPdf;

// Set IronPDF configuration, replacing 'YOUR_LICENSE_KEY' with your actual license key
const config = IronPdf.IronPdfGlobalConfig;
config.setConfig({ licenseKey: 'YOUR_LICENSE_KEY' });

async function generatePDF(title, content) {
  try {
    // Generate PDF from HTML content
    const pdf = await PdfDocument.fromHtml(`<html><body><h1>${title}</h1><p>${content}</p></body></html>`);
    return await pdf.saveAsBuffer();
  } catch (error) {
    console.error('Error generating PDF:', error);
    throw error;
  }
}

module.exports = generatePDF;

const IronPdf = require('@ironsoftware/ironpdf');
const { PdfDocument } = IronPdf;

// Set IronPDF configuration, replacing 'YOUR_LICENSE_KEY' with your actual license key
const config = IronPdf.IronPdfGlobalConfig;
config.setConfig({ licenseKey: 'YOUR_LICENSE_KEY' });

async function generatePDF(title, content) {
  try {
    // Generate PDF from HTML content
    const pdf = await PdfDocument.fromHtml(`<html><body><h1>${title}</h1><p>${content}</p></body></html>`);
    return await pdf.saveAsBuffer();
  } catch (error) {
    console.error('Error generating PDF:', error);
    throw error;
  }
}

module.exports = generatePDF;

JAVASCRIPT

Cómo configurar el cliente Deepstream

Escriba un script de JavaScript que escuche datos en tiempo real y genere PDFs basados en esos datos:

const { DeepstreamClient } = require('@deepstream/client');
const generatePDF = require('./generatePdf'); // Path to your PDF generation function

// Connect to the Deepstream server
const client = new DeepstreamClient('127.0.0.1:6020');

// Log in to the server
client.login(null, async (success) => {
  if (success) {
    console.log('Deepstream connected successfully');
    // Listen for a custom event to trigger PDF generation
    const event = client.event;
    event.subscribe('generate-pdf', async (data) => {
      const { title, content } = data;
      if (!title || !content) {
        console.error('Missing title or content for PDF generation');
        return;
      }
      try {
        // Generate the PDF
        const pdfBuffer = await generatePDF(title, content);
        // Handle the PDF buffer (e.g., save to file, send over network)
        console.log('PDF generated successfully');
        // Example: Save PDF to a file (optional)
        const fs = require('fs');
        fs.writeFileSync('generated.pdf', pdfBuffer);
      } catch (error) {
        console.error('Error generating PDF:', error);
      }
    });
  } else {
    console.error('Failed to connect to Deepstream');
  }
});

const { DeepstreamClient } = require('@deepstream/client');
const generatePDF = require('./generatePdf'); // Path to your PDF generation function

// Connect to the Deepstream server
const client = new DeepstreamClient('127.0.0.1:6020');

// Log in to the server
client.login(null, async (success) => {
  if (success) {
    console.log('Deepstream connected successfully');
    // Listen for a custom event to trigger PDF generation
    const event = client.event;
    event.subscribe('generate-pdf', async (data) => {
      const { title, content } = data;
      if (!title || !content) {
        console.error('Missing title or content for PDF generation');
        return;
      }
      try {
        // Generate the PDF
        const pdfBuffer = await generatePDF(title, content);
        // Handle the PDF buffer (e.g., save to file, send over network)
        console.log('PDF generated successfully');
        // Example: Save PDF to a file (optional)
        const fs = require('fs');
        fs.writeFileSync('generated.pdf', pdfBuffer);
      } catch (error) {
        console.error('Error generating PDF:', error);
      }
    });
  } else {
    console.error('Failed to connect to Deepstream');
  }
});

JAVASCRIPT

Eventos de publicación para activar la generación de PDF

Se pueden publicar eventos para disparar la generación de PDFs desde otro archivo de JavaScript o parte de su aplicación:

const { DeepstreamClient } = require('@deepstream/client');

// Connect to the Deepstream server
const client = new DeepstreamClient('127.0.0.1:6020');

// Log in to the server
client.login(null, () => {
  const event = client.event;
  // Publish a custom event with title and content
  event.publish('generate-pdf', {
    title: 'Sample PDF Title',
    content: 'This is the content of the PDF document.'
  });
});

const { DeepstreamClient } = require('@deepstream/client');

// Connect to the Deepstream server
const client = new DeepstreamClient('127.0.0.1:6020');

// Log in to the server
client.login(null, () => {
  const event = client.event;
  // Publish a custom event with title and content
  event.publish('generate-pdf', {
    title: 'Sample PDF Title',
    content: 'This is the content of the PDF document.'
  });
});

JAVASCRIPT

Deepstream.io se implementa escuchando eventos en tiempo real que dispararán la generación de PDF. La función generatePDF crea un documento PDF basado en datos de eventos de Deepstream.io usando IronPDF. El DeepstreamClient se suscribe a estos eventos, y cada vez que se publican eventos relevantes, llama a la función de generación de PDF. Tal integración permite la generación dinámica de PDFs en tiempo real basada en la ocurrencia de eventos, solicitudes, o cambios de datos.

deepstream io (Cómo Funciona para Desarrolladores): Figura 4 - Salida PDF

Licencias

Para que el código compile y funcione sin una marca de agua, se requiere una clave de licencia. Los desarrolladores que deseen una licencia de prueba pueden registrarse aquí. Obtener una no requiere presentar una tarjeta de crédito. Regístrese para una prueba gratuita introduciendo su correo electrónico.

Conclusión

Una de las soluciones más fuertes para el manejo de datos en tiempo real y la generación dinámico de documentos se logra a través de una combinación de deepstream.io e IronPDF. deepstream.io sincroniza cambios y registra todos los eventos en tiempo real, por lo que puede reaccionar de inmediato a cualquier cambio en los datos. IronPDF ofrece un mecanismo robusto para crear documentos profesionales sobre la marcha. Esta integración permitirá que sus aplicaciones creen y procesen automáticamente documentos PDF no solo cuando cambian los datos en vivo, sino también cada vez que un usuario interactúa con su aplicación.

Ya sea generación de informes, facturas u otro tipo de documento, deepstream.io integrado con IronPDF permite la simplificación de flujos de trabajo, la creación responsiva de documentos, y mantiene su aplicación ágil y actualizada con información en tiempo real. Este par funciona mejor para aplicaciones ágiles, impulsadas por datos y responsivas que exigen soporte de generación y manejo de documentos en tiempo real.

Las bibliotecas proporcionadas por Iron Software nos permiten crear programas rápida y fácilmente para una variedad de sistemas operativos, navegadores y plataformas, incluyendo Windows, Android, MAC, Linux, etc.

Curtis Chau

Chatea con el equipo de ingeniería ahora

Escritor Técnico

Curtis Chau tiene una licenciatura en Ciencias de la Computación (Carleton University) y se especializa en el desarrollo front-end con experiencia en Node.js, TypeScript, JavaScript y React. Apasionado por crear interfaces de usuario intuitivas y estéticamente agradables, disfruta trabajando con frameworks modernos y creando manuales bien ...