Python: Création d'une API REST

Comment créer une API REST avec Flask

👋 Bienvenue sur la documentation de Stackhero !

Stackhero propose une solution cloud Python prête à l'emploi offrant de nombreux avantages, notamment :

  • Déployez votre application en quelques secondes avec un simple git push.
  • Utilisez votre propre nom de domaine et bénéficiez de la configuration automatique des certificats HTTPS pour une sécurité renforcée.
  • Profitez de la tranquillité d'esprit avec des sauvegardes automatiques, des mises à jour en un clic, et une tarification simple, transparente et prévisible.
  • Obtenez des performances optimales et une sécurité robuste grâce à une VM privée et dédiée.

Gagnez du temps et simplifiez-vous la vie : il ne faut que 5 minutes pour essayer la solution d'hébergement cloud Python de Stackhero !

Cette documentation est un guide convivial pour les débutants sur la création d'une API REST en Python.

Dans cet exemple, nous utilisons Flask, un micro-framework léger et facile à utiliser qui vous permet de créer rapidement des applications web.

Prérequis

Avant de commencer, assurez-vous que votre ordinateur est équipé des outils suivants :

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

Si votre environnement de développement n'est pas encore configuré, consultez le guide Development platform pour des instructions détaillées. Alternativement, vous pouvez utiliser la plateforme en ligne Code-Hero. Code-Hero fournit un IDE et un terminal en ligne, avec tous les outils essentiels préinstallés, vous permettant de commencer à coder immédiatement sans aucune installation.

API REST Python exécutée dans Code-Hero, accessible directement depuis le navigateurAPI REST Python exécutée dans Code-Hero, accessible directement depuis le navigateur

Création d'un nouveau projet

La première étape consiste à créer un nouveau répertoire de projet. Pour ce guide, nous le nommerons myRestApi :

mkdir myRestApi
cd myRestApi

Ensuite, définissez la version de Python sur la dernière disponible en utilisant asdf, et initialisez le dépôt Git :

asdf install python latest \
  && asdf local python latest

echo "__pycache__/" >> .gitignore

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

Installation de la dépendance Flask

Pour cet exemple, nous n'avons besoin que d'une seule dépendance : Flask.

Flask est un framework web léger qui permet un développement rapide des applications web. Il est conçu pour être simple et facile à utiliser, permettant aux développeurs de créer et déployer des services web rapidement. Le support intégré pour le routage, le templating et la gestion des requêtes HTTP fait de Flask un excellent choix pour créer des APIs REST.

Installez Flask (et python-dotenv) en utilisant pip :

pip install Flask python-dotenv

Nous installons ici les modules Flask et python-dotenv. Vous verrez bientôt pourquoi nous utilisons python-dotenv (spoiler : c'est pour gérer les variables d'environnement).

Après l'installation, figez les versions des packages dans un fichier requirements.txt :

pip freeze > requirements.txt

Figurer vos dépendances garantit que votre serveur de production ou vos collègues utilisent les mêmes versions que vous. Quelques secondes de travail peuvent éviter de nombreux maux de tête futurs.

Implémentation de l'API REST avec Flask

Passons maintenant au code !

Créez un fichier nommé app.py et insérez le code suivant :

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

# Charger les variables d'environnement depuis le fichier .env lorsque nous ne sommes pas en production
if os.environ.get('ENV') != 'production':
    load_dotenv()

# Créer l'application Flask
app = Flask(__name__)

# Jeu de données d'exemple
tasks = [
    {
        'id': 1,
        'title': 'Acheter des courses',
        'description': 'Lait, Fromage, Pizza, Fruits',
        'done': False
    },
    {
        'id': 2,
        'title': 'Apprendre Python',
        'description': 'Apprendre les bases de la programmation Python',
        'done': False
    }
]

# Route '/api/tasks' (GET) pour lister toutes les tâches
@app.route('/api/tasks', methods=['GET'])
def get_tasks():
    return jsonify({'tasks': tasks})

# Route '/api/tasks/<task_id>' (GET) pour obtenir une tâche spécifique par son 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': 'Tâche non trouvée'}), 404
    return jsonify({'task': task[0]})

# Route '/api/tasks' (POST) pour créer une nouvelle tâche
@app.route('/api/tasks', methods=['POST'])
def create_task():
    if not request.json or 'title' not in request.json:
        return jsonify({'error': 'Le titre est requis'}), 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

# Démarrer le serveur API
if __name__ == '__main__':
    if os.environ.get('ENV') == 'production':
        app.run()
    else:
        app.run(host='0.0.0.0', port=8080, debug=True)

Pour démarrer le serveur, exécutez :

python app.py

Avec l'option host='0.0.0.0', vous pouvez également accéder à votre API en utilisant votre navigateur lorsque vous utilisez Code-Hero. Il suffit de naviguer vers http://<XXXXXX>.stackhero-network.com:8080/api/tasks, en remplaçant <XXXXXX> par votre domaine Code-Hero.

Tester votre API REST

Une fois le serveur en cours d'exécution, vous pouvez interagir avec lui en utilisant cURL. Voici quelques exemples :

  • Récupérer toutes les tâches :

    curl -s http://localhost:8080/api/tasks
{
  "tasks": [
    {
      "description": "Lait, Fromage, Pizza, Fruits",
      "done": false,
      "id": 1,
      "title": "Acheter des courses"
    },
    {
      "description": "Apprendre les bases de la programmation Python",
      "done": false,
      "id": 2,
      "title": "Apprendre Python"
    }
  ]
}

  • Récupérer la tâche avec l'ID 2 :

    curl -s http://localhost:8080/api/tasks/2
{
  "task": {
    "description": "Apprendre les bases de la programmation Python",
    "done": false,
    "id": 2,
    "title": "Apprendre Python"
  }
}

  • Créer une nouvelle tâche :

    curl -s -X POST -H "Content-Type: application/json" \
-d '{"title": "Nouvelle tâche", "description": "Créée avec cURL"}' \
http://localhost:8080/api/tasks
{
  "task": {
    "description": "Créée avec cURL",
    "done": false,
    "id": 3,
    "title": "Nouvelle tâche"
  }
}

Astuce : Redirigez la sortie vers jq pour embellir le JSON. Par exemple, curl -s http://localhost:8080/api/tasks/2 | jq produit un résultat plus lisible.

Exemple d'API REST Python utilisant Flask, exécutée dans Stackhero Code-Hero, avec le serveur (1) et le client utilisant cURL (2)Exemple d'API REST Python utilisant Flask, exécutée dans Stackhero Code-Hero, avec le serveur (1) et le client utilisant cURL (2)

Gestion des variables d'environnement

Les variables d'environnement sont essentielles pour protéger les informations sensibles, telles que les identifiants de base de données ou les clés API. Il y a deux principaux avantages à utiliser des variables d'environnement :

  1. Vos secrets ne sont pas stockés dans votre dépôt Git, garantissant que des personnes non autorisées ne peuvent pas accéder à vos données sensibles même si elles accèdent à votre code source.
  2. Vous pouvez utiliser des identifiants différents pour différents environnements (par exemple, production contre développement).

Pour gérer les variables d'environnement, nous utilisons le module python-dotenv. Tout d'abord, installez-le si ce n'est pas déjà fait :

pip install python-dotenv
pip freeze > requirements.txt

Ensuite, créez un fichier .env à la racine de votre projet et ajoutez vos variables d'environnement de développement. Par exemple :

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

Enfin, ajoutez le fichier .env à votre .gitignore pour maintenir la sécurité :

echo ".env" >> .gitignore

Pour accéder à ces variables d'environnement en Python, utilisez simplement os.environ.get() :

import os

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

Le fichier .env est utilisé uniquement pour l'environnement de développement. Pour le staging ou la production, définissez les variables d'environnement sur le tableau de bord Stackhero dans la configuration de votre service Python.

Préparation de Python et Flask pour le déploiement en production

Bien que ce guide utilise le serveur de développement intégré de Flask, pour la production, il est essentiel d'utiliser un serveur WSGI prêt pour la production tel que Gunicorn. Suivez ces étapes :

  1. Installez Gunicorn :

    pip install gunicorn
pip freeze > requirements.txt

  2. Démarrez votre application en utilisant Gunicorn avec l'argument app:app (où le premier app est le nom du fichier et le second app est l'instance Flask) :

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

  3. Créez un Makefile pour simplifier le passage entre les modes développement et production :

    .DEFAULT_GOAL := dev

# Par défaut, Stackhero pour Python exécute la règle "run". Nous la remplaçons pour exécuter la règle 'prod'.
run: prod

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

dev:
 	python app.py

Vous pouvez exécuter votre serveur en mode développement en utilisant make dev (ou simplement make), et en mode production en utilisant make prod.

Déploiement de votre code Python en production

La manière la plus simple de déployer votre projet Python est d'utiliser le service d'hébergement cloud Python de Stackhero. Les principales fonctionnalités incluent :

  • Déploiement avec un simple git push
  • Domaine personnalisable avec gestion automatique des certificats TLS (HTTPS)
  • Fonctionne sur une VM privée et dédiée pour une sécurité maximale
  • Prend en charge HTTP/2, TLS 1.3 (HTTPS), WebSockets, compression GZIP & Brotli, ETag, et accès aux ports TCP/UDP

Configuration du service "Stackhero for Python"

Pour déployer votre code sur Stackhero, suivez ces étapes :

  1. Récupérez votre clé publique en utilisant :

    cat ~/.ssh/id_*.pub

  2. Dans le tableau de bord Stackhero, allez à votre service "Stackhero for Python" et cliquez sur le bouton "Configurer".

  3. Copiez la clé publique de la première étape et collez-la dans le champ "SSH public keys" ou "Key".

  4. Validez la configuration en cliquant sur le bouton "Valider" en bas de la page.

Configuration de la clé publique "Stackhero for Python"Configuration de la clé publique "Stackhero for Python"

Vous n'avez pas de clés SSH ? Créez-les en exécutant :

ssh-keygen -t ed25519

Enfin, configurez votre dépôt pour déployer sur Stackhero. Dans votre dossier de projet, ajoutez un remote Git en utilisant la commande fournie dans votre service Stackhero (remplacez <XXXXXX> par le domaine de votre service) :

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

Commande Git remoteCommande Git remote

Déploiement en production

Une fois tout configuré, déployez votre code en production avec une seule commande :

git push stackhero main

Assurez-vous d'ajouter et de valider vos modifications avant de pousser votre code en production. Dans Stackhero Code-Hero, vous pouvez rapidement valider les modifications en utilisant la Command Palette (appuyez sur Ctrl+Shift+P sur Windows/Linux ou Cmd+Shift+P sur macOS et tapez Git: Commit).

Après le déploiement, visitez votre URL d'API à https://<XXXXXX>.stackhero-network.com/api/tasks (remplacez <XXXXXX> par le domaine de votre service) pour voir votre API Flask en action.

Conclusion

En suivant ce guide, vous comprenez maintenant comment créer une API REST avec Flask. Avec ces connaissances, vous pouvez développer et étendre vos applications RESTful en toute confiance, en les intégrant avec divers services front-end et back-end.

Other articles for Python