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à.
# Guida introduttiva all'SDK per Rust
Scopri come installare, configurare e utilizzare l'SDK per creare un'applicazione Rust per accedere a una AWS risorsa a livello di codice.
**Topics**
+ [Autenticazione con AWS](credentials.md)
+ [Creazione di una semplice applicazione](hello.md)
+ [Nozioni fondamentali](fundamentals.md)
# Autenticazione con l'AWSutilizzo di AWS SDK per Rust
È necessario stabilire in che modo il codice si autentica AWS durante lo sviluppo con. Servizi AWS È possibile configurare l'accesso programmatico alle AWS risorse in diversi modi a seconda dell'ambiente e dell'AWSaccesso a disposizione.
Per scegliere il metodo di autenticazione e configurarlo per l'SDK, consulta [Autenticazione e accesso](https://docs.aws.amazon.com/sdkref/latest/guide/access.html) nella Guida di *riferimento agli strumenti AWS SDKs e agli strumenti*.
Consigliamo ai nuovi utenti che si stanno sviluppando localmente e che non dispongono di un metodo di autenticazione da parte del datore di lavoro di AWS IAM Identity Center configurarlo. Questo metodo include l'installazione di AWS CLI per facilitare la configurazione e per accedere regolarmente al portale di AWS accesso.
Se scegli questo metodo, completa la procedura per l'[accesso per lo sviluppo AWS locale utilizzando le credenziali della console](https://docs.aws.amazon.com/sdkref/latest/guide/access-login.html) nella *Guida di riferimento AWS SDKs e agli strumenti*. Successivamente, l'ambiente dovrebbe contenere i seguenti elementi:
+ IlAWS CLI, che viene utilizzato per avviare una sessione del portale di AWS accesso prima di eseguire l'applicazione.
+ Un [AWS`config`file condiviso](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) con un `[default]` profilo con un set di valori di configurazione a cui è possibile fare riferimento dall'SDK. Per trovare la posizione di questo file, consulta [Posizione dei file condivisi nella Guida](https://docs.aws.amazon.com/sdkref/latest/guide/file-location.html) di *riferimento agli strumenti AWS SDKs e strumenti*.
+ Il `config` file condiviso imposta l'[https://docs.aws.amazon.com/sdkref/latest/guide/feature-region.html](https://docs.aws.amazon.com/sdkref/latest/guide/feature-region.html)impostazione. Questo imposta l'impostazione predefinita Regione AWS utilizzata dall'SDK per AWS le richieste. Questa regione viene utilizzata per le richieste di servizio SDK che non sono specificate con una regione da utilizzare.
+ L'SDK utilizza la configurazione del [provider di credenziali di accesso](https://docs.aws.amazon.com/sdkref/latest/guide/feature-login-credentials.html) del profilo per acquisire le credenziali prima di inviare richieste a. AWS Il `login_session` valore, che memorizza l'identità della sessione della console di gestione selezionata durante il flusso di lavoro di accesso, consente l'accesso ai AWS servizi utilizzati nell'applicazione.
Il seguente `config` file di esempio mostra un profilo predefinito impostato con la sessione della console di configurazione del provider di credenziali di accesso selezionata durante il flusso di lavoro di accesso. L'`login_session`impostazione del profilo si riferisce alla sessione di console denominata selezionata durante il flusso di lavoro:
```
[default]
login_session = arn:aws:iam::0123456789012:user/username
region = us-east-1
```
**Nota**
È necessario abilitare la `credentials-login` funzionalità della `aws-config` cassa per utilizzare questo provider di credenziali.
## Ulteriori informazioni di autenticazione
Utenti umani, noti anche come *identità umane,* sono le persone, gli amministratori, gli sviluppatori, gli operatori e i consumatori delle tue applicazioni. Devono avere un'identità per accedere agli AWS ambienti e alle applicazioni dell'utente. Gli utenti umani che fanno parte della tua organizzazione, ovvero tu, lo sviluppatore, sono noti come *identità della forza lavoro*.
Utilizza credenziali temporanee per l'accesso. AWS Puoi utilizzare un provider di identità per i tuoi utenti umani per fornire l'accesso federato agli AWS account assumendo ruoli che forniscono credenziali temporanee. Per la gestione centralizzata degli accessi, ti consigliamo di utilizzare AWS IAM Identity Center (IAM Identity Center) per gestire l'accesso ai tuoi account e le autorizzazioni all'interno di tali account. Per altre alternative, consulta quanto segue:
+ Per ulteriori informazioni sulle best practice, consulta [Best practice per la sicurezza in IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) nella *Guida per l'utente di IAM*.
+ Per creare AWS credenziali a breve termine, consulta [Temporary Security Credentials](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html) nella *IAM User Guide*.
+ *Per ulteriori informazioni sugli altri provider di credenziali supportati da SDK for Rust, consulta Fornitori di [credenziali standardizzati nella and Tools Reference Guide](https://docs.aws.amazon.com/sdkref/latest/guide/standardized-credentials.html). AWS SDKs *
# Creazione di una semplice applicazione utilizzando l'AWSSDK per Rust
Puoi iniziare rapidamente a usare AWS SDK for Rust seguendo questo tutorial per creare una semplice applicazione che chiama unServizio AWS.
## Prerequisiti
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:
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
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.
# Fondamenti per AWS SDK per Rust
Scopri i fondamenti della programmazione con AWS SDK per Rust, ad esempio: i fondamenti del linguaggio di programmazione Rust, informazioni su SDK for Rust crates, configurazione del progetto e SDK per l'uso del runtime Tokio da parte di Rust.
## Prerequisiti
Per poter utilizzare, devi avere installato Rust e AWS SDK per Rust 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:
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).
## Nozioni di base su Rust
Di seguito sono riportate alcune nozioni di base del linguaggio di programmazione Rust che sarebbe utile conoscere. Tutti i riferimenti per ulteriori informazioni provengono da [The Rust Programming Language](https://doc.rust-lang.org/book/title-page.html#the-rust-programming-language).
+ `Cargo.toml`è il file di configurazione standard del progetto Rust, contiene le dipendenze e alcuni metadati sul progetto. I file sorgente di Rust hanno un'`.rs`estensione di file. Vedi [Hello, Cargo\$1](https://doc.rust-lang.org/book/ch01-03-hello-cargo.html) .
+ `Cargo.toml`Possono essere personalizzati con profili, vedere [Personalizzazione delle build con profili di rilascio](https://doc.rust-lang.org/book/ch14-01-release-profiles.html). Questi profili sono completamente indipendenti e indipendenti dall' AWS uso dei profili all'interno del file condiviso. AWS `config`
+ Un modo comune per aggiungere dipendenze di libreria al progetto e a questo file consiste nell'utilizzare. `cargo add` Per informazioni, consulta [https://doc.rust-lang.org/cargo/commands/cargo-add.html](https://doc.rust-lang.org/cargo/commands/cargo-add.html).
+ Rust ha una struttura funzionale di base come la seguente. La `let` parola chiave dichiara una variabile e potrebbe essere abbinata a assignment (=). Se non si specifica un tipo dopo`let`, il compilatore ne dedurrà uno. Vedi [Variabili e mutabilità.](https://doc.rust-lang.org/book/ch03-01-variables-and-mutability.html)
```
fn main() {
let w = "world";
println!("Hello {}!", w);
}
```
+ Per dichiarare una variabile `x` con un tipo esplicito`T`, Rust utilizza la sintassi. `x: T` [Vedi Tipi di dati.](https://doc.rust-lang.org/book/ch03-02-data-types.html)
+ `struct X {}`definisce il nuovo tipo`X`. I metodi sono implementati sul tipo di struttura personalizzato`X`. I metodi per il tipo `X` sono dichiarati con blocchi di implementazione preceduti da una parola chiave`impl`. All'interno del blocco di implementazione, `self` si riferisce all'istanza della struttura su cui è stato chiamato il metodo. Vedi [Sintassi `impl` delle [parole chiave](https://doc.rust-lang.org/std/keyword.impl.html) e del metodo](https://doc.rust-lang.org/book/ch05-03-method-syntax.html).
+ Se è un punto esclamativo («\$1») segue quella che sembra essere una definizione di funzione o una chiamata di funzione, quindi il codice definisce o chiama una macro. Vedi [Macro](https://doc.rust-lang.org/book/ch19-06-macros.html?highlight=macro#macros).
+ In Rust, gli errori irreversibili sono rappresentati dalla macro. `panic!` Quando un programma incontra una, smette di funzionare, stampa un messaggio di errore, si riavvia, pulisce `panic!` lo stack e si chiude. [Vedi Errori irrecuperabili con. `panic!`](https://doc.rust-lang.org/book/ch09-01-unrecoverable-errors-with-panic.html)
+ Rust non supporta l'ereditarietà delle funzionalità dalle classi base come fanno gli altri linguaggi di programmazione; è così che Rust fornisce il `traits` sovraccarico dei metodi. Si potrebbe pensare che i tratti siano concettualmente simili a un'interfaccia. Tuttavia, le caratteristiche e le interfacce reali presentano differenze e vengono spesso utilizzate in modo diverso nel processo di progettazione. Vedi [Tratti: definizione del comportamento condiviso](https://doc.rust-lang.org/book/ch10-02-traits.html).
+ Il polimorfismo si riferisce al codice che supporta funzionalità per più tipi di dati senza doverli scrivere singolarmente. Rust supporta il polimorfismo tramite enumerazioni, tratti e generici. Vedi [Ereditarietà come sistema di tipi e come condivisione di codice](https://doc.rust-lang.org/book/ch17-01-what-is-oo.html?#inheritance-as-a-type-system-and-as-code-sharing).
+ Rust è molto esplicito sulla memoria. I puntatori intelligenti «sono strutture di dati che agiscono come un puntatore ma hanno anche metadati e funzionalità aggiuntivi». [Vedi Smart Pointers.](https://doc.rust-lang.org/book/ch15-00-smart-pointers.html)
+ Il tipo `Cow` è un puntatore clone-on-write intelligente che aiuta a trasferire la proprietà della memoria al chiamante quando necessario. Per informazioni, consulta [https://doc.rust-lang.org/std/borrow/enum.Cow.html](https://doc.rust-lang.org/std/borrow/enum.Cow.html).
+ Il tipo `Arc` è un puntatore intelligente Atomically Reference Counted che conta le istanze allocate. Per informazioni, consulta [https://doc.rust-lang.org/std/sync/struct.Arc.html](https://doc.rust-lang.org/std/sync/struct.Arc.html).
+ L'SDK per Rust utilizza spesso il pattern builder per costruire tipi complessi.
## AWS SDK per Rust crea i fondamenti
+ Il core crate principale per la funzionalità SDK for Rust è. `aws-config` È inclusa nella maggior parte dei progetti perché fornisce funzionalità per leggere la configurazione dall'ambiente.
```
$ cargo add aws-config
```
+ Non confondetelo con Servizio AWS quello che viene chiamato AWS Config. Poiché si tratta di un servizio, segue la convenzione standard delle Servizio AWS casse e viene chiamato. `aws-sdk-config`
+ La libreria SDK for Rust è suddivisa in diverse casse di libreria ciascuna. Servizio AWS[Queste casse sono disponibili all'indirizzo https://docs.rs/.](https://docs.rs/)
+ Servizio AWS le casse seguono la convenzione di denominazione di`aws-sdk-[servicename]`, ad esempio e. `aws-sdk-s3` `aws-sdk-dynamodb`
## Configurazione del progetto con cui lavorare Servizi AWS
+ Dovrai aggiungere una cassa al tuo progetto per ogni cassa Servizio AWS che desideri venga utilizzata dall'applicazione.
+ Il modo consigliato per aggiungere una cassa è utilizzare la riga di comando nella directory del progetto eseguendo`cargo add [crateName]`, ad esempio. `cargo add aws-sdk-s3`
+ Questo aggiungerà una riga nella parte `Cargo.toml` inferiore `[dependencies]` del progetto.
+ Per impostazione predefinita, questo aggiungerà la versione più recente della cassa al tuo progetto.
+ Nel file sorgente, utilizzate l'`use`istruzione per inserire gli oggetti contenuti nelle loro casse nel campo Scope. Vedi [Utilizzo di pacchetti esterni](https://doc.rust-lang.org/book/ch07-04-bringing-paths-into-scope-with-the-use-keyword.html#using-external-packages) sul sito Web del linguaggio di programmazione Rust.
+ I nomi delle casse sono spesso sillabati, ma i trattini vengono convertiti in caratteri di sottolineatura quando si utilizza effettivamente la cassa. Ad esempio, la `aws-config` cassa viene utilizzata nell'istruzione del codice come:. `use` `use aws_config`
+ La configurazione è un argomento complesso. La configurazione può avvenire direttamente nel codice o essere specificata esternamente in variabili di ambiente o file di configurazione. Per ulteriori informazioni, consulta [Configurazione esterna dei client AWS SDK per Rust di servizio](config-external.md).
+ Quando l'SDK carica la configurazione, vengono registrati i valori non validi anziché interrompere l'esecuzione, poiché la maggior parte delle impostazioni ha valori predefiniti ragionevoli. Per informazioni su come attivare la registrazione, consulta. [Configurazione e utilizzo della registrazione nell' AWS SDK per Rust](logging.md)
+ La maggior parte delle variabili di ambiente e delle impostazioni dei file di configurazione vengono caricate una volta all'avvio del programma. Eventuali aggiornamenti ai valori non verranno visualizzati fino al riavvio del programma.
## Runtime Tokio
+ Tokio è un runtime asincrono per il linguaggio di programmazione SDK for Rust, esegue le attività. `async` [Vedi [tokio.rs](http://docs.rs/tokio) e docs.rs/tokio.](http://tokio.rs/)
+ L'SDK per Rust richiede un runtime asincrono. Ti consigliamo di aggiungere la seguente cassa ai tuoi progetti:
```
$ cargo add tokio --features=full
```
+ La macro di `tokio::main` attributi crea un punto di ingresso principale asincrono al programma. Per utilizzare questa macro, aggiungetela alla riga che precede il `main` metodo, come illustrato di seguito:
```
#[tokio::main]
async fn main() -> Result<(), Error> {
```