Usando a CLI do .NET Lambda Global

A CLI do .NET e a extensão .NET Lambda Global Tools (Amazon.Lambda.Tools) oferecem uma maneira multiplataforma de criar aplicações do Lambda baseadas no .NET, empacotá-las e implantá-las no Lambda. Nesta seção, você aprenderá a criar novos projetos do Lambda do .NET usando a CLI do .NET e os modelos do Amazon Lambda e a empacotá-los e implantá-los usando o Amazon.Lambda.Tools

Pré-requisitos

SDK do .NET 8

Se você ainda não o fez, instale o SDK e o runtime do .NET 8.

Modelos de projetos do AWS Amazon.Lambda.Templates do .NET

Para gerar o código da função do Lambda, use o Pacote do NuGet Amazon.Lambda.Templates. Para instalar esse pacote de modelo, execute o comando a seguir:

dotnet new install Amazon.Lambda.Templates

Ferramentas AWS Amazon.Lambda.Tools da CLI Global do .NET

Para criar as funções do Lambda, você usa a extensão .NET Global Tools do Amazon.Lambda.Tools. Para instalar Amazon.Lambda.Tools, execute o comando a seguir:

dotnet tool install -g Amazon.Lambda.Tools

Para obter mais informações sobre a extensão Amazon.Lambda.Tools da CLI do .NET, consulte o repositório AWS Extensions for .NET CLI no GitHub.

Criar projetos do .NET usando a CLI do .NET

Na CLI do .NET, você usa o comando dotnet new para criar projetos do .NET em uma linha de comando. O Lambda oferece modelos adicionais usando o pacote NuGet Amazon.Lambda.Templates.

Depois de instalar o pacote, execute o comando a seguir para ver uma lista dos modelos disponíveis.

dotnet new list

Para examinar detalhes sobre um modelo, use a opção help. Por exemplo, para ver detalhes sobre o modelo de lambda.EmptyFunction, execute o comando a seguir.

dotnet new lambda.EmptyFunction --help

Para criar um modelo básico para uma função do .NET Lambda, use o modelo lambda.EmptyFunction. Isso cria uma função simples que pega uma string como entrada e a converte em maiúsculas usando o método ToUpper. O modelo é compatível com as opções a seguir:

• --name: o nome da função.

• --region: a região da AWS na qual criar a função.

• --profile: o nome de um perfil no arquivo de credenciais do AWS SDK for .NET. Para saber mais sobre perfis de credenciais no .NET, consulte Configure AWS credentials no AWS SDK for .NET Developer Guide.

Neste exemplo, criamos uma nova função vazia denominada myDotnetFunction usando o perfil e as configurações do Região da AWS padrão:

dotnet new lambda.EmptyFunction --name myDotnetFunction

Esse comando cria os seguintes arquivos e diretórios no diretório do seu projeto.

└── myDotnetFunction
    ├── src
    │   └── myDotnetFunction
    │       ├── Function.cs
    │       ├── Readme.md
    │       ├── aws-lambda-tools-defaults.json
    │       └── myDotnetFunction.csproj
    └── test
        └── myDotnetFunction.Tests
            ├── FunctionTest.cs
            └── myDotnetFunction.Tests.csproj

No diretório src/myDotnetFunction, examine os seguintes arquivos:

• aws-lambda-tools-defaults.json: este é o local em que você especifica as opções de linha de comando ao implantar sua função do Lambda. Por exemplo:

    "profile" : "default",
    "region" : "us-east-2",
    "configuration" : "Release",
    "function-architecture": "x86_64",
    "function-runtime":"dotnet8",
    "function-memory-size" : 256,
    "function-timeout" : 30,
    "function-handler" : "myDotnetFunction::myDotnetFunction.Function::FunctionHandler"

• Function.cs: o código da função do manipulador do Lambda. É um modelo C # que inclui a biblioteca Amazon.Lambda.Core padrão e um atributo LambdaSerializer padrão. Para obter mais informações sobre os requisitos e as opções de serialização, consulte Serialização em funções do Lambda. Isso também inclui uma função de exemplo que você pode editar para aplicar o código de sua função do Lambda.

  using Amazon.Lambda.Core;
  
  // Assembly attribute to enable the Lambda function's JSON input to be converted into a .NET class.
  [assembly: LambdaSerializer(typeof(Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer))]
  
  namespace myDotnetFunction;
  
  public class Function
  {
  
      /// <summary>
      /// A simple function that takes a string and does a ToUpper
      /// </summary≫
      /// <param name="input"></param>
      /// <param name="context"></param>
      /// <returns></returns>
      public string FunctionHandler(string input, ILambdaContext context)
      {
          return input.ToUpper();
      }
  }

• myDotnetFunction.csproj: um arquivo MSBuild que lista os arquivos e assemblies que compõem a aplicação.

  <Project Sdk="Microsoft.NET.Sdk">
    <PropertyGroup>
      <TargetFramework>net8.0</TargetFramework>
      <ImplicitUsings>enable</ImplicitUsings>
      <Nullable>enable</Nullable>
      <GenerateRuntimeConfigurationFiles>true</GenerateRuntimeConfigurationFiles>
      <AWSProjectType>Lambda</AWSProjectType>
      <!-- This property makes the build directory similar to a publish directory and helps the AWS .NET Lambda Mock Test Tool find project dependencies. -->
      <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies>
      <!-- Generate ready to run images during publishing to improve cold start time. -->
      <PublishReadyToRun>true</PublishReadyToRun>
    </PropertyGroup>
    <ItemGroup>
      <PackageReference Include="Amazon.Lambda.Core" Version="2.2.0" />
      <PackageReference Include="Amazon.Lambda.Serialization.SystemTextJson" Version="2.4.0" />
    </ItemGroup>
  </Project>
  

• Readme: use este arquivo para documentar sua função do Lambda.

No diretório myfunction/test, examine os seguintes arquivos:

• myDotnetFunction.Tests.csproj: conforme observado anteriormente, este é um arquivo MSBuild que lista os arquivos e assemblies que compõem seu projeto de teste. Observe também que ele inclui a biblioteca Amazon.Lambda.Core, portanto, é possível integrar perfeitamente qualquer modelo do Lambda necessário para testar sua função.

  <Project Sdk="Microsoft.NET.Sdk">
     ... 
  
      <PackageReference Include="Amazon.Lambda.Core" Version="2.2.0 " />
     ...
  

• FunctionTest.cs: o mesmo arquivo de modelo de código C # que é incluído no diretório src. Edite esse arquivo para espelhar o código de produção de sua função e testá-lo antes de carregar sua função do Lambda em um ambiente de produção.

  using Xunit;
  using Amazon.Lambda.Core;
  using Amazon.Lambda.TestUtilities;
  
  using MyFunction;
  
  namespace MyFunction.Tests
  {
      public class FunctionTest
      {
          [Fact]
          public void TestToUpperFunction()
          {
  
              // Invoke the lambda function and confirm the string was upper cased.
              var function = new Function();
              var context = new TestLambdaContext();
              var upperCase = function.FunctionHandler("hello world", context);
  
              Assert.Equal("HELLO WORLD", upperCase);
          }
      }
  }
  

Implantar projetos do .NET usando a CLI do .NET

Para criar o pacote de implantação e implantá-lo no Lambda, você usa as ferramentas da CLI de Amazon.Lambda.Tools. Para implantar a função usando os arquivos que você criou nas etapas anteriores, primeiro navegue até a pasta que contém o arquivo .csproj da função.

cd myDotnetFunction/src/myDotnetFunction

Para implantar o código no Lambda como um pacote de implantação .zip, execute o comando a seguir. Escolha o nome da sua função.

dotnet lambda deploy-function myDotnetFunction

Durante a implantação, o assistente solicita que você selecione um Função de execução do Lambda. Para esse exemplo, selecione lambda_basic_role.

Depois de implantar a função, você poderá testá-la na nuvem usando o comando dotnet lambda invoke-function. Para o código de exemplo no modelo da lambda.EmptyFunction, você pode testar a função passando uma string usando a opção --payload.

dotnet lambda invoke-function myDotnetFunction --payload "Just checking if everything is OK"

Se a função foi implantada com sucesso, você deverá ver um resultado semelhante ao apresentado a seguir.

dotnet lambda invoke-function myDotnetFunction --payload "Just checking if everything is OK"
Amazon Lambda Tools for .NET Core applications (5.8.0)
Project Home: https://github.com/aws/aws-extensions-for-dotnet-cli, https://github.com/aws/aws-lambda-dotnet

Payload:
"JUST CHECKING IF EVERYTHING IS OK"

Log Tail:
START RequestId: id Version: $LATEST
END RequestId: id
REPORT RequestId: id  Duration: 0.99 ms       Billed Duration: 1 ms         Memory Size: 256 MB     Max Memory Used: 12 MB

Usar camadas Lambda com a CLI do .NET

nota

Usar camadas com funções em uma linguagem compilada, como C#, pode não oferecer a mesma quantidade de benefícios que com uma linguagem interpretada, como Python. Como C# é uma linguagem compilada, suas funções ainda precisam carregar manualmente quaisquer montagens compartilhadas na memória durante a fase inicial, o que pode aumentar os tempos de inicialização a frio. Em vez disso, recomendamos incluir qualquer código compartilhado no momento da compilação para aproveitar as otimizações integradas do compilador.

A CLI do .NET é compatível com comandos que ajudam a publicar camadas e implantar funções C# que consomem camadas. Para publicar uma camada em um bucket específico do Amazon S3, execute o seguinte comando no mesmo diretório do seu arquivo .csproj:

dotnet lambda publish-layer <layer_name> --layer-type runtime-package-store --s3-bucket <s3_bucket_name>

Em seguida, ao implantar sua função usando a CLI do .NET, especifique o ARN da camada a ser consumida no comando a seguir:

dotnet lambda deploy-function <function_name> --function-layers arn:aws:lambda:us-east-1:123456789012:layer:layer-name:1

Para obter um exemplo completo de uma função Hello World, consulte a amostra blank-csharp-com-layer.