Why Every Developer Needs FRP: Fast Reverse Proxy for Secure Remote Access

Introducing the powerful internal network penetration tool FRP (Fast Reverse Proxy)

Why every programmer must have an excellent internal network penetration tool

In computer networks, internal network penetration creates a secure channel via the public network, allowing services inside a private network to be accessed externally. For programmers, this enables several key capabilities.

Access internal services

Benefits: Internal network penetration lets developers access internal services over the public network, which is especially convenient for remote work or when cloud services need to reach internal resources.

Necessity: Services inside a private network cannot be accessed directly via a public IP; penetration breaks this limitation, allowing easy external access and testing.

Remote debugging and development

Benefits: Developers can debug and develop remotely by mapping local services to the public network, enabling work from any device without being tied to a specific network.

Necessity: Continuous iteration and testing benefit from remote debugging, which improves development efficiency and reduces geographic constraints.

Webhook reception

Benefits: Internal network penetration can receive webhook requests from external services, essential for handling callbacks such as GitHub webhooks.

Necessity: External services often need to send callbacks to a specific address, which is impossible from a private network without penetration; FRP maps the local service to a public address to enable this.

Sensitive data protection

Benefits: FRP uses encryption and authentication to secure communication between internal services and external environments, allowing developers to use internal services safely from outside.

Necessity: Protecting user privacy and complying with security standards requires a controlled remote access method, which FRP provides.

Therefore, programmers must learn to use internal network penetration tools, as they greatly aid daily work.

Recommended tool: FRP (Fast Reverse Proxy)

FRP stands out for several reasons:

Simple configuration

FRP offers clear configuration files that are easy to set up without deep networking knowledge.

Multi‑protocol support

It supports TCP, UDP, HTTP, HTTPS, and more, suitable for simple port mapping as well as complex web service proxying.

Security guarantees

FRP provides authentication and TLS/SSL encryption to protect data transmission, essential for handling sensitive information.

Cross‑platform support

Available on Windows, Linux, and macOS, offering flexibility across environments.

High performance and stability

Designed for high concurrency and stable operation in production.

Active community and continuous updates

An active open‑source community provides support and regular improvements.

Flexible application scenarios

Supports remote debugging, exposing internal services, webhook reception, and more.

Quick start with FRP on Ubuntu 20.04

We use Linux Ubuntu 20.04.2 LTS x86_64 for demonstration. FRP requires two servers: a client and a server.

FRP server

Listen for external requests: The server listens on a public port for incoming connections.

Reverse‑proxy internal services: Incoming requests are forwarded to the FRP client inside the private network.

Security authentication and encryption: Supports username/password authentication and optional TLS encryption.

FRP client

Connect to FRP server: The client establishes a connection to the server using the address and port defined in its configuration.

Map internal services: The client links internal services to the server, specifying type, IP, and port.

Maintain heartbeat: Periodic heartbeats keep the connection stable for long‑running services.

Configure the FRP server

1. Download FRP:

wget https://github.com/fatedier/frp/releases/download/v0.36.2/frp_0.36.2_linux_amd64.tar.gz

2. Extract: tar -zxvf frp_0.36.2_linux_amd64.tar.gz 3. Copy example config: cp frps.ini /etc/frp/frps.ini 4. Edit frps.ini (set bind_port to the desired listening port, e.g., 7000): bind_port = 7000 5. Start the server: ./frps -c /etc/frp/frps.ini Configure the FRP client

1. Download and extract FRP (same steps as server).

2. Copy example client config: cp frpc.ini /etc/frp/frpc.ini 3. Edit frpc.ini (set server_addr, server_port, and token to match the server):

[common]
server_addr = your_server_ip
server_port = 7000
token = your_token

4. Add a mapping rule, e.g., expose local port 80 as remote port 6000:

[web]
type = http
local_ip = 127.0.0.1
local_port = 80
remote_port = 6000

5. Start the client: ./frpc -c /etc/frp/frpc.ini After both sides are running, you can access the internal service via the public IP and remote port, for example, SSH to 47.104.77.123 on port 6000: ssh [email protected] -p 6000 Note: Ensure the chosen ports are open in the firewall.