🌐 Update Portuguese translations with LLM prompt (#14228)

* validated llm translation

* validated llm translation

* validated llm translation

* validated llm translation

* validated llm translation

* validated llm translation

* validated llm translation

* validated llm translation

* validated llm translation

* validated llm translation

* validated llm translation

* validated llm translation

* validated llm translation

* validated llm translation

* validated llm translation

* validated llm translation

* validated llm translation

* fix non-Annotated in llm-prompt

* rerun after a few changes in llm-prompt

* fix non-Annotated

* validated llm translation

* fix llm translation

* update outdated translations

* fix translation for operation IDs

* add header link

* add missing link

* fix line break

* fix diff

* fix llm translation

* fix 'Atualize' to 'Atualizar'

* update alternatives.md

* update async.md

* update fastapi-cli.md

* update features.md

* update help-fastapi.md

* update history-design-future.md

* update index.md

* update advanced/events.md

* update advanced/middleware.md

* update advanced/response-cookies.md

* update advanced/response-headers.md

* update advanced/templates.md

* update advanced/testing-websockets.md

* update advanced/using-request-directly.md

* update advanced/websockets.md

* update advanced/security/oauth2-scopes.md

* update deployment/cloud.md

* update deployment/manually.md

* update how-to/custom-request-and-route.md

* update how-to/migrate-from-pydantic-v1-to-pydantic-v2.md

* update tutorial/background-tasks.md

* update tutorial/first-steps.md

* update tutorial/handling-errors.md

* update tutorial/middleware.md

* update tutorial/request-files.md

* update tutorial/sql-databases.md

* update tutorial/static-files.md

* update tutorial/testing.md

* update tutorial/dependencies/dependencies-with-yield.md

* update advanced/advanced-dependencies.md

---------

Co-authored-by: Motov Yurii <109919500+YuriiMotov@users.noreply.github.com>

docs/pt/docs/about/index.md

@@ -1,3 +1,3 @@
-# Sobre
+# Sobre { #about }
 
-Sobre o FastAPI, seus padrões, inspirações e muito mais. 🤓
+Sobre o FastAPI, seu design, inspiração e mais. 🤓

docs/pt/docs/advanced/additional-responses.md

@@ -1,6 +1,6 @@
-# Retornos Adicionais no OpenAPI
+# Retornos Adicionais no OpenAPI { #additional-responses-in-openapi }
 
-/// warning | Aviso
+/// warning | Atenção
 
 Este é um tema bem avançado.
 
@@ -14,7 +14,7 @@ Essas respostas adicionais serão incluídas no esquema do OpenAPI, e também ap
 
 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.
 
-## Retorno Adicional com `model`
+## Retorno Adicional com `model` { #additional-response-with-model }
 
 Você pode fornecer o parâmetro `responses` aos seus *decoradores de caminho*.
 
@@ -49,7 +49,7 @@ O local correto é:
 
 ///
 
-O retorno gerado no OpenAI para esta *operação de caminho* será:
+O retorno gerado no OpenAPI para esta *operação de rota* será:
 
 ```JSON hl_lines="3-12"
 {
@@ -169,11 +169,11 @@ Os esquemas são referenciados em outro local dentro do esquema OpenAPI:
 }
 ```
 
-## Media types adicionais para o retorno principal
+## Media types adicionais para o retorno 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.
 
-Por exemplo, você pode adicionar um media type adicional de `image/png`, declarando que a sua *operação de caminho* pode retornar um objeto JSON (com o media type `application/json`) ou uma imagem PNG:
+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:
 
 {* ../../docs_src/additional_responses/tutorial002.py hl[19:24,28] *}
 
@@ -191,7 +191,7 @@ Porém se você especificou uma classe de retorno com o valor `None` como media
 
 ///
 
-## Combinando informações
+## 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`.
 
@@ -209,9 +209,9 @@ Isso será combinado e incluído em seu OpenAPI, e disponibilizado na documenta
 
 <img src="/img/tutorial/additional-responses/image01.png">
 
-## Combinar retornos predefinidos e personalizados
+## Combinar retornos predefinidos e personalizados { #combine-predefined-responses-and-custom-ones }
 
-Você pode querer possuir alguns retornos predefinidos que são aplicados para diversas *operações de caminho*, porém você deseja combinar com retornos personalizados que são necessários para cada *operação de caminho*.
+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*.
 
 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 caminho* e combiná-las com personalizações adicionais.
+Você pode utilizar essa técnica para reutilizar alguns retornos predefinidos nas suas *operações de rota* e combiná-las com personalizações adicionais.
 
 Por exemplo:
 
 {* ../../docs_src/additional_responses/tutorial004.py hl[13:17,26] *}
 
-## Mais informações sobre retornos OpenAPI
+## Mais informações sobre retornos 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:
 
-* <a href="https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#responsesObject" class="external-link" target="_blank">Objeto de Retorno OpenAPI</a>, inclui o `Response Object`.
-* <a href="https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#responseObject" class="external-link" target="_blank">Objeto de Retorno OpenAPI</a>, 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`.
+* <a href="https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#responses-object" class="external-link" target="_blank">Objeto de Retorno OpenAPI</a>, inclui o `Response Object`.
+* <a href="https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#response-object" class="external-link" target="_blank">Objeto de Retorno OpenAPI</a>, 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`.

docs/pt/docs/advanced/additional-status-codes.md

@@ -1,22 +1,22 @@
-# Códigos de status adicionais
+# Códigos de status adicionais { #additional-status-codes }
 
-Por padrão, o **FastAPI** retornará as respostas utilizando o `JSONResponse`, adicionando o conteúdo do retorno da sua *operação de caminho* dentro do `JSONResponse`.
+Por padrão, o **FastAPI** retornará as respostas utilizando o `JSONResponse`, adicionando o conteúdo do retorno da sua *operação de rota* dentro do `JSONResponse`.
 
-Ele usará o código de status padrão ou o que você definir na sua *operação de caminho*.
+Ele usará o código de status padrão ou o que você definir na sua *operação de rota*.
 
-## Códigos de status adicionais
+## Códigos de status adicionais { #additional-status-codes_1 }
 
 Caso você queira retornar códigos de status adicionais além do código principal, você pode fazer isso retornando um `Response` diretamente, como por exemplo um `JSONResponse`, e definir os códigos de status adicionais diretamente.
 
-Por exemplo, vamos dizer que você deseja ter uma *operação de caminho* que permita atualizar itens, e retornar um código de status HTTP 200 "OK" quando for bem sucedido.
+Por exemplo, vamos dizer que você deseja ter uma *operação de rota* que permita atualizar itens, e retornar um código de status HTTP 200 "OK" quando for bem sucedido.
 
-Mas você também deseja aceitar novos itens. E quando os itens não existiam, ele os cria, e retorna o código de status HTTP 201 "Created.
+Mas você também deseja aceitar novos itens. E quando os itens não existiam, ele os cria, e retorna o código de status HTTP 201 "Created".
 
 Para conseguir isso, importe `JSONResponse` e retorne o seu conteúdo diretamente, definindo o `status_code` que você deseja:
 
 {* ../../docs_src/additional_status_codes/tutorial001_an_py310.py hl[4,25] *}
 
-/// warning | Aviso
+/// warning | Atenção
 
 Quando você retorna um `Response` diretamente, como no exemplo acima, ele será retornado diretamente.
 
@@ -26,7 +26,7 @@ Garanta que ele tenha toda informação que você deseja, e que os valores sejam
 
 ///
 
-/// note | Detalhes técnicos
+/// note | Detalhes Técnicos
 
 Você também pode utilizar `from starlette.responses import JSONResponse`.
 
@@ -34,7 +34,7 @@ O **FastAPI** disponibiliza o `starlette.responses` como `fastapi.responses` ape
 
 ///
 
-## OpenAPI e documentação da API
+## OpenAPI e documentação da API { #openapi-and-api-docs }
 
 Se você retorna códigos de status adicionais e retornos diretamente, eles não serão incluídos no esquema do OpenAPI (a documentação da API), porque o FastAPI não tem como saber de antemão o que será retornado.
 

docs/pt/docs/advanced/advanced-dependencies.md

@@ -1,6 +1,6 @@
-# Dependências avançadas
+# Dependências avançadas { #advanced-dependencies }
 
-## Dependências parametrizadas
+## Dependências parametrizadas { #parameterized-dependencies }
 
 Todas as dependências que vimos até agora são funções ou classes fixas.
 
@@ -10,7 +10,7 @@ Vamos imaginar que queremos ter uma dependência que verifica se o parâmetro de
 
 Porém nós queremos poder parametrizar o conteúdo fixo.
 
-## Uma instância "chamável"
+## Uma instância "chamável" { #a-callable-instance }
 
 Em Python existe uma maneira de fazer com que uma instância de uma classe seja um "chamável".
 
@@ -22,7 +22,7 @@ Para fazer isso, nós declaramos o método `__call__`:
 
 Neste caso, o `__call__` é o que o **FastAPI** utilizará para verificar parâmetros adicionais e sub dependências, e isso é o que será chamado para passar o valor ao parâmetro na sua *função de operação de rota* posteriormente.
 
-## Parametrizar a instância
+## Parametrizar a instância { #parameterize-the-instance }
 
 E agora, nós podemos utilizar o `__init__` para declarar os parâmetros da instância que podemos utilizar para "parametrizar" a dependência:
 
@@ -30,7 +30,7 @@ E agora, nós podemos utilizar o `__init__` para declarar os parâmetros da inst
 
 Neste caso, o **FastAPI** nunca tocará ou se importará com o `__init__`, nós vamos utilizar diretamente em nosso código.
 
-## Crie uma instância
+## Crie uma instância { #create-an-instance }
 
 Nós poderíamos criar uma instância desta classe com:
 
@@ -38,7 +38,7 @@ Nós poderíamos criar uma instância desta classe com:
 
 E deste modo nós podemos "parametrizar" a nossa dependência, que agora possui `"bar"` dentro dele, como o atributo `checker.fixed_content`.
 
-## Utilize a instância como dependência
+## Utilize a instância como dependência { #use-the-instance-as-a-dependency }
 
 Então, nós podemos utilizar este `checker` em um `Depends(checker)`, no lugar de `Depends(FixedContentQueryChecker)`, porque a dependência é a instância, `checker`, e não a própria classe.
 
@@ -63,3 +63,101 @@ Nos capítulos sobre segurança, existem funções utilitárias que são impleme
 Se você entendeu tudo isso, você já sabe como essas funções utilitárias para segurança funcionam por debaixo dos panos.
 
 ///
+
+## Dependências com `yield`, `HTTPException`, `except` e Tarefas em Segundo Plano { #dependencies-with-yield-httpexception-except-and-background-tasks }
+
+/// warning | Atenção
+
+Muito provavelmente você não precisa desses detalhes técnicos.
+
+Esses detalhes são úteis principalmente se você tinha uma aplicação FastAPI anterior à versão 0.121.0 e está enfrentando problemas com dependências com `yield`.
+
+///
+
+Dependências com `yield` evoluíram ao longo do tempo para contemplar diferentes casos de uso e corrigir alguns problemas, aqui está um resumo do que mudou.
+
+### Dependências com `yield` e `scope` { #dependencies-with-yield-and-scope }
+
+Na versão 0.121.0, o FastAPI adicionou suporte a `Depends(scope="function")` para dependências com `yield`.
+
+Usando `Depends(scope="function")`, o código de saída após o `yield` é executado logo depois que a *função de operação de rota* termina, antes de a response ser enviada de volta ao cliente.
+
+E ao usar `Depends(scope="request")` (o padrão), o código de saída após o `yield` é executado depois que a response é enviada.
+
+Você pode ler mais na documentação em [Dependências com `yield` - Saída antecipada e `scope`](../tutorial/dependencies/dependencies-with-yield.md#early-exit-and-scope).
+
+### Dependências com `yield` e `StreamingResponse`, Detalhes Técnicos { #dependencies-with-yield-and-streamingresponse-technical-details }
+
+Antes do FastAPI 0.118.0, se você usasse uma dependência com `yield`, o código de saída (após o `yield`) rodaria depois que a *função de operação de rota* retornasse, mas logo antes de enviar a resposta.
+
+A intenção era evitar manter recursos por mais tempo que o necessário, esperando a resposta percorrer a rede.
+
+Essa mudança também significava que, se você retornasse um `StreamingResponse`, o código de saída da dependência com `yield` já teria sido executado.
+
+Por exemplo, se você tivesse uma sessão de banco de dados em uma dependência com `yield`, o `StreamingResponse` não conseguiria usar essa sessão enquanto transmite dados, porque a sessão já teria sido fechada no código de saída após o `yield`.
+
+Esse comportamento foi revertido na versão 0.118.0, para que o código de saída após o `yield` seja executado depois que a resposta for enviada.
+
+/// info | Informação
+
+Como você verá abaixo, isso é muito semelhante ao comportamento antes da versão 0.106.0, mas com várias melhorias e correções de bugs para casos extremos.
+
+///
+
+#### Casos de uso com código de saída antecipado { #use-cases-with-early-exit-code }
+
+Há alguns casos de uso, com condições específicas, que poderiam se beneficiar do comportamento antigo de executar o código de saída das dependências com `yield` antes de enviar a resposta.
+
+Por exemplo, imagine que você tem código que usa uma sessão de banco de dados em uma dependência com `yield` apenas para verificar um usuário, mas a sessão de banco de dados nunca é usada novamente na *função de operação de rota*, somente na dependência, e a resposta demora a ser enviada, como um `StreamingResponse` que envia dados lentamente, mas por algum motivo não usa o banco de dados.
+
+Nesse caso, a sessão de banco de dados seria mantida até que a resposta termine de ser enviada, mas se você não a usa, então não seria necessário mantê-la.
+
+Veja como poderia ser:
+
+{* ../../docs_src/dependencies/tutorial013_an_py310.py *}
+
+O código de saída, o fechamento automático da `Session` em:
+
+{* ../../docs_src/dependencies/tutorial013_an_py310.py ln[19:21] *}
+
+...seria executado depois que a resposta terminar de enviar os dados lentos:
+
+{* ../../docs_src/dependencies/tutorial013_an_py310.py ln[30:38] hl[31:33] *}
+
+Mas como `generate_stream()` não usa a sessão do banco de dados, não é realmente necessário manter a sessão aberta enquanto envia a resposta.
+
+Se você tiver esse caso específico usando SQLModel (ou SQLAlchemy), você poderia fechar explicitamente a sessão depois que não precisar mais dela:
+
+{* ../../docs_src/dependencies/tutorial014_an_py310.py ln[24:28] hl[28] *}
+
+Dessa forma a sessão liberaria a conexão com o banco de dados, para que outras requisições pudessem usá-la.
+
+Se você tiver um caso diferente que precise sair antecipadamente de uma dependência com `yield`, por favor crie uma <a href="https://github.com/fastapi/fastapi/discussions/new?category=questions" class="external-link" target="_blank">Pergunta no GitHub Discussions</a> com o seu caso específico e por que você se beneficiaria de ter o fechamento antecipado para dependências com `yield`.
+
+Se houver casos de uso convincentes para fechamento antecipado em dependências com `yield`, considerarei adicionar uma nova forma de optar por esse fechamento antecipado.
+
+### Dependências com `yield` e `except`, Detalhes Técnicos { #dependencies-with-yield-and-except-technical-details }
+
+Antes do FastAPI 0.110.0, se você usasse uma dependência com `yield`, e então capturasse uma exceção com `except` nessa dependência, e você não relançasse a exceção, a exceção seria automaticamente levantada/encaminhada para quaisquer tratadores de exceção ou para o tratador de erro interno do servidor.
+
+Isso foi alterado na versão 0.110.0 para corrigir consumo de memória não tratado decorrente de exceções encaminhadas sem um tratador (erros internos do servidor), e para torná-lo consistente com o comportamento do código Python regular.
+
+### Tarefas em Segundo Plano e Dependências com `yield`, Detalhes Técnicos { #background-tasks-and-dependencies-with-yield-technical-details }
+
+Antes do FastAPI 0.106.0, lançar exceções após o `yield` não era possível, o código de saída em dependências com `yield` era executado depois que a resposta era enviada, então [Tratadores de Exceções](../handling-errors.md#install-custom-exception-handlers){.internal-link target=_blank} já teriam sido executados.
+
+Isso foi projetado assim principalmente para permitir o uso dos mesmos objetos "yielded" por dependências dentro de tarefas em segundo plano, porque o código de saída seria executado depois que as tarefas em segundo plano fossem concluídas.
+
+Isso foi alterado no FastAPI 0.106.0 com a intenção de não manter recursos enquanto se espera a resposta percorrer a rede.
+
+/// tip | Dica
+
+Além disso, uma tarefa em segundo plano normalmente é um conjunto de lógica independente que deve ser tratado separadamente, com seus próprios recursos (por exemplo, sua própria conexão de banco de dados).
+
+Assim, desta forma você provavelmente terá um código mais limpo.
+
+///
+
+Se você costumava depender desse comportamento, agora você deve criar os recursos para tarefas em segundo plano dentro da própria tarefa em segundo plano, e usar internamente apenas dados que não dependam dos recursos de dependências com `yield`.
+
+Por exemplo, em vez de usar a mesma sessão de banco de dados, você criaria uma nova sessão de banco de dados dentro da tarefa em segundo plano, e obteria os objetos do banco de dados usando essa nova sessão. E então, em vez de passar o objeto do banco de dados como parâmetro para a função da tarefa em segundo plano, você passaria o ID desse objeto e então obteria o objeto novamente dentro da função da tarefa em segundo plano.

docs/pt/docs/advanced/async-tests.md

@@ -1,4 +1,4 @@
-# Testes Assíncronos
+# Testes Assíncronos { #async-tests }
 
 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`.
 
@@ -6,11 +6,11 @@ Ser capaz de utilizar funções assíncronas em seus testes pode ser útil, por
 
 Vamos ver como nós podemos fazer isso funcionar.
 
-## pytest.mark.anyio
+## pytest.mark.anyio { #pytest-mark-anyio }
 
 Se quisermos chamar funções assíncronas em nossos testes, as nossas funções de teste precisam ser assíncronas. O AnyIO oferece um plugin bem legal para isso, que nos permite especificar que algumas das nossas funções de teste precisam ser chamadas de forma assíncrona.
 
-## HTTPX
+## HTTPX { #httpx }
 
 Mesmo que a sua aplicação **FastAPI** utilize funções normais com `def` no lugar de `async def`, ela ainda é uma aplicação `async` por baixo dos panos.
 
@@ -18,7 +18,7 @@ O `TestClient` faz algumas mágicas para invocar a aplicação FastAPI assíncro
 
 O `TestClient` é baseado no <a href="https://www.python-httpx.org" class="external-link" target="_blank">HTTPX</a>, e felizmente nós podemos utilizá-lo diretamente para testar a API.
 
-## Exemplo
+## Exemplo { #example }
 
 Para um exemplos simples, vamos considerar uma estrutura de arquivos semelhante ao descrito em [Bigger Applications](../tutorial/bigger-applications.md){.internal-link target=_blank} e [Testing](../tutorial/testing.md){.internal-link target=_blank}:
 
@@ -38,7 +38,7 @@ O arquivo `test_main.py` teria os testes para para o arquivo `main.py`, ele pode
 
 {* ../../docs_src/async_tests/test_main.py *}
 
-## Executá-lo
+## Executá-lo { #run-it }
 
 Você pode executar os seus testes normalmente via:
 
@@ -52,7 +52,7 @@ $ pytest
 
 </div>
 
-## Em Detalhes
+## Em Detalhes { #in-detail }
 
 O marcador `@pytest.mark.anyio` informa ao pytest que esta função de teste deve ser invocada de maneira assíncrona:
 
@@ -82,18 +82,18 @@ Note que nós estamos utilizando async/await com o novo `AsyncClient` - a requis
 
 ///
 
-/// warning | Aviso
+/// warning | Atenção
 
-Se a sua aplicação depende dos eventos de vida útil (*lifespan*), o `AsyncClient` não acionará estes eventos. Para garantir que eles são acionados, utilize o `LifespanManager` do <a href="https://github.com/florimondmanca/asgi-lifespan#usage" class="external-link" target="_blank">florimondmanca/asgi-lifespan</a>.
+Se a sua aplicação depende de eventos de lifespan, o `AsyncClient` não acionará estes eventos. Para garantir que eles são acionados, utilize o `LifespanManager` do <a href="https://github.com/florimondmanca/asgi-lifespan#usage" class="external-link" target="_blank">florimondmanca/asgi-lifespan</a>.
 
 ///
 
-## Outras Chamadas de Funções Assíncronas
+## Outras Chamadas de Funções Assíncronas { #other-asynchronous-function-calls }
 
-Como a função de teste agora é assíncrona, você pode chamar (e `esperar`) outras funções `async` além de enviar requisições para a sua aplicação FastAPI em seus testes, exatamente como você as chamaria em qualquer outro lugar do seu código.
+Como a função de teste agora é assíncrona, você pode chamar (e `await`) outras funções `async` além de enviar requisições para a sua aplicação FastAPI em seus testes, exatamente como você as chamaria em qualquer outro lugar do seu código.
 
 /// 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 <a href="https://stackoverflow.com/questions/41584243/runtimeerror-task-attached-to-a-different-loop" class="external-link" target="_blank">MotorClient do MongoDB</a>) 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 funções assíncronas em seus testes (e.g. ao utilizar o <a href="https://stackoverflow.com/questions/41584243/runtimeerror-task-attached-to-a-different-loop" class="external-link" target="_blank">MotorClient do MongoDB</a>) 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")`.
 
 ///

docs/pt/docs/advanced/behind-a-proxy.md

@@ -1,34 +1,131 @@
-# Atrás de um Proxy
+# Atrás de um Proxy { #behind-a-proxy }
 
-Em algumas situações, você pode precisar usar um servidor **proxy** como Traefik ou Nginx com uma configuração que adiciona um prefixo de caminho extra que não é visto pela sua aplicação.
+Em muitas situações, você usaria um **proxy** como Traefik ou Nginx na frente da sua aplicação FastAPI.
+
+Esses proxies podem lidar com certificados HTTPS e outras coisas.
+
+## Headers Encaminhados pelo Proxy { #proxy-forwarded-headers }
+
+Um **proxy** na frente da sua aplicação normalmente definiria alguns headers dinamicamente antes de enviar as requisições para o seu **servidor**, para informar ao servidor que a requisição foi **encaminhada** pelo proxy, informando a URL original (pública), incluindo o domínio, que está usando HTTPS, etc.
+
+O programa do **servidor** (por exemplo, **Uvicorn** via **CLI do FastAPI**) é capaz de interpretar esses headers e então repassar essas informações para a sua aplicação.
+
+Mas, por segurança, como o servidor não sabe que está atrás de um proxy confiável, ele não interpretará esses headers.
+
+/// note | Detalhes Técnicos
+
+Os headers do proxy são:
+
+* <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/X-Forwarded-For" class="external-link" target="_blank">X-Forwarded-For</a>
+* <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/X-Forwarded-Proto" class="external-link" target="_blank">X-Forwarded-Proto</a>
+* <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/X-Forwarded-Host" class="external-link" target="_blank">X-Forwarded-Host</a>
+
+///
+
+### Ativar 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.
+
+Se você definir como `--forwarded-allow-ips="*"`, ele confiará em todos os IPs de entrada.
+
+Se o seu **servidor** estiver atrás de um **proxy** confiável e somente o proxy falar com ele, isso fará com que ele aceite seja qual for o IP desse **proxy**.
+
+<div class="termy">
+
+```console
+$ 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)
+```
+
+</div>
+
+### Redirecionamentos com HTTPS { #redirects-with-https }
+
+Por exemplo, suponha que você defina uma *operação de rota* `/items/`:
+
+{* ../../docs_src/behind_a_proxy/tutorial001_01.py hl[6] *}
+
+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 talvez sua aplicação esteja hospedada em `https://mysuperapp.com`, e o redirecionamento deveria ser para `https://mysuperapp.com/items/`.
+
+Ao definir `--proxy-headers`, agora o FastAPI conseguirá redirecionar para o local correto. 😎
+
+```
+https://mysuperapp.com/items/
+```
+
+/// tip | Dica
+
+Se você quiser saber mais sobre HTTPS, confira o tutorial [Sobre HTTPS](../deployment/https.md){.internal-link target=_blank}.
+
+///
+
+### Como funcionam os headers encaminhados pelo proxy { #how-proxy-forwarded-headers-work }
+
+Aqui está uma representação visual de como o **proxy** adiciona headers encaminhados entre o cliente e o **servidor da aplicação**:
+
+```mermaid
+sequenceDiagram
+    participant Client
+    participant Proxy as Proxy/Load Balancer
+    participant Server as FastAPI Server
+
+    Client->>Proxy: HTTPS Request<br/>Host: mysuperapp.com<br/>Path: /items
+
+    Note over Proxy: Proxy adds forwarded headers
+
+    Proxy->>Server: HTTP Request<br/>X-Forwarded-For: [client IP]<br/>X-Forwarded-Proto: https<br/>X-Forwarded-Host: mysuperapp.com<br/>Path: /items
+
+    Note over Server: Server interprets headers<br/>(if --forwarded-allow-ips is set)
+
+    Server->>Proxy: HTTP Response<br/>with correct HTTPS URLs
+
+    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**.
+
+Esses headers preservam informações sobre a requisição original que, de outra forma, seriam perdidas:
+
+* X-Forwarded-For: o endereço IP original do cliente
+* X-Forwarded-Proto: o protocolo original (`https`)
+* X-Forwarded-Host: o host original (`mysuperapp.com`)
+
+Quando a **CLI do FastAPI** é configurada com `--forwarded-allow-ips`, ela confia nesses headers e os utiliza, por exemplo, para gerar as URLs corretas em redirecionamentos.
+
+## Proxy com um prefixo de path removido { #proxy-with-a-stripped-path-prefix }
+
+Você pode ter um proxy que adiciona um prefixo de path à sua aplicação.
 
 Nesses casos, você pode usar `root_path` para configurar sua aplicação.
 
-O `root_path` é um mecanismo fornecido pela especificação ASGI (que o FastAPI utiliza, através do Starlette).
+O `root_path` é um mecanismo fornecido pela especificação ASGI (na qual o FastAPI é construído, através do Starlette).
 
 O `root_path` é usado para lidar com esses casos específicos.
 
 E também é usado internamente ao montar sub-aplicações.
 
-## Proxy com um prefixo de caminho removido
+Ter um proxy com um prefixo de path removido, nesse caso, significa que você poderia declarar um path em `/app` no seu código, mas então você adiciona uma camada no topo (o proxy) que colocaria sua aplicação **FastAPI** sob um path como `/api/v1`.
 
-Ter um proxy com um prefixo de caminho removido, nesse caso, significa que você poderia declarar um caminho em `/app` no seu código, mas então, você adiciona uma camada no topo (o proxy) que colocaria sua aplicação **FastAPI** sob um caminho como `/api/v1`.
-
-Nesse caso, o caminho original `/app` seria servido em `/api/v1/app`.
+Nesse caso, o path original `/app` seria servido em `/api/v1/app`.
 
 Embora todo o seu código esteja escrito assumindo que existe apenas `/app`.
 
 {* ../../docs_src/behind_a_proxy/tutorial001.py hl[6] *}
 
-E o proxy estaria **"removendo"** o **prefixo do caminho** 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 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`.
 
 Até aqui, tudo funcionaria normalmente.
 
-Mas então, quando você abre a interface de documentação integrada (o frontend), ele esperaria obter o OpenAPI schema em `/openapi.json`, em vez de `/api/v1/openapi.json`.
+Mas então, quando você abre a interface de documentação integrada (o frontend), ela esperaria obter o OpenAPI schema em `/openapi.json`, em vez de `/api/v1/openapi.json`.
 
 Então, o frontend (que roda no navegador) tentaria acessar `/openapi.json` e não conseguiria obter o OpenAPI schema.
 
-Como temos um proxy com um prefixo de caminho de `/api/v1` para nossa aplicação, o frontend precisa buscar o OpenAPI schema em `/api/v1/openapi.json`.
+Como temos um proxy com um prefixo de path de `/api/v1` para nossa aplicação, o frontend precisa buscar o OpenAPI schema em `/api/v1/openapi.json`.
 
 ```mermaid
 graph LR
@@ -47,7 +144,7 @@ O IP `0.0.0.0` é comumente usado para significar que o programa escuta em todos
 
 ///
 
-A interface de documentação também precisaria do OpenAPI schema para declarar que API `server` está localizado em `/api/v1` (atrás do proxy). Por exemplo:
+A interface de documentação também precisaria do OpenAPI schema para declarar que este `server` da API está localizado em `/api/v1` (atrás do proxy). Por exemplo:
 
 ```JSON hl_lines="4-8"
 {
@@ -64,16 +161,16 @@ A interface de documentação também precisaria do OpenAPI schema para declarar
 }
 ```
 
-Neste exemplo, o "Proxy" poderia ser algo como **Traefik**. E o servidor seria algo como CLI do FastAPI com **Uvicorn**, executando sua aplicação FastAPI.
+Neste exemplo, o "Proxy" poderia ser algo como **Traefik**. E o servidor seria algo como a CLI do FastAPI com **Uvicorn**, executando sua aplicação FastAPI.
 
-### Fornecendo o `root_path`
+### Fornecendo o `root_path` { #providing-the-root-path }
 
 Para conseguir isso, você pode usar a opção de linha de comando `--root-path` assim:
 
 <div class="termy">
 
 ```console
-$ fastapi run main.py --root-path /api/v1
+$ 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)
 ```
@@ -90,11 +187,11 @@ E a opção de linha de comando `--root-path` fornece esse `root_path`.
 
 ///
 
-### Verificando o `root_path` atual
+### 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).
 
-Aqui estamos incluindo ele na mensagem apenas para fins de demonstração.
+Aqui estamos incluindo-o na mensagem apenas para fins de demonstração.
 
 {* ../../docs_src/behind_a_proxy/tutorial001.py hl[8] *}
 
@@ -103,7 +200,7 @@ Então, se você iniciar o Uvicorn com:
 <div class="termy">
 
 ```console
-$ fastapi run main.py --root-path /api/v1
+$ 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)
 ```
@@ -119,15 +216,15 @@ A resposta seria algo como:
 }
 ```
 
-### Configurando o `root_path` na aplicação FastAPI
+### Configurando o `root_path` na aplicação FastAPI { #setting-the-root-path-in-the-fastapi-app }
 
-Alternativamente, se você não tiver uma maneira de fornecer uma opção de linha de comando como `--root-path` ou equivalente, você pode definir o parâmetro `--root-path` ao criar sua aplicação FastAPI:
+Alternativamente, se você não tiver uma maneira de fornecer uma opção de linha de comando como `--root-path` ou equivalente, você pode definir o parâmetro `root_path` ao criar sua aplicação FastAPI:
 
 {* ../../docs_src/behind_a_proxy/tutorial002.py hl[3] *}
 
-Passar o `root_path`h para `FastAPI` seria o equivalente a passar a opção de linha de comando `--root-path` para Uvicorn ou Hypercorn.
+Passar o `root_path` para `FastAPI` seria o equivalente a passar a opção de linha de comando `--root-path` para Uvicorn ou Hypercorn.
 
-### Sobre `root_path`
+### Sobre `root_path` { #about-root-path }
 
 Tenha em mente que o servidor (Uvicorn) não usará esse `root_path` para nada além de passá-lo para a aplicação.
 
@@ -144,19 +241,19 @@ Portanto, ele não esperará ser acessado em `http://127.0.0.1:8000/api/v1/app`.
 
 O Uvicorn esperará que o proxy acesse o Uvicorn em `http://127.0.0.1:8000/app`, e então seria responsabilidade do proxy adicionar o prefixo extra `/api/v1` no topo.
 
-## Sobre proxies com um prefixo de caminho removido
+## Sobre proxies com um prefixo de path removido { #about-proxies-with-a-stripped-path-prefix }
 
-Tenha em mente que um proxy com prefixo de caminho removido é apenas uma das maneiras de configurá-lo.
+Tenha em mente que um proxy com prefixo de path removido é apenas uma das maneiras de configurá-lo.
 
-Provavelmente, em muitos casos, o padrão será que o proxy não tenha um prefixo de caminho removido.
+Provavelmente, em muitos casos, o padrão será que o proxy não tenha um prefixo de path removido.
 
-Em um caso como esse (sem um prefixo de caminho removido), o proxy escutaria em algo como `https://myawesomeapp.com`, e então se o navegador acessar `https://myawesomeapp.com/api/v1/app` e seu servidor (por exemplo, Uvicorn) escutar em `http://127.0.0.1:8000` o proxy (sem um prefixo de caminho removido) acessaria o Uvicorn no mesmo caminho: `http://127.0.0.1:8000/api/v1/app`.
+Em um caso como esse (sem um prefixo de path removido), o proxy escutaria em algo como `https://myawesomeapp.com`, e então, se o navegador acessar `https://myawesomeapp.com/api/v1/app` e seu servidor (por exemplo, Uvicorn) escutar em `http://127.0.0.1:8000`, o proxy (sem um prefixo de path removido) acessaria o Uvicorn no mesmo path: `http://127.0.0.1:8000/api/v1/app`.
 
-## Testando localmente com Traefik
+## Testando localmente com Traefik { #testing-locally-with-traefik }
 
-Você pode facilmente executar o experimento localmente com um prefixo de caminho removido usando <a href="https://docs.traefik.io/" class="external-link" target="_blank">Traefik</a>.
+Você pode facilmente executar o experimento localmente com um prefixo de path removido usando <a href="https://docs.traefik.io/" class="external-link" target="_blank">Traefik</a>.
 
-<a href="https://github.com/containous/traefik/releases" class="external-link" target="_blank">Faça o download do Traefik.</a>, Ele é um único binário e você pode extrair o arquivo compactado e executá-lo diretamente do terminal.
+<a href="https://github.com/containous/traefik/releases" class="external-link" target="_blank">Faça o download do Traefik</a>, 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:
 
@@ -203,9 +300,9 @@ Agora crie esse outro arquivo `routes.toml`:
           url = "http://127.0.0.1:8000"
 ```
 
-Esse arquivo configura o Traefik para usar o prefixo de caminho `/api/v1`.
+Esse arquivo configura o Traefik para usar o prefixo de path `/api/v1`.
 
-E então ele redirecionará suas solicitações para seu Uvicorn rodando em `http://127.0.0.1:8000`.
+E então o Traefik redirecionará suas solicitações para seu Uvicorn rodando em `http://127.0.0.1:8000`.
 
 Agora inicie o Traefik:
 
@@ -224,14 +321,14 @@ E agora inicie sua aplicação, usando a opção `--root-path`:
 <div class="termy">
 
 ```console
-$ fastapi run main.py --root-path /api/v1
+$ 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)
 ```
 
 </div>
 
-### Verifique as respostas
+### Verifique as respostas { #check-the-responses }
 
 Agora, se você for ao URL com a porta para o Uvicorn: <a href="http://127.0.0.1:8000/app" class="external-link" target="_blank">http://127.0.0.1:8000/app</a>, você verá a resposta normal:
 
@@ -248,7 +345,7 @@ Perceba que, mesmo acessando em `http://127.0.0.1:8000/app`, ele mostra o `root_
 
 ///
 
-E agora abra o URL com a porta para o Traefik, incluindo o prefixo de caminho: <a href="http://127.0.0.1:9999/api/v1/app" class="external-link" target="_blank">http://127.0.0.1:9999/api/v1/app</a>.
+E agora abra o URL com a porta para o Traefik, incluindo o prefixo de path: <a href="http://127.0.0.1:9999/api/v1/app" class="external-link" target="_blank">http://127.0.0.1:9999/api/v1/app</a>.
 
 Obtemos a mesma resposta:
 
@@ -259,19 +356,19 @@ Obtemos a mesma resposta:
 }
 ```
 
-mas desta vez no URL com o prefixo de caminho fornecido pelo proxy: `/api/v1`.
+mas desta vez no URL com o prefixo de path fornecido pelo proxy: `/api/v1`.
 
-Claro, a ideia aqui é que todos acessariam a aplicação através do proxy, então a versão com o prefixo de caminho `/api/v1` é a "correta".
+Claro, a ideia aqui é que todos acessariam a aplicação através do proxy, então a versão com o prefixo de path `/api/v1` é a "correta".
 
-E a versão sem o prefixo de caminho (`http://127.0.0.1:8000/app`), fornecida diretamente pelo Uvicorn, seria exclusivamente para o _proxy_ (Traefik) acessá-la.
+E a versão sem o prefixo de path (`http://127.0.0.1:8000/app`), fornecida diretamente pelo Uvicorn, seria exclusivamente para o _proxy_ (Traefik) acessá-la.
 
-Isso demonstra como o Proxy (Traefik) usa o prefixo de caminho e como o servidor (Uvicorn) usa o `root_path` da opção `--root-path`.
+Isso demonstra como o Proxy (Traefik) usa o prefixo de path e como o servidor (Uvicorn) usa o `root_path` da opção `--root-path`.
 
-### Verifique a interface de documentação
+### Verifique a interface de documentação { #check-the-docs-ui }
 
 Mas aqui está a parte divertida. ✨
 
-A maneira "oficial" de acessar a aplicação seria através do proxy com o prefixo de caminho que definimos. Então, como esperaríamos, se você tentar a interface de documentação servida diretamente pelo Uvicorn, sem o prefixo de caminho no URL, ela não funcionará, porque espera ser acessada através do proxy.
+A maneira "oficial" de acessar a aplicação seria através do proxy com o prefixo de path que definimos. Então, como esperaríamos, se você tentar a interface de documentação servida diretamente pelo Uvicorn, sem o prefixo de path no URL, ela não funcionará, porque espera ser acessada através do proxy.
 
 Você pode verificar em <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>:
 
@@ -287,9 +384,9 @@ Exatamente como queríamos. ✔️
 
 Isso porque o FastAPI usa esse `root_path` para criar o `server` padrão no OpenAPI com o URL fornecido pelo `root_path`.
 
-## Servidores adicionais
+## Servidores adicionais { #additional-servers }
 
-/// warning | Aviso
+/// warning | Atenção
 
 Este é um caso de uso mais avançado. Sinta-se à vontade para pular.
 
@@ -297,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.
 
@@ -346,7 +443,7 @@ A interface de documentação interagirá com o servidor que você selecionar.
 
 ///
 
-### Desabilitar servidor automático de `root_path`
+### Desabilitar 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`:
 
@@ -354,8 +451,8 @@ Se você não quiser que o **FastAPI** inclua um servidor automático usando o `
 
 e então ele não será incluído no OpenAPI schema.
 
-## Montando uma sub-aplicação
+## Montando uma sub-aplicação { #mounting-a-sub-application }
 
-Se você precisar montar uma sub-aplicação (como descrito em [Sub Aplicações - Montagens](sub-applications.md){.internal-link target=_blank}) enquanto também usa um proxy com `root_path`, você pode fazer isso normalmente, como esperaria.
+Se você precisar montar uma sub-aplicação (como descrito em [Sub-aplicações - Montagens](sub-applications.md){.internal-link target=_blank}) enquanto também usa um proxy com `root_path`, você pode fazer isso normalmente, como esperaria.
 
 O FastAPI usará internamente o `root_path` de forma inteligente, então tudo funcionará. ✨

docs/pt/docs/advanced/custom-response.md

@@ -1,4 +1,4 @@
-# Resposta Personalizada - HTML, Stream, File e outras
+# Resposta Personalizada - HTML, Stream, File e outras { #custom-response-html-stream-file-others }
 
 Por padrão, o **FastAPI** irá retornar respostas utilizando `JSONResponse`.
 
@@ -8,9 +8,9 @@ Mas se você retornar uma `Response` diretamente (ou qualquer subclasse, como `J
 
 Mas você também pode declarar a `Response` que você deseja utilizar (e.g. qualquer subclasse de `Response`), em um *decorador de operação de rota* utilizando o parâmetro `response_class`.
 
-Os conteúdos que você retorna em sua *função de operador de rota* serão colocados dentro dessa `Response`.
+Os conteúdos que você retorna em sua *função de operação de rota* serão colocados dentro dessa `Response`.
 
-E se a `Response` tiver um media type JSON (`application/json`), como é o caso com `JSONResponse` e `UJSONResponse`, os dados que você retornar serão automaticamente convertidos (e filtrados) com qualquer `response_model` do Pydantic que for declarado em sua *função de operador de rota*.
+E se a `Response` tiver um media type JSON (`application/json`), como é o caso com `JSONResponse` e `UJSONResponse`, os dados que você retornar serão automaticamente convertidos (e filtrados) com qualquer `response_model` do Pydantic que for declarado no decorador de operação de rota.
 
 /// note | Nota
 
@@ -18,7 +18,7 @@ Se você utilizar uma classe de Resposta sem media type, o FastAPI esperará que
 
 ///
 
-## Utilizando `ORJSONResponse`
+## Utilizando `ORJSONResponse` { #use-orjsonresponse }
 
 Por exemplo, se você precisa bastante de performance, você pode instalar e utilizar o <a href="https://github.com/ijl/orjson" class="external-link" target="_blank">`orjson`</a> e definir a resposta para ser uma `ORJSONResponse`.
 
@@ -48,7 +48,7 @@ A `ORJSONResponse` está disponível apenas no FastAPI, e não no Starlette.
 
 ///
 
-## Resposta HTML
+## Resposta HTML { #html-response }
 
 Para retornar uma resposta com HTML diretamente do **FastAPI**, utilize `HTMLResponse`.
 
@@ -67,7 +67,7 @@ E será documentado como tal no OpenAPI.
 
 ///
 
-### Retornando uma `Response`
+### Retornando uma `Response` { #return-a-response }
 
 Como visto em [Retornando uma Resposta Diretamente](response-directly.md){.internal-link target=_blank}, você também pode sobrescrever a resposta diretamente na sua *operação de rota*, ao retornar ela.
 
@@ -75,7 +75,7 @@ O mesmo exemplo de antes, retornando uma `HTMLResponse`, poderia parecer com:
 
 {* ../../docs_src/custom_response/tutorial003.py hl[2,7,19] *}
 
-/// warning | Aviso
+/// warning | Atenção
 
 Uma `Response` retornada diretamente em sua *função de operação de rota* não será documentada no OpenAPI (por exemplo, o `Content-Type` não será documentado) e não será visível na documentação interativa automática.
 
@@ -87,13 +87,13 @@ Obviamente, o cabeçalho `Content-Type`, o código de status, etc, virão do obj
 
 ///
 
-### Documentar no OpenAPI e sobrescrever `Response`
+### Documentar no OpenAPI e sobrescrever `Response` { #document-in-openapi-and-override-response }
 
 Se você deseja sobrescrever a resposta dentro de uma função, mas ao mesmo tempo documentar o "media type" no OpenAPI, você pode utilizar o parâmetro `response_class` E retornar um objeto `Response`.
 
 A `response_class` será usada apenas para documentar o OpenAPI da *operação de rota*, mas sua `Response` será usada como foi definida.
 
-##### Retornando uma `HTMLResponse` diretamente
+#### Retornando uma `HTMLResponse` diretamente { #return-an-htmlresponse-directly }
 
 Por exemplo, poderia ser algo como:
 
@@ -107,7 +107,7 @@ Mas se você passasse uma `HTMLResponse` em `response_class` também, o **FastAP
 
 <img src="/img/tutorial/custom-response/image01.png">
 
-## Respostas disponíveis
+## Respostas disponíveis { #available-responses }
 
 Aqui estão algumas dos tipos de resposta disponíveis.
 
@@ -121,7 +121,7 @@ O **FastAPI** provê a mesma `starlette.responses` como `fastapi.responses` apen
 
 ///
 
-### `Response`
+### `Response` { #response }
 
 A classe principal de respostas, todas as outras respostas herdam dela.
 
@@ -138,23 +138,23 @@ O FastAPI (Starlette, na verdade) irá incluir o cabeçalho Content-Length autom
 
 {* ../../docs_src/response_directly/tutorial002.py hl[1,18] *}
 
-### `HTMLResponse`
+### `HTMLResponse` { #htmlresponse }
 
 Usa algum texto ou sequência de bytes e retorna uma resposta HTML. Como você leu acima.
 
-### `PlainTextResponse`
+### `PlainTextResponse` { #plaintextresponse }
 
 Usa algum texto ou sequência de bytes para retornar uma resposta de texto não formatado.
 
 {* ../../docs_src/custom_response/tutorial005.py hl[2,7,9] *}
 
-### `JSONResponse`
+### `JSONResponse` { #jsonresponse }
 
 Pega alguns dados e retorna uma resposta com codificação `application/json`.
 
 É a resposta padrão utilizada no **FastAPI**, como você leu acima.
 
-### `ORJSONResponse`
+### `ORJSONResponse` { #orjsonresponse }
 
 Uma alternativa mais rápida de resposta JSON utilizando o <a href="https://github.com/ijl/orjson" class="external-link" target="_blank">`orjson`</a>, como você leu acima.
 
@@ -164,7 +164,7 @@ Essa resposta requer a instalação do pacote `orjson`, com o comando `pip insta
 
 ///
 
-### `UJSONResponse`
+### `UJSONResponse` { #ujsonresponse }
 
 Uma alternativa de resposta JSON utilizando a biblioteca <a href="https://github.com/ultrajson/ultrajson" class="external-link" target="_blank">`ujson`</a>.
 
@@ -174,7 +174,7 @@ Essa resposta requer a instalação do pacote `ujson`, com o comando `pip instal
 
 ///
 
-/// warning | Aviso
+/// warning | Atenção
 
 `ujson` é menos cauteloso que a implementação nativa do Python na forma que os casos especiais são tratados
 
@@ -188,7 +188,7 @@ Essa resposta requer a instalação do pacote `ujson`, com o comando `pip instal
 
 ///
 
-### `RedirectResponse`
+### `RedirectResponse` { #redirectresponse }
 
 Retorna um redirecionamento HTTP. Utiliza o código de status 307 (Redirecionamento Temporário) por padrão.
 
@@ -212,26 +212,24 @@ Você também pode utilizar o parâmetro `status_code` combinado com o parâmetr
 
 {* ../../docs_src/custom_response/tutorial006c.py hl[2,7,9] *}
 
-### `StreamingResponse`
+### `StreamingResponse` { #streamingresponse }
 
-Recebe uma gerador assíncrono ou um gerador/iterador comum e retorna o corpo da requisição continuamente (stream).
+Recebe um gerador assíncrono ou um gerador/iterador comum e retorna o corpo da resposta de forma contínua (stream).
 
 {* ../../docs_src/custom_response/tutorial007.py hl[2,14] *}
 
-#### Utilizando `StreamingResponse` com objetos semelhantes a arquivos
+#### Utilizando `StreamingResponse` com objetos semelhantes a arquivos { #using-streamingresponse-with-file-like-objects }
 
-Se você tiver um objeto semelhante a um arquivo (e.g. o objeto retornado por `open()`), você pode criar uma função geradora para iterar sobre esse objeto.
+Se você tiver um objeto <a href="https://docs.python.org/3/glossary.html#term-file-like-object" class="external-link" target="_blank">semelhante a um arquivo</a> (e.g. o objeto retornado por `open()`), você pode criar uma função geradora para iterar sobre esse objeto.
 
 Dessa forma, você não precisa ler todo o arquivo na memória primeiro, e você pode passar essa função geradora para `StreamingResponse` e retorná-la.
 
 Isso inclui muitas bibliotecas que interagem com armazenamento em nuvem, processamento de vídeos, entre outras.
 
-```{ .python .annotate hl_lines="2  10-12  14" }
-{!../../docs_src/custom_response/tutorial008.py!}
-```
+{* ../../docs_src/custom_response/tutorial008.py hl[2,10:12,14] *}
 
 1. Essa é a função geradora. É definida como "função geradora" porque contém declarações `yield` nela.
-2. Ao utilizar o bloco `with`, nós garantimos que o objeto semelhante a um arquivo é fechado após a função geradora ser finalizada. Isto é, após a resposta terminar de ser enivada.
+2. Ao utilizar o bloco `with`, nós garantimos que o objeto semelhante a um arquivo é fechado após a função geradora ser finalizada. Isto é, após a resposta terminar de ser enviada.
 3. Essa declaração `yield from` informa a função para iterar sobre essa coisa nomeada de `file_like`. E então, para cada parte iterada, fornece essa parte como se viesse dessa função geradora (`iterfile`).
 
     Então, é uma função geradora que transfere o trabalho de "geração" para alguma outra coisa interna.
@@ -244,10 +242,10 @@ Perceba que aqui estamos utilizando o `open()` da biblioteca padrão que não su
 
 ///
 
-### `FileResponse`
+### `FileResponse` { #fileresponse }
 
 Envia um arquivo  de forma assíncrona e contínua (stream).
-*
+
 Recebe um conjunto de argumentos do construtor diferente dos outros tipos de resposta:
 
 * `path` - O caminho do arquivo que será transmitido
@@ -265,7 +263,7 @@ Você também pode usar o parâmetro `response_class`:
 
 Nesse caso, você pode retornar o caminho do arquivo diretamente da sua *função de operação de rota*.
 
-## Classe de resposta personalizada
+## Classe de resposta personalizada { #custom-response-class }
 
 Você pode criar sua própria classe de resposta, herdando de `Response` e usando essa nova classe.
 
@@ -273,7 +271,7 @@ Por exemplo, vamos supor que você queira utilizar o <a href="https://github.com
 
 Vamos supor também que você queira retornar um JSON indentado e formatado, então você quer utilizar a opção `orjson.OPT_INDENT_2` do orjson.
 
-Você poderia criar uma classe `CustomORJSONResponse`. A principal coisa a ser feita é sobrecarregar o método render da classe Response, `Response.render(content)`, que retorna o conteúdo em bytes, para retornar o conteúdo que você deseja:
+Você poderia criar uma classe `CustomORJSONResponse`. A principal coisa a ser feita é sobrecarregar o método render da classe Response, `Response.render(content)`, que retorna o conteúdo em bytes:
 
 {* ../../docs_src/custom_response/tutorial009c.py hl[9:14,17] *}
 
@@ -293,7 +291,7 @@ Agora em vez de retornar:
 
 Obviamente, você provavelmente vai encontrar maneiras muito melhores de se aproveitar disso do que a formatação de JSON. 😉
 
-## Classe de resposta padrão
+## Classe de resposta padrão { #default-response-class }
 
 Quando você criar uma instância da classe **FastAPI** ou um `APIRouter` você pode especificar qual classe de resposta utilizar por padrão.
 
@@ -309,6 +307,6 @@ Você ainda pode substituir `response_class` em *operações de rota* como antes
 
 ///
 
-## Documentação adicional
+## Documentação adicional { #additional-documentation }
 
 Você também pode declarar o media type e muitos outros detalhes no OpenAPI utilizando `responses`: [Retornos Adicionais no OpenAPI](additional-responses.md){.internal-link target=_blank}.

docs/pt/docs/advanced/dataclasses.md

@@ -1,4 +1,4 @@
-# Usando Dataclasses
+# Usando Dataclasses { #using-dataclasses }
 
 FastAPI é construído em cima do **Pydantic**, e eu tenho mostrado como usar modelos Pydantic para declarar requisições e respostas.
 
@@ -28,7 +28,7 @@ Mas se você tem um monte de dataclasses por aí, este é um truque legal para u
 
 ///
 
-## Dataclasses em `response_model`
+## Dataclasses em `response_model` { #dataclasses-in-response-model }
 
 Você também pode usar `dataclasses` no parâmetro `response_model`:
 
@@ -40,7 +40,7 @@ Dessa forma, seu esquema aparecerá na interface de documentação da API:
 
 <img src="/img/tutorial/dataclasses/image01.png">
 
-## Dataclasses em Estruturas de Dados Aninhadas
+## Dataclasses em Estruturas de Dados Aninhadas { #dataclasses-in-nested-data-structures }
 
 Você também pode combinar `dataclasses` com outras anotações de tipo para criar estruturas de dados aninhadas.
 
@@ -48,9 +48,7 @@ Em alguns casos, você ainda pode ter que usar a versão do Pydantic das `datacl
 
 Nesse caso, você pode simplesmente trocar as `dataclasses` padrão por `pydantic.dataclasses`, que é um substituto direto:
 
-```{ .python .annotate hl_lines="1  5  8-11  14-17  23-25  28" }
-{!../../docs_src/dataclasses/tutorial003.py!}
-```
+{* ../../docs_src/dataclasses/tutorial003.py hl[1,5,8:11,14:17,23:25,28] *}
 
 1. Ainda importamos `field` das `dataclasses` padrão.
 
@@ -86,12 +84,12 @@ Você pode combinar `dataclasses` com outras anotações de tipo em muitas combi
 
 Confira as dicas de anotação no código acima para ver mais detalhes específicos.
 
-## Saiba Mais
+## Saiba Mais { #learn-more }
 
 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 <a href="https://docs.pydantic.dev/latest/concepts/dataclasses/" class="external-link" target="_blank">documentação do Pydantic sobre dataclasses</a>.
 
-## Versão
+## Versão { #version }
 
 Isso está disponível desde a versão `0.67.0` do FastAPI. 🔖

docs/pt/docs/advanced/events.md

@@ -1,65 +1,64 @@
-# Eventos de vida útil
+# Eventos de lifespan { #lifespan-events }
 
-Você pode definir a lógica (código) que poderia ser executada antes da aplicação **inicializar**. Isso significa que esse código será executado **uma vez**, **antes** da aplicação **começar a receber requisições**.
+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**.
 
-Do mesmo modo, você pode definir a lógica (código) que será executada quando a aplicação estiver sendo **encerrada**. Nesse caso, este código será executado **uma vez**, **depois** de ter possivelmente tratado **várias 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**.
 
-Por conta desse código ser executado antes da aplicação **começar** a receber requisições, e logo após **terminar** de lidar com as requisições, ele cobre toda a **vida útil** (_lifespan_) da aplicação (o termo "vida útil" será importante em um segundo 😉).
+Como esse código é executado antes de a aplicação **começar** a receber requisições e logo depois que ela **termina** de lidar com as requisições, ele cobre todo o **lifespan** da aplicação (a palavra "lifespan" será importante em um segundo 😉).
 
-Pode ser muito útil para configurar **recursos** que você precisa usar por toda aplicação, e que são **compartilhados** entre as requisições, e/ou que você precisa **limpar** depois. Por exemplo, o pool de uma conexão com o banco de dados ou carregamento de um modelo compartilhado de aprendizado de máquina (_machine learning_).
+Isso pode ser muito útil para configurar **recursos** que você precisa usar por toda a aplicação, e que são **compartilhados** entre as requisições e/ou que você precisa **limpar** depois. Por exemplo, um pool de conexões com o banco de dados ou o carregamento de um modelo de machine learning compartilhado.
 
-## Caso de uso
+## Caso de uso { #use-case }
 
-Vamos iniciar com um exemplo de **caso de uso** e então ver como resolvê-lo com isso.
+Vamos começar com um exemplo de **caso de uso** e então ver como resolvê-lo com isso.
 
-Vamos imaginar que você tem alguns **modelos de _machine learning_** que deseja usar para lidar com as requisições. 🤖
+Vamos imaginar que você tem alguns **modelos de machine learning** que deseja usar para lidar com as requisições. 🤖
 
-Os mesmos modelos são compartilhados entre as requisições, então não é um modelo por requisição, ou um por usuário ou algo parecido.
+Os mesmos modelos são compartilhados entre as requisições, então não é um modelo por requisição, ou um por usuário, ou algo parecido.
 
-Vamos imaginar que o carregamento do modelo pode **demorar bastante tempo**, porque ele tem que ler muitos **dados do disco**. Então você não quer fazer isso a cada requisição.
+Vamos imaginar que o carregamento do modelo pode **demorar bastante tempo**, porque ele precisa ler muitos **dados do disco**. Então você não quer fazer isso a cada requisição.
 
-Você poderia carregá-lo no nível mais alto do módulo/arquivo, mas isso também poderia significaria **carregar o modelo** mesmo se você estiver executando um simples teste automatizado, então esse teste poderia ser **lento** porque teria que esperar o carregamento do modelo antes de ser capaz de executar uma parte independente do código.
+Você poderia carregá-lo no nível mais alto do módulo/arquivo, mas isso também significaria **carregar o modelo** mesmo se você estivesse executando um teste automatizado simples; então esse teste poderia ser **lento** porque teria que esperar o carregamento do modelo antes de conseguir executar uma parte independente do código.
 
+É isso que vamos resolver: vamos carregar o modelo antes de as requisições serem tratadas, mas apenas um pouco antes de a aplicação começar a receber requisições, não enquanto o código estiver sendo carregado.
 
-Isso é que nós iremos resolver, vamos carregar o modelo antes das requisições serem manuseadas, mas apenas um pouco antes da aplicação começar a receber requisições, não enquanto o código estiver sendo carregado.
+## Lifespan { #lifespan }
 
-## Vida útil (_Lifespan_)
+Você pode definir essa lógica de *inicialização* e *encerramento* usando o parâmetro `lifespan` da aplicação `FastAPI`, e um "gerenciador de contexto" (vou mostrar o que é isso em um segundo).
 
-Você pode definir essa lógica de *inicialização* e *encerramento* usando os parâmetros de `lifespan` da aplicação `FastAPI`, e um "gerenciador de contexto" (te mostrarei o que é isso a seguir).
+Vamos começar com um exemplo e depois ver em detalhes.
 
-Vamos iniciar com um exemplo e ver isso detalhadamente.
-
-Nós criamos uma função assíncrona chamada `lifespan()` com `yield` como este:
+Nós criamos uma função assíncrona `lifespan()` com `yield` assim:
 
 {* ../../docs_src/events/tutorial003.py hl[16,19] *}
 
-Aqui nós estamos simulando a *inicialização* custosa do carregamento do modelo colocando a (falsa) função de modelo no dicionário com modelos de _machine learning_ antes do `yield`. Este código será executado **antes** da aplicação **começar a receber requisições**, durante a *inicialização*.
+Aqui estamos simulando a operação de *inicialização* custosa de carregar o modelo, colocando a (falsa) função do modelo no dicionário com modelos de machine learning antes do `yield`. Esse código será executado **antes** de a aplicação **começar a receber requisições**, durante a *inicialização*.
 
-E então, logo após o `yield`, descarregaremos o modelo. Esse código será executado **após** a aplicação **terminar de lidar com as requisições**, pouco antes do *encerramento*. Isso poderia, por exemplo, liberar recursos como memória ou GPU.
+E então, logo após o `yield`, descarregamos o modelo. Esse código será executado **depois** de a aplicação **terminar de lidar com as requisições**, pouco antes do *encerramento*. Isso poderia, por exemplo, liberar recursos como memória ou uma GPU.
 
 /// tip | Dica
 
 O `shutdown` aconteceria quando você estivesse **encerrando** a aplicação.
 
-Talvez você precise inicializar uma nova versão, ou apenas cansou de executá-la. 🤷
+Talvez você precise iniciar uma nova versão, ou apenas cansou de executá-la. 🤷
 
 ///
 
-### Função _lifespan_
+### Função lifespan { #lifespan-function }
 
-A primeira coisa a notar, é que estamos definindo uma função assíncrona com `yield`. Isso é muito semelhante à Dependências com `yield`.
+A primeira coisa a notar é que estamos definindo uma função assíncrona com `yield`. Isso é muito semelhante a Dependências com `yield`.
 
 {* ../../docs_src/events/tutorial003.py hl[14:19] *}
 
-A primeira parte da função, antes do `yield`, será  executada **antes** da aplicação inicializar.
+A primeira parte da função, antes do `yield`, será executada **antes** de a aplicação iniciar.
 
-E a parte posterior do `yield` irá executar **após** a aplicação ser encerrada.
+E a parte posterior ao `yield` será executada **depois** de a aplicação ter terminado.
 
-### Gerenciador de Contexto Assíncrono
+### Gerenciador de contexto assíncrono { #async-context-manager }
 
 Se você verificar, a função está decorada com um `@asynccontextmanager`.
 
-Que converte a função em algo chamado de "**Gerenciador de Contexto Assíncrono**".
+Isso converte a função em algo chamado "**gerenciador de contexto assíncrono**".
 
 {* ../../docs_src/events/tutorial003.py hl[1,13] *}
 
@@ -70,97 +69,97 @@ with open("file.txt") as file:
     file.read()
 ```
 
-Nas versões mais recentes de Python, há também um **gerenciador de contexto assíncrono**. Você o usaria com `async with`:
+Em versões mais recentes do Python, há também um **gerenciador de contexto assíncrono**. Você o usaria com `async with`:
 
 ```Python
 async with lifespan(app):
     await do_stuff()
 ```
 
-Quando você cria um gerenciador de contexto ou um gerenciador de contexto assíncrono como mencionado acima, o que ele faz é que, antes de entrar no bloco `with`, ele irá executar o código anterior ao `yield`, e depois de sair do bloco `with`, ele irá executar o código depois do `yield`.
+Quando você cria um gerenciador de contexto ou um gerenciador de contexto assíncrono como acima, o que ele faz é: antes de entrar no bloco `with`, ele executa o código antes do `yield`, e após sair do bloco `with`, ele executa o código depois do `yield`.
 
-No nosso exemplo de código acima, nós não usamos ele diretamente, mas nós passamos para o FastAPI para ele usá-lo.
+No nosso exemplo de código acima, não o usamos diretamente, mas passamos para o FastAPI para que ele o use.
 
-O parâmetro `lifespan` da aplicação `FastAPI` usa um **Gerenciador de Contexto Assíncrono**, então nós podemos passar nosso novo gerenciador de contexto assíncrono do `lifespan` para ele.
+O parâmetro `lifespan` da aplicação `FastAPI` aceita um **gerenciador de contexto assíncrono**, então podemos passar para ele nosso novo gerenciador de contexto assíncrono `lifespan`.
 
 {* ../../docs_src/events/tutorial003.py hl[22] *}
 
-## Eventos alternativos (deprecados)
+## Eventos alternativos (descontinuados) { #alternative-events-deprecated }
 
-/// warning | Aviso
+/// warning | Atenção
 
-A maneira recomendada para lidar com a *inicialização* e o *encerramento* é usando o parâmetro `lifespan` da aplicação `FastAPI` como descrito acima.
+A forma recomendada de lidar com a *inicialização* e o *encerramento* é usando o parâmetro `lifespan` da aplicação `FastAPI`, como descrito acima. Se você fornecer um parâmetro `lifespan`, os manipuladores de eventos `startup` e `shutdown` não serão mais chamados. É tudo `lifespan` ou tudo por eventos, não ambos.
 
-Você provavelmente pode pular essa parte.
+Você provavelmente pode pular esta parte.
 
 ///
 
-Existe uma forma alternativa para definir a execução dessa lógica durante *inicialização* e durante *encerramento*.
+Existe uma forma alternativa de definir essa lógica para ser executada durante a *inicialização* e durante o *encerramento*.
 
-Você pode definir manipuladores de eventos (funções) que precisam ser executadas antes da aplicação inicializar, ou quando a aplicação estiver encerrando.
+Você pode definir manipuladores de eventos (funções) que precisam ser executados antes de a aplicação iniciar ou quando a aplicação estiver encerrando.
 
 Essas funções podem ser declaradas com `async def` ou `def` normal.
 
-### Evento `startup`
+### Evento `startup` { #startup-event }
 
-Para adicionar uma função que deve rodar antes da aplicação iniciar, declare-a com o evento `"startup"`:
+Para adicionar uma função que deve rodar antes de a aplicação iniciar, declare-a com o evento `"startup"`:
 
 {* ../../docs_src/events/tutorial001.py hl[8] *}
 
-Nesse caso, a função de manipulação de evento `startup` irá inicializar os itens do "banco de dados" (só um `dict`) com alguns valores.
+Nesse caso, a função de manipulador do evento `startup` inicializará os itens do "banco de dados" (apenas um `dict`) com alguns valores.
 
-Você pode adicionar mais que uma função de manipulação de evento.
+Você pode adicionar mais de uma função de manipulador de eventos.
 
-E sua aplicação não irá começar a receber requisições até que todos os manipuladores de eventos de `startup` sejam concluídos.
+E sua aplicação não começará a receber requisições até que todos os manipuladores de eventos `startup` sejam concluídos.
 
-### Evento `shutdown`
+### Evento `shutdown` { #shutdown-event }
 
-Para adicionar uma função que deve ser executada quando a aplicação estiver encerrando, declare ela com o evento `"shutdown"`:
+Para adicionar uma função que deve ser executada quando a aplicação estiver encerrando, declare-a com o evento `"shutdown"`:
 
 {* ../../docs_src/events/tutorial002.py hl[6] *}
 
-Aqui, a função de manipulação de evento `shutdown` irá escrever uma linha de texto `"Application shutdown"` no arquivo `log.txt`.
+Aqui, a função de manipulador do evento `shutdown` escreverá uma linha de texto `"Application shutdown"` no arquivo `log.txt`.
 
 /// info | Informação
 
-Na função `open()`, o `mode="a"` significa "acrescentar", então, a linha irá ser adicionada depois de qualquer coisa que esteja naquele arquivo, sem sobrescrever o conteúdo anterior.
+Na função `open()`, o `mode="a"` significa "acrescentar", então a linha será adicionada depois do que já estiver naquele arquivo, sem sobrescrever o conteúdo anterior.
 
 ///
 
 /// tip | Dica
 
-Perceba que nesse caso nós estamos usando a função padrão do Python `open()` que interage com um arquivo.
+Perceba que, nesse caso, estamos usando a função padrão do Python `open()` que interage com um arquivo.
 
-Então, isso envolve I/O (input/output), que exige "esperar" que coisas sejam escritas em disco.
+Então, isso envolve I/O (input/output), que requer "esperar" que as coisas sejam escritas em disco.
 
 Mas `open()` não usa `async` e `await`.
 
-Então, nós declaramos uma função de manipulação de evento com o padrão `def` ao invés de `async def`.
+Assim, declaramos a função de manipulador de evento com `def` padrão em vez de `async def`.
 
 ///
 
-### `startup` e `shutdown` juntos
+### `startup` e `shutdown` juntos { #startup-and-shutdown-together }
 
-Há uma grande chance que a lógica para sua *inicialização* e *encerramento* esteja conectada, você pode querer iniciar alguma coisa e então finalizá-la, adquirir um recurso e então liberá-lo, etc.
+Há uma grande chance de que a lógica para sua *inicialização* e *encerramento* esteja conectada, você pode querer iniciar alguma coisa e então finalizá-la, adquirir um recurso e então liberá-lo, etc.
 
-Fazendo isso em funções separadas que não compartilham lógica ou variáveis entre elas é mais difícil já que você precisa armazenar os valores em variáveis globais ou truques parecidos.
+Fazer isso em funções separadas que não compartilham lógica ou variáveis entre si é mais difícil, pois você precisaria armazenar valores em variáveis globais ou truques semelhantes.
 
-Por causa disso, agora é recomendado em vez disso usar o `lifespan` como explicado acima.
+Por causa disso, agora é recomendado usar o `lifespan`, como explicado acima.
 
-## Detalhes técnicos
+## Detalhes técnicos { #technical-details }
 
-Só um detalhe técnico para nerds curiosos. 🤓
+Apenas um detalhe técnico para nerds curiosos. 🤓
 
-Por baixo, na especificação técnica ASGI, essa é a parte do <a href="https://asgi.readthedocs.io/en/latest/specs/lifespan.html" class="external-link" target="_blank">Protocolo Lifespan</a>, e define eventos chamados `startup` e `shutdown`.
+Por baixo, na especificação técnica do ASGI, isso é parte do <a href="https://asgi.readthedocs.io/en/latest/specs/lifespan.html" class="external-link" target="_blank">Protocolo Lifespan</a>, e define eventos chamados `startup` e `shutdown`.
 
 /// info | Informação
 
-Você pode ler mais sobre o manipulador `lifespan` do Starlette na <a href="https://www.starlette.dev/lifespan/" class="external-link" target="_blank">Documentação do Lifespan Starlette</a>.
+Você pode ler mais sobre os manipuladores de `lifespan` do Starlette na <a href="https://www.starlette.dev/lifespan/" class="external-link" target="_blank">Documentação do Lifespan do Starlette</a>.
 
-Incluindo como manipular estado do lifespan que pode ser usado em outras áreas do seu código.
+Incluindo como lidar com estado do lifespan que pode ser usado em outras áreas do seu código.
 
 ///
 
-## Sub Aplicações
+## Sub Aplicações { #sub-applications }
 
-🚨 Tenha em mente que esses eventos de lifespan (de inicialização e desligamento) irão somente ser executados para a aplicação principal, não para [Sub Aplicações - Montagem](sub-applications.md){.internal-link target=_blank}.
+🚨 Tenha em mente que esses eventos de lifespan (inicialização e encerramento) serão executados apenas para a aplicação principal, não para [Sub Aplicações - Montagem](sub-applications.md){.internal-link target=_blank}.

docs/pt/docs/advanced/generate-clients.md

@@ -1,115 +1,76 @@
-# Generate Clients
+# Gerando SDKs { #generating-sdks }
 
-Como o **FastAPI** é baseado na especificação **OpenAPI**, você obtém compatibilidade automática com muitas ferramentas, incluindo a documentação automática da API (fornecida pelo Swagger UI).
+Como o **FastAPI** é baseado na especificação **OpenAPI**, suas APIs podem ser descritas em um formato padrão que muitas ferramentas entendem.
 
-Uma vantagem particular que nem sempre é óbvia é que você pode **gerar clientes** (às vezes chamados de <abbr title="Software Development Kits">**SDKs**</abbr>) para a sua API, para muitas **linguagens de programação** diferentes.
+Isso facilita gerar **documentação** atualizada, bibliotecas clientes (<abbr title="Software Development Kits – Kits de Desenvolvimento de Software">**SDKs**</abbr>) em várias linguagens e **testes** ou **fluxos de trabalho de automação** que permanecem em sincronia com o seu código.
 
-## Geradores de Clientes OpenAPI
+Neste guia, você aprenderá como gerar um **SDK em TypeScript** para o seu backend FastAPI.
 
-Existem muitas ferramentas para gerar clientes a partir do **OpenAPI**.
+## Geradores de SDK de código aberto { #open-source-sdk-generators }
 
-Uma ferramenta comum é o <a href="https://openapi-generator.tech/" class="external-link" target="_blank">OpenAPI Generator</a>.
+Uma opção versátil é o <a href="https://openapi-generator.tech/" class="external-link" target="_blank">OpenAPI Generator</a>, que suporta **muitas linguagens de programação** e pode gerar SDKs a partir da sua especificação OpenAPI.
 
-Se voce está construindo um **frontend**, uma alternativa muito interessante é o <a href="https://github.com/hey-api/openapi-ts" class="external-link" target="_blank">openapi-ts</a>.
+Para **clientes TypeScript**, o <a href="https://heyapi.dev/" class="external-link" target="_blank">Hey API</a> é uma solução feita sob medida, oferecendo uma experiência otimizada para o ecossistema TypeScript.
 
-## Geradores de Clientes e SDKs - Patrocinadores
+Você pode descobrir mais geradores de SDK em <a href="https://openapi.tools/#sdk" class="external-link" target="_blank">OpenAPI.Tools</a>.
 
-Existem também alguns geradores de clientes e SDKs baseados na OpenAPI (FastAPI) **patrocinados por empresas**, em alguns casos eles podem oferecer **recursos adicionais** além de SDKs/clientes gerados de alta qualidade.
+/// tip | Dica
 
-Alguns deles também ✨ [**patrocinam o FastAPI**](../help-fastapi.md#sponsor-the-author){.internal-link target=_blank} ✨, isso garante o **desenvolvimento** contínuo e saudável do FastAPI e seu **ecossistema**.
+O FastAPI gera automaticamente especificações **OpenAPI 3.1**, então qualquer ferramenta que você usar deve suportar essa versão.
 
-E isso mostra o verdadeiro compromisso deles com o FastAPI e sua **comunidade** (você), pois eles não apenas querem fornecer um **bom serviço**, mas também querem garantir que você tenha um **framework bom e saudável**, o FastAPI. 🙇
+///
+
+## Geradores de SDK dos patrocinadores do FastAPI { #sdk-generators-from-fastapi-sponsors }
+
+Esta seção destaca soluções **financiadas por investimento** e **com suporte de empresas** que patrocinam o FastAPI. Esses produtos fornecem **funcionalidades adicionais** e **integrações** além de SDKs gerados com alta qualidade.
+
+Ao ✨ [**patrocinar o FastAPI**](../help-fastapi.md#sponsor-the-author){.internal-link target=_blank} ✨, essas empresas ajudam a garantir que o framework e seu **ecossistema** continuem saudáveis e **sustentáveis**.
+
+O patrocínio também demonstra um forte compromisso com a **comunidade** FastAPI (você), mostrando que elas se importam não apenas em oferecer um **ótimo serviço**, mas também em apoiar um **framework robusto e próspero**, o FastAPI. 🙇
 
 Por exemplo, você pode querer experimentar:
 
 * <a href="https://speakeasy.com/editor?utm_source=fastapi+repo&utm_medium=github+sponsorship" class="external-link" target="_blank">Speakeasy</a>
-* <a href="https://www.stainlessapi.com/?utm_source=fastapi&utm_medium=referral" class="external-link" target="_blank">Stainless</a>
-* <a href="https://developers.liblab.com/tutorials/sdk-for-fastapi/?utm_source=fastapi" class="external-link" target="_blank">liblab</a>
+* <a href="https://www.stainless.com/?utm_source=fastapi&utm_medium=referral" class="external-link" target="_blank">Stainless</a>
+* <a href="https://developers.liblab.com/tutorials/sdk-for-fastapi?utm_source=fastapi" class="external-link" target="_blank">liblab</a>
 
-Existem também várias outras empresas que oferecem serviços semelhantes que você pode pesquisar e encontrar online. 🤓
+Algumas dessas soluções também podem ser open source ou oferecer planos gratuitos, para que você possa testá-las sem compromisso financeiro. Outros geradores comerciais de SDK estão disponíveis e podem ser encontrados online. 🤓
 
-## Gerar um Cliente Frontend TypeScript
+## Crie um SDK em TypeScript { #create-a-typescript-sdk }
 
-Vamos começar com um aplicativo **FastAPI** simples:
+Vamos começar com uma aplicação FastAPI simples:
 
 {* ../../docs_src/generate_clients/tutorial001_py39.py hl[7:9,12:13,16:17,21] *}
 
 Note que as *operações de rota* definem os modelos que usam para o corpo da requisição e o corpo da resposta, usando os modelos `Item` e `ResponseMessage`.
 
-### Documentação da API
+### Documentação da API { #api-docs }
 
-Se você acessar a documentação da API, verá que ela tem os **schemas** para os dados a serem enviados nas requisições e recebidos nas respostas:
+Se você for para `/docs`, verá que ela tem os **schemas** para os dados a serem enviados nas requisições e recebidos nas respostas:
 
 <img src="/img/tutorial/generate-clients/image01.png">
 
 Você pode ver esses schemas porque eles foram declarados com os modelos no app.
 
-Essas informações estão disponíveis no **OpenAPI schema** do app e são mostradas na documentação da API (pelo Swagger UI).
+Essas informações estão disponíveis no **schema OpenAPI** do app e são mostradas na documentação da API.
 
 E essas mesmas informações dos modelos que estão incluídas no OpenAPI são o que pode ser usado para **gerar o código do cliente**.
 
-### Gerar um Cliente TypeScript
+### Hey API { #hey-api }
 
-Agora que temos o app com os modelos, podemos gerar o código do cliente para o frontend.
+Depois que tivermos uma aplicação FastAPI com os modelos, podemos usar o Hey API para gerar um cliente TypeScript. A forma mais rápida é via npx.
 
-#### Instalar o `openapi-ts`
-
-Você pode instalar o `openapi-ts` no seu código frontend com:
-
-<div class="termy">
-
-```console
-$ npm install @hey-api/openapi-ts --save-dev
-
----> 100%
+```sh
+npx @hey-api/openapi-ts -i http://localhost:8000/openapi.json -o src/client
 ```
 
-</div>
+Isso gerará um SDK TypeScript em `./src/client`.
 
-#### Gerar o Código do Cliente
+Você pode aprender como <a href="https://heyapi.dev/openapi-ts/get-started" class="external-link" target="_blank">instalar `@hey-api/openapi-ts`</a> e ler sobre o <a href="https://heyapi.dev/openapi-ts/output" class="external-link" target="_blank">resultado gerado</a> no site deles.
 
-Para gerar o código do cliente, você pode usar a aplicação de linha de comando `openapi-ts` que agora está instalada.
+### Usando o SDK { #using-the-sdk }
 
-Como ela está instalada no projeto local, você provavelmente não conseguiria chamar esse comando diretamente, mas você o colocaria no seu arquivo `package.json`.
-
-Poderia ser assim:
-
-```JSON  hl_lines="7"
-{
-  "name": "frontend-app",
-  "version": "1.0.0",
-  "description": "",
-  "main": "index.js",
-  "scripts": {
-    "generate-client": "openapi-ts --input http://localhost:8000/openapi.json --output ./src/client --client axios"
-  },
-  "author": "",
-  "license": "",
-  "devDependencies": {
-    "@hey-api/openapi-ts": "^0.27.38",
-    "typescript": "^4.6.2"
-  }
-}
-```
-
-Depois de ter esse script NPM `generate-client` lá, você pode executá-lo com:
-
-<div class="termy">
-
-```console
-$ npm run generate-client
-
-frontend-app@1.0.0 generate-client /home/user/code/frontend-app
-> openapi-ts --input http://localhost:8000/openapi.json --output ./src/client --client axios
-```
-
-</div>
-
-Esse comando gerará o código em `./src/client` e usará o `axios` (a biblioteca HTTP frontend) internamente.
-
-### Experimente o Código do Cliente
-
-Agora você pode importar e usar o código do cliente, ele poderia ser assim, observe que você obtém preenchimento automático para os métodos:
+Agora você pode importar e usar o código do cliente. Poderia ser assim, observe que você obtém preenchimento automático para os métodos:
 
 <img src="/img/tutorial/generate-clients/image02.png">
 
@@ -119,7 +80,7 @@ Você também obterá preenchimento automático para o corpo a ser enviado:
 
 /// tip | Dica
 
-Observe o preenchimento automático para `name` e `price`, que foi definido no aplicativo FastAPI, no modelo `Item`.
+Observe o preenchimento automático para `name` e `price`, que foi definido na aplicação FastAPI, no modelo `Item`.
 
 ///
 
@@ -131,17 +92,17 @@ O objeto de resposta também terá preenchimento automático:
 
 <img src="/img/tutorial/generate-clients/image05.png">
 
-## App FastAPI com Tags
+## Aplicação FastAPI com Tags { #fastapi-app-with-tags }
 
-Em muitos casos seu app FastAPI será maior, e você provavelmente usará tags para separar diferentes grupos de *operações de rota*.
+Em muitos casos, sua aplicação FastAPI será maior, e você provavelmente usará tags para separar diferentes grupos de *operações de rota*.
 
 Por exemplo, você poderia ter uma seção para **items** e outra seção para **users**, e elas poderiam ser separadas por tags:
 
 {* ../../docs_src/generate_clients/tutorial002_py39.py hl[21,26,34] *}
 
-### Gerar um Cliente TypeScript com Tags
+### Gere um cliente TypeScript com Tags { #generate-a-typescript-client-with-tags }
 
-Se você gerar um cliente para um app FastAPI usando tags, normalmente também separará o código do cliente com base nas tags.
+Se você gerar um cliente para uma aplicação FastAPI usando tags, normalmente também separará o código do cliente com base nas tags.
 
 Dessa forma, você poderá ter as coisas ordenadas e agrupadas corretamente para o código do cliente:
 
@@ -152,33 +113,33 @@ Nesse caso você tem:
 * `ItemsService`
 * `UsersService`
 
-### Nomes dos Métodos do Cliente
+### Nomes dos métodos do cliente { #client-method-names }
 
-Agora os nomes dos métodos gerados como `createItemItemsPost` não parecem muito "limpos":
+Agora os nomes dos métodos gerados como `createItemItemsPost` não parecem muito “limpos”:
 
 ```TypeScript
 ItemsService.createItemItemsPost({name: "Plumbus", price: 5})
 ```
 
-...isto ocorre porque o gerador de clientes usa o **operation ID** interno do OpenAPI para cada *operação de rota*.
+...isso ocorre porque o gerador de clientes usa o **ID de operação** interno do OpenAPI para cada *operação de rota*.
 
-O OpenAPI exige que cada operation ID seja único em todas as *operações de rota*, então o FastAPI usa o **nome da função**, o **caminho** e o **método/operacao HTTP** para gerar esse operation ID, porque dessa forma ele pode garantir que os operation IDs sejam únicos.
+O OpenAPI exige que cada ID de operação seja único em todas as *operações de rota*, então o FastAPI usa o **nome da função**, o **path** e o **método/operação HTTP** para gerar esse ID de operação, porque dessa forma ele pode garantir que os IDs de operação sejam únicos.
 
 Mas eu vou te mostrar como melhorar isso a seguir. 🤓
 
-### IDs de Operação Personalizados e Melhores Nomes de Método
+## IDs de operação personalizados e nomes de métodos melhores { #custom-operation-ids-and-better-method-names }
 
 Você pode **modificar** a maneira como esses IDs de operação são **gerados** para torná-los mais simples e ter **nomes de método mais simples** nos clientes.
 
 Neste caso, você terá que garantir que cada ID de operação seja **único** de alguma outra maneira.
 
-Por exemplo, você poderia garantir que cada *operação de rota* tenha uma tag, e então gerar o ID da operação com base na **tag** e no **nome** da *operação de rota* (o nome da função).
+Por exemplo, você poderia garantir que cada *operação de rota* tenha uma tag, e então gerar o ID de operação com base na **tag** e no **nome** da *operação de rota* (o nome da função).
 
-### Função Personalizada para Gerar IDs de Operação Únicos
+### Função personalizada para gerar IDs exclusivos { #custom-generate-unique-id-function }
 
-O FastAPI usa um **ID único** para cada *operação de rota*, ele é usado para o **ID da operação** e também para os nomes de quaisquer modelos personalizados necessários, para requisições ou respostas.
+O FastAPI usa um **ID exclusivo** para cada *operação de rota*, ele é usado para o **ID de operação** e também para os nomes de quaisquer modelos personalizados necessários, para requisições ou respostas.
 
-Você pode personalizar essa função. Ela recebe uma `APIRoute` e gera uma string.
+Você pode personalizar essa função. Ela recebe uma `APIRoute` e retorna uma string.
 
 Por exemplo, aqui está usando a primeira tag (você provavelmente terá apenas uma tag) e o nome da *operação de rota* (o nome da função).
 
@@ -186,15 +147,15 @@ Você pode então passar essa função personalizada para o **FastAPI** como o p
 
 {* ../../docs_src/generate_clients/tutorial003_py39.py hl[6:7,10] *}
 
-### Gerar um Cliente TypeScript com IDs de Operação Personalizados
+### Gere um cliente TypeScript com IDs de operação personalizados { #generate-a-typescript-client-with-custom-operation-ids }
 
 Agora, se você gerar o cliente novamente, verá que ele tem os nomes dos métodos melhorados:
 
 <img src="/img/tutorial/generate-clients/image07.png">
 
-Como você pode ver, os nomes dos métodos agora têm a tag e, em seguida, o nome da função. Agora eles não incluem informações do caminho da URL e da operação HTTP.
+Como você pode ver, os nomes dos métodos agora têm a tag e, em seguida, o nome da função. Agora eles não incluem informações do path da URL e da operação HTTP.
 
-### Pré-processar a Especificação OpenAPI para o Gerador de Clientes
+### Pré-processar a especificação OpenAPI para o gerador de clientes { #preprocess-the-openapi-specification-for-the-client-generator }
 
 O código gerado ainda tem algumas **informações duplicadas**.
 
@@ -202,7 +163,7 @@ Nós já sabemos que esse método está relacionado aos **items** porque essa pa
 
 Provavelmente ainda queremos mantê-lo para o OpenAPI em geral, pois isso garantirá que os IDs de operação sejam **únicos**.
 
-Mas para o cliente gerado, poderíamos **modificar** os IDs de operação do OpenAPI logo antes de gerar os clientes, apenas para tornar esses nomes de método mais **simples**.
+Mas para o cliente gerado, poderíamos **modificar** os IDs de operação do OpenAPI logo antes de gerar os clientes, apenas para tornar esses nomes de método mais agradáveis e **limpos**.
 
 Poderíamos baixar o JSON do OpenAPI para um arquivo `openapi.json` e então poderíamos **remover essa tag prefixada** com um script como este:
 
@@ -218,44 +179,30 @@ Poderíamos baixar o JSON do OpenAPI para um arquivo `openapi.json` e então pod
 
 Com isso, os IDs de operação seriam renomeados de coisas como `items-get_items` para apenas `get_items`, dessa forma o gerador de clientes pode gerar nomes de métodos mais simples.
 
-### Gerar um Cliente TypeScript com o OpenAPI Pré-processado
+### Gere um cliente TypeScript com o OpenAPI pré-processado { #generate-a-typescript-client-with-the-preprocessed-openapi }
 
-Agora, como o resultado final está em um arquivo `openapi.json`, você modificaria o `package.json` para usar esse arquivo local, por exemplo:
+Como o resultado final está agora em um arquivo `openapi.json`, você precisa atualizar o local de entrada:
 
-```JSON  hl_lines="7"
-{
-  "name": "frontend-app",
-  "version": "1.0.0",
-  "description": "",
-  "main": "index.js",
-  "scripts": {
-    "generate-client": "openapi-ts --input ./openapi.json --output ./src/client --client axios"
-  },
-  "author": "",
-  "license": "",
-  "devDependencies": {
-    "@hey-api/openapi-ts": "^0.27.38",
-    "typescript": "^4.6.2"
-  }
-}
+```sh
+npx @hey-api/openapi-ts -i ./openapi.json -o src/client
 ```
 
-Depois de gerar o novo cliente, você teria agora **nomes de métodos "limpos"**, com todo o **preenchimento automático**, **erros em linha**, etc:
+Depois de gerar o novo cliente, você terá agora **nomes de métodos “limpos”**, com todo o **preenchimento automático**, **erros em linha**, etc:
 
 <img src="/img/tutorial/generate-clients/image08.png">
 
-## Benefícios
+## Benefícios { #benefits }
 
-Ao usar os clientes gerados automaticamente, você teria **preenchimento automático** para:
+Ao usar os clientes gerados automaticamente, você terá **preenchimento automático** para:
 
 * Métodos.
-* Corpo de requisições, parâmetros da query, etc.
-* Corpo de respostas.
+* Corpos de requisições, parâmetros de query, etc.
+* Corpos de respostas.
 
-Você também teria **erros em linha** para tudo.
+Você também terá **erros em linha** para tudo.
 
-E sempre que você atualizar o código do backend, e **regenerar** o frontend, ele teria quaisquer novas *operações de rota* disponíveis como métodos, as antigas removidas, e qualquer outra alteração seria refletida no código gerado. 🤓
+E sempre que você atualizar o código do backend e **regenerar** o frontend, ele terá quaisquer novas *operações de rota* disponíveis como métodos, as antigas removidas, e qualquer outra alteração será refletida no código gerado. 🤓
 
-Isso também significa que se algo mudar, será **refletido** no código do cliente automaticamente. E se você **construir** o cliente, ele dará erro se houver alguma **incompatibilidade** nos dados usados.
+Isso também significa que, se algo mudou, será **refletido** no código do cliente automaticamente. E se você **construir** o cliente, ele falhará caso haja qualquer **incompatibilidade** nos dados usados.
 
-Então, você **detectaria vários erros** muito cedo no ciclo de desenvolvimento, em vez de ter que esperar que os erros apareçam para seus usuários finais em produção e então tentar depurar onde está o problema. ✨
+Assim, você **detectará muitos erros** muito cedo no ciclo de desenvolvimento, em vez de ter que esperar que os erros apareçam para seus usuários finais em produção e então tentar depurar onde está o problema. ✨

docs/pt/docs/advanced/index.md

@@ -1,10 +1,10 @@
-# Guia de Usuário Avançado
+# Guia de Usuário Avançado { #advanced-user-guide }
 
-## Recursos Adicionais
+## Recursos Adicionais { #additional-features }
 
 O [Tutorial - Guia de Usuário](../tutorial/index.md){.internal-link target=_blank} deve ser o suficiente para dar a você um tour por todos os principais recursos do **FastAPI**.
 
-Na próxima seção você verá outras opções, configurações, e recursos adicionais.
+Nas próximas seções você verá outras opções, configurações, e recursos adicionais.
 
 /// tip | Dica
 
@@ -14,14 +14,8 @@ E é possível que para seu caso de uso, a solução esteja em uma delas.
 
 ///
 
-## Leia o Tutorial primeiro
+## Leia o Tutorial primeiro { #read-the-tutorial-first }
 
 Você ainda pode usar a maior parte dos recursos no **FastAPI** com o conhecimento do [Tutorial - Guia de Usuário](../tutorial/index.md){.internal-link target=_blank}.
 
 E as próximas seções assumem que você já leu ele, e que você conhece suas ideias principais.
-
-## Curso TestDriven.io
-
-Se você gostaria de fazer um curso avançado-iniciante para complementar essa seção da documentação, você pode querer conferir: <a href="https://testdriven.io/courses/tdd-fastapi/" class="external-link" target="_blank">Test-Driven Development com FastAPI e Docker</a> por **TestDriven.io**.
-
-Eles estão atualmente doando 10% de todos os lucros para o desenvolvimento do **FastAPI**. 🎉 😄

docs/pt/docs/advanced/middleware.md

@@ -1,4 +1,4 @@
-# Middleware Avançado
+# Middleware Avançado { #advanced-middleware }
 
 No tutorial principal você leu como adicionar [Middleware Personalizado](../tutorial/middleware.md){.internal-link target=_blank} à sua aplicação.
 
@@ -6,9 +6,9 @@ E então você também leu como lidar com [CORS com o `CORSMiddleware`](../tutor
 
 Nesta seção, veremos como usar outros middlewares.
 
-## Adicionando middlewares ASGI
+## Adicionando middlewares ASGI { #adding-asgi-middlewares }
 
-Como o **FastAPI** é baseado no Starlette e implementa a especificação <abbr title="Asynchronous Server Gateway Interface">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.
 
@@ -39,19 +39,19 @@ app.add_middleware(UnicornMiddleware, some_config="rainbow")
 
 `app.add_middleware()` recebe uma classe de middleware como o primeiro argumento e quaisquer argumentos adicionais a serem passados para o middleware.
 
-## Middlewares Integrados
+## Middlewares Integrados { #integrated-middlewares }
 
 **FastAPI** inclui vários middlewares para casos de uso comuns, veremos a seguir como usá-los.
 
 /// note | Detalhes Técnicos
 
-Para o próximo exemplo, você também poderia usar `from starlette.middleware.something import SomethingMiddleware`.
+Para os próximos exemplos, você também poderia usar `from starlette.middleware.something import SomethingMiddleware`.
 
 **FastAPI** fornece vários middlewares em `fastapi.middleware` apenas como uma conveniência para você, o desenvolvedor. Mas a maioria dos middlewares disponíveis vem diretamente do Starlette.
 
 ///
 
-## `HTTPSRedirectMiddleware`
+## `HTTPSRedirectMiddleware` { #httpsredirectmiddleware }
 
 Garante que todas as requisições devem ser `https` ou `wss`.
 
@@ -59,7 +59,7 @@ Qualquer requisição para `http` ou `ws` será redirecionada para o esquema seg
 
 {* ../../docs_src/advanced_middleware/tutorial001.py hl[2,6] *}
 
-## `TrustedHostMiddleware`
+## `TrustedHostMiddleware` { #trustedhostmiddleware }
 
 Garante que todas as requisições recebidas tenham um cabeçalho `Host` corretamente configurado, a fim de proteger contra ataques de cabeçalho de host HTTP.
 
@@ -68,10 +68,11 @@ Garante que todas as requisições recebidas tenham um cabeçalho `Host` correta
 Os seguintes argumentos são suportados:
 
 * `allowed_hosts` - Uma lista de nomes de domínio que são permitidos como nomes de host. Domínios com coringa, como `*.example.com`, são suportados para corresponder a subdomínios. Para permitir qualquer nome de host, use `allowed_hosts=["*"]` ou omita o middleware.
+* `www_redirect` - Se definido como True, as requisições para versões sem www dos hosts permitidos serão redirecionadas para suas versões com www. O padrão é `True`.
 
 Se uma requisição recebida não for validada corretamente, uma resposta `400` será enviada.
 
-## `GZipMiddleware`
+## `GZipMiddleware` { #gzipmiddleware }
 
 Gerencia respostas GZip para qualquer requisição que inclua `"gzip"` no cabeçalho `Accept-Encoding`.
 
@@ -84,7 +85,7 @@ Os seguintes argumentos são suportados:
 * `minimum_size` - Não comprima respostas menores que este tamanho mínimo em bytes. O padrão é `500`.
 * `compresslevel` - Usado durante a compressão GZip. É um inteiro variando de 1 a 9. O padrão é `9`. Um valor menor resulta em uma compressão mais rápida, mas em arquivos maiores, enquanto um valor maior resulta em uma compressão mais lenta, mas em arquivos menores.
 
-## Outros middlewares
+## Outros middlewares { #other-middlewares }
 
 Há muitos outros middlewares ASGI.
 

docs/pt/docs/advanced/openapi-callbacks.md

@@ -1,29 +1,29 @@
-# Callbacks na OpenAPI
+# Callbacks na OpenAPI { #openapi-callbacks }
 
 Você poderia criar uma API com uma *operação de rota* que poderia acionar uma solicitação a uma *API externa* criada por outra pessoa (provavelmente o mesmo desenvolvedor que estaria *usando* sua API).
 
-O processo que acontece quando seu aplicativo de API chama a *API externa* é chamado de "callback". Porque o software que o desenvolvedor externo escreveu envia uma solicitação para sua API e então sua API *chama de volta*, enviando uma solicitação para uma *API externa* (que provavelmente foi criada pelo mesmo desenvolvedor).
+O processo que acontece quando sua aplicação de API chama a *API externa* é chamado de "callback". Porque o software que o desenvolvedor externo escreveu envia uma solicitação para sua API e então sua API *chama de volta*, enviando uma solicitação para uma *API externa* (que provavelmente foi criada pelo mesmo desenvolvedor).
 
 Nesse caso, você poderia querer documentar como essa API externa *deveria* ser. Que *operação de rota* ela deveria ter, que corpo ela deveria esperar, que resposta ela deveria retornar, etc.
 
-## Um aplicativo com callbacks
+## Um aplicativo com callbacks { #an-app-with-callbacks }
 
 Vamos ver tudo isso com um exemplo.
 
-Imagine que você tem um aplicativo que permite criar faturas.
+Imagine que você desenvolve um aplicativo que permite criar faturas.
 
 Essas faturas terão um `id`, `title` (opcional), `customer` e `total`.
 
-O usuário da sua API (um desenvolvedor externo) criará uma fatura em sua API com uma solicitação POST.
+O usuário da sua API (um desenvolvedor externo) criará uma fatura na sua API com uma solicitação POST.
 
 Então sua API irá (vamos imaginar):
 
-* Enviar uma solicitação de pagamento para o desenvolvedor externo.
+* Enviar a fatura para algum cliente do desenvolvedor externo.
 * Coletar o dinheiro.
 * Enviar a notificação de volta para o usuário da API (o desenvolvedor externo).
-* Isso será feito enviando uma solicitação POST (de *sua API*) para alguma *API externa* fornecida por esse desenvolvedor externo (este é o "callback").
+    * Isso será feito enviando uma solicitação POST (de *sua API*) para alguma *API externa* fornecida por esse desenvolvedor externo (este é o "callback").
 
-## O aplicativo **FastAPI** normal
+## O aplicativo **FastAPI** normal { #the-normal-fastapi-app }
 
 Vamos primeiro ver como o aplicativo da API normal se pareceria antes de adicionar o callback.
 
@@ -39,11 +39,11 @@ O parâmetro de consulta `callback_url` usa um tipo Pydantic <a href="https://do
 
 ///
 
-A única coisa nova é o argumento `callbacks=invoices_callback_router.routes` no decorador da *operação de rota*. Veremos o que é isso a seguir.
+A única novidade é o `callbacks=invoices_callback_router.routes` como argumento do decorador da *operação de rota*. Veremos o que é isso a seguir.
 
-## Documentando o callback
+## Documentando o callback { #documenting-the-callback }
 
-O código real do callback dependerá muito do seu próprio aplicativo de API.
+O código real do callback dependerá muito da sua própria aplicação de API.
 
 E provavelmente variará muito de um aplicativo para o outro.
 
@@ -58,7 +58,7 @@ Mas possivelmente a parte mais importante do callback é garantir que o usuário
 
 Então, o que faremos a seguir é adicionar o código para documentar como essa *API externa* deve ser para receber o callback de *sua API*.
 
-A documentação aparecerá na interface do Swagger em `/docs` em sua API, e permitirá que os desenvolvedores externos saibam como construir a *API externa*.
+A documentação aparecerá na Swagger UI em `/docs` na sua API, e permitirá que os desenvolvedores externos saibam como construir a *API externa*.
 
 Esse exemplo não implementa o callback em si (que poderia ser apenas uma linha de código), apenas a parte da documentação.
 
@@ -66,11 +66,11 @@ Esse exemplo não implementa o callback em si (que poderia ser apenas uma linha
 
 O callback real é apenas uma solicitação HTTP.
 
-Quando implementando o callback por você mesmo, você pode usar algo como <a href="https://www.python-httpx.org" class="external-link" target="_blank">HTTPX</a> ou <a href="https://requests.readthedocs.io/" class="external-link" target="_blank">Requisições</a>.
+Ao implementar o callback por conta própria, você pode usar algo como <a href="https://www.python-httpx.org" class="external-link" target="_blank">HTTPX</a> ou <a href="https://requests.readthedocs.io/" class="external-link" target="_blank">Requests</a>.
 
 ///
 
-## Escrevendo o código de documentação do callback
+## Escreva o código de documentação do callback { #write-the-callback-documentation-code }
 
 Esse código não será executado em seu aplicativo, nós só precisamos dele para *documentar* como essa *API externa* deveria ser.
 
@@ -80,37 +80,37 @@ Então vamos usar esse mesmo conhecimento para documentar como a *API externa* d
 
 /// tip | Dica
 
-Quando escrever o código para documentar um callback, pode ser útil imaginar que você é aquele *desenvolvedor externo*. E que você está atualmente implementando a *API externa*, não *sua API*.
+Ao escrever o código para documentar um callback, pode ser útil imaginar que você é aquele *desenvolvedor externo*. E que você está atualmente implementando a *API externa*, não *sua API*.
 
-Adotar temporariamente esse ponto de vista (do *desenvolvedor externo*) pode ajudar a sentir que é mais óbvio onde colocar os parâmetros, o modelo Pydantic para o corpo, para a resposta, etc. para essa *API externa*.
+Adotar temporariamente esse ponto de vista (do *desenvolvedor externo*) pode ajudar a perceber mais facilmente onde colocar os parâmetros, o modelo Pydantic para o corpo, para a resposta, etc. para essa *API externa*.
 
 ///
 
-### Criar um `APIRouter` para o callback
+### Crie um `APIRouter` de callback { #create-a-callback-apirouter }
 
-Primeiramente crie um novo `APIRouter` que conterá um ou mais callbacks.
+Primeiro crie um novo `APIRouter` que conterá um ou mais callbacks.
 
 {* ../../docs_src/openapi_callbacks/tutorial001.py hl[3,25] *}
 
-### Crie a *operação de rota* do callback
+### Crie a *operação de rota* do callback { #create-the-callback-path-operation }
 
 Para criar a *operação de rota* do callback, use o mesmo `APIRouter` que você criou acima.
 
-Ele deve parecer exatamente como uma *operação de rota* normal do FastAPI:
+Ela deve parecer exatamente como uma *operação de rota* normal do FastAPI:
 
-* Ele provavelmente deveria ter uma declaração do corpo que deveria receber, por exemplo. `body: InvoiceEvent`.
-* E também deveria ter uma declaração de um código de status de resposta, por exemplo. `response_model=InvoiceEventReceived`.
+* Ela provavelmente deveria ter uma declaração do corpo que deveria receber, por exemplo, `body: InvoiceEvent`.
+* E também poderia ter uma declaração da resposta que deveria retornar, por exemplo, `response_model=InvoiceEventReceived`.
 
 {* ../../docs_src/openapi_callbacks/tutorial001.py hl[16:18,21:22,28:32] *}
 
 Há 2 diferenças principais de uma *operação de rota* normal:
 
 * Ela não necessita ter nenhum código real, porque seu aplicativo nunca chamará esse código. Ele é usado apenas para documentar a *API externa*. Então, a função poderia ter apenas `pass`.
-* A *rota* pode conter uma <a href="https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#key-expression" class="external-link" target="_blank">expressão OpenAPI 3</a> (veja mais abaixo) onde pode usar variáveis com parâmetros e partes da solicitação original enviada para *sua API*.
+* O *path* pode conter uma <a href="https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#key-expression" class="external-link" target="_blank">expressão OpenAPI 3</a> (veja mais abaixo) em que pode usar variáveis com parâmetros e partes da solicitação original enviada para *sua API*.
 
-### A expressão do caminho do callback
+### A expressão do path do callback { #the-callback-path-expression }
 
-A *rota* do callback pode ter uma <a href="https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#key-expression" class="external-link" target="_blank">expressão OpenAPI 3</a> que pode conter partes da solicitação original enviada para *sua API*.
+O *path* do callback pode ter uma <a href="https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#key-expression" class="external-link" target="_blank">expressão OpenAPI 3</a> que pode conter partes da solicitação original enviada para *sua API*.
 
 Nesse caso, é a `str`:
 
@@ -163,11 +163,11 @@ Perceba como a URL de callback usada contém a URL recebida como um parâmetro d
 
 ///
 
-### Adicionar o roteador de callback
+### Adicione o roteador de callback { #add-the-callback-router }
 
-Nesse ponto você tem a(s) *operação de rota de callback* necessária(s) (a(s) que o *desenvolvedor externo* deveria implementar na *API externa*) no roteador de callback que você criou acima.
+Nesse ponto você tem a(s) *operação(ões) de rota de callback* necessária(s) (a(s) que o *desenvolvedor externo* deveria implementar na *API externa*) no roteador de callback que você criou acima.
 
-Agora use o parâmetro `callbacks` no decorador da *operação de rota de sua API* para passar o atributo `.routes` (que é na verdade apenas uma `list` de rotas/*operações de rota*) do roteador de callback que você criou acima:
+Agora use o parâmetro `callbacks` no decorador da *operação de rota da sua API* para passar o atributo `.routes` (que é na verdade apenas uma `list` de rotas/*operações de path*) do roteador de callback:
 
 {* ../../docs_src/openapi_callbacks/tutorial001.py hl[35] *}
 
@@ -177,7 +177,7 @@ Perceba que você não está passando o roteador em si (`invoices_callback_route
 
 ///
 
-### Verifique a documentação
+### Verifique a documentação { #check-the-docs }
 
 Agora você pode iniciar seu aplicativo e ir para <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>.
 

docs/pt/docs/advanced/openapi-webhooks.md

@@ -1,4 +1,4 @@
-# Webhooks OpenAPI
+# Webhooks OpenAPI { #openapi-webhooks }
 
 Existem situações onde você deseja informar os **usuários** da sua API que a sua aplicação pode chamar a aplicação *deles* (enviando uma requisição) com alguns dados, normalmente para **notificar** algum tipo de **evento**.
 
@@ -6,7 +6,7 @@ Isso significa que no lugar do processo normal de seus usuários enviarem requis
 
 Isso normalmente é chamado de **webhook**.
 
-## Etapas dos Webhooks
+## Etapas dos webhooks { #webhooks-steps }
 
 Normalmente, o processo é que **você define** em seu código qual é a mensagem que você irá mandar, o **corpo da sua requisição**.
 
@@ -16,7 +16,7 @@ E os **seus usuários** definem de alguma forma (em algum painel por exemplo) a
 
 Toda a **lógica** sobre como cadastrar as URLs para os webhooks e o código para enviar de fato as requisições cabe a você definir. Você escreve da maneira que você desejar no **seu próprio código**.
 
-## Documentando webhooks com o FastAPI e OpenAPI
+## Documentando webhooks com o FastAPI e OpenAPI { #documenting-webhooks-with-fastapi-and-openapi }
 
 Com o **FastAPI**, utilizando o OpenAPI, você pode definir os nomes destes webhooks, os tipos das operações HTTP que a sua aplicação pode enviar (e.g. `POST`, `PUT`, etc.) e os **corpos** da requisição que a sua aplicação enviaria.
 
@@ -28,7 +28,7 @@ Webhooks estão disponíveis a partir do OpenAPI 3.1.0, e possui suporte do Fast
 
 ///
 
-## Uma aplicação com webhooks
+## Uma aplicação com webhooks { #an-app-with-webhooks }
 
 Quando você cria uma aplicação com o **FastAPI**, existe um atributo chamado `webhooks`, que você utilizar para defini-los da mesma maneira que você definiria as suas **operações de rotas**, utilizando por exemplo `@app.webhooks.post()`.
 
@@ -42,11 +42,11 @@ O objeto `app.webhooks` é na verdade apenas um `APIRouter`, o mesmo tipo que vo
 
 ///
 
-Note que utilizando webhooks você não está de fato declarando uma **rota** (como `/items/`), o texto que informa é apenas um **identificador** do webhook (o nome do evento), por exemplo em `@app.webhooks.post("new-subscription")`, o nome do webhook é `new-subscription`.
+Note que utilizando webhooks você não está de fato declarando um *path* (como `/items/`), o texto que informa é apenas um **identificador** do webhook (o nome do evento), por exemplo em `@app.webhooks.post("new-subscription")`, o nome do webhook é `new-subscription`.
 
-Isto porque espera-se que os **seus usuários** definam o verdadeiro **caminho da URL** onde eles desejam receber a requisição do webhook de algum outra maneira. (e.g. um painel).
+Isto porque espera-se que os **seus usuários** definam o verdadeiro **URL path** onde eles desejam receber a requisição do webhook de algum outra maneira. (e.g. um painel).
 
-### Confira a documentação
+### Confira a documentação { #check-the-docs }
 
 Agora você pode iniciar a sua aplicação e ir até <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>.
 

docs/pt/docs/advanced/path-operation-advanced-configuration.md

@@ -1,8 +1,8 @@
-# Configuração Avançada da Operação de Rota
+# Configuração Avançada da Operação de Rota { #path-operation-advanced-configuration }
 
-## operationId do OpenAPI
+## operationId do OpenAPI { #openapi-operationid }
 
-/// warning | Aviso
+/// warning | Atenção
 
 Se você não é um "especialista" no OpenAPI, você provavelmente não precisa disso.
 
@@ -14,13 +14,13 @@ Você precisa ter certeza que ele é único para cada operação.
 
 {* ../../docs_src/path_operation_advanced_configuration/tutorial001.py hl[6] *}
 
-### Utilizando o nome da *função de operação de rota* como o operationId
+### Utilizando o nome da *função de operação de rota* como o operationId { #using-the-path-operation-function-name-as-the-operationid }
 
 Se você quiser utilizar o nome das funções da sua API como `operationId`s, você pode iterar sobre todos esses nomes e sobrescrever o `operationId` em  cada *operação de rota* utilizando o `APIRoute.name` dela.
 
 Você deve fazer isso depois de adicionar todas as suas *operações de rota*.
 
-{* ../../docs_src/path_operation_advanced_configuration/tutorial002.py hl[2,12:21,24] *}
+{* ../../docs_src/path_operation_advanced_configuration/tutorial002.py hl[2, 12:21, 24] *}
 
 /// tip | Dica
 
@@ -28,7 +28,7 @@ Se você chamar `app.openapi()` manualmente, os `operationId`s devem ser atualiz
 
 ///
 
-/// warning | Aviso
+/// warning | Atenção
 
 Se você fizer isso, você tem que ter certeza de que cada uma das suas *funções de operação de rota* tem um nome único.
 
@@ -36,13 +36,13 @@ Mesmo que elas estejam em módulos (arquivos Python) diferentes.
 
 ///
 
-## Excluir do OpenAPI
+## Excluir do OpenAPI { #exclude-from-openapi }
 
 Para excluir uma *operação de rota* do esquema OpenAPI gerado (e por consequência, dos sistemas de documentação automáticos), utilize o parâmetro `include_in_schema` e defina ele como `False`:
 
 {* ../../docs_src/path_operation_advanced_configuration/tutorial003.py hl[6] *}
 
-## Descrição avançada a partir de docstring
+## Descrição avançada a partir de docstring { #advanced-description-from-docstring }
 
 Você pode limitar as linhas utilizadas a partir de uma docstring de uma *função de operação de rota* para o OpenAPI.
 
@@ -52,7 +52,7 @@ Ele não será mostrado na documentação, mas outras ferramentas (como o Sphinx
 
 {* ../../docs_src/path_operation_advanced_configuration/tutorial004.py hl[19:29] *}
 
-## Respostas Adicionais
+## Respostas Adicionais { #additional-responses }
 
 Você provavelmente já viu como declarar o `response_model` e `status_code` para uma *operação de rota*.
 
@@ -62,11 +62,11 @@ Você também pode declarar respostas adicionais, com seus modelos, códigos de
 
 Existe um capítulo inteiro da nossa documentação sobre isso, você pode ler em [Retornos Adicionais no OpenAPI](additional-responses.md){.internal-link target=_blank}.
 
-## Extras do OpenAPI
+## Extras do OpenAPI { #openapi-extra }
 
 Quando você declara uma *operação de rota* na sua aplicação, o **FastAPI** irá gerar os metadados relevantes da *operação de rota* automaticamente para serem incluídos no esquema do OpenAPI.
 
-/// note | Nota
+/// note | Detalhes Técnicos
 
 Na especificação do OpenAPI, isso é chamado de um <a href="https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#operation-object" class="external-link" target="_blank">Objeto de Operação</a>.
 
@@ -88,7 +88,7 @@ Caso você só precise declarar respostas adicionais, uma forma conveniente de f
 
 Você pode estender o esquema do OpenAPI para uma *operação de rota* utilizando o parâmetro `openapi_extra`.
 
-### Extensões do OpenAPI
+### Extensões do OpenAPI { #openapi-extensions }
 
 Esse parâmetro `openapi_extra` pode ser útil, por exemplo, para declarar [Extensões do OpenAPI](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#specificationExtensions):
 
@@ -129,7 +129,7 @@ E se você olhar o esquema OpenAPI resultante (na rota `/openapi.json` da sua AP
 }
 ```
 
-### Esquema de *operação de rota* do OpenAPI personalizado
+### Esquema de *operação de rota* do OpenAPI personalizado { #custom-openapi-path-operation-schema }
 
 O dicionário em `openapi_extra` vai ter todos os seus níveis mesclados dentro do esquema OpenAPI gerado automaticamente para a *operação de rota*.
 
@@ -139,39 +139,39 @@ Por exemplo, você poderia optar por ler e validar a requisição com seu própr
 
 Você pode fazer isso com `openapi_extra`:
 
-{* ../../docs_src/path_operation_advanced_configuration/tutorial006.py hl[19:36,39:40] *}
+{* ../../docs_src/path_operation_advanced_configuration/tutorial006.py hl[19:36, 39:40] *}
 
 Nesse exemplo, nós não declaramos nenhum modelo do Pydantic. Na verdade, o corpo da requisição não está nem mesmo <abbr title="convertido de um formato plano, como bytes, para objetos Python">analisado</abbr> como JSON, ele é lido diretamente como `bytes` e a função `magic_data_reader()` seria a responsável por analisar ele de alguma forma.
 
 De toda forma, nós podemos declarar o esquema esperado para o corpo da requisição.
 
-### Tipo de conteúdo do OpenAPI personalizado
+### Tipo de conteúdo do OpenAPI personalizado { #custom-openapi-content-type }
 
-Utilizando esse mesmo truque, você pode utilizar um modelo Pydantic para definir o esquema JSON que é então incluído na seção do esquema personalizado do OpenAPI na *operação de rota*.
+Utilizando esse mesmo truque, você pode utilizar um modelo Pydantic para definir o JSON Schema que é então incluído na seção do esquema personalizado do OpenAPI na *operação de rota*.
 
 E você pode fazer isso até mesmo quando os dados da requisição não seguem o formato JSON.
 
-Por exemplo, nesta aplicação nós não usamos a funcionalidade integrada ao FastAPI de extrair o esquema JSON dos modelos Pydantic nem a validação automática do JSON. Na verdade, estamos declarando o tipo do conteúdo da requisição como YAML, em vez de JSON:
+Por exemplo, nesta aplicação nós não usamos a funcionalidade integrada ao FastAPI de extrair o JSON Schema dos modelos Pydantic nem a validação automática do JSON. Na verdade, estamos declarando o tipo do conteúdo da requisição como YAML, em vez de JSON:
 
 //// tab | Pydantic v2
 
-{* ../../docs_src/path_operation_advanced_configuration/tutorial007.py hl[17:22,24] *}
+{* ../../docs_src/path_operation_advanced_configuration/tutorial007.py hl[17:22, 24] *}
 
 ////
 
 //// tab | Pydantic v1
 
-{* ../../docs_src/path_operation_advanced_configuration/tutorial007_pv1.py hl[17:22,24] *}
+{* ../../docs_src/path_operation_advanced_configuration/tutorial007_pv1.py hl[17:22, 24] *}
 
 ////
 
 /// info | Informação
 
-Na versão 1 do Pydantic, o método para obter o esquema JSON de um modelo é `Item.schema()`, na versão 2 do Pydantic, o método é `Item.model_json_schema()`
+Na versão 1 do Pydantic, o método para obter o JSON Schema de um modelo é `Item.schema()`, na versão 2 do Pydantic, o método é `Item.model_json_schema()`.
 
 ///
 
-Entretanto, mesmo que não utilizemos a funcionalidade integrada por padrão, ainda estamos usando um modelo Pydantic para gerar um esquema JSON manualmente para os dados que queremos receber no formato YAML.
+Entretanto, mesmo que não utilizemos a funcionalidade integrada por padrão, ainda estamos usando um modelo Pydantic para gerar um JSON Schema manualmente para os dados que queremos receber no formato YAML.
 
 Então utilizamos a requisição diretamente, e extraímos o corpo como `bytes`. Isso significa que o FastAPI não vai sequer tentar analisar o corpo da requisição como JSON.
 
@@ -195,7 +195,7 @@ Na versão 1 do Pydantic, o método para analisar e validar um objeto era `Item.
 
 ///
 
-///tip | Dica
+/// tip | Dica
 
 Aqui reutilizamos o mesmo modelo do Pydantic.
 

docs/pt/docs/advanced/response-change-status-code.md

@@ -1,10 +1,10 @@
-# Retorno - Altere o Código de Status
+# Retorno - Altere o Código de Status { #response-change-status-code }
 
 Você provavelmente leu anteriormente que você pode definir um [Código de Status do Retorno](../tutorial/response-status-code.md){.internal-link target=_blank} padrão.
 
 Porém em alguns casos você precisa retornar um código de status diferente do padrão.
 
-## Caso de uso
+## Caso de uso { #use-case }
 
 Por exemplo, imagine que você deseja retornar um código de status HTTP de "OK" `200` por padrão.
 
@@ -14,7 +14,7 @@ Mas você ainda quer ser capaz de filtrar e converter o dado que você retornar
 
 Para estes casos, você pode utilizar um parâmetro `Response`.
 
-## Use um parâmetro `Response`
+## Use um parâmetro `Response` { #use-a-response-parameter }
 
 Você pode declarar um parâmetro do tipo `Response` em sua *função de operação de rota* (assim como você pode fazer para cookies e headers).
 

docs/pt/docs/advanced/response-cookies.md

@@ -1,12 +1,12 @@
-# Cookies de Resposta
+# Cookies de Resposta { #response-cookies }
 
-## Usando um parâmetro `Response`
+## 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*.
 
 E então você pode definir cookies nesse objeto de resposta *temporário*.
 
-{* ../../docs_src/response_cookies/tutorial002.py hl[1,8:9] *}
+{* ../../docs_src/response_cookies/tutorial002.py hl[1, 8:9] *}
 
 Em seguida, você pode retornar qualquer objeto que precise, como normalmente faria (um `dict`, um modelo de banco de dados, etc).
 
@@ -16,11 +16,11 @@ E se você declarou um `response_model`, ele ainda será usado para filtrar e co
 
 Você também pode declarar o parâmetro `Response` em dependências e definir cookies (e cabeçalhos) nelas.
 
-## Retornando uma `Response` diretamente
+## Retorne uma `Response` diretamente { #return-a-response-directly }
 
 Você também pode criar cookies ao retornar uma `Response` diretamente no seu código.
 
-Para fazer isso, você pode criar uma resposta como descrito em [Retornando uma Resposta Diretamente](response-directly.md){.internal-link target=_blank}.
+Para fazer isso, você pode criar uma resposta como descrito em [Retorne uma Resposta Diretamente](response-directly.md){.internal-link target=_blank}.
 
 Então, defina os cookies nela e a retorne:
 
@@ -36,7 +36,7 @@ E também que você não esteja enviando nenhum dado que deveria ter sido filtra
 
 ///
 
-### Mais informações
+### Mais informações { #more-info }
 
 /// note | Detalhes Técnicos
 

docs/pt/docs/advanced/response-directly.md

@@ -1,4 +1,4 @@
-# Retornando uma Resposta Diretamente
+# Retornando uma Resposta Diretamente { #return-a-response-directly }
 
 Quando você cria uma *operação de rota* no **FastAPI** você pode retornar qualquer dado nela: um dicionário (`dict`), uma lista (`list`), um modelo do Pydantic ou do seu banco de dados, etc.
 
@@ -10,7 +10,7 @@ Mas você pode retornar a `JSONResponse` diretamente nas suas *operações de ro
 
 Pode ser útil para retornar cabeçalhos e cookies personalizados, por exemplo.
 
-## Retornando uma `Response`
+## Retornando uma `Response` { #return-a-response }
 
 Na verdade, você pode retornar qualquer `Response` ou subclasse dela.
 
@@ -26,7 +26,7 @@ Ele não vai fazer conversões de dados com modelos do Pydantic, não irá conve
 
 Isso te dá bastante flexibilidade. Você pode retornar qualquer tipo de dado, sobrescrever qualquer declaração e validação nos dados, etc.
 
-## Utilizando o `jsonable_encoder` em uma `Response`
+## Utilizando o `jsonable_encoder` em uma `Response` { #using-the-jsonable-encoder-in-a-response }
 
 Como o **FastAPI** não realiza nenhuma mudança na `Response` que você retorna, você precisa garantir que o conteúdo dela está pronto para uso.
 
@@ -44,23 +44,22 @@ Você também pode utilizar `from starlette.responses import JSONResponse`.
 
 ///
 
-## Retornando uma `Response`
+## Retornando uma `Response` personalizada { #returning-a-custom-response }
 
 O exemplo acima mostra todas as partes que você precisa, mas ainda não é muito útil, já que você poderia ter retornado o `item` diretamente, e o **FastAPI** colocaria em uma `JSONResponse` para você, convertendo em um `dict`, etc. Tudo isso por padrão.
 
 Agora, vamos ver como você pode usar isso para retornar uma resposta personalizada.
 
-Vamos dizer quer retornar uma resposta <a href="https://pt.wikipedia.org/wiki/XML" class="external-link" target="_blank">XML</a>.
+Vamos dizer que você quer retornar uma resposta <a href="https://en.wikipedia.org/wiki/XML" class="external-link" target="_blank">XML</a>.
 
 Você pode colocar o seu conteúdo XML em uma string, colocar em uma `Response`, e retorná-lo:
 
 {* ../../docs_src/response_directly/tutorial002.py hl[1,18] *}
 
-## Notas
+## Notas { #notes }
 
 Quando você retorna uma `Response` diretamente os dados não são validados, convertidos (serializados) ou documentados automaticamente.
 
-Mas você ainda pode documentar como descrito em [Retornos Adicionais no OpenAPI
-](additional-responses.md){.internal-link target=_blank}.
+Mas você ainda pode documentar como descrito em [Retornos Adicionais no OpenAPI](additional-responses.md){.internal-link target=_blank}.
 
 Você pode ver nas próximas seções como usar/declarar essas `Responses` customizadas enquanto mantém a conversão e documentação automática dos dados.

docs/pt/docs/advanced/response-headers.md

@@ -1,12 +1,12 @@
-# Cabeçalhos de resposta
+# Cabeçalhos de resposta { #response-headers }
 
-## Usando um parâmetro `Response`
+## 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).
 
 Então você pode definir os cabeçalhos nesse objeto de resposta *temporário*.
 
-{* ../../docs_src/response_headers/tutorial002.py hl[1,7:8] *}
+{* ../../docs_src/response_headers/tutorial002.py hl[1, 7:8] *}
 
 Em seguida você pode retornar qualquer objeto que precisar, da maneira que faria normalmente (um `dict`, um modelo de banco de dados, etc.).
 
@@ -16,7 +16,7 @@ Se você declarou um `response_model`, ele ainda será utilizado para filtrar e
 
 Você também pode declarar o parâmetro `Response` em dependências e definir cabeçalhos (e cookies) nelas.
 
-## Retornar uma `Response` diretamente
+## Retorne uma `Response` diretamente { #return-a-response-directly }
 
 Você também pode adicionar cabeçalhos quando retornar uma `Response` diretamente.
 
@@ -24,7 +24,7 @@ Crie uma resposta conforme descrito em [Retornar uma resposta diretamente](respo
 
 {* ../../docs_src/response_headers/tutorial001.py hl[10:12] *}
 
-/// note | Detalhes técnicos
+/// note | Detalhes Técnicos
 
 Você também pode usar `from starlette.responses import Response` ou `from starlette.responses import JSONResponse`.
 
@@ -34,8 +34,8 @@ E como a `Response` pode ser usada frequentemente para definir cabeçalhos e coo
 
 ///
 
-## Cabeçalhos personalizados
+## Cabeçalhos personalizados { #custom-headers }
 
-Tenha em mente que cabeçalhos personalizados proprietários podem ser adicionados <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers" class="external-link" target="_blank">usando o prefixo 'X-'</a>.
+Tenha em mente que cabeçalhos personalizados proprietários podem ser adicionados <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers" class="external-link" target="_blank">usando o prefixo `X-`</a>.
 
 Porém, se voce 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){.internal-link target=_blank}), usando o parâmetro `expose_headers` descrito na <a href="https://www.starlette.dev/middleware/#corsmiddleware" class="external-link" target="_blank">documentação de CORS do Starlette</a>.

docs/pt/docs/advanced/security/http-basic-auth.md

@@ -1,10 +1,10 @@
-# HTTP Basic Auth
+# HTTP Basic Auth { #http-basic-auth }
 
 Para os casos mais simples, você pode utilizar o HTTP Basic Auth.
 
 No HTTP Basic Auth, a aplicação espera um cabeçalho que contém um usuário e uma senha.
 
-Caso ela não receba, ela retorna um erro HTTP 401 "Unauthorized" (*Não Autorizado*).
+Caso ela não receba, ela retorna um erro HTTP 401 "Unauthorized".
 
 E retorna um cabeçalho `WWW-Authenticate` com o valor `Basic`, e um parâmetro opcional `realm`.
 
@@ -12,7 +12,7 @@ Isso sinaliza ao navegador para mostrar o prompt integrado para um usuário e se
 
 Então, quando você digitar o usuário e senha, o navegador os envia automaticamente no cabeçalho.
 
-## HTTP Basic Auth Simples
+## HTTP Basic Auth Simples { #simple-http-basic-auth }
 
 * Importe `HTTPBasic` e `HTTPBasicCredentials`.
 * Crie um "esquema `security`" utilizando `HTTPBasic`.
@@ -22,11 +22,11 @@ Então, quando você digitar o usuário e senha, o navegador os envia automatica
 
 {* ../../docs_src/security/tutorial006_an_py39.py hl[4,8,12] *}
 
-Quando você tentar abrir a URL pela primeira vez (ou clicar no botão "Executar" nos documentos) o navegador vai pedir pelo seu usuário e senha:
+Quando você tentar abrir a URL pela primeira vez (ou clicar no botão "Executar" na documentação) o navegador vai pedir pelo seu usuário e senha:
 
 <img src="/img/tutorial/security/image12.png">
 
-## Verifique o usuário
+## Verifique o usuário { #check-the-username }
 
 Aqui está um exemplo mais completo.
 
@@ -52,7 +52,7 @@ if not (credentials.username == "stanleyjobson") or not (credentials.password ==
 
 Porém, ao utilizar o `secrets.compare_digest()`, isso estará seguro contra um tipo de ataque chamado "timing attacks" (ataques de temporização).
 
-### Ataques de Temporização
+### Ataques de Temporização { #timing-attacks }
 
 Mas o que é um "timing attack" (ataque de temporização)?
 
@@ -80,19 +80,19 @@ if "stanleyjobsox" == "stanleyjobson" and "love123" == "swordfish":
 
 O Python terá que comparar todo o `stanleyjobso` tanto em `stanleyjobsox` como em `stanleyjobson` antes de perceber que as strings não são a mesma. Então isso levará alguns microssegundos a mais para retornar "Usuário ou senha incorretos".
 
-#### O tempo para responder ajuda os invasores
+#### O tempo para responder ajuda os invasores { #the-time-to-answer-helps-the-attackers }
 
 Neste ponto, ao perceber que o servidor demorou alguns microssegundos a mais para enviar o retorno "Usuário ou senha incorretos", os invasores irão saber que eles acertaram _alguma coisa_, algumas das letras iniciais estavam certas.
 
 E eles podem tentar de novo sabendo que provavelmente é algo mais parecido com `stanleyjobsox` do que com `johndoe`.
 
-#### Um ataque "profissional"
+#### Um ataque "profissional" { #a-professional-attack }
 
 Claro, os invasores não tentariam tudo isso de forma manual, eles escreveriam um programa para fazer isso, possivelmente com milhares ou milhões de testes por segundo. E obteriam apenas uma letra a mais por vez.
 
 Mas fazendo isso, em alguns minutos ou horas os invasores teriam adivinhado o usuário e senha corretos, com a "ajuda" da nossa aplicação, apenas usando o tempo levado para responder.
 
-#### Corrija com o `secrets.compare_digest()`
+#### Corrija com o `secrets.compare_digest()` { #fix-it-with-secrets-compare-digest }
 
 Mas em nosso código já estamos utilizando o `secrets.compare_digest()`.
 
@@ -100,8 +100,7 @@ Resumindo, levará o mesmo tempo para comparar `stanleyjobsox` com `stanleyjobso
 
 Deste modo, ao utilizar `secrets.compare_digest()` no código de sua aplicação, ela estará a salvo contra toda essa gama de ataques de segurança.
 
-
-### Retorne o erro
+### Retorne o erro { #return-the-error }
 
 Após detectar que as credenciais estão incorretas, retorne um `HTTPException` com o status 401 (o mesmo retornado quando nenhuma credencial foi informada) e adicione o cabeçalho `WWW-Authenticate` para fazer com que o navegador mostre o prompt de login novamente:
 

docs/pt/docs/advanced/security/index.md

@@ -1,6 +1,6 @@
-# Segurança Avançada
+# Segurança Avançada { #advanced-security }
 
-## Funcionalidades Adicionais
+## Funcionalidades Adicionais { #additional-features }
 
 Existem algumas funcionalidades adicionais para lidar com segurança além das cobertas em [Tutorial - Guia de Usuário: Segurança](../../tutorial/security/index.md){.internal-link target=_blank}.
 
@@ -12,7 +12,7 @@ E é possível que para o seu caso de uso, a solução está em uma delas.
 
 ///
 
-## Leia o Tutorial primeiro
+## Leia o Tutorial primeiro { #read-the-tutorial-first }
 
 As próximas seções pressupõem que você já leu o principal [Tutorial - Guia de Usuário: Segurança](../../tutorial/security/index.md){.internal-link target=_blank}.
 

docs/pt/docs/advanced/security/oauth2-scopes.md

@@ -1,4 +1,4 @@
-# Escopos OAuth2
+# Escopos OAuth2 { #oauth2-scopes }
 
 Você pode utilizar escopos do OAuth2 diretamente com o **FastAPI**, eles são integrados para funcionar perfeitamente.
 
@@ -10,7 +10,7 @@ Toda vez que você "se autentica com" Facebook, Google, GitHub, Microsoft, X (Tw
 
 Nesta seção, você verá como gerenciar a autenticação e autorização com os mesmos escopos do OAuth2 em sua aplicação **FastAPI**.
 
-/// warning | Aviso
+/// warning | Atenção
 
 Isso é uma seção mais ou menos avançada. Se você está apenas começando, você pode pular.
 
@@ -18,7 +18,7 @@ Você não necessariamente precisa de escopos do OAuth2, e você pode lidar com
 
 Mas o OAuth2 com escopos pode ser integrado de maneira fácil em sua API (com OpenAPI) e a sua documentação de API.
 
-No entando, você ainda aplica estes escopos, ou qualquer outro requisito de segurança/autorização, conforme necessário, em seu código.
+No entanto, você ainda aplica estes escopos, ou qualquer outro requisito de segurança/autorização, conforme necessário, em seu código.
 
 Em muitos casos, OAuth2 com escopos pode ser um exagero.
 
@@ -26,7 +26,7 @@ Mas se você sabe que precisa, ou está curioso, continue lendo.
 
 ///
 
-## Escopos OAuth2 e OpenAPI
+## Escopos OAuth2 e OpenAPI { #oauth2-scopes-and-openapi }
 
 A especificação OAuth2 define "escopos" como uma lista de strings separadas por espaços.
 
@@ -58,15 +58,15 @@ Para o OAuth2, eles são apenas strings.
 
 ///
 
-## Visão global
+## Visão global { #global-view }
 
 Primeiro, vamos olhar rapidamente as partes que mudam dos exemplos do **Tutorial - Guia de Usuário** para [OAuth2 com Senha (e hash), Bearer com tokens JWT](../../tutorial/security/oauth2-jwt.md){.internal-link target=_blank}. Agora utilizando escopos OAuth2:
 
-{* ../../docs_src/security/tutorial005_an_py310.py hl[5,9,13,47,65,106,108:116,122:125,129:135,140,156] *}
+{* ../../docs_src/security/tutorial005_an_py310.py hl[5,9,13,47,65,106,108:116,122:126,130:136,141,157] *}
 
 Agora vamos revisar essas mudanças passo a passo.
 
-## Esquema de segurança OAuth2
+## Esquema de segurança OAuth2 { #oauth2-security-scheme }
 
 A primeira mudança é que agora nós estamos declarando o esquema de segurança OAuth2 com dois escopos disponíveis, `me` e `items`.
 
@@ -82,9 +82,9 @@ Este é o mesmo mecanismo utilizado quando você adiciona permissões enquanto s
 
 <img src="/img/tutorial/security/image11.png">
 
-## Token JWT com escopos
+## Token JWT com escopos { #jwt-token-with-scopes }
 
-Agora, modifique o *caminho de rota* para retornar os escopos solicitados.
+Agora, modifique a *operação de rota* do token para retornar os escopos solicitados.
 
 Nós ainda estamos utilizando o mesmo `OAuth2PasswordRequestForm`. Ele inclui a propriedade `scopes` com uma `list` de `str`, com cada escopo que ele recebeu na requisição.
 
@@ -98,15 +98,15 @@ Porém em sua aplicação, por segurança, você deve garantir que você apenas
 
 ///
 
-{* ../../docs_src/security/tutorial005_an_py310.py hl[156] *}
+{* ../../docs_src/security/tutorial005_an_py310.py hl[157] *}
 
-## Declare escopos em *operações de rota* e dependências
+## Declare escopos em *operações de rota* e dependências { #declare-scopes-in-path-operations-and-dependencies }
 
 Agora nós declaramos que a *operação de rota* para `/users/me/items/` exige o escopo `items`.
 
 Para isso, nós importamos e utilizamos `Security` de `fastapi`.
 
-Você pode utilizar `Security` para declarar dependências (assim como `Depends`), porém o `Security` também recebe o parâmetros `scopes` com uma lista de escopos (strings).
+Você pode utilizar `Security` para declarar dependências (assim como `Depends`), porém o `Security` também recebe o parâmetro `scopes` com uma lista de escopos (strings).
 
 Neste caso, nós passamos a função `get_current_active_user` como dependência para `Security` (da mesma forma que nós faríamos com `Depends`).
 
@@ -124,9 +124,9 @@ Nós estamos fazendo isso aqui para demonstrar como o **FastAPI** lida com escop
 
 ///
 
-{* ../../docs_src/security/tutorial005_an_py310.py hl[5,140,171] *}
+{* ../../docs_src/security/tutorial005_an_py310.py hl[5,141,172] *}
 
-/// info | Informações Técnicas
+/// info | Detalhes Técnicos
 
 `Security` é na verdade uma subclasse de `Depends`, e ele possui apenas um parâmetro extra que veremos depois.
 
@@ -136,7 +136,7 @@ Mas quando você importa `Query`, `Path`, `Depends`, `Security` entre outros de
 
 ///
 
-## Utilize `SecurityScopes`
+## Utilize `SecurityScopes` { #use-securityscopes }
 
 Agora atualize a dependência `get_current_user`.
 
@@ -152,7 +152,7 @@ A classe `SecurityScopes` é semelhante à classe `Request` (`Request` foi utili
 
 {* ../../docs_src/security/tutorial005_an_py310.py hl[9,106] *}
 
-## Utilize os `scopes`
+## Utilize os `scopes` { #use-the-scopes }
 
 O parâmetro `security_scopes` será do tipo `SecurityScopes`.
 
@@ -166,7 +166,7 @@ Nesta exceção, nós incluímos os escopos necessários (se houver algum) como
 
 {* ../../docs_src/security/tutorial005_an_py310.py hl[106,108:116] *}
 
-## Verifique o `username` e o formato dos dados
+## Verifique o `username` e o formato dos dados { #verify-the-username-and-data-shape }
 
 Nós verificamos que nós obtemos um `username`, e extraímos os escopos.
 
@@ -180,17 +180,17 @@ No lugar de, por exemplo, um `dict`, ou alguma outra coisa, que poderia quebrar
 
 Nós também verificamos que nós temos um usuário com o "*username*", e caso contrário, nós levantamos a mesma exceção que criamos anteriormente.
 
-{* ../../docs_src/security/tutorial005_an_py310.py hl[47,117:128] *}
+{* ../../docs_src/security/tutorial005_an_py310.py hl[47,117:129] *}
 
-## Verifique os `scopes`
+## Verifique os `scopes` { #verify-the-scopes }
 
 Nós verificamos agora que todos os escopos necessários, por essa dependência e todos os dependentes (incluindo as *operações de rota*) estão incluídas nos escopos fornecidos pelo token recebido, caso contrário, levantamos uma `HTTPException`.
 
 Para isso, nós utilizamos `security_scopes.scopes`, que contém uma `list` com todos esses escopos como uma `str`.
 
-{* ../../docs_src/security/tutorial005_an_py310.py hl[129:135] *}
+{* ../../docs_src/security/tutorial005_an_py310.py hl[130:136] *}
 
-## Árvore de dependência e escopos
+## Árvore de dependência e escopos { #dependency-tree-and-scopes }
 
 Vamos rever novamente essa árvore de dependência e os escopos.
 
@@ -223,7 +223,7 @@ Tudo depende dos `scopes` declarados em cada *operação de rota* e cada depend
 
 ///
 
-## Mais detalhes sobre `SecurityScopes`
+## Mais detalhes sobre `SecurityScopes` { #more-details-about-securityscopes }
 
 Você pode utilizar `SecurityScopes` em qualquer lugar, e em diversos lugares. Ele não precisa estar na dependência "raiz".
 
@@ -233,9 +233,9 @@ Porque o `SecurityScopes` terá todos os escopos declarados por dependentes, voc
 
 Todos eles serão validados independentemente para cada *operação de rota*.
 
-## Verifique
+## Verifique { #check-it }
 
-Se você abrir os documentos da API, você pode antenticar e especificar quais escopos você quer autorizar.
+Se você abrir os documentos da API, você pode autenticar e especificar quais escopos você quer autorizar.
 
 <img src="/img/tutorial/security/image11.png">
 
@@ -245,9 +245,9 @@ E se você selecionar o escopo `me`, mas não o escopo `items`, você poderá ac
 
 Isso é o que aconteceria se uma aplicação terceira que tentou acessar uma dessas *operações de rota* com um token fornecido por um usuário, dependendo de quantas permissões o usuário forneceu para a aplicação.
 
-## Sobre integrações de terceiros
+## Sobre integrações de terceiros { #about-third-party-integrations }
 
-Neste exemplos nós estamos utilizando o fluxo de senha do OAuth2.
+Neste exemplo nós estamos utilizando o fluxo de senha do OAuth2.
 
 Isso é apropriado quando nós estamos autenticando em nossa própria aplicação, provavelmente com o nosso próprio "*frontend*".
 
@@ -269,6 +269,6 @@ Mas no final, eles estão implementando o mesmo padrão OAuth2.
 
 O **FastAPI** inclui utilitários para todos esses fluxos de autenticação OAuth2 em `fastapi.security.oauth2`.
 
-## `Security` em docoradores de `dependências`
+## `Security` em decoradores de `dependencies` { #security-in-decorator-dependencies }
 
-Da mesma forma que você pode definir uma `list` de `Depends` no parâmetro de `dependencias` do decorador (como explicado em [Dependências em decoradores de operações de rota](../../tutorial/dependencies/dependencies-in-path-operation-decorators.md){.internal-link target=_blank}), você também pode utilizar `Security` com escopos lá.
+Da mesma forma que você pode definir uma `list` de `Depends` no parâmetro `dependencies` do decorador (como explicado em [Dependências em decoradores de operações de rota](../../tutorial/dependencies/dependencies-in-path-operation-decorators.md){.internal-link target=_blank}), você também pode utilizar `Security` com escopos lá.

docs/pt/docs/advanced/settings.md

@@ -1,148 +1,30 @@
-# Configurações e Variáveis de Ambiente
+# Configurações e Variáveis de Ambiente { #settings-and-environment-variables }
 
-Em muitos casos a sua aplicação pode precisar de configurações externas, como chaves secretas, credenciais de banco de dados, credenciais para serviços de email, etc.
+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 (podem mudar), como URLs de bancos de dados. E muitas delas podem conter dados sensíveis, como tokens secretos.
+A maioria dessas configurações é variável (pode mudar), como URLs de banco de dados. E muitas podem ser sensíveis, como segredos.
 
-Por isso é comum prover essas configurações como variáveis de ambiente que são utilizidas pela aplicação.
-
-## Variáveis de Ambiente
+Por esse motivo, é comum fornecê-las em variáveis de ambiente lidas pela aplicação.
 
 /// tip | Dica
 
-Se você já sabe o que são variáveis de ambiente e como utilizá-las, sinta-se livre para avançar para o próximo tópico.
+Para entender variáveis de ambiente, você pode ler [Variáveis de Ambiente](../environment-variables.md){.internal-link target=_blank}.
 
 ///
 
-Uma <a href="https://pt.wikipedia.org/wiki/Variável_de_ambiente" class="external-link" target="_blank">variável de ambiente</a> (abreviada em inglês para "env var") é uma variável definida fora do código Python, no sistema operacional, e pode ser lida pelo seu código Python (ou por outros programas).
+## Tipagem e validação { #types-and-validation }
 
-Você pode criar e utilizar variáveis de ambiente no terminal, sem precisar utilizar Python:
+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).
 
-//// tab | Linux, macOS, Windows Bash
+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.
 
-<div class="termy">
+## Pydantic `Settings` { #pydantic-settings }
 
-```console
-// Você pode criar uma env var MY_NAME usando
-$ export MY_NAME="Wade Wilson"
+Felizmente, o Pydantic fornece uma ótima utilidade para lidar com essas configurações vindas de variáveis de ambiente com <a href="https://docs.pydantic.dev/latest/concepts/pydantic_settings/" class="external-link" target="_blank">Pydantic: Settings management</a>.
 
-// E utilizá-la em outros programas, como
-$ echo "Hello $MY_NAME"
+### Instalar `pydantic-settings` { #install-pydantic-settings }
 
-Hello Wade Wilson
-```
-
-</div>
-
-////
-
-//// tab | Windows PowerShell
-
-<div class="termy">
-
-```console
-// Criando env var MY_NAME
-$ $Env:MY_NAME = "Wade Wilson"
-
-// Usando em outros programas, como
-$ echo "Hello $Env:MY_NAME"
-
-Hello Wade Wilson
-```
-
-</div>
-
-////
-
-### Lendo variáveis de ambiente com Python
-
-Você também pode criar variáveis de ambiente fora do Python, no terminal (ou com qualquer outro método), e realizar a leitura delas no Python.
-
-Por exemplo, você pode definir um arquivo `main.py` com o seguinte código:
-
-```Python hl_lines="3"
-import os
-
-name = os.getenv("MY_NAME", "World")
-print(f"Hello {name} from Python")
-```
-
-/// tip | Dica
-
-O segundo parâmetro em <a href="https://docs.python.org/3.8/library/os.html#os.getenv" class="external-link" target="_blank">`os.getenv()`</a> é o valor padrão para o retorno.
-
-Se nenhum valor for informado, `None` é utilizado por padrão, aqui definimos `"World"` como o valor padrão a ser utilizado.
-
-///
-
-E depois você pode executar esse arquivo:
-
-<div class="termy">
-
-```console
-// Aqui ainda não definimos a env var
-$ python main.py
-
-// Por isso obtemos o valor padrão
-
-Hello World from Python
-
-// Mas se definirmos uma variável de ambiente primeiro
-$ export MY_NAME="Wade Wilson"
-
-// E executarmos o programa novamente
-$ python main.py
-
-// Agora ele pode ler a variável de ambiente
-
-Hello Wade Wilson from Python
-```
-
-</div>
-
-Como variáveis de ambiente podem ser definidas fora do código da aplicação, mas acessadas pela aplicação, e não precisam ser armazenadas (versionadas com `git`) junto dos outros arquivos, é comum utilizá-las para guardar configurações.
-
-Você também pode criar uma variável de ambiente específica para uma invocação de um programa, que é acessível somente para esse programa, e somente enquanto ele estiver executando.
-
-Para fazer isso, crie a variável imediatamente antes de iniciar o programa, na mesma linha:
-
-<div class="termy">
-
-```console
-// Criando uma env var MY_NAME na mesma linha da execução do programa
-$ MY_NAME="Wade Wilson" python main.py
-
-// Agora a aplicação consegue ler a variável de ambiente
-
-Hello Wade Wilson from Python
-
-// E a variável deixa de existir após isso
-$ python main.py
-
-Hello World from Python
-```
-
-</div>
-
-/// tip | Dica
-
-Você pode ler mais sobre isso em: <a href="https://12factor.net/pt_br/config" class="external-link" target="_blank">The Twelve-Factor App: Configurações</a>.
-
-///
-
-### Tipagem e Validação
-
-Essas variáveis de ambiente suportam apenas strings, por serem externas ao Python e por que precisam ser compatíveis com outros programas e o resto do sistema (e até mesmo com outros sistemas operacionais, como Linux, Windows e macOS).
-
-Isso significa que qualquer valor obtido de uma variável de ambiente em Python terá o tipo `str`, e qualquer conversão para um tipo diferente ou validação deve ser realizada no código.
-
-## Pydantic `Settings`
-
-Por sorte, o Pydantic possui uma funcionalidade para lidar com essas configurações vindas de variáveis de ambiente utilizando <a href="https://docs.pydantic.dev/latest/usage/pydantic_settings/" class="external-link" target="_blank">Pydantic: Settings management</a>.
-
-### Instalando `pydantic-settings`
-
-Primeiro, instale o pacote `pydantic-settings`:
+Primeiro, certifique-se de criar seu [ambiente virtual](../virtual-environments.md){.internal-link target=_blank}, ativá-lo e então instalar o pacote `pydantic-settings`:
 
 <div class="termy">
 
@@ -153,7 +35,7 @@ $ pip install pydantic-settings
 
 </div>
 
-Ele também está incluído no fastapi quando você instala com a opção `all`:
+Ele também vem incluído quando você instala os extras `all` com:
 
 <div class="termy">
 
@@ -164,19 +46,19 @@ $ pip install "fastapi[all]"
 
 </div>
 
-/// info
+/// info | Informação
 
-Na v1 do Pydantic ele estava incluído no pacote principal. Agora ele está distribuido como um pacote independente para que você possa optar por instalar ou não caso você não precise dessa funcionalidade.
+No Pydantic v1 ele vinha incluído no pacote principal. Agora é distribuído como um pacote independente para que você possa optar por instalá-lo ou não, caso não precise dessa funcionalidade.
 
 ///
 
-### Criando o objeto `Settings`
+### Criar o objeto `Settings` { #create-the-settings-object }
 
-Importe a classe `BaseSettings` do Pydantic e crie uma nova subclasse, de forma parecida com um modelo do Pydantic.
+Importe `BaseSettings` do Pydantic e crie uma subclasse, muito parecido com um modelo do Pydantic.
 
-Os atributos da classe são declarados com anotações de tipo, e possíveis valores padrão, da mesma maneira que os modelos do Pydantic.
+Da mesma forma que com modelos do Pydantic, você declara atributos de classe com anotações de tipo e, possivelmente, valores padrão.
 
-Você pode utilizar todas as ferramentas e funcionalidades de validação que são utilizadas nos modelos do Pydantic, como tipos de dados diferentes e validações adicionei com `Field()`.
+Você pode usar as mesmas funcionalidades e ferramentas de validação que usa em modelos do Pydantic, como diferentes tipos de dados e validações adicionais com `Field()`.
 
 //// tab | Pydantic v2
 
@@ -186,9 +68,9 @@ Você pode utilizar todas as ferramentas e funcionalidades de validação que s
 
 //// tab | Pydantic v1
 
-/// info
+/// info | Informação
 
-Na versão 1 do Pydantic você importaria `BaseSettings` diretamente do módulo `pydantic` em vez do módulo `pydantic_settings`.
+No Pydantic v1 você importaria `BaseSettings` diretamente de `pydantic` em vez de `pydantic_settings`.
 
 ///
 
@@ -198,23 +80,23 @@ Na versão 1 do Pydantic você importaria `BaseSettings` diretamente do módulo
 
 /// tip | Dica
 
-Se você quiser algo pronto para copiar e colar na sua aplicação, não use esse exemplo, mas sim o exemplo abaixo.
+Se você quer algo rápido para copiar e colar, não use este exemplo, use o último abaixo.
 
 ///
 
-Portanto, quando você cria uma instância da classe `Settings` (nesse caso, o objeto `settings`), o Pydantic lê as variáveis de ambiente sem diferenciar maiúsculas e minúsculas, por isso, uma variável maiúscula `APP_NAME` será usada para o atributo `app_name`.
+Então, quando você cria uma instância dessa classe `Settings` (neste caso, no objeto `settings`), o Pydantic vai ler as variáveis de ambiente sem diferenciar maiúsculas de minúsculas; assim, uma variável em maiúsculas `APP_NAME` ainda será lida para o atributo `app_name`.
 
-Depois ele irá converter e validar os dados. Assim, quando você utilizar aquele objeto `settings`, os dados terão o tipo que você declarou (e.g. `items_per_user` será do tipo `int`).
+Em seguida, ele converterá e validará os dados. Assim, quando você usar esse objeto `settings`, terá dados dos tipos que declarou (por exemplo, `items_per_user` será um `int`).
 
-### Usando o objeto `settings`
+### Usar o `settings` { #use-the-settings }
 
-Depois, Você pode utilizar o novo objeto `settings` na sua aplicação:
+Depois você pode usar o novo objeto `settings` na sua aplicação:
 
 {* ../../docs_src/settings/tutorial001.py hl[18:20] *}
 
-### Executando o servidor
+### Executar o servidor { #run-the-server }
 
-No próximo passo, você pode inicializar o servidor passando as configurações em forma de variáveis de ambiente, por exemplo, você poderia definir `ADMIN_EMAIL` e `APP_NAME` da seguinte forma:
+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:
 
 <div class="termy">
 
@@ -228,110 +110,110 @@ $ ADMIN_EMAIL="deadpool@example.com" APP_NAME="ChimichangApp" fastapi run main.p
 
 /// tip | Dica
 
-Para definir múltiplas variáveis de ambiente para um único comando basta separá-las utilizando espaços, e incluir todas elas antes do comando.
+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.
 
 ///
 
-Assim, o atributo `admin_email` seria definido como `"deadpool@example.com"`.
+Então a configuração `admin_email` seria definida como `"deadpool@example.com"`.
 
-`app_name` seria `"ChimichangApp"`.
+O `app_name` seria `"ChimichangApp"`.
 
-E `items_per_user` manteria o valor padrão de `50`.
+E `items_per_user` manteria seu valor padrão de `50`.
 
-## Configurações em um módulo separado
+## Configurações em outro módulo { #settings-in-another-module }
 
-Você também pode incluir essas configurações em um arquivo de um módulo separado como visto em [Bigger Applications - Multiple Files](../tutorial/bigger-applications.md){.internal-link target=\_blank}.
+Você pode colocar essas configurações em outro arquivo de módulo como visto em [Aplicações Maiores - Múltiplos Arquivos](../tutorial/bigger-applications.md){.internal-link target=_blank}.
 
-Por exemplo, você pode adicionar um arquivo `config.py` com:
+Por exemplo, você poderia ter um arquivo `config.py` com:
 
 {* ../../docs_src/settings/app01/config.py *}
 
-E utilizar essa configuração em `main.py`:
+E então usá-lo em um arquivo `main.py`:
 
 {* ../../docs_src/settings/app01/main.py hl[3,11:13] *}
 
 /// tip | Dica
 
-Você também precisa incluir um arquivo `__init__.py` como visto em [Bigger Applications - Multiple Files](../tutorial/bigger-applications.md){.internal-link target=\_blank}.
+Você também precisaria de um arquivo `__init__.py` como visto em [Aplicações Maiores - Múltiplos Arquivos](../tutorial/bigger-applications.md){.internal-link target=_blank}.
 
 ///
 
-## Configurações em uma dependência
+## Configurações em uma dependência { #settings-in-a-dependency }
 
-Em certas ocasiões, pode ser útil fornecer essas configurações a partir de uma dependência, em vez de definir um objeto global `settings` que é utilizado em toda a aplicação.
+Em algumas ocasiões, pode ser útil fornecer as configurações a partir de uma dependência, em vez de ter um objeto global `settings` usado em todos os lugares.
 
-Isso é especialmente útil durante os testes, já que é bastante simples sobrescrever uma dependência com suas configurações personalizadas.
+Isso pode ser especialmente útil durante os testes, pois é muito fácil sobrescrever uma dependência com suas próprias configurações personalizadas.
 
-### O arquivo de configuração
+### O arquivo de configuração { #the-config-file }
 
-Baseando-se no exemplo anterior, seu arquivo `config.py` seria parecido com isso:
+Vindo do exemplo anterior, seu arquivo `config.py` poderia ser assim:
 
 {* ../../docs_src/settings/app02/config.py hl[10] *}
 
-Perceba que dessa vez não criamos uma instância padrão `settings = Settings()`.
+Perceba que agora não criamos uma instância padrão `settings = Settings()`.
 
-### O arquivo principal da aplicação
+### O arquivo principal da aplicação { #the-main-app-file }
 
-Agora criamos a dependência que retorna um novo objeto `config.Settings()`.
+Agora criamos uma dependência que retorna um novo `config.Settings()`.
 
 {* ../../docs_src/settings/app02_an_py39/main.py hl[6,12:13] *}
 
 /// tip | Dica
 
-Vamos discutir sobre `@lru_cache` logo mais.
+Vamos discutir o `@lru_cache` em breve.
 
-Por enquanto, você pode considerar `get_settings()` como uma função normal.
+Por enquanto, você pode assumir que `get_settings()` é uma função normal.
 
 ///
 
-E então podemos declarar essas configurações como uma dependência na função de operação da rota e utilizar onde for necessário.
+E então podemos exigi-la na *função de operação de rota* como dependência e usá-la onde for necessário.
 
 {* ../../docs_src/settings/app02_an_py39/main.py hl[17,19:21] *}
 
-### Configurações e testes
+### Configurações e testes { #settings-and-testing }
 
-Então seria muito fácil fornecer uma configuração diferente durante a execução dos testes sobrescrevendo a dependência de `get_settings`:
+Então seria muito fácil fornecer um objeto de configurações diferente durante os testes criando uma sobrescrita de dependência para `get_settings`:
 
 {* ../../docs_src/settings/app02/test_main.py hl[9:10,13,21] *}
 
-Na sobrescrita da dependência, definimos um novo valor para `admin_email` quando instanciamos um novo objeto `Settings`, e então retornamos esse novo objeto.
+Na sobrescrita da dependência definimos um novo valor para `admin_email` ao criar o novo objeto `Settings`, e então retornamos esse novo objeto.
 
-Após isso, podemos testar se o valor está sendo utilizado.
+Depois podemos testar que ele é usado.
 
-## Lendo um arquivo `.env`
+## Lendo um arquivo `.env` { #reading-a-env-file }
 
-Se você tiver muitas configurações que variem bastante, talvez em ambientes distintos, pode ser útil colocá-las em um arquivo e depois lê-las como se fossem variáveis de ambiente.
+Se você tiver muitas configurações que possivelmente mudam bastante, talvez em diferentes ambientes, pode ser útil colocá-las em um arquivo e então lê-las como se fossem variáveis de ambiente.
 
-Essa prática é tão comum que possui um nome, essas variáveis de ambiente normalmente são colocadas em um arquivo `.env`, e esse arquivo é chamado de "dotenv".
+Essa prática é tão comum que tem um nome: essas variáveis de ambiente são comumente colocadas em um arquivo `.env`, e o arquivo é chamado de "dotenv".
 
 /// tip | Dica
 
-Um arquivo iniciando com um ponto final (`.`) é um arquivo oculto em sistemas baseados em Unix, como Linux e MacOS.
+Um arquivo começando com um ponto (`.`) é um arquivo oculto em sistemas tipo Unix, como Linux e macOS.
 
-Mas um arquivo dotenv não precisa ter esse nome exato.
+Mas um arquivo dotenv não precisa ter exatamente esse nome de arquivo.
 
 ///
 
-Pydantic suporta a leitura desses tipos de arquivos utilizando uma biblioteca externa. Você pode ler mais em <a href="https://docs.pydantic.dev/latest/concepts/pydantic_settings/#dotenv-env-support" class="external-link" target="_blank">Pydantic Settings: Dotenv (.env) support</a>.
+O Pydantic tem suporte para leitura desses tipos de arquivos usando uma biblioteca externa. Você pode ler mais em <a href="https://docs.pydantic.dev/latest/concepts/pydantic_settings/#dotenv-env-support" class="external-link" target="_blank">Pydantic Settings: Dotenv (.env) support</a>.
 
 /// tip | Dica
 
-Para que isso funcione você precisa executar `pip install python-dotenv`.
+Para isso funcionar, você precisa executar `pip install python-dotenv`.
 
 ///
 
-### O arquivo `.env`
+### O arquivo `.env` { #the-env-file }
 
-Você pode definir um arquivo `.env` com o seguinte conteúdo:
+Você poderia ter um arquivo `.env` com:
 
 ```bash
 ADMIN_EMAIL="deadpool@example.com"
 APP_NAME="ChimichangApp"
 ```
 
-### Obtendo configurações do `.env`
+### Ler configurações do `.env` { #read-settings-from-env }
 
-E então adicionar o seguinte código em `config.py`:
+E então atualizar seu `config.py` com:
 
 //// tab | Pydantic v2
 
@@ -339,7 +221,7 @@ E então adicionar o seguinte código em `config.py`:
 
 /// tip | Dica
 
-O atributo `model_config` é usado apenas para configuração do Pydantic. Você pode ler mais em <a href="https://docs.pydantic.dev/latest/usage/model_config/" class="external-link" target="_blank">Pydantic Model Config</a>.
+O atributo `model_config` é usado apenas para configuração do Pydantic. Você pode ler mais em <a href="https://docs.pydantic.dev/latest/concepts/config/" class="external-link" target="_blank">Pydantic: Concepts: Configuration</a>.
 
 ///
 
@@ -357,48 +239,48 @@ A classe `Config` é usada apenas para configuração do Pydantic. Você pode le
 
 ////
 
-/// info
+/// info | Informação
 
-Na versão 1 do Pydantic a configuração é realizada por uma classe interna `Config`, na versão 2 do Pydantic isso é feito com o atributo `model_config`. Esse atributo recebe um `dict`, para utilizar o autocomplete e checagem de erros do seu editor de texto você pode importar e utilizar `SettingsConfigDict` para definir esse `dict`.
+Na versão 1 do Pydantic a configuração era feita em uma classe interna `Config`, na versão 2 do Pydantic é feita em um atributo `model_config`. Esse atributo recebe um `dict`, e para ter autocompletar e erros inline você pode importar e usar `SettingsConfigDict` para definir esse `dict`.
 
 ///
 
-Aqui definimos a configuração `env_file` dentro da classe `Settings` do Pydantic, e definimos o valor como o nome do arquivo dotenv que queremos utilizar.
+Aqui definimos a configuração `env_file` dentro da sua classe `Settings` do Pydantic e definimos o valor como o nome do arquivo dotenv que queremos usar.
 
-### Declarando `Settings` apenas uma vez com `lru_cache`
+### Criando o `Settings` apenas uma vez com `lru_cache` { #creating-the-settings-only-once-with-lru-cache }
 
-Ler o conteúdo de um arquivo em disco normalmente é uma operação custosa (lenta), então você provavelmente quer fazer isso apenas um vez e reutilizar o mesmo objeto settings depois, em vez de ler os valores a cada requisição.
+Ler um arquivo do disco normalmente é uma operação custosa (lenta), então você provavelmente vai querer fazer isso apenas uma vez e depois reutilizar o mesmo objeto de configurações, em vez de lê-lo a cada requisição.
 
-Mas cada vez que fazemos:
+Mas toda vez que fizermos:
 
 ```Python
 Settings()
 ```
 
-um novo objeto `Settings` é instanciado, e durante a instanciação, o arquivo `.env` é lido novamente.
+um novo objeto `Settings` seria criado e, na criação, ele leria o arquivo `.env` novamente.
 
-Se a função da dependência fosse apenas:
+Se a função de dependência fosse assim:
 
 ```Python
 def get_settings():
     return Settings()
 ```
 
-Iriamos criar um novo objeto a cada requisição, e estaríamos lendo o arquivo `.env` a cada requisição. ⚠️
+criaríamos esse objeto para cada requisição e leríamos o arquivo `.env` para cada requisição. ⚠️
 
-Mas como estamos utilizando o decorador `@lru_cache` acima, o objeto `Settings` é criado apenas uma vez, na primeira vez que a função é chamada. ✔️
+Mas como estamos usando o decorador `@lru_cache` por cima, o objeto `Settings` será criado apenas uma vez, na primeira vez em que for chamado. ✔️
 
 {* ../../docs_src/settings/app03_an_py39/main.py hl[1,11] *}
 
-Dessa forma, todas as chamadas da função `get_settings()` nas dependências das próximas requisições, em vez de executar o código interno de `get_settings()` e instanciar um novo objeto `Settings`, irão retornar o mesmo objeto que foi retornado na primeira chamada, de novo e de novo.
+Em qualquer chamada subsequente de `get_settings()` nas dependências das próximas requisições, em vez de executar o código interno de `get_settings()` e criar um novo objeto `Settings`, ele retornará o mesmo objeto que foi retornado na primeira chamada, repetidamente.
 
-#### Detalhes Técnicos de `lru_cache`
+#### Detalhes Técnicos do `lru_cache` { #lru-cache-technical-details }
 
-`@lru_cache` modifica a função decorada para retornar o mesmo valor que foi retornado na primeira vez, em vez de calculá-lo novamente, executando o código da função toda vez.
+`@lru_cache` modifica a função que decora para retornar o mesmo valor que foi retornado na primeira vez, em vez de calculá-lo novamente executando o código da função todas as vezes.
 
-Assim, a função abaixo do decorador é executada uma única vez para cada combinação dos argumentos passados. E os valores retornados para cada combinação de argumentos são sempre reutilizados para cada nova chamada da função com a mesma combinação de argumentos.
+Assim, a função abaixo dele será executada uma vez para cada combinação de argumentos. E então os valores retornados para cada uma dessas combinações de argumentos serão usados repetidamente sempre que a função for chamada com exatamente a mesma combinação de argumentos.
 
-Por exemplo, se você definir uma função:
+Por exemplo, se você tiver uma função:
 
 ```Python
 @lru_cache
@@ -406,59 +288,59 @@ def say_hi(name: str, salutation: str = "Ms."):
     return f"Hello {salutation} {name}"
 ```
 
-Seu programa poderia executar dessa forma:
+seu programa poderia executar assim:
 
 ```mermaid
 sequenceDiagram
 
-participant code as Código
+participant code as Code
 participant function as say_hi()
-participant execute as Executar Função
+participant execute as Execute function
 
     rect rgba(0, 255, 0, .1)
         code ->> function: say_hi(name="Camila")
-        function ->> execute: executar código da função
-        execute ->> code: retornar o resultado
+        function ->> execute: execute function code
+        execute ->> code: return the result
     end
 
     rect rgba(0, 255, 255, .1)
         code ->> function: say_hi(name="Camila")
-        function ->> code: retornar resultado armazenado
+        function ->> code: return stored result
     end
 
     rect rgba(0, 255, 0, .1)
         code ->> function: say_hi(name="Rick")
-        function ->> execute: executar código da função
-        execute ->> code: retornar o resultado
+        function ->> execute: execute function code
+        execute ->> code: return the result
     end
 
     rect rgba(0, 255, 0, .1)
         code ->> function: say_hi(name="Rick", salutation="Mr.")
-        function ->> execute: executar código da função
-        execute ->> code: retornar o resultado
+        function ->> execute: execute function code
+        execute ->> code: return the result
     end
 
     rect rgba(0, 255, 255, .1)
         code ->> function: say_hi(name="Rick")
-        function ->> code: retornar resultado armazenado
+        function ->> code: return stored result
     end
 
     rect rgba(0, 255, 255, .1)
         code ->> function: say_hi(name="Camila")
-        function ->> code: retornar resultado armazenado
+        function ->> code: return stored result
     end
 ```
 
-No caso da nossa dependência `get_settings()`, a função não recebe nenhum argumento, então ela sempre retorna o mesmo valor.
+No caso da nossa dependência `get_settings()`, a função nem recebe argumentos, então ela sempre retorna o mesmo valor.
 
-Dessa forma, ela se comporta praticamente como uma variável global, mas ao ser utilizada como uma função de uma dependência, pode facilmente ser sobrescrita durante os testes.
+Dessa forma, ela se comporta quase como se fosse apenas uma variável global. Mas como usa uma função de dependência, podemos sobrescrevê-la facilmente para testes.
 
-`@lru_cache` é definido no módulo `functools` que faz parte da biblioteca padrão do Python, você pode ler mais sobre esse decorador no link <a href="https://docs.python.org/3/library/functools.html#functools.lru_cache" class="external-link" target="_blank">Python Docs sobre `@lru_cache`</a>.
+`@lru_cache` faz parte de `functools`, que faz parte da biblioteca padrão do Python; você pode ler mais sobre isso na <a href="https://docs.python.org/3/library/functools.html#functools.lru_cache" class="external-link" target="_blank">documentação do Python para `@lru_cache`</a>.
 
-## Recapitulando
+## Recapitulando { #recap }
 
-Você pode usar o módulo Pydantic Settings para gerenciar as configurações de sua aplicação, utilizando todo o poder dos modelos Pydantic.
+Você pode usar Pydantic Settings para lidar com as configurações da sua aplicação, com todo o poder dos modelos Pydantic.
 
-- Utilizar dependências simplifica os testes.
-- Você pode utilizar arquivos .env junto das configurações do Pydantic.
-- Utilizar o decorador `@lru_cache` evita que o arquivo .env seja lido de novo e de novo para cada requisição, enquanto permite que você sobrescreva durante os testes.
+* Usando uma dependência você pode simplificar os testes.
+* Você pode usar arquivos `.env` com ele.
+* Usar `@lru_cache` permite evitar ler o arquivo dotenv repetidamente a cada requisição, enquanto permite sobrescrevê-lo durante os testes.

docs/pt/docs/advanced/sub-applications.md

@@ -1,41 +1,41 @@
-# Sub Aplicações - Montagens
+# Sub Aplicações - Montagens { #sub-applications-mounts }
 
 Se você precisar ter duas aplicações FastAPI independentes, cada uma com seu próprio OpenAPI e suas próprias interfaces de documentação, você pode ter um aplicativo principal e "montar" uma (ou mais) sub-aplicações.
 
-## Montando uma aplicação **FastAPI**
+## Montando uma aplicação **FastAPI** { #mounting-a-fastapi-application }
 
-"Montar" significa adicionar uma aplicação completamente "independente" em um caminho específico, que então se encarrega de lidar com tudo sob esse caminho, com as operações de rota declaradas nessa sub-aplicação.
+"Montar" significa adicionar uma aplicação completamente "independente" em um path específico, que então se encarrega de lidar com tudo sob esse path, com as _operações de rota_ declaradas nessa sub-aplicação.
 
-### Aplicação de nível superior
+### Aplicação de nível superior { #top-level-application }
 
 Primeiro, crie a aplicação principal, de nível superior, **FastAPI**, e suas *operações de rota*:
 
-{* ../../docs_src/sub_applications/tutorial001.py hl[3,6:8] *}
+{* ../../docs_src/sub_applications/tutorial001.py hl[3, 6:8] *}
 
-### Sub-aplicação
+### Sub-aplicação { #sub-application }
 
 Em seguida, crie sua sub-aplicação e suas *operações de rota*.
 
 Essa sub-aplicação é apenas outra aplicação FastAPI padrão, mas esta é a que será "montada":
 
-{* ../../docs_src/sub_applications/tutorial001.py hl[11,14:16] *}
+{* ../../docs_src/sub_applications/tutorial001.py hl[11, 14:16] *}
 
-### Monte a sub-aplicação
+### Monte a sub-aplicação { #mount-the-sub-application }
 
 Na sua aplicação de nível superior, `app`, monte a sub-aplicação, `subapi`.
 
-Neste caso, ela será montada no caminho `/subapi`:
+Neste caso, ela será montada no path `/subapi`:
 
-{* ../../docs_src/sub_applications/tutorial001.py hl[11,19] *}
+{* ../../docs_src/sub_applications/tutorial001.py hl[11, 19] *}
 
-### Verifique a documentação automática da API
+### Verifique a documentação automática da API { #check-the-automatic-api-docs }
 
-Agora, execute `uvicorn` com a aplicação principal, se o seu arquivo for `main.py`, seria:
+Agora, execute o comando `fastapi` com o seu arquivo:
 
 <div class="termy">
 
 ```console
-$ uvicorn main:app --reload
+$ fastapi dev main.py
 
 <span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
 ```
@@ -50,17 +50,17 @@ Você verá a documentação automática da API para a aplicação principal, in
 
 E então, abra a documentação para a sub-aplicação, em <a href="http://127.0.0.1:8000/subapi/docs" class="external-link" target="_blank">http://127.0.0.1:8000/subapi/docs</a>.
 
-Você verá a documentação automática da API para a sub-aplicação, incluindo apenas suas próprias _operações de rota_, todas sob o prefixo de sub-caminho correto `/subapi`:
+Você verá a documentação automática da API para a sub-aplicação, incluindo apenas suas próprias _operações de rota_, todas sob o prefixo de sub-path correto `/subapi`:
 
 <img src="/img/tutorial/sub-applications/image02.png">
 
 Se você tentar interagir com qualquer uma das duas interfaces de usuário, elas funcionarão corretamente, porque o navegador será capaz de se comunicar com cada aplicação ou sub-aplicação específica.
 
-### Detalhes Técnicos: `root_path`
+### Detalhes Técnicos: `root_path` { #technical-details-root-path }
 
-Quando você monta uma sub-aplicação como descrito acima, o FastAPI se encarrega de comunicar o caminho de montagem para a sub-aplicação usando um mecanismo da especificação ASGI chamado `root_path`.
+Quando você monta uma sub-aplicação como descrito acima, o FastAPI se encarrega de comunicar o path de montagem para a sub-aplicação usando um mecanismo da especificação ASGI chamado `root_path`.
 
-Dessa forma, a sub-aplicação saberá usar esse prefixo de caminho para a interface de documentação.
+Dessa forma, a sub-aplicação saberá usar esse prefixo de path para a interface de documentação.
 
 E a sub-aplicação também poderia ter suas próprias sub-aplicações montadas e tudo funcionaria corretamente, porque o FastAPI lida com todos esses `root_path`s automaticamente.
 

docs/pt/docs/advanced/templates.md

@@ -1,4 +1,4 @@
-# Templates
+# Templates { #templates }
 
 Você pode usar qualquer template engine com o **FastAPI**.
 
@@ -6,28 +6,30 @@ Uma escolha comum é o Jinja2, o mesmo usado pelo Flask e outras ferramentas.
 
 Existem utilitários para configurá-lo facilmente que você pode usar diretamente em sua aplicação **FastAPI** (fornecidos pelo Starlette).
 
-## Instalação de dependências
+## Instalar dependências { #install-dependencies }
 
-Para instalar o `jinja2`, siga o código abaixo:
+Certifique-se de criar um [ambiente virtual](../virtual-environments.md){.internal-link target=_blank}, ativá-lo e instalar `jinja2`:
 
 <div class="termy">
 
 ```console
 $ pip install jinja2
+
+---> 100%
 ```
 
 </div>
 
-## Usando `Jinja2Templates`
+## Usando `Jinja2Templates` { #using-jinja2templates }
 
 * Importe `Jinja2Templates`.
-* Crie um `templates` que você possa reutilizar posteriormente.
+* Crie um objeto `templates` que você possa reutilizar posteriormente.
 * Declare um parâmetro `Request` no *path operation* que retornará um template.
-* Use o `template` que você criou para renderizar e retornar uma `TemplateResponse`, passe o nome do template, o request object, e um "context" dict com pares chave-valor a serem usados dentro do template do Jinja2.
+* 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.py hl[4,11,15:18] *}
 
-/// note
+/// note | Nota
 
 Antes do FastAPI 0.108.0, Starlette 0.29.0, `name` era o primeiro parâmetro.
 
@@ -49,7 +51,7 @@ Você também poderia usar `from starlette.templating import Jinja2Templates`.
 
 ///
 
-## Escrevendo Templates
+## Escrevendo templates { #writing-templates }
 
 Então você pode escrever um template em `templates/item.html`, por exemplo:
 
@@ -57,7 +59,7 @@ Então você pode escrever um template em `templates/item.html`, por exemplo:
 {!../../docs_src/templates/templates/item.html!}
 ```
 
-### Interpolação de Valores no Template
+### Valores de contexto do template { #template-context-values }
 
 No código HTML que contém:
 
@@ -81,7 +83,7 @@ Por exemplo, dado um ID de valor `42`, aparecerá:
 Item ID: 42
 ```
 
-### Argumentos do `url_for`
+### 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*.
 
@@ -103,9 +105,9 @@ Por exemplo, com um ID de `42`, isso renderizará:
 <a href="/items/42">
 ```
 
-## Templates e Arquivos Estáticos
+## Templates e arquivos estáticos { #templates-and-static-files }
 
-Você também pode usar `url_for()` dentro do template e usá-lo, por examplo, com o `StaticFiles` que você montou com o `name="static"`.
+Você também pode usar `url_for()` dentro do template e usá-lo, por exemplo, com o `StaticFiles` que você montou com o `name="static"`.
 
 ```jinja hl_lines="4"
 {!../../docs_src/templates/templates/item.html!}
@@ -117,8 +119,8 @@ Neste exemplo, ele seria vinculado a um arquivo CSS em `static/styles.css` com:
 {!../../docs_src/templates/static/styles.css!}
 ```
 
-E como você está usando `StaticFiles`, este arquivo CSS será automaticamente servido pela sua aplicação FastAPI na URL `/static/styles.css`.
+E como você está usando `StaticFiles`, este arquivo CSS será automaticamente servido pela sua aplicação **FastAPI** na URL `/static/styles.css`.
 
-## Mais detalhes
+## Mais detalhes { #more-details }
 
 Para obter mais detalhes, incluindo como testar templates, consulte a <a href="https://www.starlette.dev/templates/" class="external-link" target="_blank">documentação da Starlette sobre templates</a>.

docs/pt/docs/advanced/testing-dependencies.md

@@ -1,6 +1,6 @@
-# Testando Dependências com Sobreposição (Overrides)
+# Testando Dependências com Sobreposições { #testing-dependencies-with-overrides }
 
-## Sobrepondo dependências durante os testes
+## Sobrepondo dependências durante os testes { #overriding-dependencies-during-testing }
 
 Existem alguns cenários onde você deseje sobrepor uma dependência durante os testes.
 
@@ -8,7 +8,7 @@ Você não quer que a dependência original execute (e nenhuma das subdependênc
 
 Em vez disso, você deseja fornecer uma dependência diferente que será usada somente durante os testes (possivelmente apenas para alguns testes específicos) e fornecerá um valor que pode ser usado onde o valor da dependência original foi usado.
 
-### Casos de uso: serviço externo
+### Casos de uso: serviço externo { #use-cases-external-service }
 
 Um exemplo pode ser que você possua um provedor de autenticação externo que você precisa chamar.
 
@@ -20,7 +20,7 @@ Você provavelmente quer testar o provedor externo uma vez, mas não necessariam
 
 Neste caso, você pode sobrepor (*override*) a dependência que chama o provedor, e utilizar uma dependência customizada que retorna um *mock* do usuário, apenas para os seus testes.
 
-### Utilize o atributo `app.dependency_overrides`
+### Utilize o atributo `app.dependency_overrides` { #use-the-app-dependency-overrides-attribute }
 
 Para estes casos, a sua aplicação **FastAPI** possui o atributo `app.dependency_overrides`. Ele é um simples `dict`.
 
@@ -34,7 +34,7 @@ E então o **FastAPI** chamará a sobreposição no lugar da dependência origin
 
 Você pode definir uma sobreposição de dependência para uma dependência que é utilizada em qualquer lugar da sua aplicação **FastAPI**.
 
-A dependência original pode estar sendo utilizada em uma *função de operação de rota*, um *docorador de operação de rota* (quando você não utiliza o valor retornado), uma chamada ao `.include_router()`, etc.
+A dependência original pode estar sendo utilizada em uma *função de operação de rota*, um *decorador de operação de rota* (quando você não utiliza o valor retornado), uma chamada ao `.include_router()`, etc.
 
 O FastAPI ainda poderá sobrescrevê-lo.
 
@@ -48,6 +48,6 @@ app.dependency_overrides = {}
 
 /// tip | Dica
 
-Se você quer sobrepor uma dependência apenas para alguns testes, você pode definir a sobreposição no início do testes (dentro da função de teste) e reiniciá-la ao final (no final da função de teste).
+Se você quer sobrepor uma dependência apenas para alguns testes, você pode definir a sobreposição no início do teste (dentro da função de teste) e reiniciá-la ao final (no final da função de teste).
 
 ///

docs/pt/docs/advanced/testing-events.md

@@ -1,5 +1,11 @@
-# Testando Eventos: inicialização - encerramento
+# Testando eventos: lifespan e inicialização - encerramento { #testing-events-lifespan-and-startup-shutdown }
 
-Quando você precisa que os seus manipuladores de eventos (`startup` e `shutdown`) sejam executados em seus testes, você pode utilizar o `TestClient` usando a instrução `with`:
+Quando você precisa que o `lifespan` seja executado em seus testes, você pode utilizar o `TestClient` com a instrução `with`:
+
+{* ../../docs_src/app_testing/tutorial004.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)
+
+Para os eventos `startup` e `shutdown` descontinuados, você pode usar o `TestClient` da seguinte forma:
 
 {* ../../docs_src/app_testing/tutorial003.py hl[9:12,20:24] *}

docs/pt/docs/advanced/testing-websockets.md

@@ -1,4 +1,4 @@
-# Testando WebSockets
+# Testando WebSockets { #testing-websockets }
 
 Você pode usar o mesmo `TestClient` para testar WebSockets.
 

docs/pt/docs/advanced/using-request-directly.md

@@ -1,10 +1,10 @@
-# Utilizando o Request diretamente
+# Utilizando o Request diretamente { #using-the-request-directly }
 
 Até agora você declarou as partes da requisição que você precisa utilizando os seus tipos.
 
 Obtendo dados de:
 
-* Os parâmetros das rotas.
+* O path como parâmetros.
 * Cabeçalhos (*Headers*).
 * Cookies.
 * etc.
@@ -13,7 +13,7 @@ E ao fazer isso, o **FastAPI** está validando as informações, convertendo-as
 
 Porém há situações em que você possa precisar acessar o objeto `Request` diretamente.
 
-## Detalhes sobre o objeto `Request`
+## 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 <a href="https://www.starlette.dev/requests/" class="external-link" target="_blank">`Request`</a> do Starlette diretamente quando precisar.
 
@@ -23,7 +23,7 @@ Embora qualquer outro parâmetro declarado normalmente (o corpo da requisição
 
 Mas há situações específicas onde é útil utilizar o objeto `Request`.
 
-## Utilize o objeto `Request` diretamente
+## Utilize o objeto `Request` diretamente { #use-the-request-object-directly }
 
 Vamos imaginar que você deseja obter o endereço de IP/host do cliente dentro da sua *função de operação de rota*.
 
@@ -35,15 +35,15 @@ Ao declarar o parâmetro com o tipo sendo um `Request` em sua *função de opera
 
 /// tip | Dica
 
-Note que neste caso, nós estamos declarando o parâmetro da rota ao lado do parâmetro da requisição.
+Note que neste caso, nós estamos declarando o parâmetro de path ao lado do parâmetro da requisição.
 
-Assim, o parâmetro da rota será extraído, validado, convertido para o tipo especificado e anotado com OpenAPI.
+Assim, o parâmetro de path será extraído, validado, convertido para o tipo especificado e anotado com OpenAPI.
 
 Do mesmo jeito, você pode declarar qualquer outro parâmetro normalmente, e além disso, obter o `Request` também.
 
 ///
 
-## Documentação do `Request`
+## Documentação do `Request` { #request-documentation }
 
 Você pode ler mais sobre os detalhes do objeto <a href="https://www.starlette.dev/requests/" class="external-link" target="_blank">`Request` no site da documentação oficial do Starlette.</a>.
 

docs/pt/docs/advanced/websockets.md

@@ -1,10 +1,10 @@
-# WebSockets
+# WebSockets { #websockets }
 
 Você pode usar <a href="https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API" class="external-link" target="_blank">WebSockets</a> com **FastAPI**.
 
-## Instalando `WebSockets`
+## Instale `websockets` { #install-websockets }
 
-Garanta que você criou um [ambiente virtual](../virtual-environments.md){.internal-link target=_blank}, o ativou e instalou o `websockets`:
+Garanta que você criou um [ambiente virtual](../virtual-environments.md){.internal-link target=_blank}, o ativou e instalou o `websockets` (uma biblioteca Python que facilita o uso do protocolo "WebSocket"):
 
 <div class="termy">
 
@@ -16,9 +16,9 @@ $ pip install websockets
 
 </div>
 
-## Cliente WebSockets
+## Cliente WebSockets { #websockets-client }
 
-### Em produção
+### Em produção { #in-production }
 
 Em seu sistema de produção, você provavelmente tem um frontend criado com um framework moderno como React, Vue.js ou Angular.
 
@@ -40,11 +40,11 @@ Mas é a maneira mais simples de focar no lado do servidor de WebSockets e ter u
 
 {* ../../docs_src/websockets/tutorial001.py hl[2,6:38,41:43] *}
 
-## Criando um `websocket`
+## Crie um `websocket` { #create-a-websocket }
 
 Em sua aplicação **FastAPI**, crie um `websocket`:
 
-{*../../docs_src/websockets/tutorial001.py hl[46:47]*}
+{* ../../docs_src/websockets/tutorial001.py hl[1,46:47] *}
 
 /// note | Detalhes Técnicos
 
@@ -54,15 +54,15 @@ A **FastAPI** fornece o mesmo `WebSocket` diretamente apenas como uma conveniên
 
 ///
 
-## Aguardar por mensagens e enviar mensagens
+## Aguarde mensagens e envie mensagens { #await-for-messages-and-send-messages }
 
 Em sua rota WebSocket você pode esperar (`await`) por mensagens e enviar mensagens.
 
-{*../../docs_src/websockets/tutorial001.py hl[48:52]*}
+{* ../../docs_src/websockets/tutorial001.py hl[48:52] *}
 
 Você pode receber e enviar dados binários, de texto e JSON.
 
-## Tente você mesmo
+## Tente { #try-it }
 
 Se seu arquivo for nomeado `main.py`, execute sua aplicação com:
 
@@ -96,7 +96,7 @@ Você pode enviar (e receber) muitas mensagens:
 
 E todas elas usarão a mesma conexão WebSocket.
 
-## Usando `Depends` e outros
+## Usando `Depends` e outros { #using-depends-and-others }
 
 Nos endpoints WebSocket você pode importar do `fastapi` e usar:
 
@@ -109,7 +109,7 @@ Nos endpoints WebSocket você pode importar do `fastapi` e usar:
 
 Eles funcionam da mesma forma que para outros endpoints FastAPI/*operações de rota*:
 
-{*../../docs_src/websockets/tutorial002_an_py310.py hl[68:69,82]*}
+{* ../../docs_src/websockets/tutorial002_an_py310.py hl[68:69,82] *}
 
 /// info | Informação
 
@@ -119,7 +119,7 @@ Você pode usar um código de fechamento dos <a href="https://tools.ietf.org/htm
 
 ///
 
-### Tente os WebSockets com dependências
+### Tente os WebSockets com dependências { #try-the-websockets-with-dependencies }
 
 Se seu arquivo for nomeado `main.py`, execute sua aplicação com:
 
@@ -133,11 +133,11 @@ $ fastapi dev main.py
 
 </div>
 
-Abrar seu browser em: <a href="http://127.0.0.1:8000" class="external-link" target="_blank">http://127.0.0.1:8000</a>.
+Abra seu navegador em: <a href="http://127.0.0.1:8000" class="external-link" target="_blank">http://127.0.0.1:8000</a>.
 
 Lá você pode definir:
 
-* O "Item ID", usado na rota.
+* O "Item ID", usado no path.
 * O "Token" usado como um parâmetro de consulta.
 
 /// tip | Dica
@@ -150,15 +150,15 @@ Com isso você pode conectar o WebSocket e então enviar e receber mensagens:
 
 <img src="/img/tutorial/websockets/image05.png">
 
-## Lidando com desconexões e múltiplos clientes
+## Lidando com desconexões e múltiplos clientes { #handling-disconnections-and-multiple-clients }
 
 Quando uma conexão WebSocket é fechada, o `await websocket.receive_text()` levantará uma exceção `WebSocketDisconnect`, que você pode então capturar e lidar como neste exemplo.
 
-{*../../docs_src/websockets/tutorial003_py39.py hl[79:81]*}
+{* ../../docs_src/websockets/tutorial003_py39.py hl[79:81] *}
 
 Para testar:
 
-* Abrar o aplicativo com várias abas do navegador.
+* Abra o aplicativo com várias abas do navegador.
 * Escreva mensagens a partir delas.
 * Então feche uma das abas.
 
@@ -172,13 +172,13 @@ Client #1596980209979 left the chat
 
 O app acima é um exemplo mínimo e simples para demonstrar como lidar e transmitir mensagens para várias conexões WebSocket.
 
-Mas tenha em mente que, como tudo é manipulado na memória, em uma única lista, ele só funcionará enquanto o processo estiver em execução e só funcionará com um único processo.
+Mas tenha em mente que, como tudo é manipulado na memória, em uma única list, ele só funcionará enquanto o processo estiver em execução e só funcionará com um único processo.
 
 Se você precisa de algo fácil de integrar com o FastAPI, mas que seja mais robusto, suportado por Redis, PostgreSQL ou outros, verifique o <a href="https://github.com/encode/broadcaster" class="external-link" target="_blank">encode/broadcaster</a>.
 
 ///
 
-## Mais informações
+## Mais informações { #more-info }
 
 Para aprender mais sobre as opções, verifique a documentação do Starlette para:
 

docs/pt/docs/advanced/wsgi.md

@@ -1,22 +1,22 @@
-# Adicionando WSGI - Flask, Django, entre outros
+# Adicionando WSGI - Flask, Django, entre outros { #including-wsgi-flask-django-others }
 
-Como você viu em [Sub Applications - Mounts](sub-applications.md){.internal-link target=_blank} e [Behind a Proxy](behind-a-proxy.md){.internal-link target=_blank}, você pode **"montar"** aplicações WSGI.
+Como você viu em [Subaplicações - Montagens](sub-applications.md){.internal-link target=_blank} e [Atrás de um Proxy](behind-a-proxy.md){.internal-link target=_blank}, você pode montar aplicações WSGI.
 
 Para isso, você pode utilizar o `WSGIMiddleware` para encapsular a sua aplicação WSGI, como por exemplo Flask, Django, etc.
 
-## Usando o `WSGIMiddleware`
+## Usando `WSGIMiddleware` { #using-wsgimiddleware }
 
 Você precisa importar o `WSGIMiddleware`.
 
-Em seguinda, encapsular a aplicação WSGI (e.g. Flask) com o middleware.
+Em seguida, encapsule a aplicação WSGI (e.g. Flask) com o middleware.
 
-E então **"montar"** em um caminho de rota.
+E então monte isso sob um path.
 
-{* ../../docs_src/wsgi/tutorial001.py hl[2:3,23] *}
+{* ../../docs_src/wsgi/tutorial001.py hl[2:3,3] *}
 
-## Conferindo
+## Confira { #check-it }
 
-Agora todas as requisições sob o caminho `/v1/` serão manipuladas pela aplicação utilizando Flask.
+Agora, todas as requisições sob o path `/v1/` serão manipuladas pela aplicação Flask.
 
 E o resto será manipulado pelo **FastAPI**.
 

docs/pt/docs/alternatives.md

@@ -1,34 +1,34 @@
-# Alternativas, Inspiração e Comparações
+# Alternativas, Inspiração e Comparações { #alternatives-inspiration-and-comparisons }
 
-O que inspirou o **FastAPI**, como ele se compara às alternativas e o que FastAPI aprendeu delas.
+O que inspirou o **FastAPI**, como ele se compara às alternativas e o que ele aprendeu com elas.
 
-## Introdução
+## Introdução { #intro }
 
-**FastAPI** não poderia existir se não fosse pelos trabalhos anteriores de outras pessoas.
+**FastAPI** não existiria se não fosse pelo trabalho anterior de outras pessoas.
 
-Houveram tantas ferramentas criadas que ajudaram a inspirar sua criação.
+Houve muitas ferramentas criadas antes que ajudaram a inspirar sua criação.
 
-Tenho evitado criar um novo framework por anos. Primeiramente tentei resolver todos os recursos cobertos pelo **FastAPI** utilizando muitos frameworks diferentes, plug-ins e ferramentas.
+Tenho evitado criar um novo framework por vários anos. Primeiro tentei resolver todas as funcionalidades cobertas pelo **FastAPI** utilizando muitos frameworks, plug-ins e ferramentas diferentes.
 
-Mas em algum ponto, não houve outra opção senão criar algo que fornecesse todos esses recursos, pegando as melhores idéias de ferramentas anteriores, e combinando eles da melhor forma possível, utilizando recursos da linguagem que não estavam disponíveis antes (_Type Hints_ no Python 3.6+).
+Mas em algum momento, não havia outra opção senão criar algo que fornecesse todos esses recursos, pegando as melhores ideias de ferramentas anteriores e combinando-as da melhor maneira possível, usando funcionalidades da linguagem que nem sequer estavam disponíveis antes (anotações de tipo no Python 3.6+).
 
-## Ferramentas anteriores
+## Ferramentas anteriores { #previous-tools }
 
-### <a href="https://www.djangoproject.com/" class="external-link" target="_blank">Django</a>
+### <a href="https://www.djangoproject.com/" class="external-link" target="_blank">Django</a> { #django }
 
-É o framework mais popular e largamente confiável. É utilizado para construir sistemas como o _Instagram_.
+É o framework Python mais popular e amplamente confiável. É utilizado para construir sistemas como o Instagram.
 
-É bem acoplado com banco de dados relacional (como MySQL ou PostgreSQL), então, tendo um banco de dados NoSQL (como Couchbase, MongoDB, Cassandra etc) como a principal ferramenta de armazenamento não é muito fácil.
+É relativamente bem acoplado com bancos de dados relacionais (como MySQL ou PostgreSQL), então, ter um banco de dados NoSQL (como Couchbase, MongoDB, Cassandra, etc.) como mecanismo principal de armazenamento não é muito fácil.
 
-Foi criado para gerar HTML no _backend_, não para criar APIs utilizando um _frontend_ moderno (como React, Vue.js e Angular) ou por outros sistemas (como dispositivos <abbr title="Internet das Coisas">IoT</abbr>) comunicando com ele.
+Foi criado para gerar o HTML no backend, não para criar APIs usadas por um frontend moderno (como React, Vue.js e Angular) ou por outros sistemas (como dispositivos <abbr title="Internet of Things – Internet das Coisas">IoT</abbr>) comunicando com ele.
 
-### <a href="https://www.django-rest-framework.org/" class="external-link" target="_blank">Django REST Framework</a>
+### <a href="https://www.django-rest-framework.org/" class="external-link" target="_blank">Django REST Framework</a> { #django-rest-framework }
 
-Django REST framework foi criado para ser uma caixa de ferramentas flexível para construção de APIs web utilizando Django por baixo, para melhorar suas capacidades de API.
+Django REST framework foi criado para ser uma caixa de ferramentas flexível para construção de APIs Web utilizando Django por baixo, para melhorar suas capacidades de API.
 
-Ele é utilizado por muitas companhias incluindo Mozilla, Red Hat e Eventbrite.
+Ele é utilizado por muitas empresas incluindo Mozilla, Red Hat e Eventbrite.
 
-Ele foi um dos primeiros exemplos de **documentação automática de API**, e essa foi especificamente uma das primeiras idéias que inspirou "a busca por" **FastAPI**.
+Foi um dos primeiros exemplos de **documentação automática de API**, e essa foi especificamente uma das primeiras ideias que inspirou "a busca por" **FastAPI**.
 
 /// note | Nota
 
@@ -38,57 +38,57 @@ Django REST Framework foi criado por Tom Christie. O mesmo criador de Starlette
 
 /// check | **FastAPI** inspirado para
 
-Ter uma documentação automática da API em interface web.
+Ter uma interface web de documentação automática da API.
 
 ///
 
-### <a href="https://flask.palletsprojects.com" class="external-link" target="_blank">Flask</a>
+### <a href="https://flask.palletsprojects.com" class="external-link" target="_blank">Flask</a> { #flask }
 
-Flask é um "microframework", não inclui integração com banco de dados nem muitas das coisas que vêm por padrão no Django.
+Flask é um "microframework", não inclui integrações com banco de dados nem muitas das coisas que vêm por padrão no Django.
 
-Sua simplicidade e flexibilidade permitem fazer coisas como utilizar bancos de dados NoSQL como principal sistema de armazenamento de dados.
+Essa simplicidade e flexibilidade permitem fazer coisas como utilizar bancos de dados NoSQL como o principal sistema de armazenamento de dados.
 
-Por ser tão simples, é relativamente intuitivo de aprender, embora a documentação esteja de forma mais técnica em alguns pontos.
+Por ser muito simples, é relativamente intuitivo de aprender, embora a documentação se torne um pouco técnica em alguns pontos.
 
-Ele é comumente utilizado por outras aplicações que não necessariamente precisam de banco de dados, gerenciamento de usuários, ou algum dos muitos recursos que já vem instalados no Django. Embora muitos desses recursos possam ser adicionados com plug-ins.
+Ele também é comumente utilizado por outras aplicações que não necessariamente precisam de banco de dados, gerenciamento de usuários, ou qualquer uma das muitas funcionalidades que já vêm prontas no Django. Embora muitas dessas funcionalidades possam ser adicionadas com plug-ins.
 
-Esse desacoplamento de partes, e sendo um "microframework" que pode ser extendido para cobrir exatamente o que é necessário era um recurso chave que eu queria manter.
+Esse desacoplamento de partes, e ser um "microframework" que pode ser estendido para cobrir exatamente o que é necessário era uma funcionalidade chave que eu queria manter.
 
-Dada a simplicidade do Flask, parecia uma ótima opção para construção de APIs. A próxima coisa a procurar era um "Django REST Framework" para Flask.
+Dada a simplicidade do Flask, ele parecia uma boa opção para construção de APIs. A próxima coisa a encontrar era um "Django REST Framework" para Flask.
 
 /// check | **FastAPI** inspirado para
 
-Ser um microframework. Fazer ele fácil para misturar e combinar com ferramentas e partes necessárias.
+Ser um microframework. Tornar fácil misturar e combinar as ferramentas e partes necessárias.
 
-Ser simples e com sistema de roteamento fácil de usar.
+Ter um sistema de roteamento simples e fácil de usar.
 
 ///
 
-### <a href="https://requests.readthedocs.io" class="external-link" target="_blank">Requests</a>
+### <a href="https://requests.readthedocs.io" class="external-link" target="_blank">Requests</a> { #requests }
 
-**FastAPI** não é uma alternativa para **Requests**. O escopo deles é muito diferente.
+**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, FastAPI pegou alguma inspiração do Requests.
+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, um complementando o outro.
+Eles estão, mais ou menos, em pontas opostas, complementando-se.
 
-Requests tem um projeto muito simples e intuitivo, fácil de usar, com padrões sensíveis. Mas ao mesmo tempo, é muito poderoso e customizável.
+Requests tem um design muito simples e intuitivo, é muito fácil de usar, com padrões sensatos. Mas ao mesmo tempo, é muito poderoso e personalizável.
 
 É por isso que, como dito no site oficial:
 
 > Requests é um dos pacotes Python mais baixados de todos os tempos
 
-O jeito de usar é muito simples. Por exemplo, para fazer uma requisição `GET`, você deveria escrever:
+O jeito de usar é muito simples. Por exemplo, para fazer uma requisição `GET`, você escreveria:
 
 ```Python
 response = requests.get("http://example.com/some/url")
 ```
 
-A contra-parte da aplicação FastAPI, *rota de operação*, poderia parecer como:
+A contra-parte na aplicação FastAPI, a operação de rota, poderia ficar assim:
 
 ```Python hl_lines="1"
 @app.get("/some/url")
@@ -102,50 +102,50 @@ Veja as similaridades em `requests.get(...)` e `@app.get(...)`.
 
 * Ter uma API simples e intuitiva.
 * Utilizar nomes de métodos HTTP (operações) diretamente, de um jeito direto e intuitivo.
-* Ter padrões sensíveis, mas customizações poderosas.
+* Ter padrões sensatos, mas customizações poderosas.
 
 ///
 
-### <a href="https://swagger.io/" class="external-link" target="_blank">Swagger</a> / <a href="https://github.com/OAI/OpenAPI-Specification/" class="external-link" target="_blank">OpenAPI</a>
+### <a href="https://swagger.io/" class="external-link" target="_blank">Swagger</a> / <a href="https://github.com/OAI/OpenAPI-Specification/" class="external-link" target="_blank">OpenAPI</a> { #swagger-openapi }
 
-O principal recurso que eu queria do Django REST Framework era a documentação automática da API.
+A principal funcionalidade que eu queria do Django REST Framework era a documentação automática da API.
 
-Então eu descobri que existia um padrão para documentar APIs, utilizando JSON (ou YAML, uma extensão do JSON) chamado Swagger.
+Então descobri que existia um padrão para documentar APIs, utilizando JSON (ou YAML, uma extensão do JSON) chamado Swagger.
 
-E tinha uma interface web para APIs Swagger já criada. Então, sendo capaz de gerar documentação Swagger para uma API poderia permitir utilizar essa interface web automaticamente.
+E havia uma interface web para APIs Swagger já criada. Então, ser capaz de gerar documentação Swagger para uma API permitiria usar essa interface web automaticamente.
 
-Em algum ponto, Swagger foi dado para a Fundação Linux, e foi renomeado OpenAPI.
+Em algum ponto, Swagger foi doado para a Fundação Linux, para ser renomeado OpenAPI.
 
-Isso acontece porquê quando alguém fala sobre a versão 2.0 é comum dizer "Swagger", e para a versão 3+, "OpenAPI".
+É por isso que ao falar sobre a versão 2.0 é comum dizer "Swagger", e para a versão 3+ "OpenAPI".
 
 /// check | **FastAPI** inspirado para
 
-Adotar e usar um padrão aberto para especificações API, ao invés de algum esquema customizado.
+Adotar e usar um padrão aberto para especificações de API, em vez de um schema personalizado.
 
-E integrar ferramentas de interface para usuários baseado nos padrões:
+E integrar ferramentas de interface para usuários baseadas nos padrões:
 
 * <a href="https://github.com/swagger-api/swagger-ui" class="external-link" target="_blank">Swagger UI</a>
 * <a href="https://github.com/Rebilly/ReDoc" class="external-link" target="_blank">ReDoc</a>
 
-Esses dois foram escolhidos por serem bem populares e estáveis, mas fazendo uma pesquisa rápida, você pode encontrar dúzias de interfaces alternativas adicionais para OpenAPI (assim você poderá utilizar com **FastAPI**).
+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**).
 
 ///
 
-### Flask REST frameworks
+### Flask REST frameworks { #flask-rest-frameworks }
 
-Existem vários Flask REST frameworks, mas depois de investir tempo e trabalho investigando eles, eu descobri que muitos estão descontinuados ou abandonados, com alguns tendo questões que fizeram eles inadequados.
+Existem vários Flask REST frameworks, mas depois de investir tempo e trabalho investigando-os, descobri que muitos estão descontinuados ou abandonados, com diversas questões em aberto que os tornaram inadequados.
 
-### <a href="https://marshmallow.readthedocs.io/en/3.0/" class="external-link" target="_blank">Marshmallow</a>
+### <a href="https://marshmallow.readthedocs.io/en/stable/" class="external-link" target="_blank">Marshmallow</a> { #marshmallow }
 
-Um dos principais recursos necessários em sistemas API é "<abbr title="também chamado _ marshalling, conversão">serialização</abbr>" de dados, que é pegar dados do código (Python) e converter eles em alguma coisa que possa ser enviado através da rede. Por exemplo, converter um objeto contendo dados de um banco de dados em um objeto JSON. Converter objetos `datetime` em strings etc.
+Uma das principais funcionalidades necessárias em sistemas de API é a "<abbr title="também chamado marshalling, conversão">serialização</abbr>" de dados, que é pegar dados do código (Python) e convertê-los em algo que possa ser enviado pela rede. Por exemplo, converter um objeto contendo dados de um banco de dados em um objeto JSON. Converter objetos `datetime` em strings, etc.
 
-Outro grande recurso necessário nas APIs é validação de dados, certificando que os dados são válidos, dados certos parâmetros. Por exemplo, algum campo é `int`, e não alguma string aleatória. Isso é especialmente útil para dados que estão chegando.
+Outra grande funcionalidade necessária pelas APIs é a validação de dados, garantindo que os dados são válidos, dados certos parâmetros. Por exemplo, que algum campo seja `int`, e não alguma string aleatória. Isso é especialmente útil para dados de entrada.
 
 Sem um sistema de validação de dados, você teria que realizar todas as verificações manualmente, no código.
 
-Esses recursos são o que Marshmallow foi construído para fornecer. Ele é uma ótima biblioteca, e eu já utilizei muito antes.
+Essas funcionalidades são o que o Marshmallow foi construído para fornecer. É uma ótima biblioteca, e eu a utilizei bastante antes.
 
-Mas ele foi criado antes da existência do _type hints_ do Python. Então, para definir todo o <abbr title="definição de como os dados devem ser formados">_schema_</abbr> você precisa utilizar específicas ferramentas e classes fornecidas pelo Marshmallow.
+Mas ele foi criado antes de existirem as anotações de tipo do Python. Então, para definir cada <abbr title="a definição de como os dados devem ser formados">schema</abbr> você precisa utilizar utilitários e classes específicos fornecidos pelo Marshmallow.
 
 /// check | **FastAPI** inspirado para
 
@@ -153,17 +153,17 @@ Usar código para definir "schemas" que forneçam, automaticamente, tipos de dad
 
 ///
 
-### <a href="https://webargs.readthedocs.io/en/latest/" class="external-link" target="_blank">Webargs</a>
+### <a href="https://webargs.readthedocs.io/en/latest/" class="external-link" target="_blank">Webargs</a> { #webargs }
 
-Outro grande recurso necessário pelas APIs é a <abbr title="ler e converter para dados Python">análise</abbr> de dados vindos de requisições.
+Outra grande funcionalidade requerida pelas APIs é o <abbr title="ler e converter para dados Python">parsing</abbr> de dados vindos de requisições de entrada.
 
-Webargs é uma ferramente feita para fornecer o que está no topo de vários frameworks, inclusive Flask.
+Webargs é uma ferramenta feita para fornecer isso no topo de vários frameworks, inclusive Flask.
 
-Ele utiliza Marshmallow por baixo para validação de dados. E ele foi criado pelos mesmos desenvolvedores.
+Ele utiliza Marshmallow por baixo para a validação de dados. E foi criado pelos mesmos desenvolvedores.
 
-Ele é uma grande ferramenta e eu também a utilizei muito, antes de ter o **FastAPI**.
+É uma grande ferramenta e eu também a utilizei bastante, antes de ter o **FastAPI**.
 
-/// info
+/// info | Informação
 
 Webargs foi criado pelos mesmos desenvolvedores do Marshmallow.
 
@@ -171,29 +171,29 @@ Webargs foi criado pelos mesmos desenvolvedores do Marshmallow.
 
 /// check | **FastAPI** inspirado para
 
-Ter validação automática de dados vindos de requisições.
+Ter validação automática dos dados de requisições de entrada.
 
 ///
 
-### <a href="https://apispec.readthedocs.io/en/stable/" class="external-link" target="_blank">APISpec</a>
+### <a href="https://apispec.readthedocs.io/en/stable/" class="external-link" target="_blank">APISpec</a> { #apispec }
 
-Marshmallow e Webargs fornecem validação, análise e serialização como plug-ins.
+Marshmallow e Webargs fornecem validação, parsing e serialização como plug-ins.
 
-Mas a documentação ainda está faltando. Então APISpec foi criado.
+Mas a documentação ainda estava faltando. Então APISpec foi criado.
 
-APISpec tem plug-ins para muitos frameworks (e tem um plug-in para Starlette também).
+É um plug-in para muitos frameworks (e há um plug-in para Starlette também).
 
-O jeito como ele funciona é que você escreve a definição do _schema_ usando formato YAML dentro da _docstring_ de cada função controlando uma rota.
+O jeito como ele funciona é que você escreve a definição do schema usando formato YAML dentro da docstring de cada função que lida com uma rota.
 
-E ele gera _schemas_ OpenAPI.
+E ele gera schemas OpenAPI.
 
-É assim como funciona no Flask, Starlette, Responder etc.
+É assim como funciona no Flask, Starlette, Responder, etc.
 
-Mas então, nós temos novamente o problema de ter uma micro-sintaxe, dentro de uma string Python (um grande YAML).
+Mas então, temos novamente o problema de ter uma micro-sintaxe, dentro de uma string Python (um grande YAML).
 
-O editor não poderá ajudar muito com isso. E se nós modificarmos os parâmetros dos _schemas_ do Marshmallow e esquecer de modificar também aquela _docstring_ YAML, o _schema_ gerado pode ficar obsoleto.
+O editor não pode ajudar muito com isso. E se modificarmos parâmetros ou schemas do Marshmallow e esquecermos de também modificar aquela docstring em YAML, o schema gerado ficaria obsoleto.
 
-/// info
+/// info | Informação
 
 APISpec foi criado pelos mesmos desenvolvedores do Marshmallow.
 
@@ -201,31 +201,31 @@ APISpec foi criado pelos mesmos desenvolvedores do Marshmallow.
 
 /// check | **FastAPI** inspirado para
 
-Dar suporte a padrões abertos para APIs, OpenAPI.
+Dar suporte ao padrão aberto para APIs, OpenAPI.
 
 ///
 
-### <a href="https://flask-apispec.readthedocs.io/en/latest/" class="external-link" target="_blank">Flask-apispec</a>
+### <a href="https://flask-apispec.readthedocs.io/en/latest/" class="external-link" target="_blank">Flask-apispec</a> { #flask-apispec }
 
-É um plug-in Flask, que amarra junto Webargs, Marshmallow e APISpec.
+É um plug-in Flask, que amarra juntos Webargs, Marshmallow e APISpec.
 
-Ele utiliza a informação do Webargs e Marshmallow para gerar automaticamente _schemas_ OpenAPI, usando APISpec.
+Ele utiliza a informação do Webargs e Marshmallow para gerar automaticamente schemas OpenAPI, usando APISpec.
 
-É uma grande ferramenta, mas muito subestimada. Ela deveria ser um pouco mais popular do que muitos outros plug-ins Flask. É de ser esperado que sua documentação seja bem concisa e abstrata.
+É uma grande ferramenta, muito subestimada. Deveria ser bem mais popular do que muitos plug-ins Flask por aí. Pode ser devido à sua documentação ser concisa e abstrata demais.
 
-Isso resolveu o problema de ter que escrever YAML (outra sintaxe) dentro das _docstrings_ Python.
+Isso resolveu ter que escrever YAML (outra sintaxe) dentro das docstrings do Python.
 
-Essa combinação de Flask, Flask-apispec com Marshmallow e Webargs foi meu _backend stack_ favorito até construir o **FastAPI**.
+Essa combinação de Flask, Flask-apispec com Marshmallow e Webargs foi a minha stack de backend favorita até construir o **FastAPI**.
 
-Usando essa combinação levou a criação de vários geradores Flask _full-stack_. Há muitas _stacks_ que eu (e vários times externos) estou utilizando até agora:
+Usá-la levou à criação de vários geradores Flask full-stack. Estas são as principais stacks que eu (e várias equipes externas) tenho utilizado até agora:
 
 * <a href="https://github.com/tiangolo/full-stack" class="external-link" target="_blank">https://github.com/tiangolo/full-stack</a>
 * <a href="https://github.com/tiangolo/full-stack-flask-couchbase" class="external-link" target="_blank">https://github.com/tiangolo/full-stack-flask-couchbase</a>
 * <a href="https://github.com/tiangolo/full-stack-flask-couchdb" class="external-link" target="_blank">https://github.com/tiangolo/full-stack-flask-couchdb</a>
 
-E esses mesmos geradores _full-stack_ foram a base dos [Geradores de Projetos **FastAPI**](project-generation.md){.internal-link target=_blank}.
+E esses mesmos geradores full-stack foram a base dos [Geradores de Projetos **FastAPI**](project-generation.md){.internal-link target=_blank}.
 
-/// info
+/// info | Informação
 
 Flask-apispec foi criado pelos mesmos desenvolvedores do Marshmallow.
 
@@ -233,151 +233,149 @@ Flask-apispec foi criado pelos mesmos desenvolvedores do Marshmallow.
 
 /// check | **FastAPI** inspirado para
 
-Gerar _schema_ OpenAPI automaticamente, a partir do mesmo código que define serialização e validação.
+Gerar o schema OpenAPI automaticamente, a partir do mesmo código que define serialização e validação.
 
 ///
 
-### <a href="https://nestjs.com/" class="external-link" target="_blank">NestJS</a> (and <a href="https://angular.io/" class="external-link" target="_blank">Angular</a>)
+### <a href="https://nestjs.com/" class="external-link" target="_blank">NestJS</a> (e <a href="https://angular.io/" class="external-link" target="_blank">Angular</a>) { #nestjs-and-angular }
 
-NestJS, que não é nem Python, é um framework NodeJS JavaScript (TypeScript) inspirado pelo Angular.
+Isso nem é Python, NestJS é um framework NodeJS em JavaScript (TypeScript) inspirado pelo Angular.
 
-Ele alcança de uma forma similar ao que pode ser feito com o Flask-apispec.
+Ele alcança algo um tanto similar ao que pode ser feito com Flask-apispec.
 
-Ele tem um sistema de injeção de dependência integrado, inspirado pelo Angular 2. É necessário fazer o pré-registro dos "injetáveis" (como todos os sistemas de injeção de dependência que conheço), então, adicionando verbosidade e repetição de código.
+Ele tem um sistema de injeção de dependência integrado, inspirado pelo Angular 2. É necessário fazer o pré-registro dos "injetáveis" (como todos os sistemas de injeção de dependência que conheço), então, adiciona verbosidade e repetição de código.
 
-Como os parâmetros são descritos com tipos TypeScript (similar aos _type hints_ do Python), o suporte ao editor é muito bom.
+Como os parâmetros são descritos com tipos do TypeScript (similares às anotações de tipo do Python), o suporte do editor é muito bom.
 
-Mas como os dados TypeScript não são preservados após a compilação para o JavaScript, ele não pode depender dos tipos para definir a validação, serialização e documentação ao mesmo tempo. Devido a isso e a algumas decisões de projeto, para pegar a validação, serialização e geração automática do _schema_, é necessário adicionar decoradores em muitos lugares. Então, ele se torna muito verboso.
+Mas como os dados do TypeScript não são preservados após a compilação para JavaScript, ele não pode depender dos tipos para definir validação, serialização e documentação ao mesmo tempo. Devido a isso e a algumas decisões de projeto, para obter validação, serialização e geração automática de schema, é necessário adicionar decorators em muitos lugares. Então, ele se torna bastante verboso.
 
-Ele também não controla modelos aninhados muito bem. Então, se o corpo JSON na requisição for um objeto JSON que contém campos internos que contém objetos JSON aninhados, ele não consegue ser validado e documentado apropriadamente.
+Ele não consegue lidar muito bem com modelos aninhados. Então, se o corpo JSON na requisição for um objeto JSON que contém campos internos que por sua vez são objetos JSON aninhados, ele não consegue ser documentado e validado apropriadamente.
 
 /// check | **FastAPI** inspirado para
 
-Usar tipos Python para ter um ótimo suporte do editor.
+Usar tipos do Python para ter um ótimo suporte do editor.
 
-Ter um sistema de injeção de dependência poderoso. Achar um jeito de minimizar repetição de código.
+Ter um sistema de injeção de dependência poderoso. Encontrar um jeito de minimizar repetição de código.
 
 ///
 
-### <a href="https://sanic.readthedocs.io/en/latest/" class="external-link" target="_blank">Sanic</a>
+### <a href="https://sanic.readthedocs.io/en/latest/" class="external-link" target="_blank">Sanic</a> { #sanic }
 
-Ele foi um dos primeiros frameworks Python extremamente rápido baseado em `asyncio`. Ele foi feito para ser muito similar ao Flask.
+Ele foi um dos primeiros frameworks Python extremamente rápidos baseados em `asyncio`. Ele foi feito para ser muito similar ao Flask.
 
-/// note | Detalhes técnicos
+/// note | Detalhes Técnicos
 
-Ele utiliza <a href="https://github.com/MagicStack/uvloop" class="external-link" target="_blank">`uvloop`</a> ao invés do '_loop_' `asyncio` padrão do Python. É isso que deixa ele tão rápido.
+Ele utilizava <a href="https://github.com/MagicStack/uvloop" class="external-link" target="_blank">`uvloop`</a> em vez do loop `asyncio` padrão do Python. É isso que o deixava tão rápido.
 
-Ele claramente inspirou Uvicorn e Starlette, que são atualmente mais rápidos que o Sanic em testes de performance abertos.
+Ele claramente inspirou Uvicorn e Starlette, que atualmente são mais rápidos que o Sanic em benchmarks abertos.
 
 ///
 
 /// check | **FastAPI** inspirado para
 
-Achar um jeito de ter uma performance insana.
+Encontrar um jeito de ter uma performance insana.
 
-É por isso que o **FastAPI** é baseado em Starlette, para que ele seja o framework mais rápido disponível (performance testada por terceiros).
+É por isso que o **FastAPI** é baseado em Starlette, pois ela é o framework mais rápido disponível (testado por benchmarks de terceiros).
 
 ///
 
-### <a href="https://falconframework.org/" class="external-link" target="_blank">Falcon</a>
+### <a href="https://falconframework.org/" class="external-link" target="_blank">Falcon</a> { #falcon }
 
-Falcon é outro framework Python de alta performance, e é projetado para ser minimalista, e funciona como fundação de outros frameworks como Hug.
+Falcon é outro framework Python de alta performance, projetado para ser minimalista, e servir como base para outros frameworks como Hug.
 
-Ele usa o padrão anterior para frameworks web Python (WSGI) que é síncrono, então ele não pode controlar _WebSockets_ e outros casos de uso. No entanto, ele também tem uma boa performance.
+Ele é projetado para ter funções que recebem dois parâmetros, uma "request" e uma "response". Então você "lê" partes da requisição, e "escreve" partes para a resposta. Por causa desse design, não é possível declarar parâmetros de requisição e corpos com as anotações de tipo padrão do Python como parâmetros de função.
 
-Ele é projetado para ter funções que recebem dois parâmetros, uma "requisição" e uma "resposta". Então você "lê" as partes da requisição, e "escreve" partes para a resposta. Devido ao seu design, não é possível declarar parâmetros de requisição e corpos com _type hints_ Python padrão como parâmetros de funções.
-
-Então, validação de dados, serialização e documentação tem que ser feitos no código, não automaticamente. Ou eles terão que ser implementados como um framework acima do Falcon, como o Hug. Essa mesma distinção acontece em outros frameworks que são inspirados pelo design do Falcon, tendo um objeto de requisição e um objeto de resposta como parâmetros.
+Então, validação de dados, serialização e documentação têm que ser feitos no código, não automaticamente. Ou eles têm que ser implementados como um framework acima do Falcon, como o Hug. Essa mesma distinção acontece em outros frameworks inspirados pelo design do Falcon, de ter um objeto de request e um objeto de response como parâmetros.
 
 /// check | **FastAPI** inspirado para
 
-Achar jeitos de conseguir melhor performance.
+Encontrar maneiras de obter uma ótima performance.
 
-Juntamente com Hug (como Hug é baseado no Falcon) inspirou **FastAPI** para declarar um parâmetro de `resposta` nas funções.
+Juntamente com Hug (como Hug é baseado no Falcon) inspirou **FastAPI** a declarar um parâmetro de `response` nas funções.
 
 Embora no FastAPI seja opcional, é utilizado principalmente para configurar cabeçalhos, cookies e códigos de status alternativos.
 
 ///
 
-### <a href="https://moltenframework.com/" class="external-link" target="_blank">Molten</a>
+### <a href="https://moltenframework.com/" class="external-link" target="_blank">Molten</a> { #molten }
 
-Eu descobri Molten nos primeiros estágios da construção do **FastAPI**. E ele tem umas idéias bem similares:
+Eu descobri Molten nos primeiros estágios da construção do **FastAPI**. E ele tem ideias bastante similares:
 
-* Baseado em _type hints_ Python.
-* Validação e documentação desses tipos.
-* Sistema de injeção de dependência.
+* Baseado nas anotações de tipo do Python.
+* Validação e documentação a partir desses tipos.
+* Sistema de Injeção de Dependência.
 
-Ele não utiliza validação de dados, seriallização e documentação de bibliotecas de terceiros como o Pydantic, ele tem seu prórpio. Então, essas definições de tipo de dados não podem ser reutilizados tão facilmente.
+Ele não utiliza uma biblioteca de terceiros para validação de dados, serialização e documentação como o Pydantic, ele tem a sua própria. Então, essas definições de tipos de dados não seriam reutilizáveis tão facilmente.
 
-Ele exige um pouco mais de verbosidade nas configurações. E como é baseado no WSGI (ao invés de ASGI), ele não é projetado para ter a vantagem da alta performance fornecida por ferramentas como Uvicorn, Starlette e Sanic.
+Ele exige configurações um pouco mais verbosas. E como é baseado em WSGI (em vez de ASGI), ele não é projetado para tirar vantagem da alta performance fornecida por ferramentas como Uvicorn, Starlette e Sanic.
 
-O sistema de injeção de dependência exige pré-registro das dependências e as dependências são resolvidas baseadas nos tipos declarados. Então, não é possível declarar mais do que um "componente" que fornece um certo tipo.
+O sistema de injeção de dependência exige pré-registro das dependências e elas são resolvidas com base nos tipos declarados. Então, não é possível declarar mais de um "componente" que forneça um certo tipo.
 
-Rotas são declaradas em um único lugar, usando funções declaradas em outros lugares (ao invés de usar decoradores que possam ser colocados diretamente acima da função que controla o _endpoint_). Isso é mais perto de como o Django faz isso do que como Flask (e Starlette) faz. Ele separa no código coisas que são relativamente amarradas.
+As rotas são declaradas em um único lugar, usando funções declaradas em outros lugares (em vez de usar decorators que possam ser colocados diretamente acima da função que lida com o endpoint). Isso é mais próximo de como o Django faz do que de como o Flask (e o Starlette) fazem. Separa no código coisas que são relativamente bem acopladas.
 
 /// check | **FastAPI** inspirado para
 
-Definir validações extras para tipos de dados usando valores "padrão" de atributos dos modelos. Isso melhora o suporte do editor, e não estava disponível no Pydantic antes.
+Definir validações extras para tipos de dados usando o valor "padrão" de atributos dos modelos. Isso melhora o suporte do editor, e não estava disponível no Pydantic antes.
 
 Isso na verdade inspirou a atualização de partes do Pydantic, para dar suporte ao mesmo estilo de declaração da validação (toda essa funcionalidade já está disponível no Pydantic).
 
 ///
 
-### <a href="https://github.com/hugapi/hug" class="external-link" target="_blank">Hug</a>
+### <a href="https://github.com/hugapi/hug" class="external-link" target="_blank">Hug</a> { #hug }
 
-Hug foi um dos primeiros frameworks a implementar a declaração de tipos de parâmetros usando Python _type hints_. Isso foi uma ótima idéia que inspirou outras ferramentas a fazer o mesmo.
+Hug foi um dos primeiros frameworks a implementar a declaração de tipos de parâmetros de API usando anotações de tipo do Python. Isso foi uma ótima ideia que inspirou outras ferramentas a fazer o mesmo.
 
-Ele usou tipos customizados em suas declarações ao invés dos tipos padrão Python, mas mesmo assim foi um grande passo.
+Ele usou tipos personalizados em suas declarações em vez dos tipos padrão do Python, mas mesmo assim foi um grande passo adiante.
 
-Ele também foi um dos primeiros frameworks a gerar um _schema_ customizado declarando a API inteira em JSON.
+Ele também foi um dos primeiros frameworks a gerar um schema personalizado declarando a API inteira em JSON.
 
-Ele não era baseado em um padrão como OpenAPI e JSON Schema. Então não poderia ter interação direta com outras ferramentas, como Swagger UI. Mas novamente, era uma idéia muito inovadora.
+Ele não era baseado em um padrão como OpenAPI e JSON Schema. Então não seria simples integrá-lo com outras ferramentas, como Swagger UI. Mas novamente, era uma ideia muito inovadora.
 
-Hug tinha um incomum, interessante recurso: usando o mesmo framework, é possível criar tanto APIs como CLIs.
+Ele tem um recurso interessante e incomum: usando o mesmo framework, é possível criar APIs e também CLIs.
 
-Como é baseado nos padrões anteriores de frameworks web síncronos (WSGI), ele não pode controlar _Websockets_ e outras coisas, embora ele ainda tenha uma alta performance também.
+Como é baseado no padrão anterior para frameworks web Python síncronos (WSGI), ele não consegue lidar com Websockets e outras coisas, embora ainda tenha alta performance também.
 
-/// info
+/// info | Informação
 
-Hug foi criado por Timothy Crosley, o mesmo criador do  <a href="https://github.com/timothycrosley/isort" class="external-link" target="_blank">`isort`</a>, uma grande ferramenta para ordenação automática de _imports_ em arquivos Python.
+Hug foi criado por Timothy Crosley, o mesmo criador do <a href="https://github.com/timothycrosley/isort" class="external-link" target="_blank">`isort`</a>, uma ótima ferramenta para ordenar automaticamente imports em arquivos Python.
 
 ///
 
-/// check | Idéias inspiradas para o **FastAPI**
+/// check | Ideias que inspiraram o **FastAPI**
 
-Hug inspirou partes do APIStar, e foi uma das ferramentas que eu achei mais promissora, ao lado do APIStar.
+Hug inspirou partes do APIStar, e foi uma das ferramentas que achei mais promissoras, ao lado do APIStar.
 
-Hug ajudou a inspirar o **FastAPI** a usar _type hints_ do Python para declarar parâmetros, e para gerar um _schema_ definindo a API automaticamente.
+Hug ajudou a inspirar o **FastAPI** a usar anotações de tipo do Python para declarar parâmetros e para gerar um schema definindo a API automaticamente.
 
-Hug inspirou **FastAPI** a declarar um parâmetro de `resposta` em funções para definir cabeçalhos e cookies.
+Hug inspirou **FastAPI** a declarar um parâmetro de `response` em funções para definir cabeçalhos e cookies.
 
 ///
 
-### <a href="https://github.com/encode/apistar" class="external-link" target="_blank">APIStar</a> (<= 0.5)
+### <a href="https://github.com/encode/apistar" class="external-link" target="_blank">APIStar</a> (<= 0.5) { #apistar-0-5 }
 
-Antes de decidir construir **FastAPI** eu encontrei o servidor **APIStar**. Tinha quase tudo que eu estava procurando e tinha um grande projeto.
+Pouco antes de decidir construir o **FastAPI** eu encontrei o servidor **APIStar**. Ele tinha quase tudo o que eu estava procurando e tinha um ótimo design.
 
-Ele foi uma das primeiras implementações de um framework usando Python _type hints_ para declarar parâmetros e requisições que eu nunca vi (antes no NestJS e Molten). Eu encontrei ele mais ou menos na mesma época que o Hug. Mas o APIStar utilizava o padrão OpenAPI.
+Foi uma das primeiras implementações de um framework usando anotações de tipo do Python para declarar parâmetros e requisições que eu já vi (antes do NestJS e Molten). Eu o encontrei mais ou menos na mesma época que o Hug. Mas o APIStar utilizava o padrão OpenAPI.
 
-Ele tinha validação de dados automática, serialização de dados e geração de _schema_ OpenAPI baseado nos mesmos _type hints_ em vários locais.
+Ele tinha validação de dados automática, serialização de dados e geração de schema OpenAPI baseadas nas mesmas anotações de tipo em vários locais.
 
-Definições de _schema_ de corpo não utilizavam os mesmos Python _type hints_ como Pydantic, ele era um pouco mais similar ao Marshmallow, então, o suporte ao editor não seria tão bom, ainda assim, APIStar era a melhor opção disponível.
+As definições de schema de corpo não utilizavam as mesmas anotações de tipo do Python como o Pydantic, eram um pouco mais similares ao Marshmallow, então o suporte do editor não seria tão bom, ainda assim, APIStar era a melhor opção disponível.
 
-Ele obteve as melhores performances em testes na época (somente batido por Starlette).
+Ele obteve os melhores benchmarks de performance na época (somente ultrapassado por Starlette).
 
 A princípio, ele não tinha uma interface web com documentação automática da API, mas eu sabia que poderia adicionar o Swagger UI a ele.
 
-Ele tinha um sistema de injeção de dependência. Ele exigia pré-registro dos componentes, como outras ferramentas já discutidas acima. Mas ainda era um grande recurso.
+Ele tinha um sistema de injeção de dependência. Exigia pré-registro dos componentes, como outras ferramentas já discutidas acima. Mas ainda assim era um grande recurso.
 
-Eu nunca fui capaz de usar ele num projeto inteiro, por não ter integração de segurança, então, eu não pude substituir todos os recursos que eu tinha com os geradores _full-stack_ baseados no Flask-apispec. Eu tive em minha gaveta de projetos a idéia de criar um _pull request_ adicionando essa funcionalidade.
+Eu nunca fui capaz de usá-lo em um projeto completo, pois ele não tinha integração de segurança, então, eu não pude substituir todos os recursos que eu tinha com os geradores full-stack baseados no Flask-apispec. Eu tinha no meu backlog de projetos criar um pull request adicionando essa funcionalidade.
 
 Mas então, o foco do projeto mudou.
 
-Ele não era mais um framework web API, como o criador precisava focar no Starlette.
+Ele não era mais um framework web de API, pois o criador precisava focar no Starlette.
 
 Agora APIStar é um conjunto de ferramentas para validar especificações OpenAPI, não um framework web.
 
-/// info
+/// info | Informação
 
 APIStar foi criado por Tom Christie. O mesmo cara que criou:
 
@@ -391,98 +389,97 @@ APIStar foi criado por Tom Christie. O mesmo cara que criou:
 
 Existir.
 
-A idéia de declarar múltiplas coisas (validação de dados, serialização e documentação) com os mesmos tipos Python, que ao mesmo tempo fornecesse grande suporte ao editor, era algo que eu considerava uma brilhante idéia.
+A ideia de declarar múltiplas coisas (validação de dados, serialização e documentação) com os mesmos tipos do Python, que ao mesmo tempo fornecessem grande suporte ao editor, era algo que eu considerava uma ideia brilhante.
 
-E após procurar por um logo tempo por um framework similar e testar muitas alternativas diferentes, APIStar foi a melhor opção disponível.
+E após procurar por muito tempo por um framework similar e testar muitas alternativas diferentes, APIStar foi a melhor opção disponível.
 
-Então APIStar parou de existir como um servidor e Starlette foi criado, e foi uma nova melhor fundação para tal sistema. Essa foi a inspiração final para construir **FastAPI**.
+Então APIStar deixou de existir como servidor e o Starlette foi criado, sendo uma nova e melhor fundação para tal sistema. Essa foi a inspiração final para construir o **FastAPI**.
 
-Eu considero **FastAPI** um "sucessor espiritual" para o APIStar, evoluindo e melhorando os recursos, sistema de tipagem e outras partes, baseado na aprendizagem de todas essas ferramentas acima.
+Eu considero o **FastAPI** um "sucessor espiritual" do APIStar, enquanto aprimora e amplia as funcionalidades, o sistema de tipagem e outras partes, baseado nos aprendizados de todas essas ferramentas anteriores.
 
 ///
 
-## Usados por **FastAPI**
+## Usados por **FastAPI** { #used-by-fastapi }
 
-### <a href="https://docs.pydantic.dev/" class="external-link" target="_blank">Pydantic</a>
+### <a href="https://docs.pydantic.dev/" class="external-link" target="_blank">Pydantic</a> { #pydantic }
 
-Pydantic é uma biblioteca para definir validação de dados, serialização e documentação (usando JSON Schema) baseado nos Python _type hints_.
+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.
 
-Isso faz dele extremamente intuitivo.
+Isso o torna extremamente intuitivo.
 
-Ele é comparável ao Marshmallow. Embora ele seja mais rápido que Marshmallow em testes de performance. E ele é baseado nos mesmos Python _type hints_, o suporte ao editor é ótimo.
+Ele é comparável ao Marshmallow. Embora seja mais rápido que o Marshmallow em benchmarks. E como é baseado nas mesmas anotações de tipo do Python, o suporte do editor é ótimo.
 
 /// check | **FastAPI** usa isso para
 
-Controlar toda a validação de dados, serialização de dados e modelo de documentação automática (baseado no JSON Schema).
+Controlar toda a validação de dados, serialização de dados e documentação automática de modelos (baseada no JSON Schema).
 
-**FastAPI** então pega dados do JSON Schema e coloca eles no OpenAPI, à parte de todas as outras coisas que ele faz.
+**FastAPI** então pega esses dados do JSON Schema e os coloca no OpenAPI, além de todas as outras coisas que faz.
 
 ///
 
-### <a href="https://www.starlette.dev/" class="external-link" target="_blank">Starlette</a>
+### <a href="https://www.starlette.dev/" class="external-link" target="_blank">Starlette</a> { #starlette }
 
-Starlette é um framework/caixa de ferramentas <abbr title="O novo padrão para construção de Python web assíncrono">ASGI</abbr> peso leve, o que é ideal para construir serviços assíncronos de alta performance.
+Starlette é um framework/caixa de ferramentas <abbr title="O novo padrão para construir aplicações web Python assíncronas">ASGI</abbr> leve, o que é ideal para construir serviços asyncio de alta performance.
 
-Ele é muito simples e intuitivo. É projetado para ser extensível facilmente, e ter componentes modulares.
+Ele é muito simples e intuitivo. É projetado para ser facilmente extensível, e ter componentes modulares.
 
 Ele tem:
 
 * Performance seriamente impressionante.
 * Suporte a WebSocket.
-* Suporte a GraphQL.
-* Tarefas de processamento interno por trás dos panos.
+* Tarefas em segundo plano dentro do processo.
 * Eventos de inicialização e encerramento.
 * Cliente de testes construído com HTTPX.
-* Respostas CORS, GZip, Arquivos Estáticos, Streaming.
+* CORS, GZip, Arquivos Estáticos, respostas Streaming.
 * Suporte para Sessão e Cookie.
 * 100% coberto por testes.
 * Código base 100% anotado com tipagem.
-* Dependências complexas Zero.
+* Poucas dependências obrigatórias.
 
-Starlette é atualmente o mais rápido framework Python testado. Somente ultrapassado pelo Uvicorn, que não é um framework, mas um servidor.
+Starlette é atualmente o framework Python mais rápido testado. Somente ultrapassado pelo Uvicorn, que não é um framework, mas um servidor.
 
 Starlette fornece toda a funcionalidade básica de um microframework web.
 
-Mas ele não fornece validação de dados automática, serialização e documentação.
+Mas ele não fornece validação de dados automática, serialização ou documentação.
 
-Essa é uma das principais coisas que **FastAPI** adiciona no topo, tudo baseado em Python _type hints_ (usando Pydantic). Isso, mais o sistema de injeção de dependência, utilidades de segurança, geração de _schema_ OpenAPI, etc.
+Essa é uma das principais coisas que o **FastAPI** adiciona por cima, tudo baseado nas anotações de tipo do Python (usando Pydantic). Isso, mais o sistema de injeção de dependência, utilidades de segurança, geração de schema OpenAPI, etc.
 
 /// note | Detalhes Técnicos
 
-ASGI é um novo "padrão" sendo desenvolvido pelos membros do time central do Django. Ele ainda não está como "Padrão Python" (PEP), embora eles estejam em processo de fazer isso.
+ASGI é um novo "padrão" sendo desenvolvido por membros do time central do Django. Ele ainda não é um "padrão Python" (uma PEP), embora eles estejam no processo de fazer isso.
 
-No entanto, ele já está sendo utilizado como "padrão" por diversas ferramentas. Isso melhora enormemente a interoperabilidade, como você poderia trocar Uvicorn por qualquer outro servidor ASGI (como Daphne ou Hypercorn), ou você poderia adicionar ferramentas compatíveis com ASGI, como `python-socketio`.
+No entanto, ele já está sendo utilizado como "padrão" por diversas ferramentas. Isso melhora enormemente a interoperabilidade, pois você poderia trocar Uvicorn por qualquer outro servidor ASGI (como Daphne ou Hypercorn), ou você poderia adicionar ferramentas compatíveis com ASGI, como `python-socketio`.
 
 ///
 
 /// check | **FastAPI** usa isso para
 
-Controlar todas as partes web centrais. Adiciona recursos no topo.
+Controlar todas as partes web centrais. Adiciona funcionalidades por cima.
 
-A classe `FastAPI` em si herda `Starlette`.
+A classe `FastAPI` em si herda diretamente da classe `Starlette`.
 
-Então, qualquer coisa que você faz com Starlette, você pode fazer diretamente com **FastAPI**, pois ele é basicamente um Starlette com esteróides.
+Então, qualquer coisa que você pode fazer com Starlette, você pode fazer diretamente com o **FastAPI**, pois ele é basicamente um Starlette com esteróides.
 
 ///
 
-### <a href="https://www.uvicorn.dev/" class="external-link" target="_blank">Uvicorn</a>
+### <a href="https://www.uvicorn.dev/" class="external-link" target="_blank">Uvicorn</a> { #uvicorn }
 
-Uvicorn é um servidor ASGI peso leve, construído com uvloop e httptools.
+Uvicorn é um servidor ASGI extremamente rápido, construído com uvloop e httptools.
 
-Ele não é um framework web, mas sim um servidor. Por exemplo, ele não fornece ferramentas para roteamento por rotas. Isso é algo que um framework como Starlette (ou **FastAPI**) poderia fornecer por cima.
+Ele não é um framework web, mas sim um servidor. Por exemplo, ele não fornece ferramentas para roteamento por paths. Isso é algo que um framework como Starlette (ou **FastAPI**) forneceria por cima.
 
 Ele é o servidor recomendado para Starlette e **FastAPI**.
 
-/// check | **FastAPI** recomenda isso para
+/// check | **FastAPI** o recomenda como
 
 O principal servidor web para rodar aplicações **FastAPI**.
 
-Você pode combinar ele com o Gunicorn, para ter um servidor multi-processos assíncrono.
+Você também pode usar a opção de linha de comando `--workers` para ter um servidor assíncrono multi-processos.
 
 Verifique mais detalhes na seção [Deployment](deployment/index.md){.internal-link target=_blank}.
 
 ///
 
-## Performance e velocidade
+## Benchmarks e velocidade { #benchmarks-and-speed }
 
 Para entender, comparar e ver a diferença entre Uvicorn, Starlette e FastAPI, verifique a seção sobre [Benchmarks](benchmarks.md){.internal-link target=_blank}.

docs/pt/docs/async.md

@@ -1,10 +1,10 @@
-# Concorrência e async / await
+# Concorrência e async / await { #concurrency-and-async-await }
 
 Detalhes sobre a sintaxe `async def` para *funções de operação de rota* e alguns conceitos de código assíncrono, concorrência e paralelismo.
 
-## Com pressa?
+## Com pressa? { #in-a-hurry }
 
-<abbr title="muito longo; não li"><strong>TL;DR:</strong></abbr>
+<abbr title="too long; didn't read – muito longo; não li"><strong>TL;DR:</strong></abbr>
 
 Se você estiver utilizando bibliotecas de terceiros que dizem para você chamar as funções com `await`, como:
 
@@ -12,7 +12,7 @@ Se você estiver utilizando bibliotecas de terceiros que dizem para você chamar
 results = await some_library()
 ```
 
-Então, declare sua *função de operação de rota* com `async def` como:
+Então, declare suas *funções de operação de rota* com `async def` como:
 
 ```Python hl_lines="2"
 @app.get('/')
@@ -21,7 +21,7 @@ async def read_results():
     return results
 ```
 
-/// note
+/// note | Nota
 
 Você só pode usar `await` dentro de funções criadas com `async def`.
 
@@ -29,7 +29,7 @@ Você só pode usar `await` dentro de funções criadas com `async def`.
 
 ---
 
-Se você está usando biblioteca de terceiros que se comunica com alguma coisa (um banco de dados, uma API, sistema de arquivos etc) e não tem suporte para utilizar `await` (esse é atualmente o caso para a maioria das bibliotecas de banco de dados), então declare suas *funções de operação de rota* normalmente, com apenas `def`, como:
+Se você está usando uma biblioteca de terceiros que se comunica com alguma coisa (um banco de dados, uma API, o sistema de arquivos etc.) e não tem suporte para utilizar `await` (esse é atualmente o caso para a maioria das bibliotecas de banco de dados), então declare suas *funções de operação de rota* normalmente, com apenas `def`, como:
 
 ```Python hl_lines="2"
 @app.get('/')
@@ -40,7 +40,7 @@ def results():
 
 ---
 
-Se sua aplicação (de alguma forma) não tem que se comunicar com nada mais e esperar que o respondam, use `async def`.
+Se sua aplicação (de alguma forma) não tem que se comunicar com nada mais e esperar que o respondam, use `async def`, mesmo que você não precise usar `await` dentro dela.
 
 ---
 
@@ -54,17 +54,17 @@ De qualquer forma, em ambos os casos acima, FastAPI irá trabalhar assincronamen
 
 Mas, seguindo os passos acima, ele será capaz de fazer algumas otimizações de performance.
 
-## Detalhes Técnicos
+## Detalhes Técnicos { #technical-details }
 
-Versões modernas de Python tem suporte para **"código assíncrono"** usando algo chamado **"corrotinas"**, com sintaxe **`async` e `await`**.
+Versões modernas de Python têm suporte para **"código assíncrono"** usando algo chamado **"corrotinas"**, com sintaxe **`async` e `await`**.
 
-Vamos ver aquela frase por partes na seção abaixo:
+Vamos ver aquela frase por partes nas seções abaixo:
 
 * **Código assíncrono**
 * **`async` e `await`**
 * **Corrotinas**
 
-## Código assíncrono
+## Código assíncrono { #asynchronous-code }
 
 Código assíncrono apenas significa que a linguagem 💬 tem um jeito de dizer para o computador / programa 🤖 que em certo ponto do código, ele 🤖 terá que esperar *algo* finalizar em outro lugar. Vamos dizer que esse *algo* seja chamado "arquivo lento" 📝.
 
@@ -74,10 +74,10 @@ Então o computador / programa 🤖 irá voltar sempre que tiver uma chance, sej
 
 Depois, ele 🤖 pega a primeira tarefa para finalizar (vamos dizer, nosso "arquivo lento" 📝) e continua o que tem que fazer com ela.
 
-Esse "esperar por algo" normalmente se refere a operações <abbr title="Entrada e Saída">I/O</abbr> que são relativamente "lentas" (comparadas à velocidade do processador e da memória RAM), como esperar por:
+Esse "esperar por algo" normalmente se refere a operações <abbr title="Input and Output – Entrada e Saída">I/O</abbr> que são relativamente "lentas" (comparadas à velocidade do processador e da memória RAM), como esperar por:
 
 * dados do cliente para serem enviados através da rede
-* dados enviados pelo seu programa serem recebidos pelo clente através da rede
+* dados enviados pelo seu programa serem recebidos pelo cliente através da rede
 * conteúdo de um arquivo no disco ser lido pelo sistema e entregue ao seu programa
 * conteúdo que seu programa deu ao sistema para ser escrito no disco
 * uma operação em uma API remota
@@ -85,7 +85,7 @@ Esse "esperar por algo" normalmente se refere a operações <abbr title="Entrada
 * uma solicitação no banco de dados retornar o resultado
 * etc.
 
-Quanto o tempo de execução é consumido majoritariamente pela espera de operações <abbr title="Entrada e Saída">I/O</abbr>, essas operações são chamadas operações "limitadas por I/O".
+Quanto o tempo de execução é consumido majoritariamente pela espera de operações <abbr title="Input and Output – Entrada e Saída">I/O</abbr>, essas operações são chamadas operações "limitadas por I/O".
 
 Isso é chamado de "assíncrono" porque o computador / programa não tem que ser "sincronizado" com a tarefa lenta, esperando pelo momento exato em que a tarefa finaliza, enquanto não faz nada, para ser capaz de pegar o resultado da tarefa e dar continuidade ao trabalho.
 
@@ -93,9 +93,9 @@ Ao invés disso, sendo um sistema "assíncrono", uma vez finalizada, a tarefa po
 
 Para "síncrono" (contrário de "assíncrono") também é utilizado o termo "sequencial", porquê o computador / programa segue todos os passos, em sequência, antes de trocar para uma tarefa diferente, mesmo se alguns passos envolvam esperar.
 
-### Concorrência e hambúrgueres
+### Concorrência e hambúrgueres { #concurrency-and-burgers }
 
-Essa idéia de código **assíncrono** descrita acima é às vezes chamado de **"concorrência"**. Isso é diferente de **"paralelismo"**.
+Essa ideia de código **assíncrono** descrita acima é às vezes chamada de **"concorrência"**. Isso é diferente de **"paralelismo"**.
 
 **Concorrência** e **paralelismo** ambos são relacionados a "diferentes coisas acontecendo mais ou menos ao mesmo tempo".
 
@@ -103,31 +103,51 @@ Mas os detalhes entre *concorrência* e *paralelismo* são bem diferentes.
 
 Para ver essa diferença, imagine a seguinte história sobre hambúrgueres:
 
-### Hambúrgueres concorrentes
+### Hambúrgueres concorrentes { #concurrent-burgers }
 
 Você vai com seu _crush_ na lanchonete, e fica na fila enquanto o caixa pega os pedidos das pessoas na sua frente. 😍
 
+<img src="/img/async/concurrent-burgers/concurrent-burgers-01.png" class="illustration">
+
 Então chega a sua vez, você pede dois saborosos hambúrgueres para você e seu _crush_.  🍔🍔
 
-O caixa diz alguma coisa para o cozinheiro na cozinha para que eles saivam que têm que preparar seus hambúrgueres (mesmo que ele esteja atualmente preparando os lanches dos outros clientes).
+<img src="/img/async/concurrent-burgers/concurrent-burgers-02.png" class="illustration">
+
+O caixa diz alguma coisa para o cozinheiro na cozinha para que eles saibam que têm que preparar seus hambúrgueres (mesmo que ele esteja atualmente preparando os lanches dos outros clientes).
+
+<img src="/img/async/concurrent-burgers/concurrent-burgers-03.png" class="illustration">
 
 Você paga. 💸
 
 O caixa te entrega seu número de chamada.
 
+<img src="/img/async/concurrent-burgers/concurrent-burgers-04.png" class="illustration">
+
 Enquanto você espera, você vai com seu _crush_ e pega uma mesa, senta e conversa com seu _crush_ por um bom tempo (já que seus hambúrgueres são muito saborosos, e leva um tempo para serem preparados).
 
 Já que você está sentado na mesa com seu _crush_, esperando os hambúrgueres, você pode passar esse tempo admirando o quão lindo, maravilhoso e esperto é seu _crush_ ✨😍✨.
 
+<img src="/img/async/concurrent-burgers/concurrent-burgers-05.png" class="illustration">
+
 Enquanto espera e conversa com seu _crush_, de tempos em tempos, você verifica o número da chamada exibido no balcão para ver se já é sua vez.
 
 Então em algum momento, é finalmente sua vez. Você vai ao balcão, pega seus hambúrgueres e volta para a mesa.
 
+<img src="/img/async/concurrent-burgers/concurrent-burgers-06.png" class="illustration">
+
 Você e seu _crush_ comem os hambúrgueres e aproveitam o tempo. ✨
 
+<img src="/img/async/concurrent-burgers/concurrent-burgers-07.png" class="illustration">
+
+/// info | Informação
+
+Belas ilustrações de <a href="https://www.instagram.com/ketrinadrawsalot" class="external-link" target="_blank">Ketrina Thompson</a>. 🎨
+
+///
+
 ---
 
-Imagine que você seja o computador / programa nessa história.
+Imagine que você seja o computador / programa 🤖 nessa história.
 
 Enquanto você está na fila, você está somente ocioso 😴, esperando por sua vez, sem fazer nada muito "produtivo". Mas a fila é rápida porque o caixa só está pegando os pedidos (não os preparando), então está tudo bem.
 
@@ -139,13 +159,13 @@ Contudo, à medida que você se afasta do balcão e senta na mesa, com um númer
 
 Então o caixa 💁 diz que "seus hambúrgueres estão prontos" colocando seu número no balcão, mas você não corre que nem um maluco imediatamente quando o número exibido é o seu. Você sabe que ninguém irá roubar seus hambúrgueres porque você tem o seu número da chamada, e os outros têm os deles.
 
-Então você espera seu _crush_ terminar a história que estava contando (terminar o trabalho atual ⏯ / tarefa sendo processada 🤓), sorri gentilmente e diz que você está indo buscar os hambúrgueres.
+Então você espera seu _crush_ terminar a história que estava contando (terminar o trabalho atual ⏯ / tarefa sendo processada 🤓), sorri gentilmente e diz que você está indo buscar os hambúrgueres ⏸.
 
-Então você vai ao balcão 🔀, para a tarefa inicial que agora está finalizada⏯, pega os hambúrgueres, agradece, e leva-os para a mesa. Isso finaliza esse passo / tarefa da interação com o balcão ⏹. Isso, por sua vez, cria uma nova tarefa, a de "comer hambúrgueres" 🔀 ⏯, mas a tarefa anterior de "pegar os hambúrgueres" já está finalizada ⏹.
+Então você vai ao balcão 🔀, para a tarefa inicial que agora está finalizada ⏯, pega os hambúrgueres, agradece, e leva-os para a mesa. Isso finaliza esse passo / tarefa da interação com o balcão ⏹. Isso, por sua vez, cria uma nova tarefa, a de "comer hambúrgueres" 🔀 ⏯, mas a tarefa anterior de "pegar os hambúrgueres" já está finalizada ⏹.
 
-### Hambúrgueres paralelos
+### Hambúrgueres paralelos { #parallel-burgers }
 
-Agora vamos imaginar que esses não são "Hambúrgueres Concorrentes", e sim "Hambúrgueres Paralelos"
+Agora vamos imaginar que esses não são "Hambúrgueres Concorrentes", e sim "Hambúrgueres Paralelos".
 
 Você vai com seu _crush_ na lanchonete paralela.
 
@@ -153,29 +173,47 @@ Você fica na fila enquanto vários (vamos dizer 8) caixas que também são cozi
 
 Todo mundo na sua frente está esperando seus hambúrgueres ficarem prontos antes de deixar o caixa porque cada um dos 8 caixas vai e prepara o hambúrguer logo após receber o pedido, antes de pegar o próximo pedido.
 
+<img src="/img/async/parallel-burgers/parallel-burgers-01.png" class="illustration">
+
 Então é finalmente sua vez, você pede 2 hambúrgueres muito saborosos para você e seu _crush_.
 
 Você paga 💸.
 
+<img src="/img/async/parallel-burgers/parallel-burgers-02.png" class="illustration">
+
 O caixa vai para a cozinha.
 
 Você espera, na frente do balcão 🕙, para que ninguém pegue seus hambúrgueres antes de você, já que não tem números de chamadas.
 
+<img src="/img/async/parallel-burgers/parallel-burgers-03.png" class="illustration">
+
 Como você e seu _crush_ estão ocupados não permitindo que ninguém passe na frente e pegue seus hambúrgueres assim que estiverem prontos, você não pode dar atenção ao seu _crush_. 😞
 
-Isso é trabalho "síncrono", você está "sincronizado" com o caixa / cozinheiro👨‍🍳. Você tem que esperar 🕙 e estar lá no exato momento que o caixa / cozinheiro 👨‍🍳 terminar os hambúrgueres e os der a você, ou então, outro alguém pode pegá-los.
+Isso é trabalho "síncrono", você está "sincronizado" com o caixa / cozinheiro 👨‍🍳. Você tem que esperar 🕙 e estar lá no exato momento que o caixa / cozinheiro 👨‍🍳 terminar os hambúrgueres e os der a você, ou então, outro alguém pode pegá-los.
+
+<img src="/img/async/parallel-burgers/parallel-burgers-04.png" class="illustration">
 
 Então seu caixa / cozinheiro 👨‍🍳 finalmente volta com seus hambúrgueres, depois de um longo tempo esperando 🕙 por eles em frente ao balcão.
 
+<img src="/img/async/parallel-burgers/parallel-burgers-05.png" class="illustration">
+
 Você pega seus hambúrgueres e vai para a mesa com seu _crush_.
 
 Vocês comem os hambúrgueres, e o trabalho está terminado. ⏹
 
+<img src="/img/async/parallel-burgers/parallel-burgers-06.png" class="illustration">
+
 Não houve muita conversa ou flerte já que a maior parte do tempo foi gasto esperando 🕙 na frente do balcão. 😞
 
+/// info | Informação
+
+Belas ilustrações de <a href="https://www.instagram.com/ketrinadrawsalot" class="external-link" target="_blank">Ketrina Thompson</a>. 🎨
+
+///
+
 ---
 
-Nesse cenário dos hambúrgueres paralelos, você é um computador / programa com dois processadores (você e seu _crush_), ambos esperando 🕙 e dedicando sua atenção ⏯ "esperando no balcão" 🕙 por um bom tempo.
+Nesse cenário dos hambúrgueres paralelos, você é um computador / programa 🤖 com dois processadores (você e seu _crush_), ambos esperando 🕙 e dedicando sua atenção ⏯ "esperando no balcão" 🕙 por um bom tempo.
 
 A lanchonete paralela tem 8 processadores (caixas / cozinheiros), enquanto a lanchonete dos hambúrgueres concorrentes tinha apenas 2 (um caixa e um cozinheiro).
 
@@ -183,7 +221,7 @@ Ainda assim, a experiência final não foi a melhor. 😞
 
 ---
 
-Essa seria o equivalente paralelo à histório dos hambúrgueres. 🍔
+Essa seria o equivalente paralelo à história dos hambúrgueres. 🍔
 
 Para um exemplo "mais real", imagine um banco.
 
@@ -195,7 +233,7 @@ E você tinha que esperar 🕙 na fila por um longo tempo ou poderia perder a ve
 
 Você provavelmente não gostaria de levar seu _crush_ 😍 com você para um rolezinho no banco 🏦.
 
-### Conclusão dos hambúrgueres
+### Conclusão dos hambúrgueres { #burger-conclusion }
 
 Nesse cenário dos "hambúrgueres com seu _crush_", como tem muita espera, faz mais sentido ter um sistema concorrente ⏸🔀⏯.
 
@@ -215,7 +253,7 @@ E esse é o mesmo nível de performance que você tem com o **FastAPI**.
 
 E como você pode ter paralelismo e assincronicidade ao mesmo tempo, você tem uma maior performance do que a maioria dos frameworks NodeJS testados e lado a lado com Go, que é uma linguagem compilada, mais próxima ao C <a href="https://www.techempower.com/benchmarks/#section=data-r17&hw=ph&test=query&l=zijmkf-1" class="external-link" target="_blank">(tudo graças ao Starlette)</a>.
 
-### Concorrência é melhor que paralelismo?
+### Concorrência é melhor que paralelismo? { #is-concurrency-better-than-parallelism }
 
 Não! Essa não é a moral da história.
 
@@ -239,7 +277,7 @@ Mas nesse caso, se você trouxesse os 8 ex-caixas / cozinheiros / agora-faxineir
 
 Nesse cenário, cada um dos faxineiros (incluindo você) poderia ser um processador, fazendo a sua parte do trabalho.
 
-E a maior parte do tempo de execução é tomada por trabalho real (ao invés de ficar esperando), e o trabalho em um computador é feito pela <abbr title="Unidade de Processamento Central">CPU</abbr>. Eles chamam esses problemas de "limitados por CPU".
+E a maior parte do tempo de execução é tomada por trabalho real (ao invés de ficar esperando), e o trabalho em um computador é feito pela <abbr title="Central Processing Unit – Unidade Central de Processamento">CPU</abbr>. Eles chamam esses problemas de "limitados por CPU".
 
 ---
 
@@ -249,22 +287,20 @@ Por exemplo:
 
 * **Processamento de áudio** ou **imagem**
 * **Visão Computacional**: uma imagem é composta por milhões de pixels, cada pixel tem 3 valores / cores, processar isso normalmente exige alguma computação em todos esses pixels ao mesmo tempo
+* **Aprendizado de Máquina**: Normalmente exige muita multiplicação de matrizes e vetores. Pense numa grande planilha com números e em multiplicar todos eles juntos e ao mesmo tempo.
+* **Deep Learning**: Esse é um subcampo do Aprendizado de Máquina, então, o mesmo se aplica. A diferença é que não há apenas uma grande planilha com números para multiplicar, mas um grande conjunto delas, e em muitos casos, você utiliza um processador especial para construir e/ou usar esses modelos.
 
-* **Machine Learning**: Normalmente exige muita multiplicação de matrizes e vetores. Pense numa grande planilha com números e em multiplicar todos eles juntos e ao mesmo tempo.
-
-* **Deep Learning**: Esse é um subcampo do Machine Learning, então, o mesmo se aplica. A diferença é que não há apenas uma grande planilha com números para multiplicar, mas um grande conjunto delas, e em muitos casos, você utiliza um processador especial para construir e/ou usar esses modelos.
-
-### Concorrência + Paralelismo: Web + Machine learning
+### Concorrência + Paralelismo: Web + Aprendizado de Máquina { #concurrency-parallelism-web-machine-learning }
 
 Com **FastAPI** você pode levar a vantagem da concorrência que é muito comum para desenvolvimento web (o mesmo atrativo de NodeJS).
 
-Mas você também pode explorar os benefícios do paralelismo e multiprocessamento (tendo múltiplos processadores rodando em paralelo) para trabalhos **limitados por CPU** como aqueles em sistemas de Machine Learning.
+Mas você também pode explorar os benefícios do paralelismo e multiprocessamento (tendo múltiplos processadores rodando em paralelo) para trabalhos **limitados por CPU** como aqueles em sistemas de Aprendizado de Máquina.
 
-Isso, somado ao simples fato que Python é a principal linguagem para **Data Science**, Machine Learning e especialmente Deep Learning, faz do FastAPI uma ótima escolha para APIs web e aplicações com Data Science / Machine Learning (entre muitas outras).
+Isso, somado ao simples fato que Python é a principal linguagem para **Data Science**, Aprendizado de Máquina e especialmente Deep Learning, faz do FastAPI uma ótima escolha para APIs web e aplicações com Data Science / Aprendizado de Máquina (entre muitas outras).
 
-Para ver como alcançar esse paralelismo em produção veja a seção sobre [Deployment](deployment/index.md){.internal-link target=_blank}.
+Para ver como alcançar esse paralelismo em produção veja a seção sobre [Implantação](deployment/index.md){.internal-link target=_blank}.
 
-## `async` e `await`
+## `async` e `await` { #async-and-await }
 
 Versões modernas do Python têm um modo muito intuitivo para definir código assíncrono. Isso faz parecer do mesmo jeito do código normal "sequencial" e fazer a "espera" para você nos momentos certos.
 
@@ -274,7 +310,7 @@ Quando tem uma operação que exigirá espera antes de dar os resultados e tem s
 burgers = await get_burgers(2)
 ```
 
-A chave aqui é o `await`. Ele diz ao Python que ele tem que esperar por `get_burgers(2)` finalizar suas coisas 🕙 antes de armazenar os resultados em `burgers`. Com isso, o Python saberá que ele pode ir e fazer outras coisas 🔀 ⏯ nesse meio tempo (como receber outra requisição).
+A chave aqui é o `await`. Ele diz ao Python que ele tem que esperar ⏸ por `get_burgers(2)` finalizar suas coisas 🕙 antes de armazenar os resultados em `burgers`. Com isso, o Python saberá que ele pode ir e fazer outras coisas 🔀 ⏯ nesse meio tempo (como receber outra requisição).
 
 Para o `await` funcionar, tem que estar dentro de uma função que suporte essa assincronicidade. Para fazer isso, apenas declare a função com `async def`:
 
@@ -306,18 +342,18 @@ burgers = get_burgers(2)
 
 Então, se você está usando uma biblioteca que diz que você pode chamá-la com `await`, você precisa criar as *funções de operação de rota* com `async def`, como em:
 
-```Python hl_lines="2 3"
+```Python hl_lines="2-3"
 @app.get('/burgers')
 async def read_burgers():
     burgers = await get_burgers(2)
     return burgers
 ```
 
-### Mais detalhes técnicos
+### Mais detalhes técnicos { #more-technical-details }
 
 Você deve ter observado que `await` pode ser usado somente dentro de funções definidas com `async def`.
 
-Mas ao mesmo tempo, funções definidas com `async def` têm que ser "aguardadas". Então, funções com `async def` pdem ser chamadas somente dentro de funções definidas com `async def` também.
+Mas ao mesmo tempo, funções definidas com `async def` têm que ser "aguardadas". Então, funções com `async def` podem ser chamadas somente dentro de funções definidas com `async def` também.
 
 Então, sobre o ovo e a galinha, como você chama a primeira função async?
 
@@ -325,7 +361,7 @@ Se você estivar trabalhando com **FastAPI** não terá que se preocupar com iss
 
 Mas se você quiser usar `async` / `await` sem FastAPI, você também pode fazê-lo.
 
-### Escreva seu próprio código assíncrono
+### Escreva seu próprio código assíncrono { #write-your-own-async-code }
 
 Starlette (e **FastAPI**) são baseados no <a href="https://anyio.readthedocs.io/en/stable/" class="external-link" target="_blank">AnyIO</a>, o que o torna compatível com ambos o <a href="https://docs.python.org/3/library/asyncio-task.html" class="external-link" target="_blank">asyncio</a> da biblioteca padrão do Python, e o <a href="https://trio.readthedocs.io/en/stable/" class="external-link" target="_blank">Trio</a>.
 
@@ -333,10 +369,9 @@ Em particular, você pode usar diretamente o <a href="https://anyio.readthedocs.
 
 E até se você não estiver utilizando FastAPI, você também pode escrever suas próprias aplicações assíncronas com o <a href="https://anyio.readthedocs.io/en/stable/" class="external-link" target="_blank">AnyIO</a> por ser altamente compatível e ganhar seus benefícios (e.g. *concorrência estruturada*).
 
-Eu criei outra biblioteca em cima do AnyIO, como uma fina camada acima, para melhorar um pouco as anotações de tipo e obter melhor **autocompletar**, **erros de linha**, etc. Ela também possui uma introdução amigável e um tutorial para ajudar você a **entender** e escrever **seu próprio código async**: <a href="https://asyncer.tiangolo.com/" class="external-link" target="_blank">Asyncer</a>. Seria particularmente útil se você precisar **combinar código async com código regular** (bloqueador/síncrono).
+Eu criei outra biblioteca em cima do AnyIO, como uma fina camada acima, para melhorar um pouco as anotações de tipo e obter melhor **preenchimento automático**, **erros inline**, etc. Ela também possui uma introdução amigável e um tutorial para ajudar você a **entender** e escrever **seu próprio código async**: <a href="https://asyncer.tiangolo.com/" class="external-link" target="_blank">Asyncer</a>. Seria particularmente útil se você precisar **combinar código async com código regular** (bloqueador/síncrono).
 
-
-### Outras formas de código assíncrono
+### Outras formas de código assíncrono { #other-forms-of-asynchronous-code }
 
 Esse estilo de usar `async` e `await` é relativamente novo na linguagem.
 
@@ -346,17 +381,17 @@ Essa mesma sintaxe (ou quase a mesma) foi também incluída recentemente em vers
 
 Mas antes disso, controlar código assíncrono era bem mais complexo e difícil.
 
-Nas versões anteriores do Python, você poderia utilizar threads ou <a href="http://www.gevent.org/" class="external-link" target="_blank">Gevent</a>. Mas o código é bem mais complexo de entender, debugar, e pensar sobre.
+Nas versões anteriores do Python, você poderia utilizar threads ou <a href="https://www.gevent.org/" class="external-link" target="_blank">Gevent</a>. Mas o código é bem mais complexo de entender, debugar, e pensar sobre.
 
 Nas versões anteriores do NodeJS / Navegador JavaScript, você utilizaria "callbacks". O que leva ao "inferno do callback".
 
-## Corrotinas
+## Corrotinas { #coroutines }
 
 **Corrotina** é apenas um jeito bonitinho para a coisa que é retornada de uma função `async def`. O Python sabe que é algo como uma função, que pode começar e que vai terminar em algum ponto, mas que pode ser pausada ⏸ internamente também, sempre que tiver um `await` dentro dela.
 
 Mas toda essa funcionalidade de código assíncrono com `async` e `await` é muitas vezes resumida como usando "corrotinas". É comparável ao principal recurso chave do Go, a "Gorrotina".
 
-## Conclusão
+## Conclusão { #conclusion }
 
 Vamos ver a mesma frase de cima:
 
@@ -366,9 +401,9 @@ Isso pode fazer mais sentido agora. ✨
 
 Tudo isso é o que empodera o FastAPI (através do Starlette) e que o faz ter uma performance tão impressionante.
 
-## Detalhes muito técnicos
+## Detalhes muito técnicos { #very-technical-details }
 
-/// warning
+/// warning | Atenção
 
 Você pode provavelmente pular isso.
 
@@ -378,23 +413,23 @@ Se você tem certo conhecimento técnico (corrotinas, threads, blocking etc) e e
 
 ///
 
-### Funções de operação de rota
+### Funções de operação de rota { #path-operation-functions }
 
 Quando você declara uma *função de operação de rota* com `def` normal ao invés de `async def`, ela é rodada em uma threadpool externa que é então aguardada, ao invés de ser chamada diretamente (já que ela bloquearia o servidor).
 
-Se você está chegando de outro framework assíncrono que não funciona como descrito acima e você está acostumado a definir *funções de operação de rota* triviais somente de computação com simples `def` para ter um mínimo ganho de performance (cerca de 100 nanosegundos), por favor observe que no **FastAPI** o efeito pode ser bem o oposto. Nesses casos, é melhor usar `async def` a menos que suas *funções de operação de rota* utilizem código que performe bloqueamento <abbr title="Input/Output: disco lendo ou escrevendo, comunicações de rede.">IO</abbr>.
+Se você está chegando de outro framework assíncrono que não funciona como descrito acima e você está acostumado a definir *funções de operação de rota* triviais somente de computação com simples `def` para ter um mínimo ganho de performance (cerca de 100 nanosegundos), por favor observe que no **FastAPI** o efeito pode ser bem o oposto. Nesses casos, é melhor usar `async def` a menos que suas *funções de operação de rota* utilizem código que performe bloqueamento <abbr title="Input/Output – Entrada e Saída: leitura ou escrita no disco, comunicações de rede.">I/O</abbr>.
 
 Ainda, em ambas as situações, as chances são que o **FastAPI** [ainda será mais rápido](index.md#performance){.internal-link target=_blank} do que (ou ao menos comparável a) seu framework anterior.
 
-### Dependências
+### Dependências { #dependencies }
 
 O mesmo se aplica para as [dependências](tutorial/dependencies/index.md){.internal-link target=_blank}. Se uma dependência tem as funções com padrão `def` ao invés de `async def`, ela é rodada no threadpool externo.
 
-### Sub-dependências
+### Sub-dependências { #sub-dependencies }
 
 Você pode ter múltiplas dependências e [sub-dependências](tutorial/dependencies/sub-dependencies.md){.internal-link target=_blank} requisitando uma à outra (como parâmetros de definições de funções), algumas delas podem ser criadas com `async def` e algumas com `def` normal. Isso ainda funcionaria, e aquelas criadas com `def` normal seriam chamadas em uma thread externa (do threadpool) ao invés de serem "aguardadas".
 
-### Outras funções de utilidade
+### Outras funções de utilidade { #other-utility-functions }
 
 Qualquer outra função de utilidade que você chame diretamente pode ser criada com `def` normal ou `async def` e o FastAPI não irá afetar o modo como você a chama.
 

docs/pt/docs/benchmarks.md

@@ -1,10 +1,10 @@
-# Comparações
+# Benchmarks { #benchmarks }
 
-As comparações independentes da TechEmpower mostram as aplicações **FastAPI** rodando com Uvicorn como <a href="https://www.techempower.com/benchmarks/#section=test&runid=7464e520-0dc2-473d-bd34-dbdfd7e85911&hw=ph&test=query&l=zijzen-7" class="external-link" target="_blank">um dos _frameworks_ Python mais rápidos disponíveis</a>, somente atrás dos próprios Starlette e Uvicorn (utilizados internamente pelo FastAPI). (*)
+Benchmarks independentes da TechEmpower mostram as aplicações **FastAPI** rodando com Uvicorn como <a href="https://www.techempower.com/benchmarks/#section=test&runid=7464e520-0dc2-473d-bd34-dbdfd7e85911&hw=ph&test=query&l=zijzen-7" class="external-link" target="_blank">um dos frameworks Python mais rápidos disponíveis</a>, somente atrás dos próprios Starlette e Uvicorn (utilizados internamente pelo FastAPI).
 
 Mas quando se checa _benchmarks_ e comparações você deveria ter o seguinte em mente.
 
-## Comparações e velocidade
+## Benchmarks e velocidade { #benchmarks-and-speed }
 
 Ao verificar os _benchmarks_, é comum observar algumas ferramentas de diferentes tipos comparadas como equivalentes.
 

docs/pt/docs/deployment/cloud.md

@@ -1,13 +1,16 @@
-# Implantar FastAPI em provedores de nuvem
+# Implantar FastAPI em provedores de nuvem { #deploy-fastapi-on-cloud-providers }
 
 Você pode usar praticamente **qualquer provedor de nuvem** para implantar seu aplicativo FastAPI.
 
-Na maioria dos casos, os principais provedores de nuvem têm guias para implantar o FastAPI com eles.
+Na maioria dos casos, os principais provedores de nuvem têm tutoriais para implantar o FastAPI com eles.
 
-## Provedores de Nuvem - Patrocinadores
+## Provedores de Nuvem - Patrocinadores { #cloud-providers-sponsors }
 
 Alguns provedores de nuvem ✨ [**patrocinam o FastAPI**](../help-fastapi.md#sponsor-the-author){.internal-link target=_blank} ✨, o que garante o **desenvolvimento** contínuo e saudável do FastAPI e seu **ecossistema**.
 
-E isso mostra seu verdadeiro comprometimento com o FastAPI e sua **comunidade** (você), pois eles não querem apenas fornecer a você um **bom serviço**, mas também querem ter certeza de que você tenha uma **estrutura boa e saudável**, o FastAPI. 🙇
+E isso mostra seu verdadeiro comprometimento com o FastAPI e sua **comunidade** (você), pois eles não querem apenas fornecer a você um **bom serviço**, mas também querem ter certeza de que você tenha um **framework bom e saudável**, o FastAPI. 🙇
 
-Talvez você queira experimentar os serviços deles e seguir os guias.
+Talvez você queira experimentar os serviços deles e seguir os tutoriais:
+
+* <a href="https://docs.render.com/deploy-fastapi?utm_source=deploydoc&utm_medium=referral&utm_campaign=fastapi" class="external-link" target="_blank">Render</a>
+* <a href="https://docs.railway.com/guides/fastapi?utm_medium=integration&utm_source=docs&utm_campaign=fastapi" class="external-link" target="_blank">Railway</a>

docs/pt/docs/deployment/concepts.md

@@ -1,4 +1,4 @@
-# Conceitos de Implantações
+# Conceitos de Implantações { #deployments-concepts }
 
 Ao implantar um aplicativo **FastAPI**, ou na verdade, qualquer tipo de API da web, há vários conceitos com os quais você provavelmente se importa e, usando-os, você pode encontrar a maneira **mais apropriada** de **implantar seu aplicativo**.
 
@@ -23,7 +23,7 @@ Nos próximos capítulos, darei a você mais **receitas concretas** para implant
 
 Mas por enquanto, vamos verificar essas importantes **ideias conceituais**. Esses conceitos também se aplicam a qualquer outro tipo de API da web. 💡
 
-## Segurança - HTTPS
+## Segurança - HTTPS { #security-https }
 
 No [capítulo anterior sobre HTTPS](https.md){.internal-link target=_blank} aprendemos como o HTTPS fornece criptografia para sua API.
 
@@ -31,7 +31,7 @@ Também vimos que o HTTPS normalmente é fornecido por um componente **externo**
 
 E tem que haver algo responsável por **renovar os certificados HTTPS**, pode ser o mesmo componente ou pode ser algo diferente.
 
-### Ferramentas de exemplo para HTTPS
+### Ferramentas de exemplo para HTTPS { #example-tools-for-https }
 
 Algumas das ferramentas que você pode usar como um proxy de terminação TLS são:
 
@@ -55,11 +55,11 @@ Mostrarei alguns exemplos concretos nos próximos capítulos.
 
 Os próximos conceitos a serem considerados são todos sobre o programa que executa sua API real (por exemplo, Uvicorn).
 
-## Programa e Processo
+## Programa e Processo { #program-and-process }
 
 Falaremos muito sobre o "**processo**" em execução, então é útil ter clareza sobre o que ele significa e qual é a diferença com a palavra "**programa**".
 
-### O que é um Programa
+### O que é um Programa { #what-is-a-program }
 
 A palavra **programa** é comumente usada para descrever muitas coisas:
 
@@ -67,7 +67,7 @@ A palavra **programa** é comumente usada para descrever muitas coisas:
 * O **arquivo** que pode ser **executado** pelo sistema operacional, por exemplo: `python`, `python.exe` ou `uvicorn`.
 * Um programa específico enquanto está **em execução** no sistema operacional, usando a CPU e armazenando coisas na memória. Isso também é chamado de **processo**.
 
-### O que é um Processo
+### O que é um Processo { #what-is-a-process }
 
 A palavra **processo** normalmente é usada de forma mais específica, referindo-se apenas ao que está sendo executado no sistema operacional (como no último ponto acima):
 
@@ -88,11 +88,11 @@ E, por exemplo, você provavelmente verá que há vários processos executando o
 
 Agora que sabemos a diferença entre os termos **processo** e **programa**, vamos continuar falando sobre implantações.
 
-## Executando na inicialização
+## Executando na inicialização { #running-on-startup }
 
 Na maioria dos casos, quando você cria uma API web, você quer que ela esteja **sempre em execução**, ininterrupta, para que seus clientes possam sempre acessá-la. Isso é claro, a menos que você tenha um motivo específico para querer que ela seja executada somente em certas situações, mas na maioria das vezes você quer que ela esteja constantemente em execução e **disponível**.
 
-### Em um servidor remoto
+### Em um servidor remoto { #in-a-remote-server }
 
 Ao configurar um servidor remoto (um servidor em nuvem, uma máquina virtual, etc.), a coisa mais simples que você pode fazer é usar `fastapi run` (que usa Uvicorn) ou algo semelhante, manualmente, da mesma forma que você faz ao desenvolver localmente.
 
@@ -102,15 +102,15 @@ Mas se sua conexão com o servidor for perdida, o **processo em execução** pro
 
 E se o servidor for reiniciado (por exemplo, após atualizações ou migrações do provedor de nuvem), você provavelmente **não notará**. E por causa disso, você nem saberá que precisa reiniciar o processo manualmente. Então, sua API simplesmente permanecerá inativa. 😱
 
-### Executar automaticamente na inicialização
+### Executar automaticamente na inicialização { #run-automatically-on-startup }
 
 Em geral, você provavelmente desejará que o programa do servidor (por exemplo, Uvicorn) seja iniciado automaticamente na inicialização do servidor e, sem precisar de nenhuma **intervenção humana**, tenha um processo sempre em execução com sua API (por exemplo, Uvicorn executando seu aplicativo FastAPI).
 
-### Programa separado
+### Programa separado { #separate-program }
 
 Para conseguir isso, você normalmente terá um **programa separado** que garantiria que seu aplicativo fosse executado na inicialização. E em muitos casos, ele também garantiria que outros componentes ou aplicativos também fossem executados, por exemplo, um banco de dados.
 
-### Ferramentas de exemplo para executar na inicialização
+### Ferramentas de exemplo para executar na inicialização { #example-tools-to-run-at-startup }
 
 Alguns exemplos de ferramentas que podem fazer esse trabalho são:
 
@@ -125,29 +125,29 @@ Alguns exemplos de ferramentas que podem fazer esse trabalho são:
 
 Darei exemplos mais concretos nos próximos capítulos.
 
-## Reinicializações
+## Reinicializações { #restarts }
 
 Semelhante a garantir que seu aplicativo seja executado na inicialização, você provavelmente também deseja garantir que ele seja **reiniciado** após falhas.
 
-### Nós cometemos erros
+### Nós cometemos erros { #we-make-mistakes }
 
 Nós, como humanos, cometemos **erros** o tempo todo. O software quase *sempre* tem **bugs** escondidos em lugares diferentes. 🐛
 
 E nós, como desenvolvedores, continuamos aprimorando o código à medida que encontramos esses bugs e implementamos novos recursos (possivelmente adicionando novos bugs também 😅).
 
-### Pequenos erros são tratados automaticamente
+### Pequenos erros são tratados automaticamente { #small-errors-automatically-handled }
 
 Ao criar APIs da web com FastAPI, se houver um erro em nosso código, o FastAPI normalmente o conterá na única solicitação que acionou o erro. 🛡
 
 O cliente receberá um **Erro Interno do Servidor 500** para essa solicitação, mas o aplicativo continuará funcionando para as próximas solicitações em vez de travar completamente.
 
-### Erros maiores - Travamentos
+### Erros maiores - Travamentos { #bigger-errors-crashes }
 
 No entanto, pode haver casos em que escrevemos algum código que **trava todo o aplicativo**, fazendo com que o Uvicorn e o Python travem. 💥
 
 E ainda assim, você provavelmente não gostaria que o aplicativo permanecesse inativo porque houve um erro em um lugar, você provavelmente quer que ele **continue em execução** pelo menos para as *operações de caminho* que não estão quebradas.
 
-### Reiniciar após falha
+### Reiniciar após falha { #restart-after-crash }
 
 Mas nos casos com erros realmente graves que travam o **processo** em execução, você vai querer um componente externo que seja responsável por **reiniciar** o processo, pelo menos algumas vezes...
 
@@ -161,7 +161,7 @@ Então, vamos nos concentrar nos casos principais, onde ele pode travar completa
 
 Você provavelmente gostaria de ter a coisa responsável por reiniciar seu aplicativo como um **componente externo**, porque a essa altura, o mesmo aplicativo com Uvicorn e Python já havia travado, então não há nada no mesmo código do mesmo aplicativo que possa fazer algo a respeito.
 
-### Ferramentas de exemplo para reiniciar automaticamente
+### Ferramentas de exemplo para reiniciar automaticamente { #example-tools-to-restart-automatically }
 
 Na maioria dos casos, a mesma ferramenta usada para **executar o programa na inicialização** também é usada para lidar com **reinicializações** automáticas.
 
@@ -176,19 +176,19 @@ Por exemplo, isso poderia ser resolvido por:
 * Gerenciado internamente por um provedor de nuvem como parte de seus serviços
 * Outros...
 
-## Replicação - Processos e Memória
+## Replicação - Processos e Memória { #replication-processes-and-memory }
 
 Com um aplicativo FastAPI, usando um programa de servidor como o comando `fastapi` que executa o Uvicorn, executá-lo uma vez em **um processo** pode atender a vários clientes simultaneamente.
 
 Mas em muitos casos, você desejará executar vários processos de trabalho ao mesmo tempo.
 
-### Processos Múltiplos - Trabalhadores
+### Processos Múltiplos - Trabalhadores { #multiple-processes-workers }
 
 Se você tiver mais clientes do que um único processo pode manipular (por exemplo, se a máquina virtual não for muito grande) e tiver **vários núcleos** na CPU do servidor, você poderá ter **vários processos** em execução com o mesmo aplicativo ao mesmo tempo e distribuir todas as solicitações entre eles.
 
 Quando você executa **vários processos** do mesmo programa de API, eles são comumente chamados de **trabalhadores**.
 
-### Processos do Trabalhador e Portas
+### Processos do Trabalhador e Portas { #worker-processes-and-ports }
 
 Lembra da documentação [Sobre HTTPS](https.md){.internal-link target=_blank} que diz que apenas um processo pode escutar em uma combinação de porta e endereço IP em um servidor?
 
@@ -196,19 +196,19 @@ Isso ainda é verdade.
 
 Então, para poder ter **vários processos** ao mesmo tempo, tem que haver um **único processo escutando em uma porta** que então transmite a comunicação para cada processo de trabalho de alguma forma.
 
-### Memória por Processo
+### Memória por Processo { #memory-per-process }
 
 Agora, quando o programa carrega coisas na memória, por exemplo, um modelo de aprendizado de máquina em uma variável, ou o conteúdo de um arquivo grande em uma variável, tudo isso **consome um pouco da memória (RAM)** do servidor.
 
 E vários processos normalmente **não compartilham nenhuma memória**. Isso significa que cada processo em execução tem suas próprias coisas, variáveis ​​e memória. E se você estiver consumindo uma grande quantidade de memória em seu código, **cada processo** consumirá uma quantidade equivalente de memória.
 
-### Memória do servidor
+### Memória do servidor { #server-memory }
 
 Por exemplo, se seu código carrega um modelo de Machine Learning com **1 GB de tamanho**, quando você executa um processo com sua API, ele consumirá pelo menos 1 GB de RAM. E se você iniciar **4 processos** (4 trabalhadores), cada um consumirá 1 GB de RAM. Então, no total, sua API consumirá **4 GB de RAM**.
 
 E se o seu servidor remoto ou máquina virtual tiver apenas 3 GB de RAM, tentar carregar mais de 4 GB de RAM causará problemas. 🚨
 
-### Processos Múltiplos - Um Exemplo
+### Processos Múltiplos - Um Exemplo { #multiple-processes-an-example }
 
 Neste exemplo, há um **Processo Gerenciador** que inicia e controla dois **Processos de Trabalhadores**.
 
@@ -224,7 +224,7 @@ Um detalhe interessante é que a porcentagem da **CPU usada** por cada processo
 
 Se você tiver uma API que faz uma quantidade comparável de cálculos todas as vezes e tiver muitos clientes, então a **utilização da CPU** provavelmente *também será estável* (em vez de ficar constantemente subindo e descendo rapidamente).
 
-### Exemplos de ferramentas e estratégias de replicação
+### Exemplos de ferramentas e estratégias de replicação { #examples-of-replication-tools-and-strategies }
 
 Pode haver várias abordagens para conseguir isso, e falarei mais sobre estratégias específicas nos próximos capítulos, por exemplo, ao falar sobre Docker e contêineres.
 
@@ -247,7 +247,7 @@ Falarei mais sobre imagens de contêiner, Docker, Kubernetes, etc. em um capítu
 
 ///
 
-## Etapas anteriores antes de começar
+## Etapas anteriores antes de começar { #previous-steps-before-starting }
 
 Há muitos casos em que você deseja executar algumas etapas **antes de iniciar** sua aplicação.
 
@@ -269,7 +269,7 @@ Nesse caso, você não precisaria se preocupar com nada disso. 🤷
 
 ///
 
-### Exemplos de estratégias de etapas anteriores
+### Exemplos de estratégias de etapas anteriores { #examples-of-previous-steps-strategies }
 
 Isso **dependerá muito** da maneira como você **implanta seu sistema** e provavelmente estará conectado à maneira como você inicia programas, lida com reinicializações, etc.
 
@@ -285,7 +285,7 @@ Darei exemplos mais concretos de como fazer isso com contêineres em um capítul
 
 ///
 
-## Utilização de recursos
+## Utilização de recursos { #resource-utilization }
 
 Seu(s) servidor(es) é(são) um **recurso** que você pode consumir ou **utilizar**, com seus programas, o tempo de computação nas CPUs e a memória RAM disponível.
 
@@ -305,7 +305,7 @@ Você poderia colocar um **número arbitrário** para atingir, por exemplo, algo
 
 Você pode usar ferramentas simples como `htop` para ver a CPU e a RAM usadas no seu servidor ou a quantidade usada por cada processo. Ou você pode usar ferramentas de monitoramento mais complexas, que podem ser distribuídas entre servidores, etc.
 
-## Recapitular
+## Recapitular { #recap }
 
 Você leu aqui alguns dos principais conceitos que provavelmente precisa ter em mente ao decidir como implantar seu aplicativo:
 

docs/pt/docs/deployment/docker.md

@@ -1,4 +1,4 @@
-# FastAPI em contêineres - Docker
+# FastAPI em contêineres - Docker { #fastapi-in-containers-docker }
 
 Ao fazer o deploy de aplicações FastAPI uma abordagem comum é construir uma **imagem de contêiner Linux**. Isso normalmente é feito usando o <a href="https://www.docker.com/" class="external-link" target="_blank">**Docker**</a>. Você pode a partir disso fazer o deploy dessa imagem de algumas maneiras.
 
@@ -6,7 +6,7 @@ Usando contêineres Linux você tem diversas vantagens incluindo **segurança**,
 
 /// tip | Dica
 
-Está com pressa e já sabe dessas coisas? Pode ir direto para [`Dockerfile` abaixo 👇](#construindo-uma-imagem-docker-para-fastapi).
+Está com pressa e já sabe dessas coisas? Pode ir direto para o [`Dockerfile` abaixo 👇](#build-a-docker-image-for-fastapi).
 
 ///
 
@@ -24,25 +24,25 @@ RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
 
 COPY ./app /code/app
 
-CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "80"]
+CMD ["fastapi", "run", "app/main.py", "--port", "80"]
 
-# If running behind a proxy like Nginx or Traefik add --proxy-headers
-# CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "80", "--proxy-headers"]
+# Se estiver executando atrás de um proxy como Nginx ou Traefik, adicione --proxy-headers
+# CMD ["fastapi", "run", "app/main.py", "--port", "80", "--proxy-headers"]
 ```
 
 </details>
 
-## O que é um Contêiner
+## O que é um Contêiner { #what-is-a-container }
 
-Contêineres (especificamente contêineres Linux) são um jeito muito **leve** de empacotar aplicações contendo todas as dependências e arquivos necessários enquanto os mantém isolados de outros contêineres (outras aplicações ou componentes) no mesmo sistema.
+Contêineres (principalmente contêineres Linux) são um jeito muito **leve** de empacotar aplicações contendo todas as dependências e arquivos necessários enquanto os mantém isolados de outros contêineres (outras aplicações ou componentes) no mesmo sistema.
 
 Contêineres Linux rodam usando o mesmo kernel Linux do hospedeiro (máquina, máquina virtual, servidor na nuvem, etc). Isso simplesmente significa que eles são muito leves (comparados com máquinas virtuais emulando um sistema operacional completo).
 
 Dessa forma, contêineres consomem **poucos recursos**, uma quantidade comparável com rodar os processos diretamente (uma máquina virtual consumiria muito mais).
 
-Contêineres também possuem seus próprios processos (comumente um único processo), sistema de arquivos e rede **isolados** simplificando deploy, segurança, desenvolvimento, etc.
+Contêineres também possuem seus próprios processos em execução (comumente **um único processo**), sistema de arquivos e rede **isolados**, simplificando deploy, segurança, desenvolvimento, etc.
 
-## O que é uma Imagem de Contêiner
+## O que é uma Imagem de Contêiner { #what-is-a-container-image }
 
 Um **contêiner** roda a partir de uma **imagem de contêiner**.
 
@@ -56,7 +56,7 @@ Uma imagem de contêiner é comparável ao arquivo de **programa** e seus conte
 
 E o **contêiner** em si (em contraste à **imagem de contêiner**) é a própria instância da imagem rodando, comparável a um **processo**. Na verdade, um contêiner está rodando somente quando há um **processo rodando** (e normalmente é somente um processo). O contêiner finaliza quando não há um processo rodando nele.
 
-## Imagens de contêiner
+## Imagens de contêiner { #container-images }
 
 Docker tem sido uma das principais ferramentas para criar e gerenciar **imagens de contêiner** e **contêineres**.
 
@@ -71,15 +71,15 @@ E existe muitas outras imagens para diferentes coisas, como bancos de dados, por
 * <a href="https://hub.docker.com/_/mongo" class="external-link" target="_blank">MongoDB</a>
 * <a href="https://hub.docker.com/_/redis" class="external-link" target="_blank">Redis</a>, etc.
 
-Usando imagens de contêiner pré-prontas é muito fácil **combinar** e usar diferentes ferramentas. Por exemplo, para testar um novo banco de dados. Em muitos casos, você pode usar as **imagens oficiais** precisando somente de variáveis de ambiente para configurá-las.
+Usando imagens de contêiner pré-prontas é muito fácil **combinar** e usar diferentes ferramentas. Por exemplo, para testar um novo banco de dados. Em muitos casos, você pode usar as **imagens oficiais**, precisando somente de variáveis de ambiente para configurá-las.
 
-Dessa forma, em muitos casos você pode aprender sobre contêineres e Docker e re-usar essa experiência com diversos componentes e ferramentas.
+Dessa forma, em muitos casos você pode aprender sobre contêineres e Docker e reusar essa experiência com diversos componentes e ferramentas.
 
 Então, você rodaria **vários contêineres** com coisas diferentes, como um banco de dados, uma aplicação Python, um servidor web com uma aplicação frontend React, e conectá-los juntos via sua rede interna.
 
 Todos os sistemas de gerenciamento de contêineres (como Docker ou Kubernetes) possuem essas funcionalidades de rede integradas a eles.
 
-## Contêineres e Processos
+## Contêineres e Processos { #containers-and-processes }
 
 Uma **imagem de contêiner** normalmente inclui em seus metadados o programa padrão ou comando que deve ser executado quando o **contêiner** é iniciado e os parâmetros a serem passados para esse programa. Muito similar ao que seria se estivesse na linha de comando.
 
@@ -91,11 +91,11 @@ Um contêiner normalmente tem um **único processo**, mas também é possível i
 
 Mas não é possível ter um contêiner rodando sem **pelo menos um processo rodando**. Se o processo principal parar, o contêiner também para.
 
-## Construindo uma Imagem Docker para FastAPI
+## Construir uma Imagem Docker para FastAPI { #build-a-docker-image-for-fastapi }
 
 Okay, vamos construir algo agora! 🚀
 
-Eu vou mostrar como construir uma **imagem Docker** para FastAPI **do zero**, baseado na **imagem oficial do Python**.
+Eu vou mostrar como construir uma **imagem Docker** para FastAPI **do zero**, baseada na imagem **oficial do Python**.
 
 Isso é o que você quer fazer na **maioria dos casos**, por exemplo:
 
@@ -103,22 +103,21 @@ Isso é o que você quer fazer na **maioria dos casos**, por exemplo:
 * Quando rodando em uma **Raspberry Pi**
 * Usando um serviço em nuvem que irá rodar uma imagem de contêiner para você, etc.
 
-### O Pacote Requirements
+### Requisitos de Pacotes { #package-requirements }
 
-Você normalmente teria os **requisitos do pacote** para sua aplicação em algum arquivo.
+Você normalmente teria os **requisitos de pacotes** da sua aplicação em algum arquivo.
 
 Isso pode depender principalmente da ferramenta que você usa para **instalar** esses requisitos.
 
-O caminho mais comum de fazer isso é ter um arquivo `requirements.txt` com os nomes dos pacotes e suas versões, um por linha.
+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){.internal-link target=_blank} para definir os intervalos de versões.
+Você, naturalmente, usaria as mesmas ideias que você leu em [Sobre versões do FastAPI](versions.md){.internal-link target=_blank} para definir os intervalos de versões.
 
 Por exemplo, seu `requirements.txt` poderia parecer com:
 
 ```
-fastapi>=0.68.0,<0.69.0
-pydantic>=1.8.0,<2.0.0
-uvicorn>=0.15.0,<0.16.0
+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:
@@ -128,27 +127,25 @@ E você normalmente instalaria essas dependências de pacote com `pip`, por exem
 ```console
 $ pip install -r requirements.txt
 ---> 100%
-Successfully installed fastapi pydantic uvicorn
+Successfully installed fastapi pydantic
 ```
 
 </div>
 
-/// info
+/// info | Informação
 
-Há outros formatos e ferramentas para definir e instalar dependências de pacote.
-
-Eu vou mostrar um exemplo depois usando Poetry em uma seção abaixo. 👇
+Há outros formatos e ferramentas para definir e instalar dependências de pacotes.
 
 ///
 
-### Criando o Código do **FastAPI**
+### Crie o código do **FastAPI** { #create-the-fastapi-code }
 
 * Crie um diretório `app` e entre nele.
 * Crie um arquivo vazio `__init__.py`.
 * Crie um arquivo `main.py` com:
 
 ```Python
-from typing import Optional
+from typing import Union
 
 from fastapi import FastAPI
 
@@ -165,28 +162,28 @@ def read_item(item_id: int, q: Union[str, None] = None):
     return {"item_id": item_id, "q": q}
 ```
 
-### Dockerfile
+### Dockerfile { #dockerfile }
 
 Agora, no mesmo diretório do projeto, crie um arquivo `Dockerfile` com:
 
 ```{ .dockerfile .annotate }
-# (1)
+# (1)!
 FROM python:3.9
 
-# (2)
+# (2)!
 WORKDIR /code
 
-# (3)
+# (3)!
 COPY ./requirements.txt /code/requirements.txt
 
-# (4)
+# (4)!
 RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
 
-# (5)
+# (5)!
 COPY ./app /code/app
 
-# (6)
-CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "80"]
+# (6)!
+CMD ["fastapi", "run", "app/main.py", "--port", "80"]
 ```
 
 1. Inicie a partir da imagem base oficial do Python.
@@ -205,7 +202,7 @@ CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "80"]
 
     A opção `--no-cache-dir` diz ao `pip` para não salvar os pacotes baixados localmente, pois isso só aconteceria se `pip` fosse executado novamente para instalar os mesmos pacotes, mas esse não é o caso quando trabalhamos com contêineres.
 
-    /// note
+    /// note | Nota
 
     `--no-cache-dir` é apenas relacionado ao `pip`, não tem nada a ver com Docker ou contêineres.
 
@@ -223,21 +220,51 @@ CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "80"]
 
     Então, é importante colocar isso **perto do final** do `Dockerfile`, para otimizar o tempo de construção da imagem do contêiner.
 
-6. Defina o **comando** para rodar o servidor `uvicorn`.
+6. Defina o **comando** para usar `fastapi run`, que utiliza o Uvicorn por baixo dos panos.
 
     `CMD` recebe uma lista de strings, cada uma dessas strings é o que você digitaria na linha de comando separado por espaços.
 
     Esse comando será executado a partir do **diretório de trabalho atual**, o mesmo diretório `/code` que você definiu acima com `WORKDIR /code`.
 
-    Porque o programa será iniciado em `/code` e dentro dele está o diretório `./app` com seu código, o **Uvicorn** será capaz de ver e **importar** `app` de `app.main`.
-
-/// tip
+/// tip | Dica
 
 Revise o que cada linha faz clicando em cada bolha com o número no código. 👆
 
 ///
 
-Agora você deve ter uma estrutura de diretório como:
+/// warning | Atenção
+
+Certifique-se de **sempre** usar a **forma exec** da instrução `CMD`, como explicado abaixo.
+
+///
+
+#### Use `CMD` - Forma Exec { #use-cmd-exec-form }
+
+A instrução <a href="https://docs.docker.com/reference/dockerfile/#cmd" class="external-link" target="_blank">`CMD`</a> no Docker pode ser escrita de duas formas:
+
+✅ Forma **Exec**:
+
+```Dockerfile
+# ✅ Faça assim
+CMD ["fastapi", "run", "app/main.py", "--port", "80"]
+```
+
+⛔️ Forma **Shell**:
+
+```Dockerfile
+# ⛔️ Não faça assim
+CMD fastapi run app/main.py --port 80
+```
+
+Garanta que você sempre use a forma **exec** para assegurar que o FastAPI consiga encerrar graciosamente e que os [eventos de lifespan](../advanced/events.md){.internal-link target=_blank} sejam disparados.
+
+Você pode ler mais na <a href="https://docs.docker.com/reference/dockerfile/#shell-and-exec-form" class="external-link" target="_blank">documentação do Docker sobre as formas shell e exec</a>.
+
+Isso pode ser bem perceptível ao usar `docker compose`. Veja esta seção de FAQ do Docker Compose para mais detalhes técnicos: <a href="https://docs.docker.com/compose/faq/#why-do-my-services-take-10-seconds-to-recreate-or-stop" class="external-link" target="_blank">Por que meus serviços demoram 10 segundos para recriar ou parar?</a>.
+
+#### Estrutura de diretórios { #directory-structure }
+
+Agora você deve haver uma estrutura de diretório como:
 
 ```
 .
@@ -248,15 +275,15 @@ Agora você deve ter uma estrutura de diretório como:
 └── requirements.txt
 ```
 
-#### Por Trás de um Proxy de Terminação TLS
+#### Por trás de um Proxy de Terminação TLS { #behind-a-tls-termination-proxy }
 
-Se você está executando seu contêiner atrás de um Proxy de Terminação TLS (load balancer) como Nginx ou Traefik, adicione a opção `--proxy-headers`, isso fará com que o Uvicorn confie nos cabeçalhos enviados por esse proxy, informando que o aplicativo está sendo executado atrás do HTTPS, etc.
+Se você está executando seu contêiner atrás de um Proxy de Terminação TLS (load balancer) como Nginx ou Traefik, adicione a opção `--proxy-headers`, isso fará com que o Uvicorn (pela CLI do FastAPI) confie nos cabeçalhos enviados por esse proxy, informando que o aplicativo está sendo executado atrás do HTTPS, etc.
 
 ```Dockerfile
-CMD ["uvicorn", "app.main:app", "--proxy-headers", "--host", "0.0.0.0", "--port", "80"]
+CMD ["fastapi", "run", "app/main.py", "--proxy-headers", "--port", "80"]
 ```
 
-#### Cache Docker
+#### Cache Docker { #docker-cache }
 
 Existe um truque importante nesse `Dockerfile`, primeiro copiamos o **arquivo com as dependências sozinho**, não o resto do código. Deixe-me te contar o porquê disso.
 
@@ -288,7 +315,7 @@ A partir daí, perto do final do `Dockerfile`, copiamos todo o código. Como iss
 COPY ./app /code/app
 ```
 
-### Construindo a Imagem Docker
+### Construa a Imagem Docker { #build-the-docker-image }
 
 Agora que todos os arquivos estão no lugar, vamos construir a imagem do contêiner.
 
@@ -305,7 +332,7 @@ $ docker build -t myimage .
 
 </div>
 
-/// tip
+/// tip | Dica
 
 Note o `.` no final, é equivalente a `./`, ele diz ao Docker o diretório a ser usado para construir a imagem do contêiner.
 
@@ -313,19 +340,19 @@ Nesse caso, é o mesmo diretório atual (`.`).
 
 ///
 
-### Inicie o contêiner Docker
+### Inicie o Contêiner Docker { #start-the-docker-container }
 
 * Execute um contêiner baseado na sua imagem:
 
 <div class="termy">
 
 ```console
-$ docker run -d --name mycontêiner -p 80:80 myimage
+$ docker run -d --name mycontainer -p 80:80 myimage
 ```
 
 </div>
 
-## Verifique
+## Verifique { #check-it }
 
 Você deve ser capaz de verificar isso no URL do seu contêiner Docker, por exemplo: <a href="http://192.168.99.100/items/5?q=somequery" class="external-link" target="_blank">http://192.168.99.100/items/5?q=somequery</a> ou <a href="http://127.0.0.1/items/5?q=somequery" class="external-link" target="_blank">http://127.0.0.1/items/5?q=somequery</a> (ou equivalente, usando seu host Docker).
 
@@ -335,7 +362,7 @@ Você verá algo como:
 {"item_id": 5, "q": "somequery"}
 ```
 
-## Documentação interativa da API
+## Documentação interativa da API { #interactive-api-docs }
 
 Agora você pode ir para <a href="http://192.168.99.100/docs" class="external-link" target="_blank">http://192.168.99.100/docs</a> ou <a href="http://127.0.0.1/docs" class="external-link" target="_blank">http://127.0.0.1/docs</a> (ou equivalente, usando seu host Docker).
 
@@ -343,7 +370,7 @@ Você verá a documentação interativa automática da API (fornecida pelo <a hr
 
 ![Swagger UI](https://fastapi.tiangolo.com/img/index/index-01-swagger-ui-simple.png)
 
-## Documentação alternativa da API
+## Documentação alternativa da API { #alternative-api-docs }
 
 E você também pode ir para <a href="http://192.168.99.100/redoc" class="external-link" target="_blank">http://192.168.99.100/redoc</a> ou <a href="http://127.0.0.1/redoc" class="external-link" target="_blank">http://127.0.0.1/redoc</a> (ou equivalente, usando seu host Docker).
 
@@ -351,7 +378,7 @@ Você verá a documentação alternativa automática (fornecida pela <a href="ht
 
 ![ReDoc](https://fastapi.tiangolo.com/img/index/index-02-redoc-simple.png)
 
-## Construindo uma Imagem Docker com um Arquivo Único FastAPI
+## Construa uma Imagem Docker com um FastAPI de Arquivo Único { #build-a-docker-image-with-a-single-file-fastapi }
 
 Se seu FastAPI for um único arquivo, por exemplo, `main.py` sem um diretório `./app`, sua estrutura de arquivos poderia ser assim:
 
@@ -373,20 +400,20 @@ COPY ./requirements.txt /code/requirements.txt
 
 RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
 
-# (1)
+# (1)!
 COPY ./main.py /code/
 
-# (2)
-CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "80"]
+# (2)!
+CMD ["fastapi", "run", "main.py", "--port", "80"]
 ```
 
 1. Copie o arquivo `main.py` para o diretório `/code` diretamente (sem nenhum diretório `./app`).
 
-2. Execute o Uvicorn e diga a ele para importar o objeto `app` de `main` (em vez de importar de `app.main`).
+2. Use `fastapi run` para servir sua aplicação no arquivo único `main.py`.
 
-Então ajuste o comando Uvicorn para usar o novo módulo `main` em vez de `app.main` para importar o objeto FastAPI `app`.
+Quando você passa o arquivo para `fastapi run` ele detecta automaticamente que é um arquivo único e não parte de um pacote e sabe como importá-lo e servir sua aplicação FastAPI. 😎
 
-## Conceitos de Implantação
+## Conceitos de Implantação { #deployment-concepts }
 
 Vamos falar novamente sobre alguns dos mesmos [Conceitos de Implantação](concepts.md){.internal-link target=_blank} em termos de contêineres.
 
@@ -403,21 +430,21 @@ Vamos revisar esses **conceitos de implantação** em termos de contêineres:
 * Memória
 * Passos anteriores antes de começar
 
-## HTTPS
+## HTTPS { #https }
 
 Se nos concentrarmos apenas na **imagem do contêiner** para um aplicativo FastAPI (e posteriormente no **contêiner** em execução), o HTTPS normalmente seria tratado **externamente** por outra ferramenta.
 
 Isso poderia ser outro contêiner, por exemplo, com <a href="https://traefik.io/" class="external-link" target="_blank">Traefik</a>, lidando com **HTTPS** e aquisição **automática** de **certificados**.
 
-/// tip
+/// tip | Dica
 
-Traefik tem integrações com Docker, Kubernetes e outros, portanto, é muito fácil configurar e configurar o HTTPS para seus contêineres com ele.
+Traefik tem integrações com Docker, Kubernetes e outros, portanto, é muito fácil configurar o HTTPS para seus contêineres com ele.
 
 ///
 
 Alternativamente, o HTTPS poderia ser tratado por um provedor de nuvem como um de seus serviços (enquanto ainda executasse o aplicativo em um contêiner).
 
-## Executando na inicialização e reinicializações
+## Executando na inicialização e reinicializações { #running-on-startup-and-restarts }
 
 Normalmente, outra ferramenta é responsável por **iniciar e executar** seu contêiner.
 
@@ -427,21 +454,21 @@ Na maioria (ou em todos) os casos, há uma opção simples para habilitar a exec
 
 Sem usar contêineres, fazer aplicativos executarem na inicialização e com reinicializações pode ser trabalhoso e difícil. Mas quando **trabalhando com contêineres** em muitos casos essa funcionalidade é incluída por padrão. ✨
 
-## Replicação - Número de Processos
+## Replicação - Número de Processos { #replication-number-of-processes }
 
-Se você tiver um <abbr title="Um grupo de máquinas que são configuradas para estarem conectadas e trabalharem juntas de alguma forma">cluster</abbr> de máquinas com **Kubernetes**, Docker Swarm Mode, Nomad ou outro sistema complexo semelhante para gerenciar contêineres distribuídos em várias máquinas, então provavelmente desejará **lidar com a replicação** no **nível do cluster** em vez de usar um **gerenciador de processos** (como o Gunicorn com workers) em cada contêiner.
+Se você tiver um <abbr title="Um grupo de máquinas que são configuradas para estarem conectadas e trabalharem juntas de alguma forma.">cluster</abbr> de máquinas com **Kubernetes**, Docker Swarm Mode, Nomad ou outro sistema complexo semelhante para gerenciar contêineres distribuídos em várias máquinas, então provavelmente desejará **lidar com a replicação** no **nível do cluster** em vez de usar um **gerenciador de processos** (como Uvicorn com workers) em cada contêiner.
 
 Um desses sistemas de gerenciamento de contêineres distribuídos como o Kubernetes normalmente tem alguma maneira integrada de lidar com a **replicação de contêineres** enquanto ainda oferece **balanceamento de carga** para as solicitações recebidas. Tudo no **nível do cluster**.
 
-Nesses casos, você provavelmente desejará criar uma **imagem do contêiner do zero** como [explicado acima](#dockerfile), instalando suas dependências e executando **um único processo Uvicorn** em vez de executar algo como Gunicorn com trabalhadores Uvicorn.
+Nesses casos, você provavelmente desejará criar uma **imagem Docker do zero** como [explicado acima](#dockerfile), instalando suas dependências e executando **um único processo Uvicorn** em vez de usar múltiplos workers do Uvicorn.
 
-### Balanceamento de Carga
+### Balanceador de Carga { #load-balancer }
 
 Quando usando contêineres, normalmente você terá algum componente **escutando na porta principal**. Poderia ser outro contêiner que também é um **Proxy de Terminação TLS** para lidar com **HTTPS** ou alguma ferramenta semelhante.
 
-Como esse componente assumiria a **carga** de solicitações e distribuiria isso entre os trabalhadores de uma maneira (esperançosamente) **balanceada**, ele também é comumente chamado de **Balanceador de Carga**.
+Como esse componente assumiria a **carga** de solicitações e distribuiria isso entre os workers de uma maneira (esperançosamente) **balanceada**, ele também é comumente chamado de **Balanceador de Carga**.
 
-/// tip
+/// tip | Dica
 
 O mesmo componente **Proxy de Terminação TLS** usado para HTTPS provavelmente também seria um **Balanceador de Carga**.
 
@@ -449,9 +476,9 @@ O mesmo componente **Proxy de Terminação TLS** usado para HTTPS provavelmente
 
 E quando trabalhar com contêineres, o mesmo sistema que você usa para iniciar e gerenciá-los já terá ferramentas internas para transmitir a **comunicação de rede** (por exemplo, solicitações HTTP) do **balanceador de carga** (que também pode ser um **Proxy de Terminação TLS**) para o(s) contêiner(es) com seu aplicativo.
 
-### Um Balanceador de Carga - Múltiplos Contêineres de Workers
+### Um Balanceador de Carga - Múltiplos Contêineres de Workers { #one-load-balancer-multiple-worker-containers }
 
-Quando trabalhando com **Kubernetes** ou sistemas similares de gerenciamento de contêiner distribuído, usando seus mecanismos de rede internos permitiria que o único **balanceador de carga** que estivesse escutando na **porta principal** transmitisse comunicação (solicitações) para possivelmente **múltiplos contêineres** executando seu aplicativo.
+Quando trabalhando com **Kubernetes** ou sistemas similares de gerenciamento de contêiner distribuído, usar seus mecanismos de rede internos permite que o único **balanceador de carga** que está escutando na **porta principal** transmita a comunicação (solicitações) para possivelmente **múltiplos contêineres** executando seu aplicativo.
 
 Cada um desses contêineres executando seu aplicativo normalmente teria **apenas um processo** (ex.: um processo Uvicorn executando seu aplicativo FastAPI). Todos seriam **contêineres idênticos**, executando a mesma coisa, mas cada um com seu próprio processo, memória, etc. Dessa forma, você aproveitaria a **paralelização** em **núcleos diferentes** da CPU, ou até mesmo em **máquinas diferentes**.
 
@@ -459,54 +486,61 @@ E o sistema de contêiner com o **balanceador de carga** iria **distribuir as so
 
 E normalmente esse **balanceador de carga** seria capaz de lidar com solicitações que vão para *outros* aplicativos em seu cluster (por exemplo, para um domínio diferente, ou sob um prefixo de URL diferente), e transmitiria essa comunicação para os contêineres certos para *esse outro* aplicativo em execução em seu cluster.
 
-### Um Processo por Contêiner
+### Um Processo por Contêiner { #one-process-per-container }
 
 Nesse tipo de cenário, provavelmente você desejará ter **um único processo (Uvicorn) por contêiner**, pois já estaria lidando com a replicação no nível do cluster.
 
-Então, nesse caso, você **não** desejará ter um gerenciador de processos como o Gunicorn com trabalhadores Uvicorn, ou o Uvicorn usando seus próprios trabalhadores Uvicorn. Você desejará ter apenas um **único processo Uvicorn** por contêiner (mas provavelmente vários contêineres).
+Então, nesse caso, você **não** desejará ter múltiplos workers no contêiner, por exemplo com a opção de linha de comando `--workers`. Você desejará ter apenas um **único processo Uvicorn** por contêiner (mas provavelmente vários contêineres).
 
-Tendo outro gerenciador de processos dentro do contêiner (como seria com o Gunicorn ou o Uvicorn gerenciando trabalhadores Uvicorn) só adicionaria **complexidade desnecessária** que você provavelmente já está cuidando com seu sistema de cluster.
+Ter outro gerenciador de processos dentro do contêiner (como seria com múltiplos workers) só adicionaria **complexidade desnecessária** que você provavelmente já está cuidando com seu sistema de cluster.
 
-### Contêineres com Múltiplos Processos e Casos Especiais
+### Contêineres com Múltiplos Processos e Casos Especiais { #containers-with-multiple-processes-and-special-cases }
 
-Claro, existem **casos especiais** em que você pode querer ter um **contêiner** com um **gerenciador de processos Gunicorn** iniciando vários **processos trabalhadores Uvicorn** dentro.
+Claro, existem **casos especiais** em que você pode querer ter **um contêiner** com vários **processos workers do Uvicorn** dentro.
 
-Nesses casos, você pode usar a **imagem oficial do Docker** que inclui o **Gunicorn** como um gerenciador de processos executando vários **processos trabalhadores Uvicorn**, e algumas configurações padrão para ajustar o número de trabalhadores com base nos atuais núcleos da CPU automaticamente. Eu vou te contar mais sobre isso abaixo em [Imagem Oficial do Docker com Gunicorn - Uvicorn](#imagem-oficial-do-docker-com-gunicorn-uvicorn).
+Nesses casos, você pode usar a opção de linha de comando `--workers` para definir o número de workers que deseja executar:
+
+```{ .dockerfile .annotate }
+FROM python:3.9
+
+WORKDIR /code
+
+COPY ./requirements.txt /code/requirements.txt
+
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+
+COPY ./app /code/app
+
+# (1)!
+CMD ["fastapi", "run", "app/main.py", "--port", "80", "--workers", "4"]
+```
+
+1. Aqui usamos a opção de linha de comando `--workers` para definir o número de workers como 4.
 
 Aqui estão alguns exemplos de quando isso pode fazer sentido:
 
-#### Um Aplicativo Simples
+#### Um Aplicativo Simples { #a-simple-app }
 
-Você pode querer um gerenciador de processos no contêiner se seu aplicativo for **simples o suficiente** para que você não precise (pelo menos não agora) ajustar muito o número de processos, e você pode simplesmente usar um padrão automatizado (com a imagem oficial do Docker), e você está executando em um **único servidor**, não em um cluster.
+Você pode querer um gerenciador de processos no contêiner se seu aplicativo for **simples o suficiente** para rodar em um **único servidor**, não em um cluster.
 
-#### Docker Compose
+#### Docker Compose { #docker-compose }
 
 Você pode estar implantando em um **único servidor** (não em um cluster) com o **Docker Compose**, então você não teria uma maneira fácil de gerenciar a replicação de contêineres (com o Docker Compose) enquanto preserva a rede compartilhada e o **balanceamento de carga**.
 
-Então você pode querer ter **um único contêiner** com um **gerenciador de processos** iniciando **vários processos trabalhadores** dentro.
-
-#### Prometheus and Outros Motivos
-
-Você também pode ter **outros motivos** que tornariam mais fácil ter um **único contêiner** com **múltiplos processos** em vez de ter **múltiplos contêineres** com **um único processo** em cada um deles.
-
-Por exemplo (dependendo de sua configuração), você poderia ter alguma ferramenta como um exportador do Prometheus no mesmo contêiner que deve ter acesso a **cada uma das solicitações** que chegam.
-
-Nesse caso, se você tivesse **múltiplos contêineres**, por padrão, quando o Prometheus fosse **ler as métricas**, ele receberia as métricas de **um único contêiner cada vez** (para o contêiner que tratou essa solicitação específica), em vez de receber as **métricas acumuladas** de todos os contêineres replicados.
-
-Então, nesse caso, poderia ser mais simples ter **um único contêiner** com **múltiplos processos**, e uma ferramenta local (por exemplo, um exportador do Prometheus) no mesmo contêiner coletando métricas do Prometheus para todos os processos internos e expor essas métricas no único contêiner.
+Então você pode querer ter **um único contêiner** com um **gerenciador de processos** iniciando **vários processos workers** dentro.
 
 ---
 
-O ponto principal é que **nenhum** desses são **regras escritas em pedra** que você deve seguir cegamente. Você pode usar essas idéias para **avaliar seu próprio caso de uso** e decidir qual é a melhor abordagem para seu sistema, verificando como gerenciar os conceitos de:
+O ponto principal é que **nenhum** desses são **regras escritas em pedra** que você deve seguir cegamente. Você pode usar essas ideias para **avaliar seu próprio caso de uso** e decidir qual é a melhor abordagem para seu sistema, verificando como gerenciar os conceitos de:
 
 * Segurança - HTTPS
 * Executando na inicialização
 * Reinicializações
 * Replicação (o número de processos em execução)
 * Memória
-* Passos anteriores antes de inicializar
+* Passos anteriores antes de iniciar
 
-## Memória
+## Memória { #memory }
 
 Se você executar **um único processo por contêiner**, terá uma quantidade mais ou menos bem definida, estável e limitada de memória consumida por cada um desses contêineres (mais de um se eles forem replicados).
 
@@ -514,17 +548,17 @@ E então você pode definir esses mesmos limites e requisitos de memória em sua
 
 Se sua aplicação for **simples**, isso provavelmente **não será um problema**, e você pode não precisar especificar limites de memória rígidos. Mas se você estiver **usando muita memória** (por exemplo, com **modelos de aprendizado de máquina**), deve verificar quanta memória está consumindo e ajustar o **número de contêineres** que executa em **cada máquina** (e talvez adicionar mais máquinas ao seu cluster).
 
-Se você executar **múltiplos processos por contêiner** (por exemplo, com a imagem oficial do Docker), deve garantir que o número de processos iniciados não **consuma mais memória** do que o disponível.
+Se você executar **múltiplos processos por contêiner**, deve garantir que o número de processos iniciados não **consuma mais memória** do que o disponível.
 
-## Passos anteriores antes de inicializar e contêineres
+## Passos anteriores antes de iniciar e contêineres { #previous-steps-before-starting-and-containers }
 
 Se você estiver usando contêineres (por exemplo, Docker, Kubernetes), existem duas abordagens principais que você pode usar.
 
-### Contêineres Múltiplos
+### Contêineres Múltiplos { #multiple-containers }
 
-Se você tiver **múltiplos contêineres**, provavelmente cada um executando um **único processo** (por exemplo, em um cluster do **Kubernetes**), então provavelmente você gostaria de ter um **contêiner separado** fazendo o trabalho dos **passos anteriores** em um único contêiner, executando um único processo, **antes** de executar os contêineres trabalhadores replicados.
+Se você tiver **múltiplos contêineres**, provavelmente cada um executando um **único processo** (por exemplo, em um cluster do **Kubernetes**), então provavelmente você gostaria de ter um **contêiner separado** fazendo o trabalho dos **passos anteriores** em um único contêiner, executando um único processo, **antes** de executar os contêineres workers replicados.
 
-/// info
+/// info | Informação
 
 Se você estiver usando o Kubernetes, provavelmente será um <a href="https://kubernetes.io/docs/concepts/workloads/pods/init-containers/" class="external-link" target="_blank">Init Container</a>.
 
@@ -532,85 +566,29 @@ Se você estiver usando o Kubernetes, provavelmente será um <a href="https://ku
 
 Se no seu caso de uso não houver problema em executar esses passos anteriores **em paralelo várias vezes** (por exemplo, se você não estiver executando migrações de banco de dados, mas apenas verificando se o banco de dados está pronto), então você também pode colocá-los em cada contêiner logo antes de iniciar o processo principal.
 
-### Contêiner Único
+### Contêiner Único { #single-container }
 
-Se você tiver uma configuração simples, com um **único contêiner** que então inicia vários **processos trabalhadores** (ou também apenas um processo), então poderia executar esses passos anteriores no mesmo contêiner, logo antes de iniciar o processo com o aplicativo. A imagem oficial do Docker suporta isso internamente.
+Se você tiver uma configuração simples, com um **único contêiner** que então inicia vários **processos workers** (ou também apenas um processo), então poderia executar esses passos anteriores no mesmo contêiner, logo antes de iniciar o processo com o aplicativo.
 
-## Imagem Oficial do Docker com Gunicorn - Uvicorn
+### Imagem Docker base { #base-docker-image }
 
-Há uma imagem oficial do Docker que inclui o Gunicorn executando com trabalhadores Uvicorn, conforme detalhado em um capítulo anterior: [Server Workers - Gunicorn com Uvicorn](server-workers.md){.internal-link target=_blank}.
+Antes havia uma imagem oficial do FastAPI para Docker: <a href="https://github.com/tiangolo/uvicorn-gunicorn-fastapi-docker" class="external-link" target="_blank">tiangolo/uvicorn-gunicorn-fastapi</a>. Mas agora ela está descontinuada. ⛔️
 
-Essa imagem seria útil principalmente nas situações descritas acima em: [Contêineres com Múltiplos Processos e Casos Especiais](#conteineres-com-multiplos-processos-e-casos-especiais).
+Você provavelmente **não** deve usar essa imagem base do Docker (ou qualquer outra semelhante).
 
-* <a href="https://github.com/tiangolo/uvicorn-gunicorn-fastapi-docker" class="external-link" target="_blank">tiangolo/uvicorn-gunicorn-fastapi</a>.
+Se você está usando **Kubernetes** (ou outros) e já está definindo a **replicação** no nível do cluster, com vários **contêineres**. Nesses casos, é melhor **construir uma imagem do zero** como descrito acima: [Construir uma Imagem Docker para FastAPI](#build-a-docker-image-for-fastapi).
 
-/// warning
+E se você precisar ter múltiplos workers, você pode simplesmente usar a opção de linha de comando `--workers`.
 
-Existe uma grande chance de que você **não** precise dessa imagem base ou de qualquer outra semelhante, e seria melhor construir a imagem do zero, como [descrito acima em: Construa uma Imagem Docker para o FastAPI](#construindo-uma-imagem-docker-para-fastapi).
+/// note | Detalhes Técnicos
+
+A imagem Docker foi criada quando o Uvicorn não suportava gerenciar e reiniciar workers mortos, então era necessário usar o Gunicorn com o Uvicorn, o que adicionava bastante complexidade, apenas para que o Gunicorn gerenciasse e reiniciasse os processos workers do Uvicorn.
+
+Mas agora que o Uvicorn (e o comando `fastapi`) suportam o uso de `--workers`, não há razão para usar uma imagem base do Docker em vez de construir a sua própria (é praticamente a mesma quantidade de código 😅).
 
 ///
 
-Essa imagem tem um mecanismo de **auto-ajuste** incluído para definir o **número de processos trabalhadores** com base nos núcleos de CPU disponíveis.
-
-Isso tem **padrões sensíveis**, mas você ainda pode alterar e atualizar todas as configurações com **variáveis de ambiente** ou arquivos de configuração.
-
-Há também suporte para executar <a href="https://github.com/tiangolo/uvicorn-gunicorn-fastapi-docker#pre_start_path" class="external-link" target="_blank">**passos anteriores antes de iniciar**</a> com um script.
-
-/// tip
-
-Para ver todas as configurações e opções, vá para a página da imagem Docker:  <a href="https://github.com/tiangolo/uvicorn-gunicorn-fastapi-docker" class="external-link" target="_blank">tiangolo/uvicorn-gunicorn-fastapi</a>.
-
-///
-
-### Número de Processos na Imagem Oficial do Docker
-
-O **número de processos** nesta imagem é **calculado automaticamente** a partir dos **núcleos de CPU** disponíveis.
-
-Isso significa que ele tentará **aproveitar** o máximo de **desempenho** da CPU possível.
-
-Você também pode ajustá-lo com as configurações usando **variáveis de ambiente**, etc.
-
-Mas isso também significa que, como o número de processos depende da CPU do contêiner em execução, a **quantidade de memória consumida** também dependerá disso.
-
-Então, se seu aplicativo consumir muito memória (por exemplo, com modelos de aprendizado de máquina), e seu servidor tiver muitos núcleos de CPU **mas pouca memória**, então seu contêiner pode acabar tentando usar mais memória do que está disponível e degradar o desempenho muito (ou até mesmo travar). 🚨
-
-### Criando um `Dockerfile`
-
-Aqui está como você criaria um `Dockerfile` baseado nessa imagem:
-
-```Dockerfile
-FROM tiangolo/uvicorn-gunicorn-fastapi:python3.9
-
-COPY ./requirements.txt /app/requirements.txt
-
-RUN pip install --no-cache-dir --upgrade -r /app/requirements.txt
-
-COPY ./app /app
-```
-
-### Aplicações Maiores
-
-Se você seguiu a seção sobre a criação de [Aplicações Maiores com Múltiplos Arquivos](../tutorial/bigger-applications.md){.internal-link target=_blank}, seu `Dockerfile` pode parecer com isso:
-
-```Dockerfile
-
-```Dockerfile hl_lines="7"
-FROM tiangolo/uvicorn-gunicorn-fastapi:python3.9
-
-COPY ./requirements.txt /app/requirements.txt
-
-RUN pip install --no-cache-dir --upgrade -r /app/requirements.txt
-
-COPY ./app /app/app
-```
-
-### Quando Usar
-
-Você provavelmente **não** deve usar essa imagem base oficial (ou qualquer outra semelhante) se estiver usando **Kubernetes** (ou outros) e já estiver definindo **replicação** no nível do cluster, com vários **contêineres**. Nesses casos, é melhor **construir uma imagem do zero** conforme descrito acima: [Construindo uma Imagem Docker para FastAPI](#construindo-uma-imagem-docker-para-fastapi).
-
-Essa imagem seria útil principalmente nos casos especiais descritos acima em [Contêineres com Múltiplos Processos e Casos Especiais](#conteineres-com-multiplos-processos-e-casos-especiais). Por exemplo, se sua aplicação for **simples o suficiente** para que a configuração padrão de número de processos com base na CPU funcione bem, você não quer se preocupar com a configuração manual da replicação no nível do cluster e não está executando mais de um contêiner com seu aplicativo. Ou se você estiver implantando com **Docker Compose**, executando em um único servidor, etc.
-
-## Deploy da Imagem do Contêiner
+## Deploy da Imagem do Contêiner { #deploy-the-container-image }
 
 Depois de ter uma imagem de contêiner (Docker), existem várias maneiras de implantá-la.
 
@@ -622,100 +600,11 @@ Por exemplo:
 * Com outra ferramenta como o Nomad
 * Com um serviço de nuvem que pega sua imagem de contêiner e a implanta
 
-## Imagem Docker com Poetry
+## Imagem Docker com `uv` { #docker-image-with-uv }
 
-Se você usa <a href="https://python-poetry.org/" class="external-link" target="_blank">Poetry</a> para gerenciar as dependências do seu projeto, pode usar a construção multi-estágio do Docker:
+Se você está usando o <a href="https://github.com/astral-sh/uv" class="external-link" target="_blank">uv</a> para instalar e gerenciar seu projeto, você pode seguir o <a href="https://docs.astral.sh/uv/guides/integration/docker/" class="external-link" target="_blank">guia de Docker do uv</a>.
 
-```{ .dockerfile .annotate }
-# (1)
-FROM python:3.9 as requirements-stage
-
-# (2)
-WORKDIR /tmp
-
-# (3)
-RUN pip install poetry
-
-# (4)
-COPY ./pyproject.toml ./poetry.lock* /tmp/
-
-# (5)
-RUN poetry export -f requirements.txt --output requirements.txt --without-hashes
-
-# (6)
-FROM python:3.9
-
-# (7)
-WORKDIR /code
-
-# (8)
-COPY --from=requirements-stage /tmp/requirements.txt /code/requirements.txt
-
-# (9)
-RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
-
-# (10)
-COPY ./app /code/app
-
-# (11)
-CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "80"]
-```
-
-1. Esse é o primeiro estágio, ele é chamado `requirements-stage`.
-
-2. Defina `/tmp` como o diretório de trabalho atual.
-
-    Aqui é onde geraremos o arquivo `requirements.txt`
-
-3. Instale o Poetry nesse estágio do Docker.
-
-4. Copie os arquivos `pyproject.toml` e `poetry.lock` para o diretório `/tmp`.
-
-    Porque está usando `./poetry.lock*` (terminando com um `*`), não irá falhar se esse arquivo ainda não estiver disponível.
-
-5. Gere o arquivo `requirements.txt`.
-
-6. Este é o estágio final, tudo aqui será preservado na imagem final do contêiner.
-
-7. Defina o diretório de trabalho atual como `/code`.
-
-8. Copie o arquivo `requirements.txt` para o diretório `/code`.
-
-    Essse arquivo só existe no estágio anterior do Docker, é por isso que usamos `--from-requirements-stage` para copiá-lo.
-
-9. Instale as dependências de pacote do arquivo `requirements.txt` gerado.
-
-10. Copie o diretório `app` para o diretório `/code`.
-
-11. Execute o comando `uvicorn`, informando-o para usar o objeto `app` importado de `app.main`.
-
-/// tip
-
-Clique nos números das bolhas para ver o que cada linha faz.
-
-///
-
-Um **estágio do Docker** é uma parte de um `Dockerfile` que funciona como uma **imagem temporária do contêiner** que só é usada para gerar alguns arquivos para serem usados posteriormente.
-
-O primeiro estágio será usado apenas para **instalar Poetry** e para **gerar o `requirements.txt`** com as dependências do seu projeto a partir do arquivo `pyproject.toml` do Poetry.
-
-Esse arquivo `requirements.txt` será usado com `pip` mais tarde no **próximo estágio**.
-
-Na imagem final do contêiner, **somente o estágio final** é preservado. Os estágios anteriores serão descartados.
-
-Quando usar Poetry, faz sentido usar **construções multi-estágio do Docker** porque você realmente não precisa ter o Poetry e suas dependências instaladas na imagem final do contêiner, você **apenas precisa** ter o arquivo `requirements.txt` gerado para instalar as dependências do seu projeto.
-
-Então, no próximo (e último) estágio, você construiria a imagem mais ou menos da mesma maneira descrita anteriormente.
-
-### Por trás de um proxy de terminação TLS - Poetry
-
-Novamente, se você estiver executando seu contêiner atrás de um proxy de terminação TLS (balanceador de carga) como Nginx ou Traefik, adicione a opção `--proxy-headers` ao comando:
-
-```Dockerfile
-CMD ["uvicorn", "app.main:app", "--proxy-headers", "--host", "0.0.0.0", "--port", "80"]
-```
-
-## Recapitulando
+## Recapitulando { #recap }
 
 Usando sistemas de contêiner (por exemplo, com **Docker** e **Kubernetes**), torna-se bastante simples lidar com todos os **conceitos de implantação**:
 
@@ -724,10 +613,8 @@ Usando sistemas de contêiner (por exemplo, com **Docker** e **Kubernetes**), to
 * Reinícios
 * Replicação (o número de processos rodando)
 * Memória
-* Passos anteriores antes de inicializar
+* Passos anteriores antes de iniciar
 
 Na maioria dos casos, você provavelmente não desejará usar nenhuma imagem base e, em vez disso, **construir uma imagem de contêiner do zero** baseada na imagem oficial do Docker Python.
 
-Tendo cuidado com a **ordem** das instruções no `Dockerfile` e o **cache do Docker**, você pode **minimizar os tempos de construção**, para maximizar sua produtividade (e evitar a tédio). 😎
-
-Em alguns casos especiais, você pode querer usar a imagem oficial do Docker para o FastAPI. 🤓
+Tendo cuidado com a **ordem** das instruções no `Dockerfile` e o **cache do Docker**, você pode **minimizar os tempos de construção**, para maximizar sua produtividade (e evitar o tédio). 😎

docs/pt/docs/deployment/https.md

@@ -1,4 +1,4 @@
-# Sobre HTTPS
+# Sobre HTTPS { #about-https }
 
 É fácil assumir que HTTPS é algo que é apenas "habilitado" ou não.
 
@@ -10,31 +10,31 @@ Se você está com pressa ou não se importa, continue com as seções seguintes
 
 ///
 
-Para aprender o básico de HTTPS de uma perspectiva do usuário, verifique <a href="https://howhttps.works/pt-br/" class="external-link" target="_blank">https://howhttps.works/pt-br/</a>.
+Para aprender o básico de HTTPS do ponto de vista do consumidor, verifique <a href="https://howhttps.works/" class="external-link" target="_blank">https://howhttps.works/</a>.
 
 Agora, a partir de uma perspectiva do desenvolvedor, aqui estão algumas coisas para ter em mente ao pensar em HTTPS:
 
-* Para HTTPS, **o servidor** precisa ter certificados gerados por **um terceiro**.
-    * Esses certificados são na verdade **adquiridos** de um terceiro, eles não são simplesmente "gerados".
-* Certificados têm um **tempo de vida**.
-    * Eles **expiram**.
-    * E então eles precisam ser **renovados**, **adquirindo-os novamente** de um terceiro.
-* A criptografia da conexão acontece no **nível TCP**.
-    * Essa é uma camada **abaixo do HTTP**.
-    * Portanto, o manuseio do **certificado e da criptografia** é feito **antes do HTTP**.
-* **O TCP não sabe sobre "domínios"**. Apenas sobre endereços IP.
-    * As informações sobre o **domínio solicitado** vão nos **dados HTTP**.
-* Os **certificados HTTPS** “certificam” um **determinado domínio**, mas o protocolo e a encriptação acontecem ao nível do TCP, **antes de sabermos** de que domínio se trata.
-* **Por padrão**, isso significa que você só pode ter **um certificado HTTPS por endereço IP**.
+* Para HTTPS, o servidor precisa ter "certificados" gerados por um terceiro.
+    * Esses certificados são na verdade adquiridos de um terceiro, eles não são simplesmente "gerados".
+* Certificados têm um tempo de vida.
+    * Eles expiram.
+    * E então eles precisam ser renovados, adquirindo-os novamente de um terceiro.
+* A criptografia da conexão acontece no nível TCP.
+    * Essa é uma camada abaixo do HTTP.
+    * Portanto, o manuseio do certificado e da criptografia é feito antes do HTTP.
+* O TCP não sabe sobre "domínios". Apenas sobre endereços IP.
+    * As informações sobre o domínio específico solicitado vão nos dados HTTP.
+* Os certificados HTTPS “certificam” um determinado domínio, mas o protocolo e a encriptação acontecem ao nível do TCP, antes de sabermos de que domínio se trata.
+* Por padrão, isso significa que você só pode ter um certificado HTTPS por endereço IP.
     * Não importa o tamanho do seu servidor ou quão pequeno cada aplicativo que você tem nele possa ser.
-    * No entanto, existe uma **solução** para isso.
-* Há uma **extensão** para o protocolo **TLS** (aquele que lida com a criptografia no nível TCP, antes do HTTP) chamado **<a href="https://en.wikipedia.org/wiki/Server_Name_Indication" class="external-link" target="_blank"><abbr title="Server Name Indication">SNI</abbr></a>**.
-    * Esta extensão SNI permite que um único servidor (com um **único endereço IP**) tenha **vários certificados HTTPS** e atenda a **vários domínios / aplicativos HTTPS**.
-    * Para que isso funcione, um **único** componente (programa) em execução no servidor, ouvindo no **endereço IP público**, deve ter **todos os certificados HTTPS** no servidor.
-* **Depois** de obter uma conexão segura, o protocolo de comunicação **ainda é HTTP**.
-    * Os conteúdos são **criptografados**, embora sejam enviados com o **protocolo HTTP**.
+    * No entanto, existe uma solução para isso.
+* Há uma extensão para o protocolo TLS (aquele que lida com a criptografia no nível TCP, antes do HTTP) chamada <a href="https://en.wikipedia.org/wiki/Server_Name_Indication" class="external-link" target="_blank"><abbr title="Server Name Indication">SNI</abbr></a>.
+    * Esta extensão SNI permite que um único servidor (com um único endereço IP) tenha vários certificados HTTPS e atenda a vários domínios / aplicativos HTTPS.
+    * Para que isso funcione, um único componente (programa) em execução no servidor, ouvindo no endereço IP público, deve ter todos os certificados HTTPS no servidor.
+* Depois de obter uma conexão segura, o protocolo de comunicação ainda é HTTP.
+    * Os conteúdos são criptografados, embora sejam enviados com o protocolo HTTP.
 
-É uma prática comum ter um **programa/servidor HTTP** em execução no servidor (máquina, host, etc.) e **gerenciar todas as partes HTTPS**: **recebendo as requisições encriptadas**, enviando as **solicitações HTTP descriptografadas** para o aplicativo HTTP real em execução no mesmo servidor (a aplicação **FastAPI**, neste caso), pegue a **resposta HTTP** do aplicativo, **criptografe-a** usando o **certificado HTTPS** apropriado e envie-a de volta ao cliente usando **HTTPS**. Este servidor é frequentemente chamado de **<a href="https://en.wikipedia.org/wiki/TLS_termination_proxy" class="external-link" target="_blank">Proxy de Terminação TLS</a>**.
+É uma prática comum ter um programa/servidor HTTP em execução no servidor (máquina, host, etc.) e gerenciar todas as partes HTTPS: recebendo as requisições HTTPS encriptadas, enviando as solicitações HTTP descriptografadas para o aplicativo HTTP real em execução no mesmo servidor (a aplicação FastAPI, neste caso), pegar a resposta HTTP do aplicativo, criptografá-la usando o certificado HTTPS apropriado e enviá-la de volta ao cliente usando HTTPS. Este servidor é frequentemente chamado de <a href="https://en.wikipedia.org/wiki/TLS_termination_proxy" class="external-link" target="_blank">Proxy de Terminação TLS</a>.
 
 Algumas das opções que você pode usar como Proxy de Terminação TLS são:
 
@@ -43,31 +43,31 @@ Algumas das opções que você pode usar como Proxy de Terminação TLS são:
 * Nginx
 * HAProxy
 
-## Let's Encrypt
+## Let's Encrypt { #lets-encrypt }
 
-Antes de Let's Encrypt, esses **certificados HTTPS** eram vendidos por terceiros confiáveis.
+Antes de Let's Encrypt, esses certificados HTTPS eram vendidos por terceiros confiáveis.
 
 O processo de aquisição de um desses certificados costumava ser complicado, exigia bastante papelada e os certificados eram bastante caros.
 
-Mas então o **<a href="https://letsencrypt.org/" class="external-link" target="_blank">Let's Encrypt</a>** foi criado.
+Mas então o <a href="https://letsencrypt.org/" class="external-link" target="_blank">Let's Encrypt</a> foi criado.
 
-Ele é um projeto da Linux Foundation que fornece **certificados HTTPS gratuitamente** . De forma automatizada. Esses certificados usam toda a segurança criptográfica padrão e têm vida curta (cerca de 3 meses), então a **segurança é, na verdade, melhor** por causa de sua vida útil reduzida.
+Ele é um projeto da Linux Foundation que fornece certificados HTTPS gratuitamente. De forma automatizada. Esses certificados usam toda a segurança criptográfica padrão e têm vida curta (cerca de 3 meses), então a segurança é, na verdade, melhor por causa do seu lifespan reduzido.
 
 Os domínios são verificados com segurança e os certificados são gerados automaticamente. Isso também permite automatizar a renovação desses certificados.
 
-A ideia é automatizar a aquisição e renovação desses certificados, para que você tenha **HTTPS seguro, de graça e para sempre**.
+A ideia é automatizar a aquisição e renovação desses certificados, para que você tenha HTTPS seguro, de graça e para sempre.
 
-## HTTPS para Desenvolvedores
+## HTTPS para Desenvolvedores { #https-for-developers }
 
 Aqui está um exemplo de como uma API HTTPS poderia ser estruturada, passo a passo, com foco principal nas ideias relevantes para desenvolvedores.
 
-### Nome do domínio
+### Nome do domínio { #domain-name }
 
-A etapa inicial provavelmente seria **adquirir** algum **nome de domínio**. Então, você iria configurá-lo em um servidor DNS (possivelmente no mesmo provedor em nuvem).
+A etapa inicial provavelmente seria adquirir algum nome de domínio. Então, você iria configurá-lo em um servidor DNS (possivelmente no mesmo provedor em nuvem).
 
-Você provavelmente usaria um servidor em nuvem (máquina virtual) ou algo parecido, e ele teria <abbr title="Que não muda">fixed</abbr> **Endereço IP público**.
+Você provavelmente usaria um servidor em nuvem (máquina virtual) ou algo parecido, e ele teria um <abbr title="Que não muda">fixo</abbr> Endereço IP público.
 
-No(s) servidor(es) DNS, você configuraria um registro (`registro A`) para apontar **seu domínio** para o **endereço IP público do seu servidor**.
+No(s) servidor(es) DNS, você configuraria um registro (um `A record`) para apontar seu domínio para o endereço IP público do seu servidor.
 
 Você provavelmente fará isso apenas uma vez, na primeira vez em que tudo estiver sendo configurado.
 
@@ -77,123 +77,155 @@ Essa parte do Nome do Domínio se dá muito antes do HTTPS, mas como tudo depend
 
 ///
 
-### DNS
+### DNS { #dns }
 
 Agora vamos focar em todas as partes que realmente fazem parte do HTTPS.
 
-Primeiro, o navegador iria verificar com os **servidores DNS** qual o **IP do domínio**, nesse caso, `someapp.example.com`.
+Primeiro, o navegador iria verificar com os servidores DNS qual o IP do domínio, nesse caso, `someapp.example.com`.
 
-Os servidores DNS iriam informar o navegador para utilizar algum **endereço IP** específico. Esse seria o endereço IP público em uso no seu servidor, que você configurou nos servidores DNS.
+Os servidores DNS iriam informar o navegador para utilizar algum endereço IP específico. Esse seria o endereço IP público em uso no seu servidor, que você configurou nos servidores DNS.
 
 <img src="/img/deployment/https/https01.drawio.svg">
 
-### Início do Handshake TLS
+### Início do Handshake TLS { #tls-handshake-start }
 
-O navegador então irá comunicar-se com esse endereço IP na **porta 443** (a porta HTTPS).
+O navegador então irá comunicar-se com esse endereço IP na porta 443 (a porta HTTPS).
 
 A primeira parte dessa comunicação é apenas para estabelecer a conexão entre o cliente e o servidor e para decidir as chaves criptográficas a serem utilizadas, etc.
 
 <img src="/img/deployment/https/https02.drawio.svg">
 
-Esse interação entre o cliente e o servidor para estabelecer uma conexão TLS é chamada de **Handshake TLS**.
+Esse interação entre o cliente e o servidor para estabelecer uma conexão TLS é chamada de Handshake TLS.
 
-### TLS com a Extensão SNI
+### TLS com a Extensão SNI { #tls-with-sni-extension }
 
-**Apenas um processo** no servidor pode se conectar a uma **porta** em um **endereço IP**. Poderiam existir outros processos conectados em outras portas desse mesmo endereço IP, mas apenas um para cada combinação de endereço IP e porta.
+Apenas um processo no servidor pode se conectar a uma porta em um endereço IP. Poderiam existir outros processos conectados em outras portas desse mesmo endereço IP, mas apenas um para cada combinação de endereço IP e porta.
 
 TLS (HTTPS) usa a porta `443` por padrão. Então essa é a porta que precisamos.
 
-Como apenas um único processo pode se comunicar com essa porta, o processo que faria isso seria o **Proxy de Terminação TLS**.
+Como apenas um único processo pode se comunicar com essa porta, o processo que faria isso seria o Proxy de Terminação TLS.
 
-O Proxy de Terminação TLS teria acesso a um ou mais **certificados TLS** (certificados HTTPS).
+O Proxy de Terminação TLS teria acesso a um ou mais certificados TLS (certificados HTTPS).
 
-Utilizando a **extensão SNI** discutida acima, o Proxy de Terminação TLS iria checar qual dos certificados TLS (HTTPS) disponíveis deve ser usado para essa conexão, utilizando o que corresponda ao domínio esperado pelo cliente.
+Utilizando a extensão SNI discutida acima, o Proxy de Terminação TLS iria checar qual dos certificados TLS (HTTPS) disponíveis deve ser usado para essa conexão, utilizando o que corresponda ao domínio esperado pelo cliente.
 
 Nesse caso, ele usaria o certificado para `someapp.example.com`.
 
 <img src="/img/deployment/https/https03.drawio.svg">
 
-O cliente já **confia** na entidade que gerou o certificado TLS (nesse caso, o Let's Encrypt, mas veremos sobre isso mais tarde), então ele pode **verificar** que o certificado é válido.
+O cliente já confia na entidade que gerou o certificado TLS (nesse caso, o Let's Encrypt, mas veremos sobre isso mais tarde), então ele pode verificar que o certificado é válido.
 
-Então, utilizando o certificado, o cliente e o Proxy de Terminação TLS **decidem como encriptar** o resto da **comunicação TCP**. Isso completa a parte do **Handshake TLS**.
+Então, utilizando o certificado, o cliente e o Proxy de Terminação TLS decidem como encriptar o resto da comunicação TCP. Isso completa a parte do Handshake TLS.
 
-Após isso, o cliente e o servidor possuem uma **conexão TCP encriptada**, que é provida pelo TLS. E então eles podem usar essa conexão para começar a **comunicação HTTP** propriamente dita.
+Após isso, o cliente e o servidor possuem uma conexão TCP encriptada, que é provida pelo TLS. E então eles podem usar essa conexão para começar a comunicação HTTP propriamente dita.
 
-E isso resume o que é **HTTPS**, apenas **HTTP** simples dentro de uma **conexão TLS segura** em vez de uma conexão TCP pura (não encriptada).
+E isso resume o que é HTTPS, apenas HTTP simples dentro de uma conexão TLS segura em vez de uma conexão TCP pura (não encriptada).
 
 /// tip | Dica
 
-Percebe que a encriptação da comunicação acontece no **nível do TCP**, não no nível do HTTP.
+Percebe que a encriptação da comunicação acontece no nível do TCP, não no nível do HTTP.
 
 ///
 
-### Solicitação HTTPS
+### Solicitação HTTPS { #https-request }
 
-Agora que o cliente e servidor (especialmente o navegador e o Proxy de Terminação TLS) possuem uma **conexão TCP encriptada**, eles podem iniciar a **comunicação HTTP**.
+Agora que o cliente e servidor (especialmente o navegador e o Proxy de Terminação TLS) possuem uma conexão TCP encriptada, eles podem iniciar a comunicação HTTP.
 
-Então, o cliente envia uma **solicitação HTTPS**. Que é apenas uma solicitação HTTP sobre uma conexão TLS encriptada.
+Então, o cliente envia uma solicitação HTTPS. Que é apenas uma solicitação HTTP sobre uma conexão TLS encriptada.
 
 <img src="/img/deployment/https/https04.drawio.svg">
 
-### Desencriptando a Solicitação
+### Desencriptando a Solicitação { #decrypt-the-request }
 
-O Proxy de Terminação TLS então usaria a encriptação combinada para **desencriptar a solicitação**, e transmitiria a **solicitação básica (desencriptada)** para o processo executando a aplicação (por exemplo, um processo com Uvicorn executando a aplicação FastAPI).
+O Proxy de Terminação TLS então usaria a encriptação combinada para desencriptar a solicitação, e transmitiria a solicitação básica (desencriptada) para o processo executando a aplicação (por exemplo, um processo com Uvicorn executando a aplicação FastAPI).
 
 <img src="/img/deployment/https/https05.drawio.svg">
 
-### Resposta HTTP
+### Resposta HTTP { #http-response }
 
-A aplicação processaria a solicitação e retornaria uma **resposta HTTP básica (não encriptada)** para o Proxy de Terminação TLS.
+A aplicação processaria a solicitação e retornaria uma resposta HTTP básica (não encriptada) para o Proxy de Terminação TLS.
 
 <img src="/img/deployment/https/https06.drawio.svg">
 
-### Resposta HTTPS
+### Resposta HTTPS { #https-response }
 
-O Proxy de Terminação TLS iria **encriptar a resposta** utilizando a criptografia combinada anteriormente (que foi definida com o certificado para `someapp.example.com`), e devolveria para o navegador.
+O Proxy de Terminação TLS iria encriptar a resposta utilizando a criptografia combinada anteriormente (que foi definida com o certificado para `someapp.example.com`), e devolveria para o navegador.
 
-No próximo passo, o navegador verifica que a resposta é válida e encriptada com a chave criptográfica correta, etc. E depois **desencripta a resposta** e a processa.
+No próximo passo, o navegador verifica que a resposta é válida e encriptada com a chave criptográfica correta, etc. E depois desencripta a resposta e a processa.
 
 <img src="/img/deployment/https/https07.drawio.svg">
 
-O cliente (navegador) saberá que a resposta vem do servidor correto por que ela usa a criptografia que foi combinada entre eles usando o **certificado HTTPS** anterior.
+O cliente (navegador) saberá que a resposta vem do servidor correto por que ela usa a criptografia que foi combinada entre eles usando o certificado HTTPS anterior.
 
-### Múltiplas Aplicações
+### Múltiplas Aplicações { #multiple-applications }
 
-Podem existir **múltiplas aplicações** em execução no mesmo servidor (ou servidores), por exemplo: outras APIs ou um banco de dados.
+Podem existir múltiplas aplicações em execução no mesmo servidor (ou servidores), por exemplo: outras APIs ou um banco de dados.
 
-Apenas um processo pode estar vinculado a um IP e porta (o Proxy de Terminação TLS, por exemplo), mas outras aplicações/processos também podem estar em execução no(s) servidor(es), desde que não tentem usar a mesma **combinação de IP público e porta**.
+Apenas um processo pode estar vinculado a um IP e porta (o Proxy de Terminação TLS, por exemplo), mas outras aplicações/processos também podem estar em execução no(s) servidor(es), desde que não tentem usar a mesma combinação de IP público e porta.
 
 <img src="/img/deployment/https/https08.drawio.svg">
 
-Dessa forma, o Proxy de Terminação TLS pode gerenciar o HTTPS e os certificados de **múltiplos domínios**, para múltiplas aplicações, e então transmitir as requisições para a aplicação correta em cada caso.
+Dessa forma, o Proxy de Terminação TLS pode gerenciar o HTTPS e os certificados de múltiplos domínios, para múltiplas aplicações, e então transmitir as requisições para a aplicação correta em cada caso.
 
-### Renovação de Certificados
+### Renovação de Certificados { #certificate-renewal }
 
-Em algum momento futuro, cada certificado irá **expirar** (aproximadamente 3 meses após a aquisição).
+Em algum momento futuro, cada certificado irá expirar (aproximadamente 3 meses após a aquisição).
 
 E então, haverá outro programa (em alguns casos pode ser o próprio Proxy de Terminação TLS) que irá interagir com o Let's Encrypt e renovar o(s) certificado(s).
 
 <img src="/img/deployment/https/https.drawio.svg">
 
-Os **certificados TLS** são **associados com um nome de domínio**, e não a um endereço IP.
+Os certificados TLS são associados com um nome de domínio, e não a um endereço IP.
 
-Então para renovar os certificados, o programa de renovação precisa **provar** para a autoridade (Let's Encrypt) que ele realmente **possui e controla esse domínio**>
+Então para renovar os certificados, o programa de renovação precisa provar para a autoridade (Let's Encrypt) que ele realmente "possui" e controla esse domínio.
 
 Para fazer isso, e acomodar as necessidades de diferentes aplicações, existem diferentes opções para esse programa. Algumas escolhas populares são:
 
-* **Modificar alguns registros DNS**
-    * Para isso, o programa de renovação precisa ter suporte as APIs do provedor DNS, então, dependendo do provedor DNS que você utilize, isso pode ou não ser uma opção viável.
-* **Executar como um servidor** (ao menos durante o processo de aquisição do certificado) no endereço IP público associado com o domínio.
+* Modificar alguns registros DNS
+    * Para isso, o programa de renovação precisa ter suporte às APIs do provedor DNS, então, dependendo do provedor DNS que você utilize, isso pode ou não ser uma opção viável.
+* Executar como um servidor (ao menos durante o processo de aquisição do certificado) no endereço IP público associado com o domínio.
     * Como dito anteriormente, apenas um processo pode estar ligado a uma porta e IP específicos.
     * Essa é uma dos motivos que fazem utilizar o mesmo Proxy de Terminação TLS para gerenciar a renovação de certificados ser tão útil.
     * Caso contrário, você pode ter que parar a execução do Proxy de Terminação TLS momentaneamente, inicializar o programa de renovação para renovar os certificados, e então reiniciar o Proxy de Terminação TLS. Isso não é o ideal, já que sua(s) aplicação(ões) não vão estar disponíveis enquanto o Proxy de Terminação TLS estiver desligado.
 
-Todo esse processo de renovação, enquanto o aplicativo ainda funciona, é uma das principais razões para preferir um **sistema separado para gerenciar HTTPS** com um Proxy de Terminação TLS em vez de usar os certificados TLS no servidor da aplicação diretamente (e.g. com o Uvicorn).
+Todo esse processo de renovação, enquanto o aplicativo ainda funciona, é uma das principais razões para preferir um sistema separado para gerenciar HTTPS com um Proxy de Terminação TLS em vez de usar os certificados TLS no servidor da aplicação diretamente (e.g. com o Uvicorn).
 
-## Recapitulando
+## Cabeçalhos encaminhados por Proxy { #proxy-forwarded-headers }
 
-Possuir **HTTPS** habilitado na sua aplicação é bastante importante, e até **crítico** na maioria dos casos. A maior parte do esforço que você tem que colocar sobre o HTTPS como desenvolvedor está em **entender esses conceitos** e como eles funcionam.
+Ao usar um proxy para lidar com HTTPS, seu servidor de aplicação (por exemplo, Uvicorn via FastAPI CLI) não sabe nada sobre o processo de HTTPS; ele se comunica com HTTP simples com o Proxy de Terminação TLS.
 
-Mas uma vez que você saiba o básico de **HTTPS para desenvolvedores**, você pode combinar e configurar diferentes ferramentas facilmente para gerenciar tudo de uma forma simples.
+Esse proxy normalmente define alguns cabeçalhos HTTP dinamicamente antes de transmitir a requisição para o servidor de aplicação, para informar ao servidor de aplicação que a requisição está sendo encaminhada pelo proxy.
 
-Em alguns dos próximos capítulos, eu mostrarei para você vários exemplos concretos de como configurar o **HTTPS** para aplicações **FastAPI**. 🔒
+/// note | Detalhes Técnicos
+
+Os cabeçalhos do proxy são:
+
+* <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/X-Forwarded-For" class="external-link" target="_blank">X-Forwarded-For</a>
+* <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/X-Forwarded-Proto" class="external-link" target="_blank">X-Forwarded-Proto</a>
+* <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/X-Forwarded-Host" class="external-link" target="_blank">X-Forwarded-Host</a>
+
+///
+
+No entanto, como o servidor de aplicação não sabe que está atrás de um proxy confiável, por padrão ele não confiaria nesses cabeçalhos.
+
+Mas você pode configurar o servidor de aplicação para confiar nos cabeçalhos encaminhados enviados pelo proxy. Se você estiver usando o FastAPI CLI, pode usar a opção de CLI `--forwarded-allow-ips` para dizer de quais IPs ele deve confiar nesses cabeçalhos encaminhados.
+
+Por exemplo, se o servidor de aplicação só estiver recebendo comunicação do proxy confiável, você pode defini-lo como `--forwarded-allow-ips="*"` para fazê-lo confiar em todos os IPs de entrada, já que ele só receberá requisições de seja lá qual for o IP usado pelo proxy.
+
+Dessa forma, a aplicação seria capaz de saber qual é sua própria URL pública, se está usando HTTPS, o domínio, etc.
+
+Isso seria útil, por exemplo, para lidar corretamente com redirecionamentos.
+
+/// tip | Dica
+
+Você pode saber mais sobre isso na documentação em [Atrás de um Proxy - Habilitar cabeçalhos encaminhados pelo proxy](../advanced/behind-a-proxy.md#enable-proxy-forwarded-headers){.internal-link target=_blank}
+
+///
+
+## Recapitulando { #recap }
+
+Possuir HTTPS habilitado na sua aplicação é bastante importante, e até crítico na maioria dos casos. A maior parte do esforço que você tem que colocar sobre o HTTPS como desenvolvedor está em entender esses conceitos e como eles funcionam.
+
+Mas uma vez que você saiba o básico de HTTPS para desenvolvedores, você pode combinar e configurar diferentes ferramentas facilmente para gerenciar tudo de uma forma simples.
+
+Em alguns dos próximos capítulos, eu mostrarei para você vários exemplos concretos de como configurar o HTTPS para aplicações FastAPI. 🔒

docs/pt/docs/deployment/index.md

@@ -1,7 +1,21 @@
-# Implantação
+# Implantação { #deployment }
 
-A implantação de uma aplicação **FastAPI** é relativamente simples.
+Implantar uma aplicação **FastAPI** é relativamente fácil.
 
-Existem várias maneiras para fazer isso, dependendo do seu caso específico e das ferramentas que você utiliza.
+## O que significa Implantação { #what-does-deployment-mean }
 
-Você verá mais detalhes para se ter em mente e algumas das técnicas para a implantação nas próximas seções.
+Implantar uma aplicação significa executar as etapas necessárias para torná-la disponível para os usuários.
+
+Para uma **web API**, isso normalmente envolve colocá-la em uma **máquina remota**, com um **programa de servidor** que ofereça bom desempenho, estabilidade, etc., de modo que seus **usuários** possam **acessar** a aplicação com eficiência e sem interrupções ou problemas.
+
+Isso contrasta com as fases de **desenvolvimento**, em que você está constantemente alterando o código, quebrando e consertando, parando e reiniciando o servidor de desenvolvimento, etc.
+
+## Estratégias de Implantação { #deployment-strategies }
+
+Há várias maneiras de fazer isso, dependendo do seu caso de uso específico e das ferramentas que você utiliza.
+
+Você pode **implantar um servidor** por conta própria usando uma combinação de ferramentas, pode usar um **serviço em nuvem** que faça parte do trabalho por você, entre outras opções.
+
+Vou mostrar alguns dos principais conceitos que você provavelmente deve ter em mente ao implantar uma aplicação **FastAPI** (embora a maior parte se aplique a qualquer outro tipo de aplicação web).
+
+Você verá mais detalhes para ter em mente e algumas das técnicas para fazer isso nas próximas seções. ✨

docs/pt/docs/deployment/manually.md

@@ -1,6 +1,6 @@
-# Execute um Servidor Manualmente
+# Execute um Servidor Manualmente { #run-a-server-manually }
 
-## Utilize o comando `fastapi run`
+## Utilize o comando `fastapi run` { #use-the-fastapi-run-command }
 
 Em resumo, utilize o comando `fastapi run` para inicializar sua aplicação FastAPI:
 
@@ -42,23 +42,23 @@ Isto deve funcionar para a maioria dos casos. 😎
 
 Você pode utilizar esse comando, por exemplo, para iniciar sua aplicação **FastAPI** em um contêiner, em um servidor, etc.
 
-## Servidores ASGI
+## Servidores ASGI { #asgi-servers }
 
 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">ASGI</abbr>. FastAPI é um framework web ASGI.
+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`.
 
 Existem diversas alternativas, incluindo:
 
 * <a href="https://www.uvicorn.dev/" class="external-link" target="_blank">Uvicorn</a>: um servidor ASGI de alta performance.
-* <a href="https://hypercorn.readthedocs.io/" class="external-link" target="_blank">Hypercorn</a>: um servidor ASGI compátivel com HTTP/2, Trio e outros recursos.
+* <a href="https://hypercorn.readthedocs.io/" class="external-link" target="_blank">Hypercorn</a>: um servidor ASGI compatível com HTTP/2, Trio e outros recursos.
 * <a href="https://github.com/django/daphne" class="external-link" target="_blank">Daphne</a>: servidor ASGI construído para Django Channels.
 * <a href="https://github.com/emmett-framework/granian" class="external-link" target="_blank">Granian</a>: um servidor HTTP Rust para aplicações Python.
 * <a href="https://unit.nginx.org/howto/fastapi/" class="external-link" target="_blank">NGINX Unit</a>: NGINX Unit é um runtime de aplicação web leve e versátil.
 
-## Máquina Servidora e Programa Servidor
+## Máquina Servidora e Programa Servidor { #server-machine-and-server-program }
 
 Existe um pequeno detalhe sobre estes nomes para se manter em mente. 💡
 
@@ -68,7 +68,7 @@ Apenas tenha em mente que quando você ler "servidor" em geral, isso pode se ref
 
 Quando se refere à máquina remota, é comum chamá-la de **servidor**, mas também de **máquina**, **VM** (máquina virtual), **nó**. Todos esses termos se referem a algum tipo de máquina remota, normalmente executando Linux, onde você executa programas.
 
-## Instale o Programa Servidor
+## Instale o Programa Servidor { #install-the-server-program }
 
 Quando você instala o FastAPI, ele vem com um servidor de produção, o Uvicorn, e você pode iniciá-lo com o comando `fastapi run`.
 
@@ -100,7 +100,7 @@ Quando você instala o FastAPI com algo como `pip install "fastapi[standard]"`,
 
 ///
 
-## Execute o Programa Servidor
+## Execute o Programa Servidor { #run-the-server-program }
 
 Se você instalou um servidor ASGI manualmente, normalmente precisará passar uma string de importação em um formato especial para que ele importe sua aplicação FastAPI:
 
@@ -131,7 +131,7 @@ from main import app
 
 Cada programa de servidor ASGI alternativo teria um comando semelhante, você pode ler mais na documentação respectiva.
 
-/// warning | Aviso
+/// warning | Atenção
 
 Uvicorn e outros servidores suportam a opção `--reload` que é útil durante o desenvolvimento.
 
@@ -141,7 +141,7 @@ Ela ajuda muito durante o **desenvolvimento**, mas você **não deve** usá-la e
 
 ///
 
-## Conceitos de Implantação
+## Conceitos de Implantação { #deployment-concepts }
 
 Esses exemplos executam o programa do servidor (por exemplo, Uvicorn), iniciando **um único processo**, ouvindo em todos os IPs (`0.0.0.0`) em uma porta predefinida (por exemplo, `80`).
 

docs/pt/docs/deployment/server-workers.md

@@ -1,4 +1,4 @@
-# Trabalhadores do Servidor - Uvicorn com Trabalhadores
+# Trabalhadores do Servidor - Uvicorn com Trabalhadores { #server-workers-uvicorn-with-workers }
 
 Vamos rever os conceitos de implantação anteriores:
 
@@ -25,7 +25,7 @@ Em particular, ao executar no **Kubernetes** você provavelmente **não** vai qu
 
 ///
 
-## Vários trabalhadores
+## Vários trabalhadores { #multiple-workers }
 
 Você pode iniciar vários trabalhadores com a opção de linha de comando `--workers`:
 
@@ -111,7 +111,7 @@ A única opção nova aqui é `--workers` informando ao Uvicorn para iniciar 4 p
 
 Você também pode ver que ele mostra o **PID** de cada processo, `27365` para o processo pai (este é o **gerenciador de processos**) e um para cada processo de trabalho: `27368`, `27369`, `27370` e `27367`.
 
-## Conceitos de Implantaçã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**.
 
@@ -124,13 +124,13 @@ Da lista de conceitos de implantação acima, o uso de trabalhadores ajudaria pr
 * **Memória**
 * **Etapas anteriores antes de iniciar**
 
-## Contêineres e Docker
+## Contêineres e Docker { #containers-and-docker }
 
 No próximo capítulo sobre [FastAPI em contêineres - Docker](docker.md){.internal-link target=_blank}, explicarei algumas estratégias que você pode usar para lidar com os outros **conceitos de implantação**.
 
 Vou mostrar como **construir sua própria imagem do zero** para executar um único processo Uvicorn. É um processo simples e provavelmente é o que você gostaria de fazer ao usar um sistema de gerenciamento de contêineres distribuídos como o **Kubernetes**.
 
-## Recapitular
+## Recapitular { #recap }
 
 Você pode usar vários processos de trabalho com a opção CLI `--workers` com os comandos `fastapi` ou `uvicorn` para aproveitar as vantagens de **CPUs multi-core** e executar **vários processos em paralelo**.
 

docs/pt/docs/deployment/versions.md

@@ -1,46 +1,46 @@
-# Sobre as versões do FastAPI
+# Sobre as versões do FastAPI { #about-fastapi-versions }
 
-**FastAPI** já está sendo usado em produção em diversas aplicações e sistemas, a cobertura de testes é mantida em 100%, mas seu desenvolvimento está avançando rapidamente.
+**FastAPI** já está sendo usado em produção em muitas aplicações e sistemas. E a cobertura de testes é mantida em 100%. Mas seu desenvolvimento ainda está avançando rapidamente.
 
-Novos recursos são adicionados com frequência, bugs são corrigidos regularmente e o código está sempre melhorando.
+Novas funcionalidades são adicionadas com frequência, bugs são corrigidos regularmente e o código continua melhorando continuamente.
 
-Esse é o motivo das versões atuais estarem em `0.x.x`, significando que em cada versão pode haver mudanças significativas, tudo isso seguindo as <a href="https://semver.org/lang/pt-BR/" class="external-link" target="_blank">convenções de controle de versão semântica.</a>
+É por isso que as versões atuais ainda são `0.x.x`, isso reflete que cada versão pode potencialmente ter mudanças significativas. Isso segue as convenções de <a href="https://semver.org/" class="external-link" target="_blank">Versionamento Semântico</a>.
 
-Já é possível criar aplicativos de produção com **FastAPI** (e provavelmente você já faz isso há algum tempo), apenas precisando ter certeza de usar uma versão que funcione corretamente com o resto do seu código.
+Você pode criar aplicações de produção com **FastAPI** agora mesmo (e provavelmente já vem fazendo isso há algum tempo), apenas certifique-se de usar uma versão que funcione corretamente com o resto do seu código.
 
-## Fixe a sua versão de `fastapi`
+## Fixe a sua versão de `fastapi` { #pin-your-fastapi-version }
 
-A primeira coisa que você deve fazer é "fixar" a versão do **FastAPI** que você está utilizando na mais atual, na qual você sabe que funciona corretamente para o seu aplicativo.
+A primeira coisa que você deve fazer é "fixar" a versão do **FastAPI** que você está utilizando na versão mais recente específica que você sabe que funciona corretamente para a sua aplicação.
 
-Por exemplo, supondo que você está usando a versão `0.45.0` em sua aplicação.
+Por exemplo, suponha que você esteja usando a versão `0.112.0` em sua aplicação.
 
-Caso você utilize o arquivo `requirements.txt`, você poderia especificar a versão com:
+Se você usa um arquivo `requirements.txt`, você poderia especificar a versão com:
 
 ```txt
-fastapi==0.45.0
+fastapi[standard]==0.112.0
 ```
 
-Isso significa que você conseguiria utilizar a versão exata `0.45.0`.
+isso significaria que você usaria exatamente a versão `0.112.0`.
 
-Ou, você poderia fixá-la com:
+Ou você também poderia fixá-la com:
 
 ```txt
-fastapi>=0.45.0,<0.46.0
+fastapi[standard]>=0.112.0,<0.113.0
 ```
 
-isso significa que você iria usar as versões `0.45.0` ou acima, mas inferiores à `0.46.0`, por exemplo, a versão `0.45.2` ainda seria aceita.
+isso significaria que você usaria as versões `0.112.0` ou superiores, mas menores que `0.113.0`, por exemplo, a versão `0.112.2` ainda seria aceita.
 
-Se você usar qualquer outra ferramenta para gerenciar suas instalações, como Poetry, Pipenv ou outras, todas elas têm uma maneira que você pode usar para definir as versões específicas dos seus pacotes.
+Se você usa qualquer outra ferramenta para gerenciar suas instalações, como `uv`, Poetry, Pipenv ou outras, todas elas têm uma forma de definir versões específicas para seus pacotes.
 
-## Versões disponíveis
+## Versões disponíveis { #available-versions }
 
-Você pode ver as versões disponíveis (por exemplo, para verificar qual é a versão atual) em [Release Notes](../release-notes.md){.internal-link target=\_blank}.
+Você pode ver as versões disponíveis (por exemplo, para verificar qual é a mais recente) nas [Release Notes](../release-notes.md){.internal-link target=_blank}.
 
-## Sobre versões
+## Sobre versões { #about-versions }
 
-Seguindo as convenções de controle de versão semântica, qualquer versão abaixo de `1.0.0` pode adicionar mudanças significativas.
+Seguindo as convenções de Versionamento Semântico, qualquer versão abaixo de `1.0.0` pode potencialmente adicionar mudanças significativas.
 
-FastAPI também segue a convenção de que qualquer alteração de versão "PATCH" é para correção de bugs e alterações não significativas.
+FastAPI também segue a convenção de que qualquer alteração de versão "PATCH" é para correções de bugs e mudanças que não quebram compatibilidade.
 
 /// tip | Dica
 
@@ -54,40 +54,40 @@ Logo, você deveria conseguir fixar a versão, como:
 fastapi>=0.45.0,<0.46.0
 ```
 
-Mudanças significativas e novos recursos são adicionados em versões "MINOR".
+Mudanças significativas e novas funcionalidades são adicionadas em versões "MINOR".
 
 /// tip | Dica
 
-O "MINOR" é o número que está no meio, por exemplo, em `0.2.3`, a versão MINOR é `2`.
+O "MINOR" é o número do meio, por exemplo, em `0.2.3`, a versão MINOR é `2`.
 
 ///
 
-## Atualizando as versões do FastAPI
+## Atualizando as versões do FastAPI { #upgrading-the-fastapi-versions }
 
 Você deve adicionar testes para a sua aplicação.
 
-Com **FastAPI** isso é muito fácil (graças a Starlette), verifique a documentação: [Testing](../tutorial/testing.md){.internal-link target=\_blank}
+Com **FastAPI** isso é muito fácil (graças ao Starlette), veja a documentação: [Testing](../tutorial/testing.md){.internal-link target=_blank}
 
-Após a criação dos testes, você pode atualizar a sua versão do **FastAPI** para uma mais recente, execute os testes para se certificar de que todo o seu código está funcionando corretamente.
+Depois que você tiver testes, você pode atualizar a sua versão do **FastAPI** para uma mais recente e se certificar de que todo o seu código está funcionando corretamente executando seus testes.
 
-Se tudo estiver funcionando, ou após você realizar as alterações necessárias e todos os testes estiverem passando, então você pode fixar sua versão de `FastAPI` para essa mais nova.
+Se tudo estiver funcionando, ou após você realizar as alterações necessárias e todos os testes estiverem passando, então você pode fixar sua versão de `fastapi` para essa versão mais recente.
 
-## Sobre Starlette
+## Sobre Starlette { #about-starlette }
 
 Não é recomendado fixar a versão de `starlette`.
 
 Versões diferentes de **FastAPI** utilizarão uma versão específica e mais recente de Starlette.
 
-Então, você pode deixar **FastAPI** escolher a versão compatível e correta de Starlette.
+Então, você pode deixar **FastAPI** usar a versão correta do Starlette.
 
-## Sobre Pydantic
+## Sobre Pydantic { #about-pydantic }
 
-Pydantic incluí os testes para **FastAPI** em seus próprios testes, então as novas versões de Pydantic (acima da `1.0.0`) sempre serão compatíveis com FastAPI.
+Pydantic inclui os testes para **FastAPI** em seus próprios testes, então novas versões do Pydantic (acima de `1.0.0`) são sempre compatíveis com FastAPI.
 
-Você pode fixar qualquer versão de Pydantic que desejar, desde que seja acima da `1.0.0` e abaixo da `2.0.0`.
+Você pode fixar o Pydantic em qualquer versão acima de `1.0.0` que funcione para você.
 
 Por exemplo:
 
 ```txt
-pydantic>=1.2.0,<2.0.0
+pydantic>=2.7.0,<3.0.0
 ```

docs/pt/docs/environment-variables.md

@@ -1,4 +1,4 @@
-# Variáveis de Ambiente
+# Variáveis de Ambiente { #environment-variables }
 
 /// tip | Dica
 
@@ -10,7 +10,7 @@ Uma variável de ambiente (também conhecida como "**env var**") é uma variáve
 
 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
+## 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:
 
@@ -50,7 +50,7 @@ Hello Wade Wilson
 
 ////
 
-## Ler Variáveis de Ambiente no Python
+## 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**.
 
@@ -157,7 +157,7 @@ Você pode ler mais sobre isso em <a href="https://12factor.net/config" class="e
 
 ///
 
-## Tipos e Validação
+## 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).
 
@@ -165,7 +165,7 @@ Isso significa que **qualquer valor** lido em Python de uma variável de ambient
 
 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){.internal-link target=_blank}.
 
-## Variável de Ambiente `PATH`
+## 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.
 
@@ -209,7 +209,7 @@ Por exemplo, quando você digita `python` no terminal, o sistema operacional pro
 
 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`
+### 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`.
 
@@ -287,7 +287,7 @@ $ C:\opt\custompython\bin\python
 
 Essas informações serão úteis ao aprender sobre [Ambientes Virtuais](virtual-environments.md){.internal-link target=_blank}.
 
-## Conclusão
+## Conclusão { #conclusion }
 
 Com isso, você deve ter uma compreensão básica do que são **variáveis ​​de ambiente** e como usá-las em Python.
 

docs/pt/docs/fastapi-cli.md

@@ -1,87 +1,75 @@
-# FastAPI CLI
+# FastAPI CLI { #fastapi-cli }
 
-**FastAPI CLI** é uma interface por linha de comando do `fastapi` que você pode usar para rodar sua app FastAPI, gerenciar seu projeto FastAPI e mais.
+**FastAPI CLI** é 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 (ex.: com `pip install fastapi`), isso inclui um pacote chamado `fastapi-cli`. Esse pacote disponibiliza o comando `fastapi` no terminal.
+Quando você instala o FastAPI (por exemplo, com `pip install "fastapi[standard]"`), isso inclui um pacote chamado `fastapi-cli`; esse pacote disponibiliza o comando `fastapi` no terminal.
 
-Para rodar seu app FastAPI em desenvolvimento, você pode usar o comando `fastapi dev`:
+Para executar sua aplicação FastAPI durante o desenvolvimento, você pode usar o comando `fastapi dev`:
 
 <div class="termy">
 
 ```console
-$ <font color="#4E9A06">fastapi</font> dev <u style="text-decoration-style:single">main.py</u>
-<font color="#3465A4">INFO    </font> Using path <font color="#3465A4">main.py</font>
-<font color="#3465A4">INFO    </font> Resolved absolute path <font color="#75507B">/home/user/code/awesomeapp/</font><font color="#AD7FA8">main.py</font>
-<font color="#3465A4">INFO    </font> Searching for package file structure from directories with <font color="#3465A4">__init__.py</font> files
-<font color="#3465A4">INFO    </font> Importing from <font color="#75507B">/home/user/code/</font><font color="#AD7FA8">awesomeapp</font>
+$ <font color="#4E9A06">fastapi</font> dev <u style="text-decoration-style:solid">main.py</u>
 
- ╭─ <font color="#8AE234"><b>Python module file</b></font> ─╮
- │                      │
- │  🐍 main.py          │
- │                      │
- ╰──────────────────────╯
+  <span style="background-color:#009485"><font color="#D3D7CF"> FastAPI </font></span>  Starting development server 🚀
 
-<font color="#3465A4">INFO    </font> Importing module <font color="#4E9A06">main</font>
-<font color="#3465A4">INFO    </font> Found importable FastAPI app
+             Searching for package file structure from directories with
+             <font color="#3465A4">__init__.py</font> files
+             Importing from <font color="#75507B">/home/user/code/</font><font color="#AD7FA8">awesomeapp</font>
 
- ╭─ <font color="#8AE234"><b>Importable FastAPI app</b></font> ─╮
- │                          │
- │  <span style="background-color:#272822"><font color="#FF4689">from</font></span><span style="background-color:#272822"><font color="#F8F8F2"> main </font></span><span style="background-color:#272822"><font color="#FF4689">import</font></span><span style="background-color:#272822"><font color="#F8F8F2"> app</font></span><span style="background-color:#272822">  </span>  │
- │                          │
- ╰──────────────────────────╯
+   <span style="background-color:#007166"><font color="#D3D7CF"> module </font></span>  🐍 main.py
 
-<font color="#3465A4">INFO    </font> Using import string <font color="#8AE234"><b>main:app</b></font>
+     <span style="background-color:#007166"><font color="#D3D7CF"> code </font></span>  Importing the FastAPI app object from the module with the
+             following code:
 
- <span style="background-color:#C4A000"><font color="#2E3436">╭────────── FastAPI CLI - Development mode ───────────╮</font></span>
- <span style="background-color:#C4A000"><font color="#2E3436">│                                                     │</font></span>
- <span style="background-color:#C4A000"><font color="#2E3436">│  Serving at: http://127.0.0.1:8000                  │</font></span>
- <span style="background-color:#C4A000"><font color="#2E3436">│                                                     │</font></span>
- <span style="background-color:#C4A000"><font color="#2E3436">│  API docs: http://127.0.0.1:8000/docs               │</font></span>
- <span style="background-color:#C4A000"><font color="#2E3436">│                                                     │</font></span>
- <span style="background-color:#C4A000"><font color="#2E3436">│  Running in development mode, for production use:   │</font></span>
- <span style="background-color:#C4A000"><font color="#2E3436">│                                                     │</font></span>
- <span style="background-color:#C4A000"><font color="#2E3436">│  </font></span><span style="background-color:#C4A000"><font color="#555753"><b>fastapi run</b></font></span><span style="background-color:#C4A000"><font color="#2E3436">                                        │</font></span>
- <span style="background-color:#C4A000"><font color="#2E3436">│                                                     │</font></span>
- <span style="background-color:#C4A000"><font color="#2E3436">╰─────────────────────────────────────────────────────╯</font></span>
+             <u style="text-decoration-style:solid">from </u><u style="text-decoration-style:solid"><b>main</b></u><u style="text-decoration-style:solid"> import </u><u style="text-decoration-style:solid"><b>app</b></u>
 
-<font color="#4E9A06">INFO</font>:     Will watch for changes in these directories: [&apos;/home/user/code/awesomeapp&apos;]
-<font color="#4E9A06">INFO</font>:     Uvicorn running on <b>http://127.0.0.1:8000</b> (Press CTRL+C to quit)
-<font color="#4E9A06">INFO</font>:     Started reloader process [<font color="#34E2E2"><b>2265862</b></font>] using <font color="#34E2E2"><b>WatchFiles</b></font>
-<font color="#4E9A06">INFO</font>:     Started server process [<font color="#06989A">2265873</font>]
-<font color="#4E9A06">INFO</font>:     Waiting for application startup.
-<font color="#4E9A06">INFO</font>:     Application startup complete.
+      <span style="background-color:#007166"><font color="#D3D7CF"> app </font></span>  Using import string: <font color="#3465A4">main:app</font>
+
+   <span style="background-color:#007166"><font color="#D3D7CF"> server </font></span>  Server started at <font color="#729FCF"><u style="text-decoration-style:solid">http://127.0.0.1:8000</u></font>
+   <span style="background-color:#007166"><font color="#D3D7CF"> server </font></span>  Documentation at <font color="#729FCF"><u style="text-decoration-style:solid">http://127.0.0.1:8000/docs</u></font>
+
+      <span style="background-color:#007166"><font color="#D3D7CF"> tip </font></span>  Running in development mode, for production use:
+             <b>fastapi run</b>
+
+             Logs:
+
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Will watch for changes in these directories:
+             <b>[</b><font color="#4E9A06">&apos;/home/user/code/awesomeapp&apos;</font><b>]</b>
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Uvicorn running on <font color="#729FCF"><u style="text-decoration-style:solid">http://127.0.0.1:8000</u></font> <b>(</b>Press CTRL+C to
+             quit<b>)</b>
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Started reloader process <b>[</b><font color="#34E2E2"><b>383138</b></font><b>]</b> using WatchFiles
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Started server process <b>[</b><font color="#34E2E2"><b>383153</b></font><b>]</b>
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Waiting for application startup.
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Application startup complete.
 ```
 
 </div>
 
-Aquele commando por linha de programa chamado `fastapi` é o **FastAPI CLI**.
+O programa de linha de comando chamado `fastapi` é o **FastAPI CLI**.
 
-O FastAPI CLI recebe o caminho do seu programa Python, detecta automaticamente a variável com o FastAPI (comumente nomeada `app`) e como importá-la, e então a serve.
+O FastAPI CLI recebe o caminho para o seu programa Python (por exemplo, `main.py`), detecta automaticamente a instância de `FastAPI` (comumente nomeada `app`), determina a forma correta de importação e então a serve.
 
-Para produção você usaria `fastapi run` no lugar. 🚀
+Para produção, você usaria `fastapi run`. 🚀
 
-Internamente, **FastAPI CLI** usa <a href="https://www.uvicorn.dev" class="external-link" target="_blank">Uvicorn</a>, um servidor ASGI de alta performance e pronto para produção. 😎
+Internamente, o **FastAPI CLI** usa o <a href="https://www.uvicorn.dev" class="external-link" target="_blank">Uvicorn</a>, um servidor ASGI de alta performance e pronto para produção. 😎
 
-## `fastapi dev`
+## `fastapi dev` { #fastapi-dev }
 
-Quando você roda `fastapi dev`, isso vai executar em modo de desenvolvimento.
+Executar `fastapi dev` inicia o modo de desenvolvimento.
 
-Por padrão, teremos o **recarregamento automático** ativo, então o programa irá recarregar o servidor automaticamente toda vez que você fizer mudanças no seu código. Isso usa muitos recursos e pode ser menos estável. Você deve apenas usá-lo em 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ê deve 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`).
 
-O servidor de desenvolvimento escutará no endereço de IP `127.0.0.1` por padrão, este é o IP que sua máquina usa para se comunicar com ela mesma (`localhost`).
+## `fastapi run` { #fastapi-run }
 
-## `fastapi run`
+Executar `fastapi run` inicia o FastAPI em modo de produção por padrão.
 
-Quando você rodar `fastapi run`, isso executará em modo de produção por padrã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.
 
-Este modo terá **recarregamento automático desativado** por padrão.
+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 isso por conta própria.
 
-Isso irá escutar no endereço de IP `0.0.0.0`, o que significa todos os endereços IP disponíveis, dessa forma o programa estará acessível publicamente para qualquer um que consiga se comunicar com a máquina. Isso é como você normalmente roda em produção em um contêiner, por exemplo.
+/// tip | Dica
 
-Em muitos casos você pode ter (e deveria ter) um "proxy de saída" tratando HTTPS no topo, isso dependerá de como você fará o deploy da sua aplicação, seu provedor pode fazer isso pra você ou talvez seja necessário fazer você mesmo.
-
-/// tip
-
-Você pode aprender mais sobre em [documentação de deployment](deployment/index.md){.internal-link target=_blank}.
+Você pode aprender mais sobre isso na [documentação de deployment](deployment/index.md){.internal-link target=_blank}.
 
 ///

docs/pt/docs/features.md

@@ -1,19 +1,19 @@
-# Recursos
+# Recursos { #features }
 
-## Recursos do FastAPI
+## Recursos do FastAPI { #fastapi-features }
 
 **FastAPI** te oferece o seguinte:
 
-### Baseado em padrões abertos
+### Baseado em padrões abertos { #based-on-open-standards }
 
-* <a href="https://github.com/OAI/OpenAPI-Specification" class="external-link" target="_blank"><strong>OpenAPI</strong></a> para criação de APIs, incluindo declarações de <abbr title="também conhecido como métodos HTTP, como POST, GET, PUT, DELETE">operações</abbr> de <abbr title="também conhecido como: endpoints, routes">caminho</abbr>, parâmetros, requisições de corpo, segurança etc.
+* <a href="https://github.com/OAI/OpenAPI-Specification" class="external-link" target="_blank"><strong>OpenAPI</strong></a> para criação de APIs, incluindo declarações de <abbr title="também conhecido como: endpoints, routes">caminho</abbr> <abbr title="também conhecido como métodos HTTP, como POST, GET, PUT, DELETE">operações</abbr>, parâmetros, requisições de corpo, segurança etc.
 * Modelo de documentação automática com <a href="https://json-schema.org/" class="external-link" target="_blank"><strong>JSON Schema</strong></a> (já que o OpenAPI em si é baseado no JSON Schema).
 * Projetado em cima desses padrões após um estudo meticuloso, em vez de uma reflexão breve.
 * Isso também permite o uso de **geração de código do cliente** automaticamente em muitas linguagens.
 
-### Documentação automática
+### Documentação automática { #automatic-docs }
 
-Documentação interativa da API e navegação _web_ da interface de usuário. Como o _framework_ é baseado no OpenAPI, há várias opções, 2 incluídas por padrão.
+Documentação interativa da API e navegação web da interface de usuário. Como o framework é baseado no OpenAPI, há várias opções, 2 incluídas por padrão.
 
 * <a href="https://github.com/swagger-api/swagger-ui" class="external-link" target="_blank"><strong>Swagger UI</strong></a>, com navegação interativa, chame e teste sua API diretamente do navegador.
 
@@ -23,9 +23,9 @@ Documentação interativa da API e navegação _web_ da interface de usuário. C
 
 ![ReDoc](https://fastapi.tiangolo.com/img/index/index-06-redoc-02.png)
 
-### Apenas Python moderno
+### Apenas Python moderno { #just-modern-python }
 
-Tudo é baseado no padrão das declarações de **tipos do Python 3.8** (graças ao Pydantic). Nenhuma sintaxe nova para aprender. Apenas o padrão moderno do Python.
+Tudo é baseado no padrão das declarações de **tipos do Python** (graças ao Pydantic). Nenhuma sintaxe nova para aprender. Apenas o padrão moderno do Python.
 
 Se você precisa refrescar a memória rapidamente sobre como usar tipos do Python (mesmo que você não use o FastAPI), confira esse rápido tutorial: [Tipos do Python](python-types.md){.internal-link target=_blank}.
 
@@ -63,7 +63,7 @@ second_user_data = {
 my_second_user: User = User(**second_user_data)
 ```
 
-/// info
+/// info | Informação
 
 `**second_user_data` quer dizer:
 
@@ -71,13 +71,13 @@ Passe as chaves e valores do dicionário `second_user_data` diretamente como arg
 
 ///
 
-### Suporte de editores
+### Suporte de editores { #editor-support }
 
-Todo o _framework_ foi projetado para ser fácil e intuitivo de usar, todas as decisões foram testadas em vários editores antes do início do desenvolvimento, para garantir a melhor experiência de desenvolvimento.
+Todo o framework foi projetado para ser fácil e intuitivo de usar, todas as decisões foram testadas em vários editores antes do início do desenvolvimento, para garantir a melhor experiência de desenvolvimento.
 
-Na última pesquisa do desenvolvedor Python ficou claro <a href="https://www.jetbrains.com/research/python-developers-survey-2017/#tools-and-features" class="external-link" target="_blank">que o recurso mais utilizado é o "auto completar"</a>.
+Na pesquisa de desenvolvedores Python, ficou claro <a href="https://www.jetbrains.com/research/python-developers-survey-2017/#tools-and-features" class="external-link" target="_blank">que um dos recursos mais utilizados é o "preenchimento automático"</a>.
 
-Todo o _framework_ **FastAPI** é feito para satisfazer isso. Auto completação funciona em todos os lugares.
+Todo o framework **FastAPI** é feito para satisfazer isso. O preenchimento automático funciona em todos os lugares.
 
 Você raramente precisará voltar à documentação.
 
@@ -91,17 +91,17 @@ Aqui está como o editor poderá te ajudar:
 
 ![editor support](https://fastapi.tiangolo.com/img/pycharm-completion.png)
 
-Você terá completação do seu código que você poderia considerar impossível antes. Como por exemplo, a chave `price` dentro do corpo JSON (que poderia ter sido aninhado) que vem de uma requisição.
+Você terá preenchimento automático no seu código que você poderia considerar impossível antes. Como por exemplo, a chave `price` dentro do corpo JSON (que poderia ter sido aninhado) que vem de uma requisição.
 
-Sem a necessidade de digitar nomes de chaves erroneamente, ir e voltar entre documentações, ou rolar pela página para descobrir se você utilizou `username` or `user_name`.
+Sem a necessidade de digitar nomes de chaves erroneamente, ir e voltar entre documentações, ou rolar pela página para descobrir se você utilizou `username` ou `user_name`.
 
-### Breve
+### Breve { #short }
 
 Há **padrões** sensíveis para tudo, com configurações adicionais em todos os lugares. Todos os parâmetros podem ser regulados para fazer o que você precisa e para definir a API que você necessita.
 
 Por padrão, tudo **"simplesmente funciona"**.
 
-### Validação
+### Validação { #validation }
 
 * Validação para a maioria dos (ou todos?) **tipos de dados** do Python, incluindo:
     * objetos JSON (`dict`).
@@ -117,7 +117,7 @@ Por padrão, tudo **"simplesmente funciona"**.
 
 Toda a validação é controlada pelo robusto e bem estabelecido **Pydantic**.
 
-### Segurança e autenticação
+### Segurança e autenticação { #security-and-authentication }
 
 Segurança e autenticação integradas. Sem nenhum compromisso com bancos de dados ou modelos de dados.
 
@@ -130,34 +130,34 @@ Todos os esquemas de seguranças definidos no OpenAPI, incluindo:
     * parâmetros da Query.
     * Cookies etc.
 
-Além disso, todos os recursos de seguranças do Starlette (incluindo **cookies de sessão**).
+Além disso, todos os recursos de segurança do Starlette (incluindo **cookies de sessão**).
 
 Tudo construído como ferramentas e componentes reutilizáveis que são fáceis de integrar com seus sistemas, armazenamento de dados, banco de dados relacionais e não-relacionais etc.
 
-### Injeção de dependência
+### Injeção de dependência { #dependency-injection }
 
 FastAPI inclui um sistema de <abbr title='também conhecido como "components", "resources", "services", "providers"'><strong>injeção de dependência</strong></abbr> extremamente fácil de usar, mas extremamente poderoso.
 
 * Mesmo dependências podem ter dependências, criando uma hierarquia ou **"grafo" de dependências**.
-* Tudo **automaticamente controlado** pelo _framework_.
+* Tudo **automaticamente controlado** pelo framework.
 * Todas as dependências podem pedir dados das requisições e **ampliar** as restrições e documentação automática da **operação de caminho**.
 * **Validação automática** mesmo para parâmetros da *operação de caminho* definidos em dependências.
 * Suporte para sistemas de autenticação complexos, **conexões com banco de dados** etc.
-* **Sem comprometer** os bancos de dados, _frontends_ etc. Mas fácil integração com todos eles.
+* **Sem comprometer** os bancos de dados, frontends etc. Mas fácil integração com todos eles.
 
-### "Plug-ins" ilimitados
+### "Plug-ins" ilimitados { #unlimited-plug-ins }
 
 Ou, de outra forma, sem a necessidade deles, importe e use o código que precisar.
 
 Qualquer integração é projetada para ser tão simples de usar (com dependências) que você pode criar um "plug-in" para suas aplicações com 2 linhas de código usando a mesma estrutura e sintaxe para as suas *operações de caminho*.
 
-### Testado
+### Testado { #tested }
 
 * 100% <abbr title="A quantidade de código que é testada automaticamente">de cobertura de testes</abbr>.
-* 100% do código utiliza <abbr title="Type annotations do Python, com isso seu editor e ferramentas externas podem te dar um suporte melhor">type annotations</abbr>.
+* 100% do código com <abbr title="Anotações de tipo do Python, com isso seu editor e ferramentas externas podem te dar um suporte melhor">anotações de tipo</abbr>.
 * Usado para aplicações em produção.
 
-## Recursos do Starlette
+## Recursos do Starlette { #starlette-features }
 
 **FastAPI** é totalmente compatível com (e baseado no) <a href="https://www.starlette.dev/" class="external-link" target="_blank"><strong>Starlette</strong></a>. Então, qualquer código adicional Starlette que você tiver, também funcionará.
 
@@ -165,18 +165,17 @@ Qualquer integração é projetada para ser tão simples de usar (com dependênc
 
 Com **FastAPI**, você terá todos os recursos do **Starlette** (já que FastAPI é apenas um Starlette com esteróides):
 
-* Desempenho realmente impressionante. É <a href="https://github.com/encode/starlette#performance" class="external-link" target="_blank">um dos _frameworks_ Python disponíveis mais rápidos, a par com o **NodeJS** e **Go**</a>.
+* Desempenho realmente impressionante. É <a href="https://github.com/encode/starlette#performance" class="external-link" target="_blank">um dos frameworks Python disponíveis mais rápidos, a par com o **NodeJS** e **Go**</a>.
 * Suporte a **WebSocket**.
-* Suporte a **GraphQL**.
-* Tarefas em processo _background_.
+* Tarefas em processo background.
 * Eventos na inicialização e encerramento.
 * Cliente de testes construído sobre HTTPX.
 * Respostas em **CORS**, GZip, Static Files, Streaming.
 * Suporte a **Session e Cookie**.
 * 100% de cobertura de testes.
-* 100% do código utilizando _type annotations_.
+* 100% do código utilizando anotações de tipo.
 
-## Recursos do Pydantic
+## Recursos do Pydantic { #pydantic-features }
 
 **FastAPI** é totalmente compatível com (e baseado no) <a href="https://docs.pydantic.dev/" class="external-link" target="_blank"><strong>Pydantic</strong></a>. Então, qualquer código Pydantic adicional que você tiver, também funcionará.
 
@@ -192,7 +191,7 @@ Com **FastAPI** você terá todos os recursos do **Pydantic** (já que FastAPI u
     * Sem novas definições de esquema de micro-linguagem para aprender.
     * Se você conhece os tipos do Python, você sabe como usar o Pydantic.
 * Vai bem com o/a seu/sua **<abbr title="Ambiente de Desenvolvimento Integrado, similar a um editor de código">IDE</abbr>/<abbr title="Um programa que confere erros de código">linter</abbr>/cérebro**:
-    * Como as estruturas de dados do Pydantic são apenas instâncias de classes que você define, a auto completação, _linting_, _mypy_ e a sua intuição devem funcionar corretamente com seus dados validados.
+    * Como as estruturas de dados do Pydantic são apenas instâncias de classes que você define, o preenchimento automático, linting, mypy e a sua intuição devem funcionar corretamente com seus dados validados.
 * Valida **estruturas complexas**:
     * Use modelos hierárquicos do Pydantic, `List` e `Dict` do `typing` do Python, etc.
     * Validadores permitem que esquemas de dados complexos sejam limpos e facilmente definidos, conferidos e documentados como JSON Schema.

docs/pt/docs/help-fastapi.md

@@ -1,149 +1,256 @@
-# Ajuda FastAPI - Obter Ajuda
+# Ajude o FastAPI - Obtenha ajuda { #help-fastapi-get-help }
 
 Você gosta do **FastAPI**?
 
-Você gostaria de ajudar o FastAPI, outros usários, e o autor?
+Você gostaria de ajudar o FastAPI, outras pessoas usuárias e o autor?
 
-Ou você gostaria de obter ajuda relacionada ao **FastAPI**??
+Ou você gostaria de obter ajuda com o **FastAPI**?
 
-Existem métodos muito simples de ajudar (A maioria das ajudas podem ser feitas com um ou dois cliques).
+Há maneiras muito simples de ajudar (várias envolvem apenas um ou dois cliques).
 
-E também existem vários modos de se conseguir ajuda.
+E também há várias formas de obter ajuda.
 
-## Inscreva-se na newsletter
+## Assine a newsletter { #subscribe-to-the-newsletter }
 
-Você pode se inscrever (pouco frequente) [**FastAPI e amigos** newsletter](newsletter.md){.internal-link target=_blank} para receber atualizações:
+Você pode assinar a (infrequente) [newsletter do **FastAPI and friends**](newsletter.md){.internal-link target=_blank} para ficar por dentro de:
 
 * Notícias sobre FastAPI e amigos 🚀
 * Tutoriais 📝
-* Recursos ✨
-* Mudanças de última hora 🚨
-* Truques e dicas ✅
+* Funcionalidades ✨
+* Mudanças incompatíveis 🚨
+* Dicas e truques ✅
 
-## Siga o FastAPI no X (Twitter)
+## Siga o FastAPI no X (Twitter) { #follow-fastapi-on-x-twitter }
 
 <a href="https://x.com/fastapi" class="external-link" target="_blank">Siga @fastapi no **X (Twitter)**</a> para receber as últimas notícias sobre o **FastAPI**. 🐦
 
-## Favorite o **FastAPI** no GitHub
+## Dê uma estrela ao **FastAPI** no GitHub { #star-fastapi-in-github }
 
-Você pode "favoritar" o FastAPI no GitHub (clicando na estrela no canto superior direito): <a href="https://github.com/fastapi/fastapi" class="external-link" target="_blank">https://github.com/fastapi/fastapi</a>. ⭐️
+Você pode “marcar com estrela” o FastAPI no GitHub (clicando no botão de estrela no canto superior direito): <a href="https://github.com/fastapi/fastapi" class="external-link" target="_blank">https://github.com/fastapi/fastapi</a>. ⭐️
 
-Favoritando, outros usuários poderão encontrar mais facilmente e verão que já foi útil para muita gente.
+Ao adicionar uma estrela, outras pessoas conseguirão encontrá-lo com mais facilidade e verão que já foi útil para muita gente.
 
-## Acompanhe novos updates no repositorio do GitHub
+## Acompanhe o repositório no GitHub para lançamentos { #watch-the-github-repository-for-releases }
 
-Você pode "acompanhar" (watch) o FastAPI no GitHub (clicando no botão com um "olho" no canto superior direito): <a href="https://github.com/fastapi/fastapi" class="external-link" target="_blank">https://github.com/fastapi/fastapi</a>. 👀
+Você pode “acompanhar” (watch) o FastAPI no GitHub (clicando no botão “watch” no canto superior direito): <a href="https://github.com/fastapi/fastapi" class="external-link" target="_blank">https://github.com/fastapi/fastapi</a>. 👀
 
-Podendo selecionar apenas "Novos Updates".
+Lá você pode selecionar “Apenas lançamentos” (Releases only).
 
-Fazendo isto, serão enviadas notificações (em seu email) sempre que tiver novos updates (uma nova versão) com correções de bugs e novos recursos no **FastAPI**
+Fazendo isso, você receberá notificações (no seu email) sempre que houver um novo lançamento (uma nova versão) do **FastAPI** com correções de bugs e novas funcionalidades.
 
-## Conect-se com o autor
+## Conecte-se com o autor { #connect-with-the-author }
 
 Você pode se conectar <a href="https://tiangolo.com" class="external-link" target="_blank">comigo (Sebastián Ramírez / `tiangolo`)</a>, o autor.
 
 Você pode:
 
-* <a href="https://github.com/tiangolo" class="external-link" target="_blank">Me siga no **GitHub**</a>.
-    * Ver também outros projetos Open Source criados por mim que podem te ajudar.
-    * Me seguir para saber quando um novo projeto Open Source for criado.
-* <a href="https://x.com/tiangolo" class="external-link" target="_blank">Me siga no **X (Twitter)**</a>.
-    * Me dizer o motivo pelo o qual você está usando o FastAPI(Adoro ouvir esse tipo de comentário).
-    * Saber quando eu soltar novos anúncios ou novas ferramentas.
-    * Também é possivel <a href="https://x.com/fastapi" class="external-link" target="_blank">seguir o @fastapi no X (Twitter)</a> (uma conta aparte).
-* <a href="https://www.linkedin.com/in/tiangolo/" class="external-link" target="_blank">Conect-se comigo no **Linkedin**</a>.
-    * Saber quando eu fizer novos anúncios ou novas ferramentas (apesar de que uso o X (Twitter) com mais frequência 🤷‍♂).
-* Ler meus artigos (ou me seguir) no <a href="https://dev.to/tiangolo" class="external-link" target="_blank">**Dev.to**</a> ou no <a href="https://medium.com/@tiangolo" class="external-link" target="_blank">**Medium**</a>.
-    * Ficar por dentro de novas ideias, artigos, e ferramentas criadas por mim.
-    * Me siga para saber quando eu publicar algo novo.
+* <a href="https://github.com/tiangolo" class="external-link" target="_blank">Me seguir no **GitHub**</a>.
+    * Ver outros projetos Open Source que criei e que podem ajudar você.
+    * Me seguir para saber quando eu criar um novo projeto Open Source.
+* <a href="https://x.com/tiangolo" class="external-link" target="_blank">Me seguir no **X (Twitter)**</a> ou no <a href="https://fosstodon.org/@tiangolo" class="external-link" target="_blank">Mastodon</a>.
+    * Me contar como você usa o FastAPI (adoro saber disso).
+    * Ficar sabendo quando eu fizer anúncios ou lançar novas ferramentas.
+    * Você também pode <a href="https://x.com/fastapi" class="external-link" target="_blank">seguir @fastapi no X (Twitter)</a> (uma conta separada).
+* <a href="https://www.linkedin.com/in/tiangolo/" class="external-link" target="_blank">Me seguir no **LinkedIn**</a>.
+    * Ver quando eu fizer anúncios ou lançar novas ferramentas (embora eu use mais o X (Twitter) 🤷‍♂).
+* Ler o que escrevo (ou me seguir) no <a href="https://dev.to/tiangolo" class="external-link" target="_blank">**Dev.to**</a> ou no <a href="https://medium.com/@tiangolo" class="external-link" target="_blank">**Medium**</a>.
+    * Ler outras ideias, artigos e conhecer ferramentas que criei.
+    * Me seguir para ver quando eu publicar algo novo.
 
-## Tweete sobre **FastAPI**
+## Tweet sobre o **FastAPI** { #tweet-about-fastapi }
 
-<a href="https://x.com/compose/tweet?text=I'm loving @fastapi because... https://github.com/fastapi/fastapi" class="external-link" target="_blank">Tweete sobre o **FastAPI**</a> e compartilhe comigo e com os outros o porque de gostar do FastAPI. 🎉
+<a href="https://x.com/compose/tweet?text=I'm loving @fastapi because... https://github.com/fastapi/fastapi" class="external-link" target="_blank">Tweet sobre o **FastAPI**</a> e conte para mim e para outras pessoas por que você gosta dele. 🎉
 
-Adoro ouvir sobre como o **FastAPI** é usado, o que você gosta nele, em qual projeto/empresa está sendo usado, etc.
+Eu adoro saber como o **FastAPI** está sendo usado, o que você tem curtido nele, em qual projeto/empresa você o utiliza, etc.
 
-## Vote no FastAPI
+## Vote no FastAPI { #vote-for-fastapi }
 
 * <a href="https://www.slant.co/options/34241/~fastapi-review" class="external-link" target="_blank">Vote no **FastAPI** no Slant</a>.
-* <a href="https://alternativeto.net/software/fastapi/" class="external-link" target="_blank">Vote no **FastAPI** no AlternativeTo</a>.
+* <a href="https://alternativeto.net/software/fastapi/about/" class="external-link" target="_blank">Vote no **FastAPI** no AlternativeTo</a>.
+* <a href="https://stackshare.io/pypi-fastapi" class="external-link" target="_blank">Diga que você usa o **FastAPI** no StackShare</a>.
 
-## Responda perguntas no GitHub
+## Ajude outras pessoas com perguntas no GitHub { #help-others-with-questions-in-github }
 
-Você pode acompanhar as <a href="https://github.com/fastapi/fastapi/issues" class="external-link" target="_blank">perguntas existentes</a> e tentar ajudar outros,            . 🤓
+Você pode tentar ajudar outras pessoas com suas perguntas em:
 
-Ajudando a responder as questões de varias pessoas, você pode se tornar um [Expert em FastAPI](fastapi-people.md#especialistas){.internal-link target=_blank} oficial. 🎉
+* <a href="https://github.com/fastapi/fastapi/discussions/categories/questions?discussions_q=category%3AQuestions+is%3Aunanswered" class="external-link" target="_blank">GitHub Discussions</a>
+* <a href="https://github.com/fastapi/fastapi/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc+label%3Aquestion+-label%3Aanswered+" class="external-link" target="_blank">GitHub Issues</a>
 
-## Acompanhe o repositório do GitHub
+Em muitos casos você já pode saber a resposta para aquelas perguntas. 🤓
 
-Você pode "acompanhar" (watch) o FastAPI no GitHub (clicando no "olho" no canto superior direito): <a href="https://github.com/fastapi/fastapi" class="external-link" target="_blank">https://github.com/fastapi/fastapi</a>. 👀
+Se você estiver ajudando muitas pessoas com suas perguntas, você se tornará um(a) [Especialista em FastAPI](fastapi-people.md#fastapi-experts){.internal-link target=_blank} oficial. 🎉
 
-Se você selecionar "Acompanhando" (Watching) em vez de "Apenas Lançamentos" (Releases only) você receberá notificações quando alguém tiver uma nova pergunta.
+Apenas lembre-se, o ponto mais importante é: tente ser gentil. As pessoas chegam com frustrações e, em muitos casos, não perguntam da melhor forma, mas tente ao máximo ser gentil. 🤗
 
-Assim podendo tentar ajudar a resolver essas questões.
-
-## Faça perguntas
-
-É possível <a href="https://github.com/fastapi/fastapi/issues/new/choose" class="external-link" target="_blank">criar uma nova pergunta</a> no repositório do GitHub, por exemplo:
-
-* Faça uma **pergunta** ou pergunte sobre um **problema**.
-* Sugira novos **recursos**.
-
-**Nota**: Se você fizer uma pergunta, então eu gostaria de pedir que você também ajude os outros com suas respectivas perguntas. 😉
-
-## Crie um Pull Request
-
-É possível [contribuir](contributing.md){.internal-link target=_blank} no código fonte fazendo Pull Requests, por exemplo:
-
-* Para corrigir um erro de digitação que você encontrou na documentação.
-* Para compartilhar um artigo, video, ou podcast criados por você sobre o FastAPI <a href="https://github.com/fastapi/fastapi/edit/master/docs/en/data/external_links.yml" class="external-link" target="_blank">editando este arquivo</a>.
-    * Não se esqueça de adicionar o link no começo da seção correspondente.
-* Para ajudar [traduzir a documentação](contributing.md#traducoes){.internal-link target=_blank} para sua lingua.
-    * Também é possivel revisar as traduções já existentes.
-* Para propor novas seções na documentação.
-* Para corrigir um bug/questão.
-* Para adicionar um novo recurso.
-
-## Entre no chat
-
-Entre no 👥 <a href="https://discord.gg/VQjSZaeJmf" class="external-link" target="_blank">server de conversa do Discord</a> 👥 e conheça novas pessoas da comunidade
-do FastAPI.
-
-/// tip | Dica
-
-Para perguntas, pergunte nas <a href="https://github.com/fastapi/fastapi/issues/new/choose" class="external-link" target="_blank">questões do GitHub</a>, lá tem um chance maior de você ser ajudado sobre o FastAPI [FastAPI Experts](fastapi-people.md#especialistas){.internal-link target=_blank}.
-
-Use o chat apenas para outro tipo de assunto.
-
-///
-
-### Não faça perguntas no chat
-
-Tenha em mente que os chats permitem uma "conversa mais livre", dessa forma é muito fácil fazer perguntas que são muito genéricas e dificeís de responder, assim você pode acabar não sendo respondido.
-
-Nas questões do GitHub o template irá te guiar para que você faça a sua pergunta de um jeito mais correto, fazendo com que você receba respostas mais completas, e até mesmo que você mesmo resolva o problema antes de perguntar. E no GitHub eu garanto que sempre irei responder todas as perguntas, mesmo que leve um tempo. Eu pessoalmente não consigo fazer isso via chat. 😅
-
-Conversas no chat não são tão fáceis de serem encontrados quanto no GitHub, então questões e respostas podem se perder dentro da conversa. E apenas as que estão nas questões do GitHub contam para você se tornar um [Expert em FastAPI](fastapi-people.md#especialistas){.internal-link target=_blank}, então você receberá mais atenção nas questões do GitHub.
-
-Por outro lado, existem milhares de usuários no chat, então tem uma grande chance de você encontrar alguém para trocar uma idéia por lá em qualquer horário. 😄
-
-## Patrocine o autor
-
-Você também pode ajudar o autor financeiramente (eu) através do <a href="https://github.com/sponsors/tiangolo" class="external-link" target="_blank">GitHub sponsors</a>.
-
-Lá você pode me pagar um cafézinho ☕️ como agradecimento. 😄
-
-E você também pode se tornar um patrocinador Prata ou Ouro do FastAPI. 🏅🎉
-
-## Patrocine as ferramente que potencializam o FastAPI
-
-Como você viu na documentação, o FastAPI se apoia em nos gigantes, Starlette e Pydantic.
-
-Patrocine também:
-
-* <a href="https://github.com/sponsors/samuelcolvin" class="external-link" target="_blank">Samuel Colvin (Pydantic)</a>
-* <a href="https://github.com/sponsors/encode" class="external-link" target="_blank">Encode (Starlette, Uvicorn)</a>
+A ideia é que a comunidade do **FastAPI** seja gentil e acolhedora. Ao mesmo tempo, não aceite bullying ou comportamentos desrespeitosos com outras pessoas. Temos que cuidar uns dos outros.
 
 ---
 
-Muito Obrigado! 🚀
+Veja como ajudar outras pessoas com perguntas (em discussions ou issues):
+
+### Entenda a pergunta { #understand-the-question }
+
+* Verifique se você consegue entender qual é o **objetivo** e o caso de uso de quem está perguntando.
+
+* Depois verifique se a pergunta (a grande maioria são perguntas) está **clara**.
+
+* Em muitos casos a pergunta feita é sobre uma solução imaginada pela pessoa usuária, mas pode haver uma solução **melhor**. Se você entender melhor o problema e o caso de uso, pode sugerir uma **solução alternativa** melhor.
+
+* Se você não entender a pergunta, peça mais **detalhes**.
+
+### Reproduza o problema { #reproduce-the-problem }
+
+Na maioria dos casos e na maioria das perguntas há algo relacionado ao **código original** da pessoa.
+
+Em muitos casos ela só copia um fragmento do código, mas isso não é suficiente para **reproduzir o problema**.
+
+* Você pode pedir que forneçam um <a href="https://stackoverflow.com/help/minimal-reproducible-example" class="external-link" target="_blank">exemplo mínimo, reproduzível</a>, que você possa **copiar e colar** e executar localmente para ver o mesmo erro ou comportamento que elas estão vendo, ou para entender melhor o caso de uso.
+
+* Se você estiver muito generoso(a), pode tentar **criar um exemplo** assim você mesmo(a), apenas com base na descrição do problema. Só tenha em mente que isso pode levar bastante tempo e pode ser melhor pedir primeiro que esclareçam o problema.
+
+### Sugira soluções { #suggest-solutions }
+
+* Depois de conseguir entender a pergunta, você pode dar uma possível **resposta**.
+
+* Em muitos casos, é melhor entender o **problema subjacente ou caso de uso**, pois pode haver uma forma melhor de resolver do que aquilo que estão tentando fazer.
+
+### Peça para encerrar { #ask-to-close }
+
+Se a pessoa responder, há uma grande chance de você ter resolvido o problema, parabéns, **você é um(a) herói(na)**! 🦸
+
+* Agora, se isso resolveu o problema, você pode pedir para:
+
+    * No GitHub Discussions: marcar o comentário como a **resposta**.
+    * No GitHub Issues: **encerrar** a issue.
+
+## Acompanhe o repositório do GitHub { #watch-the-github-repository }
+
+Você pode “acompanhar” (watch) o FastAPI no GitHub (clicando no botão “watch” no canto superior direito): <a href="https://github.com/fastapi/fastapi" class="external-link" target="_blank">https://github.com/fastapi/fastapi</a>. 👀
+
+Se você selecionar “Acompanhando” (Watching) em vez de “Apenas lançamentos” (Releases only), receberá notificações quando alguém criar uma nova issue ou pergunta. Você também pode especificar que quer ser notificado(a) apenas sobre novas issues, ou discussions, ou PRs, etc.
+
+Assim você pode tentar ajudar a resolver essas questões.
+
+## Faça perguntas { #ask-questions }
+
+Você pode <a href="https://github.com/fastapi/fastapi/discussions/new?category=questions" class="external-link" target="_blank">criar uma nova pergunta</a> no repositório do GitHub, por exemplo para:
+
+* Fazer uma **pergunta** ou perguntar sobre um **problema**.
+* Sugerir uma nova **funcionalidade**.
+
+**Nota**: se você fizer isso, então vou pedir que você também ajude outras pessoas. 😉
+
+## Revise Pull Requests { #review-pull-requests }
+
+Você pode me ajudar revisando pull requests de outras pessoas.
+
+Novamente, por favor tente ao máximo ser gentil. 🤗
+
+---
+
+Veja o que ter em mente e como revisar um pull request:
+
+### Entenda o problema { #understand-the-problem }
+
+* Primeiro, garanta que você **entendeu o problema** que o pull request tenta resolver. Pode haver uma discussão mais longa em uma Discussion ou issue do GitHub.
+
+* Também há uma boa chance de o pull request não ser realmente necessário porque o problema pode ser resolvido de uma **forma diferente**. Aí você pode sugerir ou perguntar sobre isso.
+
+### Não se preocupe com estilo { #dont-worry-about-style }
+
+* Não se preocupe muito com coisas como estilos de mensagens de commit, eu vou fazer squash e merge personalizando o commit manualmente.
+
+* Também não se preocupe com regras de estilo, já há ferramentas automatizadas verificando isso.
+
+E se houver qualquer outra necessidade de estilo ou consistência, vou pedir diretamente, ou vou adicionar commits por cima com as mudanças necessárias.
+
+### Verifique o código { #check-the-code }
+
+* Verifique e leia o código, veja se faz sentido, **execute localmente** e veja se realmente resolve o problema.
+
+* Depois **comente** dizendo que você fez isso, é assim que saberei que você realmente verificou.
+
+/// info | Informação
+
+Infelizmente, eu não posso simplesmente confiar em PRs que têm várias aprovações.
+
+Já aconteceu várias vezes de haver PRs com 3, 5 ou mais aprovações, provavelmente porque a descrição é atraente, mas quando eu verifico os PRs, eles estão quebrados, têm um bug, ou não resolvem o problema que afirmam resolver. 😅
+
+Por isso, é realmente importante que você leia e execute o código, e me avise nos comentários que você fez isso. 🤓
+
+///
+
+* Se o PR puder ser simplificado de alguma forma, você pode pedir isso, mas não há necessidade de ser exigente demais, pode haver muitos pontos de vista subjetivos (e eu terei o meu também 🙈), então é melhor focar nas coisas fundamentais.
+
+### Testes { #tests }
+
+* Me ajude a verificar se o PR tem **testes**.
+
+* Verifique se os testes **falham** antes do PR. 🚨
+
+* Depois verifique se os testes **passam** após o PR. ✅
+
+* Muitos PRs não têm testes, você pode **lembrar** a pessoa de adicionar testes, ou até **sugerir** alguns testes você mesmo(a). Essa é uma das coisas que consomem mais tempo e você pode ajudar muito com isso.
+
+* Depois também comente o que você testou, assim vou saber que você verificou. 🤓
+
+## Crie um Pull Request { #create-a-pull-request }
+
+Você pode [contribuir](contributing.md){.internal-link target=_blank} com o código-fonte fazendo Pull Requests, por exemplo:
+
+* Para corrigir um erro de digitação que você encontrou na documentação.
+* Para compartilhar um artigo, vídeo ou podcast que você criou ou encontrou sobre o FastAPI, <a href="https://github.com/fastapi/fastapi/edit/master/docs/en/data/external_links.yml" class="external-link" target="_blank">editando este arquivo</a>.
+    * Garanta que você adicione seu link no início da seção correspondente.
+* Para ajudar a [traduzir a documentação](contributing.md#translations){.internal-link target=_blank} para seu idioma.
+    * Você também pode ajudar a revisar as traduções criadas por outras pessoas.
+* Para propor novas seções de documentação.
+* Para corrigir uma issue/bug existente.
+    * Garanta que você adicione testes.
+* Para adicionar uma nova funcionalidade.
+    * Garanta que você adicione testes.
+    * Garanta que você adicione documentação se for relevante.
+
+## Ajude a manter o FastAPI { #help-maintain-fastapi }
+
+Ajude-me a manter o **FastAPI**! 🤓
+
+Há muito trabalho a fazer e, para a maior parte dele, **VOCÊ** pode ajudar.
+
+As principais tarefas que você pode fazer agora são:
+
+* [Ajudar outras pessoas com perguntas no GitHub](#help-others-with-questions-in-github){.internal-link target=_blank} (veja a seção acima).
+* [Revisar Pull Requests](#review-pull-requests){.internal-link target=_blank} (veja a seção acima).
+
+Essas duas tarefas são as que **mais consomem tempo**. Esse é o principal trabalho de manter o FastAPI.
+
+Se você puder me ajudar com isso, **você está me ajudando a manter o FastAPI** e garantindo que ele continue **avançando mais rápido e melhor**. 🚀
+
+## Entre no chat { #join-the-chat }
+
+Entre no 👥 <a href="https://discord.gg/VQjSZaeJmf" class="external-link" target="_blank">servidor de chat do Discord</a> 👥 e converse com outras pessoas da comunidade FastAPI.
+
+/// tip | Dica
+
+Para perguntas, faça-as no <a href="https://github.com/fastapi/fastapi/discussions/new?category=questions" class="external-link" target="_blank">GitHub Discussions</a>, há uma chance muito maior de você receber ajuda pelos [Especialistas em FastAPI](fastapi-people.md#fastapi-experts){.internal-link target=_blank}.
+
+Use o chat apenas para outras conversas gerais.
+
+///
+
+### Não use o chat para perguntas { #dont-use-the-chat-for-questions }
+
+Tenha em mente que, como os chats permitem uma “conversa mais livre”, é fácil fazer perguntas muito gerais e mais difíceis de responder, então você pode acabar não recebendo respostas.
+
+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(a) antes de perguntar. E no GitHub eu consigo garantir que sempre vou responder tudo, mesmo que leve algum tempo. Eu pessoalmente não consigo fazer isso com os sistemas de chat. 😅
+
+As conversas nos sistemas de chat também não são tão fáceis de pesquisar quanto no GitHub, então perguntas e respostas podem se perder na conversa. E somente as que estão no GitHub contam para você se tornar um(a) [Especialista em FastAPI](fastapi-people.md#fastapi-experts){.internal-link target=_blank}, então é bem provável que você receba mais atenção no GitHub.
+
+Por outro lado, há milhares de usuários nos sistemas de chat, então há uma grande chance de você encontrar alguém para conversar por lá quase o tempo todo. 😄
+
+## Patrocine o autor { #sponsor-the-author }
+
+Se o seu **produto/empresa** depende de ou está relacionado ao **FastAPI** e você quer alcançar suas pessoas usuárias, você pode patrocinar o autor (eu) através do <a href="https://github.com/sponsors/tiangolo" class="external-link" target="_blank">GitHub sponsors</a>. Dependendo do nível, você pode obter benefícios extras, como um selo na documentação. 🎁
+
+---
+
+Obrigado! 🚀

docs/pt/docs/history-design-future.md

@@ -1,4 +1,4 @@
-# História, Design e Futuro
+# História, Design e Futuro { #history-design-and-future }
 
 Há algum tempo, <a href="https://github.com/fastapi/fastapi/issues/3#issuecomment-454956920" class="external-link" target="_blank">um usuário **FastAPI** perguntou</a>:
 
@@ -6,7 +6,7 @@ Há algum tempo, <a href="https://github.com/fastapi/fastapi/issues/3#issuecomme
 
 Aqui está um pouco dessa história.
 
-## Alternativas
+## 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.
 
@@ -28,7 +28,7 @@ Mas em algum ponto, não havia outra opção senão criar algo que oferecia toda
 
 </blockquote>
 
-## Investigação
+## Investigação { #investigation }
 
 Ao usar todas as alternativas anteriores, eu tive a chance de aprender com todas elas, aproveitar ideias e combiná-las da melhor maneira que encontrei para mim e para os times de desenvolvedores com os quais trabalhava.
 
@@ -38,7 +38,7 @@ 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.
 
-## Design
+## Design { #design }
 
 Eu então dediquei algum tempo projetando a "API" de desenvolvimento que eu queria como usuário (como um desenvolvedor usando o FastAPI).
 
@@ -48,23 +48,23 @@ Pela última <a href="https://www.jetbrains.com/research/python-developers-surve
 
 Isso significa que o **FastAPI** foi testado especificamente com os editores usados por 80% dos desenvolvedores Python. Como a maioria dos outros editores tendem a funcionar de forma similar, todos os seus benefícios devem funcionar para virtualmente todos os editores.
 
-Dessa forma eu pude encontrar a melhor maneira de reduzir duplicação de código o máximo possível, ter completação de texto em todos os lugares, conferência de tipos e erros etc.
+Dessa forma eu pude encontrar a melhor maneira de reduzir duplicação de código o máximo possível, ter preenchimento automático em todos os lugares, conferência de tipos e erros etc.
 
 Tudo de uma forma que oferecesse a melhor experiência de desenvolvimento para todos os desenvolvedores.
 
-## Requisitos
+## Requisitos { #requirements }
 
 Após testar várias alternativas, eu decidi que usaria o <a href="https://docs.pydantic.dev/" class="external-link" target="_blank">**Pydantic**</a> 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, auto completações) baseado nos testes em vários editores.
+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 <a href="https://www.starlette.dev/" class="external-link" target="_blank">**Starlette**</a>, outro requisito chave.
 
-## Desenvolvimento
+## Desenvolvimento { #development }
 
 Quando comecei a criar o **FastAPI** de fato, a maior parte das peças já estavam encaixadas, o design estava definido, os requisitos e ferramentas já estavam prontos, e o conhecimento sobre os padrões e especificações estavam claros e frescos.
 
-## Futuro
+## Futuro { #future }
 
 Nesse ponto, já está claro que o **FastAPI** com suas ideias está sendo útil para muitas pessoas.
 

docs/pt/docs/how-to/conditional-openapi.md

@@ -1,12 +1,12 @@
-# OpenAPI condicional
+# OpenAPI condicional { #conditional-openapi }
 
-Se necessário, você pode usar configurações e variáveis ​​de ambiente para configurar o OpenAPI condicionalmente, dependendo do ambiente, e até mesmo desativá-lo completamente.
+Se necessário, você pode usar configurações e variáveis de ambiente para configurar o OpenAPI condicionalmente dependendo do ambiente e até mesmo desativá-lo completamente.
 
-## Sobre segurança, APIs e documentos
+## Sobre segurança, APIs e documentação { #about-security-apis-and-docs }
 
-Ocultar suas interfaces de usuário de documentação na produção *não deveria* ser a maneira de proteger sua API.
+Ocultar suas interfaces de usuário de documentação na produção não *deveria* ser a maneira de proteger sua API.
 
-Isso não adiciona nenhuma segurança extra à sua API; as *operações de rotas* ainda estarão disponíveis onde estão.
+Isso não adiciona nenhuma segurança extra à sua API; as *operações de rota* ainda estarão disponíveis onde estão.
 
 Se houver uma falha de segurança no seu código, ela ainda existirá.
 
@@ -17,15 +17,15 @@ Se você quiser proteger sua API, há várias coisas melhores que você pode faz
 * Certifique-se de ter modelos Pydantic bem definidos para seus corpos de solicitação e respostas.
 * Configure quaisquer permissões e funções necessárias usando dependências.
 * Nunca armazene senhas em texto simples, apenas hashes de senha.
-* Implemente e use ferramentas criptográficas bem conhecidas, como tokens JWT e Passlib, etc.
+* Implemente e use ferramentas criptográficas bem conhecidas, como pwdlib e tokens JWT, etc.
 * Adicione controles de permissão mais granulares com escopos OAuth2 quando necessário.
 * ...etc.
 
-No entanto, você pode ter um caso de uso muito específico em que realmente precisa desabilitar a documentação da API para algum ambiente (por exemplo, para produção) ou dependendo de configurações de variáveis ​​de ambiente.
+No entanto, você pode ter um caso de uso muito específico em que realmente precisa desabilitar a documentação da API para algum ambiente (por exemplo, para produção) ou dependendo de configurações de variáveis de ambiente.
 
-## OpenAPI condicional com configurações e variáveis ​​de ambiente
+## OpenAPI condicional com configurações e variáveis de ambiente { #conditional-openapi-from-settings-and-env-vars }
 
-Você pode usar facilmente as mesmas configurações do Pydantic para configurar sua OpenAPI gerada e as interfaces de usuário de documentos.
+Você pode usar facilmente as mesmas configurações do Pydantic para configurar sua OpenAPI gerada e as interfaces de usuário da documentação.
 
 Por exemplo:
 
@@ -33,9 +33,9 @@ Por exemplo:
 
 Aqui declaramos a configuração `openapi_url` com o mesmo padrão de `"/openapi.json"`.
 
-E então o usamos ao criar o aplicativo `FastAPI`.
+E então a usamos ao criar a aplicação `FastAPI`.
 
-Então você pode desabilitar o OpenAPI (incluindo os documentos da interface do usuário) definindo a variável de ambiente `OPENAPI_URL` como uma string vazia, como:
+Então você pode desabilitar o OpenAPI (incluindo a documentação da interface do usuário) definindo a variável de ambiente `OPENAPI_URL` como uma string vazia, como:
 
 <div class="termy">
 
@@ -47,7 +47,7 @@ $ OPENAPI_URL= uvicorn main:app
 
 </div>
 
-Então, se você acessar as URLs em `/openapi.json`, `/docs` ou `/redoc`, você receberá apenas um erro `404 Não Encontrado` como:
+Então, se você acessar as URLs em `/openapi.json`, `/docs` ou `/redoc`, você receberá apenas um erro `404 Not Found` como:
 
 ```JSON
 {

docs/pt/docs/how-to/configure-swagger-ui.md

@@ -1,14 +1,14 @@
-# Configurar Swagger UI
+# Configure a UI do Swagger { #configure-swagger-ui }
 
 Você pode configurar alguns <a href="https://swagger.io/docs/open-source-tools/swagger-ui/usage/configuration/" class="external-link" target="_blank">parâmetros extras da UI do Swagger</a>.
 
-Para configurá-los, passe o argumento `swagger_ui_parameters` ao criar o objeto de aplicativo `FastAPI()` ou para a função `get_swagger_ui_html()`.
+Para configurá-los, passe o argumento `swagger_ui_parameters` ao criar o objeto da aplicação `FastAPI()` ou para a função `get_swagger_ui_html()`.
 
 `swagger_ui_parameters` recebe um dicionário com as configurações passadas diretamente para o Swagger UI.
 
 O FastAPI converte as configurações para **JSON** para torná-las compatíveis com JavaScript, pois é disso que o Swagger UI precisa.
 
-## Desabilitar realce de sintaxe
+## Desabilitar destaque de sintaxe { #disable-syntax-highlighting }
 
 Por exemplo, você pode desabilitar o destaque de sintaxe na UI do Swagger.
 
@@ -24,7 +24,7 @@ Mas você pode desabilitá-lo definindo `syntaxHighlight` como `False`:
 
 <img src="/img/tutorial/extending-openapi/image03.png">
 
-## Alterar o tema
+## Alterar o tema { #change-the-theme }
 
 Da mesma forma que você pode definir o tema de destaque de sintaxe com a chave `"syntaxHighlight.theme"` (observe que há um ponto no meio):
 
@@ -34,13 +34,13 @@ Essa configuração alteraria o tema de cores de destaque de sintaxe:
 
 <img src="/img/tutorial/extending-openapi/image04.png">
 
-## Alterar parâmetros de UI padrão do Swagger
+## Alterar parâmetros de UI padrão do Swagger { #change-default-swagger-ui-parameters }
 
 O FastAPI inclui alguns parâmetros de configuração padrão apropriados para a maioria dos casos de uso.
 
 Inclui estas configurações padrão:
 
-{* ../../fastapi/openapi/docs.py ln[7:23] *}
+{* ../../fastapi/openapi/docs.py ln[8:23] hl[17:23] *}
 
 Você pode substituir qualquer um deles definindo um valor diferente no argumento `swagger_ui_parameters`.
 
@@ -48,15 +48,15 @@ Por exemplo, para desabilitar `deepLinking` você pode passar essas configuraç
 
 {* ../../docs_src/configure_swagger_ui/tutorial003.py hl[3] *}
 
-## Outros parâmetros da UI do Swagger
+## Outros parâmetros da UI do Swagger { #other-swagger-ui-parameters }
 
 Para ver todas as outras configurações possíveis que você pode usar, leia a <a href="https://swagger.io/docs/open-source-tools/swagger-ui/usage/configuration/" class="external-link" target="_blank">documentação oficial dos parâmetros da UI do Swagger</a>.
 
-## Configurações somente JavaScript
+## Configurações somente JavaScript { #javascript-only-settings }
 
-A interface do usuário do Swagger também permite que outras configurações sejam objetos **somente JavaScript** (por exemplo, funções JavaScript).
+A UI do Swagger também permite que outras configurações sejam objetos **somente JavaScript** (por exemplo, funções JavaScript).
 
-O FastAPI também inclui estas configurações de `predefinições` somente para JavaScript:
+O FastAPI também inclui estas configurações `presets` somente para JavaScript:
 
 ```JavaScript
 presets: [
@@ -67,4 +67,4 @@ presets: [
 
 Esses são objetos **JavaScript**, não strings, então você não pode passá-los diretamente do código Python.
 
-Se você precisar usar configurações somente JavaScript como essas, você pode usar um dos métodos acima. Sobrescreva todas as *operações de rotas* do Swagger UI e escreva manualmente qualquer JavaScript que você precisar.
+Se você precisar usar configurações somente JavaScript como essas, você pode usar um dos métodos acima. Substitua toda a *operação de rota* do Swagger UI e escreva manualmente qualquer JavaScript que você precisar.

docs/pt/docs/how-to/custom-docs-ui-assets.md

@@ -1,26 +1,26 @@
-# Recursos Estáticos Personalizados para a UI de Documentação (Hospedagem Própria)
+# Recursos Estáticos Personalizados para a UI de Documentação (Hospedagem Própria) { #custom-docs-ui-static-assets-self-hosting }
 
 A documentação da API usa **Swagger UI** e **ReDoc**, e cada um deles precisa de alguns arquivos JavaScript e CSS.
 
-Por padrão, esses arquivos são fornecidos por um <abbr title="Content Delivery Network: Um serviço, normalmente composto por vários servidores, que fornece arquivos estáticos, como JavaScript e CSS. É comumente usado para providenciar esses arquivos do servidor mais próximo do cliente, melhorando o desempenho.">CDN</abbr>.
+Por padrão, esses arquivos são fornecidos por um <abbr title="Content Delivery Network – Rede de Entrega de Conteúdo: Um serviço, normalmente composto por vários servidores, que fornece arquivos estáticos, como JavaScript e CSS. É comumente usado para providenciar esses arquivos do servidor mais próximo do cliente, melhorando o desempenho.">CDN</abbr>.
 
 Mas é possível personalizá-los, você pode definir um CDN específico ou providenciar os arquivos você mesmo.
 
-## CDN Personalizado para JavaScript e CSS
+## CDN Personalizado para JavaScript e CSS { #custom-cdn-for-javascript-and-css }
 
-Vamos supor que você deseja usar um <abbr title="Content Delivery Network">CDN</abbr> diferente, por exemplo, você deseja usar `https://unpkg.com/`.
+Vamos supor que você deseja usar um <abbr title="Content Delivery Network – Rede de Entrega de Conteúdo">CDN</abbr> diferente, por exemplo, você deseja usar `https://unpkg.com/`.
 
 Isso pode ser útil se, por exemplo, você mora em um país que restringe algumas URLs.
 
-### Desativar a documentação automática
+### Desativar a documentação automática { #disable-the-automatic-docs }
 
 O primeiro passo é desativar a documentação automática, pois por padrão, ela usa o CDN padrão.
 
-Para desativá-los, defina suas URLs como `None` ao criar seu aplicativo `FastAPI`:
+Para desativá-los, defina suas URLs como `None` ao criar sua aplicação FastAPI:
 
 {* ../../docs_src/custom_docs_ui/tutorial001.py hl[8] *}
 
-### Incluir a documentação personalizada
+### Incluir a documentação personalizada { #include-the-custom-docs }
 
 Agora você pode criar as *operações de rota* para a documentação personalizada.
 
@@ -46,23 +46,23 @@ Swagger UI lidará com isso nos bastidores para você, mas ele precisa desse aux
 
 ///
 
-### Criar uma *operação de rota* para testar
+### Criar uma *operação de rota* para testar { #create-a-path-operation-to-test-it }
 
 Agora, para poder testar se tudo funciona, crie uma *operação de rota*:
 
 {* ../../docs_src/custom_docs_ui/tutorial001.py hl[36:38] *}
 
-### Teste
+### Teste { #test-it }
 
 Agora, você deve ser capaz de ir para a documentação em <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>, e recarregar a página, ela carregará esses recursos do novo CDN.
 
-## Hospedagem Própria de JavaScript e CSS para a documentação
+## Hospedagem Própria de JavaScript e CSS para a documentação { #self-hosting-javascript-and-css-for-docs }
 
 Hospedar o JavaScript e o CSS pode ser útil se, por exemplo, você precisa que seu aplicativo continue funcionando mesmo offline, sem acesso aberto à Internet, ou em uma rede local.
 
-Aqui você verá como providenciar esses arquivos você mesmo, no mesmo aplicativo FastAPI, e configurar a documentação para usá-los.
+Aqui você verá como providenciar esses arquivos você mesmo, na mesma aplicação FastAPI, e configurar a documentação para usá-los.
 
-### Estrutura de Arquivos do Projeto
+### Estrutura de Arquivos do Projeto { #project-file-structure }
 
 Vamos supor que a estrutura de arquivos do seu projeto se pareça com isso:
 
@@ -85,7 +85,7 @@ Sua nova estrutura de arquivos poderia se parecer com isso:
 └── static/
 ```
 
-### Baixe os arquivos
+### Baixe os arquivos { #download-the-files }
 
 Baixe os arquivos estáticos necessários para a documentação e coloque-os no diretório `static/`.
 
@@ -96,7 +96,7 @@ Você provavelmente pode clicar com o botão direito em cada link e selecionar u
 * <a href="https://cdn.jsdelivr.net/npm/swagger-ui-dist@5/swagger-ui-bundle.js" class="external-link" target="_blank">`swagger-ui-bundle.js`</a>
 * <a href="https://cdn.jsdelivr.net/npm/swagger-ui-dist@5/swagger-ui.css" class="external-link" target="_blank">`swagger-ui.css`</a>
 
-E o **ReDoc** usa os arquivos:
+E o **ReDoc** usa o arquivo:
 
 * <a href="https://cdn.jsdelivr.net/npm/redoc@2/bundles/redoc.standalone.js" class="external-link" target="_blank">`redoc.standalone.js`</a>
 
@@ -113,14 +113,14 @@ Depois disso, sua estrutura de arquivos deve se parecer com:
     └── swagger-ui.css
 ```
 
-### Prover os arquivos estáticos
+### Prover os arquivos estáticos { #serve-the-static-files }
 
 * Importe `StaticFiles`.
 * "Monte" a instância `StaticFiles()` em um caminho específico.
 
 {* ../../docs_src/custom_docs_ui/tutorial002.py hl[7,11] *}
 
-### Teste os arquivos estáticos
+### Teste os arquivos estáticos { #test-the-static-files }
 
 Inicialize seu aplicativo e vá para <a href="http://127.0.0.1:8000/static/redoc.standalone.js" class="external-link" target="_blank">http://127.0.0.1:8000/static/redoc.standalone.js</a>.
 
@@ -138,15 +138,15 @@ Isso confirma que você está conseguindo fornecer arquivos estáticos do seu ap
 
 Agora, podemos configurar o aplicativo para usar esses arquivos estáticos para a documentação.
 
-### Desativar a documentação automática para arquivos estáticos
+### Desativar a documentação automática para arquivos estáticos { #disable-the-automatic-docs-for-static-files }
 
 Da mesma forma que ao usar um CDN personalizado, o primeiro passo é desativar a documentação automática, pois ela usa o CDN padrão.
 
-Para desativá-los, defina suas URLs como `None` ao criar seu aplicativo `FastAPI`:
+Para desativá-los, defina suas URLs como `None` ao criar sua aplicação FastAPI:
 
 {* ../../docs_src/custom_docs_ui/tutorial002.py hl[9] *}
 
-### Incluir a documentação personalizada para arquivos estáticos
+### Incluir a documentação personalizada para arquivos estáticos { #include-the-custom-docs-for-static-files }
 
 E da mesma forma que com um CDN personalizado, agora você pode criar as *operações de rota* para a documentação personalizada.
 
@@ -155,7 +155,7 @@ Novamente, você pode reutilizar as funções internas do FastAPI para criar as
 * `openapi_url`: a URL onde a página HTML para a documentação pode obter o esquema OpenAPI para a sua API. Você pode usar aqui o atributo `app.openapi_url`.
 * `title`: o título da sua API.
 * `oauth2_redirect_url`: Você pode usar `app.swagger_ui_oauth2_redirect_url` aqui para usar o padrão.
-* `swagger_js_url`: a URL onde a página HTML para a sua documentação do Swagger UI pode obter o arquivo **JavaScript**. Este é o URL do CDN personalizado. **Este é o URL que seu aplicativo está fornecendo**.
+* `swagger_js_url`: a URL onde a página HTML para a sua documentação do Swagger UI pode obter o arquivo **JavaScript**. **Este é o URL que seu aplicativo está fornecendo**.
 * `swagger_css_url`: a URL onde a página HTML para a sua documentação do Swagger UI pode obter o arquivo **CSS**. **Esse é o que seu aplicativo está fornecendo**.
 
 E de forma semelhante para o ReDoc...
@@ -172,13 +172,13 @@ Swagger UI lidará com isso nos bastidores para você, mas ele precisa desse aux
 
 ///
 
-### Criar uma *operação de rota* para testar arquivos estáticos
+### Criar uma *operação de rota* para testar arquivos estáticos { #create-a-path-operation-to-test-static-files }
 
 Agora, para poder testar se tudo funciona, crie uma *operação de rota*:
 
 {* ../../docs_src/custom_docs_ui/tutorial002.py hl[39:41] *}
 
-### Teste a UI de Arquivos Estáticos
+### Teste a UI de Arquivos Estáticos { #test-static-files-ui }
 
 Agora, você deve ser capaz de desconectar o WiFi, ir para a documentação em <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>, e recarregar a página.
 

docs/pt/docs/how-to/custom-request-and-route.md

@@ -1,12 +1,12 @@
-# Requisições Personalizadas e Classes da APIRoute
+# Request e classe APIRoute personalizadas { #custom-request-and-apiroute-class }
 
-Em algum casos, você pode querer sobreescrever a lógica usada pelas classes `Request`e `APIRoute`.
+Em alguns casos, você pode querer sobrescrever a lógica usada pelas classes `Request` e `APIRoute`.
 
-Em particular, isso pode ser uma boa alternativa para uma lógica em um middleware
+Em particular, isso pode ser uma boa alternativa para uma lógica em um middleware.
 
 Por exemplo, se você quiser ler ou manipular o corpo da requisição antes que ele seja processado pela sua aplicação.
 
-/// danger | Perigo
+/// danger | Cuidado
 
 Isso é um recurso "avançado".
 
@@ -14,7 +14,7 @@ Se você for um iniciante em **FastAPI** você deve considerar pular essa seçã
 
 ///
 
-## Casos de Uso
+## Casos de Uso { #use-cases }
 
 Alguns casos de uso incluem:
 
@@ -22,13 +22,13 @@ Alguns casos de uso incluem:
 * Descomprimir corpos de requisição comprimidos com gzip.
 * Registrar automaticamente todos os corpos de requisição.
 
-## Manipulando codificações de corpo de requisição personalizadas
+## Manipulando codificações de corpo de requisição personalizadas { #handling-custom-request-body-encodings }
 
 Vamos ver como usar uma subclasse personalizada de `Request` para descomprimir requisições gzip.
 
 E uma subclasse de `APIRoute` para usar essa classe de requisição personalizada.
 
-### Criar uma classe `GzipRequest` personalizada
+### Criar uma classe `GzipRequest` personalizada { #create-a-custom-gziprequest-class }
 
 /// tip | Dica
 
@@ -44,7 +44,7 @@ Dessa forma, a mesma classe de rota pode lidar com requisições comprimidas ou
 
 {* ../../docs_src/custom_request_and_route/tutorial001.py hl[8:15] *}
 
-### Criar uma classe `GzipRoute` personalizada
+### Criar uma classe `GzipRoute` personalizada { #create-a-custom-gziproute-class }
 
 Em seguida, criamos uma subclasse personalizada de `fastapi.routing.APIRoute` que fará uso do `GzipRequest`.
 
@@ -58,7 +58,7 @@ Aqui nós usamos para criar um `GzipRequest` a partir da requisição original.
 
 /// note | Detalhes Técnicos
 
-Um `Request` também tem um `request.receive`, que é uma função para "receber" o corpo da requisição.
+Um `Request` tem um atributo `request.scope`, que é apenas um `dict` do Python contendo os metadados relacionados à requisição.
 
 Um `Request` também tem um `request.receive`, que é uma função para "receber" o corpo da requisição.
 
@@ -78,7 +78,7 @@ Depois disso, toda a lógica de processamento é a mesma.
 
 Mas por causa das nossas mudanças em `GzipRequest.body`, o corpo da requisição será automaticamente descomprimido quando for carregado pelo **FastAPI** quando necessário.
 
-## Acessando o corpo da requisição em um manipulador de exceção
+## Acessando o corpo da requisição em um manipulador de exceção { #accessing-the-request-body-in-an-exception-handler }
 
 /// tip | Dica
 
@@ -98,9 +98,9 @@ Se uma exceção ocorrer, a instância `Request` ainda estará em escopo, então
 
 {* ../../docs_src/custom_request_and_route/tutorial002.py hl[16:18] *}
 
-## Classe `APIRoute` personalizada em um router
+## Classe `APIRoute` personalizada em um router { #custom-apiroute-class-in-a-router }
 
-você também pode definir o parametro `route_class` de uma `APIRouter`;
+Você também pode definir o parâmetro `route_class` de uma `APIRouter`:
 
 {* ../../docs_src/custom_request_and_route/tutorial003.py hl[26] *}
 

docs/pt/docs/how-to/extending-openapi.md

@@ -1,10 +1,10 @@
-# Extendendo o OpenAPI
+# Extendendo o OpenAPI { #extending-openapi }
 
 Existem alguns casos em que pode ser necessário modificar o esquema OpenAPI gerado.
 
 Nesta seção, você verá como fazer isso.
 
-## O processo normal
+## O processo normal { #the-normal-process }
 
 O processo normal (padrão) é o seguinte:
 
@@ -33,31 +33,31 @@ O parâmetro `summary` está disponível no OpenAPI 3.1.0 e superior, suportado
 
 ///
 
-## Sobrescrevendo os padrões
+## Sobrescrevendo os padrões { #overriding-the-defaults }
 
 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 <a href="https://github.com/Rebilly/ReDoc/blob/master/docs/redoc-vendor-extensions.md#x-logo" class="external-link" target="_blank">Extensão OpenAPI do ReDoc para incluir um logo personalizado</a>.
 
-### **FastAPI** Normal
+### **FastAPI** Normal { #normal-fastapi }
 
 Primeiro, escreva toda a sua aplicação **FastAPI** normalmente:
 
 {* ../../docs_src/extending_openapi/tutorial001.py hl[1,4,7:9] *}
 
-### Gerar o esquema OpenAPI
+### Gerar o esquema OpenAPI { #generate-the-openapi-schema }
 
 Em seguida, use a mesma função utilitária para gerar o esquema OpenAPI, dentro de uma função `custom_openapi()`:
 
 {* ../../docs_src/extending_openapi/tutorial001.py hl[2,15:21] *}
 
-### Modificar o esquema OpenAPI
+### Modificar o esquema OpenAPI { #modify-the-openapi-schema }
 
 Agora, você pode adicionar a extensão do ReDoc, incluindo um `x-logo` personalizado ao "objeto" `info` no esquema OpenAPI:
 
 {* ../../docs_src/extending_openapi/tutorial001.py hl[22:24] *}
 
-### Armazenar em cache o esquema OpenAPI
+### Armazenar em cache o esquema OpenAPI { #cache-the-openapi-schema }
 
 Você pode usar a propriedade `.openapi_schema` como um "cache" para armazenar o esquema gerado.
 
@@ -67,14 +67,14 @@ Ele será gerado apenas uma vez, e o mesmo esquema armazenado em cache será uti
 
 {* ../../docs_src/extending_openapi/tutorial001.py hl[13:14,25:26] *}
 
-### Sobrescrever o método
+### Sobrescrever o método { #override-the-method }
 
 Agora, você pode substituir o método `.openapi()` pela sua nova função.
 
 {* ../../docs_src/extending_openapi/tutorial001.py hl[29] *}
 
-### Verificar
+### Verificar { #check-it }
 
 Uma vez que você acessar <a href="http://127.0.0.1:8000/redoc" class="external-link" target="_blank">http://127.0.0.1:8000/redoc</a>, verá que está usando seu logo personalizado (neste exemplo, o logo do **FastAPI**):
 
-<img src="/docs/en/docs/img/tutorial/extending-openapi/image01.png">
+<img src="/img/tutorial/extending-openapi/image01.png">

docs/pt/docs/how-to/general.md

@@ -1,39 +1,38 @@
-# Geral - Como Fazer - Receitas
+# Geral - Como Fazer - Receitas { #general-how-to-recipes }
 
 Aqui estão vários links para outros locais na documentação, para perguntas gerais ou frequentes
 
-## Filtro de dados- Segurança
+## Filtro de dados- Segurança { #filter-data-security }
 
-Para assegurar que você não vai retornar mais dados do que deveria, leia a seção [Tutorial - Response Model - Return Type](../tutorial/response-model.md){.internal-link target=_blank}.
+Para assegurar que você não vai retornar mais dados do que deveria, leia a seção [Tutorial - Modelo de Resposta - Tipo de Retorno](../tutorial/response-model.md){.internal-link target=_blank}.
 
-## Tags de Documentação - OpenAPI
-Para adicionar tags às suas *rotas* e agrupá-las na UI da documentação, leia a seção [Tutorial - Path Operation Configurations - Tags](../tutorial/path-operation-configuration.md#tags){.internal-link target=_blank}.
+## Tags de Documentação - OpenAPI { #documentation-tags-openapi }
+Para adicionar tags às suas *operações de rota* e agrupá-las na UI da documentação, leia a seção [Tutorial - Configurações da Operação de Rota - Tags](../tutorial/path-operation-configuration.md#tags){.internal-link target=_blank}.
 
-## Resumo e Descrição da documentação - OpenAPI
+## Resumo e Descrição da documentação - OpenAPI { #documentation-summary-and-description-openapi }
 
-Para adicionar um resumo e uma descrição às suas *rotas* e exibi-los na UI da documentação, leia a seção [Tutorial - Path Operation Configurations - Summary and Description](../tutorial/path-operation-configuration.md#summary-and-description){.internal-link target=_blank}.
+Para adicionar um resumo e uma descrição às suas *operações de rota* e exibi-los na UI da documentação, leia a seção [Tutorial - Configurações da Operação de Rota - Resumo e Descrição](../tutorial/path-operation-configuration.md#summary-and-description){.internal-link target=_blank}.
 
-## Documentação das Descrições de Resposta - OpenAPI
+## Documentação das Descrições de Resposta - OpenAPI { #documentation-response-description-openapi }
 
-Para definir a descrição de uma resposta exibida na interface da documentação, leia a seção [Tutorial - Path Operation Configurations - Response description](../tutorial/path-operation-configuration.md#response-description){.internal-link target=_blank}.
+Para definir a descrição de uma resposta exibida na interface da documentação, leia a seção [Tutorial - Configurações da Operação de Rota - Descrição da Resposta](../tutorial/path-operation-configuration.md#response-description){.internal-link target=_blank}.
 
-## Documentação para Depreciar uma *Operação de Rota* - OpenAPI
+## Documentação para Depreciar uma *Operação de Rota* - OpenAPI { #documentation-deprecate-a-path-operation-openapi }
 
-Para depreciar uma *operação de rota* e exibi-la na interface da documentação, leia a seção [Tutorial - Path Operation Configurations - Deprecation](../tutorial/path-operation-configuration.md#deprecate-a-path-operation){.internal-link target=_blank}.
+Para depreciar uma *operação de rota* e exibi-la na interface da documentação, leia a seção [Tutorial - Configurações da Operação de Rota - Depreciação](../tutorial/path-operation-configuration.md#deprecate-a-path-operation){.internal-link target=_blank}.
 
-## Converter qualquer dado para JSON
+## Converter qualquer dado para compatível com JSON { #convert-any-data-to-json-compatible }
 
+Para converter qualquer dado para um formato compatível com JSON, leia a seção [Tutorial - Codificador Compatível com JSON](../tutorial/encoder.md){.internal-link target=_blank}.
 
-Para converter qualquer dado para um formato compatível com JSON, leia a seção [Tutorial - JSON Compatible Encoder](../tutorial/encoder.md){.internal-link target=_blank}.
+## OpenAPI Metadata - Docs { #openapi-metadata-docs }
 
-## OpenAPI Metadata - Docs
+Para adicionar metadados ao seu esquema OpenAPI, incluindo  licensa, versão, contato, etc, leia a seção [Tutorial - Metadados e URLs da Documentação](../tutorial/metadata.md){.internal-link target=_blank}.
 
-Para adicionar metadados ao seu esquema OpenAPI, incluindo  licensa, versão, contato, etc, leia a seção [Tutorial - Metadata and Docs URLs](../tutorial/metadata.md){.internal-link target=_blank}.
+## OpenAPI com URL customizada { #openapi-custom-url }
 
-## OpenAPI com URL customizada
+Para customizar a URL do OpenAPI (ou removê-la), leia a seção [Tutorial - Metadados e URLs da Documentação](../tutorial/metadata.md#openapi-url){.internal-link target=_blank}.
 
-Para customizar a URL do OpenAPI (ou removê-la), leia a seção [Tutorial - Metadata and Docs URLs](../tutorial/metadata.md#openapi-url){.internal-link target=_blank}.
+## URLs de documentação do OpenAPI { #openapi-docs-urls }
 
-## URLs de documentação do OpenAPI
-
-Para alterar as URLs usadas ​​para as interfaces de usuário da documentação gerada automaticamente, leia a seção [Tutorial - Metadata and Docs URLs](../tutorial/metadata.md#docs-urls){.internal-link target=_blank}.
+Para alterar as URLs usadas ​​para as interfaces de usuário da documentação gerada automaticamente, leia a seção [Tutorial - Metadados e URLs da Documentação](../tutorial/metadata.md#docs-urls){.internal-link target=_blank}.

docs/pt/docs/how-to/graphql.md

@@ -1,4 +1,4 @@
-# GraphQL
+# GraphQL { #graphql }
 
 Como o **FastAPI** é baseado no padrão **ASGI**, é muito fácil integrar qualquer biblioteca **GraphQL** também compatível com ASGI.
 
@@ -14,7 +14,7 @@ Certifique-se de avaliar se os **benefícios** para o seu caso de uso compensam
 
 ///
 
-## Bibliotecas GraphQL
+## Bibliotecas GraphQL { #graphql-libraries }
 
 Aqui estão algumas das bibliotecas **GraphQL** que têm suporte **ASGI**. Você pode usá-las com **FastAPI**:
 
@@ -27,21 +27,21 @@ Aqui estão algumas das bibliotecas **GraphQL** que têm suporte **ASGI**. Você
 * <a href="https://graphene-python.org/" class="external-link" target="_blank">Graphene</a>
     * Com <a href="https://github.com/ciscorn/starlette-graphene3" class="external-link" target="_blank">starlette-graphene3</a>
 
-## GraphQL com Strawberry
+## GraphQL com Strawberry { #graphql-with-strawberry }
 
-Se você precisar ou quiser trabalhar com **GraphQL**, <a href="https://strawberry.rocks/" class="external-link" target="_blank">**Strawberry**</a> é a biblioteca **recomendada** pois tem o design mais próximo ao design do **FastAPI**, ela é toda baseada em **type annotations**.
+Se você precisar ou quiser trabalhar com **GraphQL**, <a href="https://strawberry.rocks/" class="external-link" target="_blank">**Strawberry**</a> é a biblioteca **recomendada** pois tem o design mais próximo ao design do **FastAPI**, ela é toda baseada em **anotações de tipo**.
 
 Dependendo do seu caso de uso, você pode preferir usar uma biblioteca diferente, mas se você me perguntasse, eu provavelmente sugeriria que você experimentasse o **Strawberry**.
 
 Aqui está uma pequena prévia de como você poderia integrar Strawberry com FastAPI:
 
-{* ../../docs_src/graphql/tutorial001.py hl[3,22,25:26] *}
+{* ../../docs_src/graphql/tutorial001.py hl[3,22,25] *}
 
 Você pode aprender mais sobre Strawberry na <a href="https://strawberry.rocks/" class="external-link" target="_blank">documentação do Strawberry</a>.
 
 E também na documentação sobre <a href="https://strawberry.rocks/docs/integrations/fastapi" class="external-link" target="_blank">Strawberry com FastAPI</a>.
 
-## Antigo `GraphQLApp` do Starlette
+## Antigo `GraphQLApp` do Starlette { #older-graphqlapp-from-starlette }
 
 Versões anteriores do Starlette incluiam uma classe `GraphQLApp` para integrar com <a href="https://graphene-python.org/" class="external-link" target="_blank">Graphene</a>.
 
@@ -49,11 +49,11 @@ Ela foi descontinuada do Starlette, mas se você tem código que a utilizava, vo
 
 /// tip | Dica
 
-Se você precisa de GraphQL, eu ainda recomendaria que você desse uma olhada no <a href="https://strawberry.rocks/" class="external-link" target="_blank">Strawberry</a>, pois ele é baseado em type annotations em vez de classes e tipos personalizados.
+Se você precisa de GraphQL, eu ainda recomendaria que você desse uma olhada no <a href="https://strawberry.rocks/" class="external-link" target="_blank">Strawberry</a>, pois ele é baseado em anotações de tipo em vez de classes e tipos personalizados.
 
 ///
 
-## Saiba Mais
+## Saiba Mais { #learn-more }
 
 Você pode aprender mais sobre **GraphQL** na <a href="https://graphql.org/" class="external-link" target="_blank">documentação oficial do GraphQL</a>.
 

docs/pt/docs/how-to/index.md

@@ -1,12 +1,12 @@
-# Como Fazer - Exemplos Práticos
+# Como Fazer - Receitas { #how-to-recipes }
 
-Aqui você encontrará diferentes exemplos práticos ou tutoriais de "como fazer" para vários tópicos.
+Aqui você encontrará diferentes exemplos práticos ou tutoriais de "como fazer" para **vários tópicos**.
 
 A maioria dessas ideias será mais ou menos **independente**, e na maioria dos casos você só precisará estudá-las se elas se aplicarem diretamente ao **seu projeto**.
 
 Se algo parecer interessante e útil para o seu projeto, vá em frente e dê uma olhada. Caso contrário, você pode simplesmente ignorá-lo.
 
-/// tip
+/// tip | Dica
 
 Se você deseja **aprender FastAPI** de forma estruturada (recomendado), leia capítulo por capítulo [Tutorial - Guia de Usuário](../tutorial/index.md){.internal-link target=_blank} em vez disso.
 

docs/pt/docs/how-to/migrate-from-pydantic-v1-to-pydantic-v2.md

@@ -0,0 +1,133 @@
+# Migrar do Pydantic v1 para o Pydantic v2 { #migrate-from-pydantic-v1-to-pydantic-v2 }
+
+Se você tem uma aplicação FastAPI antiga, pode estar usando o Pydantic versão 1.
+
+O FastAPI tem suporte ao Pydantic v1 ou v2 desde a versão 0.100.0.
+
+Se você tiver o Pydantic v2 instalado, ele será utilizado. Se, em vez disso, tiver o Pydantic v1, será ele que será utilizado.
+
+O Pydantic v1 está agora descontinuado e o suporte a ele será removido nas próximas versões do FastAPI, você deveria migrar para o Pydantic v2. Assim, você terá as funcionalidades, melhorias e correções mais recentes.
+
+/// warning | Atenção
+
+Além disso, a equipe do Pydantic interrompeu o suporte ao Pydantic v1 para as versões mais recentes do Python, a partir do **Python 3.14**.
+
+Se quiser usar as funcionalidades mais recentes do Python, você precisará garantir que usa o Pydantic v2.
+
+///
+
+Se você tem uma aplicação FastAPI antiga com Pydantic v1, aqui vou mostrar como migrá-la para o Pydantic v2 e as **novas funcionalidades no FastAPI 0.119.0** para ajudar em uma migração gradual.
+
+## Guia oficial { #official-guide }
+
+O Pydantic tem um <a href="https://docs.pydantic.dev/latest/migration/" class="external-link" target="_blank">Guia de Migração</a> 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.
+
+Você pode lê-lo para entender melhor o que mudou.
+
+## Testes { #tests }
+
+Garanta que você tenha [testes](../tutorial/testing.md){.internal-link target=_blank} para sua aplicação e que os execute na integração contínua (CI).
+
+Assim, você pode fazer a atualização e garantir que tudo continua funcionando como esperado.
+
+## `bump-pydantic` { #bump-pydantic }
+
+Em muitos casos, quando você usa modelos Pydantic regulares sem personalizações, será possível automatizar a maior parte do processo de migração do Pydantic v1 para o Pydantic v2.
+
+Você pode usar o <a href="https://github.com/pydantic/bump-pydantic" class="external-link" target="_blank">`bump-pydantic`</a> da própria equipe do Pydantic.
+
+Essa ferramenta ajuda a alterar automaticamente a maior parte do código que precisa ser modificado.
+
+Depois disso, você pode rodar os testes e verificar se tudo funciona. Se funcionar, está concluído. 😎
+
+## Pydantic v1 no v2 { #pydantic-v1-in-v2 }
+
+O Pydantic v2 inclui tudo do Pydantic v1 como um submódulo `pydantic.v1`.
+
+Isso significa que você pode instalar a versão mais recente do Pydantic v2 e importar e usar os componentes antigos do Pydantic v1 a partir desse submódulo, como se tivesse o Pydantic v1 antigo instalado.
+
+{* ../../docs_src/pydantic_v1_in_v2/tutorial001_an_py310.py hl[1,4] *}
+
+### Suporte do FastAPI ao Pydantic v1 no v2 { #fastapi-support-for-pydantic-v1-in-v2 }
+
+Desde o FastAPI 0.119.0, há também suporte parcial ao Pydantic v1 a partir de dentro do Pydantic v2, para facilitar a migração para o v2.
+
+Assim, você pode atualizar o Pydantic para a versão 2 mais recente e alterar os imports para usar o submódulo `pydantic.v1`, e em muitos casos tudo simplesmente funcionará.
+
+{* ../../docs_src/pydantic_v1_in_v2/tutorial002_an_py310.py hl[2,5,15] *}
+
+/// warning | Atenção
+
+Tenha em mente que, como a equipe do Pydantic não oferece mais suporte ao Pydantic v1 nas versões recentes do Python, a partir do Python 3.14, o uso de `pydantic.v1` também não é suportado no Python 3.14 e superiores.
+
+///
+
+### Pydantic v1 e v2 na mesma aplicação { #pydantic-v1-and-v2-on-the-same-app }
+
+Não é suportado pelo Pydantic ter um modelo do Pydantic v2 com campos próprios definidos como modelos do Pydantic v1, ou vice-versa.
+
+```mermaid
+graph TB
+    subgraph "❌ Not Supported"
+        direction TB
+        subgraph V2["Pydantic v2 Model"]
+            V1Field["Pydantic v1 Model"]
+        end
+        subgraph V1["Pydantic v1 Model"]
+            V2Field["Pydantic v2 Model"]
+        end
+    end
+
+    style V2 fill:#f9fff3
+    style V1 fill:#fff6f0
+    style V1Field fill:#fff6f0
+    style V2Field fill:#f9fff3
+```
+
+...but, you can have separated models using Pydantic v1 and v2 in the same app.
+
+```mermaid
+graph TB
+    subgraph "✅ Supported"
+        direction TB
+        subgraph V2["Pydantic v2 Model"]
+            V2Field["Pydantic v2 Model"]
+        end
+        subgraph V1["Pydantic v1 Model"]
+            V1Field["Pydantic v1 Model"]
+        end
+    end
+
+    style V2 fill:#f9fff3
+    style V1 fill:#fff6f0
+    style V1Field fill:#fff6f0
+    style V2Field fill:#f9fff3
+```
+
+Em alguns casos, é até possível ter modelos Pydantic v1 e v2 na mesma operação de rota na sua aplicação FastAPI:
+
+{* ../../docs_src/pydantic_v1_in_v2/tutorial003_an_py310.py hl[2:3,6,12,21:22] *}
+
+No exemplo acima, o modelo de entrada é um modelo Pydantic v1, e o modelo de saída (definido em `response_model=ItemV2`) é um modelo Pydantic v2.
+
+### Parâmetros do Pydantic v1 { #pydantic-v1-parameters }
+
+Se você precisar usar algumas das ferramentas específicas do FastAPI para parâmetros como `Body`, `Query`, `Form` etc. com modelos do Pydantic v1, pode importá-las de `fastapi.temp_pydantic_v1_params` enquanto conclui a migração para o Pydantic v2:
+
+{* ../../docs_src/pydantic_v1_in_v2/tutorial004_an_py310.py hl[4,18] *}
+
+### Migre em etapas { #migrate-in-steps }
+
+/// tip | Dica
+
+Primeiro tente com o `bump-pydantic`; se seus testes passarem e isso funcionar, então você concluiu tudo com um único comando. ✨
+
+///
+
+Se o `bump-pydantic` não funcionar para o seu caso, você pode usar o suporte a modelos Pydantic v1 e v2 na mesma aplicação para fazer a migração para o Pydantic v2 gradualmente.
+
+Você poderia primeiro atualizar o Pydantic para usar a versão 2 mais recente e alterar os imports para usar `pydantic.v1` para todos os seus modelos.
+
+Depois, você pode começar a migrar seus modelos do Pydantic v1 para o v2 em grupos, em etapas graduais. 🚶

docs/pt/docs/how-to/separate-openapi-schemas.md

@@ -1,4 +1,4 @@
-# Esquemas OpenAPI Separados para Entrada e Saída ou Não
+# Esquemas OpenAPI Separados para Entrada e Saída ou Não { #separate-openapi-schemas-for-input-and-output-or-not }
 
 Ao usar **Pydantic v2**, o OpenAPI gerado é um pouco mais exato e **correto** do que antes. 😎
 
@@ -6,21 +6,21 @@ Inclusive, em alguns casos, ele terá até **dois JSON Schemas** no OpenAPI para
 
 Vamos ver como isso funciona e como alterar se for necessário.
 
-## Modelos Pydantic para Entrada e Saída
+## Modelos Pydantic para Entrada e Saída { #pydantic-models-for-input-and-output }
 
 Digamos que você tenha um modelo Pydantic com valores padrão, como este:
 
 {* ../../docs_src/separate_openapi_schemas/tutorial001_py310.py ln[1:7] hl[7] *}
 
-### Modelo para Entrada
+### Modelo para Entrada { #model-for-input }
 
 Se você usar esse modelo como entrada, como aqui:
 
 {* ../../docs_src/separate_openapi_schemas/tutorial001_py310.py ln[1:15] hl[14] *}
 
-... então o campo `description` não será obrigatório. Porque ele tem um valor padrão de `None`.
+... então o campo `description` **não será obrigatório**. Porque ele tem um valor padrão de `None`.
 
-### Modelo de Entrada na Documentação
+### Modelo de Entrada na Documentação { #input-model-in-docs }
 
 Você pode confirmar que na documentação, o campo `description` não tem um **asterisco vermelho**, não é marcado como obrigatório:
 
@@ -28,7 +28,7 @@ Você pode confirmar que na documentação, o campo `description` não tem um **
 <img src="/img/tutorial/separate-openapi-schemas/image01.png">
 </div>
 
-### Modelo para Saída
+### Modelo para Saída { #model-for-output }
 
 Mas se você usar o mesmo modelo como saída, como aqui:
 
@@ -36,7 +36,7 @@ Mas se você usar o mesmo modelo como saída, como aqui:
 
 ... então, como `description` tem um valor padrão, se você **não retornar nada** para esse campo, ele ainda terá o **valor padrão**.
 
-### Modelo para Dados de Resposta de Saída
+### Modelo para Dados de Resposta de Saída { #model-for-output-response-data }
 
 Se você interagir com a documentação e verificar a resposta, mesmo que o código não tenha adicionado nada em um dos campos `description`, a resposta JSON contém o valor padrão (`null`):
 
@@ -55,15 +55,15 @@ Por causa disso, o JSON Schema para um modelo pode ser diferente dependendo se e
 * para **entrada**, o `description` **não será obrigatório**
 * para **saída**, ele será **obrigatório** (e possivelmente `None`, ou em termos de JSON, `null`)
 
-### Modelo para Saída na Documentação
+### Modelo para Saída na Documentação { #model-for-output-in-docs }
 
-Você pode verificar o modelo de saída na documentação também, ambos `name` e `description` são marcados como **obrigatórios** com um **asterisco vermelho**:
+Você pode verificar o modelo de saída na documentação também, **ambos** `name` e `description` são marcados como **obrigatórios** com um **asterisco vermelho**:
 
 <div class="screenshot">
 <img src="/img/tutorial/separate-openapi-schemas/image03.png">
 </div>
 
-### Modelo para Entrada e Saída na Documentação
+### Modelo para Entrada e Saída na Documentação { #model-for-input-and-output-in-docs }
 
 E se você verificar todos os Schemas disponíveis (JSON Schemas) no OpenAPI, verá que há dois, um `Item-Input` e um `Item-Output`.
 
@@ -77,7 +77,7 @@ Mas para `Item-Output`, `description` **é obrigatório**, tem um asterisco verm
 
 Com esse recurso do **Pydantic v2**, sua documentação da API fica mais **precisa**, e se você tiver clientes e SDKs gerados automaticamente, eles serão mais precisos também, proporcionando uma melhor **experiência para desenvolvedores** e consistência. 🎉
 
-## Não Separe Schemas
+## Não Separe Schemas { #do-not-separate-schemas }
 
 Agora, há alguns casos em que você pode querer ter o **mesmo esquema para entrada e saída**.
 
@@ -93,7 +93,7 @@ O suporte para `separate_input_output_schemas` foi adicionado no FastAPI `0.102.
 
 {* ../../docs_src/separate_openapi_schemas/tutorial002_py310.py hl[10] *}
 
-### Mesmo Esquema para Modelos de Entrada e Saída na Documentação
+### Mesmo Esquema para Modelos de Entrada e Saída na Documentação { #same-schema-for-input-and-output-models-in-docs }
 
 E agora haverá um único esquema para entrada e saída para o modelo, apenas `Item`, e `description` **não será obrigatório**:
 

docs/pt/docs/how-to/testing-database.md

@@ -1,7 +1,7 @@
-# Testando a Base de Dados
+# Testando a Base de Dados { #testing-a-database }
 
 Você pode estudar sobre bases de dados, SQL e SQLModel na <a href="https://sqlmodel.tiangolo.com/" class="external-link" target="_blank">documentação de SQLModel</a>. 🤓
 
 Aqui tem um mini <a href="https://sqlmodel.tiangolo.com/tutorial/fastapi/" class="external-link" target="_blank">tutorial de como usar SQLModel com FastAPI</a>. ✨
 
-Esse tutorial inclui uma sessão sobre <a href="https://sqlmodel.tiangolo.com/tutorial/fastapi/tests/" class="external-link" target="_blank">testar bases de dados SQL</a>. 😎
+Esse tutorial inclui uma seção sobre <a href="https://sqlmodel.tiangolo.com/tutorial/fastapi/tests/" class="external-link" target="_blank">testar bases de dados SQL</a>. 😎

docs/pt/docs/index.md

@@ -1,11 +1,11 @@
-# FastAPI
+# FastAPI { #fastapi }
 
 <style>
 .md-content .md-typeset h1 { display: none; }
 </style>
 
 <p align="center">
-  <a href="https://fastapi.tiangolo.com"><img src="https://fastapi.tiangolo.com/img/logo-margin/logo-teal.png" alt="FastAPI"></a>
+  <a href="https://fastapi.tiangolo.com/pt"><img src="https://fastapi.tiangolo.com/img/logo-margin/logo-teal.png" alt="FastAPI"></a>
 </p>
 <p align="center">
     <em>Framework FastAPI, alta performance, fácil de aprender, fácil de codar, pronto para produção</em>
@@ -27,7 +27,7 @@
 
 ---
 
-**Documentação**: <a href="https://fastapi.tiangolo.com" target="_blank">https://fastapi.tiangolo.com</a>
+**Documentação**: <a href="https://fastapi.tiangolo.com/pt" target="_blank">https://fastapi.tiangolo.com</a>
 
 **Código fonte**: <a href="https://github.com/fastapi/fastapi" target="_blank">https://github.com/fastapi/fastapi</a>
 
@@ -40,15 +40,15 @@ Os recursos chave são:
 * **Rápido**: alta performance, equivalente a **NodeJS** e **Go** (graças ao Starlette e Pydantic). [Um dos frameworks mais rápidos disponíveis](#performance).
 * **Rápido para codar**: Aumenta a velocidade para desenvolver recursos entre 200% a 300%. *
 * **Poucos bugs**: Reduz cerca de 40% de erros induzidos por humanos (desenvolvedores). *
-* **Intuitivo**: Grande suporte a _IDEs_. <abbr title="também conhecido como _auto-complete_, _autocompletion_, _IntelliSense_">_Auto-Complete_</abbr> em todos os lugares. Menos tempo debugando.
+* **Intuitivo**: Grande suporte a _IDEs_. <abbr title="também conhecido como autocompletar, preenchimento automático, IntelliSense">Preenchimento automático</abbr> em todos os lugares. Menos tempo debugando.
 * **Fácil**: Projetado para ser fácil de aprender e usar. Menos tempo lendo documentação.
-* **Enxuto**: Minimize duplicação de código. Múltiplos recursos para cada declaração de parâmetro. Menos bugs.
+* **Enxuto**: Minimize duplicação de código. Múltiplas funcionalidades para cada declaração de parâmetro. Menos bugs.
 * **Robusto**: Tenha código pronto para produção. E com documentação interativa automática.
-* **Baseado em padrões**: Baseado em (e totalmente compatível com) os padrões abertos para APIs: <a href="https://github.com/OAI/OpenAPI-Specification" class="external-link" target="_blank">OpenAPI</a> (anteriormente conhecido como Swagger) e <a href="https://json-schema.org/" class="external-link" target="_blank">_JSON Schema_</a>.
+* **Baseado em padrões**: Baseado em (e totalmente compatível com) os padrões abertos para APIs: <a href="https://github.com/OAI/OpenAPI-Specification" class="external-link" target="_blank">OpenAPI</a> (anteriormente conhecido como Swagger) e <a href="https://json-schema.org/" class="external-link" target="_blank">JSON Schema</a>.
 
 <small>* estimativas baseadas em testes realizados com equipe interna de desenvolvimento, construindo aplicações em produção.</small>
 
-## Patrocinadores Ouro
+## Patrocinadores { #sponsors }
 
 <!-- sponsors -->
 
@@ -63,9 +63,9 @@ Os recursos chave são:
 
 <!-- /sponsors -->
 
-<a href="https://fastapi.tiangolo.com/fastapi-people/#sponsors" class="external-link" target="_blank">Outros patrocinadores</a>
+<a href="https://fastapi.tiangolo.com/pt/fastapi-people/#sponsors" class="external-link" target="_blank">Outros patrocinadores</a>
 
-## Opiniões
+## Opiniões { #opinions }
 
 "*[...] Estou usando **FastAPI** muito esses dias. [...] Estou na verdade planejando utilizar ele em todos os times de **serviços _Machine Learning_ na Microsoft**. Alguns deles estão sendo integrados no _core_ do produto **Windows** e alguns produtos **Office**.*"
 
@@ -111,24 +111,24 @@ Os recursos chave são:
 
 ---
 
-## **Typer**, o FastAPI das interfaces de linhas de comando
+## **Typer**, o FastAPI das interfaces de linhas de comando { #typer-the-fastapi-of-clis }
 
 <a href="https://typer.tiangolo.com" target="_blank"><img src="https://typer.tiangolo.com/img/logo-margin/logo-margin-vector.svg" style="width: 20%;"></a>
 
-Se você estiver construindo uma aplicação <abbr title="Command Line Interface">_CLI_</abbr> para ser utilizada em um terminal ao invés de uma aplicação web, dê uma olhada no <a href="https://typer.tiangolo.com/" class="external-link" target="_blank">**Typer**</a>.
+Se você estiver construindo uma aplicação <abbr title="Command Line Interface – Interface de Linha de Comando">CLI</abbr> para ser utilizada em um terminal ao invés de uma aplicação web, dê uma olhada no <a href="https://typer.tiangolo.com/" class="external-link" target="_blank">**Typer**</a>.
 
 **Typer** é o irmão menor do FastAPI. E seu propósito é ser o **FastAPI das _CLIs_**. ⌨️ 🚀
 
-## Requisitos
+## Requisitos { #requirements }
 
 FastAPI está nos ombros de gigantes:
 
 * <a href="https://www.starlette.dev/" class="external-link" target="_blank">Starlette</a> para as partes web.
 * <a href="https://docs.pydantic.dev/" class="external-link" target="_blank">Pydantic</a> para a parte de dados.
 
-## Instalação
+## Instalação { #installation }
 
-Crie e ative um <a href="https://fastapi.tiangolo.com/pt/virtual-environments/" class="external-link" target="_blank">ambiente virtual</a>, e então instale o FastAPI:
+Crie e ative um <a href="https://fastapi.tiangolo.com/pt/virtual-environments/" class="external-link" target="_blank">ambiente virtual</a> e então instale o FastAPI:
 
 <div class="termy">
 
@@ -142,11 +142,11 @@ $ pip install "fastapi[standard]"
 
 **Nota**: Certifique-se de que você colocou `"fastapi[standard]"` com aspas, para garantir que funcione em todos os terminais.
 
-## Exemplo
+## Exemplo { #example }
 
-### Crie
+### Crie { #create-it }
 
-* Crie um arquivo `main.py` com:
+Crie um arquivo `main.py` com:
 
 ```Python
 from typing import Union
@@ -191,11 +191,11 @@ async def read_item(item_id: int, q: Union[str, None] = None):
 
 **Nota**:
 
-Se você não sabe, verifique a seção _"Com pressa?"_ sobre <a href="https://fastapi.tiangolo.com/pt/async/#com-pressa" target="_blank">`async` e `await` nas docs</a>.
+Se você não sabe, verifique a seção _"Com pressa?"_ sobre <a href="https://fastapi.tiangolo.com/pt/async/#in-a-hurry" target="_blank">`async` e `await` nas docs</a>.
 
 </details>
 
-### Rode
+### Rode { #run-it }
 
 Rode o servidor com:
 
@@ -237,7 +237,7 @@ Você pode ler mais sobre isso na <a href="https://fastapi.tiangolo.com/pt/fasta
 
 </details>
 
-### Verifique
+### Verifique { #check-it }
 
 Abra seu navegador em <a href="http://127.0.0.1:8000/items/5?q=somequery" class="external-link" target="_blank">http://127.0.0.1:8000/items/5?q=somequery</a>.
 
@@ -254,7 +254,7 @@ Você acabou de criar uma API que:
 * A _rota_ `/items/{item_id}` tem um _parâmetro de rota_ `item_id` que deve ser um `int`.
 * A _rota_ `/items/{item_id}` tem um _parâmetro query_ `q` `str` opcional.
 
-### Documentação Interativa da API
+### Documentação Interativa da API { #interactive-api-docs }
 
 Agora vá para <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>.
 
@@ -262,7 +262,7 @@ Você verá a documentação automática interativa da API (fornecida por <a hre
 
 ![Swagger UI](https://fastapi.tiangolo.com/img/index/index-01-swagger-ui-simple.png)
 
-### Documentação Alternativa da API
+### Documentação Alternativa da API { #alternative-api-docs }
 
 E agora, vá para <a href="http://127.0.0.1:8000/redoc" class="external-link" target="_blank">http://127.0.0.1:8000/redoc</a>.
 
@@ -270,7 +270,7 @@ Você verá a documentação automática alternativa (fornecida por <a href="htt
 
 ![ReDoc](https://fastapi.tiangolo.com/img/index/index-02-redoc-simple.png)
 
-## Evoluindo o Exemplo
+## Evoluindo o Exemplo { #example-upgrade }
 
 Agora modifique o arquivo `main.py` para receber um corpo para uma requisição `PUT`.
 
@@ -308,7 +308,7 @@ def update_item(item_id: int, item: Item):
 
 O servidor `fastapi dev` deverá recarregar automaticamente.
 
-### Evoluindo a Documentação Interativa da API
+### Evoluindo a Documentação Interativa da API { #interactive-api-docs-upgrade }
 
 Agora vá para <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>.
 
@@ -324,7 +324,7 @@ Agora vá para <a href="http://127.0.0.1:8000/docs" class="external-link" target
 
 ![Swagger UI interaction](https://fastapi.tiangolo.com/img/index/index-05-swagger-04.png)
 
-### Evoluindo a Documentação Alternativa da API
+### Evoluindo a Documentação Alternativa da API { #alternative-api-docs-upgrade }
 
 E agora, vá para <a href="http://127.0.0.1:8000/redoc" class="external-link" target="_blank">http://127.0.0.1:8000/redoc</a>.
 
@@ -332,7 +332,7 @@ E agora, vá para <a href="http://127.0.0.1:8000/redoc" class="external-link" ta
 
 ![ReDoc](https://fastapi.tiangolo.com/img/index/index-06-redoc-02.png)
 
-### Recapitulando
+### Recapitulando { #recap }
 
 Resumindo, você declara **uma vez** os tipos dos parâmetros, corpo etc. como parâmetros de função.
 
@@ -362,7 +362,7 @@ item: Item
 * Validação de dados:
     * Erros automáticos e claros quando o dado é inválido.
     * Validação até para objetos JSON profundamente aninhados.
-* <abbr title="também conhecido como: serialization, parsing, marshalling">Conversão</abbr> de dados de entrada: vindo da rede para dados e tipos Python. Consegue ler:
+* <abbr title="também conhecido como: serialização, parsing, marshalling">Conversão</abbr> de dados de entrada: vindo da rede para dados e tipos Python. Consegue ler:
     * JSON.
     * Parâmetros de rota.
     * Parâmetros de _query_ .
@@ -370,7 +370,7 @@ item: Item
     * Cabeçalhos.
     * Formulários.
     * Arquivos.
-* <abbr title="também conhecido como: serialization, parsing, marshalling">Conversão</abbr> de dados de saída de tipos e dados Python para dados de rede (como JSON):
+* <abbr title="também conhecido como: serialização, parsing, marshalling">Conversão</abbr> de dados de saída de tipos e dados Python para dados de rede (como JSON):
     * Converte tipos Python (`str`, `int`, `float`, `bool`, `list` etc).
     * Objetos `datetime`.
     * Objetos `UUID`.
@@ -390,7 +390,7 @@ Voltando ao código do exemplo anterior, **FastAPI** irá:
 * Verificar se existe um parâmetro de _query_ opcional nomeado como `q` (como em `http://127.0.0.1:8000/items/foo?q=somequery`) para requisições `GET`.
     * Como o parâmetro `q` é declarado com `= None`, ele é opcional.
     * Sem o `None` ele poderia ser obrigatório (como o corpo no caso de `PUT`).
-* Para requisições `PUT` para `/items/{item_id}`, lerá o corpo como JSON e:
+* Para requisições `PUT` para `/items/{item_id}`, lerá o corpo como JSON:
     * Verifica que tem um atributo obrigatório `name` que deve ser `str`.
     * Verifica que tem um atributo obrigatório `price` que deve ser `float`.
     * Verifica que tem an atributo opcional `is_offer`, que deve ser `bool`, se presente.
@@ -444,18 +444,17 @@ Para um exemplo mais completo incluindo mais recursos, veja <a href="https://fas
     * **Cookie Sessions**
     * ...e mais.
 
-## Performance
+## Performance { #performance }
 
 Testes de performance da _Independent TechEmpower_ mostram aplicações **FastAPI** rodando sob Uvicorn como <a href="https://www.techempower.com/benchmarks/#section=test&runid=7464e520-0dc2-473d-bd34-dbdfd7e85911&hw=ph&test=query&l=zijzen-7" class="external-link" target="_blank">um dos _frameworks_ Python mais rápidos disponíveis</a>, somente atrás de Starlette e Uvicorn (utilizados internamente pelo FastAPI). (*)
 
 Para entender mais sobre performance, veja a seção <a href="https://fastapi.tiangolo.com/pt/benchmarks/" class="internal-link" target="_blank">Comparações</a>.
 
-## Dependências
+## Dependências { #dependencies }
 
 O FastAPI depende do Pydantic e do Starlette.
 
-
-### Dependências `standard`
+### Dependências `standard` { #standard-dependencies }
 
 Quando você instala o FastAPI com `pip install "fastapi[standard]"`, ele vêm com o grupo `standard` (padrão) de dependências opcionais:
 
@@ -467,18 +466,23 @@ Utilizado pelo Starlette:
 
 * <a href="https://www.python-httpx.org" target="_blank"><code>httpx</code></a> - Obrigatório caso você queira utilizar o `TestClient`.
 * <a href="https://jinja.palletsprojects.com" target="_blank"><code>jinja2</code></a> - Obrigatório se você quer utilizar a configuração padrão de templates.
-* <a href="https://github.com/Kludex/python-multipart" target="_blank"><code>python-multipart</code></a> - Obrigatório se você deseja suporte a <abbr title="converting the string that comes from an HTTP request into Python data">"parsing"</abbr> de formulário, com `request.form()`.
+* <a href="https://github.com/Kludex/python-multipart" target="_blank"><code>python-multipart</code></a> - Obrigatório se você deseja suporte a <abbr title="convertendo a string que vem de uma requisição HTTP em dados Python">"parsing"</abbr> de formulário, com `request.form()`.
 
-Utilizado pelo FastAPI / Starlette:
+Utilizado pelo FastAPI:
 
 * <a href="https://www.uvicorn.dev" target="_blank"><code>uvicorn</code></a> - 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` - que disponibiliza o comando `fastapi`.
+* `fastapi-cli[standard]` - que disponibiliza o comando `fastapi`.
+    * Isso inclui `fastapi-cloud-cli`, que permite implantar sua aplicação FastAPI na <a href="https://fastapicloud.com" class="external-link" target="_blank">FastAPI Cloud</a>.
 
-### Sem as dependências `standard`
+### 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]"`.
 
-### Dpendências opcionais adicionais
+### 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]"`.
+
+### Dependências opcionais adicionais { #additional-optional-dependencies }
 
 Existem algumas dependências adicionais que você pode querer instalar.
 
@@ -492,6 +496,6 @@ Dependências opcionais adicionais do FastAPI:
 * <a href="https://github.com/ijl/orjson" target="_blank"><code>orjson</code></a> - Obrigatório se você deseja utilizar o `ORJSONResponse`.
 * <a href="https://github.com/esnme/ultrajson" target="_blank"><code>ujson</code></a> - Obrigatório se você deseja utilizar o `UJSONResponse`.
 
-## Licença
+## Licença { #license }
 
 Esse projeto é licenciado sob os termos da licença MIT.

docs/pt/docs/learn/index.md

@@ -1,5 +1,5 @@
-# Aprender
+# Aprender { #learn }
 
-Nesta parte da documentação encontramos as seções introdutórias e os tutoriais para aprendermos como usar o **FastAPI**.
+Aqui estão as seções introdutórias e os tutoriais para aprender o **FastAPI**.
 
-Nós poderíamos considerar isto um **livro**, **curso**, a maneira **oficial** e recomendada de aprender o FastAPI. 😎
+Pode considerar isto um **livro**, um **curso**, a forma **oficial** e recomendada de aprender o FastAPI. 😎

docs/pt/docs/project-generation.md

@@ -1,4 +1,4 @@
-# Full Stack FastAPI Template
+# Full Stack FastAPI Template { #full-stack-fastapi-template }
 
 _Templates_, embora tipicamente venham com alguma configuração específica, são desenhados para serem flexíveis e customizáveis. Isso permite que você os modifique e adapte para as especificações do seu projeto, fazendo-os um excelente ponto de partida. 🏁
 
@@ -6,9 +6,9 @@ Você pode usar esse _template_ para começar, já que ele inclui várias config
 
 Repositório GitHub: <a href="https://github.com/tiangolo/full-stack-fastapi-template" class="external-link" target="_blank">Full Stack FastAPI Template</a>
 
-## Full Stack FastAPI Template - Pilha de Tecnologias e Recursos
+## Full Stack FastAPI Template - Pilha de Tecnologias e Recursos { #full-stack-fastapi-template-technology-stack-and-features }
 
-- ⚡ [**FastAPI**](https://fastapi.tiangolo.com) para a API do backend em Python.
+- ⚡ [**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.
     - 💾 [PostgreSQL](https://www.postgresql.org) como banco de dados SQL.

docs/pt/docs/python-types.md

@@ -1,4 +1,4 @@
-# Introdução aos tipos Python
+# Introdução aos tipos Python { #python-types-intro }
 
 O Python possui suporte para "dicas de tipo" ou "type hints" (também chamado de "anotações de tipo" ou "type annotations")
 
@@ -18,7 +18,7 @@ Se você é um especialista em Python e já sabe tudo sobre type hints, pule par
 
 ///
 
-## Motivação
+## Motivação { #motivation }
 
 Vamos começar com um exemplo simples:
 
@@ -38,7 +38,7 @@ A função faz o seguinte:
 
 {* ../../docs_src/python_types/tutorial001.py hl[2] *}
 
-### Edite-o
+### Edite-o { #edit-it }
 
 É um programa muito simples.
 
@@ -58,7 +58,7 @@ Mas, infelizmente, você não obtém nada útil:
 
 <img src="/img/python-types/image01.png">
 
-### Adicionar tipos
+### Adicionar tipos { #add-types }
 
 Vamos modificar uma única linha da versão anterior.
 
@@ -102,7 +102,7 @@ Com isso, você pode rolar, vendo as opções, até encontrar o que "soa familia
 
 <img src="/img/python-types/image03.png">
 
-## Mais motivação
+## Mais motivação { #more-motivation }
 
 Verifique esta função, ela já possui type hints:
 
@@ -116,13 +116,13 @@ Agora você sabe que precisa corrigí-lo, converta `age` em uma string com `str(
 
 {* ../../docs_src/python_types/tutorial004.py hl[2] *}
 
-## Declarando Tipos
+## Declarando Tipos { #declaring-types }
 
 Você acabou de ver o local principal para declarar type hints. Como parâmetros de função.
 
 Este também é o principal local em que você os usaria com o **FastAPI**.
 
-### Tipos simples
+### Tipos simples { #simple-types }
 
 Você pode declarar todos os tipos padrão de Python, não apenas `str`.
 
@@ -135,7 +135,7 @@ Você pode usar, por exemplo:
 
 {* ../../docs_src/python_types/tutorial005.py hl[1] *}
 
-### Tipos genéricos com parâmetros de tipo
+### Tipos genéricos com parâmetros de tipo { #generic-types-with-type-parameters }
 
 Existem algumas estruturas de dados que podem conter outros valores, como `dict`, `list`, `set` e `tuple`. E os valores internos também podem ter seu próprio tipo.
 
@@ -143,7 +143,7 @@ Estes tipos que possuem tipos internos são chamados de tipos "**genéricos**".
 
 Para declarar esses tipos e os tipos internos, você pode usar o módulo Python padrão `typing`. Ele existe especificamente para suportar esses type hints.
 
-#### Versões mais recentes do Python
+#### Versões mais recentes do Python { #newer-versions-of-python }
 
 A sintaxe utilizando `typing` é **compatível** com todas as versões, desde o Python 3.6 até as últimas, incluindo o Python 3.9, 3.10, etc.
 
@@ -157,7 +157,7 @@ Por exemplo, "**Python 3.6+**" significa que é compatível com o Python 3.6 ou
 
 Se você pode utilizar a **versão mais recente do Python**, utilize os exemplos para as últimas versões. Eles terão as **melhores e mais simples sintaxes**, como por exemplo, "**Python 3.10+**".
 
-#### List
+#### List { #list }
 
 Por exemplo, vamos definir uma variável para ser uma `list` de `str`.
 
@@ -221,7 +221,7 @@ Observe que a variável `item` é um dos elementos da lista `items`.
 
 E, ainda assim, o editor sabe que é um `str` e fornece suporte para isso.
 
-#### Tuple e Set
+#### Tuple e Set { #tuple-and-set }
 
 Você faria o mesmo para declarar `tuple`s e `set`s:
 
@@ -246,7 +246,7 @@ Isso significa que:
 * A variável `items_t` é uma `tuple` com 3 itens, um `int`, outro `int` e uma `str`.
 * A variável `items_s` é um `set`, e cada um de seus itens é do tipo `bytes`.
 
-#### Dict
+#### Dict { #dict }
 
 Para definir um `dict`, você passa 2 parâmetros de tipo, separados por vírgulas.
 
@@ -272,17 +272,17 @@ O segundo parâmetro de tipo é para os valores do `dict`:
 
 Isso significa que:
 
-* A variável `prices` é um dict`:
+* A variável `prices` é um `dict`:
     * As chaves deste `dict` são do tipo `str` (digamos, o nome de cada item).
     * Os valores deste `dict` são do tipo `float` (digamos, o preço de cada item).
 
-#### Union
+#### Union { #union }
 
 Você pode declarar que uma variável pode ser de qualquer um dentre **diversos tipos**. Por exemplo, um `int` ou um `str`.
 
 No Python 3.6 e superior (incluindo o Python 3.10), você pode utilizar o tipo `Union` de `typing`, e colocar dentro dos colchetes os possíveis tipos aceitáveis.
 
-No Python 3.10 também existe uma **nova sintaxe** onde você pode colocar os possívels tipos separados por uma <abbr title='também chamado de "bitwise ou operador", mas o significado é irrelevante aqui'>barra vertical (`|`)</abbr>.
+No Python 3.10 também existe uma **nova sintaxe** onde você pode colocar os possíveis tipos separados por uma <abbr title='também chamado de "bitwise ou operador", mas o significado é irrelevante aqui'>barra vertical (`|`)</abbr>.
 
 //// tab | Python 3.10+
 
@@ -302,8 +302,7 @@ No Python 3.10 também existe uma **nova sintaxe** onde você pode colocar os po
 
 Em ambos os casos, isso significa que `item` poderia ser um `int` ou um `str`.
 
-
-#### Possívelmente `None`
+#### Possivelmente `None` { #possibly-none }
 
 Você pode declarar que um valor pode ter um tipo, como `str`, mas que ele também pode ser `None`.
 
@@ -335,7 +334,7 @@ Isso também significa que no Python 3.10, você pode utilizar `Something | None
 
 ////
 
-//// tab | Python 3.8+ alternative
+//// tab | Python 3.8+ alternativa
 
 ```Python hl_lines="1  4"
 {!> ../../docs_src/python_types/tutorial009b.py!}
@@ -343,7 +342,7 @@ Isso também significa que no Python 3.10, você pode utilizar `Something | None
 
 ////
 
-#### Utilizando `Union` ou `Optional`
+#### Utilizando `Union` ou `Optional` { #using-union-or-optional }
 
 Se você está utilizando uma versão do Python abaixo da 3.10, aqui vai uma dica do meu ponto de vista bem **subjetivo**:
 
@@ -360,13 +359,13 @@ Por exemplo, vamos pegar esta função:
 
 {* ../../docs_src/python_types/tutorial009c.py hl[1,4] *}
 
-O paâmetro `name` é definido como `Optional[str]`, mas ele **não é opcional**, você não pode chamar a função sem o parâmetro:
+O parâmetro `name` é definido como `Optional[str]`, mas ele **não é opcional**, você não pode chamar a função sem o parâmetro:
 
 ```Python
 say_hi()  # Oh, no, this throws an error! 😱
 ```
 
-O parâmetro `name` **ainda é obrigatório** (não *opicional*) porque ele não possui um valor padrão. Mesmo assim, `name` aceita `None` como valor:
+O parâmetro `name` **ainda é obrigatório** (não *opcional*) porque ele não possui um valor padrão. Mesmo assim, `name` aceita `None` como valor:
 
 ```Python
 say_hi(name=None)  # This works, None is valid 🎉
@@ -378,7 +377,7 @@ A boa notícia é, quando você estiver no Python 3.10 você não precisará se
 
 E então você não precisará mais se preocupar com nomes como `Optional` e `Union`. 😎
 
-#### Tipos genéricos
+#### Tipos genéricos { #generic-types }
 
 Esses tipos que usam parâmetros de tipo entre colchetes são chamados **tipos genéricos** ou **genéricos**. Por exemplo:
 
@@ -395,7 +394,7 @@ E o mesmo como no Python 3.8, do módulo `typing`:
 
 * `Union`
 * `Optional` (o mesmo que com o 3.8)
-* ...entro outros.
+* ...entre outros.
 
 No Python 3.10, como uma alternativa para a utilização dos genéricos `Union` e `Optional`, você pode usar a <abbr title='também chamado de "bitwise ou operador", mas o significado não é relevante aqui'>barra vertical (`|`)</abbr> para declarar uniões de tipos. Isso é muito melhor e mais simples.
 
@@ -414,7 +413,7 @@ E o mesmo como no Python 3.8, do módulo `typing`:
 
 * `Union`
 * `Optional`
-* ...entro outros.
+* ...entre outros.
 
 ////
 
@@ -426,11 +425,11 @@ E o mesmo como no Python 3.8, do módulo `typing`:
 * `Dict`
 * `Union`
 * `Optional`
-* ...entro outros.
+* ...entre outros.
 
 ////
 
-### Classes como tipos
+### Classes como tipos { #classes-as-types }
 
 Você também pode declarar uma classe como o tipo de uma variável.
 
@@ -450,7 +449,7 @@ Perceba que isso significa que "`one_person` é uma **instância** da classe `Pe
 
 Isso não significa que "`one_person` é a **classe** chamada `Person`".
 
-## Modelos Pydantic
+## Modelos Pydantic { #pydantic-models }
 
 O <a href="https://docs.pydantic.dev/" class="external-link" target="_blank">Pydantic</a> é uma biblioteca Python para executar a validação de dados.
 
@@ -504,8 +503,7 @@ O Pydantic tem um comportamento especial quando você usa `Optional` ou `Union[S
 
 ///
 
-
-## Type Hints com Metadados de Anotações
+## Type Hints com Metadados de Anotações { #type-hints-with-metadata-annotations }
 
 O Python possui uma funcionalidade que nos permite incluir **<abbr title="Informação sobre a informação, neste caso, informação sobre o tipo, e.g. uma descrição.">metadados</abbr> adicionais** nos type hints utilizando `Annotated`.
 
@@ -549,8 +547,7 @@ E também que o seu código será muito compatível com diversas outras ferramen
 
 ///
 
-
-## Type hints no **FastAPI**
+## Type hints no **FastAPI** { #type-hints-in-fastapi }
 
 O **FastAPI** aproveita esses type hints para fazer várias coisas.
 
@@ -574,6 +571,6 @@ O importante é que, usando tipos padrão de Python, em um único local (em vez
 
 /// info | Informação
 
-Se você já passou por todo o tutorial e voltou para ver mais sobre os tipos, um bom recurso é <a href = "https://mypy.readthedocs.io/en/latest/cheat_sheet_py3.html" class = "external-link "target =" _ blank "> a "cheat sheet" do `mypy` </a>.
+Se você já passou por todo o tutorial e voltou para ver mais sobre os tipos, um bom recurso é <a href="https://mypy.readthedocs.io/en/latest/cheat_sheet_py3.html" class="external-link" target="_blank"> a "cheat sheet" do `mypy` </a>.
 
 ///

docs/pt/docs/resources/index.md

@@ -1,3 +1,3 @@
-# Recursos
+# Recursos { #resources }
 
 Material complementar, links externos, artigos e muito mais. ✈️

docs/pt/docs/tutorial/background-tasks.md

@@ -1,84 +1,85 @@
-# Tarefas em segundo plano
+# Tarefas em segundo plano { #background-tasks }
 
-Você pode definir tarefas em segundo plano a serem executadas _ após _ retornar uma resposta.
+Você pode definir tarefas em segundo plano para serem executadas *após* retornar uma resposta.
 
-Isso é útil para operações que precisam acontecer após uma solicitação, mas que o cliente realmente não precisa esperar a operação ser concluída para receber a resposta.
+Isso é útil para operações que precisam acontecer após uma request, mas que o cliente não precisa realmente esperar a operação terminar antes de receber a resposta.
 
 Isso inclui, por exemplo:
 
-- Envio de notificações por email após a realização de uma ação:
-  - Como conectar-se a um servidor de e-mail e enviar um e-mail tende a ser "lento" (vários segundos), você pode retornar a resposta imediatamente e enviar a notificação por e-mail em segundo plano.
-- Processando dados:
-  - Por exemplo, digamos que você receba um arquivo que deve passar por um processo lento, você pode retornar uma resposta de "Aceito" (HTTP 202) e processá-lo em segundo plano.
+* Notificações por e-mail enviadas após realizar uma ação:
+    * Como conectar-se a um servidor de e-mail e enviar um e-mail tende a ser “lento” (vários segundos), você pode retornar a resposta imediatamente e enviar a notificação por e-mail em segundo plano.
+* Processamento de dados:
+    * Por exemplo, digamos que você receba um arquivo que precisa passar por um processo lento; você pode retornar uma resposta “Accepted” (HTTP 202) e processar o arquivo em segundo plano.
 
-## Usando `BackgroundTasks`
+## Usando `BackgroundTasks` { #using-backgroundtasks }
 
-Primeiro, importe `BackgroundTasks` e defina um parâmetro em sua _função de operação de caminho_ com uma declaração de tipo de `BackgroundTasks`:
+Primeiro, importe `BackgroundTasks` e defina um parâmetro na sua *função de operação de rota* com uma declaração de tipo `BackgroundTasks`:
 
 {* ../../docs_src/background_tasks/tutorial001.py hl[1,13] *}
 
 O **FastAPI** criará o objeto do tipo `BackgroundTasks` para você e o passará como esse parâmetro.
 
-## Criar uma função de tarefa
+## Crie uma função de tarefa { #create-a-task-function }
 
-Crie uma função a ser executada como tarefa em segundo plano.
+Crie uma função para ser executada como a tarefa em segundo plano.
 
 É apenas uma função padrão que pode receber parâmetros.
 
-Pode ser uma função `async def` ou `def` normal, o **FastAPI** saberá como lidar com isso corretamente.
+Pode ser uma função `async def` ou um `def` normal, o **FastAPI** saberá como lidar com isso corretamente.
 
-Nesse caso, a função de tarefa gravará em um arquivo (simulando o envio de um e-mail).
+Neste caso, a função da tarefa escreverá em um arquivo (simulando o envio de um e-mail).
 
-E como a operação de gravação não usa `async` e `await`, definimos a função com `def` normal:
+E como a operação de escrita não usa `async` e `await`, definimos a função com um `def` normal:
 
 {* ../../docs_src/background_tasks/tutorial001.py hl[6:9] *}
 
-## Adicionar a tarefa em segundo plano
+## Adicione a tarefa em segundo plano { #add-the-background-task }
 
-Dentro de sua _função de operação de caminho_, passe sua função de tarefa para o objeto _tarefas em segundo plano_ com o método `.add_task()`:
+Dentro da sua *função de operação de rota*, passe sua função de tarefa para o objeto de *tarefas em segundo plano* com o método `.add_task()`:
 
 {* ../../docs_src/background_tasks/tutorial001.py hl[14] *}
 
-`.add_task()` recebe como argumentos:
+O `.add_task()` recebe como argumentos:
 
-- Uma função de tarefa a ser executada em segundo plano (`write_notification`).
-- Qualquer sequência de argumentos que deve ser passada para a função de tarefa na ordem (`email`).
-- Quaisquer argumentos nomeados que devem ser passados ​​para a função de tarefa (`mensagem = "alguma notificação"`).
+* Uma função de tarefa a ser executada em segundo plano (`write_notification`).
+* Qualquer sequência de argumentos que deve ser passada para a função de tarefa na ordem (`email`).
+* Quaisquer argumentos nomeados que devem ser passados para a função de tarefa (`message="some notification"`).
 
-## Injeção de dependência
+## Injeção de dependências { #dependency-injection }
 
-Usar `BackgroundTasks` também funciona com o sistema de injeção de dependência, você pode declarar um parâmetro do tipo `BackgroundTasks` em vários níveis: em uma _função de operação de caminho_, em uma dependência (confiável), em uma subdependência, etc.
+Usar `BackgroundTasks` também funciona com o sistema de injeção de dependências; você pode declarar um parâmetro do tipo `BackgroundTasks` em vários níveis: em uma *função de operação de rota*, em uma dependência (dependable), em uma subdependência, etc.
 
-O **FastAPI** sabe o que fazer em cada caso e como reutilizar o mesmo objeto, de forma que todas as tarefas em segundo plano sejam mescladas e executadas em segundo plano posteriormente:
+O **FastAPI** sabe o que fazer em cada caso e como reutilizar o mesmo objeto, de forma que todas as tarefas em segundo plano sejam combinadas e executadas em segundo plano depois:
 
-{* ../../docs_src/background_tasks/tutorial002.py hl[13,15,22,25] *}
 
-Neste exemplo, as mensagens serão gravadas no arquivo `log.txt` _após_ o envio da resposta.
+{* ../../docs_src/background_tasks/tutorial002_an_py310.py hl[13,15,22,25] *}
 
-Se houver uma consulta na solicitação, ela será gravada no log em uma tarefa em segundo plano.
+Neste exemplo, as mensagens serão escritas no arquivo `log.txt` *após* o envio da resposta.
 
-E então outra tarefa em segundo plano gerada na _função de operação de caminho_ escreverá uma mensagem usando o parâmetro de caminho `email`.
+Se houver uma query na request, ela será registrada em uma tarefa em segundo plano.
 
-## Detalhes técnicos
+E então outra tarefa em segundo plano gerada na *função de operação de rota* escreverá uma mensagem usando o parâmetro de path `email`.
+
+## Detalhes técnicos { #technical-details }
 
 A classe `BackgroundTasks` vem diretamente de <a href="https://www.starlette.dev/background/" class="external-link" target="_blank">`starlette.background`</a>.
 
-Ela é importada/incluída diretamente no FastAPI para que você possa importá-la do `fastapi` e evitar a importação acidental da alternativa `BackgroundTask` (sem o `s` no final) de `starlette.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`.
 
-Usando apenas `BackgroundTasks` (e não `BackgroundTask`), é então possível usá-la como um parâmetro de _função de operação de caminho_ e deixar o **FastAPI** cuidar do resto para você, assim como ao usar o objeto `Request` diretamente.
+Usando apenas `BackgroundTasks` (e não `BackgroundTask`), é possível usá-la como um parâmetro de *função de operação de rota* e deixar o **FastAPI** cuidar do resto para você, assim como ao usar o objeto `Request` diretamente.
 
-Ainda é possível usar `BackgroundTask` sozinho no FastAPI, mas você deve criar o objeto em seu código e retornar uma Starlette `Response` incluindo-o.
+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 <a href="https://www.starlette.dev/background/" class="external-link" target="_blank"> documentação oficiais da Starlette para tarefas em segundo plano </a>.
+Você pode ver mais detalhes na <a href="https://www.starlette.dev/background/" class="external-link" target="_blank">documentação oficial da Starlette para tarefas em segundo plano</a>.
 
-## Ressalva
+## Ressalva { #caveat }
 
-Se você precisa realizar cálculos pesados ​​em segundo plano e não necessariamente precisa que seja executado pelo mesmo processo (por exemplo, você não precisa compartilhar memória, variáveis, etc), você pode se beneficiar do uso de outras ferramentas maiores, como <a href="http://www.celeryproject.org/" class="external-link" target="_blank"> Celery </a>.
+Se você precisar realizar computação pesada em segundo plano e não necessariamente precisar que seja executada pelo mesmo processo (por exemplo, você não precisa compartilhar memória, variáveis, etc.), pode se beneficiar do uso de outras ferramentas maiores, como o <a href="https://docs.celeryq.dev" class="external-link" target="_blank">Celery</a>.
 
-Eles tendem a exigir configurações mais complexas, um gerenciador de fila de mensagens/tarefas, como RabbitMQ ou Redis, mas permitem que você execute tarefas em segundo plano em vários processos e, especialmente, em vários servidores.
+Elas tendem a exigir configurações mais complexas, um gerenciador de fila de mensagens/tarefas, como RabbitMQ ou Redis, mas permitem executar tarefas em segundo plano em vários processos e, especialmente, em vários servidores.
 
-Mas se você precisa acessar variáveis ​​e objetos do mesmo aplicativo **FastAPI**, ou precisa realizar pequenas tarefas em segundo plano (como enviar uma notificação por e-mail), você pode simplesmente usar `BackgroundTasks`.
+Mas se você precisa acessar variáveis e objetos da mesma aplicação **FastAPI**, ou precisa realizar pequenas tarefas em segundo plano (como enviar uma notificação por e-mail), você pode simplesmente usar `BackgroundTasks`.
 
-## Recapitulando
+## Recapitulando { #recap }
 
-Importe e use `BackgroundTasks` com parâmetros em _funções de operação de caminho_ e dependências para adicionar tarefas em segundo plano.
+Importe e use `BackgroundTasks` com parâmetros em *funções de operação de rota* e dependências para adicionar tarefas em segundo plano.

docs/pt/docs/tutorial/bigger-applications.md

@@ -1,4 +1,4 @@
-# Aplicações Maiores - Múltiplos Arquivos
+# Aplicações Maiores - Múltiplos Arquivos { #bigger-applications-multiple-files }
 
 Se você está construindo uma aplicação ou uma API web, é raro que você possa colocar tudo em um único arquivo.
 
@@ -10,7 +10,7 @@ Se você vem do Flask, isso seria o equivalente aos Blueprints do Flask.
 
 ///
 
-## Um exemplo de estrutura de arquivos
+## Um exemplo de estrutura de arquivos { #an-example-file-structure }
 
 Digamos que você tenha uma estrutura de arquivos como esta:
 
@@ -71,7 +71,7 @@ A mesma estrutura de arquivos com comentários:
 │       └── admin.py     # "admin" submódulo, e.g. import app.internal.admin
 ```
 
-## `APIRouter`
+## `APIRouter` { #apirouter }
 
 Vamos supor que o arquivo dedicado a lidar apenas com usuários seja o submódulo em `/app/routers/users.py`.
 
@@ -81,7 +81,7 @@ Mas ele ainda faz parte da mesma aplicação/web API **FastAPI** (faz parte do m
 
 Você pode criar as *operações de rotas* para esse módulo usando o `APIRouter`.
 
-### Importar `APIRouter`
+### Importe `APIRouter` { #import-apirouter }
 
 você o importa e cria uma "instância" da mesma maneira que faria com a classe `FastAPI`:
 
@@ -89,7 +89,7 @@ você o importa e cria uma "instância" da mesma maneira que faria com a classe
 {!../../docs_src/bigger_applications/app/routers/users.py!}
 ```
 
-### *Operações de Rota* com `APIRouter`
+### *Operações de Rota* com `APIRouter` { #path-operations-with-apirouter }
 
 E então você o utiliza para declarar suas *operações de rota*.
 
@@ -113,7 +113,7 @@ Neste exemplo, a variável é chamada de `router`, mas você pode nomeá-la como
 
 Vamos incluir este `APIRouter` na aplicação principal `FastAPI`, mas primeiro, vamos verificar as dependências e outro `APIRouter`.
 
-## Dependências
+## Dependências { #dependencies }
 
 Vemos que precisaremos de algumas dependências usadas em vários lugares da aplicação.
 
@@ -159,7 +159,7 @@ Mas em casos reais, você obterá melhores resultados usando os [Utilitários de
 
 ///
 
-## Outro módulo com `APIRouter`
+## Outro módulo com `APIRouter` { #another-module-with-apirouter }
 
 Digamos que você também tenha os endpoints dedicados a manipular "itens" do seu aplicativo no módulo em `app/routers/items.py`.
 
@@ -177,7 +177,7 @@ Sabemos que todas as *operações de rota* neste módulo têm o mesmo:
 * Path `prefix`: `/items`.
 * `tags`: (apenas uma tag: `items`).
 * Extra `responses`.
-* `dependências`: todas elas precisam da dependência `X-Token` que criamos.
+* `dependencies`: todas elas precisam da dependência `X-Token` que criamos.
 
 Então, em vez de adicionar tudo isso a cada *operação de rota*, podemos adicioná-lo ao `APIRouter`.
 
@@ -224,17 +224,17 @@ O resultado final é que os caminhos dos itens agora são:
 
 /// tip | Dica
 
-Ter `dependências` no `APIRouter` pode ser usado, por exemplo, para exigir autenticação para um grupo inteiro de *operações de rota*. Mesmo que as dependências não sejam adicionadas individualmente a cada uma delas.
+Ter `dependencies` no `APIRouter` pode ser usado, por exemplo, para exigir autenticação para um grupo inteiro de *operações de rota*. Mesmo que as dependências não sejam adicionadas individualmente a cada uma delas.
 
 ///
 
-/// check
+/// check | Verifique
 
 Os parâmetros `prefix`, `tags`, `responses` e `dependencies` são (como em muitos outros casos) apenas um recurso do **FastAPI** para ajudar a evitar duplicação de código.
 
 ///
 
-### Importar as dependências
+### Importe as dependências { #import-the-dependencies }
 
 Este código reside no módulo `app.routers.items`, o arquivo `app/routers/items.py`.
 
@@ -246,7 +246,7 @@ Então usamos uma importação relativa com `..` para as dependências:
 {!../../docs_src/bigger_applications/app/routers/items.py!}
 ```
 
-#### Como funcionam as importações relativas
+#### Como funcionam as importações relativas { #how-relative-imports-work }
 
 /// tip | Dica
 
@@ -309,11 +309,11 @@ Isso se referiria a algum pacote acima de `app/`, com seu próprio arquivo `__in
 
 Mas agora você sabe como funciona, então você pode usar importações relativas em seus próprios aplicativos, não importa o quão complexos eles sejam. 🤓
 
-### Adicione algumas `tags`, `respostas` e `dependências` personalizadas
+### Adicione algumas `tags`, `responses` e `dependencies` personalizadas { #add-some-custom-tags-responses-and-dependencies }
 
 Não estamos adicionando o prefixo `/items` nem `tags=["items"]` a cada *operação de rota* porque os adicionamos ao `APIRouter`.
 
-Mas ainda podemos adicionar _mais_ `tags` que serão aplicadas a uma *operação de rota* específica, e também algumas `respostas` extras específicas para essa *operação de rota*:
+Mas ainda podemos adicionar _mais_ `tags` que serão aplicadas a uma *operação de rota* específica, e também algumas `responses` extras específicas para essa *operação de rota*:
 
 ```Python hl_lines="30-31" title="app/routers/items.py"
 {!../../docs_src/bigger_applications/app/routers/items.py!}
@@ -327,7 +327,7 @@ E também terá ambas as respostas na documentação, uma para `404` e uma para
 
 ///
 
-## O principal `FastAPI`
+## O principal `FastAPI` { #the-main-fastapi }
 
 Agora, vamos ver o módulo em `app/main.py`.
 
@@ -337,7 +337,7 @@ Este será o arquivo principal em seu aplicativo que une tudo.
 
 E como a maior parte de sua lógica agora viverá em seu próprio módulo específico, o arquivo principal será bem simples.
 
-### Importar `FastAPI`
+### Importe o `FastAPI` { #import-fastapi }
 
 Você importa e cria uma classe `FastAPI` normalmente.
 
@@ -347,7 +347,7 @@ E podemos até declarar [dependências globais](dependencies/global-dependencies
 {!../../docs_src/bigger_applications/app/main.py!}
 ```
 
-### Importe o `APIRouter`
+### Importe o `APIRouter` { #import-the-apirouter }
 
 Agora importamos os outros submódulos que possuem `APIRouter`s:
 
@@ -357,7 +357,7 @@ Agora importamos os outros submódulos que possuem `APIRouter`s:
 
 Como os arquivos `app/routers/users.py` e `app/routers/items.py` são submódulos que fazem parte do mesmo pacote Python `app`, podemos usar um único ponto `.` para importá-los usando "importações relativas".
 
-### Como funciona a importação
+### Como funciona a importação { #how-the-importing-works }
 
 A seção:
 
@@ -399,7 +399,7 @@ Para saber mais sobre pacotes e módulos Python, leia <a href="https://docs.pyth
 
 ///
 
-### Evite colisões de nomes
+### Evite colisões de nomes { #avoid-name-collisions }
 
 Estamos importando o submódulo `items` diretamente, em vez de importar apenas sua variável `router`.
 
@@ -420,9 +420,9 @@ Então, para poder usar ambos no mesmo arquivo, importamos os submódulos direta
 {!../../docs_src/bigger_applications/app/main.py!}
 ```
 
-### Incluir o `APIRouter`s para `usuários` e `itens`
+### Inclua os `APIRouter`s para `usuários` e `itens` { #include-the-apirouters-for-users-and-items }
 
-Agora, vamos incluir os `roteadores` dos submódulos `usuários` e `itens`:
+Agora, vamos incluir os `router`s dos submódulos `users` e `items`:
 
 ```Python hl_lines="10-11" title="app/main.py"
 {!../../docs_src/bigger_applications/app/main.py!}
@@ -440,7 +440,7 @@ Com `app.include_router()` podemos adicionar cada `APIRouter` ao aplicativo prin
 
 Ele incluirá todas as rotas daquele roteador como parte dele.
 
-/// note | Detalhe Técnico
+/// note | Detalhes Técnicos
 
 Na verdade, ele criará internamente uma *operação de rota* para cada *operação de rota* que foi declarada no `APIRouter`.
 
@@ -448,7 +448,7 @@ Então, nos bastidores, ele realmente funcionará como se tudo fosse o mesmo apl
 
 ///
 
-/// check
+/// check | Verifique
 
 Você não precisa se preocupar com desempenho ao incluir roteadores.
 
@@ -458,7 +458,7 @@ Então não afetará o desempenho. ⚡
 
 ///
 
-### Incluir um `APIRouter` com um `prefix` personalizado, `tags`, `responses` e `dependencies`
+### Inclua um `APIRouter` com um `prefix`, `tags`, `responses` e `dependencies` personalizados { #include-an-apirouter-with-a-custom-prefix-tags-responses-and-dependencies }
 
 Agora, vamos imaginar que sua organização lhe deu o arquivo `app/internal/admin.py`.
 
@@ -470,7 +470,7 @@ Para este exemplo, será super simples. Mas digamos que, como ele é compartilha
 {!../../docs_src/bigger_applications/app/internal/admin.py!}
 ```
 
-Mas ainda queremos definir um `prefixo` personalizado ao incluir o `APIRouter` para que todas as suas *operações de rota* comecem com `/admin`, queremos protegê-lo com as `dependências` que já temos para este projeto e queremos incluir `tags` e `responses`.
+Mas ainda queremos definir um `prefix` personalizado ao incluir o `APIRouter` para que todas as suas *operações de rota* comecem com `/admin`, queremos protegê-lo com as `dependencies` que já temos para este projeto e queremos incluir `tags` e `responses`.
 
 Podemos declarar tudo isso sem precisar modificar o `APIRouter` original passando esses parâmetros para `app.include_router()`:
 
@@ -491,7 +491,7 @@ Mas isso afetará apenas o `APIRouter` em nosso aplicativo, e não em nenhum out
 
 Assim, por exemplo, outros projetos poderiam usar o mesmo `APIRouter` com um método de autenticação diferente.
 
-### Incluir uma *operação de rota*
+### Inclua uma *operação de rota* { #include-a-path-operation }
 
 Também podemos adicionar *operações de rota* diretamente ao aplicativo `FastAPI`.
 
@@ -503,7 +503,7 @@ Aqui fazemos isso... só para mostrar que podemos 🤷:
 
 e funcionará corretamente, junto com todas as outras *operações de rota* adicionadas com `app.include_router()`.
 
-/// info | Detalhes Técnicos
+/// note | Detalhes Técnicos Avançados
 
 **Observação**: este é um detalhe muito técnico que você provavelmente pode **simplesmente pular**.
 
@@ -517,14 +517,14 @@ Como não podemos simplesmente isolá-los e "montá-los" independentemente do re
 
 ///
 
-## Verifique a documentação automática da API
+## Verifique a documentação automática da API { #check-the-automatic-api-docs }
 
-Agora, execute `uvicorn`, usando o módulo `app.main` e a variável `app`:
+Agora, execute sua aplicação:
 
 <div class="termy">
 
 ```console
-$ uvicorn app.main:app --reload
+$ fastapi dev app/main.py
 
 <span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
 ```
@@ -537,7 +537,7 @@ Você verá a documentação automática da API, incluindo os caminhos de todos
 
 <img src="/img/tutorial/bigger-applications/image01.png">
 
-## Incluir o mesmo roteador várias vezes com `prefixos` diferentes
+## Inclua o mesmo roteador várias vezes com `prefix` diferentes { #include-the-same-router-multiple-times-with-different-prefix }
 
 Você também pode usar `.include_router()` várias vezes com o *mesmo* roteador usando prefixos diferentes.
 
@@ -545,7 +545,7 @@ Isso pode ser útil, por exemplo, para expor a mesma API sob prefixos diferentes
 
 Esse é um uso avançado que você pode não precisar, mas está lá caso precise.
 
-## Incluir um `APIRouter` em outro
+## Inclua um `APIRouter` em outro { #include-an-apirouter-in-another }
 
 Da mesma forma que você pode incluir um `APIRouter` em um aplicativo `FastAPI`, você pode incluir um `APIRouter` em outro `APIRouter` usando:
 

docs/pt/docs/tutorial/body-fields.md

@@ -1,28 +1,28 @@
-# Corpo - Campos
+# Corpo - Campos { #body-fields }
 
-Da mesma forma que você pode declarar validações adicionais e metadados nos parâmetros de *funções de operações de rota* com `Query`, `Path` e `Body`, você pode declarar validações e metadados dentro de modelos do Pydantic usando `Field` do Pydantic.
+Da mesma forma que você pode declarar validações adicionais e metadados nos parâmetros de uma *função de operação de rota* com `Query`, `Path` e `Body`, você pode declarar validações e metadados dentro de modelos do Pydantic usando `Field` do Pydantic.
 
-## Importe `Field`
+## Importe `Field` { #import-field }
 
 Primeiro, você tem que importá-lo:
 
-{* ../../docs_src/body_fields/tutorial001.py hl[4] *}
+{* ../../docs_src/body_fields/tutorial001_an_py310.py hl[4] *}
 
-/// warning | Aviso
+/// warning | Atenção
 
 Note que `Field` é importado diretamente do `pydantic`, não do `fastapi` como todo o resto (`Query`, `Path`, `Body`, etc).
 
 ///
 
-## Declare atributos do modelo
+## Declare atributos do modelo { #declare-model-attributes }
 
 Você pode então utilizar `Field` com atributos do modelo:
 
-{* ../../docs_src/body_fields/tutorial001.py hl[11:14] *}
+{* ../../docs_src/body_fields/tutorial001_an_py310.py hl[11:14] *}
 
 `Field` funciona da mesma forma que `Query`, `Path` e `Body`, ele possui todos os mesmos parâmetros, etc.
 
-/// note | Detalhes técnicos
+/// note | Detalhes Técnicos
 
 Na realidade, `Query`, `Path` e outros que você verá em seguida, criam objetos de subclasses de uma classe `Param` comum, que é ela mesma uma subclasse da classe `FieldInfo` do Pydantic.
 
@@ -40,13 +40,20 @@ Note como cada atributo do modelo com um tipo, valor padrão e `Field` possuem a
 
 ///
 
-## Adicione informações extras
+## Adicione informações extras { #add-extra-information }
 
 Você pode declarar informação extra em `Field`, `Query`, `Body`, etc. E isso será incluído no JSON Schema gerado.
 
 Você irá aprender mais sobre adicionar informações extras posteriormente nessa documentação, quando estiver aprendendo a declarar exemplos.
 
-## Recapitulando
+/// warning | Atenção
+
+Chaves extras passadas para `Field` também estarão presentes no schema OpenAPI resultante da sua aplicação.
+Como essas chaves podem não fazer necessariamente parte da especificação OpenAPI, algumas ferramentas de OpenAPI, por exemplo [o validador do OpenAPI](https://validator.swagger.io/), podem não funcionar com o schema gerado.
+
+///
+
+## Recapitulando { #recap }
 
 Você pode usar `Field` do Pydantic para declarar validações extras e metadados para atributos do modelo.
 

docs/pt/docs/tutorial/body-multiple-params.md

@@ -1,14 +1,14 @@
-# Corpo - Múltiplos parâmetros
+# Corpo - Múltiplos parâmetros { #body-multiple-parameters }
 
 Agora que nós vimos como usar `Path` e `Query`, veremos usos mais avançados de declarações no corpo da requisição.
 
-## Misture `Path`, `Query` e parâmetros de corpo
+## Misture `Path`, `Query` e parâmetros de corpo { #mix-path-query-and-body-parameters }
 
 Primeiro, é claro, você pode misturar `Path`, `Query` e declarações de parâmetro no corpo da requisição livremente e o **FastAPI** saberá o que fazer.
 
 E você também pode declarar parâmetros de corpo como opcionais, definindo o valor padrão com `None`:
 
-{* ../../docs_src/body_multiple_params/tutorial001_py310.py hl[17:19] *}
+{* ../../docs_src/body_multiple_params/tutorial001_an_py310.py hl[18:20] *}
 
 /// note | Nota
 
@@ -16,7 +16,7 @@ Repare que, neste caso, o `item` que seria capturado a partir do corpo é opcion
 
 ///
 
-## Múltiplos parâmetros de corpo
+## Múltiplos parâmetros de corpo { #multiple-body-parameters }
 
 No exemplo anterior, as *operações de rota* esperariam um JSON no corpo contendo os atributos de um `Item`, exemplo:
 
@@ -62,7 +62,7 @@ O **FastAPI** fará a conversão automática a partir da requisição, assim ess
 
 Ele executará a validação dos dados compostos e irá documentá-los de maneira compatível com o esquema OpenAPI e documentação automática.
 
-## Valores singulares no corpo
+## Valores singulares no corpo { #singular-values-in-body }
 
 Assim como existem uma `Query` e uma `Path` para definir dados adicionais para parâmetros de consulta e de rota, o **FastAPI** provê o equivalente para `Body`.
 
@@ -72,7 +72,7 @@ Se você declará-lo como é, porque é um valor singular, o **FastAPI** assumir
 
 Mas você pode instruir o **FastAPI** para tratá-lo como outra chave do corpo usando `Body`:
 
-{* ../../docs_src/body_multiple_params/tutorial003.py hl[22] *}
+{* ../../docs_src/body_multiple_params/tutorial003_an_py310.py hl[23] *}
 
 Neste caso, o **FastAPI** esperará um corpo como:
 
@@ -94,7 +94,7 @@ Neste caso, o **FastAPI** esperará um corpo como:
 
 Mais uma vez, ele converterá os tipos de dados, validar, documentar, etc.
 
-## Múltiplos parâmetros de corpo e consulta
+## Múltiplos parâmetros de corpo e consulta { #multiple-body-params-and-query }
 
 Obviamente, você também pode declarar parâmetros de consulta assim que você precisar, de modo adicional a quaisquer parâmetros de corpo.
 
@@ -112,7 +112,7 @@ q: str | None = None
 
 Por exemplo:
 
-{* ../../docs_src/body_multiple_params/tutorial004_py310.py hl[26] *}
+{* ../../docs_src/body_multiple_params/tutorial004_an_py310.py hl[28] *}
 
 /// info | Informação
 
@@ -120,7 +120,7 @@ Por exemplo:
 
 ///
 
-## Declare um único parâmetro de corpo indicando sua chave
+## Declare um único parâmetro de corpo indicando sua chave { #embed-a-single-body-parameter }
 
 Suponha que você tem um único parâmetro de corpo `item`, a partir de um modelo Pydantic `Item`.
 
@@ -134,7 +134,7 @@ item: Item = Body(embed=True)
 
 como em:
 
-{* ../../docs_src/body_multiple_params/tutorial005_py310.py hl[15] *}
+{* ../../docs_src/body_multiple_params/tutorial005_an_py310.py hl[17] *}
 
 Neste caso o **FastAPI** esperará um corpo como:
 
@@ -160,7 +160,7 @@ ao invés de:
 }
 ```
 
-## Recapitulando
+## Recapitulando { #recap }
 
 Você pode adicionar múltiplos parâmetros de corpo para sua *função de operação de rota*, mesmo que a requisição possa ter somente um único corpo.
 

docs/pt/docs/tutorial/body-nested-models.md

@@ -1,32 +1,42 @@
-# Corpo - Modelos aninhados
+# Corpo - Modelos aninhados { #body-nested-models }
 
-Com o **FastAPI**, você pode definir, validar, documentar e usar modelos profundamente aninhados de forma arbitrária (graças ao Pydantic).
+Com o **FastAPI**, você pode definir, validar, documentar e usar modelos arbitrariamente e profundamente aninhados (graças ao Pydantic).
 
-## Campos do tipo Lista
+## Campos do tipo Lista { #list-fields }
 
 Você pode definir um atributo como um subtipo. Por exemplo, uma `list` do Python:
 
-{* ../../docs_src/body_nested_models/tutorial001.py hl[14] *}
+{* ../../docs_src/body_nested_models/tutorial001_py310.py hl[12] *}
 
 Isso fará com que tags seja uma lista de itens mesmo sem declarar o tipo dos elementos desta lista.
 
-## Campos do tipo Lista com um parâmetro de tipo
+## Campos do tipo Lista com um parâmetro de tipo { #list-fields-with-type-parameter }
 
 Mas o Python tem uma maneira específica de declarar listas com tipos internos ou "parâmetros de tipo":
 
-### Importe `List` do typing
+### Importe `List` do typing { #import-typings-list }
 
-Primeiramente, importe `List` do módulo `typing` que já vem por padrão no Python:
+No Python 3.9 e superior você pode usar a `list` padrão para declarar essas anotações de tipo, como veremos abaixo. 💡
+
+Mas nas versões do Python anteriores à 3.9 (3.6 e superiores), primeiro é necessário importar `List` do módulo padrão `typing` do Python:
 
 {* ../../docs_src/body_nested_models/tutorial002.py hl[1] *}
 
-### Declare a `List` com um parâmetro de tipo
+### Declare uma `list` com um parâmetro de tipo { #declare-a-list-with-a-type-parameter }
 
-Para declarar tipos que têm parâmetros de tipo(tipos internos), como `list`, `dict`, `tuple`:
+Para declarar tipos que têm parâmetros de tipo (tipos internos), como `list`, `dict`, `tuple`:
 
-* Importe os do modulo `typing`
+* Se você estiver em uma versão do Python inferior a 3.9, importe a versão equivalente do módulo `typing`
 * Passe o(s) tipo(s) interno(s) como "parâmetros de tipo" usando colchetes: `[` e `]`
 
+No Python 3.9, seria:
+
+```Python
+my_list: list[str]
+```
+
+Em versões do Python anteriores à 3.9, seria:
+
 ```Python
 from typing import List
 
@@ -39,20 +49,17 @@ Use a mesma sintaxe padrão para atributos de modelo com tipos internos.
 
 Portanto, em nosso exemplo, podemos fazer com que `tags` sejam especificamente uma "lista de strings":
 
+{* ../../docs_src/body_nested_models/tutorial002_py310.py hl[12] *}
 
-{* ../../docs_src/body_nested_models/tutorial002.py hl[14] *}
-
-## Tipo "set"
-
+## Tipos "set" { #set-types }
 
 Mas então, quando nós pensamos mais, percebemos que as tags não devem se repetir, elas provavelmente devem ser strings únicas.
 
 E que o Python tem um tipo de dados especial para conjuntos de itens únicos, o `set`.
 
-Então podemos importar `Set` e declarar `tags` como um `set` de `str`s:
+Então podemos declarar `tags` como um conjunto de strings:
 
-
-{* ../../docs_src/body_nested_models/tutorial003.py hl[1,14] *}
+{* ../../docs_src/body_nested_models/tutorial003_py310.py hl[12] *}
 
 Com isso, mesmo que você receba uma requisição contendo dados duplicados, ela será convertida em um conjunto de itens exclusivos.
 
@@ -60,7 +67,7 @@ E sempre que você enviar esses dados como resposta, mesmo se a fonte tiver dupl
 
 E também teremos anotações/documentação em conformidade.
 
-## Modelos aninhados
+## Modelos aninhados { #nested-models }
 
 Cada atributo de um modelo Pydantic tem um tipo.
 
@@ -70,17 +77,17 @@ Portanto, você pode declarar "objects" JSON profundamente aninhados com nomes,
 
 Tudo isso, aninhado arbitrariamente.
 
-### Defina um sub-modelo
+### Defina um sub-modelo { #define-a-submodel }
 
 Por exemplo, nós podemos definir um modelo `Image`:
 
-{* ../../docs_src/body_nested_models/tutorial004.py hl[9:11] *}
+{* ../../docs_src/body_nested_models/tutorial004_py310.py hl[7:9] *}
 
-### Use o sub-modelo como um tipo
+### Use o sub-modelo como um tipo { #use-the-submodel-as-a-type }
 
 E então podemos usa-lo como o tipo de um atributo:
 
-{* ../../docs_src/body_nested_models/tutorial004.py hl[20] *}
+{* ../../docs_src/body_nested_models/tutorial004_py310.py hl[18] *}
 
 Isso significa que o **FastAPI** vai esperar um corpo similar à:
 
@@ -100,28 +107,28 @@ Isso significa que o **FastAPI** vai esperar um corpo similar à:
 
 Novamente, apenas fazendo essa declaração, com o **FastAPI**, você ganha:
 
-* Suporte do editor de texto (compleção, etc), inclusive para modelos aninhados
+* Suporte do editor (preenchimento automático, etc.), inclusive para modelos aninhados
 * Conversão de dados
 * Validação de dados
 * Documentação automatica
 
-## Tipos especiais e validação
+## Tipos especiais e validação { #special-types-and-validation }
 
 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, cheque a documentação para os<a href="https://docs.pydantic.dev/latest/concepts/types/" class="external-link" target="_blank">tipos exoticos do Pydantic</a>. Você verá alguns exemplos no próximo capitulo.
+Para ver todas as opções possíveis, consulte a <a href="https://docs.pydantic.dev/latest/concepts/types/" class="external-link" target="_blank">Visão geral dos tipos do Pydantic</a>. Você verá alguns exemplos no próximo capítulo.
 
 Por exemplo, no modelo `Image` nós temos um campo `url`, nós podemos declara-lo como um `HttpUrl` do Pydantic invés de como uma `str`:
 
-{* ../../docs_src/body_nested_models/tutorial005.py hl[4,10] *}
+{* ../../docs_src/body_nested_models/tutorial005_py310.py hl[2,8] *}
 
-A string será verificada para se tornar uma URL válida e documentada no esquema JSON/1OpenAPI como tal.
+A string será verificada para se tornar uma URL válida e documentada no JSON Schema / OpenAPI como tal.
 
-## Atributos como listas de submodelos
+## Atributos como listas de submodelos { #attributes-with-lists-of-submodels }
 
 Você também pode usar modelos Pydantic como subtipos de `list`, `set`, etc:
 
-{* ../../docs_src/body_nested_models/tutorial006.py hl[20] *}
+{* ../../docs_src/body_nested_models/tutorial006_py310.py hl[18] *}
 
 Isso vai esperar(converter, validar, documentar, etc) um corpo JSON tal qual:
 
@@ -149,38 +156,43 @@ Isso vai esperar(converter, validar, documentar, etc) um corpo JSON tal qual:
 }
 ```
 
-/// info | informação
+/// info | Informação
 
-Note como o campo `images` agora tem uma lista de objetos de image.
+Observe como a chave `images` agora tem uma lista de objetos de imagem.
 
 ///
 
-## Modelos profundamente aninhados
+## Modelos profundamente aninhados { #deeply-nested-models }
 
 Você pode definir modelos profundamente aninhados de forma arbitrária:
 
-{* ../../docs_src/body_nested_models/tutorial007.py hl[9,14,20,23,27] *}
+{* ../../docs_src/body_nested_models/tutorial007_py310.py hl[7,12,18,21,25] *}
 
-/// info | informação
+/// info | Informação
 
-Note como `Offer` tem uma lista de `Item`s, que por sua vez possui opcionalmente uma lista `Image`s
+Observe como `Offer` tem uma lista de `Item`s, que por sua vez têm uma lista opcional de `Image`s
 
 ///
 
-## Corpos de listas puras
+## Corpos de listas puras { #bodies-of-pure-lists }
 
 Se o valor de primeiro nível do corpo JSON que você espera for um `array` do JSON (uma` lista` do Python), você pode declarar o tipo no parâmetro da função, da mesma forma que nos modelos do Pydantic:
 
-
 ```Python
 images: List[Image]
 ```
 
+ou no Python 3.9 e superior:
+
+```Python
+images: list[Image]
+```
+
 como em:
 
-{* ../../docs_src/body_nested_models/tutorial008.py hl[15] *}
+{* ../../docs_src/body_nested_models/tutorial008_py39.py hl[13] *}
 
-## Suporte de editor em todo canto
+## Suporte de editor em todo canto { #editor-support-everywhere }
 
 E você obtém suporte do editor em todos os lugares.
 
@@ -192,7 +204,7 @@ Você não conseguiria este tipo de suporte de editor se estivesse trabalhando d
 
 Mas você também não precisa se preocupar com eles, os dicts de entrada são convertidos automaticamente e sua saída é convertida automaticamente para JSON também.
 
-## Corpos de `dict`s arbitrários
+## Corpos de `dict`s arbitrários { #bodies-of-arbitrary-dicts }
 
 Você também pode declarar um corpo como um `dict` com chaves de algum tipo e valores de outro tipo.
 
@@ -208,7 +220,7 @@ Outro caso útil é quando você deseja ter chaves de outro tipo, por exemplo, `
 
 Neste caso, você aceitaria qualquer `dict`, desde que tenha chaves` int` com valores `float`:
 
-{* ../../docs_src/body_nested_models/tutorial009.py hl[9] *}
+{* ../../docs_src/body_nested_models/tutorial009_py39.py hl[7] *}
 
 /// tip | Dica
 
@@ -222,14 +234,14 @@ E o `dict` que você recebe como `weights` terá, na verdade, chaves `int` e val
 
 ///
 
-## Recapitulação
+## Recapitulação { #recap }
 
 Com **FastAPI** você tem a flexibilidade máxima fornecida pelos modelos Pydantic, enquanto seu código é mantido simples, curto e elegante.
 
 Mas com todos os benefícios:
 
-* Suporte do editor (compleção em todo canto!)
-* Conversão de dados (leia-se parsing/serialização)
+* Suporte do editor (preenchimento automático em todo canto!)
+* Conversão de dados (parsing/serialização)
 * Validação de dados
 * Documentação dos esquemas
 * Documentação automática

docs/pt/docs/tutorial/body-updates.md

@@ -1,6 +1,6 @@
-# Corpo - Atualizações
+# Corpo - Atualizações { #body-updates }
 
-## Atualização de dados existentes com `PUT`
+## Atualização de dados existentes com `PUT` { #update-replacing-with-put }
 
 Para atualizar um item, você pode usar a operação <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PUT" class="external-link" target="_blank">HTTP `PUT`</a>.
 
@@ -10,7 +10,7 @@ Você pode usar `jsonable_encoder` para converter os dados de entrada em dados q
 
 `PUT` é usado para receber dados que devem substituir os dados existentes.
 
-### Aviso sobre a substituição
+### Aviso sobre a substituição { #warning-about-replacing }
 
 Isso significa que, se você quiser atualizar o item `bar` usando `PUT` com um corpo contendo:
 
@@ -26,9 +26,9 @@ Como ele não inclui o atributo já armazenado `"tax": 20.2`, o modelo de entrad
 
 E os dados seriam salvos com esse "novo" `tax` de `10.5`.
 
-## Atualizações parciais com `PATCH`
+## Atualizações parciais com `PATCH` { #partial-updates-with-patch }
 
-Você também pode usar a operação <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PATCH" class="external-link" target="_blank">HTTP `PATCH`</a> para *atualizar* parcialmente os dados.
+Você também pode usar a operação <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PATCH" class="external-link" target="_blank">HTTP `PATCH`</a> para atualizar parcialmente os dados.
 
 Isso significa que você pode enviar apenas os dados que deseja atualizar, deixando o restante intacto.
 
@@ -44,7 +44,7 @@ Mas este guia te dá uma ideia de como eles são destinados a serem usados.
 
 ///
 
-### Usando o parâmetro `exclude_unset` do Pydantic
+### Usando o parâmetro `exclude_unset` do Pydantic { #using-pydantics-exclude-unset-parameter }
 
 Se você quiser receber atualizações parciais, é muito útil usar o parâmetro `exclude_unset` no método `.model_dump()` do modelo do Pydantic.
 
@@ -52,7 +52,7 @@ Como `item.model_dump(exclude_unset=True)`.
 
 /// info | Informação
 
-No Pydantic v1, o método que era chamado `.dict()` e foi depreciado (mas ainda suportado) no Pydantic v2. Agora, deve-se usar o método `.model_dump()`.
+No Pydantic v1, o método que era chamado `.dict()` e foi descontinuado (mas ainda suportado) no Pydantic v2. Agora, deve-se usar o método `.model_dump()`.
 
 Os exemplos aqui usam `.dict()` para compatibilidade com o Pydantic v1, mas você deve usar `.model_dump()` a partir do Pydantic v2.
 
@@ -64,13 +64,13 @@ Então, você pode usar isso para gerar um `dict` com apenas os dados definidos
 
 {* ../../docs_src/body_updates/tutorial002_py310.py hl[32] *}
 
-### Usando o parâmetro `update` do Pydantic
+### Usando o parâmetro `update` do Pydantic { #using-pydantics-update-parameter }
 
 Agora, você pode criar uma cópia do modelo existente usando `.model_copy()`, e passar o parâmetro `update` com um `dict` contendo os dados para atualizar.
 
 /// info | Informação
 
-No Pydantic v1, o método era chamado `.copy()`, ele foi depreciado (mas ainda suportado) no Pydantic v2, e renomeado para `.model_copy()`.
+No Pydantic v1, o método era chamado `.copy()`, ele foi descontinuado (mas ainda suportado) no Pydantic v2, e renomeado para `.model_copy()`.
 
 Os exemplos aqui usam `.copy()` para compatibilidade com o Pydantic v1, mas você deve usar `.model_copy()` com o Pydantic v2.
 
@@ -80,7 +80,7 @@ Como `stored_item_model.model_copy(update=update_data)`:
 
 {* ../../docs_src/body_updates/tutorial002_py310.py hl[33] *}
 
-### Recapitulando as atualizações parciais
+### Recapitulando as atualizações parciais { #partial-updates-recap }
 
 Resumindo, para aplicar atualizações parciais você pode:
 

docs/pt/docs/tutorial/body.md

@@ -1,16 +1,16 @@
-# Corpo da Requisição
+# Corpo da requisição { #request-body }
 
-Quando você precisa enviar dados de um cliente (como de um navegador web) para sua API, você o envia como um **corpo da requisição**.
+Quando você precisa enviar dados de um cliente (como de um navegador) para sua API, você os envia como um **corpo da requisição**.
 
 O corpo da **requisição** é a informação enviada pelo cliente para sua API. O corpo da **resposta** é a informação que sua API envia para o cliente.
 
-Sua API quase sempre irá enviar um corpo na **resposta**. Mas os clientes não necessariamente precisam enviar um corpo em toda **requisição**.
+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 <a href="https://docs.pydantic.dev/" class="external-link" target="_blank">Pydantic</a> com todos os seus poderes e benefícios.
 
 /// info | Informação
 
-Para enviar dados, você deve usar utilizar um dos métodos: `POST` (Mais comum), `PUT`, `DELETE` ou `PATCH`.
+Para enviar dados, você deve usar um dos: `POST` (o mais comum), `PUT`, `DELETE` ou `PATCH`.
 
 Enviar um corpo em uma requisição `GET` não tem um comportamento definido nas especificações, porém é suportado pelo FastAPI, apenas para casos de uso bem complexos/extremos.
 
@@ -18,19 +18,19 @@ Como é desencorajado, a documentação interativa com Swagger UI não irá most
 
 ///
 
-## Importe o `BaseModel` do Pydantic
+## Importe o `BaseModel` do Pydantic { #import-pydantics-basemodel }
 
 Primeiro, você precisa importar `BaseModel` do `pydantic`:
 
-{* ../../docs_src/body/tutorial001.py hl[4] *}
+{* ../../docs_src/body/tutorial001_py310.py hl[2] *}
 
-## Crie seu modelo de dados
+## Crie seu modelo de dados { #create-your-data-model }
 
 Então você declara seu modelo de dados como uma classe que herda `BaseModel`.
 
 Utilize os tipos Python padrão para todos os atributos:
 
-{* ../../docs_src/body/tutorial001.py hl[7:11] *}
+{* ../../docs_src/body/tutorial001_py310.py hl[5:9] *}
 
 Assim como quando declaramos parâmetros de consulta, quando um atributo do modelo possui um valor padrão, ele se torna opcional. Caso contrário, se torna obrigatório. Use `None` para torná-lo opcional.
 
@@ -39,13 +39,13 @@ Por exemplo, o modelo acima declara um JSON "`object`" (ou `dict` no Python) com
 ```JSON
 {
     "name": "Foo",
-    "description": "Uma descrição opcional",
+    "description": "An optional description",
     "price": 45.2,
     "tax": 3.5
 }
 ```
 
-...como `description` e `tax` são opcionais (Com um valor padrão de `None`), esse JSON "`object`" também é válido:
+...como `description` e `tax` são opcionais (com um valor padrão de `None`), esse JSON "`object`" também é válido:
 
 ```JSON
 {
@@ -54,40 +54,40 @@ Por exemplo, o modelo acima declara um JSON "`object`" (ou `dict` no Python) com
 }
 ```
 
-## Declare como um parâmetro
+## Declare como um parâmetro { #declare-it-as-a-parameter }
 
-Para adicionar o corpo na *função de operação de rota*, declare-o da mesma maneira que você declarou parâmetros de rota e consulta:
+Para adicioná-lo à sua *operação de rota*, declare-o da mesma maneira que você declarou parâmetros de rota e de consulta:
 
-{* ../../docs_src/body/tutorial001.py hl[18] *}
+{* ../../docs_src/body/tutorial001_py310.py hl[16] *}
 
-...E declare o tipo como o modelo que você criou, `Item`.
+...e declare o seu tipo como o modelo que você criou, `Item`.
 
-## Resultados
+## Resultados { #results }
 
-Apenas com esse declaração de tipos do Python, o **FastAPI** irá:
+Apenas com essa declaração de tipos do Python, o **FastAPI** irá:
 
 * Ler o corpo da requisição como um JSON.
 * Converter os tipos correspondentes (se necessário).
 * Validar os dados.
-    * Se algum dados for inválido, irá retornar um erro bem claro, indicando exatamente onde e o que está incorreto.
+    * Se algum dado for inválido, irá retornar um erro bem claro, indicando exatamente onde e o que estava incorreto.
 * Entregar a você a informação recebida no parâmetro `item`.
     * Como você o declarou na função como do tipo `Item`, você também terá o suporte do editor (completação, etc) para todos os atributos e seus tipos.
-* Gerar um <a href="https://json-schema.org" class="external-link" target="_blank">Esquema JSON</a> com as definições do seu modelo, você também pode utilizá-lo em qualquer lugar que quiser, se fizer sentido para seu projeto.
-* Esses esquemas farão parte do esquema OpenAPI, e utilizados nas <abbr title="User Interfaces">UIs</abbr> de documentação automática.
+* Gerar definições de <a href="https://json-schema.org" class="external-link" target="_blank">JSON Schema</a> para o seu modelo; você também pode usá-las em qualquer outro lugar se fizer sentido para o seu projeto.
+* Esses schemas farão parte do esquema OpenAPI gerado, e serão usados pelas <abbr title="User Interfaces – Interfaces de usuário">UIs</abbr> de documentação automática.
 
-## Documentação automática
+## Documentação automática { #automatic-docs }
 
-Os esquemas JSON dos seus modelos farão parte do esquema OpenAPI gerado para sua aplicação, e aparecerão na documentação interativa da API:
+Os JSON Schemas dos seus modelos farão parte do esquema OpenAPI gerado para sua aplicação, e aparecerão na documentação interativa da API:
 
 <img src="/img/tutorial/body/image01.png">
 
-E também serão utilizados em cada *função de operação de rota* que utilizá-los:
+E também serão utilizados na documentação da API dentro de cada *operação de rota* que precisar deles:
 
 <img src="/img/tutorial/body/image02.png">
 
-## Suporte do editor de texto:
+## Suporte do editor { #editor-support }
 
-No seu editor de texto, dentro da função você receberá dicas de tipos e completação em todo lugar (isso não aconteceria se você recebesse um `dict` em vez de um modelo Pydantic):
+No seu editor, dentro da função você receberá dicas de tipos e completação em todo lugar (isso não aconteceria se você recebesse um `dict` em vez de um modelo Pydantic):
 
 <img src="/img/tutorial/body/image03.png">
 
@@ -111,9 +111,9 @@ Mas você terá o mesmo suporte do editor no <a href="https://www.jetbrains.com/
 
 Se você utiliza o <a href="https://www.jetbrains.com/pycharm/" class="external-link" target="_blank">PyCharm</a> como editor, você pode utilizar o <a href="https://github.com/koxudaxi/pydantic-pycharm-plugin/" class="external-link" target="_blank">Plugin do Pydantic para o PyCharm </a>.
 
-Melhora o suporte do editor para seus modelos Pydantic com::
+Melhora o suporte do editor para seus modelos Pydantic com:
 
-* completação automática
+* preenchimento automático
 * verificação de tipos
 * refatoração
 * buscas
@@ -121,42 +121,52 @@ Melhora o suporte do editor para seus modelos Pydantic com::
 
 ///
 
-## Use o modelo
+## Use o modelo { #use-the-model }
 
 Dentro da função, você pode acessar todos os atributos do objeto do modelo diretamente:
 
-{* ../../docs_src/body/tutorial002.py hl[21] *}
+{* ../../docs_src/body/tutorial002_py310.py *}
 
-## Corpo da requisição + parâmetros de rota
+/// info | Informação
+
+No Pydantic v1 o método se chamava `.dict()`, ele foi descontinuado (mas ainda é suportado) no Pydantic v2, e renomeado para `.model_dump()`.
+
+Os exemplos aqui usam `.dict()` para compatibilidade com o Pydantic v1, mas você deve usar `.model_dump()` se puder usar o Pydantic v2.
+
+///
+
+## Corpo da requisição + parâmetros de rota { #request-body-path-parameters }
 
 Você pode declarar parâmetros de rota e corpo da requisição ao mesmo tempo.
 
-O **FastAPI** irá reconhecer que os parâmetros da função que combinam com parâmetros de rota devem ser **retirados da rota**, e parâmetros da função que são declarados como modelos Pydantic sejam **retirados do corpo da requisição**.
+O **FastAPI** irá reconhecer que os parâmetros da função que combinam com parâmetros de rota devem ser **retirados da rota**, e que parâmetros da função que são declarados como modelos Pydantic sejam **retirados do corpo da requisição**.
 
-{* ../../docs_src/body/tutorial003.py hl[17:18] *}
+{* ../../docs_src/body/tutorial003_py310.py hl[15:16] *}
 
-## Corpo da requisição + parâmetros de rota + parâmetros de consulta
+## Corpo da requisição + parâmetros de rota + parâmetros de consulta { #request-body-path-query-parameters }
 
 Você também pode declarar parâmetros de **corpo**, **rota** e **consulta**, ao mesmo tempo.
 
 O **FastAPI** irá reconhecer cada um deles e retirar a informação do local correto.
 
-{* ../../docs_src/body/tutorial004.py hl[18] *}
+{* ../../docs_src/body/tutorial004_py310.py hl[16] *}
 
 Os parâmetros da função serão reconhecidos conforme abaixo:
 
-* Se o parâmetro também é declarado na **rota**, será utilizado como um parâmetro de rota.
+* Se o parâmetro também é declarado no **path**, será utilizado como um parâmetro de rota.
 * Se o parâmetro é de um **tipo único** (como `int`, `float`, `str`, `bool`, etc) será interpretado como um parâmetro de **consulta**.
 * Se o parâmetro é declarado como um **modelo Pydantic**, será interpretado como o **corpo** da requisição.
 
-/// note | Observação
+/// note | Nota
 
 O FastAPI saberá que o valor de `q` não é obrigatório por causa do valor padrão `= None`.
 
-O `Union` em `Union[str, None]` não é utilizado pelo FastAPI, mas permite ao seu editor de texto lhe dar um suporte melhor e detectar erros.
+O `str | None` (Python 3.10+) ou o `Union` em `Union[str, None]` (Python 3.8+) não é utilizado pelo FastAPI para determinar que o valor não é obrigatório, ele saberá que não é obrigatório porque tem um valor padrão `= None`.
+
+Mas adicionar as anotações de tipo permitirá ao seu editor oferecer um suporte melhor e detectar erros.
 
 ///
 
-## Sem o Pydantic
+## Sem o Pydantic { #without-pydantic }
 
-Se você não quer utilizar os modelos Pydantic, você também pode utilizar o parâmetro **Body**. Veja a documentação para [Body - Parâmetros múltiplos: Valores singulares no body](body-multiple-params.md#valores-singulares-no-corpo){.internal-link target=_blank}.
+Se você não quer utilizar os modelos Pydantic, você também pode utilizar o parâmetro **Body**. Veja a documentação para [Body - Parâmetros múltiplos: Valores singulares no body](body-multiple-params.md#singular-values-in-body){.internal-link target=_blank}.

docs/pt/docs/tutorial/cookie-param-models.md

@@ -1,4 +1,4 @@
-# Modelos de Parâmetros de Cookie
+# Modelos de Parâmetros de Cookie { #cookie-parameter-models }
 
 Se você possui um grupo de **cookies** que estão relacionados, você pode criar um **modelo Pydantic** para declará-los. 🍪
 
@@ -16,7 +16,7 @@ Essa mesma técnica se aplica para `Query`, `Cookie`, e `Header`. 😎
 
 ///
 
-## Cookies com Modelos Pydantic
+## Cookies com Modelos Pydantic { #cookies-with-a-pydantic-model }
 
 Declare o parâmetro de **cookie** que você precisa em um **modelo Pydantic**, e depois declare o parâmetro como um `Cookie`:
 
@@ -24,9 +24,9 @@ Declare o parâmetro de **cookie** que você precisa em um **modelo Pydantic**,
 
 O **FastAPI** irá **extrair** os dados para **cada campo** dos **cookies** recebidos na requisição e lhe fornecer o modelo Pydantic que você definiu.
 
-## Verifique os Documentos
+## Verifique a Documentação { #check-the-docs }
 
-Você pode ver os cookies definidos na IU dos documentos em `/docs`:
+Você pode ver os cookies definidos na IU da documentação em `/docs`:
 
 <div class="screenshot">
 <img src="/img/tutorial/cookie-param-models/image01.png">
@@ -36,17 +36,17 @@ Você pode ver os cookies definidos na IU dos documentos em `/docs`:
 
 Tenha em mente que, como os **navegadores lidam com cookies** de maneira especial e por baixo dos panos, eles **não** permitem facilmente que o **JavaScript** lidem com eles.
 
-Se você for na **IU de documentos da API** em `/docs` você poderá ver a **documentação** para cookies das suas *operações de rotas*.
+Se você for na **IU da documentação da API** em `/docs` você poderá ver a **documentação** para cookies das suas *operações de rotas*.
 
-Mas mesmo que você **adicionar os dados** e clicar em "Executar", pelo motivo da IU dos documentos trabalharem com **JavaScript**, os cookies não serão enviados, e você verá uma mensagem de **erro** como se você não tivesse escrito nenhum dado.
+Mas mesmo que você **adicionar os dados** e clicar em "Executar", pelo motivo da IU da documentação trabalhar com **JavaScript**, os cookies não serão enviados, e você verá uma mensagem de **erro** como se você não tivesse escrito nenhum dado.
 
 ///
 
-## Proibir Cookies Adicionais
+## Proibir Cookies Adicionais { #forbid-extra-cookies }
 
 Em alguns casos especiais (provavelmente não muito comuns), você pode querer **restringir** os cookies que você deseja receber.
 
-Agora a sua API possui o poder de contrar o seu próprio <abbr title="Isso é uma brincadeira, só por precaução. Isso não tem nada a ver com consentimentos de cookies, mas é engraçado que até a API consegue rejeitar os coitados dos cookies. Coma um biscoito. 🍪">consentimento de cookie</abbr>. 🤪🍪
+Agora a sua API possui o poder de controlar o seu próprio <abbr title="Isso é uma brincadeira, só por precaução. Isso não tem nada a ver com consentimentos de cookies, mas é engraçado que até a API consegue rejeitar os coitados dos cookies. Coma um biscoito. 🍪">consentimento de cookie</abbr>. 🤪🍪
 
 
  Você pode utilizar a configuração do modelo Pydantic para `proibir` qualquer campo `extra`.
@@ -58,7 +58,7 @@ Se o cliente tentar enviar alguns **cookies extras**, eles receberão um retorno
 
 Coitados dos banners de cookies com todo o seu esforço para obter o seu consentimento para a <abbr title="Isso é uma outra piada. Não preste atenção em mim. Beba um café com o seu cookie. ☕">API rejeitá-lo</abbr>. 🍪
 
-Por exemplo, se o cliente tentar enviar um cookie `santa_tracker` com o valor de `good-list-please`, o cliente receberá uma resposta de **erro** informando que o <abbr title="O papai noel desaprova a falta de biscoitos. 🎅 Ok, chega de piadas com os cookies.">cookie `santa_tracker` is not allowed</abbr>:
+Por exemplo, se o cliente tentar enviar um cookie `santa_tracker` com o valor de `good-list-please`, o cliente receberá uma resposta de **erro** informando que o `santa_tracker` <abbr title="O papai noel desaprova a falta de biscoitos. 🎅 Ok, chega de piadas com os cookies.">cookie não é permitido</abbr>:
 
 ```json
 {
@@ -73,6 +73,6 @@ Por exemplo, se o cliente tentar enviar um cookie `santa_tracker` com o valor de
 }
 ```
 
-## Resumo
+## Resumo { #summary }
 
 Você consegue utilizar **modelos Pydantic** para declarar <abbr title="Coma um último biscoito antes de você ir embora. 🍪">**cookies**</abbr> no **FastAPI**. 😎

docs/pt/docs/tutorial/cookie-params.md

@@ -1,20 +1,19 @@
-# Parâmetros de Cookie
+# Parâmetros de Cookie { #cookie-parameters }
 
-Você pode definir parâmetros de Cookie da mesma maneira que define paramêtros com `Query` e `Path`.
+Você pode definir parâmetros de Cookie da mesma maneira que define parâmetros com `Query` e `Path`.
 
-## Importe `Cookie`
+## Importe `Cookie` { #import-cookie }
 
 Primeiro importe `Cookie`:
 
 {* ../../docs_src/cookie_params/tutorial001_an_py310.py hl[3] *}
 
-## Declare parâmetros de `Cookie`
+## Declare parâmetros de `Cookie` { #declare-cookie-parameters }
 
-Então declare os paramêtros de cookie usando a mesma estrutura que em `Path` e `Query`.
+Então declare os parâmetros de cookie usando a mesma estrutura que em `Path` e `Query`.
 
 Você pode definir o valor padrão, assim como todas as validações extras ou parâmetros de anotação:
 
-
 {* ../../docs_src/cookie_params/tutorial001_an_py310.py hl[9] *}
 
 /// note | Detalhes Técnicos
@@ -31,6 +30,16 @@ Para declarar cookies, você precisa usar `Cookie`, pois caso contrário, os par
 
 ///
 
-## Recapitulando
+/// info | Informação
+
+Tenha em mente que, como os **navegadores lidam com cookies** de maneiras especiais e nos bastidores, eles **não** permitem facilmente que o **JavaScript** os acesse.
+
+Se você for à **interface de documentação da API** em `/docs`, poderá ver a **documentação** de cookies para suas *operações de rota*.
+
+Mas mesmo que você **preencha os dados** e clique em "Execute", como a interface de documentação funciona com **JavaScript**, os cookies não serão enviados e você verá uma mensagem de **erro** como se você não tivesse escrito nenhum valor.
+
+///
+
+## Recapitulando { #recap }
 
 Declare cookies com `Cookie`, usando o mesmo padrão comum que utiliza-se em `Query` e `Path`.

docs/pt/docs/tutorial/cors.md

@@ -1,8 +1,8 @@
-# CORS (Cross-Origin Resource Sharing)
+# CORS (Cross-Origin Resource Sharing) { #cors-cross-origin-resource-sharing }
 
 <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS" class="external-link" target="_blank">CORS ou "Cross-Origin Resource Sharing"</a> refere-se às situações em que um frontend rodando em um navegador possui um código JavaScript que se comunica com um backend, e o backend está em uma "origem" diferente do frontend.
 
-## Origem
+## Origem { #origin }
 
 Uma origem é a combinação de protocolo (`http`, `https`), domínio (`myapp.com`, `localhost`, `localhost.tiangolo.com`), e porta (`80`, `443`, `8080`).
 
@@ -12,27 +12,27 @@ Então, todos estes são origens diferentes:
 * `https://localhost`
 * `http://localhost:8080`
 
-Mesmo se todos estiverem em `localhost`, eles usam diferentes protocolos e portas, portanto, são "origens" diferentes.
+Mesmo se todos estiverem em `localhost`, eles usam diferentes protocolos ou portas, portanto, são "origens" diferentes.
 
-## Passos
+## Passos { #steps }
 
-Então, digamos que você tenha um frontend rodando no seu navegador em `http://localhost:8080`, e seu JavaScript esteja tentando se comunicar com um backend rodando em http://localhost (como não especificamos uma porta, o navegador assumirá a porta padrão `80`).
+Então, digamos que você tenha um frontend rodando no seu navegador em `http://localhost:8080`, e seu JavaScript esteja tentando se comunicar com um backend rodando em `http://localhost` (como não especificamos uma porta, o navegador assumirá a porta padrão `80`).
 
-Portanto, o navegador irá enviar uma requisição HTTP `OPTIONS` ao backend, e se o backend enviar os cabeçalhos apropriados autorizando a comunicação a partir de uma origem diferente (`http://localhost:8080`) então o navegador deixará o JavaScript no frontend enviar sua requisição para o backend.
+Portanto, o navegador enviará uma requisição HTTP `OPTIONS` ao backend `:80`, e se o backend enviar os cabeçalhos apropriados autorizando a comunicação a partir dessa origem diferente (`http://localhost:8080`), então o navegador `:8080` permitirá que o JavaScript no frontend envie sua requisição para o backend `:80`.
 
-Para conseguir isso, o backend deve ter uma lista de "origens permitidas".
+Para conseguir isso, o backend `:80` deve ter uma lista de "origens permitidas".
 
-Neste caso, ele terá que incluir `http://localhost:8080` para o frontend funcionar corretamente.
+Neste caso, a lista terá que incluir `http://localhost:8080` para o frontend `:8080` funcionar corretamente.
 
-## Curingas
+## Curingas { #wildcards }
 
-É possível declarar uma lista com `"*"` (um "curinga") para dizer que tudo está permitido.
+É possível declarar a lista como `"*"` (um "curinga") para dizer que tudo está permitido.
 
 Mas isso só permitirá certos tipos de comunicação, excluindo tudo que envolva credenciais: cookies, cabeçalhos de autorização como aqueles usados ​​com Bearer Tokens, etc.
 
 Então, para que tudo funcione corretamente, é melhor especificar explicitamente as origens permitidas.
 
-## Usar `CORSMiddleware`
+## Usar `CORSMiddleware` { #use-corsmiddleware }
 
 Você pode configurá-lo em sua aplicação **FastAPI** usando o `CORSMiddleware`.
 
@@ -48,7 +48,7 @@ Você também pode especificar se o seu backend permite:
 
 {* ../../docs_src/cors/tutorial001.py hl[2,6:11,13:19] *}
 
-Os parâmetros padrão usados ​​pela implementação `CORSMiddleware` são restritivos por padrão, então você precisará habilitar explicitamente as origens, métodos ou cabeçalhos específicos para que os navegadores tenham permissão para usá-los em um contexto de domínios diferentes.
+Os parâmetros padrão usados ​​pela implementação `CORSMiddleware` são restritivos por padrão, então você precisará habilitar explicitamente as origens, métodos ou cabeçalhos específicos para que os navegadores tenham permissão para usá-los em um contexto cross domain.
 
 Os seguintes argumentos são suportados:
 
@@ -56,27 +56,30 @@ Os seguintes argumentos são suportados:
 * `allow_origin_regex` - Uma string regex para corresponder às origens que devem ter permissão para fazer requisições de origem cruzada. Por exemplo, `'https://.*\.example\.org'`.
 * `allow_methods` - Uma lista de métodos HTTP que devem ser permitidos para requisições de origem cruzada. O padrão é `['GET']`. Você pode usar `['*']` para permitir todos os métodos padrão.
 * `allow_headers` - Uma lista de cabeçalhos de solicitação HTTP que devem ter suporte para requisições de origem cruzada. O padrão é `[]`. Você pode usar `['*']` para permitir todos os cabeçalhos. Os cabeçalhos `Accept`, `Accept-Language`, `Content-Language` e `Content-Type` são sempre permitidos para <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS#simple_requests" class="external-link" rel="noopener" target="_blank">requisições CORS simples</a>.
-* `allow_credentials` - Indica que os cookies devem ser suportados para requisições de origem cruzada. O padrão é `False`. Além disso, `allow_origins` não pode ser definido como `['*']` para que as credenciais sejam permitidas, as origens devem ser especificadas.
+* `allow_credentials` - Indica que os cookies devem ser suportados para requisições de origem cruzada. O padrão é `False`.
+
+    Nenhum de `allow_origins`, `allow_methods` e `allow_headers` pode ser definido como `['*']` se `allow_credentials` estiver definido como `True`. Todos eles devem ser <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS#credentialed_requests_and_wildcards" class="external-link" rel="noopener" target="_blank">especificados explicitamente</a>.
+
 * `expose_headers` - Indica quaisquer cabeçalhos de resposta que devem ser disponibilizados ao navegador. O padrão é `[]`.
 * `max_age` - Define um tempo máximo em segundos para os navegadores armazenarem em cache as respostas CORS. O padrão é `600`.
 
 O middleware responde a dois tipos específicos de solicitação HTTP...
 
-### Requisições CORS pré-voo (preflight)
+### Requisições CORS pré-voo (preflight) { #cors-preflight-requests }
 
 Estas são quaisquer solicitações `OPTIONS` com cabeçalhos `Origin` e `Access-Control-Request-Method`.
 
 Nesse caso, o middleware interceptará a solicitação recebida e responderá com cabeçalhos CORS apropriados e uma resposta `200` ou `400` para fins informativos.
 
-### Requisições Simples
+### Requisições Simples { #simple-requests }
 
 Qualquer solicitação com um cabeçalho `Origin`. Neste caso, o middleware passará a solicitação normalmente, mas incluirá cabeçalhos CORS apropriados na resposta.
 
-## Mais informações
+## Mais informações { #more-info }
 
-Para mais informações <abbr title="Cross-Origin Resource Sharing">CORS</abbr>, acesse <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS" class="external-link" target="_blank">Mozilla CORS documentation</a>.
+Para mais informações sobre <abbr title="Cross-Origin Resource Sharing">CORS</abbr>, consulte a <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS" class="external-link" target="_blank">documentação do CORS da Mozilla</a>.
 
-/// note | Detalhes técnicos
+/// note | Detalhes Técnicos
 
 Você também pode usar `from starlette.middleware.cors import CORSMiddleware`.
 

docs/pt/docs/tutorial/debugging.md

@@ -1,14 +1,14 @@
-# Depuração
+# Depuração { #debugging }
 
 Você pode conectar o depurador no seu editor, por exemplo, com o Visual Studio Code ou PyCharm.
 
-## Chamar `uvicorn`
+## Chamar `uvicorn` { #call-uvicorn }
 
-Em seu aplicativo FastAPI, importe e execute `uvicorn` diretamente:
+Em sua aplicação FastAPI, importe e execute `uvicorn` diretamente:
 
 {* ../../docs_src/debugging/tutorial001.py hl[1,15] *}
 
-### Sobre `__name__ == "__main__"`
+### Sobre `__name__ == "__main__"` { #about-name-main }
 
 O objetivo principal de `__name__ == "__main__"` é ter algum código que seja executado quando seu arquivo for chamado com:
 
@@ -26,7 +26,7 @@ mas não é chamado quando outro arquivo o importa, como em:
 from myapp import app
 ```
 
-#### Mais detalhes
+#### Mais detalhes { #more-details }
 
 Digamos que seu arquivo se chama `myapp.py`.
 
@@ -78,9 +78,9 @@ Para mais informações, consulte <a href="https://docs.python.org/3/library/__m
 
 ///
 
-## Execute seu código com seu depurador
+## Execute seu código com seu depurador { #run-your-code-with-your-debugger }
 
-Como você está executando o servidor Uvicorn diretamente do seu código, você pode chamar seu programa Python (seu aplicativo FastAPI) diretamente do depurador.
+Como você está executando o servidor Uvicorn diretamente do seu código, você pode chamar seu programa Python (sua aplicação FastAPI) diretamente do depurador.
 
 ---
 

docs/pt/docs/tutorial/dependencies/classes-as-dependencies.md

@@ -1,8 +1,8 @@
-# Classes como Dependências
+# Classes como Dependências { #classes-as-dependencies }
 
 Antes de nos aprofundarmos no sistema de **Injeção de Dependência**, vamos melhorar o exemplo anterior.
 
-## `dict` do exemplo anterior
+## `dict` do exemplo anterior { #a-dict-from-the-previous-example }
 
 No exemplo anterior, nós retornávamos um `dict` da nossa dependência ("injetável"):
 
@@ -14,7 +14,7 @@ E sabemos que editores de texto não têm como oferecer muitas funcionalidades (
 
 Podemos fazer melhor...
 
-## O que caracteriza uma dependência
+## O que caracteriza uma dependência { #what-makes-a-dependency }
 
 Até agora você apenas viu dependências declaradas como funções.
 
@@ -38,7 +38,7 @@ something(some_argument, some_keyword_argument="foo")
 
 Então esse objeto é um "chamável".
 
-## Classes como dependências
+## Classes como dependências { #classes-as-dependencies_1 }
 
 Você deve ter percebido que para criar um instância de uma classe em Python, a mesma sintaxe é utilizada.
 
@@ -89,7 +89,7 @@ Em ambos os casos teremos:
 
 Os dados serão convertidos, validados, documentados no esquema da OpenAPI e etc nos dois casos.
 
-## Utilizando
+## Utilizando { #use-it }
 
 Agora você pode declarar sua dependência utilizando essa classe.
 
@@ -97,7 +97,7 @@ Agora você pode declarar sua dependência utilizando essa classe.
 
 O **FastAPI** chama a classe `CommonQueryParams`. Isso cria uma "instância" dessa classe e é a instância que será passada para o parâmetro `commons` na sua função.
 
-## Anotações de Tipo vs `Depends`
+## Anotações de Tipo vs `Depends` { #type-annotation-vs-depends }
 
 Perceba como escrevemos `CommonQueryParams` duas vezes no código abaixo:
 
@@ -189,11 +189,11 @@ commons = Depends(CommonQueryParams)
 
 {* ../../docs_src/dependencies/tutorial003_an_py310.py hl[19] *}
 
-Mas declarar o tipo é encorajado por que é a forma que o seu editor de texto sabe o que será passado como valor do parâmetro `commons`.
+Mas declarar o tipo é encorajado por que é a forma que o seu editor de texto sabe o que será passado como valor do parâmetro `commons`, e assim ele pode ajudar com preenchimento automático, verificações de tipo, etc:
 
 <img src="/img/tutorial/dependencies/image02.png">
 
-## Pegando um Atalho
+## Pegando um Atalho { #shortcut }
 
 Mas você pode ver que temos uma repetição do código neste exemplo, escrevendo `CommonQueryParams` duas vezes:
 

docs/pt/docs/tutorial/dependencies/dependencies-in-path-operation-decorators.md

@@ -1,4 +1,4 @@
-# Dependências em decoradores de operações de rota
+# Dependências em decoradores de operações de rota { #dependencies-in-path-operation-decorators }
 
 Em alguns casos você não precisa necessariamente retornar o valor de uma dependência dentro de uma *função de operação de rota*.
 
@@ -8,7 +8,7 @@ Mas você ainda precisa que ela seja executada/resolvida.
 
 Para esses casos, em vez de declarar um parâmetro em uma *função de operação de rota* com `Depends`, você pode adicionar um argumento `dependencies` do tipo `list` ao decorador da operação de rota.
 
-## Adicionando `dependencies` ao decorador da operação de rota
+## Adicione `dependencies` ao decorador da operação de rota { #add-dependencies-to-the-path-operation-decorator }
 
 O *decorador da operação de rota* recebe um argumento opcional `dependencies`.
 
@@ -22,7 +22,7 @@ Essas dependências serão executadas/resolvidas da mesma forma que dependência
 
 Alguns editores de texto checam parâmetros de funções não utilizados, e os mostram como erros.
 
-Utilizando `dependencies` no *decorador da operação de rota* você pode garantir que elas serão executadas enquanto evita errors de editores/ferramentas.
+Utilizando `dependencies` no *decorador da operação de rota* você pode garantir que elas serão executadas enquanto evita erros de editores/ferramentas.
 
 Isso também pode ser útil para evitar confundir novos desenvolvedores que ao ver um parâmetro não usado no seu código podem pensar que ele é desnecessário.
 
@@ -30,29 +30,29 @@ Isso também pode ser útil para evitar confundir novos desenvolvedores que ao v
 
 /// info | Informação
 
-Neste exemplo utilizamos cabeçalhos personalizados inventados `X-Keys` e `X-Token`.
+Neste exemplo utilizamos cabeçalhos personalizados inventados `X-Key` e `X-Token`.
 
 Mas em situações reais, como implementações de segurança, você pode obter mais vantagens em usar as [Ferramentas de segurança integradas (o próximo capítulo)](../security/index.md){.internal-link target=_blank}.
 
 ///
 
-## Erros das dependências e valores de retorno
+## Erros das dependências e valores de retorno { #dependencies-errors-and-return-values }
 
 Você pode utilizar as mesmas *funções* de dependências que você usaria normalmente.
 
-### Requisitos de Dependências
+### Requisitos de Dependências { #dependency-requirements }
 
 Dependências podem declarar requisitos de requisições (como cabeçalhos) ou outras subdependências:
 
 {* ../../docs_src/dependencies/tutorial006_an_py39.py hl[8,13] *}
 
-### Levantando exceções
+### Levantar exceções { #raise-exceptions }
 
-Essas dependências podem levantar exceções, da mesma forma que dependências comuns:
+Essas dependências podem `raise` exceções, da mesma forma que dependências comuns:
 
 {* ../../docs_src/dependencies/tutorial006_an_py39.py hl[10,15] *}
 
-### Valores de retorno
+### Valores de retorno { #return-values }
 
 E elas também podem ou não retornar valores, eles não serão utilizados.
 
@@ -60,10 +60,10 @@ Então, você pode reutilizar uma dependência comum (que retorna um valor) que
 
 {* ../../docs_src/dependencies/tutorial006_an_py39.py hl[11,16] *}
 
-## Dependências para um grupo de *operações de rota*
+## Dependências para um grupo de *operações de rota* { #dependencies-for-a-group-of-path-operations }
 
-Mais a frente, quando você ler sobre como estruturar aplicações maiores ([Bigger Applications - Multiple Files](../../tutorial/bigger-applications.md){.internal-link target=_blank}), possivelmente com múltiplos arquivos, você aprenderá a declarar um único parâmetro `dependencies` para um grupo de *operações de rota*.
+Mais a frente, quando você ler sobre como estruturar aplicações maiores ([Aplicações maiores - Múltiplos arquivos](../../tutorial/bigger-applications.md){.internal-link target=_blank}), possivelmente com múltiplos arquivos, você aprenderá a declarar um único parâmetro `dependencies` para um grupo de *operações de rota*.
 
-## Dependências globais
+## Dependências globais { #global-dependencies }
 
-No próximo passo veremos como adicionar dependências para uma aplicação `FastAPI` inteira, para que ela seja aplicada em toda *operação de rota*.
+No próximo passo veremos como adicionar dependências para uma aplicação `FastAPI` inteira, para que elas sejam aplicadas em toda *operação de rota*.

docs/pt/docs/tutorial/dependencies/dependencies-with-yield.md

@@ -1,12 +1,12 @@
-# Dependências com yield
+# Dependências com yield { #dependencies-with-yield }
 
-O FastAPI possui suporte para dependências que realizam <abbr title='também chamados de "código de saída", "código de cleanup", "código de teardown", "código de finalização", "código de saída para gerenciador de contextos", etc.'>alguns passos extras ao finalizar</abbr>.
+O **FastAPI** possui suporte para dependências que realizam <abbr title='às vezes também chamado de "código de saída", "código de limpeza", "código de teardown", "código de fechamento", "código de saída do gerenciador de contexto", etc.'>alguns passos extras ao finalizar</abbr>.
 
 Para fazer isso, utilize `yield` em vez de `return`, e escreva os passos extras (código) depois.
 
 /// tip | Dica
 
-Garanta que `yield` é utilizado apenas uma vez.
+Garanta utilizar `yield` apenas uma vez por dependência.
 
 ///
 
@@ -23,19 +23,19 @@ Na realidade, o FastAPI utiliza esses dois decoradores internamente.
 
 ///
 
-## Uma dependência de banco de dados com `yield`
+## Uma dependência de banco de dados com `yield` { #a-database-dependency-with-yield }
 
-Por exemplo, você poderia utilizar isso para criar uma sessão do banco de dados, e fechá-la após terminar sua operação.
+Por exemplo, você poderia utilizar isso para criar uma sessão do banco de dados, e fechá-la após terminar.
 
-Apenas o código anterior a declaração com `yield` e o código contendo essa declaração são executados antes de criar uma resposta.
+Apenas o código anterior à declaração com `yield` e o código contendo essa declaração são executados antes de criar uma resposta:
 
 {* ../../docs_src/dependencies/tutorial007.py hl[2:4] *}
 
-O valor gerado (yielded) é o que é injetado nas *operações de rota* e outras dependências.
+O valor gerado (yielded) é o que é injetado nas *operações de rota* e outras dependências:
 
 {* ../../docs_src/dependencies/tutorial007.py hl[4] *}
 
-O código após o `yield` é executado após a resposta ser entregue:
+O código após o `yield` é executado após a resposta:
 
 {* ../../docs_src/dependencies/tutorial007.py hl[5:6] *}
 
@@ -47,21 +47,19 @@ O **FastAPI** saberá o que fazer com cada uma, da mesma forma que as dependênc
 
 ///
 
-## Uma dependência com `yield` e `try`
+## Uma dependência com `yield` e `try` { #a-dependency-with-yield-and-try }
 
 Se você utilizar um bloco `try` em uma dependência com `yield`, você irá capturar qualquer exceção que for lançada enquanto a dependência é utilizada.
 
-Por exemplo, se algum código em um certo momento no meio da operação, em outra dependência ou em uma *operação de rota*, fizer um "rollback" de uma transação de banco de dados ou causar qualquer outro erro, você irá capturar a exceção em sua dependência.
+Por exemplo, se algum código em um certo momento no meio, em outra dependência ou em uma *operação de rota*, fizer um "rollback" de uma transação de banco de dados ou causar qualquer outra exceção, você irá capturar a exceção em sua dependência.
 
 Então, você pode procurar por essa exceção específica dentro da dependência com `except AlgumaExcecao`.
 
 Da mesma forma, você pode utilizar `finally` para garantir que os passos de saída são executados, com ou sem exceções.
 
-```python hl_lines="3  5"
-{!../../docs_src/dependencies/tutorial007.py!}
-```
+{* ../../docs_src/dependencies/tutorial007.py hl[3,5] *}
 
-## Subdependências com `yield`
+## Subdependências com `yield` { #sub-dependencies-with-yield }
 
 Você pode ter subdependências e "árvores" de subdependências de qualquer tamanho e forma, e qualquer uma ou todas elas podem utilizar `yield`.
 
@@ -69,73 +67,17 @@ O **FastAPI** garantirá que o "código de saída" em cada dependência com `yie
 
 Por exemplo, `dependency_c` pode depender de `dependency_b`, e `dependency_b` depender de `dependency_a`:
 
-//// tab | python 3.9+
-
-```python hl_lines="6  14  22"
-{!> ../../docs_src/dependencies/tutorial008_an_py39.py!}
-```
-
-////
-
-//// tab | python 3.8+
-
-```python hl_lines="5  13  21"
-{!> ../../docs_src/dependencies/tutorial008_an.py!}
-```
-
-////
-
-//// tab | python 3.8+ non-annotated
-
-/// tip | Dica
-
-Utilize a versão com `Annotated` se possível.
-
-///
-
-```python hl_lines="4  12  20"
-{!> ../../docs_src/dependencies/tutorial008.py!}
-```
-
-////
+{* ../../docs_src/dependencies/tutorial008_an_py39.py hl[6,14,22] *}
 
 E todas elas podem utilizar `yield`.
 
-Neste caso, `dependency_c` precisa que o valor de `dependency_b` (nomeada de `dep_b` aqui) continue disponível para executar seu código de saída.
+Neste caso, `dependency_c`, para executar seu código de saída, precisa que o valor de `dependency_b` (nomeado de `dep_b` aqui) continue disponível.
 
-E, por outro lado, `dependency_b` precisa que o valor de `dependency_a` (nomeada de `dep_a`) continue disponível para executar seu código de saída.
+E, por outro lado, `dependency_b` precisa que o valor de `dependency_a` (nomeado de `dep_a`) esteja disponível para executar seu código de saída.
 
-//// tab | python 3.9+
+{* ../../docs_src/dependencies/tutorial008_an_py39.py hl[18:19,26:27] *}
 
-```python hl_lines="18-19  26-27"
-{!> ../../docs_src/dependencies/tutorial008_an_py39.py!}
-```
-
-////
-
-//// tab | python 3.8+
-
-```python hl_lines="17-18  25-26"
-{!> ../../docs_src/dependencies/tutorial008_an.py!}
-```
-
-////
-
-//// tab | python 3.8+ non-annotated
-
-/// tip | Dica
-
-Utilize a versão com `Annotated` se possível.
-
-///
-
-```python hl_lines="16-17  24-25"
-{!> ../../docs_src/dependencies/tutorial008.py!}
-```
-
-////
-
-Da mesma forma, você pode ter algumas dependências com `yield` e outras com `return` e ter uma relação de dependência entre algumas dos dois tipos.
+Da mesma forma, você pode ter algumas dependências com `yield` e outras com `return` e ter uma relação de dependência entre algumas das duas.
 
 E você poderia ter uma única dependência que precisa de diversas outras dependências com `yield`, etc.
 
@@ -151,83 +93,45 @@ O **FastAPI** utiliza eles internamente para alcançar isso.
 
 ///
 
-## Dependências com `yield` e `httpexception`
+## Dependências com `yield` e `HTTPException` { #dependencies-with-yield-and-httpexception }
 
-Você viu que dependências podem ser utilizadas com `yield` e podem incluir blocos `try` para capturar exceções.
+Você viu que pode usar dependências com `yield` e ter blocos `try` que tentam executar algum código e depois executar algum código de saída com `finally`.
 
-Da mesma forma, você pode lançar uma `httpexception` ou algo parecido no código de saída, após o `yield`
+Você também pode usar `except` para capturar a exceção que foi levantada e fazer algo com ela.
+
+Por exemplo, você pode levantar uma exceção diferente, como `HTTPException`.
 
 /// tip | Dica
 
-Essa é uma técnica relativamente avançada, e na maioria dos casos você não precisa dela totalmente, já que você pode lançar exceções (incluindo `httpexception`) dentro do resto do código da sua aplicação, por exemplo, em uma *função de operação de rota*.
+Essa é uma técnica relativamente avançada, e na maioria dos casos você não vai precisar dela, já que você pode levantar exceções (incluindo `HTTPException`) dentro do resto do código da sua aplicação, por exemplo, na *função de operação de rota*.
 
 Mas ela existe para ser utilizada caso você precise. 🤓
 
 ///
 
-//// tab | python 3.9+
+{* ../../docs_src/dependencies/tutorial008b_an_py39.py hl[18:22,31] *}
 
-```python hl_lines="18-22  31"
-{!> ../../docs_src/dependencies/tutorial008b_an_py39.py!}
-```
+Se você quiser capturar exceções e criar uma resposta personalizada com base nisso, crie um [Manipulador de Exceções Customizado](../handling-errors.md#install-custom-exception-handlers){.internal-link target=_blank}.
 
-////
+## Dependências com `yield` e `except` { #dependencies-with-yield-and-except }
 
-//// tab | python 3.8+
-
-```python hl_lines="17-21  30"
-{!> ../../docs_src/dependencies/tutorial008b_an.py!}
-```
-
-////
-
-//// tab | python 3.8+ non-annotated
-
-/// tip | Dica
-
-Utilize a versão com `Annotated` se possível.
-
-///
-
-```python hl_lines="16-20  29"
-{!> ../../docs_src/dependencies/tutorial008b.py!}
-```
-
-////
-
-Uma alternativa que você pode utilizar para capturar exceções (e possivelmente lançar outra HTTPException) é criar um [Manipulador de Exceções Customizado](../handling-errors.md#instalando-manipuladores-de-excecoes-customizados){.internal-link target=_blank}.
-
-## Dependências com `yield` e `except`
-
-Se você capturar uma exceção com `except` em uma dependência que utilize `yield` e ela não for levantada novamente (ou uma nova exceção for levantada), o FastAPI não será capaz de identifcar que houve uma exceção, da mesma forma que aconteceria com Python puro:
+Se você capturar uma exceção com `except` em uma dependência que utilize `yield` e ela não for levantada novamente (ou uma nova exceção for levantada), o FastAPI não será capaz de identificar que houve uma exceção, da mesma forma que aconteceria com Python puro:
 
 {* ../../docs_src/dependencies/tutorial008c_an_py39.py hl[15:16] *}
 
 Neste caso, o cliente irá ver uma resposta *HTTP 500 Internal Server Error* como deveria acontecer, já que não estamos levantando nenhuma `HTTPException` ou coisa parecida, mas o servidor **não terá nenhum log** ou qualquer outra indicação de qual foi o erro. 😱
 
-### Sempre levante (`raise`) exceções em Dependências com `yield` e `except`
+### Sempre levante (`raise`) em Dependências com `yield` e `except` { #always-raise-in-dependencies-with-yield-and-except }
 
-Se você capturar uma exceção em uma dependência com `yield`, a menos que você esteja levantando outra `HTTPException` ou coisa parecida, você deveria relançar a exceção original.
+Se você capturar uma exceção em uma dependência com `yield`, a menos que você esteja levantando outra `HTTPException` ou coisa parecida, **você deve relançar a exceção original**.
 
 Você pode relançar a mesma exceção utilizando `raise`:
 
 {* ../../docs_src/dependencies/tutorial008d_an_py39.py hl[17] *}
 
-//// tab | python 3.8+ non-annotated
-
-/// tip | Dica
-
-Utilize a versão com `Annotated` se possível.
-
-///
-
-{* ../../docs_src/dependencies/tutorial008d.py hl[15] *}
-
-////
-
 Agora o cliente irá receber a mesma resposta *HTTP 500 Internal Server Error*, mas o servidor terá nosso `InternalError` personalizado nos logs. 😎
 
-## Execução de dependências com `yield`
+## Execução de dependências com `yield` { #execution-of-dependencies-with-yield }
 
 A sequência de execução é mais ou menos como esse diagrama. O tempo passa do topo para baixo. E cada coluna é uma das partes interagindo ou executando código.
 
@@ -270,57 +174,69 @@ participant tasks as Tarefas de Background
 
 Apenas **uma resposta** será enviada para o cliente. Ela pode ser uma das respostas de erro, ou então a resposta da *operação de rota*.
 
-Após uma dessas respostas ser enviada, nenhuma outra resposta pode ser enviada
+Após uma dessas respostas ser enviada, nenhuma outra resposta pode ser enviada.
 
 ///
 
 /// tip | Dica
 
-Esse diagrama mostra `HttpException`, mas você pode levantar qualquer outra exceção que você capture em uma dependência com `yield` ou um [Manipulador de exceções personalizado](../handling-errors.md#instalando-manipuladores-de-excecoes-customizados){.internal-link target=_blank}.
-
-Se você lançar qualquer exceção, ela será passada para as dependências com yield, inlcuindo a `HTTPException`. Na maioria dos casos você vai querer relançar essa mesma exceção ou uma nova a partir da dependência com `yield` para garantir que ela seja tratada adequadamente.
+Se você levantar qualquer exceção no código da *função de operação de rota*, ela será passada para as dependências com `yield`, incluindo `HTTPException`. Na maioria dos casos, você vai querer relançar essa mesma exceção ou uma nova a partir da dependência com `yield` para garantir que ela seja tratada adequadamente.
 
 ///
 
-## Dependências com `yield`, `HTTPException`, `except` e Tarefas de Background
+## Saída antecipada e `scope` { #early-exit-and-scope }
 
-/// warning | Aviso
+Normalmente, o código de saída das dependências com `yield` é executado **após a resposta** ser enviada ao cliente.
 
-Você provavelmente não precisa desses detalhes técnicos, você pode pular essa seção e continuar na próxima seção abaixo.
+Mas se você sabe que não precisará usar a dependência depois de retornar da *função de operação de rota*, você pode usar `Depends(scope="function")` para dizer ao FastAPI que deve fechar a dependência depois que a *função de operação de rota* retornar, mas **antes** de a **resposta ser enviada**.
 
-Esses detalhes são úteis principalmente se você estiver usando uma versão do FastAPI anterior à 0.106.0 e utilizando recursos de dependências com `yield` em tarefas de background.
+{* ../../docs_src/dependencies/tutorial008e_an_py39.py hl[12,16] *}
 
-///
+`Depends()` recebe um parâmetro `scope` que pode ser:
 
-### Dependências com `yield` e `except`, Detalhes Técnicos
+* `"function"`: iniciar a dependência antes da *função de operação de rota* que trata a requisição, encerrar a dependência depois que a *função de operação de rota* termina, mas **antes** de a resposta ser enviada de volta ao cliente. Assim, a função da dependência será executada **em torno** da *função de operação de rota*.
+* `"request"`: iniciar a dependência antes da *função de operação de rota* que trata a requisição (semelhante a quando se usa `"function"`), mas encerrar **depois** que a resposta é enviada de volta ao cliente. Assim, a função da dependência será executada **em torno** do ciclo de **requisição** e resposta.
 
-Antes do FastAPI 0.110.0, se você utilizasse uma dependência com `yield`, e então capturasse uma dependência com `except` nessa dependência, caso a exceção não fosse relançada, ela era automaticamente lançada para qualquer manipulador de exceções ou o manipulador de erros interno do servidor.
+Se não for especificado e a dependência tiver `yield`, ela terá `scope` igual a `"request"` por padrão.
 
-Isso foi modificado na versão 0.110.0 para consertar o consumo de memória não controlado das exceções relançadas automaticamente sem um manipulador (erros internos do servidor), e para manter o comportamento consistente com o código Python tradicional.
+### `scope` para subdependências { #scope-for-sub-dependencies }
 
-### Tarefas de Background e Dependências com `yield`, Detalhes Técnicos
+Quando você declara uma dependência com `scope="request"` (o padrão), qualquer subdependência também precisa ter `scope` igual a `"request"`.
 
-Antes do FastAPI 0.106.0, levantar exceções após um `yield` não era possível, o código de saída nas dependências com `yield` era executado *após* a resposta ser enviada, então os [Manipuladores de Exceções](../handling-errors.md#instalando-manipuladores-de-excecoes-customizados){.internal-link target=_blank} já teriam executado.
+Mas uma dependência com `scope` igual a `"function"` pode ter dependências com `scope` igual a `"function"` e com `scope` igual a `"request"`.
 
-Isso foi implementado dessa forma principalmente para permitir que os mesmos objetos fornecidos ("yielded") pelas dependências dentro de tarefas de background fossem reutilizados, por que o código de saída era executado antes das tarefas de background serem finalizadas.
+Isso porque qualquer dependência precisa conseguir executar seu código de saída antes das subdependências, pois pode ainda precisar usá-las durante seu código de saída.
 
-Ainda assim, como isso exigiria esperar que a resposta navegasse pela rede enquanto mantia ativo um recurso desnecessário na dependência com yield (por exemplo, uma conexão com banco de dados), isso mudou na versão 0.106.0 do FastAPI.
+```mermaid
+sequenceDiagram
 
-/// tip | Dica
+participant client as Cliente
+participant dep_req as Dep scope="request"
+participant dep_func as Dep scope="function"
+participant operation as Operação de Rota
 
-Adicionalmente, uma tarefa de background é, normalmente, um conjunto de lógicas independentes que devem ser manipuladas separadamente, com seus próprios recursos (e.g. sua própria conexão com banco de dados).
+    client ->> dep_req: Iniciar requisição
+    Note over dep_req: Executar código até o yield
+    dep_req ->> dep_func: Passar dependência
+    Note over dep_func: Executar código até o yield
+    dep_func ->> operation: Executar operação de rota com dependência
+    operation ->> dep_func: Retornar da operação de rota
+    Note over dep_func: Executar código após o yield
+    Note over dep_func: ✅ Dependência fechada
+    dep_func ->> client: Enviar resposta ao cliente
+    Note over client: Resposta enviada
+    Note over dep_req: Executar código após o yield
+    Note over dep_req: ✅ Dependência fechada
+```
 
-Então, dessa forma você provavelmente terá um código mais limpo.
+## Dependências com `yield`, `HTTPException`, `except` e Tarefas de Background { #dependencies-with-yield-httpexception-except-and-background-tasks }
 
-///
+Dependências com `yield` evoluíram ao longo do tempo para cobrir diferentes casos de uso e corrigir alguns problemas.
 
-Se você costumava depender desse comportamento, agora você precisa criar os recursos para uma tarefa de background dentro dela mesma, e usar internamente apenas dados que não dependam de recursos de dependências com `yield`.
+Se você quiser ver o que mudou em diferentes versões do FastAPI, você pode ler mais sobre isso no guia avançado, em [Dependências Avançadas - Dependências com `yield`, `HTTPException`, `except` e Tarefas de Background](../../advanced/advanced-dependencies.md#dependencies-with-yield-httpexception-except-and-background-tasks){.internal-link target=_blank}.
+## Gerenciadores de contexto { #context-managers }
 
-Por exemplo, em vez de utilizar a mesma sessão do banco de dados, você criaria uma nova sessão dentro da tarefa de background, e você obteria os objetos do banco de dados utilizando essa nova sessão. E então, em vez de passar o objeto obtido do banco de dados como um parâmetro para a função da tarefa de background, você passaria o ID desse objeto e buscaria ele novamente dentro da função da tarefa de background.
-
-## Gerenciadores de contexto
-
-### O que são gerenciadores de contexto
+### O que são "Gerenciadores de Contexto" { #what-are-context-managers }
 
 "Gerenciadores de Contexto" são qualquer um dos objetos Python que podem ser utilizados com a declaração `with`.
 
@@ -338,9 +254,9 @@ Quando o bloco `with` finaliza, ele se certifica de fechar o arquivo, mesmo que
 
 Quando você cria uma dependência com `yield`, o **FastAPI** irá criar um gerenciador de contexto internamente para ela, e combiná-lo com algumas outras ferramentas relacionadas.
 
-### Utilizando gerenciadores de contexto em dependências com `yield`
+### Utilizando gerenciadores de contexto em dependências com `yield` { #using-context-managers-in-dependencies-with-yield }
 
-/// warning | Aviso
+/// warning | Atenção
 
 Isso é uma ideia mais ou menos "avançada".
 
@@ -348,9 +264,10 @@ Se você está apenas iniciando com o **FastAPI** você pode querer pular isso p
 
 ///
 
-Em python, você pode criar Gerenciadores de Contexto ao <a href="https://docs.python.org/3/reference/datamodel.html#context-managers" class="external-link" target="_blank"> criar uma classe com dois métodos: `__enter__()` e `__exit__()`</a>.
+Em Python, você pode criar Gerenciadores de Contexto ao <a href="https://docs.python.org/3/reference/datamodel.html#context-managers" class="external-link" target="_blank">criar uma classe com dois métodos: `__enter__()` e `__exit__()`</a>.
 
-Você também pode usá-los dentro de dependências com `yield` do **FastAPI** ao utilizar `with` ou `async with` dentro da função da dependência:
+Você também pode usá-los dentro de dependências com `yield` do **FastAPI** ao utilizar
+`with` ou `async with` dentro da função da dependência:
 
 {* ../../docs_src/dependencies/tutorial010.py hl[1:9,13] *}
 
@@ -359,7 +276,6 @@ Você também pode usá-los dentro de dependências com `yield` do **FastAPI** a
 Outra forma de criar um gerenciador de contexto é utilizando:
 
 * <a href="https://docs.python.org/3/library/contextlib.html#contextlib.contextmanager" class="external-link" target="_blank">`@contextlib.contextmanager`</a> ou
-
 * <a href="https://docs.python.org/3/library/contextlib.html#contextlib.asynccontextmanager" class="external-link" target="_blank">`@contextlib.asynccontextmanager`</a>
 
 Para decorar uma função com um único `yield`.

docs/pt/docs/tutorial/dependencies/global-dependencies.md

@@ -1,15 +1,16 @@
-# Dependências Globais
+# Dependências Globais { #global-dependencies }
 
-Para alguns tipos de aplicação específicos você pode querer adicionar dependências para toda a aplicação.
+Para alguns tipos de aplicação você pode querer adicionar dependências para toda a aplicação.
 
-De forma semelhante a [adicionar dependências (`dependencies`) em *decoradores de operação de rota*](dependencies-in-path-operation-decorators.md){.internal-link target=_blank}, você pode adicioná-las à aplicação `FastAPI`.
+De forma semelhante a [adicionar `dependencies` aos *decoradores de operação de rota*](dependencies-in-path-operation-decorators.md){.internal-link target=_blank}, você pode adicioná-las à aplicação `FastAPI`.
 
 Nesse caso, elas serão aplicadas a todas as *operações de rota* da aplicação:
 
 {* ../../docs_src/dependencies/tutorial012_an_py39.py hl[16] *}
 
-E todos os conceitos apresentados na sessão sobre [adicionar dependências em *decoradores de operação de rota*](dependencies-in-path-operation-decorators.md){.internal-link target=_blank} ainda se aplicam, mas nesse caso, para todas as *operações de rota* da aplicação.
 
-## Dependências para conjuntos de *operações de rota*
+E todos os conceitos apresentados na seção sobre [adicionar `dependencies` aos *decoradores de operação de rota*](dependencies-in-path-operation-decorators.md){.internal-link target=_blank} ainda se aplicam, mas nesse caso, para todas as *operações de rota* da aplicação.
 
-Mais para a frente, quando você ler sobre como estruturar aplicações maiores ([Bigger Applications - Multiple Files](../../tutorial/bigger-applications.md){.internal-link target=_blank}), possivelmente com múltiplos arquivos, você irá aprender a declarar um único parâmetro `dependencies` para um conjunto de *operações de rota*.
+## Dependências para conjuntos de *operações de rota* { #dependencies-for-groups-of-path-operations }
+
+Mais para a frente, quando você ler sobre como estruturar aplicações maiores ([Aplicações Maiores - Múltiplos Arquivos](../../tutorial/bigger-applications.md){.internal-link target=_blank}), possivelmente com múltiplos arquivos, você irá aprender a declarar um único parâmetro `dependencies` para um conjunto de *operações de rota*.

docs/pt/docs/tutorial/dependencies/index.md

@@ -1,10 +1,10 @@
-# Dependências
+# Dependências { #dependencies }
 
-O **FastAPI** possui um poderoso, mas intuitivo sistema de **<abbr title="também conhecidos como, recursos, provedores, serviços, injetáveis">Injeção de Dependência</abbr>**.
+O **FastAPI** possui um poderoso, mas intuitivo sistema de **<abbr title="também conhecidos como: componentes, recursos, provedores, serviços, injetáveis">Injeção de Dependência</abbr>**.
 
 Esse sistema foi pensado para ser fácil de usar, e permitir que qualquer desenvolvedor possa integrar facilmente outros componentes ao **FastAPI**.
 
-## O que é "Injeção de Dependência"
+## O que é "Injeção de Dependência" { #what-is-dependency-injection }
 
 **"Injeção de Dependência"** no mundo da programação significa, que existe uma maneira de declarar no seu código (nesse caso, suas *funções de operação de rota*) para declarar as coisas que ele precisa para funcionar e que serão utilizadas: "dependências".
 
@@ -19,13 +19,13 @@ Isso é bastante útil quando você precisa:
 
 Tudo isso, enquanto minimizamos a repetição de código.
 
-## Primeiros passos
+## Primeiros passos { #first-steps }
 
 Vamos ver um exemplo simples. Tão simples que não será muito útil, por enquanto.
 
 Mas dessa forma podemos focar em como o sistema de **Injeção de Dependência** funciona.
 
-### Criando uma dependência, ou "injetável"
+### Criando uma dependência, ou "injetável" { #create-a-dependency-or-dependable }
 
 Primeiro vamos focar na dependência.
 
@@ -57,15 +57,15 @@ FastAPI passou a suportar a notação `Annotated` (e começou a recomendá-la) n
 
 Se você utiliza uma versão anterior, ocorrerão erros ao tentar utilizar `Annotated`.
 
-Certifique-se de [Atualizar a versão do FastAPI](../../deployment/versions.md#atualizando-as-versoes-do-fastapi){.internal-link target=_blank} para pelo menos 0.95.1 antes de usar `Annotated`.
+Certifique-se de [Atualizar a versão do FastAPI](../../deployment/versions.md#upgrading-the-fastapi-versions){.internal-link target=_blank} para pelo menos 0.95.1 antes de usar `Annotated`.
 
 ///
 
-### Importando `Depends`
+### Importando `Depends` { #import-depends }
 
 {* ../../docs_src/dependencies/tutorial001_an_py310.py hl[3] *}
 
-### Declarando a dependência, no "dependente"
+### Declarando a dependência, no "dependente" { #declare-the-dependency-in-the-dependant }
 
 Da mesma forma que você utiliza `Body`, `Query`, etc. Como parâmetros de sua *função de operação de rota*, utilize `Depends` com um novo parâmetro:
 
@@ -106,7 +106,7 @@ common_parameters --> read_users
 
 Assim, você escreve um código compartilhado apenas uma vez e o **FastAPI** se encarrega de chamá-lo em suas *operações de rota*.
 
-/// check | Checando
+/// check | Verifique
 
 Perceba que você não precisa criar uma classe especial e enviar a dependência para algum outro lugar em que o **FastAPI** a "registre" ou realize qualquer operação similar.
 
@@ -114,7 +114,7 @@ Você apenas envia para `Depends` e o **FastAPI** sabe como fazer o resto.
 
 ///
 
-## Compartilhando dependências `Annotated`
+## Compartilhando dependências `Annotated` { #share-annotated-dependencies }
 
 Nos exemplos acima, você pode ver que existe uma pequena **duplicação de código**.
 
@@ -140,7 +140,7 @@ As dependências continuarão funcionando como esperado, e a **melhor parte** é
 
 Isso é especialmente útil para uma **base de código grande** onde **as mesmas dependências** são utilizadas repetidamente em **muitas *operações de rota***.
 
-## `Async` ou não, eis a questão
+## `Async` ou não, eis a questão { #to-async-or-not-to-async }
 
 Como as dependências também serão chamadas pelo **FastAPI** (da mesma forma que *funções de operação de rota*), as mesmas regras se aplicam ao definir suas funções.
 
@@ -152,11 +152,11 @@ Não faz diferença. O **FastAPI** sabe o que fazer.
 
 /// note | Nota
 
-Caso você não conheça, veja em [Async: *"Com Pressa?"*](../../async.md#com-pressa){.internal-link target=_blank} a sessão acerca de `async` e `await` na documentação.
+Caso você não conheça, veja em [Async: *"Com Pressa?"*](../../async.md#in-a-hurry){.internal-link target=_blank} a sessão acerca de `async` e `await` na documentação.
 
 ///
 
-## Integrando com OpenAPI
+## Integrando com OpenAPI { #integrated-with-openapi }
 
 Todas as declarações de requisições, validações e requisitos para suas dependências (e sub-dependências) serão integradas em um mesmo esquema OpenAPI.
 
@@ -164,7 +164,7 @@ Então, a documentação interativa também terá toda a informação sobre essa
 
 <img src="/img/tutorial/dependencies/image01.png">
 
-## Caso de Uso Simples
+## Caso de Uso Simples { #simple-usage }
 
 Se você parar para ver, *funções de operação de rota* são declaradas para serem usadas sempre que uma *rota* e uma *operação* se encaixam, e então o **FastAPI** se encarrega de chamar a função correspondente com os argumentos corretos, extraindo os dados da requisição.
 
@@ -182,7 +182,7 @@ Outros termos comuns para essa mesma ideia de "injeção de dependência" são:
 * injetáveis
 * componentes
 
-## Plug-ins em **FastAPI**
+## Plug-ins em **FastAPI** { #fastapi-plug-ins }
 
 Integrações e "plug-ins" podem ser construídos com o sistema de **Injeção de Dependência**. Mas na verdade, **não há necessidade de criar "plug-ins"**, já que utilizando dependências é possível declarar um número infinito de integrações e interações que se tornam disponíveis para as suas *funções de operação de rota*.
 
@@ -190,7 +190,7 @@ E as dependências pode ser criadas de uma forma bastante simples e intuitiva qu
 
 Você verá exemplos disso nos próximos capítulos, acerca de bancos de dados relacionais e NoSQL, segurança, etc.
 
-## Compatibilidade do **FastAPI**
+## Compatibilidade do **FastAPI** { #fastapi-compatibility }
 
 A simplicidade do sistema de injeção de dependência do **FastAPI** faz ele compatível com:
 
@@ -203,7 +203,7 @@ A simplicidade do sistema de injeção de dependência do **FastAPI** faz ele co
 * sistemas de injeção de dados de resposta
 * etc.
 
-## Simples e Poderoso
+## Simples e Poderoso { #simple-and-powerful }
 
 Mesmo que o sistema hierárquico de injeção de dependência seja simples de definir e utilizar, ele ainda é bastante poderoso.
 
@@ -243,7 +243,7 @@ admin_user --> activate_user
 paying_user --> pro_items
 ```
 
-## Integração com **OpenAPI**
+## Integração com **OpenAPI** { #integrated-with-openapi_1 }
 
 Todas essas dependências, ao declarar os requisitos para suas *operações de rota*, também adicionam parâmetros, validações, etc.
 

docs/pt/docs/tutorial/dependencies/sub-dependencies.md

@@ -1,4 +1,4 @@
-# Subdependências
+# Subdependências { #sub-dependencies }
 
 Você pode criar dependências que possuem **subdependências**.
 
@@ -6,9 +6,9 @@ Elas podem ter o nível de **profundidade** que você achar necessário.
 
 O **FastAPI** se encarrega de resolver essas dependências.
 
-## Primeira dependência "injetável"
+## Primeira dependência "dependable" { #first-dependency-dependable }
 
-Você pode criar uma primeira dependência (injetável) dessa forma:
+Você pode criar uma primeira dependência ("dependable") dessa forma:
 
 {* ../../docs_src/dependencies/tutorial005_an_py310.py hl[8:9] *}
 
@@ -16,20 +16,20 @@ Esse código declara um parâmetro de consulta opcional, `q`, com o tipo `str`,
 
 Isso é bastante simples (e não muito útil), mas irá nos ajudar a focar em como as subdependências funcionam.
 
-## Segunda dependência, "injetável" e "dependente"
+## Segunda dependência, "dependable" e "dependente" { #second-dependency-dependable-and-dependant }
 
-Então, você pode criar uma outra função para uma dependência (um "injetável") que ao mesmo tempo declara sua própria dependência (o que faz dela um "dependente" também):
+Então, você pode criar uma outra função para uma dependência (um "dependable") que ao mesmo tempo declara sua própria dependência (o que faz dela um "dependente" também):
 
 {* ../../docs_src/dependencies/tutorial005_an_py310.py hl[13] *}
 
 Vamos focar nos parâmetros declarados:
 
-* Mesmo que essa função seja uma dependência ("injetável") por si mesma, ela também declara uma outra dependência (ela "depende" de outra coisa).
+* Mesmo que essa função seja uma dependência ("dependable") por si mesma, ela também declara uma outra dependência (ela "depende" de outra coisa).
     * Ela depende do `query_extractor`, e atribui o valor retornado pela função ao parâmetro `q`.
 * Ela também declara um cookie opcional `last_query`, do tipo `str`.
     * Se o usuário não passou nenhuma consulta `q`, a última consulta é utilizada, que foi salva em um cookie anteriormente.
 
-## Utilizando a dependência
+## Utilizando a dependência { #use-the-dependency }
 
 Então podemos utilizar a dependência com:
 
@@ -54,7 +54,7 @@ read_query["/items/"]
 query_extractor --> query_or_cookie_extractor --> read_query
 ```
 
-## Utilizando a mesma dependência múltiplas vezes
+## Utilizando a mesma dependência múltiplas vezes { #using-the-same-dependency-multiple-times }
 
 Se uma de suas dependências é declarada várias vezes para a mesma *operação de rota*, por exemplo, múltiplas dependências com uma mesma subdependência, o **FastAPI** irá chamar essa subdependência uma única vez para cada requisição.
 
@@ -86,7 +86,7 @@ async def needy_dependency(fresh_value: str = Depends(get_value, use_cache=False
 
 ////
 
-## Recapitulando
+## Recapitulando { #recap }
 
 Com exceção de todas as palavras complicadas usadas aqui, o sistema de **Injeção de Dependência** é bastante simples.
 

docs/pt/docs/tutorial/encoder.md

@@ -1,4 +1,4 @@
-# Codificador Compatível com JSON
+# Codificador Compatível com JSON { #json-compatible-encoder }
 
 Existem alguns casos em que você pode precisar converter um tipo de dados (como um modelo Pydantic) para algo compatível com JSON (como um `dict`, `list`, etc).
 
@@ -6,13 +6,13 @@ Por exemplo, se você precisar armazená-lo em um banco de dados.
 
 Para isso, **FastAPI** fornece uma função `jsonable_encoder()`.
 
-## Usando a função `jsonable_encoder`
+## Usando a função `jsonable_encoder` { #using-the-jsonable-encoder }
 
 Vamos imaginar que você tenha um banco de dados `fake_db` que recebe apenas dados compatíveis com JSON.
 
 Por exemplo, ele não recebe objetos `datetime`, pois estes objetos não são compatíveis com JSON.
 
-Então, um objeto `datetime` teria que ser convertido em um `str` contendo os dados no formato  <a href="https://en.wikipedia.org/wiki/ISO_8601" class="external-link" target="_blank">ISO</a>.
+Então, um objeto `datetime` teria que ser convertido em um `str` contendo os dados no <a href="https://en.wikipedia.org/wiki/ISO_8601" class="external-link" target="_blank">formato ISO</a>.
 
 Da mesma forma, este banco de dados não receberia um modelo Pydantic (um objeto com atributos), apenas um `dict`.
 

docs/pt/docs/tutorial/extra-data-types.md

@@ -1,4 +1,4 @@
-# Tipos de dados extras
+# Tipos de dados extras { #extra-data-types }
 
 Até agora, você tem usado tipos de dados comuns, tais como:
 
@@ -17,7 +17,7 @@ E você ainda terá os mesmos recursos que viu até agora:
 * Validação de dados.
 * Anotação e documentação automáticas.
 
-## Outros tipos de dados
+## Outros tipos de dados { #other-data-types }
 
 Aqui estão alguns dos tipos de dados adicionais que você pode usar:
 
@@ -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 ISO 8601 diferença de tempo", <a href="https://docs.pydantic.dev/latest/concepts/serialization/" class="external-link" target="_blank">cheque a documentação para mais informações</a>.
+    * O Pydantic também permite representá-lo como uma "codificação ISO 8601 diferença de tempo", <a href="https://docs.pydantic.dev/latest/concepts/serialization/#custom-serializers" class="external-link" target="_blank">cheque a documentação para mais informações</a>.
 * `frozenset`:
     * Em requisições e respostas, será tratado da mesma forma que um `set`:
         * Nas requisições, uma lista será lida, eliminando duplicadas e convertendo-a em um `set`.
@@ -49,14 +49,14 @@ 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 será representado como um `float`.
-* Você pode checar todos os tipos de dados válidos do Pydantic aqui: <a href="https://docs.pydantic.dev/latest/concepts/types/" class="external-link" target="_blank">Tipos de dados do Pydantic</a>.
+* Você pode checar todos os tipos de dados válidos do Pydantic aqui: <a href="https://docs.pydantic.dev/latest/usage/types/types/" class="external-link" target="_blank">Tipos de dados do Pydantic</a>.
 
-## Exemplo
+## Exemplo { #example }
 
 Aqui está um exemplo de *operação de rota* com parâmetros utilizando-se de alguns dos tipos acima.
 
-{* ../../docs_src/extra_data_types/tutorial001.py hl[1,3,12:16] *}
+{* ../../docs_src/extra_data_types/tutorial001_an_py310.py hl[1,3,12:16] *}
 
 Note que os parâmetros dentro da função tem seu tipo de dados natural, e você pode, por exemplo, realizar manipulações normais de data, como:
 
-{* ../../docs_src/extra_data_types/tutorial001.py hl[18:19] *}
+{* ../../docs_src/extra_data_types/tutorial001_an_py310.py hl[18:19] *}

docs/pt/docs/tutorial/extra-models.md

@@ -1,4 +1,4 @@
-# Modelos Adicionais
+# Modelos Adicionais { #extra-models }
 
 Continuando com o exemplo anterior, será comum ter mais de um modelo relacionado.
 
@@ -6,9 +6,9 @@ Isso é especialmente o caso para modelos de usuários, porque:
 
 * O **modelo de entrada** precisa ser capaz de ter uma senha.
 * O **modelo de saída** não deve ter uma senha.
-* O **modelo de banco de dados** provavelmente precisaria ter uma senha criptografada.
+* O **modelo de banco de dados** provavelmente precisaria ter uma senha com hash.
 
-/// danger
+/// danger | Cuidado
 
 Nunca armazene senhas em texto simples dos usuários. Sempre armazene uma "hash segura" que você pode verificar depois.
 
@@ -16,15 +16,23 @@ Se não souber, você aprenderá o que é uma "senha hash" nos [capítulos de se
 
 ///
 
-## Múltiplos modelos
+## Múltiplos modelos { #multiple-models }
 
 Aqui está uma ideia geral de como os modelos poderiam parecer com seus campos de senha e os lugares onde são usados:
 
-{* ../../docs_src/extra_models/tutorial001.py hl[9,11,16,22,24,29:30,33:35,40:41] *}
+{* ../../docs_src/extra_models/tutorial001_py310.py hl[7,9,14,20,22,27:28,31:33,38:39] *}
 
-### Sobre `**user_in.dict()`
+/// info | Informação
 
-#### O `.dict()` do Pydantic
+No Pydantic v1 o método se chamava `.dict()`, ele foi descontinuado (mas ainda é suportado) no Pydantic v2 e renomeado para `.model_dump()`.
+
+Os exemplos aqui usam `.dict()` por compatibilidade com o Pydantic v1, mas você deve usar `.model_dump()` se puder usar o Pydantic v2.
+
+///
+
+### Sobre `**user_in.dict()` { #about-user-in-dict }
+
+#### O `.dict()` do Pydantic { #pydantics-dict }
 
 `user_in` é um modelo Pydantic da classe `UserIn`.
 
@@ -61,7 +69,7 @@ teríamos um `dict` Python com:
 }
 ```
 
-#### Desembrulhando um `dict`
+#### Desembrulhando um `dict` { #unpacking-a-dict }
 
 Se tomarmos um `dict` como `user_dict` e passarmos para uma função (ou classe) com `**user_dict`, o Python irá "desembrulhá-lo". Ele passará as chaves e valores do `user_dict` diretamente como argumentos chave-valor.
 
@@ -93,7 +101,7 @@ UserInDB(
 )
 ```
 
-#### Um modelo Pydantic a partir do conteúdo de outro
+#### Um modelo Pydantic a partir do conteúdo de outro { #a-pydantic-model-from-the-contents-of-another }
 
 Como no exemplo acima, obtivemos o `user_dict` a partir do `user_in.dict()`, este código:
 
@@ -108,11 +116,11 @@ seria equivalente a:
 UserInDB(**user_in.dict())
 ```
 
-...porque `user_in.dict()` é um `dict`, e depois fazemos o Python "desembrulhá-lo" passando-o para UserInDB precedido por `**`.
+...porque `user_in.dict()` é um `dict`, e depois fazemos o Python "desembrulhá-lo" passando-o para `UserInDB` precedido por `**`.
 
 Então, obtemos um modelo Pydantic a partir dos dados em outro modelo Pydantic.
 
-#### Desembrulhando um `dict` e palavras-chave extras
+#### Desembrulhando um `dict` e palavras-chave extras { #unpacking-a-dict-and-extra-keywords }
 
 E, então, adicionando o argumento de palavra-chave extra `hashed_password=hashed_password`, como em:
 
@@ -132,13 +140,13 @@ UserInDB(
 )
 ```
 
-/// warning
+/// warning | Atenção
 
-As funções adicionais de suporte são apenas para demonstração de um fluxo possível dos dados, mas é claro que elas não fornecem segurança real.
+As funções adicionais de suporte `fake_password_hasher` e `fake_save_user` servem apenas para demonstrar um fluxo possível dos dados, mas é claro que elas não fornecem segurança real.
 
 ///
 
-## Reduzir duplicação
+## Reduzir duplicação { #reduce-duplication }
 
 Reduzir a duplicação de código é uma das ideias principais no **FastAPI**.
 
@@ -154,25 +162,25 @@ Toda conversão de dados, validação, documentação, etc. ainda funcionará no
 
 Dessa forma, podemos declarar apenas as diferenças entre os modelos (com `password` em texto claro, com `hashed_password` e sem senha):
 
-{* ../../docs_src/extra_models/tutorial002.py hl[9,15:16,19:20,23:24] *}
+{* ../../docs_src/extra_models/tutorial002_py310.py hl[7,13:14,17:18,21:22] *}
 
-## `Union` ou `anyOf`
+## `Union` ou `anyOf` { #union-or-anyof }
 
-Você pode declarar uma resposta como o `Union` de dois tipos, o que significa que a resposta seria qualquer um dos dois.
+Você pode declarar uma resposta como o `Union` de dois ou mais tipos, o que significa que a resposta seria qualquer um deles.
 
 Isso será definido no OpenAPI com `anyOf`.
 
-Para fazer isso, use a dica de tipo padrão do Python <a href="https://docs.python.org/3/library/typing.html#typing.Union" class="external-link" target="_blank">`typing.Union`</a>:
+Para fazer isso, use a anotação de tipo padrão do Python <a href="https://docs.python.org/3/library/typing.html#typing.Union" class="external-link" target="_blank">`typing.Union`</a>:
 
-/// note
+/// note | Nota
 
 Ao definir um <a href="https://docs.pydantic.dev/latest/concepts/types/#unions" class="external-link" target="_blank">`Union`</a>, 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]`.
 
 ///
 
-{* ../../docs_src/extra_models/tutorial003.py hl[1,14:15,18:20,33] *}
+{* ../../docs_src/extra_models/tutorial003_py310.py hl[1,14:15,18:20,33] *}
 
-### `Union` no Python 3.10
+### `Union` no Python 3.10 { #union-in-python-3-10 }
 
 Neste exemplo, passamos `Union[PlaneItem, CarItem]` como o valor do argumento `response_model`.
 
@@ -184,27 +192,27 @@ Se estivesse em uma anotação de tipo, poderíamos ter usado a barra vertical,
 some_variable: PlaneItem | CarItem
 ```
 
-Mas se colocarmos isso em `response_model=PlaneItem | CarItem` teríamos um erro, pois o Python tentaria executar uma **operação inválida** entre `PlaneItem` e `CarItem` em vez de interpretar isso como uma anotação de tipo.
+Mas se colocarmos isso na atribuição `response_model=PlaneItem | CarItem`, teríamos um erro, pois o Python tentaria executar uma **operação inválida** entre `PlaneItem` e `CarItem` em vez de interpretar isso como uma anotação de tipo.
 
-## Lista de modelos
+## Lista de modelos { #list-of-models }
 
 Da mesma forma, você pode declarar respostas de listas de objetos.
 
 Para isso, use o padrão Python `typing.List` (ou simplesmente `list` no Python 3.9 e superior):
 
-{* ../../docs_src/extra_models/tutorial004.py hl[1,20] *}
+{* ../../docs_src/extra_models/tutorial004_py39.py hl[18] *}
 
-## Resposta com `dict` arbitrário
+## Resposta com `dict` arbitrário { #response-with-arbitrary-dict }
 
 Você também pode declarar uma resposta usando um simples `dict` arbitrário, declarando apenas o tipo das chaves e valores, sem usar um modelo Pydantic.
 
 Isso é útil se você não souber os nomes de campo / atributo válidos (que seriam necessários para um modelo Pydantic) antecipadamente.
 
-Neste caso, você pode usar `typing.Dict` (ou simplesmente dict no Python 3.9 e superior):
+Neste caso, você pode usar `typing.Dict` (ou simplesmente `dict` no Python 3.9 e superior):
 
-{* ../../docs_src/extra_models/tutorial005.py hl[1,8] *}
+{* ../../docs_src/extra_models/tutorial005_py39.py hl[6] *}
 
-## Em resumo
+## Recapitulação { #recap }
 
 Use vários modelos Pydantic e herde livremente para cada caso.
 

docs/pt/docs/tutorial/first-steps.md

@@ -1,4 +1,4 @@
-# Primeiros Passos
+# Primeiros Passos { #first-steps }
 
 O arquivo FastAPI mais simples pode se parecer com:
 
@@ -48,15 +48,15 @@ $ <font color="#4E9A06">fastapi</font> dev <u style="text-decoration-style:solid
 
 </div>
 
-Na saída, temos:
+Na saída, há uma linha com algo como:
 
 ```hl_lines="4"
 INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
 ```
 
-Essa linha mostra a URL onde a sua aplicação está sendo servida, que nesse caso é a sua máquina local.
+Essa linha mostra a URL onde a sua aplicação está sendo servida, na sua máquina local.
 
-### Confira
+### Confira { #check-it }
 
 Abra o seu navegador em <a href="http://127.0.0.1:8000" class="external-link" target="_blank">http://127.0.0.1:8000</a>.
 
@@ -66,7 +66,7 @@ Você verá essa resposta em JSON:
 {"message": "Hello World"}
 ```
 
-### Documentação Interativa de APIs
+### Documentação Interativa de APIs { #interactive-api-docs }
 
 Agora vá para <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>.
 
@@ -74,7 +74,7 @@ Você verá a documentação interativa automática da API (fornecida por <a hre
 
 ![Swagger UI](https://fastapi.tiangolo.com/img/index/index-01-swagger-ui-simple.png)
 
-### Documentação Alternativa de APIs
+### Documentação Alternativa de APIs { #alternative-api-docs }
 
 E agora, vá para <a href="http://127.0.0.1:8000/redoc" class="external-link" target="_blank">http://127.0.0.1:8000/redoc</a>.
 
@@ -82,31 +82,31 @@ Você verá a documentação alternativa automática (fornecida por <a href="htt
 
 ![ReDoc](https://fastapi.tiangolo.com/img/index/index-02-redoc-simple.png)
 
-### OpenAPI
+### OpenAPI { #openapi }
 
 O **FastAPI** gera um "*schema*" com toda a sua API usando o padrão **OpenAPI** para definir APIs.
 
-#### "*Schema*"
+#### "*Schema*" { #schema }
 
 Um "*schema*" é uma definição ou descrição de algo. Não o código que o implementa, mas apenas uma descrição abstrata.
 
-#### API "*schema*"
+#### API "*schema*" { #api-schema }
 
 Nesse caso, <a href="https://github.com/OAI/OpenAPI-Specification" class="external-link" target="_blank">OpenAPI</a> é uma especificação que determina como definir um *schema* da sua API.
 
-Esta definição de *schema* inclui as rotas da sua API, os parâmetros possíveis que elas usam, etc.
+Esta definição de *schema* inclui os paths da sua API, os parâmetros possíveis que eles usam, etc.
 
-#### "*Schema*" de dados
+#### "*Schema*" de dados { #data-schema }
 
 O termo "*schema*" também pode se referir à forma de alguns dados, como um conteúdo JSON.
 
 Nesse caso, significaria os atributos JSON e os tipos de dados que eles possuem, etc.
 
-#### OpenAPI e JSON *Schema*
+#### OpenAPI e JSON Schema { #openapi-and-json-schema }
 
-OpenAPI define um *schema* de API para sua API. E esse *schema* inclui definições (ou "*schemas*") dos dados enviados e recebidos por sua API usando **JSON *Schema***, o padrão para *schemas* de dados JSON.
+OpenAPI define um *schema* de API para sua API. E esse *schema* inclui definições (ou "*schemas*") dos dados enviados e recebidos por sua API usando **JSON Schema**, o padrão para *schemas* de dados JSON.
 
-#### Verifique o `openapi.json`
+#### Verifique o `openapi.json` { #check-the-openapi-json }
 
 Se você está curioso(a) sobre a aparência do *schema* bruto OpenAPI, o FastAPI gera automaticamente um JSON (*schema*) com as descrições de toda a sua API.
 
@@ -116,7 +116,7 @@ Ele mostrará um JSON começando com algo como:
 
 ```JSON
 {
-    "openapi": "3.0.2",
+    "openapi": "3.1.0",
     "info": {
         "title": "FastAPI",
         "version": "0.1.0"
@@ -135,7 +135,7 @@ Ele mostrará um JSON começando com algo como:
 ...
 ```
 
-#### Para que serve o OpenAPI
+#### Para que serve o OpenAPI { #what-is-openapi-for }
 
 O *schema* OpenAPI é o que possibilita os dois sistemas de documentação interativos mostrados.
 
@@ -143,15 +143,15 @@ E existem dezenas de alternativas, todas baseadas em OpenAPI. Você pode facilme
 
 Você também pode usá-lo para gerar código automaticamente para clientes que se comunicam com sua API. Por exemplo, aplicativos front-end, móveis ou IoT.
 
-## Recapitulando, passo a passo
+## Recapitulando, passo a passo { #recap-step-by-step }
 
-### Passo 1: importe `FastAPI`
+### Passo 1: importe `FastAPI` { #step-1-import-fastapi }
 
 {* ../../docs_src/first_steps/tutorial001.py hl[1] *}
 
 `FastAPI` é uma classe Python que fornece todas as funcionalidades para sua API.
 
-/// note | Detalhes técnicos
+/// note | Detalhes Técnicos
 
 `FastAPI` é uma classe que herda diretamente de `Starlette`.
 
@@ -159,7 +159,7 @@ Você pode usar todas as funcionalidades do <a href="https://www.starlette.dev/"
 
 ///
 
-### Passo 2: crie uma "instância" de `FastAPI`
+### Passo 2: crie uma "instância" de `FastAPI` { #step-2-create-a-fastapi-instance }
 
 {* ../../docs_src/first_steps/tutorial001.py hl[3] *}
 
@@ -167,11 +167,11 @@ Aqui, a variável `app` será uma "instância" da classe `FastAPI`.
 
 Este será o principal ponto de interação para criar toda a sua API.
 
-### Passo 3: crie uma *rota*
+### Passo 3: crie uma operação de rota { #step-3-create-a-path-operation }
 
-#### Rota
+#### Path { #path }
 
-"Rota" aqui se refere à última parte da URL, começando do primeiro `/`.
+"Path" aqui se refere à última parte da URL, começando do primeiro `/`.
 
 Então, em uma URL como:
 
@@ -179,7 +179,7 @@ Então, em uma URL como:
 https://example.com/items/foo
 ```
 
-...a rota seria:
+...o path seria:
 
 ```
 /items/foo
@@ -187,13 +187,13 @@ https://example.com/items/foo
 
 /// info | Informação
 
-Uma "rota" também é comumente chamada de "endpoint".
+Um "path" também é comumente chamado de "endpoint" ou de "rota".
 
 ///
 
-Ao construir uma API, a "rota" é a principal forma de separar "preocupações" e "recursos".
+Ao construir uma API, o "path" é a principal forma de separar "preocupações" e "recursos".
 
-#### Operação
+#### Operação { #operation }
 
 "Operação" aqui se refere a um dos "métodos" HTTP.
 
@@ -211,7 +211,7 @@ Um dos:
 * `PATCH`
 * `TRACE`
 
-No protocolo HTTP, você pode se comunicar com cada rota usando um (ou mais) desses "métodos".
+No protocolo HTTP, você pode se comunicar com cada path usando um (ou mais) desses "métodos".
 
 ---
 
@@ -228,16 +228,16 @@ Portanto, no OpenAPI, cada um dos métodos HTTP é chamado de "operação".
 
 Vamos chamá-los de "**operações**" também.
 
-#### Defina um *decorador de rota*
+#### Defina um decorador de operação de rota { #define-a-path-operation-decorator }
 
 {* ../../docs_src/first_steps/tutorial001.py hl[6] *}
 
 O `@app.get("/")` diz ao **FastAPI** que a função logo abaixo é responsável por tratar as requisições que vão para:
 
-* a rota `/`
-* usando o  <abbr title="o método HTTP GET">operador <code>get</code></abbr>
+* o path `/`
+* usando uma <abbr title="um método HTTP GET">operação <code>get</code></abbr>
 
-/// info | `@decorador`
+/// info | Informações sobre `@decorator`
 
 Essa sintaxe `@alguma_coisa` em Python é chamada de "decorador".
 
@@ -245,9 +245,9 @@ Você o coloca em cima de uma função. Como um chapéu decorativo (acho que é
 
 Um "decorador" pega a função abaixo e faz algo com ela.
 
-Em nosso caso, este decorador informa ao **FastAPI** que a função abaixo corresponde a **rota** `/` com uma **operação** `get`.
+Em nosso caso, este decorador informa ao **FastAPI** que a função abaixo corresponde ao **path** `/` com uma **operação** `get`.
 
-É o "**decorador de rota**".
+É o "**decorador de operação de rota**".
 
 ///
 
@@ -276,11 +276,11 @@ Por exemplo, ao usar GraphQL, você normalmente executa todas as ações usando
 
 ///
 
-### Passo 4: defina uma **função de rota**
+### Passo 4: defina a função de operação de rota { #step-4-define-the-path-operation-function }
 
-Esta é a nossa "**função de rota**":
+Esta é a nossa "**função de operação de rota**":
 
-* **rota**: é `/`.
+* **path**: é `/`.
 * **operação**: é `get`.
 * **função**: é a função abaixo do "decorador" (abaixo do `@app.get("/")`).
 
@@ -288,9 +288,9 @@ Esta é a nossa "**função de rota**":
 
 Esta é uma função Python.
 
-Ela será chamada pelo **FastAPI** sempre que receber uma requisição para a URL "`/ `" usando uma operação `GET`.
+Ela será chamada pelo **FastAPI** sempre que receber uma requisição para a URL "`/`" usando uma operação `GET`.
 
-Neste caso, é uma função `assíncrona`.
+Neste caso, é uma função `async`.
 
 ---
 
@@ -300,11 +300,11 @@ Você também pode defini-la como uma função normal em vez de `async def`:
 
 /// note | Nota
 
-Se você não sabe a diferença, verifique o [Async: *"Com pressa?"*](../async.md#com-pressa){.internal-link target=_blank}.
+Se você não sabe a diferença, verifique o [Async: *"Com pressa?"*](../async.md#in-a-hurry){.internal-link target=_blank}.
 
 ///
 
-### Passo 5: retorne o conteúdo
+### Passo 5: retorne o conteúdo { #step-5-return-the-content }
 
 {* ../../docs_src/first_steps/tutorial001.py hl[8] *}
 
@@ -314,10 +314,10 @@ Você também pode devolver modelos Pydantic (você verá mais sobre isso mais t
 
 Existem muitos outros objetos e modelos que serão convertidos automaticamente para JSON (incluindo ORMs, etc). Tente usar seus favoritos, é altamente provável que já sejam compatíveis.
 
-## Recapitulando
+## Recapitulando { #recap }
 
 * Importe `FastAPI`.
 * Crie uma instância do `app`.
-* Coloque o **decorador que define a operação** (como `@app.get("/")`).
-* Escreva uma **função para a operação da rota** (como `def root(): ...`) abaixo.
-* Execute o servidor de desenvolvimento (como `uvicorn main:app --reload`).
+* Escreva um **decorador de operação de rota** usando decoradores como `@app.get("/")`.
+* Defina uma **função de operação de rota**; por exemplo, `def root(): ...`.
+* Execute o servidor de desenvolvimento usando o comando `fastapi dev`.

docs/pt/docs/tutorial/handling-errors.md

@@ -1,4 +1,4 @@
-# Manipulação de erros
+# Manipulação de erros { #handling-errors }
 
 Há diversas situações em que você precisa notificar um erro a um cliente que está utilizando a sua API.
 
@@ -20,15 +20,15 @@ Os status codes na faixa dos 400 significam que houve um erro por parte do clien
 
 Você se lembra de todos aqueles erros (e piadas) a respeito do "**404 Not Found**"?
 
-## Use o `HTTPException`
+## Use o `HTTPException` { #use-httpexception }
 
 Para retornar ao cliente *responses* HTTP com erros, use o `HTTPException`.
 
-### Import `HTTPException`
+### Import `HTTPException` { #import-httpexception }
 
 {* ../../docs_src/handling_errors/tutorial001.py hl[1] *}
 
-### Lance o `HTTPException` no seu código.
+### Lance o `HTTPException` no seu código. { #raise-an-httpexception-in-your-code }
 
 `HTTPException`, ao fundo, nada mais é do que a conjunção entre uma exceção comum do Python e informações adicionais relevantes para APIs.
 
@@ -42,13 +42,12 @@ Neste exemplo, quando o cliente pede, na requisição, por um item cujo ID não
 
 {* ../../docs_src/handling_errors/tutorial001.py hl[11] *}
 
-### A response resultante
-
+### A response resultante { #the-resulting-response }
 
 Se o cliente faz uma requisição para `http://example.com/items/foo` (um `item_id` `"foo"`), esse cliente receberá um HTTP status code 200, e uma resposta JSON:
 
 
-```
+```JSON
 {
   "item": "The Foo Wrestlers"
 }
@@ -71,7 +70,7 @@ Esses tipos de dados são manipulados automaticamente pelo **FastAPI** e convert
 
 ///
 
-## Adicione headers customizados
+## Adicione headers customizados { #add-custom-headers }
 
 Há certas situações em que é bastante útil poder adicionar headers customizados no HTTP error. Exemplo disso seria adicionar headers customizados para tipos de segurança.
 
@@ -81,7 +80,7 @@ Mas caso você precise, para um cenário mais complexo, você pode adicionar hea
 
 {* ../../docs_src/handling_errors/tutorial002.py hl[14] *}
 
-## Instalando manipuladores de exceções customizados
+## Instale manipuladores de exceções customizados { #install-custom-exception-handlers }
 
 Você pode adicionar manipuladores de exceção customizados com <a href="https://www.starlette.dev/exceptions/" class="external-link" target="_blank">a mesma seção de utilidade de exceções presentes no Starlette</a>
 
@@ -109,7 +108,7 @@ Você também pode usar `from starlette.requests import Request` and `from starl
 
 ///
 
-## Sobrescreva o manipulador padrão de exceções
+## Sobrescreva os manipuladores de exceções padrão { #override-the-default-exception-handlers }
 
 **FastAPI** tem alguns manipuladores padrão de exceções.
 
@@ -117,12 +116,16 @@ Esses manipuladores são os responsáveis por retornar o JSON padrão de respost
 
 Você pode sobrescrever esses manipuladores de exceção com os seus próprios manipuladores.
 
-## Sobrescreva exceções de validação da requisição
+### Sobrescreva exceções de validação da requisição { #override-request-validation-exceptions }
 
 Quando a requisição contém dados inválidos, **FastAPI** internamente lança para o `RequestValidationError`.
 
+E também inclui um manipulador de exceções padrão para ele.
+
 Para sobrescrevê-lo, importe o `RequestValidationError` e use-o com o `@app.exception_handler(RequestValidationError)` para decorar o manipulador de exceções.
 
+O manipulador de exceções receberá um `Request` e a exceção.
+
 {* ../../docs_src/handling_errors/tutorial004.py hl[2,14:16] *}
 
 Se você for ao `/items/foo`, em vez de receber o JSON padrão com o erro:
@@ -150,15 +153,15 @@ path -> item_id
   value is not a valid integer (type=type_error.integer)
 ```
 
-### `RequestValidationError` vs `ValidationError`
+#### `RequestValidationError` vs `ValidationError` { #requestvalidationerror-vs-validationerror }
 
-/// warning | Aviso
+/// warning | Atenção
 
 Você pode pular estes detalhes técnicos caso eles não sejam importantes para você neste momento.
 
 ///
 
-`RequestValidationError` é uma subclasse do <a href="https://docs.pydantic.dev/latest/#error-handling" class="external-link" target="_blank">`ValidationError`</a> existente no Pydantic.
+`RequestValidationError` é uma subclasse do <a href="https://docs.pydantic.dev/latest/concepts/models/#error-handling" class="external-link" target="_blank">`ValidationError`</a> existente no Pydantic.
 
 **FastAPI** faz uso dele para que você veja o erro no seu log, caso você utilize um modelo de Pydantic em `response_model`, e seus dados tenham erro.
 
@@ -168,6 +171,8 @@ E assim deve ser porque seria um bug no seu código ter o `ValidationError` do P
 
 E enquanto você conserta o bug, os clientes / usuários não deveriam ter acesso às informações internas do erro, porque, desse modo, haveria exposição de uma vulnerabilidade de segurança.
 
+### Sobrescreva o manipulador de erro `HTTPException` { #override-the-httpexception-error-handler }
+
 Do mesmo modo, você pode sobreescrever o `HTTPException`.
 
 Por exemplo, você pode querer retornar uma *response* em *plain text* ao invés de um JSON para os seguintes erros:
@@ -182,12 +187,14 @@ Você pode usar `from starlette.responses import PlainTextResponse`.
 
 ///
 
-### Use o body do `RequestValidationError`.
+### Use o body do `RequestValidationError`. { #use-the-requestvalidationerror-body }
 
 O `RequestValidationError` contém o `body` que ele recebeu de dados inválidos.
 
 Você pode utilizá-lo enquanto desenvolve seu app para conectar o *body* e debugá-lo, e assim retorná-lo ao usuário, etc.
 
+{* ../../docs_src/handling_errors/tutorial005.py hl[14] *}
+
 Tente enviar um item inválido como este:
 
 ```JSON
@@ -197,7 +204,7 @@ Tente enviar um item inválido como este:
 }
 ```
 
-Você receberá uma *response* informando-o de que a data é inválida, e contendo o *body* recebido:
+Você receberá uma *response* informando-o de que os dados são inválidos, e contendo o *body* recebido:
 
 ```JSON hl_lines="12-15"
 {
@@ -218,27 +225,27 @@ Você receberá uma *response* informando-o de que a data é inválida, e conten
 }
 ```
 
-#### O `HTTPException` do FastAPI vs o `HTTPException` do Starlette.
+#### O `HTTPException` do FastAPI vs o `HTTPException` do Starlette { #fastapis-httpexception-vs-starlettes-httpexception }
 
 O **FastAPI** tem o seu próprio `HTTPException`.
 
 E a classe de erro `HTTPException` do **FastAPI** herda da classe de erro do `HTTPException` do Starlette.
 
-A diferença entre os dois é a de que o `HTTPException` do **FastAPI** permite que você adicione *headers* que serão incluídos nas *responses*.
-
-Esses *headers* são necessários/utilizados internamente pelo OAuth 2.0 e também por outras utilidades de segurança.
+A única diferença é que o `HTTPException` do **FastAPI** aceita qualquer dado que possa ser convertido em JSON para o campo `detail`, enquanto o `HTTPException` do Starlette aceita apenas strings para esse campo.
 
 Portanto, você pode continuar lançando o `HTTPException` do **FastAPI** normalmente no seu código.
 
 Porém, quando você registrar um manipulador de exceção, você deve registrá-lo através do `HTTPException` do Starlette.
 
-Dessa forma, se qualquer parte do código interno, extensão ou plug-in do Starlette lançar o `HTTPException`, o seu manipulador de exceção poderá capturar esse lançamento e tratá-lo.
+Dessa forma, se qualquer parte do código interno, extensão ou plug-in do Starlette lançar um `HTTPException` do Starlette, o seu manipulador poderá capturar e tratá-lo.
+
+Neste exemplo, para poder ter ambos os `HTTPException` no mesmo código, a exceção do Starlette é renomeada para `StarletteHTTPException`:
 
 ```Python
 from starlette.exceptions import HTTPException as StarletteHTTPException
 ```
 
-### Re-use os manipulares de exceção do **FastAPI**
+### Reutilize os manipuladores de exceção do **FastAPI** { #reuse-fastapis-exception-handlers }
 
 Se você quer usar a exceção em conjunto com o mesmo manipulador de exceção *default* do **FastAPI**, você pode importar e re-usar esses manipuladores de exceção do `fastapi.exception_handlers`:
 

docs/pt/docs/tutorial/header-param-models.md

@@ -1,8 +1,8 @@
-# Modelos de Parâmetros do Cabeçalho
+# Modelos de Parâmetros do Cabeçalho { #header-parameter-models }
 
 Se você possui um grupo de **parâmetros de cabeçalho** relacionados, você pode criar um **modelo do Pydantic** para declará-los.
 
-Isso vai lhe permitir **reusar o modelo** em **múltiplos lugares** e também declarar validações e metadadados para todos os parâmetros de uma vez. 😎
+Isso vai lhe permitir **reusar o modelo** em **múltiplos lugares** e também declarar validações e metadados para todos os parâmetros de uma vez. 😎
 
 /// note | Nota
 
@@ -10,7 +10,7 @@ Isso é possível desde a versão `0.115.0` do FastAPI. 🤓
 
 ///
 
-## Parâmetros do Cabeçalho com um Modelo Pydantic
+## Parâmetros do Cabeçalho com um Modelo Pydantic { #header-parameters-with-a-pydantic-model }
 
 Declare os **parâmetros de cabeçalho** que você precisa em um **modelo do Pydantic**, e então declare o parâmetro como `Header`:
 
@@ -18,7 +18,7 @@ Declare os **parâmetros de cabeçalho** que você precisa em um **modelo do Pyd
 
 O **FastAPI** irá **extrair** os dados de **cada campo** a partir dos **cabeçalhos** da requisição e te retornará o modelo do Pydantic que você definiu.
 
-### Checando a documentação
+## Checando a documentação { #check-the-docs }
 
 Você pode ver os headers necessários na interface gráfica da documentação em `/docs`:
 
@@ -26,7 +26,7 @@ Você pode ver os headers necessários na interface gráfica da documentação e
 <img src="/img/tutorial/header-param-models/image01.png">
 </div>
 
-### Proibindo Cabeçalhos adicionais
+## Proibindo Cabeçalhos adicionais { #forbid-extra-headers }
 
 Em alguns casos de uso especiais (provavelmente não muito comuns), você pode querer **restringir** os cabeçalhos que você quer receber.
 
@@ -51,6 +51,22 @@ Por exemplo, se o cliente tentar enviar um cabeçalho `tool` com o valor `plumbu
 }
 ```
 
-## Resumo
+## Desativar conversão de underscores { #disable-convert-underscores }
+
+Da mesma forma que com parâmetros de cabeçalho normais, quando você tem caracteres de sublinhado nos nomes dos parâmetros, eles são **automaticamente convertidos em hifens**.
+
+Por exemplo, se você tem um parâmetro de cabeçalho `save_data` no código, o cabeçalho HTTP esperado será `save-data`, e ele aparecerá assim na documentação.
+
+Se por algum motivo você precisar desativar essa conversão automática, também poderá fazê-lo para modelos do Pydantic para parâmetros de cabeçalho.
+
+{* ../../docs_src/header_param_models/tutorial003_an_py310.py hl[19] *}
+
+/// warning | Atenção
+
+Antes de definir `convert_underscores` como `False`, tenha em mente que alguns proxies e servidores HTTP não permitem o uso de cabeçalhos com sublinhados.
+
+///
+
+## Resumo { #summary }
 
 Você pode utilizar **modelos do Pydantic** para declarar **cabeçalhos** no **FastAPI**. 😎

docs/pt/docs/tutorial/header-params.md

@@ -1,20 +1,20 @@
-# Parâmetros de Cabeçalho
+# Parâmetros de Cabeçalho { #header-parameters }
 
 Você pode definir parâmetros de Cabeçalho da mesma maneira que define paramêtros com `Query`, `Path` e `Cookie`.
 
-## importe `Header`
+## Importe `Header` { #import-header }
 
 Primeiro importe `Header`:
 
-{* ../../docs_src/header_params/tutorial001_py310.py hl[1] *}
+{* ../../docs_src/header_params/tutorial001_an_py310.py hl[3] *}
 
-## Declare parâmetros de `Header`
+## Declare parâmetros de `Header` { #declare-header-parameters }
 
 Então declare os paramêtros de cabeçalho usando a mesma estrutura que em `Path`, `Query` e `Cookie`.
 
 O primeiro valor é o valor padrão, você pode passar todas as validações adicionais ou parâmetros de anotação:
 
-{* ../../docs_src/header_params/tutorial001_py310.py hl[7] *}
+{* ../../docs_src/header_params/tutorial001_an_py310.py hl[9] *}
 
 /// note | Detalhes Técnicos
 
@@ -24,13 +24,13 @@ Mas lembre-se que quando você importa `Query`, `Path`, `Header`, e outras de `f
 
 ///
 
-/// info
+/// info | Informação
 
 Para declarar headers, você precisa usar `Header`, caso contrário, os parâmetros seriam interpretados como parâmetros de consulta.
 
 ///
 
-## Conversão automática
+## Conversão automática { #automatic-conversion }
 
 `Header` tem algumas funcionalidades a mais em relação a `Path`, `Query` e `Cookie`.
 
@@ -46,15 +46,15 @@ Portanto, você pode usar `user_agent` como faria normalmente no código Python,
 
 Se por algum motivo você precisar desabilitar a conversão automática de sublinhados para hífens, defina o parâmetro `convert_underscores` de `Header` para `False`:
 
-{* ../../docs_src/header_params/tutorial002_py310.py hl[8] *}
+{* ../../docs_src/header_params/tutorial002_an_py310.py hl[10] *}
 
-/// warning | Aviso
+/// warning | Atenção
 
 Antes de definir `convert_underscores` como `False`, lembre-se de que alguns proxies e servidores HTTP não permitem o uso de cabeçalhos com sublinhados.
 
 ///
 
-## Cabeçalhos duplicados
+## Cabeçalhos duplicados { #duplicate-headers }
 
 É possível receber cabeçalhos duplicados. Isso significa, o mesmo cabeçalho com vários valores.
 
@@ -64,9 +64,9 @@ Você receberá todos os valores do cabeçalho duplicado como uma `list` Python.
 
 Por exemplo, para declarar um cabeçalho de `X-Token` que pode aparecer mais de uma vez, você pode escrever:
 
-{* ../../docs_src/header_params/tutorial003_py310.py hl[7] *}
+{* ../../docs_src/header_params/tutorial003_an_py310.py hl[9] *}
 
-Se você se comunicar com essa *operação de caminho* enviando dois cabeçalhos HTTP como:
+Se você se comunicar com essa *operação de rota* enviando dois cabeçalhos HTTP como:
 
 ```
 X-Token: foo
@@ -84,8 +84,8 @@ A resposta seria como:
 }
 ```
 
-## Recapitulando
+## Recapitulando { #recap }
 
 Declare cabeçalhos com `Header`, usando o mesmo padrão comum que utiliza-se em `Query`, `Path` e `Cookie`.
 
-E não se preocupe com sublinhados em suas variáveis, FastAPI cuidará da conversão deles.
+E não se preocupe com sublinhados em suas variáveis, **FastAPI** cuidará da conversão deles.

docs/pt/docs/tutorial/index.md

@@ -1,4 +1,4 @@
-# Tutorial - Guia de Usuário
+# Tutorial - Guia de Usuário { #tutorial-user-guide }
 
 Esse tutorial mostra como usar o **FastAPI** com a maior parte de seus recursos, passo a passo.
 
@@ -6,11 +6,11 @@ Cada seção constrói, gradualmente, sobre as anteriores, mas sua estrutura sã
 
 Ele também foi construído para servir como uma referência futura, então você pode voltar e ver exatamente o que você precisa.
 
-## Rode o código
+## Rode o código { #run-the-code }
 
 Todos os blocos de código podem ser copiados e utilizados diretamente (eles são, na verdade, arquivos Python testados).
 
-Para rodar qualquer um dos exemplos, copie o codigo para um arquivo `main.py`, e inicie o `uvivorn` com:
+Para rodar qualquer um dos exemplos, copie o código para um arquivo `main.py`, e inicie o `fastapi dev` com:
 
 <div class="termy">
 
@@ -54,15 +54,15 @@ $ <font color="#4E9A06">fastapi</font> dev <u style="text-decoration-style:solid
 
 É **ALTAMENTE recomendado** que você escreva ou copie o código, edite-o e rode-o localmente.
 
-Usá-lo em seu editor é o que realmente te mostra os benefícios do FastAPI, ver quão pouco código você tem que escrever, todas as conferências de tipo, auto completações etc.
+Usá-lo em seu editor é o que realmente te mostra os benefícios do FastAPI, ver quão pouco código você tem que escrever, todas as conferências de tipo, preenchimento automático, etc.
 
 ---
 
-## Instale o FastAPI
+## Instale o FastAPI { #install-fastapi }
 
 O primeiro passo é instalar o FastAPI.
 
-Para o tutorial, você deve querer instalá-lo com todas as dependências e recursos opicionais.
+Certifique-se de criar um [ambiente virtual](../virtual-environments.md){.internal-link target=_blank}, ativá-lo e então **instalar o FastAPI**:
 
 <div class="termy">
 
@@ -76,17 +76,19 @@ $ pip install "fastapi[standard]"
 
 /// note | Nota
 
-Quando você instala com pip install "fastapi[standard]", ele vem com algumas dependências opcionais padrão.
+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 <a href="https://fastapicloud.com" class="external-link" target="_blank">FastAPI Cloud</a>.
 
-Se você não quiser ter essas dependências opcionais, pode instalar pip install fastapi em vez disso.
+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]"`.
 
 ///
 
-## Guia Avançado de Usuário
+## Guia Avançado de Usuário { #advanced-user-guide }
 
 Há também um **Guia Avançado de Usuário** que você pode ler após esse **Tutorial - Guia de Usuário**.
 
-O **Guia Avançado de Usuário** constrói sobre esse, usa os mesmos conceitos e te ensina alguns recursos extras.
+O **Guia Avançado de Usuário** constrói sobre esse, usa os mesmos conceitos e te ensina algumas funcionalidades extras.
 
 Mas você deveria ler primeiro o **Tutorial - Guia de Usuário** (que você está lendo agora).
 

docs/pt/docs/tutorial/metadata.md

@@ -1,8 +1,8 @@
-# Metadados e Urls de Documentos
+# Metadados e Urls de Documentos { #metadata-and-docs-urls }
 
 Você pode personalizar várias configurações de metadados na sua aplicação **FastAPI**.
 
-## Metadados para API
+## Metadados para API { #metadata-for-api }
 
 Você pode definir os seguintes campos que são usados na especificação OpenAPI e nas interfaces automáticas de documentação da API:
 
@@ -30,7 +30,7 @@ Com essa configuração, a documentação automática da API se pareceria com:
 
 <img src="/img/tutorial/metadata/image01.png">
 
-## Identificador de Licença
+## Identificador de Licença { #license-identifier }
 
 Desde o OpenAPI 3.1.0 e FastAPI 0.99.0, você também pode definir o license_info com um identifier em vez de uma url.
 
@@ -38,7 +38,7 @@ Por exemplo:
 
 {* ../../docs_src/metadata/tutorial001_1.py hl[31] *}
 
-## Metadados para tags
+## Metadados para tags { #metadata-for-tags }
 
 Você também pode adicionar metadados adicionais para as diferentes tags usadas para agrupar suas operações de rota com o parâmetro `openapi_tags`.
 
@@ -52,7 +52,7 @@ Cada dicionário pode conter:
     * `description`: uma `str` com uma breve descrição da documentação externa.
     * `url` (**obrigatório**): uma `str` com a URL da documentação externa.
 
-### Criar Metadados para tags
+### Criar Metadados para tags { #create-metadata-for-tags }
 
 Vamos tentar isso em um exemplo com tags para `users` e `items`.
 
@@ -68,31 +68,31 @@ Você não precisa adicionar metadados para todas as tags que você usa.
 
 ///
 
-### Use suas tags
+### Use suas tags { #use-your-tags }
 
 Use o parâmetro `tags` com suas *operações de rota* (e `APIRouter`s) para atribuí-los a diferentes tags:
 
 {* ../../docs_src/metadata/tutorial004.py hl[21,26] *}
 
-/// info  | Informação
+/// info | Informação
 
-Leia mais sobre tags em [Configuração de Operação de Caminho](path-operation-configuration.md#tags){.internal-link target=_blank}.
+Leia mais sobre tags em [Configuração de operação de rota](path-operation-configuration.md#tags){.internal-link target=_blank}.
 
 ///
 
-### Cheque os documentos
+### Cheque os documentos { #check-the-docs }
 
 Agora, se você verificar a documentação, ela exibirá todos os metadados adicionais:
 
 <img src="/img/tutorial/metadata/image02.png">
 
-### Ordem das tags
+### Ordem das tags { #order-of-tags }
 
 A ordem de cada dicionário de metadados de tag também define a ordem exibida na interface de documentação.
 
 Por exemplo, embora `users` apareça após `items` em ordem alfabética, ele é exibido antes deles, porque adicionamos seus metadados como o primeiro dicionário na lista.
 
-## URL da OpenAPI
+## URL da OpenAPI { #openapi-url }
 
 Por padrão, o esquema OpenAPI é servido em `/openapi.json`.
 
@@ -104,7 +104,7 @@ Por exemplo, para defini-lo para ser servido em `/api/v1/openapi.json`:
 
 Se você quiser desativar completamente o esquema OpenAPI, pode definir `openapi_url=None`, o que também desativará as interfaces de documentação que o utilizam.
 
-## URLs da Documentação
+## URLs da Documentação { #docs-urls }
 
 Você pode configurar as duas interfaces de documentação incluídas:
 

docs/pt/docs/tutorial/middleware.md

@@ -1,4 +1,4 @@
-# Middleware
+# Middleware { #middleware }
 
 Você pode adicionar middleware à suas aplicações **FastAPI**.
 
@@ -11,15 +11,15 @@ Um "middleware" é uma função que manipula cada **requisição** antes de ser
 * Ele pode fazer algo com essa **resposta** ou executar qualquer código necessário.
 * Então ele retorna a **resposta**.
 
-/// note | Detalhes técnicos
+/// note | Detalhes Técnicos
 
 Se você tiver dependências com `yield`, o código de saída será executado *depois* do middleware.
 
-Se houver alguma tarefa em segundo plano (documentada posteriormente), ela será executada *depois* de todo o middleware.
+Se houver alguma tarefa em segundo plano (abordada na seção [Tarefas em segundo plano](background-tasks.md){.internal-link target=_blank}, que você verá mais adiante), ela será executada *depois* de todo o middleware.
 
 ///
 
-## Criar um middleware
+## Criar um middleware { #create-a-middleware }
 
 Para criar um middleware, use o decorador `@app.middleware("http")` logo acima de uma função.
 
@@ -35,13 +35,13 @@ A função middleware recebe:
 
 /// tip | Dica
 
-Tenha em mente que cabeçalhos proprietários personalizados podem ser adicionados <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers" class="external-link" target="_blank">usando o prefixo 'X-'</a>.
+Tenha em mente que cabeçalhos proprietários personalizados podem ser adicionados <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers" class="external-link" target="_blank">usando o prefixo `X-`</a>.
 
 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){.internal-link target=_blank}) usando o parâmetro `expose_headers` documentado em <a href="https://www.starlette.dev/middleware/#corsmiddleware" class="external-link" target="_blank">Documentos CORS da Starlette</a>.
 
 ///
 
-/// note | Detalhes técnicos
+/// note | Detalhes Técnicos
 
 Você também pode usar `from starlette.requests import Request`.
 
@@ -49,7 +49,7 @@ Você também pode usar `from starlette.requests import Request`.
 
 ///
 
-### Antes e depois da `response`
+### Antes e depois da `response` { #before-and-after-the-response }
 
 Você pode adicionar código para ser executado com a `request`, antes que qualquer *operação de rota* o receba.
 
@@ -59,7 +59,36 @@ Por exemplo, você pode adicionar um cabeçalho personalizado `X-Process-Time` c
 
 {* ../../docs_src/middleware/tutorial001.py hl[10,12:13] *}
 
-## Outros middlewares
+/// tip | Dica
+
+Aqui usamos <a href="https://docs.python.org/3/library/time.html#time.perf_counter" class="external-link" target="_blank">`time.perf_counter()`</a> em vez de `time.time()` porque ele pode ser mais preciso para esses casos de uso. 🤓
+
+///
+
+## 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.
+
+No caminho da requisição, o middleware mais externo roda primeiro.
+
+No caminho da resposta, ele roda por último.
+
+Por exemplo:
+
+```Python
+app.add_middleware(MiddlewareA)
+app.add_middleware(MiddlewareB)
+```
+
+Isso resulta na seguinte ordem de execução:
+
+* **Requisição**: MiddlewareB → MiddlewareA → rota
+
+* **Resposta**: rota → MiddlewareA → MiddlewareB
+
+Esse comportamento de empilhamento garante que os middlewares sejam executados em uma ordem previsível e controlável.
+
+## Outros middlewares { #other-middlewares }
 
 Mais tarde, você pode ler mais sobre outros middlewares no [Guia do usuário avançado: Middleware avançado](../advanced/middleware.md){.internal-link target=_blank}.
 

docs/pt/docs/tutorial/path-operation-configuration.md

@@ -1,14 +1,14 @@
-# Configuração da Operação de Rota
+# Configuração da Operação de Rota { #path-operation-configuration }
 
 Existem vários parâmetros que você pode passar para o seu *decorador de operação de rota* para configurá-lo.
 
-/// warning | Aviso
+/// warning | Atenção
 
 Observe que esses parâmetros são passados diretamente para o *decorador de operação de rota*, não para a sua *função de operação de rota*.
 
 ///
 
-## Código de Status da Resposta
+## Código de Status da Resposta { #response-status-code }
 
 Você pode definir o `status_code` (HTTP) para ser usado na resposta da sua *operação de rota*.
 
@@ -16,7 +16,7 @@ Você pode passar diretamente o código `int`, como `404`.
 
 Mas se você não se lembrar o que cada código numérico significa, pode usar as constantes de atalho em `status`:
 
-{* ../../docs_src/path_operation_configuration/tutorial001.py hl[3,17] *}
+{* ../../docs_src/path_operation_configuration/tutorial001_py310.py hl[1,15] *}
 
 Esse código de status será usado na resposta e será adicionado ao esquema OpenAPI.
 
@@ -28,17 +28,17 @@ Você também poderia usar `from starlette import status`.
 
 ///
 
-## Tags
+## Tags { #tags }
 
 Você pode adicionar tags para sua *operação de rota*, passe o parâmetro `tags` com uma `list` de `str` (comumente apenas um `str`):
 
-{* ../../docs_src/path_operation_configuration/tutorial002.py hl[17,22,27] *}
+{* ../../docs_src/path_operation_configuration/tutorial002_py310.py hl[15,20,25] *}
 
 Eles serão adicionados ao esquema OpenAPI e usados pelas interfaces de documentação automática:
 
 <img src="/img/tutorial/path-operation-configuration/image01.png">
 
-### Tags com Enums
+### Tags com Enums { #tags-with-enums }
 
 Se você tem uma grande aplicação, você pode acabar acumulando **várias tags**, e você gostaria de ter certeza de que você sempre usa a **mesma tag** para *operações de rota* relacionadas.
 
@@ -48,30 +48,29 @@ Nestes casos, pode fazer sentido armazenar as tags em um `Enum`.
 
 {* ../../docs_src/path_operation_configuration/tutorial002b.py hl[1,8:10,13,18] *}
 
-## Resumo e descrição
+## Resumo e descrição { #summary-and-description }
 
 Você pode adicionar um `summary` e uma `description`:
 
-{* ../../docs_src/path_operation_configuration/tutorial003.py hl[20:21] *}
+{* ../../docs_src/path_operation_configuration/tutorial003_py310.py hl[18:19] *}
 
-## Descrição do docstring
+## Descrição do docstring { #description-from-docstring }
 
 Como as descrições tendem a ser longas e cobrir várias linhas, você pode declarar a descrição da *operação de rota* na <abbr title="uma string de várias linhas como a primeira expressão dentro de uma função (não atribuída a nenhuma variável) usada para documentação">docstring</abbr> da função e o **FastAPI** irá lê-la de lá.
 
 Você pode escrever <a href="https://en.wikipedia.org/wiki/Markdown" class="external-link" target="_blank">Markdown</a> na docstring, ele será interpretado e exibido corretamente (levando em conta a indentação da docstring).
 
-{* ../../docs_src/path_operation_configuration/tutorial004.py hl[19:27] *}
+{* ../../docs_src/path_operation_configuration/tutorial004_py310.py hl[17:25] *}
 
 Ela será usada nas documentações interativas:
 
-
 <img src="/img/tutorial/path-operation-configuration/image02.png">
 
-## Descrição da resposta
+## Descrição da resposta { #response-description }
 
 Você pode especificar a descrição da resposta com o parâmetro `response_description`:
 
-{* ../../docs_src/path_operation_configuration/tutorial005.py hl[21] *}
+{* ../../docs_src/path_operation_configuration/tutorial005_py310.py hl[19] *}
 
 /// info | Informação
 
@@ -79,7 +78,7 @@ Note que `response_description` se refere especificamente à resposta, a `descri
 
 ///
 
-/// check
+/// check | Verifique
 
 OpenAPI especifica que cada *operação de rota* requer uma descrição de resposta.
 
@@ -89,7 +88,7 @@ Então, se você não fornecer uma, o **FastAPI** irá gerar automaticamente uma
 
 <img src="/img/tutorial/path-operation-configuration/image03.png">
 
-## Depreciar uma *operação de rota*
+## Descontinuar uma *operação de rota* { #deprecate-a-path-operation }
 
 Se você precisar marcar uma *operação de rota* como <abbr title="obsoleta, recomendada não usá-la">descontinuada</abbr>, mas sem removê-la, passe o parâmetro `deprecated`:
 
@@ -103,6 +102,6 @@ Verifique como *operações de rota* descontinuadas e não descontinuadas se par
 
 <img src="/img/tutorial/path-operation-configuration/image05.png">
 
-## Resumindo
+## Resumindo { #recap }
 
 Você pode configurar e adicionar metadados para suas *operações de rota* facilmente passando parâmetros para os *decoradores de operação de rota*.

docs/pt/docs/tutorial/path-params-numeric-validations.md

@@ -1,91 +1,128 @@
-# Parâmetros da Rota e Validações Numéricas
+# Parâmetros de path e validações numéricas { #path-parameters-and-numeric-validations }
 
-Do mesmo modo que você pode declarar mais validações e metadados para parâmetros de consulta com `Query`, você pode declarar os mesmos tipos de validações e metadados para parâmetros de rota com `Path`.
+Da mesma forma que você pode declarar mais validações e metadados para parâmetros de consulta com `Query`, você pode declarar o mesmo tipo de validações e metadados para parâmetros de path com `Path`.
 
-## Importe `Path`
+## Importe `Path` { #import-path }
 
-Primeiro, importe `Path` de `fastapi`:
+Primeiro, importe `Path` de `fastapi`, e importe `Annotated`:
 
-{* ../../docs_src/path_params_numeric_validations/tutorial001_py310.py hl[1] *}
+{* ../../docs_src/path_params_numeric_validations/tutorial001_an_py310.py hl[1,3] *}
 
-## Declare metadados
+/// info | Informação
 
-Você pode declarar todos os parâmetros da mesma maneira que na `Query`.
+O FastAPI adicionou suporte a `Annotated` (e passou a recomendá-lo) na versão 0.95.0.
 
-Por exemplo para declarar um valor de metadado `title` para o parâmetro de rota `item_id` você pode digitar:
+Se você tiver uma versão mais antiga, verá erros ao tentar usar `Annotated`.
 
-{* ../../docs_src/path_params_numeric_validations/tutorial001_py310.py hl[8] *}
-
-/// note | Nota
-
-Um parâmetro de rota é sempre obrigatório, como se fizesse parte da rota.
-
-Então, você deve declará-lo com `...` para marcá-lo como obrigatório.
-
-Mesmo que você declare-o como `None` ou defina um valor padrão, isso não teria efeito algum, o parâmetro ainda seria obrigatório.
+Certifique-se de [Atualizar a versão do FastAPI](../deployment/versions.md#upgrading-the-fastapi-versions){.internal-link target=_blank} para pelo menos 0.95.1 antes de usar `Annotated`.
 
 ///
 
-## Ordene os parâmetros de acordo com sua necessidade
+## Declare metadados { #declare-metadata }
 
-Suponha que você queira declarar o parâmetro de consulta `q` como uma `str` obrigatória.
+Você pode declarar todos os mesmos parâmetros que em `Query`.
 
-E você não precisa declarar mais nada em relação a este parâmetro, então você não precisa necessariamente usar `Query`.
+Por exemplo, para declarar um valor de metadado `title` para o parâmetro de path `item_id` você pode digitar:
 
-Mas você ainda precisa usar `Path` para o parâmetro de rota `item_id`.
+{* ../../docs_src/path_params_numeric_validations/tutorial001_an_py310.py hl[10] *}
 
-O Python irá acusar se você colocar um elemento com um valor padrão definido antes de outro que não tenha um valor padrão.
+/// note | Nota
 
-Mas você pode reordená-los, colocando primeiro o elemento sem o valor padrão (o parâmetro de consulta `q`).
+Um parâmetro de path é sempre obrigatório, pois precisa fazer parte do path. Mesmo que você o declare como `None` ou defina um valor padrão, isso não afetaria nada, ele ainda seria sempre obrigatório.
 
-Isso não faz diferença para o **FastAPI**. Ele vai detectar os parâmetros pelos seus nomes, tipos e definições padrão (`Query`, `Path`, etc), sem se importar com a ordem.
+///
+
+## Ordene os parâmetros de acordo com sua necessidade { #order-the-parameters-as-you-need }
+
+/// tip | Dica
+
+Isso provavelmente não é tão importante ou necessário se você usar `Annotated`.
+
+///
+
+Vamos supor que você queira declarar o parâmetro de consulta `q` como uma `str` obrigatória.
+
+E você não precisa declarar mais nada para esse parâmetro, então você realmente não precisa usar `Query`.
+
+Mas você ainda precisa usar `Path` para o parâmetro de path `item_id`. E você não quer usar `Annotated` por algum motivo.
+
+O Python vai reclamar se você colocar um valor com “padrão” antes de um valor que não tem “padrão”.
+
+Mas você pode reordená-los e colocar primeiro o valor sem padrão (o parâmetro de consulta `q`).
+
+Isso não faz diferença para o **FastAPI**. Ele vai detectar os parâmetros pelos seus nomes, tipos e declarações de padrão (`Query`, `Path`, etc.), sem se importar com a ordem.
 
 Então, você pode declarar sua função assim:
 
 {* ../../docs_src/path_params_numeric_validations/tutorial002.py hl[7] *}
 
-## Ordene os parâmetros de a acordo com sua necessidade, truques
+Mas tenha em mente que, se você usar `Annotated`, você não terá esse problema, não fará diferença, pois você não está usando valores padrão de parâmetros de função para `Query()` ou `Path()`.
 
-Se você quiser declarar o parâmetro de consulta `q` sem um `Query` nem um valor padrão, e o parâmetro de rota `item_id` usando `Path`, e definí-los em uma ordem diferente, Python tem um pequeno truque na sintaxe para isso.
+{* ../../docs_src/path_params_numeric_validations/tutorial002_an_py39.py *}
+
+## Ordene os parâmetros de acordo com sua necessidade, truques { #order-the-parameters-as-you-need-tricks }
+
+/// tip | Dica
+
+Isso provavelmente não é tão importante ou necessário se você usar `Annotated`.
+
+///
+
+Aqui vai um pequeno truque que pode ser útil, mas você não vai precisar dele com frequência.
+
+Se você quiser:
+
+* declarar o parâmetro de consulta `q` sem um `Query` nem qualquer valor padrão
+* declarar o parâmetro de path `item_id` usando `Path`
+* tê-los em uma ordem diferente
+* não usar `Annotated`
+
+...o Python tem uma pequena sintaxe especial para isso.
 
 Passe `*`, como o primeiro parâmetro da função.
 
-O Python não vai fazer nada com esse `*`, mas ele vai saber que a partir dali os parâmetros seguintes deverão ser chamados argumentos nomeados (pares chave-valor), também conhecidos como <abbr title="Do inglês: K-ey W-ord Arg-uments"><code>kwargs</code></abbr>. Mesmo que eles não possuam um valor padrão.
+O Python não fará nada com esse `*`, mas saberá que todos os parâmetros seguintes devem ser chamados como argumentos nomeados (pares chave-valor), também conhecidos como <abbr title="Do inglês: K-ey W-ord Arg-uments"><code>kwargs</code></abbr>. Mesmo que eles não tenham um valor padrão.
 
 {* ../../docs_src/path_params_numeric_validations/tutorial003.py hl[7] *}
 
-## Validações numéricas: maior que ou igual
+### Melhor com `Annotated` { #better-with-annotated }
 
-Com `Query` e `Path` (e outras que você verá mais tarde) você pode declarar restrições numéricas.
+Tenha em mente que, se você usar `Annotated`, como você não está usando valores padrão de parâmetros de função, você não terá esse problema e provavelmente não precisará usar `*`.
 
-Aqui, com `ge=1`, `item_id` precisará ser um número inteiro maior que ("`g`reater than") ou igual ("`e`qual") a 1.
+{* ../../docs_src/path_params_numeric_validations/tutorial003_an_py39.py hl[10] *}
 
-{* ../../docs_src/path_params_numeric_validations/tutorial004.py hl[8] *}
+## Validações numéricas: maior que ou igual { #number-validations-greater-than-or-equal }
 
-## Validações numéricas: maior que e menor que ou igual
+Com `Query` e `Path` (e outras que você verá depois) você pode declarar restrições numéricas.
 
-O mesmo se aplica para:
+Aqui, com `ge=1`, `item_id` precisará ser um número inteiro “`g`reater than or `e`qual” a `1`.
+
+{* ../../docs_src/path_params_numeric_validations/tutorial004_an_py39.py hl[10] *}
+
+## Validações numéricas: maior que e menor que ou igual { #number-validations-greater-than-and-less-than-or-equal }
+
+O mesmo se aplica a:
 
 * `gt`: maior que (`g`reater `t`han)
 * `le`: menor que ou igual (`l`ess than or `e`qual)
 
-{* ../../docs_src/path_params_numeric_validations/tutorial005.py hl[9] *}
+{* ../../docs_src/path_params_numeric_validations/tutorial005_an_py39.py hl[10] *}
 
-## Validações numéricas: valores do tipo float, maior que e menor que
+## Validações numéricas: floats, maior que e menor que { #number-validations-floats-greater-than-and-less-than }
 
-Validações numéricas também funcionam para valores do tipo `float`.
+Validações numéricas também funcionam para valores `float`.
 
-Aqui é onde se torna importante a possibilidade de declarar <abbr title="greater than"><code>gt</code></abbr> e não apenas <abbr title="greater than or equal"><code>ge</code></abbr>. Com isso você pode especificar, por exemplo, que um valor deve ser maior que `0`, ainda que seja menor que `1`.
+Aqui é onde se torna importante poder declarar <abbr title="greater than – maior que"><code>gt</code></abbr> e não apenas <abbr title="greater than or equal – maior que ou igual"><code>ge</code></abbr>. Com isso você pode exigir, por exemplo, que um valor seja maior que `0`, mesmo que seja menor que `1`.
 
-Assim, `0.5` seria um valor válido. Mas `0.0` ou `0` não seria.
+Assim, `0.5` seria um valor válido. Mas `0.0` ou `0` não seriam.
 
-E o mesmo para <abbr title="less than"><code>lt</code></abbr>.
+E o mesmo para <abbr title="less than – menor que"><code>lt</code></abbr>.
 
-{* ../../docs_src/path_params_numeric_validations/tutorial006.py hl[11] *}
+{* ../../docs_src/path_params_numeric_validations/tutorial006_an_py39.py hl[13] *}
 
-## Recapitulando
+## Recapitulando { #recap }
 
-Com `Query`, `Path` (e outras que você ainda não viu) você pode declarar metadados e validações de texto do mesmo modo que com [Parâmetros de consulta e validações de texto](query-params-str-validations.md){.internal-link target=_blank}.
+Com `Query`, `Path` (e outras que você ainda não viu) você pode declarar metadados e validações de string do mesmo modo que em [Parâmetros de consulta e validações de string](query-params-str-validations.md){.internal-link target=_blank}.
 
 E você também pode declarar validações numéricas:
 
@@ -96,7 +133,7 @@ E você também pode declarar validações numéricas:
 
 /// info | Informação
 
-`Query`, `Path` e outras classes que você verá a frente são subclasses de uma classe comum `Param`.
+`Query`, `Path` e outras classes que você verá depois são subclasses de uma classe comum `Param`.
 
 Todas elas compartilham os mesmos parâmetros para validação adicional e metadados que você viu.
 
@@ -106,12 +143,12 @@ Todas elas compartilham os mesmos parâmetros para validação adicional e metad
 
 Quando você importa `Query`, `Path` e outras de `fastapi`, elas são na verdade funções.
 
-Que quando chamadas, retornam instâncias de classes de mesmo nome.
+Que, quando chamadas, retornam instâncias de classes de mesmo nome.
 
 Então, você importa `Query`, que é uma função. E quando você a chama, ela retorna uma instância de uma classe também chamada `Query`.
 
-Estas funções são assim (ao invés de apenas usar as classes diretamente) para que seu editor não acuse erros sobre seus tipos.
+Essas funções existem (em vez de usar diretamente as classes) para que seu editor não marque erros sobre seus tipos.
 
-Dessa maneira você pode user seu editor e ferramentas de desenvolvimento sem precisar adicionar configurações customizadas para ignorar estes erros.
+Dessa forma, você pode usar seu editor e ferramentas de codificação normais sem precisar adicionar configurações personalizadas para desconsiderar esses erros.
 
 ///

docs/pt/docs/tutorial/path-params.md

@@ -1,207 +1,188 @@
-# Parâmetros da rota da URL
+# Parâmetros de path { #path-parameters }
 
-Você pode declarar os "parâmetros" ou "variáveis" com a mesma sintaxe utilizada pelo formato de strings do Python:
+Você pode declarar "parâmetros" ou "variáveis" de path com a mesma sintaxe usada por strings de formatação do Python:
 
 {* ../../docs_src/path_params/tutorial001.py hl[6:7] *}
 
-O valor do parâmetro que foi passado à `item_id` será passado para a sua função como o argumento `item_id`.
+O valor do parâmetro de path `item_id` será passado para a sua função como o argumento `item_id`.
 
-Então, se você rodar este exemplo e for até <a href="http://127.0.0.1:8000/items/foo" class="external-link" target="_blank">http://127.0.0.1:8000/items/foo</a>, você verá a seguinte resposta:
+Então, se você executar este exemplo e acessar <a href="http://127.0.0.1:8000/items/foo" class="external-link" target="_blank">http://127.0.0.1:8000/items/foo</a>, você verá uma resposta:
 
 ```JSON
 {"item_id":"foo"}
 ```
 
-## Parâmetros da rota com tipos
+## Parâmetros de path com tipos { #path-parameters-with-types }
 
-Você pode declarar o tipo de um parâmetro na função usando as anotações padrões do Python:
+Você pode declarar o tipo de um parâmetro de path na função, usando as anotações de tipo padrão do Python:
 
 {* ../../docs_src/path_params/tutorial002.py hl[7] *}
 
-Nesse caso, `item_id` está sendo declarado como um `int`.
+Neste caso, `item_id` é declarado como um `int`.
 
 /// check | Verifique
-
-
-
+Isso fornecerá suporte do editor dentro da sua função, com verificações de erros, preenchimento automático, etc.
 ///
 
-	Isso vai dar à você suporte do seu editor dentro das funções, com verificações de erros, autocompletar, etc.
+## Dados <abbr title="também conhecido como: serialização, parsing, marshalling">conversão</abbr> { #data-conversion }
 
-## Conversão de <abbr title="também conhecido como: serialização, parsing, marshalling">dados</abbr>
-
-Se você rodar esse exemplo e abrir o seu navegador em <a href="http://127.0.0.1:8000/items/3" class="external-link" target="_blank">http://127.0.0.1:8000/items/3</a>, você verá a seguinte resposta:
+Se você executar este exemplo e abrir seu navegador em <a href="http://127.0.0.1:8000/items/3" class="external-link" target="_blank">http://127.0.0.1:8000/items/3</a>, você verá uma resposta:
 
 ```JSON
 {"item_id":3}
 ```
 
 /// check | Verifique
+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 <abbr title="convertendo a string que vem de um request HTTP em dados Python">"parsing"</abbr> automático do request.
 ///
 
-	Observe que o valor recebido pela função (e também retornado por ela) é `3`, como um Python `int`, não como uma string `"3"`.
+## Validação de dados { #data-validation }
 
-	Então, com essa declaração de tipo, o **FastAPI** dá pra você um <abbr title="convertendo a string que veio do request HTTP em um dado Python">"parsing"</abbr> automático no request .
-
-## Validação de dados
-
-Mas se você abrir o seu navegador em <a href="http://127.0.0.1:8000/items/foo" class="external-link" target="_blank">http://127.0.0.1:8000/items/foo</a>, você verá um belo erro HTTP:
+Mas se você for no navegador para <a href="http://127.0.0.1:8000/items/foo" class="external-link" target="_blank">http://127.0.0.1:8000/items/foo</a>, verá um bom erro HTTP:
 
 ```JSON
 {
-    "detail": [
-        {
-            "loc": [
-                "path",
-                "item_id"
-            ],
-            "msg": "value is not a valid integer",
-            "type": "type_error.integer"
-        }
-    ]
+  "detail": [
+    {
+      "type": "int_parsing",
+      "loc": [
+        "path",
+        "item_id"
+      ],
+      "msg": "Input should be a valid integer, unable to parse string as an integer",
+      "input": "foo"
+    }
+  ]
 }
 ```
 
-devido ao parâmetro da rota `item_id` ter um valor `"foo"`, que não é um `int`.
+porque o parâmetro de path `item_id` tinha o valor `"foo"`, que não é um `int`.
 
-O mesmo erro apareceria se você tivesse fornecido um `float` ao invés de um `int`, como em: <a href="http://127.0.0.1:8000/items/4.2" class="external-link" target="_blank">http://127.0.0.1:8000/items/4.2</a>
+O mesmo erro apareceria se você fornecesse um `float` em vez de um `int`, como em: <a href="http://127.0.0.1:8000/items/4.2" class="external-link" target="_blank">http://127.0.0.1:8000/items/4.2</a>
 
 /// check | Verifique
+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.
 ///
 
-	Então, com a mesma declaração de tipo do Python, o **FastAPI** dá pra você validação de dados.
+## Documentação { #documentation }
 
-	Observe que o erro também mostra claramente o ponto exato onde a validação não passou.
-
-	Isso é incrivelmente útil enquanto se desenvolve e debuga o código que interage com a sua API.
-
-## Documentação
-
-Quando você abrir o seu navegador em <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>, você verá de forma automática e interativa a documentação da API como:
+E quando você abrir seu navegador em <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>, você verá documentação automática, interativa, da API como:
 
 <img src="/img/tutorial/path-params/image01.png">
 
 /// check | Verifique
+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.
 ///
 
-	Novamente, apenas com a mesma declaração de tipo do Python, o **FastAPI** te dá de forma automática e interativa a documentação (integrada com o Swagger UI).
+## Benefícios baseados em padrões, documentação alternativa { #standards-based-benefits-alternative-documentation }
 
-	Veja que o parâmetro de rota está declarado como sendo um inteiro (int).
+E como o schema gerado é do padrão <a href="https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md" class="external-link" target="_blank">OpenAPI</a>, existem muitas ferramentas compatíveis.
 
-## Beneficios baseados em padrões, documentação alternativa
-
-Devido ao schema gerado ser o padrão do <a href="https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.2.md" class="external-link" target="_blank">OpenAPI</a>, existem muitas ferramentas compatíveis.
-
-Por esse motivo, o próprio **FastAPI** fornece uma API alternativa para documentação (utilizando ReDoc), que você pode acessar em <a href="http://127.0.0.1:8000/redoc" class="external-link" target="_blank">http://127.0.0.1:8000/redoc</a>:
+Por causa disso, o próprio **FastAPI** fornece uma documentação alternativa da API (usando ReDoc), que você pode acessar em <a href="http://127.0.0.1:8000/redoc" class="external-link" target="_blank">http://127.0.0.1:8000/redoc</a>:
 
 <img src="/img/tutorial/path-params/image02.png">
 
 Da mesma forma, existem muitas ferramentas compatíveis. Incluindo ferramentas de geração de código para muitas linguagens.
 
-## Pydantic
+## Pydantic { #pydantic }
 
-Toda a validação de dados é feita por baixo dos panos pelo <a href="https://docs.pydantic.dev/" class="external-link" target="_blank">Pydantic</a>, então você tem todos os benefícios disso. E assim você sabe que está em boas mãos.
+Toda a validação de dados é realizada nos bastidores pelo <a href="https://docs.pydantic.dev/" class="external-link" target="_blank">Pydantic</a>, 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 complexos de dados.
+Você pode usar as mesmas declarações de tipo com `str`, `float`, `bool` e muitos outros tipos de dados complexos.
 
-Vamos explorar muitos destes tipos nos próximos capítulos do tutorial.
+Vários deles são explorados nos próximos capítulos do tutorial.
 
-## A ordem importa
+## A ordem importa { #order-matters }
 
-Quando você cria operações de rota, você pode se deparar com situações onde você pode ter uma rota fixa.
+Ao criar *operações de rota*, você pode encontrar situações em que tem um path fixo.
 
-Algo como `/users/me` por exemplo, digamos que essa rota seja utilizada para pegar dados sobre o usuário atual.
+Como `/users/me`, digamos que seja para obter dados sobre o usuário atual.
 
-E então você pode ter também uma rota `/users/{user_id}` para pegar dados sobre um usuário específico associado a um ID de usuário.
+E então você também pode ter um path `/users/{user_id}` para obter dados sobre um usuário específico por algum ID de usuário.
 
-Porque as operações de rota são avaliadas em ordem, você precisa ter certeza que a rota para `/users/me` está sendo declarado antes da rota `/users/{user_id}`:
+Como as *operações de rota* são avaliadas em ordem, você precisa garantir que o path para `/users/me` seja declarado antes do de `/users/{user_id}`:
 
 {* ../../docs_src/path_params/tutorial003.py hl[6,11] *}
 
-Caso contrário, a rota para `/users/{user_id}` coincidiria também para `/users/me`, "pensando" que estaria recebendo o parâmetro `user_id` com o valor de `"me"`.
+Caso contrário, o path para `/users/{user_id}` também corresponderia a `/users/me`, "achando" que está recebendo um parâmetro `user_id` com o valor `"me"`.
 
-## Valores predefinidos
+Da mesma forma, você não pode redefinir uma operação de rota:
 
-Se você tem uma operação de rota que recebe um parâmetro da rota, mas que você queira que esses valores possíveis do parâmetro da rota sejam predefinidos, você pode usar <abbr title="Enumeration">`Enum`</abbr> padrão do Python.
+{* ../../docs_src/path_params/tutorial003b.py hl[6,11] *}
 
-### Criando uma classe `Enum`
+A primeira sempre será usada, já que o path corresponde primeiro.
 
-Importe `Enum` e crie uma sub-classe que herde de `str` e de `Enum`.
+## Valores predefinidos { #predefined-values }
 
-Por herdar de `str` a documentação da API vai ser capaz de saber que os valores devem ser do tipo `string` e assim ser capaz de mostrar eles corretamente.
+Se você tem uma *operação de rota* que recebe um *parâmetro de path*, mas quer que os valores válidos possíveis do *parâmetro de path* sejam predefinidos, você pode usar um <abbr title="Enumeration">`Enum`</abbr> padrão do Python.
 
-Assim, crie atributos de classe com valores fixos, que serão os valores válidos disponíveis.
+### Crie uma classe `Enum` { #create-an-enum-class }
+
+Importe `Enum` e crie uma subclasse que herde de `str` e de `Enum`.
+
+Ao herdar de `str`, a documentação da API saberá que os valores devem ser do tipo `string` e poderá renderizá-los corretamente.
+
+Em seguida, crie atributos de classe com valores fixos, que serão os valores válidos disponíveis:
 
 {* ../../docs_src/path_params/tutorial005.py hl[1,6:9] *}
 
-/// info | informação
-
+/// info | Informação
 <a href="https://docs.python.org/3/library/enum.html" class="external-link" target="_blank">Enumerations (ou enums) estão disponíveis no Python</a> desde a versão 3.4.
-
 ///
 
 /// tip | Dica
-
-
-
+Se você está se perguntando, "AlexNet", "ResNet" e "LeNet" são apenas nomes de <abbr title="Tecnicamente, arquiteturas de modelos de Deep Learning">modelos</abbr> de Aprendizado de Máquina.
 ///
 
-	Se você está se perguntando, "AlexNet", "ResNet", e "LeNet" são apenas nomes de <abbr title="técnicamente, modelos de arquitetura de Deep Learning">modelos</abbr> de Machine Learning (aprendizado de máquina).
+### Declare um parâmetro de path { #declare-a-path-parameter }
 
-### Declare um *parâmetro de rota*
-
-Logo, crie um *parâmetro de rota* com anotações de tipo usando a classe enum que você criou (`ModelName`):
+Em seguida, crie um *parâmetro de path* com anotação de tipo usando a classe enum que você criou (`ModelName`):
 
 {* ../../docs_src/path_params/tutorial005.py hl[16] *}
 
-### Revise a documentação
+### Verifique a documentação { #check-the-docs }
 
-Visto que os valores disponíveis para o parâmetro da rota estão predefinidos, a documentação interativa pode mostrar esses valores de uma forma bem legal:
+Como os valores disponíveis para o *parâmetro de path* são predefinidos, a documentação interativa pode mostrá-los de forma agradável:
 
 <img src="/img/tutorial/path-params/image03.png">
 
-### Trabalhando com os *enumeration* do Python
+### Trabalhando com *enumerações* do Python { #working-with-python-enumerations }
 
-O valor do *parâmetro da rota* será um *membro de enumeration*.
+O valor do *parâmetro de path* será um *membro de enumeração*.
 
-#### Compare *membros de enumeration*
+#### Compare membros de enumeração { #compare-enumeration-members }
 
-Você pode comparar eles com o *membro de enumeration* no enum `ModelName` que você criou:
+Você pode compará-lo com o *membro de enumeração* no seu enum `ModelName` criado:
 
 {* ../../docs_src/path_params/tutorial005.py hl[17] *}
 
-#### Obtenha o *valor de enumerate*
+#### Obtenha o valor da enumeração { #get-the-enumeration-value }
 
-Você pode ter o valor exato de enumerate (um `str` nesse caso) usando `model_name.value`, ou em geral, `your_enum_member.value`:
+Você pode obter o valor real (um `str` neste caso) usando `model_name.value`, ou, em geral, `your_enum_member.value`:
 
 {* ../../docs_src/path_params/tutorial005.py hl[20] *}
 
 /// tip | Dica
-
-
-
+Você também pode acessar o valor `"lenet"` com `ModelName.lenet.value`.
 ///
 
-	Você também poderia acessar o valor `"lenet"` com `ModelName.lenet.value`
+#### Retorne membros de enumeração { #return-enumeration-members }
 
-#### Retorne *membros de enumeration*
+Você pode retornar *membros de enum* da sua *operação de rota*, até mesmo aninhados em um corpo JSON (por exemplo, um `dict`).
 
-Você pode retornar *membros de enum* da sua *rota de operação*, em um corpo JSON aninhado (por exemplo um `dict`).
-
-Eles serão convertidos para o seus valores correspondentes (strings nesse caso) antes de serem retornados ao cliente:
+Eles serão convertidos para seus valores correspondentes (strings neste caso) antes de serem retornados ao cliente:
 
 {* ../../docs_src/path_params/tutorial005.py hl[18,21,23] *}
 
-No seu cliente você vai obter uma resposta JSON como:
+No seu cliente, você receberá uma resposta JSON como:
 
 ```JSON
 {
@@ -210,56 +191,51 @@ No seu cliente você vai obter uma resposta JSON como:
 }
 ```
 
-## Parâmetros de rota que contém caminhos
+## Parâmetros de path que contêm paths { #path-parameters-containing-paths }
 
-Digamos que você tenha uma *operação de rota* com uma rota `/files/{file_path}`.
+Digamos que você tenha uma *operação de rota* com um path `/files/{file_path}`.
 
-Mas você precisa que o próprio `file_path` contenha uma *rota*, como `home/johndoe/myfile.txt`.
+Mas você precisa que o próprio `file_path` contenha um *path*, como `home/johndoe/myfile.txt`.
 
-Então, a URL para este arquivo deveria ser algo como: `/files/home/johndoe/myfile.txt`.
+Então, a URL para esse arquivo seria algo como: `/files/home/johndoe/myfile.txt`.
 
-### Suporte do OpenAPI
+### Suporte do OpenAPI { #openapi-support }
 
-O OpenAPI não suporta uma maneira de declarar um *parâmetro de rota* que contenha uma *rota* dentro, dado que isso poderia levar a cenários que são difíceis de testar e definir.
+O OpenAPI não oferece suporte a uma maneira de declarar um *parâmetro de path* que contenha um *path* dentro, pois isso poderia levar a cenários difíceis de testar e definir.
 
-No entanto, você pode fazer isso no **FastAPI**, usando uma das ferramentas internas do Starlette.
+Ainda assim, você pode fazer isso no **FastAPI**, usando uma das ferramentas internas do Starlette.
 
-A documentação continuaria funcionando, ainda que não adicionaria nenhuma informação dizendo que o parâmetro deveria conter uma rota.
+E a documentação continuará funcionando, embora não adicione nenhuma informação dizendo que o parâmetro deve conter um path.
 
-### Conversor de rota
+### Conversor de path { #path-convertor }
 
-Usando uma opção direta do Starlette você pode declarar um *parâmetro de rota* contendo uma *rota* usando uma URL como:
+Usando uma opção diretamente do Starlette você pode declarar um *parâmetro de path* contendo um *path* usando uma URL como:
 
 ```
 /files/{file_path:path}
 ```
 
-Nesse caso, o nome do parâmetro é `file_path`, e a última parte, `:path`, diz que o parâmetro deveria coincidir com qualquer *rota*.
+Nesse caso, o nome do parâmetro é `file_path`, e a última parte, `:path`, diz que o parâmetro deve corresponder a qualquer *path*.
 
-Então, você poderia usar ele com:
+Então, você pode usá-lo com:
 
 {* ../../docs_src/path_params/tutorial004.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`.
 ///
 
-	Você poderia precisar que o parâmetro contivesse `/home/johndoe/myfile.txt`, com uma barra no inicio (`/`).
+## Recapitulação { #recap }
 
-	Neste caso, a URL deveria ser: `/files//home/johndoe/myfile.txt`, com barra dupla (`//`) entre `files` e `home`.
+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, autocompletar, etc.
+- "<abbr title="convertendo a string que vem de um request HTTP em dados Python">Parsing</abbr>" de dados
+- Validação de dados
+- Anotação da API e documentação automática
 
-## Recapitulando
+E você só precisa declará-los uma vez.
 
-Com o **FastAPI**, usando as declarações de tipo do Python, você obtém:
-
-* Suporte no editor: verificação de erros, e opção de autocompletar, etc.
-* "<abbr title="convertendo uma string que vem de um request HTTP em dado Python">Parsing</abbr>" de dados
-* Validação de dados
-* Anotação da API e documentação automática
-
-Você apenas tem que declará-los uma vez.
-
-Essa é provavelmente a vantagem mais visível do **FastAPI** se comparado com frameworks alternativos (além do desempenho puro).
+Essa é provavelmente a principal vantagem visível do **FastAPI** em comparação com frameworks alternativos (além do desempenho bruto).

docs/pt/docs/tutorial/query-param-models.md

@@ -1,4 +1,4 @@
-# Modelos de Parâmetros de Consulta
+# Modelos de Parâmetros de Consulta { #query-parameter-models }
 
 Se você possui um grupo de **parâmetros de consultas** que são relacionados, você pode criar um **modelo Pydantic** para declará-los.
 
@@ -10,7 +10,7 @@ Isso é suportado desde o FastAPI versão `0.115.0`. 🤓
 
 ///
 
-## Parâmetros de Consulta com um Modelo Pydantic
+## Parâmetros de Consulta com um Modelo Pydantic { #query-parameters-with-a-pydantic-model }
 
 Declare os **parâmetros de consulta** que você precisa em um **modelo Pydantic**, e então declare o parâmetro como `Query`:
 
@@ -19,7 +19,7 @@ Declare os **parâmetros de consulta** que você precisa em um **modelo Pydantic
 O **FastAPI** **extrairá** os dados para **cada campo** dos **parâmetros de consulta** presentes na requisição, e fornecerá o modelo Pydantic que você definiu.
 
 
-## Verifique os Documentos
+## Verifique os Documentos { #check-the-docs }
 
 Você pode ver os parâmetros de consulta nos documentos de IU em `/docs`:
 
@@ -27,7 +27,7 @@ Você pode ver os parâmetros de consulta nos documentos de IU em `/docs`:
 <img src="/img/tutorial/query-param-models/image01.png">
 </div>
 
-## Restrinja Parâmetros de Consulta Extras
+## Restrinja Parâmetros de Consulta Extras { #forbid-extra-query-parameters }
 
 Em alguns casos especiais (provavelmente não muito comuns), você queira **restrinjir** os parâmetros de consulta que deseja receber.
 
@@ -58,7 +58,7 @@ Eles receberão um retorno de **erro** informando-os que o parâmentro de consul
 }
 ```
 
-## Resumo
+## Resumo { #summary }
 
 Você pode utilizar **modelos Pydantic** para declarar **parâmetros de consulta** no **FastAPI**. 😎
 

docs/pt/docs/tutorial/query-params-str-validations.md

@@ -1,164 +1,286 @@
-# Parâmetros de consulta e validações de texto
+# Parâmetros de consulta e validações de string { #query-parameters-and-string-validations }
 
-O **FastAPI** permite que você declare informações adicionais e validações aos seus parâmetros.
+O **FastAPI** permite declarar informações adicionais e validações para os seus parâmetros.
 
-Vamos utilizar essa aplicação como exemplo:
+Vamos usar esta aplicação como exemplo:
 
-{* ../../docs_src/query_params_str_validations/tutorial001.py hl[9] *}
+{* ../../docs_src/query_params_str_validations/tutorial001_py310.py hl[7] *}
 
-O parâmetro de consulta `q` é do tipo `Union[str, None]`, o que significa que é do tipo `str` mas que também pode ser `None`, e de fato, o valor padrão é `None`, então o FastAPI saberá que não é obrigatório.
+O parâmetro de consulta `q` é do tipo `str | None`, isso significa que é do tipo `str`, mas também pode ser `None`, e de fato, o valor padrão é `None`, então o FastAPI saberá que não é obrigatório.
 
-/// note | Observação
+/// note | Nota
 
 O FastAPI saberá que o valor de `q` não é obrigatório por causa do valor padrão `= None`.
 
-O `Union` em `Union[str, None]` não é usado pelo FastAPI, mas permitirá que seu editor lhe dê um melhor suporte e detecte erros.
+Ter `str | None` permitirá que seu editor lhe ofereça melhor suporte e detecte erros.
 
 ///
 
-## Validação adicional
+## Validação adicional { #additional-validation }
 
-Nós iremos forçar que mesmo o parâmetro `q` seja opcional, sempre que informado, **seu tamanho não exceda 50 caracteres**.
+Vamos impor que, embora `q` seja opcional, sempre que for fornecido, **seu comprimento não exceda 50 caracteres**.
 
-### Importe `Query`
+### Importe `Query` e `Annotated` { #import-query-and-annotated }
 
-Para isso, primeiro importe `Query` de `fastapi`:
+Para isso, primeiro importe:
 
-{* ../../docs_src/query_params_str_validations/tutorial002.py hl[3] *}
+* `Query` de `fastapi`
+* `Annotated` de `typing`
 
-## Use `Query` como o valor padrão
+{* ../../docs_src/query_params_str_validations/tutorial002_an_py310.py hl[1,3] *}
 
-Agora utilize-o como valor padrão do seu parâmetro, definindo o parâmetro `max_length` para 50:
+/// info | Informação
 
-{* ../../docs_src/query_params_str_validations/tutorial002.py hl[9] *}
+O FastAPI adicionou suporte a `Annotated` (e passou a recomendá-lo) na versão 0.95.0.
 
-Note que substituímos o valor padrão de `None` para `Query(default=None)`, o primeiro parâmetro de `Query` serve para o mesmo propósito: definir o valor padrão do parâmetro.
+Se você tiver uma versão mais antiga, terá erros ao tentar usar `Annotated`.
 
-Então:
+Certifique-se de [Atualizar a versão do FastAPI](../deployment/versions.md#upgrading-the-fastapi-versions){.internal-link target=_blank} para pelo menos 0.95.1 antes de usar `Annotated`.
+
+///
+
+## Use `Annotated` no tipo do parâmetro `q` { #use-annotated-in-the-type-for-the-q-parameter }
+
+Lembra que eu disse antes que `Annotated` pode ser usado para adicionar metadados aos seus parâmetros na [Introdução aos tipos do Python](../python-types.md#type-hints-with-metadata-annotations){.internal-link target=_blank}?
+
+Agora é a hora de usá-lo com FastAPI. 🚀
+
+Tínhamos esta anotação de tipo:
+
+//// tab | Python 3.10+
 
 ```Python
-q: Union[str, None] = Query(default=None)
+q: str | None = None
 ```
 
-...Torna o parâmetro opcional, da mesma maneira que:
+////
+
+//// tab | Python 3.8+
 
 ```Python
 q: Union[str, None] = None
 ```
 
-Mas o declara explicitamente como um parâmetro de consulta.
+////
 
-/// info | Informação
+O que faremos é envolver isso com `Annotated`, para que fique assim:
 
-Tenha em mente que o FastAPI se preocupa com a parte:
+//// tab | Python 3.10+
 
 ```Python
-= None
+q: Annotated[str | None] = None
 ```
 
-Ou com:
+////
+
+//// tab | Python 3.8+
 
 ```Python
-= Query(default=None)
+q: Annotated[Union[str, None]] = None
 ```
 
-E irá utilizar o `None` para detectar que o parâmetro de consulta não é obrigatório.
+////
 
-O `Union` é apenas para permitir que seu editor de texto lhe dê um melhor suporte.
+Ambas as versões significam a mesma coisa, `q` é um parâmetro que pode ser `str` ou `None`, e por padrão é `None`.
+
+Agora vamos pular para a parte divertida. 🎉
+
+## Adicione `Query` ao `Annotated` no parâmetro `q` { #add-query-to-annotated-in-the-q-parameter }
+
+Agora que temos esse `Annotated` onde podemos colocar mais informações (neste caso, uma validação adicional), adicione `Query` dentro de `Annotated` e defina o parâmetro `max_length` como `50`:
+
+{* ../../docs_src/query_params_str_validations/tutorial002_an_py310.py hl[9] *}
+
+Perceba que o valor padrão continua sendo `None`, então o parâmetro ainda é opcional.
+
+Mas agora, com `Query(max_length=50)` dentro de `Annotated`, estamos dizendo ao FastAPI que queremos **validação adicional** para este valor, queremos que tenha no máximo 50 caracteres. 😎
+
+/// tip | Dica
+
+Aqui estamos usando `Query()` porque este é um **parâmetro de consulta**. Mais adiante veremos outros como `Path()`, `Body()`, `Header()` e `Cookie()`, que também aceitam os mesmos argumentos que `Query()`.
 
 ///
 
-Então, podemos passar mais parâmetros para `Query`. Neste caso, o parâmetro `max_length` que se aplica a textos:
+Agora o FastAPI vai:
 
-```Python
-q: str = Query(default=None, max_length=50)
-```
+* **Validar** os dados garantindo que o comprimento máximo seja de 50 caracteres
+* Mostrar um **erro claro** para o cliente quando os dados não forem válidos
+* **Documentar** o parâmetro na *operação de rota* do esquema OpenAPI (então ele aparecerá na **UI de docs automática**)
 
-Isso irá validar os dados, mostrar um erro claro quando os dados forem inválidos, e documentar o parâmetro na *operação de rota* do esquema OpenAPI..
+## Alternativa (antiga): `Query` como valor padrão { #alternative-old-query-as-the-default-value }
 
-## Adicionando mais validações
+Versões anteriores do FastAPI (antes de <abbr title="antes de 2023-03">0.95.0</abbr>) exigiam que você usasse `Query` como valor padrão do seu parâmetro, em vez de colocá-lo em `Annotated`. É muito provável que você veja código assim por aí, então vou te explicar.
 
-Você também pode incluir um parâmetro `min_length`:
+/// tip | Dica
 
-{* ../../docs_src/query_params_str_validations/tutorial003.py hl[10] *}
-
-## Adicionando expressões regulares
-
-Você pode definir uma <abbr title="Uma expressão regular, regex ou regexp é uma sequência de caracteres que define um parâmetro de busca para textos.">expressão regular</abbr> que combine com um padrão esperado pelo parâmetro:
-
-{* ../../docs_src/query_params_str_validations/tutorial004.py hl[11] *}
-
-Essa expressão regular específica verifica se o valor recebido no parâmetro:
-
-* `^`: Inicia com os seguintes caracteres, ou seja, não contém caracteres anteriores.
-* `fixedquery`: contém o valor exato `fixedquery`.
-* `$`: termina aqui, não contém nenhum caractere após `fixedquery`.
-
-Se você se sente perdido com todo esse assunto de **"expressão regular"**, não se preocupe. Esse é um assunto complicado para a maioria das pessoas. Você ainda pode fazer muitas coisas sem utilizar expressões regulares.
-
-Mas assim que você precisar e já tiver aprendido sobre, saiba que você poderá usá-las diretamente no **FastAPI**.
-
-## Valores padrão
-
-Da mesma maneira que você utiliza `None` como o primeiro argumento para ser utilizado como um valor padrão, você pode usar outros valores.
-
-Vamos dizer que você queira que o parâmetro de consulta `q` tenha um `min_length` de `3`, e um valor padrão de `"fixedquery"`, então declararíamos assim:
-
-{* ../../docs_src/query_params_str_validations/tutorial005.py hl[7] *}
-
-/// note | Observação
-
-O parâmetro torna-se opcional quando possui um valor padrão.
+Para código novo e sempre que possível, use `Annotated` como explicado acima. Há múltiplas vantagens (explicadas abaixo) e nenhuma desvantagem. 🍰
 
 ///
 
-## Torne-o obrigatório
+É assim que você usaria `Query()` como valor padrão do parâmetro da sua função, definindo o parâmetro `max_length` como 50:
 
-Quando você não necessita de validações ou de metadados adicionais, podemos fazer com que o parâmetro de consulta `q` seja obrigatório por não declarar um valor padrão, dessa forma:
+{* ../../docs_src/query_params_str_validations/tutorial002_py310.py hl[7] *}
+
+Como neste caso (sem usar `Annotated`) temos que substituir o valor padrão `None` na função por `Query()`, agora precisamos definir o valor padrão com o parâmetro `Query(default=None)`, ele serve ao mesmo propósito de definir esse valor padrão (pelo menos para o FastAPI).
+
+Então:
+
+```Python
+q: str | None = Query(default=None)
+```
+
+...torna o parâmetro opcional, com um valor padrão de `None`, o mesmo que:
+
+
+```Python
+q: str | None = None
+```
+
+Mas a versão com `Query` o declara explicitamente como sendo um parâmetro de consulta.
+
+Então, podemos passar mais parâmetros para `Query`. Neste caso, o parâmetro `max_length` que se aplica a strings:
+
+```Python
+q: str | None = Query(default=None, max_length=50)
+```
+
+Isso validará os dados, mostrará um erro claro quando os dados não forem válidos e documentará o parâmetro na *operação de rota* do esquema OpenAPI.
+
+### `Query` como valor padrão ou em `Annotated` { #query-as-the-default-value-or-in-annotated }
+
+Tenha em mente que, ao usar `Query` dentro de `Annotated`, você não pode usar o parâmetro `default` de `Query`.
+
+Em vez disso, use o valor padrão real do parâmetro da função. Caso contrário, haveria inconsistência.
+
+Por exemplo, isto não é permitido:
+
+```Python
+q: Annotated[str, Query(default="rick")] = "morty"
+```
+
+...porque não está claro se o valor padrão deveria ser `"rick"` ou `"morty"`.
+
+Então, você usaria (preferencialmente):
+
+```Python
+q: Annotated[str, Query()] = "rick"
+```
+
+...ou em bases de código mais antigas você encontrará:
+
+```Python
+q: str = Query(default="rick")
+```
+
+### Vantagens de `Annotated` { #advantages-of-annotated }
+
+**Usar `Annotated` é recomendado** em vez do valor padrão nos parâmetros da função, é **melhor** por vários motivos. 🤓
+
+O valor **padrão** do **parâmetro da função** é o **valor padrão real**, isso é mais intuitivo com Python em geral. 😌
+
+Você poderia **chamar** essa mesma função em **outros lugares** sem FastAPI, e ela **funcionaria como esperado**. Se houver um parâmetro **obrigatório** (sem valor padrão), seu **editor** vai avisar com um erro, e o **Python** também reclamará se você executá-la sem passar o parâmetro obrigatório.
+
+Quando você não usa `Annotated` e em vez disso usa o estilo de **valor padrão (antigo)**, se você chamar essa função sem FastAPI em **outros lugares**, terá que **lembrar** de passar os argumentos para a função para que funcione corretamente, caso contrário os valores serão diferentes do esperado (por exemplo, `QueryInfo` ou algo parecido em vez de `str`). E seu editor não vai avisar, e o Python também não vai reclamar ao executar a função, apenas quando as operações internas falharem.
+
+Como `Annotated` pode ter mais de uma anotação de metadados, você agora pode até usar a mesma função com outras ferramentas, como o <a href="https://typer.tiangolo.com/" class="external-link" target="_blank">Typer</a>. 🚀
+
+## Adicione mais validações { #add-more-validations }
+
+Você também pode adicionar um parâmetro `min_length`:
+
+{* ../../docs_src/query_params_str_validations/tutorial003_an_py310.py hl[10] *}
+
+## Adicione expressões regulares { #add-regular-expressions }
+
+Você pode definir um `pattern` de <abbr title="Uma expressão regular, regex ou regexp é uma sequência de caracteres que define um padrão de busca para strings.">expressão regular</abbr> que o parâmetro deve corresponder:
+
+{* ../../docs_src/query_params_str_validations/tutorial004_an_py310.py hl[11] *}
+
+Esse padrão específico de expressão regular verifica se o valor recebido no parâmetro:
+
+* `^`: começa com os caracteres seguintes, não tem caracteres antes.
+* `fixedquery`: tem exatamente o valor `fixedquery`.
+* `$`: termina ali, não tem mais caracteres depois de `fixedquery`.
+
+Se você se sentir perdido com essas ideias de **"expressão regular"**, não se preocupe. Esse é um assunto difícil para muitas pessoas. Você ainda pode fazer muitas coisas sem precisar de expressões regulares por enquanto.
+
+Agora você sabe que, sempre que precisar delas, pode usá-las no **FastAPI**.
+
+### Pydantic v1 `regex` em vez de `pattern` { #pydantic-v1-regex-instead-of-pattern }
+
+Antes da versão 2 do Pydantic e antes do FastAPI 0.100.0, o parâmetro se chamava `regex` em vez de `pattern`, mas agora está descontinuado.
+
+Você ainda pode ver algum código usando isso:
+
+//// tab | Pydantic v1
+
+{* ../../docs_src/query_params_str_validations/tutorial004_regex_an_py310.py hl[11] *}
+
+////
+
+Mas saiba que isso está descontinuado e deve ser atualizado para usar o novo parâmetro `pattern`. 🤓
+
+## Valores padrão { #default-values }
+
+Você pode, claro, usar valores padrão diferentes de `None`.
+
+Digamos que você queira declarar o parâmetro de consulta `q` com `min_length` de `3` e ter um valor padrão de `"fixedquery"`:
+
+{* ../../docs_src/query_params_str_validations/tutorial005_an_py39.py hl[9] *}
+
+/// note | Nota
+
+Ter um valor padrão de qualquer tipo, incluindo `None`, torna o parâmetro opcional (não obrigatório).
+
+///
+
+## Parâmetros obrigatórios { #required-parameters }
+
+Quando não precisamos declarar mais validações ou metadados, podemos tornar o parâmetro de consulta `q` obrigatório simplesmente não declarando um valor padrão, assim:
 
 ```Python
 q: str
 ```
 
-em vez desta:
+em vez de:
 
 ```Python
-q: Union[str, None] = None
+q: str | None = None
 ```
 
-Mas agora nós o estamos declarando como `Query`, conforme abaixo:
+Mas agora estamos declarando com `Query`, por exemplo assim:
 
 ```Python
-q: Union[str, None] = Query(default=None, min_length=3)
+q: Annotated[str | None, Query(min_length=3)] = None
 ```
 
-Então, quando você precisa declarar um parâmetro obrigatório utilizando o `Query`, você pode utilizar `...` como o primeiro argumento:
+Então, quando você precisa declarar um valor como obrigatório usando `Query`, você pode simplesmente não declarar um valor padrão:
 
-{* ../../docs_src/query_params_str_validations/tutorial006.py hl[7] *}
+{* ../../docs_src/query_params_str_validations/tutorial006_an_py39.py hl[9] *}
 
-/// info | Informação
+### Obrigatório, pode ser `None` { #required-can-be-none }
 
-Se você nunca viu os `...` antes: é um valor único especial, faz <a href="https://docs.python.org/3/library/constants.html#Ellipsis" class="external-link" target="_blank">parte do Python e é chamado "Ellipsis"</a>.
+Você pode declarar que um parâmetro pode aceitar `None`, mas que ainda assim é obrigatório. Isso forçaria os clientes a enviarem um valor, mesmo que o valor seja `None`.
 
-///
+Para isso, você pode declarar que `None` é um tipo válido, mas simplesmente não declarar um valor padrão:
 
-Dessa forma o **FastAPI** saberá que o parâmetro é obrigatório.
+{* ../../docs_src/query_params_str_validations/tutorial006c_an_py310.py hl[9] *}
 
-## Lista de parâmetros de consulta / múltiplos valores
+## Lista de parâmetros de consulta / múltiplos valores { #query-parameter-list-multiple-values }
 
-Quando você declara explicitamente um parâmetro com `Query` você pode declará-lo para receber uma lista de valores, ou podemos dizer, que irá receber mais de um valor.
+Quando você define explicitamente um parâmetro de consulta com `Query`, você também pode declará-lo para receber uma lista de valores, ou seja, receber múltiplos valores.
 
-Por exemplo, para declarar que o parâmetro `q` pode aparecer diversas vezes na URL, você escreveria:
+Por exemplo, para declarar um parâmetro de consulta `q` que pode aparecer várias vezes na URL, você pode escrever:
 
-{* ../../docs_src/query_params_str_validations/tutorial011.py hl[9] *}
+{* ../../docs_src/query_params_str_validations/tutorial011_an_py310.py hl[9] *}
 
-Então, com uma URL assim:
+Então, com uma URL como:
 
 ```
 http://localhost:8000/items/?q=foo&q=bar
 ```
 
-você receberá os múltiplos *parâmetros de consulta* `q` com os valores (`foo` e `bar`) em uma lista (`list`) Python dentro da *função de operação de rota*, no *parâmetro da função* `q`.
+você receberá os múltiplos valores do *parâmetro de consulta* `q` (`foo` e `bar`) em uma `list` Python dentro da sua *função de operação de rota*, no *parâmetro da função* `q`.
 
 Assim, a resposta para essa URL seria:
 
@@ -173,19 +295,19 @@ Assim, a resposta para essa URL seria:
 
 /// tip | Dica
 
-Para declarar um parâmetro de consulta com o tipo `list`, como no exemplo acima, você precisa usar explicitamente o `Query`, caso contrário será interpretado como um corpo da requisição.
+Para declarar um parâmetro de consulta com tipo `list`, como no exemplo acima, você precisa usar explicitamente `Query`, caso contrário seria interpretado como um corpo da requisição.
 
 ///
 
-A documentação interativa da API irá atualizar de acordo, permitindo múltiplos valores:
+A documentação interativa da API será atualizada de acordo, permitindo múltiplos valores:
 
 <img src="/img/tutorial/query-params-str-validations/image02.png">
 
-### Lista de parâmetros de consulta / múltiplos valores por padrão
+### Lista de parâmetros de consulta / múltiplos valores com valores padrão { #query-parameter-list-multiple-values-with-defaults }
 
-E você também pode definir uma lista (`list`) de valores padrão caso nenhum seja informado:
+Você também pode definir uma `list` de valores padrão caso nenhum seja fornecido:
 
-{* ../../docs_src/query_params_str_validations/tutorial012.py hl[9] *}
+{* ../../docs_src/query_params_str_validations/tutorial012_an_py39.py hl[9] *}
 
 Se você for até:
 
@@ -193,7 +315,7 @@ Se você for até:
 http://localhost:8000/items/
 ```
 
-O valor padrão de `q` será: `["foo", "bar"]` e sua resposta será:
+o valor padrão de `q` será: `["foo", "bar"]` e sua resposta será:
 
 ```JSON
 {
@@ -204,93 +326,163 @@ O valor padrão de `q` será: `["foo", "bar"]` e sua resposta será:
 }
 ```
 
-#### Usando `list`
+#### Usando apenas `list` { #using-just-list }
 
-Você também pode utilizar o tipo `list` diretamente em vez de `List[str]`:
+Você também pode usar `list` diretamente em vez de `list[str]`:
 
-{* ../../docs_src/query_params_str_validations/tutorial013.py hl[7] *}
+{* ../../docs_src/query_params_str_validations/tutorial013_an_py39.py hl[9] *}
 
-/// note | Observação
+/// note | Nota
 
-Tenha em mente que neste caso, o FastAPI não irá validar os conteúdos da lista.
+Tenha em mente que, neste caso, o FastAPI não verificará o conteúdo da lista.
 
-Por exemplo, um `List[int]` iria validar (e documentar) que os contéudos da lista são números inteiros. Mas apenas `list` não.
+Por exemplo, `list[int]` verificaria (e documentaria) que os conteúdos da lista são inteiros. Mas `list` sozinho não.
 
 ///
 
-## Declarando mais metadados
+## Declare mais metadados { #declare-more-metadata }
 
 Você pode adicionar mais informações sobre o parâmetro.
 
-Essa informações serão inclusas no esquema do OpenAPI e utilizado pela documentação interativa e ferramentas externas.
+Essas informações serão incluídas no OpenAPI gerado e usadas pelas interfaces de documentação e por ferramentas externas.
 
-/// note | Observação
+/// note | Nota
 
-Tenha em mente que cada ferramenta oferece diferentes níveis de suporte ao OpenAPI.
+Tenha em mente que ferramentas diferentes podem ter níveis diferentes de suporte ao OpenAPI.
 
-Algumas delas não exibem todas as informações extras que declaramos, ainda que na maioria dos casos, esses recursos estão planejados para desenvolvimento.
+Algumas delas podem ainda não mostrar todas as informações extras declaradas, embora na maioria dos casos o recurso ausente já esteja planejado para desenvolvimento.
 
 ///
 
 Você pode adicionar um `title`:
 
-{* ../../docs_src/query_params_str_validations/tutorial007.py hl[10] *}
+{* ../../docs_src/query_params_str_validations/tutorial007_an_py310.py hl[10] *}
 
 E uma `description`:
 
-{* ../../docs_src/query_params_str_validations/tutorial008.py hl[13] *}
+{* ../../docs_src/query_params_str_validations/tutorial008_an_py310.py hl[14] *}
 
-## Apelidos (alias) de parâmetros
+## Parâmetros com alias { #alias-parameters }
 
-Imagine que você queira que um parâmetro tenha o nome `item-query`.
+Imagine que você queira que o parâmetro seja `item-query`.
 
-Desta maneira:
+Assim:
 
 ```
 http://127.0.0.1:8000/items/?item-query=foobaritems
 ```
 
-Mas o nome `item-query` não é um nome de váriavel válido no Python.
+Mas `item-query` não é um nome de variável Python válido.
 
-O que mais se aproxima é `item_query`.
+O mais próximo seria `item_query`.
 
-Mas ainda você precisa que o nome seja exatamente `item-query`...
+Mas você ainda precisa que seja exatamente `item-query`...
 
-Então você pode declarar um `alias`, e esse apelido (alias) que será utilizado para encontrar o valor do parâmetro:
+Então você pode declarar um `alias`, e esse alias será usado para encontrar o valor do parâmetro:
 
-{* ../../docs_src/query_params_str_validations/tutorial009.py hl[9] *}
+{* ../../docs_src/query_params_str_validations/tutorial009_an_py310.py hl[9] *}
 
-## Parâmetros descontinuados
+## Descontinuando parâmetros { #deprecating-parameters }
 
-Agora vamos dizer que você não queria mais utilizar um parâmetro.
+Agora digamos que você não gosta mais desse parâmetro.
 
-Você tem que deixá-lo ativo por um tempo, já que existem clientes o utilizando. Mas você quer que a documentação deixe claro que este parâmetro será <abbr title="obsoleto, recomenda-se que não deve ser utilizado">descontinuado</abbr>.
+Você tem que deixá-lo por um tempo, pois há clientes usando-o, mas quer que a documentação mostre claramente que ele está <abbr title="obsoleto, recomenda-se não usá-lo">descontinuado</abbr>.
 
-Então você passa o parâmetro `deprecated=True` para `Query`:
+Então passe o parâmetro `deprecated=True` para `Query`:
 
-{* ../../docs_src/query_params_str_validations/tutorial010.py hl[18] *}
+{* ../../docs_src/query_params_str_validations/tutorial010_an_py310.py hl[19] *}
 
-Na documentação aparecerá assim:
+A documentação vai mostrar assim:
 
 <img src="/img/tutorial/query-params-str-validations/image01.png">
 
-## Recapitulando
+## Excluir parâmetros do OpenAPI { #exclude-parameters-from-openapi }
 
-Você pode adicionar validações e metadados adicionais aos seus parâmetros.
+Para excluir um parâmetro de consulta do OpenAPI gerado (e portanto, dos sistemas de documentação automáticos), defina o parâmetro `include_in_schema` de `Query` como `False`:
 
-Validações genéricas e metadados:
+{* ../../docs_src/query_params_str_validations/tutorial014_an_py310.py hl[10] *}
+
+## Validação personalizada { #custom-validation }
+
+Podem existir casos em que você precise fazer alguma **validação personalizada** que não pode ser feita com os parâmetros mostrados acima.
+
+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 <a href="https://docs.pydantic.dev/latest/concepts/validators/#field-after-validator" class="external-link" target="_blank">`AfterValidator` do Pydantic</a> dentro de `Annotated`.
+
+/// tip | Dica
+
+O Pydantic também tem <a href="https://docs.pydantic.dev/latest/concepts/validators/#field-before-validator" class="external-link" target="_blank">`BeforeValidator`</a> e outros. 🤓
+
+///
+
+Por exemplo, este validador personalizado verifica se o ID do item começa com `isbn-` para um número de livro <abbr title="ISBN significa Número Padrão Internacional de Livro">ISBN</abbr> ou com `imdb-` para um ID de URL de filme <abbr title="IMDB (Internet Movie Database) é um site com informações sobre filmes">IMDB</abbr>:
+
+{* ../../docs_src/query_params_str_validations/tutorial015_an_py310.py hl[5,16:19,24] *}
+
+/// info | Informação
+
+Isso está disponível com a versão 2 do Pydantic ou superior. 😎
+
+///
+
+/// tip | Dica
+
+Se você precisar fazer qualquer tipo de validação que exija comunicação com algum **componente externo**, como um banco de dados ou outra API, você deve usar **Dependências do FastAPI** em vez disso; você aprenderá sobre elas mais adiante.
+
+Esses validadores personalizados são para coisas que podem ser verificadas **apenas** com os **mesmos dados** fornecidos na requisição.
+
+///
+
+### Entenda esse código { #understand-that-code }
+
+O ponto importante é apenas usar **`AfterValidator` com uma função dentro de `Annotated`**. Sinta-se à vontade para pular esta parte. 🤸
+
+---
+
+Mas se você está curioso sobre este exemplo específico e ainda entretido, aqui vão alguns detalhes extras.
+
+#### String com `value.startswith()` { #string-with-value-startswith }
+
+Percebeu? Uma string usando `value.startswith()` pode receber uma tupla, e verificará cada valor na tupla:
+
+{* ../../docs_src/query_params_str_validations/tutorial015_an_py310.py ln[16:19] hl[17] *}
+
+#### Um item aleatório { #a-random-item }
+
+Com `data.items()` obtemos um <abbr title="Algo que podemos iterar com um laço for, como uma list, set, etc.">objeto iterável</abbr> com tuplas contendo a chave e o valor de cada item do dicionário.
+
+Convertimos esse objeto iterável em uma `list` adequada com `list(data.items())`.
+
+Em seguida, com `random.choice()` podemos obter um **valor aleatório** da lista, então obtemos uma tupla com `(id, name)`. Será algo como `("imdb-tt0371724", "The Hitchhiker's Guide to the Galaxy")`.
+
+Depois **atribuímos esses dois valores** da tupla às variáveis `id` e `name`.
+
+Assim, se o usuário não fornecer um ID de item, ele ainda receberá uma sugestão aleatória.
+
+...fazemos tudo isso em **uma única linha simples**. 🤯 Você não ama Python? 🐍
+
+{* ../../docs_src/query_params_str_validations/tutorial015_an_py310.py ln[22:30] hl[29] *}
+
+## Recapitulando { #recap }
+
+Você pode declarar validações adicionais e metadados para seus parâmetros.
+
+Validações e metadados genéricos:
 
 * `alias`
 * `title`
 * `description`
 * `deprecated`
 
-Validações específicas para textos:
+Validações específicas para strings:
 
 * `min_length`
 * `max_length`
-* `regex`
+* `pattern`
 
-Nesses exemplos você viu como declarar validações em valores do tipo `str`.
+Validações personalizadas usando `AfterValidator`.
 
-Leia os próximos capítulos para ver como declarar validação de outros tipos, como números.
+Nestes exemplos você viu como declarar validações para valores `str`.
+
+Veja os próximos capítulos para aprender a declarar validações para outros tipos, como números.

docs/pt/docs/tutorial/query-params.md

@@ -1,4 +1,4 @@
-# Parâmetros de Consulta
+# Parâmetros de Consulta { #query-parameters }
 
 Quando você declara outros parâmetros na função que não fazem parte dos parâmetros da rota, esses parâmetros são automaticamente interpretados como parâmetros de "consulta".
 
@@ -28,7 +28,7 @@ Todo o processo que era aplicado para parâmetros de rota também é aplicado pa
 * Validação de dados
 * Documentação automática
 
-## Valores padrão
+## Valores padrão { #defaults }
 
 Como os parâmetros de consulta não são uma parte fixa da rota, eles podem ser opcionais e podem ter valores padrão.
 
@@ -57,7 +57,7 @@ Os valores dos parâmetros na sua função serão:
 * `skip=20`: Por que você definiu isso na URL
 * `limit=10`: Por que esse era o valor padrão
 
-## Parâmetros opcionais
+## Parâmetros opcionais { #optional-parameters }
 
 Da mesma forma, você pode declarar parâmetros de consulta opcionais, definindo o valor padrão para `None`:
 
@@ -65,13 +65,13 @@ Da mesma forma, você pode declarar parâmetros de consulta opcionais, definindo
 
 Nesse caso, o parâmetro da função `q` será opcional, e `None` será o padrão.
 
-/// check | Verificar
+/// check | Verifique
 
 Você também pode notar que o **FastAPI** é esperto o suficiente para perceber que o parâmetro da rota `item_id` é um parâmetro da rota, e `q` não é, portanto, `q` é o parâmetro de consulta.
 
 ///
 
-## Conversão dos tipos de parâmetros de consulta
+## Conversão dos tipos de parâmetros de consulta { #query-parameter-type-conversion }
 
 Você também pode declarar tipos `bool`, e eles serão convertidos:
 
@@ -109,7 +109,7 @@ http://127.0.0.1:8000/items/foo?short=yes
 
 ou qualquer outra variação (tudo em maiúscula, primeira letra em maiúscula, etc), a sua função vai ver o parâmetro `short` com um valor `bool` de `True`. Caso contrário `False`.
 
-## Múltiplos parâmetros de rota e consulta
+## Múltiplos parâmetros de rota e consulta { #multiple-path-and-query-parameters }
 
 Você pode declarar múltiplos parâmetros de rota e parâmetros de consulta ao mesmo tempo, o **FastAPI** vai saber o quê é o quê.
 
@@ -119,7 +119,7 @@ Eles serão detectados pelo nome:
 
 {* ../../docs_src/query_params/tutorial004_py310.py hl[6,8] *}
 
-## Parâmetros de consulta obrigatórios
+## Parâmetros de consulta obrigatórios { #required-query-parameters }
 
 Quando você declara um valor padrão para parâmetros que não são de rota (até agora, nós vimos apenas parâmetros de consulta), então eles não são obrigatórios.
 
@@ -141,16 +141,17 @@ http://127.0.0.1:8000/items/foo-item
 
 ```JSON
 {
-    "detail": [
-        {
-            "loc": [
-                "query",
-                "needy"
-            ],
-            "msg": "field required",
-            "type": "value_error.missing"
-        }
-    ]
+  "detail": [
+    {
+      "type": "missing",
+      "loc": [
+        "query",
+        "needy"
+      ],
+      "msg": "Field required",
+      "input": null
+    }
+  ]
 }
 ```
 
@@ -181,6 +182,6 @@ Nesse caso, existem 3 parâmetros de consulta:
 
 /// tip | Dica
 
-Você também poderia usar `Enum` da mesma forma que com [Path Parameters](path-params.md#valores-predefinidos){.internal-link target=_blank}.
+Você também poderia usar `Enum` da mesma forma que com [Path Parameters](path-params.md#predefined-values){.internal-link target=_blank}.
 
 ///

docs/pt/docs/tutorial/request-files.md

@@ -1,4 +1,4 @@
-# Arquivos de Requisição
+# Arquivos de Requisição { #request-files }
 
 Você pode definir arquivos para serem enviados pelo cliente usando `File`.
 
@@ -16,13 +16,13 @@ Isso é necessário, visto que os arquivos enviados são enviados como "dados de
 
 ///
 
-## Importe `File`
+## Importe `File` { #import-file }
 
 Importe `File` e `UploadFile` de `fastapi`:
 
 {* ../../docs_src/request_files/tutorial001_an_py39.py hl[3] *}
 
-## Definir Parâmetros `File`
+## Definir Parâmetros `File` { #define-file-parameters }
 
 Crie parâmetros de arquivo da mesma forma que você faria para `Body` ou `Form`:
 
@@ -50,7 +50,7 @@ Mantenha em mente que isso significa que todo o conteúdo será armazenado na me
 
 Mas há muitos casos em que você pode se beneficiar do uso de `UploadFile`.
 
-## Parâmetros de Arquivo com `UploadFile`
+## Parâmetros de Arquivo com `UploadFile` { #file-parameters-with-uploadfile }
 
 Defina um parâmetro de arquivo com um tipo de `UploadFile`:
 
@@ -66,12 +66,12 @@ Utilizar `UploadFile` tem várias vantagens sobre `bytes`:
 * Ele tem uma <a href="https://docs.python.org/3/glossary.html#term-file-like-object" class="external-link" target="_blank">file-like</a> interface `assíncrona`.
 * Ele expõe um objeto python <a href="https://docs.python.org/3/library/tempfile.html#tempfile.SpooledTemporaryFile" class="external-link" target="_blank">`SpooledTemporaryFile`</a> que você pode passar diretamente para outras bibliotecas que esperam um objeto semelhante a um arquivo("file-like").
 
-### `UploadFile`
+### `UploadFile` { #uploadfile }
 
 `UploadFile` tem os seguintes atributos:
 
 * `filename`: Uma `str` com o nome do arquivo original que foi enviado (por exemplo, `myimage.jpg`).
-* `content_type`: Uma `str` com o tipo de conteúdo (tipo MIME / tipo de mídia) (por exemplo, `image/jpeg`).
+* `content_type`: Uma `str` com o tipo de conteúdo (MIME type / media type) (por exemplo, `image/jpeg`).
 * `file`: Um <a href="https://docs.python.org/3/library/tempfile.html#tempfile.SpooledTemporaryFile" class="external-link" target="_blank">`SpooledTemporaryFile`</a> (um <a href="https://docs.python.org/3/glossary.html#term-file-like-object" class="external-link" target="_blank">file-like</a> objeto). Este é o objeto de arquivo Python que você pode passar diretamente para outras funções ou bibliotecas que esperam um objeto semelhante a um arquivo("file-like").
 
 `UploadFile` tem os seguintes métodos `assíncronos`. Todos eles chamam os métodos de arquivo correspondentes por baixo dos panos (usando o `SpooledTemporaryFile` interno).
@@ -105,11 +105,11 @@ Quando você usa os métodos `async`, o **FastAPI** executa os métodos de arqui
 
 /// note | Detalhes Técnicos do Starlette
 
-O `UploadFile` do ***FastAPI** herda diretamente do `UploadFile` do **Starlette** , mas adiciona algumas partes necessárias para torná-lo compatível com o **Pydantic** e as outras partes do FastAPI.
+O `UploadFile` do **FastAPI** herda diretamente do `UploadFile` do **Starlette**, mas adiciona algumas partes necessárias para torná-lo compatível com o **Pydantic** e as outras partes do FastAPI.
 
 ///
 
-## O que é "Form Data"
+## O que é "Form Data" { #what-is-form-data }
 
 O jeito que os formulários HTML (`<form></form>`) enviam os dados para o servidor normalmente usa uma codificação "especial" para esses dados, a qual é diferente do JSON.
 
@@ -117,15 +117,15 @@ O jeito que os formulários HTML (`<form></form>`) enviam os dados para o servid
 
 /// note | Detalhes Técnicos
 
-Dados de formulários normalmente são codificados usando o "media type" (tipo de mídia) `application/x-www-form-urlencoded` quando não incluem arquivos.
+Dados de formulários normalmente são codificados usando o "media type" `application/x-www-form-urlencoded` quando não incluem arquivos.
 
 Mas quando o formulário inclui arquivos, ele é codificado como `multipart/form-data`. Se você usar `File`, o **FastAPI** saberá que tem que pegar os arquivos da parte correta do corpo da requisição.
 
-Se você quiser ler mais sobre essas codificações e campos de formulário, vá para a <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/POST" class="external-link" target="_blank"><abbr title="Mozilla Developer Network">MDN</abbr> web docs para <code>POST</code></a>.
+Se você quiser ler mais sobre essas codificações e campos de formulário, vá para a <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/POST" class="external-link" target="_blank"><abbr title="Mozilla Developer Network – Rede de Desenvolvedores da Mozilla">MDN</abbr> web docs para <code>POST</code></a>.
 
 ///
 
-/// warning | Aviso
+/// warning | Atenção
 
 Você pode declarar múltiplos parâmetros `File` e `Form` em uma *operação de rota*, mas você não pode declarar campos `Body` que você espera receber como JSON, pois a requisição terá o corpo codificado usando `multipart/form-data` ao invés de `application/json`.
 
@@ -133,19 +133,19 @@ Isso não é uma limitação do **FastAPI**, é parte do protocolo HTTP.
 
 ///
 
-## Upload de Arquivo Opcional
+## Upload de Arquivo Opcional { #optional-file-upload }
 
 Você pode tornar um arquivo opcional usando anotações de tipo padrão e definindo um valor padrão de `None`:
 
 {* ../../docs_src/request_files/tutorial001_02_an_py310.py hl[9,17] *}
 
-## `UploadFile` com Metadados Adicionais
+## `UploadFile` com Metadados Adicionais { #uploadfile-with-additional-metadata }
 
 Você também pode usar `File()` com `UploadFile`, por exemplo, para definir metadados adicionais:
 
 {* ../../docs_src/request_files/tutorial001_03_an_py39.py hl[9,15] *}
 
-## Uploads de Múltiplos Arquivos
+## Uploads de Múltiplos Arquivos { #multiple-file-uploads }
 
 É possível realizar o upload de vários arquivos ao mesmo tempo.
 
@@ -165,12 +165,12 @@ Você pode também pode usar `from starlette.responses import HTMLResponse`.
 
 ///
 
-### Uploads de Múltiplos Arquivos com Metadados Adicionais
+### Uploads de Múltiplos Arquivos com Metadados Adicionais { #multiple-file-uploads-with-additional-metadata }
 
 Da mesma forma de antes, você pode usar `File()` para definir parâmetros adicionais, mesmo para `UploadFile`:
 
 {* ../../docs_src/request_files/tutorial003_an_py39.py hl[11,18:20] *}
 
-## Recapitulando
+## Recapitulando { #recap }
 
 Utilize `File`, `bytes` e `UploadFile` para declarar arquivos a serem enviados na requisição, enviados como dados de formulário.

docs/pt/docs/tutorial/request-form-models.md

@@ -1,4 +1,4 @@
-# Modelos de Formulários
+# Modelos de Formulários { #form-models }
 
 Você pode utilizar **Modelos Pydantic** para declarar **campos de formulários** no FastAPI.
 
@@ -20,7 +20,7 @@ Isto é suportado desde a versão `0.113.0` do FastAPI. 🤓
 
 ///
 
-## Modelos Pydantic para Formulários
+## Modelos Pydantic para Formulários { #pydantic-models-for-forms }
 
 Você precisa apenas declarar um **modelo Pydantic** com os campos que deseja receber como **campos de formulários**, e então declarar o parâmetro como um `Form`:
 
@@ -28,7 +28,7 @@ Você precisa apenas declarar um **modelo Pydantic** com os campos que deseja re
 
 O **FastAPI** irá **extrair** as informações para **cada campo** dos **dados do formulário** na requisição e dar para você o modelo Pydantic que você definiu.
 
-## Confira os Documentos
+## Confira os Documentos { #check-the-docs }
 
 Você pode verificar na UI de documentação em `/docs`:
 
@@ -36,7 +36,7 @@ Você pode verificar na UI de documentação em `/docs`:
 <img src="/img/tutorial/request-form-models/image01.png">
 </div>
 
-## Proibir Campos Extras de Formulários
+## Proibir Campos Extras de Formulários { #forbid-extra-form-fields }
 
 Em alguns casos de uso especiais (provavelmente não muito comum), você pode desejar **restringir** os campos do formulário para aceitar apenas os declarados no modelo Pydantic. E **proibir** qualquer campo **extra**.
 
@@ -73,6 +73,6 @@ Ele receberá um retorno de erro informando-o que o campo `extra` não é permit
 }
 ```
 
-## Resumo
+## Resumo { #summary }
 
 Você pode utilizar modelos Pydantic para declarar campos de formulários no FastAPI. 😎

docs/pt/docs/tutorial/request-forms-and-files.md

@@ -1,4 +1,4 @@
-# Formulários e Arquivos da Requisição
+# Formulários e Arquivos da Requisição { #request-forms-and-files }
 
 Você pode definir arquivos e campos de formulário ao mesmo tempo usando `File` e `Form`.
 
@@ -6,32 +6,36 @@ 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 <a href="https://github.com/Kludex/python-multipart" class="external-link" target="_blank">`python-multipart`</a>.
 
-Por exemplo: `pip install python-multipart`.
+Certifique-se de criar um [ambiente virtual](../virtual-environments.md){.internal-link target=_blank}, ativá-lo e então instalar, por exemplo:
+
+```console
+$ pip install python-multipart
+```
 
 ///
 
-## Importe `File` e `Form`
+## Importe `File` e `Form` { #import-file-and-form }
 
-{* ../../docs_src/request_forms_and_files/tutorial001.py hl[1] *}
+{* ../../docs_src/request_forms_and_files/tutorial001_an_py39.py hl[3] *}
 
-## Defina parâmetros de `File` e `Form`
+## Defina parâmetros de `File` e `Form` { #define-file-and-form-parameters }
 
 Crie parâmetros de arquivo e formulário da mesma forma que você faria para `Body` ou `Query`:
 
-{* ../../docs_src/request_forms_and_files/tutorial001.py hl[8] *}
+{* ../../docs_src/request_forms_and_files/tutorial001_an_py39.py hl[10:12] *}
 
 Os arquivos e campos de formulário serão carregados como dados de formulário e você receberá os arquivos e campos de formulário.
 
 E você pode declarar alguns dos arquivos como `bytes` e alguns como `UploadFile`.
 
-/// warning | Aviso
+/// warning | Atenção
 
 Você pode declarar vários parâmetros `File` e `Form` em uma *operação de caminho*, mas não é possível declarar campos `Body` para receber como JSON, pois a requisição terá o corpo codificado usando `multipart/form-data` ao invés de `application/json`.
 
-Isso não é uma limitação do **FastAPI** , é parte do protocolo HTTP.
+Isso não é uma limitação do **FastAPI**, é parte do protocolo HTTP.
 
 ///
 
-## Recapitulando
+## Recapitulando { #recap }
 
 Usar `File` e `Form` juntos quando precisar receber dados e arquivos na mesma requisição.

docs/pt/docs/tutorial/request-forms.md

@@ -1,12 +1,12 @@
-# Dados do formulário
+# Dados do formulário { #form-data }
 
-Quando você precisar receber campos de formulário ao invés de JSON, você pode usar `Form`.
+Quando você precisar receber campos de formulário em vez de JSON, você pode usar `Form`.
 
 /// info | Informação
 
 Para usar formulários, primeiro instale <a href="https://github.com/Kludex/python-multipart" class="external-link" target="_blank">`python-multipart`</a>.
 
-Lembre-se de criar um [ambiente virtual](../virtual-environments.md){.internal-link target=_blank}, ativá-lo e então instalar a dependência, por exemplo:
+Certifique-se de criar um [ambiente virtual](../virtual-environments.md){.internal-link target=_blank}, ativá-lo e então instalá-lo, por exemplo:
 
 ```console
 $ pip install python-multipart
@@ -14,23 +14,23 @@ $ pip install python-multipart
 
 ///
 
-## Importe `Form`
+## Importe `Form` { #import-form }
 
 Importe `Form` de `fastapi`:
 
-{* ../../docs_src/request_forms/tutorial001.py hl[1] *}
+{* ../../docs_src/request_forms/tutorial001_an_py39.py hl[3] *}
 
-## Declare parâmetros de `Form`
+## Defina parâmetros de `Form` { #define-form-parameters }
 
 Crie parâmetros de formulário da mesma forma que você faria para `Body` ou `Query`:
 
-{* ../../docs_src/request_forms/tutorial001.py hl[7] *}
+{* ../../docs_src/request_forms/tutorial001_an_py39.py hl[9] *}
 
 Por exemplo, em uma das maneiras que a especificação OAuth2 pode ser usada (chamada "fluxo de senha"), é necessário enviar um `username` e uma `password` como campos do formulário.
 
-A <abbr title="especificação">spec</abbr> exige que os campos sejam exatamente nomeados como `username` e `password` e sejam enviados como campos de formulário, não JSON.
+A <abbr title="specification – especificação">spec</abbr> exige que os campos sejam exatamente nomeados como `username` e `password` e sejam enviados como campos de formulário, não JSON.
 
-Com `Form` você pode declarar os mesmos metadados e validação que com `Body` (e `Query`, `Path`, `Cookie`).
+Com `Form` você pode declarar as mesmas configurações que com `Body` (e `Query`, `Path`, `Cookie`), incluindo validação, exemplos, um alias (por exemplo, `user-name` em vez de `username`), etc.
 
 /// info | Informação
 
@@ -44,30 +44,30 @@ Para declarar corpos de formulário, você precisa usar `Form` explicitamente, p
 
 ///
 
-## Sobre "Campos de formulário"
+## Sobre "Campos de formulário" { #about-form-fields }
 
 A forma como os formulários HTML (`<form></form>`) enviam os dados para o servidor normalmente usa uma codificação "especial" para esses dados, é diferente do JSON.
 
 O **FastAPI** fará a leitura desses dados no lugar certo em vez de JSON.
 
-/// note | Detalhes técnicos
+/// note | Detalhes Técnicos
 
-Os dados dos formulários são normalmente codificados usando o "tipo de mídia" `application/x-www-form-urlencoded`.
+Os dados dos formulários são normalmente codificados usando o "media type" `application/x-www-form-urlencoded`.
 
- Mas quando o formulário inclui arquivos, ele é codificado como `multipart/form-data`. Você lerá sobre como lidar com arquivos no próximo capítulo.
+Mas quando o formulário inclui arquivos, ele é codificado como `multipart/form-data`. Você lerá sobre como lidar com arquivos no próximo capítulo.
 
-Se você quiser ler mais sobre essas codificações e campos de formulário, vá para o <a href="https://developer.mozilla.org/pt-BR/docs/Web/HTTP/Methods/POST" class="external-link" target="_blank"><abbr title="Mozilla Developer Network">MDN</abbr> web docs para <code>POST</code></a>.
+Se você quiser ler mais sobre essas codificações e campos de formulário, vá para o <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/POST" class="external-link" target="_blank"><abbr title="Mozilla Developer Network – Rede de Desenvolvedores da Mozilla">MDN</abbr> web docs para <code>POST</code></a>.
 
 ///
 
-/// warning | Aviso
+/// warning | Atenção
 
-Você pode declarar vários parâmetros `Form` em uma *operação de caminho*, mas não pode declarar campos `Body` que espera receber como JSON, pois a solicitação terá o corpo codificado usando `application/x-www- form-urlencoded` em vez de `application/json`.
+Você pode declarar vários parâmetros `Form` em uma *operação de rota*, mas não pode declarar campos `Body` que espera receber como JSON, pois a requisição terá o corpo codificado usando `application/x-www-form-urlencoded` em vez de `application/json`.
 
-Esta não é uma limitação do **FastAPI**, é parte do protocolo HTTP.
+Isso não é uma limitação do **FastAPI**, é parte do protocolo HTTP.
 
 ///
 
-## Recapitulando
+## Recapitulando { #recap }
 
 Use `Form` para declarar os parâmetros de entrada de dados de formulário.