👉 Cómo Desplegar una Aplicación Flask con SQLite en la Nube

Hemos desarrollado una aplicación web con Flask y SQLite. Ahora es momento de desplegarla en la nube para que cualquier persona pueda acceder a ella.

Hoy aprenderás:
✔️ Opciones para desplegar Flask en la nube
✔️ Cómo preparar la aplicación para producción
✔️ Usar Render o Railway para subir Flask con SQLite
✔️ Ejemplo paso a paso con un despliegue real

📌 Con este tutorial, podrás publicar tu aplicación Flask en internet.

---

1️⃣ Opciones para Desplegar Flask con SQLite

Existen varias opciones para hospedar una aplicación Flask en la nube. Algunas de las más recomendadas son:

✅ Render → Plataforma gratuita y fácil de usar para Flask y SQLite.
✅ Railway → Alternativa moderna con soporte para bases de datos.
✅ Heroku → Requiere configuraciones extra, pero es popular.
✅ VPS (Digital Ocean, AWS, Linode) → Más avanzado, pero con mayor control.

Hoy usaremos Render, ya que permite subir Flask con SQLite fácilmente.

---

2️⃣ Preparar la Aplicación Flask para Producción

Antes de desplegar, debemos crear un entorno virtual y configurar dependencias.

📌 Pasos previos:

1️⃣ Crea un entorno virtual en la carpeta de tu proyecto:

python -m venv venv
source venv/bin/activate  # En Mac/Linux
venv\Scripts\activate  # En Windows

2️⃣ Instala Flask y dependencias necesarias:

pip install flask gunicorn

3️⃣ Crea un archivo requirements.txt con las dependencias:

pip freeze > requirements.txt

📌 Este archivo es necesario para que Render instale las dependencias automáticamente.

---

3️⃣ Subir la Aplicación a GitHub

Para desplegar en Render, primero necesitamos subir el proyecto a GitHub.

📌 Pasos para subir el código a un repositorio:

git init
git add .
git commit -m "Primera versión de la app Flask"
git branch -M main
git remote add origin https://github.com/tuusuario/tu-repositorio.git
git push -u origin main

✅ Ahora el código está en GitHub y listo para ser desplegado.

---

4️⃣ Desplegar Flask con SQLite en Render

Render permite ejecutar Flask con bases de datos SQLite fácilmente.

📌 Pasos para el despliegue:

1️⃣ Ve a Render y crea una cuenta.
2️⃣ En New Web Service, selecciona tu repositorio de GitHub.
3️⃣ En Build Command, escribe:

pip install -r requirements.txt

4️⃣ En Start Command, escribe:

gunicorn -b 0.0.0.0:10000 app:app

5️⃣ Configura el puerto en 10000 y despliega la aplicación.

📌 Después del proceso, tu aplicación Flask estará en línea.

✅ Ejemplo de URL:

https://mi-aplicacion-flask.onrender.com

---

5️⃣ Probar la Aplicación en Producción

📌 Para probar que funciona correctamente, visita:

https://mi-aplicacion-flask.onrender.com/tareas

Si todo está bien, deberías ver los datos de SQLite en JSON:

[
    {"id": 1, "descripcion": "Aprender Flask", "estado": "Pendiente"},
    {"id": 2, "descripcion": "Deploy con Render", "estado": "Completado"}
]

✅ Tu aplicación Flask con SQLite ahora está accesible en internet.

---

🚀 Conclusión

✅ Render permite desplegar Flask con SQLite fácilmente.
✅ Configurar dependencias y subir el código a GitHub es clave.
✅ Una vez en la nube, cualquier persona puede acceder a la API Flask.

📌 Próximo post: Cómo conectar Flask con una base de datos PostgreSQL en producción.

📂 Código disponible en mi GitHub: github.com/josecodetech

🎥 Aprende con mis videos en YouTube: https://www.youtube.com/@josecodetech

💬 ¿Has desplegado una aplicación Flask antes? ¿Qué plataforma usaste? Cuéntamelo.

👉 Ejercicios Prácticos con Flask y SQLite en Python

Ya aprendimos a conectar SQLite con Flask para crear aplicaciones web dinámicas. Ahora es momento de poner en práctica lo aprendido con ejercicios explicados paso a paso.

Hoy resolveremos ejercicios sobre:
✔️ Conectar Flask con una base de datos SQLite
✔️ Crear una API para insertar y consultar datos
✔️ Actualizar y eliminar registros desde la web
✔️ Ejemplo práctico con un sistema de gestión de tareas

📌 Cada ejercicio incluye código, explicación y prueba de salida.

---

1️⃣ Ejercicio: Crear la Base de Datos SQLite y una Tabla de Tareas

📍 Objetivo: Crear una base de datos tareas.db y una tabla tareas.

🔹 Código:

import sqlite3

conexion = sqlite3.connect("tareas.db")
cursor = conexion.cursor()

cursor.execute("""
CREATE TABLE IF NOT EXISTS tareas (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    descripcion TEXT,
    estado TEXT
)
""")

conexion.commit()
conexion.close()
print("Base de datos y tabla de tareas creadas exitosamente.")

📌 Salida esperada:

Base de datos y tabla de tareas creadas exitosamente.

✅ Este código crea la base de datos SQLite con una tabla de tareas.

---

2️⃣ Ejercicio: Crear una API con Flask para Obtener las Tareas

📍 Objetivo: Crear una API con Flask para obtener todas las tareas almacenadas en SQLite.

🔹 Código:

from flask import Flask, jsonify
import sqlite3

app = Flask(__name__)

def get_db_connection():
    conexion = sqlite3.connect("tareas.db")
    conexion.row_factory = sqlite3.Row
    return conexion

@app.route("/tareas", methods=["GET"])
def obtener_tareas():
    conexion = get_db_connection()
    cursor = conexion.cursor()
    cursor.execute("SELECT * FROM tareas")
    tareas = cursor.fetchall()
    conexion.close()
    
    tareas_json = [{"id": tarea["id"], "descripcion": tarea["descripcion"], "estado": tarea["estado"]} for tarea in tareas]
    
    return jsonify(tareas_json)

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

📌 Salida esperada en http://127.0.0.1:5000/tareas:

[
    {"id": 1, "descripcion": "Terminar proyecto", "estado": "Pendiente"},
    {"id": 2, "descripcion": "Enviar informe", "estado": "Completado"}
]

✅ Esta API permite obtener todas las tareas almacenadas en la base de datos.

---

3️⃣ Ejercicio: Agregar Tareas a la Base de Datos Desde una API

📍 Objetivo: Permitir que los usuarios agreguen tareas mediante una API Flask.

🔹 Código:

from flask import request

@app.route("/tareas", methods=["POST"])
def agregar_tarea():
    nueva_tarea = request.json
    conexion = get_db_connection()
    cursor = conexion.cursor()
    
    cursor.execute("INSERT INTO tareas (descripcion, estado) VALUES (?, ?)",
                   (nueva_tarea["descripcion"], nueva_tarea["estado"]))
    
    conexion.commit()
    conexion.close()
    
    return jsonify({"mensaje": "Tarea agregada correctamente"}), 201

📌 Ejemplo de JSON enviado en una petición POST:

{
    "descripcion": "Aprender Flask",
    "estado": "Pendiente"
}

📌 Salida esperada:

{
    "mensaje": "Tarea agregada correctamente"
}

✅ Este código permite que los usuarios añadan tareas a la base de datos.

---

4️⃣ Ejercicio: Actualizar el Estado de una Tarea

📍 Objetivo: Modificar el estado de una tarea en la base de datos.

🔹 Código:

@app.route("/tareas/<int:id>", methods=["PUT"])
def actualizar_tarea(id):
    datos = request.json
    conexion = get_db_connection()
    cursor = conexion.cursor()
    
    cursor.execute("UPDATE tareas SET estado = ? WHERE id = ?", (datos["estado"], id))
    
    conexion.commit()
    conexion.close()
    
    return jsonify({"mensaje": "Tarea actualizada correctamente"})

📌 Ejemplo de JSON enviado en una petición PUT:

{
    "estado": "Completado"
}

📌 Salida esperada:

{
    "mensaje": "Tarea actualizada correctamente"
}

✅ Este código permite actualizar el estado de una tarea específica.

---

5️⃣ Ejercicio: Eliminar una Tarea de la Base de Datos

📍 Objetivo: Borrar una tarea de la base de datos SQLite.

🔹 Código:

@app.route("/tareas/<int:id>", methods=["DELETE"])
def eliminar_tarea(id):
    conexion = get_db_connection()
    cursor = conexion.cursor()
    
    cursor.execute("DELETE FROM tareas WHERE id = ?", (id,))
    
    conexion.commit()
    conexion.close()
    
    return jsonify({"mensaje": "Tarea eliminada correctamente"})

📌 Salida esperada al eliminar una tarea:

{
    "mensaje": "Tarea eliminada correctamente"
}

✅ Útil para eliminar registros innecesarios.

---

🚀 Conclusión

✅ Hoy hemos resuelto ejercicios con Flask y SQLite en Python.
✅ Estos ejercicios permiten crear APIs para gestionar tareas desde una base de datos.
✅ Practica modificando el código para entenderlo mejor.

📌 Próximo post: Cómo desplegar una aplicación Flask con SQLite en la nube.

📂 Descarga los ejercicios en mi GitHub: github.com/josecodetech

🎥 Aprende con mis videos en YouTube: https://www.youtube.com/@josecodetech

💬 ¿Te gustaría agregar nuevas funciones a este proyecto? ¡Coméntalo!

👉 Conectando SQLite con una Aplicación Web en Python: Flask y Bases de Datos

 

Hemos aprendido a manejar bases de datos SQLite en Python. Ahora daremos un paso más: conectar SQLite con una aplicación web usando Flask.

Hoy aprenderás:
✔️ ¿Qué es Flask y por qué usarlo?
✔️ Cómo conectar Flask con SQLite
✔️ Crear una API para interactuar con la base de datos
✔️ Consultar y mostrar datos en una página web
✔️ Ejemplo práctico paso a paso

📌 Con este tutorial, podrás construir aplicaciones web dinámicas con bases de datos.

---

1️⃣ ¿Qué es Flask y por qué usarlo?

Flask es un framework ligero para crear aplicaciones web en Python.

📌 Ventajas de Flask:
✅ Fácil de aprender y usar
✅ Permite crear APIs y páginas web dinámicas
✅ Compatible con bases de datos como SQLite
✅ Ideal para proyectos pequeños y medianos

Para instalar Flask, ejecuta:

pip install flask

---

2️⃣ Conectar Flask con SQLite

El primer paso es crear un archivo app.py y configurar la conexión con SQLite.

📌 Código para conectar Flask con SQLite:

from flask import Flask, g
import sqlite3

app = Flask(__name__)
DATABASE = "mi_base.db"

def get_db():
    db = getattr(g, "_database", None)
    if db is None:
        db = g._database = sqlite3.connect(DATABASE)
    return db

@app.teardown_appcontext
def close_connection(exception):
    db = getattr(g, "_database", None)
    if db is not None:
        db.close()

📌 Explicación:
✅ sqlite3.connect(DATABASE) → Conecta SQLite con Flask.
✅ get_db() → Obtiene la conexión a la base de datos.
✅ @app.teardown_appcontext → Cierra la conexión cuando termina la petición.

---

3️⃣ Crear una API con Flask y SQLite

Vamos a crear una API REST que devuelva los datos almacenados en SQLite.

📌 Código para obtener todos los registros de una tabla productos:

from flask import jsonify

@app.route("/productos", methods=["GET"])
def get_productos():
    db = get_db()
    cursor = db.cursor()
    cursor.execute("SELECT * FROM productos")
    productos = cursor.fetchall()
    
    productos_json = [
        {"id": p[0], "nombre": p[1], "precio": p[2], "stock": p[3]} for p in productos
    ]
    
    return jsonify(productos_json)

📌 Explicación:
✅ @app.route("/productos") → Define una ruta para obtener los productos.
✅ jsonify(productos_json) → Devuelve los datos en formato JSON.

📌 Salida esperada al visitar http://127.0.0.1:5000/productos en el navegador:

[
    {"id": 1, "nombre": "Laptop", "precio": 1200.5, "stock": 10},
    {"id": 2, "nombre": "Mouse", "precio": 25.99, "stock": 50}
]

---

4️⃣ Insertar Datos desde una API Flask

También podemos permitir que los usuarios envíen datos a la base de datos.

📌 Código para insertar productos en la base de datos:

from flask import request

@app.route("/productos", methods=["POST"])
def add_producto():
    nuevo_producto = request.json
    db = get_db()
    cursor = db.cursor()
    
    cursor.execute("INSERT INTO productos (nombre, precio, stock) VALUES (?, ?, ?)",
                   (nuevo_producto["nombre"], nuevo_producto["precio"], nuevo_producto["stock"]))
    
    db.commit()
    return jsonify({"mensaje": "Producto agregado correctamente"}), 201

📌 Explicación:
✅ request.json → Recibe los datos enviados en formato JSON.
✅ INSERT INTO productos (...) VALUES (...) → Inserta un nuevo registro en la base de datos.

📌 Ejemplo de JSON enviado en una petición POST:

{
    "nombre": "Teclado",
    "precio": 45.75,
    "stock": 30
}

✅ El producto se agregará a la base de datos y la API responderá con un mensaje de éxito.

---

5️⃣ Mostrar los Datos en una Página Web con Flask y SQLite

Flask también nos permite mostrar los datos en una página HTML en lugar de JSON.

📌 Código para mostrar los productos en una plantilla HTML:

from flask import render_template

@app.route("/")
def index():
    db = get_db()
    cursor = db.cursor()
    cursor.execute("SELECT * FROM productos")
    productos = cursor.fetchall()
    
    return render_template("index.html", productos=productos)

📌 Plantilla templates/index.html:

<!DOCTYPE html>
<html>
<head>
    <title>Lista de Productos</title>
</head>
<body>
    <h1>Productos Disponibles</h1>
    <ul>
        {% for producto in productos %}
            <li>{{ producto[1] }} - Precio: {{ producto[2] }} USD - Stock: {{ producto[3] }}</li>
        {% endfor %}
    </ul>
</body>
</html>

📌 Explicación:
✅ render_template("index.html") → Carga una plantilla HTML.
✅ {% for producto in productos %} → Muestra cada producto en la página.

📌 Salida esperada en el navegador:

Productos Disponibles
- Laptop - Precio: 1200.5 USD - Stock: 10
- Mouse - Precio: 25.99 USD - Stock: 50

✅ Esta página muestra los productos almacenados en SQLite.

---

🚀 Conclusión

✅ Flask permite conectar aplicaciones web con SQLite en Python.
✅ Podemos crear APIs REST para interactuar con la base de datos.
✅ Los datos pueden mostrarse en formato JSON o en una página HTML.

📌 Próximo post: Ejercicios prácticos con Flask y SQLite en Python.

📂 Código disponible en mi GitHub: github.com/josecodetech

🎥 Aprende con mis videos en YouTube: https://www.youtube.com/@josecodetech

💬 ¿Has trabajado con bases de datos en aplicaciones web? Cuéntamelo.