Using OpenResty as a High-Performance Proxy Server

Disclosure: Some links on this page are affiliate links. We may earn a commission if you make a purchase through them, at no additional cost to you.

OpenResty is a powerful web application server built on top of Nginx, extending its capabilities by integrating the LuaJIT engine. This combination allows developers to create highly performant web applications and services. One of OpenResty’s primary use cases is as a high-performance proxy server. With its asynchronous nature and ability to handle a large number of concurrent connections, OpenResty has become a go-to solution for organizations looking to optimize web traffic management and load balancing.

Contents show

Setting Up OpenResty as a Proxy Server

Before diving into the technical configuration, ensure you have OpenResty installed. You can easily install OpenResty on Linux systems using the following commands:

sudo apt update
sudo apt install openresty
Once installed, OpenResty runs as a drop-in replacement for Nginx. The configuration is stored in /usr/local/openresty/nginx/conf/ directory, where you can modify the nginx.conf file to tailor OpenResty to your needs.

Basic Configuration of OpenResty as a Proxy

In this section, we will configure OpenResty to act as a reverse proxy, directing incoming requests to backend servers.
Open the nginx.conf file and locate the http block.
Inside the http block, define a proxy pass to the backend server. The configuration looks like this:
nginx
server {
listen 80;
server_name example.com;

location / {
proxy_pass http://backend-server;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
}
}
This configuration tells OpenResty to listen for incoming HTTP requests on port 80 and forward them to the backend-server. The proxy_set_header directives ensure that the original headers (such as the client’s IP) are passed along to the backend.

Advanced Configuration for Load Balancing

OpenResty allows for more sophisticated proxying features like load balancing. For example, let’s say we have multiple backend servers and want to distribute traffic among them. OpenResty uses an upstream module to configure this.

Configuring an Upstream Load Balancer

The configuration below shows how to load balance between multiple backend servers using a round-robin strategy:
nginx
http {
upstream backend {
round-robin;
server backend1.example.com;
server backend2.example.com;
server backend3.example.com;
}

server {
listen 80;
server_name example.com;

location / {
proxy_pass http://backend;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
}
}
}
This configuration will distribute incoming requests across backend1.example.com, backend2.example.com, and backend3.example.com using the default round-robin method. You can also adjust the load balancing algorithm (e.g., least_conn, ip_hash) based on your use case.

Handling SSL/TLS Traffic with OpenResty

When proxying HTTPS traffic, it’s essential to handle SSL termination properly. OpenResty supports SSL termination out-of-the-box, meaning it can handle the decryption of HTTPS traffic and forward the unencrypted HTTP traffic to your backend servers.

SSL Termination Configuration

First, ensure you have the SSL certificates. Then, modify the nginx.conf file to handle SSL termination:
nginx
server {
listen 443 ssl;
server_name example.com;

ssl_certificate /path/to/certificate.crt;
ssl_certificate_key /path/to/certificate.key;

location / {
proxy_pass http://backend-server;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
}
}
This will listen on port 443 for HTTPS traffic, handle SSL decryption, and forward the unencrypted requests to the backend server.

Customizing Proxy Behavior with Lua

One of the standout features of OpenResty is its integration with Lua, allowing you to modify the proxy behavior dynamically. For instance, you can implement custom routing logic, headers manipulation, or even caching strategies.

Using Lua to Modify Request Headers

Here’s an example of how to modify request headers before forwarding them to the backend server:
nginx
server {
listen 80;
server_name example.com;

location / {
set $backend “http://backend-server”;
content_by_lua_block {
local headers = ngx.req.get_headers()
headers[“X-Custom-Header”] = “MyCustomValue”
ngx.req.set_headers(headers)
}

proxy_pass $backend;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
}
}
In this configuration, we use Lua to modify the request headers, adding a custom header X-Custom-Header with a specific value before passing the request to the backend server.

Performance Optimization Techniques

OpenResty, by leveraging Nginx’s high-performance event-driven model, already provides exceptional performance. However, further optimizations can be made by fine-tuning certain settings.

Connection Pooling

To improve the efficiency of proxying requests to backend servers, you can enable connection pooling. This reduces the overhead of establishing new TCP connections for each request.
nginx
http {
upstream backend {
server backend1.example.com;
server backend2.example.com;
keepalive 32;
}