# Tâches d'arrière-plan

Vous pouvez définir des tâches d'arrière-plan qui seront exécutées après avoir retourné une réponse.

Ceci est utile pour les opérations qui doivent avoir lieu après une requête, mais où le client n'a pas réellement besoin d'attendre que l'opération soit terminée pour recevoir une réponse.

Cela comprend, par exemple :

* Les notifications par email envoyées après l'exécution d'une action :

* «autocompletion»: «autocomplétion»

* «the request» (what the client sends to the server): «la requête»
* «the response» (what the server sends back to the client): «la réponse»

* «the request body»: «le corps de la requête»
* «the response body»: «le corps de la réponse»

* «path operation»: «opération de chemin»
* «path operations» (plural): «opérations de chemin»
* «path operation function»: «fonction de chemin»

		// load polices mapped to users
		if err := store.loadMappedPolicies(ctx, regUser, false, newCache.iamUserPolicyMap); err != nil {
			return err
		}

		bootstrapTraceMsgFirstTime("loading group policy mapping")
		// load policies mapped to groups
		if err := store.loadMappedPolicies(ctx, regUser, true, newCache.iamGroupPolicyMap); err != nil {
			return err
		}

Il est conçu pour avoir des fonctions qui reçoivent deux paramètres, une "requête" et une "réponse". Ensuite, vous
"lisez" des parties de la requête et "écrivez" des parties dans la réponse. En raison de cette conception, il n'est
pas possible de déclarer des paramètres de requête et des corps avec des indications de type Python standard comme paramètres de fonction.

                        case POM_DOMINANT -> {
                            LinkedHashSet<ArtifactRepository> reposes =
                                    new LinkedHashSet<>(project.getRemoteArtifactRepositories());
                            reposes.addAll(request.getRemoteRepositories());
                            mergedRepositories = List.copyOf(reposes);
                        }
                        case REQUEST_DOMINANT -> {

</details>

### Vérifiez

Ouvrez votre navigateur à l'adresse <a href="http://127.0.0.1:8000/items/5?q=somequery" class="external-link" target="_blank">http://127.0.0.1:8000/items/5?q=somequery</a>.

Vous obtenez alors cette réponse <abbr title="JavaScript Object Notation">JSON</abbr> :

```JSON
{"item_id": 5, "q": "somequery"}
```

Vous venez de créer une API qui :

		regUser, r.Policies, isAttach)
	if err != nil {
		return updatedAt, addedOrRemoved, effectivePolicies, err
	}

	// Notify all other MinIO peers to reload policy
	if !sys.HasWatcher() {
		for _, nerr := range globalNotificationSys.LoadPolicyMapping(ctx, userOrGroup, regUser, isGroup) {
			if nerr.Err != nil {

Vous aurez de nombreux, nombreux utilisateurs, mais votre serveur attendra 🕙 que leur connexion peu performante envoie des requêtes.

Puis vous attendrez 🕙 de nouveau que leurs réponses reviennent.

Cette "attente" 🕙 se mesure en microsecondes, mais tout de même, en cumulé cela fait beaucoup d'attente.

C'est pourquoi il est logique d'utiliser du code asynchrone ⏸🔀⏯ pour des APIs web.

        // Should not affect IP limiting
        rateLimiter.recordFailure(null, "192.168.1.8");
        assertTrue(rateLimiter.checkAttempt("realuser", "192.168.1.8"), "Should still track IP");
    }

    @Test
    public void testNullIp() throws Exception {
        // Null IP should be handled gracefully

labels.loginRequired=Connexion requise
labels.loginLink=Afficher le lien de connexion
labels.threadName=Nom du thread
labels.url=URL
labels.userFavorite=Journal des favoris
labels.userInfo=Informations utilisateur
labels.webApiJson=Réponse JSON
labels.webConfigName=Nom de la configuration d'exploration Web
labels.allLanguages=Toutes les langues
labels.dictId=ID du dictionnaire
labels.docId=ID du document
labels.endTime=Heure de fin
labels.hq=hq