All articles
Connectivity8 min read

Put your application online without moving its origin

The machine that runs an application and the address people use to reach it can have different jobs. RingLink Connector makes that separation practical

The application works. You can open it on the machine where it runs, and everyone who has seen it wants access. Then comes the networking conversation: does this machine have a public IP? Who controls the router? Can we open a port? Would it be easier to move the whole thing somewhere else?

A small application can inherit a surprisingly large infrastructure project this way. A preview running on a workstation, a service at a branch office and a workload inside a private network all have the same basic need: an address their users can reach. Moving the application is only one way to provide that address

With RingLink Connector, the origin device establishes an outbound connection to RingLink. A public application entry at the edge forwards the selected traffic back through that connection. The application can keep its local address, its existing deployment process and the machine it already runs on

The public entry belongs at the edge. The Connector reaches the selected service from inside the origin networkExternal clientsRingLink edgePublic entryTCP · Edge entryPrivate origin networkPublic app listener closedConnectorOutbound bridgePrivate origin127.0.0.1:8080Loopback listener · 127.0.0.1:8080Service traffic → local listener← Connector establishes the outbound connection
External clients
RingLink edgePublic entryTCP · Edge entry
Connector establishes the outbound connection
Public app listener closed
Private origin network
ConnectorOutbound bridge
Private origin127.0.0.1
Loopback listener · 127.0.0.1:8080Service traffic → local listener
The public entry belongs at the edge. The Connector reaches the selected service from inside the origin network

An address for the application, a home for the process

This is a useful distinction to make early. An application might belong on a particular machine because it sits next to a database, talks to a local device, or is part of a deployment that already works. None of those decisions should be made by the availability of a spare public IP

The Connector gives that machine a path to RingLink. When you publish an application, you choose its protocol and the local address and port the Connector should reach. The resulting public hostname and entry port are what you give to users

That does not expose an entire subnet. The application has an explicit local target. Other services on the host still need their own configuration, and a Mesh-only Connector cannot be used as a public application origin. For this path, use an ordinary Connector attached to an active service instance

A service that stays on 127.0.0.1

Use a supported Linux or Windows host for the Connector; the commands here use Linux with Python 3 and curl. You also need an active RingLink instance and permission to manage its applications and Connectors. The Python server is a deliberately small example, not a production web server. For a real application, keep its normal process manager and substitute its listener address

A plain HTTP service makes the idea easy to see. Put a page in a directory and bind a small server to loopback. This command starts a local listener; keep it running while you configure the application

bashA local service to publish
mkdir -p ~/private-service
printf 'Hello from a private origin\n' > ~/private-service/index.html
python3 -m http.server 8080 --bind 127.0.0.1 --directory ~/private-service
bashCheck the origin before connecting it
curl --fail --show-error http://127.0.0.1:8080/
# Hello from a private origin

Run that check in a second terminal on the same host. A connection refusal here means the local process is not listening; changing RingLink settings cannot fix it. In this example the Connector will run on this host too, so 127.0.0.1 refers to the right machine. A Connector inside a separate container has a different loopback interface: use an address it can actually reach instead

In Dashboard, open Connectors and add an ordinary Connector to your service instance. Run the generated installation command on the device that runs this service, then wait for the Connector to come online. Use the command generated for your device: it includes a short-lived enrollment credential

Now create a TCP application on the same instance. Choose the Connector as the origin, enter 127.0.0.1 as its local address and 8080 as its local port. Connector-origin applications use one target port and keep Proxy Protocol off. The public port comes from the application configuration: select an available one when your plan calls for a custom port, or use the allocated value on an automatically assigned plan

Open the hostname and entry port shown on the application. For the simple page above, the response should be the same line you see locally

bashRead the response through the public entry
curl --fail http://YOUR_RINGLINK_HOST:YOUR_EDGE_PORT/
# Hello from a private origin

Replace both placeholders with the values on your application; do not copy the local port into the public URL unless the two really match. Run this request from another machine or mobile connection. For this plain HTTP example, explicitly use http://: a browser that upgrades it to HTTPS will ask a non-TLS listener to negotiate TLS

When the page does not open, follow the first failing hop

Start with the local curl above. If it works, check that the selected Connector is online and belongs to the same instance as the application. Confirm TCP, the selected Connector, local address 127.0.0.1 and local port 8080 in the application record. Then compare the public URL’s port with the entry port shown in Dashboard

If a timeout remains, read the Connector diagnostics in Dashboard. They help separate an offline device from an unreachable local target. If you get an HTTP error page instead, inspect the application’s Host-header rules and logs. Once the public request returns the expected line, you have checked the service itself through the published path

For the screenshot below, we published a small application page using this same loopback arrangement. The page retrieved through RingLink matched the local file byte for byte. The host kept a separate management connection, and no public inbound rule was opened for the application port

Application page delivered from a loopback listener through RingLink Connector
The page opened through the public application entry. The process serving it still listens on loopback

Keep the application decisions with the application

TCP carries the HTTP or TLS bytes your application already speaks. To serve sensitive traffic, terminate TLS at the origin listener with a certificate trusted by your clients and valid for the hostname they request. Use a custom hostname you control for a public certificate; the example’s plain HTTP listener does not add TLS. Native HTTP/HTTPS application mode is a separate option for dedicated-IP instances with public origins

There are application details worth keeping in view. A service that checks Host headers or builds absolute links needs to recognize its public hostname and entry port. This Connector path does not preserve the original client IP, so origin-side IP rules cannot distinguish individual users. Keep the application’s own authentication in place

Once the connection works, the application and Connector IDs become part of the deployment record. The machine can keep doing the work it was chosen for. RingLink provides the entry through which people reach that work