AWS Lambda

É um serviço em que podemos executar funções de forma serveless. Podemos importar códigos para dentro ou para fora da AWS quando necessário e utilizado linguagens de programação que já conhecemos.

Também podemos executar chamadas de API’s da internet, da própria AWS ou de datacenters. Com o aumento de demanda a necessidade de escalabilidade do serviço é feito pela própria AWS automaticamente a depender de eventos que ocorram.

Custos e uso gratuito

Esse serviço tem certos limite de uso gratuito como especificado abaixo:

Para saber mais sobres os custos desse serviço e de outros recomendo acessar: Free Tier Categories

OBS: alguns serviços só tem esse free-tier por 12 meses(como o API Gateway que veremos mais a frente)

Caso esteja utilizando o AWS academy pode haver diferenças nessas informações, por isso recomendamos buscar no site deles as orientações adequadas caso seja seu caso.

Linguagens que AWS Lambda suporta

• C#

• GO

• Python

• JAVA

• Node.JS

• Ruby

• PowerShell

Para quem gerealmente utiliza IDE’s para programar algumas delas tem plugins que são disponibilizados pela AWS. Temos como exemplo: VSCode, Eclipse, IntelliJ e PyCharm.

Autorizações para as funções Lambda

Como a AWS permite interações entre seus diversos tipos de serviços, pode-se surgir a necessidade de a função Lambda ser chamada por algum outro serviço ou também pode executar alterações em outros serviços. Para que isso ocorra adequadamente é preciso fazer 2 tipos de autorização.

1. Autorização para invocar a função: chamada de Resource-based policy, esse tipo de autorização indica quais serviços podem fazer uso da função que criarmos

2. Autorização para execução: chamada de execution role, indica para função Lambda quais serviços ela pode acessar.

Como funciona a função handler

A função handler é a principal do nosso código. Ela recebe 2 parâmetros chamados event e context. Ambos são objetos mas cada um com uma característica diferente:

• Event: objeto com todas as informações passadas para a função para que ela execute de forma apropriada.

• Context: objeto que nos auxilia a mudar o ambiente de execução da função lambda se necessário.

Essa função sempre será executada quando houver a invocação da função Lambda por meio de algum evento

Como criar uma função

Primeiramente precisamos acessar o serviço chamado AWS Lambda. Após isso seguiremos os seguintes passos:

1. Clique em criar função

2. Preencher campos: coloque o nome da função e a arquitetura que será utilizada como mostrado abaixo, além da linguagem que iremos utilizar para escrever o código

3. 
4. Role: vamos utilizar o LabRole.(essa role só existe na AWS Academy lab caso esteja em uma conta pessoal é preciso criar um role para essa função)

5. Crie a função

6. Vá para o código da função: Selecione a função que queira ajustar e vá para a parte do código:

7. 

É nessa parte em que escreveremos nosso código em python. Faremos uma função que faça ser mostrado na tela uma pirâmide formada pelo caracter que escolhermos passar para ela. Segue abaixo o código comentado:

import json

def get_pyramid_chars(char:str,amount:int)->str:
"""
Função responsável por criar as linhas com os caracteres da pirâmide.
	-amount: inteiro que indica a quantidade de caracteres que terá na linha
	-char: caractere que deve estar presente ne linha
	-retorna a linha que foi criada dentro da função
	"""
   answer = ""
   char_amnt = 0
   while char_amnt < amount:
      answer += (char + " ")
      char_amnt += 1

   return answer


def lambda_handler(event, context):

""" Função reponsável por analisar o evento que acionará o Lambda Function.Ela sempre
 será executada após uma chamada do Lambda function.
	 -event: objeto com todas as informações passadas para a função para que ela execute de 
	 forma apropriada é aqui que vai estar o caracter que deve formar a pirâmide e sua largura
	 
	 -context: objeto que nos auxilia a mudar o ambiente de execução da função lambda se 
	 necessário.
"""
	  
	    request_parameters:dict = event.get('queryStringParameters', {}) #pega os parâmetros passados  
    drawing_char:str = request_parameters.get('caracter_desenho','') #seleciona o parametro que indicará o caracter a ser utilizado
    pyramid_base_width:int = int(request_parameters.get('largura_piramide',-1)) #seleciona o parâmetro que indica a largura que a pirãmide deve ter
    
    #verifica se os valores dos parâmetros foram passados adequadamente
    if not drawing_char or pyramid_base_width == -1:
        return {
            'statusCode': 400,
            'body': json.dumps('argumentos mal-formatados')
        }
    
    answer = ""
    #Loop para chamar a função que cria as linhas da pirâmide e juntar cada linha dentro da variável answer
    for i in range(1,pyramid_base_width+1):
       side_whitespaces = pyramid_base_width - i
       spaces = "".join([" " for x in range(side_whitespaces)])#espaços que devem estar antes e depois dos caracteres para que os níveis estejam no local certo e o desenho da pirâmide adequado
    
       answer += spaces
       answer += get_pyramid_chars(drawing_char,i)
       answer += (spaces + "\n")
     #resposta no formato adequado para renderizar o html  
    html_response = f"<pre>{answer}</pre>"
    return {
            "statusCode": 200,
            "headers": {
                "Content-Type": "text/html"
            },
            "body": html_response
    }

Com isso criamos juntos uma função de exemplo no AWS Lambda. Vamos agora criar uma API com o API Gateway e fazer uma interação entre ela e a função que criamos. A API será responsável por enviar o evento de acionamento da função, de forma a passar os parâmetros caracter_desenho e largura_piramide para que a função funcione adequadamente. Segue um exemplo de como será passado esses parâmetros :

{url_api_gateway}/rota1?caracter_desenho=*&largura_piramide=5