Módulo 1: Introdução ao AWS Lambda
MÓDULO DE APRENDIZAGEM
Visão geral
Neste tutorial, você aprenderá a usar o.NET com o AWS Lambda. Nenhum conhecimento prévio do AWS Lambda é exigido, mas você deve estar familiarizado com a AWS e com o.NET. Neste curso, você aprenderá a criar, implantar, executar, testar e depurar funções do Lambda .NET usando a linha de comando, o Visual Studio, o Visual Studio Code e o Rider.
Neste módulo introdutório, você aprenderá o que é computação sem servidor, seus benefícios e como isso se relaciona com o AWS Lambda. Isso é seguido por dois exemplos de como é fácil começar a usar o .NET nas funções do AWS Lambda.
Tempo para a conclusão
45 minutos
Computação sem servidor
Antes de falar sobre computação sem servidor, vamos abordar a computação tradicional por um momento.
Muitas empresas, pequenas e grandes, usam servidores locais ou servidores baseados em datacenters para executar suas aplicações. Quando essas empresas precisam de mais servidores, elas precisam comprá-los, instalá-los fisicamente, configurá-los, protegê-los e mantê-los. (Em alguns casos, um datacenter pode se encarregar de instalá-los fisicamente para você, mas ainda será necessário fazer todo o resto.)
Quando tudo isso for feito, a empresa poderá implantar as aplicações nesses servidores. Para muitas empresas, isso pode levar semanas ou meses. Esses atrasos tradicionalmente dificultam a escala das aplicações.
A computação em nuvem facilitou muitas dessas tarefas. Uma empresa pode iniciar uma instância de um servidor (ou várias instâncias) em minutos. A empresa pode criar suas próprias imagens de máquina com a máquina virtual e o sistema operacional configurados da maneira que quiserem. Isso reduz o volume de configuração necessário quando o servidor é iniciado, mas eles ainda precisam manter o servidor atualizado com patches, atualizações de segurança e atualizações de software, etc.
Em muitos casos, esses servidores geralmente são mantidos em funcionamento 24 horas por dia, 7 dias por semana, mesmo que não estejam em uso o tempo todo. Os servidores geralmente são provisionados para lidar com o pico de workloads que a aplicação espera. Mas fora desse pico, os servidores estão pelo menos parcialmente inativos. Políticas de escalabilidade apropriadas podem ser usadas para reduzir a ajuda com esse problema, mas pode ser difícil acertar essas políticas.
Além disso, o trabalho de provisionar e manter os servidores e o tempo que eles passam inativos geram custos que não estão beneficiando diretamente a empresa.
Uma alternativa para isso é a computação sem servidor. Não há servidores, não há manutenção, e escalabilidade é feita para você. Você escreve seu código, o implanta e deixa a AWS cuidar da infraestrutura para você.
A AWS oferece duas opções para computação sem servidor: o AWS Fargate para aplicações baseadas em contêineres e o AWS Lambda para aplicações orientadas por eventos.
AWS Lambda
O AWS Lambda é um serviço de computação sem servidor que executa o código em resposta aos eventos recebidos pelo serviço. Os eventos podem ser gerados por outros serviços da AWS, como SNS, SQS, S3, DynamoDB, API Gateway, etc.
O uso de uma API Gateway ou URLs da função do Lambda permite que você acione uma função do Lambda para ser executada em resposta a uma solicitação HTTP. As funções do Lambda também podem ser invocadas diretamente, embora isso também seja considerado um evento.
Você não precisa provisionar nenhuma infraestrutura para usar o AWS Lambda. A AWS também cuida da escalabilidade automática para atender às necessidades das aplicações, sejam algumas execuções por dia ou dezenas de milhares por segundo. A infraestrutura do Lambda, gerenciada pela AWS, é altamente disponível e tolerante a falhas.
Com as funções do Lambda, você paga apenas pelos recursos computacionais que usar. Quando seu código não estiver em execução, você não paga nada.
Você escreve as aplicações .NET usando os IDEs que você já conhece e, com a ajuda das ferramentas da AWS (ou de um IaC de sua escolha), implanta a aplicação no AWS Lambda.
Quando uma função do Lambda for invocada por um evento, um ambiente de execução será criado, o código de inicialização será executado (construtores, etc.) e, em seguida, o código para lidar com o evento será executado.
Quando a execução for concluída, o ambiente de execução permanecerá disponível para reutilização por um período de tempo não determinista.
Se outro evento chegar, o mesmo ambiente de execução será usado e o código de inicialização não será executado novamente.
Se nenhum ambiente de execução estiver disponível, um novo será criado e o código de inicialização será executado novamente.
Atualmente, as funções do AWS Lambda fornecem runtimes gerenciados para o.NET Core 3.1 e .NET 6. Se quiser escrever aplicações em outras versões do.NET, você poderá usar runtimes personalizados do Lambda ou uma versão baseada em contêiner da sua aplicação.
A AWS fornece modelos de projetos em C# e F# para funções do Lambda. Eles podem ser usados na linha de comando, Visual Studio, Visual Studio Code e Rider.
Você pode executar sua função do Lambda .NET nos processadores x86_64 e arm64. A escolha da arquitetura do processador não afeta a forma como você escreve suas aplicações. A implantação no processador de sua escolha é uma simples questão de alterar um único parâmetro de configuração.
Principais atributos do AWS Lambda
Você não precisa aprender uma nova linguagem. Use seu conhecimento existente de C# e F# para escrever as funções do Lambda.
Você pode usar as funções do Lambda com outros serviços da AWS, como SNS, SQS, S3, Step Functions e DynamoDB, para criar aplicações orientadas por eventos. Ou execute tarefas personalizadas em resposta aos eventos desses serviços.
Se você precisar orquestrar várias funções do Lambda em execução, poderá usar o AWS Step Functions. Com o Step Functions, você cria uma máquina de estado que gerencia a execução de suas funções do Lambda.
Não é necessário provisionar ou gerenciar a infraestrutura. A AWS cuida de tudo isso para você. Tudo o que você precisa decidir é a arquitetura do processador e a quantidade de memória a ser alocada para a função. Com base na sua escolha de memória, a AWS escolherá a velocidade da CPU, a largura de banda da rede e a E/S de disco apropriadas.
Suas funções do Lambda são altamente disponíveis e tolerantes a falhas, sendo executadas em várias zonas de disponibilidade em cada região.
As funções do AWS Lambda começam em milissegundos após a chegada de um evento e podem ser escaladas de forma rápida e automática para corresponder ao volume de eventos recebidos.
Você paga apenas pelo que usa, o que é cobrado pelo milissegundo de uso.
O Lambda tem um nível generoso e sempre gratuito, permitindo que você execute um milhão de solicitações gratuitas por mês e 400.000 GB-segundos de tempo de computação por mês
Se você tiver padrões de tráfego intermitentes, o Lambda será escalado para atender a essas necessidades e, quando o tráfego diminuir, você não pagará pelos recursos que não forem mais necessários.
O Lambda faz parte dos Savings Plans para computação, que oferecem preços mais baixos em troca de um compromisso de usar uma certa quantidade de tempo de computação em um período de um a três anos.
Na próxima seção, você verá como é fácil começar a usar o AWS Lambda. Com apenas alguns minutos de trabalho, você terá duas funções do AWS Lambda no .NET em execução na nuvem
Dois exemplos de como é fácil começar a usar as funções do AWS Lambda no .NET
Tempo estimado: 30 minutos
Observe que você pode seguir os exemplos apresentados aqui, mas isso não é necessário.
Se você nunca trabalhou com tecnologia sem servidor, poderá parecer assustador no começo. Até mesmo saber como começar poderá ser difícil de descobrir.
Ao final deste breve módulo, você terá duas funções do Lambda no .NET em execução na AWS.
Uma é invocada pela linha de comando e a outra por meio de um endpoint HTTPS público que você configurará quase sem esforço.
Você usará a linha de comando para criar, compilar e implantar os dois exemplos.
Pré-requisitos
1. Uma conta da AWS.
Se você não tiver uma conta da AWS, consulte esta página sobre como criar e ativar uma conta. Quando você cria uma nova conta, um nível gratuito é ativado automaticamente para você. O nível gratuito fornece o uso gratuito de determinados serviços da AWS até um limite. Saiba mais sobre o nível gratuito aqui.
2. Uma CLI da AWS instalada e configurada.
Se você não tiver a CLI da AWS, faça o download e instale-a. Em seguida, configure a CLI da AWS com suas credenciais e região padrão. Sua escolha de região padrão dependerá da sua localização geográfica e dos serviços da AWS que você quiser usar. A disponibilidade do serviço varia de acordo com a região.
O usuário da AWS deve ter a política AdministratorAccess anexada. Consulte a seção Uma nota sobre permissões, no módulo 3, para obter mais detalhes.
3. O SDK do .NET 6
Se você não tiver o SDK. do NET 6 instalado, faça o download e instale-o.
Obtenha as ferramentas e os modelos
Um módulo posterior explicará mais sobre as ferramentas e os modelos disponíveis, mas, por enquanto, você pode começar executando os dois comandos abaixo:
dotnet tool install -g Amazon.Lambda.Tools
dotnet new -i Amazon.Lambda.TemplatesDemonstração 1: O “Hello World!” das funções Lambda
Essa é a função do Lambda mais básica que você pode escrever. Ela recebe entradas e retorna uma resposta, e estará em execução em alguns minutos.
Etapa 1 - Crie um projeto .NET
Na janela da linha de comando/terminal, execute o comando a seguir para criar uma nova função do Lambda.
dotnet new lambda.EmptyFunction -n HelloLambdaEtapa 2 - Implantar a função do Lambda
Vá para o diretório HelloLambda/src/HelloLambda:
cd HelloLambda/src/HelloLambda
Se você estiver interessado, abra o projeto nesse diretório. Você verá um arquivo chamado Function.cs. É aí que o código que executa a função estará localizado. Não altere nada no arquivo por enquanto.
Na linha de comando, execute o seguinte comando para implantar a função:
dotnet lambda deploy-function --function-name HelloLambda
Você verá uma saída parecida com a abaixo.
O AWS Toolkit for Visual Studio não oferece suporte ao trabalho com seu registro público de ECR nem à habilitação de atributos como verificação automatizada e criptografia de repositórios para novos repositórios em seu registro privado. Se esses atributos forem necessários, crie repositórios usando o Console de Gerenciamento da AWS ou as ferramentas de linha de comando, como a CLI da AWS e as ferramentas da AWS para PowerShell.
Nesse momento, duas coisas poderão acontecer.
- Se não houver perfis em sua conta da AWS, você deverá “Inserir o nome do novo perfil do IAM”. Faça isso. Use o nome HelloLambdaRole.
- Se houver perfis em sua conta da AWS, você verá uma lista, mas na parte inferior aparecerá Criar novo perfil do IAM, digite o número associado a isso. Em seguida, será necessário “Inserir o nome do novo perfil do IAM”. Faça isso. Use o nome HelloLambdaRole.
Em seguida, você verá uma lista de permissões que podem ser anexadas ao perfil que você está criando. Escolha AWSLambdaBasicExecutionRole. Essa opção é o número 6 na minha lista.
Aguarde alguns segundos enquanto o perfil, as permissões e a função do Lambda são criadas.
Etapa 3 - Invoque a função do Lambda
Na linha de comando, execute:
dotnet lambda invoke-function --function-name HelloLambda --payload "Hello World!"
Na saída, você verá:
Está pronto! Você acabou de implantar uma função do Lambda na nuvem!
Etapa 4 - Limpeza
Com as funções do Lambda, nada será cobrado quando elas não estiverem em execução; no entanto, com outros serviços da AWS, haverá cobrança mesmo quando o serviço estiver inativo. É sempre uma boa prática remover os recursos que você não estiver usando.
Execute o comando a seguir para excluir a função do Lambda:
dotnet lambda delete-function --function-name HelloLambda
Observe que isso não exclui o perfil que você criou, somente a função.
Demonstração 2: Uma API .NET em execução em uma função do Lambda
Nesta demonstração, você criará uma aplicação da API.NET que lidará com as solicitações HTTPS. Você pode usar o modelo mínimo de API mais recente ou a API completa mais antiga com modelos de controladores. As etapas serão as mesmas. Se você estiver familiarizado com as declarações de nível superior do .NET 6 e os endpoints de API, considere usar o modelo mínimo, serverless.AspNetCoreMinimalAPI. Se as declarações de nível superior não forem familiares para você, use o modelo mais antigo, serverless.AspNetCoreWebAPI.
Etapa 1 - Crie um projeto .NET
Se você quiser usar o modelo mínimo de API, execute o seguinte comando:
dotnet new serverless.AspNetCoreMinimalAPI -n HelloLambdaAPI
Se o modelo completo de API com controladores for mais familiar para você, execute o seguinte comando:
dotnet new serverless.AspNetCoreWebAPI -n HelloLambdaAPI
Etapa 2 – Criar um bucket do S3
Essa é uma etapa única. O comando na etapa 3 precisa de um bucket do S3 para armazenar arquivos relacionados à implantação.
Você precisa criar um nome de bucket exclusivo em todas as contas da AWS (não apenas na sua) e em todas as regiões.
Se você estiver usando us-east-1, execute o seguinte comando:
aws s3api create-bucket --bucket your-unique-bucket-name1234
Se quiser usar uma região diferente, execute:
aws s3api create-bucket --bucket your-unique-bucket-name1234 --create-bucket-configuration LocationConstraint=REGION
Se o nome do bucket selecionado estiver em uso, você receberá o seguinte erro:
Ocorreu um erro (BucketAlreadyExists) ao chamar a operação CreateBucket: O nome do bucket solicitado não está disponível. O namespace do bucket é compartilhado por todos os usuários do sistema. Selecione um nome diferente e tente novamente.
Etapa 3 - Implantar a função do Lambda
Vá para o diretório HelloLambdaAPI/src/HelloLambdaAPI.
Na linha de comando, execute o seguinte comando para implantar a função:
dotnet lambda deploy-serverless --stack-name HelloLambdaAPI --s3-bucket your-unique-bucket-name1234
Aguarde...
Você verá alguns resultados relacionados ao processo de construção e implantação e, no final, haverá um link:
Output Name Value
------------------------------ --------------------------------------------------
ApiURL https://xxxxxxxxxx.execute-api.us-east-1.amazonaws.com/Prod/
Abra o link em um navegador. Dependendo da sua escolha de modelo de projeto, você verá uma das mensagens abaixo:
Etapa 4 - Limpeza
Para remover a função do Lambda e os recursos associados, execute o seguinte comando:
dotnet lambda delete-serverless HelloLambdaAPIConclusão
Pronto. Em apenas alguns minutos, você implantou duas funções do Lambda. É muito fácil começar a usar as funções do Lambda no .NET!