Um guia para construir uma API sem servidor AWS e um pipeline CICD

Visão geral

Este artigo demonstra o desenvolvimento de uma API sem servidor utilizando serviços AWS e estabelece um pipeline de integração/implantação contínua (CICD) no ambiente AWS.

Parte 1: explora a criação de uma função Lambda para lidar com solicitações do API Gateway e persistir os dados no DynamoDB usando o modelo de aplicativo sem servidor.

Parte 2: Detalha as etapas necessárias para configurar um repositório CodeCommit na AWS e configurar um pipeline CICD que inicia automaticamente um processo de construção após o envio de novas alterações ao repositório.

Pré-requisitos

Para este projeto, você precisará de uma conta AWS (o nível gratuito é suficiente). Os seguintes componentes da AWS serão utilizados:

• Gateway de API da AWS
• AWS Lambda
• AWS DynamoDB
• AWS CodeCommit
• AWS CodeBuild
• AWS Code Pipeline
• AWS S3
• Diversos - CloudWatch, IAM, etc.

Certifique-se de ter seu ambiente de desenvolvimento local configurado da seguinte forma:

1. Instale o AWS CLI : siga o guia aqui para instalar a AWS Command Line Interface.

   
   

2. Instale o AWS SAM (modelo de aplicativo sem servidor) : Instale o SAM CLI seguindo as instruções aqui .

   
   

3. Escolha um IDE : Use IntelliJ ou um IDE semelhante para desenvolvimento. Eu prefiro IntelliJ

   
   

4. Maven para empacotamento : certifique-se de ter o Maven instalado para empacotar seu aplicativo.

   
   

5. Opcional: Docker (se precisar testar funções do Lambda localmente): instale o Docker se planeja testar funções do Lambda localmente.

Essas ferramentas e componentes formarão a base do projeto.

Parte 1: Desenvolvimento

Nesta seção, veremos o processo de criação de um projeto inicial usando AWS SAM, incluindo a conclusão da classe de manipulador, construção, implantação na AWS e condução de testes usando Postman

Configuração do ambiente

1. Configuração da AWS :

   Vá para o console AWS em https://aws.amazon.com/console/ e faça login usando suas credenciais de usuário administrador.

   1. Crie um usuário no IAM :
      • No IAM, crie um usuário dedicado para desenvolvimento local e uso de CLI/SAM.
   2. Crie uma tabela DynamoDB :
      • Nome: "usuários", Chave Primária: "id" (Tipo: String)

2. Configure AWS CLI na máquina local :

   • Abra um terminal e execute $ aws configure
   • Forneça as chaves de acesso para o usuário IAM criado anteriormente e outros valores padrão

3. Inicialize um projeto usando AWS Serverless Application Model (SAM) :

   • Abra seu terminal e execute $ sam init
   • Escolha o modelo de início rápido da AWS.
   • Opte por um exemplo “Hello World”.
   • Selecione Java 11 ou 17, tipo de pacote como zip e use Maven como gerenciador de dependências.
   • Habilite o registro e o monitoramento com CloudWatch e XRay.

4. Renomear o projeto : Renomeie o projeto com seu nome preferido.

5. Abra o projeto no IntelliJ : Inicie o IntelliJ e abra o projeto.

6. Adicione dependências ao pom.xml :

   • Adicione as dependências necessárias ao arquivo pom.xml . Você só precisa adicionar o DynamoDB, pois outras dependências serão incluídas automaticamente pelo SAM.

      <dependencies> <dependency> <groupId>com.amazonaws</groupId> <artifactId>aws-lambda-java-core</artifactId> <version>1.2.2</version> </dependency> <dependency> <groupId>com.amazonaws</groupId> <artifactId>aws-lambda-java-events</artifactId> <version>3.11.0</version> </dependency> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.13.2</version> <scope>test</scope> </dependency> <dependency> <groupId>com.amazonaws</groupId> <artifactId>aws-java-sdk-dynamodb</artifactId> <version>1.12.573</version> </dependency> </dependencies>

     
     

Escreva a classe do manipulador

Para a função lambda, edite a classe manipuladora gerada automaticamente por sam e adicione o seguinte código; este é um código simples e, para projetos reais, você pode querer usar um código mais modular.

 public class UserRequestHandler implements RequestHandler<Map<String,String>, Map<String,String>> { private AmazonDynamoDB amazonDynamoDB; private String DYNAMODB_TABLE_NAME = "users"; private Regions REGION = Regions.US_EAST_1; @Override public Map<String,String> handleRequest(Map<String,String> input, Context context) { this.initDynamoDbClient(); LambdaLogger logger = context.getLogger(); logger.log("Input payload:" + input.toString()); String userId = UUID.randomUUID().toString(); String firstName= input.get("firstName"); String lastName= input.get("lastName"); Map<String, AttributeValue> attributesMap = new HashMap<>(); attributesMap.put("id", new AttributeValue(userId)); attributesMap.put("firstName", new AttributeValue(firstName)); attributesMap.put("lastName", new AttributeValue(lastName)); logger.log(attributesMap.toString()); amazonDynamoDB.putItem(DYNAMODB_TABLE_NAME, attributesMap); Map<String, String> response = new HashMap<>(); response.put("id", userId); response.put("firstName", firstName); response.put("lastName", lastName); return response; } private void initDynamoDbClient() { this.amazonDynamoDB = AmazonDynamoDBClientBuilder.standard() .withRegion(REGION) .build(); } }

Atualizar arquivo de modelo SAM

O arquivo de modelo SAM desempenha um papel fundamental na criação e implantação de alterações na AWS. Atualize o arquivo do projeto. Os principais elementos a serem focados neste arquivo são os nomes das funções do Lambda e os endpoints do API Gateway. Eles são fundamentais para a funcionalidade do seu aplicativo sem servidor.

 AWSTemplateFormatVersion: '2010-09-09' Transform: AWS::Serverless-2016-10-31 Description: > pc-aws-user-api Sample SAM Template for pc-aws-user-api # More info about Globals: https://github.com/awslabs/serverless-application-model/blob/master/docs/globals.rst Globals: Function: Timeout: 20 MemorySize: 128 Tracing: Active Api: TracingEnabled: true Resources: UserRequestHandlerLambdaFunction: Type: AWS::Serverless::Function # More info about Function Resource: https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#awsserverlessfunction Properties: CodeUri: PcAwsUsersApi Handler: com.pc.aws.users.UserRequestHandler::handleRequest Runtime: java11 Architectures: - x86_64 MemorySize: 512 Environment: # More info about Env Vars: https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#environment-object Variables: PARAM1: VALUE JAVA_TOOL_OPTIONS: -XX:+TieredCompilation -XX:TieredStopAtLevel=1 # More info about tiered compilation https://aws.amazon.com/blogs/compute/optimizing-aws-lambda-function-performance-for-java/ Events: PcUsers: Type: Api # More info about API Event Source: https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#api Properties: Path: /users Method: post ApplicationResourceGroup: Type: AWS::ResourceGroups::Group Properties: Name: Fn::Sub: ApplicationInsights-SAM-${AWS::StackName} ResourceQuery: Type: CLOUDFORMATION_STACK_1_0 ApplicationInsightsMonitoring: Type: AWS::ApplicationInsights::Application Properties: ResourceGroupName: Ref: ApplicationResourceGroup AutoConfigurationEnabled: 'true' Outputs: # ServerlessRestApi is an implicit API created out of Events key under Serverless::Function # Find out more about other implicit resources you can reference within SAM # https://github.com/awslabs/serverless-application-model/blob/master/docs/internals/generated_resources.rst#api PcAwsUsersApi: Description: API Gateway endpoint URL for Prod stage Value: !Sub "https://${ServerlessRestApi}.execute-api.${AWS::Region}.amazonaws.com/Prod/users/" UserRequestHandlerLambdaFunction: Description: Lambda Function ARN Value: !GetAtt UserRequestHandlerLambdaFunction.Arn UserRequestHandlerLambdaFunctionIamRole: Description: Implicit IAM Role created Value: !GetAtt UserRequestHandlerLambdaFunctionRole.Arn

Construir e implantar código usando SAM

No IntelliJ, abra o terminal e execute os seguintes comandos:

$ sam build

$ sam deploy –guided

Quando solicitado, forneça o nome da pilha como "PcAwsUsersApi" e escolha as opções padrão.

A saída mostrará a pilha do CloudFormation que foi criada e também fornecerá o endpoint do API Gateway.

Teste a API

Antes de testar a API, conceda ao DynamoDB acesso à função Lambda criada pelo SAM.

• Abra a função Lambda no Console AWS.

• Navegue até "Permissões" e localize o nome da função.

• Adicione a permissão "DynamoDBFullAccess" a esta função.

Esta etapa garante que a função Lambda tenha as permissões necessárias para interagir com o DynamoDB.

Navegue até API Gateway e siga estas etapas para obter o URL do seu serviço:

1. Acesse API Gateway no Console AWS.

2. Selecione sua API.

3. Na barra lateral esquerda, clique em “Estágios”.

4. Em "Estágios", selecione o estágio "Prod".

5. Na seção Stage Editor, você encontrará o "Invoke URL". Copie este URL.

   
   

• Inicie o aplicativo Postman.
• Crie uma solicitação POST: Configure uma nova solicitação com os seguintes detalhes:
  • Método: POSTAR
  • URL: cole o URL do endpoint do API Gateway obtido anteriormente.
• Definir cabeçalhos: adicione quaisquer cabeçalhos necessários (por exemplo, Content-Type: application/json ).

• Adicionar corpo da solicitação: crie um objeto JSON representando os dados do usuário que você deseja enviar na solicitação. Esses seriam os dados que você espera que sejam armazenados no DynamoDB.

Parte II Implementar Pipeline CICD

Nesta seção, demonstraremos como construir um pipeline CICD usando AWS CodeCommit, CodeBuild e CodePipeline. O pipeline iniciará um processo de construção que busca o código do repositório, constrói-o usando o arquivo de construção e aciona o CloudFormation para criar a pilha.

Criar repositório CodeCommit

Faça login na AWS e pesquise o serviço CodeCommit.

Crie um novo repositório no AWS CodeCommit para armazenar o código-fonte do seu projeto.

Confirmar código no repositório

No IntelliJ, abra o terminal e digite os seguintes comandos para confirmar o código criado na Etapa I

 $ git init → This initialize local git $ git add . → This will stage files $ git commit -m "commit to CodeCommit"

Enviar alterações para o repositório remoto

Copie o URL do repositório CodeCommit do console do AWS.

 $ git remote add origin <repo URL> $ git push --set-upstream origin master --> This will prompt for user/password

Criar projeto AWS CodeBuild

Configure um projeto CodeBuild que especifique como criar seu aplicativo. Isso inclui definir ambientes de construção, comandos de construção e dependências.

• Crie um bucket S3 para armazenar os arquivos de compilação.

• Pesquise AWS Code Build, crie um novo projeto e forneça CodeCommit como fonte de código e S3 para armazenamento de artefatos

Para configurar o CodeBuild, você precisará criar um arquivo de especificação de compilação chamado buildspec.yml no diretório do projeto. Este arquivo conterá os comandos e instruções de construção do CodeBuild.

Você pode consultar a documentação oficial aqui para obter instruções detalhadas sobre como criar um arquivo buildspec.yml .

 version: 0.2 phases: install: runtime-versions: java: corretto11 pre_build: commands: - echo Nothing to do in the pre_build phase... build: commands: - echo Build started on `date` - sam build - sam package --output-template-file pcoutputtemplate.yaml --s3-bucket com-appsdev-pc-001 post_build: commands: - echo Build completed on `date` artifacts: files: - pcoutputtemplate.yaml

Envie o novo arquivo para o repositório local.

Depois disso, você pode construir o projeto para ver se o código foi extraído do repositório e os artefatos foram construídos.

Crie um CodePipeline

• Crie um novo pipeline no AWS CodePipeline.

• Conecte o pipeline ao repositório do CodeCommit como origem.

• Configure o pipeline para usar o CodeBuild como estágio de construção.

• Adicione um estágio de implantação para acionar o CloudFormation usando o modelo que você criou.

O pipeline criará e implantará automaticamente o código com base no commit do git.

Teste o pipeline

• Abra seu projeto no IntelliJ.

• Faça uma pequena alteração em um de seus arquivos, por exemplo, adicione outra linha do logger.

• Confirme a alteração em seu repositório Git local.

• Envie o commit para o repositório CodeCommit.

 $ git branch CR01 $ git checkout CR01 $ git add . $ git commit -m “CR01” $ git push --set-upstream origin CR01 You cand also create a pull request in aws code commit, just for simplicity I am merging from local $ git checkout master $ git merge --ff-only CR01 $ git push

• Acesse o console do AWS CodePipeline.

• Você deverá ver o pipeline iniciar automaticamente. Ele extrairá o código mais recente do repositório, construirá o projeto usando CodeBuild e o implantará usando CloudFormation.

• Monitore o progresso no painel do CodePipeline.

Isso simulará o processo de fazer alterações em seu código, enviá-las para o repositório e fazer com que o pipeline CICD acione e implante automaticamente o código atualizado.

Ao aproveitar o AWS API Gateway, Lambda, DynamoDB, CodeCommit, CodeBuild e CodePipeline, o artigo demonstra como arquitetar um processo de implantação resiliente e automatizado.

Obrigado por ler. Que seus empreendimentos sem servidor sejam recebidos com sucesso e inovação!