Arquitetura orientada a serviços com AWS Lambda: um tutorial passo a passo

Publicados: 2022-03-11

Ao criar aplicativos da Web, há muitas escolhas a serem feitas que podem ajudar ou atrapalhar seu aplicativo no futuro, uma vez que você se comprometa com elas. Escolhas como idioma, estrutura, hospedagem e banco de dados são cruciais.

Uma dessas opções é criar um aplicativo baseado em serviço usando a Arquitetura Orientada a Serviços (SOA) ou um aplicativo tradicional monolítico. Essa é uma decisão de arquitetura comum que afeta startups, scale-ups e empresas corporativas.

A Arquitetura Orientada a Serviços é usada por um grande número de unicórnios conhecidos e empresas de alta tecnologia, como Google, Facebook, Twitter, Instagram e Uber. Aparentemente, esse padrão de arquitetura funciona para grandes empresas, mas pode funcionar para você?

Arquitetura orientada a serviços com AWS Lambda: um tutorial passo a passo

Arquitetura orientada a serviços com AWS Lambda: um tutorial passo a passo
Tweet

Neste artigo, apresentaremos o tópico da arquitetura orientada a serviços e como o AWS Lambda em combinação com o Python pode ser aproveitado para criar facilmente serviços escaláveis ​​e econômicos. Para demonstrar essas ideias, construiremos um serviço simples de upload e redimensionamento de imagens usando Python, AWS Lambda, Amazon S3 e algumas outras ferramentas e serviços relevantes.

O que é Arquitetura Orientada a Serviços?

A Arquitetura Orientada a Serviços (SOA) não é nova, tendo raízes de várias décadas atrás. Nos últimos anos, sua popularidade como padrão vem crescendo por oferecer muitos benefícios para aplicativos voltados para a web.

SOA é, em essência, a abstração de um grande aplicativo em muitos aplicativos menores de comunicação. Isso segue várias práticas recomendadas de engenharia de software, como desacoplamento, separação de interesses e arquitetura de responsabilidade única.

As implementações de SOA variam em termos de granularidade: desde muito poucos serviços que cobrem grandes áreas de funcionalidade até muitas dezenas ou centenas de pequenos aplicativos no que é chamado de arquitetura de “microsserviço”. Independentemente do nível de granularidade, o que é geralmente acordado entre os praticantes de SOA é que não é de forma alguma um almoço grátis. Como muitas boas práticas em engenharia de software, é um investimento que exigirá planejamento, desenvolvimento e testes extras.

O que é AWS Lambda?

AWS Lambda é um serviço oferecido pela plataforma Amazon Web Services. O AWS Lambda permite fazer upload de código que será executado em um contêiner sob demanda gerenciado pela Amazon. O AWS Lambda gerenciará o provisionamento e o gerenciamento de servidores para executar o código, portanto, tudo o que é necessário do usuário é um conjunto empacotado de código a ser executado e algumas opções de configuração para definir o contexto no qual o servidor é executado. Esses aplicativos gerenciados são chamados de funções do Lambda.

O AWS Lambda tem dois modos principais de operação:

Assíncrono/orientado a eventos:

As funções do Lambda podem ser executadas em resposta a um evento no modo assíncrono. Qualquer fonte de eventos, como S3, SNS, etc. não bloqueará e as funções do Lambda podem tirar proveito disso de várias maneiras, como estabelecer um pipeline de processamento para alguma cadeia de eventos. Existem muitas fontes de informações e, dependendo da fonte, os eventos serão enviados para uma função do Lambda da fonte do evento ou pesquisados ​​por eventos pelo AWS Lambda.

Síncrono/Solicitação->Resposta:

Para aplicativos que exigem que uma resposta seja retornada de forma síncrona, o Lambda pode ser executado no modo síncrono. Normalmente, isso é usado em conjunto com um serviço chamado API Gateway para retornar respostas HTTP do AWS Lambda para um usuário final, mas as funções do Lambda também podem ser chamadas de forma síncrona por meio de uma chamada direta para o AWS Lambda.

As funções do AWS Lambda são carregadas como um arquivo zip contendo o código do manipulador, além de quaisquer dependências necessárias para a operação do manipulador. Após o upload, o AWS Lambda executará esse código quando necessário e dimensionará o número de servidores de zero a milhares quando necessário, sem nenhuma intervenção extra exigida pelo consumidor.

Funções Lambda como uma evolução de SOA

SOA básico é uma maneira de estruturar sua base de código em pequenos aplicativos para beneficiar um aplicativo das maneiras descritas anteriormente neste artigo. Decorrente disso, o método de comunicação entre essas aplicações entra em foco. A SOA orientada a eventos (também conhecida como SOA 2.0) permite não apenas a comunicação direta tradicional de serviço a serviço da SOA 1.0, mas também a propagação de eventos por toda a arquitetura para comunicar a mudança.

A arquitetura orientada a eventos é um padrão que naturalmente promove baixo acoplamento e composição. Ao criar e reagir a eventos, os serviços podem ser adicionados ad hoc para adicionar novas funcionalidades a um evento existente, e vários eventos podem ser compostos para fornecer funcionalidades mais ricas.

O AWS Lambda pode ser usado como plataforma para criar aplicativos SOA 2.0 com facilidade. Há muitas maneiras de acionar uma função Lambda; da abordagem tradicional de fila de mensagens com o Amazon SNS a eventos criados por um arquivo sendo carregado no Amazon S3 ou um e-mail enviado com o Amazon SES.

Implementando um serviço de upload de imagem simples

Construiremos um aplicativo simples para fazer upload e recuperar imagens utilizando a pilha da AWS. Este projeto de exemplo conterá duas funções lambda: uma rodando no modo solicitação->resposta que será usada para servir nosso frontend web simples, e outra que detectará imagens carregadas e as redimensionará.

A primeira função lambda será executada de forma assíncrona em resposta a um evento de upload de arquivo acionado no bucket do S3 que abrigará as imagens carregadas. Ele pegará a imagem fornecida e a redimensionará para caber em uma imagem de 400 x 400.

A outra função lambda servirá a página HTML, fornecendo a funcionalidade para um usuário visualizar as imagens redimensionadas por nossa outra função Lambda, bem como uma interface para fazer upload de uma imagem.

Configuração inicial da AWS

Antes de começarmos, precisaremos configurar alguns serviços necessários da AWS, como IAM e S3. Eles serão configurados usando o console AWS baseado na web. No entanto, a maior parte da configuração também pode ser obtida usando o utilitário de linha de comando da AWS, que usaremos mais tarde.

Criando buckets do S3

O S3 (ou Simple Storage Service) é um serviço de armazenamento de objetos da Amazon que oferece armazenamento confiável e econômico de qualquer dado. Usaremos o S3 para armazenar as imagens que serão enviadas, bem como as versões redimensionadas das imagens que processamos.

O serviço S3 pode ser encontrado na lista suspensa "Serviços" no console da AWS na subseção "Armazenamento e entrega de conteúdo". Ao criar um bucket, você será solicitado a inserir o nome do bucket e selecionar uma região. A seleção de uma região próxima aos seus usuários permitirá que o S3 otimize a latência e o custo, bem como alguns fatores regulatórios. Para este exemplo, selecionaremos a região “US Standard”. Essa mesma região será usada posteriormente para hospedar as funções do AWS Lambda.

Vale a pena observar que os nomes dos buckets do S3 precisam ser exclusivos, portanto, se o nome escolhido for usado, você deverá escolher um nome novo e exclusivo.

Para este projeto de exemplo, criaremos dois buckets de armazenamento denominados “test-upload” e “test-resized”. O bucket "test-upload" será usado para fazer upload de imagens e armazenar a imagem enviada antes de ser processada e redimensionada. Depois de redimensionada, a imagem será salva no bucket "teste-resized" e a imagem bruta enviada será removida.

Permissões de upload do S3

Por padrão, as permissões do S3 são restritivas e não permitem que usuários externos ou mesmo usuários não administrativos leiam, gravem, atualizem ou excluam quaisquer permissões ou objetos no bucket. Para alterar isso, precisaremos fazer login como usuário com direitos para gerenciar as permissões do bucket da AWS.

Supondo que estejamos no console da AWS, podemos visualizar as permissões para nosso bucket de upload selecionando o bucket por nome, clicando no botão “Properties” no canto superior direito da tela e abrindo a seção “Permissions” recolhida.

Para permitir que usuários anônimos façam upload para este bucket, precisaremos editar a política do bucket para permitir a permissão específica que permite o upload. Isso é feito por meio de uma política de configuração baseada em JSON. Esse tipo de política JSON é amplamente usado em toda a AWS em conjunto com o serviço IAM. Ao clicar no botão “Editar política de bucket”, basta colar o seguinte texto e clicar em “Salvar” para permitir uploads de imagens 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/*" } ] }

Depois de fazer isso, podemos verificar se a política do bucket está correta tentando fazer upload de uma imagem para o bucket. O seguinte comando cURL fará o truque:

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

Se uma resposta de 200 intervalos for retornada, saberemos que a configuração do bucket de upload foi aplicada com sucesso. Nossos buckets do S3 agora devem estar (principalmente) configurados. Voltaremos mais tarde a este serviço no console para conectar nossos eventos de upload de imagem à invocação de nossa função de redimensionamento.

Permissões do IAM para Lambda

Todas as funções do Lambda são executadas em um contexto de permissão, neste caso, uma “função” definida pelo serviço do IAM. Essa função define todas e quaisquer permissões que a função do Lambda tem durante sua invocação. Para os propósitos deste projeto de exemplo, criaremos uma função genérica que será usada entre as duas funções do Lambda. No entanto, em um cenário de produção, uma granularidade mais fina nas definições de permissão é recomendada para garantir que quaisquer explorações de segurança sejam isoladas apenas para o contexto de permissão que foi definido.

O serviço IAM pode ser encontrado na subseção "Segurança e identidade" da lista suspensa "Serviços". O serviço IAM é uma ferramenta muito poderosa para gerenciar o acesso nos serviços da AWS, e a interface fornecida pode ser um pouco esmagadora no início se você não estiver familiarizado com ferramentas semelhantes.

Uma vez na página do painel do IAM, a subseção "Funções" pode ser encontrada no lado esquerdo da página. A partir daqui, podemos usar o botão “Create New Role” para abrir um assistente de várias etapas para definir as permissões da função. Vamos usar “lambda_role” como o nome da nossa permissão genérica. Depois de continuar na página de definição de nome, você verá a opção de selecionar um tipo de função. Como exigimos apenas acesso ao S3, clique em “AWS Service Roles” e na caixa de seleção selecione “AWS Lambda”. Você será presenteado com uma página de políticas que podem ser anexadas a esta função. Selecione a política “AmazonS3FullAccess” e prossiga para a próxima etapa para confirmar a função a ser criada.

É importante observar o nome e o ARN (Amazon Resource Name) da função criada. Isso será usado ao criar uma nova função do Lambda para identificar a função que deve ser usada para invocação de função.

Observação: o AWS Lambda registrará automaticamente todas as saídas de invocações de função no AWS Cloudwatch, um serviço de registro em log. Se essa funcionalidade for desejada, o que é recomendado para um ambiente de produção, a permissão para gravar em um fluxo de log do Cloudwatch deve ser adicionada às políticas para essa função.

O código!

Visão geral

Agora estamos prontos para começar a codificar. Assumiremos neste ponto que você configurou o comando “awscli”. Se não tiver, você pode seguir as instruções em https://aws.amazon.com/cli/ para configurar o awscli em seu computador.

Nota: o código usado nestes exemplos é reduzido para facilitar a visualização da tela. Para uma versão mais completa, visite o repositório em https://github.com/gxx/aws-lambda-python/.

Em primeiro lugar, vamos configurar uma estrutura de esqueleto para o nosso projeto.

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

Temos dois subdiretórios em nossa estrutura, um para cada uma de nossas funções lambda. Em cada um deles temos os arquivos comuns handler.py, Makefile e requirements.txt. O arquivo handler.py conterá o método para chamar a invocação de cada uma das funções lambda e pode ser considerado o ponto de entrada para as funções. O arquivo requirements.txt conterá uma lista de nossas dependências, para que possamos especificar e atualizar os requisitos facilmente. Por fim, o comando Makefile que usaremos para fornecer um mecanismo fácil de interação com o awscli. Isso tornará o processo de criação e atualização de nossa função lambda muito mais fácil.

Você notará o arquivo .pydistutils.cfg na raiz do diretório do nosso projeto. Este arquivo é necessário se você estiver trabalhando com Python no Homebrew. Devido ao método de implantação de uma função do Lambda (abordado na seção a seguir), esse arquivo é necessário. Consulte o repositório para obter mais detalhes.

Redimensionar a função Lambda da imagem

Código

Começando com a função resize_image, congelaremos a dependência Wand, nossa biblioteca de processamento de imagens, salvando Wand==0.4.2 em requirements.txt. Esta será a única dependência para nossa função lambda image_resize. A função resize_image em resize.py precisará manipular um recurso de imagem da biblioteca Wand e redimensioná-lo de acordo com os parâmetros de largura e altura especificados. Para preservar a imagem que está sendo redimensionada, usaremos um algoritmo de redimensionamento de “melhor ajuste” que manterá a proporção da imagem original, reduzindo o tamanho da imagem para caber dentro da largura e altura especificadas.

 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

Com isso fora do caminho, uma função de manipulador é necessária para aceitar o evento gerado por uma imagem carregada no S3, entregá-la à função resize_image e salvar a imagem 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()

Implantando

Com o código completo, ele precisará ser carregado no Amazon Lambda como uma nova função do Lambda. É aqui que o Makefile que foi adicionado à estrutura de diretórios entra em ação. Este Makefile será usado para implantar as definições de função do Lambda que estamos criando.

 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

As principais funções deste Makefile são “criar” e “atualizar”. Essas funções primeiro empacotam o diretório atual, que representa todo o código necessário para executar a função do Lambda. Em seguida, quaisquer dependências especificadas no arquivo requirements.txt serão instaladas no subdiretório atual a ser empacotado. A etapa de empacotamento compacta o conteúdo do diretório para ser carregado posteriormente com o comando “awscli”. Nosso Makefile pode ser adaptado para uso em outra definição de função do Lambda.

No utilitário Makefile, definimos algumas variáveis ​​necessárias para criar/atualizar nossa imagem. Configure-os conforme necessário para que os comandos Makefile funcionem corretamente para você.

  • ROLE_ARN : este é o nome de recurso da Amazon que identifica nossa função sob a qual executar a função do Lambda.
  • FUNCTION_NAME : o nome da função Lambda que estamos criando/atualizando.
  • REGION : a região sob a qual a função Lambda será criada/atualizada.
  • TIMEOUT : Tempo limite em segundos antes que uma invocação do Lambda seja eliminada.
  • MEMORY_SIZE : tamanho da memória em megabytes ao qual a função Lambda terá acesso quando invocada.
  • ZIPFILE_NAME : o nome do pacote compactado que contém o código da função Lambda e as dependências.
  • HANDLER : O caminho de importação absoluto, em notação de ponto, da função do manipulador.

Uma vez configurado, a execução do comando make create gerará algo semelhante à seguinte saída:

 $ 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": "" }

Teste

Após executar o comando de criação, a função de redimensionamento de nossas imagens fica disponível para ser utilizada, porém não foi conectada ao bucket do S3 para receber eventos. Ainda podemos testar a função por meio do Console AWS para afirmar que a função trata adequadamente os eventos de upload de arquivo do S3. No painel do AWS Lambda, que pode ser encontrado na subseção “Compute” da lista suspensa “Services”, selecione o nome da função que criamos. Esta página de detalhes da função do Lambda fornece uma lista suspensa chamada "Ações" contendo uma opção chamada "Configurar evento de teste".

Clicar nele abrirá um modal permitindo que você especifique um evento de teste e alguns modelos de exemplo. Escolha o exemplo “S3 Put” e substitua qualquer menção de um nome de bucket pelo nome do bucket que foi configurado. Depois de configurado, o uso subsequente do botão “Test” na página da função Lambda invocará a função Lambda como se o evento configurado anteriormente tivesse realmente ocorrido.

Para monitorar quaisquer rastreamentos de pilha de erros ou mensagens de log, você pode visualizar o fluxo de log no Cloudwatch. Um novo grupo de logs será criado ao mesmo tempo em que a função do Lambda foi criada. Esses fluxos de log são úteis e podem ser canalizados para outros serviços.

Conectando-se a eventos de bucket do S3

De volta ao painel do S3, expanda a seção “Eventos” recolhida localizada no menu “Propriedades” para mostrar o formulário “Notificações de eventos”. Os campos obrigatórios para nós preenchermos são as entradas “Eventos” e “Enviar para”. Em “Eventos”, selecione o evento “Objeto Criado (Todos)”. Isso permitirá a interceptação de todos os eventos que criam um objeto no bucket de upload. Para a entrada “Enviado para”, selecione o botão de opção “Função Lambda”. Uma nova seção aparecerá com uma lista suspensa contendo a função lambda “ResizeImage” que configuramos como opção. Ao clicar em “Salvar”, qualquer evento “Objeto Criado” agora será roteado como uma entrada para a invocação da função Lambda “ResizeImage”.

Agora temos a funcionalidade principal do aplicativo. Vamos executar outro teste cURL para garantir que tudo esteja funcionando conforme o esperado. Use cURL para carregar uma imagem no bucket do S3 e verifique manualmente se a imagem foi carregada no bucket de redimensionamento.

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

Ao executar este comando, a imagem redimensionada deve ser criada no bucket “teste-resized” após 50-1000ms, dependendo se a função Lambda já estava “aquecendo”.

Função Lambda da imagem de lista

Código

A função ListImage Lambda recuperará uma lista de imagens redimensionadas e as exibirá em uma página HTML para o usuário. Esta página HTML também fornece a funcionalidade para o usuário fazer upload de suas próprias imagens. Jinja2 é usado na função para renderizar HTML a partir de uma definição de modelo. Assim como antes, esses requisitos são especificados no arquivo 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>

Mais uma vez, podemos alterar o Makefile anterior e usar o comando create para implantar nossa função lambda.

Gateway de API

A função ImageList Lambda está concluída, mas não pode ser fornecida a nenhum usuário. Isso ocorre porque as funções do Lambda só podem ser chamadas em resposta a um evento de outro serviço ou programaticamente. É aqui que o serviço Amazon AWS API Gateway entra em ação. O API Gateway pode ser encontrado na subseção "Serviços de aplicativos".

O API Gateway é uma forma de modelar endpoints como um conjunto de recursos e métodos, essencialmente uma interface REST. Além de fornecer um recurso para validar e transformar solicitações, o API Gateway executa outras funções, como fornecer solicitações de limitação/limitação de taxa.

No painel do API Gateway, crie uma nova API para servir a função ListImage. O nome e a descrição podem ser definidos de acordo com sua preferência. Uma vez criada, clique no nome da nova API para acessar os detalhes da API. Crie um novo recurso para a URL raiz “/”. Este URL será usado para servir a página HTML.

Ao visualizar os detalhes da página de recurso raiz, adicione um método GET. Defina o “Tipo de integração” como “Função Lambda”, defina a “Região do Lambda” como “us-west-1” ou sua região selecionada e digite o nome da função ListImage Lambda.

Antes de começarmos a mapear nossa resposta para uma saída HTML, precisamos definir um “modelo” que definirá um esquema para a resposta do servidor, além de mapear essa resposta para um tipo de conteúdo. Selecione a seção “Modelos” para a API e clique em “Criar” para criar um novo modelo. Dê ao modelo o nome “HTML”, com um tipo de conteúdo de “text/html” e defina o esquema da seguinte forma:

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

De volta ao painel da API, selecione o recurso que criamos e navegue até a seção "Resposta de integração". Esta seção define qualquer transformação a ser processada após receber uma resposta da função do Lambda antes de canalizar a resposta para a etapa final.

Abra a seção “Mapping Templates” e adicione um novo “Content Type” de “text/html”. Remova o antigo “Tipo de conteúdo” ao mesmo tempo. À direita, altere o menu suspenso de “Passagem de saída” para “Modelo de mapeamento”. Isso nos permitirá alterar o JSON bruto aceito pelo API Gateway e usar o conteúdo HTML dentro da propriedade “htmlContent” de nossos dados retornados. Para o modelo de mapeamento, especifique “$input.htmlContent” como o modelo. Por fim, altere a seção “Method Response” removendo “application/json” de “Response Models for 200” e adicionando “text/html”.

Voltando ao painel da API, há um botão no canto superior esquerdo da página chamado “Implantar API”. Clique neste botão para atualizar ou criar a API com os recursos, métodos, modelos e mapeamentos especificados. Feito isso, uma URL será exibida para o estágio de implantação selecionado (predefinição). Finalmente, o exemplo está completo! Você pode fazer upload de alguns arquivos para testar e visualizar as imagens redimensionadas.

Empacotando

A AWS é um serviço grande e não desaparecerá tão cedo. Embora o aprisionamento do fornecedor seja sempre algo para se ter cuidado, o AWS Lambda oferece um serviço relativamente pequeno com um rico conjunto de opções de configuração auxiliares. Aproveitar os serviços fornecidos pela AWS para implementar aplicativos facilmente escaláveis ​​e de fácil manutenção proporcionará o maior benefício do uso da plataforma AWS. O AWS Lambda oferece uma solução elegante, escalável e econômica, apoiada por uma plataforma de nível empresarial usada por um grande número de consumidores. Acredito que aplicativos “sem servidor” são o caminho do futuro. Deixe-nos saber o que você pensa nos comentários abaixo.