Skip to main content
100%

Gist 4985633

✓ Published0🌍 Public
Aalessioalex
Last edited May 27, 2012
Created on Feb 19, 2013

This example demonstrates a multi-domain HTTP/HTTPS reverse proxy server built with Node.js and the `http-proxy` module. It routes incoming requests to distinct backend applications based on the requested hostname, with separate configurations for `www1.localhost` and `www2.localhost`. The server uses `crypto.createCredentials` for HTTPS SNI callbacks, enabling per-domain TLS certificates. Each backend app, defined in separate files like `www1_app.js`, responds with a plain-text message confirming the successful proxy and echoing request headers, illustrating how the proxy handles both HTTP and HTTPS traffic across multiple virtual hosts.

AI-generated description

Similar vizzes

Loading thumbnail…

Gist 4985631

This example demonstrates how to configure a Node.js HTTPS server with Server Name Indication (SNI) to serve multiple SSL certificates for different hostnames. It shows the setup for routing requests to distinct backend ports using the http-proxy library, with an SNICallback that selects the appropriate certificate context based on the incoming hostname. The code uses Node.js core `crypto.createCredentials` and `fs.readFileSync`, along with a custom `getCABundle` function that parses a bundled certificate file into an array by splitting on the `-END CERTIFICATE-` marker. It explicitly maps example-a.com and example-b.com to localhost ports 10000 and 10001.

Aalessioalex
82% match
Loading thumbnail…

http-debugging-proxy.js

This example demonstrates a custom HTTP proxy server that intercepts requests and serves local files or forwards traffic to a remote target. The code uses Node.js’s `http` module and the `http-proxy` library to create a server listening on port 5050. It checks the request URL for specific paths like `/package/http-proxy` or `/local.css` to stream local HTML or CSS files via `fs.createReadStream`. All other requests are proxied to `https://www.npmjs.org` using `proxy.web(req, res, { target })`, showing conditional routing and file serving alongside proxying.

Aalessioalex
72% match
Loading thumbnail…

Gist 4698533

This example implements a SOCKS5 proxy server in Node.js, demonstrating the TCP connection flow between a client, proxy, and destination. It shows the handshake, authentication (using USERPASS), and request forwarding stages. The code uses the `net` module’s `createServer` and `createConnection` APIs to handle incoming sockets and outbound TCP links, with buffer manipulation for parsing SOCKS5 headers, address types (IPv4, domain, IPv6), and ports. All connections are accepted, authorized, and relayed, though the `authorize` function always returns true.

Aalessioalex
69% match
Loading thumbnail…

Gist 884836

This visualization demonstrates an nginx configuration for proxying requests to a Node.js application running on port 8001. It shows the setup of an upstream server group named "node" and a server block listening on port 80, with access logging enabled. The code specifies root directory paths and includes fastcgi parameters while using proxy_pass to forward requests to the upstream. The example relies on nginx’s built-in HTTP proxy and FastCGI modules, with no external JavaScript libraries or rendering APIs involved.

Aalessioalex
68% match
Loading thumbnail…

Gist 5161583

This visualization demonstrates a Node.js server’s error-handling pattern using domains to manage ECONNRESET socket hangups. It shows how an HTTP request and response object are added to a domain, with an error listener that logs non-reset errors and disposes the domain afterward. The code uses the `domain.create()`, `reqd.add()`, `reqd.on('error')`, and `reqd.dispose()` APIs from Node’s core domain module, integrated as middleware via `app.use()`. The example highlights the flow of middleware execution and error interception in a server context.

Aalessioalex
63% match
Loading thumbnail…

Gist ca8ce8dbd8dbba7b501860f3d569f019

This example demonstrates a lightweight Express server that acts as a CORS proxy for a joke API, enabling browser-based requests to bypass cross-origin restrictions. The code uses the `express` and `request` libraries to define a route, `/jokes/random`, which forwards requests to `https://joke-api-strict-cors.appspot.com/jokes/random` and relays the JSON response back to the client. A middleware sets the `Access-Control-Allow-Origin` header to `*`, allowing any frontend to access the proxied data. The server listens on a configurable port, defaulting to 3000, and handles errors by returning a JSON error object. This setup illustrates a simple server-side solution for enabling client-side data fetching from a restricted external source.

115Dkatz
62% match
Loading thumbnail…

Gist 5383090

This example shows how to forward external HTTP traffic from port 80 to an internal Node.js server listening on port 8000 using iptables NAT rules. The text documents the command-line workflow, including listing the current NAT table, adding a PREROUTING redirect rule, and deleting faulty rules by chain and line number. It also warns against running Node as root for security reasons and acknowledges the risk of disrupting SSH access on port 22. No visualization code or data is present; the example is purely textual documentation of a system administration procedure.

Aalessioalex
61% match
Loading thumbnail…

Gist 7729027

This visualization shows the architecture of a multi-datacenter Node.js deployment, mapping how traffic flows from clients through load balancers, Apache, and hapi.js servers to legacy Java services and analytics pipelines. The diagram uses the `d3.forceSimulation` layout to position nodes representing processes, plugins, and message queues, with edges linking components like `good`, `elmer`, and `prospector`. The code highlights the `services-us-legacy` proxy plugin and its route configuration, while the analytics flow into RabbitMQ, MongoDB, and Splunk is traced from the raw gistfile1.md data.

Aalessioalex
61% match