DEV Community: camilo cabrales

IA Generativa en el desarrollo de Software

camilo cabrales — Tue, 05 Nov 2024 22:27:18 +0000

La IA Generativa nos da muchas oportunidades para mejorar, crear y aprender cuando vamos a crear o actualizar software.

Cuando empece en el desarrollo de software los IDE eran muy incipientes y no tenían muchas funcionalidades ni siquiera auto completar, después fueron mejorando con otras funcionalidades hasta llegar hasta el tiempo de la IA donde con unas simples instrucciones podemos obtener bastante código funcional y en poco tiempo. Ahora con esta aceleración a llegado un cambio exponencial para las personas que desarrollamos ya que nos debemos y tenemos que acostumbrarnos y aprender a usar estas herramientas para sacar el mejor provecho de ellas.

Hay muchas herramientas en el mercado especializadas en desarrollo de software las cuales podemos usar como:

Amazon Q
GitHub Copilot
Gemini
Cursor (IDE especializado para IA)

y todos los LLM que podemos encontrar: ChatGPT, Gemini, Claude, LLama, etc.

Tenemos demasiadas herramientas en este momento sin embargo lo que creo mas importante es que las adoptemos y nos acostumbremos a usarlas en nuestro día a día, para encontrarles la mejor aplicación en nuestras actividades de desarrollo ya que no hay otra forma de encontrarles su utilidad si no las usamos.
En estos momentos en muchos casos no es necesario tener todo un equipo: front, back, qa o arquitectura para crear un proyecto pequeño o mediano ya que estas herramientas nos ayudan a suplir estos roles de cierta forma.

Con el uso de Amazon Q me apoye para crear el siguiente juego para familiarizarse con los servicios de AWS:

https://d3ohjbsa11flwi.cloudfront.net/

Utilice estas herramientas de IA sobre todo para la creación de la interfaz de usuario ya que no soy experto, reduciendo el tiempo bastante, creo que si lo hubiera hecho solo tal vez me habría tardado mas de dos semanas y con este acelerador me demore solamente un par de días.

Desde mi punto de vista creo que estas herramientas las van a seguir perfeccionando por lo que es necesario que desde sus "inicios" las aprendamos a usar ya que en realidad son de bastante ayuda y como en este caso de una persona no experta en front logro un buen resultado en poco tiempo, cuanto mejor seria el resultado en manos de una persona experta en front. Mucho mejor.

Mi invitación es a que utilicemos estas herramientas para mejorar nuestros desarrollos y crear mejores productos, esto es el presente y futuro del desarrollo. Aprovechémoslo.

English

Generative AI gives us many opportunities to improve, create, and learn when we set out to develop or update software.

When I started in software development, IDEs were very basic and lacked many functionalities, not even offering autocomplete. Over time, they gradually improved with additional features, leading up to today’s AI-driven era, where with just a few instructions, we can generate functional code in very little time. This acceleration has brought an exponential shift for developers like us, as we now need to adapt and learn to use these tools to maximize their potential.

There are many specialized software development tools available on the market that we can use, such as:

Amazon Q
GitHub Copilot
Gemini
Cursor (an AI-specialized IDE)
...and all the LLMs we can find: ChatGPT, Gemini, Claude, LLaMA, and so on.

We have a vast array of tools available at the moment; however, what I believe is most important is that we adopt them and get used to using them daily to find the best application for our development activities. We can’t truly understand their utility unless we actually use them.

Currently, in many cases, it’s no longer necessary to have an entire team—front-end, back-end, QA, or architecture—to create a small or medium project, as these tools can help us cover these roles to some extent.

For instance, I used Amazon Q to support the creation of the following game to help people become familiar with AWS services:

https://d3ohjbsa11flwi.cloudfront.net/

I relied heavily on these AI tools, especially for creating the user interface, as I'm not an expert in UI design. This greatly reduced the time; if I had done it alone, it might have taken me over two weeks, but with this accelerator, I completed it in just a couple of days.

In my opinion, I think these tools will continue to improve, so it’s essential that we learn to use them from these “early stages,” as they are incredibly helpful. In this case, a non-expert in front-end achieved a good result in little time; imagine how much better the outcome would be in the hands of a front-end expert. Much better.

My invitation is for us to use these tools to improve our development processes and create better products—this is the present and future of development. Let’s make the most of it.

Limpiar y preparar grandes cantidades de datos de manera fácil con Glue DataBrew

camilo cabrales — Mon, 27 Mar 2023 16:48:49 +0000

Usualmente cuando queremos realizar un proceso de ETL (Extraer, Transformar, Cargar) utilizamos algunas herramientas o lenguajes de programación nos ayudan en este proceso. El desarrollo de ETL requiere de ciertos conocimientos técnicos, que nos tomaran un tiempo en adquirir. Para simplificar este proceso AWS tiene un servicio llamado Glue DataBrew que nos va a simplificar y agilizar la tarea de realizar las ETL.

En este post vamos a crear la siguiente arquitectura:

EL objetivo de esta arquitectura es: Cuando se cargue un archivo al Bucket este llame a una función Lambda que a su vez va a ejecutar una Step Fucntion que va realizar el procesamiento que hallamos definido para nuestro data set y enviara un mensaje de texto si se ejecuto correctamente o si hubo un error durante el procesamiento de la información.

Iniciemos creando el Bucket que va almacenar nuestro conjunto de datos y el resultado del proceso de ETL. Para esto buscamos el servicio de S3 y damos click en el botón Create Bucket, una vez en la pagina de creación del Bucket le damos un nombre (el nombre debe ser úrico en todo AWS), dejamos las opciones por defecto y damos click en el botón en Create Bucket que se encuentra en la parte inferior de la pantalla.

Vamos a crear dos carpetas en nuestro Bucket una para los archivos que vamos a procesar y otra de resultados. Damos click en el botón Create Folder.

La carpeta que contiene el archivo a procesar le damos el nombre de procesardata y la que almacena los resultados le damos el nombre de resultados.
Creamos la carpeta procesardata y realizamos el mismo procedimiento para la carpeta de resultados.

Creadas las carpetas deberíamos verlas en nuestro Bucket.

Ahora necesitamos subir a la carpeta de procesardata el archivo con el cual vamos a trabajar damos click en la carpeta y damos click en el botón Upload.

Seleccionamos el archivo y damos click en el botón Upload.

Ya que tenemos el archivo con el cual vamos a trabajar, buscamos el servicio Glue DataBrew una vez en la pagina principal damos click en DataSets.

En la siguiente pantalla seleccionamos el Bucket, el folder procesardata y el archivo precios.csv.

Para terminar con la creación del DataSet seleccionamos el tipo de archivo el cual estamos utilizando (.CSV separado por comas) e indicamos que la primera fila del archivo es la cabecera y damos click en el botón Create dataset.

Creado nuestro DataSet el siguiente paso es crear un proyecto en el cual vamos a realizar las modificaciones de nuestros datos. para esto damos click en Projects y luego en el botón Create project.

Para crear el proyecto necesitamos la siguiente información:

Nombre del proyecto
Receta o nombre de la receta si vamos a crear una nueva. La receta son las modificaciones que vamos a realizar al conjunto de datos.
Debemos seleccionar el Dataset con el cual vamos a trabajar.
Debemos utilizar un rol existente o crear uno nuevo definiendo un prefijo para este.

Creado nuestro proyectos veremos una pagina como la siguiente.

En la parte superior vamos a ver las opciones de uso frecuente de la receta que podemos aplicar a nuestros datos.
Abajo de la cabecera de nuestros datos vamos a poder observar las estadísticas de cada columna, lo que nos ayuda a tener una idea del comportamiento de los datos que están almacenados dentro de cada una de ellas.
En la parte derecha de la pantalla tenemos la sección de la receta, donde vamos a poder agregar diferentes tipos de modificaciones a nuestro conjunto de datos.

Ya que esta listo nuestro proyecto para trabajar vamos a crear nuestra receta, para esto damos click en el botón Add step que se encuentra en la sección de la receta.

Una vez damos click en el botón Add step se despliegan las diferentes opciones que podemos utilizar para modificar los datos. Vamos a seleccionar la opción Change to capital case de la sección de FORMAT.

Como la columna PRODUCTO tiene los nombres en mayusculas los vamos a cambiar para que cada palabra empieza por una letra en mayúscula.

Al dar click en el botón Apply veremos los resultados.

Vemos que las columnas de los días tienen los precios de cada producto, sin embargo si quisiéramos hacer alguna operación matemática sobre ellos no será posible debido a que tienen el signo $. Veamos como podemos eliminar el signo $ de las columnas.

Vamos al menú superior seleccionamos Clean y en la sección Remove seleccionamos Special characters.

Al realizar la selección en sección de Recipies se nos despliegan las opciones para realizar la limpieza de la columna. Seleccionamos la columna LUNES,Special characters y Custom value para remover el signo - que aparece delante de los ceros.

Al dar click en el botón Apply veremos que de la columna LUNES se quitaron los caracteres: - $ y se agrego un nuevo paso a nuestra receta. Este proceso lo puedes realizar para el resto de columnas de los días de la semana.

Al finalizar de remover los caracteres especiales de las columnas de los días de la semana, nuestra receta se vera de la siguiente forma.

Ahora que nuestras columnas no tienen caracteres especiales vamos a cambiar el tipo de dato para poder realizar algunas operaciones. En la parte superior de cada columna podemos ver el tipo de datos de cada columna, en las columnas de los días de la semana identificamos que son de tipo string y necesitamos cambiarlas a un valor numérico en este caso double.

Al dar click en Change type se nos presentan las opciones donde debemos seleccionar la columna y el tipo de dato al cual queremos cambiar.

Damos click en el botón Apply dando como resultado el cambio de tipo de columna y un nuevo paso se agrego a nuestra receta.

Debemos hacer este mismo procedimiento a las otras columnas, para que nuestra receta quede de la siguiente forma.

Para terminar con nuestra receta vamos a crear un nueva columna llamada Total que va almacenar la suma de los días LUNES Y VIERNES.
Hacemos click en botón FUNCTIONS - Math functions - ADD.

En la sección de la receta veremos las opciones donde seleccionamos el tipo de función (ADD), las columnas que vamos a sumar (LUNES Y VIERNES) y por ultimo damos el nombre de la columna que va almacenar el resultado (Total).

Al dar click en el botón Apply vemos que se creo la columna total y contiene la suma de las columnas LUNES Y VIERNES.

Con esto finalizamos la modificación de nuestro DataSet, ahora necesitamos definir como se van a ejecutar estas modificaciones por lo tanto necesitamos crear un Job.
Damos click en el botón Create job.

En la pantalla de creación del Job le asignamos un nombre al Job, seleccionamos el Bucket y la carpeta en la cual queremos que se almacenen los resultados (Bucket y carpeta que creamos al inicio) y le asignamos un rol que puede ser el que creamos al momento de configurar el proyecto o uno nuevo.

Al crearse el Job vamos a ver el listado con los Jobs que hayamos creado, seleccionamos el Job que acabamos de crear y damos click en el botón Run Job.

Para ver los resultados podemos ir a la carpeta resultados del Bucket que creamos y ver el archivo que genero el Job.

Hemos visto como crear, modificar un DataSet y obtener los resultados por medio de las recetas y los Jobs.
Ahora necesitamos implementar los siguientes servicios para completar nuestra arquitectura:

Un Topic y una Suscripción de SNS para enviar los mensajes de notificación.
Una Step Function que va a realizar todo el flujo para procesar el Dataset, modificando el Dataset para que tome el archivo que se suba a S3, ejecutar el Job y enviar una mensaje de texto para notificar que el proceso se realizo correctamente.
Una función Lambda que se va encargar de llamar a la Step Function cuando se suba un archivo al Bucket de S3.

Esta implementación la vamos a realizar con la siguiente plantilla de Terraform.

provider "aws" {
  region = "us-east-1"
}


resource "random_id" "random" {
  byte_length = 2
}

variable "job_name"{
    type= string
    default= "PreciosJob"
}

variable "bucket_name" {
    type = string
    default = "datosgluedatabrew"
}

variable "telefono"{
    type = string
    default = "+573005465765"
}

resource "aws_lambda_function" "lambda_function_call_step_function" {
  filename      = "lambda_function.py.zip"
  function_name = "LambdaStepFunction-${random_id.random.hex}"
  role          = aws_iam_role.lambda_execution_role.arn
  handler       = "lambda_function.lambda_handler"
  runtime       = "python3.8"
  memory_size   = 128
  timeout       = 5
  environment {
    variables = {
      STEPFUNCTIONARN = aws_sfn_state_machine.function.arn
    }
  }
}

resource "aws_iam_role" "lambda_execution_role" {
  name = "lambda_execution_role-${random_id.random.hex}"

  assume_role_policy = jsonencode({
    Version = "2012-10-17"
    Statement = [
      {
        Action = "sts:AssumeRole"
        Effect = "Allow"
        Principal = {
          Service = "lambda.amazonaws.com"
        }
      }
    ]
  })
}

resource "aws_iam_role_policy_attachment" "lambda_execution_role_policy_attach" {
  policy_arn = "arn:aws:iam::aws:policy/AWSStepFunctionsFullAccess"
  role       = aws_iam_role.lambda_execution_role.name
}

resource "aws_iam_role_policy_attachment" "lambda_execution_role_cloudwatch_attach" {
  policy_arn = "arn:aws:iam::aws:policy/CloudWatchLogsFullAccess"
  role       = aws_iam_role.lambda_execution_role.name
}


resource "aws_lambda_permission" "s3_permission_to_trigger_lambda" {
  statement_id  = "AllowExecutionFromS3Bucket"
  action        = "lambda:InvokeFunction"
  function_name = aws_lambda_function.lambda_function_call_step_function.arn
  principal     = "s3.amazonaws.com"
  source_arn    = "arn:aws:s3:::${var.bucket_name}"
}

resource "aws_s3_bucket_notification" "bucket_notification_put" {
  bucket = "${var.bucket_name}"

  lambda_function {
    lambda_function_arn = aws_lambda_function.lambda_function_call_step_function.arn
    events              = ["s3:ObjectCreated:Put"]
    filter_prefix = "procesardata/"
    filter_suffix = ".csv"
  }
  depends_on = [aws_lambda_permission.s3_permission_to_trigger_lambda]
}


resource "aws_sfn_state_machine" "function" {
  name     = "StateMachineGlueDataBrew-${random_id.random.hex}"
  role_arn = aws_iam_role.function_role.arn

  definition = <<DEFINITION
    {
  "Comment": "A description of my state machine",
  "StartAt": "Actualizar DataSet",
  "States": {
    "Actualizar DataSet": {
      "Type": "Task",
      "Parameters": {
        "Format": "CSV",
        "Input": {
          "S3InputDefinition": {
            "Bucket.$": "$.bucket",
            "BucketOwner.$": "$.cuenta",
            "Key.$": "$.carpeta"
          }
        },
        "Name": "Precios"
      },
      "Resource": "arn:aws:states:::aws-sdk:databrew:updateDataset",
      "Next": "Ejecutar Job"
    },
    "Ejecutar Job": {
      "Type": "Task",
      "Resource": "arn:aws:states:::databrew:startJobRun",
      "Parameters": {
        "Name": "${var.job_name}"
      },
      "Catch": [
        {
          "ErrorEquals": [
            "DataBrew.ConflictException"
          ],
          "Next": "SNS Error"
        }
      ],
      "Next": "SNS Job Ejecutado"
    },
    "SNS Error": {
      "Type": "Task",
      "Resource": "arn:aws:states:::sns:publish",
      "Parameters": {
        "Message": {
          "Mensaje": "Se produjo un error"
        },
        "TopicArn": "${aws_sns_topic.topic_glue_databrew.arn}"
      },
      "End": true
    },
    "SNS Job Ejecutado": {
      "Type": "Task",
      "Resource": "arn:aws:states:::sns:publish",
      "Parameters": {
        "TopicArn": "${aws_sns_topic.topic_glue_databrew.arn}",
        "Message": {
          "Mensaje": "Se ejecuto el job correctamente"
        }
      },
      "End": true
    }
  }
}
  DEFINITION
}

resource "aws_iam_role" "function_role" {
  name = "my-state-machine-role-${random_id.random.hex}"

  assume_role_policy = jsonencode({
    Version = "2012-10-17"
    Statement = [
      {
        Action = "sts:AssumeRole"
        Effect = "Allow"
        Principal = {
          Service = "states.amazonaws.com"
        }
      }
    ]
  })
}

resource "aws_iam_role_policy_attachment" "function_policy_role_sns" {
  policy_arn = "arn:aws:iam::aws:policy/AmazonSNSFullAccess"
  role       = aws_iam_role.function_role.name
}

resource "aws_iam_role_policy_attachment" "lambda_policy_glue_data_brew" {
  policy_arn = "arn:aws:iam::aws:policy/AwsGlueDataBrewFullAccessPolicy"
  role       = aws_iam_role.function_role.name
}

resource "aws_sns_topic" "topic_glue_databrew" {
  name = "topic_glue_databrew-${random_id.random.hex}"
}

resource "aws_sns_topic_subscription" "subscription_glue_databrew" {
  topic_arn = aws_sns_topic.topic_glue_databrew.arn
  protocol  = "sms"
  endpoint  = "${var.telefono}"
}

De la plantilla anterior debemos modificar las variables y la región en la cual se van desplegar los servicios.

La región.

provider "aws" {
   region = "us-east-1"
 }

El nombre que le dimos la Job.

variable "job_name"{
    type= string
    default= "PreciosJob"
}

El nombre que le dimos al Bucket.

variable "bucket_name" {
    type = string
    default = "datosgluedatabrew"
}

El numero de teléfono al cual queremos que lleguen los mensajes cuando se ejecuta el Job.

variable "telefono"{
    type = string
    default = "+573005465765"
}

Una vez que hemos modificado las variables de acuerdo a nuestras configuraciones podemos validar y ejecutar la plantilla.

Valida la plantilla

terraform validate

Crea los servicios. Recuerda que la plantilla y el código de la función Lambda se encuentren en la misma carpeta.

terraform apply

Una vez terminada la ejecución del comando, vamos a revisar que los servicios se hayan desplegado correctamente.

Buscamos SNS y damos click en Topics.

Buscamos la función Lambda.

Buscamos la Step Function.

Como todos los servicios fueron desplegados con éxito vamos a subir un nuevo archivo al Bucket para que se procese el archivo con la llamada a la función Lambda y la Step Function, cuando esta termina su proceso damos click en el nombre de la Step Function y damos click en la ultima ejecución para ver el gráfico del proceso.

Con esto finalizamos la implementación y pruebas de la arquitectura planteada al inicio.Pueden realizar mas pruebas modificando la receta o agregando mas pasos a la Step Funcion.

Para no incurrir en ningún costo pueden borrar el proyecto de Glue DataBrew, el Bucket y para eliminar los servicios creados con Terraform pueden utilizar el siguiente comando.

terraform destroy

Me pueden encontrar en

Camilo Cabrales

Referencias

API

Tunea tus funciones Lambda

camilo cabrales — Thu, 09 Mar 2023 23:30:50 +0000

Las funciones Lambda tienen un tiempo limitado a 15 minutos para procesar cada solicitud. Por este motivo debemos seleccionar de manera optima la cantidad de memoria que asignamos a nuestra función.

Con el objetivo de encontrar el rendimiento optimo para nuestra función se creo un proyecto en Git - aws-lambda-power-tuning
Public que nos va ayudar a encontrar la cantidad de memoria que requiere nuestra función para su optimo funcionamiento.

Este proyecto crea un Step Function que de acuerdo a los parámetros de memoria que le enviamos va a ejecutar la función Lambda que definamos, retornándonos los tiempos de respuesta y un consto aproximado por ejecución de cada una de los parámetros que le definimos.

En la pagina del proyecto podemos encontrar diferentes formas de realizar el despliegue de los servicios requeridos para ejecutarlo. En este caso vamos a utilizar el despliegue usando SAM como lo mencionan en la pagina - opción 2.
Nota: hay que tener Docker instalado y corriendo para poder ejecutar la plantilla de SAM.

Install the AWS SAM CLI in your local environment.

Configure your AWS credentials (requires AWS CLI installed):

$ aws configure
Clone this git repository:

$ git clone https://github.com/alexcasalboni/aws-lambda-power-tuning.git
Build the Lambda layer and any other dependencies (Docker is required):

$ cd ./aws-lambda-power-tuning
$ sam build -u
sam build -u will run SAM build using a Docker container image that provides an environment similar to that which your function would run in. SAM build in-turn looks at your AWS SAM template file for information about Lambda functions and layers in this project.

Once the build has completed you should see output that states Build Succeeded. If not there will be error messages providing guidance on what went wrong.

Deploy the application using the SAM deploy "guided" mode:

$ sam deploy -g

En el transcurso del despliegue nos va ir solicitando algunos datos que utiliza la plantilla para su despliegue, los cuales podemos dejar los que vienen por defecto dando ENTER cuando nos los solicite.

Una vez desplegada la infraestructura, vamos a crear una función Lambda a la cual queremos hacer un tuning en la asignación de la memoria. Esta función nos ayuda a calcular el factorial de un numero grande. Se eligió este tipo de calculo ya que puede tardar varios segundos.

Pegamos el código fuente y damos click en Deploy

import json
import sys
sys.set_int_max_str_digits(1000000000)

def CalcularFactorial(numero):
    resultado = 1
    for i in range(1, numero+1):
        resultado *= i
    return resultado


def lambda_handler(event, context):
    numero = 30000
    print(CalcularFactorial(numero))

Ahora que hemos creado la función Lambda, vamos a realizar las pruebas de tuning, para esto vamos a buscar el servicio Step Functions y la función que comienza con el nombre powerTuningStateMachine.

Damos click en el nombre y despues en Star Execution.

Después ingresamos los parámetros que requiere la función:

{
    "lambdaARN": "arn:aws:lambda:us-east-1:385033107168:function:Factorial",
    "powerValues": [256, 512, 1024],
    "num": 50,
    "payload": {},
    "strategy": "balanced"
}

En este caso le pasamos el arn de la función Lambda que acabamos de crear, la cantidad de memoria con la cual queremos que se ejecute, el numero de ejecuciones y la estrategia que es este caso es balanced, que sirve para encontrar la mejor relación velocidad precio por ejecución. Podemos encontrar la documentación de los parametros en este link.

Ahora veamos el resultado de la ejecución:

En esta ejecución podemos identificar que el tiempo (3 segundos) que tiene configurado por defecto la función Lambda no es suficiente para completar la tarea que debe realizar. Lo que debemos hacer es incrementar el tiempo que tiene la función Lambda para completar la tarea.
Vamos a la función Lambda y modificamos el tiempo de ejecución.

Definimos el tiempo a 3 minutos.

Modificado el tiempo de ejecución vamos nuevamente a la Step Fuction y damos click en Start Execution y copiamos los parámetros anteriores.

Al terminar la ejecución podemos ver los resultados del análisis el cual nos indica que la cantidad de memoria que que tiene mejor relación tiempo - precio es 1024.En caso que deseemos ver los resultados de una manera mas gráfica podemos copiar el link que aparece en el output y pegarlo en un navegador y veremos una pagina como la siguiente:

EL gráfico nos facilita realizar el análisis del comportamiento de la función de acuerdo a la cantidad de memoria asignada a la función Lambda.

Por ultimo si no queremos tener los servicios que se desplegaron con SAM debemos ir a CloudFormation y eliminar la plantilla para que se borren todos los servicios.

Me pueden encontrar en

Camilo Cabrales

Referencias

Despliegue Lambda Power Tools
Cuotas Lambda

Definición de arquitectura con Application Composer para análisis de documentos con Textract

camilo cabrales — Fri, 09 Dec 2022 19:57:23 +0000

Este mes (Diciembre de 2022) AWS lanzo un nuevo servicio llamado Application Composer, que nos sirve para la definición de arquitecturas Serverless de manera gráfica e intuitiva, donde podemos arrastrar los diferentes servicios en el espacio de trabajo con el objetivo de definir nuestra arquitectura.

En este post vamos a definir una arquitectura que nos va a permitir extraer el texto de varias facturas para llevar el control de nuestros gastos.

Iniciemos buscando el Servicio Application Composer

Y en la pagina principal le damos click en Canvas, que nos va a mostrar las opciones de creación de nuestra arquitectura.

Vemos dos opciones para la creación de nuestra arquitectura conectada y no conectada. La opción conectada va a sincronizar los cambios que realicemos en una carpeta de nuestro equipo y no conectada nosotros somos los encargados de guardar nuestra arquitectura.
Seleccionamos la opción no conectada y damos click en crear.

Como podemos ver la pantalla es muy intuitiva y podemos encontrar los servicios que podemos incluir, la vista de diseño, la vista de la plantilla de SAM que se va generando de acuerdo vamos incluyendo servicios en nuestra arquitectura y el ménu.

Vamos a crear la siguiente arquitectura arrastrando los servicios al Canvas.

Ahora vamos a configurar algunas de las propiedades que están disponibles desde el diseñador.

Para el Bucket configuramos el nombre:

Para la función Lambda configuramos el nombre, el runtime, la memoria y el tiempo de ejecución:

Para la tabla de DynamoDB le definimos un nombre y el nombre de la primarykey:

Ahora podemos visualizar la plantilla generada y guardamos el archivo desde el menú.

Antes de validar y modificar nuestra plantilla, vamos a ver el servicio Textract que nos sirve para extraer texto de diferentes tipos de documentos.

Para esto buscamos el servicio Textract, en la pantalla principal del servicio damos click en Analyze Document.

En la pagina podemos ver los resultados de la extracción de texto de un documento de ejemplo que nos brinda AWS y las formas con las cuales podemos obtener la información, que son: texto plano, formularios, tablas, consultas o firmas. Para nuestro caso vamos utilizar consultas (queries).

Ahora utilicemos una de las imágenes de nuestro ejemplo.

Primero seleccionamos la imagen de la cual queremos extraer el texto:

Ahora seleccionamos como queremos ver los resultados (Forms,Tables,Queries) y agregamos las consultas que vamos hacer sobre el documento. Es importante que todas las consultas empiecen por what o where, en este caso utilice una mezcla de ingles y español para que Textract encontrara los resultados de manera mas acertada, ya que si hacia los queries solo en ingles no encontraba de manera correcta los valores.

Al final Textract nos muestra los resultados en los formatos que hallamos seleccionado.

Ya que hemos visto el funcionamiento de Textract vamos a ver como podemos realizar esto de manera asíncrona con la arquitectura que definimos al inicio del post.

Vamos hacer algunas modificaciones a la plantilla que descargamos de Application Composer.

Empecemos modificando la sección de la funcion Lambda agregando las políticas TextractDetectAnalyzePolicy,CloudWatchPutMetricPolicy,S3FullAccessPolicy Lambda y después agregamos el código fuente de la función.

import boto3
import urllib

textract = boto3.client('textract')
dynamodb = boto3.client('dynamodb')

class Factura:

    def __init__(self, idFactura="", fechaFactura="", valorAPagar="",nombreArchivo=""):
        self.idFactura = idFactura
        self.fechaFactura = fechaFactura
        self.valorAPagar = valorAPagar
        self.nombreArchivo = nombreArchivo

    def getNombreArchivo(self):
        return self.nombreArchivo

    def getIdFactura(self):
        return self.idFactura

    def getFechaFactura(self):
        return self.fechaFactura

    def getValorAPagar(self):
        return self.valorAPagar

    def setIdFactura(self, idFactura):
        self.idFactura = idFactura

    def setFechaFactura(self, fechaFactura):
        self.fechaFactura = fechaFactura

    def setValorAPagar(self, valorAPagar):
        self.valorAPagar = valorAPagar

    def setNombreArchivo(self, nombreArchivo):
        self.nombreArchivo = nombreArchivo

def lambda_handler(event, context):
    # TODO implement
    bucket = event['Records'][0]['s3']['bucket']['name']
    nombreObjeto = urllib.parse.unquote_plus(event['Records'][0]['s3']['object']['key'], encoding='utf-8')

    response = textract.analyze_document(
        Document={
            'S3Object': {
                'Bucket': bucket,
                'Name': nombreObjeto
            }
        },
        FeatureTypes=["QUERIES"],
        QueriesConfig={
            "Queries": [{
                "Text": "What is the Fecha vencimiento y pago",
                "Alias": "Fecha de pago"
            },
                {
                "Text": "What is the Total a pagar",
                "Alias": "Valor a pagar"
            },
                {
                "Text": "What is the BEC",
                "Alias": "Numero de Factura"
            }]
        })
    blocks = response['Blocks']
    i = 0
    factura = Factura()
    factura.setNombreArchivo(nombreObjeto)
    for block in blocks:
        if block['BlockType'] == "QUERY_RESULT":
            if float(block['Confidence']) >= 60:
                if i == 0:
                    factura.setFechaFactura(block["Text"])
                elif i == 1:
                    factura.setValorAPagar(block["Text"])
                elif i == 2:
                    factura.setIdFactura(block["Text"])
            i += 1
            print(block)
    result = dynamodb.put_item(
        TableName='datosfacturas',
        Item={
            'PK': {'S': factura.getIdFactura()},
            'FechaPago': {'S': factura.getFechaFactura()},
            'ValorPago': {'S': factura.getValorAPagar()},
            'NombreArchivo': {'S': factura.getNombreArchivo()}
        },
        ConditionExpression="attribute_not_exists(PK)"
    )

Cuando ejecutamos el código vamos a obtener un error.
De acuerdo a la que encontré me di cuenta que al parecer se debe a la versión de boto3 que tiene Lambda configurada, para solucionar este error debemos crear una Layer con una versión mas actualizada de Boto3.

Para saber la versión de Boto3 que maneja Lambda se puede ejecutar dentro de la función:

print(boto3.__version__)

Que en mi caso el resultado es: 1.26.23 y la version actual en este momento de Boto3 es: 1.26.26.

Para dar solución vamos a crear el Layer.

LIB_DIR=boto3-mylayer/python
mkdir -p $LIB_DIR

pip3 install boto3 -t $LIB_DIR

cd boto3-mylayer
zip -r /tmp/boto3-mylayer.zip .

aws lambda publish-layer-version --layer-name boto3updated --zip-file fileb:///tmp/boto3-mylayer.zip --compatible-runtimes "python3.7" "python3.8"

Una vez creado el Layer debemos copiar el ARN y agregarlo al template.

Una vez creada la Layer y realizados los cambios en la plantilla vamos a validar y desplegar los servicios.

Para validar la plantilla debemos ejecutar el siguiente comando desde la terminal (textract.yml es el nombre que le dimos a nuestra plantilla).

sam validate --template textract.yml

Al ejecutar este comando debemos ver en la terminal algo como esto:

Ahora que la validación de nuestra plantilla es correcta debemos eejecutar el siguiente comando para desplegar los servicios de nuestra arquitectura.

sam deploy --template textract.yml --stack-name textractinvoices --capabilities CAPABILITY_IAM

El resultado del comando es el siguiente:

Hemos finalizado con el despliegue satisfactoriamente, ahora podemos ingresar a S3 y subir los archivos de prueba al bucket y validar en DynamoDB que los datos se hayan ingresado correctamente.

Application Composer es un nuevo servicio que como tal hacen algunas cosas por afinar como: agregar mas opciones de edición a cada servicio, mejorar como se generan las plantillas, sin embargo es una muy opción para definir arquitecturas Serverless y tener una plantilla SAM base que nos ayude a mejorar nuestros tiempos de desarrollo.

Archivos del post:

plantilla

archivos de prueba

Me pueden encontrar en

Camilo Cabrales

Referencias

Textract Boto3
Crear Layer Boto3

Tips para aprobar las certificaciones Associate de AWS

camilo cabrales — Wed, 16 Nov 2022 21:45:55 +0000

En este post vamos a ver algunas de las actividades que realice para aprobar las certificaciones de nivel asociado que ofrece AWS.

Veamos el porque:

Para mi el objetivo principal de realizar las certificaciones es aprender mas sobre los servicios AWS. Vi que realizar una certificación era una de las mejores manera de adquirir y afianzar los conocimientos. Ademas las certificaciones en algunos empleos son requeridas lo cual es un plus tenerlas.

Por donde empezar. Creo que si no se tiene experiencia en AWS la mejor manera de empezar es por lo básico por tener una noción de general de los servicios (Cloud Practitioner), si ya se tiene experiencia lo ideal seria empezar por la certificación mas cercana al rol que se este desempeñando actualmente.

Después de aprobar la primera certificación, pienso que lo ideal es continuar realizando certificaciones hasta el punto que se sienta cómodo y motivado en seguir aprendiendo haciéndolas. Prepararse para aprobar diferentes certificaciones ayuda a adquirir conocimientos de una mayor cantidad de servicios de AWS ya que cada una se enfoca mas en diferentes tipos de servicios.

Ahora veamos el como:

Seguí los siguientes pasos en la preparación de cada examen:

Hacer mas de un curso.
Practicar en la consola de AWS.
Presentar los test de practica.
Repetición o repaso espaciado.
Definir la fecha de presentación del examen y el lenguaje.
Repetir los puntos: 2,3,4.
Presentar el examen.

Hacer mas de un curso:

En mi caso siempre hice los cursos de Stephane Maarek en Udemy. Hice estos cursos ya que en mi búsqueda siempre eran recomendados.

Cloud Practitioner

Solutions Architect Associate

Developer Associate

SysOps Administrator Associate

Adicional a los cursos anteriores, realice cursos en las siguientes plataformas:

Skillbuilder(Hay muchos cursos gratuitos, hace poco (2022) lanzaron una opción de pago con laboratorios)
Cloudacademy(Es de pago)
Clouding La(Es de pago,Ofrece cursos personalizados)
Platzi (Es de pago)
Pluralsight (Es de pago)
Whizlabs (Es de pago algunos, los cursos se pueden comprar por separado o subscripción anual)

Estas plataformas también ofrecen cursos de nube, aunque los utilice en menor medida:

Exampro (Algunas partes son gratis)
Cloudguru(ofrecen cursos gratuitos mensualmente y subscripciones)
Digitalcloud

Practicar en la consola de AWS

La mejor forma de aprender es practicando (dicen: nadie aprende a nadar únicamente leyendo libros :)). Es mejor crear tu propia cuenta y practicar ya que AWS ofrece el nivel gratuito en el cual se pueden probar muchos de los servicios que aparecen en los exámenes. Es posible que en algunos casos sea necesario realizar un pago dependiendo el tipo de pruebas que estemos realizando. Para evitar sorpresas con los valores a pagar, con el usuario root vamos a Billing y creemos un Budget con el objetivo de definir cual es el presupuesto que estamos dispuestos a invertir y así poder tomar las medidas correspondientes a tiempo.

Algunas de las plataformas que utilice para practicar laboratorios :

Skillbuilder Con la version de pago ofrecen bastantes laboratorios adicionalmente ofrecen Cloud Quest que es un juego de rol interactivo en el cual podemos aprender con base en laboratorios (me gusto bastante la metodología)
Cloudacademy
Whizlabs

Presentar los test de practica

Otra buena forma de aprender es poner a prueba nuestros conocimientos y que mejor manera hacer test que simulan las preguntas de los exámenes. Estos test nos ayudan a hacernos una idea del tipo de preguntas que vamos a encontrar en los exámenes, no son las mismas preguntas sin embargo son muy parecidas y son una buena forma de repaso ya que las plataformas que ofrecen este tipo de test dan una explicación de la respuesta. Los test también nos ayudan a acostumbrarnos a contestar preguntas y que al momento del examen sea mas natural y no sea tan estresante la presentación del examen.

Aunque la mayoría de cursos tiene una sección de test para evaluar los conceptos, yo utilice las siguientes plataformas ya que tienen bastantes preguntas para practicar:

Whizlabs
Tutorialsdojo

AWS ofrece algunos cursos cursos enfocados en las diferentes certificaciones donde un especialista de AWS explica de manera superficial los servicios que se evalúan en el examen y la mejor forma de abordar las preguntas, creo que puede ser un buen inicio para entender el examen que se va a presentar sin embargo no creo que sea de mucho valor hacer mas de un curso en este formato sobre el mismo examen.

Pueden encontrar los temas y el porcentaje por dominio en las guías de los exámenes:

Developer
SysOps
Architect

Repetición o repaso espaciado

Para prepararme para presentar mis primeros exámenes (Cloud Practitioner, Solutions Architect) lo que hice fue crear mapas mentales de los servicios en hojas bond y pegarlos en la pared para repasar constantemente (utilice casi dos paredes :)).

Un ejemplo:

En una version mejorada de estudio, decidí utilizar la aplicación Anki (tiene version para Android) que utiliza la técnica de repaso espaciado, que me ha ayudado a retener la información a largo plazo y no solamente para aprobar un examen, ya que el objetivo principal es aprender sobre los servicios de AWS.
Les comparto los links donde pueden descargar mis apuntes realizados en la aplicación Anki:

Apuntes Developer.
Apuntes SysOps.

Definir la fecha de presentación del examen y el idioma

Es importante establecer con anticipación la fecha del examen para así poder definir la intensidad de estudio para llegar bien preparado a la fecha del examen. En caso que no sea posible presentar el examen en la fecha que se definió al inicio puede aplazar el examen hasta en dos ocasiones. Otro factor a tener en cuenta es el lugar de presentación, tenemos dos opciones: remoto o en un centro de certificación.

Remoto: debemos adecuar lugar de presentación para cumplir todas los requisitos que nos solicitan, en nuestro equipo debemos instalar el programa para presentar el examen, debemos realizar un registro donde nos piden fotos de nosotros y de nuestra identificación, hay una persona que esta vigilándonos por la cámara de nuestro equipo y únicamente habla ingles.
En mi experiencia en el examen de Solutions Architect se demoraron en habilitarme el inicio del examen lo cual me genero un poco de estrés, por lo que les aconsejo estar tranquilos ya que si les sucede se pueden llegar a tardar entre 15 a 20 minutos. En el caso del examen de SysOps lo presente en esta modalidad pero en los laboratorios se bloqueo el examen por lo que tuve que presentarlo nuevamente pero esta vez en un centro de certificación (larga historia).

Nota: Para la sección de laboratorios del examen de SysOps siempre me aparecieron laboratorios que tenían que ver con: EventBridge,SNS,Route 53 y CloudFormation.

Centro de certificación: en este momento creo que es la mejor opción ya que no debemos adecuar nuestra casa o trabajo para la presentación del examen y nos libera de preocupaciones que algo salga mal (alguien entre al cuarto, se caiga el internet, que mire para otro lado ...). En el centro de certificación nos presentamos a la hora definida, verifican nuestros datos, nos piden guardar nuestros objetos personales en un casillero, nos dan las indicaciones en caso de necesitar algo y nos asignan un pc.

En cuanto al idioma, las 4 certificaciones que aprobé las tome en ingles ya que la mayoría de cursos y sets de preguntas están en ingles. Desde el año pasado (2021) están disponibles en español las certificaciones de Cloud Practitioner, Solutions Architect y Developer, la certificación de SysOps en este momento (2022) solo se encuentra en ingles. Para las personas de habla hispana nos dan 30 minutos adicionales para terminar el examen. Creo que es tiempo mas que suficiente para presentar el examen.

Repetir

Es necesario estar en continuo aprendizaje, repasando, haciendo test, laboratorios y mucho mejor si trabajan con los servicios AWS diariamente ya que definitivamente la practica les va hacer mucho mas fácil contestar las preguntas ya que van a poder visualizar la solución del escenario planteado.

Presentar el examen

En este punto lo mas importante es haberse preparado correctamente, llegar a tiempo, dormir bien y ser positivo.
Y en caso que no se llegue a pasar la primera vez un examen, (me paso) debemos seguir adelante en nuestro aprendizaje, revisar el detalle de los resultados, fortalecer los puntos fuertes y reforzar los que nos indiquen en el resumen del resultado y sobre todo NUNCA PARAR DE APRENDER.

Me pueden encontrar en

Camilo Cabrales
Credly

Crea tablas para reportes con DynamoDB & DynamoDB Streams

camilo cabrales — Tue, 18 Oct 2022 16:03:37 +0000

Generalmente usamos DynamoDB para soluciones que necesitan un tiempo de respuesta muy bajo y no para BI o analítica de datos debido a su naturaleza.
En este post vamos a utilizar DynamoDB Streams con el objetivo de filtrar los datos y crear una tabla con información especifica para que sea consultada por una herramienta de visualización de datos cómo puede ser QuickSight.

Vamos a hacer uso de los siguientes servicios en la implementación de la solución.

DynamoDB
Lambda
Cloud9

Suponiendo que tuviéramos almacenada la información de los partidos de futbol de todas las ligas de futbol del mundo desde 1970, vamos a manejar dos tablas una para los resultados de los partidos de futbol (tabla principal) y en otra tabla (consulta) vamos a almacenar y actualizar las tablas de posiciones para posteriormente hacer nuestras visualizaciones.

Iniciemos por crear el ambiente en Cloud9 en donde vamos ejecutar nuestros scripts para poblar las tablas de DynamoDB.

Buscamos el servicio Cloud9 y damos click en crear entorno.

Vamos a ver las opciones de configuración de la maquina EC2 qué queremos utilizar para nuestro entorno. Que en este caso vamos a dejar las opciones por defecto. Damos click en el botón siguiente.

Vemos la configuración que definimos para nuestro entorno y damos click en crear.

Veremos una pantalla de espera cómo la siguiente mientras se crea nuestro entorno de trabajo.

Una vez nuestro entorno esta listo, debemos crear el archivo .py (python) que contiene el código fuente de nuestra tabla de DynamoDB. Damos click en crear archivo.

Debemos copiar el siguiente código en el nuevo archivo y guardarlo con extension .py, en este caso le vamos a dar el nombre de creartabla.py

import boto3
from boto3.dynamodb.conditions import Key


dynamodb = boto3.resource("dynamodb")

dynamodb.create_table(
        TableName='ResultadosPartidos',
        KeySchema=[
            {
                'AttributeName': 'PK',
                'KeyType': 'HASH'  # Partition key
            },
            {
                'AttributeName': 'SK',
                'KeyType': 'RANGE'  # Sort key
            }
        ],
        #Se deben crear las llaves nuevamente con su tipo de dato
        AttributeDefinitions=[
            {
                'AttributeName': 'PK',
                'AttributeType': 'S'  # Se utiliza S para tipos de datos String y N para numeros
            },
            {
                'AttributeName': 'SK',
                'AttributeType': 'S'
            }

        ],
        ProvisionedThroughput={
            'ReadCapacityUnits': 5,
            'WriteCapacityUnits': 5
        }
    )

dynamodb.create_table(
        TableName='TablaPosiciones',
        KeySchema=[
            {
                'AttributeName': 'Liga',
                'KeyType': 'HASH'  # Partition key
            },
            {
                'AttributeName': 'Equipo',
                'KeyType': 'RANGE'  # Sort key
            }
        ],
        #Se deben crear las llaves nuevamente con su tipo de dato
        AttributeDefinitions=[
            {
                'AttributeName': 'Liga',
                'AttributeType': 'S'  # Se utiliza S para tipos de datos String y N para numeros
            },
            {
                'AttributeName': 'Equipo',
                'AttributeType': 'S'
            }

        ],
        ProvisionedThroughput={
            'ReadCapacityUnits': 5,
            'WriteCapacityUnits': 5
        }
    )

Una vez creado el archivo debemos instalar boto3 ejecutando en la terminal el siguiente comando:

pip install boto3

Instalado boto3 debemos ejecutar nuestro archivo, ejecutando en la terminal el siguiente comando:

python creartabla.py

Una vez ejecutado nuestro script vamos a buscar el servicio de DynamoDB y ver las tablas que acabamos de crear.

Ahora vamos a crear la función Lambda que va a filtrar los datos de la tabla principal a la tabla que vamos a utilizar para nuestras visualizaciones. Para esto buscamos Lambda en el buscador de servicios y damos click en Create Function.

Le damos un nombre a la función Lambda, seleccionamos el lenguaje de programación (Runtime = Python3.8)y damos click en Create Function.

El siguiente paso es darle los permisos necesarios al rol asignado a la función Lambda. Para esto damos click en la pestaña Configuration en el menu Permissions y en el nombre del rol.

Agregamos las siguientes políticas al rol:

CloudWatchFullAccess: Nos sirve para acceder a logs de la función Lambda

AmazonDynamoDBFullAccess: Nos sirve para poder guardar información en la tabla y para qué DynamoDB Streams pueda invocar a la función. En otro tipo de entorno recuerden ser mas granulares con sus políticas.

En caso que únicamente se necesitara hacer invocaciones a la función Lambda desde DynamoDB Streams, se debe usar la política: AWSLambdaInvocation-DynamoDB.

Creada la función Lambda y asignado los permisos necesarios para su ejecución, vamos a habilitar el Stream en DynamoDb para que llame a la función Lambda cuando se ingrese un nuevo registro a la tabla.Para esto vamos a la pantalla principal de DynamoDB damos click en Tables, seleccionamos la tabla ResultadosPartidos y damos click en la pestaña Exports and streams.

Los siguientes pasos son habilitar el Stream y asignarle la función Lambda que ya creamos.

Habilitemos el Stream:

Seleccionamos el tipo de información que va a ser enviada la la función Lambda, en este caso solo seleccionamos la información del nuevo registro que se ingreso en la tabla.

Validamos que el stream haya quedado habilitado.

Asignamos la función al trigger la función Lambda.

Seleccionamos la función Lambda que va a procesar el Stream y la cantidad de registros que va a procesar en cada llamado.

Por ultimo validamos que el trigger este habilitado y que la función Lambda que va a procesar el stream sea la correcta.

El diseño de tabla de DynamoDb que vamos a utilizar en este post es de una sola tabla, necesitamos definir un filtro sobre los mensajes que van a ser enviados a la función Lambda con el objetivo que se procesen solamente los registros que necesitamos para construir la tabla de posiciones.

Para esto vamos de nuevo a nuestra función Lambda y damos click Configuration - Triggers. Podemos observar qué se agrego el trigger que creamos desde DynamoDB. Damos click en checkbox del trigger y después en el botón editar.

La siguiente pantalla nos muestra la configuración actual del trigger. Damos click Additional settings

Buscamos la sección Filter criteria y copiamos el siguiente filtro en el cuadro de texto.

{"eventName":["INSERT"],"dynamodb":{"NewImage":{"Local":{"S":[{ "exists": true }]}}},"dynamodb":{"NewImage":{"Visitante":{"S":[{ "exists": true }]}}}}

Guardamos los cambios.

Con los pasos anteriores configuramos el filtro del stream para que solo sean procesados por la función Lambda los eventos del tipo Insert y que dentro de la datos enviados se encuentre el campo Local y Visitante, los demás datos que no cumplan con esta condición son ignorados y la función Lambda no es invocada, lo que ayuda a reducir costos debido a que solo se procesa la información necesaria.

El siguiente paso es ponerle código fuente a nuestra función Lambda, vamos a la pestaña Code, reemplazamos el código existente por el siguiente y damos click en el botón Deploy.

import json
import boto3
from boto3.dynamodb.conditions import Key

dynamodb = boto3.resource("dynamodb")
tabla = dynamodb.Table("TablaPosiciones")
local = "local"
visitante = "visitante"

class Partido:

    def __init__(self,local,visitante,marcadorLocal,marcadorVisitante,liga):
        self.local = local
        self.visitante = visitante
        self.marcadorLocal = marcadorLocal
        self.marcadorVisitante = marcadorVisitante
        self.liga = liga


    def getLocal(self):
        return self.local

    def getVisitante(self):
        return self.visitante

    def getMarcadorLocal(self):
        return self.marcadorLocal

    def getMarcadorVisitante(self):
        return self.marcadorVisitante

    def getLiga(self):
        return self.liga

    def setLocal(self,local):
        self.local = local

    def setVisitantel(self,visitante):
        self.visitante = visitante

    def setMarcadorLocal(self,marcadorLocal):
        self.marcadorLocal = marcadorLocal

    def setMarcadorVisitante(self,marcadorVisitante):
        self.marcadorVisitante = marcadorVisitante

    def setLiga(self,liga):
        self.liga = liga

def obtenerPartido(data):
    local = data["Local"]["S"]
    visitante = data["Visitante"]["S"]
    marcadorLocal = data["MarcadorLocal"]["N"]
    marcadorVisitante = data["MarcadorVisitante"]["N"]
    liga = data["PK"]["S"].split("#")[0]
    return Partido(local,visitante,marcadorLocal,marcadorVisitante,liga)

def lambda_handler(event, context):

    data = event["Records"][0]["dynamodb"]["NewImage"]
    partido = obtenerPartido(data)
    datosLocal = tabla.query(KeyConditionExpression=Key('Liga').eq(partido.getLiga()) & Key("Equipo").eq(partido.getLocal()))
    datosVisitante = tabla.query(KeyConditionExpression=Key('Liga').eq(partido.getLiga()) & Key("Equipo").eq(partido.getVisitante()))
    actualizarDatosEquipo(datosLocal["Items"],partido,local)
    actualizarDatosEquipo(datosVisitante["Items"],partido,visitante)
    print("ejecuto")


def actualizarDatosEquipo(datos,partido,localidad):

    puntos = getPuntos(partido,localidad)

    if len(datos) == 0:
        tabla.put_item(Item={
            "Liga": partido.getLiga(),
            "Equipo":partido.getLocal() if localidad == local else partido.getVisitante(),
            "PartidosJugados":1,
            "GolesFavor": partido.getMarcadorLocal() if localidad == local else partido.getMarcadorVisitante(),
            "GolesContra":partido.getMarcadorLocal() if localidad != local else partido.getMarcadorVisitante(),
            "Puntos": puntos
        })
    else:
        tabla.update_item(
                Key={
                    "Liga": partido.getLiga(),
                    "Equipo": partido.getLocal() if localidad == local else partido.getVisitante()
                },
                UpdateExpression="set PartidosJugados=:partidos_jugados,GolesFavor=:goles_favor,GolesContra=:goles_contra,Puntos=:puntos",
                ExpressionAttributeValues={
                    ":partidos_jugados":datos[0]["PartidosJugados"] + 1,
                    ":goles_favor":int(datos[0]["GolesFavor"]) + int(partido.getMarcadorLocal()) if localidad == local else int(datos[0]["GolesFavor"]) +int(partido.getMarcadorVisitante()),
                    ":goles_contra":int(datos[0]["GolesContra"]) + int(partido.getMarcadorVisitante()) if localidad == local else int(datos[0]["GolesContra"])+int(partido.getMarcadorLocal()),
                    ":puntos":int(datos[0]["Puntos"]) + puntos
                },
                ReturnValues="UPDATED_NEW"
            )

def getPuntos(partido,localidad):
    puntos = 1
    if local == localidad:
        if partido.getMarcadorLocal() > partido.getMarcadorVisitante():
            puntos = 3
        elif partido.getMarcadorLocal() < partido.getMarcadorVisitante(): 
            puntos = 0
    else:
        if partido.getMarcadorLocal() < partido.getMarcadorVisitante():
            puntos = 3
        elif partido.getMarcadorLocal() > partido.getMarcadorVisitante(): 
            puntos = 0
    return puntos

Debemos validar el funcionamiento tanto del filtro como el del código de la función Lambda. Por lo tanto debemos ingresar nuevos items en la tabla ResultadosPartidos.
Nos dirigimos nuevamente a Cloud9 y creamos un nuevo archivo llamado data.py y lo ejecutamos utilizando en la terminal el comando python data.py.

import boto3
from boto3.dynamodb.conditions import Key

dynamodb = boto3.resource("dynamodb")
table = dynamodb.Table("ResultadosPartidos")
table.put_item(Item={
    "PK": "Premier League#2022/23",
    "SK":"Arsenal#Liverpool#2022/10/09",
    "Local":"Arsenal",
    "Visitante":"Liverpool",
    "MarcadorLocal":3,
    "MarcadorVisitante": 2,
    "Fecha":"2022/10/09"

})


table.put_item(Item={
    "PK": "Premier League#2022/23",
    "SK":"Manchester City#Southampton#2022/10/08",
    "Local":"Manchester City",
    "Visitante":"Southampton",
    "MarcadorLocal":4,
    "MarcadorVisitante": 0,
    "Fecha":"2022/10/08"

})

table.put_item(Item={
    "PK": "Premier League#2022/23",
    "SK":"Everton#Manchester Utd#2022/10/08",
    "Local":"Everton",
    "Visitante":"Manchester Utd",
    "MarcadorLocal":1,
    "MarcadorVisitante": 2,
    "Fecha":"2022/10/09"

})

table.put_item(Item={
    "PK": "Premier League#2022/23",
    "SK":"Manchester City#Manchester Utd#2022/10/08",
    "Local":"Manchester City",
    "Visitante":"Manchester Utd",
    "MarcadorLocal":6,
    "MarcadorVisitante": 3,
    "Fecha":"2022/10/02"

})

table.put_item(Item={
    "PK": "Premier League#2022/23",
    "SK":"Liverpool#Brighton#2022/10/09",
    "Local":"Liverpool",
    "Visitante":"Brighton",
    "MarcadorLocal":3,
    "MarcadorVisitante": 3,
    "Fecha":"2022/10/01"

})


table.put_item(Item={
    "PK": "Manchester City#2022/23",
    "SK":"Jugador#Erling Haaland",
    "Nombre":"Erling Haaland",
    "Goles":15,
    "Partidos Jugados": 9
})

table.put_item(Item={
    "PK": "Liverpool#2022/23",
    "SK":"Jugador#Luis Diaz",
    "Nombre":"Luis Diaz",
    "Goles":3,
    "Partidos Jugados": 8
})

table.put_item(Item={
    "PK": "Tottenham#2022/23",
    "SK":"Jugador#Kane",
    "Nombre":"Kane",
    "Goles":8,
    "Partidos Jugados": 9
})

Por ultimo vamos a validar la información almacenada en las dos tablas.

Cómo podemos observar en la tabla ResultadoPartidos se almaceno la información de los resultados de cada partido más la información de los jugadores de los equipos. Esto se realiza de esta forma por el tipo de diseño de tabla que elegimos para el ejercicio que es de única tabla.

En la tabla TablaPosiciones podemos observar que únicamente tenemos almacenado la información de los equipos de futbol y no la de los jugadores porque no cumplen con el filtro creado. Si queremos confirmar que la función Lambda solo se haya llamado las veces correctas (5 que son el numero de partidos que ingresamos), debemos ir a CloudWatch y buscar el log group que termina con el nombre de la función Lambda: lambda/lambda_stream_dynamodb y observar el numero de veces que la función fue invocada.

La Arquitectura de nuestro post es la siguiente:

Como actividad adicional pueden agregar mas registros al script de inserción, tratar de crear nuevos tipos de filtros o mejorar el código fuente de la función Lambda.

En el proximo post vamos a ver cómo crear gráficos de los datos de la tabla TablaPosiciones utilizando el servicio de QuickSight.

Me pueden encontrar en

Camilo Cabrales

Referencias

Filtros Eventos Lambda
Documentación DynamoDB
Boto3

Como crear tu página para streaming de vídeo

camilo cabrales — Thu, 08 Sep 2022 22:34:32 +0000

AWS ofrece diferentes tipos de servicios para muchos tipos de soluciones. En este post vamos a crear una pagina de streaming de video utilizando los siguientes servicios:

Amazon Interactive Video Service.
S3.
Y utilizaremos la aplicación Larix Broadcaster para realizar la transmisión de nuestro streaming.

Comencemos con la creación de nuestro canal buscando el servicio IVS (Amazon Interactive Video Service), en la pagina principal seleccionamos Channels:

Damos click en Create Channel

En la siguiente pagina vamos a configurar nuestro canal.Le asignamos un nombre, definimos el tipo de canal, su latencia; no vamos a configurar un token de autorización con el objetivo de ver el streaming desde la consola de AWS.

En la sección de almacenamiento no vamos a seleccionar que nuestro streaming se almacene en S3. Damos click en guardar.

Una vez creado nuestro canal vamos a ver una pagina con toda la información de configuración y los datos necesarios para empezar a realizar el streaming. En este momento nos vamos a enfocar en los datos de Stream key e Ingest Server.

Lo primero que debemos hacer es instalar la aplicación Larix Broadcaster, después vamos a la siguiente pagina Larix Grove-compliant URL que nos va a servir para generar el link del cual vamos a hacer el streaming.

Ya en la pagina de Web vamos a copiar en el campo URL los valores de Ingest Server seguido del Stream Key.

Una vez pegados el Ingest Server y el Stream Key en el campo URL, debemos escanear el código QR y abrir el link desde la aplicación Larix.Una vez dentro de la aplicación damos click en el botón grabar.

Dentro de la consola de AWS podemos ir a Live channels para ver los canales que están transmitiendo en vivo o dentro de nuestro canal en la sección Live Stream.

Con los pasos anteriores creamos un canal para streaming y logramos transmitir hacia él. El siguiente paso es crear una pagina web en donde podamos ver nuestro streaming.

Para eso vamos a crear un bucket en S3 (recuerden que el nombre es único en todo AWS).

Definimos que el bucket sea publico.

Creamos el bucket

Ahora debemos configurar nuestro bucket como un sitio web estático, para esto vamos a la pestaña Properties y en la sección Static website hosting damos click en el botón editar.

En el campo Index document colocamos el nombre del archivo principal por el cual se va tener acceso al bucket index.html y guardamos los cambios.

Nos hace falta modificar la política del bucket para que podamos ver nuestro sitio publico en internet.
Vamos a la pestaña Permissions a la sección Bucket policy y colocamos la siguiente política reemplazando el arn del bucket por el que creamos.

{
    "Version": "2012-10-17",
    "Id": "Policy1662669806339",
    "Statement": [
        {
            "Sid": "Stmt1662669804857",
            "Effect": "Allow",
            "Principal": "*",
            "Action": "s3:*",
            "Resource": "arn:aws:s3:::streamingbucketcamilo2022/*"
        }
    ]
}

Ahora debemos modificar el archivo index.html.

index.html

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>1 Column - fw-1-1-col</title>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
<style>
  * { padding: 0; margin: 0; }

body {
 font-family: Arial, Helvetica, sans-serif;
 font-size: 13px;
}
#wrapper { 
 margin: 0 auto;
 width: 922px;
}
#header {
 width: 900px;
 color: #333;
 padding: 10px;
 border: 1px solid #ccc;
 height: 100px;
 margin: 10px 0px 5px 0px;
 background-color:#FFFFFF;
}
#content { 
 width: 900px;
 color: #333;
 border: 1px solid #ccc;
 background:#FFFFFF;
 margin: 0px 0px 5px 0px;
 padding: 10px;
 height: 350px;
}
#footer { 
 color: #333;
 width: 900px;
 border: 1px solid #ccc;
 background-color:#FFFFFF;
 margin: 0px 0px 10px 0px;
 padding: 10px;
}
</style>
</head>
<body>
<!-- Begin Wrapper -->
<div id="wrapper">
  <!-- Begin Header -->
  <div id="header"><h1><a href="https://aws.amazon.com/es/ivs/">Amazon IVS</a></h1></div>
  <!-- End Header -->
  <!-- Begin Content -->
  <div id="content"> 
    <script src="https://player.live-video.net/1.12.0/amazon-ivs-player.min.js"></script>
    <video id="video-player" width="850" height="325"  playsinline></video>
    <script>
      if (IVSPlayer.isPlayerSupported) {
        const player = IVSPlayer.create();
        player.attachHTMLVideoElement(document.getElementById('video-player'));
        player.load("Playback URL");
        player.play();
      }
    </script>
    </div>
  <!-- End Content -->
  <!-- Begin Footer -->
  <div id="footer"> <a href="https://dev.to/cecamilo">Camilo Cabrales</div>
  <!-- End Footer -->
 </div>
<!-- End Wrapper -->
</body>
</html>

Debemos reemplazar el texto Playback URL de la linea de código player.load("Playback URL"); por el valor que tenemos en nuestro canal.

Ya hemos configurado el bucket para que funcione como un sitio web estático y modificamos el archivo index.html, el siguiente paso es subir este archivo a nuestro bucket. Para esto vamos a nuestro bucket damos click en el botón Upload y subimos el archivo. Una vez el archivo este dentro de nuestro bucket le damos click sobre el nombre y copiamos el Object URL para verlo en un navegador web.

Ahora debemos iniciar la aplicación de Larix y comenzar la transmisión la cual veremos en nuestra pagina web después de esperar unos segundos (si no inicia en unos segundos, se debe actualizar la pagina).

Con esto damos por terminado el ejercicio, tal vez puedan complementarlo agregando que el video se guarde en S3 o agregando un método de autenticación a la pagina con Cognito.

Me pueden encontrar en:

Camilo Cabrales

Referencias

Amazon IVS

Plantillas HTML

Como configurar multiples profiles desde AWS CLI

camilo cabrales — Tue, 06 Sep 2022 23:00:24 +0000

La AWS CLI es la linea de comandos de AWS que es usada para interactuar con los servicios de AWS.

Cuando usamos la CLI por primera vez debemos configurar nuestra cuenta utilizando el comando aws configure , que nos pide los siguientes datos:

AWS Access Key ID
AWS Secret Access Key
Default region name
Default output format

Para obtener el AWS Access Key ID y el AWS Secret Access Key vamos a la consola de AWS y buscamos IAM seleccionamos Users -Security Credentials y Create Access Key

Al dar click en el botón Create Access Key vamos a ver una pantalla donde podemos copiar las Keys para configurar nuestra cuenta en la CLI de la maquina en la cual estamos trabajando.

Nota: Es importante nunca compartir estas Keys, ya que pueden entrar a utilizar la cuenta con los privilegios que tiene asignados el usuario.

Ahora que sabemos como obtener las keys podemos configurar diferentes cuentas en nuestra maquina. Para esto utilizamos el comando: aws configure --profile nombredelperfil
lo que nos va a pedir las keys, la region y el formato.

Para ver las cuentas que tenemos configuradas en nuestra maquina utilizamos el comando: aws configure list-profiles

Si queremos ejecutar un comando para un perfil determinado debemos agregar al comando: --profile nombredelperfil , por ejemplo para traer todos los buckets del perfil cuenta2 debemos ejecutar el siguiente comando:
aws s3 ls --profile cuenta2

En el caso que no queramos agregar el parametro profile a cada comando podemos ejecutar:

Linux o Mac: export AWS_PROFILE=_cuenta2
Windows: setx AWS_PROFILE _cuenta2

Si queremos modificar o eliminar los profiles que tenemos configurados en nuestra maquina podemos buscar el archivo ~/.aws/config que nos va a mostrar algo como lo siguiente:

[default]
region = us-east-1
output = json
[profile cuenta2]
region = us-east-2
output = json

Es posible que necesitemos modificar las key de un profile y las podemos encontrar en el archivo ~/.aws/credentials

Conociendo los comandos y archivos anteriores podemos tener varias cuentas configuradas en una sola maquina.

Me pueden encontrar en:

Camilo Cabrales

Referencias

Documentación

Borrar

camilo cabrales — Tue, 06 Sep 2022 22:48:05 +0000

Despliegue y prueba de servicios creados con Terraform en AWS

camilo cabrales — Tue, 16 Aug 2022 15:00:15 +0000

Terraform es una herramienta de IaC multicloud, basado en el lenguaje de configuración Hansicorp que es un tipo de JSON.

Las plantillas de Terraform generalmente se distribuyen de la siguiente forma:

Provider: Se define la nube en la cual vamos a trabajar.
DataSources-Parameters: Se definen los parámetros o variables que vamos a utilizar dentro de nuestra plantilla.
Resources: Definimos los recursos a desplegar.

La siguiente arquitectura muestra los recursos que vamos a desplegar en AWS con Terraform.

plantilla

# PROVIDER

provider "aws" {
    region = "${var.aws_regions[0]}"
    #Se definen los tags comunes a todos los resources
    default_tags {
        tags = {
            despliegue = "Terraform AWS"
        }
    }
}

#DATA - PARAMETERS - VARIABLES


locals {
  tags = {
    despliegue = "Terraform AWS"
  }
}
variable "amiinstance" {
    default = "ami-090fa75af13c156b4"
    type = string  
}

variable "aws_regions" {
    default = [
        "us-east-1",
        "us-east-2"
    ]
    type = list
}

variable "aws_instance_size" {
    type = map
    default= {
        small = "t2.micro",
        medium = "t2.medium",
        large = "t2.large"
    }
}

variable "aws_instancedb_size" {
    type = map
    default= {
        small = "db.t2.micro",
        medium = "db.t2.small"
    }
}

variable "tag" {
    default = "template_terraform"
    type = string
}

variable "cidr_subnets" {
    default = [
        "10.0.1.0/24",#public
        "10.0.2.0/28",#private
        "10.0.3.0/28"#private
    ]
    type = list
}

#RESOURCES

resource "aws_vpc" "vpcterraform" {
    cidr_block = "10.0.0.0/16"
    enable_dns_hostnames = true
    tags = {
        Name = "${var.tag}"
    }
}

resource "aws_internet_gateway" "igwterraform" {
    vpc_id = "${aws_vpc.vpcterraform.id}"
    tags = {
        Name = "routeTableTFPublic_${var.tag}"
    }
}

resource "aws_route_table" "routeTableTFPublic" {
    vpc_id = "${aws_vpc.vpcterraform.id}"
    route {
        cidr_block = "0.0.0.0/0"
        gateway_id = "${aws_internet_gateway.igwterraform.id}"
    }
    tags = {
        Name = "routeTableTFPublic_${var.tag}"
    }
}

resource "aws_route_table" "routeTablerivate" {
    vpc_id = "${aws_vpc.vpcterraform.id}"
    tags = {
        Name = "routeTableTFPrivate_${var.tag}"
    }

}

resource "aws_subnet" "publicsubnet1" {
    vpc_id = "${aws_vpc.vpcterraform.id}"
    cidr_block = var.cidr_subnets[0]
    map_public_ip_on_launch = true
    availability_zone = "us-east-1a"
    tags = {
        Name = "publicsubnet1_${var.tag}"
    }
}

resource "aws_route_table_association" "routeTableAssociationTF" {
    subnet_id = "${aws_subnet.publicsubnet1.id}"
    route_table_id = "${aws_route_table.routeTableTFPublic.id}"
}

resource "aws_subnet" "privatesubnet1" {
    vpc_id = "${aws_vpc.vpcterraform.id}"
    cidr_block = var.cidr_subnets[1]
    availability_zone = "us-east-1b"
    tags = {
        Name = "privatesubnet1_${var.tag}"
    }
}

resource "aws_subnet" "privatesubnet2" {
    vpc_id = "${aws_vpc.vpcterraform.id}"
    cidr_block = var.cidr_subnets[2]
    availability_zone = "us-east-1c"
    tags = {
        Name = "privatesubnet2_${var.tag}"
    }
}

resource "aws_db_subnet_group" "dbprivatesubnetgroup"{
    name = "dbprivatesubnetgroup"
    subnet_ids = ["${aws_subnet.privatesubnet1.id}","${aws_subnet.privatesubnet2.id}"]
    tags = {
        Name = "dbprivatesubnetgroup_${var.tag}"
    }
}

resource "aws_iam_role" "instance_role" {
    assume_role_policy = jsonencode({
        "Version": "2012-10-17",
        "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "sts:AssumeRole"
            ],
            "Principal": {
                "Service": [
                    "ec2.amazonaws.com"
                ]
            }
        }
        ]
    })

    tags = {
        tag-key = "role_${var.tag}"
    }
}

resource "aws_iam_policy" "policy"{
    policy = jsonencode({
        "Version": "2012-10-17",
        "Statement": [
            {
                "Effect": "Allow",
                "Action": [
                    "cloudwatch:PutMetricData",
                    "ds:CreateComputer",
                    "ds:DescribeDirectories",
                    "ec2:DescribeInstanceStatus",
                    "logs:*",
                    "ssm:*",
                    "ec2messages:*"
                ],
                "Resource": "*"
            },
            {
                "Effect": "Allow",
                "Action": "iam:CreateServiceLinkedRole",
                "Resource": "arn:aws:iam::*:role/aws-service-role/ssm.amazonaws.com/AWSServiceRoleForAmazonSSM*",
                "Condition": {
                    "StringLike": {
                        "iam:AWSServiceName": "ssm.amazonaws.com"
                    }
                }
            },
            {
                "Effect": "Allow",
                "Action": [
                    "iam:DeleteServiceLinkedRole",
                    "iam:GetServiceLinkedRoleDeletionStatus"
                ],
                "Resource": "arn:aws:iam::*:role/aws-service-role/ssm.amazonaws.com/AWSServiceRoleForAmazonSSM*"
            },
            {
                "Effect": "Allow",
                "Action": [
                    "ssmmessages:CreateControlChannel",
                    "ssmmessages:CreateDataChannel",
                    "ssmmessages:OpenControlChannel",
                    "ssmmessages:OpenDataChannel"
                ],
                "Resource": "*"
            }
        ]
    })
    tags = {
        tag-key = "policy_${var.tag}"
    }
}

resource "aws_iam_role_policy_attachment" "policy_attachment" {
    role = "${aws_iam_role.instance_role.name}"
    policy_arn = "${aws_iam_policy.policy.arn}"
}

resource "aws_iam_instance_profile" "instance_profile" {
    role  = "${aws_iam_role.instance_role.name}"
}

resource "aws_security_group" "sg_instance" {
    vpc_id = "${aws_vpc.vpcterraform.id}"
    ingress {
        from_port = 22
        to_port = 22
        protocol ="tcp"
        cidr_blocks = ["0.0.0.0/0"]
    }
    ingress {
        from_port   = 80
        to_port     = 80
        protocol    = "tcp"
        cidr_blocks = ["0.0.0.0/0"]
    }
    egress {
        from_port   = 0
        to_port     = 0
        protocol    = "-1"
        cidr_blocks = ["0.0.0.0/0"]
    }
    tags = {
        Name = "sg_instance_${var.tag}"
    }
}

resource "aws_instance" "instancia" {
    ami= "${var.amiinstance}"
    instance_type = "${var.aws_instance_size.small}"
    subnet_id = "${aws_subnet.publicsubnet1.id}"
    vpc_security_group_ids = [ "${aws_security_group.sg_instance.id}" ]
    tags = {
        Name = "instancia_${var.tag}"
    }
    iam_instance_profile = "${aws_iam_instance_profile.instance_profile.id}"
    depends_on = [aws_internet_gateway.igwterraform]
    user_data = <<EOF
    #!/bin/bash
    yum update -y
    yum install httpd -y
    service httpd start
    chkconfig httpd on
    cd /var/www/html
    echo "<html><body><h1>Terraform Instancia: $(hostname -f)</h1></body></html>" > index.html
    EOF

}

resource "aws_security_group" "sgbd" {
    name = "sg"
    vpc_id = "${aws_vpc.vpcterraform.id}"
    ingress {
        from_port = 3306
        to_port = 3306
        protocol ="tcp"
        cidr_blocks = ["${aws_instance.instancia.private_ip}/32"]
    }
    tags = {
        Name = "sgbd_${var.tag}"
    }
}

resource "aws_db_instance" "dbinstance" {
    db_subnet_group_name = "${aws_db_subnet_group.dbprivatesubnetgroup.name}"
    engine = "mysql"
    db_name = "dbterraform"
    engine_version = "5.7.28"
    instance_class = "${var.aws_instancedb_size.small}"
    username = "admin"
    password = "admin12345678"
    allocated_storage = 10
    skip_final_snapshot = true
    vpc_security_group_ids =  [ "${aws_security_group.sgbd.id}" ]
    tags = {
        Name = "dbinstance_${var.tag}"
    }
}

output "endpoint" {
    value = "${aws_instance.instancia.public_ip}"
}

Terraform tiene comandos para iniciar, validar, desplegar y destruir los recursos definidos en nuestras plantillas (Antes de usar los siguientes comandos recuerden configurar sus access keys con el comando aws configure).

1.terraform init: Configura el directorio donde se encuentra nuestra plantilla para que pueda ser usado con Terraform.

2.terraform validate: Valida que la plantilla no tenga errores de sintaxis o de lógica.

3.terraform plan: Nos muestra una descripción de los recursos que van a ser desplegados, valida si hay cambios en nuestros recursos (en caso de actualización) y valida que nuestra plantilla no tenga errores.

4.terraform apply: Nos va a mostrar la infraestructura que se va a desplegar y nos va a preguntar que sí estamos de acuerdo por lo que debemos escribir yes para que inicie el despliegue de nuestros servicios.

Al final nos va a mostrar la cantidad de recursos que se crearon y los outputs que tenemos definidos en la plantilla.

Terraform al desplegar nuestra infraestructura crea el archivo
terraform.tfstate donde se guarda la información de los recursos desplegados.
Podemos ver qué recursos se desplegaron con el comando: terraform state list y podemos ver la información del recurso con el comando terraform state show nombre_del_recurso.

Una vez que se han creado todos nuestros recursos, vamos a verlos en la consola de AWS. Para esto buscamos resources groups y le damos click.

Ya en la pantalla principal damos click en Tag Editor, seleccionamos todas las regiones, todos los recursos, en los tags escribimos despliegue - Terraform AWS y damos click en le botón Search Resources. Esto nos va a traer todos los recursos que tiene este tag.

El resultado de la búsqueda nos va a mostrar los recursos que cumplen las condiciones anteriores.

Este resultado lo obtuvimos ya que a todos los recursos de la plantilla les asignamos el tag: Name: despliegue - Value: Terraform AWS, en el siguiente fragmento de la plantilla:

provider "aws" {
    region = "${var.aws_regions[0]}"
    #Se definen los tags comunes a todos los resources
    default_tags {
        tags = {
            despliegue = "Terraform AWS"
        }
    }
}

Ahora vamos a validar el funcionamiento de nuestra aplicación. En la pantalla de resultados damos click en la instancia de EC2 que creamos.

Los que nos lleva a la pantalla de EC2 y copiamos la Ip publica de la instancia y la colocamos en una nueva pestaña de nuestro navegador.

lo que nos va a mostrar lo siguiente:

Este resultado lo obtuvimos ya que en nuestra definición de la instancia dentro dentro de la propiedad user data le pedimos que instalara apache y creara una pagina web.

resource "aws_instance" "instancia" {
    ami= "${var.amiinstance}"
    instance_type = "${var.aws_instance_size.small}"
    subnet_id = "${aws_subnet.publicsubnet1.id}"
    vpc_security_group_ids = [ "${aws_security_group.sg_instance.id}" ]
    tags = {
        Name = "instancia_${var.tag}"
    }
    iam_instance_profile = "${aws_iam_instance_profile.instance_profile.id}"
    user_data = <<EOF
    #!/bin/bash
    yum update -y
    yum install httpd -y
    service httpd start
    chkconfig httpd on
    cd /var/www/html
    echo "<html><body><h1>Terraform Instancia: $(hostname -f)</h1></body></html>" > index.html
    yum install mysql
    EOF

}

De acuerdo a la anterior definición de nuestra instancia, no definimos un access key para poder ingresar a ella desde la terminal.
Para acceder a la instancia y validar nuestra base de datos vamos a buscar el servicio System Manager.

En la pagina principal damos click Session Manager, después en Start Session.

Ahora seleccionamos la instancia que creamos y damos click en el botón Start Session

Lo que nos va abrir una terminal como la siguiente.

Donde podemos ejecutar los comandos para acceder a la base de datos creada con la plantilla:

Instalar mysql (para usar como cliente):

sudo su
sudo yum install mysql

Conectarse a la base de datos:

mysql -h reemplezar_por_endpoint_basededatos -u admin -p database

Para lograr abrir la terminal desde System Manager se crearon los siguientes recursos en la plantilla:

aws_iam_role
aws_iam_policy
aws_iam_role_policy_attachment
aws_iam_instance_profile

para asociar el recurso aws_iam_instance_profile a nuestra instancia.

5.terraform destroy: al ejecutar el comando nos muestra los recursos que se van a eliminar, después nos solicita que autoricemos la eliminación por lo que debemos escribir yes.

Con la ejecución de estos comando terminamos con el despliegue y la liberación de los recursos desplegados con Terraform.

Terraform me parece practico ya que su sintaxis se me asemeja al desarrollo (he trabajado como desarrollador). Una de las cosas que creo mas importantes para trabajar con herramientas IAC es la documentación la cual me pareció sencilla pero practica.

Para mejorar la plantilla pueden crear archivos separados para las variables, para los outputs y realizar la misma ejecución de comandos, esto con el fin que nuestra plantilla quede más organizada y legible.

Camilo Cabrales

Referencias

IaC - Como crear un API Rest con: CloudFormation o SAM

camilo cabrales — Thu, 14 Jul 2022 21:49:45 +0000

En este post vamos a crear la siguiente infraestructura utilizando algunas de las herramienta de IaC que tenemos a nuestra disposición en AWS.

Empecemos con la plantilla para CloudFormation:

AWSTemplateFormatVersion: '2010-09-09'
Parameters:
  MetodoGET:
    Type: String
    Default: GET
  MetodoPOST:
    Type: String
    Default: POST
  ClientePath:
    Type: String
    Default: cliente
  SucursalPath:
    Type: String
    Default: sucursal
  Stage:
    Type: String
    Default: dev
  RoleFullAccessDynamoDB:
    Type: String
    Default: arn:aws:iam::aws:policy/AmazonDynamoDBFullAccess
  RoleFullAccessCloudWatch:
    Type: String
    Default: arn:aws:iam::aws:policy/CloudWatchFullAccess

Resources:
  RoleFuncionLambda:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Version: '2012-10-17'
        Statement:
          - Effect: Allow
            Principal:
              Service:
                - lambda.amazonaws.com
            Action:
              - 'sts:AssumeRole'
      Path: /
      ManagedPolicyArns:
        - !Ref RoleFullAccessDynamoDB
        - !Ref RoleFullAccessCloudWatch
  APITienda:
    Type: AWS::ApiGateway::RestApi
    Properties:
      Name: APITienda
      EndpointConfiguration:
        Types:
          - REGIONAL
  RecursoCliente:
    Type: AWS::ApiGateway::Resource
    Properties:
      RestApiId: !Ref  APITienda
      PathPart: !Ref ClientePath
      ParentId: !GetAtt APITienda.RootResourceId
  RecursoSucursal:
    Type: AWS::ApiGateway::Resource
    Properties:
      RestApiId: !Ref  APITienda
      PathPart: !Ref SucursalPath
      ParentId: !GetAtt APITienda.RootResourceId
  MetodoObtenerClientes:
    Type: AWS::ApiGateway::Method
    Properties:
      AuthorizationType: NONE
      HttpMethod: !Ref MetodoGET
      Integration:
        IntegrationHttpMethod: POST
        Type: AWS_PROXY
        Uri: !Sub
          - arn:aws:apigateway:${AWS::Region}:lambda:path/2015-03-31/functions/${lambdaArn}/invocations
          - lambdaArn: !GetAtt ObtenerClienteLambda.Arn
      ResourceId: !GetAtt RecursoCliente.ResourceId
      RestApiId: !Ref APITienda
  MetodoRegistrarCliente:
    Type: AWS::ApiGateway::Method
    Properties:
      AuthorizationType: NONE
      HttpMethod: !Ref MetodoPOST
      Integration:
        IntegrationHttpMethod: POST
        Type: AWS_PROXY
        Uri: !Sub
          - arn:aws:apigateway:${AWS::Region}:lambda:path/2015-03-31/functions/${lambdaArn}/invocations
          - lambdaArn: !GetAtt RegistrarClienteLambda.Arn
      ResourceId: !GetAtt RecursoCliente.ResourceId
      RestApiId: !Ref APITienda
  MetodoObtenerSucursales:
    Type: AWS::ApiGateway::Method
    Properties:
      AuthorizationType: NONE
      HttpMethod: !Ref MetodoGET
      Integration:
        IntegrationHttpMethod: POST
        Type: AWS_PROXY
        Uri: !Sub
          - arn:aws:apigateway:${AWS::Region}:lambda:path/2015-03-31/functions/${lambdaArn}/invocations
          - lambdaArn: !GetAtt ObtenerSucursalesLambda.Arn
      ResourceId: !GetAtt RecursoSucursal.ResourceId
      RestApiId: !Ref APITienda
  Despliegue:
    Type: AWS::ApiGateway::Deployment
    DependsOn:
      - MetodoObtenerClientes
      - MetodoRegistrarCliente
      - MetodoObtenerSucursales
    Properties: 
      RestApiId: !Ref APITienda
      StageName: !Ref Stage
  RegistrarClienteLambda:
    Type: AWS::Lambda::Function
    Properties:
      Description: "Agrega clientes a la base de datos"
      FunctionName: "RegistarCliente"
      Handler: index.lambda_handler
      MemorySize: 128
      Runtime: python3.8
      Timeout: 3
      Code: 
        ZipFile: |
          import json
          import boto3 
          from boto3.dynamodb.conditions import Key

          dynamodb = boto3.resource("dynamodb")
          table = dynamodb.Table("Tiendas")

          def lambda_handler(event, context):
            data = json.loads(event["body"])
            idCliente= data["id"]
            nombre = data["nombre"]
            apellido = data["apellido"]
            table.put_item(Item={
              "Id": "Cliente",
              "Filtro":"Id#"+idCliente,
              "Nombre":nombre,
              "Apellido":apellido
            })
            return {
              'statusCode': 200,
              'body': json.dumps(idCliente)
            }
      Role: !GetAtt  RoleFuncionLambda.Arn
  ObtenerClienteLambda:
    Type: AWS::Lambda::Function
    Properties:
      Description: "Obtiene los clientes"
      FunctionName: "ObtenerCliente"
      Handler: index.lambda_handler
      MemorySize: 128
      Runtime: python3.8
      Timeout: 3
      Code: 
        ZipFile: |
          import json
          import boto3 
          from boto3.dynamodb.conditions import Key

          dynamodb = boto3.resource("dynamodb")
          table = dynamodb.Table("Tiendas")

          def lambda_handler(event, context):

            id = event["queryStringParameters"]["id"]
            cliente = table.query(KeyConditionExpression=Key('Id').eq("Cliente") & Key('Filtro').eq('Id#'+id),                   
                                ProjectionExpression="Id,Filtro,Nombre,Apellido")
            return {
              'statusCode': 200,
              'body': json.dumps(cliente)
            }
      Role: !GetAtt  RoleFuncionLambda.Arn
  ObtenerSucursalesLambda:
    Type: AWS::Lambda::Function
    Properties:
      Description: "Obtiene las sucursales"
      FunctionName: "ObtenerSucursales"
      Handler: index.lambda_handler
      MemorySize: 128
      Runtime: python3.8
      Timeout: 3
      Code: 
        ZipFile: |
          import json
          import boto3 
          from boto3.dynamodb.conditions import Key

          dynamodb = boto3.resource("dynamodb")
          table = dynamodb.Table("Tiendas")

          def lambda_handler(event, context):

            sucursales = table.query(KeyConditionExpression=Key('Id').eq("Sucursal"),                   
                                  ProjectionExpression="Id,Filtro,Direccion")
            return {
              'statusCode': 200,
              'body': json.dumps(sucursales)
            }
      Role: !GetAtt  RoleFuncionLambda.Arn
  PermisoObtenerClientes:
    Type: AWS::Lambda::Permission
    Properties:
      Action: "lambda:InvokeFunction"
      FunctionName: !GetAtt ObtenerClienteLambda.Arn
      Principal: "apigateway.amazonaws.com"
      SourceArn: !Sub "arn:aws:execute-api:${AWS::Region}:${AWS::AccountId}:${APITienda}/*/${MetodoGET}/${ClientePath}"
  PermisoRegistrarCliente:
    Type: AWS::Lambda::Permission
    Properties:
      Action: "lambda:InvokeFunction"
      FunctionName: !Ref RegistrarClienteLambda
      Principal: "apigateway.amazonaws.com"
      SourceArn: !Sub "arn:aws:execute-api:${AWS::Region}:${AWS::AccountId}:${APITienda}/*/${MetodoPOST}/${ClientePath}"
  PermisoObtenerSucursales:
    Type: AWS::Lambda::Permission
    Properties:
      Action: "lambda:InvokeFunction"
      FunctionName: !Ref ObtenerSucursalesLambda
      Principal: "apigateway.amazonaws.com"
      SourceArn: !Sub "arn:aws:execute-api:${AWS::Region}:${AWS::AccountId}:${APITienda}/*/${MetodoGET}/${SucursalPath}"
  Tabla:
    Type: AWS::DynamoDB::Table
    Properties:
      TableName: Tiendas
      BillingMode: PROVISIONED
      ProvisionedThroughput: 
        ReadCapacityUnits: "5"
        WriteCapacityUnits: "5"
      AttributeDefinitions:
        -
          AttributeName: "Id"
          AttributeType: "S"
        -
          AttributeName: "Filtro"
          AttributeType: "S"
      KeySchema:
        -
          AttributeName: "Id"
          KeyType: "HASH"
        -
          AttributeName: "Filtro"
          KeyType: "RANGE"
Outputs:
  ApiEndPoint:
    Description: "EndPoint Api"
    Value: !Sub "https://${APITienda}.execute-api.${AWS::Region}.amazonaws.com/${Stage}/"
  ClienteEndPoint:
    Description: "EndPoint Metodos Cliente"
    Value: !Sub "https://${APITienda}.execute-api.${AWS::Region}.amazonaws.com/${Stage}/${ClientePath}"
  SucursalEndPoint:
    Description: "EndPoint Metodo Sucursal"
    Value: !Sub "https://${APITienda}.execute-api.${AWS::Region}.amazonaws.com/${Stage}/${SucursalPath}"

apirest.yml

Las etiquetas que utilizamos para crear los recursos son las siguientes:

Para poder desplegar nuestra infraestructura debemos asegurarnos de tener instalada la CLI (Instalar CLI) en nuestro equipo y haber configurado nuestras credenciales(comando aws configure).

Vamos a validar que nuestra plantilla este construida de manera correcta. Ubicados en la carpeta donde se encuentra la plantilla vamos a ejecutar el siguiente comando:

aws cloudformation validate-template --template-body file://apirest.yml

Si la plantilla esta bien construida el comando nos va a retornar la lista de parámetros que tiene nuestra plantilla.

Una vez sabemos que nuestra plantilla es correcta vamos a desplegarla utilizando el siguiente comando

aws cloudformation deploy --template-file apirest.yml --stack-name apiresIaC --capabilities CAPABILITY_IAM

que recibe como parámetros el nombre de la plantilla y el nombre del stack que vamos a crear. Adicionalmente le enviamos el parámetro --capabilities CAPABILITY_IAM ya que vamos hacer uso de IAM.

Una vez que ejecutamos el comando vamos a ver lo siguiente:

Lo que nos indica que nuestros recursos fueron desplegados con exito. Podemos revisar todo el proceso y el resultado del despliegue de la infraestructura desde la consola de AWS. Para este buscamos el servicio CloudFormation y damos click en Stacks, donde vamos a ver el stack que creamos con el comando deploy.

Si damos click en el nombre del stack creado vamos a poder ver todo el detalle de los eventos del proceso de creación, los recursos creados, los parámetros, las salidas, el template y los cambios que se han realizado sobre la plantilla. Damos click en Outputs para ver las rutas de los servicios desplegados.

Para probar nuestros servicios podemos utilizar PostMan o en mi caso estoy utilizando la extension REST Client para Visual Studio Code. Puedo probar los servicios de la siguiente manera:

POST   https://5d24uhg9db.execute-api.us-east-1.amazonaws.com/dev/cliente HTTP/1.1
content-type: application/json

{
    "id": "1",
    "nombre": "Lisa",
    "apellido": "Simpson"
}

###

GET   https://5d24uhg9db.execute-api.us-east-1.amazonaws.com/dev/cliente?id=1 HTTP/1.1
content-type: application/json

###

GET   https://5d24uhg9db.execute-api.us-east-1.amazonaws.com/dev/sucursal HTTP/1.1
content-type: application/json

Con esto finalizamos el despliegue y las pruebas de nuestro API Rest creado con CloudFormation.

Ahora vamos a crear la misma infraestructura utilizando SAM(Serverless Application Model). SAM nos permite desplegar aplicaciones sin servidor en AWS a diferencia de CloudFormation que nos permite desplegar todo tipo de recursos.

Las etiquetas que utilizamos para crear los recursos son las siguientes:

La plantilla que utilizamos es la siguiente:

AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Parameters:
  Stage:
    Type: String
    Default: dev
  RoleFullAccessDynamoDB:
    Type: String
    Default: arn:aws:iam::aws:policy/AmazonDynamoDBFullAccess
  RoleFullAccessCloudWatch:
    Type: String
    Default: arn:aws:iam::aws:policy/CloudWatchFullAccess
  ClientePath:
    Type: String
    Default: cliente
  SucursalPath:
    Type: String
    Default: sucursal
Resources:
  RoleFuncionLambda:
    Type: 'AWS::IAM::Role'
    Properties:
      AssumeRolePolicyDocument:
        Version: '2012-10-17'
        Statement:
          - Effect: Allow
            Principal:
              Service:
                - lambda.amazonaws.com
            Action:
              - 'sts:AssumeRole'
      Path: /
      ManagedPolicyArns:
        - !Ref RoleFullAccessDynamoDB
        - !Ref RoleFullAccessCloudWatch
  APITienda:
    Type: AWS::Serverless::Api
    Properties:
      Name: APITienda
      StageName: !Ref Stage

  RegistrarClienteLambda:
    Type: AWS::Serverless::Function
    Properties:
      InlineCode: |
          import json
          import boto3 
          from boto3.dynamodb.conditions import Key

          dynamodb = boto3.resource("dynamodb")
          table = dynamodb.Table("Tiendas")

          def lambda_handler(event, context):
            data = json.loads(event["body"])
            idCliente= data["id"]
            nombre = data["nombre"]
            apellido = data["apellido"]
            table.put_item(Item={
              "Id": "Cliente",
              "Filtro":"Id#"+idCliente,
              "Nombre":nombre,
              "Apellido":apellido
            })
            return {
              'statusCode': 200,
              'body': json.dumps(idCliente)
            }
      Handler: index.lambda_handler
      Runtime: python3.7
      PackageType: Zip
      FunctionName: RegistrarCliente
      Role: !GetAtt RoleFuncionLambda.Arn
      Events:
        RegistrarCliente:
          Type: Api
          Properties:
            RestApiId: !Ref APITienda
            Path: /cliente
            Method: POST
  ObtenerClienteLambda:
    Type: AWS::Serverless::Function
    Properties:
      InlineCode: |
          import json
          import boto3 
          from boto3.dynamodb.conditions import Key

          dynamodb = boto3.resource("dynamodb")
          table = dynamodb.Table("Tiendas")

          def lambda_handler(event, context):

            id = event["queryStringParameters"]["id"]
            cliente = table.query(KeyConditionExpression=Key('Id').eq("Cliente") & Key('Filtro').eq('Id#'+id),                   
                                ProjectionExpression="Id,Filtro,Nombre,Apellido")
            return {
              'statusCode': 200,
              'body': json.dumps(cliente)
            }
      Handler: index.lambda_handler
      Runtime: python3.7
      PackageType: Zip
      FunctionName: ObtenerCliente
      Role: !GetAtt RoleFuncionLambda.Arn
      Events:
        ObtenerClientes:
          Type: Api
          Properties:
            RestApiId: !Ref APITienda
            Path: /cliente
            Method: GET
  SucursalesLambda:
    Type: AWS::Serverless::Function
    Properties:
      InlineCode: |
          import json
          import boto3 
          from boto3.dynamodb.conditions import Key

          dynamodb = boto3.resource("dynamodb")
          table = dynamodb.Table("Tiendas")

          def lambda_handler(event, context):

            sucursales = table.query(KeyConditionExpression=Key('Id').eq("Sucursal"),                   
                                  ProjectionExpression="Id,Filtro,Direccion")
            print(sucursales["Items"])
            return {
              'statusCode': 200,
              'body': json.dumps(sucursales)
            }
      Handler: index.lambda_handler
      Runtime: python3.7
      PackageType: Zip
      FunctionName: ObtenerSucursales
      Role: !GetAtt RoleFuncionLambda.Arn
      Events:
        ObtenerSucursales:
          Type: Api
          Properties:
            RestApiId: !Ref APITienda
            Path: /sucursal
            Method: GET
  Tabla:
    Type: AWS::DynamoDB::Table
    Properties:
      TableName: Tiendas
      BillingMode: PROVISIONED
      ProvisionedThroughput: 
        ReadCapacityUnits: "5"
        WriteCapacityUnits: "5"
      AttributeDefinitions:
        -
          AttributeName: "Id"
          AttributeType: "S"
        -
          AttributeName: "Filtro"
          AttributeType: "S"
      KeySchema:
        -
          AttributeName: "Id"
          KeyType: "HASH"
        -
          AttributeName: "Filtro"
          KeyType: "RANGE"
Outputs:
  ApiEndPoint:
    Description: "EndPoint Api"
    Value: !Sub "https://${APITienda}.execute-api.${AWS::Region}.amazonaws.com/${Stage}/"
  ClienteEndPoint:
    Description: "EndPoint Metodos Cliente"
    Value: !Sub "https://${APITienda}.execute-api.${AWS::Region}.amazonaws.com/${Stage}/${ClientePath}"
  SucursalEndPoint:
    Description: "EndPoint Metodo Sucursal"
    Value: !Sub "https://${APITienda}.execute-api.${AWS::Region}.amazonaws.com/${Stage}/${SucursalPath}"

apirestsam.yml

Algo que diferencia a las plantillas SAM de las plantillas de CloudFormation es la siguiente linea que identifica la plantilla como SAM:

Transform: AWS::Serverless-2016-10-31

SAM utiliza algunas etiquetas diferentes para crear los recursos como:

AWS::Serverless::Api : Nos sirve para crear el API Gateway.

AWS::Serverless::Function: Nos sirve para crear la función Lambda y la integración con API Gateway (los recursos, los métodos, el stage y el despliegue).

Como podemos observar utilizar SAM para desplegar aplicaciones sin servidor es mucho mas practico que utilizar CloudFormation.

Teniendo nuestra plantilla debemos desplegarla en AWS. Primero debemos tener instalada la SAM CLI en nuestro equipo.

Una vez instalada SAM CLI vamos a validar que nuestra plantilla este construida correctamente con el siguiente comando.

sam validate --template apirestsam.yml

Como vemos que nuestra plantilla esta correcta vamos a desplegarla con el siguiente comando:

sam deploy --template-file apirestsam.yml --stack-name apirestSAMIaC --capabilities CAPABILITY_IAM

Al ejecutar el comando vamos a ver en detalle como se están creando nuestros recursos. Van a ver algo similar a esto en su terminal:

Esto nos indica que nuestra API Rest fue desplegado con éxito.
Como lo hicimos en el despliegue de la plantilla de CloudFormation podemos ir a la consola de AWS y verificar que los recursos se hayan creado.

En este post podemos observar que se pueden utilizar diferentes herramientas para cumplir un mismo objetivo, sin embargo debemos buscar siempre la mas adecuada para cada caso, que en este es SAM, ya que la infraestructura a desplegar es sin servidor.

Como ejercicio pueden implementar la función Lambda para ingresar las sucursales e implementar un método de autenticación para validar el acceso a las métodos del API Gateway.

Me pueden encontrar en:

Camilo Cabrales

Referencias

CloudFormation

SAM

Conectarse a RDS por medio de un Proxy desde una función Lambda

camilo cabrales — Tue, 14 Jun 2022 21:01:39 +0000

Muchas de las aplicaciones que creamos necesitan una fuente de datos o base de datos relacional.Cuando la aplicación crece vamos a tener una carga significativa a nuestra base de datos, por lo que vamos a realizar mas peticiones y se van a crear mas conexiones a ella, lo que puede llegar a saturar la base de datos en cuanto a cantidad de conexiones.

Para dar un mejor manejo a las conexiones AWS tiene el componente Proxy que se encarga de administrar las conexiones a la base de datos de manera eficiente y evita que podamos llegar a tener errores por el alto numero de conexiones.

En este post vamos a crear un Proxy para que sirva como punto de acceso a nuestra base de datos. El acceso a la base de datos lo vamos a realizar por medio de una función Lambda.

Los Pasos a realizar van a ser los siguientes:

Creación de una base de datos (RDS).
Creación de un Secreto (Secrets Manager).
Creación del Proxy.
Creación de la función Lambda.

Iniciemos con la creación de la base de datos, para esto buscamos el servicio RDS. Ya en la pagina principal de RDS damos click en Databases y Create Database.

Podemos observar que hay dos formas para crear nuestra base de datos: Standard create _y _Easy create. Las dos formas nos permiten crear la base de datos solo que la forma Easy create no necesitamos realizar muchas configuraciones, para nuestro caso vamos a utilizar la forma Standard create. Aunque pueden usar Easy create.

Seleccionamos el motor de base de datos PostgreSQL y dejamos la version que se carga por defecto.

Seleccionamos el template free tier para que no genere "costos" (Recuerden eliminar todos los servicios creados al terminar el ejercicio). Esta selección solo se debe utilizar para pruebas ya que son bases de datos pequeñas que no tienen alta disponibilidad ni sus datos se replican.

Ahora asignamos un identificador para la instancia de base de datos, asignamos nombre un usuario y su contraseña.

Ahora debemos seleccionar el tipo de instancia que queremos para nuestra base de datos dejamos seleccionado la que viene por defecto que es t3.micro que es una instancia de uso general (En las referencias se encuentra el link hacia los tipos de instancia que maneja AWS).Para el almacenamiento dejamos un disco de propósito general de 20GB. Los demás valores los dejamos por defecto.

El siguiente paso es seleccionar la configuración de red y el lugar de donde queremos que se tenga acceso a nuestra base de datos. Para ambientes productivos siempre es mejor dejar el Public access No, ya limita el acceso a que sea desde la VPC en la cual se crea nuestra base de datos.

En la sección Aditional Configuration, vamos a encontrar dentro de la sección Database options una lista con el nombre DB parameter group. Los parameters groups nos sirven para establecer la configuración del motor de base de datos, siempre es recomendable tener una parameter group diferente al que esta por defecto para entornos de desarrollo y producción.
Para finalizar damos click en el boton Create Database.

En la siguiente pantalla vamos a ver el listado de base de datos que tenemos en esta región. Vamos a dar click en el nombre de la base de datos que acabos de crear para ver el endpoint para conectarnos a ella.

Nuestro siguiente paso es crear el Proxy para nuestra base de datos. Para esto vamos al menu lateral izquierdo y seleccionamos Proxies y damos click en el botón Create Proxy.

Ahora debemos asignar un nombre al Proxy y seleccionar el tipo de motor de base de datos a utilizar para el Proxy.

Seguido a esto debemos seleccionar la base de datos a la cual queremos crearle el proxy, seleccionamos la base de datos que lanzamos en pasos anteriores.

En la sección de Conectivity nos pide un secreto (Nos sirve para almacenar información privada o credenciales de bases de datos). Damos click en el enlace create a new secret y nos llevara a la pagina principal de secrets manager, damos click en Store a new secret.

En esta pantalla debemos seleccionar el tipo de secreto, ingresar el usuario y contraseña que definimos al crear la base de datos y seleccionar la base de datos que va a utilizar este secreto.

Ahora debemos dar un nombre y una descripción a nuestro secreto.

Para este caso vamos a dejar la configuración por defecto, sin embargo para entornos de producción como buena practica debemos rotar nuestros secretos .

Para finalizar vamos a ver un resumen de la configuración de nuestro secreto y la forma en que podemos acceder a él por medio de algunos lenguajes de programación. Damos click en Store.

Una vez creado el secreto regresamos a la ventana donde estábamos creando el proxy y seleccionamos el secreto (es posible que el secreto no aparezca en la lista y debamos actualizar la pagina e ingresar de nuevo los datos) que acabamos de crear y damos click en el botón Create proxy.

El proxy puede tardar un tiempo en crearse, por lo que debemos esperar un poco a qué se cree.

Hasta el momento hemos creado: La base de datos, un secreto para almacenar las credenciales a la base de datos y el proxy por el cual vamos acceder a la base de datos. Ahora vamos a iniciar la creación de la función Lambda que va a conectarse a la base de datos.

Vamos a la pagina principal de Lambda y damos click en Create function.

El siguiente paso es definir la configuración de nuestra función, iniciando por asignarle un nombre, el lenguaje de programación y dejamos seleccionado para que se cree un rol por defecto.

Como el proxy solo se puede usar desde dentro de una VPC debemos seleccionar la VPC a la cual va a tener acceso. Hay que tener en cuenta que debe ser la misma VPC que seleccionamos para la base de datos y el proxy (en este ejemplo estamos utilizando la VPC por defecto que trae AWS para esta region).Aparte de la VPC debemos seleccionar las subnets desde la cuales la función Lambda puede acceder al proxy. Por ultimo debemos seleccionar el Security Group que nos va a permitir el acceso al proxy por medio del puerto que usa Postgres. Terminada la configuración damos click en el botón Create function.

Como vamos a trabajar con Postgres desde Lambda, debemos utilizar el paquete psycopg que nos ayuda a tener acceder a Postgres. Si queremos utilizar paquetes de terceros o creados por nosotros en necesario usar un Layer.(en las referencias se indica como crear Layer).

Para agregar nuestra layer vamos a la parte inferior de la pantalla de la función Lambda y damos click en Add Layer.

En la siguiente pantalla seleccionamos nuestra Layer y la versión. El numero de versión depende de las veces que la hayamos modificado el Layer.

Podemos ver que nuestra Layer se agrego con éxito.

Ya que configuramos nuestra Layer debemos asignar al rol de la función Lambda las siguientes políticas. Para esto vamos a la pestaña de Configuration - Permissions damos click en el rol de la función.

Agregamos las siguientes políticas al rol: SecretsManagerReadWrite,AmazonRDSFullAccess y una política personalizada como la siguiente:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "secretsmanager:GetResourcePolicy",
                "secretsmanager:GetSecretValue",
                "secretsmanager:DescribeSecret",
                "secretsmanager:ListSecretVersionIds",
                "secretsmanager:ListSecrets"
            ],
            "Resource": [
                "*"
            ]
        }
    ]
}

Una vez que terminamos la configuración del rol de la función Lambda vamos agregar el siguiente código.

import json
import boto3
import psycopg2

client_secret = boto3.client('secretsmanager')

def lambda_handler(event, context):
    # TODO implement

    probar_conexion()
    return {
        'statusCode': 200,
        'body': json.dumps('Test Proxy!')
    }

def probar_conexion():
    conn = psycopg2.connect(host="proxy.com",database="postgres",user='postgres',password='12345678')
    print(conn)
    conn.close()

def probar_conexion_endpoint():
    response = client_secret.get_secret_value(SecretId='arn:aws:secretsmanager:us-east-1:385033107168:secret:secret-bd-proxy-4l9BKB')
    credentials = json.loads(response["SecretString"])
    conn = psycopg2.connect(host="proxy-database-post.proxy-cty4x2ccvn0y.us-east-1.rds.amazonaws.com",database="postgres",user=credentials["username"],password=credentials["password"])
    print(conn)
    conn.close()

La función probar_conexion es la que vamos a utilizar para probar la conexión a nuestro proxy (Es necesario reemplazar los parametros: host,database,user,password por los que establecimos en la configuración de nuestra base de datos). Ahora debemos crear el tipo de prueba, desplegar la función (botón Deploy) y ejecutar la función (botón Test).

Como ejercicio pueden probar la función probar_conexion_endpoint. Para esto es necesario configurar un EndPoint (Se puede encontrar en la pagina de la VPC) que este dentro de la VPC de la función Lamba y de la base de datos, en su Security Group le debemos indicar que el Security Group de la función Lambda puede acceder a el.

Me pueden encontrar en:

Camilo Cabrales

Referencias