API RESTful en Flask – Instalación

Instalación Ambientes Virtuales

Al iniciar nuestro API en Flask primero es necesario hacer la instalación de una serie de librerías que serán necesarias para el correcto funcionamiento de nuestro código, normalmente se le denomina “requirements.txt” al archivo que contiene esta lista de librerías, este usualmente se crea en la raíz del proyecto y se pueden instalar con una herramienta para instalar paquetes de Python llamada PIP (acrónimo recursivo de Pip Installs Packages)

Para los siguientes pasos se asumirá que el lector de este tutorial ya tiene instalado Python en la versión 3.6 o superior, de manera que vamos a omitir la instalación de PIP ya que esta viene instalada con la versión de Python 3.6 por defecto. Para saber la versión de Python puedes abrir una consola con:

 Windows + R 

Escribir “cmd” sin comillas y presionar Enter y luego en la Consola escribir:

python --version

y les mostrará algo como esto:

Antes de instalar los requisitos es recomendable instalar una herramienta para trabajar con ambientes virtuales, ya que de otra manera se instalaran las librerías de forma global, para esto vamos a instalar virtualenv, en la consola escribimos:

pip install virtualenv

y presionamos Enter.

Se habrá instalado el paquete Virtualenv, ahora vamos a instalar el VirtuealenvWrapper para Windows

pip install virtualenvwrapper-win

y presionamos Enter.

Se habrá instalado el paquete para poder usar de manera mas sencilla los ambientes virtuales.

Ahora solo debemos crear un ambiente virtual y acceder al mismo para poder dentro de este instalar los paquetes asociados a nuestro proyecto de API RESTful en Flask – Python

Para esto vamos a ejecutar los siguientes comandos:

mkvirtualenv tutorial_api

Con lo cual ahora tenemos el ambiente virtual llamado “tutorial_api”, usted pueden colocar el nombre que desee, luego de crearlo estaremos automáticamente dentro del ambiente virtual por lo cual veremos el nombre del ambiente virtual entre paréntesis como en la siguiente imagen:

Los comandos que utilizarán comúnmente para el manejo de los ambientes virtuales son:

• mkvirtualenv: para crear ambientes virtuales
• lsvirtualenv: para listar los ambientes virtuales disponibles (aunque también se puede usar “workon” para listarlos)
• rmvirtualenv <nombre>: para eliminar un ambiente virtual ingresando el nombre
• workon <nombre>: para comenzar a usar un ambiente virtual ingresando el nombre
• deactivate: para dejar de usar el ambiente virtual que se esté utilizando

Instalación de Requisitos

Ahora ha llegado el momento de instalar las librerías que van a soportar nuestro proyecto de API RESTful, de manera que podemos crear el archivo “requirements.txt” para que podamos instalar de forma directa la lista de librerías a continuación:

flask-script: Instala una serie de utilidades para correr el servidor

flask-cors: Utilidad de flask para permitir  Cross Origin Resource Sharing el cual es un mecanismo que permite a recursos restringidos ser accedidos desde un dominio diferente al dominio en el cual se ubican.

sqlalchemy: ORM Para el manejo de la base de datos

flask-sqlalchemy: adaptación de sqlalchemy con flask que trae algunas caracteristicas adicionales como el manejo de sesiones.

flask-restplus: restplus para crear frontend y backend de API con flask

python-dotenv: para manejo de variables de entorno a través de un archivo sencillo .env en la raíz del proyecto

Para instalar todas estas librerías solo es necesario crearse un archivo requirements.txt en la raíz del proyecto, para poder listar los requisitos, teniendo como resultado el siguiente contenido en dicho archivo:

#Python librerías requeridas
flask
flask-restplus==0.11.0
python-dotenv==0.8.1
requests==2.19.0
flask-SQLAlchemy==2.3.0
flask-migrate
flask-script
flask-cors

Ahora solo basta con estar dentro del ambiente virtual y ejecutar en la raíz del proyecto el comando:

pip install -r requirements.txt

y esperar a que se instalen todas las librerías mencionadas

Con esto tendremos la instalación de las librerías básicas necesarias para comenzar a correr nuestro proyecto, ahora en el siguiente punto veremos los archivos iniciales para que comience a andar la carreta.

Estructura del Proyecto

Para la estructura del proyecto vamos a utilizar un enfoque muy sencillo en el cual dividiremos el código fuente en carpetas de la siguiente manera:

Dentro tendremos la carpeta “app” tendremos las carpetas esenciales que contendrán el API y los modelos, estos los crearemos mas adelante, con lo cual en esta sección nos enfocaremos en los archivos de configuración de la aplicación de manera que pueda quedar claro cual es el uso que se le da a cada uno, primero vamos a hacer una lista a continuación con los archivos por orden de prioridad:

1. app.py : Este archivo es el encargado de iniciar la aplicación, es la semilla que inicia las llamadas a otros archivos de configuración de manera que todo quede andando.
2. config.py : Este archivo carga algunos parámetros de configuración, en nuestro ejemplo los sacaremos del archivo “.env” que guarda la información inherente al puerto, versión, nombre del proyecto, credenciales de la base de datos, entre otros.
3. backend.py : En este archivo es posible crear algunas funciones que inician el API, abstrayendo al archivo app.py de estas operaciones, que aunque básicas se necesita una lógica especifica.
4. extensions.py: Archivo que crea los objetos API y DB para el API y la base de datos respectivamente
5. .env: el archivo punto env como algunos lo llaman guarda en forma de strings algunos textos que sirven para la configuración y serán los que se usen en el config.py

Código del archivo app.py:

#! /usr/bin/env python

import os

from flask_script import Manager, Server

from app.backend import create_api

#Creacion del API con un metodo externo traido del archivo backend

app = create_api(os.getenv('FLASK_CONFIG') or 'default')

#La aplicación esta ejecutandose, se incluye algun comando util.

if __name__ == '__main__':
    manager = Manager(app)
    manager.add_command("runserver", Server(threaded=bool(int(os.environ.get('THREADED'))), port=int(os.environ.get('PORT'))))
    manager.run(default_command='runserver')

El archivo de configuración también es muy sencillo, a continuación (config.py):

# Standard lib imports
import os
from datetime import timedelta
# Third-party imports
from dotenv import load_dotenv
# BITSON imports

# Ruta base del proyecto
BASEDIR = os.path.dirname(os.path.abspath(__file__))

#ruta del archivo de variables de entorno ".env"
ENV_VARS = os.path.join(BASEDIR, ".env")
#se cargan las variables de entorno
load_dotenv(ENV_VARS)

class Config:
    """Base config class"""
    PROJECT_NAME = os.environ.get('PROJECT_NAME')
    CURRENT_DIR = os.path.dirname(os.path.abspath(__file__))
    DB_SERVICE = os.environ.get('DB_SERVICE')
    DB_NAME = os.environ.get('DB_NAME')

    LOG_IN_DB = {
    'OPTIONS': [],
    'GET': [],
    'POST': [201, 200, 400],
    'PUT': [200, 400],
    'DELETE': [204, 400]
    }

    SQLALCHEMY_TRACK_MODIFICATIONS = False
    SLOW_QUERY_TIMEOUT = 0.5
    SQLALCHEMY_RECORD_QUERIES = False

    WTF_CSRF_ENABLED = False

    @staticmethod
    def init_app(app):
        pass

Archivo backend.py:

from flask import Flask
from flask_cors import CORS
from app.extensions import api
from app.extensions import db
from config import config

def create_api(environment_name=None):
    app = Flask(__name__)

    app.config.from_object(config[environment_name])

    CORS(app)

    with app.app_context():

    db.init_app(app)

    api.init_app(app)
    return app

Archivo extensions.py:

from flask_sqlalchemy import SQLAlchemy
from flask_restplus import Api

api = Api(version='v0.1', title='Tutorial API', description='tutorial para aprender a crear un API RESTful en Python')

db = SQLAlchemy()

Para el archivo .env es necesario saber que el nombre debe ser “.env” con un punto al inicio del archivo.
Archivo .env:

# Environment Variables
PORT=9001
FLASK_CONFIG=development
VERSION=1.0
PROJECT_NAME=tutorial_api

# tutorial db
DB_SERVICE=sqlite
DB_HOST=localhost
DB_PORT=5432
DB_NAME=tutorial_api_db

FLASK_APP=app

Ahora para poder probar el proyecto en su versión inicial es necesario crear estos archivos con la estructura mostrada mas arriba para los directorios.

Problemas Comunes

Es preciso revisar el código ya que en los casos mas comunes los primeros errores en python ocurren cuando la sintaxis tiene algún problema, por ejemplo que en lugar de usar tabs se estén utilizando espacios, así que lo mas probable es que la consola te de una idea inicial de donde está el problema.

Otro detalle importante es que en cada directorio de nuestra aplicación o proyecto debemos tener un archivo __init__.py que será necesario para que python reconozca ese directorio y lo trate como un directorio de paquete (es un archivo sin líneas de código).

➡ ¡Excelente! Tenemos todo lo necesario para comenzar a desarrollar nuestro proyecto. Continúa aprendiendo con nuestro curso creación de APIs RESTful con Flask – Python:

Curso de creación de APIs RESTful con Flask – Python