API gateways with Kong, will it make your project strong?

Martijn Lankhof, 8-10-2021.

De DevOps cultuur maakt veel gebruik van microservices. Dit zorgt ervoor dat een client applicatie met veel verschillende API's moet praten om alle benodigde informatie te ontvangen. Maar wat als er meer services bijkomen of bestaande services veranderen? Dit kan erg snel complex en veel werk worden voor de client. Hierbij kunnen *API gateways* een rol spelen. Dit onderzoek beantwoordt de vraag: "Hoe kan een API gateway met KONG geïmplementeerd worden in een microservice systeem?"

Deze vraag wordt beantwoord met behulp van de volgende deelvragen.

  • Wat is een API gateway?
  • Wat zijn de voor- en nadelen van een API gateway?
  • Waarvoor kan je Kong gebruiken?
  • Hoe kan met behulp van Kong een API gateway gemaakt worden in Docker?

Bij het beantwoorden van deze vragen gebruik ik de onderzoeksmethodes uit het ICT Research Methods Pack. (Han, z.d.) onder andere de methodes Literature study (Library) en Prototyping (Workshop).

Wat is een API gateway?

Client applicaties moeten met veel verschillende API's praten. Dit kan erg snel complex worden. Om dit eenvoudiger te maken wil je dat de client maar met een API praat. Dit is precies wat een API gateway doet.

Een API gateway zit tussen de client en de services in en handelt als een reverse-proxy. Een API gateway is een single point of entry naar je services. Dit zorgt ervoor dat API design, management en implementatie makkelijker en consistenter is. (Gadge & Kotwani, 2017)

Daarbij kan een API gateway ook gemeenschappelijke taken afhandelen. Denk hierbij aan authenticatie of rate limiting. Daarnaast zorgt een API gateway ook voor decoupling tussen clients en services. De client hoeft niks te weten over welke individuele services er zijn. (Microsoft, 2018)

Gateway

Voor- en nadelen

Het gebruiken van een API gateway heeft verschillende voor- en nadelen.

Doordat een API gateway tussen de front en back end in zit zorgt dit voor een extra laag of barrière voor de services. Hierdoor kan een API gateway services beschermen tegen verschillende soorten aanvallen zoals DoS en SQL injection (“Why Use API Gateway? Pros & Cons | Knowledge Base”, 2021).

Zoals eerder genoemd kan een API gateway gemeenschappelijke taken uitvoeren zoals: rate limiting, user access control en token authentication. Dit heeft als voordeel dat je dit maar een keer hoeft te implementeren. Daarnaast kunnen services dan focussen op hun taak en verspillen deze geen tijd aan randzaken waardoor de services ook minder complex worden (Microsoft, 2018).

Naast deze voordelen heeft het ook nadelen. Een API gateway zorgt voor een single point of entry. (Gadge & Kotwani, 2017) Dit betekent gelijk ook dat er een single point of failure ontstaat.

Het configureren van het systeem om gebruik te maken van de API gateway zorgt voor extra complexiteit voor developers (“Why Use API Gateway? Pros & Cons | Knowledge Base”, 2021).

De snelheid van het systeem wort beperkt door de snelheid van de API gateway (“Why Use API Gateway? Pros & Cons | Knowledge Base”, 2021).

Wat is KONG?

“Kong provides a flexible abstraction layer that securely manages communication between clients and microservices via API. Also known as an API Gateway.” (Faren, 2019)

Met Kong zet je dus een API gateway op. Kong biedt verschillende mogelijkheden om een API gateway te gebruiken. Onder andere voor Docker en Kubernetes (Kong Inc, 2021).

Een voordeel van een API gateway is het uitvoeren van gemeenschappelijke taken. Dit maakt Kong zeer eenvoudig. Doormiddel van plugins kun je extra functionaliteiten toevoegen aan Kong. (Faren, 2019) Zie: https://docs.konghq.com/hub voor een overzicht van de mogelijke plugins.

Kong

Kong in Docker

Een voor de hand liggende optie om Kong lokaal te gebruiken is Docker. Kong maakt dit ook erg eenvoudig aangezien Kong een Docker image beschikbaar stelt (https://hub.docker.com/_/kong/). Om in dit onderzoek Kong te testen gebruik ik twee simpele test API's. Deze zijn terug te vinden in deze repository.

Docker compose

Om Kong in combinatie met deze API's te laten werken gebruik ik een docker-compose.yml bestand. Allereerst moet je een network opgeven.

version: '3'

networks:
  default:
    name: kong-network

Vervolgens voeg je Kong als service. Hierbij vallen een paar aspecten op bij environment. Zo staat hier KONG_DATABASE. Kong kan de configuratie wel of niet opslaan in een database. In dit onderzoek kies ik ervoor geen gebruik te maken van de database om het simpel te houden. Dit betekent dat je een kong.yml bestand gebruikt voor de configuratie. De locatie hiervoor geef je aan met KONG_DECLARATIVE_CONFIG:. Hierbij gebruik je een volume zodat Kong de kong.yml kan vinden. De log variabelen zijn er alleen zodat Kong weet waar de log heen moet, dit is handig voor debuggen.

services:

  kong:
    image: kong:2.5.0-alpine
    hostname: kong
    container_name: kong
    environment:
      KONG_DATABASE: 'off'
      KONG_PROXY_ACCESS_LOG: '/dev/stdout'
      KONG_ADMIN_ACCESS_LOG: '/dev/stdout'
      KONG_PROXY_ERROR_LOG: '/dev/stderr'
      KONG_ADMIN_ERROR_LOG: '/dev/stderr'
      KONG_ADMIN_LISTEN: "0.0.0.0:8001"
      KONG_DECLARATIVE_CONFIG: "/opt/kong/kong.yml"
    command: "kong start"
    ports:
      - "8000:8000"
      - "8001:8001"
    volumes:
      - ./config:/opt/kong

KONG_ADMIN_LISTEN: "0.0.0.0:8001" geeft aan welke poort Kong gebruikt. Hierbij valt op dat er twee poorten staan bij ports. Port 8001 is de admin port, deze gebruik je voor informatie over Kong. Port 8000 is de port de je gebruikt voor de API's.

  test-api-een:
    image: kong-docker/test-api-een:1.0
    build: ./test-api-een
    hostname: api-een
    container_name: api-een

  test-api-twee:
    image: kong-docker/test-api-twee:1.0
    build: ./test-api-twee
    hostname: api-twee
    container_name: api-twee

Vervolgens voeg je de API's toe. Hiervoor configureer je geen ports aangezien Kong dit regelt binnen het Docker netwerk.

kong.yml

Nadat je de docker-compose hebt gemaakt kan je Kong configureren. Dit is zeer eenvoudig. In het kong.yml bestand geef je de services aan. Hierbij geef je de de naam van de services aan, de url en routes.

De url is de hostname uit de docker-compose gevolgd door de port.

Bij de routes geef je aan welk path je gebruikt. In het voorbeeld heeft api-een het path /een. Dit betekent dat je deze api benadert via {hostname}:8000/een (bijv. localhost:8000/een).

_format_version: "2.1"
_transform: true

services:
  - name: api-een
    url: http://api-een:5000
    routes:
    - name: test-api-een
      paths:
       - /een
      strip_path: true

  - name: api-twee
    url: http://api-twee:5001
    routes:
    - name: test-api-twee
      paths:
       - /twee
      strip_path: true

Plugins

Kong maakt het erg eenvoudig om plugins toe te voegen. Deze configureer je ook in de kong.yml. Om dit te testen heb ik een rate-limiter plugin (https://docs.konghq.com/hub/kong-inc/rate-limiting) toegevoegd aan de configuratie.

plugins:
- name: rate-limiting
  config: 
    minute: 5
    policy: local

Dit is erg eenvoudig omdat je alleen de name opgeeft en dan de configuratie van de plugin. De limit per minuut staat op 5 om dit makkelijk te kunnen testen.

Uitvoeren in Docker

Vervolgens start je de API met de bekende commando's:

docker-compose build
docker-compose up -d

Na het uitvoeren van deze commando's is in de onderstaande afbeeldingen te zien dat kong werkt zoals verwacht.

API eenAPI twee
root api eenroot api twee
test api eentest api twee

Kong error

Conclusie

Uit het onderzoek blijkt dat een API gateway tussen de client en de services in staat. Zo zorgt de gateway voor een single point of entry. Hierdoor praat de client maar met een API i.p.v. voor elke service een andere API. Dit maakt het voor de client veel minder complex.

Dit heeft een aantal voordelen. Zo geeft een API gateway extra beveiliging en kan de gateway gemeenschappelijke taken uitvoeren. Dit maakt de services gelijk minder complex en deze kunnen focussen op hun taak.

Echter, door de single point of entry is er ook een single point of failure. Dit is een van de belangrijkste nadelen van een API gateway.

Om een API gateway toe te voegen aan een systeem kan je Kong gebruiken. Kong biedt veel functionaliteit waardoor het erg makkelijk te gebruiken is. Zo kan je ook makkelijk extra functionaliteit toevoegen met plugins.

De uitgevoerde demo applicatie ondersteunt dit. Uit de demo app blijkt dat je met Kong inderdaad eenvoudig een API gateway op kan zetten in Docker. Hiervoor moet je de Kong image toevoegen in de docker-compose.yml. Daarnaast voeg je de services en plugins toe aan de configuratie van Kong in een kong.yml. Kong maakt dit zeer overzichtelijk en dit was daarom makkelijk toe te passen.

Concluderend kan je met Kong een API gateway eenvoudig implementeren in een microservice systeem.

Bronnen

Last change: 2025-01-13