Flask 21. Desplegar una aplicación Flask en Heroku.

Anteriormente. Apéndice 20. Uso de MYSQL o MARIADB en un proyecto Flask.

En este capítulo vamos a desplegar nuestra aplicación en Heroku, que es un servidor de alojamiento en la nube externo. Muchos proveedores de alojamiento en la nube ofrecen una plataforma administrativa en la que se pueden ejecutar aplicaciones. 

Todo lo que necesitamos para implementar una aplicación de Python en estas plataformas es la aplicación solamente, porque el hardware, el sistema operativo, los interpretes de lenguaje de secuencias de comandos, las bases de datos etc son todos administrados por el servicio. Este tipo de servicio se denomina Plataforma como servicio o PaaS.

Heroku, que es un servicio muy popular, nos facilita además una serie de servicios de forma gratuita en donde podremos implementar nuestra aplicación de Python.

Hosting en Heroku.

La implementación de una aplicación Python en Heroku se realiza a través de la herramienta de control de versiones de git, por lo que deberemos tener nuestra aplicación en un repositorio de git. Heroku busca un archivo llamado Procfile en el directorio raíz de la aplicación para obtener instrucciones sobre como iniciar la aplicación. Para los archivos de Python, Heroku también espera un archivo llamado "requirements.txt" que contendrá todas las dependencias del modulo que deben instalarse. Una vez que nuestra aplicación se cargue en los servidores de Heroku a través de git, solamente tendremos que esperar unos segundos hasta que la aplicación este en línea y funcionando. Así de simple.

Lógicamente al ser un servicio gratuito, que nos facilitan para desarrollar y practicar la programación, la capacidad de computo y almacenamiento es limitada. Si necesitas mayor potencia tendrás que adquirirla a través de lo que Heroku llama "dynos". Pero para lo básico y para practicar, el servicio gratuito nos servirá de sobra.

Crear una cuenta en Heroku.

Antes de poder empezar, lógicamente tenemos que tener una cuenta con ellos. Visita www.heroku.com y crea una cuenta gratuita.

Una vez que tengas la cuenta, inicia sesión con tu correo y password (Log in) y tendrás acceso a un panel de administración donde aparecerán nuestros proyectos.

Instalando el cliente de Heroku en el ordenador.

Heroku nos proporciona una herramienta de línea de comandos para poder interactuar con sus servicios llamada Heroku CLI, que tenemos disponible para Linux, Mac y Windows. En la documentación tenemos las instrucciones de instalación para cada una de las plataformas compatibles. 

Como yo esto trabajando con Ubuntu usaré la siguiente:

$sudo snap install --classic heroku

pero también puedes usar la que aparece en su página web más abajo para Debian, que es la que nos funcionará en la Raspberry Pi.

Nota: En ubuntu una instalación alternativa si te diese problemas de actualización (heroku update) de paquetes de snap es curl https://cli-assets.heroku.com/install.sh | sh. En este caso el programa está en /usr/local/bin/heroku

Desinstala previamente el paquete snap con sudo snap remove heroku.

Sigamos.

Lo primero que tenemos que hacer es loguearnos en la cuenta de heroku que creamos antes. Para ello tecleamos en el terminal:

$ heroku login

Heroku CLI abrirá el navegador y nos llevara a una página donde nos loguearemos. Nos pedirá la dirección de correo con la que nos registramos y nuestro password de la cuenta. Una vez hecho esto podemos cerrar la página que se nos ha abierto en el navegador y si vamos al terminal veremos que aparecemos logueados. Esta acción no hace falta volver a hacerla porque se recordará para comandos posteriores.

Preparando la aplicación para subirla a Heroku.

Aunque ser pude hacer de múltiples formas yo voy a usar la siguiente. Primeramente crearemos un esquema de directorios donde poner el proyecto con la siguiente forma:

1.- Creo una carpeta que se llame proyecto y entro en la misma. 

$ mkdir proyecto
$ cd proyecto
proyecto $

2.- Creo en el entorno virtual que usará la aplicación:

proyecto $ python3 -m venv venv

3.- Creamos la carpeta src que contendrá el código fuente del proyecto.

proyecto $ mkdir src

Dentro de esta carpeta colocaré los archivos del programa de Flask que hemos utilizado a lo largo de este tutorial y que puedes encontrar en esta carpeta del proyecto en github..

Para descargar solamente este directorio y no todo el repositorio, entras en el directorio POST 19, copias el enlace del navegador y puedes utilizar alguno de estos 2 links que te dejo:

https://downgit.github.io/#/home

https://download-directory.github.io/

para obtener un archivo zip con el código fuente. Luego extraes los archivos dentro de la carpeta src.

La carpeta src debería quedar tal como se ve a continuación.

IMPORTANTE: al tratarse de un entorno de producción asegúrate de entrar en la carpeta config, editar el archivo config.py y poner el DEBUG=False.

Heroku necesita unos cuantos archivos para subir el proyecto y que funcione. Estos son:

requirements.txt  => Este archivo contiene todas las librerías o bibliotecas de Python que el programa utiliza y que son necesarias para su funcionamiento. Todos los paquetes que utilices para el proyecto deben estar aquí para que heroku sepa lo que se necesita. Este archivo en su día lo realizamos entrando en el entorno virtual y ejecutando la siguiente instrucción:

env $ pip freeze > requirements.txt

Aquí ya esta hecho y si lo abres verás todas las bibliotecas que se utilizan en el programa.

Nota: Si en alguna ocasión te sale dentro de requirements.txt el paquete pkg-resources==0.0.0 elimínalo que luego al subirlo a heroku da un error.

Como lo voy a necesitar posteriormente para pasar de una base sqlite a una postgresql (un poco más adelante veras porqué) vamos a instalar todos los paquetes o dependencias del proyecto en local. Para  instalarlos en nuestro ordenador tenemos que entrar en el entorno virtual, en el directorio src que contiene requirements.txt y ejecutar la siguiente instrucción. Vamos a hacerlo:

env $ pip install -r requirements.txt

[runtime.txt] => Es un archivo en el que se recoge la versión de Python del programa. Este es un archivo opcional y sino lo creamos el programa se ejecutará con la versión 3.9.5. No obstante podemos elegir otra versión distinta. Mira el manual ya que hay que escribir en el archivo la versión de una forma particular y con los tres dígitos, ya que sino no funcionará. Para saber que versión de Python estamos tenemos simplemente tecleamos:

>>> python3 --version
Python 3.8.5

Procfile => En este fichero se recoge que archivo se debe ejecutar en Heroku cuando la aplicación se inicie.

En Heroku se necesita para que cualquier proyecto de Flask funcione instalar el complemento gunicorn que ejecuta el servidor http. Como este paquete en el proyecto no estaba instalado necesitamos hacerlo. Para ello entraremos en el entorno virtual (desde el directorio src, $ source ../venv/bin/activate) y ejecutaremos la siguiente instrucción:

(env) /proyecto/src $ pip install gunicorn

Luego creamos el archivo Procfile y escribimos:

web: flask db upgrade; gunicorn inicio:app

Guardamos y salimos. 

inicio es el nombre del archivo de python que ejecuta la aplicación (inicio.py) y app hace referencia al módelo que lanza la aplicación dentro del mismo (app = Flask(__name__)). "flask db upgrade" lo utilizaremos para consolidar la migración de nuestra base de datos sql a la que utiliza heroku como veremos más adelante en el capitulo.

Como esta biblioteca no estaba instalada en su día, en el archivo requirements.txt tenemos que añadirla. Para ver la versión que se nos ha instalado tecleamos:

(env) ~/proyecto/src $ pip freeze
gunicorn==20.1.0

Pues tal cual copiamos la salida "gunicorn==20.1.0" y la añadimos al final del archivo requirements.txt. 

Guardamos y salimos.

Es sistema de archivos es temporal.

En Heroku tenemos un problema. En cualquier momento se puede restablecer el servidor virtual en el que se ejecutará nuestro programa a su estado inicial. Esto ocasiona que no se pueda confiar en que los datos que se guarden en el sistema de archivos persistirán, ya que de hecho, Heroku restablece los servidores con bastante frecuencia.

El problema que se genera es que el motor de la base de datos SQlite escribe datos a un archivo en disco, que se borraría al reiniciarse el servidor al igual que todo lo que se almacene en memoria. Con lo que si se hubieran escrito nuevos registros estos se borrarían dejando la base de datos sql a su estado original.

Afortunadamente lo que si nos proporciona Heroku, con un complemento, es una base de datos propia Postgresql lo que nos solucionará el problema de la persistencia de los datos.

Trabajando con la base de datos Postgresql de Heroku.

En este punto nos encontramos con un segundo problema. Tenemos la base de datos de los usuarios en formato sqlite, la cual no es soportada por Heroku por lo que hemos comentado anteriormente. Por lo cual tenemos que usar una base con un motor de datos diferente. Heroku tiene una oferta de base de datos propia, basada en la base de datos Postgresql que vamos a utilizar. Escogeremos la que nos ofrece de forma gratuita que tiene un tamaño máximo de 8 MB y 20 conexiones simultáneas lo cual es más que suficiente para nuestro proyecto.

Para hacer esto, lo primero que tenemos que hacer es crear nuestra aplicación de Heroku. Aunque se puede hacer desde la pagina web, lo haremos desde el terminal del sistema con la instrucción:

$ heroku create nombre_proyecto_heroku

* Si el nombre_proyecto_heroku ya esta cogido te dará un error y tendrás que ponerle otro nombre distinto, el que más te guste. Yo lo he llamado novatillo.

y para añadirle una base de datos gratuita teclearemos:

heroku addons:create heroku-postgresql:hobby-dev --app nombre_proyecto_heroku

En mi caso la instrucción es como sigue:

$ heroku addons:create heroku-postgresql:hobby-dev --app novatillo
Creating heroku-postgresql:hobby-dev on ⬢ novatillo... free
Database has been created and is available
 ! This database is empty. If upgrading, you can transfer
 ! data from another database with pg:copy
Created postgresql-cylindrical-56001 as DATABASE_URL
Use heroku addons:docs heroku-postgresql to view documentation

La url de la base de datos se almacena en heroku en una variable de entorno llamada DATABASE_URL que estará disponible cuando se ejecute la aplicación. Pero aun que ya tenemos la base de datos tenemos que adaptar el conector en nuestro programa para poder usarla.

Conectando la base de datos de Heroku a nuestra aplicación Python.

Para usar PostgreSQL como nuestra base de datos en una aplicación de Python lo primero que tenemos que hacer es instalar el paquete psycopg2 en el entorno virtual, que es como el driver para que sqlalchemy pueda relacionarse con la la base postgrepsql que utiliza heroku:

(venv) ~/proyecto/src $ pip install psycopg2-binary

y como es un paquete nuevo que también es necesario para que nos funcione el proyecto en heroku tenemos que añadirlo al final del archivo requirements.txt

Ahora lo que tenemos que hacer es modificar el conector en nuestro programa para que SQLAlchemy se pueda comunicar con la base de datos de heroku una vez que lo hayamos subido a su servidor . Este conector es una variable del sistema llamada DATABASE_URL por lo que tenemos que capturarla y usarla en nuestro código tal como dice el manual de Heroku. 

Para saber cual es el conector con la base de datos de heroku podemos hacerlo desde la pagina web de administración de proyectos de heroku o desde el terminal usando la siguiente instrucción:

heroku config:get DATABASE_URL -a nombre_aplicación

# Como mi aplicación se llama novatillo  
(venv) ~/proyecto/scr $ heroku config:get DATABASE_URL -a novatillo

Copiamos todo esto que nos sale, que es la uri del conector.

Ahora tendríamos que entrar en config.py dentro de la carpeta config y modificar la línea 17 para capturar la variable de entorno en donde esta la base de datos en Heroku. Le tendríamos que decir al programa, que el conector  se encuentra primero en la variable del sistema DATABASE_URL y si no es así que use la antigua de sqlite.

Sin embargo por la nota siguiente voy a usar la uri que acabamos de copiar, y la pegaremos directamente. Ya que es un string la pegaremos dentro de un par de comillas " ".  Como ves la cadena comienza por "postgres:// ", pues bien cambia la palabra "postgres" por "postgresql". Quedarías así:

¿Por qué? Lee lo siguiente:

Nota importante a la fecha en la que estoy escribiendo esto.

 El dialecto predeterminado que utiliza heroku en su base de datos es postgres y así nos lo pasan en DATABASE_URL. Sin embargo en un cambio reciente en la líbrería SQLAlchemy en la intrucción SQLALCHEMY_DATABASE_URI se espera encontrar un conector que comience por 'postgresql' para manejar este tipo de base de datos. De ahí que utilice todo el contenido de la variable y la modifique, y no capture solamente el valor de las misma. Es necesario para que la cosa funcione. Esto no quiere decir que en un futuro heroku pueda actualizar su complemento de postgres a postgresql ya no siendo necesario realizar este cambio. Si lo dejáramos tal cual tenemos este bonito error:

sqlalchemy.exc.NoSuchModuleError: Can't load plugin: sqlalchemy.dialects:postgres

Otra posible solución es utilizar una libreria de SQLALchemy inferior a la versión 1.4.0  (1.3.23 por ejemplo debería funcionar)

Nos queda otra cuestión por resolver. Hasta ahora la base de datos que teníamos era sqlite y ahora necesitamos pasar su estructura a otro sistema: PostgreSql. Para ello tenemos que migrar la base de datos. Esto lo puedes ver en más detalle en el capitulo 14, así que aquí no lo explicaré y solo pondré los pasos:

Empezamos instalando el paquete flask-migrate en nuestro entorno virtual:

(venv) ~/proyecto/src $ pip install flask-migrate

y añadimos el paquete al archivo requirements.txt (Flask-Migrate==3.0.1)

Ahora en el archivo principal de la aplicación inicio.py tenemos que importar Migrate desde flask_migrate:

y declararla después de db=SQLAlchemy(app)

El proceso de migración es sencillo. Desde el terminal del entorno virtual inicializamos la migración. Entramos en el directorio src, si no lo estamos ya. Lo primero le decimos a Flask cual es la aplicación principal, más tarde haremos lo mismo en heroku. Lo hacemos creando una variable de entorno.

(venv) ~/proyecto/src $ export FLASK_APP=inicio.py

Seguidamente iniciamos la migración con:

(venv) ~/proyecto/src $ flask db init

y realizamos la primera migración:

(venv) ~/proyecto/src $ flask db migrate -m "preparando para heroku"

Si te fijas dentro del directorio src que tenemos en local se ha creado un nuevo directorio llamado "migrations". 

El último paso de la migración se realizará directamente cuando se ejecute la aplicación en heroku ya que si recuerdas al principio del capitulo creamos un archivo llamado Procfile, en el que usamos la última instrucción que necesitamos "flask db upgrade". Esta creará las tablas en la base de datos de heroku y pasará automáticamente los datos que tengamos en ella.

web: flask db upgrade; gunicorn inicio:app

Creación del repositorio git, configuración y subida del proyecto a heroku.

Para subir nuestro programa a Heroku hay que crear un repositorio de git. 

Claro esta que si no lo tienes instalado lo primero es descargarlo y configurarlo. Si no lo tienes ve al paso 1) y si ya lo tienes pasa al 2)

1) Ve a la página de github y create una cuenta (sign up). Te pedirá un usuario y una cuenta de correo.

Para instalar el cliente git en el ordenador, en una pi que usa Debian, o en ubuntu como estoy yo usamos:

$ sudo apt-get install git

Una vez instalado el cliente de git tenemos que configurar nuestro nombre de usuario y dirección de correo electrónico.

$ git config --global user.name "nombre_usuario"
$ git config --global user.email tucorreo@correo.com

Si quieres ver tu configuración puedes usar la siguiente orden en el terminal:

git config --list

2) Nos metemos en la carpeta src, si no lo estamos ya y tecleamos. No hace falta estar dentro del entorno virtual pero si es importante estar en la carpeta src.

$ git init

Inicia el repositorio.

$ git status 

Vemos los archivos preparados para subir (en rojo)

$ git add .

Le decimos a git que añada todo lo que hay en el directorio en el que estamos (src) al repositorio.

$ git commit -m "paquete git para subir a heroku"

y con esto creamos el repositorio. Si te fijas se ha creado un directorio llamado .git oculto dentro del directorio src. Ahí esta el repositorio. Si más adelante quieres borrar el repositorio solo tienes que borrarlo.

Ahora enlazamos la aplicación que hemos creado en Heroku (novatillo en mi caso) con la aplicación o repositorio de flask que tenemos en el ordenador.

# heroku git:remote nombre_aplicación
$ heroku git:remote novatillo

Todo esto lo hacemos dentro de la carpeta src.

Ahora que tenemos el proyecto enlazado lo subimos a heroku (¡por fin!)

$ git push heroku master

y si todo va bien, comprimirá la aplicación, subirá los archivos, instalará los paquetes y ya tendremos la aplicación subida y el link de nuestra aplicación en Heroku:

Pero antes de acceder y como el primero de los dos subcomandos que usamos en el archivo Procfile

Procfile: Heroku Procfile.

web: flask db upgrade; gunicorn inicio:app

está basado en un comando de flask, al igual que hicimos cuando iniciamos la migración en local, necesitamos añadir la variable FLASK_APP al entorno de Heroku 

$ heroku config:set FLASK_APP=inicio.py

y ya esta todo. 

Si navegamos a la página que nos ha facilitado heroku https://(nombre_proyecto).herokuapp.com veremos nuestro proyecto funcionando en el servidor:

Anexo.

Otros comandos de heroku cli que nos pueden ser útiles son:

Establecer una variable de entorno en Heroku

$ heroku config:set FLASK_APP=inicio.py

Ejecutar un comando en la consola de la aplicación en heroku. En este caso una que nos muestre el historial de 
migraciones

# heroku run -a nombre_aplicación (orden a ejecutar)
$ heroku run -a novatillo flask db history

Podríamos haber hecho el upgrade de la migración no poniendo el comando automáticamente en el archivo Procfiles sino usando la consola de esta forma:

Upgrade de la migración

$ heroku run -a novatillo flask db upgrade

Próximo Capítulo. Flask 22. Desplegar una aplicación de Flask en un contenedor de Docker.

Apendice. Uso de MySql o MariaDB en un proyecto Flask.

Anteriormente. FLASK 20 Desplegar una aplicación en Flask con Nginx y Gunicorn.

La base de datos que he usado durante el desarrollo del proyecto está muy bien para aplicaciones simples, pero si queremos implementar un servidor web completo, que puede necesitar manejar multiples solicitudes a la vez, es mejor utilizar una base de datos más robusta. Por esa razón voy a explicar como configurar una base de datos de tipo MySql en concreto MariaDB.

MariaDb es una base de datos opensource basada en MySql y que es compatible con la misma.

Lo primero que haré será instalarlo. Para ello abrimos un terminal y comenzamos actualizando los repositorios:

$ sudo apt-get update
$ sudo apt-get full-upgrade

Una vez actualizado el software de la Raspberry, procedemos a instalar MariaDB:

$ sudo apt-get install mariadb-server 

Con esto ya tenemos instalado MariaDB. Ahora vamos a tratar de configurarlo. Para ello escribimos el siguiente comando:

$ sudo mysql_secure_installation

Este comando aunque se llame mysql se puede usar con MariaDB. Lo primero que nos pide es que escribamos nuestra contraseña actual, pero como acabamos de instalarla no tenemos ninguna por lo que simplemente le damos un Enter.

Luego nos pregunta si queremos establecer una contraseña para el usuario root. Yo no voy a ponerla con lo cual presiono "n". (pero tu puedes ponerla sin problemas)

A continuación nos pregunta si queremos eliminar los usuarios anónimos, lo que si vamos a hacer. Presionamos "y"

También nos pregunta si queremos desactivar el acceso remoto, a lo que contestamos que si ya que en nuestro proyecto todas las consultas a la base de datos se realizarán de forma local.

Nos preguntará si queremos eliminar la base de datos de prueba a lo que también contestamos que si. "y"

Y para finalizar nos dirá si queremos recargar los privilegios de la tabla ahora. Contestamos que si "y"

Y ya la tenemos configurada. Otra forma es dejar las opciones por defecto pulsando simplemente Enter a cada pregunta lo que viene a ser los mismo.

Para ver que versión tenemos instalada podemos teclear:

$ mysql --version

Bien ahora que ya lo tenemos preparado vamos a ejecutar MariaDB, 

$ sudo mysql

Este comando nos conecta con MariaDB y nos mostrará su prompt donde podemos crear base de datos, usuarios etc. 

Pero lo primero que tenemos que hacer es crear un usuario nuevo adicional con privilegios que es el que usaremos en nuestro proyecto. Ejecutaremos el siguiente comando:

MariaDB [(none)]> GRANT ALL ON *.* TO 'usuario'@'localhost' IDENTIFIED BY 'password' WITH GRANT OPTION;

En donde 'usuario' es el nombre del nuevo usuario que utilizaremos en nuestra base de datos.

En donde 'localhost' es la dirección de red de la base de datos, en nuestro caso al trabajar en local usaremos localhost.

En donde 'password' es la contraseña del usuario para la base de datos.

Voy a comprobar si todo ha quedado bien. Para ello reiniciamos la tabla para que pueda reconocer mi nuevo usuario.

MariaDB [(none)]> FLUSH PRIVILEGES;

Ahora ya podemos salir de la base de datos con:

MariaDB [(none)]> EXIT;

y testearemos si mariadb está ejecutándose  y el usuario ha quedado bien registrado.

$ sudo systemctl status mariadb

Vemos que el servicio mariadb esta activo y ejecutándose y si queremos saber más sobre el shell de MariaDB podemos usar:

$ sudo mysqladmin version

ffgfg

Vamos a testear nuestro nuevo usuario. Para ello nos volveremos a conectar con el nuevo usuario que hemos creado.

$ mysql -u usuario -p

Nos preguntará la contraseña que hemos definido antes y si todo ha ido bien, veremos algo como esto:

Y desde aquí ya podemos crear la base de datos que vamos a utilizar en el proyecto.

MariaDB [(none)]> create database mibase;

o si quieres crear la base de datos usando el juego de caracteres utf-8:

MariaDB [(none)]> CREATE DATABASE mibase CHARACTER SET utf8 COLLATE utf8_bin;

Nota: si te confundes de nombre de la base y quieres borrarla, si tienes permisos sobre ella puedes hacerlo con:

MariaDB [(none)]> DROP DATABASE nombre_de_la_base_a_borrar;  

Podemos ver si ha quedado correctamente creada usando el siguiente comando, que nos muestra las bases de datos que tiene asignadas mariadb:

MariaDB [(none)]> show databases;

En el post anterior de como desplegar una aplicación en raspberry pi hemos utilizado la aplicación del post 19 así que vamos utilizar ese ejemplo, para pasar de una base de datos sqlite que utiliza a MariaDB. 

IMPORTANTE: para que todo funcione correctamente tenemos que instalar un driver que haga de enlace o controle la base de datos MariaDB desde python. Esto es muy sencillo solo tenemos que instalar el  paquete pymysql dentro de nuestro entorno virtual.

Entramos en el entorno virtual de la aplicación de ejemplo:

pi@raspberry:~/miproyecto $ source ./miEntorno/bin/activate

e instalamos el siguiente paquete, que es el driver que nos va a servir de enlace:

(miEntorno) pi@raspberry:~/miproyecto $ pip install pymysql

Como ya vimos en el post 14 sobre Flask para dejar de usar sqlite y usar la base de datos que hemos creado tendremos que hacer unos sencillos pasos, además de instalar el driver que acabamos de  hacer.

1) En el archivo de configuración de nuestra aplicación (config.py) tenemos que cambiar el conector de sqlite y usar el conector de Mariadb.

Si usaste tu propio nombre de usuario, contraseña o nombre de la base de datos tendrás que modificarlo en el conector.

Los míos eran:

usuario = usuario

contraseña = password

nombre de la base de datos mariadb = mibase

2) Migración de la base de datos creada, pero no hemos adaptado su estructura a los campos que ya tenemos creados en la aplicación. Para eso tenemos que realizar una migración. Seguimos los siguientes pasos.

a) Instalamos, sino lo tenemos ya, el paquete flask-migrate

(miEntorno) $ pip install flask-migrate

Ahora tenemos que importarlo y declararlo en el archivo de la aplicación inicio.py.

Bien como nuestra aplicación inicial, no se llama app.py ni wsgi.py, tenemos que decirle a Flask, para que haga lo mostraré a continuación, cual es nuestra aplicación principal. Para ello solo tenemos que teclear lo siguiente:

(miEntorno) $ export FLASK_APP=inicio.py

Esto solo dura mientras tengas la sesión abierta, si la cierras y vuelves a entrar tendrás que teclearlo de nuevo.

Vamos al lio. Alembic (el framework de migración utilizado por Flask-Migrate) va a realizar los cambios en la estructura de la base de datos de forma que no tengamos que volver a crearla desde cero.  Pues bien, una vez que le hemos dicho a flask cual es nuestra aplicación principal tecleamos:

(miEntorno) $ flask db init
creating directory /14/migrations ...  done
  Creating directory /14/migrations/versions ...  done
  Generating /14/migrations/alembic.ini ...  done
  Generating /14/migrations/README ...  done
  Generating /14/migrations/env.py ...  done
  Generating /14/migrations/script.py.mako ...  done
  Please edit configuration/connection/logging settings in '/14/migrations/alembic.ini' before proceeding.

Después de haber ejecutado este comando te encontrarás un nuevo directorio en el directorio de trabajo llamado migrations con unos cuantos archivos y un subdirectorio llamado versions (que contendrá las modificaciones que hagamos a la estructura de la base de datos)

Cuando hagamos una migración, Alembic, comparará la estructura almacenada en sus directorios con la actual que tengamos definida en nuestro programa y realizará los cambios. Como esta es la primera vez que ejecutaremos el comando y previamente no hay nada, lo que hará será crear tanto el archivo de la base de datos como su estructura. Y lo creará en el directorio y con el nombre que hayamos especificado dentro del archivo de configuración del proyecto, en nuestro caso en:

# Cadena de conexion
SQLALCHEMY_DATABASE_URI = 'mysql+pymysql://usuario:password@localhost/mibase'

b) Realizamos la migración. Nos situamos en el mismo directorio donde está inicio.py, si no estamos ya, y tecleamos:

(miEntorno) pi@raspberry:~/miproyecto $ flask db migrate -m "migracion mariaDB"
INFO  [alembic.runtime.migration] Context impl MySQLImpl.
INFO  [alembic.runtime.migration] Will assume non-transactional DDL.
INFO  [alembic.autogenerate.compare] Detected added table 'usuario'
  Generating
  /home/pi/miproyecto/migrations/versions/2fa6cb75c75d_migracion_mariadb.py ...  done

El programa acaba de generar un script para poder migrar la base de datos con un identificador único 2fa6cb75c75d (en tu caso será otro distinto). El comentario de la opción -m es opcional y añade una breve descripción de texto a la migración.

c) Consolidar la migración. 

(miEntorno) pi@raspberrry:~/miproyecto $ flask db upgrade
INFO  [alembic.runtime.migration] Context impl MySQLImpl.
INFO  [alembic.runtime.migration] Will assume non-transactional DDL.
INFO  [alembic.runtime.migration] Running upgrade  -> 2fa6cb75c75d, migracion mariaDB

Y listo ya tenemos nuestra base de datos, mibase, con sus tablas y sus registros preparados y listos para trabajar. 

Instalar phpMyadmin para gestionar nuestra base de datos MariaDB.

PhpMyAdmin es una herramienta escrita en php con la intención de poder manejar bases de datos de tipo Mysql a través de páginas web, utilizando un navegador web. Con el podemos hace de todo en la base de datos mysql de una forma visual.

 Actualmente puede crear y eliminar Bases de Datos, crear, eliminar y alterar tablas, borrar, editar y añadir campos, ejecutar cualquier sentencia SQL, administrar claves en campos, administrar privilegios, exportar datos en varios formatos y está disponible en 72 idiomas

El método para realizar la instalación, es tener primero tanto el apquete mariadb-server como maríadb-client. Luego podemos instalar phpmyadmin con el siguiente comando:

• $ sudo apt-get install phpmyadmin

Durante la instalación nos preguntará que servidor queremos utilizar para sevir las páginas si apache o ligthtpd. Si quieres usar nginx también se puede. Puedes conseguir información en esta web.

Si todo ha ido correcto al ir al navegador y teclear:

https://nombredelservidor_or_IP/phpmyadmin

Deberías ver la pantalla de bienvenida y a partir de ahí con el usuario que hemos definido previamente poder entrar en la aplicación.

Puedes encontrar más información sobre instalar phpMyAdmin es el blog "usuariodebian.blogspot.com"

Código del Capitulo en GitHub. Ten en cuenta que la base de datos mibase no está incluida tienes que crearla tu y cambiar el conector por el nombre de tu usuario y contraseña ya que se partio en el ejemplo de una base sqlite3.

Próximo Capítulo. Desplegar una aplicación de Flask en Heroku.