Prerequisiti Configurazione AWS SAM Esempi Ottimizzazione delle integrazioni CI/CD

Creazione di funzioni Rust Lambda con Cargo Lambda in AWS SAM

Usa l'interfaccia a AWS Serverless Application Model riga di comando (AWS SAMCLI) con le tue AWS Lambda funzioni Rust.

Argomenti

Prerequisiti
Configurazione AWS SAM da utilizzare con le funzioni Rust Lambda
Esempi
L'ottimizzazione di Rust si integra GitHub Azioni

Prerequisiti

Rustlingua: Per l'installazioneRust, vedi Installare Rust nel sito Web in Rust lingua.
Cargo Lambda: AWS SAMCLIRichiede l'installazione di Cargo Lambda, un sottocomando perCargo. Per le istruzioni di installazione, vedere Installazione nella Cargo Lambda documentazione.
Docker: La creazione e il test delle funzioni Rust Lambda richiedonoDocker. Per le istruzioni di installazione, consulta Installazione di Docker.

Configurazione AWS SAM da utilizzare con le funzioni Rust Lambda

Passaggio 1: configura il tuo AWS SAM modello

Configura il tuo AWS SAM modello con quanto segue:

Binario: opzionale. Specifica quando un singolo Cargo pacchetto definisce più di un binario, per identificare quale binario creare per questa funzione. Questa proprietà non è necessaria quando ogni funzione è un Cargo pacchetto a sé stante, ad esempio in uno Cargo spazio di lavoro.
BuildMethod – rust-cargolambda.
CodeUri— percorso del Cargo.toml file.
Gestore —bootstrap.
Runtime —provided.al2023.

Per saperne di più sui runtime personalizzati, consulta Custom AWS Lambda runtimes nella AWS Lambda Developer Guide.

Ecco un esempio di modello AWS SAM configurato:


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.al2023
...

Fase 2: Usare il AWS SAM CLI con la tua funzione Rust Lambda

Usa qualsiasi AWS SAMCLI comando con il tuo AWS SAM modello. Per ulteriori informazioni, consulta AWS SAM CLI.

Esempi

Esempio Hello World

In questo esempio, creiamo l'applicazione Hello World di esempio utilizzando Rust come runtime.

Innanzitutto, inizializziamo una nuova applicazione serverless utilizzando. sam init Durante il flusso interattivo, selezioniamo l'applicazione Hello World e scegliamo il runtime 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 - ruby4.0
        21 - ruby3.3
        22 - ruby3.2
        23 - rust (provided.al2)
        24 - rust (provided.al2023)
Runtime: 24

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.al2023)
    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

Di seguito è riportata la struttura della nostra applicazione Hello World:

hello-rust
├── README.md
├── events
│   └── event.json
├── rust_app
│   ├── Cargo.toml
│   └── src
│       └── main.rs
├── samconfig.toml
└── template.yaml

Nel nostro AWS SAM modello, la nostra Rust funzione è definita come segue:


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.al2023
      Architectures:
        - x86_64
      Events:
        HelloWorld:
          Type: Api
          Properties:
            Path: /hello
            Method: get

Successivamente, corriamo sam build per creare la nostra applicazione e prepararci per l'implementazione. AWS SAMCLICrea una .aws-sam directory e lì organizza i nostri artefatti di compilazione. La nostra funzione è creata utilizzando Cargo Lambda e archiviata come file binario eseguibile in. .aws-sam/build/HelloWorldFunction/bootstrap

Nota

Se prevedi di eseguire il sam local invoke comando in macOS, devi creare funzioni diverse prima di richiamarle. Per fare ciò, usa il seguente comando:

SAM_BUILD_MODE=debug sam build

Questo comando è necessario solo se verranno eseguiti test locali. Questo non è consigliato quando si compila per la distribuzione.


hello-rust$ sam build
Starting Build use cache
Cache is invalid, running build and copying resources for following functions (HelloWorldFunction)
Building codeuri: /Users/.../hello-rust/rust_app runtime: provided.al2023 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

Successivamente, implementiamo la nostra applicazione utilizzando. 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

Per eseguire il test, possiamo richiamare la nostra funzione Lambda utilizzando l'endpoint API.


$ curl https://ggdxec9le9.execute-api.us-west-2.amazonaws.com/Prod/hello/
Hello World!%

Per testare la nostra funzione localmente, assicuriamo innanzitutto che la Architectures proprietà della nostra funzione corrisponda al nostro computer locale.


...
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.al2023
      Architectures:
        - arm64
...

Poiché arm64 in questo esempio abbiamo modificato la nostra architettura da x86_64 a, corriamo sam build ad aggiornare gli artefatti di compilazione. Quindi corriamo per sam local invoke richiamare localmente la nostra funzione.


hello-rust$ sam local invoke
Invoking bootstrap (provided.al2023)
Local image was not found.
Removing rapid images for repo public.ecr.aws/sam/emulation-provided.al2023
Building image.....................................................................................................................................
Using local image: public.ecr.aws/lambda/provided:al2023-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

Progetto con funzione Lambda singola

Ecco un esempio di applicazione serverless contenente una funzione Rust Lambda.

Struttura della directory del progetto:

.
├── Cargo.lock
├── Cargo.toml
├── src
│   └── main.rs
└── template.yaml

AWS SAM modello:


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.al2023
...

Progetto con più funzioni Lambda

Ecco un esempio di applicazione serverless contenente più funzioni Rust Lambda, organizzate come uno spazio di lavoro. Cargo

Consigliamo Cargo uno spazio di lavoro per applicazioni con più funzioni Rust Lambda. Ogni funzione è un proprio pacchetto, quindi le funzioni possono dichiarare dipendenze indipendenti condividendo codice comune tramite un pacchetto di libreria. Ogni pacchetto produce un singolo binario che prende il nome dal pacchetto, quindi non è necessario impostare la proprietà Binary build.

Struttura della directory del progetto:

.
├── Cargo.lock
├── Cargo.toml
├── function_a
│   ├── Cargo.toml
│   └── src
│       └── main.rs
├── function_b
│   ├── Cargo.toml
│   └── src
│       └── main.rs
└── template.yaml

Cargo.tomlFile dell'area di lavoro, alla base del progetto:


[workspace]
resolver = "2"
members = [
    "function_a",
    "function_b",
]

[workspace.dependencies]
lambda_runtime = "0.13"
serde = { version = "1", features = ["derive"] }
tokio = { version = "1", features = ["macros", "rt"] }

Cargo.tomlfile per ogni funzione, ad esempiofunction_a/Cargo.toml:


[package]
name = "function_a"
version = "0.1.0"
edition = "2021"

[dependencies]
lambda_runtime = { workspace = true }
serde = { workspace = true }
tokio = { workspace = true }

AWS SAM modello. Il CodeUri valore di ciascuna funzione punta alla cartella dei pacchetti di quella funzione:


AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
  FunctionA:
    Type: AWS::Serverless::Function
    Metadata:
      BuildMethod: rust-cargolambda
    Properties:
      CodeUri: ./function_a
      Handler: bootstrap
      Runtime: provided.al2023
  FunctionB:
    Type: AWS::Serverless::Function
    Metadata:
      BuildMethod: rust-cargolambda
    Properties:
      CodeUri: ./function_b
      Handler: bootstrap
      Runtime: provided.al2023

Nota

AWS SAMCLICrea ogni funzione nello spazio di lavoro nella target directory condivisa dello spazio di lavoro, quindi Cargo compila le dipendenze condivise una volta anziché una volta per ogni funzione. Questo comportamento richiede AWS SAMCLI la versione 1.165.0 o successiva. Nelle versioni precedenti, ogni funzione è creata nella propria target directory e l'intero albero delle dipendenze viene ricompilato per ogni funzione, il che rallenta le compilazioni man mano che si aggiungono funzioni.

Assegna a ciascun pacchetto di funzioni un nome binario univoco. I nomi dei pacchetti sono univoci all'interno di uno spazio di lavoro, quindi il nome binario predefinito è già univoco. Se sostituisci il nome binario con una [[bin]] sezione, non assegnare a due pacchetti lo stesso nome binario. Si compilano nello stesso percorso nella target directory condivisa e si sovrascrivono a vicenda. AWS SAMCLIRegistra un avviso quando lo rileva.

In alternativa, un singolo pacchetto può definire più file binari. In tal caso, utilizzate la proprietà Binary build per selezionare il binario per ogni funzione:


Resources:
  FunctionA:
    Type: AWS::Serverless::Function
    Metadata:
      BuildMethod: rust-cargolambda
      BuildProperties:
        Binary: function_a
    Properties:
      CodeUri: ./
      Handler: bootstrap
      Runtime: provided.al2023

L'ottimizzazione di Rust si integra GitHub Azioni

Le build di Rust richiedono molte risorse di calcolo e un sistema di integrazione continua inizia senza artefatti compilati. Le applicazioni con diverse funzioni che condividono grandi dipendenze, ad esempio an AWSSDK, possono impiegare la maggior parte del tempo di compilazione a compilare le stesse dipendenze. Le seguenti pratiche riducono i tempi di compilazione. GitHub Actions

Usa AWS SAMCLI la versione 1.165.0 o successiva per gli spazi di lavoro

La versione 1.165.0 e successive inserisce ogni membro di uno spazio di Cargo lavoro nella target directory condivisa dello spazio di lavoro, in modo che le dipendenze condivise vengano compilate una volta per build anziché una volta per ogni funzione. Specifica la versione minima quando installi la AWS SAMCLI in modo che una build non ritorni silenziosamente al comportamento più lento.

Memorizza nella cache il Cargo registro e la directory target

Memorizza nella cache il Cargo registro (~/.cargo/registryand~/.cargo/git/db) e la target directory dello spazio di lavoro tra le esecuzioni, in modo che le dipendenze invariate vengano ripristinate anziché ricompilate. Utilizzate una cache separata per ogni destinazione di compilazione. Un processo che compila in modo incrociato gli artefatti di rilascio per arm64 produce artefatti diversi rispetto a un processo che compila nativamente per, quindi una cache condivisa non corrisponde mai. x86_64

Includi le impostazioni di compilazione nella chiave della cache

Cargoinclude impostazioni come opt-level e codegen-units nell'impronta digitale che utilizza per decidere se un artefatto compilato può essere riutilizzato. Se si modifica la [profile.release] sezione del Cargo.toml file dell'area di lavoro senza modificare la chiave della cache, la cache viene ripristinata ma ogni cassa viene comunque ricompilata. Includi un hash del Cargo.toml file dello spazio di lavoro nella chiave della cache in modo che la modifica delle impostazioni del profilo avvii una nuova cache.

Salva il tuo file Cargo.lock

Le funzioni Lambda sono eseguibili, quindi esegui il Cargo.lock commit del file. Questo ti dà build riproducibili e una chiave di cache stabile che cambia solo quando cambiano le dipendenze.

Regola il profilo di rilascio in base ai tempi di compilazione e all'avvio a freddo

Il codice della funzione viene ricompilato ad ogni esecuzione, perché cambia più spesso delle dipendenze. Il profilo di versione predefinito ottimizza il throughput in fase di esecuzione, di cui molte funzioni Lambda non hanno bisogno. L'ottimizzazione delle dimensioni produce file binari più piccoli, il che aiuta anche a velocizzare l'avvio a freddo, mentre l'aumento del numero di unità di generazione del codice aumenta il parallelismo durante la compilazione. Lascia disattivata l'ottimizzazione del tempo di collegamento (lto), perché rallenta la compilazione. Aggiungete quanto segue al file dello spazio di lavoroCargo.toml:


[profile.release]
opt-level = "s"
codegen-units = 256
lto = false
strip = true

Misura l'effetto sulla tua applicazione. Queste impostazioni scambiano una piccola quantità di prestazioni di runtime con il tempo di compilazione e la dimensione binaria.

Evita esecuzioni duplicate del flusso di lavoro

Un flusso di lavoro che viene eseguito su entrambi pull_request gli eventi push e viene eseguito due volte per lo stesso commit. GitHub Actionsle cache sono suddivise in base al branch e alla pull request, quindi le due esecuzioni scrivono in ambiti di cache diversi e nessuna delle due riutilizza la cache dell'altra. Usa un gruppo di concorrenza inserito nell'head commit, in modo che ogni commit venga compilato da una sola esecuzione.

Il seguente flusso di lavoro crea uno Cargo spazio di lavoro con le funzioni Rust Lambda e applica le pratiche arm64 precedenti:


name: Build

on:
  push:
    branches: [main]
  pull_request:

# Collapse the push and pull_request runs for the same commit into a single run.
concurrency:
  group: ${{ github.workflow }}-${{ github.event.pull_request.head.sha || github.sha }}
  cancel-in-progress: true

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v5

      - uses: dtolnay/rust-toolchain@stable
        with:
          targets: aarch64-unknown-linux-gnu

      # Cache the Cargo registry and the workspace target directory. The key covers
      # the compilation target, Cargo.lock, and the workspace Cargo.toml, so that
      # changing a dependency or a release profile setting starts a new cache
      # instead of restoring one whose artifacts Cargo discards.
      - uses: actions/cache@v4
        with:
          path: |
            ~/.cargo/registry/index
            ~/.cargo/registry/cache
            ~/.cargo/git/db
            target
          key: cargo-arm64-${{ hashFiles('Cargo.lock', 'Cargo.toml') }}
          restore-keys: |
            cargo-arm64-

      - name: Install build tools
        run: pip install cargo-lambda 'aws-sam-cli>=1.165.0'

      - name: Build
        run: sam build

La restore-keys voce consente di avviare un'esecuzione dalla cache più recente quando la chiave non corrisponde esattamente, in modo che una modifica della dipendenza riutilizzi le casse che non sono state modificate invece di compilare nuovamente tutto.

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Creazione di funzioni.NET native AOT

Funzioni Python con uv