29 sept. 2016

CRUD usando Flask y MongoDB con ORM Flask-MongoAlchemy (parte 4)

CRUD usando Flask y MongoDB con ORM Flask-MongoAlchemy (parte 4)

Continuando con la serie de artículos sobre acceso a mongodb desde Flask. 
Para revisar los artículos relacionados a este artículo pueden ver:

La base de datos sigue manteniendo el formato de los artículos anteriores.

En este caso se va a ingresar el empleado "Ernesto" , luego se busca en la base de datos, se actualizará su información y se eliminará de la base de datos.

Archivo Dockerfile

Este archivo tiene pequeños cambios, se eliminó pymongo y Flask-PyMongo, aunque mongoalchemy al final lo usa. 

A continuación el archivo Dockerfile:


FROM python
WORKDIR /code/
RUN pip3 install --upgrade pip
RUN pip3 install Flask
RUN pip3 install Flask-MongoAlchemy
EXPOSE 5000
ADD ./app/* /code/
COPY ./app/* /code/
CMD python run.py 

El archivo docker-compose.yml se mantiene igual que en los artículos anteriores.


Archivo app/run.py


En este caso el crud se hace con mongoalchemy. 

A continuación se muestra el código de run.py:

#!/usr/bin/env python
#Se importa Flask, reqest y jsonify
from flask import Flask, request,jsonify
#Se importa MongoAlchemy
from flask_mongoalchemy import MongoAlchemy
#Se importa dumps
from bson.json_util import dumps
#Se instancia la clase de Flask, se configura el acceso
#a la base de datos mongodb a empleados
app = Flask(__name__)
app.config['MONGOALCHEMY_DATABASE'] = 'empleados'
app.config['MONGOALCHEMY_CONNECTION_STRING'] = 'mongodb://mongo:27017/empleados'
#Se instancia mongoalchemy pasando la app.
db = MongoAlchemy(app)
#Se crea la clase empleados la cual manejara los documentos.
class empleados(db.Document):
    nombre = db.StringField()
    sexo = db.StringField()
    edad = db.IntField()
    dni = db.IntField()
#Se define la funcion add con metodo get
@app.route('/add',methods=['GET'])
def add():
    #Se crea la instancia empleado de la clase empleados donde se
    #logra hacer la inserción de un empleado con el metodo save.
    empleado = empleados(nombre=str(request.args['nombre']),
                            sexo = str(request.args['sexo']),
                            edad = int(request.args['edad']),
                            dni = int(request.args['dni']))
    empleado.save()
    #Se retorna que el usuario fue agregado.
    return jsonify({'resultado': 'Usuario agregado' })
#Se crea la funcion find con metodo get.
@app.route('/find',methods=['GET'])
def find():
    #Se realiza la busqueda y se devuelve el resultado, si existe un error de atributo (que el empleado no existe)
    #Se devuelve empleado no encontrado.
    try:
        resultado = empleados.query.filter(empleados.nombre == str(request.args['nombre'])).first()
        return dumps({'resultado':{'nombre':resultado.nombre,'sexo':resultado.sexo,'edad':resultado.edad,'dni':resultado.dni}})
    except (AttributeError):
        return dumps({'resultado': 'Empleado no encontrado'})
@app.route('/update',methods=['GET'])
def update():
    #Se intenta buscar al empleado, si existe se toma los argumentos para actualizar sus
    #datos y devolver que se actualizo, si no devuelve usuario no encontrado.
    try:
        resultado = empleados.query.filter(empleados.nombre == str(request.args['nombre'])).first()
        resultado.sexo = str(request.args['sexo'])
        resultado.edad = int(request.args['edad'])
        resultado.dni = int(request.args['dni'])
        resultado.save()
        return dumps({'resultado':'Empleado actualizado'})
    except (AttributeError):
        return dumps({'resultado': 'Empleado no encontrado'})
@app.route('/delete/<nombre>')
def remove(nombre):
    #Se busca el empleado, si existe se borra de la base de datos y se devuelve
    #mensaje de empleado borrado, si no, se devuelve el mensaje de empleado no
    #encontrado.
    try:
        resultado = empleados.query.filter(empleados.nombre == str(nombre)).first()
        resultado.remove()
        return dumps({'resultado':'empleado borrado'})
    except (AttributeError):
        return dumps({'resultado':'Empleado no encontrado'})
if __name__ == "__main__":
    #Se corre la aplicacion en modo debug
    app.run(host="0.0.0.0",debug=True)


Construir la imagen Docker y ejecutar los contenedores


Para construir la imagen se ejecuta:
docker-compose build

Para ejecutar los contenedores docker se ejecuta:

docker-compose up

Probar el CRUD

Crear un empleado:

Al abrir el navegador en el siguiente URL se inserta el empleado:

http://localhost:5000/add?nombre=Ernesto&dni=33&edad=11&sexo=Masculino

El resultado se muestra en un JSON:
{
  "resultado": "Usuario agregado"
}

Buscar un empleado

Al abrir el navegador con el siguiente URL se busca el empleado:

http://localhost:5000/find?nombre=Ernesto

El resultado de la busqueda se muestra en un JSON:

{"resultado": {"nombre": "Ernesto", "sexo": "Masculino", "dni": 33, "edad": 11}}



Actualizar un empleado

Al abrir el navegador con el siguiente URL se actualiza la información de un usuario:

http://localhost:5000/update?nombre=Ernesto&edad=45&dni=50&sexo=Masculino


El resultado se muestra en un JSON:

{"resultado": "Empleado actualizado"}


Borrar un empleado

Ahora queda eliminar un documento de la base de datos, se abre el siguiente URL:

http://localhost:5000/delete/Ernesto

El resultado se muestra en un JSON:

{"resultado": "empleado borrado"}

Si se vuelve a consultar por el usuario el JSON que se devuelve dirá usuario no encontrado:

http://localhost:5000/find?nombre=Ernesto

{"resultado": "Empleado no encontrado"}

Esto indica que ha sido borrado de la base de datos el documento del empleado.

Ya con esto se probó todo el proceso del CRUD en documentos de una colección de la base de datos MongoDB.

El código fuente de la aplicación de este artículo se encuentra en el repositorio tutorial-flask en la rama mongo4 en gitlab.

28 sept. 2016

CRUD usando Flask para MongoDB (parte 3).

CRUD usando Flask para MongoDB 

Continuando con la serie de artículos sobre acceso a mongodb desde Flask. 

Para revisar los artículos relacionados a este artículo pueden ver:

En la base de datos mongodb se tiene lo siguientes datos de los empleados:



[{"edad": 29, "nombre": "Jane Doe", "dni": 8, "sexo": "Femenino", "_id": {"$oid": "57ebbce45fd2bbeffc51330b"}}, {"edad": 39, "nombre": "John Doe", "dni": 7, "sexo": "Masculino", "_id": {"$oid": "57ebbd195fd2bbeffc51330c"}}, {"edad": 55, "nombre": "Pedro Perez", "dni": 6, "sexo": "Masculino", "_id": {"$oid": "57ebbd505fd2bbeffc51330d"}}, {"edad": 65, "nombre": "Petra", "dni": 5, "sexo": "Femenino", "_id": {"$oid": "57ebbd6b5fd2bbeffc51330e"}}, {"edad": 18, "nombre": "Luis Gonzalez", "dni": 4, "sexo": "Masculino", "_id": {"$oid": "57ebc34d5fd2bbeffc51330f"}}, {"edad": 28, "nombre": "Carolina", "dni": 3, "sexo": "Femenino", "_id": {"$oid": "57ebc3715fd2bbeffc513310"}}, {"edad": 34, "nombre": "Luissana", "dni": 2, "sexo": "Femenino", "_id": {"$oid": "57ebc3935fd2bbeffc513311"}}, {"edad": 43, "nombre": "Neg", "dni": 1, "sexo": "Masculino", "_id": {"$oid": "57ebc4b85fd2bbeffc513312"}}]

Para este artículo se va a desarrollar y probar un CRUD con Flask usando como base de datos mongodb.

Insertar un empleado en la colección


El código para insertar un empleado se muestra a continuación:



#Se define la funcion add con metodo get
@app.route('/add',methods=['GET'])
def add():
    #Se toma el nombre, sexo, edad y dni como argumentos del url
    nombre = str(request.args['nombre'])
    sexo = str(request.args['sexo'])
    edad = int(request.args['edad'])
    dni = int(request.args['dni'])
    #Se usa la coleccin empleados.
    empleados = mongo.db.empleados
    #Se inserta el documento a la coleccion
    empleados.insert({'nombre':nombre,'sexo':sexo,'edad':edad,'dni':dni})
    #Se retorna que el usuario fue agregado.
    return jsonify({'resultado': 'Usuario agregado' })


Buscar un empleado en la colección


El código para buscar un empleado en la colección se muestra a continuación:

#Se crea la funcion find con metodo get.

@app.route('/find',methods=['GET'])

def find():

    #Se obtiene el nombre como argumento del url.

    nombre = str(request.args['nombre'])

    #Se conecta a la coleccion empleados.

    empleados = mongo.db.empleados

    #Se busca el nombre en la coleccion.

    resultado = empleados.find_one({'nombre':nombre})

    #Y se devuelve el resultado.

    return dumps(resultado)



Actualizar un empleado en la colección


El código para actualizar un empleado se muestra a continuación:



#Se define la funcion update con metodo get que actualiza un documento de la

#coleccion.

@app.route('/update',methods=['GET'])

def update():

    #Se toma el nombre,edad y dni como argumentos.

    nombre = str(request.args['nombre'])

    edad = int(request.args['edad'])

    dni = int(request.args['dni'])

    #Se conecta a la coleccion.

    empleados = mongo.db.empleados

    #Se busca el nombre en los documentos.

    empleado = empleados.find_one({'nombre':nombre})

    #Se actuliza la edad, el dni.

    empleado['edad'] = edad

    empleado['dni'] = dni

    #Se salva el empleado en la coleccion.

    empleados.save(empleado)

    #Se devuelve que el usuario ha sido actualizado.

    return dumps({'resultado': 'Usuario actualizado'})




Remover un empleado de la colección



El código para remover un empleado de la colección es el siguiente:

#Se define la funcion delete.
#donde en el url se pasa el nombre del empleado a borrar
@app.route('/delete/<nombre>')
def delete(nombre):
    #Se conecta a la coleccion empleados.
    empleados = mongo.db.empleados
    #Se busca el documento del empleado por el nombre.
    empleado = empleados.find_one({'nombre':nombre})
    #Se remueve el empleado de la coleccion.
    empleados.remove(empleado)
    #Se devuelve el resultado.
    return dumps({'resultado': 'Usuario removido'})


Noten que la forma de pasar argumentos a la función delete es diferente de las demás funciones.


Construcción de la imagen Docker y ejecución de los contenedores

Los archivos Dockerfile y docker-compose.yml se explicaron en el primer artículo de esta sección ( se encuentran en el inicio de este artículo los enlaces).

Para construir la imagen docker se ejecuta:

docker-compose build

Para ejecutar los contenedores de la aplicación y de mongodb se ejecuta:

docker-compose up



Prueba del CRUD


Para crear un empleado se abre el siguiente URL en el navegador: 
http://localhost:5000/add?nombre=Ernesto&dni=33&edad=11&sexo=Masculino

Devuelve un json:
{
  "resultado": "Usuario agregado"
}



Para buscar el empleado que se incorporó anteriormente se abre el navegador en el URL:

http://localhost:5000/find?nombre=Ernesto

Devuelve el siguiente json:
{"_id": {"$oid": "57ec8714b7cd2f00565e8784"}, "sexo": "Masculino", "edad": 11, "nombre": "Ernesto", "dni": 33}


Para actualizar al empleado Ernesto se abre el navegador en el siguiente URL:

http://localhost:5000/update?nombre=Ernesto&edad=45&dni=50

Acá se actualiza la edad y el dni.

Esto devuelve el siguiente json:

{"resultado": "Usuario actualizado"}

Por último se va a eliminar al empleado abriendo el navegador en el siguiente URL:

http://localhost:5000/delete/Ernesto

Esto devuelve el siguiente json:

{"resultado": "Usuario removido"}


Se nota que para el delete la forma de pasar el URL es distinta a las demás que se han ejecutado.



El código fuente de este artículo se encuentra en la rama mongo3 de gitlab.com

Consulta a MongoDB desde Flask (parte 2 - paginación)

Consulta a MongoDB desde Flask (parte 2 - paginación) 

Continuando con la serie de artículos sobre acceso a mongodb desde Flask. 


Para revisar los artículos relacionados a este artículo pueden ver:

En la base de datos mongodb se tiene lo siguientes datos de los empleados:

[{"edad": 29, "nombre": "Jane Doe", "dni": 8, "sexo": "Femenino", "_id": {"$oid": "57ebbce45fd2bbeffc51330b"}}, {"edad": 39, "nombre": "John Doe", "dni": 7, "sexo": "Masculino", "_id": {"$oid": "57ebbd195fd2bbeffc51330c"}}, {"edad": 55, "nombre": "Pedro Perez", "dni": 6, "sexo": "Masculino", "_id": {"$oid": "57ebbd505fd2bbeffc51330d"}}, {"edad": 65, "nombre": "Petra", "dni": 5, "sexo": "Femenino", "_id": {"$oid": "57ebbd6b5fd2bbeffc51330e"}}, {"edad": 18, "nombre": "Luis Gonzalez", "dni": 4, "sexo": "Masculino", "_id": {"$oid": "57ebc34d5fd2bbeffc51330f"}}, {"edad": 28, "nombre": "Carolina", "dni": 3, "sexo": "Femenino", "_id": {"$oid": "57ebc3715fd2bbeffc513310"}}, {"edad": 34, "nombre": "Luissana", "dni": 2, "sexo": "Femenino", "_id": {"$oid": "57ebc3935fd2bbeffc513311"}}, {"edad": 43, "nombre": "Neg", "dni": 1, "sexo": "Masculino", "_id": {"$oid": "57ebc4b85fd2bbeffc513312"}}]

Ahora se agregó un campo llamado dni, y se tienen 8 empleados. 


El código fuente de este artículo lo pueden ver en la rama mongo2 de gitlab.

Estructura de directorios y archivos

tutorial-flask
├── app
│   └── run.py
├── docker-compose.yml
├── Dockerfile
└── README.md


Esta es la misma estructura del artículo anterior.


Archivo Dockerfile y docker-compose.yml


Estos archivos son los mismos del artículo anterior.

Script app/run.py 

Este script permite paginar según una variable llamada dni, el cual se usará para realizar la consulta paginada. 

A continuación el código de run.py:


#!/usr/bin/env python
#Se importa Flask, reqest y jsonify
from flask import Flask, request,jsonify
#Se importa pyMOngo
from flask_pymongo import  PyMongo, pymongo
#Se importa dumps
from bson.json_util import dumps
#Se instancia la clase de Flask, se configura el acceso
#a la base de datos mongodb a empleados
app = Flask(__name__)
app.config['MONGO_DBNAME'] = 'empleados'
app.config['MONGO_URI'] = 'mongodb://mongo:27017/empleados'
#Se asocia la app a pymongo
mongo = PyMongo(app)
#Se define la ruta /dnis con metodo GET
@app.route('/dnis',methods=['GET'])
def dni():
    #Se consutla la coleccion empleados
    empleados = mongo.db.empleados
    #Se toma los argumentos del url offset y limite
    offset = int(request.args['offset'])
    limite = int(request.args['limite'])
    #Se define el decremento como la diferencia entre offset y el limite
    decremento = offset-limite
    #Se define el incremento como la suma entre offset y limite
    incremento = offset+limite
    #Mientras no de error de indice
    try:
        #Se define el dni inicial, el ultimo
        dniInicio = empleados.find().sort('dni',pymongo.ASCENDING)
        dniUltimo = dniInicio[offset]['dni']
        #Se hace la consulta a la base de datos
        empleados  = empleados.find({'dni': {'$gte': dniUltimo}}).sort('dni',pymongo.ASCENDING).limit(limite)
        #Se crea el listado de donde se almacena los diccionarios.
        listado = []
        #Se agrega a listado os dni y nombres de los empleados.
        for i in empleados:
            listado.append({'dni': i['dni'],'nombre': i['nombre']})
        #Se define el url previo y siguiente, donde se juega con el offset para avanzar o regresar
        prev_url = 'http://localhost:5000/dnis?limite=' + str(limite) + '&offset=' + str(decremento)
        next_url = 'http://localhost:5000/dnis?limite=' + str(limite) + '&offset=' + str(incremento)
        #Si decremento es negativo se coloca el url en blanco.
        if  ( decremento <  0) :
            prev_url = ''
        #Se retorna el json con los resultados y los urls.
        return jsonify({'resultado': listado,'prev_url':prev_url,'next_url':next_url })
    except (IndexError,):
        #Si hay error de indice se defin el url siguiente en blanco, el url previo se mantiene.
        next_url = ''
        prev_url = 'http://localhost:5000/dnis?limite=' + str(limite) + '&offset=' + str(decremento)
        #Se retorna un json con el resultado y urls .
        return jsonify({'resultado': 'FIN','prev_url':prev_url,'next_url':'' })
if __name__ == "__main__":
    #Se corre la aplicacion en modo debug
    app.run(host="0.0.0.0",debug=True)




Creación de la imagen docker y ejecución de los contenedores


Para crear la imagen docker se ejecuta:

docker-compose build

Para ejecutar los contenedores:

docker-compose up


A continuación se muestra una imagen de la salida de la ejecución:



A continuación se muestra los documentos por medio de la aplicación robomongo:


Al abrir el url (http://localhost:5000/dnis?limite=3&offset=0 ), donde limite es la cantidad de objetos a mostrar por página, el offset es el desplazamiento.

La primera figura muestra el primer grupo de empleados (no se tiene url para regresar):
Al darle clic al siguiente url se tiene a continuación los dni 4,5 y 6 (aparece el url de regresar y avanzar):


Al darle clic a avanzar se tiene los empleados de dni 7 y 8:


Como se tienen 8 elementos, se llegó al dni 8, al darle avanzar muestra que se terminó el json y que sólo se tiene enlace para regresar:


27 sept. 2016

Consulta a MongoDB desde Flask (parte 1)


Consulta a MongoDB desde Flask (parte 1)


En este artículo se usará Docker para construir la imagen que contiene el script en Flask con sus dependencias, se usará docker-compose.yml para asociar dicha imagen como contenedor con un contenedor de mongoDB.

Para revisar los artículos relacionados a este artículo pueden ver:


Se tiene una colección empleados en una base de datos empleados  con los siguientes datos:

[{"_id": {"$oid": "57eb0887c535b9e290a6386d"}, "nombre": "Jane Doe", "sexo": "femenino", "edad": 29.0}, {"_id": {"$oid": "57eb0892c535b9e290a6386e"}, "nombre": "John Doe", "sexo": "masculino", "edad": 39.0}, {"_id": {"$oid": "57eb1c16c535b9e290a6386f"}, "nombre": "Pedro Perez", "sexo": "masculino", "edad": 55.0}, {"_id": {"$oid": "57eb1c66c535b9e290a63870"}, "nombre": "Petra", "sexo": "femenino", "edad": 65.0}]


Estructura de archivos y directorios

La estructura de archivos y directorios del proyecto del artículo es la siguiente:

tutorial-flask
├── app
│   └── run.py
├── docker-compose.yml
├── Dockerfile
├── README.md
└── tmp



Archivo Dockerfile


El archivo Dockerfile usa de sistema base Python, e instalará las siguientes dependencias:
  • Actualización de pip
  • pymongo
  • Flask
  • Flask-PyMongo
Además expone el puerto 5000 y ejecuta el script run.py.

A continuación el contenido del archivo Dockerfile:

FROM python
WORKDIR /code/
RUN pip3 install --upgrade pip
RUN pip3 install  pymongo
RUN pip3 install Flask
RUN pip3 install Flask-PyMongo
EXPOSE 5000
ADD ./app/* /code/
COPY ./app/* /code/
CMD python run.py




Archivo docker-compose.yml

El archivo docker-compose.yml define la construcción de la imagen Docker a partir del archivo Dockerfile, el puerto a exponer, el volumen a exponer y se enlaza con el contenedor mongo, el cual usa la imagen de mongo, expone el puerto 27017, y por último expone el volumen.

A continuación el contenido del archivo:

flask-mongo:
  build: .
  ports:
    - "5000:5000"
  volumes:
    - "./app/:/code"
  links:
    - mongo
mongo:
  image: mongo
  ports:
    - "27017:27017"
  volumes:
    - "/srv/data/db:/data/db:rw"


Si se quiere que la base de datos mongodb sea pública se expone los puertos, si no, entonces no se define los puertos. Para el caso de manejar persistencia de datos en la base de datos si es necesario definir el volumen. 

Script run.py


Este script se muestra a continuación: 
#!/usr/bin/env python
#Se importa Flask
from flask import Flask
#Se importa PyMongo
from flask_pymongo import  PyMongo
#Se importa dumps de bson.json_util
from bson.json_util import dumps
#Se crea la instancia Flask
app = Flask(__name__)
#Se configura el acceso a la base de datos mongodb
app.config['MONGO_DBNAME'] = 'empleados'
app.config['MONGO_URI'] = 'mongodb://mongo:27017/empleados'
#Se asocia la configuración pasando la app
mongo = PyMongo(app)
#Se define la ruta raiz con metodo POST
@app.route('/',methods=['POST'])
def index():
    #Se realiza la conexion a la coleccion empleados
    empleados = mongo.db.empleados
    #Se hace la consulta y se devuelve  en formato json_util
    resultados = empleados.find()
    return dumps(resultados)
if __name__ == "__main__":
    #Se corre la aplicacion en modo debug
    app.run(host="0.0.0.0",debug=True)



Crear la imagen Docker y ejecutar los contenedores


Para crear la imagen Docker se ejecuta:

docker-compose build


Para ejecutar los dos contenedores se ejecuta:

docker-compose up


A continuación se muestra los documentos de la colección desde robomongo:




Para realizar la consulta se usará postman (una aplicación para google chrome), a continuación se muestra la imagen del resultado de la consulta:




Al consultar vía POST a 127.0.0.1 puerto 5000, se devuelve el json con todos los empleados que se tienen en la base de datos mongodb.

El código fuente de este artículo lo pueden ver en la rama mongo1 en gitlab.

25 sept. 2016

Trabajar con datos JSON en Flask

Trabajar con datos JSON  en Flask 



Este artículo es la continuación del artículo anterior Crear datos JSON a partir de un diccionario en Flask (parte 1) (actualización- Docker).

Este  artículo se basa del artículo en inglés: Working with JSON in Python Flask.

El código fuente de este artículo lo pueden bajar de la rama json2 en gitlab.

Los demás artículos sobre Flask lo pueden ver en enlace de la etiqueta Flask.


Archivos Dockerfile y docker-compose.yml

En el archivo Dockerfile se agrega la instalación de la librería names a cual facilita el manejo de nombres y apellidos de manera aleatoria para ser usado en la aplicación cliente app.py en la clase Empleado.

El código completo del archivo Dockerfile es el siguiente:


FROM python
WORKDIR /code
RUN pip3 install --upgrade pip
RUN pip3 install  flask
RUN pip3 install names
EXPOSE 5000
ADD . /code
CMD python app.py

El archivo docker-compose.yml tiene lo siguiente:


tutorial-json2:

  build: .

  ports:

   - "5000:5000"

  volumes:

   - .:/code


Clase Empleado


Para este artículo se crea un módulo llamado empleado.py que tiene una clase Empleado, la cual se guarda el nombre y apellido del empleado en el __init__, luego se crea un método el cual permite crear un json a partir de un diccionario:


def toJSON(self):

        return {"Empleado": {'nombre': self.nombre,

                 'apellido': self.apellido}}




El código completo de empleado.py se muestra a continuación:


#!/usr/bin/env python





"""Se cra la insancia Empleado

Se crea el constructor donde se le pasa el nombre y apellido

"""



class Empleado:

    def __init__(self,nombre,apellido):

        self.nombre = nombre

        self.apellido = apellido



    def toJSON(self):

        return {"Empleado": {'nombre': self.nombre,

                 'apellido': self.apellido}}





Aplicación app.py


En este caso se usa el módulo names el cual permite generar nombres y apellidos de manera aleatoria,  se usa la clase Empleado para guardar los datos:




#!/usr/bin/env python

#Se importa de flask a Flask, jsonify y json

from flask import Flask,jsonify,json

#Se importa empleados import Empleado

from empleado import Empleado

#Se importa names

import names

#Se importa sys

import sys



#Se crea la instancia de la aplicacion

app = Flask(__name__)



#Se crea

#Se define el decorador route donde se da la ruta del servidor web.

@app.route("/ListaEmpleados")

def ListaEmpleados():

    try:

        #inicializar la lista de empleados

        listaEmpleados = []

        #crear instancias para llenar la lista

        for i in range(0,5):

            empleado = Empleado(names.get_first_name(),names.get_last_name())

            listaEmpleados.append(empleado)



        # convertir en dato json al diccionario

        jsonStr = json.dumps([e.toJSON() for e in listaEmpleados])

    except :

        print ("error", sys.exc_info()[0])



    #Retorna el json

    return jsonStr





if __name__ == '__main__':

    app.run(host="0.0.0.0",debug=True)


Ejecución de la aplicación


Para ejecutar la aplicación se ejecuta docker-compose:

docker-compose build
docker-compose up


Al abrir el url (http://localhost:5000/ListaEmpleados ) se muestra la lista de empleados con su nombre y su apellido (nombres y apellidos aleatorios).

A continuación se muestra una captura de pantalla del navegador:



Para terminar se muestra la salida de la aplicación:

Recreating tutorialflask_tutorial-json1_1
Attaching to tutorialflask_tutorial-json1_1
tutorial-json1_1 |  * Running on http://0.0.0.0:5000/ (Press CTRL+C to quit)
tutorial-json1_1 |  * Restarting with stat
tutorial-json1_1 |  * Debugger is active!
tutorial-json1_1 |  * Debugger pin code: 733-227-386
tutorial-json1_1 | 172.17.0.1 - - [25/Sep/2016 20:34:42] "GET /ListaEmpleados HTTP/1.1" 200 -

AddThis