Microservicio con Docker

**Que son Microservicios

Primero que todo, para entender el ejemplo veremos que es un microservicio . En términos simples éste es un componente de software que implementa una función o tarea específica y que en el contexto de la Arquitectura de Microservicios (MSA por sus siglas en inglés) se despliega de manera independiente, se ejecuta en su propio entorno y se comunica a través de mecanismos ligeros. Otras características de los mcroservicios es que estos tienen una gestión descentralizada (cada microservicio tiene su propia base de datos, su propio servidor HTTP, etc.).

Se debe considerar que en el contexto de una Arquitectura de Microservicios, cada servicio es parte de un entorno en el cual existen otros servicios que en conjunto pueden implementar un sistema o solución completa.

El este ejemplo implementaremos un microservicio que permite manejar mensajes registrados a través de un sitio web o a través de un cliente móvil. Este servicio se compone de una API REST que implementa los métodos POST (Para recibir y almacenar los mensajes) y GET (para listar los mensajes ingresados). Todos los mensajes son almacenados en un Base de Datos Relacional, la cual contiene las tablas para la gestión de los mensajes registrados.

Para el ejemplo usaremos las imagenes:

El código fuentes, Dockerfiles están publicado en:

**Descripción del Microservicio

El microservicio está compuesto por una API REST (Message Service) que permite que los clientes (web / mobile) envíen y recuperen mensajes y una Base de Datos Relacional (DB Messages) para el almacenamiento de dichos mensajes. La API estará desarrollada utilizando Python 3 / Tornado / Tornado-Rest. Para la base de datos se utiliza PostgreSQL 9.5.

Cada componente es una imagen de Docker: Message Service (rancavil/microservicio) y DB Messages (rancavil/pg-db).

**Despliegue del Microservicio utilizando Docker

Para el despliegue del microservicio utilizaremos la herramienta docker-compose, la cual permite ejecutar, relacionar y gestionar múltiples contenedores.

Docker-compose nos permitirá desplegar el microservicio a través de la definición de un archivo yml y nos permitirá administrarlo a través de simples comandos.

**Instalación de docker-compose

Para instalar docker-compose ir al siguiente link, para verificar la instalación ejecutamos el siguiente comando.

$ docker-compose --version
docker-compose version1.20.1, build 1719ceb

**Creación del archivo docker-compose.yml

En un editor de texto creamos el siguiente archivo docker-compose.yml

version: '3'

services:
     servicio:
          image: rancavil/microservicio
          ports:
               - 80:8002links:
               - db-postgresql
     db-postgresql:
          image: rancavil/pg-db

Este archivo define que el microservicio estará compuesto por los contenedores creados a partir de las imágenes microservicios (API REST) y pg-db (Base de Datos PostgreSQL).

La configuración del archivo indica que la aplicación (microservicio) se compone de dos servicios: servicio y db-postgresql. En la definición de servicio se indica que el servicio enlaza el puerto 80 con el puerto 8002 del contenedor (puerto donde expone el servicio el contenedor), adicionalmente se indica que existe un enlace (link) al contenedor pg-postgresql.

Para iniciar el servicio ejecutamos el siguiente comando. Debemos ejecutarlo en el mismo directorio donde esté el archivo docker-compose.yml.

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

La opción -f indica el archivo yml que se ejecutará (no es necesario si es que ejecutamos docker-compose en el mismo directorio del archivo yml).

La opción -d indica que los servicios se ejecutarán en modo demonio.

Para verificar que los servicios se estén corriendo, ejecutamos

$ docker ps

**Prueba del Microservicio

Las pruebas se pueden ejecutar utilizando cualquier cliente HTTP (curl o Postman, por ejemplo).

Para obtener un listado de mensajes utilizamos el método GET.

Nota: myserver es el nombre o la IP de nuestro equipo.

$ curl http://myserver/message

{
    "messages": [
        {
            "id":2,
            "username":"wolverine",
            "text":"test 1"
        }
     ]
}

Para pobrar el envío de mensajes utilizamos el método POST.

$ curl -H"Content-Type: application/json" -X POST -d '{"username":"abc","text":"abc"}' http://myserver/message

{
  "status": "Mensaje creado"
}

Verificamos si se almacenó nuestro nuevo mensaje ejecutando nuevamente el siguiente comando.

$ curl http://myserver/message

{
    "messages": [
        {
            "id": 2,
            "username": "wolverine",
            "text": "test 1"
        },
        {
            "id": 3,
            "username": "abc",
            "text": "abc"
        }
     ]
}

Dado que los servicios se ejecutan en modo demonio, para ver los logs ejecutamos.

$ docker-compose -f docker-compose.yml -logs -f <nombre del servicio>

nombre del servicio puede ser servicio o db-postgresql.

Por último, para detener la ejecución de los servicios ejecutamos el siguiente comando.

$ docker-compose -f docker-compose.yml stop
Stopping microservice_servicio_1 ... 
Stopping microservice_db-postgresql_1 ...