Arquitectura orientada a servicios con AWS Lambda: un tutorial paso a paso

Al crear aplicaciones web, hay muchas opciones que pueden ayudar o dificultar su aplicación en el futuro una vez que se comprometa con ellas. Las opciones como el idioma, el marco, el alojamiento y la base de datos son cruciales.

Una de esas opciones es si crear una aplicación basada en servicios mediante la arquitectura orientada a servicios (SOA) o una aplicación monolítica tradicional. Esta es una decisión arquitectónica común que afecta por igual a empresas emergentes, ampliadas y empresariales.

La arquitectura orientada a servicios es utilizada por una gran cantidad de unicornios conocidos y empresas de alta tecnología como Google, Facebook, Twitter, Instagram y Uber. Aparentemente, este patrón de arquitectura funciona para grandes empresas, pero ¿puede funcionar para usted?

En este artículo, presentaremos el tema de la arquitectura orientada a servicios y cómo se puede aprovechar AWS Lambda en combinación con Python para crear fácilmente servicios escalables y rentables. Para demostrar estas ideas, crearemos un servicio simple de carga y cambio de tamaño de imágenes utilizando Python, AWS Lambda, Amazon S3 y algunas otras herramientas y servicios relevantes.

¿Qué es la arquitectura orientada a servicios?

La Arquitectura Orientada a Servicios (SOA) no es nueva, tiene raíces desde hace varias décadas. En los últimos años, su popularidad como patrón ha ido en aumento debido a que ofrece muchos beneficios para las aplicaciones orientadas a la web.

SOA es, en esencia, la abstracción de una gran aplicación en muchas aplicaciones más pequeñas que se comunican. Esto sigue varias mejores prácticas de ingeniería de software, como el desacoplamiento, la separación de preocupaciones y la arquitectura de responsabilidad única.

Las implementaciones de SOA varían en términos de granularidad: desde muy pocos servicios que cubren grandes áreas de funcionalidad hasta muchas docenas o cientos de pequeñas aplicaciones en lo que se denomina arquitectura de "microservicio". Independientemente del nivel de granularidad, lo que generalmente se acepta entre los profesionales de SOA es que de ninguna manera es un almuerzo gratis. Como muchas buenas prácticas en ingeniería de software, es una inversión que requerirá planificación, desarrollo y pruebas adicionales.

¿Qué es AWS Lambda?

AWS Lambda es un servicio ofrecido por la plataforma Amazon Web Services. AWS Lambda le permite cargar código que se ejecutará en un contenedor bajo demanda administrado por Amazon. AWS Lambda administrará el aprovisionamiento y la administración de servidores para ejecutar el código, por lo que todo lo que se necesita del usuario es un conjunto de código empaquetado para ejecutar y algunas opciones de configuración para definir el contexto en el que se ejecuta el servidor. Estas aplicaciones administradas se denominan funciones de Lambda.

AWS Lambda tiene dos modos principales de operación:

Asíncrono/impulsado por eventos:

Las funciones Lambda se pueden ejecutar en respuesta a un evento en modo asíncrono. Cualquier fuente de eventos, como S3, SNS, etc., no se bloqueará y las funciones de Lambda pueden aprovechar esto de muchas maneras, como establecer una canalización de procesamiento para alguna cadena de eventos. Hay muchas fuentes de información y, según la fuente, los eventos se enviarán a una función Lambda desde la fuente del evento o AWS Lambda los sondeará en busca de eventos.

Síncrono/Solicitud->Respuesta:

Para las aplicaciones que requieren que se devuelva una respuesta sincrónicamente, Lambda se puede ejecutar en modo sincrónico. Por lo general, esto se usa junto con un servicio llamado API Gateway para devolver respuestas HTTP de AWS Lambda a un usuario final; sin embargo, las funciones de Lambda también se pueden llamar de forma síncrona a través de una llamada directa a AWS Lambda.

Las funciones de AWS Lambda se cargan como un archivo zip que contiene el código del controlador además de las dependencias necesarias para el funcionamiento del controlador. Una vez cargado, AWS Lambda ejecutará este código cuando sea necesario y escalará la cantidad de servidores de cero a miles cuando sea necesario, sin necesidad de ninguna intervención adicional por parte del consumidor.

Funciones Lambda como evolución de SOA

SOA básica es una forma de estructurar su base de código en pequeñas aplicaciones para beneficiar a una aplicación de las formas descritas anteriormente en este artículo. A partir de esto, se enfoca el método de comunicación entre estas aplicaciones. La SOA impulsada por eventos (también conocida como SOA 2.0) permite no solo la comunicación tradicional directa de servicio a servicio de SOA 1.0, sino también que los eventos se propaguen a través de la arquitectura para comunicar el cambio.

La arquitectura impulsada por eventos es un patrón que naturalmente promueve el acoplamiento flexible y la componibilidad. Al crear eventos y reaccionar a ellos, se pueden agregar servicios ad-hoc para agregar una nueva funcionalidad a un evento existente, y se pueden componer varios eventos para proporcionar una funcionalidad más rica.

AWS Lambda se puede utilizar como plataforma para crear fácilmente aplicaciones SOA 2.0. Hay muchas formas de activar una función Lambda; desde el enfoque tradicional de cola de mensajes con Amazon SNS, hasta eventos creados por un archivo que se carga en Amazon S3 o un correo electrónico que se envía con Amazon SES.

Implementación de un servicio de carga de imágenes simple

Construiremos una aplicación simple para cargar y recuperar imágenes utilizando la pila de AWS. Este proyecto de ejemplo contendrá dos funciones lambda: una que se ejecuta en modo de solicitud->respuesta que se usará para servir nuestra interfaz web simple, y otra que detectará las imágenes cargadas y las cambiará de tamaño.

La primera función lambda se ejecutará de forma asíncrona en respuesta a un evento de carga de archivos activado en el depósito S3 que albergará las imágenes cargadas. Tomará la imagen proporcionada y la cambiará de tamaño para que quepa en una imagen de 400x400.

La otra función lambda servirá a la página HTML, proporcionando tanto la funcionalidad para que un usuario vea las imágenes redimensionadas por nuestra otra función Lambda como una interfaz para cargar una imagen.

Configuración inicial de AWS

Antes de que podamos comenzar, necesitaremos configurar algunos servicios de AWS necesarios, como IAM y S3. Estos se configurarán utilizando la consola de AWS basada en la web. Sin embargo, la mayor parte de la configuración también se puede lograr mediante la utilidad de línea de comandos de AWS, que usaremos más adelante.

Creación de cubos S3

S3 (o Simple Storage Service) es un servicio de almacenamiento de objetos de Amazon que ofrece un almacenamiento fiable y rentable de cualquier dato. Usaremos S3 para almacenar las imágenes que se cargarán, así como las versiones redimensionadas de las imágenes que hemos procesado.

El servicio S3 se puede encontrar en el menú desplegable "Servicios" en la consola de AWS en la subsección "Almacenamiento y entrega de contenido". Al crear un depósito, se le pedirá que ingrese el nombre del depósito y que seleccione una región. Seleccionar una región cercana a sus usuarios permitirá que S3 optimice la latencia y el costo, así como algunos factores normativos. Para este ejemplo, seleccionaremos la región "Estándar de EE. UU.". Esta misma región se utilizará más adelante para alojar las funciones de AWS Lambda.

Vale la pena señalar que los nombres de depósito de S3 deben ser únicos, por lo que si se toma el nombre elegido, se le pedirá que elija un nombre nuevo y único.

Para este proyecto de ejemplo, crearemos dos cubos de almacenamiento llamados "prueba de carga" y "prueba de cambio de tamaño". El cubo de "carga de prueba" se utilizará para cargar imágenes y almacenar la imagen cargada antes de que se procese y se cambie el tamaño. Una vez redimensionada, la imagen se guardará en el depósito de "redimensionamiento de prueba" y se eliminará la imagen cargada sin procesar.

Permisos de carga de S3

De forma predeterminada, los permisos de S3 son restrictivos y no permitirán que los usuarios externos o incluso los usuarios no administrativos lean, escriban, actualicen o eliminen permisos u objetos en el depósito. Para cambiar esto, necesitaremos iniciar sesión como un usuario con derechos para administrar los permisos de depósito de AWS.

Suponiendo que estamos en la consola de AWS, podemos ver los permisos para nuestro depósito de carga seleccionando el depósito por nombre, haciendo clic en el botón "Propiedades" en la parte superior derecha de la pantalla y abriendo la sección "Permisos" contraída.

Para permitir que los usuarios anónimos carguen en este depósito, necesitaremos editar la política del depósito para permitir el permiso específico que permite la carga. Esto se logra a través de una política de configuración basada en JSON. Este tipo de políticas JSON se utilizan ampliamente en AWS junto con el servicio IAM. Al hacer clic en el botón "Editar política de depósito", simplemente pegue el siguiente texto y haga clic en "Guardar" para permitir la carga de imágenes públicas:

 { "Version": "2008-10-17", "Id": "Policy1346097257207", "Statement": [ { "Sid": "Allow anonymous upload to /", "Effect": "Allow", "Principal": { "AWS": "*" }, "Action": "s3:PutObject", "Resource": "arn:aws:s3:::test-upload/*" } ] }

Después de hacer esto, podemos verificar que la política del depósito sea correcta al intentar cargar una imagen en el depósito. El siguiente comando cURL hará el truco:

 curl https://test-upload.s3.amazonaws.com -F 'key=test.jpeg' -F '[email protected]'

Si se devuelve una respuesta de rango 200, sabremos que la configuración para el depósito de carga se aplicó correctamente. Nuestros cubos S3 ahora deberían estar (en su mayoría) configurados. Volveremos más tarde a este servicio en la consola para conectar nuestros eventos de carga de imágenes a la invocación de nuestra función de cambio de tamaño.

Permisos de IAM para Lambda

Todos los roles de Lambda se ejecutan dentro de un contexto de permiso, en este caso, un "rol" definido por el servicio IAM. Este rol define todos y cada uno de los permisos que tiene la función de Lambda durante su invocación. Para los fines de este proyecto de ejemplo, crearemos un rol genérico que se usará entre las dos funciones de Lambda. Sin embargo, en un escenario de producción, se recomienda una granularidad más fina en las definiciones de permisos para garantizar que cualquier explotación de seguridad se aísle solo al contexto de permiso que se definió.

El servicio IAM se puede encontrar en la subsección "Seguridad e identidad" del menú desplegable "Servicios". El servicio IAM es una herramienta muy poderosa para administrar el acceso a través de los servicios de AWS, y la interfaz proporcionada puede ser un poco abrumadora al principio si no está familiarizado con herramientas similares.

Una vez en la página del panel de IAM, la subsección "Roles" se puede encontrar en el lado izquierdo de la página. Desde aquí, podemos usar el botón "Crear nuevo rol" para abrir un asistente de varios pasos para definir los permisos del rol. Usemos "lambda_role" como el nombre de nuestro permiso genérico. Después de continuar desde la página de definición de nombre, se le presentará la opción de seleccionar un tipo de rol. Como solo requerimos acceso a S3, haga clic en "AWS Service Roles" y dentro del cuadro de selección, seleccione "AWS Lambda". Se le presentará una página de políticas que se pueden adjuntar a este rol. Seleccione la política "AmazonS3FullAccess" y continúe con el siguiente paso para confirmar el rol que se creará.

Es importante anotar el nombre y el ARN (Amazon Resource Name) del rol creado. Esto se usará al crear una nueva función de Lambda para identificar el rol que se usará para la invocación de la función.

Nota: AWS Lambda registrará automáticamente todos los resultados de las invocaciones de funciones en AWS Cloudwatch, un servicio de registro. Si se desea esta funcionalidad, que se recomienda para un entorno de producción, se debe agregar el permiso para escribir en un flujo de registro de Cloudwatch a las políticas para este rol.

¡El código!

Visión de conjunto

Ahora estamos listos para comenzar a codificar. Supondremos en este punto que ha configurado el comando "awscli". Si no lo ha hecho, puede seguir las instrucciones en https://aws.amazon.com/cli/ para configurar awscli en su computadora.

Nota: el código utilizado en estos ejemplos es más corto para facilitar la visualización en pantalla. Para obtener una versión más completa, visite el repositorio en https://github.com/gxx/aws-lambda-python/.

En primer lugar, configuremos una estructura de esqueleto para nuestro proyecto.

 aws-lambda-python/ - image_list/ - handler.py - list.html - Makefile - requirements.txt - image_resize/ - handler.py - resize.py - Makefile - requirements.txt - .pydistutils.cfg

Tenemos dos subdirectorios en nuestra estructura, uno para cada una de nuestras funciones lambda. En cada uno de estos tenemos los archivos comunes handler.py, Makefile y requirements.txt. El archivo handler.py contendrá el método para llamar a la invocación de cada una de las funciones lambda y puede considerarse el punto de entrada para las funciones. El archivo requirements.txt contendrá una lista de nuestras dependencias, para que podamos especificar y actualizar fácilmente los requisitos. Por último, usaremos el comando Makefile para proporcionar un mecanismo sencillo para interactuar con awscli. Esto facilitará mucho el proceso de creación y actualización de nuestra función lambda.

Notará el archivo .pydistutils.cfg en la raíz de nuestro directorio de proyectos. Este archivo es necesario si está trabajando con Python en Homebrew. Debido al método de implementación de una función Lambda (tratado en la siguiente sección), este archivo es necesario. Ver el repositorio para más detalles.

Cambiar el tamaño de la función Lambda de la imagen

Código

Comenzando con la función resize_image, congelaremos la dependencia de Wand, nuestra biblioteca de procesamiento de imágenes, guardando Wand==0.4.2 en requirements.txt. Esta será la única dependencia para nuestra función lambda image_resize. La función resize_image en resize.py deberá manejar un recurso de imagen de la biblioteca Wand y cambiar su tamaño de acuerdo con los parámetros de ancho y alto especificados. Para preservar la imagen que se está cambiando de tamaño, utilizaremos un algoritmo de cambio de tamaño de "mejor ajuste" que mantendrá la relación de imagen de la imagen original, mientras reduce el tamaño de la imagen para que se ajuste al ancho y la altura especificados.

 def resize_image(image, resize_width, resize_height): ... original_ratio = image.width / float(image.height) resize_ratio = resize_width / float(resize_height) # We stick to the original ratio here, regardless of what the resize ratio is if original_ratio > resize_ratio: # If width is larger, we base the resize height as a function of the ratio of the width resize_height = int(round(resize_width / original_ratio)) else: # Otherwise, we base the width as a function of the ratio of the height resize_width = int(round(resize_height * original_ratio)) if ((image.width - resize_width) + (image.height - resize_height)) < 0: filter_name = 'mitchell' else: filter_name = 'lanczos2' image.resize(width=resize_width, height=resize_height, filter=filter_name, blur=1) return image

Con eso fuera del camino, se requiere una función de controlador para aceptar el evento generado por una imagen cargada S3, transferirlo a la función resize_image y guardar la imagen redimensionada resultante.

 from __future__ import print_function import boto3 from wand.image import Image from resize import resize_image def handle_resize(event, context): # Obtain the bucket name and key for the event bucket_name = event['Records'][0]['s3']['bucket']['name'] key_path = event['Records'][0]['s3']['object']['key'] response = boto3.resource('s3').Object(bucket_name, key_path).get() # Retrieve the S3 Object # Perform the resize operation with Image(blob=response['Body'].read()) as image: resized_data = resize_image(image, 400, 400).make_blob() # And finally, upload to the resize bucket the new image s3_connection.Object('test-resized', key_path).put(ACL='public-read', Body=resized_data) # Finally remove, as the bucket is public and we don't want just anyone dumping the list of our files! s3_object.delete()

Desplegando

Con el código completo, deberá cargarse en Amazon Lambda como una nueva función de Lambda. Aquí es donde entra en juego el Makefile que se ha agregado a la estructura de directorios. Este Makefile se usará para implementar las definiciones de funciones de Lambda que estamos creando.

 ROLE_ARN = arn:aws:iam::601885388019:role/lambda_role FUNCTION_NAME = ResizeImage REGION = us-west-1 TIMEOUT = 15 MEMORY_SIZE = 512 ZIPFILE_NAME = image_resize.zip HANDLER = handler.handle_resize clean_pyc : find . | grep .pyc$ | xargs rm install_deps : pip install -r requirements.txt -t . build : install_deps clean_pyc zip $(ZIPFILE_NAME) -r * create : build aws lambda create-function --region $(REGION) \ --function-name $(FUNCTION_NAME) \ --zip-file fileb://$(ZIPFILE_NAME) \ --role $(ROLE_ARN) \ --handler $(HANDLER) \ --runtime python2.7 \ --timeout $(TIMEOUT) \ --memory-size $(MEMORY_SIZE) update : build aws lambda update-function-code --region $(REGION) \ --function-name $(FUNCTION_NAME) \ --zip-file fileb://$(ZIPFILE_NAME) \ --publish

Las funciones principales de este Makefile son “crear” y “actualizar”. Estas funciones primero empaquetan el directorio actual, que representa todo el código necesario para ejecutar la función Lambda. A continuación, las dependencias especificadas en el archivo requirements.txt se instalarán en el subdirectorio actual para empaquetarlas. El paso de empaquetado comprime el contenido del directorio para luego cargarlo con el comando "awscli". Nuestro Makefile se puede adaptar para su uso en la otra definición de función de Lambda.

En la utilidad Makefile, definimos algunas variables necesarias para crear/actualizar nuestra imagen. Configúrelos según sea necesario para que los comandos Makefile funcionen correctamente para usted.

• ROLE_ARN : este es el nombre de recurso de Amazon que identifica nuestro rol bajo el cual ejecutar la función Lambda.
• FUNCTION_NAME : el nombre de la función de Lambda que estamos creando o actualizando.
• REGION : la región en la que se creará/actualizará la función Lambda.
• TIMEOUT : tiempo de espera en segundos antes de que se elimine una invocación de Lambda.
• MEMORY_SIZE : tamaño de la memoria en megabytes a la que tendrá acceso la función Lambda cuando se invoque.
• ZIPFILE_NAME : el nombre del paquete comprimido que contiene el código de la función Lambda y las dependencias.
• HANDLER : la ruta de importación absoluta, en notación de puntos, de la función del controlador.

Una vez configurado, ejecutar el comando make create generará algo similar al siguiente resultado:

 $ make create pip install -r requirements.txt -t . ... find . | grep .pyc| xargs rm zip image_resize.zip -r * ... aws lambda create-function --region ap-northeast-1 \ --function-name ResizeImage2 \ --zip-file fileb://image_resize.zip \ --role arn:aws:iam::11111111111:role/lambda_role \ --handler handler.handle_resize \ --runtime python2.7 \ --timeout 15 \ --memory-size 512 { "CodeSha256": "doB1hsujmZnxZHidnLKP3XG2ifHM3jteLEBvsK1G2nasKSo=", "FunctionName": "ResizeImage", "CodeSize": 155578, "MemorySize": 512, "FunctionArn": "arn:aws:lambda:us-west-1:11111111111:function:ResizeImage", "Version": "$LATEST", "Role": "arn:aws:iam::11111111111:role/lambda_role", "Timeout": 15, "LastModified": "2016-01-10T11:11:11.000+0000", "Handler": "handler.handle_resize", "Runtime": "python2.7", "Description": "" }

Pruebas

Después de ejecutar el comando de creación, la función de cambio de tamaño para nuestras imágenes está disponible para usarse, sin embargo, no se ha conectado al depósito S3 para recibir eventos. Todavía podemos probar la función a través de la consola de AWS para afirmar que la función maneja correctamente los eventos de carga de archivos de S3. En el panel de AWS Lambda, que se puede encontrar en la subsección "Cómputo" del menú desplegable "Servicios", seleccione el nombre de la función que hemos creado. Esta página de detalles de la función Lambda proporciona un menú desplegable denominado "Acciones" que contiene una opción denominada "Configurar evento de prueba".

Al hacer clic en esto, se abrirá un modal que le permitirá especificar un evento de prueba y algunas plantillas de ejemplo. Elija el ejemplo "S3 Put" y reemplace cualquier mención de un nombre de depósito con el nombre del depósito que se ha configurado. Una vez que se haya configurado, el uso posterior del botón "Prueba" en la página de la función Lambda invocará la función Lambda como si realmente hubiera ocurrido el evento configurado previamente.

Para monitorear cualquier seguimiento de la pila de errores o mensajes de registro, puede ver el flujo de registro en Cloudwatch. Se habrá creado un nuevo grupo de registros al mismo tiempo que se creó la función Lambda. Estos flujos de registro son útiles y se pueden canalizar a otros servicios.

Conectarse a eventos de depósito de S3

De vuelta en el panel de S3, expanda la sección "Eventos" colapsada ubicada en el menú "Propiedades" para mostrar el formulario "Notificaciones de eventos". Los campos obligatorios que debemos completar son las entradas "Eventos" y "Enviar a". En "Eventos", seleccione el evento "Objeto creado (todos)". Esto permitirá la interceptación de todos los eventos que crean un objeto en el depósito de carga. Para la entrada "Enviado a", seleccione el botón de radio "Función Lambda". Aparecerá una nueva sección con un desplegable que contiene la función lambda “ResizeImage” que hemos configurado como opción. Al hacer clic en "Guardar", cualquier evento de "Objeto creado" ahora se enrutará como una entrada para la invocación de la función Lambda "ResizeImage".

Ahora tenemos la funcionalidad principal de la aplicación. Ejecutemos otra prueba cURL para asegurarnos de que todo funciona como se esperaba. Use cURL para cargar una imagen en el depósito de S3 y verifique manualmente que la imagen se cargue en el depósito de cambio de tamaño.

 curl https://test-upload.s3.amazonaws.com -F 'key=test.jpeg' -F '[email protected]'

Al ejecutar este comando, la imagen redimensionada debe crearse en el depósito de "redimensionamiento de prueba" después de 50-1000 ms, dependiendo de si la función Lambda ya se ha "calentado".

Función Lambda de imagen de lista

Código

La función ListImage Lambda recuperará una lista de imágenes redimensionadas y las mostrará en una página HTML para el usuario. Esta página HTML también proporciona la funcionalidad para que el usuario cargue sus propias imágenes. Jinja2 se usa en la función para representar HTML a partir de una definición de plantilla. Al igual que antes, estos requisitos se especifican en el archivo requirements.txt .

 from __future__ import print_function import os import boto3 from jinja2 import Environment from jinja2 import FileSystemLoader def _render_template(image_urls): env = Environment(loader=FileSystemLoader(os.path.abspath(os.path.dirname(__file__)))) template = env.get_template('list.html') rendered_template = template.render(image_urls=image_urls) return rendered_template def handle_list_image(event, context): bucket = boto3.resource('s3').Bucket('test-resized') image_summaries = sorted((image_summary for image_summary in bucket.objects.all()), key=lambda o: o.last_modified) image_urls = [] for summary in image_summaries: image_urls.append( boto3.client('s3').generate_presigned_url( 'get_object', Params={ 'Bucket': summary.bucket_name, 'Key': summary.key } ) ) return {'htmlContent': _render_template(image_urls)}

 <html> <head> <title>List Images</title> <script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.4/jquery.min.js"></script> <script> var uploadImage = (function () { var inProgress = false; return function () { if (inProgress) { return; } inProgress = true; var formData = new FormData(); var fileData = $('#image-file').prop('files')[0]; formData.append('key', parseInt(Math.random() * 1000000)); formData.append('acl', 'public-read'); formData.append('file', fileData); $.ajax({ url: 'https://test-upload.s3.amazonaws.com/', type: 'POST', data: formData, processData: false, contentType: false, success: function (data) { window.location.reload(); } }); } })(); </script> <style type="text/css"> .image__container { float: left; width: 30%; margin-left: 2.5%; margin-right: 2.5%; max-width: 400px; } </style> </head> <body> <nav> <input type="file" onchange="uploadImage()" value="Upload Image" /> </nav> <section> {% for image_url in image_urls %} <div class="image__container"> <img src="{{ image_url }}" /> </div> {% endfor %} </section> </body> </html>

Una vez más, podemos modificar el Makefile anterior y usar el comando crear para implementar nuestra función lambda.

Puerta de enlace API

La función ImageList Lambda está completa, sin embargo, no se puede servir a ningún usuario. Esto se debe a que las funciones de Lambda solo se pueden llamar en respuesta a un evento de otro servicio o mediante programación. Aquí es donde entra en juego el servicio de puerta de enlace API de Amazon AWS. API Gateway se puede encontrar en la subsección "Servicios de aplicaciones".

API Gateway es una forma de modelar puntos finales como un conjunto de recursos y métodos, esencialmente una interfaz REST. Además de proporcionar una función para validar y transformar solicitudes, API Gateway realiza otras funciones, como proporcionar solicitudes de limitación de velocidad o limitación de velocidad.

Desde el tablero de API Gateway, cree una nueva API para servir la función ListImage. El nombre y la descripción se pueden configurar según sus preferencias. Una vez creada, haga clic en el nombre de la nueva API para acceder a los detalles de la API. Cree un nuevo recurso para la URL raíz "/". Esta URL se utilizará para servir la página HTML.

Mientras visualiza los detalles de la página de recursos raíz, agregue un método GET. Establezca el "Tipo de integración" en "Función Lambda", establezca la "Región Lambda" en "us-west-1" o su región seleccionada, y escriba el nombre de la función ListImage Lambda.

Antes de que podamos comenzar a mapear nuestra respuesta a una salida HTML, debemos definir un "modelo" que definirá un esquema para la respuesta del servidor además de mapear esta respuesta a un tipo de contenido. Seleccione la sección "Modelos" para la API y haga clic en "Crear" para crear un nuevo modelo. Asigne al modelo el nombre "HTML", con un tipo de contenido de "texto/html" y defina el esquema de la siguiente manera:

 { "$schema": "http://json-schema.org/draft-04/schema#", "title" : "HTML", "type" : "object" }

De vuelta en el panel de API, seleccione el recurso que hemos creado y navegue a la sección "Respuesta de integración". Esta sección define cualquier transformación para procesar después de recibir una respuesta de la función Lambda antes de canalizar la respuesta al paso final.

Abra la sección "Plantillas de mapeo" y agregue un nuevo "Tipo de contenido" de "texto/html". Elimine el antiguo "Tipo de contenido" al mismo tiempo. A la derecha, cambie el menú desplegable de "Transferencia de salida" a "Plantilla de asignación". Esto nos permitirá modificar el JSON sin formato aceptado por API Gateway y, en su lugar, usar el contenido HTML dentro de la propiedad "htmlContent" de nuestros datos devueltos. Para la plantilla de asignación, especifique "$input.htmlContent" como plantilla. Finalmente, modifique la sección "Respuesta de método" eliminando "aplicación/json" de "Modelos de respuesta para 200" y agregando "texto/html" en su lugar.

Volviendo al tablero de la API, hay un botón en la parte superior izquierda de la página con la etiqueta "Implementar API". Haga clic en este botón para actualizar o crear la API con los recursos, métodos, modelos y asignaciones especificados. Una vez hecho esto, se mostrará una URL para la etapa de implementación que se seleccionó (predeterminada). ¡Finalmente, el ejemplo está completo! Puede cargar algunos archivos para probar y ver las imágenes redimensionadas.

Terminando

AWS es un gran servicio y no desaparecerá pronto. Aunque el bloqueo del proveedor siempre es algo que se debe tener cuidado, AWS Lambda ofrece un servicio relativamente delgado con un amplio conjunto de opciones de configuración auxiliares. Aprovechar los servicios proporcionados por AWS para implementar aplicaciones fácilmente escalables y mantenibles brindará el mayor beneficio del uso de la plataforma de AWS. AWS Lambda ofrece una solución elegante, escalable y rentable respaldada por una plataforma de nivel empresarial utilizada por una gran cantidad de consumidores. Creo que las aplicaciones "sin servidor" son el camino hacia el futuro. Háganos saber lo que piensa en los comentarios a continuación.