Ya anteriormente hemos hablado de API Kong en varias ocasiones, por ejemplo: Reference Architectures Kubernetes o Microservicios usando API Gateway Kong. Hoy vendremos a presentar un caso Real donde de manera muy fácil y rápida podremos tener una API construída con Python Flask en pocos minutos con un key-auth mediante API Kong Gateway.

Veamos brevemente el índice de pasos a seguir:

• Construiremos dos Docker: uno con el software de API Kong y otro con un PostgreSQL para hacerle de base de datos.
• Construiremos un Docker con nuestra API desarrollada en Python mediante el framework Flask.
• Configuraremos y Validaremos la conexión contra la API creada anteriormente mediante API Kong que actuará como Proxy.

Instalación de API Kong + PostgreSQL Database

Para hacerlo fácil, lanzamos dos Docker con la exposición de los puertos y los distintos “environment” para realizar mediante Docker las conexiones de visibilidad, para ello lanzaremos primero la base de datos:

sudo docker run -d --name kong-database -p 5432:5432 -e "POSTGRES_USER=kong" -e "POSTGRES_DB=kong" postgres:9.5

Y seguidamente, el docker con el API Kong:

sudo docker run -d --name kong --link kong-database:kong-database -e KONG_DATABASE=postgres -e KONG_PG_HOST=kong-database -p 8000:8000 -p 8443:8443 -p 8001:8001 -p 7946:7946 -p 7946:7946/udp kong:0.10.1

Si todo va bien, podremos validar el correcto funcionamiento accediendo vía URL a la configuración: http://IP_HOSTNAME:8001 y nos devolverá unos resultados “by default”.

NOTA: Para hacer la administración de Kong más simple, podemos instalarnos Kongdash.

Creando nuestra API con Flask

Antes que nada, tendremos un par de premisas en consideración que son:

• Utilizaremos una base de datos de muestra, de SQL Lite para simplificar, la podéis encontrar en: http://www.sqlitetutorial.net/sqlite-sample-database/
• Desplegaremos el código de forma local en nuestra instancia principal de Docker para que se puedan construir rápidamente los contenedores a partir de él.

Primero de todo crearemos nuestra “App” con Flask y para ello, en un directorio de trabajo cualquiera, crearemos esta estructura de directorios y ficheros:

• ../requeriments.txt
• ../Dockerfile
• ../app

Accediento al directorio app crearemos el fichero app.py con un contenido de ejemplo como:

from flask import Flask, request, jsonify
from flask_restful import Resource, Api
from sqlalchemy import create_engine
from json import dumps
import hashlib

e = create_engine('sqlite:///chinook.db')  # loads database into memory

app = Flask(__name__)
api = Api(app)  # GET, POST, etc functionally

class artists(Resource):
    def get(self):
        conn = e.connect() # db connection
        query = conn.execute("select artistid, name from artists;")
        result = {'data': [dict(zip(tuple (query.keys()) ,i)) for i in query.cursor]}
        return jsonify(result) # format results in json format

class tracks(Resource):
    def get(self):
        conn = e.connect() # db connection
        query = conn.execute("select trackid, name, composer, unitprice from tracks;")
        result = {'data': [dict(zip(tuple (query.keys()) ,i)) for i in query.cursor]}
        return jsonify(result) # format results in json format

api.add_resource(artists, '/artists')  # bind url identifier to class
api.add_resource(tracks, '/tracks')  # bind url identifier to class

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=80)

Volviendo al directorio principal de nuestra API, crearemos el fichero requirements.txt con el siguiente contenido:

flask==1.0.2
flask-restful
sqlalchemy

Básicamente son las librerías que pediremos a Docker instale antes de arrancar nuestra aplicación en Flask. Siguiendo en el mismo directorio, crearemos el fichero Dockerfile con el siguiente contenido:

FROM python:3
WORKDIR /usr/src/app
COPY requirements.txt ./
RUN pip install --no-cache-dir -r requirements.txt
COPY app .
ENV FLASK_APP=app.py
CMD [ "python", "./app.py" ]

Éste será el documento de soporte para el Docker Build, aquí tiene las instrucciones para poder crear una imágen con nuestra aplicación en Flask y los requerimientos a instalar durante la construcción de la misma.

Una vez creado el fichero, lanzaremos, en dos pasos, la creación de la imagen y el contenedor con la misma:

Build the docker Image

sudo docker build -t flask-sample-one:latest .

Run the Docker Container

sudo docker run -d --name api-flask -p 80:80 flask-sample-one

Si todo va bien, tendremos el contenedor creado con nombre “api-flask” y junto a los dos anteriores: “kong-database” y “kong”.

Configuraremos y Validación de API Kong Gateway

Para hacerlo más visual y utilizando Kongdash, mostramos a continuación la creación de la API proxy, la creación del primer usuario con su “apikey” y, finalmente, la validación de la API ya aplicando la seguridad:

Bien, llegados a éste punto, podemos decir que ya tenemos un API Gateway configurado y funcionando, podremos validarlo mediante un navegador: http://IP_HOSTNAME:8000/demo/tracks?apikey=1111

Autor: Joakim Vivas