Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Principes fondamentaux de AWS SDK pour Rust
Apprenez les principes fondamentaux de la programmation avec AWS SDK pour Rust, notamment : les principes fondamentaux du langage de programmation Rust, des informations sur le SDK pour les caisses Rust, la configuration du projet et le SDK pour l'utilisation du moteur d'exécution Tokio par Rust.
## Conditions préalables
Pour utiliser le AWS SDK pour Rust, vous devez avoir installé Rust et Cargo.
+ Installez la chaîne d'outils Rust : [https://www.rust-lang. org/tools/install](https://www.rust-lang.org/tools/install)
+ Installez l'`cargo-component`[outil](https://github.com/bytecodealliance/cargo-component) en exécutant la commande : `cargo install cargo-component`
### Outils recommandés :
Les outils optionnels suivants peuvent être installés dans votre IDE pour vous aider à compléter le code et à résoudre les problèmes.
+ L'extension rust-analyzer, voir [Rust dans Visual Studio Code](https://code.visualstudio.com/docs/languages/rust).
+ Amazon Q Developer, consultez [Installation de l'extension ou du plugin Amazon Q Developer dans votre IDE](https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/q-in-IDE-setup.html).
## Principes fondamentaux de Rust
Voici quelques notions de base du langage de programmation Rust qu'il serait utile de connaître. Toutes les références pour plus d'informations proviennent [du langage de programmation Rust](https://doc.rust-lang.org/book/title-page.html#the-rust-programming-language).
+ `Cargo.toml`est le fichier de configuration standard du projet Rust, il contient les dépendances et certaines métadonnées relatives au projet. Les fichiers source Rust ont une extension de `.rs` fichier. Découvrez [Hello, Cargo \!](https://doc.rust-lang.org/book/ch01-03-hello-cargo.html) .
+ Ils `Cargo.toml` peuvent être personnalisés à l'aide de profils, voir [Personnalisation des versions avec des profils de version](https://doc.rust-lang.org/book/ch14-01-release-profiles.html). Ces profils ne sont absolument pas liés et indépendants AWS de l'utilisation des profils dans le AWS `config` fichier partagé.
+ Une méthode courante pour ajouter des dépendances de bibliothèque à votre projet et à ce fichier consiste à utiliser`cargo add`. Consultez [https://doc.rust-lang.org/cargo/commands/cargo-add.html](https://doc.rust-lang.org/cargo/commands/cargo-add.html).
+ Rust a une structure fonctionnelle de base comme la suivante. Le `let` mot clé déclare une variable et peut être associé à assignment (=). Si vous ne spécifiez pas de type par la suite`let`, le compilateur en déduira un. Voir [Variables et mutabilité](https://doc.rust-lang.org/book/ch03-01-variables-and-mutability.html).
```
fn main() {
let w = "world";
println!("Hello {}!", w);
}
```
+ Pour déclarer une variable `x` avec un type explicite`T`, Rust utilise la syntaxe`x: T`. Voir [Types de données](https://doc.rust-lang.org/book/ch03-02-data-types.html).
+ `struct X {}`définit le nouveau type`X`. Les méthodes sont implémentées sur le type `X` de structure personnalisé. Les méthodes de type `X` sont déclarées avec des blocs d'implémentation préfixés par un mot-clé`impl`. À l'intérieur du bloc d'implémentation, `self` fait référence à l'instance de la structure à laquelle la méthode a été appelée. Voir [Syntaxe `impl` des [mots clés](https://doc.rust-lang.org/std/keyword.impl.html) et des méthodes](https://doc.rust-lang.org/book/ch05-03-method-syntax.html).
+ Si un point d'exclamation (« \! ») suit ce qui semble être une définition de fonction ou un appel de fonction, puis le code définit ou appelle une macro. Voir [Macros](https://doc.rust-lang.org/book/ch19-06-macros.html?highlight=macro#macros).
+ Dans Rust, les erreurs irrécupérables sont représentées par la macro. `panic!` Lorsqu'un programme rencontre un, `panic!` il s'arrête de fonctionner, affiche un message d'échec, se déroule, nettoie la pile et quitte le programme. Consultez la section [Erreurs irrécupérables](https://doc.rust-lang.org/book/ch09-01-unrecoverable-errors-with-panic.html) avec. `panic!`
+ Rust ne prend pas en charge l'héritage des fonctionnalités des classes de base comme le font les autres langages de programmation ; `traits` c'est ainsi que Rust permet de surcharger les méthodes. Les traits peuvent être considérés comme étant conceptuellement similaires à une interface. Cependant, les traits et les interfaces réelles présentent des différences et sont souvent utilisés différemment dans le processus de conception. Voir [Traits : définition d'un comportement partagé](https://doc.rust-lang.org/book/ch10-02-traits.html).
+ Le polymorphisme fait référence au code qui prend en charge les fonctionnalités de plusieurs types de données sans avoir à écrire chacun d'entre eux individuellement. Rust soutient le polymorphisme par le biais d'énumérations, de traits et de génériques. Voir [l'héritage en tant que système de types et en tant que partage de code](https://doc.rust-lang.org/book/ch17-01-what-is-oo.html?#inheritance-as-a-type-system-and-as-code-sharing).
+ Rust est très explicite à propos de la mémoire. Les pointeurs intelligents « sont des structures de données qui agissent comme un pointeur mais qui possèdent également des métadonnées et des fonctionnalités supplémentaires ». Voir [Smart Pointers](https://doc.rust-lang.org/book/ch15-00-smart-pointers.html).
+ Le type `Cow` est un pointeur clone-on-write intelligent qui permet de transférer la propriété de la mémoire à l'appelant lorsque cela est nécessaire. Consultez [https://doc.rust-lang.org/std/borrow/enum.Cow.html](https://doc.rust-lang.org/std/borrow/enum.Cow.html).
+ Le type `Arc` est un pointeur intelligent à comptage de références atomiques qui compte les instances allouées. Consultez [https://doc.rust-lang.org/std/sync/struct.Arc.html](https://doc.rust-lang.org/std/sync/struct.Arc.html).
+ Le SDK pour Rust utilise fréquemment le modèle de générateur pour construire des types complexes.
## AWS SDK pour Rust principes fondamentaux de la caisse
+ La principale caisse de base de la fonctionnalité du SDK pour Rust est`aws-config`. Ceci est inclus dans la majorité des projets car il fournit des fonctionnalités permettant de lire la configuration depuis l'environnement.
```
$ cargo add aws-config
```
+ Ne le confondez pas avec ce Service AWS qu'on appelle AWS Config. Comme il s'agit d'un service, il suit la convention standard des Service AWS caisses et est appelé`aws-sdk-config`.
+ La bibliothèque du SDK pour Rust est séparée en différentes caisses de bibliothèque par chacune Service AWS. Ces caisses sont disponibles sur [https://docs.rs/](https://docs.rs/).
+ Service AWS les caisses suivent la convention de dénomination de`aws-sdk-{{[servicename]}}`, telle que `aws-sdk-s3` et`aws-sdk-dynamodb`.
## Configuration du projet pour travailler avec Services AWS
+ Vous devrez ajouter une caisse à votre projet pour chaque élément Service AWS que vous souhaitez que votre application utilise.
+ La méthode recommandée pour ajouter une caisse consiste à utiliser la ligne de commande dans le répertoire de votre projet en exécutant`cargo add {{[crateName]}}`, par exemple`cargo add aws-sdk-s3`.
+ Cela ajoutera une ligne au `Cargo.toml` sous-titre de votre projet`[dependencies]`.
+ Par défaut, cela ajoutera la dernière version de la caisse à votre projet.
+ Dans votre fichier source, utilisez l'`use`instruction pour placer les objets de leur caisse dans le champ d'application. Consultez la section [Utilisation de packages externes](https://doc.rust-lang.org/book/ch07-04-bringing-paths-into-scope-with-the-use-keyword.html#using-external-packages) sur le site Web du langage de programmation Rust.
+ Les noms des caisses sont souvent marqués d'un trait d'union, mais les traits d'union sont convertis en traits de soulignement lorsque vous utilisez réellement la caisse. Par exemple, la `aws-config` caisse est utilisée dans l'`use`instruction de code sous la forme :`use aws_config`.
+ La configuration est un sujet complexe. La configuration peut se produire directement dans le code ou être spécifiée de manière externe dans des variables d'environnement ou des fichiers de configuration. Pour de plus amples informations, veuillez consulter [Configuration externe AWS SDK pour Rust des clients de service](config-external.md).
+ Lorsque le SDK charge votre configuration, les valeurs non valides sont enregistrées au lieu d'interrompre l'exécution, car la plupart des paramètres ont des valeurs par défaut raisonnables. Pour savoir comment activer la journalisation, voir[Configuration et utilisation de la journalisation dans le AWS SDK pour Rust](logging.md).
+ La plupart des variables d'environnement et des paramètres du fichier de configuration sont chargés une seule fois au démarrage du programme. Aucune mise à jour des valeurs ne sera visible tant que vous ne redémarrerez pas votre programme.
## Tokyo Runtime
+ Tokio est un environnement d'exécution asynchrone pour le langage de programmation SDK pour Rust, il exécute les tâches. `async` [Consultez [tokio.rs](http://tokio.rs/) et docs.rs/tokio.](http://docs.rs/tokio)
+ Le SDK pour Rust nécessite un environnement d'exécution asynchrone. Nous vous recommandons d'ajouter la caisse suivante à vos projets :
```
$ cargo add tokio --features=full
```
+ La macro `tokio::main` d'attribut crée un point d'entrée principal asynchrone vers votre programme. Pour utiliser cette macro, ajoutez-la à la ligne précédant votre `main` méthode, comme indiqué ci-dessous :
```
#[tokio::main]
async fn main() -> Result<(), Error> {
```