crypto.MetaAlgorithm:                   "DAREv2-HMAC-SHA256",
			crypto.MetaSealedKeySSEC:               "IAA8PGAA==",
			ReservedMetadataPrefix + "actual-size": "594870264",
			"content-type":                         "application/octet-stream",
			"etag":                                 "166b1545b4c1535294ee0686678bea8c-2",
		},
		Parts: []ObjectPartInfo{
			{
				Number:     1,
				Size:       297580380,
				ActualSize: 297435132,

	ProxyRequest                        bool      // only set for GET/HEAD in active-active replication scenario
	ProxyHeaderSet                      bool      // only set for GET/HEAD in active-active replication scenario
	ReplicationRequest                  bool      // true only if replication request
	ReplicationSourceTaggingTimestamp   time.Time // set if MinIOSourceTaggingTimestamp received

Lorsque vous déployez une application **FastAPI**, ou en fait n'importe quel type de web API, il existe plusieurs concepts qui vous importent probablement, et en les utilisant vous pouvez trouver la manière la **plus appropriée** de **déployer votre application**.

Parmi les concepts importants, on trouve :

* Sécurité - HTTPS
* Exécuter au démarrage
* Redémarrages
* Réplication (le nombre de processus en cours d'exécution)
* Mémoire

### Fichier d’application **FastAPI** { #fastapi-app-file }

Supposons que vous ayez une structure de fichiers comme décrit dans [Applications plus grandes](bigger-applications.md) :

```
.
├── app
│   ├── __init__.py
│   └── main.py
```

Dans le fichier `main.py`, vous avez votre application **FastAPI** :


{* ../../docs_src/app_testing/app_a_py310/main.py *}

### Fichier de test { #testing-file }

    # and dropping support for any version of Pydantic before that one (so, in a very long time)
    def bytes_schema(self, schema: CoreSchema) -> JsonSchemaValue:
        json_schema = {"type": "string", "contentMediaType": "application/octet-stream"}
        bytes_mode = (
            self._config.ser_json_bytes
            if self.mode == "serialization"
            else self._config.val_json_bytes
        )
        if bytes_mode == "base64":

    protected void writeJsonResponse(final HttpServletResponse response, final int status, final Map<String, Object> data)
            throws IOException {
        response.setStatus(status);
        response.setContentType("application/json");
        response.setCharacterEncoding("UTF-8");
        response.getWriter().write(objectMapper.writeValueAsString(data));
    }

    /**
     * Creates a success response map.
     *

                            "Failed to log out.", new SsoProcessException(msg));
                }
                return new StreamResponse("metadata").contentType("application/xhtml+xml").stream(out -> {
                    try (final Writer writer = new OutputStreamWriter(out.stream(), Constants.UTF_8_CHARSET)) {
                        writer.write(metadata);
                    }

{* ../../docs_src/response_model/tutorial003_05_py310.py hl[7] *}

This will make FastAPI skip the response model generation and that way you can have any return type annotations you need without it affecting your FastAPI application. 🤓

## Response Model encoding parameters { #response-model-encoding-parameters }

Your response model could have default values, like:

{* ../../docs_src/response_model/tutorial004_py310.py hl[9,11:12] *}

Cela apporte la même **expérience développeur** que pour créer des applications avec FastAPI au **déploiement** dans le cloud. 🎉

Cela prend également en charge la plupart des éléments nécessaires lors du déploiement d’une application, notamment :

* HTTPS
* Réplication, avec mise à l’échelle automatique basée sur les requêtes
* etc.

### Застосунок верхнього рівня { #top-level-application }

Спочатку створіть головний, верхньорівневий застосунок **FastAPI** та його _операції шляху_:

{* ../../docs_src/sub_applications/tutorial001_py310.py hl[3, 6:8] *}

### Підзастосунок { #sub-application }

Потім створіть свій підзастосунок та його _операції шляху_.