AIDE PYTHON

deepstream io (Comment ça marche pour les développeurs)

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

Mis à jour:juin 22, 2025

Un serveur en temps réel est conçu pour répondre aux données instantanément, le rendant réactif à chaque interaction utilisateur ou événement système. Contrairement aux serveurs de requête-réponse conventionnels qui introduisent des délais, les [serveurs](https://en.wikipedia.org/wiki/Server_(computing) en temps réel utilisent des technologies et des protocoles pour garantir un échange d'informations continu et des mises à jour instantanées. Cela est dû au fait qu'un serveur en temps réel est crucial pour plusieurs applications nécessitant des communications en direct : systèmes de messagerie, jeux en ligne, plateformes de trading financier et outils collaboratifs. Dans cet article, nous allons apprendre à utiliser le serveur en temps réel open-source deepstream et IronPDF pour générer des PDFs.

deepstream.io est un serveur en temps réel évolutif pour la synchronisation des données et la messagerie un-à-plusieurs. Il peut gérer les données facilement et maintenir de nombreux clients synchronisés avec une très faible latence, prenant en charge le transfert de données binaires. deepstream.io est conçu pour être mis derrière d'autres équilibreurs de charge et offre un moyen efficace de synchroniser les données et de garder les fichiers ressources à jour, ce qui le rend parfaitement adapté aux applications mettant à jour les données en temps réel et recherchant une solution de serveur évolutive.

deepstream io (Comment cela fonctionne pour les développeurs) : Figure 1 - deepstream.io

La mise en œuvre de deepstream.io par les développeurs permet facilement des mises à jour en direct, des applications collaboratives et des expériences interactives en temps réel, sans partir de zéro. Il a été conçu pour des charges élevées et une mise à l'échelle efficace, en faisant le logiciel de choix pour les applications à haute concurrence. deepstream.io est flexible et peut se révéler être l'ajout parfait à votre pile de technologies de diverses manières. Il fournit une solution complète pour permettre aux utilisateurs de créer des applications web et mobiles en temps réel, réactives et interactives.

Pour créer un nouveau répertoire Node.js, entrez les commandes suivantes dans la console :

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

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

SHELL

Installer le paquet deepstream.io

Tout d'abord, vous devez installer deepstream.io. Vous pouvez soit utiliser NPM pour l'installer, soit télécharger les binaires depuis le site officiel.

npm install @deepstream/server

npm install @deepstream/server

SHELL

Configuration de base 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

Le fragment de code ci-dessus montre comment configurer et démarrer un serveur deepstream.io en utilisant le paquet @deepstream/server dans Node.js. Il commence par importer la classe Deepstream du paquet, puis créer une nouvelle instance. En appelant server.start(), le serveur est démarré et est prêt à accepter des connexions entrantes pour gérer les services de liaison de données en temps réel, de messagerie ou de présence.

Connexion de Deepstream au Client

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

Le code ci-dessus montre comment se connecter à deepstream en utilisant la bibliothèque @deepstream/client. Ce script importe la classe DeepstreamClient, crée une instance et la connecte à un serveur deepstream s’exécutant localement sur l'adresse IP 127.0.0.1 sur le port 6020. Il se connecte sans identifiants, ce qui est suffisant si le serveur n’utilise pas l’authentification ou s’il est utilisé pour des cas de test. Cette configuration initialise un client capable de synchronisation des données et de communication en temps réel.

Une fois la connexion avec le nœud du serveur établie, un message similaire à celui ci-dessous apparaîtra dans la console du serveur.

deepstream io (Comment cela fonctionne pour les développeurs) : Figure 2 - Message de console

Utilisation de Listener avec deepstream.io

Ci-dessous se trouve un exemple de code qui peut être utilisé pour créer des écouteurs, un des concepts clés 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

Dans le code ci-dessus, le client se connecte à un serveur deepstream hébergé sur 127.0.0.1:6020 en utilisant la bibliothèque @deepstream/client. Après authentification réussie, il publie un événement personnalisé nommé "custom-event" avec une charge utile { message: "Bonjour, Deepstream !" }.

Présentation d'IronPDF

Utilisez IronPDF, un package Node.js incroyablement puissant, pour créer, éditer, convertir et modifier des documents PDF. C'est un outil utilisé dans la majorité des processus basés sur la programmation pour les PDFs, et les processus backend tels que la modification des PDFs existants et la conversion de HTML en PDFs. Dans les applications où la création et la gestion dynamique des PDFs sont nécessaires, IronPDF devient très utile. Il fournit un moyen convivial et flexible de générer des documents PDF de qualité.

deepstream io (Comment cela fonctionne pour les développeurs) : Figure 3 - IronPDF

Installer le package IronPDF

Utilisez npm pour télécharger et installer des packages qui activent la capacité IronPDF de Node.js.

npm install @ironsoftware/ironpdf

npm install @ironsoftware/ironpdf

SHELL

Fonction de génération de PDF

Créez une fonction qui utilise IronPDF pour générer des 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

Configurer le client Deepstream

Écrivez un script JavaScript qui écoutera les données en temps réel et générera des PDFs basés sur ces données :

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

Publication d'Événements pour Déclencher la Génération de PDF

Les événements peuvent être publiés pour déclencher la génération de PDF depuis un autre fichier JavaScript ou une partie de votre application :

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 est implémenté en écoutant les événements en temps réel qui déclencheront la génération de PDF. La fonction generatePDF crée un document PDF basé sur les données provenant des événements Deepstream.io en utilisant IronPDF. Le DeepstreamClient s'abonne à ces événements, et chaque fois que des événements pertinents sont publiés, il appelle la fonction de génération de PDF. Une telle intégration permet la génération dynamique de PDFs en temps réel basée sur les occurrences d'événements, les demandes ou les changements de données.

deepstream io (Comment cela fonctionne pour les développeurs) : Figure 4 - Sortie PDF

Licences

Pour que le code compile et fonctionne sans filigrane, une clé de licence est requise. Les développeurs qui souhaiteraient une licence d'essai peuvent s'inscrire ici. L'obtention de celle-ci ne nécessite pas de présenter une carte de crédit. Tout ce que vous avez à faire pour vous inscrire à un essai gratuit est de saisir votre adresse e-mail.

Conclusion

L'une des solutions les plus puissantes pour la gestion des données en temps réel et la génération dynamique de documents est obtenue grâce à une combinaison de deepstream.io et IronPDF. deepstream.io synchronise les changements et enregistre tous les événements en temps réel, il peut donc réagir immédiatement à tout changement de données. IronPDF fournit un mécanisme robuste pour créer des documents professionnels à la volée. Cette intégration permettra à vos applications de créer et de traiter automatiquement des documents PDF non seulement lorsque des données en direct changent, mais aussi chaque fois qu'un utilisateur interagit avec votre application.

Que ce soit pour la génération de rapports, de factures, ou tout autre type de document, deepstream.io intégré à IronPDF permet une simplification du flux de travail, une création de documents réactive, et maintient votre application légère et à jour avec les informations en temps réel. Cette association fonctionne mieux pour les applications agiles, axées sur les données et réactives qui exigent un support de génération et de gestion de documents en temps réel.

Les bibliothèques fournies par Iron Software nous permettent de créer des programmes rapidement et facilement pour une variété de systèmes d'exploitation, navigateurs et plateformes, y compris Windows, Android, MAC, Linux, etc.

Curtis Chau

Discutez maintenant avec l'équipe d'ingénierie

Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...