# Démarrer { #first-steps }

Le fichier **FastAPI** le plus simple possible pourrait ressembler à ceci :

{* ../../docs_src/first_steps/tutorial001_py310.py *}

Copiez cela dans un fichier `main.py`.

Démarrez le serveur en direct :

<div class="termy">

```console
$ <font color="#4E9A06">fastapi</font> dev

  <span style="background-color:#009485"><font color="#D3D7CF"> FastAPI </font></span>  Starting development server 🚀

Pour appeler une fonction définie avec `async def`, vous devez utiliser `await`. Donc ceci ne marche pas :

```Python
# Ceci ne fonctionne pas, car get_burgers a été défini avec async def
burgers = get_burgers(2)
```

---

* Ajouter un **JSON Schema** pour la réponse, dans l’OpenAPI du *chemin d'accès*.
    * Ceci sera utilisé par la **documentation automatique**.
    * Ceci sera également utilisé par les outils de génération automatique de code client.

Les tests :

## Extraits de code { #code-snippets }

//// tab | Test

Ceci est un extrait de code : `foo`. Et ceci est un autre extrait de code : `bar`. Et encore un autre : `baz quux`.

////

//// tab | Info

Le contenu des extraits de code doit être laissé tel quel.

{* ../../docs_src/schema_extra_example/tutorial003_an_py310.py hl[22:29] *}

### Exemple dans l'interface des documents { #example-in-the-docs-ui }

Avec l'une des méthodes ci-dessus, cela ressemblerait à ceci dans le `/docs` :

<img src="/img/tutorial/body-fields/image01.png">

### `Body` avec plusieurs `examples` { #body-with-multiple-examples }

Vous pouvez bien sûr aussi passer plusieurs `examples` :

Activer un environnement virtuel ajoute son chemin `.venv/bin` (sur Linux et macOS) ou `.venv\Scripts` (sur Windows) à la variable d’environnement `PATH`.

Disons qu’avant d’activer l’environnement, la variable `PATH` ressemblait à ceci :

//// tab | Linux, macOS

```plaintext
/usr/bin:/bin:/usr/sbin:/sbin
```

Cela signifie que le système chercherait des programmes dans :

* `/usr/bin`
* `/bin`
* `/usr/sbin`

C'est parce que FastAPI utilise ce `root_path` pour créer le `server` par défaut dans OpenAPI avec l'URL fournie par `root_path`.

## Serveurs supplémentaires { #additional-servers }

/// warning | Alertes

Ceci est un cas d'utilisation plus avancé. N'hésitez pas à l'ignorer.

///

Par défaut, **FastAPI** créera un `server` dans le schéma OpenAPI avec l'URL correspondant au `root_path`.

```Python
response = requests.get("http://example.com/some/url")
```

L’opération de chemin d'accès correspondante dans **FastAPI** pourrait ressembler à ceci :

```Python hl_lines="1"
@app.get("/some/url")
def read_url():
    return {"message": "Hello World"}
```

Notez les similitudes entre `requests.get(...)` et `@app.get(...)`.

### Utiliser le SDK { #using-the-sdk }

Vous pouvez maintenant importer et utiliser le code client. Cela pourrait ressembler à ceci, remarquez que vous obtenez l’autocomplétion pour les méthodes :

<img src="/img/tutorial/generate-clients/image02.png">

Vous obtiendrez également l’autocomplétion pour le payload à envoyer :

Par exemple, si vous avez une fonction :

```Python
@lru_cache
def say_hi(name: str, salutation: str = "Ms."):
    return f"Hello {salutation} {name}"
```

votre programme pourrait s'exécuter comme ceci :

```mermaid
sequenceDiagram

participant code as Code
participant function as say_hi()
participant execute as Execute function

    rect rgba(0, 255, 0, .1)