Una guía para crear una API sin servidor de AWS y una canalización CICD

Descripción general

Este artículo demuestra el desarrollo de una API sin servidor que utiliza servicios de AWS y establece una canalización de integración/implementación continua (CICD) dentro del entorno de AWS.

Parte 1: explora la creación de una función Lambda para manejar solicitudes de API Gateway y conservar los datos en DynamoDB utilizando el modelo de aplicación sin servidor.

Parte 2: detalla los pasos necesarios para configurar un repositorio de CodeCommit en AWS y configurar una canalización CICD que inicia automáticamente un proceso de compilación tras el envío de nuevos cambios al repositorio.

Requisitos previos

Para este proyecto, necesitará una cuenta de AWS (la capa gratuita es suficiente). Se utilizarán los siguientes componentes de AWS:

• Puerta de enlace API de AWS
• AWS Lambda
• AWSDynamoDB
• Compromiso de código de AWS
• Construcción de código AWS
• AWS CodePipeline
• AWS S3
• Varios: CloudWatch, IAM, etc.

Asegúrese de tener su entorno de desarrollo local configurado de la siguiente manera:

1. Instale AWS CLI : siga la guía aquí para instalar la interfaz de línea de comandos de AWS.

   
   

2. Instale AWS SAM (modelo de aplicación sin servidor) : instale la CLI de SAM siguiendo las instrucciones aquí .

   
   

3. Elija un IDE : utilice IntelliJ o un IDE similar para el desarrollo. prefiero intellij

   
   

4. Maven para empaquetar : asegúrese de tener Maven instalado para empaquetar su aplicación.

   
   

5. Opcional: Docker (si necesita probar las funciones de Lambda localmente): instale Docker si planea probar las funciones de Lambda localmente.

Estas herramientas y componentes formarán la base del proyecto.

Parte 1: Desarrollo

En esta sección, veremos el proceso de creación de un proyecto inicial con AWS SAM, incluida la finalización de la clase de controlador, la creación, la implementación en AWS y la realización de pruebas con Postman.

Configuración del entorno

1. Configuración de AWS :

   Vaya a la consola de AWS en https://aws.amazon.com/console/ e inicie sesión con sus credenciales de usuario administrador.

   1. Crear un usuario en IAM :
      • En IAM, cree un usuario dedicado al desarrollo local y al uso de CLI/SAM.
   2. Cree una tabla de DynamoDB :
      • Nombre: "usuarios", Clave principal: "id" (Tipo: Cadena)

2. Configure AWS CLI en la máquina local :

   • Abra una terminal y ejecute $ aws configure
   • Proporcione las claves de acceso para el usuario de IAM creado anteriormente y otros valores predeterminados

3. Inicialice un proyecto utilizando el modelo de aplicación sin servidor (SAM) de AWS :

   • Abre tu terminal y ejecuta $ sam init
   • Elija la plantilla de inicio rápido de AWS.
   • Opte por un ejemplo de "Hola mundo".
   • Seleccione Java 11 o 17, escriba el paquete zip y use Maven como administrador de dependencias.
   • Habilite el registro y la supervisión con CloudWatch y XRay.

4. Cambiar el nombre del proyecto : cambie el nombre del proyecto a su nombre preferido.

5. Abra el proyecto en IntelliJ : inicie IntelliJ y abra el proyecto.

6. Agregue dependencias a pom.xml :

   • Agregue las dependencias necesarias al archivo pom.xml . Solo necesita agregar DynamoDB, ya que SAM incluirá automáticamente otras dependencias.

      <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>

     
     

Escribir la clase de controlador

Para la función lambda, edite la clase de controlador generada automáticamente por sam y agregue el siguiente código; Este es un código simple y, para proyectos reales, es posible que desee utilizar más código 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(); } }

Actualizar el archivo de plantilla SAM

El archivo de plantilla SAM desempeña un papel fundamental en la creación e implementación de cambios en AWS. Actualice el archivo del proyecto. Los elementos clave en los que centrarse en este archivo son los nombres de las funciones Lambda y los puntos finales de API Gateway. Son fundamentales para la funcionalidad de su aplicación sin 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

Construya e implemente código usando SAM

En IntelliJ, abra la terminal y ejecute los siguientes comandos:

$ sam build

$ sam deploy –guided

Cuando se le solicite, proporcione el nombre de la pila como "PcAwsUsersApi" y elija las opciones predeterminadas.

El resultado mostrará la pila de CloudFormation que se ha creado y también proporcionará el punto final de API Gateway.

Pruebe la API

Antes de probar la API, otorgue acceso a DynamoDB al rol de Lambda creado por SAM.

• Abra la función Lambda en la consola de AWS.

• Navegue hasta "Permisos" y busque el nombre de la función.

• Agregue el permiso "DynamoDBFullAccess" a esta función.

Este paso garantiza que la función Lambda tenga los permisos necesarios para interactuar con DynamoDB.

Navegue hasta API Gateway, luego siga estos pasos para obtener la URL de su servicio:

1. Vaya a API Gateway en la consola de AWS.

2. Seleccione su API.

3. En la barra lateral izquierda, haz clic en "Etapas".

4. En "Etapas", seleccione la etapa "Prod".

5. En la sección Editor de escenario, encontrará la "URL de invocación". Copie esta URL.

   
   

• Inicie la aplicación cartero.
• Cree una solicitud POST: configure una nueva solicitud con los siguientes detalles:
  • Método: ENVIAR
  • URL: pegue la URL del punto final de API Gateway obtenida anteriormente.
• Establecer encabezados: agregue los encabezados necesarios (por ejemplo, Content-Type: application/json ).

• Agregar cuerpo de solicitud: cree un objeto JSON que represente los datos del usuario que desea enviar en la solicitud. Estos serían los datos que espera que se almacenen en DynamoDB.

Parte II Implementar el proceso CICD

En esta sección, demostraremos cómo crear una canalización CICD utilizando AWS CodeCommit, CodeBuild y CodePipeline. La canalización iniciará un proceso de compilación que recupera el código del repositorio, lo compila utilizando el archivo de compilación y activa CloudFormation para crear la pila.

Crear repositorio CodeCommit

Inicie sesión en AWS y busque el servicio CodeCommit.

Cree un nuevo repositorio en AWS CodeCommit para almacenar el código fuente de su proyecto.

Confirmar código en el repositorio

En IntelliJ, abra la terminal e ingrese los siguientes comandos para confirmar el código creado en el Paso I

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

Enviar cambios al repositorio remoto

Copie la URL del repositorio de CodeCommit desde la consola de AWS.

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

Crear proyecto de AWS CodeBuild

Configure un proyecto CodeBuild que especifique cómo construir su aplicación. Esto incluye definir entornos de compilación, comandos de compilación y dependencias.

• Cree un depósito de S3 para almacenar los archivos de compilación.

• Busque AWS Code Build, cree un nuevo proyecto y proporcione CodeCommit como fuente de código y S3 para almacenamiento de artefactos.

Para configurar CodeBuild, deberá crear un archivo de especificación de compilación llamado buildspec.yml en el directorio de su proyecto. Este archivo contendrá los comandos de compilación y las instrucciones para CodeBuild.

Puede consultar la documentación oficial aquí para obtener instrucciones detalladas sobre cómo crear un archivo 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

Envíe el nuevo archivo al repositorio desde local.

Después de esto, puede compilar el proyecto para ver si el código se extrae del repositorio y se crean los artefactos.

Crear una tubería de código

• Cree una nueva canalización en AWS CodePipeline.

• Conecte la canalización a su repositorio de CodeCommit como fuente.

• Configure la canalización para usar CodeBuild como etapa de compilación.

• Agregue una etapa de implementación para activar CloudFormation usando la plantilla que creó.

La canalización creará e implementará automáticamente código según la confirmación de git.

Pruebe la tubería

• Abra su proyecto en IntelliJ.

• Realice un pequeño cambio en uno de sus archivos, por ejemplo, agregue otra línea de registro.

• Confirme el cambio en su repositorio Git local.

• Envíe la confirmación al repositorio de 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

• Vaya a la consola de AWS CodePipeline.

• Debería ver que la canalización se inicia automáticamente. Extraerá el código más reciente del repositorio, creará el proyecto usando CodeBuild y lo implementará usando CloudFormation.

• Supervise el progreso en el panel de CodePipeline.

Esto simulará el proceso de realizar cambios en su código, enviarlos al repositorio y hacer que la canalización CICD active e implemente automáticamente el código actualizado.

Aprovechando AWS API Gateway, Lambda, DynamoDB, CodeCommit, CodeBuild y CodePipeline, el artículo demuestra cómo diseñar un proceso de implementación resiliente y automatizado.

Gracias por leer. ¡Que sus esfuerzos sin servidor se encuentren con éxito e innovación!