Library / SDK
sozu-proxy/sozu avatar
sozu-proxy/sozu

Sozu upgrades itself and ships two build products that are not the same binary

Sōzu HTTP reverse proxy, configurable at runtime, fast and safe, built in Rust. It is awesome!

3,758 stars212 forksRustAGPL-3.0

At a glance

What is it?
sozu-proxy/sozu is a reverse proxy that takes configuration over a secure socket at runtime and replaces its own workers without dropping requests. The release engineering is where the documentation is most unusually candid: ten signed tarballs, a container image that is explicitly not byte-equivalent to them, and a fuzzing crate kept outside the workspace.
Who is it for?
Sozu suits an operator who cannot take a proxy outage for a configuration change or an upgrade, and who wants a build whose provenance they can verify. It does not suit someone who needs a container image and a signed tarball to be the same bytes, because the documentation says they are not.
Can I use it commercially?
Yes, with strict conditions. AGPL-3.0 is a network copyleft licence: if people use a modified version over a network, for example as a hosted service, you must offer them its source code under the same licence.
Is it still maintained?
Yes. The repository received new commits within the last day.
What is it written in?
Mainly Rust, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • sozu-proxy/sozu3,758 ★ · +24
Star history
Repository2026-09-242026-11-15
sozu-proxy/sozu3.7k3.8k

24 Stars in the last 52 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

Configuration changes without a reload, upgrades without a restart

The first two features are the reason the project exists and they are two different promises. Hot configurability means configuration changes arrive at runtime over secure unix sockets without a reload. Always-up means something narrower and stronger: the proxy upgrades itself while it is still processing requests. The second is not a slogan about uptime measurement, it is a description of the process model, and the source layout later in the readme confirms it by naming a master and worker supervisor as the thing that orchestrates hot reconfiguration and zero-downtime upgrades. So a configuration edit and a binary replacement travel through the same machinery, which is why the supervisor exists as a separate concern from the protocol code. It also explains why the readme bothers to name the transport for configuration changes at all: a socket on the filesystem is reachable by whoever can write to that directory and by nobody else, which is a smaller surface than a management endpoint would be.

The other two feature entries describe what the proxy does with a request rather than how it is managed. It acts as a TLS endpoint so backends can focus on their own work, with the cryptography backend chosen at compile time among three options. And it exposes a live operator interface, a top-level command available behind a build feature flag, described as a dashboard in the style of the common system monitors, with sparklines, sortable tables, counters and a colour-coded event tail on one screen, running over the command socket that already exists rather than a new one.

Ten tarballs, four providers, and one combination that fails

The installation section documents a release matrix in unusual detail. Ten prebuilt archives cover the cross-product of target and cryptography provider, with names following a stated pattern, and each release also carries a checksum file covering all ten, a keyless signature pair, and build-provenance attestations that can be checked with a command. Three targets are published and four are supported from source. The provider list has four entries and they are not equally available: two cover all published targets, while the system-OpenSSL backend and a validated mode are restricted to the GNU targets, and the validated mode additionally carries a note that no service level agreement is offered for it. The documentation also states which combination to pick by default for an operator with no specific compliance constraint, which is a sensible thing to say and rarer than it should be. One combination is called out as a known gap with a specific reason and a workaround.

sh
cargo build -p sozu --release --locked
target/release/sozu start -c bin/config.toml

The container image is not the signed tarball, and the readme says so

There is a dedicated note comparing the container image against the signed archives, and it is the most useful paragraph in the release documentation. The image is built from source by the same release workflow, but inside a builder stage based on a pinned official Rust image, so the same compiler version is used in a different build environment. The consequence is stated without hedging: the binary in the image is statically linked against the alternative C library and is not byte-equivalent to either of the published archives. Build provenance currently covers the archives only. The recommendation follows directly: if you need the attested binary, extract the archive and run the executable, and building a container image from the archive is tracked as follow-up work.

One dependency could not cross-compile, so that combination is missing

The missing matrix entry is explained in the same installation section, and the explanation is the kind of detail that usually gets edited out. One architecture and C library combination builds from source but is not in the prebuilt set, because the allocator dependency's cross-compile probe cannot link its atomics tests against the wrapper toolchain used on the arm64 runner. The workaround is given: build from source against a real cross toolchain if you need that combination. So of the four supported targets, three ship as binaries and one does not, for a reason rooted in a single build dependency rather than in the proxy itself. The prebuilt set is therefore not a convenience list but a record of what the release pipeline could reproduce, and the names make that checkable: pick a target and a provider, and either there is an archive for that pair or you are building it yourself.

Five crates, and the async runtime is kept out of two of them

The source tour describes five crates and each entry is a sentence explaining what it owns. The library holds a single-threaded event loop, the version one and version two multiplexer, TCP, UDP and TLS, routing, per-IP rate limiting, metrics and a buffer pool. The binary wraps it in a supervisor, exposes the command socket and hosts the operator interface behind a feature flag. The command crate holds the protobuf schema for inter-process communication, the configuration parser, replicated state and descriptor-passing helpers. The end-to-end harness spawns real workers against mock clients and backends. The simulation crate is marked as never published and exists so the asynchronous runtime is a development dependency there, leaving the library and the binary free of it. That last constraint is the one with consequences: the event loop the proxy actually runs is single-threaded and does not use the asynchronous runtime, so the concurrency model is one worker owning its connections rather than many tasks multiplexed onto a runtime.

Fuzzing lives outside the workspace on purpose

There is one crate that is not a workspace member, and the readme explains why it is built separately: the fuzzing targets need a nightly compiler and a separate command, so they sit outside the normal build and are invoked from inside their own directory. Two targets are named, one for the frame parser and one for the header compression decoder, which are the two places where a proxy parses attacker-controlled bytes before any policy has been applied. Keeping them out of the workspace means the ordinary build does not need the nightly toolchain, which is the trade the layout is making. The header compression decoder is the more interesting of the two targets, since that is code that runs before any request has been accepted and therefore before any rate limit has been consulted.

Workers are sandboxed on the assumption of compromise

One of the reasons to use the project is network protection, and the reasoning is layered. Backends are shielded behind the proxy so direct access to them can be limited, the implementation language is described as primed for memory safety, and then the third layer is the interesting one: even if a worker is exploited, the workers are sandboxed. That is a different claim from memory safety. Memory safety means a bug has less route to becoming code execution; sandboxing means that when code execution happens anyway, the blast radius is one process handling one cluster rather than the whole proxy. The readme also names two dependencies that were optimised specifically to avoid copying, which is the performance counterpart to the safety argument. Neither argument is about the proxy being unbreakable; both are about reducing what a single mistake can cost, and the readme is careful to phrase the sandboxing claim as a containment property rather than a prevention one.

Editorial conclusion

Sozu suits an operator who cannot take a proxy outage for a configuration change or an upgrade, and who wants a build whose provenance they can verify. It does not suit someone who needs a container image and a signed tarball to be the same bytes, because the documentation says they are not. Before deploying, pick your cryptography provider from the four documented options, and if you take the container image rather than the tarball, accept that build-provenance attestation currently covers only the tarballs.

Frequently asked questions

How do I implement reverse proxy in Rust?

This repository is a finished implementation rather than a tutorial, but its source tour describes the pieces such a proxy needs: a single-threaded event loop, a multiplexer for both HTTP versions, the transport protocols, routing, per-IP rate limiting, metrics and a buffer pool, with a separate binary adding a supervisor process for runtime reconfiguration and zero-downtime upgrades.

What does Sozu require before it will run?

Building from source needs a protocol buffer compiler and the Rust toolchain pinned by the repository, and the readme quotes a specific minimum compiler version for the quickstart. The configuration file is an in-tree sample that has to be copied next to your certificates and edited before production use.

Can I run Sozu from a container image and still verify it?

Not with the image itself, and the readme is explicit about it. The container image is built by the same release workflow but in a different build environment, so its binary is not byte-equivalent to the signed archives, and build provenance currently covers only the archives. To verify a build, extract an archive and run the executable from it.

Which cryptography provider should I choose for Sozu?

The readme names a default for operators with no specific compliance constraint: the ring backend on the GNU Linux target. Two further options exist, one of them capable of post-quantum key exchange and one restricted to the GNU targets, and a fourth runs the second in a validated mode with no service level agreement offered for it.

Official sources

  1. License: AGPL-3.0
  2. Project website
  3. README
  4. Releases
  5. sozu-proxy/sozu on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/sozu-proxy-sozu.svg)](https://hysenlabs.com/projects/sozu-proxy-sozu)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/sozu-proxy-sozu.svg)](https://hysenlabs.com/projects/sozu-proxy-sozu)

Was this useful?