Skip to content
Kong Docs are moving soon! Our docs are migrating to a new home. You'll be automatically redirected to the new site in the future. In the meantime, view this page on the new site!
Kong Logo | Kong Docs Logo
  • Docs
    • Explore the API Specs
      View all API Specs View all API Specs View all API Specs arrow image
    • Documentation
      API Specs
      Kong Gateway
      Lightweight, fast, and flexible cloud-native API gateway
      Kong Konnect
      Single platform for SaaS end-to-end connectivity
      Kong AI Gateway
      Multi-LLM AI Gateway for GenAI infrastructure
      Kong Mesh
      Enterprise service mesh based on Kuma and Envoy
      decK
      Helps manage Kong’s configuration in a declarative fashion
      Kong Ingress Controller
      Works inside a Kubernetes cluster and configures Kong to proxy traffic
      Kong Gateway Operator
      Manage your Kong deployments on Kubernetes using YAML Manifests
      Insomnia
      Collaborative API development platform
  • Plugin Hub
    • Explore the Plugin Hub
      View all plugins View all plugins View all plugins arrow image
    • Functionality View all View all arrow image
      View all plugins
      AI's icon
      AI
      Govern, secure, and control AI traffic with multi-LLM AI Gateway plugins
      Authentication's icon
      Authentication
      Protect your services with an authentication layer
      Security's icon
      Security
      Protect your services with additional security layer
      Traffic Control's icon
      Traffic Control
      Manage, throttle and restrict inbound and outbound API traffic
      Serverless's icon
      Serverless
      Invoke serverless functions in combination with other plugins
      Analytics & Monitoring's icon
      Analytics & Monitoring
      Visualize, inspect and monitor APIs and microservices traffic
      Transformations's icon
      Transformations
      Transform request and responses on the fly on Kong
      Logging's icon
      Logging
      Log request and response data using the best transport for your infrastructure
  • Support
  • Community
  • Kong Academy
Get a Demo Start Free Trial
Kong Gateway
3.6.x
  • Home icon
  • Kong Gateway
  • Install
  • Kubernetes
  • Install Kong Gateway
github-edit-pageEdit this page
report-issueReport an issue
  • Kong Gateway
  • Kong Konnect
  • Kong Mesh
  • Kong AI Gateway
  • Plugin Hub
  • decK
  • Kong Ingress Controller
  • Kong Gateway Operator
  • Insomnia
  • Kuma

  • Docs contribution guidelines
  • 3.10.x (latest)
  • 3.9.x
  • 3.8.x
  • 3.7.x
  • 3.6.x
  • 3.5.x
  • 3.4.x (LTS)
  • 3.3.x
  • 2.8.x (LTS)
  • Archive (3.0.x and pre-2.8.x)
  • Introduction
    • Overview of Kong Gateway
    • Support
      • Version Support Policy
      • Third Party Dependencies
      • Browser Support
      • Vulnerability Patching Process
      • Software Bill of Materials
    • Stability
    • Release Notes
    • Breaking Changes
      • Kong Gateway 3.6.x
      • Kong Gateway 3.5.x
      • Kong Gateway 3.4.x
      • Kong Gateway 3.3.x
      • Kong Gateway 3.2.x
      • Kong Gateway 3.1.x
      • Kong Gateway 3.0.x
      • Kong Gateway 2.8.x or earlier
    • Key Concepts
      • Services
      • Routes
      • Consumers
      • Upstreams
      • Plugins
      • Consumer Groups
    • How Kong Works
      • Routing Traffic
      • Load Balancing
      • Health Checks and Circuit Breakers
    • Glossary
  • Get Started with Kong
    • Get Kong
    • Services and Routes
    • Rate Limiting
    • Proxy Caching
    • Key Authentication
    • Load-Balancing
  • Install Kong
    • Overview
    • Kubernetes
      • Overview
      • Install Kong Gateway
      • Configure the Admin API
      • Install Kong Manager
    • Docker
      • Using docker run
      • Build your own Docker images
    • Linux
      • Amazon Linux
      • Debian
      • Red Hat
      • Ubuntu
    • Post-installation
      • Set up a data store
      • Apply Enterprise license
      • Enable Kong Manager
  • Kong in Production
    • Deployment Topologies
      • Overview
      • Kubernetes Topologies
      • Hybrid Mode
        • Overview
        • Deploy Kong Gateway in Hybrid mode
      • DB-less Deployment
      • Traditional
    • Running Kong
      • Running Kong as a non-root user
      • Securing the Admin API
      • Using systemd
    • Access Control
      • Start Kong Gateway Securely
      • Programatically Creating Admins
      • Enabling RBAC
    • Licenses
      • Overview
      • Download your License
      • Deploy Enterprise License
      • Using the License API
      • Monitor Licenses Usage
    • Networking
      • Default Ports
      • DNS Considerations
      • Network and Firewall
      • CP/DP Communication through a Forward Proxy
      • PostgreSQL TLS
        • Configure PostgreSQL TLS
        • Troubleshooting PostgreSQL TLS
    • Kong Configuration File
    • Environment Variables
    • Serving a Website and APIs from Kong
    • Monitoring
      • Overview
      • Prometheus
      • StatsD
      • Datadog
      • Health Check Probes
    • Tracing
      • Overview
      • Writing a Custom Trace Exporter
      • Tracing API Reference
    • Resource Sizing Guidelines
    • Blue-Green Deployments
    • Canary Deployments
    • Clustering Reference
    • Performance
      • Performance Testing Benchmarks
      • Establish a Performance Benchmark
      • Improve performance with Brotli compression
    • Logging and Debugging
      • Log Reference
      • Dynamic log level updates
      • Customize Gateway Logs
      • Debug Requests
    • Configure a gRPC service
    • Use the Expressions Router
    • Upgrade and Migration
      • Upgrading Kong Gateway 3.x.x
      • Backup and Restore
      • Upgrade Strategies
        • Dual-Cluster Upgrade
        • In-Place Upgrade
        • Blue-Green Upgrade
        • Rolling Upgrade
      • Upgrade from 2.8 LTS to 3.4 LTS
      • Migrate from OSS to Enterprise
      • Migration Guidelines Cassandra to PostgreSQL
      • Breaking Changes
  • Kong Gateway Enterprise
    • Overview
    • Secrets Management
      • Overview
      • Getting Started
      • Secrets Rotation
      • Advanced Usage
      • Backends
        • Overview
        • Environment Variables
        • AWS Secrets Manager
        • Azure Key Vaults
        • Google Cloud Secret Manager
        • HashiCorp Vault
      • How-To
        • Securing the Database with AWS Secrets Manager
      • Reference Format
    • Dynamic Plugin Ordering
      • Overview
      • Get Started with Dynamic Plugin Ordering
    • Audit Logging
    • Keyring and Data Encryption
    • Workspaces
    • Consumer Groups
    • Event Hooks
    • Configure Data Plane Resilience
    • About Control Plane Outage Management
    • FIPS 140-2
      • Overview
      • Install the FIPS Compliant Package
    • Authenticate your Kong Gateway Amazon RDS database with AWS IAM
    • Verify Signatures for Signed Kong Images
    • Verify Build Provenance for Signed Kong Images
  • Kong AI Gateway
    • Overview
    • Get started with AI Gateway
    • LLM Provider Integration Guides
      • OpenAI
      • Cohere
      • Azure
      • Anthropic
      • Mistral
      • Llama2
    • AI Gateway plugins
  • Kong Manager
    • Overview
    • Enable Kong Manager
    • Get Started with Kong Manager
      • Services and Routes
      • Rate Limiting
      • Proxy Caching
      • Authentication with Consumers
      • Load Balancing
    • Authentication and Authorization
      • Overview
      • Create a Super Admin
      • Workspaces and Teams
      • Reset Passwords and RBAC Tokens
      • Basic Auth
      • LDAP
        • Configure LDAP
        • LDAP Service Directory Mapping
      • OIDC
        • Configure OIDC
        • OIDC Authenticated Group Mapping
        • Migrate from previous configurations
      • Sessions
      • RBAC
        • Overview
        • Enable RBAC
        • Add a Role and Permissions
        • Create a User
        • Create an Admin
    • Networking Configuration
    • Workspaces
    • Create Consumer Groups
    • Sending Email
    • Troubleshooting
  • Develop Custom Plugins
    • Overview
    • File Structure
    • Implementing Custom Logic
    • Plugin Configuration
    • Accessing the Data Store
    • Storing Custom Entities
    • Caching Custom Entities
    • Extending the Admin API
    • Writing Tests
    • Installation and Distribution
    • Proxy-Wasm Filters
      • Create a Proxy-Wasm Filter
      • Proxy-Wasm Filter Configuration
    • Plugin Development Kit
      • Overview
      • kong.client
      • kong.client.tls
      • kong.cluster
      • kong.ctx
      • kong.ip
      • kong.jwe
      • kong.log
      • kong.nginx
      • kong.node
      • kong.plugin
      • kong.request
      • kong.response
      • kong.router
      • kong.service
      • kong.service.request
      • kong.service.response
      • kong.table
      • kong.tracing
      • kong.vault
      • kong.websocket.client
      • kong.websocket.upstream
    • Plugins in Other Languages
      • Go
      • Javascript
      • Python
      • Running Plugins in Containers
      • External Plugin Performance
  • Kong Plugins
    • Overview
    • Authentication Reference
    • Allow Multiple Authentication Plugins
    • Plugin Queuing
      • Overview
      • Plugin Queuing Reference
  • Admin API
    • Overview
    • Declarative Configuration
    • Enterprise API
      • Information Routes
      • Health Routes
      • Tags
      • Debug Routes
      • Services
      • Routes
      • Consumers
      • Plugins
      • Certificates
      • CA Certificates
      • SNIs
      • Upstreams
      • Targets
      • Vaults
      • Keys
      • Filter Chains
      • Licenses
      • Workspaces
      • RBAC
      • Admins
      • Consumer Groups
      • Event Hooks
      • Keyring and Data Encryption
      • Audit Logs
      • Status API
    • Open Source API
  • Reference
    • kong.conf
    • Injecting Nginx Directives
    • CLI
    • Key Management
    • The Expressions Language
      • Overview
      • Language References
      • Performance Optimizations
    • Rate Limiting Library
    • WebAssembly
    • FAQ
enterprise-switcher-icon Switch to Enterprise
On this pageOn this page
  • Prerequisites
    • Helm Setup
  • Secrets
    • Kong Gateway Enterprise License
    • Clustering Certificates
  • Installation
    • Control Plane
    • Data Plane
  • Testing
You are browsing documentation for an older version. See the latest documentation here.

Install Kong Gateway

This guide explains how to deploy Kong Gateway on Kubernetes without using Kong Konnect or Kong Ingress Controller.

Kong Konnect is recommended for new installations to reduce deployment complexity.
Let Kong run the control plane and database for you. With Kong Konnect, you only need to run the data planes. Get started in under 5 minutes.

These instructions configure Kong Gateway to use separate control plane and data plane deployments. This is the recommended production installation method.

Prerequisites

  • Helm 3
  • kubectl v1.19 or later
  • A running PostgreSQL database

Helm Setup

Kong provides a Helm chart for deploying Kong Gateway. Add the charts.konghq.com repository and run helm repo update to ensure that you have the latest version of the chart.

helm repo add kong https://charts.konghq.com
helm repo update

Secrets

Kong Gateway Enterprise License

First, create the kong namespace:

kubectl create namespace kong

Next, create a Kong Gateway Enterprise license secret:

Kong Gateway Enterprise Free Mode
Kong Gateway Enterprise Licensed Mode
kubectl create secret generic kong-enterprise-license --from-literal=license="'{}'" -n kong

Ensure you are in the directory that contains a license.json file before running this command.

kubectl create secret generic kong-enterprise-license --from-file=license=license.json -n kong

Clustering Certificates

Kong Gateway uses mTLS to secure the control plane/data plane communication when running in hybrid mode.

  1. Generate a TLS certificate using OpenSSL.

     openssl req -new -x509 -nodes -newkey ec:<(openssl ecparam -name secp384r1) -keyout ./tls.key -out ./tls.crt -days 1095 -subj "/CN=kong_clustering"
    
  2. Create a Kubernetes secret containing the certificate.

     kubectl create secret tls kong-cluster-cert --cert=./tls.crt --key=./tls.key -n kong
    

Installation

Control Plane

The control plane contains all Kong Gateway configurations. The configuration is stored in a PostgreSQL database.

  1. Create a values-cp.yaml file.

    Kong Gateway
    Kong Gateway (OSS)
    # Do not use Kong Ingress Controller
    ingressController:
      enabled: false
       
    image:
      repository: kong/kong-gateway
      tag: "3.6.1.8"
       
    # Mount the secret created earlier
    secretVolumes:
      - kong-cluster-cert
       
    env:
      # This is a control_plane node
      role: control_plane
      # These certificates are used for control plane / data plane communication
      cluster_cert: /etc/secrets/kong-cluster-cert/tls.crt
      cluster_cert_key: /etc/secrets/kong-cluster-cert/tls.key
       
      # Database
      # CHANGE THESE VALUES
      database: postgres
      pg_database: kong
      pg_user: kong
      pg_password: demo123
      pg_host: kong-cp-postgresql.kong.svc.cluster.local
      pg_ssl: "on"
       
      # Kong Manager password
      password: kong_admin_password
       
    # Enterprise functionality
    enterprise:
      enabled: true
      license_secret: kong-enterprise-license
       
    # The control plane serves the Admin API
    admin:
      enabled: true
      http:
        enabled: true
       
    # Clustering endpoints are required in hybrid mode
    cluster:
      enabled: true
      tls:
        enabled: true
       
    clustertelemetry:
      enabled: true
      tls:
        enabled: true
       
    # Optional features
    manager:
      enabled: false
       
    # These roles will be served by different Helm releases
    proxy:
      enabled: false
    # Do not use Kong Ingress Controller
    ingressController:
      enabled: false
       
    image:
      repository: kong
      tag: "3.6.1"
       
    # Mount the secret created earlier
    secretVolumes:
      - kong-cluster-cert
       
    env:
      # This is a control_plane node
      role: control_plane
      # These certificates are used for control plane / data plane communication
      cluster_cert: /etc/secrets/kong-cluster-cert/tls.crt
      cluster_cert_key: /etc/secrets/kong-cluster-cert/tls.key
       
      # Database
      # CHANGE THESE VALUES
      database: postgres
      pg_database: kong
      pg_user: kong
      pg_password: demo123
      pg_host: kong-cp-postgresql.kong.svc.cluster.local
      pg_ssl: "on"
       
      # Kong Manager password
      password: kong_admin_password
       
    # Enterprise functionality
    enterprise:
      enabled: false
      license_secret: kong-enterprise-license
       
    # The control plane serves the Admin API
    admin:
      enabled: true
      http:
        enabled: true
       
    # Clustering endpoints are required in hybrid mode
    cluster:
      enabled: true
      tls:
        enabled: true
       
    clustertelemetry:
      enabled: true
      tls:
        enabled: true
       
    # Optional features
    manager:
      enabled: false
       
    # These roles will be served by different Helm releases
    proxy:
      enabled: false
  2. (Optional) If you want to deploy a Postgres database within the cluster for testing purposes, add the following to the bottom of values-cp.yaml.

     # This is for testing purposes only
     # DO NOT DO THIS IN PRODUCTION
     # Your cluster needs a way to create PersistentVolumeClaims
     # if this option is enabled
     postgresql:
       enabled: true
       auth:
         password: demo123
    
  3. Update the database connection values in values-cp.yaml.

    • env.pg_database: The database name to use
    • env.pg_user: Your database username
    • env.pg_password: Your database password
    • env.pg_host: The hostname of your Postgres database
    • env.pg_ssl: Use SSL to connect to the database
  4. Set your Kong Manager super admin password in values-cp.yaml.

    • env.password: The Kong Manager super admin password
  5. Run helm install to create the release.

     helm install kong-cp kong/kong -n kong --values ./values-cp.yaml
    
  6. Run kubectl get pods -n kong. Ensure that the control plane is running as expected.

     NAME                                 READY   STATUS
     kong-cp-kong-7bb77dfdf9-x28xf        1/1     Running
    

Data Plane

The Kong Gateway data plane is responsible for processing incoming traffic. It receives the routing configuration from the control plane using the clustering endpoint.

  1. Create a values-dp.yaml file.

    Kong Gateway
    Kong Gateway (OSS)
    # Do not use Kong Ingress Controller
    ingressController:
      enabled: false
       
    image:
      repository: kong/kong-gateway
      tag: "3.6.1.8"
       
    # Mount the secret created earlier
    secretVolumes:
      - kong-cluster-cert
       
    env:
      # data_plane nodes do not have a database
      role: data_plane
      database: "off"
       
      # Tell the data plane how to connect to the control plane
      cluster_control_plane: kong-cp-kong-cluster.kong.svc.cluster.local:8005
      cluster_telemetry_endpoint: kong-cp-kong-clustertelemetry.kong.svc.cluster.local:8006
       
      # Configure control plane / data plane authentication
      lua_ssl_trusted_certificate: /etc/secrets/kong-cluster-cert/tls.crt
      cluster_cert: /etc/secrets/kong-cluster-cert/tls.crt
      cluster_cert_key: /etc/secrets/kong-cluster-cert/tls.key
       
    # Enterprise functionality
    enterprise:
      enabled: true
      license_secret: kong-enterprise-license
       
    # The data plane handles proxy traffic only
    proxy:
      enabled: true
       
    # These roles are served by the kong-cp deployment
    admin:
      enabled: false
       
    manager:
      enabled: false
    # Do not use Kong Ingress Controller
    ingressController:
      enabled: false
       
    image:
      repository: kong
      tag: "3.6.1"
       
    # Mount the secret created earlier
    secretVolumes:
      - kong-cluster-cert
       
    env:
      # data_plane nodes do not have a database
      role: data_plane
      database: "off"
       
      # Tell the data plane how to connect to the control plane
      cluster_control_plane: kong-cp-kong-cluster.kong.svc.cluster.local:8005
      cluster_telemetry_endpoint: kong-cp-kong-clustertelemetry.kong.svc.cluster.local:8006
       
      # Configure control plane / data plane authentication
      lua_ssl_trusted_certificate: /etc/secrets/kong-cluster-cert/tls.crt
      cluster_cert: /etc/secrets/kong-cluster-cert/tls.crt
      cluster_cert_key: /etc/secrets/kong-cluster-cert/tls.key
       
    # Enterprise functionality
    enterprise:
      enabled: false
      license_secret: kong-enterprise-license
       
    # The data plane handles proxy traffic only
    proxy:
      enabled: true
       
    # These roles are served by the kong-cp deployment
    admin:
      enabled: false
       
    manager:
      enabled: false
  2. Run helm install to create the release.

    helm install kong-dp kong/kong -n kong --values ./values-dp.yaml
    
  3. Run kubectl get pods -n kong. Ensure that the data plane is running as expected.

     NAME                                 READY   STATUS
     kong-dp-kong-5dbcd9f6b9-f2w49        1/1     Running
    

Testing

Kong Gateway is now running. To send some test traffic, try the following:

  1. Fetch the LoadBalancer address for the kong-dp service and store it in the PROXY_IP environment variable

     PROXY_IP=$(kubectl get service --namespace kong kong-dp-kong-proxy -o jsonpath='{range .status.loadBalancer.ingress[0]}{@.ip}{@.hostname}{end}')
    
  2. Make a HTTP request to your $PROXY_IP. This will return a HTTP 404 served by Kong Gateway

     curl $PROXY_IP/mock/anything
    
  3. In another terminal, run kubectl port-forward to set up port forwarding and access the admin API.

     kubectl port-forward -n kong service/kong-cp-kong-admin 8001
    
  4. Create a mock service and route

     curl localhost:8001/services -d name=mock  -d url="https://httpbin.konghq.com"
     curl localhost:8001/services/mock/routes -d "paths=/mock"
    
  5. Make a HTTP request to your $PROXY_IP again. This time Kong Gateway will route the request to httpbin.

     curl $PROXY_IP/mock/anything
    

Previous Overview
Next Configure the Admin API
Thank you for your feedback.
Was this page useful?
Too much on your plate? close cta icon
More features, less infrastructure with Kong Konnect. 1M requests per month for free.
Try it for Free
  • Kong
    Powering the API world

    Increase developer productivity, security, and performance at scale with the unified platform for API management, service mesh, and ingress controller.

    • Products
      • Kong Konnect
      • Kong Gateway Enterprise
      • Kong Gateway
      • Kong Mesh
      • Kong Ingress Controller
      • Kong Insomnia
      • Product Updates
      • Get Started
    • Documentation
      • Kong Konnect Docs
      • Kong Gateway Docs
      • Kong Mesh Docs
      • Kong Insomnia Docs
      • Kong Konnect Plugin Hub
    • Open Source
      • Kong Gateway
      • Kuma
      • Insomnia
      • Kong Community
    • Company
      • About Kong
      • Customers
      • Careers
      • Press
      • Events
      • Contact
  • Terms• Privacy• Trust and Compliance
© Kong Inc. 2025