As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Personalize construções com AWS SAM
Você pode personalizar a criação para incluir funções específicas ou camadas do Lambda. Uma função é um recurso que você pode invocar para executar o código no Lambda. Uma camada do Lambda permite que você extraia código de uma função do Lambda que pode ser reutilizado em várias funções do Lambda. Você pode optar por personalizar a criação com funções específicas do Lambda quando quiser se concentrar no desenvolvimento e na implantação de funções individuais sem servidor sem a complexidade de gerenciar dependências ou recursos compartilhados. Além disso, você pode optar por criar uma camada do Lambda para ajudar na redução do tamanho dos pacotes de implantação, na separação da lógica da função de núcleo das dependências e na permissão para compartilhar dependências em várias funções.
Os tópicos desta seção exploram algumas das diferentes maneiras pelas quais você pode criar funções Lambda com. AWS SAM Isso inclui a criação de funções do Lambda com os runtimes do cliente e a criação de camadas do Lambda. Os tempos de execução personalizados permitem que você instale e use uma linguagem não listada nos tempos de execução do Lambda no AWS Lambda Guia do desenvolvedor. Isso permite que você crie um ambiente de execução especializado para executar funções e aplicações sem servidor. Criar somente camadas do Lambda (em vez de toda a aplicação) pode trazer benefícios de algumas maneiras. Isso pode ajudar na redução do tamanho dos pacotes de implantação, na separação da lógica da função de núcleo das dependências e na permissão para compartilhar dependências em várias funções.
Para obter mais informações, consulte [Conceitos do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-concepts.html) no *Guia do desenvolvedor do AWS Lambda *.
**Topics**
+ [Construindo funções Lambda do Node.js com esbuild em AWS SAM](serverless-sam-cli-using-build-typescript.md)
+ [Criação de funções do.NET Lambda com compilação AOT nativa no AWS SAM](build-dotnet7.md)
+ [Construindo funções do Rust Lambda com o Cargo Lambda AWS SAM](building-rust.md)
+ [Construindo funções Python Lambda com o uv AWS SAM](building-python-uv.md)
+ [Criação de funções Lambda com tempos de execução personalizados no AWS SAM](building-custom-runtimes.md)
+ [Construindo camadas Lambda em AWS SAM](building-layers.md)
# Construindo funções Lambda do Node.js com esbuild em AWS SAM
Para criar e empacotar AWS Lambda as funções do Node.js, você pode usar o AWS SAMCLI com o JavaScript bundler esbuild. O bundler esbuild oferece suporte às funções Lambda nas quais você escreve. TypeScript
Para criar uma função do Lambda Node.js com esbuild, adicione um objeto `Metadata` ao seu recurso `AWS:Serverless::Function` e especifique `esbuild` para `BuildMethod`. Quando você executa o **sam build** comando, AWS SAM usa o esbuild para agrupar o código da função Lambda.
## Propriedades de metadados
O objeto `Metadata` é compatível com as seguintes propriedades para esbuild.
### BuildMethod
Especifica o empacotador do aplicativo. O único valor aceito é `esbuild`.
### BuildProperties
Especifica as propriedades de construção do código da função do Lambda.
O objeto `BuildProperties` é compatível com as seguintes propriedades para esbuild. Todas as propriedades são opcionais. Por padrão, AWS SAM usa seu manipulador de funções Lambda como ponto de entrada.
**EntryPoints**
Especifica pontos de entrada para seu aplicativo.
**Externo**
Especifica a lista de pacotes a serem omitidos da compilação. Para obter mais informações, consulte [Externo](https://esbuild.github.io/api/#external) no *site da esbuild*.
**Formato**
Especifica o formato de saída dos JavaScript arquivos gerados em seu aplicativo. Para obter mais informações, consulte [Formato](https://esbuild.github.io/api/#format) no *site do esbuild*.
**Carregador**
Especifica a lista de configurações para carregar dados de um determinado tipo de arquivo.
**MainFields**
Especifica quais campos `package.json` tentar importar ao resolver um pacote. O valor padrão é `main,module`.
**Minimizar**
Especifica se o código de saída incluído deve ser minimizado. O valor padrão é `true`.
**OutExtension**
Personalize a extensão dos arquivos que o esbuild gera. Para obter mais informações, consulte [Extensão de saída](https://esbuild.github.io/api/#out-extension) no *site da esbuild*.
**Mapa de origem**
Especifica se o bundler produz um arquivo de mapa de origem. O valor padrão é `false`.
Quando definido como `true`, `NODE_OPTIONS: --enable-source-maps` é anexado às variáveis de ambiente da função do Lambda e um mapa de origem é gerado e incluído na função.
Como alternativa, quando `NODE_OPTIONS: --enable-source-maps` é incluído nas variáveis de ambiente da função, `Sourcemap` é automaticamente definido como `true`.
Quando conflitante, `Sourcemap: false` tem precedência sobre `NODE_OPTIONS: --enable-source-maps`.
Por padrão, o Lambda criptografa todas as variáveis de ambiente em repouso com AWS Key Management Service (AWS KMS). Ao usar mapas de origem, para que a implantação seja bem-sucedida, a função de execução da sua função deve ter permissão para realizar a ação `kms:Encrypt`.
**SourcesContent**
Especifica se o código-fonte deve ser incluído no arquivo do mapa de origem. Configure essa propriedade quando `Sourcemap` estiver definido como `'true'`.
+ Especifique `SourcesContent: 'true'` para incluir todo o código-fonte.
+ Especifique `SourcesContent: 'false'` para excluir todo o código-fonte. Isso resulta em tamanhos menores de arquivos de mapas de origem, o que é útil na produção ao reduzir os tempos de inicialização. No entanto, o código-fonte não estará disponível no depurador.
O valor padrão é `SourcesContent: true`.
Para obter mais informações, consulte [Conteúdo de fontes](https://esbuild.github.io/api/#sources-content) no *site esbuild*.
**Destino**
Especifica a ECMAScript versão de destino. O valor padrão é `es2020`.
## TypeScript Exemplo de função Lambda
O exemplo de trecho AWS SAM de modelo a seguir usa esbuild para criar uma função Lambda Node.js a partir do código em. TypeScript `hello-world/app.ts`
```
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: hello-world/
Handler: app.handler
Runtime: nodejs20.x
Architectures:
- x86_64
Events:
HelloWorld:
Type: Api
Properties:
Path: /hello
Method: get
Environment:
Variables:
NODE_OPTIONS: --enable-source-maps
Metadata:
BuildMethod: esbuild
BuildProperties:
Format: esm
Minify: false
OutExtension:
- .js=.mjs
Target: "es2020"
Sourcemap: true
EntryPoints:
- app.ts
External:
- ""
```
# Criação de funções do.NET Lambda com compilação AOT nativa no AWS SAM
Crie e empacote suas AWS Lambda funções do.NET 8 com o AWS Serverless Application Model (AWS SAM), utilizando a compilação nativa Ahead-of-Time (AOT) para melhorar AWS Lambda os tempos de inicialização a frio.
**Topics**
+ [Visão geral da AOT nativa do .NET 8](#build-dotnet7-overview)
+ [Usando AWS SAM com suas funções Lambda do.NET 8](#build-dotnet7-sam)
+ [Pré-requisitos de instalação](#build-dotnet7-prerequisites)
+ [Defina as funções Lambda do.NET 8 em seu modelo AWS SAM](#build-dotnet7-sam-define)
+ [Crie seu aplicativo com o AWS SAMCLI](#build-dotnet7-sam-build)
+ [Saiba mais](#build-dotnet7-learn-more)
## Visão geral da AOT nativa do .NET 8
Historicamente, as funções .NET Lambda têm tempos de inicialização a frio que afetam a experiência do usuário, a latência do sistema e os custos de uso de seus aplicativos sem servidor. Com a compilação AOT nativa do.NET, você pode melhorar os tempos de inicialização a frio das suas funções do Lambda. Para saber mais sobre o AOT nativo para.NET 8, consulte [Usando o AOT nativo no repositório GitHub ](https://github.com/dotnet/runtime/tree/main/src/coreclr/nativeaot#readme) *Dotnet*.
## Usando AWS SAM com suas funções Lambda do.NET 8
Faça o seguinte para configurar as funções do Lambda com .NET 8 com o AWS Serverless Application Model (AWS SAM):
+ Instale os pré-requisitos em sua máquina de desenvolvimento.
+ Defina as funções Lambda do.NET 8 em seu AWS SAM modelo.
+ Crie seu aplicativo com AWS SAMCLI o.
## Pré-requisitos de instalação
Os seguintes pré-requisitos são exigidos:
+ O AWS SAMCLI
+ .NET Core CLI
+ Amazon.Lambda.Tools .NET Core Global Tool
+ Docker
**Instale o AWS SAM CLI**
1. Para verificar se você já tem AWS SAMCLI instalado, execute o seguinte:
```
sam --version
```
1. Para instalar o AWS SAMCLI, consulte[Instale o AWS SAM CLI](install-sam-cli.md).
1. Para atualizar uma versão instalada do AWS SAMCLI, consulte[Atualizar o AWS SAM CLI](manage-sam-cli-versions.md#manage-sam-cli-versions-upgrade).
**Instalado o .NET Core CLI**
1. Para fazer download e instalar a .NET Core CLI, consulte [Download .NET](https://dotnet.microsoft.com/download) do website da Microsoft.
1. *Para obter mais informações sobre a CLI do.NET Core, consulte [.NET Core CLI](https://docs.aws.amazon.com/lambda/latest/dg/csharp-package-cli.html) no AWS Lambda Guia do Desenvolvedor*.
**Instale o Amazon.Lambda.Tools .NET Core Global Tool**
1. Execute este comando: .
```
dotnet tool install -g Amazon.Lambda.Tools
```
1. Se você já tiver a ferramenta instalada, certifique-se de que esteja usando a versão mais recente com o seguinte comando:
```
dotnet tool update -g Amazon.Lambda.Tools
```
1. Para obter mais informações sobre a ferramenta global Amazon.Lambda.Tools .NET Core, consulte o repositório Extensions [AWS for](https://github.com/aws/aws-extensions-for-dotnet-cli) .NET CLI em. GitHub
**Instalar o Docker**
+ Construir com AOT nativo, precisa que Docker seja instalado. Para obter instruções de instalação, consulte [Instalando o Docker para usar com o AWS SAMCLI](install-docker.md).
## Defina as funções Lambda do.NET 8 em seu modelo AWS SAM
Para definir um. NET8 Função Lambda em seu AWS SAM modelo, faça o seguinte:
1. Execute o seguinte comando em um diretório inicial de sua escolha:
```
sam init
```
1. Selecione `AWS Quick Start Templates` para escolher um modelo inicial.
1. Escolha o modelo `Hello World Example`.
1. Escolha não usar o runtime e o tipo de pacote mais populares inserindo `n`.
1. Em runtime, escolha `dotnet8`.
1. Em tipo de pacote, escolha `Zip`.
1. Em modelo inicial, escolha `Hello World Example using native AOT`.
**Instalar o Docker**
+ Construir com AOT nativo, precisa que Docker seja instalado. Para obter instruções de instalação, consulte [Instalando o Docker para usar com o AWS SAMCLI](install-docker.md).
```
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./src/HelloWorldAot/
Handler: bootstrap
Runtime: dotnet8
Architectures:
- x86_64
Events:
HelloWorldAot:
Type: Api
Properties:
Path: /hello
Method: get
```
**nota**
Quando a `Event` propriedade de um `AWS::Serverless::Function` é definida como`Api`, mas a `RestApiId` propriedade não é especificada, AWS SAM gera o `AWS::ApiGateway::RestApi` CloudFormation recurso.
## Crie seu aplicativo com o AWS SAMCLI
No diretório raiz do seu projeto, execute o comando `sam build` para começar a criar sua aplicação. Se a propriedade `PublishAot` tiver sido definida no arquivo de projeto do .NET 8, a CLI do AWS SAM será criada com a compilação AOT nativa. Para saber mais sobre a propriedade `PublishAot`, consulte [Implantação nativa de AOT](https://learn.microsoft.com/en-us/dotnet/core/deploying/native-aot/) na documentação *.NET* da Microsoft.
Para criar a sua função, AWS SAM CLI invoca a CLI do .NET Core CLI, que usa a ferramenta Amazon.Lambda.Lambda.Tools .NET Core Global.
**nota**
Ao criar, se um arquivo `.sln` existir no mesmo diretório ou no diretório principal do seu projeto, o diretório que contém o arquivo `.sln` será montado no contêiner. Se um arquivo `.sln` não for encontrado, somente a pasta do projeto será montada. Portanto, se você estiver criando um aplicativo de vários projetos, verifique se o arquivo `.sln` está localizado na propriedade.
## Saiba mais
Para obter mais informações sobre a criação de funções do Lambda com .NET 8, consulte [Introdução ao runtime do .NET 8 para o AWS Lambda](https://aws.amazon.com/blogs/compute/introducing-the-net-8-runtime-for-aws-lambda/).
Para obter uma referência do comando **sam build**, consulte [sam build](sam-cli-command-reference-sam-build.md).
# Construindo funções do Rust Lambda com o Cargo Lambda AWS SAM
| |
| --- |
| Esse recurso está na versão prévia AWS SAM e está sujeito a alterações. |
Use a interface de linha de AWS Serverless Application Model comando (AWS SAMCLI) com suas AWS Lambda funções do Rust.
**Topics**
+ [Pré-requisitos](#building-rust-prerequisites)
+ [Configurando AWS SAM para usar com as funções do Rust Lambda](#building-rust-configure)
+ [Exemplos](#building-rust-examples)
## Pré-requisitos
**Linguagem Rust**
Para instalarRust, consulte [Instalar Rust](https://www.rust-lang.org/tools/install) no *Rust site do idioma*.
**Cargo Lambda**
O AWS SAMCLI requer a instalação de um subcomando [https://www.cargo-lambda.info/guide/what-is-cargo-lambda.html](https://www.cargo-lambda.info/guide/what-is-cargo-lambda.html), para Cargo. Para obter instruções, consulte [Instalação](https://www.cargo-lambda.info/guide/installation.html) na *Documentação do Cargo Lambda*.
**Docker**
É necessário criar e testar as Rust funções do Lambda Docker. Para obter instruções de instalação, consulte [Instalação do Docker](install-docker.md).
**Opte pelo recurso AWS SAMCLI beta**
Como esse recurso está em versão prévia, opte por usar um dos seguintes métodos:
1. Use as variáveis de ambiente: `SAM_CLI_BETA_RUST_CARGO_LAMBDA=1`.
1. Adicione o seguinte ao arquivo `samconfig.toml`:
```
[default.build.parameters]
beta_features = true
[default.sync.parameters]
beta_features = true
```
1. Use a opção `--beta-features` ao usar um comando do AWS SAM CLI compatível. Por exemplo:
```
$ sam build --beta-features
```
1. Escolha a opção `y` quando AWS SAM CLI solicitar que você se inscreva. Este é um exemplo:
```
$ 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
```
## Configurando AWS SAM para usar com as funções do Rust Lambda
### Etapa 1: configurar seu AWS SAM modelo
Configure seu AWS SAM modelo com o seguinte:
+ **Binário** - Opcional. Especifique quando seu modelo contém várias funções do Rust Lambda.
+ **BuildMethod** – `rust-cargolambda`.
+ **CodeUri**— caminho para seu `Cargo.toml` arquivo.
+ **Manipulador** – `bootstrap`.
+ **Tempo de execução** – `provided.al2`.
Para saber mais sobre tempos de execução personalizados, consulte [AWS Lambda Tempos de execução personalizados](https://docs.aws.amazon.com/lambda/latest/dg/runtimes-custom.html) no Guia do *AWS Lambda desenvolvedor*.
Aqui está um exemplo de um AWS SAM modelo configurado:
```
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
...
```
### Etapa 2: use o AWS SAM CLI com sua função Rust Lambda
Use qualquer AWS SAMCLI comando com seu AWS SAM modelo. Para obter mais informações, consulte [AWS SAM CLI](using-sam-cli.md).
## Exemplos
### Exemplo do Hello World
**Neste exemplo, criamos o aplicativo Hello World de amostra usando Rust como nosso tempo de execução.**
Primeiro, inicializamos um novo aplicativo sem servidor usando o `sam init`. Durante o fluxo interativo, selecionamos o **aplicativo Hello World** e escolhemos o tempo de execução do **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
```
A seguir está a estrutura do nosso aplicativo Hello World:
```
hello-rust
├── README.md
├── events
│ └── event.json
├── rust_app
│ ├── Cargo.toml
│ └── src
│ └── main.rs
├── samconfig.toml
└── template.yaml
```
Em nosso AWS SAM modelo, nossa Rust função é definida da seguinte forma:
```
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
```
Em seguida, executamos `sam build` para criar nosso aplicativo e nos preparar para a implantação. O AWS SAMCLI cria um diretório `.aws-sam` e organiza nossos artefatos de construção lá. Nossa função é construída usando Cargo Lambda e armazenada como um binário executável em `.aws-sam/build/HelloWorldFunction/bootstrap`.
**nota**
Se você planeja executar o comando **sam local invoke** no macOS, precisa criar funções diferentes antes de invocar. Para fazer isso, use o seguinte comando:
**SAM\$1BUILD\$1MODE=debug sam build**
Esse comando só será necessário se for feito um teste local. Isso não é recomendado na criação para implantação.
```
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
```
Em seguida, implantamos nosso aplicativo usando `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
```
Para testar, podemos invocar nossa função do Lambda usando o endpoint da API.
```
$ curl https://ggdxec9le9.execute-api.us-west-2.amazonaws.com/Prod/hello/
Hello World!%
```
Para testar nossa função localmente, primeiro garantimos que a propriedade `Architectures` de nossa função corresponda à nossa máquina 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
...
```
Como modificamos nossa arquitetura de `x86_64` para `arm64` neste exemplo, executamos `sam build` para atualizar nossos artefatos de construção. Em seguida, executamos `sam local invoke` para invocar localmente nossa função.
```
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
```
### Projeto de função do Lambda única
**Aqui está um exemplo de um aplicativo sem servidor contendo uma função Rust Lambda.**
Estrutura do diretório do projeto:
```
.
├── Cargo.lock
├── Cargo.toml
├── src
│ └── main.rs
└── template.yaml
```
AWS SAM modelo:
```
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
...
```
### Projeto de função do Lambda Múltipla
**Aqui está um exemplo de um aplicativo sem servidor contendo várias funções do Rust Lambda.**
Estrutura do diretório do projeto:
```
.
├── Cargo.lock
├── Cargo.toml
├── src
│ ├── function_a.rs
│ └── function_b.rs
└── template.yaml
```
AWS SAM modelo:
```
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
```
Arquivo `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"
```
# Construindo funções Python Lambda com o uv AWS SAM
| |
| --- |
| Esse recurso está na versão prévia AWS SAM e está sujeito a alterações. |
Use a AWS Serverless Application Model Command Line Interface (AWS SAMCLI) com uv um rápido instalador e resolvedor de pacotes Python para criar suas funções em Python. AWS Lambda
**Topics**
+ [Pré-requisitos](#building-python-uv-prerequisites)
+ [Configurando AWS SAM para usar com funções Python Lambda e uv](#building-python-uv-configure)
+ [Exemplos](#building-python-uv-examples)
## Pré-requisitos
**Python**
*Para instalar o Python, consulte Baixar o [Python no site do Python](https://www.python.org/downloads/).*
**uv**
AWS SAMCLIRequer a instalação de [https://docs.astral.sh/uv/](https://docs.astral.sh/uv/)um instalador e resolvedor de pacotes Python extremamente rápido. Para obter instruções, consulte [Instalação](https://docs.astral.sh/uv/getting-started/installation/) na *Documentação do uv*.
**Opte pelo recurso AWS SAMCLI beta**
Como esse recurso está em versão prévia, opte por usar um dos seguintes métodos:
1. Use as variáveis de ambiente: `SAM_CLI_BETA_PYTHON_UV=1`.
1. Adicione o seguinte ao arquivo `samconfig.toml`:
```
[default.build.parameters]
beta_features = true
[default.sync.parameters]
beta_features = true
```
1. Use a opção `--beta-features` ao usar um comando do AWS SAM CLI compatível. Por exemplo:
```
$ sam build --beta-features
```
1. Escolha a opção `y` quando AWS SAM CLI solicitar que você se inscreva. Este é um exemplo:
```
$ sam build
Starting Build use cache
Build method "python-uv" 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
```
## Configurando AWS SAM para usar com funções Python Lambda e uv
### Etapa 1: configurar seu AWS SAM modelo
Configure seu AWS SAM modelo com o seguinte:
+ **BuildMethod** – `python-uv`.
+ **CodeUri**— caminho para seu diretório de código de função contendo `pyproject.toml` ou`requirements.txt`.
+ **Handler** — seu manipulador de funções (por exemplo,`app.lambda_handler`).
+ **Runtime** — versão de tempo de execução do Python (por exemplo,`python3.12`).
Aqui está um exemplo de um AWS SAM modelo configurado:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
MyFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./my_function
Handler: app.lambda_handler
Runtime: python3.12
Metadata:
BuildMethod: python-uv
...
```
## Exemplos
### Exemplo do Hello World
**Neste exemplo, criamos uma amostra do aplicativo Hello World usando Python uv como gerenciador de pacotes.**
uvpode usar uma `pyproject.toml` ou `requirements.txt` para ler dependências. Se ambos forem fornecidos, `sam build` lerá `requirements.txt` as dependências.
A seguir está a estrutura do nosso aplicativo Hello World:
```
hello-python-uv
├── README.md
├── events
│ └── event.json
├── hello_world
│ ├── __init__.py
│ ├── app.py
│ └── pyproject.toml
├── samconfig.toml
└── template.yaml
```
Arquivo `pyproject.toml`:
```
[project]
name = "my-function"
version = "0.1.0"
requires-python = ">=3.12"
dependencies = [
"requests>=2.31.0",
"boto3>=1.28.0",
]
```
Em nosso AWS SAM modelo, nossa função Python é definida da seguinte forma:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: hello_world/
Handler: app.lambda_handler
Runtime: python3.12
Architectures:
- x86_64
Metadata:
BuildMethod: python-uv
```
Em seguida, executamos `sam build` para criar nosso aplicativo e nos preparar para a implantação. O AWS SAMCLI cria um diretório `.aws-sam` e organiza nossos artefatos de construção lá. Nossas dependências de função são instaladas usando uv e armazenadas em`.aws-sam/build/HelloWorldFunction/`.
```
hello-python-uv$ sam build
Starting Build use cache
Build method "python-uv" 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-python-uv/hello_world runtime: python3.12 metadata: {'BuildMethod': 'python-uv'} architecture: x86_64 functions: HelloWorldFunction
Running PythonUvBuilder:UvBuild
Running PythonUvBuilder:CopySource
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
```
**nota**
O método de `python-uv` construção é configurado por função na `Metadata` seção. Cada função em seu modelo pode usar um método de construção diferente, permitindo que você misture funções uv `pip` baseadas com funções baseadas no mesmo AWS SAM modelo. Se nenhum método de construção for especificado, `pip` é usado por padrão.
# Criação de funções Lambda com tempos de execução personalizados no AWS SAM
Você pode usar o comando `sam build` para criar tempos de execução personalizados necessários para sua função do Lambda. Você declara a sua função do Lambda para usar um runtime especificando `Runtime: provided` para a função.
Para criar um runtime personalizado, declare o atributo do recurso `Metadata` com uma entrada `BuildMethod: makefile`. Você fornece um makefile personalizado, no qual declara um destino de construção do formulário `build-function-logical-id` que contém os comandos de construção para seu tempo de execução. Seu makefile é responsável por compilar o tempo de execução personalizado, se necessário, e copiar os artefatos de construção no local adequado para as etapas subsequentes do seu fluxo de trabalho. A localização do makefile é especificada pela propriedade `CodeUri` do recurso da função e deve ser nomeada `Makefile`.
## Exemplos
### Exemplo 1: Tempo de execução personalizado para uma função escrita em Rust
**nota**
Recomendamos criar funções do Lambda com Cargo Lambda. Para saber mais, consulte [Construindo funções do Rust Lambda com o Cargo Lambda AWS SAM](building-rust.md).
O AWS SAM modelo a seguir declara uma função que usa um tempo de execução personalizado para uma função Lambda escrita em Rust e `sam build` instrui a execução dos comandos para o destino de compilação. `build-HelloRustFunction`
```
Resources:
HelloRustFunction:
Type: AWS::Serverless::Function
Properties:
FunctionName: HelloRust
Handler: bootstrap.is.real.handler
Runtime: provided
MemorySize: 512
CodeUri: .
Metadata:
BuildMethod: makefile
```
O makefile a seguir contém o destino da compilação e os comandos que serão executados. Observe que a propriedade `CodeUri` está definida como `.`, portanto, o makefile deve estar localizado no diretório raiz do projeto (ou seja, o mesmo diretório do arquivo do modelo AWS SAM do aplicativo). O nome do arquivo deve ser `Makefile`.
```
build-HelloRustFunction:
cargo build --release --target x86_64-unknown-linux-musl
cp ./target/x86_64-unknown-linux-musl/release/bootstrap $(ARTIFACTS_DIR)
```
Para obter mais informações sobre como configurar seu ambiente de desenvolvimento para executar o comando `cargo build` no `makefile` anterior, consulte a postagem do blog [Rust Runtime for AWS Lambda](https://aws.amazon.com/blogs/opensource/rust-runtime-for-aws-lambda/).
### Exemplo 2: builder Makefile para Python3.12 (alternativa ao uso do criador agrupado)
Talvez você queira usar uma biblioteca ou módulo que não esteja incluído em um construtor empacotado. Este exemplo mostra um AWS SAM modelo para um tempo de execução do Python3.12 com um construtor de makefile.
```
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: hello_world/
Handler: app.lambda_handler
Runtime: python3.12
Metadata:
BuildMethod: makefile
```
O makefile a seguir contém o destino da compilação e os comandos que serão executados. Observe que a propriedade `CodeUri` está definida como `hello_world`, portanto, o makefile deve estar localizado na raiz do subdiretório `hello_world` e o nome do arquivo deve ser `Makefile`.
```
build-HelloWorldFunction:
cp *.py $(ARTIFACTS_DIR)
cp requirements.txt $(ARTIFACTS_DIR)
python -m pip install -r requirements.txt -t $(ARTIFACTS_DIR)
rm -rf $(ARTIFACTS_DIR)/bin
```
# Construindo camadas Lambda em AWS SAM
Você pode usar AWS SAM para criar camadas Lambda personalizadas. As camadas do Lambda permitem que você extraia código de uma função do Lambda que pode ser reutilizado em várias funções do Lambda. Criar somente camadas do Lambda (em vez de toda a aplicação) pode trazer benefícios de algumas maneiras. Isso pode ajudar na redução do tamanho dos pacotes de implantação, na separação da lógica da função de núcleo das dependências e na permissão para compartilhar dependências em várias funções. Para obter informações sobre camadas, consulte [Camadas do AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html) no *Guia do desenvolvedor do AWS Lambda *.
## Como criar uma camada Lambda no AWS SAM
**nota**
Antes de criar uma camada Lambda, você deve primeiro escrever uma camada Lambda no seu modelo. AWS SAM Para obter informações e exemplos, consulte [Aumente a eficiência usando camadas Lambda com AWS SAM](serverless-sam-cli-layers.md).
Para criar uma camada personalizada, declare-a em seu arquivo de modelo AWS Serverless Application Model (AWS SAM) e inclua uma seção de atributo de `Metadata` recurso com uma `BuildMethod` entrada. Os valores válidos para `BuildMethod` são identificadores de um [AWS Lambda runtime](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html), ou `makefile`. Inclua uma entrada `BuildArchitecture` para especificar as arquiteturas do conjunto de instruções que sua camada suporta. Os valores válidos para `BuildArchitecture` são [arquiteturas dos conjuntos de instruções Lambda](https://docs.aws.amazon.com/lambda/latest/dg/foundation-arch.html).
Se você especificar `makefile`, forneça o makefile personalizado, onde você declara um destino de construção do formulário `build-layer-logical-id` que contém os comandos de construção para sua camada. Seu makefile é responsável por compilar a camada, se necessário, e copiar os artefatos de construção no local adequado para as etapas subsequentes do seu fluxo de trabalho. A localização do makefile é especificada pela propriedade `ContentUri` do recurso de camada e deve ser nomeada `Makefile`.
**nota**
Quando você cria uma camada personalizada, AWS Lambda depende das variáveis de ambiente para encontrar seu código de camada. Os tempos de execução do Lambda incluem caminhos no diretório `/opt` em que seu código de camada é copiado. A estrutura de pastas de artefatos de construção do seu projeto deve corresponder à estrutura de pastas esperada do runtime para que seu código de camada personalizado possa ser encontrado.
Por exemplo, para Python, você pode colocar seu código no subdiretório `python/`. Para NodeJS, você pode colocar seu código no subdiretório `nodejs/node_modules/`.
Para obter mais informações, consulte [Incluindo dependências de biblioteca em uma camada](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html#configuration-layers-path) no *AWS Lambda Guia do desenvolvedor*.
Veja a seguir um exemplo de seção de atributo de recurso `Metadata`.
```
Metadata:
BuildMethod: python3.12
BuildArchitecture: arm64
```
**nota**
Se você não incluir a seção do atributo do `Metadata` recurso, AWS SAM não cria a camada. Em vez disso, ele copia os artefatos de construção do local especificado na propriedade `CodeUri` do recurso de camada. Para obter mais informações, consulte a propriedade [ContentUri](sam-resource-layerversion.md#sam-layerversion-contenturi) do tipo de recurso `AWS::Serverless::LayerVersion`.
Ao incluir a seção do atributo do `Metadata` recurso, você pode usar o `sam build` comando para criar a camada, tanto como um objeto independente quanto como uma dependência de uma AWS Lambda função.
+ ****Como um objeto independente.**** Talvez você queira criar apenas o objeto de camada, por exemplo, quando estiver testando localmente uma alteração de código na camada e não precisar criar todo o aplicativo. Para criar a camada de forma independente, especifique o recurso da camada com o comando `sam build layer-logical-id`.
+ **Como uma dependência de uma função do Lambda.** Quando você inclui o ID lógico de uma camada na propriedade `Layers` de uma função do Lambda no mesmo arquivo de modelo AWS SAM , a camada é uma dependência dessa função do Lambda. Quando essa camada também inclui uma seção de atributo de recurso `Metadata` com uma entrada `BuildMethod`, você cria a camada criando o aplicativo inteiro com o comando `sam build` ou especificando o recurso da função com o comando `sam build function-logical-id`.
## Exemplos
### Exemplo de modelo 1: Criar uma camada com o ambiente de runtime Python 3.12
O AWS SAM modelo de exemplo a seguir cria uma camada em relação ao ambiente de execução do Python 3.12.
```
Resources:
MyLayer:
Type: AWS::Serverless::LayerVersion
Properties:
ContentUri: my_layer
CompatibleRuntimes:
- python3.12
Metadata:
BuildMethod: python3.12 # Required to have AWS SAM build this layer
```
### Exemplo de modelo 2: Crie uma camada usando um makefile personalizado
O AWS SAM modelo de exemplo a seguir usa um personalizado `makefile` para criar a camada.
```
Resources:
MyLayer:
Type: AWS::Serverless::LayerVersion
Properties:
ContentUri: my_layer
CompatibleRuntimes:
- python3.12
Metadata:
BuildMethod: makefile
```
O seguinte `makefile` contém o destino da compilação e os comandos que serão executados. Observe que a propriedade `ContentUri` está definida como `my_layer`, portanto, o makefile deve estar localizado na raiz do subdiretório `my_layer` e o nome do arquivo deve ser `Makefile`. Observe também que os artefatos de construção são copiados para o `python/` subdiretório para que AWS Lambda você possa encontrar o código da camada.
```
build-MyLayer:
mkdir -p "$(ARTIFACTS_DIR)/python"
cp *.py "$(ARTIFACTS_DIR)/python"
python -m pip install -r requirements.txt -t "$(ARTIFACTS_DIR)/python"
```
**nota**
Quando o `makefile` é chamado, o destino apropriado é acionado e os artefatos devem ser copiados para a variável ambiental exposta `$ARTIFACTS_DIR`. Para obter mais informações, consulte [aws-lambda-builders em GitHub](https://github.com/aws/aws-lambda-builders/blob/develop/aws_lambda_builders/workflows/custom_make/DESIGN.md).
### Exemplo de comandos sam build
Os comandos `sam build` a seguir criam camadas que incluem as seções de atributos do recurso `Metadata`.
```
# Build the 'layer-logical-id' resource independently
$ sam build layer-logical-id
# Build the 'function-logical-id' resource and layers that this function depends on
$ sam build function-logical-id
# Build the entire application, including the layers that any function depends on
$ sam build
```