Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Creazione di una semplice applicazione utilizzando l'AWSSDK per Rust
<a name="hello"></a>

Puoi iniziare rapidamente a usare AWS SDK for Rust seguendo questo tutorial per creare una semplice applicazione che chiama unServizio AWS.

## Prerequisiti
<a name="prerequisites"></a>

Per poter utilizzareAWS SDK per Rust, devi avere installato Rust e Cargo.
+ Installa la toolchain Rust: [https://www.rust-lang. org/tools/install](https://www.rust-lang.org/tools/install)
+ Installa lo `cargo-component` [strumento](https://github.com/bytecodealliance/cargo-component) eseguendo il comando: `cargo install cargo-component`

### Strumenti consigliati:
<a name="recommended-tools"></a>

I seguenti strumenti opzionali possono essere installati nell'IDE per facilitare il completamento del codice e la risoluzione dei problemi.
+ L'estensione rust-analyzer, vedi [Rust in Visual](https://code.visualstudio.com/docs/languages/rust) Studio Code.
+ Amazon Q Developer, consulta [Installazione dell'estensione o del plug-in Amazon Q Developer nel tuo IDE](https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/q-in-IDE-setup.html).

## Crea la tua prima app SDK
<a name="hello-world"></a>

Questa procedura crea la prima applicazione SDK per Rust che elenca le tabelle DynamoDB.

1. In una finestra del terminale o della console, accedete alla posizione del computer in cui desiderate creare l'app.

1. Esegui il seguente comando per creare una `hello_world` directory e popolarla con uno scheletro progetto Rust:

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

1. Naviga nella `hello_world` directory e usa il seguente comando per aggiungere le dipendenze richieste all'app:

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

   Queste dipendenze includono le casse SDK che forniscono funzionalità di configurazione e supporto per DynamoDB, inclusa la [`tokio`cassa, utilizzata per implementare operazioni di I/O asincrone](https://crates.io/crates/tokio).
**Nota**  
A meno che non si utilizzi una funzionalità come Tokio non fornirà un runtime asincrono. `tokio/full` L'SDK per Rust richiede un runtime asincrono.  
La `aws-config/credentials-login` funzionalità abilita il supporto per le credenziali di accesso alla Console di AWS gestione. Per ulteriori informazioni, consulta [Autenticazione e accesso nella Guida di riferimento agli strumenti AWS SDKs e agli strumenti](https://docs.aws.amazon.com/sdkref/latest/guide/access.html).

1. Aggiorna la `src` directory `main.rs` in modo che contenga il codice seguente.

   ```
   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**  
Questo esempio visualizza solo la prima pagina dei risultati. Scopri come gestire più pagine di risultati. [Utilizzo dei risultati impaginati nell' AWS SDK per Rust](paginating.md) 

1. Esegui il programma:

   ```
   $ cargo run
   ```

   Dovresti vedere un elenco dei nomi delle tue tabelle.