Sanic 'Hello World'

Avant de vous lancer dans Sanic, assurez-vous d'avoir Python 3.7 ou une version plus récente et pip (le gestionnaire de paquets de Python) installés sur votre système. Sanic s'appuie fortement sur les fonctionnalités modernes de Python pour ses capacités asynchrones.

Vous pouvez vérifier votre version de Python en exécutant cette commande dans votre terminal :

python3 --version

Vous devriez voir un résultat comme Python 3.x.x. Si vous devez installer ou mettre à jour Python, visitez python.org pour la dernière version.

L'utilisation d'un environnement virtuel est cruciale pour gérer efficacement les dépendances de projet. Cela garantit que les paquets de votre projet Sanic ne conflitent pas avec d'autres projets Python ou vos installations système globales.

Tout d'abord, créez un nouveau répertoire pour votre projet Sanic et naviguez-y :

mkdir sanic-hello-world
cd sanic-hello-world

Ensuite, créez un environnement virtuel dans votre répertoire de projet :

python3 -m venv .venv

Enfin, activez votre environnement virtuel :

# Sur macOS/Linux
source .venv/bin/activate

# Sur Windows (utilisez l'invite de commande)
.venv\Scripts\activate

Votre invite de terminal devrait maintenant afficher (.venv), indiquant que l'environnement virtuel est actif.

Avec votre environnement virtuel activé, vous pouvez maintenant installer Sanic et ses dépendances en utilisant pip.

pip install sanic

Cette commande installera Sanic et tous ses composants nécessaires, y compris uvloop et httptools pour une performance maximale, s'ils sont disponibles sur votre système.

Maintenant, créons notre première application Sanic "Hello World". Dans votre répertoire de projet (sanic-hello-world), créez un nouveau fichier nommé main.py.

Ouvrez main.py dans votre éditeur de code préféré et ajoutez le code Python suivant :

from sanic import Sanic, response

# Créer une instance d'application Sanic
app = Sanic("HelloWorldSanicApp")

# Définir une route pour l'URL racine ("/")
# Cette route gère les requêtes GET
@app.get("/")
async def hello_world(request):
    """
    Gère les requêtes GET vers l'URL racine et renvoie un message "Hello, Sanic!".
    """
    return response.text("Hello, Sanic!")

# Point d'entrée pour l'exécution de l'application
if __name__ == "__main__":
    app.run(host="0.0.0.0", port=8000, dev=True)

Décomposons le fichier main.py ligne par ligne pour comprendre le fonctionnement de votre application Sanic :

• from sanic import Sanic, response

  Cette ligne importe les composants nécessaires de la bibliothèque Sanic : Sanic pour la création de l'instance d'application, et response pour la génération de réponses HTTP.

• app = Sanic("HelloWorldSanicApp")

  Ici, nous créons une instance de l'application Sanic. La chaîne "HelloWorldSanicApp" est le nom de votre application, ce qui peut être utile pour le débogage ou la journalisation.

• @app.get("/")

  Ceci est un décorateur qui indique à Sanic d'associer la fonction située juste en dessous avec le chemin d'URL racine ("/") pour les requêtes HTTP GET. Sanic propose également @app.post(), @app.put(), @app.delete(), etc., pour d'autres méthodes HTTP.

• async def hello_world(request):

  Ceci définit une fonction asynchrone nommée hello_world. Le mot-clé async est crucial pour Sanic, lui permettant de gérer les requêtes de manière concurrente sans blocage. La fonction prend un objet request comme argument, qui contient des détails sur la requête HTTP entrante.

• return response.text("Hello, Sanic!")

  Dans notre gestionnaire de route, nous utilisons response.text() pour créer une réponse HTTP avec le type de contenu text/plain et la chaîne "Hello, Sanic!" comme corps. Sanic propose également response.json() pour les réponses JSON, response.html() pour le HTML, et plus encore.

• if __name__ == "__main__":

  Cette construction Python standard garantit que le code à l'intérieur de ce bloc ne s'exécute que lorsque le script est exécuté directement (et non lorsqu'il est importé en tant que module).

• app.run(host="0.0.0.0", port=8000, dev=True)

  Cette ligne démarre le serveur web Sanic.

  • host="0.0.0.0" rend le serveur accessible depuis n'importe quelle interface réseau, utile pour Docker ou l'accès externe. Pour le développement local, `127.0.0.1` ou `localhost` peuvent également être utilisés.
  • port=8000 spécifie que le serveur écoutera sur le port 8000.
  • dev=True active le mode développement, qui inclut des fonctionnalités comme le rechargement automatique du serveur lors des modifications de code et des messages d'erreur détaillés.

Maintenant que votre fichier main.py est prêt, vous pouvez démarrer votre serveur Sanic. Assurez-vous d'être dans votre répertoire sanic-hello-world et que votre environnement virtuel est activé.

Exécutez votre application en utilisant la CLI de Sanic :

python main.py

Vous pouvez également utiliser l'outil en ligne de commande `sanic` plus idiomatique, surtout pour des configurations plus avancées. Comme nous avons inclus `if __name__ == "__main__": app.run(...)`, la commande `python main.py` est suffisante pour cet exemple simple. Si vous l'exécutiez avec `sanic main.app --dev`, l'instance de l'application devrait s'appeler `app` pour qu'elle soit découverte automatiquement. Pour ce guide, `python main.py` est plus simple et fonctionne directement.

[INFO] Goin' Fast @ http://0.0.0.0:8000
[INFO] Pour arrêter : CTRL+C
                            

Maintenant que votre application Sanic est en cours d'exécution, il est temps de tester si elle répond correctement. Ouvrez votre navigateur web et naviguez vers :

http://127.0.0.1:8000/

Vous devriez voir le texte "Hello, Sanic!" affiché dans votre navigateur. Alternativement, vous pouvez utiliser un outil en ligne de commande comme curl :

curl http://127.0.0.1:8000/

La sortie dans votre terminal devrait simplement être :

Hello, Sanic!

Félicitations ! Vous avez créé et exécuté avec succès votre première application Sanic.

Votre application Sanic continuera de s'exécuter dans votre terminal jusqu'à ce que vous l'arrêtiez manuellement. Pour arrêter le serveur, retournez simplement dans le terminal où Sanic est en cours d'exécution et appuyez sur :

CTRL + C

Cela enverra un signal d'interruption au processus du serveur, provoquant son arrêt graceful.

Vous avez terminé avec succès votre première application "Hello World" avec Sanic ! Cette connaissance fondamentale ouvre un monde de possibilités pour la création de services web asynchrones haute performance avec Python.

Voici quelques idées pour vos prochaines étapes avec Sanic :

• Routes Dynamiques : Apprenez à créer des routes avec des paramètres de chemin (par exemple, /users/<user_id>) pour construire des API plus flexibles.
• Réponses JSON : Renvoie des données structurées en utilisant response.json({"message": "Hello from Sanic!"}).
• Données de Requête : Accédez aux paramètres de requête (request.args), aux données de formulaire (request.form) et aux corps JSON (request.json).
• Middlware : Implémentez des fonctions qui s'exécutent avant ou après chaque requête pour gérer l'authentification, la journalisation ou la modification des données.
• Blueprints : Organisez votre application en composants modulaires pour des projets plus importants.
• Bases de Données : Intégrez Sanic avec des pilotes de bases de données asynchrones (comme asyncpg pour PostgreSQL ou aiomysql pour MySQL) pour les opérations de base de données.
• WebSockets : Explorez le support intégré de Sanic pour la communication WebSocket en temps réel.
• Déploiement : Apprenez à déployer votre application Sanic dans des environnements de production en utilisant Docker, Gunicorn avec des workers Uvicorn, ou le serveur natif de Sanic.

La documentation officielle de Sanic est une excellente ressource pour approfondir toutes ces fonctionnalités et plus encore.