```

El parámetro `name` **sigue siendo requerido** (no es *opcional*) porque no tiene un valor por defecto. Aun así, `name` acepta `None` como valor:

```Python
say_hi(name=None)  # Esto funciona, None es válido 🎉
```

La buena noticia es que, en la mayoría de los casos, podrás simplemente usar `|` para definir uniones de tipos:

```python
def say_hi(name: str | None):
    print(f"Hey {name}!")
```

Por defecto, **FastAPI** usa un chequeo estricto del header `Content-Type` para request bodies JSON, esto significa que las requests JSON deben incluir un header `Content-Type` válido (p. ej. `application/json`) para que el request body se parse como JSON.

## Riesgo de CSRF { #csrf-risk }

Por padrão, o **FastAPI** usa verificação estrita do cabeçalho `Content-Type` para corpos de requisição JSON; isso significa que requisições JSON devem incluir um `Content-Type` válido (por exemplo, `application/json`) para que o corpo seja interpretado como JSON.

## Risco de CSRF { #csrf-risk }

Mas esse exemplo ainda é valido e mostra como interagir com os componentes internos.

///

Também podemos usar essa mesma abordagem para acessar o corpo da requisição em um manipulador de exceção.

    "description": "An optional description",
    "price": 45.2,
    "tax": 3.5
}
```

...dado que `description` y `tax` son opcionales (con un valor por defecto de `None`), este “`object`” JSON también sería válido:

```JSON
{
    "name": "Foo",
    "price": 45.2
}
```

## Decláralo como un parámetro { #declare-it-as-a-parameter }

Pero este ejemplo sigue siendo válido y muestra cómo interactuar con los componentes internos.

///

También podemos usar este mismo enfoque para acceder al request body en un manejador de excepciones.

## Resultados { #results }

Apenas com essa declaração de tipos do Python, o **FastAPI** irá:

* Ler o corpo da requisição como JSON.
* Converter os tipos correspondentes (se necessário).
* Validar os dados.
    * Se algum dado for inválido, irá retornar um erro bem claro, indicando exatamente onde e o que estava incorreto.
* Entregar a você a informação recebida no parâmetro `item`.

///

Agora o FastAPI vai:

* Validar os dados garantindo que o comprimento máximo seja de 50 caracteres
* Mostrar um erro claro para o cliente quando os dados não forem válidos
* Documentar o parâmetro na operação de rota do esquema OpenAPI (então ele aparecerá na UI de docs automática)

Assim, `0.5` seria um valor válido. Mas `0.0` ou `0` não seriam.

E o mesmo para <abbr title="less than – menor que"><code>lt</code></abbr>.

{* ../../docs_src/path_params_numeric_validations/tutorial006_an_py310.py hl[13] *}

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

El cliente ya **confía** en la entidad que generó ese certificado TLS (en este caso Let's Encrypt, pero lo veremos más adelante), por lo que puede **verificar** que el certificado sea válido.

Luego, usando el certificado, el cliente y el TLS Termination Proxy **deciden cómo encriptar** el resto de la **comunicación TCP**. Esto completa la parte de **Handshake TLS**.