CLI de .NET Core - AWS Lambda

CLI de .NET Core

La CLI de .NET Core ofrece una manera multiplataforma de crear aplicaciones de Lambda basadas en .NET. En esta sección se presupone que ha instalado la CLI de .NET Core. Si no lo ha hecho, vea Descargar .NET en el sitio web de Microsoft.

En la CLI de .NET se usa el comando new para crear proyectos .NET desde una línea de comando. Esto resulta útil si desea crear un proyecto fuera de Visual Studio. Para ver una lista de los tipos de proyectos disponibles, abra una línea de comando, vaya hasta la ubicación donde instaló el entorno en tiempo de ejecución de .NET Core y ejecute el siguiente comando:

dotnet new -all
Usage: new [options]
...
Templates                                         Short Name         Language          Tags                             
----------------------------------------------------------------------------------------------------------------------------
Console Application                               console            [C#], F#, VB      Common/Console                   
Class library                                     classlib           [C#], F#, VB      Common/Library                   
Unit Test Project                                 mstest             [C#], F#, VB      Test/MSTest                      
xUnit Test Project                                xunit              [C#], F#, VB      Test/xUnit                       
...
Examples:
    dotnet new mvc --auth Individual
    dotnet new viewstart
    dotnet new --help

Lambda ofrece plantillas adicionales a través del paquete Nuget de Amazon.Lambda.Templates. Para instalar este paquete, ejecute el comando siguiente:

dotnet new -i Amazon.Lambda.Templates

Una vez completada la instalación, las plantillas de Lambda; aparecen como parte de dotnet new. Para examinar los detalles acerca de una plantilla, utilice la opción help.

dotnet new lambda.EmptyFunction --help

La plantilla lambda.EmptyFunction es compatible con las siguientes opciones:

Estas opciones se guardan en un archivo denominado aws-lambda-tools-defaults.json.

Cree un proyecto de función con la plantilla lambda.EmptyFunction.

dotnet new lambda.EmptyFunction --name MyFunction

En el directorio src/myfunction, examine los archivos siguientes:

  • aws-lambda-tools-defaults.json: aquí se especifican las opciones de línea de comando al implementar su función de Lambda. Por ejemplo:

      "profile" : "default",
  "region" : "us-east-2",
  "configuration" : "Release",
  "function-runtime":"dotnet6",
  "function-memory-size" : 256,
  "function-timeout" : 30,
  "function-handler" : "MyFunction::MyFunction.Function::FunctionHandler"

  • Function.cs: el código de la función de controlador de Lambda. Es una plantilla de C# que incluye la biblioteca Amazon.Lambda.Core predeterminada y un atributo LambdaSerializer predeterminado. Para obtener más información acerca de las opciones y los requisitos de serialización, consulte Serialización de las funciones de Lambda. También incluye una función de muestra que puede editar para aplicar el código de su función de Lambda.

    using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

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 MyFunction
{
    public class Function
    {      
      
        public string FunctionHandler(string input, ILambdaContext context)
        {
            return input.ToUpper();
        }
    }
}

  • MyFunction.csproj: archivo MSBuild que enumera los archivos y ensamblados que componen la aplicación.

    <Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <TargetFramework>net6.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
    <GenerateRuntimeConfigurationFiles>true</GenerateRuntimeConfigurationFiles>
    <AWSProjectType>Lambda</AWSProjectType>
    <!-- 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.1.0 " />
    <PackageReference Include="Amazon.Lambda.Serialization.SystemTextJson" Version="2.2.0" />
  </ItemGroup>

</Project>

  • Readme: use este archivo para documentar su función de Lambda.

En el directorio myfunction/test, examine los archivos siguientes:

  • myFunction.Tests.csproj: como se ha indicado anteriormente, este es un archivo MSBuild que enumera los archivos y los ensamblados que componen su proyecto de prueba. Tenga en cuenta que también incluye la biblioteca Amazon.Lambda.Core, de modo que puede integrar a la perfección cualquier plantilla de Lambda necesaria para probar la función.

    <Project Sdk="Microsoft.NET.Sdk">
   ... 

    <PackageReference Include="Amazon.Lambda.Core" Version="2.1.0 " />
   ...

  • FunctionTest.cs: el mismo archivo de plantilla de código C# que se incluye en el directorio src. Edite este archivo para reflejar el código de producto de su función y probarlo antes de cargar su función de Lambda en un entorno de producción.

    using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

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);
        }
    }
}

Una vez que la función ha superado las pruebas, puede crearla e implementarla mediante la herramienta de .NET Core Global Amazon.Lambda.Tools. Para instalar la herramienta de .NET Core Global, ejecute el siguiente comando:

dotnet tool install -g Amazon.Lambda.Tools

Si ya tiene la herramienta instalada, puede asegurarse de que es la versión más reciente usando el siguiente comando:

dotnet tool update -g Amazon.Lambda.Tools

Para obtener más información acerca de la herramienta global básica de Amazon.Lambda.Tools, consulte el repositorio AWS Extensions for .NET CLI en GitHub.

Con las herramientas Amazon.Lambda.Tools instalados, puede implementar su función con el siguiente comando:

dotnet lambda deploy-function MyFunction --function-role role

Después de la implementación, puede volver a probarla en un entorno de producción con el comando siguiente y pasar un valor distinto al controlador de la función de Lambda:

dotnet lambda invoke-function MyFunction --payload "Just Checking If Everything is OK"

Si todo es correcto, verá lo siguiente:

dotnet lambda invoke-function MyFunction --payload "Just Checking If Everything is OK"
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