Publicación de Cryptongo con Docker

Deploy de Cryptongo en Docker

Para desplegar Cryptongo se necesita tener instalado y configurado Docker en el entorno dónde se desea desplegar Cryptongo, para eso es recomendable ver el curso de Docker.

Una vez instalado Docker debemos empezar a crear las imágenes de Docker con dos Dockerfiles uno para el agente y otro para nuestra API REST.

Desplegando nuestro agente

Debemos comenzar por ejecutar un contenedor que contendrá MongoDB para guardar toda la información de las criptomonedas. MongoDB 3.4 se encuentra disponible en la imagen oficial de MongoDB para Docker.

Para ejecutar mongo solo debemos ejecutar desde la consola:

$ docker run -d --name=mongo-crypto mongo:3.4

Con el comando run le indicamos a Docker que va a ejecutar un contenedor, con el parámetro -d indicamos que se ejecutará en segundo plano, con --name asignamos un nombre personalizado al contenedor y por último especificamos el nombre de la imagen y la etiqueta.

En este caso ejecutamos la imagen mongo con la etiqueta 3.4 para especificar que de la imagen de MongoDB deberá Docker ejecutar la versión 3.4 que está disponible en el repositorio oficial.

Antes de desplegar nuestro agente haremos una modificación al código para agregar un sleep y un while para ejecutar de manera infinita nuestro agente y que espere 4 minutos para volver a pedir información del API. La modificación se debe hacer al principio y al final del archivo.

Al principio del archivo hay que importar la librería time dónde encontraremos la función de sleep. Para eso colocamos import time.

Y al final de nuestro archivo main.py, vamos a reemplazar todo el contenido que está por debajo de la línea que contiene if __name__ == "__main__": por el siguiente código:

if __name__ == "__main__":
    while True:
        print("Guardando información en Cryptongo")
        connection = get_db_connection('mongodb://mongo-crypto:27017/')
        tickers = get_cryptocurrencies_from_api()

        for ticker in tickers:
            save_ticker(connection, ticker)
        time.sleep(240)

Una forma válida y sencilla para ejecutar infinitamente un programa es agregando un while para que no se detenga la ejecución.

También cambiamos localhost por mongo-crypto para que enlacemos el contenedor de MongoDB con el del agente aprovechando las características de Docker que me permite especificar un alias como mongo-crypto que apuntará a la IP interna del contenedor de MongoDB.

También se agrega time.sleep(240) que indica a Python que espere 240 segundos, tras ese tiempo se ejecutará de nuevo el while.

El print es solo para mostrar algo en sola y verificar que todo se ejecute correctamente.

Una vez se hagan todos esos cambios procederemos a crear nuestro Dockerfile en la misma carpeta donde se encuentra main.py de nuestro agente.

El contenido del Dockerfile será el siguiente:

FROM python:3.5

WORKDIR /usr/src/app

RUN pip install requests flask pymongo

COPY main.py ./agent.py

CMD [ "python", "agent.py" ]

La primera línea del FROM se indica la imagen que usará como base, en este caso python:3.5.

WORKDIR se usa para especificar que carpeta se usará para ejecutar todos los comandos, es equivalente a hacer cd carpeta en *NIX.

En la tercera línea se usa el comando RUN para instalar las librerías con pip.

Con COPY copiamos de nuestra carpeta del agente el archivo main.py a la carpeta que tenemos especificada en WORKDIR además renombramos a agent.py

Por último especificamos el comando que tendrá nuestra imagen CMD [ "python", "agent.py" ].

Ya por último construimos y ejecutamos nuevamente docker run enlazando nuestro contenedor de MongoDB con el parámetro --link de Docker.

Construir la imagen del agente

$ docker build -t="cryptongo-agent" .

Este comando construirá la imagen con el Dockerfile que está en la carpeta y le colocará el nombre de "cryptongo-agent".

Ejecutar la imagen del agente

$ docker run -it --link=mongo-crypto:mongo-crypto cryptongo-agent
Guardando información en Cryptongo

Con docker run especificamos -it para tener una consola interactiva de nuestro contenedor y de esta forma se ejecuta en primer plano, si deseamos que sea en segundo plano cambiamos -it por -d como se hizo en el contenedor de MongoDB.

En --link especificamos el nombre de nuestro contenedor de MongoDB y el alias que tendrá dentro de nuestro contenedor del agente.

Ya en este punto está en ejecución nuestro agente de Cryptongo y cada 4 minutos pedirá información del API.

Desplegando nuestro API REST

Para nuestra API solo cambiaremos la línea que contiene:

db_connection = get_db_connection('mongodb://localhost:27017/')

por

db_connection = get_db_connection('mongodb://mongo-crypto:27017/')

Luego creamos el Dockerfile en la carpeta donde se encuentra el archivo main.py de nuestra API y colocamos el siguiente contenido:

FROM python:3.5

ENV FLASK_APP api.py

WORKDIR /usr/src/app

RUN pip install requests flask pymongo

COPY main.py ./api.py

EXPOSE 5000

CMD [ "flask", "run", "--host=0.0.0.0" ]

El archivo es muy similar al Dockerfile del agente, pero tiene dos variaciones.

La primera crea una variable de entorno necesaria por Flask para saber que archivo ejecutar, eso se realiza con el comando ENV seguido del nombre de la variable y el contenido.

La segunda modificación es el uso del comando EXPOSE para publicar el puerto 5000 de nuestra imagen, ese es el puerto que usa Flask para escuchar peticiones.

Construcción de la imagen del API

Para construir la imagen ejecutamos docker build cambiando el nombre a cryptongo-api.

$ docker build -t="cryptongo-api" .

Ejecutando el API de Cryptongo

La ejecución se realiza con docker run y de nuevo enlazamos el contenedor de MongoDB para poder leer la base de datos:

$ docker run -it --link=mongo-crypto:mongo-crypto -p 5000:5000 cryptongo-api

La diferencia esta vez es que abrimos el puerto 5000 del contenedor para enlazarlo con el puerto 5000 del servidor host, de esta forma se puede ingresar desde el navegador a la dirección IP del servidor con el puerto 5000.