En este tema, aprenderemos cómo crear endpoints RESTful utilizando Flask. Los endpoints RESTful son puntos de acceso a nuestra API que permiten a los clientes interactuar con nuestro servidor a través de métodos HTTP estándar como GET, POST, PUT y DELETE.
Conceptos Clave
- REST (Representational State Transfer): Un estilo de arquitectura para diseñar servicios web que utiliza métodos HTTP y URLs para acceder y manipular recursos.
- Endpoints: URLs específicas que representan recursos en nuestra API.
- Métodos HTTP: Acciones que se pueden realizar en los recursos (GET, POST, PUT, DELETE).
Paso a Paso para Crear Endpoints RESTful
- Configuración Inicial
Antes de comenzar, asegúrate de tener Flask instalado y configurado. Si no lo has hecho, sigue los pasos en el módulo 1 para configurar tu entorno de desarrollo.
- Creación de un Proyecto Flask
Primero, crea un nuevo proyecto Flask o abre uno existente. Asegúrate de tener una estructura básica de aplicación Flask.
from flask import Flask, jsonify, request
app = Flask(__name__)
# Datos de ejemplo
todos = [
{"id": 1, "task": "Learn Flask", "done": False},
{"id": 2, "task": "Build a REST API", "done": False}
]
# Endpoint para obtener todas las tareas
@app.route('/todos', methods=['GET'])
def get_todos():
return jsonify(todos)
if __name__ == '__main__':
app.run(debug=True)
- Creación de Endpoints Básicos
Obtener Todos los Recursos (GET)
El método GET se utiliza para obtener una lista de recursos o un recurso específico.
Obtener un Recurso Específico (GET)
Para obtener un recurso específico, podemos pasar un parámetro en la URL.
@app.route('/todos/<int:todo_id>', methods=['GET'])
def get_todo(todo_id):
todo = next((todo for todo in todos if todo["id"] == todo_id), None)
if todo is None:
return jsonify({"error": "Todo not found"}), 404
return jsonify(todo)Crear un Nuevo Recurso (POST)
El método POST se utiliza para crear un nuevo recurso.
@app.route('/todos', methods=['POST'])
def create_todo():
new_todo = request.get_json()
new_todo["id"] = len(todos) + 1
todos.append(new_todo)
return jsonify(new_todo), 201Actualizar un Recurso Existente (PUT)
El método PUT se utiliza para actualizar un recurso existente.
@app.route('/todos/<int:todo_id>', methods=['PUT'])
def update_todo(todo_id):
todo = next((todo for todo in todos if todo["id"] == todo_id), None)
if todo is None:
return jsonify({"error": "Todo not found"}), 404
data = request.get_json()
todo.update(data)
return jsonify(todo)Eliminar un Recurso (DELETE)
El método DELETE se utiliza para eliminar un recurso.
@app.route('/todos/<int:todo_id>', methods=['DELETE'])
def delete_todo(todo_id):
global todos
todos = [todo for todo in todos if todo["id"] != todo_id]
return '', 204
- Ejecución de la Aplicación
Guarda el archivo y ejecuta la aplicación Flask.
- Prueba de los Endpoints
Puedes utilizar herramientas como Postman o cURL para probar los endpoints que has creado.
Ejemplo de Prueba con cURL
-
Obtener todos los recursos:
curl -X GET http://127.0.0.1:5000/todos -
Obtener un recurso específico:
curl -X GET http://127.0.0.1:5000/todos/1 -
Crear un nuevo recurso:
curl -X POST -H "Content-Type: application/json" -d '{"task": "New Task", "done": false}' http://127.0.0.1:5000/todos -
Actualizar un recurso existente:
curl -X PUT -H "Content-Type: application/json" -d '{"task": "Updated Task", "done": true}' http://127.0.0.1:5000/todos/1 -
Eliminar un recurso:
curl -X DELETE http://127.0.0.1:5000/todos/1
Ejercicio Práctico
Ejercicio 1: Crear una API de Notas
- Crea una nueva aplicación Flask.
- Define una lista de notas con los campos
id,title, ycontent. - Implementa los siguientes endpoints:
GET /notes: Obtener todas las notas.GET /notes/<int:note_id>: Obtener una nota específica.POST /notes: Crear una nueva nota.PUT /notes/<int:note_id>: Actualizar una nota existente.DELETE /notes/<int:note_id>: Eliminar una nota.
Solución
from flask import Flask, jsonify, request
app = Flask(__name__)
# Datos de ejemplo
notes = [
{"id": 1, "title": "First Note", "content": "This is the first note"},
{"id": 2, "title": "Second Note", "content": "This is the second note"}
]
@app.route('/notes', methods=['GET'])
def get_notes():
return jsonify(notes)
@app.route('/notes/<int:note_id>', methods=['GET'])
def get_note(note_id):
note = next((note for note in notes if note["id"] == note_id), None)
if note is None:
return jsonify({"error": "Note not found"}), 404
return jsonify(note)
@app.route('/notes', methods=['POST'])
def create_note():
new_note = request.get_json()
new_note["id"] = len(notes) + 1
notes.append(new_note)
return jsonify(new_note), 201
@app.route('/notes/<int:note_id>', methods=['PUT'])
def update_note(note_id):
note = next((note for note in notes if note["id"] == note_id), None)
if note is None:
return jsonify({"error": "Note not found"}), 404
data = request.get_json()
note.update(data)
return jsonify(note)
@app.route('/notes/<int:note_id>', methods=['DELETE'])
def delete_note(note_id):
global notes
notes = [note for note in notes if note["id"] != note_id]
return '', 204
if __name__ == '__main__':
app.run(debug=True)Conclusión
En esta sección, hemos aprendido cómo crear endpoints RESTful utilizando Flask. Hemos cubierto los métodos HTTP básicos y cómo implementarlos en nuestra API. En el próximo módulo, exploraremos cómo manejar datos JSON y autenticación para nuestras APIs.
Curso de Desarrollo Web con Flask
Módulo 1: Introducción a Flask
- ¿Qué es Flask?
- Configuración de tu Entorno de Desarrollo
- Creando tu Primera Aplicación Flask
- Entendiendo la Estructura de una Aplicación Flask
Módulo 2: Conceptos Básicos de Flask
- Enrutamiento y Mapeo de URLs
- Manejo de Métodos HTTP
- Renderizando Plantillas con Jinja2
- Trabajando con Archivos Estáticos
Módulo 3: Formularios y Entrada de Usuario
Módulo 4: Integración de Bases de Datos
- Introducción a Flask-SQLAlchemy
- Definiendo Modelos
- Realizando Operaciones CRUD
- Migraciones de Base de Datos con Flask-Migrate
Módulo 5: Autenticación de Usuarios
- Registro de Usuarios
- Inicio y Cierre de Sesión de Usuarios
- Hashing de Contraseñas
- Gestión de Sesiones de Usuario
Módulo 6: Conceptos Avanzados de Flask
- Blueprints para Aplicaciones Grandes
- Manejo de Errores
- Páginas de Error Personalizadas
- Registro y Depuración
Módulo 7: APIs RESTful con Flask
- Introducción a las APIs RESTful
- Creación de Endpoints RESTful
- Manejo de Datos JSON
- Autenticación para APIs
Módulo 8: Despliegue y Producción
- Configuración de Flask para Producción
- Despliegue en Heroku
- Despliegue en AWS
- Monitoreo y Optimización del Rendimiento
Módulo 9: Pruebas y Mejores Prácticas
- Pruebas Unitarias con Flask
- Pruebas de Integración
- Cobertura de Pruebas
- Mejores Prácticas para el Desarrollo con Flask