As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Fundamentos para o AWS SDK para Rust
Aprenda os fundamentos da programação com o AWS SDK para Rust, como: fundamentos da linguagem de programação Rust, informações sobre o SDK para caixas Rust, configuração do projeto e o uso do tempo de execução Tokio pelo SDK for Rust.
## Pré-requisitos
Para usar o AWS SDK para Rust, você deve ter o Rust and Cargo instalado.
+ [Instale o conjunto de ferramentas Rust: https://www.rust-lang. org/tools/install](https://www.rust-lang.org/tools/install)
+ Instale a [ferramenta](https://github.com/bytecodealliance/cargo-component) `cargo-component` executando o comando: `cargo install cargo-component`
### Ferramentas recomendadas:
As seguintes ferramentas opcionais podem ser instaladas em seu IDE para ajudar no preenchimento de código e na solução de problemas.
+ A extensão rust-analyzer, consulte [Rust in Visual Studio Code](https://code.visualstudio.com/docs/languages/rust).
+ Amazon Q Developer, consulte [Instalar a extensão ou o plug-in Amazon Q Developer em seu IDE](https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/q-in-IDE-setup.html).
## Fundamentos do Rust
A seguir estão alguns princípios básicos da linguagem de programação Rust que seria útil conhecer. Todas as referências para obter mais informações vêm da [linguagem de programação Rust](https://doc.rust-lang.org/book/title-page.html#the-rust-programming-language).
+ `Cargo.toml` é o arquivo de configuração padrão do projeto Rust, ele contém as dependências e alguns metadados sobre o projeto. Os arquivos de origem do Rust têm uma extensão de arquivo `.rs`. Consulte [Hello, Cargo\$1](https://doc.rust-lang.org/book/ch01-03-hello-cargo.html).
+ O `Cargo.toml` pode ser personalizado com perfis, consulte [Customizing Builds with Release Profiles](https://doc.rust-lang.org/book/ch14-01-release-profiles.html). Esses perfis são completamente independentes e independentes AWS do uso de perfis no AWS `config` arquivo compartilhado.
+ Uma forma comum de adicionar dependências de biblioteca ao seu projeto e a esse arquivo é usar `cargo add`. Consulte [https://doc.rust-lang.org/cargo/commands/cargo-add.html](https://doc.rust-lang.org/cargo/commands/cargo-add.html).
+ O Rust tem uma estrutura funcional básica como a exibida a seguir. A palavra-chave `let` declara uma variável e pode ser combinada com a atribuição (=). Se você não especificar um tipo depois de `let`, o compilador inferirá um. Consulte [Variables and Mutability](https://doc.rust-lang.org/book/ch03-01-variables-and-mutability.html).
```
fn main() {
let w = "world";
println!("Hello {}!", w);
}
```
+ Para declarar uma variável `x` com um tipo explícito `T`, o Rust usa a sintaxe `x: T`. Consulte [Tipos de dados](https://doc.rust-lang.org/book/ch03-02-data-types.html).
+ `struct X {}` define o novo tipo `X`. Os métodos são implementados no tipo `X` de estrutura personalizada. Os métodos de tipo `X` são declarados com blocos de implementação prefixados com a palavra-chave `impl`. Dentro do bloco de implementação, `self` refere-se à instância da estrutura na qual o método foi chamado. Consulte [Keyword `impl`](https://doc.rust-lang.org/std/keyword.impl.html) and [Method Syntax](https://doc.rust-lang.org/book/ch05-03-method-syntax.html).
+ Se for um ponto de exclamação (“\$1”) segue o que parece ser uma definição de função ou chamada de função e, em seguida, o código está definindo ou chamando uma macro. Consulte [Macros](https://doc.rust-lang.org/book/ch19-06-macros.html?highlight=macro#macros).
+ No Rust, os erros irrecuperáveis são representados pela macro `panic!`. Quando um programa encontra um `panic!`, ele para de ser executado, imprime uma mensagem de falha, desenrola, limpa a pilha e sai. Consulte [Unrecoverable Errors with `panic!`](https://doc.rust-lang.org/book/ch09-01-unrecoverable-errors-with-panic.html).
+ O Rust não é compatível com a herança de funcionalidades de classes de base, como outras linguagens de programação. `traits` é como o Rust fornece a sobrecarga de métodos. As características podem ser consideradas conceitualmente semelhantes a uma interface. No entanto, características e interfaces verdadeiras têm diferenças e geralmente são usadas de modo diferente no processo de design. Consulte [Traits: Defining Shared Behavior](https://doc.rust-lang.org/book/ch10-02-traits.html).
+ Polimorfismo se refere ao código que oferece suporte à funcionalidade de vários tipos de dados sem precisar escrever cada um individualmente. O Rust é compatível com polimorfismo por enumerações, características e genéricos. Consulte [Inheritance as a Type System and as Code Sharing](https://doc.rust-lang.org/book/ch17-01-what-is-oo.html?#inheritance-as-a-type-system-and-as-code-sharing).
+ Rust é muito explícito sobre memória. Os ponteiros inteligentes “são estruturas de dados que agem como um ponteiro, mas também têm metadados e recursos adicionais”. Consulte [Smart Pointers](https://doc.rust-lang.org/book/ch15-00-smart-pointers.html).
+ O tipo `Cow` é um ponteiro clone-on-write inteligente que ajuda a transferir a propriedade da memória para o chamador quando necessário. Consulte [https://doc.rust-lang.org/std/borrow/enum.Cow.html](https://doc.rust-lang.org/std/borrow/enum.Cow.html).
+ O tipo `Arc` é um ponteiro inteligente com contagem de referência atômica que conta as instâncias alocadas. Consulte [https://doc.rust-lang.org/std/sync/struct.Arc.html](https://doc.rust-lang.org/std/sync/struct.Arc.html).
+ O SDK para Rust frequentemente usa o padrão builder para criar tipos complexos.
## AWS SDK para Rust fundamentos da criação
+ A caixa principal da funcionalidade do SDK para Rust é `aws-config`. Isso está incluído na maioria dos projetos porque fornece funcionalidade para ler a configuração do ambiente.
```
$ cargo add aws-config
```
+ Não confunda isso com o AWS service (Serviço da AWS) que é chamado AWS Config. Por se tratar de um serviço, ele segue a convenção padrão de AWS service (Serviço da AWS) caixas e é chamado`aws-sdk-config`.
+ A biblioteca SDK para Rust é separada em caixas de biblioteca diferentes por cada uma. AWS service (Serviço da AWS) Essas caixas estão disponíveis em [https://docs.rs/](https://docs.rs/).
+ AWS service (Serviço da AWS) as caixas seguem a convenção de nomenclatura de`aws-sdk-[servicename]`, como e. `aws-sdk-s3` `aws-sdk-dynamodb`
## Configuração do projeto para trabalhar com Serviços da AWS
+ Você precisará adicionar uma caixa ao seu projeto para cada uma AWS service (Serviço da AWS) que você deseja que seu aplicativo use.
+ A forma recomendada de adicionar uma caixa é usando a linha de comando no diretório do seu projeto executando `cargo add [crateName]`, como `cargo add aws-sdk-s3`.
+ Isso adicionará uma linha ao item `Cargo.toml` abaixo do seu projeto`[dependencies]`.
+ Por padrão, isso adicionará a versão mais recente da caixa ao seu projeto.
+ Em seu arquivo de origem, use a declaração `use` para trazer itens de suas caixas para o escopo. Consulte [Using External Packages](https://doc.rust-lang.org/book/ch07-04-bringing-paths-into-scope-with-the-use-keyword.html#using-external-packages) do site da linguagem de programação Rust Programming Language.
+ Os nomes das caixas geralmente são hifenizados, mas os hifens são convertidos em sublinhados ao realmente usar a caixa. Por exemplo, a caixa do `aws-config` é usada na instrução `use` de código como `use aws_config`.
+ A configuração é um tópico complexo. A configuração pode ocorrer diretamente no código ou ser especificada externamente em variáveis de ambiente ou arquivos de configuração. Para obter mais informações, consulte [Configurar clientes do serviço AWS SDK para Rust externamente](config-external.md).
+ Quando o SDK carrega sua configuração, valores inválidos são registrados em vez de interromper a execução porque a maioria das configurações tem padrões razoáveis. Para aprender a habilitar o registro em logs, consulte [Configurar e usar o registro em log no AWS SDK para Rust](logging.md).
+ A maioria das variáveis de ambiente e configurações do arquivo de configuração são carregadas uma vez quando o programa é iniciado. Todas as atualizações nos valores não serão vistas até que você reinicie o programa.
## Runtime do Tokio
+ O Tokio é um runtime assíncrono para a linguagem de programação SDK para Rust que executa as tarefas `async`. Consulte [tokio.rs](http://tokio.rs/) e [docs.rs/tokio](http://docs.rs/tokio).
+ O SDK para Rust requer um runtime assíncrono. Recomendamos que você adicione a caixa a seguir aos seus projetos:
```
$ cargo add tokio --features=full
```
+ A macro de atributos `tokio::main` cria um ponto de entrada principal assíncrono para seu programa. Para usar essa macro, adicione-a à linha antes do método `main`, conforme mostrado a seguir:
```
#[tokio::main]
async fn main() -> Result<(), Error> {
```