cloudparts

Lura

A Go framework for building stateless API gateways that fan one client request out to several backends and merge, filter and reshape their responses; the engine inside the KrakenD API Gateway.

Linux Foundation project
What it is
API gateways
Type
Open source
Made by
Lura Project (Linux Foundation), started as the KrakenD framework
Foundation
The Linux Foundation, joined May 2021. A series of LF Projects, LLC, donated by KrakenD
License
Apache 2.0
Facts checked
28 October 2026
Website Source code

What it is

Lura is a set of Go packages, not a ready-to-run gateway. You describe the gateway in a JSON file: each entry under endpoints is a path and method that clients call, with a list of backend requests behind it, each with its own hosts and url_pattern. The config package parses that file, the router package exposes the endpoints over HTTP through an adapter for gin, net/http’s mux, chi, gorilla, httptreemux or negroni, and the proxy package turns each incoming request into one or more backend calls. Proxies and middlewares are plain functions stacked on each other: merging calls several backends concurrently and joins their responses within a timeout, concurrent sends duplicate requests and keeps the first good answer, balancing picks a host, and an EntityFormatter applies each backend’s allow and deny field lists and mapping renames.

That makes Lura a backend-for-frontend builder: a mobile screen that needed four calls to four services can call one gateway endpoint and receive only the fields it uses. The framework is stateless, and KrakenD describes the result as nodes that run independently, “without any coordination or centralized persistence”, so instances scale out behind a load balancer. KrakenD’s Community Edition, also Apache 2.0, assembles Lura with KrakenD’s own components into a binary that adds features such as JWT and OAuth checks, CORS and multi-layer rate limiting; the Lura README sends anyone who wants a complete gateway there. Lura v3.0.0, tagged on September 30, 2026, moved the configuration format to version 4, and KrakenD CE 3.0 is built on it.

Why teams pick it

  • Aggregation is the core feature, not an add-on: one endpoint can call several backends in parallel and return a merged, trimmed response
  • Stateless and configured by a single file, so every instance is identical and scaling out means starting more of them
  • Everything is pluggable: proxies and middlewares are small Go functions, so you can embed it in your own program or swap the HTTP router
  • Vendor-neutral home for the engine behind KrakenD, a gateway the company says ran on more than a million servers a month when it was donated in 2021

Watch out for

  • A library, not a product: on its own it lacks the authentication, rate limiting and other features KrakenD layers on top, and you need Go to build anything with it
  • Development is led by KrakenD’s team, which formed the initial Technical Steering Committee, and releases are infrequent: v2.13.0 in October 2025, v2.14 in March 2026, v3.0.0 in September 2026
  • HTTP only in the router layer: adapters for other protocols such as gRPC, AMQP or NATS are listed as roadmap items
  • JSON is the only well-tested configuration format; the parser accepts others through viper, but the docs warn they haven’t been tested as much

Alternatives

What all api gateways have in common →Compare side by side →
EnvoyOpen sourceA C++ proxy for the edge and between services, configured live through the xDS APIs; the data plane under Istio, Envoy Gateway, Consul’s mesh and many others.Amazon API GatewayAWSAWS’s managed API front door: REST, HTTP and WebSocket APIs that authenticate, throttle and route calls to Lambda and other backends.NGINXOpen sourceAn event-driven web server and reverse proxy that load-balances, caches and terminates TLS for the apps behind it.Cloudflare AI GatewayCommercialA proxy between your application and AI model providers such as OpenAI, Anthropic, Google and Workers AI that logs, caches, rate-limits, retries and bills every call in one place.

How it fits with other technologies

One gateway endpoint that merges two backends and trims their fields · json

{
  "version": 4,
  "name": "My gateway",
  "port": 8080,
  "timeout": "3s",
  "endpoints": [{
    "endpoint": "/users/{user}",
    "method": "GET",
    "backend": [
      {
        "host": ["http://users-a:9000", "http://users-b:9000"],
        "url_pattern": "/registered/{user}",
        "allow": ["name", "email"],
        "mapping": { "email": "personal_email" }
      },
      {
        "host": ["http://permissions:8080"],
        "url_pattern": "/users/{user}/permissions",
        "deny": ["internal_notes"]
      }
    ]
  }]
}

A complete gateway in Go#

Adapted from the Lura README: parse the JSON file, pick a router adapter (gin here) and the default proxy stack, and run.

go
package main

import (
    "log"
    "os"

    "github.com/luraproject/lura/v3/config"
    "github.com/luraproject/lura/v3/logging"
    "github.com/luraproject/lura/v3/proxy"
    "github.com/luraproject/lura/v3/router/gin"
)

func main() {
    cfg, err := config.NewParser().Parse("/etc/lura/configuration.json")
    if err != nil {
        log.Fatal("ERROR:", err.Error())
    }
    logger, _ := logging.NewLogger("ERROR", os.Stdout, "[LURA]")
    routerFactory := gin.DefaultFactory(proxy.DefaultFactory(logger), logger)
    routerFactory.New().Run(cfg)
}

See it in a real stack

No architecture uses Lura yet. Drop it into the playground and wire it up yourself.Open playground →
Where it came from2016–2026

Front ends built on microservices often need data from several services that were not designed around any one screen, so clients made many calls and threw most of each response away. KrakenD, whose team is led by CEO Albert Lombarte, answered that with a gateway that aggregates and trims responses, and has run in production at large internet businesses since 2016. The framework’s stated rules: reactive is key, fail fast rather than succeed slowly, keep it simple, make everything pluggable, and give each request its own context.

On May 11, 2021 the Linux Foundation announced it would host the open-source core as the Lura Project, with partners including Postman, 99P Labs, Ardan Studios, Hepsiburada, Openroom, Skalena and Stayforlong; its technical charter had been adopted on April 14. KrakenD kept its Community and Enterprise editions, made Lura the engine of KrakenD 2.0, and its team became the project’s initial Technical Steering Committee. Lombarte said that week that KrakenD was running on 1.8 million servers.

Lura followed the 2.x line for five years, and v3.0.0 was tagged on September 30, 2026, with KrakenD CE 3.0 built on it.

Why it’s built this way

Aggregation as the core job
The problem KrakenD set out to solve was clients making many calls to services not shaped for them, so merging and filtering backend responses is built into the proxy layer rather than added as a plug-in.
Stateless, with configuration in one file
With no shared state or database, every instance behaves the same and the gateway scales by adding instances.
A library of small components rather than one product
Following the Unix philosophy, Lura offers reusable pieces that can be assembled into different gateways, while KrakenD ships the assembled product.

Timeline

  1. 2016

    KrakenD in production at large internet businesses

  2. 2021

    Lura technical charter adopted on April 14; Linux Foundation announces the Lura Project on May 11

  3. 2025

    Lura v2.13.0 released in October

  4. 2026

    Lura v3.0.0 tagged on September 30, with configuration version 4; KrakenD CE 3.0.2 follows on October 21

Sources9 · facts checked 28 October 2026

Improve this page on GitHub