```python
from main import app
```

Si votre code est structuré comme :

```
.
├── backend
│   ├── main.py
│   ├── __init__.py
```

Alors vous définiriez le `entrypoint` comme :

```toml
[tool.fastapi]
entrypoint = "backend.main:app"
```

ce qui équivaudrait à :

```python
from backend.main import app
```

Il démarrera alors le serveur avec votre code **FastAPI**, s'arrêtera à vos points d'arrêt, etc.

Voici à quoi cela pourrait ressembler :

<img src="/img/tutorial/debugging/image01.png">

---

Si vous utilisez Pycharm, vous pouvez :

- Ouvrez le menu « Run ».
- Sélectionnez l'option « Debug ... ».
- Un menu contextuel s'affiche alors.

Si vous utilisez des conteneurs (par ex. Docker, Kubernetes), alors il existe deux approches principales que vous pouvez utiliser.

### Plusieurs conteneurs { #multiple-containers }

/// tip | Astuce

Notez qu’ils ont le même hôte.

///

Vous pouvez alors, via le frontend, amener l’agent IA à effectuer des actions en votre nom.

Comme il s’exécute localement, et non sur l’Internet ouvert, vous décidez de ne mettre en place aucun mécanisme d’authentification, en vous fiant simplement à l’accès au réseau local.

Un de vos utilisateurs pourrait alors l’installer et l’exécuter localement.

Dans l'exemple précédent, nous renvoyions un `dict` depuis notre dépendance (« dependable ») :

{* ../../docs_src/dependencies/tutorial001_an_py310.py hl[9] *}

Mais nous recevons alors un `dict` dans le paramètre `commons` de la fonction de chemin d'accès.

Mais qu'est-ce qu'une « attaque par chronométrage » ?

Imaginons que des attaquants essaient de deviner le nom d'utilisateur et le mot de passe.

Ils envoient alors une requête avec un nom d'utilisateur `johndoe` et un mot de passe `love123`.

Le code Python de votre application serait alors équivalent à quelque chose comme :

```Python
if "johndoe" == "stanleyjobson" and "love123" == "swordfish":
    ...
```

### Paramètres et tests { #settings-and-testing }

Il devient alors très simple de fournir un autre objet de paramètres pendant les tests en créant une surcharge de dépendance pour `get_settings` :

{* ../../docs_src/settings/app02_an_py310/test_main.py hl[9:10,13,21] *}

Dans la surcharge de dépendance, nous définissons une nouvelle valeur pour `admin_email` lors de la création du nouvel objet `Settings`, puis nous renvoyons ce nouvel objet.

////

//// tab | Windows PowerShell

<div class="termy">

```console
$ Get-Command python

C:\Users\user\code\awesome-project\.venv\Scripts\python
```

</div>

S’il affiche le binaire `python` à `.venv\Scripts\python`, dans votre projet (dans cet exemple `awesome-project`), alors cela a fonctionné. 🎉

////

Si vous utilisez des bibliothèques tierces qui nécessitent d'être appelées avec `await`, telles que :

```Python
results = await some_library()
```

Alors, déclarez vos *fonctions de chemin d'accès* avec `async def` comme ceci :

```Python hl_lines="2"
@app.get('/')
async def read_results():
    results = await some_library()
    return results
```

Dans ce cas, **FastAPI** détectera qu'il y a plus d'un paramètre du corps de la requête dans la fonction (il y a deux paramètres qui sont des modèles Pydantic).

Il utilisera alors les noms des paramètres comme clés (noms de champs) dans le corps de la requête, et s'attendra à recevoir un corps de la requête semblable à :

```JSON
{
    "item": {
        "name": "Foo",