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.
# Bereitstellen von Lambda-Rust-Funktionen mit ZIP-Dateiarchiven
Auf dieser Seite wird beschrieben, wie Sie Ihre Rust-Funktion kompilieren und dann die kompilierte Binärdatei AWS Lambda mithilfe von [Cargo Lambda](https://www.cargo-lambda.info/guide/what-is-cargo-lambda.html) bereitstellen. Es zeigt auch, wie die kompilierte Binärdatei mit der AWS Command Line Interface und der AWS Serverless Application Model CLI bereitgestellt wird.
**Topics**
+ [
## Voraussetzungen
](#rust-package-prerequisites)
+ [
## Aufbau von Rust-Funktionen auf macOS, Windows oder Linux
](#rust-package-build)
+ [
## Bereitstellung der Binärdatei der Rust-Funktion mit Cargo Lambda
](#rust-deploy-cargo)
+ [
## Aufrufen Ihrer Rust-Funktion mit Cargo Lambda
](#rust-invoke-function)
## Voraussetzungen
+ [Rust](https://www.rust-lang.org/tools/install)
+ [AWS CLI Version 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
## Aufbau von Rust-Funktionen auf macOS, Windows oder Linux
Die folgenden Schritte zeigen, wie Sie das Projekt für Ihre erste Lambda-Funktion mit Rust erstellen und es mit [Cargo Lambda kompilieren, einer Open-Source-Erweiterung eines Drittanbieters für das Cargo-Befehlszeilentool](https://www.cargo-lambda.info/), die das Erstellen und Bereitstellen von Rust-Lambda-Funktionen vereinfacht.
1. Installieren Sie [Cargo Lambda](https://www.cargo-lambda.info/guide/what-is-cargo-lambda.html), eine Open-Source-Erweiterung eines Drittanbieters für das Cargo-Befehlszeilentool, die das Erstellen und Bereitstellen von Rust Lambda-Funktionen vereinfacht:
```
cargo install cargo-lambda
```
Weitere Installationsoptionen finden Sie unter [Installation](https://www.cargo-lambda.info/guide/installation.html) in der Cargo Lambda-Dokumentation.
1. Erstellen Sie die Paketstruktur. Dieser Befehl erstellt einen grundlegenden Funktionscode in `src/main.rs`. Sie können diesen Code zum Testen verwenden oder ihn durch Ihren eigenen ersetzen.
```
cargo lambda new my-function
```
1. Führen Sie im Stammverzeichnis des Pakets den Unterbefehl [build](https://www.cargo-lambda.info/commands/build.html) aus, um den Code in Ihrer Funktion zu kompilieren.
```
cargo lambda build --release
```
(Optional) Wenn Sie AWS Graviton2 auf Lambda verwenden möchten, fügen Sie das `--arm64` Flag hinzu, um Ihren Code für ARM zu kompilieren. CPUs
```
cargo lambda build --release --arm64
```
1. Bevor Sie Ihre Rust-Funktion bereitstellen, konfigurieren Sie die AWS Anmeldeinformationen auf Ihrem Computer.
```
aws configure
```
## Bereitstellung der Binärdatei der Rust-Funktion mit Cargo Lambda
Verwenden Sie den Unterbefehl [bereitstellen](https://www.cargo-lambda.info/commands/deploy.html), um die kompilierte Binärdatei für Lambda bereitzustellen. Dieser Befehl erstellt eine [Ausführungsrolle](lambda-intro-execution-role.md) und erstellt dann die Lambda-Funktion. Um eine bestehende Ausführungsrolle anzugeben, verwenden Sie die [--iam-role Flag](https://www.cargo-lambda.info/commands/deploy.html#iam-roles).
```
cargo lambda deploy my-function
```
### Bereitstellen Ihrer Rust-Funktionsbinärdatei mit dem AWS CLI
Sie können Ihre Binärdatei auch mit dem bereitstellen AWS CLI.
1. Verwenden Sie den Unterbefehl [build](https://www.cargo-lambda.info/commands/build.html), um das .zip-Bereitstellungspaket zu erstellen.
```
cargo lambda build --release --output-format zip
```
1. Um das .zip-Paket in Lambda bereitzustellen, führen Sie den Befehl [create-function](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-function.html) aus.
+ Legen Sie für `--runtime` die Option `provided.al2023` fest. Dies ist eine [reine Betriebssystem-Laufzeit](runtimes-provided.md). Reine Betriebssystemlaufzeiten werden verwendet, um kompilierte Binärdateien und benutzerdefinierte Laufzeiten für Lambda bereitzustellen.
+ Für `--role` geben Sie den ARN der [Ausführungsrolle](lambda-intro-execution-role.md) an.
```
aws lambda create-function \
--function-name my-function \
--runtime provided.al2023 \
--role arn:aws:iam::111122223333:role/lambda-role \
--handler rust.handler \
--zip-file fileb://target/lambda/my-function/bootstrap.zip
```
### Bereitstellen Ihrer Rust-Funktionsbinärdatei mit der AWS SAM CLI
Sie können Ihre Binärdatei auch mit der AWS SAM CLI bereitstellen.
1. Erstellen Sie eine AWS SAM Vorlage mit der Ressourcen- und Eigenschaftsdefinition. Legen Sie für `Runtime` die Option `provided.al2023` fest. Dies ist eine [reine Betriebssystem-Laufzeit](runtimes-provided.md). Reine Betriebssystemlaufzeiten werden verwendet, um kompilierte Binärdateien und benutzerdefinierte Laufzeiten für Lambda bereitzustellen.
Weitere Informationen zur Bereitstellung von Lambda-Funktionen mit AWS SAM finden Sie [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html)im *AWS Serverless Application Model Entwicklerhandbuch*.
**Example SAM-Ressourcen- und Eigenschaftsdefinition für eine Rust-Binärdatei**
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: SAM template for Rust binaries
Resources:
RustFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: target/lambda/my-function/
Handler: rust.handler
Runtime: provided.al2023
Outputs:
RustFunction:
Description: "Lambda Function ARN"
Value: !GetAtt RustFunction.Arn
```
1. Verwenden Sie den Unterbefehl [build](https://www.cargo-lambda.info/commands/build.html), um die Funktion zu kompilieren.
```
cargo lambda build --release
```
1. Verwenden Sie den Befehl [sam deploy](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-deploy.html), um die Funktion in Lambda bereitzustellen.
```
sam deploy --guided
```
Weitere Informationen zum Erstellen von Rust-Funktionen mit der AWS SAM CLI finden Sie unter [Build Rust Lambda functions with Cargo Lambda](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/building-rust.html) im *AWS Serverless Application Model Developer* Guide.
## Aufrufen Ihrer Rust-Funktion mit Cargo Lambda
Verwenden Sie den Unterbefehl [invoke](https://www.cargo-lambda.info/commands/invoke.html), um Ihre Funktion mit einer Nutzlast zu testen.
```
cargo lambda invoke --remote --data-ascii '{"command": "Hello world"}' my-function
```
### Aufrufen Ihrer Rust-Funktion mit dem AWS CLI
Sie können die Funktion auch verwenden AWS CLI , um die Funktion aufzurufen.
```
aws lambda invoke --function-name my-function --cli-binary-format raw-in-base64-out --payload '{"command": "Hello world"}' /tmp/out.txt
```
Die **cli-binary-format** Option ist erforderlich, wenn Sie AWS CLI Version 2 verwenden. Um dies zur Standardeinstellung zu machen, führen Sie `aws configure set cli-binary-format raw-in-base64-out` aus. Weitere Informationen finden Sie unter [Von AWS CLI unterstützte globale Befehlszeilenoptionen](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list) im *AWS Command Line Interface -Benutzerhandbuch für Version 2*.