Criando e publicando uma função AWS Lambda com o CLI do .NET Core

AWS Lambda é um serviço da AWS que nos permite criar aplicações no modelo serverless. Fornecendo suporte para as versões 2.1 e 3.1 do .NET Core, este serviço disponibiliza uma série de ferramentas que permite a criação, publicação e execução de uma função do AWS Lambda pelo CLI do .NET Core.

Curso Terraform - Fundamentos

Conhecer o curso

.NET Core CLI

A interface de linha de comando do .NET Core é uma ferramenta multiplataforma que disponibiliza nativamente recursos para a criação, desenvolvimento, execução e publicações de aplicações .NET Core. Além disso, também permite que terceiros forneçam pacotes NuGet que expandem seus recursos.

Neste artigo conheceremos os pacotes disponibilizados pela AWS Lambda, que nos permite gerenciar uma função diretamente pela linha de comando desta ferramenta.

Criando uma função AWS Lambda com CLI do .NET Core

Antes de mais nada é importante que tenha o SDK do .NET Core instalado na sua máquina. No momento da criação deste artigo, só há suporte para as versões 2.1 e 3.1 do .NET Core, então é necessário que instale uma dessas versões. Caso já tenha suporte para uma versão superior, opte por ela.

Também é importante que tenha uma conta na AWS e o AWS CLI configurado na sua máquina (esta configuração será utilizada para publicar a função Lambda). Você pode ver como fazer isso, no artigo sobre a instalação e configuração do AWS CLI do Gabriel.

Para criar uma função Lambda com o CLI do .NET Core, é necessário instalar o pacote Amazon.Lambda.Templates, que fornece uma série de templates do AWS Lambda. Esta instalação pode ser realizada com o comando abaixo:

dotnet new --install Amazon.Lambda.Templates

Note que ao instalar o pacote já serão listados os templates do AWS Lambda que foram disponibilizados na ferramenta:

No nosso caso iremos utilizar o template lambda.EmptyFunction, que permite a criação de uma função Lambda vazia:

dotnet new lambda.EmptyFunction --name ExemploFuncaoLambda

Este template irá criar um projeto com duas pastas: src e test; que contém, respectivamente, o projeto da função e o projeto de testes:

Outro arquivo importante é o aws-lambda-tools-defaults.json, presente no projeto da função. É nele que se deve informar as configurações do AWS Lambda que a função utilizará. Veremos isso em mais detalhes à frente.

Desenvolvendo a função AWS Lambda

Para este artigo criei uma função simples que retorna o nome da rua de acordo com o cep informado:

public class Function
{
    private static readonly HttpClient client = new HttpClient();
    
    /// <summary>
    /// A simple function that takes a brazilian zip code and return the street name
    /// </summary>
    /// <param name="input"></param>
    /// <param name="context"></param>
    /// <returns></returns>
    public async Task<string> FunctionHandlerAsync(string input, ILambdaContext context)
    {
        if(input != null){
            var streamTask = await client.GetStreamAsync($"https://viacep.com.br/ws/{input}/json/");
            var endereco = await JsonSerializer.DeserializeAsync<Endereco>(streamTask);
            return endereco.logradouro;
        }
        return "CEP não informado";
    }
}

Assim como o método Main do C#, a função Lambda pode ou não ser assíncrona. Neste exemplo estamos definindo uma função assíncrona.

Também note o uso da classe Endereco que possui a estrutura abaixo:

public class Endereco
{
    public string logradouro { get; set; }
}

Como o código da função mudou, é necessário alterar o projeto de teste:

public class FunctionTest
{
    [Fact]
    public void TestToUpperFunction()
    {
        var function = new Function();
        var context = new TestLambdaContext();
        var rua = function.FunctionHandlerAsync("01001000", context).Result;

        Assert.Equal("Praça da Sé", rua);
    }
}

Ele pode ser executado para verificar se está tudo certo com a função:

Com a função definida, podemos publicá-la no AWS Lambda.

Publicando a função no AWS Lambda com o CLI do .NET Core

Para publicar uma função no AWS Lambda, a primeira coisa que deve ser feita é configurar o arquivo aws-lambda-tools-defaults.json:

{
  "Information": [
    "This file provides default values for the deployment wizard inside Visual Studio and the AWS Lambda commands added to the .NET Core CLI.",
    "To learn more about the Lambda commands with the .NET Core CLI execute the following command at the command line in the project root directory.",
    "dotnet lambda help",
    "All the command line options for the Lambda command can be specified in this file."
  ],
  "profile":"default",
  "region" : "sa-east-1",
  "configuration": "Release",
  "framework": "netcoreapp3.1",
  "function-runtime": "dotnetcore3.1",
  "function-memory-size": 256,
  "function-timeout": 30,
  "function-handler": "ExemploFuncaoLambda::ExemploFuncaoLambda.Function::FunctionHandlerAsync"
}

Neste arquivo, na opção profile, deve ser informado qual credencial configurada com o AWS CLI será utilizada para a publicação da função. Esta credencial precisa ter permissão de criação de funções Lambda. Geralmente se apenas uma credencial estiver configurada, ela receberá o nome de default.

Nas demais opções temos:

• region: Região do AWS que a função será publicada;
• configuration: Tipo de configuração da função, pode ser “Debug” ou “Release”;
• framework: Framework utilizado para compilar a função;
• function-runtime: Framework utilizado para executar a função;
• function-memory-size: Limite de memória utilizada pela função em MB. Deve ser informado um múltiplo de 64.
• function-timeout: Tempo máximo de execução da função em segundos. Tempo máximo, 15 minutos;
• function-handler: Caminho da função, segundo o padrão: Projeto::Namespace.Classe::Metodo.

Já para publicar a função iremos utilizar a global tool Amazon.Lambda.Tools, que pode ser instalada com o comando abaixo:

dotnet tool install -g Amazon.Lambda.Tools

Após a instalação dela, acesse a pasta do projeto da função e execute o comando:

dotnet lambda deploy-function FuncaoExemplo --function-role role

No atributo --function-role deve ser informado quais permissões a função terá. Isso determinará se ela terá acesso a outros serviços da AWS. Caso não seja informado, as permissões podem ser definidas durante a publicação da função. Como já tenho uma role de teste definida, vou utilizá-la para publicar a função:

Se a publicação não apresentou nenhum erro, podemos testar a nossa função.

Curso Django - Tópicos de segurança

Conhecer o curso

Executando a função no AWS Lambda com o CLI do .NET Core

Com a função publicada no Lambda, ela pode ser invocada pelo CLI do .NET Core utilizando a opção lambda invoke-function, seguido do nome da função. Por exemplo:

dotnet lambda invoke-function FuncaoExemplo --payload "01001000"

Também note o atributo --payload, onde pode ser informado os dados que serão passados para a função. Ao executar este comando, a função será chamada e será exibido no terminal o seu retorno:

Caso queira excluir a sua função, pode ser utilizado o comando abaixo:

dotnet lambda delete-function FuncaoExemplo

Por fim, mesmo que a maioria das opções que vimos aqui estejam disponíveis no AWS CLI, os recursos adicionados no CLI do .NET Core, facilitam e muito o trabalho de quem desenvolve funções Lambda em C#. Se este é o seu caso, também não deixe de dar uma olhada nos demais recursos disponíveis, utilizando o comando dotnet lambda --help.

É isso por hoje. Você pode ver o código completo da função no meu Github.

Até a próxima :)