🌐 Add Portuguese translation for `docs/pt/docs/tutorial/cors.md` and `docs/pt/docs/tutorial/middleware.md` (#11916)

docs/pt/docs/tutorial/cors.md

@@ -0,0 +1,84 @@
+# 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
+
+Uma origem é a combinação de protocolo (`http`, `https`), domínio (`myapp.com`, `localhost`, `localhost.tiangolo.com`), e porta (`80`, `443`, `8080`).
+
+Então, todos estes são origens diferentes:
+
+* `http://localhost`
+* `https://localhost`
+* `http://localhost:8080`
+
+Mesmo se todos estiverem em `localhost`, eles usam diferentes protocolos e portas, portanto, são "origens" diferentes.
+
+## Passos
+
+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.
+
+Para conseguir isso, o backend deve ter uma lista de "origens permitidas".
+
+Neste caso, ele terá que incluir `http://localhost:8080` para o frontend funcionar corretamente.
+
+## Curingas
+
+É possível declarar uma lista com `"*"` (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`
+
+Você pode configurá-lo em sua aplicação **FastAPI** usando o `CORSMiddleware`.
+
+* Importe `CORSMiddleware`.
+* Crie uma lista de origens permitidas (como strings).
+* Adicione-a como um "middleware" à sua aplicação **FastAPI**.
+
+Você também pode especificar se o seu backend permite:
+
+* Credenciais (Cabeçalhos de autorização, Cookies, etc).
+* Métodos HTTP específicos (`POST`, `PUT`) ou todos eles com o curinga `"*"`.
+* Cabeçalhos HTTP específicos ou todos eles com o curinga `"*"`.
+
+```Python hl_lines="2  6-11  13-19"
+{!../../../docs_src/cors/tutorial001.py!}
+```
+
+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 seguintes argumentos são suportados:
+
+* `allow_origins` - Uma lista de origens que devem ter permissão para fazer requisições de origem cruzada. Por exemplo, `['https://example.org', 'https://www.example.org']`. Você pode usar `['*']` para permitir qualquer origem.
+* `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.
+* `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)
+
+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
+
+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
+
+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>.
+
+!!! note "Detalhes técnicos"
+    Você também pode usar `from starlette.middleware.cors import CORSMiddleware`.
+
+    **FastAPI** fornece vários middlewares em `fastapi.middleware` apenas como uma conveniência para você, o desenvolvedor. Mas a maioria dos middlewares disponíveis vêm diretamente da Starlette.

docs/pt/docs/tutorial/middleware.md

@@ -0,0 +1,61 @@
+# Middleware
+
+Você pode adicionar middleware à suas aplicações **FastAPI**.
+
+Um "middleware" é uma função que manipula cada **requisição** antes de ser processada por qualquer *operação de rota* específica. E também cada **resposta** antes de retorná-la.
+
+* Ele pega cada **requisição** que chega ao seu aplicativo.
+* Ele pode então fazer algo com essa **requisição** ou executar qualquer código necessário.
+* Então ele passa a **requisição** para ser processada pelo resto do aplicativo (por alguma *operação de rota*).
+* Ele então pega a **resposta** gerada pelo aplicativo (por alguma *operação de rota*).
+* Ele pode fazer algo com essa **resposta** ou executar qualquer código necessário.
+* Então ele retorna a **resposta**.
+
+!!! note "Detalhes técnicos"
+    Se você tiver dependências com `yield`, o código de saída será executado *depois* do middleware.
+
+    Se houver alguma tarefa em segundo plano (documentada posteriormente), ela será executada *depois* de todo o middleware.
+
+## Criar um middleware
+
+Para criar um middleware, use o decorador `@app.middleware("http")` logo acima de uma função.
+
+A função middleware recebe:
+
+* A `request`.
+* Uma função `call_next` que receberá o `request` como um parâmetro.
+    * Esta função passará a `request` para a *operação de rota* correspondente.
+    * Então ela retorna a `response` gerada pela *operação de rota* correspondente.
+* Você pode então modificar ainda mais o `response` antes de retorná-lo.
+
+```Python hl_lines="8-9  11  14"
+{!../../../docs_src/middleware/tutorial001.py!}
+```
+
+!!! 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>.
+
+    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.io/middleware/#corsmiddleware" class="external-link" target="_blank">Documentos CORS da Starlette</a>.
+
+!!! note "Detalhes técnicos"
+    Você também pode usar `from starlette.requests import Request`.
+
+    **FastAPI** fornece isso como uma conveniência para você, o desenvolvedor. Mas vem diretamente da Starlette.
+
+### Antes e depois da `response`
+
+Você pode adicionar código para ser executado com a `request`, antes que qualquer *operação de rota* o receba.
+
+E também depois que a `response` é gerada, antes de retorná-la.
+
+Por exemplo, você pode adicionar um cabeçalho personalizado `X-Process-Time` contendo o tempo em segundos que levou para processar a solicitação e gerar uma resposta:
+
+```Python hl_lines="10  12-13"
+{!../../../docs_src/middleware/tutorial001.py!}
+```
+
+## Outros 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}.
+
+Você lerá sobre como manipular <abbr title="Cross-Origin Resource Sharing">CORS</abbr> com um middleware na próxima seção.