Mysql en Flask – Bases de datos Relacionales

Mysql en flask - bases de datos relacionalesBienvenidos a un nuevo post, en este caso aprenderemos a usar mysql en flask.

En este caso vamos a crear un proyecto algo un poco más profesional, un sitio web de películas con registro de usuario. Heee??

Así es, vamos a llevar al máximo todo nuestro potencial y vamos a crear un sitio web completo, que bien podría ser una aplicación para ver películas online. Algo un poco “sacado” para entrarle tan de golpe dirás.. Nah tranquilo, lo mantendremos básico y de a poco lo vas a sacar adelante y además lo vas a alojar en tu repositorio remoto para que otros desarrolladores podamos verlo!!

 

Requisitos antes de comenzar

requisitos para aprender mysql en flaskEso sí, debo pedirte que seas fiel a mis recomendaciones y cumplas con haber aprendido medianamente lo siguiente o al menos haber leído mis post; ya que de todas maneras haremos las cosas paso a paso. Profundizando y explicando todo como te tengo acostumbrado a hacerlo. Los requisitos para acceder a el siguiente nivel, son los siguientes:

 

 

  1. Haber leído todos los post que te dejé enlazados en “Resumen de flask
  2. Haber realizado los 2 ejercicios; uno incluido en el tercer módulo y el otro lo encontrarás en el “Resumen de flask” antes mencionado en forma de 5 enlaces que corresponden a una “Mega-Guía de flask“.
  3. Haber leído sobre “base de datos relacionales” que también encontrarás los enlaces dentro del “Resumen de flask”.
  4.  Saber crear y utilizar un entorno virtual y un sistema de gestión de versiones GIT y poder crear un repositorio remoto (GitHub) para trabajar mejor con este proyecto.
  5. Estar dispuesto a montar un servidor Mysql para trabajar con bases de datos relacionales en MySql. Algo que ya expliqué en otro post (Como montar un servidor XAMPP) pero lo volveremos a ver.
  6. Leer la documentación e investigar sobre las librerías que iremos utilizando a lo largo de esta serie de post que culminarán con una aplicación para mirar películas con registro de usuarios y diferentes tipos de bases de datos.
  7. Recordar que tenemos un chat a tu disposición en caso de que necesites ayuda o te encuentres con algún error que no puedes resolver. He montado un servidor de Discord para brindar ayuda de forma más eficiente y para que puedas establecer relación con otros Desarrolladores.

 

Nuestra segunda aplicación: un sitio web de películas

aplicación para ver películasPrimero lo primero, para crear algo debemos saber ¿qué? y ¿cómo va a funcionar?. Debemos conocer los requisitos para crear nuestra aplicación y para ello debemos saber que es lo que hará. Para esto he mencionado anteriormente que es mejor “tomar notas” de lo que será la aplicación y que funcionalidades tendrá, para finalmente desarrollar un “diagrama” de como estará estructurada!. Por supuesto, tal vez te imagines como va a funcionar pero no tienes aún los conocimientos como para desarrollar un diagrama de flujo completo. Pero para eso estaré yo aquí, iremos diagramando nuestra aplicación!

Veamos los requisitos de nuestra nueva app:

yodaImagina que aparece un duende en los pies de tu cama a las 4:00AM y te dice..

-“Muy rico te haré, solo programar algo tu debes.”

—“¿Y qué es eso ¡Ho maravilloso duende brillante!” que debo programar para ser rico y famoso?

-“Una aplicación programar tu debes que películas ver permita a los registrados usuarios que buscado hayan en tu sitio web pero aprobado haya un moderador subido que otros usuarios hayan..”

—“Ya jodido duende, ¿Puedes explicarme hablando normal o al menos un poco más técnico?

-“Nooo, perdido tu oportunidad tu has!. Adios!! Puf….”

Acuérdate del duende!!
Cuando alguien a veces te propone desarrolles una aplicación a veces lo hace de esta manera. Es imprescindible sentarse pacientemente e intentar elaborar medianamente un manuscrito con las funcionalidades y requisitos para elaborar la aplicación.

¿Qué es lo que realmente quiere? y ¿Qué es lo que yo puedo desarrollar y hasta donde es conveniente añadir funcionalidades?.

Recuerda el principio “Empieza cuanto antes, mantenlo sencillo, fácil y no te repitas” En fin, comienza a rezar:

“Bello es mejor que feo. Explícito es mejor que implícito. Simple es mejor que complejo. Complejo es mejor que complicado. Plano es mejor que anidado…

El zen de Python.

Ya!, supongamos alguien nos pide lo siguiente:

Deberás crear una aplicación cuya finalidad es poder buscar y mirar películas online, la misma debe cumplir los siguientes requisitos y contar con las siguientes funcionalidades:

  1. La página de inicio debe mostrar las películas ordenadas según Estrenos, géneros y las más recomendadas. Y además debe contar con un “buscador”.
  2. Debe exigir un registro de usuario para poder mirar las películas.
  3. Cada usuario contará con un panel donde pueda guardar sus películas favoritas, y donde pueda ver los estrenos, en este panel se mostrarán también sus datos y sus rangos.
  4. Cada usuario tendrá un “rango” que según lo desee el administrador del sitio les permitirá subir y borrar películas del sitio. Los mismos serán los siguientes: “viewer”, “uploader”, “moderator”. Donde uploader solo podrá subir películas que deberán ser aprobadas o denegadas por “moderator” antes de poderse ver.
  5. Uploader debe tener un panel donde subir películas (solo los enlaces). Moderator debe tener un panel donde poder aceptar o denegar las películas que solicitan subir los Uploader’s.
  6. Esta aplicación debe contar con un reproductor de vídeo que pueda reproducir películas alojadas en la nube.

Ápa la papa! Nos ha quedado un ojo medio vago. ¿Verdad?.. Solo vamos a cumplir estos requisitos y añadir estas funcionalidades que se nos exigen, ni más ni menos!. Para ello debemos comenzar a imaginar lo siguiente (mientras se cumplan los requisitos lo demás queda a nuestro gusto e imaginación):

  • Habrá una página de inicio general donde se mostrarán las películas pero al momento de intentar verlas se exigirá un registro de usuario.
  • Una vez registrado el usuario deberá poder logearse, y allí obtendrá acceso a un panel que sera el de “viewer” donde solo podrá reproducir películas. Y para esto necesitamos incrustar un reproductor de películas y una lista donde pueda guardar las que le gustan.
  • Pero si un administrador otorga a algún “Viewer” el rango “Uploader” este deberá además en su panel una opción para subir películas. Y si le otorga el rango “Moderator” deberá tener además una lista de las películas subidas donde poder aceptarlas o denegarlas según si son para mayores o no aptas para ver con la abuela.
  • Osease que un “Uploader” y un “Moderator” también son viewers porque pueden querer dejar el trabajo asignado y mirarse una pelis, y sería injusto que ellos no pudieran o no tuvieran una lista de favoritas.

Ya podemos realizar algo parecido a un diagrama para orientarnos respecto de los niveles de acceso de los usuarios que visiten el sitio y como estará estructurado medianamente, por ahora algo así:

Diagrama de aplicación en flask para ver películas

Por supuesto no estamos diagramando los procesos internos, sino más bien la vista de un visitante promedio a la página web de nuestra aplicación y su circuito hasta que se registra, accede y puede ver una película. Es un más o menos funcionará así a simple vista..

Sin embargo, pensemos ahora en organizar los procesos internos, ya sabemos que vamos a contar con una base de datos donde alojaremos a los usuarios y las películas, y también deberemos programar un controlador que sea capaz de crear nuevos usuarios en base a un modelo y comprobar los datos de login de una base de datos, entre otras cosas.. Por lo que deberíamos incluir código aparte de las rutas o url’s en nuestro controlador.. ¿No sería mejor apartar la parte del registro, comprobación de login y de rango de usuario en una carpeta aparte?. Claro que sí! es una idea buenísima y más adelante te explicaré bien el porque!

Lo ideal en este caso sería tener una aplicación base que contenga una sub-aplicación encargada de la gestión de usuarios. Y a su vez ambas respeten una arquitectura MVC, por lo que nuestra sub-aplicación de gestión de usuarios será en realidad algo así como un módulo también organizado en MVC. Esto lo podemos hacer con una librería que he nombrado antes “Blueprint’s“.

Pero antes de comenzar con nuestro proyecto debemos considerar que tipo de bases de datos vamos a utilizar.

¿Qué tipo de base de datos vamos a utilizar?

Principalmente déjame decirte que a pesar de que podríamos utilizar solamente bases de datos no relacionales como ya has visto JSON; es mi deseo comenzar a utilizar bases de datos relacionales en especifico Mysql debido a que vamos a trabajar con usuarios.

Y tampoco sería necesario montar un servidor Mysql si podríamos trabajar con SQLite. Pero, quiero que aprendas Mysql porque este tiene un sistema de administración de usuarios bien construido y es ideal para comenzar a aprender a desarrollar aplicaciones para luego trabajar en un servidor remoto o Hosting y aprender las medidas de seguridad y autenticación correctas!!

Por otro lado si quieres leer una comparación de Mysql con SQLite aquí te dejo un enlace: Mysql vs SQLite

Pero no solo eso..

Combinar bases de datos relacionales con no relacionales.

Vamos a utilizar ambos tipos de bases de datos, principalmente vamos a crear una base de datos MySql para la gestión de usuarios y una base de datos JSON para la gestión de películas. ¿Y por qué no ponemos todo en MySql?. Te estarás preguntando..

Porque si se tratara de una aplicación real al subir las películas, las imágenes de portada y demás a la base de datos MySql estaríamos sobrecargando innecesariamente con peso y relaciones extras. Cuando perfectamente podemos almacenar las fichas de las películas (Titulo, uploader, imágenes, review, link, etc.) en un JSON con un enlace a su respectiva reproducción y comprobar mediante el controlador si determinado usuario puede o no acceder a ver esa película así como también según el rango si este puede añadir o eliminar películas.

Montar un servidor Mysql

MySql es un sistema de gestión de base de datos relacionales y el más utilizado en la actualidad. El mismo comparte las sentencias del lenguaje SQL y es necesario instalarlo como servicio local o remoto. Esto significa que deberás montar un servicio MySql en tu equipo u en otro equipo para trabajar con Mysql en flask.

Existen diversas formas de instalarlo, digamos mediante el clásico instalador de MySQL o bien podemos instalar como es mi caso XAMPP que según la wikipedia:

XAMPP es un paquete de software libre, que consiste principalmente en el sistema de gestión de bases de datos MySQL, el servidor web Apache y los intérpretes para lenguajes de script PHP y Perl.

Yo personalmente a estas alturas prefiero instalar Xampp y configurar el servidor como local aunque a veces me gusta usarlo de forma REMOTA. Si todo está bien configurado no hay porque tener miedo!. Lo que también me lleva a veces a solo encender los servicios que considero necesarios. En este caso vamos a trabajar en windows ya que me encuentro con algunos inconvenientes respecto a mi sistema linux pero de todas maneras yo ya redacte un post anteriormente sobre montar un servidor XAMMP seguro:

Guía completa: montar un servidor XAMMP seguro

De todas formas voy a colocar un vídeo aquí para que sigas mis pasos, solo en Windows por ahora:

 

 

 

 

 

  • No permitas acceso en el firewall. Y recuerda que debemos modificar en el panel de administración de XAMPP en “config” de MySQL en el archivo “my.ini” descomentar la linea “bind-address” eliminando las almohadillas.

xampp
Si realizaste las cosas como están en el vídeo, enhorabuena!!. Tienes tu servidor Apache y Mysql local!!

Recordemos los archivos de configuración importantes:

Dirección para acceder a nuestro servidor local como cliente: “127.0.0.1” o “localhost

Carpeta de instalación de XAMPP por defecto: “C:/xampp

Directorio Raíz del servidor web: “C:/xampp/htdocs

Archivo de configuración de Apache: acceder desde el panel o “C:/xampp/php/php.ini

Archivo de configuración de MySQL: acceder desde el panel o “C:/xampp/mysql/bin/my.ini

Archivo de configuración de PhpMyAdmin: “C:/xampp/phpmyadmin/config.inc.php

 

PhpMyAdmin como gestor de nuestras bases de datos

PhpMyAdmin mysql en flaskEs importante instalar y configurar PhpMyAdmin porque es el que vamos a utilizar para crear, modificar, en fin gestionar nuestras bases de datos relacionales y me resulta increíblemente sencillo y potente!. Sin duda debes aprender a utilizarlo y trabajar con el ya que es el más común y utilizado en los servidores web o hosting que funcionan con Cpanel. Y por lo que respecta a subir tu aplicación a un servidor privado de pago probablemente te encuentres con estas mismas herramientas que intento enseñarte a utilizar!

 

Crear una nueva base de datos usando PhpMyAdmin

Crear nueva base de datos en phpmyadminEs momento de crear la base de datos que vamos a utilizar para nuestros usuarios, la cual se encontrará en blanco. Tu puedes darle el nombre que sea, y puedes eliminarla y volverla a crear cuantas veces desees. Lo cierto es que para que podamos conectarnos a ella debe existir, así que vamos a ello. En Phpmyadmin verás un apartado para crear tu base de datos arriba a la izquierda donde dice “Nueva”!

En mi caso la llamare “usuarios_db“. Una vez que ingresamos el nombre hacemos clic en “Crear” y eso es todo. Luego ya debemos crear nuestro proyecto y posteriormente aprenderemos a usar mysql en flask conectando nuestra base de datos.

No vamos a modificar nada de la base de datos desde PhpMyAdmin pero si será útil para ver lo que está sucediendo dentro.

Así que ya te imaginas cual es el paso siguiente.. Comenzar con nuestro proyecto de aplicación!

 

Crear nuestra carpeta de proyecto, entorno virtual y repositorio remoto

Como ya te dije antes ahora que ya hemos creado la base de datos debemos crear nuestra carpeta donde vamos a trabajar con nuestro proyecto, crear un entorno virtual y un repositorio local / remoto para trabajar. Te recomiendo que no te lances sin repositorio al menos local porque el código se te puede hacer confuso más adelante. Aquí vamos a hacer todo desde el inicio.

Vamos a ello:

 

 

 

 

 

 

 

 

 

 

 

 

Los comandos son principalmente los siguientes, obviamente en tu caso cambiarán las ubicaciones del interprete, etc:

  1. python pip.py
  2. python -m pip install virtualenv
  3. where python / which python
  4. virtualenv venv –python=C:/python/python.exe
  5. ..venv/Scripts/activate.bat o “source /venv/bin/activate”
  6. python -m pip install flask
  7. git init
  8. git commit -m “mensaje del commit”
  9. git config –global user.email = “email@email”
  10. git config –global user.name = “TuNombreDeUsuario”
  11. git remote add origin “urldeturepositiorioremoto”
  12. git branch -m Master
  13. git push -u origin master

Y finalmente nuestro archivo “run.py“, “controlador principal” de ahora en más ha quedado así:

from flask import Flask
app = Flask(__name__)
@app.route('/')
def inicio():
    return ('Hola esta es la página de inicio')

if __name__ == '__main__':
    app.run(debug=True)
    

Nada muy especial, ¿no?. Ahora vamos a hacer la conexión con la base de datos “db_usuarios” que habíamos creado, la cual está vacía aún (no posee tablas, registros, etc). Pero antes es importante ir apartando las cosas, no queremos tener todo nuestro controlador desordenado, que la conexión, que las rutas, que la peluca de la tía. No, no!. Todo debe estar en orden en un fichero para cada fin!

 

Mysql en flask con SQLAlchemy

FLASK-SQLAlchemy es una extensión que nos provee de una serie de herramientas para manejar el modelo de datos de nuestra app; así se nos permite trabajar con SQLAlchemy (Object Relational Maper o ORM).

La importancia de un ORM

SQLAlchemy nos brinda un ORM, algo de lo que he hablado mucho en “bases de datos relacionales”, el cual es un modelo de programación que nos permite transformar las relaciones, es decir, las tablas de nuestra bases de datos relacionales en un entidad. Así podremos trabajar las tablas desde el código de nuestra aplicación como si se tratara de objetos facilitándonos y reduciendo mucho el uso del lenguaje SQL. De esta manera en vez de necesitar escribir toda una sentencia en SQL cada vez que quiera obtener un resultado o realizar una modificación en alguna tabla simplemente podremos llamar estos cambios desde nuestro código como si se tratara de los métodos o atributos de un objeto.

Fíjate por ejemplo al tratar de consultar los usuarios en la base de datos; solo necesitamos llamar el método “get_by_id” de la clase “Usuarios” y pasarle la id que estamos buscando como argumento para el parámetro “user_id“:

def load_user(user_id):
    return Usuarios.get_by_id(int(user_id))

Si ves bien las dos líneas de código anteriores son una función de python que recibe como parámetro “user_id” donde obviamente se tratará de pasarle un numero entero a la función y esta llamará al método de la clase Usuarios que es utilizado para obtener datos del usuario. Este método podría ser así:

def get_by_id(id):
        return Usuarios.query.get(id)

Esta es la magia de utilizar el ORM de SQLAlchemy, simplemente llamamos al método get() pasando el campo como argumento, en este caso el “id” según el o los cuales pretendemos se nos devuelva un resultado, es decir, se realizará una búsqueda y se devolverán los coincidentes si existen. Así que pasando por ejemplo el número “2” como argumento obtendremos el usuario cuyo id sea “2”.

Claro que esto es lo mismo que hacer una query o consulta escrita en lenguaje SQL por ejemplo (SELECT “Nombre” FROM Usuarios WHERE id = 2), pero nadie en su sano juicio preferiría escribir miles de consultas una y otra vez. Además de tener que utilizar “punteros” y abrir o cerrar la conexión a la base de datos cada vez que realice una consulta o modifique algún campo. Y en eso nos ayudará SQLAlchemy, vas a amarlo!

SQLAlchemy no solo es un ORM, sino que cuenta con un núcleo que también tiene y se encarga de otras funciones:

SQLAlchemy Bayer

Dentro de las funciones del núcleo por ejemplo se encuentra la gestión de las conexiones a la base de datos y el “Dialect” que son los distintos tipos de gestores de bases de datos con los que puede trabajar, por ejemplo “Mysql, PostgreSQL, SQLite, etc”. También tenemos el manejo del lenguaje SQL y los “Schemas o types” ya aquí hablando del manejo de datos estructurados y los diferentes tipos que acepta. Y finalmente como tercer capa tenemos las librerías compartidas y el lenguaje Python como API de manejo de la DB donde API significa “interfaz de programación de aplicaciones” y hace referencia al uso y programación en Python.

Básicamente es como si contáramos con un motor capaz de gestionar conexiones y convertir el lenguaje SQL en python y viceversa.

Es nuestro “puente” entre el código python y el lenguaje que utiliza la base de datos (SQL).

Es como un motor capaz de llevar y traer información sin tener que hablarle al gestor de la bases de datos RDBMS en su idioma.

 

Así que ya sabes!
Ahora que sabes bien lo que es SQLAlchemy podrás utilizarlo siempre en tus proyectos donde utilices Bases de datos Relacionales!. Ojalá hayas comprendido bien sus funciones y niveles o capas para que puedas explotar al máximo su potencial!! Y si quieres ser una persona un poco más sabia y experta en el tema para luego poner en tu portfolio que sabes trabajar con SQLAlchemy; no olvides leer la DOCUMENTACIÓN COMPLETA aquí: https://www.sqlalchemy.org/

Venga! Al menos hazlo usando el traductor!. Me lo agradecerás algún día no muy lejano 😉

 

Instalar e importar FLASK-SQLAlchemy

Para utilizarlo obviamente lo debemos instalar en nuestro entorno virtual de trabajo y lo hacemos usando pip:

#Recuerda que debe estar activado tu entorno virtual (venv), de lo contrario al importar tendrás errores…

pip install Flask-Sqlalchemy

Luego de instalado lo importamos en el controlador principal (run.py) y creamos una instancia de la misma que llamaremos “db”. Lo dejamos algo así:

#Import
from flask import Flask
from flask_sqlalchemy import SQLAlchemy

#Instancias
app = Flask(__name__)
db = SQLAlchemy(app)


#Rutas
@app.route('/')
def inicio():
    return ('Hola esta es la página de inicio')

#Run
if __name__ == '__main__':
    app.run(debug=True)
    

 

Imagina que alguien va a clonar tu proyecto y lo quiere “montar” de manera local para probarlo, necesitará montar también un servidor Mysql, crear la base de datos y conectar tu app a su servidor Mysql, porque claro, no vas a pensar que esta persona tendrá el mismo usuario y la misma password.. Obviamente debe existir un archivo donde se puedan cambiar estos valores y en lo personal es mejor que sea un archivo aparte. Para ello vamos a crear el archivo “config.py” donde almacenaremos todas las configuraciones de nuestra app:

Crear un archivo de configuraciones “config.py”

Creamos el archivo en nuestra carpeta del proyecto junto al controlador principal “run.py“. Luego de crear nuestro “config.py” debemos importarlo al controlador principal indicando que se trata de un archivo de configuración.

En nuestro archivo “config.py” indicamos la conexión con la base de datos, en mi caso así:

#Conexion a la base de datos
SQLALCHEMY_DATABASE_URI='mysql+pymysql://root:pythones.net@localhost/db_usuarios'
SQLALCHEMY_TRACK_MODIFICATIONS = False

Como recordarás va primero el nombre de usuario y seguido de los dos puntos la contraseña de acceso, luego el “host” en este caso localhost y luego el nombre de la base de datos.

Ahora debemos importar este archivo e indicarle al controlador principal que se trata de un archivo que almacena variables de configuración. Para ello hacemos uso del método config() del objeto app en nuestro caso que hereda de la clase Flask:

Importar config en nuestro controlador principal (run.py) y luego instanciar SQLAlchemy:

#Import
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
import config #importamos el archivo de configuración "config.py"

#Instancia +config 
app = Flask(__name__)
app.config.from_object(config)
db = SQLAlchemy(app)

#Rutas
@app.route('/')
def inicio():
    return ('Hola esta es la página de inicio')

#Run
if __name__ == '__main__':
    app.run(debug=True)

Como ves primero instanciamos la app de Flask y luego definimos la configuración para la misma en la linea siguiente para luego instanciar db de SQLAlchemy. Si inviertes estas lineas, obtendrás un error porque la app se instanciaría primero de SQLAlchemy sin aplicar las configuraciones que determinan donde encontrar la base de datos.

Pero eso no es todo, si intentas correr tu aplicación te encontrarás con un error que advierte “ModuleNotFoundError: No module named ‘pymysql'”. Esto es porque SQLAlchemy utiliza pymysql para establecer la conexión como bien lo definimos anteriormente.

Entonces debemos instalar “pymysql”:

python -m pip install pymysql

Y finalmente podremos correr nuestra app:

python run.py

Y deberíamos ver lo siguiente:

mysql en flask 1

Hasta aquí “técnicamente” estaríamos conectados a la base de datos mysql excepto que hayas colocado mal los datos de acceso a la base de datos (usuario / password / host).

mme-min

En la siguiente entrada vamos a diagramar las relaciones necesarias y crear el modelo con la clase usuario. También vamos a crear las tablas en la base de datos a partir del modelo para empezar a trabajar con registros. Así podremos ver paso a paso el proceso de creación de un nuevo registro (un usuario) y como obtener determinados valores de la base de datos mediante SQLAlchemy.

PD: No olvides:

git add .

git commit -m “Hemos conectado base de datos”

git push -u origin master


 

 

Continúa leyendo!
Entrada anterior! Siguiente entrada!(En proceso)
Compartir es agradecer! :)

Hey no te vayas sin dejarme un comentario!

Este sitio usa Akismet para reducir el spam. Aprende cómo se procesan los datos de tus comentarios.

Aprende a programar de manera profesional!

¿Todavía sin obtener una retribución justa de tu aprendizaje?

Curso de Python Udemy

Convierteté en un verdadero Jedy de Python y comienza a desarrollar aplicaciones de forma profesional obteniendo un certificado de Udemy!. Pasate por la sección de Cursos Premium y realiza los mejores cursos con certificación válida a nivel internacional por apenas unos dolares!