Ejecutar microservicio Spring Boot en una función AWS Lambda

En el post de hoy vamos a tratar de explicar cómo podemos crear un microservicio en Spring Boot y publicarlo en una función Lambda de AWS. Una vez lo tengamos en AWS, dispondremos de un endpoint con el que podremos ejecutar la lógica contenida en nuestro microservicio. Para ello, aparte de Spring Boot, vamos a apoyarnos en las facilidades proporcionadas por el proyecto Spring Cloud. En el ejemplo vamos a utilizar Visual Studio Code para desarrollar la función, pero el proceso sería equivalente utilizando Eclipse.

Como punto de partida de nuestro proyecto, vamos a suponer que ya tenemos creada una aplicación Spring Boot, denominada "cloud-function". Para crear la aplicación hemos utilizado la siguiente configuración en el Spring Initializr.

 

Una vez generado el proyecto y cargado en nuestro Visual Studio Code, la estructura de nuestra aplicación debería quedar algo así como la siguiente:

 

Generación de paquete JAR con el microservicio

 

Los pasos a seguir para configurar nuestro microservicio serían los siguientes.

 

1º) En primer lugar, añadimos las dependencias precisadas en nuestro "pom.xml". Por lo que respecta al framework Spring, tendríamos que añadir lo siguiente en los apartados <dependencies> y <dependencyManagement>:

 

 

    <dependencies>

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter</artifactId>

        </dependency>

        <dependency>

            <groupId>org.springframework.cloud</groupId>

            <artifactId>spring-cloud-starter-function-web</artifactId>

        </dependency>

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-test</artifactId>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-web</artifactId>

        </dependency>

        <dependency>

            <groupId>org.springframework.cloud</groupId>

            <artifactId>spring-cloud-function-web</artifactId>

        </dependency>

        <dependency>

            <groupId>org.springframework.cloud</groupId>

            <artifactId>spring-cloud-function-adapter-aws</artifactId>

        </dependency>

    </dependencies>

 

    <dependencyManagement>

        <dependencies>

            <dependency>

                <groupId>org.springframework.cloud</groupId>

                <artifactId>spring-cloud-dependencies</artifactId>

                <version>${spring-cloud.version}</version>

                <type>pom</type>

                <scope>import</scope>

            </dependency>

        </dependencies>

    </dependencyManagement>

 

⛔ Es importante mencionar que hay que añadir la dependencia Adapter de AWS. Esto es necesario para que nuestro paquete se genere con la estructura correcta para su posterior ejecución en una función AWS Lambda.

spring-cloud-function-adapter-aws

 

2º) Por lo que respecta al paquete JAR a generar posteriormente, en nuestro "pom.xml" añadimos lo siguiente en el apartado <build>:

 

    <build>

        <plugins>

            <plugin>

                <groupId>org.springframework.boot</groupId>

                <artifactId>spring-boot-maven-plugin</artifactId>

                <configuration>

                    <outputDirectory>target/deploy</outputDirectory>

                </configuration>

                <dependencies>

                    <dependency>

                        <groupId>org.springframework.boot.experimental</groupId>

                        <artifactId>spring-boot-thin-layout</artifactId>

                        <version>1.0.28.RELEASE</version>

                    </dependency>

                </dependencies>

            </plugin>

            <plugin>

                <groupId>org.apache.maven.plugins</groupId>

                <artifactId>maven-shade-plugin</artifactId>

                <configuration>

                    <createDependencyReducedPom>false</createDependencyReducedPom>

                    <shadedArtifactAttached>true</shadedArtifactAttached>

                    <shadedClassifierName>aws</shadedClassifierName>

                </configuration>

            </plugin>

        </plugins>

    </build>

 

 

3º) Para simular el microservicio, vamos a añadir una función (@Bean) en nuestra clase principal (CloudFunctionApplication.java). Lo único que haremos es imprimir un mensaje y un parámetro de entrada.

 

 

@SpringBootApplication

public class CloudFunctionApplication {

    public static void main(String[] args) {

        SpringApplication.run(CloudFunctionApplication.class, args);

    }

    // Funcion para prueba de microservicio

    @Bean

    public Function<String,String> function() {

        return (value) -> "Bienvenido, usuario de Spring Cloud y AWS Lambda - Version " + value;

       

    }

}

 

 

👉 En el "application.properties" únicamente incluimos estas dos propiedades:

spring.application.name=cloud-function

spring.cloud.function.definition=function

 

 4º) A continuación, generamos el paquete de la aplicación mediante Maven. Lanzamos el comando en el terminal de Visual Studio Code.

mvn clean package

5º) Si el Build finaliza sin problemas, en la carpeta "target" de nuestra aplicación aparecerá el nuevo paquete JAR generado. En nuestro caso, se habrá generado un JAR con la estructura requerida para su despliegue en una función Lambda de AWS.

cloud-function-0.01-SNAPSHOT-aws.jar

Con esto ya tendríamos preparado el paquete de nuestro microservicio.

 

Creación de AWS Lambda para el microservicio

 

A continuación, tenemos que ir a la consola AWS para proceder a la creación de una función Lambda en la que subiremos el paquete JAR que acabamos de generar.

 

Los pasos a seguir para configurar nuestra Lambda serían los siguientes.

6º) Dentro de la consola AWS, nos vamos al apartado de funciones Lambda.

 

7º) Pulsamos el botón CREATE FUNCTION y vamos al detalle de la función Lambda.

 

8º) Vamos al apartado de "ADDITIONAL CONFIGURATION" y seleccionamos la opción "Enable function URL".

 

9º) Revisamos la configuración global de la función Lambda.

 

10º) Pulsamos CREATE FUNCTION. Si no hay problemas, la función quedará creada correctamente. 

👉 Si nos fijamos en el apartado "FUNCTION URL", ahí podremos ver el endpoint que ha quedado asignado a la función Lambda. En nuestro ejemplo es el siguiente:

https://5sglm6tsfaawatronvklwoumbe0srtyc.lambda-url.us-east-1.on.aws/

 

11º) A continuación, pulsamos el botón UPLOAD FROM y seleccionamos la opción ".zip or .jar file".

 12º) Pulsamos UPLOAD y subimos el fichero JAR que previamente habíamos generado.

13º) Pulsamos SAVE. Si no hay ningún problema, el fichero JAR quedará asociado a la función Lambda que acabamos de crear.

 

Configuración del Handler de la función Lambda

 

 14º) A continuación, nos vamos al apartado "RUNTIME SETTINGS".

 

 15º) Pulsamos el botón EDIT y vamos a la ventana de "Runtime settings".

 

16º) En el apartado "HANDLER" tenemos que indicar el endpoint estándar proporcionado por el Adaptador de AWS.

org.springframework.cloud.function.adapter.aws.FunctionInvoker::handleRequest

 

 17º) Pulsamos SAVE y la función Lambda quedará actualizada.

 

Prueba del microservicio desde Postman

 

18º) A continuación, podemos probar el endpoint de la función Lambda desde Postman. Nos creamos un Request con la siguiente configuración. En nuestro ejemplo el endpoint es el siguiente (ten en cuenta que será un endpoint diferente para tu función Lambda):

https://5sglm6tsfaawatronvklwoumbe0srtyc.lambda-url.us-east-1.on.aws/  

Introducimos un valor de entrada y pulsamos SEND. En la salida se verá impreso el mensaje que tenemos codificado en nuestro microservicio.

 

👿 Como siempre, los logs de la ejecución de la función Lambda podremos verla en el servicio CloudWatch a través de la consola AWS. Para ello, dentro de la función Lambda, nos vamos al apartado MONITOR y pulsamos el botón VIEW CLOUDWATCH LOGS. Así saltaremos a una ventana donde podremos ir revisando los logs que se generen para nuestra Lambda.

 

Y con esto podemos ver que hemos acabado codificando un microservicio Lambda sin más esfuerzo que utilizar el Adaptador AWS incluido en Spring Cloud. 

Conclusión

Hay que tener en cuenta que para este microservicio hemos utilizado interfaces funcionales y el adaptador AWS disponible para arquitecturas serverless. Si lo que queremos es utilizar un microservicio clásico (que se esté ejecutando en un contenedor Docker mediante AWS Fargate) y trasladarlo a una función Lambda, entonces tendremos que realizar algunos cambios en nuestra aplicación Spring Boot y utilizar otro Adaptador AWS diferente. 

 

Pero bueno, eso ya lo veremos en un futuro post. Por lo que respecta a lo que quería comentarte hoy, ya hemos terminado... cualquier duda que os surja al respecto podéis dejármela aquí abajo, como siempre.

 

¡Nos vemos en el siguiente post!

Saludos.