Centro do desenvolvedor/.NET na AWS/...

Workloads do .NET no AWS Lambda

MÓDULO 6

VISÃO GERAL DO CURSO
INTRODUÇÃO AO AWS LAMBDA
FERRAMENTAS PARA DESENVOLVIMENTO EM .NET
.NET NO AWS LAMBDA
TRABALHAR COM OUTROS SERVIÇOS DA AWS
TESTE DE UNIDADE E DEPURAÇÃO
LABORATÓRIO PRÁTICO: CRIE E IMPLANTE FUNÇÕES DO LAMBDA
AVALIAÇÃO DE HABILIDADES

Módulo 6: Laboratório prático: criar e implantar funções do Lambda

 LABORATÓRIO PRÁTICO

Objetivos do laboratório

Nesses laboratórios, você colocará em prática o que aprendeu neste curso

Você criará uma variedade de funções do Lambda no .NET 6/7, além de implantá-las e invocá-las.

Existem 3 laboratórios neste módulo:

Laboratório 1: Aplicação Web do .NET 6 em execução no Arm64
Laboratório 2: Invocar uma função do Lambda de um programa C# no computador
Laboratório 3: Invocar uma função do Lambda a partir de outra

Pré-requisitos

Você não tem uma conta da AWS.

Um de seus usuários da AWS tem a política AdministratorAccess anexada. Consulte a seção Uma nota sobre permissões, no módulo 3 para obter mais detalhes./p>

Você instalou o SDK do .NET 6.

Você instalou as extensões da AWS para a CLI do .NET (dotnet lambda...).

Você instalou os modelos principais do AWS Lambda para o .NET Core.

Você instalou o PowerShell. Se você precisar instalá-lo para Window/Mac/Linux, consulte https://github.com/PowerShell/PowerShell.

Você pode encontrar mais informações sobre as ferramentas acima no módulo 2.

Você tem um bucket do S3 para pilhas do CloudFormation. Caso contrário, siga as instruções abaixo.

 Tempo para a conclusão

45 minutos

Laboratório 1: Aplicação Web do .NET 6 em execução no Arm64

Etapa 1: Criar o projeto

Com isso, você criará um projeto .NET sem servidor.

1. Crie um projeto .NET sem servidor

dotnet new serverless.AspNetCoreWebApp -n AspNetCoreWebApp
Isso criará o projeto dentro do diretório AspNetCoreWebApp\src\AspNetCoreWebApp.
2. Abra o projeto
Abra este projeto em seu IDE favorito.

Etapa 2: Fazer algumas alterações no código

Nesta etapa, você modificará o código do projeto gerado.
1. Atualize o Index.cshtml.cs
Depois de abrir o projeto no IDE, abra Pages/Index.cshtml.cs no editor de código.

Você pode deixar a instrução de uso e o namespace como estão, mas substitua a classe IndexModel pela seguinte: 
public class IndexModel : PageModel
{
    public string? Architecture { get; set; }
    public string? DotnetVersion { get; set; }
    
    public void OnGet()
    {
        Architecture = System.Runtime.InteropServices.RuntimeInformation.ProcessArchitecture.ToString();
        DotnetVersion = Environment.Version.ToString();
    }
}

2. Atualizar o Index.cshtml

Abra o arquivo Pages/index.cshtml.

Substitua o conteúdo do arquivo, incluindo </h2>, por: 
@page
@model IndexModel
@{
    ViewData["Title"] = "Home page";
}

<div class="text-center">
  <h1 class="display-4">Welcome to .NET Lambda functions on AWS!</h1>
  <h2>Your application is using .NET <code>@Model.DotnetVersion</code>, <code>@Model.Architecture</code>.</h2>
</div>
Deixe o elemento <svg>no lugar.

Essas alterações permitirão que você veja qual versão do .NET você está executando e o tipo de processador que está usando

Etapa 3: Configurar a arquitetura do processador

Nesta etapa, você definirá a arquitetura do processador como Arm64.
1. Altere a arquitetura do processador para Arm64
Mais uma mudança.

Abra o arquivo serverless.template.

Encontre a tecla “Handler” e adicione a próxima linha: 
"Architectures": ["arm64"],
Seu bloco de código deve ter a seguinte aparência agora: 
"AspNetCoreFunction": {
  "Type": "AWS::Serverless::Function",
  "Properties": {
    "Handler": "AspNetCoreWebApp::AspNetCoreWebApp.LambdaEntryPoint::FunctionHandlerAsync",
    "Architectures": ["arm64"],
2. Salvar e criar
Salve todas as suas alterações e crie a aplicação para não receber nenhum erro de compilação.

Etapa 4: implantar a função

Nesta etapa, você implantará e testará a função do Lambda.
1. Implante a função na AWS
Na linha de comando, execute: 
dotnet lambda deploy-serverless --stack-name AspNetCoreWebApp --s3-bucket your-unique-bucket-name1234
Deixe que a AWS implante a função do Lambda.

Você verá resultado em cada etapa da implantação, à medida que ela é trabalhada e concluída. 
8/9/2022 1:45 PM     AspNetCoreFunctionProxyResourcePermissionProd CREATE_COMPLETE
8/9/2022 1:45 PM     AspNetCoreWebApp                         CREATE_COMPLETE
Stack finished updating with status: CREATE_COMPLETE

Output Name                    Value
------------------------------ --------------------------------------------------
ApiURL                         https://xxxxxxxxx.execute-api.us-east-1.amazonaws.com/Prod/
2. Crie um projeto do .NET WebAPI
No final da saída, haverá um ApiURL, abra-o em seu navegador.

Etapa 5: Limpar

Nesta etapa, você excluirá o projeto sem servidor da AWS.
1. Exclua o projeto sem servidor
Para remover todos os recursos criados durante a execução: 
dotnet lambda delete-serverless --stack-name AspNetCoreWebApp

Laboratório 2: Invocar uma função do Lambda de um programa C# no computador

Etapa 1: Criar a função do Lambda

Nesta etapa, você criará um projeto Lambda vazio.

1. Crie o projeto

Se você ainda estiver no diretório que criou para o laboratório anterior, mova-o para um diretório limpo. Crie uma nova função do Lambda na linha de comando:

dotnet new lambda.EmptyFunction -n GetS3Buckets
Isso criará o projeto dentro do diretório AspNetCoreWebApp\src\AspNetCoreWebApp.

Etapa 2: Alterações no código

Nesta etapa, você modificará o código do projeto gerado.

1. Adicionar pacote

Vá para a pasta GetS3Buckets\src\ GetS3Buckets e adicione o pacote AWS SDK S3 ao projeto:

cd GetS3Buckets\src\ GetS3Buckets
dotnet add package AWSSDK.S3

2. Atualize o Function.cs

Abra o Function.cs no IDE e substitua o código por:

using Amazon.Lambda.Core;
using Amazon.S3;
using Amazon.S3.Model;

// 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 GetS3Buckets;

public class Function
{
   public async Task<IEnumerable<string>> FunctionHandler(ILambdaContext context)
    {
        var s3Client = new AmazonS3Client();

        ListBucketsRequest listBucketsRequest = new ListBucketsRequest();
        ListBucketsResponse listBucketsResponse = await s3Client.ListBucketsAsync(listBucketsRequest);

        var bucketNames = listBucketsResponse.Buckets.Select(b => b.BucketName);

        return bucketNames;
    }
}

Etapa 3: implantar a função

Nesta etapa, você implantará e testará a função do Lambda.

1. Implante a função na AWS

Implante a função na AWS usando:

dotnet lambda deploy-function GetS3Buckets

Quando for necessário selecionar um perfil, escolha a opção de criar um novo. Use o nome GetS3BucketsRole para o perfil.

Quando for necessário anexar uma política, escolha a opção AWSLambdaBasicExecutionRole, que é a número 6 na minha lista.

Etapa 4: Adicionar permissão para ListAllMyBuckets

Nesta etapa, você adicionará permissões para listar seus buckets do S3.

1. Criar política de IAM

A política que você anexou à função não tem a permissão necessária para listar os buckets do S3.

Crie um novo arquivo chamado S3ListAllMyBucketsPolicy.json.

Cole o seguinte no arquivo -

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "s3:ListAllMyBuckets",
            "Resource": "*"
        }
    ]
}

2. Adicionar política ao perfil

Adicione a política ao GetS3BucketsRole:

aws iam put-role-policy --role-name GetS3BucketsRole --policy-name ListAllMyBuckets --policy-document file://S3ListAllMyBucketsPolicy.json

Aguarde alguns instantes para que as permissões sejam aplicadas.

Etapa 5: Invocar a função do Lambda na linha de comando

Nesta etapa, você implantará e testará a função do Lambda.

1. Invoque a função na linha de comando

Antes de criar um programa em C# para invocar a função, tente invocá-la pela linha de comando:

dotnet lambda invoke-function --function-name GetS3Buckets

Você deverá ver um resultado que lista todos os buckets.

Isso verificará se a função do Lambda funciona conforme o esperado.

Etapa 6: Invocar a função do Lambda na linha de comando

Nesta etapa, você criará um programa em C# que invoca a função do Lambda.

1. Crie uma aplicação do console

Crie uma aplicação do console .NET usando:

dotnet new console -n GetS3BucketsCallFromLocal

2. Adicionar o pacote AWSSDK.Lambda

Vá para a pasta GetS3BucketsCallFromLocal.

cd GetS3BucketsCallFromLocal

Adicione o pacote AWS SDK Lambda, isso permite invocar funções do Lambda:

dotnet add package AWSSDK.Lambda

3. Atualize o Program.cs

Abra o arquivo Program.cs e substitua-o por:

using System.Text.Json;
using Amazon.Lambda;
using Amazon.Lambda.Model;

AmazonLambdaClient client = new AmazonLambdaClient();

var request = new InvokeRequest
{
    FunctionName = "GetS3Buckets"
};

var result = await client.InvokeAsync(request);

var buckets = JsonSerializer.Deserialize<IEnumerable<string>>(result.Payload);

foreach (var bucket in buckets)
{
    Console.WriteLine(bucket);
}

Etapa 7: Experimente

Nesta etapa, você testará o programa do console e invocará a função do Lambda.

1. Execute a aplicação do console

Na linha de comando do diretório GetS3BucketsCallFromLocal, execute:

dotnet run

Você deverá ver uma lista de nomes de buckets.

Etapa 8: Limpar

Você vai usar essa função no próximo laboratório, então não há limpeza por enquanto.

Laboratório 3: Invocar uma função do Lambda a partir de outra

Etapa 1: Criar a função GetS3Buckets

Conclua o laboratório anterior.

Etapa 2: Criar uma função do Lambda

Nesta etapa, você criará uma função do Lambda para chamar as funções GetS3Buckets.

1. Crie um projeto Lambda vazio

Na linha de comando, execute:

dotnet new lambda.EmptyFunction -n GetS3BucketsCallFromLambdaFunction

2. Alterar pasta

Vá para o diretório GetS3BucketsCallFromLambdaFunction\src\GetS3BucketsCallFromLambdaFunction.

Etapa 3: Atualizar o código

Nesta etapa, você atualizará o código do projeto.

1. Adicionar o pacote AWSSDK.Lambda

Adicione o pacote AWS SDK Lambda ao projeto:

dotnet add package AWSSDK.Lambda

2. Atualize o Function.cs

Abra o arquivo Function.cs e substitua o código por:

using Amazon.Lambda;
using Amazon.Lambda.Core;
using Amazon.Lambda.Model;
using System.Text.Json;
// 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 GetS3BucketsCallFromLambdaFunction;

public class Function
{
    
    public async Task<IEnumerable<string>> FunctionHandler(ILambdaContext context)
    {
        AmazonLambdaClient client = new AmazonLambdaClient();

        var request = new InvokeRequest
        {
            FunctionName = "GetS3Buckets",
        };

        var result = await client.InvokeAsync(request);

        var bucketNames = JsonSerializer.Deserialize<IEnumerable<string>>(result.Payload);

        return bucketNames;
    }
}

Neste exemplo, a função do Lambda GetS3BucketsCallFromLambdaFunction está chamando a função GetS3Buckets e retornando a resposta, sem fazer alterações na resposta.

Etapa 4: Implantar a função GetS3BucketsCallFromLambdaFunction

Nesta etapa, você implantará a função do Lambda GetS3BucketsCallFromLambdaFunction na AWS.

1. Implante a função

Na linha de comando, execute:

dotnet lambda deploy-function GetS3BucketsCallFromLambdaFunction

2. Crie o perfil

Crie um novo perfil para a função chamada 

GetS3BucketsCallFromLambdaFunctionRole.

3. Anexar política ao perfil

Anexe a política AWSLambdaBasicExecutionRole ao perfil.

Etapa 5: Tentar invocar a GetS3BucketsCallFromLambdaFunction

Nesta etapa, você tentará invocar a função.

1. Implante a função

Tente invocar GetS3BucketsCallFromLambdaFunctionRole:

dotnet lambda invoke-function --function-name GetS3BucketsCallFromLambdaFunction

Você receberá um erro como o abaixo:

Payload:
{
  "errorType": "AmazonLambdaException",
  "errorMessage": "User: arn:aws:sts::000000000000:assumed-role/GetS3BucketsCallFromLambdaFunctionRole/GetS3BucketsCallFromLambdaFunction 
is not authorized to perform: lambda:InvokeFunction on resource: arn:aws:lambda:us-east-1:000000000000:function:GetS3Buckets because no 
identity-based policy allows the lambda:InvokeFunction action",

Isso ocorre porque GetS3BucketsCallFromLambdaFunction requer permissões para invocar GetS3Buckets.

Na próxima etapa, você adicionará uma política em linha que concede a GetS3BucketsCallFromLambdaFunction a permissão necessária.

Etapa 6: Conceder permissão à função GetS3BucketsCallFromLambdaFunction para invocar GetS3Buckets

Nesta etapa, você concederá permissões a GetS3BucketsCallFromLambdaFunction para invocar GetS3Buckets.

1. Obtenha o ARN de GetS3Buckets

Antes de conceder direitos de invocação para GetS3BucketsCallFromLambdaFunction, você precisa obter o Nome do recurso da Amazon (ARN) de GetS3Buckets.

Você pode fazer isso de duas maneiras. Primeiro do Console da AWS. Acesse o serviço do Lambda e selecione a função GetS3Buckets

Você pode clicar em Copiar ARN nas duas áreas destacadas.

Para obter o ARN de GetS3Buckets na linha de comando, execute:

dotnet lambda get-function-config GetS3Buckets

Você verá um resultado semelhante a -

Página inicial do projeto: https://github.com/aws/aws-extensions-for-dotnet-cli,

 https://github.com/aws/aws-lambda-dotnet

Name:                         GetS3Buckets
Arn:                          arn:aws:lambda:us-east-1:000000000000:function:GetS3Buckets
Package Type:                 Zip
Runtime:                      dotnet6
Function Handler:             GetS3Buckets::GetS3Buckets.Function::FunctionHandler
Last Modified:                2022-08-10T13:58:29.211+0000
Memory Size:                  256
Ephemeral Storage Size:       512
Role:                         arn:aws:iam::000000000000:role/GetS3Buckets
Timeout:                      30
Version:                      $LATEST
State:                        Active
Last Update Status:           Successful
KMS Key ARN:                  (default) aws/lambda

Muitas informações úteis, mas o que você quer está na segunda linha da tabela, o Arn.

Crie um arquivo chamado InvokeGetS3Buckets.json e adicione o seguinte:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action":[
                "lambda:InvokeFunction"
            ],
            "Resource": "arn:aws:lambda:us-east-1:000000000000:function:GetS3Buckets"
        }
    ]
}
Repl

Substitua o “Recurso” pelo ARN da função do Lambda que você obteve da linha de comando ou da interface do console.

2. Atualize as permissões

Execute o seguinte:

aws iam put-role-policy --role-name GetS3BucketsCallFromLambdaFunctionRole
 --policy-name InvokeGetS3BucketsFunction 
 --policy-document file://InvokeGetS3Buckets.json

Pode levar alguns minutos para que as permissões sejam atualizadas na AWS.

Etapa 7: invocar a função GetS3BucketsCallFromLambdaFunction novamente

Nesta etapa, você invocará novamente a função.

1. Invoque a função com dotnet lambda invoke-function

Desta vez, você poderá invocar a função:

dotnet lambda invoke-function --function-name GetS3BucketsCallFromLambdaFunction

Conclusão

Nesses laboratórios, você coloca o que aprendeu em prática. Você primeiro criou uma aplicação Web que pode ser acessada de qualquer lugar do mundo. Em seguida, você implantou uma função do Lambda que você invocou diretamente de um programa C# em seu computador. Em seguida, você cria o segundo laboratório implantando outra função do Lambda e invocando uma função do Lambda a partir de outra. Você também teve que resolver os problemas de permissão à medida que eles surgiram.

A partir daqui, você pode experimentar o uso de outros serviços da AWS com funções do Lambda e criar aplicações do Lambda mais complexas.

Essa página foi útil?

 Feedback
Iniciar o módulo sete

Avaliação de habilidades