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. # Création de fonctions Rust Lambda avec in Cargo Lambda AWS SAM | | | --- | | Cette fonctionnalité est en version préliminaire AWS SAM et est sujette à modification. | Utilisez l'interface de ligne de AWS Serverless Application Model commande (AWS SAMCLI) avec vos AWS Lambda fonctions Rust. **Topics** + [Conditions préalables](#building-rust-prerequisites) + [Configuration AWS SAM à utiliser avec les fonctions Rust Lambda](#building-rust-configure) + [Exemples](#building-rust-examples) ## Conditions préalables **Langage Rust** Pour installer Rust, consultez la section [Installer Rust](https://www.rust-lang.org/tools/install) sur le *site web du langage Rust*. **Cargo Lambda** La CLI  AWS SAM nécessite l'installation de [https://www.cargo-lambda.info/guide/what-is-cargo-lambda.html](https://www.cargo-lambda.info/guide/what-is-cargo-lambda.html), une sous-commande pour Cargo. Pour les instructions d'installation, consultez la rubrique [Installation](https://www.cargo-lambda.info/guide/installation.html) dans la *documentation Cargo Lambda*. **Docker** La création et le test de fonctions Lambda Rust nécessitent Docker. Pour obtenir des instructions d’installation, consultez [Installation de Docker](install-docker.md). **Activer la fonctionnalité bêta de la CLI  AWS SAM** Cette fonctionnalité étant en cours de prévisualisation, vous devez l'activer en utilisant l'une des méthodes suivantes : 1. Utiliser la variable d'environnement : `SAM_CLI_BETA_RUST_CARGO_LAMBDA=1`. 1. Ajoutez ce qui suit à votre fichier `samconfig.toml` : ``` [default.build.parameters] beta_features = true [default.sync.parameters] beta_features = true ``` 1. Utilisez l'option `--beta-features` lorsque vous utilisez une commande de la CLI  AWS SAM prise en charge. Par exemple : ``` $ sam build --beta-features ``` 1. Choisissez l'option `y` lorsque la CLI  AWS SAM vous y invite. Voici un exemple : ``` $ 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 ``` ## Configuration AWS SAM à utiliser avec les fonctions Rust Lambda ### Étape 1 : Configuration de votre AWS SAM modèle Configurez votre AWS SAM modèle avec les éléments suivants : + **Binaire** : facultatif. Spécifiez quand votre modèle contient plusieurs fonctions Lambda Rust. + **BuildMethod** – `rust-cargolambda`. + **CodeUri**— chemin d'accès à votre `Cargo.toml` fichier. + **Gestionnaire** : `bootstrap`. + **Exécution** : `provided.al2`. Pour en savoir plus sur les environnements d'exécution personnalisés, consultez la section [AWS Lambda Runtimes personnalisés](https://docs.aws.amazon.com/lambda/latest/dg/runtimes-custom.html) dans le manuel du *AWS Lambda développeur*. Voici un exemple de AWS SAM modèle configuré : ``` 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 ... ``` ### Étape 2 : utiliser la CLI  AWS SAM avec votre fonction Lambda Rust Utilisez n'importe quelle AWS SAMCLI commande avec votre AWS SAM modèle. Pour de plus amples informations, veuillez consulter [AWS SAM CLI](using-sam-cli.md). ## Exemples ### Exemple Hello World **Dans cet exemple, nous créons l'exemple d'application Hello World en utilisant Rust comme notre exécution.** Tout d'abord, nous initialisons une nouvelle application sans serveur en utilisant `sam init`. Au cours du flux interactif, nous sélectionnons l'**application Hello World** et choisissons l'exécution **Rust**. ``` $ 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 ``` Voici la structure de notre application Hello World : ``` hello-rust ├── README.md ├── events │ └── event.json ├── rust_app │ ├── Cargo.toml │ └── src │ └── main.rs ├── samconfig.toml └── template.yaml ``` Dans notre AWS SAM modèle, notre Rust fonction est définie comme suit : ``` 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 ``` Ensuite, nous exécutons `sam build` pour créer notre application et préparer son déploiement. La CLI  AWS SAM crée un répertoire `.aws-sam` et organise nos artefacts de création. Notre fonction est construite en utilisant Cargo Lambda et stockée sous forme de binaire exécutable à l'emplacement suivant : `.aws-sam/build/HelloWorldFunction/bootstrap`. **Note** Si vous envisagez d'exécuter la **sam local invoke** commande sous macOS, vous devez créer des fonctions différentes avant de l'invoquer. Pour ce faire, utilisez la commande suivante : **SAM\$1BUILD\$1MODE=debug sam build** Cette commande n'est nécessaire que si des tests locaux doivent être effectués. Cela n'est pas recommandé lors de la création en vue du déploiement. ``` 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 ``` Ensuite, nous déployons notre application en utilisant `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 ``` Pour tester, nous pouvons appeler notre fonction Lambda à l'aide du point de terminaison de l'API. ``` $ curl https://ggdxec9le9.execute-api.us-west-2.amazonaws.com/Prod/hello/ Hello World!% ``` Pour tester notre fonction localement, nous devons d'abord nous assurer que la propriété `Architectures`de notre fonction correspond à notre ordinateur local. ``` ... 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 ... ``` Comme nous avons modifié notre architecture en passant de `x86_64` à `arm64` dans cet exemple, nous exécutons `sam build` pour mettre à jour nos artefacts de création. Nous exécutons ensuite `sam local invoke` pour appeler notre fonction localement. ``` 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 ``` ### Projet de fonction Lambda unique **Voici un exemple d'application sans serveur contenant une fonction Lambda Rust.** Structure du répertoire du projet : ``` . ├── Cargo.lock ├── Cargo.toml ├── src │ └── main.rs └── template.yaml ``` AWS SAM modèle : ``` 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 ... ``` ### Projet de fonctions Lambda multiples **Voici un exemple d'application sans serveur contenant plusieurs fonctions Lambda Rust.** Structure du répertoire du projet : ``` . ├── Cargo.lock ├── Cargo.toml ├── src │ ├── function_a.rs │ └── function_b.rs └── template.yaml ``` AWS SAM modèle : ``` 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 ``` Fichier `Cargo.toml` : ``` [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" ```