reverse-proxy-service is tower's Services that perform reverse proxy.

These Services are implemented to be used in axum, but they can be used in a more general situation.

See the documentation.

lib.rs:

reverse-proxy-service is tower Services that performs "reverse proxy" with various rewriting rules.

Internally these services use hyper::Client to send an incoming request to the another server. The connector for a client can be HttpConnector, HttpsConnector, or any ones whichever you want.

Examples

There are two types of services, OneshotService and ReusedService. The OneshotService owns the Client, while the ReusedService shares the Client via Arc.

General usage

use reverse_proxy_service::ReusedServiceBuilder;
use reverse_proxy_service::{ReplaceAll, ReplaceN};

use hyper::body::Body;
use http::Request;
use tower_service::Service as _;

let svc_builder = reverse_proxy_service::builder_http("example.com:1234").unwrap();

let req1 = Request::builder()
    .method("GET")
    .uri("https://myserver.com/foo/bar/foo")
    .body(Body::empty())
    .unwrap();

// Clones Arc<Client>
let mut svc1 = svc_builder.build(ReplaceAll("foo", "baz"));
// http://example.com:1234/baz/bar/baz
let _res = svc1.call(req1).await.unwrap();

let req2 = Request::builder()
    .method("POST")
    .uri("https://myserver.com/foo/bar/foo")
    .header("Content-Type", "application/x-www-form-urlencoded")
    .body(Body::from("key=value"))
    .unwrap();

let mut svc2 = svc_builder.build(ReplaceN("foo", "baz", 1));
// http://example.com:1234/baz/bar/foo
let _res = svc2.call(req2).await.unwrap();

In this example, the svc1 and svc2 shares the same Client, holding the Arc<Client>s inside them.

For more information of rewriting rules (ReplaceAll, ReplaceN etc.), see the documentations of rewrite.

With axum

use reverse_proxy_service::ReusedServiceBuilder;
use reverse_proxy_service::{TrimPrefix, AppendSuffix, Static};

use axum::Router;

#[tokio::main]
async fn main() {
    let host1 = reverse_proxy_service::builder_http("example.com").unwrap();
    let host2 = reverse_proxy_service::builder_http("example.net:1234").unwrap();

    let app = Router::new()
        .route_service("/healthcheck", host1.build(Static("/")))
        .route_service("/users/*path", host1.build(TrimPrefix("/users")))
        .route_service("/posts", host2.build(AppendSuffix("/")));

    axum::Server::bind(&"0.0.0.0:3000".parse().unwrap())
        .serve(app.into_make_service())
        .await
        .unwrap();
}

Return Types

The return type (Future::Output) of ReusedService and OneshotService is Result<Result<Response, Error>, Infallible>. This is because axum's Router accepts only such Services.

The Error type implements IntoResponse if you enable the axumfeature. It returns an empty body, with the status code INTERNAL_SERVER_ERROR. The description of this error will be logged out at error level in the into_response() method.

Features

By default only http1 is enabled.

• http1: uses hyper/http1
• http2: uses hyper/http2
• https: alias to nativetls
• nativetls: uses the hyper-tls crate
• rustls: alias to rustls-webpki-roots
• rustls-webpki-roots: uses the hyper-rustls crate, with the feature webpki-roots
• rustls-native-roots: uses the hyper-rustls crate, with the feature rustls-native-certs
• rustls-http2: http2 plus rustls, and rustls/http2 is enabled
• axum: implements IntoResponse for Error

You must turn on either http1or http2. You cannot use the services if, for example, only the https feature is on.

Through this document, we use rustls to mean any of rustls* features unless otherwise specified.