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à.
# 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> {
```