Tak więc w OpenAPI każda z metod HTTP nazywana jest "operacją".

Będziemy je również nazywali "**operacjami**".

#### Zdefiniuj *dekorator operacji na ścieżce*

{* ../../docs_src/first_steps/tutorial001.py hl[6] *}

`@app.get("/")` mówi **FastAPI** że funkcja poniżej odpowiada za obsługę żądań, które trafiają do:

* ścieżki `/`
* używając <abbr title="metoda HTTP GET">operacji <code>get</code></abbr>

* Wszystkie zależności mogą wymagać danych w żądaniach oraz rozszerzać ograniczenia i automatyczną dokumentację **<abbr title="po angielsku: path operations">operacji na ścieżce</abbr>**.
* **Automatyczna walidacja** parametrów *operacji na ścieżce* zdefiniowanych w zależnościach.
* Obsługa złożonych systemów uwierzytelniania użytkowników, **połączeń z bazami danych**, itp.

Zobaczysz następującą odpowiedź JSON:

```JSON
{"item_id": 5, "q": "somequery"}
```

Właśnie stworzyłeś API które:

* Otrzymuje żądania HTTP w _ścieżce_ `/` i `/items/{item_id}`.
* Obie _ścieżki_ używają operacji `GET` (znane także jako _metody_ HTTP).
* _Ścieżka_ `/items/{item_id}` ma _parametr ścieżki_ `item_id` który powinien być obiektem typu `int`.

# Configuração da Operação de Rota

Existem vários parâmetros que você pode passar para o seu *decorador de operação de rota* para configurá-lo.

/// warning | "Aviso"

Observe que esses parâmetros são passados diretamente para o *decorador de operação de rota*, não para a sua *função de operação de rota*.

///

## Código de Status da Resposta

Você pode definir o `status_code` (HTTP) para ser usado na resposta da sua *operação de rota*.

Você pode utilizar `async def` ou apenas `def`.

E você pode declarar dependências utilizando `async def` dentro de *funções de operação de rota* definidas com `def`, ou declarar dependências com `def` e utilizar dentro de *funções de operação de rota* definidas com `async def`, etc.

```Python hl_lines="3  25"
{!../../docs_src/openapi_callbacks/tutorial001.py!}
```

### Crie a *operação de rota* do callback

Para criar a *operação de rota* do callback, use o mesmo `APIRouter` que você criou acima.

Ele deve parecer exatamente como uma *operação de rota* normal do FastAPI:

* Ele provavelmente deveria ter uma declaração do corpo que deveria receber, por exemplo. `body: InvoiceEvent`.

```

/// info | "Informação"

Uma "rota" também é comumente chamada de "endpoint".

///

Ao construir uma API, a "rota" é a principal forma de separar "preocupações" e "recursos".

#### Operação

"Operação" aqui se refere a um dos "métodos" HTTP.

Um dos:

* `POST`
* `GET`
* `PUT`
* `DELETE`

...e os mais exóticos:

* `OPTIONS`
* `HEAD`
* `PATCH`
* `TRACE`

* Ele pega cada **requisição** que chega ao seu aplicativo.
* Ele pode então fazer algo com essa **requisição** ou executar qualquer código necessário.
* Então ele passa a **requisição** para ser processada pelo resto do aplicativo (por alguma *operação de rota*).

Ou a dependência não retorna nenhum valor.

Mas você ainda precisa que ela seja executada/resolvida.

Para esses casos, em vez de declarar um parâmetro em uma *função de operação de rota* com `Depends`, você pode adicionar um argumento `dependencies` do tipo `list` ao decorador da operação de rota.

## Adicionando `dependencies` ao decorador da operação de rota

Nesse caso, a função de tarefa gravará em um arquivo (simulando o envio de um e-mail).

E como a operação de gravação não usa `async` e `await`, definimos a função com `def` normal:

```Python hl_lines="6-9"
{!../../docs_src/background_tasks/tutorial001.py!}
```

## Adicionar a tarefa em segundo plano

Dentro de sua _função de operação de caminho_, passe sua função de tarefa para o objeto _tarefas em segundo plano_ com o método `.add_task()`: