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á.

# Criação de um aplicativo simples usando o AWS SDK para Rust
<a name="hello"></a>

Você pode começar rapidamente com o AWS SDK for Rust seguindo este tutorial para criar um aplicativo simples que chama um. AWS service (Serviço da AWS)

## Pré-requisitos
<a name="prerequisites"></a>

Para usar oAWS 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:
<a name="recommended-tools"></a>

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).

## Criar sua primeira aplicação do SDK
<a name="hello-world"></a>

Esse procedimento cria sua primeira aplicação do SDK para Rust que lista suas tabelas do DynamoDB.

1. Em uma janela de terminal ou console, navegue até o local no computador em que deseja criar a aplicação.

1. Insira o comando a seguir para criar um diretório `hello_world` e preenchê-lo com um projeto básico do Rust:

   ```
   $ cargo new hello_world --bin
   ```

1. Navegue até o diretório `hello_world` e use o seguinte comando para adicionar as dependências necessárias à aplicação:

   ```
   $ cargo add aws-config aws-sdk-dynamodb tokio --features tokio/full,aws-config/credentials-login
   ```

   Essas dependências incluem as caixas do SDK que fornecem recursos de configuração e suporte para o DynamoDB, incluindo a [caixa `tokio`](https://crates.io/crates/tokio) usada para implementar operações de E/S assíncronas.
**nota**  
A menos que você use um recurso como o `tokio/full`, o Tokio, não fornecerá um runtime assíncrono. O SDK para Rust requer um runtime assíncrono.  
O `aws-config/credentials-login` recurso permite o suporte às credenciais de login do AWS Management Console. Consulte [Autenticação e acesso no AWS SDKs Guia de referência de ferramentas](https://docs.aws.amazon.com/sdkref/latest/guide/access.html) para obter mais informações.

1. Atualize `main.rs` no diretório `src` para conter o código a seguir.

   ```
   use aws_config::meta::region::RegionProviderChain;
   use aws_config::BehaviorVersion;
   use aws_sdk_dynamodb::{Client, Error};
   
   /// Lists your DynamoDB tables in the default Region or us-east-1 if a default Region isn't set.
   #[tokio::main]
   async fn main() -> Result<(), Error> {
       let region_provider = RegionProviderChain::default_provider().or_else("us-east-1");
       let config = aws_config::defaults(BehaviorVersion::latest())
           .region(region_provider)
           .load()
           .await;
       let client = Client::new(&config);
   
       let resp = client.list_tables().send().await?;
   
       println!("Tables:");
   
       let names = resp.table_names();
   
       for name in names {
           println!("  {}", name);
       }
   
       println!();
       println!("Found {} tables", names.len());
   
       Ok(())
   }
   ```
**nota**  
Esse exemplo exibe apenas a primeira página de resultados. Consulte [Usar resultados paginados no AWS SDK para Rust](paginating.md) para saber como lidar com várias páginas de resultados. 

1. Execute o programa:

   ```
   $ cargo run
   ```

   Você deve ver uma lista com os nomes das suas tabelas.