Instalación de la Puerta de API Kong

Kong es una puerta de API de código abierto ampliamente utilizada, construida sobre Nginx, que proporciona una plataforma escalable para gestionar APIs, microservicios y aplicaciones. La arquitectura basada en complementos de Kong permite autenticación, limitación de velocidad, CORS, transformación de solicitud/respuesta y más. Esta guía cubre instalación basada en Docker y paquetes, configuración de servicios y rutas, complementos esenciales, uso de API de administración, y la herramienta de configuración declarativa deck.

¿Qué es Kong

Kong es una puerta de API y capa de gestión de microservicios que simplifica la arquitectura de aplicaciones al:

Enrutar solicitudes a microservicios apropiados
Aplicar autenticación y autorización
Limitación de velocidad y configuración de tráfico
Versionado de API y transformaciones
Monitoreo y registro

Kong funciona como una capa de proxy inverso, ubicada entre clientes y servicios backend.

Requisitos del Sistema

Asegúrese de que su sistema cumpla con:

Kernel de Linux 3.10 o superior
512 MB de RAM mínimo (2 GB recomendado)
PostgreSQL 9.5+ o Cassandra 3.11+ para almacenamiento de datos
100 MB de espacio en disco para el binario de Kong
Acceso de red a la base de datos y servicios backend

Instalación con Docker

El método de implementación más simple para Kong utiliza Docker y Docker Compose. Cree un docker-compose.yml:

version: '3.8'

services:
  postgres:
    image: postgres:15-alpine
    restart: always
    environment:
      POSTGRES_DB: kong
      POSTGRES_USER: kong
      POSTGRES_PASSWORD: kong_secure_password_123
    ports:
      - "5432:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD", "pg_isready", "-U", "kong"]
      interval: 10s
      timeout: 5s
      retries: 5

  kong-migration:
    image: kong:3.4-alpine
    command: kong migrations bootstrap
    depends_on:
      postgres:
        condition: service_healthy
    environment:
      KONG_DATABASE: postgres
      KONG_PG_HOST: postgres
      KONG_PG_USER: kong
      KONG_PG_PASSWORD: kong_secure_password_123
      KONG_PG_DATABASE: kong

  kong:
    image: kong:3.4-alpine
    restart: always
    depends_on:
      - kong-migration
    ports:
      - "8000:8000"  # Proxy
      - "8443:8443"  # Proxy SSL
      - "8001:8001"  # Admin API
      - "8444:8444"  # Admin API SSL
    environment:
      KONG_DATABASE: postgres
      KONG_PG_HOST: postgres
      KONG_PG_USER: kong
      KONG_PG_PASSWORD: kong_secure_password_123
      KONG_PG_DATABASE: kong
      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_LOG_LEVEL: info

  konga:
    image: pantsel/konga:latest
    restart: always
    depends_on:
      - kong
    ports:
      - "1337:1337"
    environment:
      NODE_ENV: production
      DB_ADAPTER: postgres
      DB_HOST: postgres
      DB_USER: kong
      DB_PASSWORD: kong_secure_password_123
      DB_DATABASE: konga

volumes:
  postgres_data:

networks:
  default:
    name: kong_network

Implementar Kong:

docker-compose up -d

Verifique que Kong está ejecutándose:

curl http://localhost:8001

Acceda al panel de control de Konga en http://localhost:1337

Instalación desde Gestor de Paquetes

Para Ubuntu/Debian:

curl https://repo.konghq.com/gpg.key | sudo apt-key add -
echo "deb https://repo.konghq.com/ubuntu/ $(lsb_release -sc) main" | sudo tee /etc/apt/sources.list.d/kong.list
sudo apt update
sudo apt install kong

Para RHEL/CentOS:

curl https://repo.konghq.com/rpm/el7/[email protected] | sudo yum install -
sudo yum install kong

Cree el archivo de configuración de Kong /etc/kong/kong.conf:

database = postgres
pg_host = localhost
pg_port = 5432
pg_user = kong
pg_password = kong_secure_password_123
pg_database = kong

proxy_listen = 0.0.0.0:8000, 0.0.0.0:8443 ssl
admin_listen = 127.0.0.1:8001

ssl_cert = /etc/kong/ssl/kong.crt
ssl_cert_key = /etc/kong/ssl/kong.key

log_level = notice

Ejecute migraciones:

kong migrations bootstrap -c /etc/kong/kong.conf

Inicie Kong:

kong start -c /etc/kong/kong.conf

Configuración de Base de Datos

Cree la base de datos y usuario de PostgreSQL:

sudo -u postgres psql <<EOF
CREATE USER kong WITH PASSWORD 'kong_secure_password_123';
CREATE DATABASE kong OWNER kong;
GRANT ALL PRIVILEGES ON DATABASE kong TO kong;
EOF

O utilizando las migraciones de Kong:

kong migrations bootstrap -c /etc/kong/kong.conf

Descripción General de Configuración

Conceptos principales de Kong:

Servicios: Servicios backend o microservicios
Rutas: Caminos u hosts que se asignan a servicios
Complementos: Agregan funcionalidad como autenticación, limitación de velocidad
Consumidores: Consumidores de API o usuarios
Credenciales: Claves de API o credenciales de autenticación

Configuración de Servicios

Cree un servicio a través de la API de Administración de Kong:

curl -X POST http://localhost:8001/services \
  -H "Content-Type: application/json" \
  -d '{
    "name": "web-service",
    "url": "http://192.168.1.100:8000"
  }'

Actualice un servicio:

curl -X PATCH http://localhost:8001/services/web-service \
  -H "Content-Type: application/json" \
  -d '{
    "url": "http://192.168.1.100:8001"
  }'

Liste servicios:

curl http://localhost:8001/services

Cree múltiples servicios:

curl -X POST http://localhost:8001/services \
  -H "Content-Type: application/json" \
  -d '{"name": "api-service", "url": "http://192.168.1.110:8080"}'

curl -X POST http://localhost:8001/services \
  -H "Content-Type: application/json" \
  -d '{"name": "blog-service", "url": "http://192.168.1.120:3000"}'

Configuración de Rutas

Cree una ruta que apunte a un servicio:

curl -X POST http://localhost:8001/services/web-service/routes \
  -H "Content-Type: application/json" \
  -d '{
    "name": "web-route",
    "paths": ["/"],
    "methods": ["GET", "POST", "PUT", "DELETE"]
  }'

Cree rutas con coincidencia de host:

curl -X POST http://localhost:8001/services/api-service/routes \
  -H "Content-Type: application/json" \
  -d '{
    "name": "api-route",
    "hosts": ["api.example.com"],
    "paths": ["/api"]
  }'

curl -X POST http://localhost:8001/services/blog-service/routes \
  -H "Content-Type: application/json" \
  -d '{
    "name": "blog-route",
    "hosts": ["blog.example.com"],
    "paths": ["/"]
  }'

Actualice una ruta:

curl -X PATCH http://localhost:8001/services/web-service/routes/web-route \
  -H "Content-Type: application/json" \
  -d '{
    "strip_path": true,
    "preserve_host": true
  }'

Gestión de Complementos

Liste complementos disponibles:

curl http://localhost:8001/plugins/enabled

Habilite un complemento globalmente:

curl -X POST http://localhost:8001/plugins \
  -H "Content-Type: application/json" \
  -d '{
    "name": "cors",
    "config": {
      "origins": ["*"],
      "methods": ["GET", "POST", "PUT", "DELETE"],
      "headers": ["Content-Type", "Authorization"],
      "exposed_headers": ["X-Total-Count"]
    }
  }'

Habilite complemento en un servicio:

curl -X POST http://localhost:8001/services/api-service/plugins \
  -H "Content-Type: application/json" \
  -d '{
    "name": "cors",
    "config": {
      "origins": ["https://example.com"]
    }
  }'

Habilite complemento en una ruta:

curl -X POST http://localhost:8001/services/web-service/routes/web-route/plugins \
  -H "Content-Type: application/json" \
  -d '{
    "name": "request-transformer",
    "config": {
      "add": {
        "headers": ["X-Custom-Header:custom-value"]
      }
    }
  }'

Complementos de Autenticación

Cree un consumidor:

curl -X POST http://localhost:8001/consumers \
  -H "Content-Type: application/json" \
  -d '{"username": "app-client", "custom_id": "app-123"}'

Habilite complemento de autenticación básica:

curl -X POST http://localhost:8001/services/api-service/plugins \
  -H "Content-Type: application/json" \
  -d '{"name": "basic-auth"}'

Agregue credenciales de autenticación básica:

curl -X POST http://localhost:8001/consumers/app-client/basic-auth \
  -H "Content-Type: application/json" \
  -d '{"username": "api_user", "password": "secure_password"}'

Habilite complemento de autenticación por clave:

curl -X POST http://localhost:8001/services/api-service/plugins \
  -H "Content-Type: application/json" \
  -d '{"name": "key-auth", "config": {"key_names": ["apikey"]}}'

Agregue una clave de API:

curl -X POST http://localhost:8001/consumers/app-client/key-auth \
  -H "Content-Type: application/json" \
  -d '{"key": "super-secret-apikey-12345"}'

Pruebe la autenticación por clave de API:

curl -H "apikey: super-secret-apikey-12345" http://localhost:8000/api/

Habilite OAuth 2.0:

curl -X POST http://localhost:8001/services/api-service/plugins \
  -H "Content-Type: application/json" \
  -d '{"name": "oauth2", "config": {"mandatory_scope": true, "enable_implicit_grant": true}}'

Complemento de Limitación de Velocidad

Habilite el complemento de limitación de velocidad:

curl -X POST http://localhost:8001/services/api-service/plugins \
  -H "Content-Type: application/json" \
  -d '{
    "name": "rate-limiting",
    "config": {
      "minute": 100,
      "hour": 10000,
      "policy": "local",
      "fault_tolerant": true,
      "hide_client_headers": false
    }
  }'

Aplique límites diferentes por consumidor:

curl -X POST http://localhost:8001/consumers/app-client/plugins \
  -H "Content-Type: application/json" \
  -d '{
    "name": "rate-limiting",
    "config": {
      "minute": 500,
      "hour": 50000
    }
  }'

Habilite limitación de velocidad de respuesta:

curl -X POST http://localhost:8001/services/api-service/plugins \
  -H "Content-Type: application/json" \
  -d '{
    "name": "response-ratelimiting",
    "config": {
      "limits": {
        "default": {"minute": 1000}
      }
    }
  }'

API de Administración

Liste todas las rutas:

curl http://localhost:8001/routes

Obtenga detalles de una ruta específica:

curl http://localhost:8001/routes/web-route

Elimine una ruta:

curl -X DELETE http://localhost:8001/routes/web-route

Elimine un servicio:

curl -X DELETE http://localhost:8001/services/web-service

Obtenga el estado de salud:

curl http://localhost:8001/status

Configuración Declarativa con Deck

Instale deck:

curl -sL https://github.com/kong/deck/releases/download/v1.28.0/deck_1.28.0_linux_amd64.tar.gz | tar xz -C /usr/local/bin

Cree un archivo de configuración de Kong kong.yaml:

_format_version: "3.0"
_info:
  title: My API Gateway
  description: Production API Gateway Configuration
  version: 1.0.0

services:
  - name: web-service
    url: http://192.168.1.100:8000
    routes:
      - name: web-route
        paths:
          - /
        strip_path: false

  - name: api-service
    url: http://192.168.1.110:8080
    routes:
      - name: api-route
        hosts:
          - api.example.com
        paths:
          - /api
    plugins:
      - name: rate-limiting
        config:
          minute: 100
          hour: 10000
      - name: basic-auth

  - name: blog-service
    url: http://192.168.1.120:3000
    routes:
      - name: blog-route
        hosts:
          - blog.example.com

plugins:
  - name: cors
    config:
      origins:
        - "*"
      methods:
        - GET
        - POST
      headers:
        - Content-Type
        - Authorization

consumers:
  - username: app-client
    basic_auth:
      - username: api_user
        password: secure_password
    key_auth:
      - key: super-secret-apikey

Sincronice la configuración con Kong:

deck sync -s kong.yaml

Valide la configuración sin aplicar:

deck validate -s kong.yaml

Vuelque la configuración actual de Kong:

deck dump > current-kong.yaml

Solución de Problemas

Compruebe el estado del servicio Kong:

systemctl status kong
journalctl -u kong -f

Verifique que Kong está respondiendo:

curl -v http://localhost:8001
curl -v http://localhost:8000

Compruebe la conectividad de la base de datos:

curl http://localhost:8001/status

Revise los registros de Kong:

tail -f /var/log/kong/error.log
tail -f /var/log/kong/access.log

Pruebe el enrutamiento de servicios:

curl -H "Host: api.example.com" http://localhost:8000/api/test

Depure complementos:

curl http://localhost:8001/plugins
curl http://localhost:8001/services/api-service/plugins

Conclusión

Kong proporciona una plataforma de puerta de API flexible y escalable con una potente arquitectura de complementos para autenticación, limitación de velocidad, transformación y monitoreo. Ya sea implementando mediante Docker Compose o gestores de paquetes, Kong simplifica la gestión de API y la orquestación de microservicios. La combinación de la API de Administración para configuración programática y Deck para gestión declarativa garantiza operaciones flexibles a escala.

Instalación de la puerta de API Kong