DEV Community: Deepanshu Pandey

Understanding Regex in Kong Gateway: Then vs Now

Deepanshu Pandey — Sat, 19 Jul 2025 14:25:30 +0000

Whether you're building scalable APIs or managing complex traffic flows, Kong Gateway offers powerful routing capabilities — and at the heart of that power lies one timeless tool: regular expressions (regex).

Regex gives you fine-grained control over how requests are matched, routed, or filtered. But like everything else, Kong's support for regex has evolved significantly — especially with the introduction of expressions in newer versions.

In this post, let’s dive deep into:

How regex worked in earlier versions of Kong
What’s changed in Kong 3.x and beyond
Practical use cases and syntax examples
When to use plain regex and when to switch to expressions

🔍 What is Regex in Kong?

Regular expressions are string patterns that allow matching flexible and complex inputs — such as paths, headers, hostnames, and even query parameters.

In Kong, regex is typically used to:

Match incoming request paths (e.g., /users/123)
Match hostnames (e.g., *.example.com)
Filter headers like X-User-Type: admin

You can write regex patterns in route fields such as paths, hosts, or headers, and Kong will evaluate them to decide whether a request should be routed.

📜 Regex in Older Kong Versions (Pre-3.x)

In earlier Kong versions, regex was supported — but only within a few specific fields:

Use regex in paths, like /api/v1/users/\d+
Use regex in headers, with special syntax like ~ for case-sensitive, and ~* for case-insensitive matching
Combine multiple route conditions — but they were evaluated separately and limited in complexity

🧪 Example 1: Regex in Path

"paths": ["/users/\d+"]

🧪 Example 2: Regex in Header

"headers": {
"x-role": ["~^admin$"]
}

⚠️ Limitations in the Past

While powerful, this older approach came with limitations:

❌ No way to write complex combined conditions (e.g., header + path regex)
❌ Couldn’t easily use request method (GET, POST) in regex logic
❌ Static matching — no dynamic plugin control or conditional logic
❌ Managing multiple routes with slightly different patterns became messy

⚡ Regex in Modern Kong (v3.0 – v3.7+)

With the evolution of Kong Gateway (starting around v3.0), expressions were introduced — bringing more power, flexibility, and logical operations to routing and plugin control.

✅ Good News: Regex still works!

Regex is still fully supported in:

paths
hosts
headers

But now, you also get regex support inside expressions, unlocking much more power.

🧠 What Are Expressions?

Expressions in Kong are Lua-style conditions that can evaluate fields like:

request.path
request.headers
request.method
request.query
request.jwt.claims

And yes — you can use regex functions like string.match() and ngx.re.match() inside them.

🔁 Regex vs Expressions in Kong (Tabular View)

Here’s how the two approaches compare:

💡 Real-World Use Cases

Path Matching with Regex

"paths": ["/orders/\d{4,6}"]
Matches /orders/1234 or /orders/654321.

Header Matching with Regex

"headers": {
"x-region": ["~^apac-.*$"]
}
Matches x-region: apac-east or apac-west.

Expression with Regex (New Style)

expression = "ngx.re.match(request.path, '^/reports/[0-9]{4}/[a-z]+$')"

Case-Insensitive Header Match using Expressions

expression = "string.lower(request.headers['x-department']) == 'finance'"

✅ Tips for Writing Safe Regex in Kong

Escape special characters properly in JSON/YAML (use \)
Use ~* for case-insensitive matches
Test with https://regex101.com/ before deploying
Prefer expressions for combined, readable logic
Be cautious — overly complex regex can slow down high-throughput routes

📦 Summary

Regex is still a cornerstone of Kong Gateway’s routing power — but the introduction of expressions has taken it to the next level.

🏷️ Older versions = regex only in a few places, limited flexibility
🧠 Newer versions (3.0+) = regex plus full-blown logic with expressions
🔄 Use regex where it makes sense (simple patterns)
⚙️ Use expressions for more advanced routing or plugin logic

🧩 Final Thoughts

Regex hasn’t gone anywhere — but it now has a smarter companion in Kong expressions.

By combining the two, you can create more dynamic, maintainable, and secure Kong configurations.

So… are you still using regex the old way?

Try expressions with regex today — and level up your API Gateway game! 💥

The Ultimate Guide to Installing Kong Gateway on Docker, Kubernetes, and Linux

Deepanshu Pandey — Sat, 26 Apr 2025 13:02:50 +0000

What is Kong Gateway ?

Kong Gateway is a robust, scalable API Gateway and Microservices Management Layer designed to simplify the process of managing APIs. It provides features such as load balancing, traffic control, monitoring, and security—all in one place. With its flexible deployment options, Kong can be installed on a range of platforms, including Docker, Kubernetes, and various Linux distributions.

Why Use Kong Gateway ?

Kong is favored for its:

Scalability: With support for Kubernetes and Docker, Kong can handle high traffic loads.
High Availability: Its clustering feature ensures your API Gateway remains operational even during heavy traffic or node failures.
Security: Kong provides features like rate-limiting, authentication, and access control to keep your APIs secure.
Performance: Designed for microservices architecture, Kong is built for speed, allowing efficient API traffic routing.

Kong Gateway Installation on Docker

Prerequisites

Before you begin the installation, ensure that you have:

Docker installed on your system.
A basic understanding of Docker and containers.

Step-by-Step Installation Guide

To install Kong Gateway on Docker, follow these steps:

1. Pull the Kong Image

First, you need to pull the official Kong Gateway image from Docker Hub:

docker pull kong/kong-gateway:latest

2. Run Kong Container

Now, run the Kong Gateway container. The following command will run Kong in detached mode, bind it to a host port, and set an environment variable for the database:

docker run -d --name kong \ -e "KONG_DATABASE=off" \ -e "KONG_DECLARATIVE_CONFIG=/kong/kong.yml" \ -e "KONG_PROXY_ACCESS_LOG=/dev/stdout" \ -e "KONG_ADMIN_ACCESS_LOG=/dev/stdout" \ -e "KONG_ADMIN_ERROR_LOG=/dev/stderr" \ -e "KONG_PORT_MAPS=8000:8000" \ -e "KONG_PORT=8000" \ -v /path/to/your/kong.yml:/kong/kong.yml \ -p 8000:8000 \ kong/kong-gateway:latest

3. Check Kong Gateway

After the container is running, you can check Kong’s status by sending a request to its Admin API:

curl -i http://localhost:8001

Verifying the Installation

To ensure that Kong Gateway is running correctly, you can check the logs:

docker logs kong

If everything is working, you should see Kong logs indicating it’s up and running.

Kong Gateway Installation on Kubernetes

Prerequisites

Before installing Kong on Kubernetes, ensure the following:

A Kubernetes cluster (using Minikube, GKE, or any other provider).
kubectl command-line tool configured to communicate with your Kubernetes cluster.

Step-by-Step Installation Guide

Kong can be installed in Kubernetes using Helm, a package manager for Kubernetes.

1. Install Helm

If you don’t have Helm installed, use the following command:

curl https://get.helm.sh/helm-v3.7.1-linux-amd64.tar.gz -o helm-v3.7.1-linux-amd64.tar.gz tar -xvzf helm-v3.7.1-linux-amd64.tar.gz sudo mv linux-amd64/helm /usr/local/bin/helm

2. Add Kong’s Helm Repository

Add the official Kong Helm repository:

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

3. Install Kong Gateway

Use Helm to install Kong into your Kubernetes cluster:

helm install kong kong/kong-gateway --set ingressController.enabled=true

4. Verify Installation

After installation, check if Kong pods are running with:

kubectl get pods -n kong

This command will list the pods, and you should see kong-ingress-controller running.

Verifying the Installation

Test the Kong Gateway by making a request to the Kong proxy:

_curl -i http://<KONG_PROXY_IP>:8000_

If you see a response, then Kong is successfully deployed on Kubernetes.

Kong Gateway Installation on Linux

Now, let’s look at how to install Kong Gateway on different Linux distri__butions.

Installing on Debian

1. Add Kong Repository

Add the Kong APT repository to your system:

curl -fsSL https://konghq.com/install-deb | sudo tee /etc/apt/sources.list.d/kong.list

2. Install Kong

Install Kong with the following command:

sudo apt-get update sudo apt-get install kong

3. Verify Installation

Check Kong’s version:

kong version

Installing on Ubuntu

The installation process for Ubuntu is the same as Debian, since Ubuntu is based on Debian.

1. Add Kong Repository

Add the Kong APT repository:

curl -fsSL https://konghq.com/install-deb | sudo tee /etc/apt/sources.list.d/kong.list

2. Install Kong

Install Kong with:

sudo apt-get update sudo apt-get install kong

3. Verify Installation

Confirm the installation by checking Kong’s version:

kong version

Installing on RedHat

1. Add Kong Repository

Add the Kong repository for RedHat:

sudo curl -fsSL https://konghq.com/install-rpm | sudo tee /etc/yum.repos.d/kong.repo

2. Install Kong

Install Kong using YUM:

sudo yum install kong

3. Verify Installation

Verify that Kong is installed by checking its version:

kong version

Installing on Amazon Linux 2

1. Add Kong Repository

Add the Kong repository for Amazon Linux 2:

sudo curl -fsSL https://konghq.com/install-rpm | sudo tee /etc/yum.repos.d/kong.repo

2. Install Kong

Install Kong using YUM:

sudo yum install kong

3. Verify Installation

Confirm Kong is installed:

kong version

Verifying the Installation

For any Linux distribution, after installation, verify the Kong service is running by checking its status:

sudo systemctl status kong

Conclusion

Kong Gateway provides powerful API management capabilities, whether you're deploying on Docker, Kubernetes, or Linux. With just a few simple steps, you can install Kong on any of these platforms and start using its features for managing your microservices and APIs.

This guide covers the installation for each of the popular platforms, and you can always refer to the official documentation for further customization and configuration.

For more detailed information and advanced configurations, visit the official Kong Gateway Installation Documentation.

Ready to get started with Kong Gateway? Happy installing!

Unlocking Efficiency: The Power of Kong AI Gateway

Deepanshu Pandey — Sat, 26 Apr 2025 09:16:03 +0000

In today’s rapidly evolving digital landscape, organizations increasingly rely on APIs to drive innovation, enhance connectivity, and streamline operations. However, as the complexity of managing these APIs grows, the need for advanced solutions becomes paramount.

Enter Kong’s AI Gateway—a revolutionary product designed to transform the way we think about API management by leveraging artificial intelligence to provide intelligent insights, enhanced security, and optimized performance.

What is the AI Gateway?

The rapid emergence of various AI LLM providers, including open-source and self-hosted models, has led to a fragmented technology landscape with inconsistent standards and controls.

This fragmentation complicates how developers and organizations utilize
and govern AI services. Kong Gateway’s extensive API management
capabilities and plugin extensibility make it an ideal solution for providing AI-specific management and governance services.

Since AI providers often do not adhere to a standardized API specification, the AI Gateway offers a normalized API layer that enables clients to access multiple AI services from a single codebase. It
enhances capabilities such as credential management, AI usage observability, governance, an prompt engineering for fine-tuning models. Developers can utilize no-code AI plugins to enrich their existing API traffic, thereby enhancing application functionality with ease.

You can activate the AI Gateway features through a range of modern, specialized plugins, following the same approach as with other Kong Gateway plugins. When integrated with existing Kong Gateway plugins, users can quickly build a robust AI management platform without the need for custom coding or introducing new, unfamiliar tools.

Key Features and Benefits

1. Intelligent Traffic Management: The AI Gateway’s intelligent traffic management capabilities analyze real-time data to optimize request routing. By employing machine learning algorithms, the gateway adapts to changing conditions, ensuring that requests are processed through the most efficient paths. This results in lower latency, improved performance, and a seamless user experience. Additionally, the gateway can automatically balance loads across services, preventing any single service from becoming a bottleneck.

2. Enhanced Security: Security is a top concern for any organization operating in the digital realm. The AI Gateway takes a proactive stance by using AI to identify and mitigate threats before they impact your systems. It can detect anomalies in traffic patterns, flag suspicious
activities, and automatically apply security protocols to safeguard APIs. This real-time threat detection ensures that your APIs are resilient against attacks, providing peace of mind to organizations and their users.

3. Seamless Integration: The AI Gateway is designed to fit seamlessly within existing infrastructures. It supports a wide array of integrations, allowing organizations to connect with their current tools and platforms without any disruption. This flexibility means teams
can leverage the AI Gateway's capabilities without overhauling their entire tech stack, making it easier to adopt and implement.

4. Automated Insights and Reporting: With the AI Gateway, organizations benefit from automated insights that simplify the understanding of API usage and performance metrics. These insights are generated through AI analysis, allowing teams to access critical
information at a glance. This capability enables informed decision making, optimizes resource allocation, and drives continuous improvement, ultimately enhancing overall performance.

5. Collaborative Features: Modern workplaces thrive on collaboration, and the AI Gateway facilitates teamwork across various departments. It provides features that enhance communication between developers, security teams, and operations staff, fostering a unified approach to API management. By breaking down silos, the AI Gateway promotes efficiency
and accelerates the development lifecycle.

6. Plugin Ecosystem: One of the standout aspects of the AI Gateway is its robust plugin ecosystem. Kong offers a variety of plugins that extend the functionality of the gateway, allowing organizations to customize their API management experience.

Most used LLMs:

The infographic presents a breakdown of the most popular Large Language Models (LLMs) currently in use. Here's a summary of the key takeaways:

Dominant Players:

1. ChatGPT: With a significant share of 27%, ChatGPT remains the most widely used LLM. Its user-friendly interface and impressive language capabilities have contributed to its popularity.

2. Azure AI: Closely following ChatGPT, Azure AI holds a 18% share. It's backed by Microsoft's extensive resources and offers a range of AI services, including LLM capabilities.

3. Google Gemini: Google's latest LLM, Gemini, has quickly gained traction with a 17% share. It's known for its advanced capabilities in various language tasks.

Other Notable LLMs:

1. Meta Llama: With an 8% share, Meta Llama is a powerful LLM developed by Meta (formerly Facebook).

2. Amazon Bedrock: Amazon's Bedrock offers access to a variety of foundation models, including LLMs. It holds a 7% share.

3. Claude: Anthropic's Claude is a versatile LLM with a 7% share, known for its ability to generate creative and informative text.

4. Cohere: Cohere provides a suite of AI tools, including LLMs, with a 5% share.

5. Mistral: Mistral is a relatively new LLM with a 4% share, gaining attention for its promising capabilities.

Key Insights:

1. ChatGPT's Dominance: ChatGPT's strong market position highlights its ability to meet a wide range of user needs.

2. Cloud Providers' Influence: Major cloud providers like Microsoft and Google are making significant strides in the LLM space, providing powerful AI capabilities to their users.

3. Emerging Players: LLMs like Meta Llama and Mistral demonstrate the growing diversity and innovation in the LLM landscape.

This infographic offers a snapshot of the current LLM landscape, highlighting the leading models and their relative popularity. As the field of AI continues to evolve, we can expect further developments
and shifts in the usage of LLMs.

Kong AI Plugins

1. AI Proxy:

Purpose: This plugin simplifies making your first AI request.
How it works: It provides a user-friendly interface to connect to various AI models or services, allowing you to experiment and build AI-powered applications without deep technical knowledge.

2. AI Gateway:

Purpose: This is the core plugin that enables you to build new AI applications faster and power existing API traffic with AI capabilities.
How it works: It integrates multiple LLMs (Large Language Models) and provides security, metrics, and other essential functionalities for AI-powered applications. It also supports declarative configuration, making it easier to manage AI integrations.

3. Request Transformer:

Purpose: This plugin allows you to transform API requests with no-code AI integrations.
How it works: It uses AI models to modify, enhance, or augment incoming requests, making them more suitable for processing by the backend services.

4. Response Transformer:

Purpose: This plugin transforms, enriches, and augments API responses using no-code AI integrations.
How it works: It uses AI models to process API responses and generate more informative or personalized outputs.

5. AI Prompt Guard:

Purpose: This plugin secures your AI prompts by implementing advanced prompt security.
How it works: It analyses prompts and filters out malicious or inappropriate content, ensuring that the AI models are used responsibly.

6. AI Prompt Template:

Purpose: This plugin helps you create better prompts by building AI templates that are compatible with the OpenAI interface.
How it works: It provides a structured way to create effective prompts for AI models, improving the quality of AI-generated outputs.

7. AI Prompt Decorator:

Purpose: This plugin helps you build better AI contexts by centrally managing the contexts and behaviors of every AI prompt.
How it works: It allows you to define and manage the context of an AI prompt, ensuring that the AI model understands the desired outcome and generates more relevant responses.

In essence, the Kong AI Gateway plugins provide a comprehensive suite of tools to build and manage AI-powered applications. They simplify the integration of AI models, enhance security, and improve the overall performance of AI-driven systems.

Use cases of Kong AI Gateway

1. Multi-AI Adoption

Core Concept: This approach emphasizes utilizing the right AI model for the right task. It's about tailoring AI solutions to specific needs, rather than relying on a one-size-fits-all model.

Benefits:

Flexibility: Different AI models excel in different tasks (e.g., image recognition, natural language processing, etc.). Choosing the best-suited model allows for optimal results.
Cost-Control: Not every task requires the most advanced AI model. By selecting the right model, you can optimize costs without compromising performance.

2. AI Data Governance

Core Concept: This focuses on ensuring responsible and ethical use of AI by controlling the flow of information to AI models.

Importance:

Data Privacy: Protecting sensitive data from unauthorized access or misuse is paramount.
Model Bias: Preventing AI models from learning and perpetuating biases in the data they are trained on.

3. AI Usage Governance

Core Concept: This involves monitoring and regulating the use of AI to mitigate risks and ensure compliance with policies.

Why it Matters:

Unregulated AI: Uncontrolled AI usage can lead to unintended consequences, such as job displacement or algorithmic bias.
Policy Enforcement: AI Usage Governance ensures that AI is used in accordance with ethical guidelines and legal regulations.

Conclusion

Kong’s AI Gateway represents a significant advancement in API management, merging cutting-edge AI technology with robust functionality. As businesses navigate the complexities of the digital landscape, solutions like the AI Gateway offer the tools needed to thrive.

Whether you aim to improve traffic management, enhance security, or gain deeper insights into your API performance, the AI Gateway is designed to meet these challenges head-on. With its intelligent features, seamless integration, and customizable plugins, it’s time to explore how Kong’s AI Gateway can transform your API strategy and drive your organization forward.

For more information about the AI Gateway and to explore the available plugins, visit the official Kong documentation and hub. Embrace the future of API management today!

What is deck and How can it be used in Kong? A Hands-on Guide

Deepanshu Pandey — Thu, 25 Apr 2024 08:29:21 +0000

Deck

Deck is a tool that helps you manage your Kong configuration in a declarative way. This configuration can be conveniently stored in the code repository. Deck is responsible for synchronizing the Kong configuration in the code repository with the running Kong instance. It was created mainly to make it easy to automate Kong configuration management in CI/CD processes.

In the world of Kong, Deck is a tool that helps manage configurations using declarative files. These files describe how Kong's API Gateway should be set up, including things like services, routes, and plugins.

Overall, Deck simplifies managing Kong clusters by providing a clear and manageable way to define and apply configurations.

Why Use Deck?

There are several benefits to using Deck for managing configurations in Kong:

• Version control: Deck uses declarative files, which can be version controlled using tools like Git. This allows you to track changes to your Kong configuration over time, revert to previous versions if needed, and collaborate with others on configuration management.

• Repeatability and automation: With Deck, you can define your desired Kong configuration in a file. This makes it easy to deploy the same configuration across multiple environments (e.g., development, staging, production) or automate deployments using CI/CD pipelines.

• Reduced errors: Manual configuration changes in Kong can be prone to errors. Deck allows you to define your configuration declaratively, reducing the risk of typos or inconsistencies.
• Improved collaboration: Deck's declarative files make it easier for teams to collaborate on Kong configuration management. Everyone can see the desired state of the configuration in a single file.

• Backup and disaster recovery: Deck allows you to easily export your Kong configuration to a file. This file can be used to back up your configuration or restore it in case of a disaster.

• Simplified configuration management: Overall, Deck simplifies the process of managing Kong configurations by providing a centralized and automated approach. This can save time and effort for administrators.

Install Deck:

Want to get started with Deck?

The official installation guide is available here:

https://docs.konghq.com/deck/latest/installation/

As I am on Windows, here are the specific commands to install Deck:

download https://github.com/kong/deck/releases/download/v1.35.0/deck_1.35.0_windows_amd64.tar.gz
curl -sL https://github.com/kong/deck/releases/download/v1.35.0/deck_1.35.0_windows_amd64.tar.gz -o deck.tar.gz
mkdir deck
tar -xf deck_1.35.0_windows_amd64.tar.gz -C deck
powershell -command "[Environment]::SetEnvironmentVariable('Path', [Environment]::GetEnvironmentVariable('Path', 'User') + [IO.Path]::PathSeparator + [System.IO.Directory]::GetCurrentDirectory() + '\deck', 'User')"

Ready to see Deck in action? Let's try out some commands and see how they interact with Kong.

deck gateway ping:

deck gateway ping is a specific command used to verify connectivity between Deck and Kong's Admin API.

Now Let us create a service and a route.

Here's how to define a service in your Deck state file:

command:

curl -i -X POST --url http://localhost:8001/services/ --data 'name=Testing1' --data 'url=http://httpbin.org\get'

The Deck state file now includes the service definition for Kong.

Let's define a route in Kong.

curl -i -X POST --url http://localhost:8001/services/Testing1/routes --data 'name=Testing1_route' --data 'hosts[]=localhost:8000'

Perfect! With the route definition in your Deck state file.

deck gateway dump:

deck gateway dump --workspace default --output-file deck.yaml

What this command will do it?

The deck gateway dump command in Kong is used to export the entire configuration of your Kong Gateway instance into a local file. This file serves as a snapshot of your current Kong configuration, containing details about all entities like services, routes, plugins, consumers, and more.

There is a slight change in command which is described below.

• deck gateway dump: This specifies using the deck tool to perform a "dump" operation on your Kong Gateway configuration. Dumping refers to exporting the configuration data.

• --workspace default: This option (with the flag --workspace) defines the workspace you want to target for the dump operation. Here, it's set to "default," which likely refers to the default workspace used by Deck in your environment.

Workspaces are a Kong Gateway Enterprise feature that allows managing multiple configurations within the same Kong instance. If you're not using Kong Gateway Enterprise, this flag might be omitted.

• --output-file deck.yaml: This option (with the flag --output-file) specifies the destination for the dumped configuration. Here, it's set to a file named "deck.yaml." This tells Deck to write the exported configuration data in YAML format to the "deck.yaml" file.

The deck.yaml file containing our Kong configuration has been successfully saved to our local machine.

Checking the deck.yaml file confirms that the configuration for our Testing1 service has been successfully exported.

Service

Route

Let's modify some aspects of the Testing1 service and its route within the Deck state file.

The deck.yaml file has been updated! I've made some changes to the Testing1 service and route configuration, which are likely highlighted in yellow for clarity. Additionally, I've added a new path (/deck_testing) to the route definition.

I've refreshed the Kong Gateway, but the changes in the deck.yaml file don't seem to be reflected yet.

Service configuration:

Route configuration

Let's now switch gears and talk about the deck gateway diff command.

deck gateway diff:

The deck gateway diff command in Kong is a vital tool for understanding the discrepancies between your desired Kong configuration and its current state.

deck gateway diff essentially performs a dry run by comparing the configuration defined in your Deck state file with the actual configuration running on your Kong instance. It highlights any differences between:

• Existing entities: Services, routes, plugins, consumers, and other entities defined in Kong.

• Missing entities: Entities present in your Deck state file but not yet configured in Kong.

• Modified entities: Entities that have different properties in your Deck state file compared to the running Kong instance.

Benefits of using deck gateway diff:

• Prevents unintended changes: By identifying differences beforehand, you can avoid accidentally applying unwanted configuration changes to your Kong instance.

• Highlights configuration drift: It helps detect any manual modifications made directly to Kong's configuration, which can lead to inconsistencies with your desired state defined in the Deck file.

• Improves debugging: If you encounter issues with your Kong setup, deck gateway diff can help pinpoint discrepancies between your intended configuration and the actual state.

command:

deck gateway diff --workspace default

Thus, this command will create a service “Testing1_New” and route “Testing1_routeNew” which we had edited in the deck.yaml configuration file in the above steps.

Let's move on to step 4, where we'll use the deck gateway sync command

deck gateway sync:

The deck gateway sync command updates our Kong Gateway to reflect the settings we've defined in a separate file.

command:

deck gateway sync --workspace default deck.yaml

This command utilizes the deck tool to manage configurations in Kong Gateway and specifically targets a workspace and a state file. Let's break it down:

• deck gateway sync: This specifies using the deck tool to perform a "sync" operation on your Kong Gateway configuration. Sync refers to synchronizing the configuration with the state file.

• --workspace default: This option (with the flag --workspace) defines the workspace you want to target for the synchronization. Here, it's set to "default," which means Deck will focus on the default workspace within your Kong Gateway instance (if applicable). Workspaces are a Kong Gateway Enterprise feature for managing multiple configurations. If you're not using Kong Gateway Enterprise, this flag might be omitted.

• deck.yaml: This refers to the state file containing your desired Kong Gateway configuration. It likely resides in the current directory where you're running the command.

And now, if we sign in to Kong Manager, we can check whether or not the new route and service have been created.

Thus, it is evident that Kong has invented a new service and route.

deck gateway validate:

The deck gateway validate command acts as a quality check for your Kong Gateway configuration defined in a Deck state file. Here's a breakdown:

validate: This keyword indicates the action you want to perform, which is validation.

What deck gateway validate does:

Reads the State File: The command reads the configuration details entirely from the specified Deck state file.
Checks for Errors: It performs various checks on the configuration data within the file. Here are some potential validations:

a. Syntax Errors: Ensures the YAML or JSON format of the file is valid and free of any typos or syntax errors.

b. Missing References: Checks if all entities referenced in the configuration (e.g., a route referencing a specific service) actually exist in the state file itself. This helps identify potential configuration inconsistencies.

c. Internal Consistency: Validates if the configuration adheres to Kong's internal rules and logic. For example, checking if plugin configurations are compatible with the referenced services or routes.

command:

deck gateway validate --workspace default deck.yaml

deck gateway reset:

The deck gateway reset command in Kong is a powerful but potentially destructive operation. It's used to completely wipe out the existing configuration of our Kong Gateway instance.

What deck gateway reset does?

This command essentially deletes all entities (services, routes, plugins, consumers, etc.) currently configured in our Kong Gateway instance. It essentially resets Kong to a blank slate, removing any existing API definitions, access controls, or plugin configurations.

Important Considerations:

• Irreversible Action: Unlike some other deck commands, deck gateway reset is an irreversible operation. Once executed, there's no way to recover the previous configuration without backups.

• Use with Caution: Due to its destructive nature, it's crucial to use this command with extreme caution. It's recommended only for scenarios where you absolutely need to start fresh with a clean Kong Gateway configuration.

• Alternative Approaches: Depending on your situation, alternative approaches might be more suitable:

a. deck gateway sync with an empty state file: If we want to remove all configurations from Kong, we can create a blank Deck state file (containing no entities) and use deck gateway sync with that file. This achieves the same outcome as deck gateway reset but allows us to potentially recover from accidental execution by keeping the blank state file as a reference.

b. Manual Configuration Removal: For smaller deployments, we might consider manually removing configurations through the Kong Admin API or the Kong Gateway interface.

command:

deck gateway reset --workspace default deck.yaml

Deck documentation for Kong is available here: https://docs.konghq.com/deck/latest/

Conclusion:

This is an article about a tool called Deck. It helps manage Kong's configuration in a declarative way. Deck offers a variety of commands to accomplish this. Some of these commands help generate configuration files. Others help transform existing configurations. Still others help synchronize configurations with Kong. Overall, Deck seems to be a useful tool for managing Kong configurations.

Demystifying Dynamic URLs: How to Build Them with Kong

Deepanshu Pandey — Wed, 03 Apr 2024 09:38:56 +0000

A dynamic URL is a web address that can change based on certain factors, unlike a static URL that remains constant. It's like a customizable address that adjusts depending on what you're looking for on a website.

Here's a breakdown of how they work:

• Components: Dynamic URLs typically include a base URL and a query string. The base URL is the core address of the website, while the query string contains specific instructions or data separated by "?" and "&" symbols.

• Example: Imagine an online store. A static URL for a product might be https://www.example.com/shoes/red-sneakers. This works well for a single product.

But with dynamic URLs, things get more flexible. The URL could look like https://www.example.com/products?color=red&size=10. Here, "products" is the base URL, and the query string specifies "color=red" and "size=10".

Static vs. Dynamic URLs: Choosing the Right Path for Your Website

In the world of web development, URLs (Uniform Resource Locators) play a crucial role in directing users to specific content on your website. But not all URLs are created equal.

We have two main categories: static URLs and dynamic URLs. Understanding the differences between them is essential for building an efficient and user-friendly website.

Static URLs: The Simpler Sibling

Imagine a static URL as a clear street address. It points directly to a specific location on your website, like a particular page or file. These URLs are typically easy to remember and manage.

  Benefits of Static URLs:

• SEO Friendly: Search engines love static URLs because they're easy to crawl and understand. This can boost your website's ranking in search results.

• Simpler Management: Static URLs are straightforward to manage and cache, making them ideal for smaller websites with relatively fixed content.

    Drawbacks of Static URLs:

• Limited Flexibility: As your website grows, static URLs can become cumbersome. Imagine adding hundreds of products to an online store – each product would require a unique static URL, making maintenance a challenge.

• Content Updates: Updating information across multiple static pages with the same content can be time-consuming.

Dynamic URLs: Adapting to User Needs

Dynamic URLs, on the other hand, are more like interactive maps. They can change based on user input, database queries, or server-side logic. This allows for a more dynamic and adaptable website experience.

Advantages of Dynamic URLs:

• Flexibility is Key: Dynamic URLs excel at handling vast amounts of content with a single route. This is perfect for websites with large databases or frequently changing content.

• Personalized Experiences: By responding to user input, dynamic URLs can create a more personalized experience for each visitor. Imagine a news website displaying news relevant to your location or interests.

• Streamlined Management: Adding or updating content becomes easier with dynamic URLs. You don't need to create a new URL for each change – the dynamic system takes care of it.
Challenges of Dynamic URLs:

• Complexity: Setting up dynamic URLs can involve more configuration and management compared to static ones.

• SEO Considerations: While search engines have become adept at handling dynamic URLs, some SEO best practices need to be followed to ensure proper indexing.

So, Which URL Should You Choose?

The best choice depends on your website's specific needs:

• Static URLs: Ideal for simple websites with fixed content or where SEO is a top priority.

• Dynamic URLs: Perfect for websites with extensive content databases, user-generated content, or where personalization is important.

  Demystifying Dynamic Routing in Kong: A User-Centric Approach

At Kong, we frequently hear from customers and potential users about mastering dynamic routing based on URLs and headers. This blog post dives into various dynamic routing scenarios and explores how Kong empowers you to tackle them effectively.

The Essence of API Gateways:

An API gateway sits like a central hub, intelligently directing incoming requests to the appropriate backend service. In Kong, we represent these backend services as "Services”.

Services: The Backbone of Routing:

A Service object serves as the blueprint for an upstream API or service. Its core attribute is the URL, which defines where Kong should forward the traffic. This URL can be a simple string or a more granular configuration specifying protocol, host, port, and path components.

The Power of Dynamic Routing:

The default behavior is fantastic, but what if you need more flexibility? Dynamic routing in Kong allows you to go beyond static URLs and create routes that adapt based on specific elements within the URL and request headers. This unlocks a world of possibilities for managing complex API interactions.

   Next Steps:

In the following sections of this blog post, we'll delve into specific use cases for dynamic routing and showcase how Kong empowers you to implement them to create a robust and adaptable API layer.

Hands-on with Kong Manager: Configuring Dynamic Routing

Now, let's put theory into practice! We'll walk you through setting up dynamic routing in Kong Manager using an example.
Imagine we have an API named "Dynamic_url" that acts as a middleman, forwarding requests to an upstream service located at https://php-noise.com/noise.php

Logging In and Setting Up:

Access Kong Manager: Head to your Kong Manager dashboard and log in.
Choose Your Workspace: Here we need to specify the workspace. I'll be working in the default workspace.
Navigate to Services: Click on the "Services" tab to manage your backend services.
Adding a New Service: Within the "Services" section, locate the "Add a Service" button and click on it.

Instead of defining a specific path segment in the service itself, I'll simply use a forward slash ("/") for the path. This way, I can achieve more flexibility by specifying the actual upstream path later using the Request Transformer plugin.

Continuing Our Kong Manager Setup: Creating the Route
Now that we've created the "Dynamic_url" service representing our backend API, let's define a route within this service to handle dynamic routing. This route will tell Kong how to handle requests that include the path "/common".

Connecting the Dots with a Route:

Accessing the Dynamic_url Service: Within Kong Manager, find the "Dynamic_url" service we just created. Click on it to access its details.
Adding a Route: Look for a button or option labeled "Add Route" or something similar. Click on it to initiate the route creation process.
Naming the Route: Provide a descriptive name for your route. In this case, let's call it "Dynamic-Route" to reflect its purpose for testing dynamic routing.
Defining the Path: Locate the field labeled "Path(s)". Here, we'll specify the path segment that will trigger this route. Enter /common in this field.
Specifying the HTTP Method: In addition to defining the path, Kong routes also allow you to specify the HTTP method that the route handles. Since we're focusing on fetching data from the "Dynamic_url" service, we'll use the GET method.

Let's move forward with enhancing our Kong route by incorporating three plugins: Basic Authentication, ACL, and Request Transformer.

These plugins offer powerful functionalities to secure and manage your API traffic. Here's a breakdown of why each plugin is valuable:

Basic Authentication Plugin: Purpose: This plugin adds a layer of security by requiring users to provide valid credentials (username and password) before accessing the route. This helps restrict access to authorized users only.

Why Use It: Let say our "Dynamic_url" service handles sensitive data, implementing basic authentication ensures only authorized users can interact with it. This helps prevent unauthorized access attempts.

ACL (Access Control List) Plugin:

Purpose: The ACL plugin provides fine-grained control over who can access the route. You can define rules based on factors like consumer credentials, IP addresses, or custom attributes.

Why Use It: The ACL plugin goes beyond basic authentication by allowing you to create more granular access policies. You can define specific permissions for different users or groups, ensuring only those who meet the criteria can access the route.
Let's refine the explanation of the ACL plugin configuration in our Kong route to specify the allowed consumer group.

Focusing on the ACL Plugin:

Within the ACL plugin configuration for our route, we’ll be defining an access control rule that specifically allows access to consumers belonging to the group named "consumer1".

Why Consumer Group "consumer1"?
Assuming you have a mechanism for managing consumer groups in Kong, this configuration restricts access to the route for the "Dynamic_url" service to only those consumers who are explicitly assigned to the "consumer1" group. This provides a controlled access layer for your API.

Request Transformer Plugin: Purpose: This plugin allows you to modify the request before it's forwarded to the upstream service. You can manipulate headers, parameters, or even the request body.

Why Use It: The Request Transformer plugin offers flexibility in how you prepare requests before sending them upstream. You can use it to:

• Add or remove headers for specific purposes.

• Modify request parameters based on routing logic.

• Transform the request body to match the format expected by the upstream service.

Now, to dynamically determine the path forwarded to the upstream service, we'll configure the Request Transformer plugin to modify the request URI. We'll specify the upstream path as "/noise.php" within the plugin.

By strategically using these plugins in your Kong route, we can create a secure and well-managed API environment for your "Dynamic_url" service.

With a well-configured route and plugins in place, we need to define a consumer for this route. Think of a consumer as an entity that interacts with our Kong API. It could represent:

• An external application: This could be a mobile app, another web service, or any external system that needs to access your API through Kong.

• An internal application: Within your organization, different internal applications might require access to your API endpoints. Consumers allow you to manage access for each of these entities.

Consumer and Security Configuration
• Consumer "consumer1": We've created a consumer named "consumer1" in Kong. This consumer will represent the entity authorized to access the route.

• ACL Plugin and Consumer Allowance: Within the ACL plugin configuration for the route, we’ve established a rule that specifically allows access for the "consumer1" consumer. This ensures only "consumer1" can interact with this route based on our chosen access control policy.

• Basic Authentication User: An additional layer of security is implemented through basic authentication. I've created at least one basic authentication user (username and password combination). When the "consumer1" consumer attempts to access the route, it will need to provide valid credentials associated with this user to gain access.

Now that we've configured the route and security in Kong, it's time to test its functionality using Insomnia, a popular HTTP client.

We'll focus on testing without enabling dynamic path manipulation for now.

Test Results: Success!
That's fantastic! Our testing in Insomnia has yielded positive results:

• 200 OK Response: When we send a request to the route through Kong using Insomnia, we receive a 200 OK status code. This indicates successful communication and suggests Kong is functioning as expected, forwarding the request to the upstream service.

• Consistent Response from Upstream: Additionally, if we directly access the upstream URL (php-noise.com/noise.php) outside of Kong, we receive the same 200 OK response. This confirms that the upstream service itself is also operational and returning the expected response.

Testing the Local API (Static Parameters):
Now that we understand the functionality of the URL, let's move forward with testing it in Insomnia (or your preferred HTTP client) to verify its behavior. In this initial test, we'll focus on using the URL exactly as provided, without enabling dynamic routing features in Kong.

Here's what we're aiming to achieve:

• Sending a Request: Make a request to the complete URL: http://localhost:8000/common/noise.php?r=0&g=55&b=200&tiles=50&tileSize=7&borderWidth=0&mode=brightness&json

• Verifying Response: Observe the response from the script. Ideally, you should receive a 200 OK status code indicating successful communication. The response body should contain the generated noise data in JSON format, based on the parameters provided:

• Color: Red (r=0), Green (g=55), Blue (b=200)
• Tile layout: 50 tiles (tiles=50)
• Tile size: 7 pixels each (tileSize=7)
• No border (borderWidth=0)
• Brightness mode (mode=brightness)

By testing with the complete URL and its pre-defined parameters, we're establishing a baseline for the script's functionality without introducing dynamic elements through Kong. This will help us isolate any issues later when we incorporate dynamic routing.

While the current response isn't what we ultimately aim for, it's understandable as we haven't implemented dynamic routing in Kong. Let's move on to that step.

Enabling Dynamic Routing in Kong: Capturing the Path with (?\S*)

Now that we've established a baseline for the local script's functionality, let's move forward and enable dynamic routing in Kong. This will allow us to capture a dynamic part of the URL path and use it to construct the upstream path for requests.

Introducing the (?\S) Regular Expression:

The first step involves adding a regular expression (?\S*) to our Kong route configuration. Let's break down this expression and understand its purpose:

• (?: This part defines a capturing group named "path". Captured values within this group will be accessible later using the name "path".

• \S*: This matches any sequence of non-whitespace characters (zero or more times). This captures the dynamic portion of the URL path that follows the static /common segment.

Incorporating Captured Path into Upstream Path: Using $(uri_captures['path']) in Request Transformer
Now that we've captured the dynamic path segment using the regular expression in the route, let's see how to utilize it to construct the upstream path dynamically. This is where the Request Transformer plugin and the expression $(uri_captures['path']) come into play.

Understanding $(uri_captures['path']):

• Accessing Captured Values: This expression acts as a placeholder within the Request Transformer plugin to access values captured by named groups in regular expressions within your routes.

• Referencing the "path" Group: Specifically, $(uri_captures['path']) references the value captured by the "path" group in your route's regular expression.
Dynamic Path Construction:

Here's how this works in action:

• Request Arrival: A request with a path like /common/data456 arrives at Kong.

• Capturing Path Value: The route captures data456 in the "path" group.

• Plugin Transformation: The Request Transformer plugin takes over. It replaces the static path in the request with a new path constructed using $(uri_captures['path']).

• Dynamic Path Formation: The plugin replaces $(uri_captures['path']) with the actual captured value (data456), resulting in a new path, likely /noise.php in our case.

Ready to Test with Dynamic Routing!

With dynamic routing now enabled in Kong, we've reached an exciting stage. The regular expression in your route captures dynamic path segments, and the Request Transformer plugin utilizes $(uri_captures['path']) to construct the upstream path based on the captured value.

Time for Insomnia Testing (Round 2):

Let's revisit Insomnia and test the same API again:

http://localhost:8000/common/noise.php?r=0&g=55&b=200&tiles=50&tileSize=7&borderWidth=0&mode=brightness&json

Success! Dynamic Routing Delivers!

That's fantastic news! By testing the API again in Insomnia we're now receiving the expected response.

This successful test demonstrates that we've effectively implemented dynamic routing in Kong. Now, our API can handle requests with various path segments after "/common" and route them appropriately to our noise.php script for processing.

Insomnia Test Round 3: Exploring Additional Parameters

Now, let's move on to round 3 of testing in Insomnia to explore how the API handles additional parameters:

New API:
http://localhost:8000/common/noise.php?hex=${hex}&json&base64

Excellent! The successful response from the API confirms that our dynamic routing configuration in Kong is functioning flawlessly.

Conclusion: Mastering Dynamic Routing with Kong

In this post, we've explored how to leverage Kong's dynamic routing capabilities to achieve flexible API routing. We started by establishing a baseline for a local script (noise.php) that generates visual noise data. Then, we configured Kong to dynamically handle requests with varying path segments:

• Capturing Dynamic Paths: We utilized a regular expression in the route definition to capture dynamic portions of the URL path after a static prefix.

• Request Transformation: The Request Transformer plugin played a crucial role. It dynamically modified the upstream path within the request based on the captured value using $(uri_captures['path']). This allowed Kong to route requests to the appropriate upstream service (noise.php) regardless of the specific path segment used.

Benefits of Dynamic Routing:

• Flexibility: Dynamic routing allows you to handle a wider range of URL structures within your API without requiring separate routes for each variation.

• Maintainability: By using a single route with dynamic path capturing, you simplify Kong configuration and reduce the need for managing numerous static routes.

• Control Over Upstreams: The captured path segment can be used not only for routing but also for manipulating other aspects of the request before forwarding it to the upstream service.