So erstelle ich einen Scratch-Proxyserver mit Node.js

Vielleicht sind Sie neugierig, wie Proxyserver funktionieren und wie sie Daten über das Internet bereitstellen. In diesem Blog werde ich einen Proxyserver mithilfe von Core-NodeJs implementieren. Dies habe ich mithilfe eines Core-NodeJs-Pakets namens „net“ erreicht, das bereits mit NodeJs geliefert wird.

So funktioniert Proxy

Ein Proxyserver ist ein Agent zwischen dem Client und dem Server. Wenn ein

Wenn der Client eine Anfrage an einen Server sendet, wird diese an einen Ziel-Proxy weitergeleitet
Server. Der Ziel-Proxyserver verarbeitet die Anfrage und sendet sie
an den Hauptserver und der Hauptserver sendet die Rückanfrage an den
Proxyserver und der Proxyserver sendet die Anfrage an den Client.

Richten Sie einen Proxyserver ein

Bevor Sie mit dem Programmieren beginnen, wissen Sie wenig über Socket und NodeJs. Sie wissen, was ein Socket ist und wie sie funktionieren.
In NodeJs gibt es zwei Methoden zum Implementieren eines Proxyservers. Zuerst benutzerdefinierte Methode und zweitens eingebaut. Beides ist leicht zu verstehen.

Um Ihren Proxy-Server zu testen, können Sie Ihren lokalen HTTP-Server auf Ihrem lokalen Computer ausführen und dann den Host-Computer als Ziel verwenden.

• Jetzt definiere ich das Netzpaket und schreibe dann den Zielserver und die Portnummer.

const net = require('net');

// Define the target host and port
const targetHost = 'localhost'; // Specify the hostname of the target server. For Ex: (12.568.45.25)
const targetPort = 80; // Specify the port of the target server

• TCP-Server erstellen und überwachen.

const server = net.createServer((clientSocket) => {

});

// Start listening for incoming connections on the specified port
const proxyPort = 3000; // Specify the port for the proxy server
server.listen(proxyPort, () => {
    console.log(`Reverse proxy server is listening on port ${proxyPort}`);
});

• Wir haben einen Server mit dem Net-Paket erstellt. Es handelt sich um einen TCP-Server, der die Portnummer 3000 ausführt, wie wir sie mit der Variablen „proxyPort“ definieren. Wenn der Server startet, wird auf der Konsole die Meldung „Reverse-Proxy-Server überwacht Port 3000“ angezeigt.
• Wenn der Client versucht, eine Verbindung zum Proxyserver herzustellen, führt er die Rückruffunktion aus, die sich in createServer befindet.

• Im Server-Funktionsrückruf haben wir einen Parameter clientSocket, es ist die Benutzerverbindung, die wir für die Verbindung erhalten haben.

• Daten vom Benutzer akzeptieren und empfangen
  

const targetHost = 'localhost'; // Specify the hostname of the target server. For Ex: (12.568.45.25)
const targetPort = 80; // Specify the port of the target server

// Create a TCP server
const server = net.createServer((clientSocket) => {
    // Establish a connection to the target host
    net.createConnection({host: targetHost, port: targetPort}, () => {

        // When data is received from the client, write it to the target server
        clientSocket.on("data", (data) => {
            targetSocket.write(data);
        });

        // When data is received from the target server, write it back to the client
        targetSocket.on("data", (data) => {
            clientSocket.write(data);
        });
    });
});

• Wenn ein Client versucht, eine Verbindung zum Proxyserver herzustellen, erstellen wir mit „create createConnection“ eine temporäre Verbindung zum Server
• createServer hat 2 Argumente
  • 1. Host, zu dem wir eine Verbindung herstellen möchten. In diesem Fall müssen wir eine Verbindung zu unserem Server-Host herstellen, der in der Variable „targetHost“ definiert ist.
  • 2. Port, mit dem wir eine Verbindung herstellen möchten. In diesem Fall müssen wir eine Verbindung zu unserem Server-Port herstellen, der in der Variable „targetPort“ definiert ist.
• Wenn der Benutzer nun Daten sendet, übergebe ich diese Daten an den Server. mit diesem Code

 clientSocket.on("data", (data) => {
     targetSocket.write(data);
 });

• Dann sendet der Server Daten. Ich werde diese Daten mithilfe dieses Codes an den Benutzer senden

  targetSocket.on("data", (data) => {
      clientSocket.write(data);
  });

• Herzlichen Glückwunsch! Sie haben Ihren Proxyserver erfolgreich erstellt.

Fehlerbehandlung

Während es spannend ist, die Funktionalität des Proxyservers zu erkunden, erfordert die Gewährleistung der Zuverlässigkeit robuste Fehlerbehandlungsmethoden, um unerwartete Probleme elegant zu bewältigen. Um diese Art von Fehlern zu behandeln, gibt es ein Ereignis namens Fehler. Es ist sehr einfach umzusetzen.

    const server = net.createServer((clientSocket) => {
     // Establish a connection to the target host
     const targetSocket = net.createConnection({host: targetHost,port: targetPort}, () => {

       // Handle errors when connecting to the target server
       targetSocket.on('error', (err) => {
         console.error('Error connecting to target:', err);
         clientSocket.end(); // close connection
       });

       // Handle errors related to the client socket
       clientSocket.on('error', (err) => {
         console.error('Client socket error:', err);
         targetSocket.end(); // close connection
       });
     });
   });

• Wenn ein Fehler auftritt, werden wir den Fehler beheben und dann die Verbindung schließen.

ALLE Code

• Ersetzen Sie den Hostnamen und die Portnummer nach Ihren Wünschen.

const net = require('net');

// Define the target host and port
const targetHost = 'localhost'; // Specify the hostname of the target server
const targetPort = 80; // Specify the port of the target server

// Create a TCP server
const server = net.createServer((clientSocket) => {
   // Establish a connection to the target host
   const targetSocket = net.createConnection({
      host: targetHost,
      port: targetPort
   }, () => {
      // When data is received from the target server, write it back to the client
      targetSocket.on("data", (data) => {
         clientSocket.write(data);
      });

      // When data is received from the client, write it to the target server
      clientSocket.on("data", (data) => {
         targetSocket.write(data);
      });
   });

   // Handle errors when connecting to the target server
   targetSocket.on('error', (err) => {
      console.error('Error connecting to target:', err);
      clientSocket.end();
   });

   // Handle errors related to the client socket
   clientSocket.on('error', (err) => {
      console.error('Client socket error:', err);
      targetSocket.end();
   });
});

// Start listening for incoming connections on the specified port
const proxyPort = 3000; // Specify the port for the proxy server
server.listen(proxyPort, () => {
   console.log(`Reverse proxy server is listening on port ${proxyPort}`);
});

Gebaute Methode

Um die Komplexität der Client- und Serververbindung zu reduzieren, haben wir eine integrierte Methodenpipe. Ich werde diese Syntax ersetzen

// Handle errors when connecting to the target server
targetSocket.on("data", (data) => {
   clientSocket.write(data);
});

// When data is received from the client, write it to the target server
clientSocket.on("data", (data) => {
   targetSocket.write(data);
});

In diese Syntax

// Pipe data from the client to the target
clientSocket.pipe(targetSocket);

// When data is received from the client, write it to the target server
targetSocket.pipe(clientSocket);

Hier ist der gesamte Code

const net = require('net');

// Define the target host and port
const targetHost = 'localhost';
const targetPort = 80;

// Create a TCP server
const server = net.createServer((clientSocket) => {
   // Establish a connection to the target host
   const targetSocket = net.createConnection({
      host: targetHost,
      port: targetPort
   }, () => {
      // Pipe data from the client to the target
      clientSocket.pipe(targetSocket);

      // Pipe data from the target to the client
      targetSocket.pipe(clientSocket);
   });

   // Handle errors
   targetSocket.on('error', (err) => {
      console.error('Error connecting to target:', err);
      clientSocket.end();
   });

   clientSocket.on('error', (err) => {
      console.error('Client socket error:', err);
      targetSocket.end();
   });
});

// Start listening for incoming connections
const proxyPort = 3000;
server.listen(proxyPort, () => {
   console.log(`Reverse proxy server is listening on port ${proxyPort}`);
});

Ein funktionierender Proxyserver!

Folgen Sie mir auf GitHub avinashtare, Danke.

Das obige ist der detaillierte Inhalt vonSo erstelle ich einen Scratch-Proxyserver mit Node.js. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!