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. # Erstellen von Rust Lambda-Funktionen mit Cargo Lambda in AWS SAM | | | --- | | Diese Funktion befindet sich in der Vorschauversion für AWS SAM und kann sich ändern. | Verwenden Sie die AWS Serverless Application Model Befehlszeilenschnittstelle (AWS SAMCLI) mit Ihren AWS Lambda Rust-Funktionen. **Topics** + [Voraussetzungen](#building-rust-prerequisites) + [Konfiguration AWS SAM für die Verwendung mit Rust Lambda-Funktionen](#building-rust-configure) + [Beispiele](#building-rust-examples) ## Voraussetzungen **RustSprache** Informationen zur Installation Rust finden [Sie unter Installieren Rust](https://www.rust-lang.org/tools/install) auf der *RustSprachwebsite*. **Cargo Lambda** Das AWS SAMCLI erfordert die Installation von [https://www.cargo-lambda.info/guide/what-is-cargo-lambda.html](https://www.cargo-lambda.info/guide/what-is-cargo-lambda.html), einen Unterbefehl fürCargo. Installationsanweisungen finden Sie in der *Cargo LambdaDokumentation* unter [Installation](https://www.cargo-lambda.info/guide/installation.html). **Docker** Das Erstellen und Testen von Rust Lambda-Funktionen erfordertDocker. Installationsanweisungen finden Sie unter [Installieren von Docker](install-docker.md). **Melden Sie sich für die AWS SAMCLI Beta-Funktion an** Da es sich bei dieser Funktion um eine Vorschauversion handelt, müssen Sie sich mit einer der folgenden Methoden anmelden: 1. Verwenden Sie die Umgebungsvariable:`SAM_CLI_BETA_RUST_CARGO_LAMBDA=1`. 1. Fügen Sie der `samconfig.toml`-Datei Folgendes hinzu: ``` [default.build.parameters] beta_features = true [default.sync.parameters] beta_features = true ``` 1. Verwenden Sie die `--beta-features` Option, wenn Sie einen unterstützten AWS SAMCLI Befehl verwenden. Beispiel: ``` $ sam build --beta-features ``` 1. Wählen Sie die Option`y`, wenn Sie AWS SAMCLI aufgefordert werden, sich anzumelden. Im Folgenden wird ein Beispiel gezeigt: ``` $ sam build Starting Build use cache Build method "rust-cargolambda" is a beta feature. Please confirm if you would like to proceed You can also enable this beta feature with "sam build --beta-features". [y/N]: y ``` ## Konfiguration AWS SAM für die Verwendung mit Rust Lambda-Funktionen ### Schritt 1: Konfigurieren Sie Ihre Vorlage AWS SAM Konfigurieren Sie Ihre AWS SAM Vorlage wie folgt: + **Binär** — Optional. Geben Sie an, wann Ihre Vorlage mehrere Rust-Lambda-Funktionen enthält. + **BuildMethod** – `rust-cargolambda`. + **CodeUri**— Pfad zu deiner `Cargo.toml` Datei. + **Handler** —`bootstrap`. + **Laufzeit** —`provided.al2`. Weitere Informationen zu benutzerdefinierten Laufzeiten finden Sie unter [Benutzerdefinierte AWS Lambda Laufzeiten](https://docs.aws.amazon.com/lambda/latest/dg/runtimes-custom.html) im *AWS Lambda Entwicklerhandbuch*. Hier ist ein Beispiel für eine konfigurierte AWS SAM Vorlage: ``` AWSTemplateFormatVersion: '2010-09-09' Transform: AWS::Serverless-2016-10-31 ... Resources: MyFunction: Type: AWS::Serverless::Function Metadata: BuildMethod: rust-cargolambda BuildProperties: function_a Properties: CodeUri: ./rust_app Handler: bootstrap Runtime: provided.al2 ... ``` ### Schritt 2: Verwenden Sie die AWS SAMCLI mit Ihrer Rust Lambda-Funktion Verwenden Sie einen beliebigen AWS SAMCLI Befehl mit Ihrer AWS SAM Vorlage. Weitere Informationen finden Sie unter [AWS SAM CLI](using-sam-cli.md). ## Beispiele ### Beispiel Hello World **In diesem Beispiel erstellen wir die Hello World-Beispielanwendung Rust als Laufzeit.** Zunächst initialisieren wir eine neue serverlose Anwendung mit. `sam init` Während des interaktiven Ablaufs wählen wir die **Hello World-Anwendung** und wählen die **Rust-Laufzeit** aus. ``` $ sam init ... Which template source would you like to use? 1 - AWS Quick Start Templates 2 - Custom Template Location Choice: 1 Choose an AWS Quick Start application template 1 - Hello World Example 2 - Multi-step workflow 3 - Serverless API ... Template: 1 Use the most popular runtime and package type? (Python and zip) [y/N]: ENTER Which runtime would you like to use? 1 - dotnet8 2 - dotnet6 3 - go (provided.al2) ... 18 - python3.11 19 - python3.10 20 - ruby3.3 21 - ruby3.2 22 - rust (provided.al2) 23 - rust (provided.al2023) Runtime: 22 Based on your selections, the only Package type available is Zip. We will proceed to selecting the Package type as Zip. Based on your selections, the only dependency manager available is cargo. We will proceed copying the template using cargo. Would you like to enable X-Ray tracing on the function(s) in your application? [y/N]: ENTER Would you like to enable monitoring using CloudWatch Application Insights? For more info, please view https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch-application-insights.html [y/N]: ENTER Project name [sam-app]: hello-rust ----------------------- Generating application: ----------------------- Name: hello-rust Runtime: rust (provided.al2) Architectures: x86_64 Dependency Manager: cargo Application Template: hello-world Output Directory: . Configuration file: hello-rust/samconfig.toml Next steps can be found in the README file at hello-rust/README.md Commands you can use next ========================= [*] Create pipeline: cd hello-rust && sam pipeline init --bootstrap [*] Validate SAM template: cd hello-rust && sam validate [*] Test Function in the Cloud: cd hello-rust && sam sync --stack-name {stack-name} --watch ``` Im Folgenden ist die Struktur unserer Hello World-Anwendung dargestellt: ``` hello-rust ├── README.md ├── events │ └── event.json ├── rust_app │ ├── Cargo.toml │ └── src │ └── main.rs ├── samconfig.toml └── template.yaml ``` In unserer AWS SAM Vorlage ist unsere Rust Funktion wie folgt definiert: ``` AWSTemplateFormatVersion: '2010-09-09' Transform: AWS::Serverless-2016-10-31 ... Resources: HelloWorldFunction: Type: AWS::Serverless::Function Metadata: BuildMethod: rust-cargolambda Properties: CodeUri: ./rust_app Handler: bootstrap Runtime: provided.al2 Architectures: - x86_64 Events: HelloWorld: Type: Api Path: /hello Method: get ``` Als Nächstes erstellen wir `sam build` unsere Anwendung und bereiten sie auf die Bereitstellung vor. Das AWS SAMCLI erstellt ein `.aws-sam` Verzeichnis und organisiert dort unsere Build-Artefakte. Unsere Funktion wird unter Verwendung einer ausführbaren Binärdatei erstellt Cargo Lambda und als solche gespeichert. `.aws-sam/build/HelloWorldFunction/bootstrap` **Anmerkung** Wenn Sie den **sam local invoke** Befehl in macOS ausführen möchten, müssen Sie vor dem Aufrufen andere Funktionen erstellen. Verwenden Sie dazu den folgenden Befehl: **SAM\$1BUILD\$1MODE=debug sam build** Dieser Befehl wird nur benötigt, wenn lokale Tests durchgeführt werden sollen. Dies wird nicht empfohlen, wenn Sie für die Bereitstellung erstellen. ``` hello-rust$ sam build Starting Build use cache Build method "rust-cargolambda" is a beta feature. Please confirm if you would like to proceed You can also enable this beta feature with "sam build --beta-features". [y/N]: y Experimental features are enabled for this session. Visit the docs page to learn more about the AWS Beta terms https://aws.amazon.com/service-terms/. Cache is invalid, running build and copying resources for following functions (HelloWorldFunction) Building codeuri: /Users/.../hello-rust/rust_app runtime: provided.al2 metadata: {'BuildMethod': 'rust-cargolambda'} architecture: x86_64 functions: HelloWorldFunction Running RustCargoLambdaBuilder:CargoLambdaBuild Running RustCargoLambdaBuilder:RustCopyAndRename Build Succeeded Built Artifacts : .aws-sam/build Built Template : .aws-sam/build/template.yaml Commands you can use next ========================= [*] Validate SAM template: sam validate [*] Invoke Function: sam local invoke [*] Test Function in the Cloud: sam sync --stack-name {{stack-name}} --watch [*] Deploy: sam deploy --guided ``` Als Nächstes stellen wir unsere Anwendung bereit mit`sam deploy --guided`. ``` hello-rust$ sam deploy --guided Configuring SAM deploy ====================== Looking for config file [samconfig.toml] : Found Reading default arguments : Success Setting default arguments for 'sam deploy' ========================================= Stack Name [hello-rust]: ENTER AWS Region [us-west-2]: ENTER #Shows you resources changes to be deployed and require a 'Y' to initiate deploy Confirm changes before deploy [Y/n]: ENTER #SAM needs permission to be able to create roles to connect to the resources in your template Allow SAM CLI IAM role creation [Y/n]: ENTER #Preserves the state of previously provisioned resources when an operation fails Disable rollback [y/N]: ENTER HelloWorldFunction may not have authorization defined, Is this okay? [y/N]: y Save arguments to configuration file [Y/n]: ENTER SAM configuration file [samconfig.toml]: ENTER SAM configuration environment [default]: ENTER Looking for resources needed for deployment: ... Uploading to hello-rust/56ba6585d80577dd82a7eaaee5945c0b 817973 / 817973 (100.00%) Deploying with following values =============================== Stack name : hello-rust Region : us-west-2 Confirm changeset : True Disable rollback : False Deployment s3 bucket : aws-sam-cli-managed-default-samclisam-s3-demo-bucket-1a4x26zbcdkqr Capabilities : ["CAPABILITY_IAM"] Parameter overrides : {} Signing Profiles : {} Initiating deployment ===================== Uploading to hello-rust/a4fc54cb6ab75dd0129e4cdb564b5e89.template 1239 / 1239 (100.00%) Waiting for changeset to be created.. CloudFormation stack changeset --------------------------------------------------------------------------------------------------------- Operation LogicalResourceId ResourceType Replacement --------------------------------------------------------------------------------------------------------- + Add HelloWorldFunctionHelloW AWS::Lambda::Permission N/A orldPermissionProd ... --------------------------------------------------------------------------------------------------------- Changeset created successfully. arn:aws:cloudformation:us-west-2:012345678910:changeSet/samcli-deploy1681427201/f0ef1563-5ab6-4b07-9361-864ca3de6ad6 Previewing CloudFormation changeset before deployment ====================================================== Deploy this changeset? [y/N]: y 2023-04-13 13:07:17 - Waiting for stack create/update to complete CloudFormation events from stack operations (refresh every 5.0 seconds) --------------------------------------------------------------------------------------------------------- ResourceStatus ResourceType LogicalResourceId ResourceStatusReason --------------------------------------------------------------------------------------------------------- CREATE_IN_PROGRESS AWS::IAM::Role HelloWorldFunctionRole - CREATE_IN_PROGRESS AWS::IAM::Role HelloWorldFunctionRole Resource creation ... --------------------------------------------------------------------------------------------------------- CloudFormation outputs from deployed stack --------------------------------------------------------------------------------------------------------- Outputs --------------------------------------------------------------------------------------------------------- Key HelloWorldFunctionIamRole Description Implicit IAM Role created for Hello World function Value arn:aws:iam::012345678910:role/hello-rust-HelloWorldFunctionRole-10II2P13AUDUY Key HelloWorldApi Description API Gateway endpoint URL for Prod stage for Hello World function Value https://ggdxec9le9.execute-api.us-west-2.amazonaws.com/Prod/hello/ Key HelloWorldFunction Description Hello World Lambda Function ARN Value arn:aws:lambda:us-west-2:012345678910:function:hello-rust-HelloWorldFunction- yk4HzGzYeZBj --------------------------------------------------------------------------------------------------------- Successfully created/updated stack - hello-rust in us-west-2 ``` Zum Testen können wir unsere Lambda-Funktion über den API-Endpunkt aufrufen. ``` $ curl https://ggdxec9le9.execute-api.us-west-2.amazonaws.com/Prod/hello/ Hello World!% ``` Um unsere Funktion lokal zu testen, stellen wir zunächst sicher, dass die `Architectures` Eigenschaft unserer Funktion mit unserem lokalen Computer übereinstimmt. ``` ... Resources: HelloWorldFunction: Type: AWS::Serverless::Function # More info about Function Resource: https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#awsserverlessfunction Metadata: BuildMethod: rust-cargolambda # More info about Cargo Lambda: https://github.com/cargo-lambda/cargo-lambda Properties: CodeUri: ./rust_app # Points to dir of Cargo.toml Handler: bootstrap # Do not change, as this is the default executable name produced by Cargo Lambda Runtime: provided.al2 Architectures: - arm64 ... ``` Da wir `arm64` in diesem Beispiel unsere Architektur von `x86_64` bis geändert haben, führen `sam build` wir die Aktualisierung unserer Build-Artefakte durch. Anschließend starten wir`sam local invoke`, um unsere Funktion lokal aufzurufen. ``` hello-rust$ sam local invoke Invoking bootstrap (provided.al2) Local image was not found. Removing rapid images for repo public.ecr.aws/sam/emulation-provided.al2 Building image..................................................................................................................................... Using local image: public.ecr.aws/lambda/provided:al2-rapid-arm64. Mounting /Users/.../hello-rust/.aws-sam/build/HelloWorldFunction as /var/task:ro,delegated, inside runtime container START RequestId: fbc55e6e-0068-45f9-9f01-8e2276597fc6 Version: $LATEST {"statusCode":200,"body":"Hello World!"}END RequestId: fbc55e6e-0068-45f9-9f01-8e2276597fc6 REPORT RequestId: fbc55e6e-0068-45f9-9f01-8e2276597fc6 Init Duration: 0.68 ms Duration: 130.63 ms Billed Duration: 131 ms Memory Size: 128 MB Max Memory Used: 128 MB ``` ### Projekt mit einer einzigen Lambda-Funktion **Hier ist ein Beispiel für eine serverlose Anwendung, die eine Rust-Lambda-Funktion enthält.** Struktur des Projektverzeichnisses: ``` . ├── Cargo.lock ├── Cargo.toml ├── src │ └── main.rs └── template.yaml ``` AWS SAM Vorlage: ``` AWSTemplateFormatVersion: '2010-09-09' Transform: AWS::Serverless-2016-10-31 ... Resources: MyFunction: Type: AWS::Serverless::Function Metadata: BuildMethod: rust-cargolambda Properties: CodeUri: ./ Handler: bootstrap Runtime: provided.al2 ... ``` ### Projekt mit mehreren Lambda-Funktionen **Hier ist ein Beispiel für eine serverlose Anwendung, die mehrere Rust-Lambda-Funktionen enthält.** Struktur des Projektverzeichnisses: ``` . ├── Cargo.lock ├── Cargo.toml ├── src │ ├── function_a.rs │ └── function_b.rs └── template.yaml ``` AWS SAM Vorlage: ``` AWSTemplateFormatVersion: '2010-09-09' Transform: AWS::Serverless-2016-10-31 ... Resources: FunctionA: Type: AWS::Serverless::Function Metadata: BuildMethod: rust-cargolambda BuildProperties: Binary: function_a Properties: CodeUri: ./ Handler: bootstrap Runtime: provided.al2 FunctionB: Type: AWS::Serverless::Function Metadata: BuildMethod: rust-cargolambda BuildProperties: Binary: function_b Properties: CodeUri: ./ Handler: bootstrap Runtime: provided.al2 ``` `Cargo.toml`-Datei: ``` [package] name = "test-handler" version = "0.1.0" edition = "2021" [dependencies] lambda_runtime = "0.6.0" serde = "1.0.136" tokio = { version = "1", features = ["macros"] } tracing = { version = "0.1", features = ["log"] } tracing-subscriber = { version = "0.3", default-features = false, features = ["fmt"] } [[bin]] name = "function_a" path = "src/function_a.rs" [[bin]] name = "function_b" path = "src/function_b.rs" ```