* `password`: alguns dos próximos capítulos tratarão disso.
* `openIdConnect`: tem uma forma para definir como descobrir automaticamente o dado da autenticação OAuth2.
    * Essa descoberta automática é o que é definido na especificação OpenID Connect.


/// tip | Dica

{% raw %}

```jinja
Item ID: {{ id }}
```

{% endraw %}

...aparecerá o `id` obtido do "context" `dict` que você passou:

```Python
{"id": id}
```

Por exemplo, dado um ID de valor `42`, aparecerá:

```html
Item ID: 42
```

### Argumentos do `url_for`

///

La única cosa que la función devuelta por `GzipRequest.get_route_handler` hace diferente es convertir el `Request` en un `GzipRequest`.

Haciendo esto, nuestro `GzipRequest` se encargará de descomprimir los datos (si es necesario) antes de pasarlos a nuestras *path operations*.

Después de eso, toda la lógica de procesamiento es la misma.

///

## Esperar mensajes y enviar mensajes

En tu ruta de WebSocket puedes `await` para recibir mensajes y enviar mensajes.

{* ../../docs_src/websockets/tutorial001.py hl[48:52] *}

Puedes recibir y enviar datos binarios, de texto y JSON.

## Pruébalo

Si tu archivo se llama `main.py`, ejecuta tu aplicación con:

<div class="termy">

```console
$ fastapi dev main.py

Aquí hay un poquito de esa historia.

## Alternativas

He estado creando APIs con requisitos complejos durante varios años (Machine Learning, sistemas distribuidos, trabajos asíncronos, bases de datos NoSQL, etc.), liderando varios equipos de desarrolladores.

Como parte de eso, necesitaba investigar, probar y usar muchas alternativas.

La historia de **FastAPI** es en gran parte la historia de sus predecesores.

    * Por lo tanto, el manejo de **certificados y encriptación** se realiza **antes de HTTP**.
* **TCP no sabe acerca de "dominios"**. Solo sobre direcciones IP.
    * La información sobre el **dominio específico** solicitado va en los **datos HTTP**.
* Los **certificados HTTPS** "certifican" un **cierto dominio**, pero el protocolo y la encriptación ocurren a nivel de TCP, **antes de saber** con cuál dominio se está tratando.

    * `200` es el código de estado por defecto, lo que significa que todo estaba "OK".
    * Otro ejemplo sería `201`, "Created". Comúnmente se usa después de crear un nuevo registro en la base de datos.
    * Un caso especial es `204`, "No Content". Este response se usa cuando no hay contenido para devolver al cliente, por lo tanto, el response no debe tener un body.

Para lograr esto, normalmente tendrás un **programa separado** que se asegurará de que tu aplicación se ejecute al iniciarse. Y en muchos casos, también se asegurará de que otros componentes o aplicaciones se ejecuten, por ejemplo, una base de datos.

### Herramientas de Ejemplo para Ejecutar al Iniciar

Algunos ejemplos de las herramientas que pueden hacer este trabajo son:

* Docker
* Kubernetes
* Docker Compose
* Docker en Modo Swarm

```

Pero posiblemente la parte más importante del callback es asegurarse de que el usuario de tu API (el desarrollador externo) implemente la *API externa* correctamente, de acuerdo con los datos que *tu API* va a enviar en el request body del callback, etc.

Entonces, lo que haremos a continuación es agregar el código para documentar cómo debería verse esa *API externa* para recibir el callback de *tu API*.

// Y luego llamamos al programa nuevamente
$ python main.py

// Ahora puede leer la variable de entorno

Hello Wade Wilson from Python
```

</div>

////

Dado que las variables de entorno pueden configurarse fuera del código, pero pueden ser leídas por el código, y no tienen que ser almacenadas (committed en `git`) con el resto de los archivos, es común usarlas para configuraciones o **ajustes**.