mirror
/
tiangolo.fastapi
mirror of https://github.com/tiangolo/fastapi
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

validated llm translation

pull/14228/head
Rafael de Oliveira Marques 9 months ago
parent
0b14db02ae
commit
edd3f4995f
1 changed files with 33 additions and 33 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 66
      docs/pt/docs/tutorial/bigger-applications.md

66
docs/pt/docs/tutorial/bigger-applications.md
View File

@ -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`
### Importar `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.
@ -137,7 +137,7 @@ Agora usaremos uma dependência simples para ler um cabeçalho `X-Token` persona
////
//// tab | Python 3.8+ non-Annotated
//// tab | Python 3.8+ não anotado
/// tip | Dica
@ -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
### Importar 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`
### Incluir o `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`
### Incluir 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*
### Incluir 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
/// info | Detalhes Muito Técnicos
**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
## Incluir 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
## Incluir 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:

Write Preview
Loading…
Cancel
Save