Programacion: marzo 2025

martes, 25 de marzo de 2025

👉 Autenticación de APIs en Flask con JWT (JSON Web Tokens)

Después de implementar autenticación con sesiones en Flask, es momento de aprender una alternativa moderna y escalable: JWT (JSON Web Tokens). Ideal para APIs RESTful.

En este post aprenderás:
✔️ Qué es JWT y para qué se usa
✔️ Cómo generar y verificar tokens en Flask
✔️ Proteger rutas con decoradores
✔️ Ejemplo práctico paso a paso

📌 JWT es ampliamente usado en APIs modernas por su seguridad y portabilidad.

1️⃣ ¿Qué es JWT?

JWT (JSON Web Token) es un estándar para transmitir información de forma segura entre dos partes.

📌 Se compone de 3 partes codificadas en base64:

Header (tipo y algoritmo)
Payload (datos del usuario)
Signature (clave secreta)

✅ Es útil para autenticar usuarios sin necesidad de sesiones.

2️⃣ Instalar dependencias

pip install flask flask_sqlalchemy pyjwt

También usaremos werkzeug.security para manejar contraseñas:

from werkzeug.security import generate_password_hash, check_password_hash

3️⃣ Generar el token JWT al iniciar sesión

import jwt
from datetime import datetime, timedelta
from flask import Flask, request, jsonify

app = Flask(__name__)
app.config["SECRET_KEY"] = "clave_super_segura"

def generar_token(usuario_id):
    payload = {
        "usuario_id": usuario_id,
        "exp": datetime.utcnow() + timedelta(hours=1)
    }
    token = jwt.encode(payload, app.config["SECRET_KEY"], algorithm="HS256")
    return token

4️⃣ Ruta de Login para devolver un JWT

@app.route("/login", methods=["POST"])
def login():
    datos = request.json
    usuario = Usuario.query.filter_by(email=datos["email"]).first()
    
    if usuario and check_password_hash(usuario.password, datos["password"]):
        token = generar_token(usuario.id)
        return jsonify({"token": token})
    
    return jsonify({"error": "Credenciales inválidas"}), 401

📌 Salida esperada:

{
  "token": "eyJhbGciOiJIUzI1NiIsInR..."
}

5️⃣ Proteger rutas con un decorador personalizado

from functools import wraps

def token_requerido(f):
    @wraps(f)
    def decorador(*args, **kwargs):
        token = request.headers.get("Authorization")
        if not token:
            return jsonify({"error": "Token requerido"}), 403
        
        try:
            datos = jwt.decode(token, app.config["SECRET_KEY"], algorithms=["HS256"])
            usuario = Usuario.query.get(datos["usuario_id"])
        except:
            return jsonify({"error": "Token inválido o expirado"}), 403
        
        return f(usuario, *args, **kwargs)
    return decorador

6️⃣ Ruta protegida usando el token

@app.route("/perfil")
@token_requerido
def perfil(usuario):
    return jsonify({
        "usuario": usuario.username,
        "email": usuario.email
    })

✅ Si el token es válido, se accede al perfil del usuario autenticado.

7️⃣ Cómo enviar el token desde el cliente

📌 En las peticiones protegidas, se debe incluir el token:

GET /perfil HTTP/1.1  
Authorization: eyJhbGciOiJIUzI1NiIsInR...

✅ Esto permite que el backend valide al usuario sin usar cookies ni sesiones.

🚀 Conclusión

✅ JWT es ideal para autenticar usuarios en APIs REST.
✅ Protege tus rutas con decoradores y claves secretas.
✅ A diferencia de Flask-Login, JWT es stateless, perfecto para microservicios.

📌 Próximo post: Cómo refrescar tokens JWT y controlar expiración.

📂 Código en GitHub: github.com/josecodetech
🎥 Tutorial en YouTube: https://www.youtube.com/@josecodetech/

💬 ¿Ya usaste JWT? ¿Prefieres sesiones o tokens? Cuéntamelo 👇

viernes, 21 de marzo de 2025

👉 Autenticación de Usuarios en Flask con PostgreSQL y SQLAlchemy

En este post aprenderás a crear un sistema de autenticación de usuarios en Flask usando PostgreSQL como base de datos.

Vamos a implementar:
✔️ Registro de nuevos usuarios
✔️ Login con verificación de credenciales
✔️ Hashing de contraseñas con Werkzeug
✔️ Mantenimiento de sesión con Flask
✔️ Ejemplo práctico con rutas protegidas

📌 Este es el primer paso para construir aplicaciones web seguras.

1️⃣ Instalar las dependencias necesarias

Asegúrate de tener Flask y PostgreSQL ya configurados. Luego, instala:

pip install flask flask_sqlalchemy psycopg2-binary flask_bcrypt flask_login

2️⃣ Configurar la app y la base de datos

from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask_bcrypt import Bcrypt
from flask_login import LoginManager

app = Flask(__name__)
app.config["SQLALCHEMY_DATABASE_URI"] = "postgresql://mi_usuario:mi_clave@localhost/mi_app"
app.config["SECRET_KEY"] = "clave_secreta_super_segura"

db = SQLAlchemy(app)
bcrypt = Bcrypt(app)
login_manager = LoginManager(app)

3️⃣ Modelo de Usuario con contraseña encriptada

from flask_login import UserMixin

class Usuario(db.Model, UserMixin):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(50), unique=True, nullable=False)
    email = db.Column(db.String(120), unique=True, nullable=False)
    password = db.Column(db.String(128), nullable=False)

📌 Creamos la tabla con:

with app.app_context():
    db.create_all()

4️⃣ Registro de nuevos usuarios con contraseña encriptada

from flask import request, jsonify

@app.route("/registro", methods=["POST"])
def registro():
    datos = request.json
    hashed_password = bcrypt.generate_password_hash(datos["password"]).decode("utf-8")
    nuevo_usuario = Usuario(username=datos["username"], email=datos["email"], password=hashed_password)

    db.session.add(nuevo_usuario)
    db.session.commit()

    return jsonify({"mensaje": "Usuario registrado con éxito"}), 201

📌 JSON esperado:

{
  "username": "jose",
  "email": "jose@example.com",
  "password": "123456"
}

5️⃣ Inicio de sesión y validación de contraseña

from flask_login import login_user

@app.route("/login", methods=["POST"])
def login():
    datos = request.json
    usuario = Usuario.query.filter_by(email=datos["email"]).first()

    if usuario and bcrypt.check_password_hash(usuario.password, datos["password"]):
        login_user(usuario)
        return jsonify({"mensaje": "Login exitoso"}), 200
    return jsonify({"error": "Credenciales incorrectas"}), 401

6️⃣ Rutas protegidas para usuarios logueados

from flask_login import login_required, current_user

@app.route("/perfil")
@login_required
def perfil():
    return jsonify({
        "usuario": current_user.username,
        "email": current_user.email
    })

✅ Esta ruta solo puede ser accedida si el usuario está autenticado.

7️⃣ Cerrar sesión

from flask_login import logout_user

@app.route("/logout")
@login_required
def logout():
    logout_user()
    return jsonify({"mensaje": "Sesión cerrada"})

🚀 Conclusión

✅ Hemos creado un sistema de registro, login y sesión en Flask.
✅ Las contraseñas se almacenan encriptadas con Bcrypt.
✅ Flask-Login facilita la autenticación y la protección de rutas.

📌 Próximo post: Cómo integrar JWT para APIs seguras en Flask.

📂 Código en GitHub: github.com/josecodetech
🎥 Tutorial en YouTube: https://www.youtube.com/@josecodetech

💬 ¿Qué tipo de autenticación sueles usar en tus proyectos Flask?

domingo, 16 de marzo de 2025

👉 Ejercicios Prácticos con Flask y PostgreSQL en Python

Ya aprendimos a conectar Flask con PostgreSQL. Ahora es momento de poner en práctica lo aprendido con ejercicios explicados paso a paso.

Hoy resolveremos ejercicios sobre:
✔️ Crear una base de datos PostgreSQL y conectarla a Flask
✔️ Definir modelos con SQLAlchemy
✔️ Construir una API REST para insertar y consultar datos
✔️ Actualizar y eliminar registros en PostgreSQL desde Flask

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

1️⃣ Ejercicio: Crear la Base de Datos y Conectarla con Flask

📍 Objetivo: Crear una base de datos PostgreSQL y conectarla a Flask usando SQLAlchemy.

📌 Código:

from flask import Flask
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)

# Configurar PostgreSQL en Flask
app.config["SQLALCHEMY_DATABASE_URI"] = "postgresql://mi_usuario:mi_clave@localhost/mi_app"
app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False

db = SQLAlchemy(app)

@app.route("/")
def home():
    return "Conexión exitosa con PostgreSQL"

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

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

Conexión exitosa con PostgreSQL

✅ Este código establece la conexión entre Flask y PostgreSQL.

2️⃣ Ejercicio: Definir un Modelo para Usuarios en PostgreSQL

📍 Objetivo: Crear una tabla usuarios en PostgreSQL con SQLAlchemy.

📌 Código:

class Usuario(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    nombre = db.Column(db.String(100), nullable=False)
    email = db.Column(db.String(120), unique=True, nullable=False)

# Crear la tabla en PostgreSQL
with app.app_context():
    db.create_all()

📌 Salida esperada:

Tabla usuarios creada en PostgreSQL

✅ Ahora Flask puede almacenar y gestionar usuarios en PostgreSQL.

3️⃣ Ejercicio: Insertar Datos en PostgreSQL desde Flask

📍 Objetivo: Crear una API que permita agregar nuevos usuarios.

📌 Código:

from flask import request, jsonify

@app.route("/usuarios", methods=["POST"])
def agregar_usuario():
    datos = request.json
    nuevo_usuario = Usuario(nombre=datos["nombre"], email=datos["email"])
    
    db.session.add(nuevo_usuario)
    db.session.commit()
    
    return jsonify({"mensaje": "Usuario agregado correctamente"}), 201

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

{
    "nombre": "Carlos",
    "email": "carlos@example.com"
}

📌 Salida esperada:

{
    "mensaje": "Usuario agregado correctamente"
}

✅ Ahora los usuarios pueden registrarse desde una API en Flask.

4️⃣ Ejercicio: Consultar Usuarios desde PostgreSQL

📍 Objetivo: Obtener una lista de usuarios desde PostgreSQL.

📌 Código:

@app.route("/usuarios", methods=["GET"])
def obtener_usuarios():
    usuarios = Usuario.query.all()
    
    usuarios_json = [
        {"id": u.id, "nombre": u.nombre, "email": u.email} for u in usuarios
    ]
    
    return jsonify(usuarios_json)

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

[
    {"id": 1, "nombre": "Carlos", "email": "carlos@example.com"},
    {"id": 2, "nombre": "Ana", "email": "ana@example.com"}
]

✅ Ahora la API Flask puede consultar usuarios en PostgreSQL.

5️⃣ Ejercicio: Actualizar Datos de un Usuario

📍 Objetivo: Modificar el email de un usuario en PostgreSQL.

📌 Código:

@app.route("/usuarios/<int:id>", methods=["PUT"])
def actualizar_usuario(id):
    datos = request.json
    usuario = Usuario.query.get_or_404(id)
    
    usuario.email = datos["email"]
    db.session.commit()
    
    return jsonify({"mensaje": "Usuario actualizado correctamente"})

📌 Ejemplo de JSON enviado en PUT:

{
    "email": "nuevoemail@example.com"
}

📌 Salida esperada:

{
    "mensaje": "Usuario actualizado correctamente"
}

✅ Permite modificar registros en la base de datos desde Flask.

6️⃣ Ejercicio: Eliminar un Usuario en PostgreSQL

📍 Objetivo: Borrar un usuario de la base de datos PostgreSQL.

📌 Código:

@app.route("/usuarios/<int:id>", methods=["DELETE"])
def eliminar_usuario(id):
    usuario = Usuario.query.get_or_404(id)
    
    db.session.delete(usuario)
    db.session.commit()
    
    return jsonify({"mensaje": "Usuario eliminado correctamente"})

📌 Salida esperada:

{
    "mensaje": "Usuario eliminado correctamente"
}

✅ Ahora los usuarios pueden ser eliminados desde la API.

🚀 Conclusión

✅ Flask y PostgreSQL permiten construir APIs escalables en Python.
✅ SQLAlchemy facilita la manipulación de datos en la base de datos.
✅ Ahora puedes crear, leer, actualizar y eliminar registros en PostgreSQL.

📌 Próximo post: Cómo autenticar usuarios en Flask con PostgreSQL.

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

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

💬 ¿Has trabajado con PostgreSQL en Flask? ¿Qué tal tu experiencia? Cuéntamelo.

jueves, 13 de marzo de 2025

👉 Conectando Flask con PostgreSQL para Aplicaciones Web en Producción

En el post anterior, desplegamos nuestra aplicación Flask con SQLite. Sin embargo, para proyectos más grandes, PostgreSQL es una mejor opción.

Hoy aprenderás:
✔️ Por qué usar PostgreSQL en vez de SQLite
✔️ Cómo conectar Flask con PostgreSQL
✔️ Migrar datos de SQLite a PostgreSQL
✔️ Ejemplo paso a paso con SQLAlchemy

📌 Al final del tutorial, podrás manejar bases de datos PostgreSQL en Flask.

1️⃣ ¿Por qué Usar PostgreSQL en Producción?

📌 Diferencias entre SQLite y PostgreSQL:

Característica	SQLite	PostgreSQL
Uso recomendado	Apps pequeñas	Proyectos grandes
Manejo de datos	Local (archivo)	Cliente-servidor
Concurrencia	Limitada	Alta escalabilidad
Soporte de usuarios	No	Sí
Integración con la nube	No recomendada	Ideal para producción

🔹 Usamos PostgreSQL cuando necesitamos:
✅ Alta concurrencia (múltiples usuarios accediendo a la base de datos).
✅ Escalabilidad (mejor rendimiento en grandes volúmenes de datos).
✅ Despliegue en producción con plataformas en la nube.

2️⃣ Instalar PostgreSQL y Crear una Base de Datos

📌 Si no tienes PostgreSQL, instálalo:

🔹 En Linux (Ubuntu/Debian):

sudo apt update && sudo apt install postgresql postgresql-contrib

🔹 En Windows:
Descarga desde postgresql.org e instala.

📌 Para acceder a PostgreSQL en la terminal:

sudo -i -u postgres
psql

📌 Crea una base de datos llamada mi_app:

CREATE DATABASE mi_app;

📌 Crea un usuario y otorga permisos:

CREATE USER mi_usuario WITH PASSWORD 'mi_clave';
GRANT ALL PRIVILEGES ON DATABASE mi_app TO mi_usuario;

✅ La base de datos PostgreSQL está lista para usarse con Flask.

3️⃣ Conectar Flask con PostgreSQL

Usaremos SQLAlchemy, el ORM de Flask, para manejar PostgreSQL.

📌 Instala las dependencias:

pip install flask flask-sqlalchemy psycopg2-binary

📌 Configura Flask para conectarse a PostgreSQL:

from flask import Flask
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)

# Configurar PostgreSQL en Flask
app.config["SQLALCHEMY_DATABASE_URI"] = "postgresql://mi_usuario:mi_clave@localhost/mi_app"
app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False

db = SQLAlchemy(app)

@app.route("/")
def home():
    return "Conexión exitosa con PostgreSQL"

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

📌 Explicación:
✅ SQLALCHEMY_DATABASE_URI → Define la conexión con PostgreSQL.
✅ db = SQLAlchemy(app) → Inicializa SQLAlchemy en Flask.

📌 Ejecuta la aplicación:

python app.py

✅ Si visitas http://127.0.0.1:5000/ y ves "Conexión exitosa con PostgreSQL", todo está funcionando.

4️⃣ Migrar Datos de SQLite a PostgreSQL

Si tienes datos en SQLite, puedes migrarlos a PostgreSQL fácilmente.

📌 Pasos para migrar:

1️⃣ Exportar datos desde SQLite:

sqlite3 mi_base.db .dump > backup.sql

2️⃣ Convertir el formato de SQLite a PostgreSQL:
Abre backup.sql en un editor de texto y reemplaza:

"AUTOINCREMENT" por "SERIAL"
INSERT INTO "tabla" por INSERT INTO tabla

3️⃣ Importar datos en PostgreSQL:

psql -U mi_usuario -d mi_app -f backup.sql

✅ Los datos ahora están en PostgreSQL y listos para usarse con Flask.

5️⃣ Crear una Tabla y Manipular Datos con SQLAlchemy

📌 Código para definir y manipular datos en PostgreSQL con SQLAlchemy:

class Usuario(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    nombre = db.Column(db.String(100), nullable=False)
    email = db.Column(db.String(120), unique=True, nullable=False)

# Crear la base de datos y la tabla
with app.app_context():
    db.create_all()

📌 Insertar datos en PostgreSQL desde Flask:

nuevo_usuario = Usuario(nombre="José", email="jose@example.com")
db.session.add(nuevo_usuario)
db.session.commit()

📌 Consultar datos en PostgreSQL:

usuarios = Usuario.query.all()
for usuario in usuarios:
    print(usuario.nombre, usuario.email)

✅ PostgreSQL ahora está completamente integrado con Flask.

🚀 Conclusión

✅ PostgreSQL es más potente y escalable que SQLite para producción.
✅ SQLAlchemy facilita la conexión entre Flask y PostgreSQL.
✅ Migrar datos de SQLite a PostgreSQL es simple con .dump.

📌 Próximo post: Ejercicios prácticos con Flask y PostgreSQL.

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

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

💬 ¿Prefieres SQLite o PostgreSQL? Cuéntamelo en los comentarios.

miércoles, 12 de marzo de 2025

👉 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.

domingo, 9 de marzo de 2025

👉 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!

viernes, 7 de marzo de 2025

👉 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.

martes, 25 de marzo de 2025

1️⃣ ¿Qué es JWT?

2️⃣ Instalar dependencias

3️⃣ Generar el token JWT al iniciar sesión

4️⃣ Ruta de Login para devolver un JWT

5️⃣ Proteger rutas con un decorador personalizado

6️⃣ Ruta protegida usando el token

7️⃣ Cómo enviar el token desde el cliente

🚀 Conclusión

viernes, 21 de marzo de 2025

1️⃣ Instalar las dependencias necesarias

2️⃣ Configurar la app y la base de datos

3️⃣ Modelo de Usuario con contraseña encriptada

4️⃣ Registro de nuevos usuarios con contraseña encriptada

5️⃣ Inicio de sesión y validación de contraseña

6️⃣ Rutas protegidas para usuarios logueados

7️⃣ Cerrar sesión

🚀 Conclusión

domingo, 16 de marzo de 2025

1️⃣ Ejercicio: Crear la Base de Datos y Conectarla con Flask

2️⃣ Ejercicio: Definir un Modelo para Usuarios en PostgreSQL

3️⃣ Ejercicio: Insertar Datos en PostgreSQL desde Flask

4️⃣ Ejercicio: Consultar Usuarios desde PostgreSQL

5️⃣ Ejercicio: Actualizar Datos de un Usuario

6️⃣ Ejercicio: Eliminar un Usuario en PostgreSQL

🚀 Conclusión

jueves, 13 de marzo de 2025

1️⃣ ¿Por qué Usar PostgreSQL en Producción?

2️⃣ Instalar PostgreSQL y Crear una Base de Datos

3️⃣ Conectar Flask con PostgreSQL

4️⃣ Migrar Datos de SQLite a PostgreSQL

5️⃣ Crear una Tabla y Manipular Datos con SQLAlchemy

🚀 Conclusión

miércoles, 12 de marzo de 2025

1️⃣ Opciones para Desplegar Flask con SQLite

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

3️⃣ Subir la Aplicación a GitHub

4️⃣ Desplegar Flask con SQLite en Render

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

🚀 Conclusión

domingo, 9 de marzo de 2025

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

🔹 Código:

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

🔹 Código:

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

🔹 Código:

4️⃣ Ejercicio: Actualizar el Estado de una Tarea

🔹 Código:

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

🔹 Código:

🚀 Conclusión

viernes, 7 de marzo de 2025

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.

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

2️⃣ Conectar Flask con SQLite

3️⃣ Crear una API con Flask y SQLite

4️⃣ Insertar Datos desde una API Flask

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

🚀 Conclusión

Vistas de página en total

metricool