Repository: docker-library/docs
Pull request #2082: Add krakend official image
Author: login: alombarte
Created: 2021-11-17T14:55:45Z | Merged: 2025-03-26T23:12:42Z

Hi there,

We are currently whitelisted as open-source contributors, and we would also like to add our KrakenD image to the official list.

Thanks!


Diff:
diff --git a/krakend/README-short.txt b/krakend/README-short.txt
new file mode 100644
index 000000000000..f0d3871d3d32
--- /dev/null
+++ b/krakend/README-short.txt
@@ -0,0 +1 @@
+KrakenD is a stateless, high-performance, enterprise-ready, open source API gateway written in Go.
\ No newline at end of file
diff --git a/krakend/content.md b/krakend/content.md
new file mode 100644
index 000000000000..0dedadd7c26d
--- /dev/null
+++ b/krakend/content.md
@@ -0,0 +1,154 @@
+%%LOGO%%
+
+# What is KrakenD?
+
+[KrakenD](https://www.krakend.io/) is a stateless, high-performance, enterprise-ready, open-source API gateway written in Go. Its engine (formerly known as *KrakenD Framework*) is now a **Linux Foundation Project** codenamed [Lura Project](https://luraproject.org/). Lura is the only enterprise-grade API Gateway hosted in a neutral, open forum.
+
+KrakenD is lightweight and straightforward, as it only requires writing the configuration file. No Go knowledge is required. It offers connectivity to internal and external services, data transformation and filtering, and aggregation of multiple data sources (APIs, gRPC, queues and pub/sub, lambda, etc.) simultaneously or in cascade. It protects access to your API, throughputs its usage, and integrates with many third-parties.
+
+All features are designed to offer extraordinary performance and infinite scalability.
+
+## How to use this image
+
+KrakenD only needs a single configuration file to create an API Gateway, although you can have a complex setup reflecting your organization structure. The configuration file(s) can live anywhere in the container, but the default location (the workdir) is `/etc/krakend`.
+
+To use the image, `COPY` your `krakend.json` file inside the container or mount it using a volume. The configuration is checked only once during the startup and never used again. Don't have a config file yet? Generate it with the [KrakenD Designer UI](https://designer.krakend.io).
+
+⚠️ **NOTICE**: KrakenD does not use live reload when your configuration changes. Restart the container.
+
+### Quick start
+
+You can start an empty gateway with a health check with the following commands:
+
+```bash
+docker run -d -p 8080:8080 -v "$PWD:/etc/krakend/" %%IMAGE%%
+
+curl http://localhost:8080/__health
+{"agents":{},"now":"2024-05-23 14:35:55.552591448 +0000 UTC m=+26.856583003","status":"ok"}
+```
+
+### More Examples
+
+The following are several examples of running KrakenD. By default, the command `run` is executed, but you can pass other commands and flags at the end of the run command.
+
+The configuration files are taken from the current directory (`$PWD`). Therefore, all examples expect to find at least the file `krakend.json`.
+
+#### Run with the debug enabled (flag `-d`):
+
+This flag is **SAFE to use in production**. It's meant to enable KrakenD as a fake backend itself by enabling a [`/__debug` endpoint](https://www.krakend.io/docs/endpoints/debug-endpoint/)
+
+```bash
+docker run -p 8080:8080 -v "${PWD}:/etc/krakend/" %%IMAGE%% run -d -c /etc/krakend/krakend.json
+```
+
+#### Checking the syntax of your configuration file
+
+See the [check command](https://www.krakend.io/docs/commands/check/)
+
+```bash
+docker run -it -v $PWD:/etc/krakend/ %%IMAGE%% check --config krakend.json
+```
+
+#### Show the help:
+
+```bash
+docker run --rm -it %%IMAGE%% help
+```
+
+### Building your custom KrakenD image
+
+Most production deployments will not want to rely on mounting a volume for the container but to use their image based on `%%IMAGE%%`:
+
+Your `Dockerfile` could look like this:
+
+```Dockerfile
+FROM %%IMAGE%%:<version>
+# NOTE: Avoid using :latest image on production. Stick to a major version instead.
+
+COPY krakend.json ./
+
+# Check and test that the file is valid
+RUN krakend check -t --lint-no-network -c krakend.json
+```
+
+If you want to manage your KrakenD configuration using multiple files and folders, reusing templates, and distributing the configuration amongst your teams, you can use the [flexible configuration (FC)](https://www.krakend.io/docs/configuration/flexible-config/). The following `Dockerfile` combines FC, the `krakend check` command, and a 2-step build.
+
+```Dockerfile
+FROM %%IMAGE%%:<version> as builder
+
+COPY krakend.tmpl .
+COPY config .
+
+# Save temporary output file to /tmp to avoid permission errors
+RUN FC_ENABLE=1 \
+    FC_OUT=/tmp/krakend.json \
+    FC_PARTIALS="/etc/krakend/partials" \
+    FC_SETTINGS="/etc/krakend/settings" \
+    FC_TEMPLATES="/etc/krakend/templates" \
+    krakend check -d -t -c krakend.tmpl
+
+# Copy the output file only and discard any other files
+FROM %%IMAGE%%:<version>
+COPY --from=builder /tmp/krakend.json .
+```
+
+Then build with `docker build -t my_krakend .`
+
+The configuration above assumes you have a folder structure like the following:
+
+	.
+	├── config
+	│   ├── partials
+	│   ├── settings
+	│   │   └── env.json
+	│   └── templates
+	│       └── some.tmpl
+	├── Dockerfile
+	└── krakend.tmpl
+
+### Docker Compose example
+
+Finally, a simple `docker-compose` file to start KrakenD with your API would be:
+
+```yaml
+version: "3"
+services:
+  krakend:
+    image: %%IMAGE%%:<version>
+    ports:
+      - "8080:8080"
+    volumes:
+      - ./:/etc/krakend
+```
+
+And another one that uses the flexible configuration and a custom template filename (`my_krakend.tmpl`) on each start:
+
+```yaml
+version: "3"
+services:
+  krakend:
+    image: %%IMAGE%%:<version>
+    ports:
+      - "8080:8080"
+    volumes:
+      - ./:/etc/krakend
+    environment:
+      - FC_ENABLE=1
+      - FC_OUT=/tmp/krakend.json
+      - FC_PARTIALS="/etc/krakend/config/partials"
+      - FC_SETTINGS="/etc/krakend/config/settings/prod"
+      - FC_TEMPLATES="/etc/krakend/config/templates"
+    command:
+      command: ["krakend", "run", "-c", "krakend.tmpl", "-d"]
+```
+
+### Container permissions and commands
+
+All `krakend` commands are executed as `krakend` user (uid=1000), and the rest of the commands (e.g., `sh`) are executed as root.
+
+You can directly use sub-commands of `krakend` like `run`, `help`, `version`, `check`, `check-plugin`, or `test-plugin` as the entrypoint will add the `krakend` command automatically. For example, the following lines are equivalent:
+
+```bash
+docker run --rm -it %%IMAGE%% help
+docker run --rm -it %%IMAGE%% krakend help
+```
diff --git a/krakend/get-help.md b/krakend/get-help.md
new file mode 100644
index 000000000000..56c5731ed60e
--- /dev/null
+++ b/krakend/get-help.md
@@ -0,0 +1 @@
+[documentation](https://www.krakend.io/docs/overview/introduction/), [community support](https://groups.google.com/a/krakend.io/g/community), [open an issue](https://github.com/krakend/krakend-ce/issues), [other support channels](https://www.krakend.io/support/)
diff --git a/krakend/github-repo b/krakend/github-repo
new file mode 100644
index 000000000000..e48225a5287f
--- /dev/null
+++ b/krakend/github-repo
@@ -0,0 +1 @@
+https://github.com/krakend/krakend-ce
diff --git a/krakend/license.md b/krakend/license.md
new file mode 100644
index 000000000000..62249b167719
--- /dev/null
+++ b/krakend/license.md
@@ -0,0 +1 @@
+View [license information](https://github.com/krakend/krakend-ce/blob/master/LICENSE) for the software contained in this image.
diff --git a/krakend/logo-120.png b/krakend/logo-120.png
new file mode 100644
index 000000000000..1f19d4ffede0
Binary files /dev/null and b/krakend/logo-120.png differ
diff --git a/krakend/logo.png b/krakend/logo.png
new file mode 100644
index 000000000000..7a4be7f5ce1b
Binary files /dev/null and b/krakend/logo.png differ
diff --git a/krakend/maintainer.md b/krakend/maintainer.md
new file mode 100644
index 000000000000..2fcab789f470
--- /dev/null
+++ b/krakend/maintainer.md
@@ -0,0 +1 @@
+[the KrakenD Maintainers](%%GITHUB-REPO%%)
diff --git a/krakend/metadata.json b/krakend/metadata.json
new file mode 100644
index 000000000000..538442b9d959
--- /dev/null
+++ b/krakend/metadata.json
@@ -0,0 +1,7 @@
+{
+  "hub": {
+    "categories": [
+      "api-management"
+    ]
+  }
+}


Reviews:
user: login: LaurentGoderre
state: COMMENTED
author_association: MEMBER
submitted_at: 2024-05-23T16:24:03Z
user: login: LaurentGoderre
state: COMMENTED
author_association: MEMBER
submitted_at: 2024-05-23T16:26:04Z
user: login: alombarte
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2024-05-23T16:47:52Z
user: login: alombarte
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2024-05-23T16:48:04Z
user: login: LaurentGoderre
state: APPROVED
author_association: MEMBER
submitted_at: 2024-05-23T19:31:58Z
user: login: yosifkit
state: APPROVED
author_association: MEMBER
submitted_at: 2025-03-11T21:56:06Z
user: login: tianon
body: Some of these things build on what I've just written in https://github.com/docker-library/official-images/pull/13592#issuecomment-2719104792, so I recommend starting there.  This is all really minor stuff, though. :+1:
state: COMMENTED
author_association: MEMBER
submitted_at: 2025-03-12T20:55:13Z
user: login: tianon
state: APPROVED
author_association: MEMBER
submitted_at: 2025-03-26T23:10:22Z

Review comments:
diff_hunk: @@ -0,0 +1,144 @@
+%%LOGO%%
+
+# What is KrakenD?
+
+[KrakenD](https://www.krakend.io/) is a stateless, high-performance, enterprise-ready, open-source API gateway written in Go. Its engine (formerly known as *KrakenD Framework*) is now a **Linux Foundation Project** codenamed [Lura Project](https://luraproject.org/). Lura is the only enterprise-grade API Gateway hosted in a neutral, open forum.
+
+KrakenD is lightweight and straightforward as it only requires writing the configuration file. No Go knowledge is required. It offers connectivity to internal and external services, transformation and filtering of data, aggregation of multiple data sources (APIs, gRPC, queues and pub/sub, lambda, etc) simultaneously or in cascade, protects the access to your API, throughputs its usage, and integrates with a lot of third-parties.
+
+All features are designed to offer extraordinary performance and infinite scalability.
+
+## How to use this image
+KrakenD only needs a single configuration file to create an API Gateway, although you can have a complex setup reflecting your organization structure. The configuration file(s) can live anywhere in the container, but the default location is `/etc/krakend`.
+
+To use the image, `COPY` your `krakend.json` file inside the container or mount it using a volume. The configuration is checked only once during the startup and never used again. Don't have a config file yet? Generate it with the [KrakenD Designer UI](https://designer.krakend.io).
+
+⚠️ **NOTICE**: KrakenD does not use live reload when your configuration changes. Restart the container.
+
+### Quick start
+You can start an empty gateway with a health check with the following commands:
+
+```console
+$ echo '{ "version": 3 }' > krakend.json
path: krakend/content.md
user: login: LaurentGoderre
body: This is included in the image by default so is not required for a "quick start" so maybe should be covered in a separate block.
created_at: 2024-05-23T16:24:03Z
author_association: MEMBER
diff_hunk: @@ -0,0 +1,144 @@
+%%LOGO%%
+
+# What is KrakenD?
+
+[KrakenD](https://www.krakend.io/) is a stateless, high-performance, enterprise-ready, open-source API gateway written in Go. Its engine (formerly known as *KrakenD Framework*) is now a **Linux Foundation Project** codenamed [Lura Project](https://luraproject.org/). Lura is the only enterprise-grade API Gateway hosted in a neutral, open forum.
+
+KrakenD is lightweight and straightforward as it only requires writing the configuration file. No Go knowledge is required. It offers connectivity to internal and external services, transformation and filtering of data, aggregation of multiple data sources (APIs, gRPC, queues and pub/sub, lambda, etc) simultaneously or in cascade, protects the access to your API, throughputs its usage, and integrates with a lot of third-parties.
+
+All features are designed to offer extraordinary performance and infinite scalability.
+
+## How to use this image
+KrakenD only needs a single configuration file to create an API Gateway, although you can have a complex setup reflecting your organization structure. The configuration file(s) can live anywhere in the container, but the default location is `/etc/krakend`.
+
+To use the image, `COPY` your `krakend.json` file inside the container or mount it using a volume. The configuration is checked only once during the startup and never used again. Don't have a config file yet? Generate it with the [KrakenD Designer UI](https://designer.krakend.io).
+
+⚠️ **NOTICE**: KrakenD does not use live reload when your configuration changes. Restart the container.
+
+### Quick start
+You can start an empty gateway with a health check with the following commands:
+
+```console
+$ echo '{ "version": 3 }' > krakend.json
+$ docker run -d -p 8080:8080 -v "$PWD:/etc/krakend/" %%IMAGE%%
+...
+$ curl http://localhost:8080/__health
+{"agents":{},"now":"2022-11-25 14:35:55.552591448 +0000 UTC m=+26.856583003","status":"ok"}
+```
+
+### More Examples
+The following are several examples of running KrakenD. By default, the command `run` is executed, but you can pass
+other commands and flags at the end of the run command.
+
+The configuration files are taken from the current directory (`$PWD`). Therefore, all examples expect to find at least the file `krakend.json`.
+
+####  Run with the debug enabled (flag `-d`):
+This flag is **SAFE to use in production**. It's meant to enable KrakenD as a fake backend itself by enabling a [`/__debug` endpoint](https://www.krakend.io/docs/endpoints/debug-endpoint/)
+
+```console
+    docker run -p 8080:8080 -v "${PWD}:/etc/krakend/" %%IMAGE%% run -d -c /etc/krakend/krakend.json
+```
+
+#### Checking the syntax of your configuration file
+See the [check command](https://www.krakend.io/docs/commands/check/)
+
+```console
+    docker run -it -p 8080:8080 -v $PWD:/etc/krakend/ %%IMAGE%% check --config krakend.json
+```
+#### Show the help:
+
+    docker run -it -p 8080:8080 -v $PWD:/etc/krakend/ %%IMAGE%% help
+
+
+### Building your custom KrakenD image
+
+Most production deployments will not want to rely on mounting a volume for the container but to use their image based on `%%IMAGE%%`:
+
+Your `Dockerfile` could look like this:
+
+```Dockerfile
+FROM %%IMAGE%%:<version>
+# NOTE: Avoid using :latest image on production. Stick to a major version instead.
+
+COPY krakend.json /etc/krakend/krakend.json
+
+# Check and test that the file is valid
+RUN krakend check -d -t -c /etc/krakend/krakend.json
+```
+
+If you want to manage your KrakenD configuration using multiple files and folders, reusing templates, and distributing the configuration amongst your teams, you can use the [flexible configuration (FC)](https://www.krakend.io/docs/configuration/flexible-config/). The following `Dockerfile` combines FC, the `krakend check` command, and a 2-step build.
+
+```Dockerfile
+FROM %%IMAGE%%:<version> as builder
+
+COPY krakend.tmpl .
+COPY config .
+
+# Save temporary output file to /tmp to avoid permission errors
+RUN FC_ENABLE=1 \
+    FC_OUT=/tmp/krakend.json \
+    FC_PARTIALS="/etc/krakend/partials" \
+    FC_SETTINGS="/etc/krakend/settings" \
+    FC_TEMPLATES="/etc/krakend/templates" \
+    krakend check -d -t -c krakend.tmpl
+
+# Copy the output file only and discard any other files
+FROM %%IMAGE%%:<version>
+COPY --from=builder /tmp/krakend.json .
+```
+Then build with `docker build -t my_krakend .`
+
+The configuration above assumes you have a folder structure like the following:
+```
+.
+├── config
+│   ├── partials
+│   ├── settings
+│   │   └── env.json
+│   └── templates
+│       └── some.tmpl
+├── Dockerfile
+└── krakend.tmpl
+```
+
+### Docker Compose example
+Finally, a simple `docker-compose` file to start KrakenD with your API would be:
+
+```yaml
+version: "3"
+services:
+  krakend:
+    image: %%IMAGE%%:<version>
+    ports:
+      - "8080:8080"
+    volumes:
+      - ./:/etc/krakend
+```
+
+And another one that uses the flexible configuration and a custom template filename (`my_krakend.tmpl`) on each start:
+
+```yaml
+version: "3"
+services:
+  krakend:
+    image: %%IMAGE%%:<version>
+    ports:
+      - "8080:8080"
+    volumes:
+      - ./:/etc/krakend
+    environment:
+      - FC_ENABLE=1
+      - FC_OUT=/tmp/krakend.json
+      - FC_PARTIALS="/etc/krakend/config/partials"
+      - FC_SETTINGS="/etc/krakend/config/settings/prod"
+      - FC_TEMPLATES="/etc/krakend/config/templates"
+    command:
+      command: ["krakend", "run", "-c", "krakend.tmpl", "-d"]
+```
+### Container permissions and commands
+All `krakend` commands are executed as `krakend` user (uid=1000) through `su-exec`, and the rest of the commands (e.g., `sh`) are executed as root.
+
+You can directly use sub-commands of `krakend` like `run`, `help`, `version`, `check`, `check-plugin` or `validate` as the entrypoint will add the `krakend` command automatically. For example, the following lines are equivalent:
+
+    docker run -it -p 8080:8080 -v $PWD:/etc/krakend/ %%IMAGE%% help
+    docker run -it -p 8080:8080 -v $PWD:/etc/krakend/ %%IMAGE%% krakend help
path: krakend/content.md
user: login: LaurentGoderre
body: The port is not necessary here since it runs the CLI right?
created_at: 2024-05-23T16:26:03Z
author_association: MEMBER
diff_hunk: @@ -0,0 +1,144 @@
+%%LOGO%%
+
+# What is KrakenD?
+
+[KrakenD](https://www.krakend.io/) is a stateless, high-performance, enterprise-ready, open-source API gateway written in Go. Its engine (formerly known as *KrakenD Framework*) is now a **Linux Foundation Project** codenamed [Lura Project](https://luraproject.org/). Lura is the only enterprise-grade API Gateway hosted in a neutral, open forum.
+
+KrakenD is lightweight and straightforward as it only requires writing the configuration file. No Go knowledge is required. It offers connectivity to internal and external services, transformation and filtering of data, aggregation of multiple data sources (APIs, gRPC, queues and pub/sub, lambda, etc) simultaneously or in cascade, protects the access to your API, throughputs its usage, and integrates with a lot of third-parties.
+
+All features are designed to offer extraordinary performance and infinite scalability.
+
+## How to use this image
+KrakenD only needs a single configuration file to create an API Gateway, although you can have a complex setup reflecting your organization structure. The configuration file(s) can live anywhere in the container, but the default location is `/etc/krakend`.
+
+To use the image, `COPY` your `krakend.json` file inside the container or mount it using a volume. The configuration is checked only once during the startup and never used again. Don't have a config file yet? Generate it with the [KrakenD Designer UI](https://designer.krakend.io).
+
+⚠️ **NOTICE**: KrakenD does not use live reload when your configuration changes. Restart the container.
+
+### Quick start
+You can start an empty gateway with a health check with the following commands:
+
+```console
+$ echo '{ "version": 3 }' > krakend.json
+$ docker run -d -p 8080:8080 -v "$PWD:/etc/krakend/" %%IMAGE%%
+...
+$ curl http://localhost:8080/__health
+{"agents":{},"now":"2022-11-25 14:35:55.552591448 +0000 UTC m=+26.856583003","status":"ok"}
+```
+
+### More Examples
+The following are several examples of running KrakenD. By default, the command `run` is executed, but you can pass
+other commands and flags at the end of the run command.
+
+The configuration files are taken from the current directory (`$PWD`). Therefore, all examples expect to find at least the file `krakend.json`.
+
+####  Run with the debug enabled (flag `-d`):
+This flag is **SAFE to use in production**. It's meant to enable KrakenD as a fake backend itself by enabling a [`/__debug` endpoint](https://www.krakend.io/docs/endpoints/debug-endpoint/)
+
+```console
+    docker run -p 8080:8080 -v "${PWD}:/etc/krakend/" %%IMAGE%% run -d -c /etc/krakend/krakend.json
+```
+
+#### Checking the syntax of your configuration file
+See the [check command](https://www.krakend.io/docs/commands/check/)
+
+```console
+    docker run -it -p 8080:8080 -v $PWD:/etc/krakend/ %%IMAGE%% check --config krakend.json
+```
+#### Show the help:
+
+    docker run -it -p 8080:8080 -v $PWD:/etc/krakend/ %%IMAGE%% help
+
+
+### Building your custom KrakenD image
+
+Most production deployments will not want to rely on mounting a volume for the container but to use their image based on `%%IMAGE%%`:
+
+Your `Dockerfile` could look like this:
+
+```Dockerfile
+FROM %%IMAGE%%:<version>
+# NOTE: Avoid using :latest image on production. Stick to a major version instead.
+
+COPY krakend.json /etc/krakend/krakend.json
+
+# Check and test that the file is valid
+RUN krakend check -d -t -c /etc/krakend/krakend.json
+```
+
+If you want to manage your KrakenD configuration using multiple files and folders, reusing templates, and distributing the configuration amongst your teams, you can use the [flexible configuration (FC)](https://www.krakend.io/docs/configuration/flexible-config/). The following `Dockerfile` combines FC, the `krakend check` command, and a 2-step build.
+
+```Dockerfile
+FROM %%IMAGE%%:<version> as builder
+
+COPY krakend.tmpl .
+COPY config .
+
+# Save temporary output file to /tmp to avoid permission errors
+RUN FC_ENABLE=1 \
+    FC_OUT=/tmp/krakend.json \
+    FC_PARTIALS="/etc/krakend/partials" \
+    FC_SETTINGS="/etc/krakend/settings" \
+    FC_TEMPLATES="/etc/krakend/templates" \
+    krakend check -d -t -c krakend.tmpl
+
+# Copy the output file only and discard any other files
+FROM %%IMAGE%%:<version>
+COPY --from=builder /tmp/krakend.json .
+```
+Then build with `docker build -t my_krakend .`
+
+The configuration above assumes you have a folder structure like the following:
+```
+.
+├── config
+│   ├── partials
+│   ├── settings
+│   │   └── env.json
+│   └── templates
+│       └── some.tmpl
+├── Dockerfile
+└── krakend.tmpl
+```
+
+### Docker Compose example
+Finally, a simple `docker-compose` file to start KrakenD with your API would be:
+
+```yaml
+version: "3"
+services:
+  krakend:
+    image: %%IMAGE%%:<version>
+    ports:
+      - "8080:8080"
+    volumes:
+      - ./:/etc/krakend
+```
+
+And another one that uses the flexible configuration and a custom template filename (`my_krakend.tmpl`) on each start:
+
+```yaml
+version: "3"
+services:
+  krakend:
+    image: %%IMAGE%%:<version>
+    ports:
+      - "8080:8080"
+    volumes:
+      - ./:/etc/krakend
+    environment:
+      - FC_ENABLE=1
+      - FC_OUT=/tmp/krakend.json
+      - FC_PARTIALS="/etc/krakend/config/partials"
+      - FC_SETTINGS="/etc/krakend/config/settings/prod"
+      - FC_TEMPLATES="/etc/krakend/config/templates"
+    command:
+      command: ["krakend", "run", "-c", "krakend.tmpl", "-d"]
+```
+### Container permissions and commands
+All `krakend` commands are executed as `krakend` user (uid=1000) through `su-exec`, and the rest of the commands (e.g., `sh`) are executed as root.
+
+You can directly use sub-commands of `krakend` like `run`, `help`, `version`, `check`, `check-plugin` or `validate` as the entrypoint will add the `krakend` command automatically. For example, the following lines are equivalent:
+
+    docker run -it -p 8080:8080 -v $PWD:/etc/krakend/ %%IMAGE%% help
+    docker run -it -p 8080:8080 -v $PWD:/etc/krakend/ %%IMAGE%% krakend help
path: krakend/content.md
user: login: alombarte
body: Absolutely right. Removed. Also the volume.
created_at: 2024-05-23T16:47:52Z
author_association: CONTRIBUTOR
diff_hunk: @@ -0,0 +1,144 @@
+%%LOGO%%
+
+# What is KrakenD?
+
+[KrakenD](https://www.krakend.io/) is a stateless, high-performance, enterprise-ready, open-source API gateway written in Go. Its engine (formerly known as *KrakenD Framework*) is now a **Linux Foundation Project** codenamed [Lura Project](https://luraproject.org/). Lura is the only enterprise-grade API Gateway hosted in a neutral, open forum.
+
+KrakenD is lightweight and straightforward as it only requires writing the configuration file. No Go knowledge is required. It offers connectivity to internal and external services, transformation and filtering of data, aggregation of multiple data sources (APIs, gRPC, queues and pub/sub, lambda, etc) simultaneously or in cascade, protects the access to your API, throughputs its usage, and integrates with a lot of third-parties.
+
+All features are designed to offer extraordinary performance and infinite scalability.
+
+## How to use this image
+KrakenD only needs a single configuration file to create an API Gateway, although you can have a complex setup reflecting your organization structure. The configuration file(s) can live anywhere in the container, but the default location is `/etc/krakend`.
+
+To use the image, `COPY` your `krakend.json` file inside the container or mount it using a volume. The configuration is checked only once during the startup and never used again. Don't have a config file yet? Generate it with the [KrakenD Designer UI](https://designer.krakend.io).
+
+⚠️ **NOTICE**: KrakenD does not use live reload when your configuration changes. Restart the container.
+
+### Quick start
+You can start an empty gateway with a health check with the following commands:
+
+```console
+$ echo '{ "version": 3 }' > krakend.json
path: krakend/content.md
user: login: alombarte
body: Removed
created_at: 2024-05-23T16:48:04Z
author_association: CONTRIBUTOR
diff_hunk: @@ -0,0 +1,150 @@
+%%LOGO%%
+
+# What is KrakenD?
+
+[KrakenD](https://www.krakend.io/) is a stateless, high-performance, enterprise-ready, open-source API gateway written in Go. Its engine (formerly known as *KrakenD Framework*) is now a **Linux Foundation Project** codenamed [Lura Project](https://luraproject.org/). Lura is the only enterprise-grade API Gateway hosted in a neutral, open forum.
+
+KrakenD is lightweight and straightforward as it only requires writing the configuration file. No Go knowledge is required. It offers connectivity to internal and external services, transformation and filtering of data, aggregation of multiple data sources (APIs, gRPC, queues and pub/sub, lambda, etc) simultaneously or in cascade, protects the access to your API, throughputs its usage, and integrates with a lot of third-parties.
+
+All features are designed to offer extraordinary performance and infinite scalability.
+
+## How to use this image
+
+KrakenD only needs a single configuration file to create an API Gateway, although you can have a complex setup reflecting your organization structure. The configuration file(s) can live anywhere in the container, but the default location is `/etc/krakend`.
+
+To use the image, `COPY` your `krakend.json` file inside the container or mount it using a volume. The configuration is checked only once during the startup and never used again. Don't have a config file yet? Generate it with the [KrakenD Designer UI](https://designer.krakend.io).
+
+⚠️ **NOTICE**: KrakenD does not use live reload when your configuration changes. Restart the container.
+
+### Quick start
+
+You can start an empty gateway with a health check with the following commands:
+
+```console
+$ docker run -d -p 8080:8080 -v "$PWD:/etc/krakend/" %%IMAGE%%
+...
+$ curl http://localhost:8080/__health
+{"agents":{},"now":"2024-05-23 14:35:55.552591448 +0000 UTC m=+26.856583003","status":"ok"}
+```
+
+### More Examples
+
+The following are several examples of running KrakenD. By default, the command `run` is executed, but you can pass other commands and flags at the end of the run command.
+
+The configuration files are taken from the current directory (`$PWD`). Therefore, all examples expect to find at least the file `krakend.json`.
+
+#### Run with the debug enabled (flag `-d`):
+
+This flag is **SAFE to use in production**. It's meant to enable KrakenD as a fake backend itself by enabling a [`/__debug` endpoint](https://www.krakend.io/docs/endpoints/debug-endpoint/)
+
+```console
+    docker run -p 8080:8080 -v "${PWD}:/etc/krakend/" %%IMAGE%% run -d -c /etc/krakend/krakend.json
+```
path: krakend/content.md
user: login: tianon
body: These should not be indented _and_ code-fenced, and if you want to use `console` as the highlight, you'll want to add the "prompt" sigil (`$`); alternatively, you could switch to `bash`:

````suggestion
```console
$ docker run -p 8080:8080 -v "${PWD}:/etc/krakend/" %%IMAGE%% run -d -c /etc/krakend/krakend.json
```
````

or:

````suggestion
```bash
docker run -p 8080:8080 -v "${PWD}:/etc/krakend/" %%IMAGE%% run -d -c /etc/krakend/krakend.json
```
````
created_at: 2025-03-12T18:36:56Z
author_association: MEMBER
diff_hunk: @@ -0,0 +1,150 @@
+%%LOGO%%
+
+# What is KrakenD?
+
+[KrakenD](https://www.krakend.io/) is a stateless, high-performance, enterprise-ready, open-source API gateway written in Go. Its engine (formerly known as *KrakenD Framework*) is now a **Linux Foundation Project** codenamed [Lura Project](https://luraproject.org/). Lura is the only enterprise-grade API Gateway hosted in a neutral, open forum.
+
+KrakenD is lightweight and straightforward as it only requires writing the configuration file. No Go knowledge is required. It offers connectivity to internal and external services, transformation and filtering of data, aggregation of multiple data sources (APIs, gRPC, queues and pub/sub, lambda, etc) simultaneously or in cascade, protects the access to your API, throughputs its usage, and integrates with a lot of third-parties.
+
+All features are designed to offer extraordinary performance and infinite scalability.
+
+## How to use this image
+
+KrakenD only needs a single configuration file to create an API Gateway, although you can have a complex setup reflecting your organization structure. The configuration file(s) can live anywhere in the container, but the default location is `/etc/krakend`.
+
+To use the image, `COPY` your `krakend.json` file inside the container or mount it using a volume. The configuration is checked only once during the startup and never used again. Don't have a config file yet? Generate it with the [KrakenD Designer UI](https://designer.krakend.io).
+
+⚠️ **NOTICE**: KrakenD does not use live reload when your configuration changes. Restart the container.
+
+### Quick start
+
+You can start an empty gateway with a health check with the following commands:
+
+```console
+$ docker run -d -p 8080:8080 -v "$PWD:/etc/krakend/" %%IMAGE%%
+...
+$ curl http://localhost:8080/__health
+{"agents":{},"now":"2024-05-23 14:35:55.552591448 +0000 UTC m=+26.856583003","status":"ok"}
+```
+
+### More Examples
+
+The following are several examples of running KrakenD. By default, the command `run` is executed, but you can pass other commands and flags at the end of the run command.
+
+The configuration files are taken from the current directory (`$PWD`). Therefore, all examples expect to find at least the file `krakend.json`.
+
+#### Run with the debug enabled (flag `-d`):
+
+This flag is **SAFE to use in production**. It's meant to enable KrakenD as a fake backend itself by enabling a [`/__debug` endpoint](https://www.krakend.io/docs/endpoints/debug-endpoint/)
+
+```console
+    docker run -p 8080:8080 -v "${PWD}:/etc/krakend/" %%IMAGE%% run -d -c /etc/krakend/krakend.json
+```
+
+#### Checking the syntax of your configuration file
+
+See the [check command](https://www.krakend.io/docs/commands/check/)
+
+```console
+    docker run -it -v $PWD:/etc/krakend/ %%IMAGE%% check --config krakend.json
path: krakend/content.md
user: login: tianon
body: See above.
created_at: 2025-03-12T18:37:15Z
author_association: MEMBER
diff_hunk: @@ -0,0 +1,150 @@
+%%LOGO%%
+
+# What is KrakenD?
+
+[KrakenD](https://www.krakend.io/) is a stateless, high-performance, enterprise-ready, open-source API gateway written in Go. Its engine (formerly known as *KrakenD Framework*) is now a **Linux Foundation Project** codenamed [Lura Project](https://luraproject.org/). Lura is the only enterprise-grade API Gateway hosted in a neutral, open forum.
+
+KrakenD is lightweight and straightforward as it only requires writing the configuration file. No Go knowledge is required. It offers connectivity to internal and external services, transformation and filtering of data, aggregation of multiple data sources (APIs, gRPC, queues and pub/sub, lambda, etc) simultaneously or in cascade, protects the access to your API, throughputs its usage, and integrates with a lot of third-parties.
+
+All features are designed to offer extraordinary performance and infinite scalability.
+
+## How to use this image
+
+KrakenD only needs a single configuration file to create an API Gateway, although you can have a complex setup reflecting your organization structure. The configuration file(s) can live anywhere in the container, but the default location is `/etc/krakend`.
+
+To use the image, `COPY` your `krakend.json` file inside the container or mount it using a volume. The configuration is checked only once during the startup and never used again. Don't have a config file yet? Generate it with the [KrakenD Designer UI](https://designer.krakend.io).
+
+⚠️ **NOTICE**: KrakenD does not use live reload when your configuration changes. Restart the container.
+
+### Quick start
+
+You can start an empty gateway with a health check with the following commands:
+
+```console
+$ docker run -d -p 8080:8080 -v "$PWD:/etc/krakend/" %%IMAGE%%
+...
+$ curl http://localhost:8080/__health
+{"agents":{},"now":"2024-05-23 14:35:55.552591448 +0000 UTC m=+26.856583003","status":"ok"}
+```
+
+### More Examples
+
+The following are several examples of running KrakenD. By default, the command `run` is executed, but you can pass other commands and flags at the end of the run command.
+
+The configuration files are taken from the current directory (`$PWD`). Therefore, all examples expect to find at least the file `krakend.json`.
+
+#### Run with the debug enabled (flag `-d`):
+
+This flag is **SAFE to use in production**. It's meant to enable KrakenD as a fake backend itself by enabling a [`/__debug` endpoint](https://www.krakend.io/docs/endpoints/debug-endpoint/)
+
+```console
+    docker run -p 8080:8080 -v "${PWD}:/etc/krakend/" %%IMAGE%% run -d -c /etc/krakend/krakend.json
+```
+
+#### Checking the syntax of your configuration file
+
+See the [check command](https://www.krakend.io/docs/commands/check/)
+
+```console
+    docker run -it -v $PWD:/etc/krakend/ %%IMAGE%% check --config krakend.json
+```
+
+#### Show the help:
+
+	docker run -it %%IMAGE%% help
path: krakend/content.md
user: login: tianon
body: This should be consistent too (and this one in particular probably ought to include `--rm`).
created_at: 2025-03-12T18:37:40Z
author_association: MEMBER
diff_hunk: @@ -0,0 +1,150 @@
+%%LOGO%%
+
+# What is KrakenD?
+
+[KrakenD](https://www.krakend.io/) is a stateless, high-performance, enterprise-ready, open-source API gateway written in Go. Its engine (formerly known as *KrakenD Framework*) is now a **Linux Foundation Project** codenamed [Lura Project](https://luraproject.org/). Lura is the only enterprise-grade API Gateway hosted in a neutral, open forum.
+
+KrakenD is lightweight and straightforward as it only requires writing the configuration file. No Go knowledge is required. It offers connectivity to internal and external services, transformation and filtering of data, aggregation of multiple data sources (APIs, gRPC, queues and pub/sub, lambda, etc) simultaneously or in cascade, protects the access to your API, throughputs its usage, and integrates with a lot of third-parties.
+
+All features are designed to offer extraordinary performance and infinite scalability.
+
+## How to use this image
+
+KrakenD only needs a single configuration file to create an API Gateway, although you can have a complex setup reflecting your organization structure. The configuration file(s) can live anywhere in the container, but the default location is `/etc/krakend`.
+
+To use the image, `COPY` your `krakend.json` file inside the container or mount it using a volume. The configuration is checked only once during the startup and never used again. Don't have a config file yet? Generate it with the [KrakenD Designer UI](https://designer.krakend.io).
+
+⚠️ **NOTICE**: KrakenD does not use live reload when your configuration changes. Restart the container.
+
+### Quick start
+
+You can start an empty gateway with a health check with the following commands:
+
+```console
+$ docker run -d -p 8080:8080 -v "$PWD:/etc/krakend/" %%IMAGE%%
+...
+$ curl http://localhost:8080/__health
+{"agents":{},"now":"2024-05-23 14:35:55.552591448 +0000 UTC m=+26.856583003","status":"ok"}
+```
+
+### More Examples
+
+The following are several examples of running KrakenD. By default, the command `run` is executed, but you can pass other commands and flags at the end of the run command.
+
+The configuration files are taken from the current directory (`$PWD`). Therefore, all examples expect to find at least the file `krakend.json`.
+
+#### Run with the debug enabled (flag `-d`):
+
+This flag is **SAFE to use in production**. It's meant to enable KrakenD as a fake backend itself by enabling a [`/__debug` endpoint](https://www.krakend.io/docs/endpoints/debug-endpoint/)
+
+```console
+    docker run -p 8080:8080 -v "${PWD}:/etc/krakend/" %%IMAGE%% run -d -c /etc/krakend/krakend.json
+```
+
+#### Checking the syntax of your configuration file
+
+See the [check command](https://www.krakend.io/docs/commands/check/)
+
+```console
+    docker run -it -v $PWD:/etc/krakend/ %%IMAGE%% check --config krakend.json
+```
+
+#### Show the help:
+
+	docker run -it %%IMAGE%% help
+
+### Building your custom KrakenD image
+
+Most production deployments will not want to rely on mounting a volume for the container but to use their image based on `%%IMAGE%%`:
+
+Your `Dockerfile` could look like this:
+
+```Dockerfile
+FROM %%IMAGE%%:<version>
+# NOTE: Avoid using :latest image on production. Stick to a major version instead.
+
+COPY krakend.json /etc/krakend/krakend.json
+
+# Check and test that the file is valid
+RUN krakend check -d -t -c /etc/krakend/krakend.json
path: krakend/content.md
user: login: tianon
body: As I noted in the review on the `Dockerfile`, I think this gets cleaner for users if you lean into the `WORKDIR`:

```suggestion
COPY krakend.json ./

# Check and test that the file is valid
RUN krakend check -d -t -c krakend.json
```

(although this is one that's up to you)
created_at: 2025-03-12T18:42:58Z
author_association: MEMBER
diff_hunk: @@ -0,0 +1,150 @@
+%%LOGO%%
+
+# What is KrakenD?
+
+[KrakenD](https://www.krakend.io/) is a stateless, high-performance, enterprise-ready, open-source API gateway written in Go. Its engine (formerly known as *KrakenD Framework*) is now a **Linux Foundation Project** codenamed [Lura Project](https://luraproject.org/). Lura is the only enterprise-grade API Gateway hosted in a neutral, open forum.
+
+KrakenD is lightweight and straightforward as it only requires writing the configuration file. No Go knowledge is required. It offers connectivity to internal and external services, transformation and filtering of data, aggregation of multiple data sources (APIs, gRPC, queues and pub/sub, lambda, etc) simultaneously or in cascade, protects the access to your API, throughputs its usage, and integrates with a lot of third-parties.
+
+All features are designed to offer extraordinary performance and infinite scalability.
+
+## How to use this image
+
+KrakenD only needs a single configuration file to create an API Gateway, although you can have a complex setup reflecting your organization structure. The configuration file(s) can live anywhere in the container, but the default location is `/etc/krakend`.
+
+To use the image, `COPY` your `krakend.json` file inside the container or mount it using a volume. The configuration is checked only once during the startup and never used again. Don't have a config file yet? Generate it with the [KrakenD Designer UI](https://designer.krakend.io).
+
+⚠️ **NOTICE**: KrakenD does not use live reload when your configuration changes. Restart the container.
+
+### Quick start
+
+You can start an empty gateway with a health check with the following commands:
+
+```console
+$ docker run -d -p 8080:8080 -v "$PWD:/etc/krakend/" %%IMAGE%%
+...
+$ curl http://localhost:8080/__health
+{"agents":{},"now":"2024-05-23 14:35:55.552591448 +0000 UTC m=+26.856583003","status":"ok"}
+```
+
+### More Examples
+
+The following are several examples of running KrakenD. By default, the command `run` is executed, but you can pass other commands and flags at the end of the run command.
+
+The configuration files are taken from the current directory (`$PWD`). Therefore, all examples expect to find at least the file `krakend.json`.
+
+#### Run with the debug enabled (flag `-d`):
+
+This flag is **SAFE to use in production**. It's meant to enable KrakenD as a fake backend itself by enabling a [`/__debug` endpoint](https://www.krakend.io/docs/endpoints/debug-endpoint/)
+
+```console
+    docker run -p 8080:8080 -v "${PWD}:/etc/krakend/" %%IMAGE%% run -d -c /etc/krakend/krakend.json
+```
+
+#### Checking the syntax of your configuration file
+
+See the [check command](https://www.krakend.io/docs/commands/check/)
+
+```console
+    docker run -it -v $PWD:/etc/krakend/ %%IMAGE%% check --config krakend.json
+```
+
+#### Show the help:
+
+	docker run -it %%IMAGE%% help
+
+### Building your custom KrakenD image
+
+Most production deployments will not want to rely on mounting a volume for the container but to use their image based on `%%IMAGE%%`:
+
+Your `Dockerfile` could look like this:
+
+```Dockerfile
+FROM %%IMAGE%%:<version>
+# NOTE: Avoid using :latest image on production. Stick to a major version instead.
+
+COPY krakend.json /etc/krakend/krakend.json
+
+# Check and test that the file is valid
+RUN krakend check -d -t -c /etc/krakend/krakend.json
+```
+
+If you want to manage your KrakenD configuration using multiple files and folders, reusing templates, and distributing the configuration amongst your teams, you can use the [flexible configuration (FC)](https://www.krakend.io/docs/configuration/flexible-config/). The following `Dockerfile` combines FC, the `krakend check` command, and a 2-step build.
+
+```Dockerfile
+FROM %%IMAGE%%:<version> as builder
+
+COPY krakend.tmpl .
+COPY config .
+
+# Save temporary output file to /tmp to avoid permission errors
+RUN FC_ENABLE=1 \
+    FC_OUT=/tmp/krakend.json \
+    FC_PARTIALS="/etc/krakend/partials" \
+    FC_SETTINGS="/etc/krakend/settings" \
+    FC_TEMPLATES="/etc/krakend/templates" \
+    krakend check -d -t -c krakend.tmpl
+
+# Copy the output file only and discard any other files
+FROM %%IMAGE%%:<version>
+COPY --from=builder /tmp/krakend.json .
+```
+
+Then build with `docker build -t my_krakend .`
+
+The configuration above assumes you have a folder structure like the following:
+
+	.
+	├── config
+	│   ├── partials
+	│   ├── settings
+	│   │   └── env.json
+	│   └── templates
+	│       └── some.tmpl
+	├── Dockerfile
+	└── krakend.tmpl
+
+### Docker Compose example
+
+Finally, a simple `docker-compose` file to start KrakenD with your API would be:
+
+```yaml
+version: "3"
+services:
+  krakend:
+    image: %%IMAGE%%:<version>
+    ports:
+      - "8080:8080"
+    volumes:
+      - ./:/etc/krakend
+```
+
+And another one that uses the flexible configuration and a custom template filename (`my_krakend.tmpl`) on each start:
+
+```yaml
+version: "3"
+services:
+  krakend:
+    image: %%IMAGE%%:<version>
+    ports:
+      - "8080:8080"
+    volumes:
+      - ./:/etc/krakend
+    environment:
+      - FC_ENABLE=1
+      - FC_OUT=/tmp/krakend.json
+      - FC_PARTIALS="/etc/krakend/config/partials"
+      - FC_SETTINGS="/etc/krakend/config/settings/prod"
+      - FC_TEMPLATES="/etc/krakend/config/templates"
+    command:
+      command: ["krakend", "run", "-c", "krakend.tmpl", "-d"]
+```
+
+### Container permissions and commands
+
+All `krakend` commands are executed as `krakend` user (uid=1000) through `su-exec`, and the rest of the commands (e.g., `sh`) are executed as root.
path: krakend/content.md
user: login: tianon
body: As noted in the other review, I would suggest not marrying yourself explicitly to `su-exec`:

```suggestion
All `krakend` commands are executed as `krakend` user (uid=1000), and the rest of the commands (e.g., `sh`) are executed as root.
```
created_at: 2025-03-12T20:47:53Z
author_association: MEMBER
diff_hunk: @@ -0,0 +1,150 @@
+%%LOGO%%
+
+# What is KrakenD?
+
+[KrakenD](https://www.krakend.io/) is a stateless, high-performance, enterprise-ready, open-source API gateway written in Go. Its engine (formerly known as *KrakenD Framework*) is now a **Linux Foundation Project** codenamed [Lura Project](https://luraproject.org/). Lura is the only enterprise-grade API Gateway hosted in a neutral, open forum.
+
+KrakenD is lightweight and straightforward as it only requires writing the configuration file. No Go knowledge is required. It offers connectivity to internal and external services, transformation and filtering of data, aggregation of multiple data sources (APIs, gRPC, queues and pub/sub, lambda, etc) simultaneously or in cascade, protects the access to your API, throughputs its usage, and integrates with a lot of third-parties.
+
+All features are designed to offer extraordinary performance and infinite scalability.
+
+## How to use this image
+
+KrakenD only needs a single configuration file to create an API Gateway, although you can have a complex setup reflecting your organization structure. The configuration file(s) can live anywhere in the container, but the default location is `/etc/krakend`.
+
+To use the image, `COPY` your `krakend.json` file inside the container or mount it using a volume. The configuration is checked only once during the startup and never used again. Don't have a config file yet? Generate it with the [KrakenD Designer UI](https://designer.krakend.io).
+
+⚠️ **NOTICE**: KrakenD does not use live reload when your configuration changes. Restart the container.
+
+### Quick start
+
+You can start an empty gateway with a health check with the following commands:
+
+```console
+$ docker run -d -p 8080:8080 -v "$PWD:/etc/krakend/" %%IMAGE%%
+...
+$ curl http://localhost:8080/__health
+{"agents":{},"now":"2024-05-23 14:35:55.552591448 +0000 UTC m=+26.856583003","status":"ok"}
+```
+
+### More Examples
+
+The following are several examples of running KrakenD. By default, the command `run` is executed, but you can pass other commands and flags at the end of the run command.
+
+The configuration files are taken from the current directory (`$PWD`). Therefore, all examples expect to find at least the file `krakend.json`.
+
+#### Run with the debug enabled (flag `-d`):
+
+This flag is **SAFE to use in production**. It's meant to enable KrakenD as a fake backend itself by enabling a [`/__debug` endpoint](https://www.krakend.io/docs/endpoints/debug-endpoint/)
+
+```console
+    docker run -p 8080:8080 -v "${PWD}:/etc/krakend/" %%IMAGE%% run -d -c /etc/krakend/krakend.json
+```
+
+#### Checking the syntax of your configuration file
+
+See the [check command](https://www.krakend.io/docs/commands/check/)
+
+```console
+    docker run -it -v $PWD:/etc/krakend/ %%IMAGE%% check --config krakend.json
+```
+
+#### Show the help:
+
+	docker run -it %%IMAGE%% help
+
+### Building your custom KrakenD image
+
+Most production deployments will not want to rely on mounting a volume for the container but to use their image based on `%%IMAGE%%`:
+
+Your `Dockerfile` could look like this:
+
+```Dockerfile
+FROM %%IMAGE%%:<version>
+# NOTE: Avoid using :latest image on production. Stick to a major version instead.
+
+COPY krakend.json /etc/krakend/krakend.json
+
+# Check and test that the file is valid
+RUN krakend check -d -t -c /etc/krakend/krakend.json
+```
+
+If you want to manage your KrakenD configuration using multiple files and folders, reusing templates, and distributing the configuration amongst your teams, you can use the [flexible configuration (FC)](https://www.krakend.io/docs/configuration/flexible-config/). The following `Dockerfile` combines FC, the `krakend check` command, and a 2-step build.
+
+```Dockerfile
+FROM %%IMAGE%%:<version> as builder
+
+COPY krakend.tmpl .
+COPY config .
+
+# Save temporary output file to /tmp to avoid permission errors
+RUN FC_ENABLE=1 \
+    FC_OUT=/tmp/krakend.json \
+    FC_PARTIALS="/etc/krakend/partials" \
+    FC_SETTINGS="/etc/krakend/settings" \
+    FC_TEMPLATES="/etc/krakend/templates" \
+    krakend check -d -t -c krakend.tmpl
+
+# Copy the output file only and discard any other files
+FROM %%IMAGE%%:<version>
+COPY --from=builder /tmp/krakend.json .
+```
+
+Then build with `docker build -t my_krakend .`
+
+The configuration above assumes you have a folder structure like the following:
+
+	.
+	├── config
+	│   ├── partials
+	│   ├── settings
+	│   │   └── env.json
+	│   └── templates
+	│       └── some.tmpl
+	├── Dockerfile
+	└── krakend.tmpl
+
+### Docker Compose example
+
+Finally, a simple `docker-compose` file to start KrakenD with your API would be:
+
+```yaml
+version: "3"
+services:
+  krakend:
+    image: %%IMAGE%%:<version>
+    ports:
+      - "8080:8080"
+    volumes:
+      - ./:/etc/krakend
+```
+
+And another one that uses the flexible configuration and a custom template filename (`my_krakend.tmpl`) on each start:
+
+```yaml
+version: "3"
+services:
+  krakend:
+    image: %%IMAGE%%:<version>
+    ports:
+      - "8080:8080"
+    volumes:
+      - ./:/etc/krakend
+    environment:
+      - FC_ENABLE=1
+      - FC_OUT=/tmp/krakend.json
+      - FC_PARTIALS="/etc/krakend/config/partials"
+      - FC_SETTINGS="/etc/krakend/config/settings/prod"
+      - FC_TEMPLATES="/etc/krakend/config/templates"
+    command:
+      command: ["krakend", "run", "-c", "krakend.tmpl", "-d"]
+```
+
+### Container permissions and commands
+
+All `krakend` commands are executed as `krakend` user (uid=1000) through `su-exec`, and the rest of the commands (e.g., `sh`) are executed as root.
+
+You can directly use sub-commands of `krakend` like `run`, `help`, `version`, `check`, `check-plugin` or `validate` as the entrypoint will add the `krakend` command automatically. For example, the following lines are equivalent:
+
+	docker run -it %%IMAGE%% help
+	docker run -it %%IMAGE%% krakend help
path: krakend/content.md
user: login: tianon
body: Again, you probably ought to use a fenced code block here with either `console` or `bash` (and add the prompt or not as appropriate), and with `help` as the example, `--rm` is appropriate to include.
created_at: 2025-03-12T20:48:38Z
author_association: MEMBER

PR comments:
user: login: tianon
created_at: 2021-11-17T23:18:03Z
body: I'm frankly very confused here by several things :see_no_evil: :innocent:

"We are currently whitelisted as open-source contributors" isn't a familiar phrase for me, so I'd love to hear more details on what exactly that means to you and/or the krakend project?

https://github.com/luraproject/lura/pull/488 (merged by a familiar face :eyes:) makes me wonder if it really makes sense to make a "krakend" image if it's going to be (has been for months??) renamed to "lura" ?  What's the deal with https://www.krakend.io/ (no mention of Lura there I can find) ?

What's the relationship between @devopsfaith and the krakend / lura project/community?  What is "krakend-ce" ? :grimacing: 
author_association: MEMBER
user: login: alombarte
created_at: 2021-11-18T08:50:32Z
body: Hi @tianon ,

Thanks for your quick response. I understand why you are confused, :joy: I will explain, no worries. The easy part: By whitelisted, I mean that we are already in the Open Source Program (and we are whitelisted for the data pull rate restrictions).

All these different names you are mentioning are things we drag from our history. @devopsfaith started as a group where some friends were creating projects for fun, and took a random name. KrakenD was hosted there in 2016 as one of the projects (there were also things like [api2html](https://www.api2html.com)). The @devopsfaith it will eventually disappear, and all repos transferred to the new @krakendio to precisely avoid this confusion.

Lura is to KrakenD similarly what Moby is to Docker. There is no Lura ready-to-use image, as it is an API gateway toolkit/libraries to build your own gateway. Lura was originally the "KrakenD framework" (KrakenD's engine) and donated recently to the [Linux Foundation (press note)](https://www.linuxfoundation.org/press-release/open-source-api-gateway-krakend-becomes-linux-foundation-project/). You can still see 302 the redirection to Lura [here](https://github.com/devopsfaith/krakend). 

KrakenD CE was a distinction between the framework and the Community Edition (CE-). But today, when we talk about KrakenD, we are referring to the repo krakend-ce.

You probably have more questions, and I will be happy to answer, but let me do one to me. Why our Business Director @obokaman-com looks familiar to you? I am curious about it.

author_association: CONTRIBUTOR
user: login: alombarte
created_at: 2021-11-25T09:00:15Z
body: Hi @tianon ,

Is there anything else I can help you with? Do not hesitate to ask.
Thanks for your review!
author_association: CONTRIBUTOR
user: login: ksylvan
created_at: 2023-03-10T16:05:39Z
body: What is happening with this? It's been a while.
author_association: NONE
user: login: yosifkit
created_at: 2025-03-11T16:06:35Z
body: close/reopen to trigger GitHub actions once again
author_association: MEMBER
user: login: tianon
created_at: 2025-03-12T20:56:39Z
body: (It would also be helpful if you squash your commits, particularly the merge commits.)
author_association: MEMBER
user: login: tianon
created_at: 2025-03-26T23:07:10Z
body: (force pushed a rebase+squash and the newline-at-EOL `markdownfmt` fix)
author_association: MEMBER
user: login: alombarte
created_at: 2025-03-28T08:46:18Z
body: Thank you @tianon!
author_association: CONTRIBUTOR