Fuente: Concurrencia en lambda. https://docs.aws.amazon.com/lambda/latest/dg/lambda-concurrency.html

Si la concurrencia de una función alcanza el límite establecido por AWS (por defecto el límite en cada cuenta es de 1000), se limitarán las invocaciones adicionales a ese límite lo que generará solicitudes fallidas. Este límite puede incrementarse, solicitando su incremento a través de Service Quota.

Figura 1: Service Quota. Fuente AWS Console

La métrica en Amazon CloudWatch que contiene este dato a revisar se llama: ConcurrentExecutions que se calcula al multiplicar el promedio de solicitudes por segundo por la duración promedio de las solicitudes en segundos.

Concurrencia = PromSolicitudesxSeg X DuracionPromSolicitudesxSeg

Eso quiere decir que si tenemos una función que recibe 100 solicitudes por segundo y cada solicitud tarda alrededor de 300 milisegundos en completarse, la concurrencia sería de 30

Concurrencia = 100 X 0,3

Con Amazon CloudWatch podemos:

• Seleccionar la métrica ConcurrentExecutions para ver el número de ejecuciones concurrentes activas en la cuenta o en funciones específicas.

  

  Figura 2: Métrica ConcurrentExecutions. Fuente AWS Console

• Crear un gráfico que muestre la cantidad de cuántas ejecuciones concurrentes que se han ejecutado en un intervalo de tiempo dado.

  

Figura 3: Gráfico de ConcurrentExecutions. Fuente AWS Console

Usando Amazon CloudWatch Explorer

Con esta opción de Amazon Cloudwatch podremos rápidamente consultar varias métricas en simultáneo para un recurso en particular

Figura 4: Amazon CloudWatch Explorer. Fuente AWS Console

Figura 5: Servicios disponibles en Amazon CloudWatch Explorer. Fuente AWS Console

Figura 6: Métricas para lambda. Fuente AWS Console

En este caso hemos seleccionado el servicio de Lambda con algunas métricas claves (invocations, errors, throttles, concurrentExecutions). Ajustando el rango de fechas a consultar podemos ver rápidamente el resultado estás métricas segregadas para cada lambda de la cuenta.

Figura 6: Resultado de métricas para lambda segregadas por lambda. Fuente AWS Console

En el caso de los resultados de ConcurrentExecutions sobre todas las lambdas de una cuenta para un periodo dado observamos picos, que alcanzan el límite actual de la cuenta, mientras que otros tambien tienen picos a observar.

Figura 7: Detalle de la métrica ConcurrentExecutions segregada por lambda. Fuente AWS Console

Al identificar que lambdas son las que están consumiendo la concurrencia de la cuenta, podemos tomar acciones para evitar que vuelva a suceder como:

• Aplicar un monitoreo activo con Amazon CloudWatch

• Establecer alertas que notifiquen cuando se acerque al límite de concurrencia.​

• Cada Lambda debe ser aprovisionada en la cuenta con una alarma que monitoree la métrica ConcurrentExecutions.

• Cuando la alarma se active, se puede configurar una acción para que dispare otra Lambda que ajuste el valor de concurrencia reservada de la Lambda original.​

• Establecer concurrencia reservada sólo para algunas funciones. lambda​

• Desacoplar cargas de trabajo con SQS o SNS​

• Solicitar aumento de cuota en el límite de concurrencia (límite actual 1000)

La charla inició con algunas preguntas como:

• ¿Por qué es tan alta mi factura de AWS? Pensé que debería gastar menos en la nube

• ¿Cómo puedo reducir los costos de AWS para los entornos de desarrollo y control de calidad?

• ¿Qué opciones tengo para bajar mis costos en AWS?

Y una mención al Recap of Werner Vogels Keynote en el re:Invent 2023

“Sistemas no observados llevan a costos desconocidos”

Wegner Vegels. CTO y vicepresidente de Amazon.com

Hablamos sobre cómo WeTransfer logró reducir en un 78% el impacto medioambiental mediante la optimización del consumo de recursos del servidor en 2022.

Despilfarro en la nube

Muchas veces dentro de nuestra organización, tenemos falencias que conllevan a altos costos o costos ocultos que por falta de visibilidad no nos percatamos y pagamos mes a mes. Algunos ejemplos de este despilfarro se muestran a continuación:

Causas comunes del despilfarro en la nube

Para abordar estos problemas, podemos ejecutar algunas acciones para automatizar la eficiencia de costos en la nube, como:

• Infraestructura como código (IaC): al aprovisionar recursos en la nube por IaC podemos rápidamente eliminarlos cuando ya no los usemos sin necesidad de hacer una eliminación manual, con esto evitamos que queden recursos huérfanos o recursos sin utilizar.

• El apagado de recursos: lo podemos aplicar en ambientes bajos como DEV, QA y Stagging. Con el fin de minimizar costos apagando los recursos durante las noches y fines de semana y activandolos en horario laboral.

• Integración con FinOps: FinOps es una disciplina que ayuda a las organizaciones a gestionar sus finanzas en la nube, mediante buenas prácticas y colaboración entre equipos de ingeniería, finanzas y negocios

Beneficios de FinOps

FinOps - Framework en AWS

Dentro del framework podemos encontrar ejecutar algunas acciones para cada fase:

Principios de la Optimización de Costos

Además de las acciones antes mencionadas, la optimización de costos se basa en estos principios:

• Stop: detén recursos o servicios que ya no son necesarios o que están en desuso

• Resizing: ajusta el tamaño de los recursos (como máquinas virtuales, bases de datos, etc.) según la necesidad real

• Shift: mueve cargas de trabajo o recursos a una infraestructura más eficiente o rentable

• Reduce: elimina recursos infrautilizados o reduce el uso de servicios costosos

Herramientas Nativas de AWS para la Gestión de Costos

Por otro lado AWS, nos proporciona un conjunto de servicios y herramientas que nos pueden ayudar con la gestión de costos.

Algunas de ellas son:

Siguientes pasos

• Define, acuerda y aplica el etiquetado de asignación de costos

• Define las métricas, establece objetivos y revisa

• Permite que los equipos diseñen teniendo en cuenta los costos

• Asigna responsabilidad en la optimización

Enlaces de interés

https://aws.amazon.com/es/blogs/aws-cloud-financial-management/

https://www.finops.org/introduction/what-is-finops/

https://aws-experience.com/emea/smb/cost-optimization

Es la misma idea que existe en el backend con los microservicios pero trasladadas al front; es decir, tendremos BD, backend y front independientes.

Por ejemplo si tuviéramos una tienda de e-commerce tendríamos las siguientes aplicaciones:

• Para el registro/login del usuario: sería una micro-aplicación que puede estar en React

• Para el producto: sería una micro-aplicación que puede estar en Angular

• Para el carrito de compras: sería una micro-aplicación que puede estar en Vue

• Para el checkout: esta micro-aplicación podría estar en React

¿Que ventajas nos ofrecen los microfrontends?

Es ideal porque te permite reutilizar los microfrontends en otras aplicaciones, manteniendo un solo código.

Cada microfrontend tiene su propio repositorio de código, su propio archivo package.json y su propia configuración de implementación de compilación. De esta manera, cada microfrontend tiene un proceso de compilación independiente y una implementación/CI independiente. Lo que nos brinda tiempos de construcción rápidos.

En un futuro todo el frontend en las grandes empresas, con equipos alrededor del mundo irán usando este enfoque, para aplicaciones muy grandes que requiere que diferentes equipos hagas diferentes cosas

¿Cómo orquestar los microfrontends?

Para esta solución se ha usado Single SPA

Single SPA es un framework que trabaja como orquestador de microfronts, gestiona tu microfronts con frameworks y librerías como React, Vue, y Angular, lo que nos permite usarlos en la misma página sin tener tener que actualizarla.

El proyecto

Ahora que ya tenemos más claro, que son los microfronts, vamos a comentar sobre la solución de esta oportunidad: es un proyecto que consume algunas API’s para mostrar información de personajes de Rick and Morty y Harry Potter.

Para los microfrontends se utilizó React y se crearon 5 microfrontends, los cuales se alojan en repos diferentes, los cuales los puedes descargar desde los siguientes enlaces:

• fr-shell

• fr-header

• fr-list

• fr-category

• fr-utils

Ahora para su despliegue utilice AWS Amplify

¿Qué es AWS Amplify?

Es un framework que nos ayuda en todo el ciclo de vida de nuestras aplicaciones en la nube.

Tiene diferentes componentes que podemos usar, en este caso usaremos el componente de hosting. El cual nos permitirá desplegar todos los micro-frontends en S3 y CloudFront.

¿Cómo desplegar nuestro microfrontends usando AWS Amplify?

Para la configuración podemos seguir la documentación

Una vez listo, podemos continuar con nuestro siguiente paso para crear los recursos necesarios para desplegar nuestra aplicación con AWS Amplify

Primero nos ubicaremos en la carpeta de nuestro microfront padre (fr-shell) y ejecutaremos el siguiente comando:

amplify init

El cual nos pedirá ingresar información sobre el proyecto. Podemos revisar más detalles en la documentación

Tomará un tiempo hasta que el despliegue de los recursos termine. Luego de ello tendremos una aplicación creada dentro del panel de AWS Amplify.

Así como una pila de CloudFormation con un bucket S3 con archivos de metadatos de Amplify y dos roles de IAM

El comando anterior, nos crea esta estructura de proyecto

Como mencione anteriormente, AWSAmplify nos permite agregar hosting, para ello dentro de nuestro proyecto (fr-shell) ejecutaremos el siguiente comando:

amplify add hosting

Y seleccionaremos la opción de Amazon CloudFront and S3

Nos pedirá ingresar el nombre de nuestro bucket S3. Y una vez completado, la estructura de nuestro proyecto se actualizará con una nueva carpeta con el nombre hosting dentro de la carpeta amplify/backend.

Este hosting que hemos agregado, permitirá acceder al bucket S3 solo a través de la distribución de CloudFront, mediante la creación de una Identidad de acceso de origen (OAI) de CloudFront.

Ahora queda publicar nuestros cambios

amplify publish

Este comando además de subir nuestros cambios al bucket S3 y crear la distribución de CloudFront, también genera el build del proyecto.

Una vez completado el proceso, nos arrojará el endpoint de la distribución de CloudFront que usaremos para acceder a nuestro sitio web.

Pero eso no termina aquí, necesitamos desplegar los otros microfrontends que tenemos (en total son 5). Así que repetiremos los pasos previamente para cada uno de los microfrontends:

amplify init

amplify add hosting

amplify publish

Tomaremos nota de cada uno de los endpoints de la distribuciones de CloudFront de cada microfrontend.

Luego en el archivo fr-shell/src/index.ejs pueden configurar sus entornos, en mi caso solo tengo local y prod, por ese motivo es que le pondré un else y el valor sería el endpoint de la distribución de CloudFront que corresponda.

Una vez hecho el cambio haremos nuevamente un amplify publish sobre nuestro microfrontend fr-shell

Como necesitamos acceder a archivos distribuidos en CloudFront directamente en el código, debemos configurar los ajustes de CORS, para ello entraremos en cada distribución de CloudFront y haremos la siguiente configuración:

¡Listo! Podemos acceder a nuestros microfrontends desplegados, usando el endpoint de fr-shell. Teniendo el siguiente resultado

To cloud and beyond! 🚀

En el sitio web nos indica el funcionamiento de este servicio: “AWS Organizations le permite crear cuentas nuevas de AWS sin costo adicional. Con cuentas en la organización, puede asignar recursos, agrupar cuentas y aplicar políticas de gobernanza a cuentas o grupos fácilmente.”

Podemos crear cuentas para los distintos departamentos de una organización: TI, Marketing, Finanzas, etc; o bien podemos crear cuentas para entornos o proyectos: Producción, Desarrollo, Pruebas, etc. De esta manera podemos aprovechar algunas ventajas como:

• Los limites de servicio serán por cuenta y ya no serán compartidos entre los distintos proyectos dentro una cuenta en común

• Podemos establecer políticas de control de servicio (SCP) a nivel de cuenta para evitar ciertas acciones o creación de recursos de un servicio en particular o en una region en particular

• Podemos invitar cuentas que ya existen o bien podemos crear una cuenta ingresando el correo

• Podemos compartir recursos entre cuentas

• Podemos tener una mayor visibilidad sobre los gastos realizados por un departamento o proyecto, ya que los gastos se verán reflejados para esa cuenta en particular

• Facturación consolidada, podemos obtener descuentos al agrupar los costos de todas las cuentas

Fuente: https://docs.aws.amazon.com/organizations/latest/userguide/orgs_getting-started_concepts.html

Sabiendo todo esto, quise configurar mi cuenta de organización, anteriormente tenia mi cuenta principal con mi usuario root, el cual tenia el MFA habilitado y había creado un usuario con acceso administrador (y también con el MFA habilitado) el cual era el que usaba para ingresar a la consola o con sus credenciales de acceso realizar operaciones a través de AWS CLI. Pero esta vez, tendría mi organización con 2 cuentas: una para cada uno de los proyectos que estoy realizando. Hoy quiero compartir como fue que realice esta configuración:

1- Crear una cuenta de AWS

Para ello necesitamos un correo electrónico y una tarjeta de debito/crédito para poder registrarla.

En el caso de AWS cuando creamos una cuenta, ésta tiene una capa gratuita durante un año pero si en algún momento nos excedemos en algún servicio o usamos algún servicio no incluido en la capa gratuita ese monto se nos debitara de la tarjeta que hemos registrado.

Para evitar ello, es importante revisar que incluye esa capa gratuita,

https://aws.amazon.com/es/free/

Y para crear la cuenta, te dejo el enlace a la documentación oficial

https://aws.amazon.com/es/premiumsupport/knowledge-center/create-and-activate-aws-account/

2- Ir a AWS Organizations y crear nuestra estructura de organización

Para ello, con nuestro usuario root ingresaremos a la opción de Organización en el menu superior izquierdo

Una vez dentro, podremos ver mas información y enlace a la documentación de este servicio

Ingresaremos a la opción: Cuentas de AWS

Esta es mi estructura de organización que he creado, partimos de la raíz y podemos tener varias unidades organizativas (OU), que pueden ir anidadas, es decir podemos tener una OU dentro de otra OU.

Dentro de cada OU vamos a tener nuestras cuentas de AWS, una cuenta solo puede pertenecer a una OU a la vez.

Para crear una OU, basta con seleccionar el check de Root e ir al menú de Acciones

Una vez allí, ingresamos el nombre de la OU y la creamos.

Repetiremos el proceso tantas veces sea necesario.

Ahora el siguiente paso es agregar las cuentas de AWS a la OU que corresponda

3- Invitar una cuenta que ya existe

En este caso, si tenemos una cuenta de AWS que ya existe y queremos que sea parte de la organización podemos invitarla a formar parte.

Nota: Una cuenta de AWS solo puede pertenecer a una organización a la vez, si la cuenta que quieres agregar ya pertenece a otra organización, primero deberá retirarse de esa organización antes de pertenecer a la nueva organización

4 - Agregar una cuenta no existe

En este caso ingresaremos los datos que nos piden para crear la cuenta

Y al cabo de unos minutos nos llegará al correo ingresado un mensaje indicándonos que la cuenta ha sido creada

5- Trasladar una cuenta a una OU

Una vez tengamos listas nuestras cuentas necesitamos trasladarlas

Y seleccionamos la OU a la que pertenecer la cuenta

6 - Habilitar AWS Identity Center

Ahora debemos establecer los usuarios y permisos a las cuentas que hemos creado, para ello necesitamos ir al panel de AWS Identity Center y habilitar el servicio

Una vez habilitado, nos mostrará la URL por la cual accederemos para loguearnos. La cual si queremos la podemos personalizar.

7 - Conjunto de permisos

Los conjuntos de permisos definen el nivel de acceso que los usuarios del Centro de identidades de IAM tienen a las cuentas de AWS asignadas. Los nombres de los conjuntos de permisos aparecen como roles disponibles en el portal de acceso de AWS. Los usuarios asignadas a varios conjuntos de permisos de AWS pueden iniciar sesión en el portal de acceso de AWS, elegir una cuenta y, a continuación, elegir un rol que AWS haya creado a partir de un conjunto de permisos asignado. Más información

Para un usuario administrador:

Seleccionaremos el conjunto de permisos predefinido: AdministratorAccess

Hay otros permisos predefinidos que podemos usar según el caso

Establecemos el nombre del conjunto de permisos y la duración de la sesión

Para usuarios no administradores

Para mi caso, usaré el permiso predefinido: PowerUserAccess

Una vez creados los conjuntos de permisos, estos se aprovisionarán y estarán listos para usar

8 - Creación de usuarios

Estos usuarios pueden iniciar sesión en el portal de acceso de AWS para obtener acceso a las cuentas y aplicaciones en la nube de AWS asignadas.

Ingresamos los datos solicitados

En mi caso no he creado grupos, así que ire al siguiente paso

Verificamos que todo este bien y creamos el usuario

Cuando creamos un usuario, se envía un correo de verificación al correo del usuario creado

El cual nos pedirá establecer una contraseña

Ahora debemos habilitar el MFA del usuario, para lo cual entraremos en el detalle

Y seleccionaremos la opción de Registro MFA

Seguimos los pasos de acuerdo al tipo de dispositivo MFA que tengamos. Y una vez listo, nos pedirá cada vez que iniciemos sesión un código aleatorio además del usuario/contraseña

9 - Asignar usuarios a las cuentas que tendrán acceso

Seleccionamos una o más cuentas de AWS para el acceso de múltiples cuentas a usuarios

Luego seleccionamos el o los usuarios a agregar

Seleccionamos los permisos que tendrá ese usuario en esa cuenta

Revisamos y confirmamos

Para verificar el acceso iniciamos sesión en la URL proporcionada en el punto 6

Una vez ingresado los datos podremos ver las cuentas de AWS a las que tenemos acceso y en caso de tener mas de un tipo de permiso podremos elegir cual usar

Si ingresamos con la opción de consola de administración podremos observar en el desplegable del menu superior derecho información relacionada a nuestra cuenta

10 - Para la configuración de AWS CLI

Debemos tener instalado AWS CLI
https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html

Luego ejecutamos aws configure e ingresaremos los datos que nos provee AWS

Y listo, así podemos configurar un entorno multicuenta con AWS Organizations, estableciendo usuarios y permisos para estas cuentas con AWS Identity Center

Más información:

https://docs.aws.amazon.com/organizations/latest/userguide/orgs_tutorials_basic.html

Recuerdo que vi un curso de Cloud Essentials donde explicaban los conceptos de la tecnología en la nube y algunos de los servicios de AWS haciendo referencia al funcionamiento de una cafetería, el cual me ayudo muchísimo a comprender todos esos conceptos.

Descubriendo los AWS User Groups

Seguí buscando más información y material para leer, y fue así como descubrí los AWS User Groups que están presentes en muchísimos países como Perú y además había una comunidad de AWS Girls Perú ahí fue cuando quede completamente enamorada, porque chicas como yo que les gustaba la tecnología habían armado una comunidad y daban charlas sobre tecnología en la nube y los distintos servicios de AWS en nuestro idioma: español.

Empece a seguir los AWS User Groups en las redes sociales, en ese entonces debido al confinamiento los eventos eran online por lo que podía asistir sin problemas de horario y ver también los eventos pasados. También descubrí las comunidades de AWS Girls Women Colombia y AWS Girls Chile que también daban sus charlas de manera remota.

Descubrí las certificaciones que ofrece AWS y la vi como una oportunidad de darle un impulso a mi carrera, aprender sobre una tecnología que me gustaba mucho y que cada vez es mas demandada por las empresas. Así que me puse a investigar un poco mas sobre ellas, inicialmente quería presentar la certificación Developer Associate porque estaba mas relacionada con mis tareas del día a día (soy desarrolladora de software) pero la realidad era que no tenia experiencia en la nube de AWS y en ninguna otra, por lo que preferí presentar primero el examen de certificación Cloud Practitioner.

Preparándome para la certificación: Cloud Practitioner

Para este examen de certificación aun no tenia el voucher comprado, pero empece a estudiar como si ya lo hubiese agendado (esto fue a finales del 2021), me registre en la plataforma de SkillBuilder con mi correo personal y empece a llevar los cursos recomendados para el examen, también estuve revisando la playlist de las comunidades de AWS Girls Peru y AWS Girls Women Colombia.

Luego a inicios del 2022, en mi empresa nos avisan de una capacitación que estaba ofreciendo AWS y que podíamos acceder por ser partner de ellos, el Rocket Journey un programa intensivo de 4 semanas que nos capacitaba y brindaba material de apoyo para lograr la certificación de Cloud Practitioner junto con otras mas.

Ahí descubrí que si me registraba a AWS SkillBuilder con mi correo corporativo tenia acceso a mas cursos que no tenia acceso con mi cuenta personal y por si fuera poco, al final del Rocket Journey darían 120 vouchers a las personas con la mejor puntuación en una actividad que habían en la semana final (yo aun no tenia el voucher para el examen de certificación) así que sentí que mi momento había llegado y debía darlo todo para ser una de las 120 beneficiadas 💪

Y así fue, gracias a Dios conseguí estar dentro de los 120. A los pocos días me llego el voucher a mi correo y agendé mi examen semanas después y logre pasarlo (Abril 2022) para este examen se necesitaba una nota de 70% o mas para aprobar. Había logrado mi primera certificación y estaba muy emocionada, había aprendido tantas cosas y sentía la necesidad de seguir aprendiendo mas, esta vez me prepararía para mi siguiente examen: Architect Associate.

Preparándome para la certificación: Solution Architect Associate

En la búsqueda de información encontré un programa que busca darle oportunidades a las mujeres en el mundo cloud de AWS, asi fue como me tope con el programa de AWS CloudUp for her (antes AWS She Builds), un programa de entrenamiento que esta disponible en 2 versiones: para la certificación Cloud Practioner y para la certificación Architect Associate. Me registre y espere la próxima fecha de inicio. Este programa ofrece no solo entrenamiento para el examen sino que también te da la posibilidad de obtener un voucher de certificación si apruebas un examen de practica con mas de 80%. Yo ya venia de aprobar mi examen de Cloud Practitioner y por aprobar cualquiera de los exámenes de certificación AWS te brinda un código de descuento del 50% para que lo puedas usar ya sea para tu próxima certificación o para revalidar la que tienes (ya que tienen una duración de 3 años).

Aunque el contenido del programa estaba en ingles y los horarios de las charlas no siempre se ajustaban a mi zona horaria, hacia lo posible por asistir mientras continuaba estudiando con otros recursos por mi cuenta.

Ciertamente, el contenido de esta certificación era más extenso, debías conocer al detalle más servicios y también ganar experiencia practica en la consola. Ya tenia un background de redes de mi época universitaria que me toca desempolvar de mi mente y lo cual lo hizo mas llevadero, pero ciertamente el realizar laboratorios y talleres prácticos ayudaban a afianzar los conocimientos. También empece a tomar notas que en algunos casos iban acompañados de gráficos y tips de los servicios que iba a aprendiendo.

Durante este proceso me integre a 2 comunidades: AWS Girls Perú y AWS Girls Chile, con el grupo de AWS Girls Perú tuve la oportunidad de asistir a sus eventos presenciales y así poder conocer a otras chicas que como yo tienen esa misma pasión por la tecnología en la nube y los servicios de AWS; con el grupo de AWS Girls Chile aunque hay una distancia de muchos kilómetros hicimos match de inmediato y formamos también una bonita comunidad en la que intercambiamos ideas, recursos y materiales de estudio.

A finales de agosto (2022) presente y aprobé mi examen. Mas que feliz por lo logrado, y ya con la siguiente meta trazada: mi examen de Developer Associate, del cual ya escribí una entrada de cómo me prepare y de los recursos que tome que pueden consultar en este enlace.

Mi primera charla en la comunidad

Si hay un tema que me ha gustado mucho desde que empece mi camino a la nube ha sido: Serveless (del que hablare en otro post para no hacer este demasiado extenso)

Surgió la oportunidad de dar una charla virtual desde la comunidad de AWS Girls Chile, así que quise hablar de Lambda y Event Bridge. Acá les dejo el video de la charla.

Compartir tus conocimientos en comunidad es una oportunidad maravillosa de seguir aprendiendo, porque siempre he pensado que la mejor manera de aprender es enseñando a los demás y en ese proceso ambas partes aprenden y no solo la que enseña)

Ser parte de las comunidades y ser ponente en las charlas o asistir a los eventos presenciales, te da la oportunidad de hacerte visible y generar mas networking, en mi caso me ofrecieron la oportunidad de ser instructora del programa de AWS re/start (luego creare una entrada para hablar mas al respecto)

Me ofrecieron ser parte del team organizador de AWS Girls Perú

Empece este año (2023) celebrando con mi familia haber pasado mi examen de Developer Associate y justo ese mismo día, me invitan a formar parte del team organizador de la comunidad de AWS Girls Perú dije: sí! sin dudarlo, me gusta ser parte de la comunidad y me gusta el poder motivar a otras personas a que empiecen su camino en la nube.

Así que iniciamos este 2023 llenas de energía y coordinando lo que fue nuestro primer evento del año. Acá les dejo el video

Se vienen muchas actividades para la comunidad que ya iremos informando en nuestras redes.

¿Palabras finales?

Escribir esta entrada del blog me ha emocionado al ver hacia atrás y ver dónde estoy ahora. Emocionada de ver todo lo que se viene y de hacer lo que me gusta y me apasiona.

Si por ahí estas queriendo empezar tu camino en la nube, adelante, hazlo! Hay un montón de comunidades y personas dispuestas a ayudarte en el proceso.

AWS Application Composer

Uno de esos servicios nuevos llamo mi atencion: AWS Application Composer (https://docs.aws.amazon.com/application-composer/latest/dg/what-is-composer.html ), un servicio que permite desde una interfaz Drag-and-Drop arrastrar y soltar distintos servicios asi como interconectarlos para poder crear una arquitectura cloud serverless, entregando el código en cloudformation.

De esta manera podemos concentrarnos en diseñar nuestra arquitectura y dejar que Application Composer construya cómo se logra, sin necesidad de ser un experto en AWS CloudFormation.

Podemos usarlo creando un proyecto de cero o cargando uno ya existente, en ambos casos tenemos 2 modos disponibles: conectados o no conectados,si elegimos el estado conectado los cambios que hagamos en las fuentes se verán reflejados en AWS Application Composer y viceversa, los cambios realizados en AWS Application Composer se reflejarán en el código fuente de nuestra aplicación.

Después de diseñar la aplicación serverless con AWS Application Composer, podemos usar cualquier servicio compatible con AWS CloudFormation para la implementación.

En mi caso, utilice: AWS SAM, que me permite realizar depuración y pruebas locales, así como ayudarme con el empaquetado y despliegue de mi aplicación.

La aplicación que desarrollé es un servicio de procesamiento de video. Para ello emplee un servicio que me ayuda con esta tarea que es AWS Elemental MediaConvert (https://aws.amazon.com/es/mediaconvert/) que funciona tomando un video como entrada y, transcodificando el video a una o más versiones diferentes y luego coloca estas versiones en otro bucket S3.

Para hacer la aplicación serverless, utilice un bucket S3 en donde se cargan los archivos a procesar, cada vez que se detectaba el evento cuando se cargaba un video al bucket, éste se enviaba a una cola SQS que era consumida por una función Lambda (está basada en NodeJS versión 18) que se encarga de llamar a AWS Elemental MediaConvert para el procesamiento del video.

Manos a la obra!

1- Configuración de AWS CLI

Necesitamos configurar AWS CLI en nuestro entorno local.

http://docs.aws.amazon.com/cli/latest/userguide/installing.html

Tenemos que tener nuestras credenciales de seguridad (Access keys)

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html#Using_CreateAccessKey_CLIAPI

Luego ejecutamos desde una terminal en su sistema:

aws configure

La CLI de AWS solicita varias cosas:

Las credenciales de usuario (Access keys)

La región que usaremos: us-east-1

El formato de salida predeterminado: json.

2 - Obtener el endpoint de la API de MediaConvert

Para ello iremos al panel del AWS Elemental MediaConvert y luego iremos al menú lateral izquierdo en la sección Account, este endpoint lo usaremos para una variable de entorno de nuestra función lambda

3- Crear un rol: media-convert-role

Necesitamos crear un rol para nuestra función lambda, MediaConvert necesita tener acceso a S3, así como a API Gateway. Sin esta función, MediaConvert simplemente no se ejecutará cuando intente invocarlo desde Lambda.

Iremos al panel IAM y luego a Roles, haremos clic en Crear rol

Seleccionamos AWS Service y luego en el select buscamos MediaConvert, clic en el botón Siguiente

AWS ya ha predefinido qué políticas necesita para este rol.

Elegimos Siguiente

Establecemos el nombre

Asigne a su función el nombre media-convert-role y luego haga clic en Crear rol.

Necesitaremos el ARN del rol para una variable de entorno de nuestra función lambda.

4 - Bucket de carga de videos a procesar

Desde AWS Application Composer tenemos el primer bucket que es donde se cargaran los videos a procesar, el nombre de este bucket por defecto es el nombre de nuestra pila o stack junto con el número de nuestra cuenta de AWS:

BucketName: !Sub ${AWS::StackName}-bucket-${AWS::AccountId}

Lo podemos encontrar en la pestaña Template o bien desde nuestras fuentes en template.yaml y buscar dentro de recursos a nuestro Bucket, podemos cambiarlo a otro nombre de nuestra preferencia.

5- Nuestra cola SQS

Cada vez que un video se cargue al bucket S3 definido en el paso 4, este evento es enviado a una cola SQS que se creará cuando despleguemos nuestro proyecto.

6- La función Lambda

En el caso de nuestra función Lambda podemos indicar varios parámetros dentro de AWS Application Composer, seleccionando el elemento y luego la opción Details que mostrará más opciones en el lateral derecho de la pantalla

Podemos especificar el runtime de nuestra Lambda, así como la ubicación del código de nuestra función (src/Function) y el método que se ejecuta cuando nuestra función es invocada (index.handler)

También podemos especificar otros valores desde esta pantalla, como es el caso de las políticas de permisos:

Version: '2012-10-17'

Statement:

- Effect: Allow

Action:

- iam:GetRole

- iam:PassRole

- mediaconvert:*

Resource: arn:aws:iam::619747668685:role/media-convert-role

Y también las variables de entorno que necesitamos especificar:

• MEDIA_ENDPOINT: el endpoint de mediaConvert

• MEDIA_ROLE: el ARN del rol previamente creado

• TRANSCODED_VIDEO_BUCKET: el nombre de nuestro bucket de salida donde almacenaremos los videos procesador por MediaConvert

Todas las modificaciones que hagamos desde AWS Application Composer las veremos reflejadas en nuestro archivo local template.yaml

También debemos definir nuestro rol para la función lambda: aws-sam-lambda-role

El cual haremos referencia en nuestro archivo local template.yaml

El código fuente de la función lambda es:

'use strict';

const AWS = require('aws-sdk')

// Obtiene el valor de la variable de entorno MEDIA_ENDPOINT que está configurada en template.yml
const mediaConvert = new AWS.MediaConvert({
    endpoint: process.env.MEDIA_ENDPOINT
});
// Obtiene el nombre del bucket donde se enviaran los videos procesados de la variable de entorno TRANSCODED_VIDEO_BUCKET que está configurada en template.yml
const outputBucketName = process.env.TRANSCODED_VIDEO_BUCKET;

exports.handler = async (event) => {

    const s3Event = JSON.parse(event.Records[0].body)

    try {
        const key = s3Event.Records[0].s3.object.key;
        const sourceKey = decodeURIComponent(key.replace(/\+/g, ' '));
        const outputKey = sourceKey.split('.')[0];

        // Establece la ubicación del video de entrada para la definición de trabajo de MediaConvert
        const input = 's3://' + s3Event.Records[0].s3.bucket.name + '/' + key;

        // Create S3 service object
        const outputBucket = new AWS.S3({apiVersion: '2006-03-01'});

        // Create the parameters for calling createBucket
        var bucketParams = {
          Bucket : outputBucketName
        };

        // call S3 to create the bucket
        outputBucket.createBucket(bucketParams, function(err, data) {
          if (err) {
            console.log("Error", err);
          } else {
            console.log("Success", data.Location);
          }
        });

        // Establece el bucket de salida para los nuevos archivos de video
        const output = 's3://' + outputBucketName + '/' + outputKey + '/';


        const job = {
          //  Obtiene el ARN del rol MediaConvert que se especifica en template.yml
            "Role": process.env.MEDIA_ROLE,
            "Settings": {
                "Inputs": [{
                    "FileInput": input,
                    // Especifica el selector de audio para la definición de trabajo de MediaConvert. De manera predeterminada, nombrará una sola pista de audio en el video.
                    "AudioSelectors": {
                        "Audio Selector 1": {
                            "SelectorType": "TRACK",
                            "Tracks": [1]
                        }
                    }
                }],
                "OutputGroups": [{
                    "Name": "File Group",
                    "Outputs": [{
                        "Preset": "System-Generic_Hd_Mp4_Avc_Aac_16x9_1920x1080p_24Hz_6Mbps",
                        "Extension": "mp4",
                        "NameModifier": "_16x9_1920x1080p_24Hz_6Mbps"
                    }, {
                        "Preset": "System-Generic_Hd_Mp4_Avc_Aac_16x9_1280x720p_24Hz_4.5Mbps",
                        "Extension": "mp4",
                        "NameModifier": "_16x9_1280x720p_24Hz_4.5Mbps"
                    }, {
                        "Preset": "System-Generic_Sd_Mp4_Avc_Aac_4x3_640x480p_24Hz_1.5Mbps",
                        "Extension": "mp4",
                        "NameModifier": "_4x3_640x480p_24Hz_1.5Mbps"
                    }],
                    "OutputGroupSettings": {
                        "Type": "FILE_GROUP_SETTINGS",
                        "FileGroupSettings": {
                            "Destination": output
                        }
                    }
                }]
            }
        };

        const mediaConvertResult = await mediaConvert.createJob(job).promise();
        console.log('mediaConvertResult ' , mediaConvertResult);

    } catch (error) {
        console.error(error);
    }
};

Nuestra función lambda utiliza AWS SDK por lo que necesitamos agregar dicha dependencia dentro de nuestro package.json.

{
  "name": "function",
  "version": "1.0.0",
  "devDependencies": {
    "aws-sdk": "^2.1270.0"
  }
}

Y luego de ello ejecutar npm i dentro de la carpeta donde su ubica este archivo src/Function/ y debemos agregar unas líneas a nuestro template.yaml.

Quedando finalmente así:

Resources:
  Bucket:
    Type: AWS::S3::Bucket
    Properties:
      BucketName: !Sub ${AWS::StackName}-alfalfita-cloud-bucket-${AWS::AccountId}
      BucketEncryption:
        ServerSideEncryptionConfiguration:
          - ServerSideEncryptionByDefault:
              SSEAlgorithm: aws:kms
              KMSMasterKeyID: alias/aws/s3
      PublicAccessBlockConfiguration:
        IgnorePublicAcls: true
        RestrictPublicBuckets: true
      NotificationConfiguration:
        QueueConfigurations:
          - Event: s3:ObjectCreated:*
            Queue: !GetAtt Queue.Arn
          - Event: s3:ObjectRemoved:*
            Queue: !GetAtt Queue.Arn
    DependsOn:
      - BucketToQueuePermission
  BucketBucketPolicy:
    Type: AWS::S3::BucketPolicy
    Properties:
      Bucket: !Ref Bucket
      PolicyDocument:
        Id: RequireEncryptionInTransit
        Version: '2012-10-17'
        Statement:
          - Principal: '*'
            Action: '*'
            Effect: Deny
            Resource:
              - !GetAtt Bucket.Arn
              - !Sub ${Bucket.Arn}/*
            Condition:
              Bool:
                aws:SecureTransport: 'false'
  Queue:
    Type: AWS::SQS::Queue
  BucketToQueuePermission:
    Type: AWS::SQS::QueuePolicy
    Properties:
      PolicyDocument:
        Version: '2012-10-17'
        Statement:
          - Effect: Allow
            Principal:
              Service: s3.amazonaws.com
            Action: sqs:SendMessage
            Resource: !GetAtt Queue.Arn
            Condition:
              ArnEquals:
                aws:SourceArn: !Sub arn:${AWS::Partition}:s3:::${AWS::StackName}-alfalfita-cloud-bucket-${AWS::AccountId}
      Queues:
        - !Ref Queue
  Function:
    Type: AWS::Serverless::Function
    Properties:
      Description: !Sub
        - Stack ${AWS::StackName} Function ${ResourceName}
        - ResourceName: Function
      CodeUri: src/Function
      Handler: index.handler
      Role: arn:aws:iam::619747668685:role/aws-sam-lambda-role
      Runtime: nodejs18.x
      MemorySize: 3008
      Timeout: 30
      Tracing: Active
      Events:
        Queue:
          Type: SQS
          Properties:
            Queue: !GetAtt Queue.Arn
            BatchSize: 1
      Environment:
        Variables:
          MEDIA_ENDPOINT: https://lxlxpswfb.mediaconvert.us-east-1.amazonaws.com
          MEDIA_ROLE: arn:aws:iam::619747668685:role/media-convert-role
          TRANSCODED_VIDEO_BUCKET: serverless-video-transcoded-alfalfita-cloud-06122022
      Policies:
        Version: '2012-10-17'
        Statement:
          - Effect: Allow
            Action:
              - iam:GetRole
              - iam:PassRole
              - mediaconvert:*
            Resource: arn:aws:iam::619747668685:role/media-convert-role
    Metadata:
      BuildProperties:
        UseNpmCi: true
  FunctionLogGroup:
    Type: AWS::Logs::LogGroup
    DeletionPolicy: Retain
    Properties:
      LogGroupName: !Sub /aws/lambda/${Function}
Transform: AWS::Serverless-2016-10-31

Para más información:

https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-using-build.html

6 - Instalar AWS SAM CLI

Para prepararnos para desplegar nuestra aplicación en la nube, necesitamos un servicio compatible con Cloudformation para la implementación, en este caso AWS SAM, la documentación para la instalación la podemos encontrar en:

https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/install-sam-cli.html

Una vez instalado AWS SAM CLI podemos usarlo desde la terminal, con los diversos comandos que proporciona

Ejecutamos primero sam-build

Y luego preparamos el despliegue guiado que nos permitirá establecer ciertos valores:

Confirmamos los cambios, y veremos como los recursos se irán creando:

Confirmamos que la pila existe en el panel de CloudFormation

Ahora probamos nuestra función, subiendo un video al bucket S3

Veremos que tendremos un nuevo bucket donde encontraremos diversos formatos de nuestro video original

AWS Elemental MediaConvert: https://docs.aws.amazon.com/mediaconvert/index.html

El repositorio con la solución lo encuentras en:

https://github.com/alfalfita/decoder-video-with-sam-and-lambda

Para esta solución usaremos:

• ReactJS

• Amazon S3

• Amazon CloudFront

• AWS Lambda

• AWS CLI

• SAM CLI

Utilizaremos SAM CLI para construir nuestra aplicación a través de una plantilla de CloudFormation para crear los recursos necesarios en la nube y de esta manera tener también una plantilla que puede ser reutilizada en otros proyectos.

Empezaremos creando nuestro proyecto de ReactJS. Para ello necesitamos tener instalado Node >= 14.0.0 y npm >= 5.6.

¿Cómo crear una aplicación con React?

Una vez creado nuestro proyecto en la raíz del mismo crearemos un archivo template.yaml que sera nuestro template de CloudFormation que desplegaremos usando SAM CLI.

CODIGO

AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: >
  Sitio web con AWS SAM

Parameters:
  DomainName:
    Type: String
    Description: "Nombre de dominio"
  IndexDocument:
    Type: String
    Description: "Documento index"
    Default: "index.html"

Resources:
  CloudFrontOriginAccessIdentity:
    Type: 'AWS::CloudFront::CloudFrontOriginAccessIdentity'
    Properties:
      CloudFrontOriginAccessIdentityConfig:
        Comment: 'Desplegando un sitio web con AWS SAM'

  S3Bucket:
    Type: AWS::S3::Bucket
    Properties:
      BucketName: !Ref DomainName

  S3BucketPolicy:
    Type: AWS::S3::BucketPolicy
    Properties:
      Bucket: !Ref S3Bucket
      PolicyDocument:
        Statement:
          - Effect: Allow
            Action: 's3:GetObject'
            Resource:
              - !Sub "arn:aws:s3:::${S3Bucket}/*"
            Principal:
              AWS: !Sub "arn:aws:iam::cloudfront:user/CloudFront Origin Access Identity ${CloudFrontOriginAccessIdentity}"

  CloudfrontDistribution:
    Type: "AWS::CloudFront::Distribution"
    Properties:
      DistributionConfig:
        Comment: "Distribucion de Cloudfront"
        DefaultRootObject: "index.html"
        Enabled: true
        HttpVersion: http2
        Origins:
          - Id: s3-website
            DomainName: !Sub "${S3Bucket}.s3.${AWS::Region}.amazonaws.com"
            S3OriginConfig:
              OriginAccessIdentity:
                Fn::Sub: 'origin-access-identity/cloudfront/${CloudFrontOriginAccessIdentity}'
        DefaultCacheBehavior:
          Compress: 'true'
          AllowedMethods:
            - GET
            - HEAD
            - OPTIONS
          ForwardedValues:
            QueryString: false
          TargetOriginId: s3-website
          ViewerProtocolPolicy : redirect-to-https

Outputs:
  BucketName:
    Description: "Nombre del bucket"
    Value: !Ref S3Bucket
  CloudFrontDistribution:
    Description: "ID de la distribucion de CloudFormation"
    Value: !Ref CloudfrontDistribution
  WebsiteUrl:
    Description: "Sitio web"
    Value: !Sub "https://${DomainName}/"

Esta plantilla nos permitirá crear los siguientes servicios:

• CloudFrontOriginAccessIdentity: no necesitamos otorgar acceso al publico al bucket S3 directamente ni habilitar el alojamiento de sitios web usando una OriginAccessIdentity, en su lugar podemos conectar nuestro bucket S3 con CloudFront, la manera más segura para dirigir el acceso a los archivos del bucket a las solicitudes que llegan a través de CloudFront.

  Más información: https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/private-content-restricting-access-to-s3.html

  https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/quickref-cloudfront.html

• S3Bucket: nuestro bucket de S3 donde subiremos nuestra carpeta build del proyecto.

• S3BucketPolicy: política que define quién puede acceder y qué tipo de operaciones se permiten en el bucket. Aquí restringimos con OriginAccessIdentity el acceso de lectura solo a CloudFront.

• CloudFrontDistribution: distribución de CloudFront para indicar a CloudFront desde dónde desea enviar el contenido y los detalles acerca de cómo realizar un seguimiento y administrar la entrega de contenido con baja latencia a nivel mundial.

Implementación de la solución

• Primero necesitamos generar el build de nuestro proyecto ReactJS. Para ello ejecutamos el siguiente comando en la raíz del proyecto donde esta ubicado el archivo package.json

  npm run build

• Esto generará una carpeta con el compilado de nuestra solución que subiremos luego a nuestro bucket S3 usando AWS CLI

• Ahora necesitamos desplegar nuestra plantilla de CloudFormation para que se creen los recursos en nuestra cuenta de AWS en la nube

• Para ello ejecutamos el siguiente comando en la raíz de nuestro proyecto donde tenemos el archivo template.yaml

  sam build

  

Luego para el despliegue, ejecutamos el siguiente comando y completamos la información solicitada:

sam deploy --guided

Veremos que los recursos que definimos en nuestra plantilla se empezarán a crear. La distribución de CloudFront llevará al inicio algo de tiempo completar, una vez completada la implementación, tendrá un nombre de dominio generado por AWS con el formato d3ue2ep9txxx01.cloudfront.net que usaremos para realizar nuestra solicitud al sitio web.

Ahora debemos subir el contenido de nuestra carpeta build del proyecto de ReactJS al bucket podemos usar el comando :

aws s3 sync ./build s3://my-bucket-with-oac

Una vez que se carguen los archivos, deberíamos poder ver en nombre de dominio de Cloudfront nuestro sitio web

https://d3ue2ep9txxx01.cloudfront.net/

Ahora nos queda pendiente la opción de invalidar la distribución de CloudFront (que veremos en otra entrada) cuando se detecten cambios en el bucket S3, para ello utilizaremos una función lambda que nos ayudará con ese trabajo.

Nota:

En ocasiones me sucedia, que al deployar los cambios estos no se veian reflejados. Por lo que tenia que ejecutar este comando para forzar la actualización

sam deploy --force-upload

Enlace al repositorio github con las fuentes

Ahora voy en busca de mi tercera certificación: Developer - Associate, algunas compañeras me han comentado que tanto la certificación de arquitecto como la de developer tienen temas en común, que por ahí quizás primero pude haber tomado la de developer y luego la de arquitecto, pero en fin, supongo que el orden de los productos no altera el resultado.

Empezando esta nueva ruta de estudios, ya tengo algunos materiales/cursos que he ido adquiriendo (y que use para prepararme para las anteriores certificaciones) y quiero compartir con ustedes cuales son:

• Empezando con la guía del examen, que nos permitirá tener un abreboca de la certificación y conocer que es lo que nos van a evaluar y que porcentaje tiene cada tema

Guía del examen

Luego tomo un par de cursos, en este punto (y muy a criterio de cada uno) suelo hacer apuntes, porque es muchísima la información que estamos por ver, muchísimos servicios y términos que probablemente sean nuevos, los apuntes nos ayudan a luego poder echar un vistazo rápido a ellos sin tener que irnos a buscar el video X en el minuto Z"Y. Ademas que cuando tomas apuntes refuerzas lo que aprendes, porque le das tu propia interpretación y puedes tomar nota de esos tips que siempre están presentes.

• El curso de Udemy de Stephane Maarek . Esta en inglés pero tienes opción de ponerle subtítulos, un curso bien estructurado, que combina los conceptos teóricos con la practica y adicional un conjunto de preguntas para evaluar lo que vas aprendiendo.

• El curso de Adrian Cantrill , un curso para poner en practica aplicando los conceptos a un ejemplo de la vida real, también refuerzo los temas del curso anterior y me ayuda a complementar mi estudio

• El libro AWS Certified Developer Official Study Guide: Associate (DVA-C01) Exam, a pesar que es del año 2019, nos ayuda a leer con mayor profundidad de los temas, algunas imágenes ya quedan desfasadas por el cambio de UI de la consola de AWS pero igual es un buen complemento.

• El sitio web de Skillbuilder, proporciona una gran cantidad de recursos entre videos, labs, juegos interactivos (Cloud Quest) para reforzar aún más el conocimiento. Y por si fuera, si en tu caso la empresa para la que trabajas es Partner de AWS, podrás acceder a más materiales, inclusive a cursos en vivo que ayudarán a obtener la certificación. En ocasiones AWS lanza cursos de preparación para Partners de AWS para las certificaciones que suelen durar varias semanas y te van haciendo acompañamiento, enviando material y videos sugeridos para complementar tu formación.

• El set de exámenes de Neal Davis aquí me concentro en las preguntas que explican las respuestas, y busco leer tanto las respuestas buenas como malas, a la vez que me ayuda a identificar los temas que debo repasar.

• El set de exámenes de Tutoriales Dojo un set bastante completo. Suelo empezar con un test antes de iniciar con los cursos de teoría/practica. Esto me ayuda a ver mis resultados antes de mi preparación y luego al terminar los cursos (1 y 2) vuelvo a hacerlo para evaluar si mejore. Una vez que hago eso, procuro realizar 2 exámenes a la semana (dependiendo de cuanto tiempo me queda para presentar el examen puede ser mas)

• El set de exámenes de Whizlasbs, otro abanico de preguntas para complementar los test de Tutoriales Dojo.

Respecto a los exámenes de practica, no suelo repetirlos en un tiempo corto, pero si anoto los temas en los que veo que siempre fallo y también trato de identificar cuales son los servicios que mas preguntan, de esa lista de servicios me leo los FAQ's.

El link de los FAQ's de los servicios de AWS suele tener este formato:

https://aws.amazon.com/es/**nombreServicio**/faqs/

Leerlos te ayuda a conocer mas sobre los servicios y algunos datos o características particulares que te pueden preguntar en el examen

Una vez que termine con los cursos, el libro, las FAQ's y he practicado varios exámenes de practica, debería poder lograr una puntuación mayor a 80% en todos los casos, si aún no lo alcanzo entonces debo detenerme ver en que estoy fallando y buscar mas información al respecto (que me despeje las dudas que tengo). Una vez que me alcance y supere el 80% en los exámenes de practica, estamos listos para presentar el examen de certificación. Si aún no lo obtengo y se acerca la fecha de examen que agende, entonces lo mejor será reprogramarlo hasta que me sienta segura.

El día antes del examen, suelo practicar un par de exámenes y es todo, para el día del examen no reviso ningún material más para no sobrecargarme. Trato de descansar bien, y alimentarme bien para ir con muchas energías a presentar el examen.

Para conocer más sobre el examen de certificación, visite: https://aws.amazon.com/es/certification/certified-developer-associate/

Aprenda a diseñar arquitecturas resilientes, de alto rendimiento, seguras y rentables en la nube de AWS.

Si te estás preparando para el examen AWS Certified Solutions Architect - Associate (SAA-C03), o simplemente desea comprender mejor la arquitectura en AWS, esta opción es para usted.

Aprende en un entorno divertido, gratuito e interactivo. Haga sus preguntas en vivo en el chat para interactuar con los anfitriones y la comunidad. O use el hashtag #AWSPowerHour y etiquete a su anfitrión @trevorspires en LinkedIn. ¡Él buscará interactuar contigo!

Serán 6 episodios, desde este link encontrarás la fecha y hora en la que debes conectarte. ¡No olvides agendarlo!

Hoy quiero hablarte de dos programas: el programa acelerador de SAA el cual fue esencial para que aprobará el examen. Es un programa disponible para los socios (partners) de AWS, un programa de capacitación de 7 semanas y sesiones de revisión en línea dirigidas por entrenadores de AWS para ayudarlo a aprobar el examen. El entrenamiento es en inglés pero puedes acceder luego a las clases grabadas en caso necesites repasar el contenido.

El programa arranca el lunes 26 de septiembre y puedes inscribirte aquí:

https://mpa-saa-accelerator.splashthat.com/

Otro programa que también arranca este mes es el Rocket Journey: Solutions Architect - Associate, un programa de capacitación de 7 semanas también para los socios (partners) de AWS, destinado a una audiencia en español.

El programa arranca el viernes 9 de septiembre y puedes inscribirte aquí:

https://rocket-journey-saa-spa.splashthat.com/

Si tienes la oportunidad de inscribirte, aprovecha la oportunidad 🚀

Comprender lo que implica poner en marcha un sitio web o cualquier otra aplicación o carga de trabajo vs. utilizar la nube para llevar a cabo ese trabajo, nos permitirá tener un mejor entendimiento de los servicios que nos proporciona AWS.

En esta ocasión estaremos hablando de algunos servicios de cómputo de AWS como: EC2, ECS y Lambda, veremos también algunos conceptos claves de éstos servicios con algunos ejemplos para hacer más fácil su compresión.

¿Quizás a más de uno le ha pasado que ha dejado corriendo una instancia EC2 y olvido apagarla? 💸

Ahora imagina que tienes corriendo no 1 sino varias instancias EC2 con las que tu equipo trabaja semana tras semana, eso se traduce en 168 horas semanales, en un horario laboral digamos de unas 10 horas (LUN-VIE de 8:30 am a 6:30 pm) menos de la mitad de las horas son donde realmente se hace uso de esas instancias.

Y si te digo que podemos iniciar y detener las instancias EC2 en función de las etiquetas (tags) para ahorrar costos de hasta un 70% en instancias que solo son necesarias durante ese u otro horario laboral (utilización semanal reducida de 168 horas a ~50 horas).

Para lograr vamos a hacer uso de funciones lambda para programarlo en función de las horas de trabajo.

Pero ¿qué es Lambda?

Con serverless no necesitas aprovisionar infraestructura, ni hacer mantenimiento, ni ocuparte del autoescalado. Es altamente disponible y seguro. Serverless no solo es para computo, puede ser para base de datos, almacenamiento u otros servicios

• Es una de las opciones de computo que nos ofrece AWS, en este caso una opción serverless

• La unidad de escala es una función y el nivel de abstracción es un runtime

• Configuramos el código para que se ejecute cuando lo necesite (a demanda) en base por ejemplo a ciertos eventos.

• Su modelo de pago es por uso (ms) de acuerdo al tiempo de ejecución de la función lambda con incrementos de 1 ms

y ¿qué es EventBridge?

La versión 2 de Amazon CloudWatch Events

• Facilita la creación de aplicaciones basadas en eventos a escala mediante eventos generados

• Puede configurar reglas de enrutamiento para determinar a dónde enviar los datos

• Cuenta con un bus de evento por defecto (en CloudWatch Events tiene solo un bus)

• Puede tener buses de eventos adicionales

CRON

• Cron es un programa de utilidad de Unix que se utiliza para ejecutar comandos o scripts programados.

• Con una expresión cron, puede definir una regla que se active a una hora especificada de un determinado día de cada semana o mes

• Las expresiones Cron tienen seis campos obligatorios, que están separados por un espacio en blanco.

¡Manos a la obra!

¿Qué necesitamos?

1. Crear una política y un rol de ejecución de AWS Identity and Access Management (IAM) personalizados **para la función Lambda **

2. Crear las funciones Lambda que detengan e inicien las instancias de EC2 en base al tag de la instancia

3. Probar las funciones Lambda

4. Crear reglas de EventBridge que desencadenen la función en un horario.

En este video junto a la comunidad de AWS Girls Chile, les explico el paso a paso de la solución 😊

La actividad de 3 horas de duración te permitirá acumular puntos conforme vayas resolviendo lols desafíos. El ganador obtendrá como premio un viaje todo pagado al AWS re:Invent Las Vegas 2022!

https://pages.awscloud.com/GLOBAL-gamedev-OE-AWS-GameDay-WorldChampionship-2022-reg-event.html#form

¿Qué esperas para participar ?

Saludos,

Diana