Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Grundlagen für die AWS SDK für Rust
Lernen Sie die Grundlagen der Programmierung mit der Programmiersprache Rust AWS SDK für Rust, Informationen zum SDK für Rust-Kisten, zur Projektkonfiguration und zur Verwendung der Tokio-Runtime durch das SDK durch Rust.
## Voraussetzungen
Um das verwenden zu können, müssen Sie AWS SDK für Rust Rust und Cargo installiert haben.
+ Installieren Sie die Rust-Toolchain: [https://www.rust-lang. org/tools/install](https://www.rust-lang.org/tools/install)
+ Installieren Sie das `cargo-component` [Tool](https://github.com/bytecodealliance/cargo-component), indem Sie den folgenden Befehl ausführen: `cargo install cargo-component`
### Empfohlene Tools:
Die folgenden optionalen Tools können in Ihrer IDE installiert werden, um Sie bei der Codevervollständigung und Fehlerbehebung zu unterstützen.
+ Die Rust-Analyzer-Erweiterung finden Sie unter [rust in Visual Studio Code](https://code.visualstudio.com/docs/languages/rust).
+ Amazon Q Developer, siehe [Installation der Amazon Q Developer-Erweiterung oder des Amazon Q Developer-Plugins in Ihrer IDE](https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/q-in-IDE-setup.html).
## Grundlagen von Rust
Im Folgenden sind einige Grundlagen der Programmiersprache Rust aufgeführt, deren Kenntnis hilfreich wäre. Alle Referenzen für weitere Informationen stammen aus [der Programmiersprache Rust](https://doc.rust-lang.org/book/title-page.html#the-rust-programming-language).
+ `Cargo.toml`ist die Standard-Rust-Projektkonfigurationsdatei. Sie enthält die Abhängigkeiten und einige Metadaten über das Projekt. Rust-Quelldateien haben eine `.rs` Dateierweiterung. Siehe [Hallo, Cargo\$1](https://doc.rust-lang.org/book/ch01-03-hello-cargo.html) .
+ `Cargo.toml`Sie können mit Profilen angepasst werden, siehe [Anpassen von Builds mit Release-Profilen](https://doc.rust-lang.org/book/ch14-01-release-profiles.html). Diese Profile haben nichts miteinander zu tun und sind unabhängig von der Verwendung AWS von Profilen in der gemeinsam genutzten AWS `config` Datei.
+ Eine übliche Methode, Ihrem Projekt und dieser Datei Bibliotheksabhängigkeiten hinzuzufügen, ist die Verwendung`cargo add`. Siehe [https://doc.rust-lang.org/cargo/commands/cargo-add.html](https://doc.rust-lang.org/cargo/commands/cargo-add.html).
+ Rust hat eine grundlegende Funktionsstruktur wie die folgende. Das `let` Schlüsselwort deklariert eine Variable und kann mit einer Zuweisung (=) gepaart werden. Wenn Sie danach keinen Typ angeben`let`, leitet der Compiler davon ab. Siehe [Variablen und Veränderbarkeit.](https://doc.rust-lang.org/book/ch03-01-variables-and-mutability.html)
```
fn main() {
let w = "world";
println!("Hello {}!", w);
}
```
+ Um eine Variable `x` mit einem expliziten Typ zu deklarieren`T`, verwendet Rust Syntax`x: T`. Siehe [Datentypen](https://doc.rust-lang.org/book/ch03-02-data-types.html).
+ `struct X {}`definiert den neuen Typ`X`. Methoden werden für den benutzerdefinierten Strukturtyp implementiert`X`. Methoden für den Typ `X` werden mit Implementierungsblöcken deklariert, denen ein Schlüsselwort `impl` vorangestellt ist. `self`Bezieht sich innerhalb des Implementierungsblocks auf die Instanz der Struktur, für die die Methode aufgerufen wurde. Siehe [Syntax von [Schlüsselwörtern `impl`](https://doc.rust-lang.org/std/keyword.impl.html) und Methoden](https://doc.rust-lang.org/book/ch05-03-method-syntax.html).
+ Wenn ein Ausrufezeichen („\$1“) folgt dem, was wie eine Funktionsdefinition oder ein Funktionsaufruf aussieht, dann definiert der Code ein Makro oder ruft es auf. Siehe [Makros](https://doc.rust-lang.org/book/ch19-06-macros.html?highlight=macro#macros).
+ In Rust werden nicht behebbare Fehler durch das Makro dargestellt. `panic!` Wenn ein Programm auf ein Problem stößt, stoppt `panic!` es die Ausführung, gibt eine Fehlermeldung aus, wickelt den Vorgang ab, bereinigt den Stapel und beendet das Programm. Weitere Informationen finden Sie unter [Nicht behebbare Fehler mit](https://doc.rust-lang.org/book/ch09-01-unrecoverable-errors-with-panic.html). `panic!`
+ Rust unterstützt die Vererbung von Funktionen aus Basisklassen nicht wie andere Programmiersprachen. So ermöglicht Rust das Überladen von Methoden. `traits` Man könnte sich vorstellen, dass Merkmale konzeptionell einer Schnittstelle ähneln. Merkmale und echte Schnittstellen weisen jedoch Unterschiede auf und werden im Entwurfsprozess oft unterschiedlich verwendet. Weitere Informationen finden Sie unter [Merkmale: Definition von gemeinsamem Verhalten](https://doc.rust-lang.org/book/ch10-02-traits.html).
+ Polymorphismus bezieht sich auf Code, der Funktionen für mehrere Datentypen unterstützt, ohne dass jeder einzelne Datentyp einzeln geschrieben werden muss. Rust unterstützt Polymorphismus durch Aufzählungen, Merkmale und Generika. Siehe [Vererbung als Typsystem und als](https://doc.rust-lang.org/book/ch17-01-what-is-oo.html?#inheritance-as-a-type-system-and-as-code-sharing) Code-Sharing.
+ Rust ist sehr explizit, wenn es um Speicher geht. Intelligente Zeiger „sind Datenstrukturen, die sich wie ein Zeiger verhalten, aber auch zusätzliche Metadaten und Funktionen haben“. Siehe [Intelligente Zeiger](https://doc.rust-lang.org/book/ch15-00-smart-pointers.html).
+ Bei diesem Typ `Cow` handelt es sich um einen clone-on-write intelligenten Zeiger, mit dessen Hilfe der Speicherbesitz bei Bedarf auf den Anrufer übertragen wird. Siehe [https://doc.rust-lang.org/std/borrow/enum.Cow.html](https://doc.rust-lang.org/std/borrow/enum.Cow.html).
+ Bei diesem Typ `Arc` handelt es sich um einen intelligenten Zeiger mit atomarer Referenzzählung, der zugewiesene Instanzen zählt. Siehe [https://doc.rust-lang.org/std/sync/struct.Arc.html](https://doc.rust-lang.org/std/sync/struct.Arc.html).
+ Das SDK für Rust verwendet häufig das Builder-Muster für die Konstruktion komplexer Typen.
## AWS SDK für Rust Grundlagen erstellen
+ Die primäre Kernkiste für die Funktionalität des SDK für Rust ist. `aws-config` Dies ist in den meisten Projekten enthalten, da es Funktionen zum Lesen von Konfigurationen aus der Umgebung bietet.
```
$ cargo add aws-config
```
+ Verwechseln Sie das nicht mit dem AWS-Service , was genannt AWS Config wird. Da es sich um einen Dienst handelt, folgt er der Standardkonvention von AWS-Service Kisten und wird aufgerufen. `aws-sdk-config`
+ Die SDK for Rust-Bibliothek ist jeweils in verschiedene Bibliothekskisten unterteilt. AWS-Service[Diese Kisten sind unter https://docs.rs/ verfügbar.](https://docs.rs/)
+ AWS-Service Kisten folgen der Namenskonvention von`aws-sdk-[servicename]`, z. B. `aws-sdk-s3` und. `aws-sdk-dynamodb`
## Projektkonfiguration für die Arbeit mit AWS-Services
+ Sie müssen Ihrem Projekt für jedes Projekt, das Ihre Anwendung verwenden soll AWS-Service , eine Kiste hinzufügen.
+ Die empfohlene Methode, eine Kiste hinzuzufügen, besteht darin, die Befehlszeile im Verzeichnis Ihres Projekts zu verwenden`cargo add [crateName]`, indem Sie beispielsweise Folgendes ausführen. `cargo add aws-sdk-s3`
+ Dadurch wird dem Ordner Ihres Projekts eine Zeile hinzugefügt`Cargo.toml`. `[dependencies]`
+ Standardmäßig wird dadurch die neueste Version der Kiste zu Ihrem Projekt hinzugefügt.
+ Verwenden Sie in Ihrer Quelldatei die `use` Anweisung, um Elemente aus ihren Kisten in den Gültigkeitsbereich einzubeziehen. Weitere Informationen finden Sie [unter Verwenden externer Pakete](https://doc.rust-lang.org/book/ch07-04-bringing-paths-into-scope-with-the-use-keyword.html#using-external-packages) auf der Website der Programmiersprache Rust.
+ Kistennamen werden oft mit Bindestrich getrennt, aber die Bindestriche werden in Unterstriche umgewandelt, wenn die Kiste tatsächlich verwendet wird. Zum Beispiel wird die `aws-config` Kiste in der Codeanweisung als: verwendet. `use` `use aws_config`
+ Konfiguration ist ein komplexes Thema. Die Konfiguration kann direkt im Code erfolgen oder extern in Umgebungsvariablen oder Konfigurationsdateien angegeben werden. Weitere Informationen finden Sie unter [Externes Konfigurieren von AWS SDK für Rust Service-Clients](config-external.md).
+ Wenn das SDK Ihre Konfiguration lädt, werden ungültige Werte protokolliert, anstatt die Ausführung anzuhalten, da die meisten Einstellungen vernünftige Standardwerte haben. Informationen zum Aktivieren der Protokollierung finden Sie unter. [Konfiguration und Verwendung der Protokollierung im AWS SDK für Rust](logging.md)
+ Die meisten Umgebungsvariablen und Einstellungen der Konfigurationsdatei werden einmal geladen, wenn Ihr Programm gestartet wird. Aktualisierungen der Werte werden erst sichtbar, wenn Sie Ihr Programm neu starten.
## Tokio-Laufzeit
+ Tokio ist eine asynchrone Laufzeit für die Programmiersprache SDK für Rust, sie führt die Aufgaben aus. `async` [http://tokio.rs/](http://tokio.rs/)
+ Das SDK für Rust benötigt eine asynchrone Laufzeit. Wir empfehlen Ihnen, Ihren Projekten die folgende Kiste hinzuzufügen:
```
$ cargo add tokio --features=full
```
+ Das `tokio::main` Attribut-Makro erstellt einen asynchronen Haupteinstiegspunkt zu Ihrem Programm. Um dieses Makro zu verwenden, fügen Sie es der Zeile vor Ihrer `main` Methode hinzu, wie im Folgenden gezeigt:
```
#[tokio::main]
async fn main() -> Result<(), Error> {
```