Para crear una base de datos y sus tablas para una aplicación web de Flask necesitamos tener un contexto de aplicación de la misma. Ese será nuestro propósito a cumplir en este tutorial.

Vale la pena recordar que se recomienda utilizar un entorno virtual para instalar los paquetes de flask y flask_sqlalchemy que son los que se necesitan como mínimo para crear una aplicación de flask y controlar la base de datos a través de SQLAlchemy.

Si ya se sabe de antemano cómo crear un entorno virtual de Python, activarlo e instalar paquetes dentro entonces, puedes saltar a la sub-sección: “¿Cómo verificar las versiones de paquetes instalados dentro de un entorno virtual de Python?”.

Si ya se conoce de antemano que existe un problema al crear la base de datos como el siguiente:

This typically means that you attempted to use functionality that needed
the current application. To solve this, set up an application context
with app.app_context(). See the documentation for more information. 

Entonces se puede saltar a la sección de: “¿Cómo crear una aplicación de Flask con una base de datos?”.

Si ya se tiene una base de datos, y sólo desconocido cómo solucionar el problema del uso de el contexto de aplicación de flask, entonces se puede saltar a la sección de: “¿Cómo crear una base de datos utilizando un contexto de aplicación de Flask?”, y leer de allí en adelante, después de todo esa es la sección que explica el propósito principal de este tutorial.

 ¿Cómo crear un entorno virtual de Python?

Para crear un entorno virtual de Python (donde se instalarán los paquetes después) debemos ejecutar:

python3 -m venv env

El comando anterior crear un entorno virtual con el nombre de “env” (se puede utilizar cualquier otro nombre).

 ¿Cómo activar un entorno virtual de Python?

Para activar un entorno virtual de Python debemos ejecutar un comando cuya sintaxis depende del sistema operativo que se utilice. A continuación de muestran las formas más comunes:

Para GNU/Linux (bash): source env/bin/activate

Para Windows (cmd/símbolo del sistema): env\Scripts\bin\activate

Para Windows (powershell):

• Primero hay que establecer la política de ejecución para archivos ejecutables (scripts).
• Después hay que ejecutar el archivo ejecutable: activate.ps1 para activar el entorno virtual de python.

Como se puede observar, hay pasos adicionales para activar el entorno virtual de Python en Windows utilizando Powershell. Existen distintas maneras de lograrlo, a continuación, les muestro las que podrían ser recomendadas para este caso en específico:

Set-ExecutionPolicy -ExecutionPolicy AllSigned -Scope CurrentUser

El comando anterior habilitará la ejecución de archivos ejecutables firmados (scripts) para el usuario actual.

Solo después de haber ejecutado el comando anterior es que podremos ejecutar el siguiente comando:

.\env\Scripts\Activate.ps1

Entonces saldrá un mensaje en la ventana de Powershell que dirá más o menos lo siguiente:

_{env\Scripts\Activate.ps1 is published by CN=Python Software Foundation, O=Python Software
Foundation, L=Wolfeboro, S=New Hampshire, C=US and is not trusted on your system. Only run scripts from trusted
publishers.
[V] Never run [D] Do not run [R] Run once [A] Always run [?] Help (default is “D”):}

Allí colocaremos la letra “R” o “A”. “R” para confiar en el script por una sesión, o “A” para confiar en el script siempre. Yo les recomiendo la “R”, aunque para este caso podríamos responder con “A” ya que utilizaremos un script conocido y regularmente utilizado, y como se puede observar en el anterior mensaje pues está firmado por Python Software Foundation.

Y eso sería todo para activar el entorno virtual de Python en Powershell (Windows). Para volver a cambiar la política de ejecución de scripts a como estaba antes basta con ejecutar el siguiente comando:

Set-ExecutionPolicy -ExecutionPolicy Undefined -Scope CurrentUser

Para listar las distintas políticas de ejecución de scripts en Powershell, se puede ejecutar:

Get-ExecutionPolicy -List

Y con una combinación de todo lo aprendiendo se puede cambiar la política de ejecución de scripts para distintos contextos y con distintos niveles de confianza.

¿Cómo instalar paquetes dentro de un entorno virtual de Python?

Para instalar paquetes dentro de un entorno virtual de Python se debe de haber creado un entorno virtual de Python previamente, y además debe de estar activado. Una vez que se haya hecho lo anterior, basta con ejecutar el siguiente comando:

pip install [nombre del paquete]

Que al menos para este caso instalaremos dos paquetes:

• flask: Para crear el contexto de aplicación de flask.
• flask_sqlalchemy: Para controlar la base de datos a través de este framework.

Entonces debemos ejecutar el siguiente comando:

pip install flask flask_sqlalchemy

¿Cómo verificar las versiones de paquetes instalados dentro de un entorno virtual de Python?

Ahora, para lograr nuestro objetivo primero debemos verificar las versiones de los paquetes instalados ejecutando el siguiente comando: 

pip list

El resultado de ejecutar el comando anterior será una lista de los paquetes instalados y sus versiones. Allí deberemos de verificar que nuestras versiones sean las siguientes:

• flask: Debe de ser una versión mayor o igual a 2.2.x.
• flask_sqlalchemy: Debe ser una versión mayor o igual a  3.x.x.

Si es así, entonces podremos completar las instrucciones que siguen.

¿Cómo crear una aplicación de Flask con una base de datos?

Escribiremos un archivo muy simple para crear una aplicación de flask que utilice una base de datos. El archivo será el siguiente (y para este ejemplo se guardará bajo el nombre de “app.py”):

from flask import Flask
from flask import Flask 
from flask_sqlalchemy import SQLAlchemy 
 
import os
 
BASE_DIR = os.path.dirname(__file__)
DB_FILE = os.path.join(BASE_DIR, "development.sqlite3")
DB_URI = "sqlite:///" + DB_FILE
SECRET_KEY = "123"
 
app = Flask(__name__)
app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
app.config["SQLALCHEMY_DATABASE_URI"] = DB_URI
app.config["SECRET_KEY"] = SECRET_KEY
db = SQLAlchemy(app)
 
class Log(db.Model):
    __tablename__ = "logs"
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(100), nullable=False)
    content = db.Column(db.Text)  
 
@app.route("/")
def index():
    return "Index."

Es un archivo simple llamado “app.py” que contiene las líneas necesarias de código para crear una aplicación de flask que utiliza una base de datos a través de flask_sqlalchemy (SQLAlchemy), y define un modelo “Log” para una tabla que se llamará “logs” dentro de SQL y tiene tres columnas que son: id (llave primaria númerica autoincrementable), title (cadena necesaria de máximo 100 caracteres),  y content (almacena texto). La base de datos se creará al mismo nivel que nuestro archivo “app.py” y su nombre será “development.sqlite3”. Ahora necesitamos crear esa base de datos y sus tablas para, posteriormente, poder establecer la conexión con nuestra aplicación de Flask.

¿Cómo crear una base de datos utilizando un contexto de aplicación de Flask?

Finalmente, crearemos y utilizaremos un contexto de aplicación de Flask para crear nuestra base de datos (flask_sqlalchemy/SQLAlchemy).

Hay distintas maneras de lograr nuestro objetivo, la manera más simple es la siguiente:

• Activar el entorno virtual de python donde se hayan instalado los paquetes de flask y flask_sqlalchemy.
• Acceder a una shell con un contexto de aplicación de flask, para ello ejecutando el comando: flask shell.

Una vez estemos dentro de la sesión interactiva (al haber ejecutado “flask shell“), vamos a escribir lo siguiente:

>>> db.create_all()

Nótese que los signos “>>> ” no deben de escribirse, esos son solo signos que aparecen para indicar que se está dentro de la sesión interactiva de Python con un contexto de aplicación de flask. Para que quede claro, una vez que se haya ejecutado “flask shell“, dentro de dicha sesión se debe de ejecutar (escribir y presionar la tecla “Enter”): “db.create_all()“.

Y listo, ahora podemos verificar que al mismo nivel de nuestro archivo “app.py” hay un archivo llamado “development.sqlite3” que es nuestra base de datos, y que podemos examinar al ejecutar “sqlite3 developmente.sqlite3” (se debe de tener instalado sqlite3) para abrir una sesión interactiva, y entonces dentro ejecutaremos “.schema” (sí, es necesario añadir el signo “.” como prefijo antes de “schema”) para observar el esquema de la base de datos; si se utilizó el archivo de ejemplo entonces debería de haber un esquema para la tabla “logs”.

Y listo, eso es todo. Pero antes de terminar, se debe decir que hay otra manera de lograr exactamente lo mismo, y es la siguiente:

• Abrir una sesión interactiva de Python, para ello hay que ejecutar: python3.
• Dentro de la sesión interactiva hay que importar los objetos de app y db.
• Crear un contexto de aplicación de flask.
• Crear la base de datos.

Los anteriores pasos se verían así:

python3

Entonces dentro de la sesión interactiva de python, se ejecutará lo siguiente:

>>> from app import app, db
>>> with app.app_context():
>>>    db.create_all()
>>> exit()

* Nótese que los signos “>>> ” no debe de escribirse, esos son solo signos que aparecen para indicar que se está dentro de la sesión interactiva de Python.

Es muy importante notar que la línea de “db.create_all()” tiene como prefijo una identación. Dicha identación se puede agregar presionando la tecla <Tab> o colocando espacios (se deberá usar la misma cantidad de espacios en cada identación para mantener la consistencia en los bloques de código, por supuesto, aquí es simple porque solo hacemos una identación en esta sesión interactiva) con la barra espaciadora.

Después de eso el resultado debería ser el mismo, que es tener el archivo “development.sqlite3” que es nuestra base de datos para nuestra aplicación.

Ahora sí, eso es todo. Espero que haya sido de utilidad este tutorial.