Sync fastapi docs from 50113da1 on 2026-09-11

2026-09-11 04:00:08 +00:00
parent 632909b5f6
commit 818066b271
739 changed files with 4974 additions and 17395 deletions
@@ -1,4 +1,4 @@
-# Retornos Adicionais no OpenAPI { #additional-responses-in-openapi }
+# Respostas Adicionais no OpenAPI { #additional-responses-in-openapi }

 /// warning | Atenção

@@ -8,23 +8,23 @@ Se você está começando com o **FastAPI**, provavelmente você não precisa di

 ///

-Você pode declarar retornos adicionais, com códigos de status adicionais, media types, descrições, etc.
+Você pode declarar respostas adicionais, com códigos de status adicionais, media types, descrições, etc.

 Essas respostas adicionais serão incluídas no esquema do OpenAPI, e também aparecerão na documentação da API.

-Porém para as respostas adicionais, você deve garantir que está retornando um `Response` como por exemplo o `JSONResponse` diretamente, junto com o código de status e o conteúdo.
+Porém para essas respostas adicionais, você deve garantir que está retornando um `Response` como por exemplo o `JSONResponse` diretamente, junto com o código de status e o conteúdo.

-## Retorno Adicional com `model` { #additional-response-with-model }
+## Resposta Adicional com `model` { #additional-response-with-model }

-Você pode fornecer o parâmetro `responses` aos seus *decoradores de caminho*.
+Você pode fornecer o parâmetro `responses` aos seus *decoradores de operação de rota*.

-Este parâmetro recebe um `dict`, as chaves são os códigos de status para cada retorno, como por exemplo `200`, e os valores são um outro `dict` com a informação de cada um deles.
+Este parâmetro recebe um `dict`: as chaves são os códigos de status para cada resposta, como por exemplo `200`, e os valores são outros `dict`s com a informação de cada um deles.

-Cada um desses `dict` de retorno pode ter uma chave `model`, contendo um modelo do Pydantic, assim como o `response_model`.
+Cada um desses `dict`s de resposta pode ter uma chave `model`, contendo um modelo do Pydantic, assim como o `response_model`.

-O **FastAPI** pegará este modelo, gerará o esquema JSON dele e incluirá no local correto do OpenAPI.
+O **FastAPI** pegará este modelo, gerará seu JSON Schema e incluirá no local correto do OpenAPI.

-Por exemplo, para declarar um outro retorno com o status code `404` e um modelo do Pydantic chamado `Message`, você pode escrever:
+Por exemplo, para declarar outra resposta com o código de status `404` e um modelo do Pydantic chamado `Message`, você pode escrever:

 {* ../../docs_src/additional_responses/tutorial001_py310.py hl[18,22] *}

@@ -38,18 +38,18 @@ Lembre-se que você deve retornar o `JSONResponse` diretamente.

 A chave `model` não é parte do OpenAPI.

-O **FastAPI** pegará o modelo do Pydantic, gerará o `JSON Schema`, e adicionará no local correto.
+O **FastAPI** pegará o modelo do Pydantic, gerará o JSON Schema, e adicionará no local correto.

 O local correto é:

-* Na chave `content`, que tem como valor um outro objeto JSON (`dict`) que contém:
-    * Uma chave com o media type, como por exemplo `application/json`, que contém como valor um outro objeto JSON, contendo::
-        * Uma chave `schema`, que contém como valor o JSON Schema do modelo, sendo este o local correto.
-            * O **FastAPI** adiciona aqui a referência dos esquemas JSON globais que estão localizados em outro lugar, ao invés de incluí-lo diretamente. Deste modo, outras aplicações e clientes podem utilizar estes esquemas JSON diretamente, fornecer melhores ferramentas de geração de código, etc.
+* Na chave `content`, que tem como valor outro objeto JSON (`dict`) que contém:
+    * Uma chave com o media type, como por exemplo `application/json`, que contém como valor outro objeto JSON, que contém:
+        * Uma chave `schema`, que tem como valor o JSON Schema do modelo, sendo este o local correto.
+            * O **FastAPI** adiciona aqui a referência aos JSON Schemas globais que estão localizados em outro lugar no seu OpenAPI, ao invés de incluí-lo diretamente. Deste modo, outras aplicações e clientes podem utilizar estes JSON Schemas diretamente, fornecer melhores ferramentas de geração de código, etc.

 ///

-O retorno gerado no OpenAPI para esta *operação de rota* será:
+As respostas geradas no OpenAPI para esta *operação de rota* serão:

 ```JSON hl_lines="3-12"
 {
@@ -169,9 +169,9 @@ Os esquemas são referenciados em outro local dentro do esquema OpenAPI:
 }
 ```

-## Media types adicionais para o retorno principal { #additional-media-types-for-the-main-response }
+## Media types adicionais para a resposta principal { #additional-media-types-for-the-main-response }

-Você pode utilizar o mesmo parâmetro `responses` para adicionar diferentes media types para o mesmo retorno principal.
+Você pode utilizar o mesmo parâmetro `responses` para adicionar diferentes media types para a mesma resposta principal.

 Por exemplo, você pode adicionar um media type adicional de `image/png`, declarando que a sua *operação de rota* pode retornar um objeto JSON (com o media type `application/json`) ou uma imagem PNG:

@@ -185,33 +185,33 @@ Note que você deve retornar a imagem utilizando um `FileResponse` diretamente.

 /// note | Nota

-A menos que você especifique um media type diferente explicitamente em seu parâmetro `responses`, o FastAPI assumirá que o retorno possui o mesmo media type contido na classe principal de retorno (padrão `application/json`).
+A menos que você especifique um media type diferente explicitamente em seu parâmetro `responses`, o FastAPI assumirá que a resposta possui o mesmo media type contido na classe principal de resposta (padrão `application/json`).

-Porém se você especificou uma classe de retorno com o valor `None` como media type, o FastAPI utilizará `application/json` para qualquer retorno adicional que possui um modelo associado.
+Porém se você especificou uma classe de resposta personalizada com o valor `None` como media type, o FastAPI utilizará `application/json` para qualquer resposta adicional que possui um modelo associado.

 ///

 ## Combinando informações { #combining-information }

-Você também pode combinar informações de diferentes lugares, incluindo os parâmetros `response_model`, `status_code`, e `responses`.
+Você também pode combinar informações de resposta de diferentes lugares, incluindo os parâmetros `response_model`, `status_code`, e `responses`.

-Você pode declarar um `response_model`, utilizando o código de status padrão `200` (ou um customizado caso você precise), e depois adicionar informações adicionais para esse mesmo retorno em `responses`, diretamente no esquema OpenAPI.
+Você pode declarar um `response_model`, utilizando o código de status padrão `200` (ou um personalizado caso você precise), e depois adicionar informações adicionais para essa mesma resposta em `responses`, diretamente no esquema OpenAPI.

-O **FastAPI** manterá as informações adicionais do `responses`, e combinará com o esquema JSON do seu modelo.
+O **FastAPI** manterá as informações adicionais do `responses`, e combinará com o JSON Schema do seu modelo.

-Por exemplo, você pode declarar um retorno com o código de status `404` que utiliza um modelo do Pydantic e tem uma `description` customizada.
+Por exemplo, você pode declarar uma resposta com o código de status `404` que utiliza um modelo do Pydantic e tem uma `description` personalizada.

-E um retorno com o código de status `200` que utiliza o seu `response_model`, porém inclui um `example` customizado:
+E uma resposta com o código de status `200` que utiliza o seu `response_model`, porém inclui um `example` personalizado:

 {* ../../docs_src/additional_responses/tutorial003_py310.py hl[20:31] *}

-Isso será combinado e incluído em seu OpenAPI, e disponibilizado na documentação da sua API:
+Isso será combinado e incluído em seu OpenAPI, e mostrado na documentação da API:

 <img src="/img/tutorial/additional-responses/image01.png">

-## Combinar retornos predefinidos e personalizados { #combine-predefined-responses-and-custom-ones }
+## Combinar respostas predefinidas e personalizadas { #combine-predefined-responses-and-custom-ones }

-Você pode querer possuir alguns retornos predefinidos que são aplicados para diversas *operações de rota*, porém você deseja combinar com retornos personalizados que são necessários para cada *operação de rota*.
+Você pode querer possuir algumas respostas predefinidas que são aplicadas para diversas *operações de rota*, porém deseja combinar com respostas personalizadas que são necessárias para cada *operação de rota*.

 Para estes casos, você pode utilizar a técnica do Python de "desempacotamento" de um `dict` utilizando `**dict_to_unpack`:

@@ -233,15 +233,15 @@ Aqui, o `new_dict` terá todos os pares de chave-valor do `old_dict` mais o novo
 }
 ```

-Você pode utilizar essa técnica para reutilizar alguns retornos predefinidos nas suas *operações de rota* e combiná-las com personalizações adicionais.
+Você pode utilizar essa técnica para reutilizar algumas respostas predefinidas nas suas *operações de rota* e combiná-las com personalizações adicionais.

 Por exemplo:

 {* ../../docs_src/additional_responses/tutorial004_py310.py hl[11:15,24] *}

-## Mais informações sobre retornos OpenAPI { #more-information-about-openapi-responses }
+## Mais informações sobre respostas OpenAPI { #more-information-about-openapi-responses }

-Para verificar exatamente o que você pode incluir nos retornos, você pode conferir estas seções na especificação do OpenAPI:
+Para verificar exatamente o que você pode incluir nas respostas, você pode conferir estas seções na especificação do OpenAPI:

-* [Objeto de Retornos do OpenAPI](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#responses-object), inclui o `Response Object`.
-* [Objeto de Retorno do OpenAPI](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#response-object), você pode incluir qualquer coisa dele diretamente em cada retorno dentro do seu parâmetro `responses`. Incluindo `description`, `headers`, `content` (dentro dele que você declara diferentes media types e esquemas JSON), e `links`.
+* [Objeto de Respostas do OpenAPI](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#responses-object), inclui o `Response Object`.
+* [Objeto de Resposta do OpenAPI](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#response-object), você pode incluir qualquer coisa dele diretamente em cada resposta dentro do seu parâmetro `responses`. Incluindo `description`, `headers`, `content` (dentro dele que você declara diferentes media types e JSON Schemas), e `links`.
@@ -2,7 +2,7 @@

 Você já viu como testar as suas aplicações **FastAPI** utilizando o `TestClient` que é fornecido. Até agora, você viu apenas como escrever testes síncronos, sem utilizar funções `async`.

-Ser capaz de utilizar funções assíncronas em seus testes pode ser útil, por exemplo, quando você está realizando uma consulta em seu banco de dados de maneira assíncrona. Imagine que você deseja testar realizando requisições para a sua aplicação FastAPI e depois verificar que a sua aplicação inseriu corretamente as informações no banco de dados, ao utilizar uma biblioteca assíncrona para banco de dados.
+Ser capaz de utilizar funções assíncronas em seus testes pode ser útil, por exemplo, quando você está realizando uma consulta em seu banco de dados de maneira assíncrona. Imagine que você deseja testar enviando requisições para a sua aplicação FastAPI e depois verificar que o seu backend gravou com sucesso os dados corretos no banco de dados, ao utilizar uma biblioteca assíncrona para banco de dados.

 Vamos ver como nós podemos fazer isso funcionar.

@@ -20,7 +20,7 @@ O `TestClient` é baseado no [HTTPX](https://www.python-httpx.org), e felizmente

 ## Exemplo { #example }

-Para um exemplos simples, vamos considerar uma estrutura de arquivos semelhante ao descrito em [Aplicações Maiores](../tutorial/bigger-applications.md) e [Testes](../tutorial/testing.md):
+Para um exemplo simples, vamos considerar uma estrutura de arquivos semelhante à descrita em [Aplicações Maiores](../tutorial/bigger-applications.md) e [Testes](../tutorial/testing.md):

 ```
 .
@@ -34,7 +34,7 @@ O arquivo `main.py` teria:

 {* ../../docs_src/async_tests/app_a_py310/main.py *}

-O arquivo `test_main.py` teria os testes para para o arquivo `main.py`, ele poderia ficar assim:
+O arquivo `test_main.py` teria os testes para o arquivo `main.py`, ele poderia ficar assim agora:

 {* ../../docs_src/async_tests/app_a_py310/test_main.py *}

@@ -45,7 +45,7 @@ Você pode executar os seus testes normalmente via:
 <div class="termy">

 ```console
-$ pytest
+$ uv run pytest

 ---> 100%
 ```
@@ -94,6 +94,6 @@ Como a função de teste agora é assíncrona, você pode chamar (e `await`) out

 /// tip | Dica

-Se você se deparar com um `RuntimeError: Task attached to a different loop` ao integrar funções assíncronas em seus testes (e.g. ao utilizar o [MotorClient do MongoDB](https://stackoverflow.com/questions/41584243/runtimeerror-task-attached-to-a-different-loop)) Lembre-se de instanciar objetos que precisam de um loop de eventos (*event loop*) apenas em funções assíncronas, e.g. um callback `@app.on_event("startup")`.
+Se você se deparar com um `RuntimeError: Task attached to a different loop` ao integrar chamadas de funções assíncronas em seus testes (e.g. ao utilizar o [MotorClient do MongoDB](https://stackoverflow.com/questions/41584243/runtimeerror-task-attached-to-a-different-loop)), lembre-se de instanciar objetos que precisam de um loop de eventos apenas em funções async, e.g. um callback `@app.on_event("startup")`.

 ///
@@ -22,9 +22,9 @@ Os headers do proxy são:

 ///

-### Ativar headers encaminhados pelo proxy { #enable-proxy-forwarded-headers }
+### Ative os headers encaminhados pelo proxy { #enable-proxy-forwarded-headers }

-Você pode iniciar a CLI do FastAPI com a opção de linha de comando `--forwarded-allow-ips` e informar os endereços IP que devem ser confiáveis para ler esses headers encaminhados.
+Você pode iniciar a CLI do FastAPI com a *Opção de CLI* `--forwarded-allow-ips` e informar os endereços IP que devem ser confiáveis para ler esses headers encaminhados.

 Se você definir como `--forwarded-allow-ips="*"`, ele confiará em todos os IPs de entrada.

@@ -33,7 +33,7 @@ Se o seu **servidor** estiver atrás de um **proxy** confiável e somente o prox
 <div class="termy">

 ```console
-$ fastapi run --forwarded-allow-ips="*"
+$ uv run fastapi run --forwarded-allow-ips="*"

 <span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
 ```
@@ -48,7 +48,7 @@ Por exemplo, suponha que você defina uma *operação de rota* `/items/`:

 Se o cliente tentar ir para `/items`, por padrão, ele seria redirecionado para `/items/`.

-Mas antes de definir a opção de linha de comando `--forwarded-allow-ips`, poderia redirecionar para `http://localhost:8000/items/`.
+Mas antes de definir a *Opção de CLI* `--forwarded-allow-ips`, poderia redirecionar para `http://localhost:8000/items/`.

 Mas talvez sua aplicação esteja hospedada em `https://mysuperapp.com`, e o redirecionamento deveria ser para `https://mysuperapp.com/items/`.

@@ -87,7 +87,7 @@ sequenceDiagram
    Proxy->>Client: HTTPS Response
 ```

-O **proxy** intercepta a requisição original do cliente e adiciona os headers especiais de encaminhamento (`X-Forwarded-*`) antes de repassar a requisição para o **servidor da aplicação**.
+O **proxy** intercepta a requisição original do cliente e adiciona os headers especiais *encaminhados* (`X-Forwarded-*`) antes de repassar a requisição para o **servidor da aplicação**.

 Esses headers preservam informações sobre a requisição original que, de outra forma, seriam perdidas:

@@ -117,7 +117,7 @@ Embora todo o seu código esteja escrito assumindo que existe apenas `/app`.

 {* ../../docs_src/behind_a_proxy/tutorial001_py310.py hl[6] *}

-E o proxy estaria **"removendo"** o **prefixo de path** dinamicamente antes de transmitir a solicitação para o servidor da aplicação (provavelmente Uvicorn via CLI do FastAPI), mantendo sua aplicação convencida de que está sendo servida em `/app`, para que você não precise atualizar todo o seu código para incluir o prefixo `/api/v1`.
+E o proxy estaria **"removendo"** o **prefixo de path** dinamicamente antes de transmitir a requisição para o servidor da aplicação (provavelmente Uvicorn via CLI do FastAPI), mantendo sua aplicação convencida de que está sendo servida em `/app`, para que você não precise atualizar todo o seu código para incluir o prefixo `/api/v1`.

 Até aqui, tudo funcionaria normalmente.

@@ -170,7 +170,7 @@ Para conseguir isso, você pode usar a opção de linha de comando `--root-path`
 <div class="termy">

 ```console
-$ fastapi run main.py --forwarded-allow-ips="*" --root-path /api/v1
+$ uv run fastapi run main.py --forwarded-allow-ips="*" --root-path /api/v1

 <span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
 ```
@@ -189,7 +189,7 @@ E a opção de linha de comando `--root-path` fornece esse `root_path`.

 ### Verificando o `root_path` atual { #checking-the-current-root-path }

-Você pode obter o `root_path` atual usado pela sua aplicação para cada solicitação, ele faz parte do dicionário `scope` (que faz parte da especificação ASGI).
+Você pode obter o `root_path` atual usado pela sua aplicação para cada requisição, ele faz parte do dicionário `scope` (que faz parte da especificação ASGI).

 Aqui estamos incluindo-o na mensagem apenas para fins de demonstração.

@@ -200,7 +200,7 @@ Então, se você iniciar o Uvicorn com:
 <div class="termy">

 ```console
-$ fastapi run main.py --forwarded-allow-ips="*" --root-path /api/v1
+$ uv run fastapi run main.py --forwarded-allow-ips="*" --root-path /api/v1

 <span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
 ```
@@ -253,7 +253,7 @@ Em um caso como esse (sem um prefixo de path removido), o proxy escutaria em alg

 Você pode facilmente executar o experimento localmente com um prefixo de path removido usando [Traefik](https://docs.traefik.io/).

-[Faça o download do Traefik](https://github.com/containous/traefik/releases), ele é um único binário, você pode extrair o arquivo compactado e executá-lo diretamente do terminal.
+[Faça o download do Traefik](https://github.com/traefik/traefik/releases), ele é um único binário, você pode extrair o arquivo compactado e executá-lo diretamente do terminal.

 Então, crie um arquivo `traefik.toml` com:

@@ -302,7 +302,7 @@ Agora crie esse outro arquivo `routes.toml`:

 Esse arquivo configura o Traefik para usar o prefixo de path `/api/v1`.

-E então o Traefik redirecionará suas solicitações para seu Uvicorn rodando em `http://127.0.0.1:8000`.
+E então o Traefik redirecionará suas requisições para seu Uvicorn rodando em `http://127.0.0.1:8000`.

 Agora inicie o Traefik:

@@ -321,7 +321,7 @@ E agora inicie sua aplicação, usando a opção `--root-path`:
 <div class="termy">

 ```console
-$ fastapi run main.py --forwarded-allow-ips="*" --root-path /api/v1
+$ uv run fastapi run main.py --forwarded-allow-ips="*" --root-path /api/v1

 <span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
 ```
@@ -394,7 +394,7 @@ Este é um caso de uso mais avançado. Sinta-se à vontade para pular.

 Por padrão, o **FastAPI** criará um `server` no OpenAPI schema com o URL para o `root_path`.

-Mas você também pode fornecer outros `servers` alternativos, por exemplo, se quiser que a mesma interface de documentação interaja com ambientes de staging e produção.
+Mas você também pode fornecer outros `servers` alternativos, por exemplo, se quiser que *a mesma* interface de documentação interaja com ambientes de staging e produção.

 Se você passar uma lista personalizada de `servers` e houver um `root_path` (porque sua API está atrás de um proxy), o **FastAPI** inserirá um "server" com esse `root_path` no início da lista.

@@ -451,7 +451,7 @@ Se você não especificar o parâmetro `servers` e `root_path` for igual a `/`,

 ///

-### Desabilitar servidor automático de `root_path` { #disable-automatic-server-from-root-path }
+### Desabilite o servidor automático de `root_path` { #disable-automatic-server-from-root-path }

 Se você não quiser que o **FastAPI** inclua um servidor automático usando o `root_path`, você pode usar o parâmetro `root_path_in_servers=False`:

@@ -6,7 +6,7 @@ Mas o FastAPI também suporta o uso de [`dataclasses`](https://docs.python.org/3

 {* ../../docs_src/dataclasses_/tutorial001_py310.py hl[1,6:11,18:19] *}

-Isso ainda é suportado graças ao **Pydantic**, pois ele tem [suporte interno para `dataclasses`](https://docs.pydantic.dev/latest/concepts/dataclasses/#use-of-stdlib-dataclasses-with-basemodel).
+Isso ainda é suportado graças ao **Pydantic**, pois ele tem [suporte interno para `dataclasses`](https://pydantic.dev/docs/validation/latest/concepts/dataclasses/#usage-of-stdlib-dataclasses-with-basemodel).

 Então, mesmo com o código acima que não usa Pydantic explicitamente, o FastAPI está usando Pydantic para converter essas dataclasses padrão para a própria versão de dataclasses do Pydantic.

@@ -88,7 +88,7 @@ Confira as dicas de anotação no código acima para ver mais detalhes específi

 Você também pode combinar `dataclasses` com outros modelos Pydantic, herdar deles, incluí-los em seus próprios modelos, etc.

-Para saber mais, confira a [documentação do Pydantic sobre dataclasses](https://docs.pydantic.dev/latest/concepts/dataclasses/).
+Para saber mais, confira a [documentação do Pydantic sobre dataclasses](https://pydantic.dev/docs/validation/latest/concepts/dataclasses/).

 ## Versão { #version }

@@ -1,6 +1,5 @@
 # Eventos de lifespan { #lifespan-events }

-
 Você pode definir a lógica (código) que deve ser executada antes da aplicação **inicializar**. Isso significa que esse código será executado **uma vez**, **antes** de a aplicação **começar a receber requisições**.

 Da mesma forma, você pode definir a lógica (código) que deve ser executada quando a aplicação estiver **encerrando**. Nesse caso, esse código será executado **uma vez**, **depois** de possivelmente ter tratado **várias requisições**.
@@ -155,7 +154,7 @@ Por baixo, na especificação técnica do ASGI, isso é parte do [Protocolo Life

 /// note | Nota

-Você pode ler mais sobre os manipuladores de `lifespan` do Starlette na [Documentação do Lifespan do Starlette](https://www.starlette.dev/lifespan/).
+Você pode ler mais sobre os manipuladores de `lifespan` do Starlette na [Documentação do Lifespan do Starlette](https://starlette.dev/lifespan/).

 Incluindo como lidar com estado do lifespan que pode ser usado em outras áreas do seu código.

@@ -12,7 +12,7 @@ Uma opção versátil é o [OpenAPI Generator](https://openapi-generator.tech/),

 Para **clientes TypeScript**, o [Hey API](https://heyapi.dev/) é uma solução feita sob medida, oferecendo uma experiência otimizada para o ecossistema TypeScript.

-Você pode descobrir mais geradores de SDK em [OpenAPI.Tools](https://openapi.tools/#sdk).
+Você pode descobrir mais geradores de SDK em [OpenAPI.Tools](https://openapi.tools/categories/sdk-generators).

 /// tip | Dica

@@ -8,7 +8,7 @@ Nesta seção, veremos como usar outros middlewares.

 ## Adicionando middlewares ASGI { #adding-asgi-middlewares }

-Como o **FastAPI** é baseado no Starlette e implementa a especificação <abbr title="Asynchronous Server Gateway Interface – Interface de Gateway de Servidor Assíncrona">ASGI</abbr>, você pode usar qualquer middleware ASGI.
+Como o **FastAPI** é baseado no Starlette e implementa a especificação <abbr title="Asynchronous Server Gateway Interface - Interface de Gateway de Servidor Assíncrona">ASGI</abbr>, você pode usar qualquer middleware ASGI.

 O middleware não precisa ser feito para o FastAPI ou Starlette para funcionar, desde que siga a especificação ASGI.

@@ -91,7 +91,7 @@ Há muitos outros middlewares ASGI.

 Por exemplo:

-* [`ProxyHeadersMiddleware` do Uvicorn](https://github.com/encode/uvicorn/blob/master/uvicorn/middleware/proxy_headers.py)
+* [`ProxyHeadersMiddleware` do Uvicorn](https://github.com/Kludex/uvicorn/blob/main/uvicorn/middleware/proxy_headers.py)
 * [MessagePack](https://github.com/florimondmanca/msgpack-asgi)

-Para checar outros middlewares disponíveis, confira [Documentação de Middlewares do Starlette](https://www.starlette.dev/middleware/) e a [Lista Incrível do ASGI](https://github.com/florimondmanca/awesome-asgi).
+Para checar outros middlewares disponíveis, confira [Documentação de Middlewares do Starlette](https://starlette.dev/middleware/) e a [Lista Incrível do ASGI](https://github.com/florimondmanca/awesome-asgi).
@@ -35,7 +35,7 @@ Essa parte é bastante normal, a maior parte do código provavelmente já é fam

 /// tip | Dica

-O parâmetro de consulta `callback_url` usa um tipo Pydantic [Url](https://docs.pydantic.dev/latest/api/networks/).
+O parâmetro de consulta `callback_url` usa um tipo Pydantic [Url](https://pydantic.dev/docs/validation/latest/api/pydantic/networks/).

 ///

@@ -106,11 +106,11 @@ Ela deve parecer exatamente como uma *operação de rota* normal do FastAPI:
 Há 2 diferenças principais de uma *operação de rota* normal:

 * Ela não necessita ter nenhum código real, porque sua aplicação nunca chamará esse código. Ele é usado apenas para documentar a *API externa*. Então, a função poderia ter apenas `pass`.
-* O *path* pode conter uma [expressão OpenAPI 3](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#key-expression) (veja mais abaixo) em que pode usar variáveis com parâmetros e partes do request original enviado para *sua API*.
+* O *path* pode conter uma [expressão OpenAPI 3](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#key-expression) (veja mais abaixo) em que pode usar variáveis com parâmetros e partes do request original enviado para *sua API*.

 ### A expressão do path do callback { #the-callback-path-expression }

-O *path* do callback pode ter uma [expressão OpenAPI 3](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#key-expression) que pode conter partes do request original enviado para *sua API*.
+O *path* do callback pode ter uma [expressão OpenAPI 3](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#key-expression) que pode conter partes do request original enviado para *sua API*.

 Nesse caso, é a `str`:

@@ -48,4 +48,4 @@ E como o `Response` pode ser usado frequentemente para definir cabeçalhos e coo

 ///

-Para ver todos os parâmetros e opções disponíveis, verifique a [documentação no Starlette](https://www.starlette.dev/responses/#set-cookie).
+Para ver todos os parâmetros e opções disponíveis, verifique a [documentação no Starlette](https://starlette.dev/responses/#set-cookie).
@@ -1,6 +1,5 @@
 # Cabeçalhos de resposta { #response-headers }

-
 ## Use um parâmetro `Response` { #use-a-response-parameter }

 Você pode declarar um parâmetro do tipo `Response` na sua *função de operação de rota* (assim como você pode fazer para cookies).
@@ -39,4 +38,4 @@ E como a `Response` pode ser usada frequentemente para definir cabeçalhos e coo

 Tenha em mente que cabeçalhos personalizados proprietários podem ser adicionados [usando o prefixo `X-`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers).

-Porém, se você tiver cabeçalhos personalizados que deseja que um cliente no navegador possa ver, você precisa adicioná-los às suas configurações de CORS (saiba mais em [CORS (Cross-Origin Resource Sharing)](../tutorial/cors.md)), usando o parâmetro `expose_headers` descrito na [documentação de CORS do Starlette](https://www.starlette.dev/middleware/#corsmiddleware).
+Porém, se você tiver cabeçalhos personalizados que deseja que um cliente no navegador possa ver, você precisa adicioná-los às suas configurações de CORS (saiba mais em [CORS (Cross-Origin Resource Sharing)](../tutorial/cors.md)), usando o parâmetro `expose_headers` descrito na [documentação de CORS do Starlette](https://starlette.dev/middleware/#corsmiddleware).
@@ -1,36 +1,39 @@
 # Configurações e Variáveis de Ambiente { #settings-and-environment-variables }

-
 Em muitos casos, sua aplicação pode precisar de configurações externas, por exemplo chaves secretas, credenciais de banco de dados, credenciais para serviços de e-mail, etc.

 A maioria dessas configurações é variável (pode mudar), como URLs de banco de dados. E muitas podem ser sensíveis, como segredos.

 Por esse motivo, é comum fornecê-las em variáveis de ambiente lidas pela aplicação.

+Uma **variável de ambiente** (também conhecida como **env var**) é um valor que existe fora do código Python, no sistema operacional, e pode ser lido pela sua aplicação e por outros programas.
+
+Você pode criar uma variável de ambiente para um comando ao executá-lo. Você verá os comandos específicos de cada plataforma abaixo.
+
 /// tip | Dica

-Para entender variáveis de ambiente, você pode ler [Variáveis de Ambiente](../environment-variables.md).
+Leia o [guia de Variáveis de Ambiente](https://tiangolo.com/guides/environment-variables/) para uma explicação detalhada de como variáveis de ambiente funcionam.

 ///

 ## Tipagem e validação { #types-and-validation }

-Essas variáveis de ambiente só conseguem lidar com strings de texto, pois são externas ao Python e precisam ser compatíveis com outros programas e com o resto do sistema (e até com diferentes sistemas operacionais, como Linux, Windows, macOS).
+Essas variáveis de ambiente só conseguem lidar com strings de texto, pois são externas ao Python e precisam ser compatíveis com outros programas e com o resto do sistema (e até com diferentes sistemas operacionais, como Linux, Windows e macOS).

 Isso significa que qualquer valor lido em Python a partir de uma variável de ambiente será uma `str`, e qualquer conversão para um tipo diferente ou validação precisa ser feita em código.

 ## Pydantic `Settings` { #pydantic-settings }

-Felizmente, o Pydantic fornece uma ótima utilidade para lidar com essas configurações vindas de variáveis de ambiente com [Pydantic: Settings management](https://docs.pydantic.dev/latest/concepts/pydantic_settings/).
+Felizmente, o Pydantic fornece uma ótima utilidade para lidar com essas configurações vindas de variáveis de ambiente com [Pydantic: Settings management](https://pydantic.dev/docs/validation/latest/concepts/pydantic_settings/).

 ### Instalar `pydantic-settings` { #install-pydantic-settings }

-Primeiro, certifique-se de criar seu [ambiente virtual](../virtual-environments.md), ativá-lo e então instalar o pacote `pydantic-settings`:
+Adicione o pacote `pydantic-settings` ao seu projeto:

 <div class="termy">

 ```console
-$ pip install pydantic-settings
+$ uv add pydantic-settings
 ---> 100%
 ```

@@ -41,7 +44,7 @@ Ele também vem incluído quando você instala os extras `all` com:
 <div class="termy">

 ```console
-$ pip install "fastapi[all]"
+$ uv add "fastapi[all]"
 ---> 100%
 ```

@@ -77,19 +80,39 @@ Depois você pode usar o novo objeto `settings` na sua aplicação:

 Em seguida, você executaria o servidor passando as configurações como variáveis de ambiente, por exemplo, você poderia definir `ADMIN_EMAIL` e `APP_NAME` com:

+//// tab | Linux, macOS, Windows Bash
+
 <div class="termy">

 ```console
-$ ADMIN_EMAIL="deadpool@example.com" APP_NAME="ChimichangApp" fastapi run main.py
+$ ADMIN_EMAIL="deadpool@example.com" APP_NAME="ChimichangApp" uv run fastapi run main.py

 <span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
 ```

 </div>

+////
+
+//// tab | Windows PowerShell
+
+<div class="termy">
+
+```console
+$ $Env:ADMIN_EMAIL = "deadpool@example.com"
+$ $Env:APP_NAME = "ChimichangApp"
+$ uv run fastapi run main.py
+
+<span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
+```
+
+</div>
+
+////
+
 /// tip | Dica

-Para definir várias variáveis de ambiente para um único comando, basta separá-las com espaço e colocá-las todas antes do comando.
+No Bash, para definir várias env vars para um único comando, separe-as com espaço e coloque todas antes do comando.

 ///

@@ -173,11 +196,11 @@ Mas um arquivo dotenv não precisa ter exatamente esse nome de arquivo.

 ///

-O Pydantic tem suporte para leitura desses tipos de arquivos usando uma biblioteca externa. Você pode ler mais em [Pydantic Settings: Dotenv (.env) support](https://docs.pydantic.dev/latest/concepts/pydantic_settings/#dotenv-env-support).
+O Pydantic tem suporte para leitura desses tipos de arquivos usando uma biblioteca externa. Você pode ler mais em [Pydantic Settings: suporte a Dotenv (.env)](https://pydantic.dev/docs/validation/latest/concepts/pydantic_settings/#dotenv-env-support).

 /// tip | Dica

-Para isso funcionar, você precisa executar `pip install python-dotenv`.
+Para isso funcionar, adicione `python-dotenv` ao seu projeto com `uv add python-dotenv`.

 ///

@@ -198,7 +221,7 @@ E então atualizar seu `config.py` com:

 /// tip | Dica

-O atributo `model_config` é usado apenas para configuração do Pydantic. Você pode ler mais em [Pydantic: Concepts: Configuration](https://docs.pydantic.dev/latest/concepts/config/).
+O atributo `model_config` é usado apenas para configuração do Pydantic. Você pode ler mais em [Pydantic: Conceitos: Configuração](https://pydantic.dev/docs/validation/latest/concepts/config/).

 ///

@@ -296,7 +319,7 @@ Dessa forma, ela se comporta quase como se fosse apenas uma variável global. Ma

 ## Recapitulando { #recap }

-Você pode usar Pydantic Settings para lidar com as configurações da sua aplicação, com todo o poder dos modelos Pydantic.
+Você pode usar Pydantic Settings para lidar com as definições ou configurações da sua aplicação, com todo o poder dos modelos Pydantic.

 * Usando uma dependência você pode simplificar os testes.
 * Você pode usar arquivos `.env` com ele.
@@ -35,7 +35,7 @@ Agora, execute o comando `fastapi`:
 <div class="termy">

 ```console
-$ fastapi dev
+$ uv run fastapi dev

 <span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
 ```
@@ -8,12 +8,12 @@ Existem utilitários para configurá-lo facilmente que você pode usar diretamen

 ## Instalar dependências { #install-dependencies }

-Certifique-se de criar um [ambiente virtual](../virtual-environments.md), ativá-lo e instalar `jinja2`:
+Adicione `jinja2` ao seu projeto:

 <div class="termy">

 ```console
-$ pip install jinja2
+$ uv add jinja2

 ---> 100%
 ```
@@ -24,22 +24,22 @@ $ pip install jinja2

 * Importe `Jinja2Templates`.
 * Crie um objeto `templates` que você possa reutilizar posteriormente.
-* Declare um parâmetro `Request` no *path operation* que retornará um template.
-* Use o `templates` que você criou para renderizar e retornar uma `TemplateResponse`, passe o nome do template, o objeto `request` e um dicionário "context" com pares chave-valor a serem usados dentro do template do Jinja2.
+* Declare um parâmetro `Request` na *operação de rota* que retornará um template.
+* Use o `templates` que você criou para renderizar e retornar uma `TemplateResponse`, passe o nome do template, o objeto request e um dicionário "context" com pares chave-valor a serem usados dentro do template do Jinja2.

 {* ../../docs_src/templates/tutorial001_py310.py hl[4,11,15:18] *}

 /// note | Nota

-Antes do FastAPI 0.108.0, Starlette 0.29.0, `name` era o primeiro parâmetro.
+Antes do FastAPI 0.108.0, Starlette 0.29.0, o `name` era o primeiro parâmetro.

-Além disso, em versões anteriores, o objeto `request` era passado como parte dos pares chave-valor no "context" dict para o Jinja2.
+Além disso, antes disso, em versões anteriores, o objeto `request` era passado como parte dos pares chave-valor no context para o Jinja2.

 ///

 /// tip | Dica

-Ao declarar `response_class=HTMLResponse`, a documentação entenderá que a resposta será HTML.
+Ao declarar `response_class=HTMLResponse`, a interface da documentação poderá saber que a resposta será HTML.

 ///

@@ -53,7 +53,7 @@ Você também poderia usar `from starlette.templating import Jinja2Templates`.

 ## Escrevendo templates { #writing-templates }

-Então você pode escrever um template em `templates/item.html`, por exemplo:
+Então você pode escrever um template em `templates/item.html` com, por exemplo:

 ```jinja hl_lines="7"
 {!../../docs_src/templates/templates/item.html!}
@@ -77,7 +77,7 @@ Item ID: {{ id }}
 {"id": id}
 ```

-Por exemplo, dado um ID de valor `42`, aparecerá:
+Por exemplo, com um ID de `42`, isso renderizará:

 ```html
 Item ID: 42
@@ -85,7 +85,7 @@ Item ID: 42

 ### Argumentos do `url_for` no template { #template-url-for-arguments }

-Você também pode usar `url_for()` dentro do template, ele recebe como argumentos os mesmos argumentos que seriam usados pela sua *path operation function*.
+Você também pode usar `url_for()` dentro do template, ele recebe como argumentos os mesmos argumentos que seriam usados pela sua *função de operação de rota*.

 Logo, a seção com:

@@ -97,7 +97,7 @@ Logo, a seção com:

 {% endraw %}

-...irá gerar um link para a mesma URL que será tratada pela *path operation function* `read_item(id=id)`.
+...irá gerar um link para a mesma URL que será tratada pela *função de operação de rota* `read_item(id=id)`.

 Por exemplo, com um ID de `42`, isso renderizará:

@@ -123,4 +123,4 @@ E como você está usando `StaticFiles`, este arquivo CSS será automaticamente

 ## Mais detalhes { #more-details }

-Para obter mais detalhes, incluindo como testar templates, consulte a [documentação da Starlette sobre templates](https://www.starlette.dev/templates/).
+Para obter mais detalhes, incluindo como testar templates, consulte a [documentação da Starlette sobre templates](https://starlette.dev/templates/).
@@ -4,7 +4,8 @@ Quando você precisa que o `lifespan` seja executado em seus testes, você pode

 {* ../../docs_src/app_testing/tutorial004_py310.py hl[9:15,18,27:28,30:32,41:43] *}

-Você pode ler mais detalhes sobre o ["Executando lifespan em testes no site oficial da documentação do Starlette."](https://www.starlette.dev/lifespan/#running-lifespan-in-tests)
+
+Você pode ler mais detalhes sobre o ["Executando lifespan em testes no site oficial da documentação do Starlette."](https://starlette.dev/lifespan/#running-lifespan-in-tests)

 Para os eventos `startup` e `shutdown` descontinuados, você pode usar o `TestClient` da seguinte forma:

@@ -8,6 +8,6 @@ Para isso, você utiliza o `TestClient` dentro de uma instrução `with`, conect

 /// note | Nota

-Para mais detalhes, confira a documentação do Starlette para [testar WebSockets](https://www.starlette.dev/testclient/#testing-websocket-sessions).
+Para mais detalhes, confira a documentação do Starlette para [testar WebSockets](https://starlette.dev/testclient/#testing-websocket-sessions).

 ///
@@ -15,13 +15,13 @@ Porém há situações em que você possa precisar acessar o objeto `Request` di

 ## Detalhes sobre o objeto `Request` { #details-about-the-request-object }

-Como o **FastAPI** é na verdade o **Starlette** por baixo, com camadas de diversas funcionalidades por cima, você pode utilizar o objeto [`Request`](https://www.starlette.dev/requests/) do Starlette diretamente quando precisar.
+Como o **FastAPI** é na verdade o **Starlette** por baixo, com camadas de diversas funcionalidades por cima, você pode utilizar o objeto [`Request`](https://starlette.dev/requests/) do Starlette diretamente quando precisar.

 Isso significaria também que se você obtiver informações do objeto `Request` diretamente (ler o corpo da requisição por exemplo), as informações não serão validadas, convertidas ou documentadas (com o OpenAPI, para a interface de usuário automática da API) pelo FastAPI.

 Embora qualquer outro parâmetro declarado normalmente (o corpo da requisição com um modelo Pydantic, por exemplo) ainda seria validado, convertido, anotado, etc.

-Mas há situações específicas onde é útil utilizar o objeto `Request`.
+Mas há situações específicas onde é útil obter o objeto `Request`.

 ## Utilize o objeto `Request` diretamente { #use-the-request-object-directly }

@@ -45,7 +45,7 @@ Do mesmo jeito, você pode declarar qualquer outro parâmetro normalmente, e al

 ## Documentação do `Request` { #request-documentation }

-Você pode ler mais sobre os detalhes do [objeto `Request` no site da documentação oficial do Starlette](https://www.starlette.dev/requests/).
+Você pode ler mais sobre os detalhes do [objeto `Request` no site da documentação oficial do Starlette](https://starlette.dev/requests/).

 /// note | Detalhes Técnicos

@@ -4,12 +4,12 @@ Você pode usar [WebSockets](https://developer.mozilla.org/en-US/docs/Web/API/We

 ## Instale `websockets` { #install-websockets }

-Garanta que você criou um [ambiente virtual](../virtual-environments.md), o ativou e instalou o `websockets` (uma biblioteca Python que facilita o uso do protocolo "WebSocket"):
+Adicione `websockets` (uma biblioteca Python que facilita o uso do protocolo "WebSocket") ao seu projeto:

 <div class="termy">

 ```console
-$ pip install websockets
+$ uv add websockets

 ---> 100%
 ```
@@ -69,7 +69,7 @@ Coloque seu código em um arquivo `main.py` e então execute sua aplicação:
 <div class="termy">

 ```console
-$ fastapi dev
+$ uv run fastapi dev

 <span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
 ```
@@ -126,7 +126,7 @@ Execute sua aplicação:
 <div class="termy">

 ```console
-$ fastapi dev
+$ uv run fastapi dev

 <span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
 ```
@@ -182,5 +182,5 @@ Se você precisa de algo fácil de integrar com o FastAPI, mas que seja mais rob

 Para aprender mais sobre as opções, verifique a documentação do Starlette para:

-* [A classe `WebSocket`](https://www.starlette.dev/websockets/).
-* [Manipulação de WebSockets baseada em classes](https://www.starlette.dev/endpoints/#websocketendpoint).
+* [A classe `WebSocket`](https://starlette.dev/websockets/).
+* [Manipulação de WebSockets baseada em classes](https://starlette.dev/endpoints/#websocketendpoint).
@@ -1,4 +1,4 @@
-# Adicionando WSGI - Flask, Django, entre outros { #including-wsgi-flask-django-others }
+# Incluindo WSGI - Flask, Django, entre outros { #including-wsgi-flask-django-others }


 Como você viu em [Subaplicações - Montagens](sub-applications.md) e [Atrás de um Proxy](behind-a-proxy.md), você pode montar aplicações WSGI.
@@ -9,7 +9,7 @@ Para isso, você pode utilizar o `WSGIMiddleware` para encapsular a sua aplicaç

 /// note | Nota

-Isso requer instalar `a2wsgi`, por exemplo com `pip install a2wsgi`.
+Isso requer adicionar `a2wsgi` ao seu projeto, por exemplo com `uv add a2wsgi`.

 ///

@@ -37,13 +37,13 @@ Agora, todas as requisições sob o path `/v1/` serão manipuladas pela aplicaç

 E o resto será manipulado pelo **FastAPI**.

-Se você rodar a aplicação e ir até [http://localhost:8000/v1/](http://localhost:8000/v1/), você verá o retorno do Flask:
+Se você rodar a aplicação e ir até [http://localhost:8000/v1/](http://localhost:8000/v1/) você verá o retorno do Flask:

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

-E se você for até [http://localhost:8000/v2](http://localhost:8000/v2), você verá o retorno do FastAPI:
+E se você for até [http://localhost:8000/v2](http://localhost:8000/v2) você verá o retorno do FastAPI:

 ```JSON
 {
@@ -68,11 +68,11 @@ Ter um sistema de roteamento simples e fácil de usar.

 **FastAPI** na verdade não é uma alternativa ao **Requests**. O escopo deles é muito diferente.

-Na verdade, é comum utilizar Requests dentro de uma aplicação FastAPI.
+Na verdade, é comum utilizar Requests *dentro* de uma aplicação FastAPI.

 Ainda assim, o FastAPI tirou bastante inspiração do Requests.

-**Requests** é uma biblioteca para interagir com APIs (como um cliente), enquanto **FastAPI** é uma biblioteca para construir APIs (como um servidor).
+**Requests** é uma biblioteca para *interagir* com APIs (como um cliente), enquanto **FastAPI** é uma biblioteca para *construir* APIs (como um servidor).

 Eles estão, mais ou menos, em pontas opostas, complementando-se.

@@ -125,7 +125,7 @@ Adotar e usar um padrão aberto para especificações de API, em vez de um schem
 E integrar ferramentas de interface para usuários baseadas nos padrões:

 * [Swagger UI](https://github.com/swagger-api/swagger-ui)
-* [ReDoc](https://github.com/Rebilly/ReDoc)
+* [ReDoc](https://github.com/Redocly/redoc)

 Essas duas foram escolhidas por serem bem populares e estáveis, mas fazendo uma pesquisa rápida, você pode encontrar dúzias de interfaces alternativas adicionais para OpenAPI (que você pode utilizar com **FastAPI**).

@@ -237,7 +237,7 @@ Gerar o schema OpenAPI automaticamente, a partir do mesmo código que define ser

 ///

-### [NestJS](https://nestjs.com/) (e [Angular](https://angular.io/)) { #nestjs-and-angular }
+### [NestJS](https://nestjs.com/) (e [Angular](https://angular.dev/)) { #nestjs-and-angular }

 Isso nem é Python, NestJS é um framework NodeJS em JavaScript (TypeScript) inspirado pelo Angular.

@@ -337,7 +337,7 @@ Como é baseado no padrão anterior para frameworks web Python síncronos (WSGI)

 /// note | Nota

-Hug foi criado por Timothy Crosley, o mesmo criador do [`isort`](https://github.com/timothycrosley/isort), uma ótima ferramenta para ordenar automaticamente imports em arquivos Python.
+Hug foi criado por Timothy Crosley, o mesmo criador do [`isort`](https://github.com/PyCQA/isort), uma ótima ferramenta para ordenar automaticamente imports em arquivos Python.

 ///

@@ -401,7 +401,7 @@ Eu considero o **FastAPI** um "sucessor espiritual" do APIStar, enquanto aprimor

 ## Usados por **FastAPI** { #used-by-fastapi }

-### [Pydantic](https://docs.pydantic.dev/) { #pydantic }
+### [Pydantic](https://pydantic.dev/docs/) { #pydantic }

 Pydantic é uma biblioteca para definir validação de dados, serialização e documentação (usando JSON Schema) com base nas anotações de tipo do Python.

@@ -417,7 +417,7 @@ Controlar toda a validação de dados, serialização de dados e documentação

 ///

-### [Starlette](https://www.starlette.dev/) { #starlette }
+### [Starlette](https://starlette.dev/) { #starlette }

 Starlette é um framework/caixa de ferramentas <dfn title="O novo padrão para construir aplicações web Python assíncronas">ASGI</dfn> leve, o que é ideal para construir serviços asyncio de alta performance.

@@ -462,7 +462,7 @@ Então, qualquer coisa que você pode fazer com Starlette, você pode fazer dire

 ///

-### [Uvicorn](https://www.uvicorn.dev/) { #uvicorn }
+### [Uvicorn](https://uvicorn.dev) { #uvicorn }

 Uvicorn é um servidor ASGI extremamente rápido, construído com uvloop e httptools.

@@ -105,36 +105,32 @@ Isso é o que você quer fazer na **maioria dos casos**, por exemplo:

 ### Requisitos de Pacotes { #package-requirements }

-Você normalmente teria os **requisitos de pacotes** da sua aplicação em algum arquivo.
+Quando você gerencia seu projeto com `uv`, suas dependências diretas são declaradas em `pyproject.toml` e as versões resolvidas exatas são armazenadas em `uv.lock`.

-Isso pode depender principalmente da ferramenta que você usa para **instalar** esses requisitos.
-
-A forma mais comum de fazer isso é ter um arquivo `requirements.txt` com os nomes dos pacotes e suas versões, um por linha.
-
-Você, naturalmente, usaria as mesmas ideias que você leu em [Sobre versões do FastAPI](versions.md) para definir os intervalos de versões.
-
-Por exemplo, seu `requirements.txt` poderia parecer com:
-
-```
-fastapi[standard]>=0.113.0,<0.114.0
-pydantic>=2.7.0,<3.0.0
-```
-
-E você normalmente instalaria essas dependências de pacote com `pip`, por exemplo:
+Você pode adicionar os pacotes de que sua aplicação precisa com:

 <div class="termy">

 ```console
-$ pip install -r requirements.txt
+$ uv add "fastapi[standard]" pydantic
 ---> 100%
-Successfully installed fastapi pydantic
 ```

 </div>

 /// note | Nota

-Há outros formatos e ferramentas para definir e instalar dependências de pacotes.
+O Dockerfile abaixo usa `pip` dentro do contêiner. Você pode exportar as dependências bloqueadas do seu projeto uv para o formato `requirements.txt` esperado por ele:
+
+<div class="termy">
+
+```console
+$ uv export --format requirements-txt --no-dev --no-emit-project --output-file requirements.txt
+```
+
+</div>
+
+O `requirements.txt` gerado é uma exportação para a construção do contêiner. Continue gerenciando dependências com `uv add` e gere-o novamente quando `uv.lock` mudar.

 ///

@@ -372,7 +368,7 @@ Você verá a documentação interativa automática da API (fornecida pelo [Swag

 E você também pode ir para [http://192.168.99.100/redoc](http://192.168.99.100/redoc) ou [http://127.0.0.1/redoc](http://127.0.0.1/redoc) (ou equivalente, usando seu host Docker).

-Você verá a documentação alternativa automática (fornecida pelo [ReDoc](https://github.com/Rebilly/ReDoc)):
+Você verá a documentação alternativa automática (fornecida pelo [ReDoc](https://github.com/Redocly/redoc)):

 ![ReDoc](https://fastapi.tiangolo.com/img/index/index-02-redoc-simple.png)

@@ -5,7 +5,7 @@ Você pode implantar sua aplicação FastAPI no [FastAPI Cloud](https://fastapic
 <div class="termy">

 ```console
-$ fastapi deploy
+$ uv run fastapi deploy

 Deploying to FastAPI Cloud...

@@ -48,13 +48,13 @@ Vamos nos aprofundar um pouco mais em detalhes.

 FastAPI utiliza um padrão para construir frameworks e servidores web em Python chamado <abbr title="Asynchronous Server Gateway Interface - Interface de Gateway de Servidor Assíncrono">ASGI</abbr>. FastAPI é um framework web ASGI.

-A principal coisa que você precisa para executar uma aplicação **FastAPI** (ou qualquer outra aplicação ASGI) em uma máquina de servidor remoto é um programa de servidor ASGI como o **Uvicorn**, que é o que vem por padrão no comando `fastapi`.
+A principal coisa que você precisa para executar uma aplicação **FastAPI** (ou qualquer outra aplicação ASGI) em uma máquina de servidor remoto é um programa de servidor ASGI como o **Uvicorn**, este é o que vem por padrão no comando `fastapi`.

 Existem diversas alternativas, incluindo:

-* [Uvicorn](https://www.uvicorn.dev/): um servidor ASGI de alta performance.
-* [Hypercorn](https://hypercorn.readthedocs.io/): um servidor ASGI compatível com HTTP/2, Trio e outras funcionalidades.
-* [Daphne](https://github.com/django/daphne): servidor ASGI construído para Django Channels.
+* [Uvicorn](https://uvicorn.dev): um servidor ASGI de alta performance.
+* [Hypercorn](https://hypercorn.readthedocs.io/): um servidor ASGI compatível com HTTP/2 e Trio, entre outras funcionalidades.
+* [Daphne](https://github.com/django/daphne): o servidor ASGI construído para Django Channels.
 * [Granian](https://github.com/emmett-framework/granian): um servidor HTTP Rust para aplicações Python.

 ## Máquina Servidora e Programa Servidor { #server-machine-and-server-program }
@@ -73,14 +73,14 @@ Quando você instala o FastAPI, ele vem com um servidor de produção, o Uvicorn

 Mas você também pode instalar um servidor ASGI manualmente.

-Certifique-se de criar um [ambiente virtual](../virtual-environments.md), ativá-lo e, em seguida, você pode instalar a aplicação do servidor.
+Adicione a aplicação do servidor ao seu projeto.

 Por exemplo, para instalar o Uvicorn:

 <div class="termy">

 ```console
-$ pip install "uvicorn[standard]"
+$ uv add "uvicorn[standard]"

 ---> 100%
 ```
@@ -95,7 +95,7 @@ Adicionando o `standard`, o Uvicorn instalará e usará algumas dependências ex

 Isso inclui o `uvloop`, a substituição de alto desempenho para `asyncio`, que fornece um grande aumento de desempenho de concorrência.

-Quando você instala o FastAPI com algo como `pip install "fastapi[standard]"`, você já obtém `uvicorn[standard]` também.
+Quando você adiciona o FastAPI com algo como `uv add "fastapi[standard]"`, você já obtém `uvicorn[standard]` também.

 ///

@@ -106,7 +106,7 @@ Se você instalou um servidor ASGI manualmente, normalmente precisará passar um
 <div class="termy">

 ```console
-$ uvicorn main:app --host 0.0.0.0 --port 80
+$ uv run uvicorn main:app --host 0.0.0.0 --port 80

 <span style="color: green;">INFO</span>:     Uvicorn running on http://0.0.0.0:80 (Press CTRL+C to quit)
 ```
@@ -9,9 +9,9 @@ Vamos rever os conceitos de implantação anteriores:
 * Memória
 * Etapas anteriores antes de iniciar

-Até este ponto, com todos os tutoriais nos documentos, você provavelmente estava executando um **programa de servidor**, por exemplo, usando o comando `fastapi`, que executa o Uvicorn, executando um **único processo**.
+Até este ponto, com todos os tutoriais na documentação, você provavelmente estava executando um **programa de servidor**, por exemplo, usando o comando `fastapi`, que executa o Uvicorn, executando um **único processo**.

-Ao implantar aplicativos, você provavelmente desejará ter alguma **replicação de processos** para aproveitar **vários núcleos** e poder lidar com mais solicitações.
+Ao implantar aplicativos, você provavelmente desejará ter alguma **replicação de processos** para aproveitar **vários núcleos** e poder lidar com mais requests.

 Como você viu no capítulo anterior sobre [Conceitos de implantação](concepts.md), há várias estratégias que você pode usar.

@@ -21,7 +21,7 @@ Aqui mostrarei como usar o **Uvicorn** com **processos de trabalho** usando o co

 Se você estiver usando contêineres, por exemplo com Docker ou Kubernetes, falarei mais sobre isso no próximo capítulo: [FastAPI em contêineres - Docker](docker.md).

-Em particular, ao executar no **Kubernetes** você provavelmente **não** vai querer usar vários trabalhadores e, em vez disso, executar **um único processo Uvicorn por contêiner**, mas falarei sobre isso mais adiante neste capítulo.
+Em particular, ao executar no **Kubernetes** você provavelmente **não** vai querer usar trabalhadores e, em vez disso, executar **um único processo Uvicorn por contêiner**, mas falarei sobre isso mais adiante naquele capítulo.

 ///

@@ -86,7 +86,7 @@ Se você preferir usar o comando `uvicorn` diretamente:
 <div class="termy">

 ```console
-$ uvicorn main:app --host 0.0.0.0 --port 8080 --workers 4
+$ uv run uvicorn main:app --host 0.0.0.0 --port 8080 --workers 4
 <font color="#A6E22E">INFO</font>:     Uvicorn running on <b>http://0.0.0.0:8080</b> (Press CTRL+C to quit)
 <font color="#A6E22E">INFO</font>:     Started parent process [<font color="#A1EFE4"><b>27365</b></font>]
 <font color="#A6E22E">INFO</font>:     Started server process [<font color="#A1EFE4">27368</font>]
@@ -113,7 +113,7 @@ Você também pode ver que ele mostra o **PID** de cada processo, `27365` para o

 ## Conceitos de Implantação { #deployment-concepts }

-Aqui você viu como usar vários **trabalhadores** para **paralelizar** a execução do aplicativo, aproveitar **vários núcleos** na CPU e conseguir atender **mais solicitações**.
+Aqui você viu como usar vários **trabalhadores** para **paralelizar** a execução do aplicativo, aproveitar **vários núcleos** na CPU e conseguir atender **mais requests**.

 Da lista de conceitos de implantação acima, o uso de trabalhadores ajudaria principalmente com a parte da **replicação** e um pouco com as **reinicializações**, mas você ainda precisa cuidar dos outros:

@@ -1,298 +1,11 @@
 # Variáveis de Ambiente { #environment-variables }

-/// tip | Dica
+Uma **variável de ambiente** (também conhecida como **env var**) é um valor que existe fora do seu código Python, no sistema operacional, e pode ser lido pela sua aplicação e por outros programas.

-Se você já sabe o que são "variáveis de ambiente" e como usá-las, pode pular esta seção.
+Aplicações FastAPI normalmente usam variáveis de ambiente para configuração, como URLs de bancos de dados, credenciais de email e chaves secretas.

-///
+Você aprenderá como usá-las para configuração da aplicação em [Configurações e Variáveis de Ambiente](advanced/settings.md).

-Uma variável de ambiente (também conhecida como "**env var**") é uma variável que existe **fora** do código Python, no **sistema operacional**, e pode ser lida pelo seu código Python (ou por outros programas também).
+## Saiba Mais { #learn-more }

-Variáveis de ambiente podem ser úteis para lidar com **configurações** do aplicativo, como parte da **instalação** do Python, etc.
-
-## Criar e Usar Variáveis de Ambiente { #create-and-use-env-vars }
-
-Você pode **criar** e usar variáveis de ambiente no **shell (terminal)**, sem precisar do Python:
-
-//// tab | Linux, macOS, Windows Bash
-
-<div class="termy">
-
-```console
-// Você pode criar uma variável de ambiente MY_NAME com
-$ export MY_NAME="Wade Wilson"
-
-// Então você pode usá-la com outros programas, como
-$ echo "Hello $MY_NAME"
-
-Hello Wade Wilson
-```
-
-</div>
-
-////
-
-//// tab | Windows PowerShell
-
-<div class="termy">
-
-```console
-// Criar uma variável de ambiente MY_NAME
-$ $Env:MY_NAME = "Wade Wilson"
-
-// Usá-la com outros programas, como
-$ echo "Hello $Env:MY_NAME"
-
-Hello Wade Wilson
-```
-
-</div>
-
-////
-
-## Ler Variáveis de Ambiente no Python { #read-env-vars-in-python }
-
-Você também pode criar variáveis de ambiente **fora** do Python, no terminal (ou com qualquer outro método) e depois **lê-las no Python**.
-
-Por exemplo, você poderia ter um arquivo `main.py` com:
-
-```Python hl_lines="3"
-import os
-
-name = os.getenv("MY_NAME", "World")
-print(f"Hello {name} from Python")
-```
-
-/// tip | Dica
-
-O segundo argumento para [`os.getenv()`](https://docs.python.org/3.8/library/os.html#os.getenv) é o valor padrão a ser retornado.
-
-Se não for fornecido, é `None` por padrão, Aqui fornecemos `"World"` como o valor padrão a ser usado.
-
-///
-
-Então você poderia chamar esse programa Python:
-
-//// tab | Linux, macOS, Windows Bash
-
-<div class="termy">
-
-```console
-// Aqui ainda não definimos a variável de ambiente
-$ python main.py
-
-// Como não definimos a variável de ambiente, obtemos o valor padrão
-
-Hello World from Python
-
-// Mas se criarmos uma variável de ambiente primeiro
-$ export MY_NAME="Wade Wilson"
-
-// E então chamar o programa novamente
-$ python main.py
-
-// Agora ele pode ler a variável de ambiente
-
-Hello Wade Wilson from Python
-```
-
-</div>
-
-////
-
-//// tab | Windows PowerShell
-
-<div class="termy">
-
-```console
-// Aqui ainda não definimos a variável de ambiente
-$ python main.py
-
-// Como não definimos a variável de ambiente, obtemos o valor padrão
-
-Hello World from Python
-
-// Mas se criarmos uma variável de ambiente primeiro
-$ $Env:MY_NAME = "Wade Wilson"
-
-// E então chamar o programa novamente
-$ python main.py
-
-// Agora ele pode ler a variável de ambiente
-
-Hello Wade Wilson from Python
-```
-
-</div>
-
-////
-
-Como as variáveis de ambiente podem ser definidas fora do código, mas podem ser lidas pelo código e não precisam ser armazenadas (com versão no `git`) com o restante dos arquivos, é comum usá-las para configurações ou **definições**.
-
-Você também pode criar uma variável de ambiente apenas para uma **invocação específica do programa**, que só está disponível para aquele programa e apenas pela duração dele.
-
-Para fazer isso, crie-a na mesma linha, antes do próprio programa:
-
-<div class="termy">
-
-```console
-// Criar uma variável de ambiente MY_NAME para esta chamada de programa
-$ MY_NAME="Wade Wilson" python main.py
-
-// Agora ele pode ler a variável de ambiente
-
-Hello Wade Wilson from Python
-
-// A variável de ambiente não existe mais depois
-$ python main.py
-
-Hello World from Python
-```
-
-</div>
-
-/// tip | Dica
-
-Você pode ler mais sobre isso em [The Twelve-Factor App: Config](https://12factor.net/config).
-
-///
-
-## Tipos e Validação { #types-and-validation }
-
-Essas variáveis de ambiente só podem lidar com **strings de texto**, pois são externas ao Python e precisam ser compatíveis com outros programas e com o resto do sistema (e até mesmo com diferentes sistemas operacionais, como Linux, Windows, macOS).
-
-Isso significa que **qualquer valor** lido em Python de uma variável de ambiente **será uma `str`**, e qualquer conversão para um tipo diferente ou qualquer validação precisa ser feita no código.
-
-Você aprenderá mais sobre como usar variáveis de ambiente para lidar com **configurações do aplicativo** no [Guia do Usuário Avançado - Configurações e Variáveis de Ambiente](./advanced/settings.md).
-
-## Variável de Ambiente `PATH` { #path-environment-variable }
-
-Existe uma variável de ambiente **especial** chamada **`PATH`** que é usada pelos sistemas operacionais (Linux, macOS, Windows) para encontrar programas para executar.
-
-O valor da variável `PATH` é uma longa string composta por diretórios separados por dois pontos `:` no Linux e macOS, e por ponto e vírgula `;` no Windows.
-
-Por exemplo, a variável de ambiente `PATH` poderia ter esta aparência:
-
-//// tab | Linux, macOS
-
-```plaintext
-/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin
-```
-
-Isso significa que o sistema deve procurar programas nos diretórios:
-
-* `/usr/local/bin`
-* `/usr/bin`
-* `/bin`
-* `/usr/sbin`
-* `/sbin`
-
-////
-
-//// tab | Windows
-
-```plaintext
-C:\Program Files\Python312\Scripts;C:\Program Files\Python312;C:\Windows\System32
-```
-
-Isso significa que o sistema deve procurar programas nos diretórios:
-
-* `C:\Program Files\Python312\Scripts`
-* `C:\Program Files\Python312`
-* `C:\Windows\System32`
-
-////
-
-Quando você digita um **comando** no terminal, o sistema operacional **procura** o programa em **cada um dos diretórios** listados na variável de ambiente `PATH`.
-
-Por exemplo, quando você digita `python` no terminal, o sistema operacional procura um programa chamado `python` no **primeiro diretório** dessa lista.
-
-Se ele o encontrar, então ele o **usará**. Caso contrário, ele continua procurando nos **outros diretórios**.
-
-### Instalando o Python e Atualizando o `PATH` { #installing-python-and-updating-the-path }
-
-Durante a instalação do Python, você pode ser questionado sobre a atualização da variável de ambiente `PATH`.
-
-//// tab | Linux, macOS
-
-Vamos supor que você instale o Python e ele fique em um diretório `/opt/custompython/bin`.
-
-Se você concordar em atualizar a variável de ambiente `PATH`, o instalador adicionará `/opt/custompython/bin` para a variável de ambiente `PATH`.
-
-Poderia parecer assim:
-
-```plaintext
-/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/opt/custompython/bin
-```
-
-Dessa forma, ao digitar `python` no terminal, o sistema encontrará o programa Python em `/opt/custompython/bin` (último diretório) e o utilizará.
-
-////
-
-//// tab | Windows
-
-Digamos que você instala o Python e ele acaba em um diretório `C:\opt\custompython\bin`.
-
-Se você disser sim para atualizar a variável de ambiente `PATH`, o instalador adicionará `C:\opt\custompython\bin` à variável de ambiente `PATH`.
-
-```plaintext
-C:\Program Files\Python312\Scripts;C:\Program Files\Python312;C:\Windows\System32;C:\opt\custompython\bin
-```
-
-Dessa forma, quando você digitar `python` no terminal, o sistema encontrará o programa Python em `C:\opt\custompython\bin` (o último diretório) e o utilizará.
-
-////
-
-Então, se você digitar:
-
-<div class="termy">
-
-```console
-$ python
-```
-
-</div>
-
-//// tab | Linux, macOS
-
-O sistema **encontrará** o programa `python` em `/opt/custompython/bin` e o executará.
-
-Seria aproximadamente equivalente a digitar:
-
-<div class="termy">
-
-```console
-$ /opt/custompython/bin/python
-```
-
-</div>
-
-////
-
-//// tab | Windows
-
-O sistema **encontrará** o programa `python` em `C:\opt\custompython\bin\python` e o executará.
-
-Seria aproximadamente equivalente a digitar:
-
-<div class="termy">
-
-```console
-$ C:\opt\custompython\bin\python
-```
-
-</div>
-
-////
-
-Essas informações serão úteis ao aprender sobre [Ambientes Virtuais](virtual-environments.md).
-
-## Conclusão { #conclusion }
-
-Com isso, você deveria ter uma compreensão básica do que são **variáveis de ambiente** e como usá-las em Python.
-
-Você também pode ler mais sobre elas na [Wikipedia para Variáveis de Ambiente](https://en.wikipedia.org/wiki/Environment_variable).
-
-Em muitos casos, não é muito óbvio como as variáveis de ambiente seriam úteis e aplicáveis imediatamente. Mas elas continuam aparecendo em muitos cenários diferentes quando você está desenvolvendo, então é bom saber sobre elas.
-
-Por exemplo, você precisará dessas informações na próxima seção, sobre [Ambientes Virtuais](virtual-environments.md).
+Leia o [guia de Variáveis de Ambiente](https://tiangolo.com/guides/environment-variables/) para uma explicação detalhada e multiplataforma, incluindo como criar e ler variáveis de ambiente e como a variável de ambiente `PATH` funciona.
@@ -2,7 +2,7 @@

 **FastAPI <abbr title="command line interface - interface de linha de comando">CLI</abbr>** é um programa de linha de comando que você pode usar para servir sua aplicação FastAPI, gerenciar seu projeto FastAPI e muito mais.

-Quando você instala o FastAPI (por exemplo, com `pip install "fastapi[standard]"`), ele vem com um programa de linha de comando que você pode executar no terminal.
+Quando você adiciona o FastAPI ao seu projeto (por exemplo, com `uv add "fastapi[standard]"`), ele vem com um programa de linha de comando que você pode executar no terminal.

 Para executar sua aplicação FastAPI durante o desenvolvimento, você pode usar o comando `fastapi dev`:

@@ -52,7 +52,7 @@ Em produção, você usaria `fastapi run` em vez de `fastapi dev`. 🚀

 ///

-Internamente, o **FastAPI CLI** usa o [Uvicorn](https://www.uvicorn.dev), um servidor ASGI de alta performance e pronto para produção. 😎
+Internamente, o **FastAPI CLI** usa o [Uvicorn](https://uvicorn.dev), um servidor ASGI de alta performance e pronto para produção. 😎

 O CLI `fastapi` tentará detectar automaticamente a aplicação FastAPI a ser executada, assumindo que seja um objeto chamado `app` em um arquivo `main.py` (ou algumas outras variantes).

@@ -100,13 +100,13 @@ from backend.main import app
 Você também pode passar o caminho do arquivo para o comando `fastapi dev`, e ele deduzirá o objeto da aplicação FastAPI a usar:

 ```console
-$ fastapi dev main.py
+$ uv run fastapi dev main.py
 ```

 Ou, você também pode passar a opção `--entrypoint` para o comando `fastapi dev`:

 ```console
-$ fastapi dev --entrypoint main:app
+$ uv run fastapi dev --entrypoint main:app
 ```

 Mas você teria que lembrar de passar o caminho\entrypoint correto toda vez que chamar o comando `fastapi`.
@@ -119,13 +119,17 @@ Executar `fastapi dev` inicia o modo de desenvolvimento.

 Por padrão, o **recarregamento automático** está ativado, recarregando o servidor automaticamente quando você faz mudanças no seu código. Isso consome muitos recursos e pode ser menos estável do que quando está desativado. Você deveria usá-lo apenas no desenvolvimento. Ele também escuta no endereço IP `127.0.0.1`, que é o IP para a sua máquina se comunicar apenas consigo mesma (`localhost`).

+Antes de importar sua aplicação, `fastapi dev` define a variável de ambiente `FASTAPI_ENV` como `development`. Se `FASTAPI_ENV` já estiver definida, seu valor existente é preservado. Isso permite que o código de inicialização da aplicação escolha um comportamento adequado para desenvolvimento, ao mesmo tempo que permite fornecer um ambiente específico da aplicação, como `staging`.
+
+Os valores convencionais de `FASTAPI_ENV` são `development` e `production`. Atualmente, `fastapi run` deixa `FASTAPI_ENV` inalterada, então defina-a explicitamente se sua aplicação precisar detectar o modo de produção.
+
 ## `fastapi run` { #fastapi-run }

 Executar `fastapi run` inicia o FastAPI em modo de produção.

-Por padrão, o **recarregamento automático** está desativado. Ele também escuta no endereço IP `0.0.0.0`, o que significa todos os endereços IP disponíveis; dessa forma, ficará acessível publicamente para qualquer pessoa que consiga se comunicar com a máquina. É assim que você normalmente o executaria em produção, por exemplo, em um contêiner.
+Por padrão, **auto-reload** está desativado. Ele também escuta no endereço IP `0.0.0.0`, o que significa todos os endereços IP disponíveis; dessa forma, ficará acessível publicamente para qualquer pessoa que consiga se comunicar com a máquina. É assim que você normalmente o executaria em produção, por exemplo, em um contêiner.

-Na maioria dos casos, você teria (e você deveria ter) um "proxy de terminação" tratando o HTTPS por cima; isso dependerá de como você faz o deploy da sua aplicação, seu provedor pode fazer isso por você ou talvez seja necessário que você configure isso por conta própria.
+Na maioria dos casos, você teria (e deveria ter) um "proxy de terminação" tratando o HTTPS por cima; isso dependerá de como você faz o deploy da sua aplicação, seu provedor pode fazer isso por você ou talvez seja necessário que você configure por conta própria.

 /// tip | Dica

@@ -19,7 +19,7 @@ Documentação interativa da API e navegação web da interface de usuário. Com

 ![Interação Swagger UI](https://fastapi.tiangolo.com/img/index/index-03-swagger-02.png)

-* Documentação alternativa da API com [**ReDoc**](https://github.com/Rebilly/ReDoc).
+* Documentação alternativa da API com [**ReDoc**](https://github.com/Redocly/redoc).

 ![ReDoc](https://fastapi.tiangolo.com/img/index/index-06-redoc-02.png)

@@ -159,7 +159,7 @@ Qualquer integração é projetada para ser tão simples de usar (com dependênc

 ## Funcionalidades do Starlette { #starlette-features }

-**FastAPI** é totalmente compatível com (e baseado no) [**Starlette**](https://www.starlette.dev/). Então, qualquer código adicional Starlette que você tiver, também funcionará.
+**FastAPI** é totalmente compatível com (e baseado no) [**Starlette**](https://starlette.dev/). Então, qualquer código adicional Starlette que você tiver, também funcionará.

 `FastAPI` é na verdade uma sub-classe do `Starlette`. Então, se você já conhece ou usa Starlette, a maioria das funcionalidades se comportará da mesma forma.

@@ -177,7 +177,7 @@ Com **FastAPI**, você terá todas as funcionalidades do **Starlette** (já que

 ## Funcionalidades do Pydantic { #pydantic-features }

-**FastAPI** é totalmente compatível com (e baseado no) [**Pydantic**](https://docs.pydantic.dev/). Então, qualquer código Pydantic adicional que você tiver, também funcionará.
+**FastAPI** é totalmente compatível com (e baseado no) [**Pydantic**](https://pydantic.dev/docs/). Então, qualquer código Pydantic adicional que você tiver, também funcionará.

 Incluindo bibliotecas externas também baseadas no Pydantic, como <abbr title="Object-Relational Mapper - Mapeador Objeto-Relacional">ORM</abbr>s e <abbr title="Object-Document Mapper - Mapeador Objeto-Documento">ODM</abbr>s para bancos de dados.

@@ -45,20 +45,6 @@ Você pode seguir [a mim (Sebastián Ramírez / `tiangolo`)](https://tiangolo.co
 * [@tiangolo.com no **Bluesky**](https://bsky.app/profile/tiangolo.com)
 * [@tiangolo no **LinkedIn**](https://www.linkedin.com/in/tiangolo/).

-## Ajude outras pessoas com perguntas no GitHub { #help-others-with-questions-in-github }
-
-Você pode tentar ajudar outras pessoas com suas perguntas no [GitHub Discussions](https://github.com/fastapi/fastapi/discussions/categories/questions?discussions_q=category%3AQuestions+is%3Aunanswered).
-
-Em muitos casos você já pode saber a resposta para aquelas perguntas. 🤓
-
-Se você estiver ajudando muitas pessoas com suas perguntas, você se tornará um(a) [Especialista em FastAPI](fastapi-people.md#fastapi-experts) oficial. 🎉
-
-Apenas lembre-se, o ponto mais importante é: tente ser gentil. 🤗
-
-### Como ajudar { #how-to-help }
-
-Siga o [guia sobre como ajudar](https://tiangolo.com/open-source/help/#help-others-with-questions-in-github) aqui.
-
 ## Faça perguntas { #ask-questions }

 Você pode [criar uma nova pergunta](https://github.com/fastapi/fastapi/discussions/new?category=questions) no repositório do GitHub, por exemplo para:
@@ -68,7 +54,7 @@ Você pode [criar uma nova pergunta](https://github.com/fastapi/fastapi/discussi

 ## Entre no chat { #join-the-chat }

-Entre no 👥 [servidor de chat do Discord](https://discord.gg/VQjSZaeJmf) 👥 e converse com outras pessoas da comunidade FastAPI.
+Entre no 👥 [servidor de chat do Discord](https://discord.com/invite/VQjSZaeJmf) 👥 e converse com outras pessoas da comunidade FastAPI.

 /// tip | Dica

@@ -85,3 +71,9 @@ Tenha em mente que, como os chats permitem uma “conversa mais livre”, é fá
 No GitHub, o template vai orientar você a escrever a pergunta certa para que você consiga obter uma boa resposta com mais facilidade, ou até resolver o problema sozinho antes de perguntar.

 As conversas nos sistemas de chat também não são tão fáceis de pesquisar quanto no GitHub; elas se perdem.
+
+## Experimente o FastAPI Cloud { #try-fastapi-cloud }
+
+O financiamento principal do FastAPI e amigos vem do [**FastAPI Cloud**](https://fastapicloud.com), uma plataforma para fazer deploy de aplicações FastAPI de forma simples e rápida, com um único comando, `fastapi deploy`.
+
+O FastAPI Cloud é criado pela mesma equipe por trás do FastAPI. Você pode experimentá-lo e considerá-lo para seus projetos.
@@ -8,7 +8,7 @@ Aqui está um pouco dessa história.

 ## Alternativas { #alternatives }

-Eu tenho criado APIs com requisitos complexos por vários anos (Aprendizado de Máquina, sistemas distribuídos, tarefas assíncronas, banco de dados NoSQL etc.), liderando vários times de desenvolvedores.
+Eu tenho criado APIs com requisitos complexos por vários anos (Aprendizado de Máquina, sistemas distribuídos, tarefas assíncronas, bancos de dados NoSQL etc.), liderando vários times de desenvolvedores.

 Como parte disso, eu precisava investigar, testar e usar muitas alternativas.

@@ -22,9 +22,9 @@ Como dito na seção [Alternativas](alternatives.md):

 Há muitas ferramentas criadas antes que ajudaram a inspirar sua criação.

-Eu estive evitando a criação de um novo _framework_ por vários anos. Primeiro tentei resolver todas as funcionalidades cobertas por **FastAPI** usando muitos _frameworks_, _plug-ins_ e ferramentas diferentes.
+Eu estive evitando a criação de um novo framework por vários anos. Primeiro tentei resolver todas as funcionalidades cobertas por **FastAPI** usando muitos frameworks, plug-ins e ferramentas diferentes.

-Mas em algum ponto, não havia outra opção senão criar algo que oferecia todas as funcionalidades, aproveitando as melhores ideias de ferramentas anteriores, e combinando-as da melhor maneira possível, usando funcionalidades da linguagem que nem estavam disponíveis antes (anotações de tipo do Python 3.6+).
+Mas em algum ponto, não havia outra opção senão criar algo que oferecia todas essas funcionalidades, aproveitando as melhores ideias de ferramentas anteriores, e combinando-as da melhor maneira possível, usando funcionalidades da linguagem que nem estavam disponíveis antes (anotações de tipo do Python 3.6+).

 </blockquote>

@@ -36,7 +36,7 @@ Por exemplo, estava claro que idealmente ele deveria ser baseado nas anotações

 Também, a melhor abordagem era usar padrões já existentes.

-Então, antes mesmo de começar a codificar o **FastAPI**, eu investi vários meses estudando as especificações do OpenAPI, JSON Schema, OAuth2 etc. Entendendo suas relações, sobreposições e diferenças.
+Então, antes mesmo de começar a codificar o **FastAPI**, eu investi vários meses estudando as especificações do OpenAPI, JSON Schema, OAuth2 etc. Entendendo sua relação, sobreposições e diferenças.

 ## Design { #design }

@@ -54,11 +54,11 @@ Tudo de uma forma que oferecesse a melhor experiência de desenvolvimento para t

 ## Requisitos { #requirements }

-Após testar várias alternativas, eu decidi que usaria o [**Pydantic**](https://docs.pydantic.dev/) por suas vantagens.
+Após testar várias alternativas, eu decidi que usaria o [**Pydantic**](https://pydantic.dev/docs/) por suas vantagens.

 Então eu contribuí com ele, para deixá-lo completamente de acordo com o JSON Schema, para dar suporte a diferentes maneiras de definir declarações de restrições, e melhorar o suporte a editores (conferências de tipos, preenchimento automático) baseado nos testes em vários editores.

-Durante o desenvolvimento, eu também contribuí com o [**Starlette**](https://www.starlette.dev/), outro requisito chave.
+Durante o desenvolvimento, eu também contribuí com o [**Starlette**](https://starlette.dev/), o outro requisito chave.

 ## Desenvolvimento { #development }

@@ -66,7 +66,7 @@ O dicionário `scope` e a função `receive` são ambos parte da especificação

 E essas duas coisas, `scope` e `receive`, são o que é necessário para criar uma nova instância de `Request`.

-Para aprender mais sobre o `Request` confira a [documentação do Starlette sobre Requests](https://www.starlette.dev/requests/).
+Para aprender mais sobre o `Request` confira a [documentação do Starlette sobre Requests](https://starlette.dev/requests/).

 ///

@@ -6,7 +6,7 @@ Nesta seção, você verá como fazer isso.

 ## O processo normal { #the-normal-process }

-O processo normal (padrão) é o seguinte:
+O processo normal (padrão) é o seguinte.

 Uma aplicação (instância) do `FastAPI` possui um método `.openapi()` que deve retornar o esquema OpenAPI.

@@ -45,9 +45,9 @@ O parâmetro `summary` está disponível no OpenAPI 3.1.0 e superior, suportado

 Com as informações acima, você pode usar a mesma função utilitária para gerar o esquema OpenAPI e sobrescrever cada parte que precisar.

-Por exemplo, vamos adicionar [Extensão OpenAPI do ReDoc para incluir um logo personalizado](https://github.com/Rebilly/ReDoc/blob/master/docs/redoc-vendor-extensions.md#x-logo).
+Por exemplo, vamos adicionar [Extensão OpenAPI do ReDoc para incluir um logo personalizado](https://github.com/Redocly/redoc/blob/main/docs/redoc-vendor-extensions.md#x-logo).

-### **FastAPI** Normal { #normal-fastapi }
+### Normal **FastAPI** { #normal-fastapi }

 Primeiro, escreva toda a sua aplicação **FastAPI** normalmente:

@@ -81,7 +81,7 @@ Agora, você pode substituir o método `.openapi()` pela sua nova função.

 {* ../../docs_src/extending_openapi/tutorial001_py310.py hl[29] *}

-### Verificar { #check-it }
+### Verifique { #check-it }

 Uma vez que você acessar [http://127.0.0.1:8000/redoc](http://127.0.0.1:8000/redoc), verá que está usando seu logo personalizado (neste exemplo, o logo do **FastAPI**):

@@ -22,7 +22,7 @@ Aqui estão algumas das bibliotecas **GraphQL** que têm suporte **ASGI**. Você
 * [Strawberry](https://strawberry.rocks/) 🍓
    * Com [documentação para FastAPI](https://strawberry.rocks/docs/integrations/fastapi)
 * [Ariadne](https://ariadnegraphql.org/)
-    * Com [documentação para FastAPI](https://ariadnegraphql.org/docs/fastapi-integration)
+    * Com [documentação para FastAPI](https://ariadnegraphql.org/server/Integrations/fastapi-integration)
 * [Tartiflette](https://tartiflette.io/)
    * Com [Tartiflette ASGI](https://tartiflette.github.io/tartiflette-asgi/) para fornecer integração ASGI
 * [Graphene](https://graphene-python.org/)
@@ -24,7 +24,7 @@ Se você tem uma aplicação FastAPI antiga com Pydantic v1, aqui vou mostrar co

 ## Guia oficial { #official-guide }

-O Pydantic tem um [Guia de Migração](https://docs.pydantic.dev/latest/migration/) oficial do v1 para o v2.
+O Pydantic tem um [Guia de Migração](https://pydantic.dev/docs/validation/latest/get-started/migration/) oficial do v1 para o v2.

 Ele também inclui o que mudou, como as validações agora são mais corretas e rigorosas, possíveis ressalvas, etc.

@@ -110,14 +110,14 @@ Os recursos chave são:
  </div>
  <div class="fastapi-opinions__panel" id="fo-panel-uber" role="tabpanel" aria-labelledby="fo-tab-uber" tabindex="0" hidden>
    <blockquote class="fastapi-opinions__quote">"Nós adotamos a biblioteca <strong>FastAPI</strong> para iniciar um servidor <strong>REST</strong> que pode ser consultado para obter <strong>previsões</strong>." <em>[para o Ludwig]</em></blockquote>
-    <div class="fastapi-opinions__attr">— Piero Molino, Yaroslav Dudin, Sai Sumanth Miryala, <strong>Uber</strong> <a href="https://eng.uber.com/ludwig-v0-2/">(ref)</a></div>
+    <div class="fastapi-opinions__attr">— Piero Molino, Yaroslav Dudin, Sai Sumanth Miryala, <strong>Uber</strong> <a href="https://www.uber.com/us/en/blog/ludwig-v0-2/">(ref)</a></div>
  </div>
  <div class="fastapi-opinions__panel" id="fo-panel-netflix" role="tabpanel" aria-labelledby="fo-tab-netflix" tabindex="0" hidden>
    <blockquote class="fastapi-opinions__quote">"A <strong>Netflix</strong> tem o prazer de anunciar o lançamento open-source do nosso framework de orquestração de <strong>gerenciamento de crises</strong>: <strong>Dispatch</strong>!" <em>[criado com FastAPI]</em></blockquote>
    <div class="fastapi-opinions__attr">— Kevin Glisson, Marc Vilanova, Forest Monsen, <strong>Netflix</strong> <a href="https://netflixtechblog.com/introducing-dispatch-da4b8a2a8072">(ref)</a></div>
  </div>
  <div class="fastapi-opinions__panel" id="fo-panel-cisco" role="tabpanel" aria-labelledby="fo-tab-cisco" tabindex="0" hidden>
-    <blockquote class="fastapi-opinions__quote">"Se alguém estiver procurando construir uma API Python para produção, eu recomendaria fortemente o <strong>FastAPI</strong>. Ele é <strong>lindamente projetado</strong>, <strong>simples de usar</strong> e <strong>altamente escalável</strong> — tornou-se um <strong>componente chave</strong> na nossa estratégia de desenvolvimento API first."</blockquote>
+    <blockquote class="fastapi-opinions__quote">"Se alguém estiver procurando construir uma API Python para produção, eu recomendaria fortemente o <strong>FastAPI</strong>. Ele é <strong>lindamente projetado</strong>, <strong>simples de usar</strong> e <strong>altamente escalável</strong> — tornou-se um <strong>componente chave</strong> na nossa estratégia de desenvolvimento API-first."</blockquote>
    <div class="fastapi-opinions__attr">— Deon Pillsbury, <strong>Cisco</strong> <a href="https://www.linkedin.com/posts/deonpillsbury_cisco-cx-python-activity-6963242628536487936-trAp/">(ref)</a></div>
  </div>
 </div>
@@ -133,7 +133,7 @@ Os recursos chave são:

 "_Nós adotamos a biblioteca **FastAPI** para iniciar um servidor **REST** que pode ser consultado para obter **previsões**. [para o Ludwig]_"

-<div style="text-align: right; margin-right: 10%;">Piero Molino, Yaroslav Dudin, and Sai Sumanth Miryala - <strong>Uber</strong> <a href="https://eng.uber.com/ludwig-v0-2/"><small>(ref)</small></a></div>
+<div style="text-align: right; margin-right: 10%;">Piero Molino, Yaroslav Dudin, e Sai Sumanth Miryala - <strong>Uber</strong> <a href="https://www.uber.com/us/en/blog/ludwig-v0-2/"><small>(ref)</small></a></div>

 ---

@@ -151,12 +151,6 @@ Os recursos chave são:

 </div>

-## FastAPI Conf { #fastapi-conf }
-
-[**FastAPI Conf '26**](https://fastapiconf.com) acontece em **28 de outubro de 2026** em **Amsterdã, NL**. Tudo sobre FastAPI, direto da fonte. 🎤
-
-<a class="fastapi-feature-banner" href="https://fastapiconf.com"><img src="https://fastapi.tiangolo.com/img/fastapi-conf.jpeg" alt="FastAPI Conf '26 - October 28, 2026 - Amsterdam, NL"></a>
-
 ## Mini documentário do FastAPI { #fastapi-mini-documentary }

 Há um [mini documentário do FastAPI](https://www.youtube.com/watch?v=mpR8ngthqiE) lançado no fim de 2025, você pode assisti-lo online:
@@ -175,17 +169,17 @@ Se você estiver construindo uma aplicação <abbr title="Command Line Interface

 FastAPI está nos ombros de gigantes:

-* [Starlette](https://www.starlette.dev/) para as partes web.
-* [Pydantic](https://docs.pydantic.dev/) para a parte de dados.
+* [Starlette](https://starlette.dev/) para as partes web.
+* [Pydantic](https://pydantic.dev/docs/) para a parte de dados.

 ## Instalação { #installation }

-Crie e ative um [ambiente virtual](https://fastapi.tiangolo.com/pt/virtual-environments/) e então instale o FastAPI:
+Primeiro, [instale o `uv`](https://docs.astral.sh/uv/getting-started/installation/), e então adicione o FastAPI ao seu projeto:

 <div class="termy">

 ```console
-$ pip install "fastapi[standard]"
+$ uv add "fastapi[standard]"

 ---> 100%
 ```
@@ -194,6 +188,8 @@ $ pip install "fastapi[standard]"

 **Nota**: Certifique-se de que você colocou `"fastapi[standard]"` com aspas, para garantir que funcione em todos os terminais.

+Se você preferir usar `pip`, instale `fastapi[standard]` dentro de um ambiente virtual. Veja o [guia de instalação](tutorial/#install-fastapi) para os passos alternativos.
+
 ## Exemplo { #example }

 ### Crie { #create-it }
@@ -250,7 +246,7 @@ Rode o servidor com:
 <div class="termy">

 ```console
-$ fastapi dev
+$ uv run fastapi dev

 ╭────────── FastAPI CLI - Development mode ───────────╮
 │                                                     │
@@ -277,7 +273,7 @@ INFO:     Application startup complete.
 <details markdown="1">
 <summary>Sobre o comando <code>fastapi dev</code>...</summary>

-O comando `fastapi dev` lê automaticamente o seu arquivo `main.py`, detecta a aplicação **FastAPI** nele e inicia um servidor usando o [Uvicorn](https://www.uvicorn.dev).
+O comando `fastapi dev` lê automaticamente o seu arquivo `main.py`, detecta a aplicação **FastAPI** nele e inicia um servidor usando o [Uvicorn](https://uvicorn.dev).

 Por padrão, o `fastapi dev` iniciará com auto-reload habilitado para desenvolvimento local.

@@ -314,7 +310,7 @@ Você verá a documentação automática interativa da API (fornecida por [Swagg

 E agora, vá para [http://127.0.0.1:8000/redoc](http://127.0.0.1:8000/redoc).

-Você verá a documentação automática alternativa (fornecida por [ReDoc](https://github.com/Rebilly/ReDoc)):
+Você verá a documentação automática alternativa (fornecida por [ReDoc](https://github.com/Redocly/redoc)):

 ![ReDoc](https://fastapi.tiangolo.com/img/index/index-02-redoc-simple.png)

@@ -497,7 +493,7 @@ Você pode opcionalmente implantar sua aplicação FastAPI na [FastAPI Cloud](ht
 <div class="termy">

 ```console
-$ fastapi deploy
+$ uv run fastapi deploy

 Deploying to FastAPI Cloud...

@@ -520,7 +516,7 @@ Ela simplifica o processo de **construir**, **implantar** e **acessar** uma API

 Traz a mesma **experiência do desenvolvedor** de construir aplicações com FastAPI para **implantá-las** na nuvem. 🎉

-A FastAPI Cloud é a principal patrocinadora e financiadora dos projetos open source do ecossistema *FastAPI and friends*. ✨
+A FastAPI Cloud é a principal patrocinadora e financiadora dos projetos open source *FastAPI and friends*. ✨

 #### Implante em outros provedores de nuvem { #deploy-to-other-cloud-providers }

@@ -540,7 +536,7 @@ O FastAPI depende do Pydantic e do Starlette.

 ### Dependências `standard` { #standard-dependencies }

-Quando você instala o FastAPI com `pip install "fastapi[standard]"`, ele vem com o grupo `standard` de dependências opcionais:
+Quando você instala o FastAPI com `uv add "fastapi[standard]"`, ele vem com o grupo `standard` de dependências opcionais:

 Utilizado pelo Pydantic:

@@ -554,17 +550,17 @@ Utilizado pelo Starlette:

 Utilizado pelo FastAPI:

-* [`uvicorn`](https://www.uvicorn.dev) - para o servidor que carrega e serve a sua aplicação. Isto inclui `uvicorn[standard]`, que inclui algumas dependências (e.g. `uvloop`) necessárias para servir em alta performance.
+* [`uvicorn`](https://uvicorn.dev) - para o servidor que carrega e serve a sua aplicação. Isto inclui `uvicorn[standard]`, que inclui algumas dependências (e.g. `uvloop`) necessárias para servir em alta performance.
 * `fastapi-cli[standard]` - que disponibiliza o comando `fastapi`.
    * Isso inclui `fastapi-cloud-cli`, que permite implantar sua aplicação FastAPI na [FastAPI Cloud](https://fastapicloud.com).

 ### Sem as dependências `standard` { #without-standard-dependencies }

-Se você não deseja incluir as dependências opcionais `standard`, você pode instalar utilizando `pip install fastapi` ao invés de `pip install "fastapi[standard]"`.
+Se você não deseja incluir as dependências opcionais `standard`, você pode instalar utilizando `uv add fastapi` ao invés de `uv add "fastapi[standard]"`.

 ### Sem o `fastapi-cloud-cli` { #without-fastapi-cloud-cli }

-Se você quiser instalar o FastAPI com as dependências padrão, mas sem o `fastapi-cloud-cli`, você pode instalar com `pip install "fastapi[standard-no-fastapi-cloud-cli]"`.
+Se você quiser instalar o FastAPI com as dependências padrão, mas sem o `fastapi-cloud-cli`, você pode instalar com `uv add "fastapi[standard-no-fastapi-cloud-cli]"`.

 ### Dependências opcionais adicionais { #additional-optional-dependencies }

@@ -572,13 +568,13 @@ Existem algumas dependências adicionais que você pode querer instalar.

 Dependências opcionais adicionais do Pydantic:

-* [`pydantic-settings`](https://docs.pydantic.dev/latest/usage/pydantic_settings/) - para gerenciamento de configurações.
-* [`pydantic-extra-types`](https://docs.pydantic.dev/latest/usage/types/extra_types/extra_types/) - para tipos extras a serem utilizados com o Pydantic.
+* [`pydantic-settings`](https://pydantic.dev/docs/validation/latest/concepts/pydantic_settings/) - para gerenciamento de configurações.
+* [`pydantic-extra-types`](https://github.com/pydantic/pydantic-extra-types) - para tipos extras a serem utilizados com o Pydantic.

 Dependências opcionais adicionais do FastAPI:

 * [`orjson`](https://github.com/ijl/orjson) - Obrigatório se você deseja utilizar o `ORJSONResponse`.
-* [`ujson`](https://github.com/esnme/ultrajson) - Obrigatório se você deseja utilizar o `UJSONResponse`.
+* [`ujson`](https://github.com/ultrajson/ultrajson) - Obrigatório se você deseja utilizar o `UJSONResponse`.

 ## Licença { #license }

@@ -4,13 +4,13 @@ Templates, embora tipicamente venham com alguma configuração específica, são

 Você pode usar esse template para começar, já que ele inclui várias configurações iniciais, segurança, banco de dados e alguns endpoints de API já feitos para você.

-Repositório GitHub: [Full Stack FastAPI Template](https://github.com/tiangolo/full-stack-fastapi-template)
+Repositório GitHub: [Full Stack FastAPI Template](https://github.com/fastapi/full-stack-fastapi-template)

 ## Full Stack FastAPI Template - Pilha de Tecnologias e Recursos { #full-stack-fastapi-template-technology-stack-and-features }

 - ⚡ [**FastAPI**](https://fastapi.tiangolo.com/pt) para a API do backend em Python.
  - 🧰 [SQLModel](https://sqlmodel.tiangolo.com) para as interações do Python com bancos de dados SQL (ORM).
-  - 🔍 [Pydantic](https://docs.pydantic.dev), usado pelo FastAPI, para validação de dados e gerenciamento de configurações.
+  - 🔍 [Pydantic](https://pydantic.dev/docs/), usado pelo FastAPI, para validação de dados e gerenciamento de configurações.
  - 💾 [PostgreSQL](https://www.postgresql.org) como banco de dados SQL.
 - 🚀 [React](https://react.dev) para o frontend.
  - 💃 Usando TypeScript, hooks, Vite, e outras partes de uma stack frontend moderna.
@@ -269,7 +269,7 @@ Isso não significa que "`one_person` é a **classe** chamada `Person`".

 ## Modelos Pydantic { #pydantic-models }

-[Pydantic](https://docs.pydantic.dev/) é uma biblioteca Python para executar a validação de dados.
+[Pydantic](https://pydantic.dev/docs/) é uma biblioteca Python para executar a validação de dados.

 Você declara a "forma" dos dados como classes com atributos.

@@ -285,7 +285,7 @@ Um exemplo da documentação oficial do Pydantic:

 /// note | Nota

-Para saber mais sobre [Pydantic, verifique a documentação](https://docs.pydantic.dev/).
+Para saber mais sobre [Pydantic, verifique a documentação](https://pydantic.dev/docs/).

 ///

@@ -54,6 +54,7 @@ O **FastAPI** sabe o que fazer em cada caso e como reutilizar o mesmo objeto, de

 {* ../../docs_src/background_tasks/tutorial002_an_py310.py hl[13,15,22,25] *}

+
 Neste exemplo, as mensagens serão escritas no arquivo `log.txt` *após* o envio da resposta.

 Se houver uma query na request, ela será registrada em uma tarefa em segundo plano.
@@ -62,7 +63,7 @@ E então outra tarefa em segundo plano gerada na *função de operação de rota

 ## Detalhes técnicos { #technical-details }

-A classe `BackgroundTasks` vem diretamente de [`starlette.background`](https://www.starlette.dev/background/).
+A classe `BackgroundTasks` vem diretamente de [`starlette.background`](https://starlette.dev/background/).

 Ela é importada/incluída diretamente no FastAPI para que você possa importá-la de `fastapi` e evitar importar acidentalmente a alternativa `BackgroundTask` (sem o `s` no final) de `starlette.background`.

@@ -70,7 +71,7 @@ Usando apenas `BackgroundTasks` (e não `BackgroundTask`), é possível usá-la

 Ainda é possível usar `BackgroundTask` sozinho no FastAPI, mas você precisa criar o objeto no seu código e retornar uma `Response` da Starlette incluindo-o.

-Você pode ver mais detalhes na [documentação oficial da Starlette para tarefas em segundo plano](https://www.starlette.dev/background/).
+Você pode ver mais detalhes na [documentação oficial da Starlette para tarefas em segundo plano](https://starlette.dev/background/).

 ## Ressalva { #caveat }

@@ -186,7 +186,7 @@ O resultado final é que os paths dos itens agora são:
 * Todas essas *operações de rota* terão a list de `dependencies` avaliada/executada antes delas.
    * Se você também declarar dependências em uma *operação de rota* específica, **elas também serão executadas**.
    * As dependências do router são executadas primeiro, depois as [`dependencies` no decorador](dependencies/dependencies-in-path-operation-decorators.md) e, em seguida, as dependências de parâmetros normais.
-    * Você também pode adicionar [dependências de `Segurança` com `scopes`](../advanced/security/oauth2-scopes.md).
+    * Você também pode adicionar [dependências de `Security` com `scopes`](../advanced/security/oauth2-scopes.md).

 /// tip | Dica

@@ -487,7 +487,7 @@ Dessa forma o comando `fastapi` saberá onde encontrar sua aplicação.
 Você também poderia passar o path para o comando, como:

 ```console
-$ fastapi dev app/main.py
+$ uv run fastapi dev app/main.py
 ```

 Mas você teria que lembrar de passar o path correto toda vez que chamar o comando `fastapi`.
@@ -503,7 +503,7 @@ Agora, execute sua aplicação:
 <div class="termy">

 ```console
-$ fastapi dev
+$ uv run fastapi dev

 <span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
 ```
@@ -96,7 +96,7 @@ Novamente, apenas fazendo essa declaração, com o **FastAPI**, você ganha:

 Além dos tipos singulares normais como `str`, `int`, `float`, etc. Você também pode usar tipos singulares mais complexos que herdam de `str`.

-Para ver todas as opções possíveis, consulte a [Visão geral dos tipos do Pydantic](https://docs.pydantic.dev/latest/concepts/types/). Você verá alguns exemplos no próximo capítulo.
+Para ver todas as opções possíveis, consulte a [Visão geral dos tipos do Pydantic](https://pydantic.dev/docs/validation/latest/concepts/types/). Você verá alguns exemplos no próximo capítulo.

 Por exemplo, no modelo `Image` nós temos um campo `url`, nós podemos declará-lo como um `HttpUrl` do Pydantic em vez de como uma `str`:

@@ -182,7 +182,7 @@ Mas você também não precisa se preocupar com eles, os dicts de entrada são c

 Você também pode declarar um corpo como um `dict` com chaves de algum tipo e valores de outro tipo.

-Sem ter que saber de antemão quais são os nomes de campos/atributos válidos (como seria o caso dos modelos Pydantic).
+Dessa forma, você não precisa saber de antemão quais são os nomes de campos/atributos válidos (como seria o caso dos modelos Pydantic).

 Isso seria útil se você deseja receber chaves que ainda não conhece.

@@ -7,7 +7,7 @@ O corpo da **requisição** é a informação enviada pelo cliente para sua API.

 Sua API quase sempre precisa enviar um corpo na **resposta**. Mas os clientes não necessariamente precisam enviar **corpos de requisição** o tempo todo, às vezes eles apenas requisitam um path, talvez com alguns parâmetros de consulta, mas não enviam um corpo.

-Para declarar um corpo da **requisição**, você utiliza os modelos do [Pydantic](https://docs.pydantic.dev/) com todos os seus poderes e benefícios.
+Para declarar um corpo da **requisição**, você utiliza os modelos do [Pydantic](https://pydantic.dev/docs/) com todos os seus poderes e benefícios.

 /// note | Nota

@@ -15,7 +15,7 @@ O objetivo principal de `__name__ == "__main__"` é ter algum código que seja e
 <div class="termy">

 ```console
-$ python myapp.py
+$ uv run python myapp.py
 ```

 </div>
@@ -35,7 +35,7 @@ Se você executá-lo com:
 <div class="termy">

 ```console
-$ python myapp.py
+$ uv run python myapp.py
 ```

 </div>
@@ -36,7 +36,7 @@ Aqui estão alguns dos tipos de dados adicionais que você pode usar:
 * `datetime.timedelta`:
    * O `datetime.timedelta` do Python.
    * Em requisições e respostas será representado como um `float` de segundos totais.
-    * O Pydantic também permite representá-lo como uma "codificação de diferença de tempo ISO 8601", [veja a documentação para mais informações](https://docs.pydantic.dev/latest/concepts/serialization/#custom-serializers).
+    * O Pydantic também permite representá-lo como uma "codificação de diferença de tempo ISO 8601", [veja a documentação para mais informações](https://pydantic.dev/docs/validation/latest/concepts/serialization/#custom-serializers).
 * `frozenset`:
    * Em requisições e respostas, será tratado da mesma forma que um `set`:
        * Nas requisições, uma list será lida, eliminando duplicadas e convertendo-a em um `set`.
@@ -49,7 +49,7 @@ Aqui estão alguns dos tipos de dados adicionais que você pode usar:
 * `Decimal`:
    * O `Decimal` padrão do Python.
    * Em requisições e respostas, tratado da mesma forma que um `float`.
-* Você pode checar todos os tipos de dados válidos do Pydantic aqui: [Tipos de dados do Pydantic](https://docs.pydantic.dev/latest/usage/types/types/).
+* Você pode checar todos os tipos de dados válidos do Pydantic aqui: [Tipos de dados do Pydantic](https://pydantic.dev/docs/validation/latest/concepts/types/).

 ## Exemplo { #example }

@@ -166,7 +166,7 @@ Para fazer isso, use a anotação de tipo padrão do Python [`typing.Union`](htt

 /// note | Nota

-Ao definir um [`Union`](https://docs.pydantic.dev/latest/concepts/types/#unions), inclua o tipo mais específico primeiro, seguido pelo tipo menos específico. No exemplo abaixo, o tipo mais específico `PlaneItem` vem antes de `CarItem` em `Union[PlaneItem, CarItem]`.
+Ao definir um [`Union`](https://pydantic.dev/docs/validation/latest/concepts/unions/), inclua o tipo mais específico primeiro, seguido pelo tipo menos específico. No exemplo abaixo, o tipo mais específico `PlaneItem` vem antes de `CarItem` em `Union[PlaneItem, CarItem]`.

 ///

@@ -6,12 +6,18 @@ O arquivo FastAPI mais simples pode se parecer com:

 Copie o conteúdo para um arquivo `main.py`.

+/// tip | Dica
+
+FastAPI tem uma [extensão oficial para VS Code](https://marketplace.visualstudio.com/items?itemName=FastAPILabs.fastapi-vscode) (e Cursor), que fornece muitas funcionalidades, incluindo um explorador de operações de rota, busca de operações de rota, navegação CodeLens em testes (ir para a definição a partir dos testes), e deploy e logs da FastAPI Cloud, tudo a partir do seu editor.
+
+///
+
 Execute o servidor ao vivo:

 <div class="termy">

 ```console
-$ <font color="#4E9A06">fastapi</font> dev
+$ <font color="#4E9A06">uv run fastapi</font> dev

  <span style="background-color:#009485"><font color="#D3D7CF"> FastAPI </font></span>  Starting development server 🚀

@@ -78,7 +84,7 @@ Você verá a documentação interativa automática da API (fornecida por [Swagg

 E agora, vá para [http://127.0.0.1:8000/redoc](http://127.0.0.1:8000/redoc).

-Você verá a documentação alternativa automática (fornecida por [ReDoc](https://github.com/Rebilly/ReDoc)):
+Você verá a documentação alternativa automática (fornecida por [ReDoc](https://github.com/Redocly/redoc)):

 ![ReDoc](https://fastapi.tiangolo.com/img/index/index-02-redoc-simple.png)

@@ -185,13 +191,13 @@ from backend.main import app
 Você também pode passar o path do arquivo para o comando `fastapi dev`, e ele vai deduzir o objeto de aplicação FastAPI a ser usado:

 ```console
-$ fastapi dev main.py
+$ uv run fastapi dev main.py
 ```

 Ou você também pode passar a opção `--entrypoint` para o comando `fastapi dev`:

 ```console
-$ fastapi dev --entrypoint main:app
+$ uv run fastapi dev --entrypoint main:app
 ```

 Mas você teria que lembrar de passar o path\entrypoint correto toda vez que chamar o comando `fastapi`.
@@ -205,7 +211,7 @@ Você pode, opcionalmente, fazer o deploy da sua aplicação FastAPI na [FastAPI
 <div class="termy">

 ```console
-$ fastapi deploy
+$ uv run fastapi deploy

 Deploying to FastAPI Cloud...

@@ -232,7 +238,7 @@ A CLI detectará automaticamente sua aplicação FastAPI e a fará o deploy na n

 `FastAPI` é uma classe que herda diretamente de `Starlette`.

-Você pode usar todas as funcionalidades do [Starlette](https://www.starlette.dev/) com `FastAPI` também.
+Você pode usar todas as funcionalidades do [Starlette](https://starlette.dev/) com `FastAPI` também.

 ///

@@ -52,7 +52,7 @@ Para isso, use `fallback="index.html"`:

 {* ../../docs_src/frontend/tutorial002_py310.py hl[5] *}

-**FastAPI** usa esse fallback somente para requests `GET` e `HEAD` que parecem navegação do navegador. Arquivos ausentes como JavaScript, CSS e imagens ainda retornam `404`.
+**FastAPI** usa esse fallback somente para requests `GET` e `HEAD` que aceitam HTML explicitamente com `Accept: text/html` ou `Accept: application/xhtml+xml`, como requests de navegação do navegador normalmente fazem. Arquivos ausentes como JavaScript, CSS e imagens ainda retornam `404`.

 Requests com outros métodos, como `POST` ou `PUT`, para paths que correspondem apenas ao fallback do frontend também retornam `404`. *Operações de rota* regulares do **FastAPI** ainda têm prioridade maior que rotas de frontend.

@@ -106,9 +106,13 @@ Então paths de frontend ausentes retornam o `404` normal.

 ## Verifique o Diretório { #check-directory }

-Por padrão, `app.frontend()` verifica se o diretório existe quando a aplicação é criada.
+Por padrão, `app.frontend()` usa `check_dir="auto"`.

-Isso ajuda a identificar erros de configuração cedo. Por exemplo, se o diretório de saída do build do frontend estiver ausente, **FastAPI** gerará um erro na inicialização.
+Quando a variável de ambiente `FASTAPI_ENV` é definida como `development`, **FastAPI** mostra apenas um aviso se o diretório de saída do build do frontend estiver ausente. O [comando `fastapi dev`](https://github.com/fastapi/fastapi-cli#fastapi-dev) define essa variável de ambiente para você se ela ainda não estiver definida. Isso permite iniciar o backend antes de fazer o build ou iniciar o frontend durante o desenvolvimento.
+
+Em qualquer outro ambiente, **FastAPI** gera um erro quando a aplicação é criada. Isso ajuda a identificar erros de configuração cedo, antes de fazer deploy de uma aplicação sem seus arquivos de frontend.
+
+Você também pode definir `check_dir=True` para sempre verificar o diretório quando a aplicação for criada.

 Se seus arquivos de frontend forem criados depois, por exemplo por uma etapa de build separada após o objeto da aplicação ser criado, defina `check_dir=False`:

@@ -132,6 +136,8 @@ Responses de frontend são executadas dentro da aplicação **FastAPI** normal,

 Dependências da aplicação, de um `APIRouter` e de `include_router()` também se aplicam a responses de frontend. Isso pode ser útil para proteger um frontend com autenticação por cookie ou similar.

+Dependências também podem modificar headers de response e adicionar tarefas em segundo plano, como em *operações de rota* normais.
+
 ## Apenas Saída de Build Estático { #static-build-output-only }

 `app.frontend()` serve arquivos já gerados pelo build do seu frontend.
@@ -81,7 +81,7 @@ Mas caso precise em um cenário avançado, você pode adicionar headers customiz

 ## Instale manipuladores de exceções customizados { #install-custom-exception-handlers }

-Você pode adicionar manipuladores de exceção customizados com [as mesmas utilidades de exceção do Starlette](https://www.starlette.dev/exceptions/).
+Você pode adicionar manipuladores de exceção customizados com [as mesmas utilidades de exceção do Starlette](https://starlette.dev/exceptions/).

 Digamos que você tenha uma exceção customizada `UnicornException` que você (ou uma biblioteca que você usa) possa lançar com `raise`.

@@ -10,12 +10,12 @@ Ele também foi construído para servir como uma referência futura, então voc

 Todos os blocos de código podem ser copiados e utilizados diretamente (eles são, na verdade, arquivos Python testados).

-Para executar qualquer um dos exemplos, copie o código para um arquivo `main.py`, e inicie o `fastapi dev`:
+Para executar qualquer um dos exemplos, copie o código para um arquivo `main.py`, e inicie o `fastapi dev` com `uv run`:

 <div class="termy">

 ```console
-$ <font color="#4E9A06">fastapi</font> dev
+$ <font color="#4E9A06">uv run fastapi</font> dev

  <span style="background-color:#009485"><font color="#D3D7CF"> FastAPI </font></span>  Starting development server 🚀

@@ -60,35 +60,75 @@ Usá-lo em seu editor é o que realmente mostra os benefícios do FastAPI, vendo

 ## Instale o FastAPI { #install-fastapi }

-O primeiro passo é instalar o FastAPI.
+O primeiro passo é configurar seu projeto e adicionar o FastAPI.

-Certifique-se de criar um [ambiente virtual](../virtual-environments.md), ativá-lo e então **instalar o FastAPI**:
+Instale o [`uv`](https://docs.astral.sh/uv/getting-started/installation/), então crie um projeto e adicione o FastAPI:

 <div class="termy">

 ```console
-$ pip install "fastapi[standard]"
+$ uv init awesome-project --bare
+$ cd awesome-project
+$ uv add "fastapi[standard]"

 ---> 100%
 ```

 </div>

+`uv add` cria o ambiente virtual do projeto em `.venv`, adiciona o FastAPI ao `pyproject.toml` e cria `uv.lock` para que as mesmas versões dos pacotes possam ser instaladas posteriormente.
+
+/// details | O que estes comandos fazem
+
+* `uv init`: cria um novo projeto Python.
+* `awesome-project`: cria o projeto em um novo diretório com este nome.
+* `--bare`: cria apenas o arquivo `pyproject.toml` mínimo, sem gerar um `main.py`, `README.md` ou outros arquivos de exemplo. Você criará os arquivos da aplicação nos próximos passos deste tutorial.
+
+Então `cd awesome-project` entra no novo diretório do projeto antes de adicionar o FastAPI.
+
+`uv` usará uma versão compatível do Python já instalada em seu sistema, ou baixará uma se necessário.
+
+Quando você executa `uv add`, ele seleciona versões compatíveis do FastAPI e de todos os pacotes dos quais o FastAPI depende. Ele registra as versões exatas em `uv.lock`, tornando possível instalar as mesmas versões dos pacotes posteriormente em outro computador ou ao fazer deploy da aplicação.
+
+Criar ou atualizar este arquivo é chamado de [**locking** das dependências do projeto](https://docs.astral.sh/uv/concepts/projects/sync/). O `uv` faz isso automaticamente quando você adiciona um pacote.
+
+///
+
+/// details | Opções de instalação do FastAPI
+
+Quando você instala com `uv add "fastapi[standard]"`, ele vem com algumas dependências opcionais padrão, incluindo `fastapi-cloud-cli`, que permite fazer deploy na [FastAPI Cloud](https://fastapicloud.com).
+
+Se você não quiser ter essas dependências opcionais, pode instalar `uv add fastapi` em vez disso.
+
+Se você quiser instalar as dependências padrão, mas sem o `fastapi-cloud-cli`, você pode instalar com `uv add "fastapi[standard-no-fastapi-cloud-cli]"`.
+
+///
+
+/// details | Usando `pip` em vez disso
+
+Se você preferir gerenciar um ambiente virtual e pacotes manualmente, crie e ative um ambiente virtual e então instale o FastAPI com `pip install "fastapi[standard]"`.
+
+Leia o [guia de Ambientes Virtuais](https://tiangolo.com/guides/virtual-environments/) para os passos detalhados.
+
+///
+
+## Habilidades de Agentes de IA { #ai-agent-skills }
+
+O FastAPI inclui uma skill oficial para agentes de codificação de IA. Ela é incluída no pacote, então sua orientação permanece alinhada com a versão do FastAPI instalada no seu projeto e é atualizada quando você atualiza o FastAPI.
+
+Depois de instalar o FastAPI no seu projeto, você pode instalar a skill com <a href="https://library-skills.io">Library Skills</a>:
+
+```bash
+uvx library-skills
+```
+
 /// note | Nota

-Quando você instala com `pip install "fastapi[standard]"`, ele vem com algumas dependências opcionais padrão, incluindo `fastapi-cloud-cli`, que permite fazer deploy na [FastAPI Cloud](https://fastapicloud.com).
-
-Se você não quiser ter essas dependências opcionais, pode instalar `pip install fastapi` em vez disso.
-
-Se você quiser instalar as dependências padrão, mas sem o `fastapi-cloud-cli`, você pode instalar com `pip install "fastapi[standard-no-fastapi-cloud-cli]"`.
+`uvx` é um alias para `uv tool run`. Ele executa Library Skills em um ambiente temporário e isolado enquanto Library Skills verifica os pacotes instalados no seu projeto.

 ///

-/// tip | Dica
-
-O FastAPI tem uma [extensão oficial para o VS Code](https://marketplace.visualstudio.com/items?itemName=FastAPILabs.fastapi-vscode) (e para o Cursor), que fornece vários recursos, incluindo um explorador de operações de rota, busca de operações de rota, navegação CodeLens em testes (ir para a definição a partir dos testes) e deploy e logs da FastAPI Cloud, tudo direto do seu editor.
-
-///
+A skill é compatível com Codex, Claude Code, Cursor, GitHub Copilot, Gemini CLI, Pi, OpenCode e a maioria dos outros agentes de codificação. Para Claude Code, selecione `.claude/skills` quando for perguntado onde instalar a skill.

 ## Guia Avançado de Usuário { #advanced-user-guide }

@@ -1,6 +1,6 @@
 # Middleware { #middleware }

-Você pode adicionar middleware à suas aplicações **FastAPI**.
+Você pode adicionar middleware às aplicações **FastAPI**.

 Um "middleware" é uma função que manipula cada **requisição** antes de ser processada por qualquer *operação de rota* específica. E também cada **resposta** antes de retorná-la.

@@ -37,7 +37,7 @@ A função middleware recebe:

 Tenha em mente que cabeçalhos proprietários personalizados podem ser adicionados [usando o prefixo `X-`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers).

-Mas se você tiver cabeçalhos personalizados desejando que um cliente em um navegador esteja apto a ver, você precisa adicioná-los às suas configurações CORS ([CORS (Cross-Origin Resource Sharing)](cors.md)) usando o parâmetro `expose_headers` documentado na [Documentação CORS da Starlette](https://www.starlette.dev/middleware/#corsmiddleware).
+Mas se você tiver cabeçalhos personalizados desejando que um cliente em um navegador esteja apto a ver, você precisa adicioná-los às suas configurações CORS ([CORS (Cross-Origin Resource Sharing)](cors.md)) usando o parâmetro `expose_headers` documentado na [Documentação CORS da Starlette](https://starlette.dev/middleware/#corsmiddleware).

 ///

@@ -55,7 +55,7 @@ Você pode adicionar código para ser executado com a `request`, antes que qualq

 E também depois que a `response` é gerada, antes de retorná-la.

-Por exemplo, você pode adicionar um cabeçalho personalizado `X-Process-Time` contendo o tempo em segundos que levou para processar a solicitação e gerar uma resposta:
+Por exemplo, você pode adicionar um cabeçalho personalizado `X-Process-Time` contendo o tempo em segundos que levou para processar a requisição e gerar uma resposta:

 {* ../../docs_src/middleware/tutorial001_py310.py hl[10,12:13] *}

@@ -67,9 +67,9 @@ Aqui usamos [`time.perf_counter()`](https://docs.python.org/3/library/time.html#

 ## Ordem de execução de múltiplos middlewares { #multiple-middleware-execution-order }

-Quando você adiciona múltiplos middlewares usando o decorador `@app.middleware()` ou o método `app.add_middleware()`, cada novo middleware envolve a aplicação, formando uma pilha. O último middleware adicionado é o mais externo, e o primeiro é o mais interno.
+Quando você adiciona múltiplos middlewares usando o decorador `@app.middleware()` ou o método `app.add_middleware()`, cada novo middleware envolve a aplicação, formando uma pilha. O último middleware adicionado é o *mais externo*, e o primeiro é o *mais interno*.

-No caminho da requisição, o middleware mais externo roda primeiro.
+No caminho da requisição, o middleware *mais externo* roda primeiro.

 No caminho da resposta, ele roda por último.

@@ -21,7 +21,9 @@ Você pode declarar o tipo de um parâmetro de path na função, usando as anota
 Neste caso, `item_id` é declarado como um `int`.

 /// tip | Dica
+
 Isso fornecerá suporte do editor dentro da sua função, com verificações de erros, preenchimento automático, etc.
+
 ///

 ## Dados <dfn title="também conhecido como: serialização, parsing, marshalling">conversão</dfn> { #data-conversion }
@@ -33,9 +35,11 @@ Se você executar este exemplo e abrir seu navegador em [http://127.0.0.1:8000/i
 ```

 /// tip | Dica
+
 Perceba que o valor que sua função recebeu (e retornou) é `3`, como um `int` do Python, não uma string `"3"`.

 Então, com essa declaração de tipo, o **FastAPI** fornece <dfn title="convertendo a string que vem de um request HTTP em dados Python">"parsing"</dfn> automático do request.
+
 ///

 ## Validação de dados { #data-validation }
@@ -63,11 +67,13 @@ porque o parâmetro de path `item_id` tinha o valor `"foo"`, que não é um `int
 O mesmo erro apareceria se você fornecesse um `float` em vez de um `int`, como em: [http://127.0.0.1:8000/items/4.2](http://127.0.0.1:8000/items/4.2)

 /// tip | Dica
+
 Então, com a mesma declaração de tipo do Python, o **FastAPI** fornece validação de dados.

 Observe que o erro também declara claramente exatamente o ponto onde a validação não passou.

 Isso é incrivelmente útil ao desenvolver e depurar código que interage com sua API.
+
 ///

 ## Documentação { #documentation }
@@ -77,14 +83,16 @@ E quando você abrir seu navegador em [http://127.0.0.1:8000/docs](http://127.0.
 <img src="/img/tutorial/path-params/image01.png">

 /// tip | Dica
+
 Novamente, apenas com a mesma declaração de tipo do Python, o **FastAPI** fornece documentação automática e interativa (integrando o Swagger UI).

 Observe que o parâmetro de path está declarado como um inteiro.
+
 ///

 ## Benefícios baseados em padrões, documentação alternativa { #standards-based-benefits-alternative-documentation }

-E como o schema gerado é do padrão [OpenAPI](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md), existem muitas ferramentas compatíveis.
+E como o schema gerado é do padrão [OpenAPI](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md), existem muitas ferramentas compatíveis.

 Por causa disso, o próprio **FastAPI** fornece uma documentação alternativa da API (usando ReDoc), que você pode acessar em [http://127.0.0.1:8000/redoc](http://127.0.0.1:8000/redoc):

@@ -94,7 +102,7 @@ Da mesma forma, existem muitas ferramentas compatíveis. Incluindo ferramentas d

 ## Pydantic { #pydantic }

-Toda a validação de dados é realizada nos bastidores pelo [Pydantic](https://docs.pydantic.dev/), então você recebe todos os benefícios disso. E você sabe que está em boas mãos.
+Toda a validação de dados é realizada nos bastidores pelo [Pydantic](https://pydantic.dev/docs/), então você recebe todos os benefícios disso. E você sabe que está em boas mãos.

 Você pode usar as mesmas declarações de tipo com `str`, `float`, `bool` e muitos outros tipos de dados complexos.

@@ -135,7 +143,9 @@ Em seguida, crie atributos de classe com valores fixos, que serão os valores v
 {* ../../docs_src/path_params/tutorial005_py310.py hl[1,6:9] *}

 /// tip | Dica
+
 Se você está se perguntando, "AlexNet", "ResNet" e "LeNet" são apenas nomes de modelos de Aprendizado de Máquina <dfn title="Tecnicamente, arquiteturas de modelos de Deep Learning">modelos</dfn>.
+
 ///

 ### Declare um parâmetro de path { #declare-a-path-parameter }
@@ -167,7 +177,9 @@ Você pode obter o valor real (um `str` neste caso) usando `model_name.value`, o
 {* ../../docs_src/path_params/tutorial005_py310.py hl[20] *}

 /// tip | Dica
+
 Você também pode acessar o valor `"lenet"` com `ModelName.lenet.value`.
+
 ///

 #### Retorne membros de enumeração { #return-enumeration-members }
@@ -218,19 +230,21 @@ Então, você pode usá-lo com:
 {* ../../docs_src/path_params/tutorial004_py310.py hl[6] *}

 /// tip | Dica
+
 Você pode precisar que o parâmetro contenha `/home/johndoe/myfile.txt`, com uma barra inicial (`/`).

 Nesse caso, a URL seria: `/files//home/johndoe/myfile.txt`, com uma barra dupla (`//`) entre `files` e `home`.
+
 ///

 ## Recapitulação { #recap }

 Com o **FastAPI**, ao usar declarações de tipo do Python curtas, intuitivas e padrão, você obtém:

- Suporte no editor: verificações de erro, preenchimento automático, etc.
- "<dfn title="convertendo a string que vem de um request HTTP em dados Python">parsing</dfn>" de dados
- Validação de dados
- Anotação da API e documentação automática
+* Suporte no editor: verificações de erro, preenchimento automático, etc.
+* "<dfn title="convertendo a string que vem de um request HTTP em dados Python">parsing</dfn>" de dados
+* Validação de dados
+* Anotação da API e documentação automática

 E você só precisa declará-los uma vez.

@@ -370,11 +370,11 @@ Podem existir casos em que você precise fazer alguma **validação personalizad

 Nesses casos, você pode usar uma **função validadora personalizada** que é aplicada após a validação normal (por exemplo, depois de validar que o valor é uma `str`).

-Você pode fazer isso usando o [`AfterValidator` do Pydantic](https://docs.pydantic.dev/latest/concepts/validators/#field-after-validator) dentro de `Annotated`.
+Você pode fazer isso usando o [`AfterValidator` do Pydantic](https://pydantic.dev/docs/validation/latest/concepts/validators/#field-after-validator) dentro de `Annotated`.

 /// tip | Dica

-O Pydantic também tem [`BeforeValidator`](https://docs.pydantic.dev/latest/concepts/validators/#field-before-validator) e outros. 🤓
+O Pydantic também tem [`BeforeValidator`](https://pydantic.dev/docs/validation/latest/concepts/validators/#field-before-validator) e outros. 🤓

 ///

@@ -6,10 +6,10 @@ Você pode definir arquivos para serem enviados pelo cliente usando `File`.

 Para receber arquivos enviados, primeiro instale [`python-multipart`](https://github.com/Kludex/python-multipart).

-Garanta que você criou um [ambiente virtual](../virtual-environments.md), o ativou e então o instalou, por exemplo:
+Adicione-o ao seu projeto:

 ```console
-$ pip install python-multipart
+$ uv add python-multipart
 ```

 Isso é necessário, visto que os arquivos enviados são enviados como "dados de formulário".
@@ -6,10 +6,10 @@ Você pode utilizar **Modelos Pydantic** para declarar **campos de formulários*

 Para utilizar formulários, instale primeiramente o [`python-multipart`](https://github.com/Kludex/python-multipart).

-Certifique-se de criar um [ambiente virtual](../virtual-environments.md), ativá-lo, e então instalar. Por exemplo:
+Adicione-o ao seu projeto:

 ```console
-$ pip install python-multipart
+$ uv add python-multipart
 ```

 ///
@@ -6,10 +6,10 @@ Você pode definir arquivos e campos de formulário ao mesmo tempo usando `File`

 Para receber arquivos carregados e/ou dados de formulário, primeiro instale [`python-multipart`](https://github.com/Kludex/python-multipart).

-Certifique-se de criar um [ambiente virtual](../virtual-environments.md), ativá-lo e então instalar, por exemplo:
+Adicione-o ao seu projeto:

 ```console
-$ pip install python-multipart
+$ uv add python-multipart
 ```

 ///
@@ -6,10 +6,10 @@ Quando você precisar receber campos de formulário em vez de JSON, você pode u

 Para usar formulários, primeiro instale [`python-multipart`](https://github.com/Kludex/python-multipart).

-Certifique-se de criar um [ambiente virtual](../virtual-environments.md), ativá-lo e então instalá-lo, por exemplo:
+Adicione-o ao seu projeto:

 ```console
-$ pip install python-multipart
+$ uv add python-multipart
 ```

 ///
@@ -76,16 +76,16 @@ Aqui estamos declarando um modelo `UserIn`, ele conterá uma senha em texto simp

 Para usar `EmailStr`, primeiro instale [`email-validator`](https://github.com/JoshData/python-email-validator).

-Certifique-se de criar um [ambiente virtual](../virtual-environments.md), ative-o e então instale-o, por exemplo:
+Adicione-o ao seu projeto:

 ```console
-$ pip install email-validator
+$ uv add email-validator
 ```

 ou com:

 ```console
-$ pip install "pydantic[email]"
+$ uv add "pydantic[email]"
 ```

 ///
@@ -202,7 +202,7 @@ Isso também funcionará porque `RedirectResponse` é uma subclasse de `Response

 Mas quando você retorna algum outro objeto arbitrário que não é um tipo Pydantic válido (por exemplo, um objeto de banco de dados) e você o anota dessa forma na função, o FastAPI tentará criar um modelo de resposta Pydantic a partir dessa anotação de tipo e falhará.

-O mesmo aconteceria se você tivesse algo como uma <dfn title="uma união entre vários tipos significa 'qualquer um desses tipos'.">união</dfn> entre tipos diferentes onde um ou mais deles não são tipos Pydantic válidos, por exemplo, isso falharia 💥:
+O mesmo aconteceria se você tivesse algo como uma <dfn title='uma união entre vários tipos significa "qualquer um desses tipos".'>união</dfn> entre tipos diferentes onde um ou mais deles não são tipos Pydantic válidos, por exemplo, isso falharia 💥:

 {* ../../docs_src/response_model/tutorial003_04_py310.py hl[8] *}

@@ -218,7 +218,7 @@ Neste caso, você pode desabilitar a geração do modelo de resposta definindo `

 {* ../../docs_src/response_model/tutorial003_05_py310.py hl[7] *}

-Isso fará com que o FastAPI pule a geração do modelo de resposta e, dessa forma, você pode ter quaisquer anotações de tipo de retorno que precisar sem afetar seu aplicativo FastAPI. 🤓
+Isso fará com que o FastAPI pule a geração do modelo de resposta e, dessa forma, você pode ter quaisquer anotações de tipo de retorno que precisar sem afetar sua aplicação FastAPI. 🤓

 ## Parâmetros de codificação do modelo de resposta { #response-model-encoding-parameters }

@@ -242,7 +242,7 @@ Você pode definir o parâmetro `response_model_exclude_unset=True` do *decorado

 e esses valores padrão não serão incluídos na resposta, apenas os valores realmente definidos.

-Então, se você enviar uma solicitação para essa *operação de rota* para o item com ID `foo`, a resposta (sem incluir valores padrão) será:
+Então, se você enviar uma request para essa *operação de rota* para o item com ID `foo`, a resposta (sem incluir valores padrão) será:

 ```JSON
 {
@@ -258,7 +258,7 @@ Você também pode usar:
 * `response_model_exclude_defaults=True`
 * `response_model_exclude_none=True`

-conforme descrito na [documentação do Pydantic](https://docs.pydantic.dev/1.10/usage/exporting_models/#modeldict) para `exclude_defaults` e `exclude_none`.
+conforme descrito na [documentação do Pydantic](https://pydantic.dev/docs/validation/latest/concepts/serialization/#excluding-and-including-fields-based-on-their-value) para `exclude_defaults` e `exclude_none`.

 ///

@@ -291,7 +291,7 @@ Se os dados tiverem os mesmos valores que os padrões, como o item com ID `baz`:
 }
 ```

-O FastAPI é inteligente o suficiente (na verdade, o Pydantic é inteligente o suficiente) para perceber que, embora `description`, `tax` e `tags` tenham os mesmos valores que os padrões, eles foram definidos explícita e diretamente (em vez de retirados dos padrões).
+O FastAPI é inteligente o suficiente (na verdade, o Pydantic é inteligente o suficiente) para perceber que, embora `description`, `tax` e `tags` tenham os mesmos valores que os padrões, eles foram definidos explicitamente (em vez de retirados dos padrões).

 Portanto, eles serão incluídos na resposta JSON.

@@ -13,7 +13,7 @@ Você pode declarar `examples` para um modelo Pydantic que serão adicionados ao

 Essas informações extras serão adicionadas como estão ao **JSON Schema** de saída para esse modelo e serão usadas na documentação da API.

-Você pode usar o atributo `model_config`, que recebe um `dict`, conforme descrito na [documentação do Pydantic: Configuration](https://docs.pydantic.dev/latest/api/config/).
+Você pode usar o atributo `model_config`, que recebe um `dict`, conforme descrito na [documentação do Pydantic: Configuration](https://pydantic.dev/docs/validation/latest/api/pydantic/config/).

 Você pode definir `"json_schema_extra"` com um `dict` contendo quaisquer dados adicionais que você queira que apareçam no JSON Schema gerado, incluindo `examples`.

@@ -16,7 +16,7 @@ Vamos usar as ferramentas fornecidas pelo **FastAPI** para lidar com segurança.

 Vamos primeiro usar o código e ver como funciona, e depois voltaremos para entender o que está acontecendo.

-## Crie um `main.py` { #create-main-py }
+## Crie `main.py` { #create-main-py }

 Copie o exemplo em um arquivo `main.py`:

@@ -26,14 +26,14 @@ Copie o exemplo em um arquivo `main.py`:

 /// note | Nota

-O pacote [`python-multipart`](https://github.com/Kludex/python-multipart) é instalado automaticamente com o **FastAPI** quando você executa o comando `pip install "fastapi[standard]"`.
+O pacote [`python-multipart`](https://github.com/Kludex/python-multipart) é instalado automaticamente com o **FastAPI** quando você executa o comando `uv add "fastapi[standard]"`.

-Entretanto, se você usar o comando `pip install fastapi`, o pacote `python-multipart` não é incluído por padrão.
+Entretanto, se você usar o comando `uv add fastapi`, o pacote `python-multipart` não é incluído por padrão.

-Para instalá-lo manualmente, certifique-se de criar um [ambiente virtual](../../virtual-environments.md), ativá-lo e então instalá-lo com:
+Para instalá-lo manualmente, adicione-o ao seu projeto com:

 ```console
-$ pip install python-multipart
+$ uv add python-multipart
 ```

 Isso ocorre porque o **OAuth2** usa "form data" para enviar o `username` e o `password`.
@@ -45,7 +45,7 @@ Execute o exemplo com:
 <div class="termy">

 ```console
-$ fastapi dev
+$ uv run fastapi dev

 <span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
 ```
@@ -172,7 +172,7 @@ Agora você pode passar esse `oauth2_scheme` em uma dependência com `Depends`.

 {* ../../docs_src/security/tutorial001_an_py310.py hl[12] *}

-Essa dependência fornecerá uma `str` que é atribuída ao parâmetro `token` da função de operação de rota.
+Essa dependência fornecerá uma `str` que é atribuída ao parâmetro `token` da *função de operação de rota*.

 O **FastAPI** saberá que pode usar essa dependência para definir um "esquema de segurança" no esquema OpenAPI (e na documentação automática da API).

@@ -28,14 +28,14 @@ Se você quiser brincar com tokens JWT e ver como eles funcionam, visite [https:

 ## Instalar `PyJWT` { #install-pyjwt }

-Nós precisamos instalar o `PyJWT` para criar e verificar os tokens JWT em Python.
+Nós precisamos instalar o `PyJWT` para gerar e verificar os tokens JWT em Python.

-Certifique-se de criar um [ambiente virtual](../../virtual-environments.md), ativá-lo e então instalar o `pyjwt`:
+Adicione `pyjwt` ao seu projeto:

 <div class="termy">

 ```console
-$ pip install pyjwt
+$ uv add pyjwt

 ---> 100%
 ```
@@ -62,9 +62,9 @@ Mas não é possível converter os caracteres sem sentido de volta para a senha

 Se o seu banco de dados for roubado, o invasor não terá as senhas em texto puro dos seus usuários, apenas os hashes.

-Então, o invasor não poderá tentar usar essas senhas em outro sistema (como muitos usuários utilizam a mesma senha em vários lugares, isso seria perigoso).
+Então, o invasor não poderá tentar usar essa senha em outro sistema (como muitos usuários utilizam a mesma senha em vários lugares, isso seria perigoso).

-## Instalar o `pwdlib` { #install-pwdlib }
+## Instalar `pwdlib` { #install-pwdlib }

 pwdlib é um excelente pacote Python para lidar com hashes de senhas.

@@ -72,12 +72,12 @@ Ele suporta muitos algoritmos de hashing seguros e utilitários para trabalhar c

 O algoritmo recomendado é o "Argon2".

-Certifique-se de criar um [ambiente virtual](../../virtual-environments.md), ativá-lo e então instalar o pwdlib com Argon2:
+Adicione `pwdlib` com Argon2 ao seu projeto:

 <div class="termy">

 ```console
-$ pip install "pwdlib[argon2]"
+$ uv add "pwdlib[argon2]"

 ---> 100%
 ```
@@ -215,7 +215,7 @@ Password: `secret`

 /// tip | Dica

-Observe que em nenhuma parte do código está a senha em texto puro "`secret`", nós temos apenas o hash.
+Observe que em nenhuma parte do código está a senha em texto puro "`secret`", nós temos apenas a versão com hash.

 ///

@@ -234,7 +234,7 @@ Chame o endpoint `/users/me/`, você receberá o retorno como:

 <img src="/img/tutorial/security/image09.png">

-Se você abrir as ferramentas de desenvolvedor, poderá ver que os dados enviados incluem apenas o token. A senha é enviada apenas na primeira requisição para autenticar o usuário e obter o token de acesso, mas não é enviada nas próximas requisições:
+Se você abrir as ferramentas de desenvolvedor, poderá ver que os dados enviados incluem apenas o token. A senha é enviada apenas na primeira requisição para autenticar o usuário e obter o token de acesso, mas não depois:

 <img src="/img/tutorial/security/image10.png">

@@ -34,12 +34,12 @@ Este é um tutorial muito simples e curto, se você quiser aprender sobre bancos

 ## Instale o `SQLModel` { #install-sqlmodel }

-Primeiro, certifique-se de criar seu [ambiente virtual](../virtual-environments.md), ativá-lo e, em seguida, instalar o `sqlmodel`:
+Adicione `sqlmodel` ao seu projeto:

 <div class="termy">

 ```console
-$ pip install sqlmodel
+$ uv add sqlmodel
 ---> 100%
 ```

@@ -152,7 +152,7 @@ Você pode executar o app:
 <div class="termy">

 ```console
-$ fastapi dev
+$ uv run fastapi dev

 <span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
 ```
@@ -337,7 +337,7 @@ Você pode executar o app novamente:
 <div class="termy">

 ```console
-$ fastapi dev
+$ uv run fastapi dev

 <span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
 ```
@@ -45,4 +45,4 @@ Todos esses parâmetros podem ser diferentes de "`static`", ajuste-os de acordo

 ## Mais informações { #more-info }

-Para mais detalhes e opções, consulte [a documentação da Starlette sobre Arquivos Estáticos](https://www.starlette.dev/staticfiles/).
+Para mais detalhes e opções, consulte [a documentação da Starlette sobre Arquivos Estáticos](https://starlette.dev/staticfiles/).
@@ -1,6 +1,6 @@
 # Testando { #testing }

-Graças ao [Starlette](https://www.starlette.dev/testclient/), testar aplicações **FastAPI** é fácil e agradável.
+Graças ao [Starlette](https://starlette.dev/testclient/), testar aplicações **FastAPI** é fácil e agradável.

 Ele é baseado no [HTTPX](https://www.python-httpx.org), que por sua vez é projetado com base em Requests, por isso é muito familiar e intuitivo.

@@ -12,10 +12,10 @@ Com ele, você pode usar o [pytest](https://docs.pytest.org/) diretamente com **

 Para usar o `TestClient`, primeiro instale [`httpx`](https://www.python-httpx.org).

-Certifique-se de criar um [ambiente virtual](../virtual-environments.md), ativá-lo e instalá-lo, por exemplo:
+Adicione-o ao seu projeto:

 ```console
-$ pip install httpx
+$ uv add httpx
 ```

 ///
@@ -156,12 +156,12 @@ Se você tiver um modelo Pydantic em seu teste e quiser enviar seus dados para a

 Depois disso, você só precisa instalar o `pytest`.

-Certifique-se de criar um [ambiente virtual](../virtual-environments.md), ativá-lo e instalá-lo, por exemplo:
+Adicione-o ao seu projeto:

 <div class="termy">

 ```console
-$ pip install pytest
+$ uv add pytest

 ---> 100%
 ```
@@ -175,7 +175,7 @@ Execute os testes com:
 <div class="termy">

 ```console
-$ pytest
+$ uv run pytest

 ================ test session starts ================
 platform linux -- Python 3.6.9, pytest-5.3.5, py-1.8.1, pluggy-0.13.1
@@ -1,864 +1,35 @@
 # Ambientes Virtuais { #virtual-environments }

-Ao trabalhar em projetos Python, você provavelmente deveria usar um **ambiente virtual** (ou um mecanismo similar) para isolar os pacotes que você instala para cada projeto.
+Ao trabalhar com projetos Python, você deveria usar um **ambiente virtual** para isolar os pacotes instalados para cada projeto.

-/// note | Nota
-
-Se você já sabe sobre ambientes virtuais, como criá-los e usá-los, talvez seja melhor pular esta seção. 🤓
-
-///
-
-/// tip | Dica
-
-Um **ambiente virtual** é diferente de uma **variável de ambiente**.
-
-Uma **variável de ambiente** é uma variável no sistema que pode ser usada por programas.
-
-Um **ambiente virtual** é um diretório com alguns arquivos.
-
-///
-
-/// note | Nota
-
-Esta página lhe ensinará como usar **ambientes virtuais** e como eles funcionam.
-
-Se você estiver pronto para adotar uma **ferramenta que gerencia tudo** para você (incluindo a instalação do Python), experimente [uv](https://github.com/astral-sh/uv).
-
-///
+Para projetos FastAPI, recomendo usar [uv](https://docs.astral.sh/uv/) para gerenciar o projeto, suas dependências e seu ambiente virtual.

 ## Crie um Projeto { #create-a-project }

-Primeiro, crie um diretório para seu projeto.
-
-O que normalmente faço é criar um diretório chamado `code` dentro do meu diretório home/user.
-
-E dentro disso eu crio um diretório por projeto.
+Instale `uv` usando o [guia oficial de instalação](https://docs.astral.sh/uv/getting-started/installation/) e então crie um projeto:

 <div class="termy">

 ```console
-// Vá para o diretório inicial
-$ cd
-// Crie um diretório para todos os seus projetos de código
-$ mkdir code
-// Entre nesse diretório de código
-$ cd code
-// Crie um diretório para este projeto
-$ mkdir awesome-project
-// Entre no diretório do projeto
+$ uv init awesome-project --bare
 $ cd awesome-project
+$ uv add "fastapi[standard]"
 ```

 </div>

-## Crie um ambiente virtual { #create-a-virtual-environment }
+`uv` cria um ambiente virtual para o projeto automaticamente. Você não precisa criar ou ativar um por conta própria.

-Ao começar a trabalhar em um projeto Python **pela primeira vez**, crie um ambiente virtual **<dfn title="existem outras opções, esta é uma diretriz simples">dentro do seu projeto</dfn>**.
-
-/// tip | Dica
-
-Você só precisa fazer isso **uma vez por projeto**, não toda vez que trabalhar.
-
-///
-
-//// tab | `venv`
-
-Para criar um ambiente virtual, você pode usar o módulo `venv` que vem com o Python.
+Execute comandos dentro do ambiente do projeto com `uv run`, por exemplo:

 <div class="termy">

 ```console
-$ python -m venv .venv
+$ uv run fastapi dev
 ```

 </div>

-/// details | O que esse comando significa
+## Saiba Mais { #learn-more }

-* `python`: usa o programa chamado `python`
-* `-m`: chama um módulo como um script, nós diremos a ele qual módulo vem em seguida
-* `venv`: usa o módulo chamado `venv` que normalmente vem instalado com o Python
-* `.venv`: cria o ambiente virtual no novo diretório `.venv`
-
-///
-
-////
-
-//// tab | `uv`
-
-Se você tiver [`uv`](https://github.com/astral-sh/uv) instalado, poderá usá-lo para criar um ambiente virtual.
-
-<div class="termy">
-
-```console
-$ uv venv
-```
-
-</div>
-
-/// tip | Dica
-
-Por padrão, `uv` criará um ambiente virtual em um diretório chamado `.venv`.
-
-Mas você pode personalizá-lo passando um argumento adicional com o nome do diretório.
-
-///
-
-////
-
-Esse comando cria um novo ambiente virtual em um diretório chamado `.venv`.
-
-/// details | `.venv` ou outro nome
-
-Você pode criar o ambiente virtual em um diretório diferente, mas há uma convenção para chamá-lo de `.venv`.
-
-///
-
-## Ative o ambiente virtual { #activate-the-virtual-environment }
-
-Ative o novo ambiente virtual para que qualquer comando Python que você executar ou pacote que você instalar o utilize.
-
-/// tip | Dica
-
-Faça isso **toda vez** que iniciar uma **nova sessão de terminal** para trabalhar no projeto.
-
-///
-
-//// tab | Linux, macOS
-
-<div class="termy">
-
-```console
-$ source .venv/bin/activate
-```
-
-</div>
-
-////
-
-//// tab | Windows PowerShell
-
-<div class="termy">
-
-```console
-$ .venv\Scripts\Activate.ps1
-```
-
-</div>
-
-////
-
-//// tab | Windows Bash
-
-Ou se você usa o Bash para Windows (por exemplo, [Git Bash](https://gitforwindows.org/)):
-
-<div class="termy">
-
-```console
-$ source .venv/Scripts/activate
-```
-
-</div>
-
-////
-
-/// tip | Dica
-
-Toda vez que você instalar um **novo pacote** naquele ambiente, **ative** o ambiente novamente.
-
-Isso garante que, se você usar um **programa de terminal (<abbr title="command line interface - interface de linha de comando">CLI</abbr>)** instalado por esse pacote, você usará aquele do seu ambiente virtual e não qualquer outro que possa ser instalado globalmente, provavelmente com uma versão diferente do que você precisa.
-
-///
-
-## Verifique se o ambiente virtual está ativo { #check-the-virtual-environment-is-active }
-
-Verifique se o ambiente virtual está ativo (o comando anterior funcionou).
-
-/// tip | Dica
-
-Isso é **opcional**, mas é uma boa maneira de **verificar** se tudo está funcionando conforme o esperado e se você está usando o ambiente virtual pretendido.
-
-///
-
-//// tab | Linux, macOS, Windows Bash
-
-<div class="termy">
-
-```console
-$ which python
-
-/home/user/code/awesome-project/.venv/bin/python
-```
-
-</div>
-
-Se ele mostrar o binário `python` em `.venv/bin/python`, dentro do seu projeto (neste caso `awesome-project`), então funcionou. 🎉
-
-////
-
-//// tab | Windows PowerShell
-
-<div class="termy">
-
-```console
-$ Get-Command python
-
-C:\Users\user\code\awesome-project\.venv\Scripts\python
-```
-
-</div>
-
-Se ele mostrar o binário `python` em `.venv\Scripts\python`, dentro do seu projeto (neste caso `awesome-project`), então funcionou. 🎉
-
-////
-
-## Atualize `pip` { #upgrade-pip }
-
-/// tip | Dica
-
-Se você usar [`uv`](https://github.com/astral-sh/uv), você o usará para instalar coisas em vez do `pip`, então não precisará atualizar o `pip`. 😎
-
-///
-
-Se você estiver usando `pip` para instalar pacotes (ele vem por padrão com o Python), você deveria **atualizá-lo** para a versão mais recente.
-
-Muitos erros exóticos durante a instalação de um pacote são resolvidos apenas atualizando o `pip` primeiro.
-
-/// tip | Dica
-
-Normalmente, você faria isso **uma vez**, logo após criar o ambiente virtual.
-
-///
-
-Certifique-se de que o ambiente virtual esteja ativo (com o comando acima) e execute:
-
-<div class="termy">
-
-```console
-$ python -m pip install --upgrade pip
-
---> 100%
-```
-
-</div>
-
-/// tip | Dica
-
-Às vezes, você pode receber um erro **`No module named pip`** ao tentar atualizar o pip.
-
-Se isso acontecer, instale e atualize o pip usando o comando abaixo:
-
-<div class="termy">
-
-```console
-$ python -m ensurepip --upgrade
-
---> 100%
-```
-
-</div>
-
-Esse comando instalará o pip caso ele ainda não esteja instalado e também garante que a versão instalada do pip seja pelo menos tão recente quanto a disponível em `ensurepip`.
-
-///
-
-## Adicione `.gitignore` { #add-gitignore }
-
-Se você estiver usando **Git** (você deveria), adicione um arquivo `.gitignore` para excluir tudo em seu `.venv` do Git.
-
-/// tip | Dica
-
-Se você usou [`uv`](https://github.com/astral-sh/uv) para criar o ambiente virtual, ele já fez isso para você, você pode pular esta etapa. 😎
-
-///
-
-/// tip | Dica
-
-Faça isso **uma vez**, logo após criar o ambiente virtual.
-
-///
-
-<div class="termy">
-
-```console
-$ echo "*" > .venv/.gitignore
-```
-
-</div>
-
-/// details | O que esse comando significa
-
-* `echo "*"`: irá "imprimir" o texto `*` no terminal (a próxima parte muda isso um pouco)
-* `>`: qualquer coisa impressa no terminal pelo comando à esquerda de `>` não deve ser impressa, mas sim escrita no arquivo que vai à direita de `>`
-* `.gitignore`: o nome do arquivo onde o texto deve ser escrito
-
-E `*` para Git significa "tudo". Então, ele ignorará tudo no diretório `.venv`.
-
-Esse comando criará um arquivo `.gitignore` com o conteúdo:
-
-```gitignore
-*
-```
-
-///
-
-## Instale Pacotes { #install-packages }
-
-Após ativar o ambiente, você pode instalar pacotes nele.
-
-/// tip | Dica
-
-Faça isso **uma vez** ao instalar ou atualizar os pacotes que seu projeto precisa.
-
-Se precisar atualizar uma versão ou adicionar um novo pacote, você **fará isso novamente**.
-
-///
-
-### Instale pacotes diretamente { #install-packages-directly }
-
-Se estiver com pressa e não quiser usar um arquivo para declarar os requisitos de pacote do seu projeto, você pode instalá-los diretamente.
-
-/// tip | Dica
-
-É uma (muito) boa ideia colocar os pacotes e versões que seu programa precisa em um arquivo (por exemplo `requirements.txt` ou `pyproject.toml`).
-
-///
-
-//// tab | `pip`
-
-<div class="termy">
-
-```console
-$ pip install "fastapi[standard]"
-
---> 100%
-```
-
-</div>
-
-////
-
-//// tab | `uv`
-
-Se você tem o [`uv`](https://github.com/astral-sh/uv):
-
-<div class="termy">
-
-```console
-$ uv pip install "fastapi[standard]"
---> 100%
-```
-
-</div>
-
-////
-
-### Instale a partir de `requirements.txt` { #install-from-requirements-txt }
-
-Se você tiver um `requirements.txt`, agora poderá usá-lo para instalar seus pacotes.
-
-//// tab | `pip`
-
-<div class="termy">
-
-```console
-$ pip install -r requirements.txt
---> 100%
-```
-
-</div>
-
-////
-
-//// tab | `uv`
-
-Se você tem o [`uv`](https://github.com/astral-sh/uv):
-
-<div class="termy">
-
-```console
-$ uv pip install -r requirements.txt
---> 100%
-```
-
-</div>
-
-////
-
-/// details | `requirements.txt`
-
-Um `requirements.txt` com alguns pacotes poderia se parecer com:
-
-```requirements.txt
-fastapi[standard]==0.113.0
-pydantic==2.8.0
-```
-
-///
-
-## Execute seu programa { #run-your-program }
-
-Depois de ativar o ambiente virtual, você pode executar seu programa, e ele usará o Python dentro do seu ambiente virtual com os pacotes que você instalou lá.
-
-<div class="termy">
-
-```console
-$ python main.py
-
-Hello World
-```
-
-</div>
-
-## Configure seu editor { #configure-your-editor }
-
-Você provavelmente usaria um editor. Certifique-se de configurá-lo para usar o mesmo ambiente virtual que você criou (ele provavelmente o detectará automaticamente) para que você possa obter preenchimento automático e erros em linha.
-
-Por exemplo:
-
-* [VS Code](https://code.visualstudio.com/docs/python/environments#_select-and-activate-an-environment)
-* [PyCharm](https://www.jetbrains.com/help/pycharm/creating-virtual-environment.html)
-
-/// tip | Dica
-
-Normalmente, você só precisa fazer isso **uma vez**, ao criar o ambiente virtual.
-
-///
-
-## Desative o ambiente virtual { #deactivate-the-virtual-environment }
-
-Quando terminar de trabalhar no seu projeto, você pode **desativar** o ambiente virtual.
-
-<div class="termy">
-
-```console
-$ deactivate
-```
-
-</div>
-
-Dessa forma, quando você executar `python`, ele não tentará executá-lo naquele ambiente virtual com os pacotes instalados nele.
-
-## Pronto para trabalhar { #ready-to-work }
-
-Agora você está pronto para começar a trabalhar no seu projeto.
-
-
-
-/// tip | Dica
-
-Você quer entender o que é tudo isso acima?
-
-Continue lendo. 👇🤓
-
-///
-
-## Por que ambientes virtuais { #why-virtual-environments }
-
-Para trabalhar com o FastAPI, você precisa instalar o [Python](https://www.python.org/).
-
-Depois disso, você precisará **instalar** o FastAPI e quaisquer outros **pacotes** que queira usar.
-
-Para instalar pacotes, você normalmente usaria o comando `pip` que vem com o Python (ou alternativas semelhantes).
-
-No entanto, se você usar `pip` diretamente, os pacotes serão instalados no seu **ambiente Python global** (a instalação global do Python).
-
-### O Problema { #the-problem }
-
-Então, qual é o problema em instalar pacotes no ambiente global do Python?
-
-Em algum momento, você provavelmente acabará escrevendo muitos programas diferentes que dependem de **pacotes diferentes**. E alguns desses projetos em que você trabalha dependerão de **versões diferentes** do mesmo pacote. 😱
-
-Por exemplo, você pode criar um projeto chamado `philosophers-stone`, este programa depende de outro pacote chamado **`harry`, usando a versão `1`**. Então, você precisa instalar `harry`.
-
-```mermaid
-flowchart LR
-    stone(philosophers-stone) -->|requires| harry-1[harry v1]
-```
-
-Então, em algum momento depois, você cria outro projeto chamado `prisoner-of-azkaban`, e esse projeto também depende de `harry`, mas esse projeto precisa do **`harry` versão `3`**.
-
-```mermaid
-flowchart LR
-    azkaban(prisoner-of-azkaban) --> |requires| harry-3[harry v3]
-```
-
-Mas agora o problema é que, se você instalar os pacotes globalmente (no ambiente global) em vez de em um **ambiente virtual** local, você terá que escolher qual versão do `harry` instalar.
-
-Se você quiser executar `philosophers-stone`, precisará primeiro instalar `harry` versão `1`, por exemplo com:
-
-<div class="termy">
-
-```console
-$ pip install "harry==1"
-```
-
-</div>
-
-E então você acabaria com `harry` versão `1` instalado em seu ambiente Python global.
-
-```mermaid
-flowchart LR
-    subgraph global[global env]
-        harry-1[harry v1]
-    end
-    subgraph stone-project[philosophers-stone project]
-        stone(philosophers-stone) -->|requires| harry-1
-    end
-```
-
-Mas se você quiser executar `prisoner-of-azkaban`, você precisará desinstalar `harry` versão `1` e instalar `harry` versão `3` (ou apenas instalar a versão `3` desinstalaria automaticamente a versão `1`).
-
-<div class="termy">
-
-```console
-$ pip install "harry==3"
-```
-
-</div>
-
-E então você acabaria com `harry` versão `3` instalado em seu ambiente Python global.
-
-E se você tentar executar `philosophers-stone` novamente, há uma chance de que **não funcione** porque ele precisa de `harry` versão `1`.
-
-```mermaid
-flowchart LR
-    subgraph global[global env]
-        harry-1[<strike>harry v1</strike>]
-        style harry-1 fill:#ccc,stroke-dasharray: 5 5
-        harry-3[harry v3]
-    end
-    subgraph stone-project[philosophers-stone project]
-        stone(philosophers-stone) -.-x|⛔️| harry-1
-    end
-    subgraph azkaban-project[prisoner-of-azkaban project]
-        azkaban(prisoner-of-azkaban) --> |requires| harry-3
-    end
-```
-
-/// tip | Dica
-
-É muito comum em pacotes Python tentar ao máximo **evitar alterações drásticas** em **novas versões**, mas é melhor prevenir do que remediar e instalar versões mais recentes intencionalmente e, quando possível, executar os testes para verificar se tudo está funcionando corretamente.
-
-///
-
-Agora, imagine isso com **muitos** outros **pacotes** dos quais todos os seus **projetos dependem**. Isso é muito difícil de gerenciar. E você provavelmente acabaria executando alguns projetos com algumas **versões incompatíveis** dos pacotes, e não saberia por que algo não está funcionando.
-
-Além disso, dependendo do seu sistema operacional (por exemplo, Linux, Windows, macOS), ele pode ter vindo com o Python já instalado. E, nesse caso, provavelmente tinha alguns pacotes pré-instalados com algumas versões específicas **necessárias para o seu sistema**. Se você instalar pacotes no ambiente global do Python, poderá acabar **quebrando** alguns dos programas que vieram com seu sistema operacional.
-
-## Onde os pacotes são instalados { #where-are-packages-installed }
-
-Quando você instala o Python, ele cria alguns diretórios com alguns arquivos no seu computador.
-
-Alguns desses diretórios são os responsáveis por ter todos os pacotes que você instala.
-
-Quando você executa:
-
-<div class="termy">
-
-```console
-// Não execute isso agora, é apenas um exemplo 🤓
-$ pip install "fastapi[standard]"
---> 100%
-```
-
-</div>
-
-Isso fará o download de um arquivo compactado com o código FastAPI, normalmente do [PyPI](https://pypi.org/project/fastapi/).
-
-Ele também fará o **download** de arquivos para outros pacotes dos quais o FastAPI depende.
-
-Em seguida, ele **extrairá** todos esses arquivos e os colocará em um diretório no seu computador.
-
-Por padrão, ele colocará os arquivos baixados e extraídos no diretório que vem com a instalação do Python, que é o **ambiente global**.
-
-## O que são ambientes virtuais { #what-are-virtual-environments }
-
-A solução para os problemas de ter todos os pacotes no ambiente global é usar um **ambiente virtual para cada projeto** em que você trabalha.
-
-Um ambiente virtual é um **diretório**, muito semelhante ao global, onde você pode instalar os pacotes para um projeto.
-
-Dessa forma, cada projeto terá seu próprio ambiente virtual (diretório `.venv`) com seus próprios pacotes.
-
-```mermaid
-flowchart TB
-    subgraph stone-project[philosophers-stone project]
-        stone(philosophers-stone) --->|requires| harry-1
-        subgraph venv1[.venv]
-            harry-1[harry v1]
-        end
-    end
-    subgraph azkaban-project[prisoner-of-azkaban project]
-        azkaban(prisoner-of-azkaban) --->|requires| harry-3
-        subgraph venv2[.venv]
-            harry-3[harry v3]
-        end
-    end
-    stone-project ~~~ azkaban-project
-```
-
-## O que significa ativar um ambiente virtual { #what-does-activating-a-virtual-environment-mean }
-
-Quando você ativa um ambiente virtual, por exemplo com:
-
-//// tab | Linux, macOS
-
-<div class="termy">
-
-```console
-$ source .venv/bin/activate
-```
-
-</div>
-
-////
-
-//// tab | Windows PowerShell
-
-<div class="termy">
-
-```console
-$ .venv\Scripts\Activate.ps1
-```
-
-</div>
-
-////
-
-//// tab | Windows Bash
-
-Ou se você usa o Bash para Windows (por exemplo, [Git Bash](https://gitforwindows.org/)):
-
-<div class="termy">
-
-```console
-$ source .venv/Scripts/activate
-```
-
-</div>
-
-////
-
-Esse comando criará ou modificará algumas [variáveis de ambiente](environment-variables.md) que estarão disponíveis para os próximos comandos.
-
-Uma dessas variáveis é a variável `PATH`.
-
-/// tip | Dica
-
-Você pode aprender mais sobre a variável de ambiente `PATH` na seção [Variáveis de ambiente](environment-variables.md#path-environment-variable).
-
-///
-
-A ativação de um ambiente virtual adiciona seu caminho `.venv/bin` (no Linux e macOS) ou `.venv\Scripts` (no Windows) à variável de ambiente `PATH`.
-
-Digamos que antes de ativar o ambiente, a variável `PATH` estava assim:
-
-//// tab | Linux, macOS
-
-```plaintext
-/usr/bin:/bin:/usr/sbin:/sbin
-```
-
-Isso significa que o sistema procuraria programas em:
-
-* `/usr/bin`
-* `/bin`
-* `/usr/sbin`
-* `/sbin`
-
-////
-
-//// tab | Windows
-
-```plaintext
-C:\Windows\System32
-```
-
-Isso significa que o sistema procuraria programas em:
-
-* `C:\Windows\System32`
-
-////
-
-Após ativar o ambiente virtual, a variável `PATH` ficaria mais ou menos assim:
-
-//// tab | Linux, macOS
-
-```plaintext
-/home/user/code/awesome-project/.venv/bin:/usr/bin:/bin:/usr/sbin:/sbin
-```
-
-Isso significa que o sistema agora começará a procurar primeiro por programas em:
-
-```plaintext
-/home/user/code/awesome-project/.venv/bin
-```
-
-antes de procurar nos outros diretórios.
-
-Então, quando você digita `python` no terminal, o sistema encontrará o programa Python em
-
-```plaintext
-/home/user/code/awesome-project/.venv/bin/python
-```
-
-e usa esse.
-
-////
-
-//// tab | Windows
-
-```plaintext
-C:\Users\user\code\awesome-project\.venv\Scripts;C:\Windows\System32
-```
-
-Isso significa que o sistema agora começará a procurar primeiro por programas em:
-
-```plaintext
-C:\Users\user\code\awesome-project\.venv\Scripts
-```
-
-antes de procurar nos outros diretórios.
-
-Então, quando você digita `python` no terminal, o sistema encontrará o programa Python em
-
-```plaintext
-C:\Users\user\code\awesome-project\.venv\Scripts\python
-```
-
-e usa esse.
-
-////
-
-Um detalhe importante é que ele colocará o caminho do ambiente virtual no **início** da variável `PATH`. O sistema o encontrará **antes** de encontrar qualquer outro Python disponível. Dessa forma, quando você executar `python`, ele usará o Python **do ambiente virtual** em vez de qualquer outro `python` (por exemplo, um `python` de um ambiente global).
-
-Ativar um ambiente virtual também muda algumas outras coisas, mas esta é uma das mais importantes.
-
-## Verificando um ambiente virtual { #checking-a-virtual-environment }
-
-Ao verificar se um ambiente virtual está ativo, por exemplo com:
-
-//// tab | Linux, macOS, Windows Bash
-
-<div class="termy">
-
-```console
-$ which python
-
-/home/user/code/awesome-project/.venv/bin/python
-```
-
-</div>
-
-////
-
-//// tab | Windows PowerShell
-
-<div class="termy">
-
-```console
-$ Get-Command python
-
-C:\Users\user\code\awesome-project\.venv\Scripts\python
-```
-
-</div>
-
-////
-
-Isso significa que o programa `python` que será usado é aquele **no ambiente virtual**.
-
-Você usa `which` no Linux e macOS e `Get-Command` no Windows PowerShell.
-
-A maneira como esse comando funciona é que ele vai e verifica na variável de ambiente `PATH`, passando por **cada caminho em ordem**, procurando pelo programa chamado `python`. Uma vez que ele o encontre, ele **mostrará o caminho** para esse programa.
-
-A parte mais importante é que quando você chama `python`, esse é exatamente o "`python`" que será executado.
-
-Assim, você pode confirmar se está no ambiente virtual correto.
-
-/// tip | Dica
-
-É fácil ativar um ambiente virtual, obter um Python e então **ir para outro projeto**.
-
-E o segundo projeto **não funcionaria** porque você está usando o **Python incorreto**, de um ambiente virtual para outro projeto.
-
-É útil poder verificar qual `python` está sendo usado. 🤓
-
-///
-
-## Por que desativar um ambiente virtual { #why-deactivate-a-virtual-environment }
-
-Por exemplo, você pode estar trabalhando em um projeto `philosophers-stone`, **ativar esse ambiente virtual**, instalar pacotes e trabalhar com esse ambiente.
-
-E então você quer trabalhar em **outro projeto** `prisoner-of-azkaban`.
-
-Você vai para aquele projeto:
-
-<div class="termy">
-
-```console
-$ cd ~/code/prisoner-of-azkaban
-```
-
-</div>
-
-Se você não desativar o ambiente virtual para `philosophers-stone`, quando você executar `python` no terminal, ele tentará usar o Python de `philosophers-stone`.
-
-<div class="termy">
-
-```console
-$ cd ~/code/prisoner-of-azkaban
-
-$ python main.py
-
-// Erro ao importar sirius, ele não está instalado 😱
-Traceback (most recent call last):
-    File "main.py", line 1, in <module>
-        import sirius
-```
-
-</div>
-
-Mas se você desativar o ambiente virtual e ativar o novo para `prisoner-of-azkaban`, quando você executar `python`, ele usará o Python do ambiente virtual em `prisoner-of-azkaban`.
-
-<div class="termy">
-
-```console
-$ cd ~/code/prisoner-of-azkaban
-
-// Você não precisa estar no diretório antigo para desativar, você pode fazer isso de onde estiver, mesmo depois de ir para o outro projeto 😎
-$ deactivate
-
-// Ative o ambiente virtual em prisoner-of-azkaban/.venv 🚀
-$ source .venv/bin/activate
-
-// Agora, quando você executar o python, ele encontrará o pacote sirius instalado neste ambiente virtual ✨
-$ python main.py
-
-I solemnly swear 🐺
-```
-
-</div>
-
-## Alternativas { #alternatives }
-
-Este é um guia simples para você começar e lhe ensinar como tudo funciona **por baixo**.
-
-Existem muitas **alternativas** para gerenciar ambientes virtuais, dependências de pacotes (requisitos) e projetos.
-
-Quando estiver pronto e quiser usar uma ferramenta para **gerenciar todo o projeto**, dependências de pacotes, ambientes virtuais, etc., sugiro que você experimente o [uv](https://github.com/astral-sh/uv).
-
-`uv` pode fazer muitas coisas, ele pode:
-
-* **Instalar o Python** para você, incluindo versões diferentes
-* Gerenciar o **ambiente virtual** para seus projetos
-* Instalar **pacotes**
-* Gerenciar **dependências e versões** de pacotes para seu projeto
-* Certificar-se de que você tenha um conjunto **exato** de pacotes e versões para instalar, incluindo suas dependências, para que você possa ter certeza de que pode executar seu projeto em produção exatamente da mesma forma que em seu computador durante o desenvolvimento, isso é chamado de **bloqueio**
-* E muitas outras coisas
-
-## Conclusão { #conclusion }
-
-Se você leu e entendeu tudo isso, agora **você sabe muito mais** sobre ambientes virtuais do que muitos desenvolvedores por aí. 🤓
-
-Saber esses detalhes provavelmente será útil no futuro, quando você estiver depurando algo que parece complexo, mas você saberá **como tudo funciona por baixo**. 😎
+Leia o [guia de Ambientes Virtuais](https://tiangolo.com/guides/virtual-environments/) para aprender como ambientes virtuais funcionam por baixo, incluindo ativação e o fluxo de trabalho alternativo com `python -m venv` e `pip`.