Créer des routeurs FastAPI avec CRUD et dépendances d’authentification

Ce que ça fait

• Poser des points d’accès REST, des codes HTTP adaptés (201 à la création, 204 à la suppression), monter le routeur, et relier des modèles Pydantic.
• On choisit `def` ou `async def` selon que l’on appelle des entrées-sorties asynchrones : on n’appelle pas d’entrées-sorties bloquantes depuis un gestionnaire `async def`.
• Les ressources de longue durée (pools, clients HTTP) se gèrent dans `lifespan` et s’injectent via `Depends`.
• Un modèle se trouve dans `assets/template.py`.
• Ce n’est pas le déploiement de l’appli sur App Service (skill sœur).
• Le langage de référence est Python.

Pour qui, et un exemple

Les équipes Python qui ajoutent un routeur FastAPI, des routes authentifiées et des modèles de réponse, plutôt que de déployer l’appli sur Azure.

On s’en sert pour créer un routeur FastAPI, des points d’accès REST, un CRUD, ou une route authentifiée, avec les modèles et les codes de statut documentés. Exemple rédigé par iadujour.fr à partir du SKILL.md, non testé.

Installer

npx skills add microsoft/skills (sélection de la skill dans l’assistant, README).

Fonctionne avec

• GitHub Copilot
• Copilot CLI

Source : README : exemples de « Copilot CLI » et « GitHub Copilot in VS Code » ; l’installation `npx skills add` envoie les fichiers vers le répertoire de l’agent choisi, sans liste exhaustive.

Niveau : Intermédiaire

À savoir

Extrait du SKILL.md

La description d’origine, celle que l’agent lit pour décider de charger la skill (en anglais) :

Create FastAPI routers with CRUD operations, authentication dependencies, and proper response models. Use when building REST API endpoints, creating new routes, implementing CRUD operations, or adding authenticated endpoints in FastAPI applications.

Citée depuis le SKILL.md au commit 4a2873f . Le dossier contient aussi 2 fichiers annexes (assets/, references/).

Le SKILL.md compte 63 lignes et 7 sections principales :

• Quick Start
• Authentication Patterns
• Response Models
• HTTP Status Codes
• Integration Steps
• Best Practices
• Reference Files

Licence : MIT

Vérifiée le 10 novembre 2026 sur : fichier LICENSE du dépôt . Licence déclarée dans le frontmatter : « MIT ». Titulaire : Copyright (c) Microsoft Corporation..

La licence autorise la reprise : le texte intégral du SKILL.md est reproduit ci-dessous, sans modification, avec sa mention de licence.

Texte intégral du SKILL.md

Reproduit sans modification depuis microsoft/skills (commit 4a2873f) , © Microsoft, sous licence MIT (fichier de licence d’origine ).

---
name: fastapi-router-py
description: Create FastAPI routers with CRUD operations, authentication dependencies, and proper response models. Use when building REST API endpoints, creating new routes, implementing CRUD operations, or adding authenticated endpoints in FastAPI applications.
license: MIT
metadata:
  author: Microsoft
  version: "1.0.0"
---

# FastAPI Router

Create FastAPI routers following established patterns with proper authentication, response models, and HTTP status codes.

## Quick Start

Copy the template from [assets/template.py](assets/template.py) and replace placeholders:
- `{{ResourceName}}` → PascalCase name (e.g., `Project`)
- `{{resource_name}}` → snake_case name (e.g., `project`)
- `{{resource_plural}}` → plural form (e.g., `projects`)

## Authentication Patterns

```python
# Optional auth - returns None if not authenticated
current_user: Optional[User] = Depends(get_current_user)

# Required auth - raises 401 if not authenticated
current_user: User = Depends(get_current_user_required)
```

## Response Models

```python
@router.get("/items/{item_id}", response_model=Item)
async def get_item(item_id: str) -> Item:
    ...

@router.get("/items", response_model=list[Item])
async def list_items() -> list[Item]:
    ...
```

## HTTP Status Codes

```python
@router.post("/items", status_code=status.HTTP_201_CREATED)
async def create_item(item: ItemCreate) -> Item:
  ...

@router.delete("/items/{id}", status_code=status.HTTP_204_NO_CONTENT)
async def delete_item(id: str) -> None:
  ...
```

## Integration Steps

1. Create router in `src/backend/app/routers/`
2. Mount in `src/backend/app/main.py`
3. Create corresponding Pydantic models
4. Create service layer if needed
5. Add frontend API functions

## Best Practices

1. **Pick `def` or `async def` per endpoint based on whether you call async I/O; do not call blocking I/O from an `async def` handler.**
2. **Manage long-lived resources (DB pools, HTTP clients) in `lifespan` and inject via `Depends`;** use `with`/`async with` for per-request resources.

## Reference Files

| File | Contents |
|------|----------|
| [references/capabilities.md](references/capabilities.md) | Additional non-hero capabilities, operation-group coverage, and production checklists. |