Install Kong Gateway on Docker

    Kong Gateway supports both PostgreSQL 9.5+ and Cassandra 3.11.* as its datastore. This guide provides steps to configure PostgreSQL.

    If you prefer to use the open-source Kong Gateway image with Docker Compose, Kong also provides a Docker Compose template with built-in orchestration and scalability.

    Some are not publicly accessible. If you need a specific patch version and can’t find it on Kong’s public Docker Hub page, contact .

    The Kong Gateway software is governed by the Kong Software License Agreement. Kong Gateway (OSS) is licensed under an .

    • A Docker-enabled system with proper Docker access
    • (Enterprise only) A file from Kong

    Choose a path to install Kong Gateway:

    • With a database: Use a database to store Kong entity configurations. Can use the Admin API or declarative configuration files to configure Kong.
    • : Store Kong configuration in-memory on the node. In this mode, the Admin API is read only, and you have to manage Kong using declarative configuration.

    If this is your first time trying out Kong Gateway, we recommend installing it with a database.

    Set up a Kong Gateway container with a PostgreSQL database to store Kong configuration.

    1. Create a custom Docker network to allow the containers to discover and communicate with each other:

      You can name this network anything you want. We use kong-net as an example throughout this guide.

    2. Start a PostgreSQL container:

      1.  docker run -d --name kong-database \
      2.   --network=kong-net \
      3.   -p 5432:5432 \
      4.   -e "POSTGRES_USER=kong" \
      5.   -e "POSTGRES_DB=kong" \
      6.   -e "POSTGRES_PASSWORD=kongpass" \
      7.   postgres:9.6
      • POSTGRES_USER and POSTGRES_DB: Set these values to kong. This is the default value that Kong Gateway expects.
      • POSTGRES_PASSWORD: Set the database password to any string.

      In this example, the Postgres container named kong-database can communicate with any containers on the kong-net network.

    3. Prepare the Kong database:

      Kong Gateway

      1. docker run --rm --network=kong-net \
      2.   -e "KONG_DATABASE=postgres" \
      3.   -e "KONG_PG_HOST=kong-database" \
      4.   -e "KONG_PG_PASSWORD=kongpass" \
      5.   -e "KONG_PASSWORD=test" \
      6.  kong/kong-gateway:2.6.0.4-alpine kong migrations bootstrap
      1. docker run --rm --network=kong-net \
      2.   -e "KONG_DATABASE=postgres" \
      3.   -e "KONG_PG_HOST=kong-database" \
      4.   -e "KONG_PG_PASSWORD=kongpass" \
      5.  kong:2.6.0-alpine kong migrations bootstrap

      Where:

      • KONG_DATABASE: Specifies the type of database that Kong is using.
      • : The name of the Postgres Docker container that is communicating over the kong-net network, from the previous step.
      • KONG_PG_PASSWORD: The password that you set when bringing up the Postgres container in the previous step.
      • KONG_PASSWORD (Enterprise only): The default password for the admin super user for Kong Gateway.

    Start Kong Gateway

    1. Run the following command to start a container with Kong Gateway:

      Kong Gateway

      Kong Gateway (OSS)

      1. docker run -d --name kong-gateway \
      2.   --network=kong-net \
      3.   -e "KONG_DATABASE=postgres" \
      4.   -e "KONG_PG_HOST=kong-database" \
      5.   -e "KONG_PG_USER=kong" \
      6.   -e "KONG_PG_PASSWORD=kongpass" \
      7.   -e "KONG_PROXY_ACCESS_LOG=/dev/stdout" \
      8.   -e "KONG_ADMIN_ACCESS_LOG=/dev/stdout" \
      9.   -e "KONG_PROXY_ERROR_LOG=/dev/stderr" \
      10.   -e "KONG_ADMIN_ERROR_LOG=/dev/stderr" \
      11.   -e "KONG_ADMIN_LISTEN=0.0.0.0:8001" \
      13.   -p 8000:8000 \
      14.   -p 8443:8443 \
      15.   -p 8001:8001 \
      16.   -p 8444:8444 \
      17.   -p 8002:8002 \
      18.   -p 8445:8445 \
      19.   -p 8003:8003 \
      20.   -p 8004:8004 \
      21.   kong/kong-gateway:2.6.0.4-alpine

      Where:

      • --name and --network: The name of the container to create, and the Docker network it communicates on.
      • KONG_DATABASE: Specifies the type of database that Kong is using.
      • : The name of the Postgres Docker container that is communicating over the kong-net network.
      • KONG_PG_USER and KONG_PG_PASSWORD: The Postgres username and password. Kong Gateway needs the login information to store configuration data in the KONG_PG_HOST database.
      • All parameters: set filepaths for the logs to output to, or use the values in the example to print messages and errors to stdout and stderr.
      • KONG_ADMIN_LISTEN: The port that the Kong Admin API listens on for requests.
      • : (Enterprise only) The URL for accessing Kong Manager, preceded by a protocol (for example, http://).

    2. Verify your installation:

      Access the /services endpoint using the Admin API:

      1.  curl -i -X GET --url http://localhost:8001/services

      You should receive a 200 status code.

    3. (Not available in OSS) Verify that Kong Manager is running by accessing it using the URL specified in KONG_ADMIN_GUI_URL:

      1.  http://localhost:8002

    Get started with Kong Gateway

    Now that you have a running Gateway instance, Kong provides a series of to help you set up and enhance your first Service.

    In particular, right after installation you might want to:

    If you’re done testing Kong Gateway and no longer need the containers, you can clean them up using the following commands:

    1. docker kill kong-gateway
    2. docker kill kong-database
    3. docker container rm kong-gateway
    4. docker container rm kong-database
    5. docker network rm kong-net

    The following steps walk you through starting Kong Gateway in DB-less mode.

    Create a Docker network

    Run the following command:

    1. docker network create kong-net

    This step is not strictly needed for running Kong in DB-less mode, but it is a good precaution in case you want to add other things in the future (like a Rate Limiting plugin backed up by a Redis cluster).

    Prepare your configuration file

    1. Prepare your declarative configuration file in .yml or .json format.

      The syntax and properties are described in the guide. Add whatever core entities (Services, Routes, Plugins, Consumers, etc) you need to this file.

      For example, a simple file with a Service and a Route could look something like this:

      This guide assumes you named the file kong.yml.

    2. Save your declarative configuration locally, and note the filepath.

    1. From the same directory where you just created the kong.yml file, run the following command to start a container with Kong Gateway:

      Kong Gateway

      Kong Gateway (OSS)

      1.   --network=kong-net \
      2.   -v "$(pwd):/kong/declarative/" \
      3.   -e "KONG_DATABASE=off" \
      4.   -e "KONG_DECLARATIVE_CONFIG=/kong/declarative/kong.yml" \
      5.   -e "KONG_PROXY_ACCESS_LOG=/dev/stdout" \
      6.   -e "KONG_ADMIN_ACCESS_LOG=/dev/stdout" \
      8.   -e "KONG_ADMIN_ERROR_LOG=/dev/stderr" \
      9.   -e "KONG_ADMIN_LISTEN=0.0.0.0:8001" \
      10.   -e "KONG_ADMIN_GUI_URL=http://localhost:8002" \
      11.   -p 8000:8000 \
      12.   -p 8443:8443 \
      13.   -p 8001:8001 \
      14.   -p 8444:8444 \
      15.   -p 8002:8002 \
      16.   -p 8445:8445 \
      17.   -p 8003:8003 \
      18.   -p 8004:8004 \
      19.   kong/kong-gateway:2.6.0.4-alpine
      1. docker run -d --name kong-dbless \
      2.   --network=kong-net \
      3.   -v "$(pwd):/kong/declarative/" \
      4.   -e "KONG_DATABASE=off" \
      5.   -e "KONG_DECLARATIVE_CONFIG=/kong/declarative/kong.yml" \
      6.   -e "KONG_PROXY_ACCESS_LOG=/dev/stdout" \
      7.   -e "KONG_ADMIN_ACCESS_LOG=/dev/stdout" \
      8.   -e "KONG_PROXY_ERROR_LOG=/dev/stderr" \
      9.   -e "KONG_ADMIN_ERROR_LOG=/dev/stderr" \
      10.   -e "KONG_ADMIN_LISTEN=0.0.0.0:8001, 0.0.0.0:8444 ssl" \
      11.   -p 8000:8000 \
      12.   -p 8443:8443 \
      13.   -p 127.0.0.1:8001:8001 \
      14.   -p 127.0.0.1:8444:8444 \
      15.   kong:2.6.0-alpine

      Where:

      • --name and --network: The name of the container to create, and the Docker network it communicates on.
      • -v $(pwd):/path/to/target/: Mount the current directory on your local filesystem to a directory in the Docker container. This makes the kong.yml file visible from the Docker container.
      • KONG_DATABASE: Sets the database to off to tell Kong not to use any backing database for configuration storage.
      • : The path to a declarative configuration file inside the container. This path should match the target path that you’re mapping with -v.
      • All _LOG parameters: set filepaths for the logs to output to, or use the values in the example to print messages and errors to stdout and stderr.
      • : The port that the Kong Admin API listens on for requests.
      • KONG_ADMIN_GUI_URL: (Enterprise only) The URL for accessing Kong Manager, preceded by a protocol (for example, http://).

    2. Verify that Kong Gateway is running:

      1.  curl -i http://localhost:8001

      Test an endpoint. For example, get a list of services:

      1.  curl -i http://localhost:8001/services

    Get started with Kong Gateway

    Now that you have a running Gateway instance, Kong provides a series of getting started guides to help you set up and enhance your first Service.

    If you use the sample kong.yml in this guide, you already have a Service and a Route configured. Here are a few more things to check out:

    Clean up containers

    If you did not receive a status code or need assistance completing setup, reach out to your support contact or head over to the Support Portal.