Ela apenas retorna uma resposta JSON com o resultado do método `.openapi()` da aplicação.

Por padrão, o que o método `.openapi()` faz é verificar se a propriedade `.openapi_schema` tem conteúdo e retorná-lo.

Se não tiver, ele gera o conteúdo usando a função utilitária em `fastapi.openapi.utils.get_openapi`.

E essa função `get_openapi()` recebe como parâmetros:

* `title`: O título do OpenAPI, exibido na documentação.

//// tab | Python 3.8+

```Python hl_lines="12"
{!> ../../docs_src/separate_openapi_schemas/tutorial002.py!}
```

////

### Mesmo Esquema para Modelos de Entrada e Saída na Documentação

E agora haverá um único esquema para entrada e saída para o modelo, apenas `Item`, e `description` **não será obrigatório**:

<div class="screenshot">
<img src="/img/tutorial/separate-openapi-schemas/image05.png">
</div>

A resposta seria algo como:

```JSON
{
    "message": "Hello World",
    "root_path": "/api/v1"
}
```

### Configurando o `root_path` na aplicação FastAPI

Alternativamente, se você não tiver uma maneira de fornecer uma opção de linha de comando como `--root-path` ou equivalente, você pode definir o parâmetro `--root-path` ao criar sua aplicação FastAPI:

{* ../../docs_src/behind_a_proxy/tutorial002.py hl[3] *}

Ambas as dependências retornarão apenas um erro HTTP se o usuário não existir ou se estiver inativo.

Portanto, em nosso endpoint, só obteremos um usuário se o usuário existir, tiver sido autenticado corretamente e estiver ativo:

//// tab | Python 3.10+

```Python hl_lines="58-66  69-74  94"
{!> ../../docs_src/security/tutorial003_an_py310.py!}
```

////

Mas em muitos casos, você desejará executar vários processos de trabalho ao mesmo tempo.

### Processos Múltiplos - Trabalhadores

Se você tiver mais clientes do que um único processo pode manipular (por exemplo, se a máquina virtual não for muito grande) e tiver **vários núcleos** na CPU do servidor, você poderá ter **vários processos** em execução com o mesmo aplicativo ao mesmo tempo e distribuir todas as solicitações entre eles.

* Ele pode fazer algo com essa **resposta** ou executar qualquer código necessário.
* Então ele retorna a **resposta**.

/// note | "Detalhes técnicos"

Se você tiver dependências com `yield`, o código de saída será executado *depois* do middleware.

Se houver alguma tarefa em segundo plano (documentada posteriormente), ela será executada *depois* de todo o middleware.

///

```txt
Hello, World from Flask!
```

E se você for até <a href="http://localhost:8000/v2" class="external-link" target="_blank">http://localhost:8000/v2</a>, você verá o retorno do FastAPI:

```JSON
{
    "message": "Hello World"
}

Tenha em mente que cabeçalhos personalizados proprietários podem ser adicionados <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers" class="external-link" target="_blank">usando o prefixo 'X-'</a>.

/// note | "Detalhes técnicos"

Na realidade, `Query`, `Path` e outros que você verá em seguida, criam objetos de subclasses de uma classe `Param` comum, que é ela mesma uma subclasse da classe `FieldInfo` do Pydantic.

E `Field` do Pydantic retorna uma instância de `FieldInfo` também.

`Body` também retorna objetos de uma subclasse de `FieldInfo` diretamente. E tem outras que você verá mais tarde que são subclasses da classe `Body`.

Então, a seção:

```Python
    uvicorn.run(app, host="0.0.0.0", port=8000)
```

vai executar.

---

Isso não acontecerá se você importar esse módulo (arquivo).

Então, se você tiver outro arquivo `importer.py` com:

```Python
from myapp import app

# Mais um pouco de código
```