Building a Scalable API Gateway with Kong, Node.js, and TypeScript

APIs are the backbone of modern applications, and as your application grows, managing API traffic, security, and scalability becomes increasingly important. That’s where Kong, a powerful API gateway, comes in. In this post, I’ll walk you through how to set up a scalable backend using Kong, Node.js, TypeScript, and Hono.

Whether you’re building a new project or looking to improve your existing API infrastructure, this guide will help you get started with a modern and maintainable architecture.

Why Kong?

Kong is an open-source API gateway that simplifies API management. It acts as a reverse proxy, handling tasks like:

• Routing: Directing requests to the appropriate backend services.
• Rate Limiting: Controlling traffic to prevent abuse.
• Authentication: Securing your APIs with plugins.
• Logging and Monitoring: Keeping track of API usage.

By using Kong, you can focus on building your application while Kong takes care of the heavy lifting for API management.

Project Overview

This project demonstrates how to:

• Build a backend with Node.js and TypeScript.
• Use Hono, a lightweight web framework, to define API routes.
• Implement dependency injection with Awilix for better modularity.
• Configure Kong to manage API traffic and apply rate limiting.

The source code for this project is available on GitHub. Feel free to clone it and follow along!

Setting Up the Project

Prerequisites

Before diving in, make sure you have the following installed:

• Node.js (LTS version recommended)
• Docker (for running Kong)
• PNPM (a fast package manager)

Installation Steps

1. Clone the repository:

   git clone https://github.com/mikeeggertsen/kong-example.git
   cd kong-example

2. Install dependencies:

   pnpm install

3. Set up your environment variables by creating a .env file:

   cp .env-example .env

4. Update the .env file with your desired configuration, such as the port number:

   PORT=3000

Running the Application

Development Mode

Build and start the kong development service

docker compose -f docker-compose-dev.yml -d up

Then start the application in development mode:

pnpm run dev

You are then able to access the backend either through the Kong API Gateway at http://localhost:8000 or directly at http://localhost:3000

Production Mode

For production, build and start the application:

docker compose -f docker-compose.yml -d up

Once the services are up, you can access the application only through the Kong API Gateway at http://localhost:8000

Exploring the API

The application includes two simple endpoints:

• GET /hello-world: Returns a "Hello World" message.
• GET /health: Returns a health check response (OK).

When using port 8000 these endpoints are routed through Kong, which acts as the API gateway.

Configuring Kong

The kong.yml file defines how Kong routes traffic and applies plugins. Here’s an example configuration:

_format_version: "3.0"
 
services:
  - name: backend-service
    url: http://host.docker.internal:3000
    routes:
      - name: backend-routes
        strip_path: false
        paths:
          - /api
 
plugins:
  - name: rate-limiting
    service: backend-service
    config:
      minute: 10
      policy: local

What This Does:

1. Routes: Kong forwards requests from /api to the backend service running on port 3000.
2. Rate Limiting: Limits requests to 10 per minute for the /api route.

This setup ensures that your API is both accessible and protected from abuse.

Key Technologies Used

1. Hono

Hono is a fast, lightweight web framework that’s perfect for building APIs. It’s modern, minimal, and works seamlessly with TypeScript.

2. Awilix

Awilix provides dependency injection, making your codebase modular and easier to test. It allows you to register controllers, services, and repositories as singletons in a DI container.

3. TypeScript

TypeScript adds type safety to your code, reducing runtime errors and improving developer productivity.

Why This Architecture?

This architecture is designed for scalability and maintainability. By combining Kong with a modular backend built in Node.js and TypeScript, you get:

• Scalability: Kong handles API traffic efficiently, even as your user base grows.
• Security: Kong’s plugins provide features like authentication and rate limiting.
• Maintainability: Dependency injection and TypeScript make the codebase easier to manage and extend.

Final Thoughts

Building a scalable API gateway doesn’t have to be complicated. With Kong, Node.js, and TypeScript, you can create a robust backend that’s easy to manage and extend. Whether you’re just starting out or looking to improve your existing API infrastructure, this setup provides a solid foundation.

If you’re interested in trying it out, check out the GitHub repository. I’d love to hear your thoughts and feedback.

Happy coding!

Tags

Kong, API Gateway, Node.js, TypeScript, Hono, Awilix, Docker