Python: Creación de una API REST

Cómo crear una API REST usando Flask

👋 ¡Bienvenido a la documentación de Stackhero!

Stackhero ofrece una solución nube de Python lista para usar que proporciona una serie de beneficios, incluyendo:

  • Despliegue su aplicación en segundos con un simple git push.
  • Use su propio nombre de dominio y benefíciese de la configuración automática de certificados HTTPS para una mayor seguridad.
  • Disfrute de la tranquilidad con copias de seguridad automáticas, actualizaciones con un clic, y precios sencillos, transparentes y predecibles.
  • Obtenga un rendimiento óptimo y una seguridad robusta gracias a una VM privada y dedicada.

Ahorre tiempo y simplifique su vida: solo toma 5 minutos probar la solución de alojamiento en la nube de Python de Stackhero.

Esta documentación es una guía amigable para principiantes sobre cómo crear una API REST en Python.

En este ejemplo, usamos Flask, un micro-framework ligero y fácil de usar que le permite crear aplicaciones web rápidamente.

Requisitos previos

Antes de comenzar, asegúrese de que su ordenador esté equipado con las siguientes herramientas:

  1. Python
  2. pip
  3. git
  4. asdf

Si su entorno de desarrollo aún no está configurado, consulte la guía Development platform para obtener instrucciones detalladas. Alternativamente, puede usar la plataforma en línea Code-Hero. Code-Hero proporciona un IDE y terminal en línea, con todas las herramientas esenciales preinstaladas, para que pueda comenzar a programar de inmediato sin ninguna instalación.

API REST de Python ejecutándose en Code-Hero, accesible directamente desde el navegadorAPI REST de Python ejecutándose en Code-Hero, accesible directamente desde el navegador

Creación de un nuevo proyecto

El primer paso es crear un nuevo directorio de proyecto. Para esta guía, lo llamaremos myRestApi:

mkdir myRestApi
cd myRestApi

A continuación, configure la versión de Python a la última disponible usando asdf e inicialice el repositorio Git:

asdf install python latest \
  && asdf local python latest

echo "__pycache__/" >> .gitignore

git init
git add -A .
git commit -m "First commit"

Instalación de la dependencia Flask

Para este ejemplo, solo necesitamos una dependencia: Flask.

Flask es un framework web ligero que permite un desarrollo rápido de aplicaciones web. Está diseñado para ser simple y fácil de usar, permitiendo a los desarrolladores crear y desplegar servicios web rápidamente. El soporte integrado para enrutamiento, plantillas y manejo de solicitudes HTTP hace de Flask una excelente opción para crear APIs REST.

Instale Flask (y python-dotenv) usando pip:

pip install Flask python-dotenv

Estamos instalando aquí los módulos Flask y python-dotenv. Pronto verá por qué usamos python-dotenv (spoiler: es para gestionar variables de entorno).

Después de la instalación, congele las versiones de los paquetes en un archivo requirements.txt:

pip freeze > requirements.txt

Congelar sus dependencias asegura que su servidor de producción o sus colegas usen las mismas versiones que usted. Solo unos segundos de trabajo pueden prevenir muchos dolores de cabeza futuros.

Implementación de la API REST usando Flask

¡Ahora, vamos al código!

Cree un archivo llamado app.py e inserte el siguiente código:

import os
from dotenv import load_dotenv
from flask import Flask, jsonify, request

# Cargar variables de entorno desde el archivo .env cuando no estamos en producción
if os.environ.get('ENV') != 'production':
    load_dotenv()

# Crear la aplicación Flask
app = Flask(__name__)

# Conjunto de datos de ejemplo
tasks = [
    {
        'id': 1,
        'title': 'Comprar comestibles',
        'description': 'Leche, Queso, Pizza, Frutas',
        'done': False
    },
    {
        'id': 2,
        'title': 'Aprender Python',
        'description': 'Aprender los conceptos básicos de programación en Python',
        'done': False
    }
]

# Ruta '/api/tasks' (GET) para listar todas las tareas
@app.route('/api/tasks', methods=['GET'])
def get_tasks():
    return jsonify({'tasks': tasks})

# Ruta '/api/tasks/<task_id>' (GET) para obtener una tarea específica por su ID
@app.route('/api/tasks/<int:task_id>', methods=['GET'])
def get_task(task_id):
    task = [task for task in tasks if task['id'] == task_id]
    if len(task) == 0:
        return jsonify({'error': 'Tarea no encontrada'}), 404
    return jsonify({'task': task[0]})

# Ruta '/api/tasks' (POST) para crear una nueva tarea
@app.route('/api/tasks', methods=['POST'])
def create_task():
    if not request.json or 'title' not in request.json:
        return jsonify({'error': 'El título es obligatorio'}), 400
    task = {
        'id': tasks[-1]['id'] + 1,
        'title': request.json['title'],
        'description': request.json.get('description', ""),
        'done': False
    }
    tasks.append(task)
    return jsonify({'task': task}), 201

# Iniciar el servidor API
if __name__ == '__main__':
    if os.environ.get('ENV') == 'production':
        app.run()
    else:
        app.run(host='0.0.0.0', port=8080, debug=True)

Para iniciar el servidor, ejecute:

python app.py

Con la opción host='0.0.0.0', también puede acceder a su API usando su navegador cuando use Code-Hero. Simplemente navegue a http://<XXXXXX>.stackhero-network.com:8080/api/tasks, reemplazando <XXXXXX> con su dominio de Code-Hero.

Pruebas de su API REST

Una vez que el servidor esté en funcionamiento, puede interactuar con él usando cURL. Aquí hay algunos ejemplos:

  • Recuperar todas las tareas:

    curl -s http://localhost:8080/api/tasks
{
  "tasks": [
    {
      "description": "Leche, Queso, Pizza, Frutas",
      "done": false,
      "id": 1,
      "title": "Comprar comestibles"
    },
    {
      "description": "Aprender los conceptos básicos de programación en Python",
      "done": false,
      "id": 2,
      "title": "Aprender Python"
    }
  ]
}

  • Recuperar la tarea con ID 2:

    curl -s http://localhost:8080/api/tasks/2
{
  "task": {
    "description": "Aprender los conceptos básicos de programación en Python",
    "done": false,
    "id": 2,
    "title": "Aprender Python"
  }
}

  • Crear una nueva tarea:

    curl -s -X POST -H "Content-Type: application/json" \
-d '{"title": "Nueva tarea", "description": "Creada con cURL"}' \
http://localhost:8080/api/tasks
{
  "task": {
    "description": "Creada con cURL",
    "done": false,
    "id": 3,
    "title": "Nueva tarea"
  }
}

Consejo: Redirija la salida a jq para embellecer el JSON. Por ejemplo, curl -s http://localhost:8080/api/tasks/2 | jq produce un resultado más legible.

Ejemplo de API REST de Python usando Flask, ejecutándose en Stackhero Code-Hero, con el servidor (1) y el cliente usando cURL (2)Ejemplo de API REST de Python usando Flask, ejecutándose en Stackhero Code-Hero, con el servidor (1) y el cliente usando cURL (2)

Gestión de variables de entorno

Las variables de entorno son vitales para proteger información sensible, como credenciales de bases de datos o claves API. Hay dos beneficios principales al usar variables de entorno:

  1. Sus secretos no se almacenan en su repositorio Git, asegurando que personas no autorizadas no puedan acceder a sus datos sensibles incluso si acceden a su código fuente.
  2. Puede usar diferentes credenciales para diferentes entornos (por ejemplo, producción frente a desarrollo).

Para gestionar las variables de entorno, usamos el módulo python-dotenv. Primero, instálelo si aún no lo ha hecho:

pip install python-dotenv
pip freeze > requirements.txt

A continuación, cree un archivo .env en la raíz de su proyecto y agregue sus variables de entorno de desarrollo. Por ejemplo:

ENV="development"
DATABASE_PASSWORD="secretPassword"
THIRD_API_PRIVATE_KEY="secretKey"

Finalmente, agregue el archivo .env a su .gitignore para mantener la seguridad:

echo ".env" >> .gitignore

Para acceder a estas variables de entorno en Python, simplemente use os.environ.get():

import os

print(os.environ.get('ENV'))

El archivo .env se usa solo para el entorno de desarrollo. Para staging o producción, configure las variables de entorno en el panel de Stackhero en la configuración de su servicio Python.

Preparación de Python y Flask para el despliegue en producción

Aunque esta guía usa el servidor de desarrollo integrado de Flask, para producción es esencial usar un servidor WSGI listo para producción como Gunicorn. Siga estos pasos:

  1. Instale Gunicorn:

    pip install gunicorn
pip freeze > requirements.txt

  2. Inicie su aplicación usando Gunicorn con el argumento app:app (donde el primer app es el nombre del archivo y el segundo app es la instancia de Flask):

    ENV=production gunicorn app:app \
  --error-logfile - \
  -b 0.0.0.0:8080

  3. Cree un Makefile para simplificar el cambio entre los modos de desarrollo y producción:

    .DEFAULT_GOAL := dev

# Por defecto, Stackhero para Python ejecuta la regla "run". La sobrescribimos para ejecutar la regla 'prod'.
run: prod

prod:
 	ENV=production gunicorn app:app \
 	  --error-logfile - \
 	  -b 0.0.0.0:8080

dev:
 	python app.py

Puede ejecutar su servidor en modo desarrollo usando make dev (o simplemente make), y en modo producción usando make prod.

Despliegue de su código Python en producción

La forma más sencilla de desplegar su proyecto Python es usar el servicio de alojamiento en la nube Python de Stackhero. Las características clave incluyen:

  • Despliegue con un simple git push
  • Dominio personalizable con gestión automática de certificados TLS (HTTPS)
  • Funciona en una VM privada y dedicada para máxima seguridad
  • Soporta HTTP/2, TLS 1.3 (HTTPS), WebSockets, compresión GZIP & Brotli, ETag, y acceso a puertos TCP/UDP

Configuración del servicio "Stackhero for Python"

Para desplegar su código en Stackhero, siga estos pasos:

  1. Recupere su clave pública usando:

    cat ~/.ssh/id_*.pub

  2. En el panel de Stackhero, vaya a su servicio "Stackhero for Python" y haga clic en el botón "Configurar".

  3. Copie la clave pública del primer paso y péguela en el campo "SSH public keys" o "Key".

  4. Valide la configuración haciendo clic en el botón "Validar" en la parte inferior de la página.

Configuración de la clave pública "Stackhero for Python"Configuración de la clave pública "Stackhero for Python"

¿No tiene claves SSH? Créelas ejecutando:

ssh-keygen -t ed25519

Finalmente, configure su repositorio para desplegar en Stackhero. En su carpeta de proyecto, agregue un remoto Git usando el comando proporcionado en su servicio Stackhero (reemplace <XXXXXX> con el dominio de su servicio):

git remote add stackhero ssh://stackhero@<XXXXXX>.stackhero-network.com:222/project.git

Comando Git remoteComando Git remote

Despliegue en producción

Una vez que todo esté configurado, despliegue su código en producción con un solo comando:

git push stackhero main

Asegúrese de agregar y confirmar sus cambios antes de enviar su código a producción. En Stackhero Code-Hero, puede confirmar rápidamente los cambios usando el Command Palette (presione Ctrl+Shift+P en Windows/Linux o Cmd+Shift+P en macOS y escriba Git: Commit).

Después del despliegue, visite su URL de API en https://<XXXXXX>.stackhero-network.com/api/tasks (reemplace <XXXXXX> con el dominio de su servicio) para ver su API Flask en acción.

Conclusión

Siguiendo esta guía, ahora entiende cómo crear una API REST usando Flask. Con este conocimiento, puede desarrollar y expandir sus aplicaciones RESTful con confianza, integrándolas con varios servicios front-end y back-end.

Other articles for Python