Mais vous pouvez configurer le **serveur d'application** pour qu'il fasse confiance aux en-têtes transmis (*forwarded*) envoyés par le **proxy**. Si vous utilisez FastAPI CLI, vous pouvez utiliser l'*option CLI* `--forwarded-allow-ips` pour lui indiquer à partir de quelles IP il doit faire confiance à ces en-têtes transmis.

Cela a été modifié dans la version 0.110.0 pour corriger une consommation de mémoire non gérée due aux exceptions transmises sans gestionnaire (erreurs internes du serveur), et pour rendre le comportement cohérent avec celui du code Python classique.

This is still true.

So, to be able to have **multiple processes** at the same time, there has to be a **single process listening on a port** that then transmits the communication to each worker process in some way.

### Memory per Process { #memory-per-process }

    }

    /** Returns a new response body that transmits this byte array. */
    @JvmStatic
    @JvmName("create")
    fun ByteArray.toResponseBody(contentType: MediaType? = null): ResponseBody =
      Buffer()
        .write(this)
        .asResponseBody(contentType, size.toLong())

    /** Returns a new response body that transmits this byte string. */
    @JvmStatic
    @JvmName("create")

| `minio_node_if_tx_bytes_max`  | Bytes transmitted in 60s (max).                            |
| `minio_node_if_tx_errors`     | Transmit errors in 60s.                                    |
| `minio_node_if_tx_errors_avg` | Transmit errors in 60s (avg).                              |
| `minio_node_if_tx_errors_max` | Transmit errors in 60s (max).                              |

## CPU Metrics

Seul le code précédant et incluant l'instruction `yield` est exécuté avant la création de la réponse :

{* ../../docs_src/dependencies/tutorial007_py310.py hl[2:4] *}

La valeur transmise par `yield` est celle qui est injectée dans les *chemins d'accès* et autres dépendances :

{* ../../docs_src/dependencies/tutorial007_py310.py hl[4] *}

Le code suivant l'instruction `yield` est exécuté après la réponse :

<img src="/img/deployment/https/https04.drawio.svg">

### Decrypt the Request { #decrypt-the-request }

The TLS Termination Proxy would use the encryption agreed to **decrypt the request**, and would transmit the **plain (decrypted) HTTP request** to the process running the application (for example a process with Uvicorn running the FastAPI application).

<img src="/img/deployment/https/https05.drawio.svg">

{* ../../docs_src/custom_response/tutorial006c_py310.py hl[2,7,9] *}

### `StreamingResponse` { #streamingresponse }

Toma un generador `async` o un generador/iterador normal (una función con `yield`) y transmite el cuerpo del response.

{* ../../docs_src/custom_response/tutorial007_py310.py hl[3,16] *}

/// note | Nota Técnica

import okhttp3.internal.http.RealResponseBody
import okio.Buffer
import okio.ForwardingSink
import okio.ForwardingSource
import okio.Sink
import okio.Socket
import okio.Source
import okio.buffer

/**
 * Transmits a single HTTP request and a response pair. This layers connection management and events
 * on [ExchangeCodec], which handles the actual I/O.
 */
class Exchange(
  internal val call: RealCall,

      if (outFinished) {
        this.sink.finished = true
        notifyAll() // Because doReadTimeout() may have changed.
      }
    }

    // Only DATA frames are subject to flow-control. Transmit the HEADER frame if the connection
    // flow-control window is fully depleted.
    if (!flushHeaders) {
      withLock {
        flushHeaders = (connection.writeBytesTotal >= connection.writeBytesMaximum)
      }