Skipper's install example is still pinned to v0.27.92
An HTTP router and reverse proxy for service composition, including use cases like Kubernetes Ingress
At a glance
- What is it?
- Skipper is an HTTP router and reverse proxy for service composition, built around a descriptive routing language and four separate binaries. Its quickstart commands, its licence line and its feature list each point somewhere slightly different.
- Who is it for?
- Skipper fits a large Go organisation that wants routing rules to come from a data store rather than from static files, and that expects to write its own filters eventually, because that is what the project is built for.
- Can I use it commercially?
- Check first. The repository uses a licence we do not classify automatically, so read its LICENSE file before any commercial use.
- Is it still maintained?
- Yes. The repository last received commits 2 days ago.
- What is it written in?
- Mainly Go, 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.
Star history
- zalando/skipper3,334 ★ · +5
| Repository | 2026-09-24 | 2026-11-15 |
|---|---|---|
| zalando/skipper | 3.3k | 3.3k |
5 Stars in the last 52 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
Four request properties decide the route
The routing model is short enough to state in full. Routes are identified by properties of the incoming request: path, method, host and headers. Once a route matches, filters can modify the request and the response, and each route carries its own filter configuration rather than sharing one global list. Requests and backend responses are streamed at the same time rather than buffered, and a route can also be a shunt, meaning it answers the request itself instead of forwarding it, which the file suggests using as a static file server or as a mock backend for diagnostics. The configuration language for all this is eskip, shipped with the project as its own binary, and the example route in the getting started section is a single line pairing a path predicate with a backend URL. The container route publishes two ports, 9090 for the proxy itself and 9911 for something the visible text never names, with metrics and logging directories in the tree being the place to look for what answers on it.
Rules change without reloads, from five kinds of source
Route updates do not require downtime, and the data source is chosen at deployment rather than compiled in. The documented sources are etcd, Kubernetes Ingress, static files, a route string passed directly, and custom sources you write yourself. The Ingress path is the one with its own behaviour: Skipper can serve as an Ingress controller without reloading, and it is designed to sit behind another controller that routes public traffic to a fleet of proxies, with an AWS example linked for that arrangement. Two shipped components exist because of Kubernetes specifically. One proxies to spare the API server from overload by using the ETag header so the data plane spends less CPU. The other is a validation webhook that checks manifests are safe to deploy.
Four binaries, one linker flag pattern
The build file compiles four programs from one source tree: the proxy, the eskip configuration tool, the validation webhook and routesrv. Each target passes the same pair of linker flags, injecting a version variable and a commit hash into the binary at compile time, which is why the version flag can print all three pieces of information at once:
Skipper version v0.27.92 (commit: 344e73c6, runtime: go1.27.1)The version string itself comes from git describe with tags, always and dirty, so an untagged working tree reports as dirty rather than lying about a release. A VERSION file also sits at the root, and the make variable can be overridden, so a release build does not depend on the tag being present in the checkout.
The getting started commands are a release behind
The binary installation example downloads a specific archived release rather than the latest one, and prints that same version back:
% curl -LO https://github.com/zalando/skipper/releases/download/v0.27.92/skipper-v0.27.92-linux-amd64.tar.gz
% tar xzf skipper-v0.27.92-linux-amd64.tar.gz
% mv skipper-v0.27.92-linux-amd64/* $GOBIN/
% skipper -versionThe three most recent releases are in the v0.28 line, so a reader who copies the example gets a proxy several minor versions behind the current tag, with a runtime line that also names an older Go toolchain. The example additionally assumes a Go bin directory already exists and is on the path, which is the one prerequisite it does not create for you. The source route is two commands, clone and make, and reaches the same binary from the current tree.
Four generations of tracing in one dependency list
The direct requirements include three separate tracing stacks rather than one: a Lightstep tracer, the OpenTracing interface with its basic implementation, and an Instana sensor. The tree also carries an OpenTelemetry directory. Alongside them sit Prometheus client libraries, a third-party metrics library and a logging directory, so a deployment inherits four instrumentation generations and picks one. This is not stated as a feature anywhere in the file. It matters because each stack has its own exporter configuration, and a project that started with one of them and then added another has usually kept the old one working for compatibility.
Policy engines in the build, policy containers on the wish list
The feature list names five things as outstanding, and the first two are a proxy library and authentication with authorization. The authentication line adds a condition in parentheses: no external dependency on an OAuth proxy or on Open Policy Agent containers. Meanwhile the direct requirements already include Open Policy Agent itself, an environment-aware build of it, its Envoy plugin and the Envoy control plane, and the tree has a directory for JSON web tokens. So the direction of travel is inlining policy evaluation into the data plane, and the dependencies are already there for it. The other three outstanding items are cluster rate limits without instance local storage, Let's Encrypt with remote storage, and a tiered cache over local and remote storage.
Plugin tests build shared objects from committed directories
The build file carves out two directories from the source list, one for plugins expected to succeed and one for plugins expected to fail, and then names five shared objects to build from them: a no-op filter, a predicate that matches nothing, a no-op data client, a no-op multi-type plugin, and one plugin in the failing directory. That last one is the interesting case, because a plugin system that cannot be tested against a plugin that must fail is not really tested. The same build file reads the process file descriptor limit through the shell, and a target exists to raise it, which matches the note in the working-with-code section that the tests can fail on a Mac purely because the open file limit is too low.
readme.md, doc.go and two licence statements
The top level of the repository mixes documentation tooling with governance files in a way worth knowing about. There is a lowercase readme file beside a Go documentation file at the package root, a documentation directory with its own site build file, a directory of design proposals, a context file, an agent instructions file, a directory of the same, a cluster fuzzing configuration, a delivery descriptor and a maintainers file. The licence appears twice as well: the README carries an Apache 2.0 badge, a LICENSE file sits at the root, and the repository's own licence metadata records no assertion rather than a named licence. Nothing in the tree reconciles those, so anyone with a compliance question has to read the file rather than trust the badge.
Editorial conclusion
Skipper fits a large Go organisation that wants routing rules to come from a data store rather than from static files, and that expects to write its own filters eventually, because that is what the project is built for. Before adopting it, check four things: which route source you will run in production, since the Ingress path and the etcd path behave differently at failure, whether you need the features its own list calls outstanding, such as rate limiting and certificate storage, how many tracing stacks you are willing to inherit, since four appear across its dependencies and directories, and whether the licence statement you need is the badge in the README or the metadata on the repository, which do not agree. The plugin mechanism is the part to read first if you plan to extend it.
Frequently asked questions
What is Zalando Skipper?
An HTTP router and reverse proxy for service composition, designed to handle more than 300k route definitions with detailed lookup conditions and to modify request and response flow through filters configured per route. It speaks HTTP/1.1, H2C and HTTP/2.
How do you run Zalando Skipper from a local route file?
Write an eskip file pairing a path predicate with a backend, check it with eskip check, which logs nothing when the file is valid, then start the proxy with the routes file flag and request it. The worked example serves on localhost:9090.
Where can Zalando Skipper read its routes from?
From etcd, Kubernetes Ingress, static files, a route string given directly, or custom configuration sources. It can act as an Ingress controller without reloads, and a separate routesrv proxy reduces API server load by using the ETag header.
Does Zalando Skipper handle authentication?
It can run as an authentication proxy checking incoming requests with Basic auth, an OAuth2 provider or an OpenID Connect provider, with audit logging. Its feature list still names authentication and authorization as outstanding, wanting no external auth proxy or policy agent container.
How many programs does Zalando Skipper build?
Four: the proxy, the eskip configuration tool, the Kubernetes validation webhook and routesrv. Each is compiled with linker flags that inject the version and the commit hash, which is what the version flag prints along with the Go runtime version.
What licence is Zalando Skipper under?
Its README carries an Apache 2.0 badge and a LICENSE file sits at the root of the repository, while the repository's licence metadata records no assertion instead of a named licence. Nothing visible reconciles the two.
Official sources
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.
[](https://hysenlabs.com/projects/zalando-skipper)Star history chart for your README
[](https://hysenlabs.com/projects/zalando-skipper)Was this useful?