¿Qué aprenderá?

• El uso de AWS y Terraform para facilitar el aprovisionamiento y despliegue de una aplicación modernizada que convive con software legado. Adicionalmente, revisará cómo se reporta un post-experimento.

¿Qué hará?

• El despliegue de la arquitectura que se definió en el pre-experimento Day Trader sobre el proveedor de nube AWS. Recordemos que en dicho pre-experimento se reporta un diseño detallado y una infraestructura computacional para la app. modernizada (la cual hemos colocado en la figura que sigue a manera de recordatorio). Además, se explicó el código Node.js del nuevo order-service y las modificaciones que debieron hacerse en el Daytrader legado para lograr que se comunicara con order-service a través de colas de mensajería.

Figure 1. Infraestructura computacional del experimento.

¿Cuáles son los prerrequisitos?

• Conocimiento previo del pre-experimento DayTrader
• Conocimientos básicos de AWS
• Acceso al Learner Lab de AWS Academy
• Conocimientos básicos de Terraform
• Conocimiento básicos de Git

En el tutorial se automatiza el aprovisionamiento de la infraestructura computacional, planteada en el pre-experimento, sobre AWS Learner Lab usando Terraform. Adicionalmente, se despliega la app. modernizada en Beanstalk y el Day Trader legado en la máquina del estudiante. Seguidamente, se hace una demostración de la app. modernizada a través de un video. El tutorial cierra con el post-experimento Day Trader.

Ingrese a AWS Academy con sus credenciales y luego escoja el curso "Learner Lab...". En "Modules>>Laboratorio de aprendizaje" inicie el laboratorio con el botón "Start lab", esto abrirá la terminal:

Al dar clic en el botón "AWS Details">> "Show" podrá encontrar los datos: aws_access_key_id, aws_secret_access_key y aws_session_token.

Adicionalmente, al final en la sección de "AWS Details">>"Cloud Labs" puede encontrar la región. Todos estos datos son necesarios para desarrollar el tutorial, así que anotelos en algún lado para su posterior utilización.

Instale AWS cli en su máquina de estudiante siguiendo estas instrucciones. Una vez terminada la instalación y configuración de AWS cli abra la terminal de comando de su sistema operativo (SO) para ejecutar el siguiente comando y siga las instrucciones para configurar su aws_access_key_id y aws_secret_access_key teniendo en cuenta los datos que previamente anotó.

aws configure

Como resultado, AWS cli creará un archivo en la ruta ~/.aws/credentials cuya apariencia es como se muestra en el recuadro que sigue. Donde <your_access_key_id> y <your_secret_access_key> serán reemplazados por los datos entrados por usted durante la configuración. El archivo facilitará el desarrollo de las instrucciones que siguen.

[default]
aws_access_key_id = <your_access_key_id>
aws_secret_access_key = <your_secret_access_key>

Edite el archivo desde un editor de texto (por ej., bloc de notas) para agregar la línea que se muestra a continuación. El archivo se encontrará en <path>\.aws\credentials. Cabe resaltar que el <path> depende del sistema operativo de su máquina de estudiante. Por ej., en Windows será C:\Users\<USERNAME>\.aws\

[default]
...
aws_session_token =<your_session_token>

Para desarrollar este paso del tutorial, asegúrese de que tiene Terraform instalado en su máquina estudiante. En caso que no, lo invitamos a revisar este enlace con las instrucciones de instalación: https://developer.hashicorp.com/terraform/tutorials/aws-get-started/install-cli

Desde la terminal de comandos de su máquina estudiante, clone el proyecto de Terraform que se encuentra en el siguiente repositorio:

https://github.com/SELF-Software-Evolution-Lab/experimento-terraform

El proyecto de Terraform está dividido en varias carpetas, para ir creando recursos conforme a las necesidades del despliegue. Comenzaremos creando la base de datos de Postgres, necesaria para que corra el order-service modernizado. Para eso vaya dentro del proyecto clonado de Terraform y diríjase a la subcarpeta rds-order-service.

Dentro de esta carpeta, cree el archivo terraform.tfvars, el archivo debe lucir como sigue (configure su access_key, secret_key y region reemplazandolos por los valores que anotó en el paso anterior):

#terraform.tfvars
aws_access_key = "AWS_ACCESS_KEY_ID"
aws_secret_key = "AWS_SECRET_ACCESS_KEY"
region = "REGION"

Ahora, para inicializar Terraform dentro de esta carpeta ejecute el siguiente comando:

terraform init

Para visualizar las acciones que se ejecutarán al correr el script de Terraform ejecuta en su consola:

terraform plan

Finalmente, para ejecutar el script de Terraform que creará la base de datos RDS ejecute:

terraform apply

Asegúrese de anotar los valores que se retornan para db_instance_endpoint y el puerto (ver captura) ya que estos datos serán usados para crear el esquema de la base de datos de "order_service", así como para desplegar el order-service nuevo.

Una vez aprovisionada la infraestructura de base de datos es necesario ponerla a punto con el esquema de la tabla de órdenes. Para esto, descargue alguna herramienta de administración de bases Postgres (por ej., pgAdmin4, dbeaver, etc). A continuación, indicamos el paso a paso de conexión si tiene pgAdmin4.

En pgAdmin4 debe seleccionar Server>Register>Server, lo cual va a abrir una ventana para hacer la configuración de conexión. En la sección "General", coloque un nombre cualquiera que le permita identificar la conexión a la base de datos, en nuestro caso colocamos "daytrader" como se muestra seguidamente:

Después diríjase a "Connection" en donde va a llenar los datos que se listan abajo y también se ilustran en la captura que sigue:

• Host name/addess = <POSTGRES_HOST> (este valor corresponde a lo obtenido en la sección de "desplegar infraestructura computacional")
• Port = 5432
• Maintenance Database=postgres
• Username= daytrader
• Password=daytraderpassword

Finalmente, presione el botón guardar.

En el explorador de la izquierda de pgAdmin4, seleccione el servidor que acaba de registrar ("daytrader"). Haga clic derecho allí, seleccione "Databases>>Create>>Database". El nombre de la base de datos tiene que ser "order_service" como se ve en la siguiente captura de pantalla:

Como resultado, se creará la base de datos. Ahora, en el explorador de la izquierda de pgAdmin4, bajo "order-service", seleccione "Schemas" y de clic derecho para crear un esquema como se muestra a continuación:

Esto abre una ventana con la configuración del esquema. Usted debe marcar dicho esquema como "public" y guardar.

Luego, en el explorador de pgAdmin4, diríjase a daytrader>order_service>Tables>QueryToo, como se ve en la siguiente captura:

Esto abre una nueva ventana en donde debe colocar el siguiente script el cual creará la tabla order_entity en la base Postgres:

CREATE TYPE public.order_entity_type_enum AS ENUM
    ('BUY', 'SELL');

CREATE TYPE public.order_entity_status_enum AS ENUM
    ('OPEN', 'PROCESSING', 'COMPLETED', 'CLOSED', 'CANCELED');

CREATE TABLE IF NOT EXISTS public.order_entity
(
    id  SERIAL PRIMARY KEY ,
    "accountId" character varying COLLATE pg_catalog."default" NOT NULL,
    "userId" character varying COLLATE pg_catalog."default" NOT NULL,
    "quoteId" character varying COLLATE pg_catalog."default" NOT NULL,
    "holdingId" character varying COLLATE pg_catalog."default",
    type order_entity_type_enum NOT NULL,
    quantity integer NOT NULL,
    price real NOT NULL,
    "orderFee" real NOT NULL,
    status order_entity_status_enum NOT NULL DEFAULT 'OPEN'::order_entity_status_enum,
    "openDate" timestamp without time zone NOT NULL DEFAULT now(),
    "completionDate" timestamp without time zone,
    "createdAt" timestamp without time zone NOT NULL DEFAULT now(),
    "updatedAt" timestamp without time zone NOT NULL DEFAULT now()
);

Finalmente, ejecute el script con el botón que se ve en la siguiente captura:

Puede confirmar la creación de la tabla ejecutando la siguiente línea:

 SELECT * FROM public.order_entity;

Lo siguiente que haremos es configurar las colas de mensajería SNS y SQS, para esto, diríjase a la carpeta order-service-queues del proyecto de Terraform. Dentro de esta carpeta, cree el archivo terraform.tfvars, configure su access_key_id, secret_ access_key y region reemplazandolos por los valores que anotó en el paso anterior.

#terraform.tfvars
aws_access_key = "AWS_ACCESS_KEY_ID"
aws_secret_key = "AWS_SECRET_ACCESS_KEY"
region = "REGION"

Para inicializar Terraform dentro de esta carpeta ejecute el comando:

terraform init

Para visualizar las acciones que se ejecutarán al correr el script de Terraform ejecute en su consola:

terraform plan

Finalmente, para ejecutar el script de Terraform que creará las colas SNS y SQS, corra el comando de apply de Terraform:

terraform apply

Desde la terminal de comandos de su máquina estudiante, clone el repositorio que sigue:

https://github.com/SELF-Software-Evolution-Lab/experimento-order-service

Para desplegar order-service en elastic beanstalk diríjase a la siguiente url y realice el proceso de instalación del eb cli (Step 2).

https://aws.amazon.com/getting-started/hands-on/set-up-command-line-elastic-beanstalk/

Una vez instalado eb cli, desde la terminal de comandos de su máquina estudiante, dentro de la carpeta del proyecto que acaba de clonar, ejecute:

eb init --profile default --region <REGION>

Siga las indicaciones del cli:

— Seleccione la misma región en la que creó la base de datos y las colas

— Ingrese su aws-access-id y aws-secret-key, si el cli lo requiere

— De un nombre para la aplicación, en nuestro caso daremos daytrader-order-service

— Seleccione la plataforma de despliegue con Node.js y luego seleccione Node.js con la versión 18 de node.

— Responda N a la pregunta de CodeCommit

— Si desea conectarse a las instancias a través de SSH, configure la llave privada para acceso por SSH.

A continuación ilustramos el paso a paso que hicimos en cli.

Ahora para crear la aplicación y el ambiente en Amazon Elastic Beanstalk ejecute el siguiente comando:

eb create daytrader-order-service-dev --service-role LabRole -ip LabInstanceProfile --instance_type t3.medium

Siga los pasos de creación teniendo en cuenta lo siguiente:

— Introduzca un nombre de su entorno. Nosotros usaremos "daytrader-order-service-dev", pero usted puede poner el nombre que desee.

— Seleccione un balanceador de carga de tipo "Aplicación"

— Seleccione 'N' a 'Spot Fleet Requests'

Ejecute el siguiente comando para seleccionar el ambiente en el que va a trabajar:

eb use daytrader-order-service-dev

Con esto el servicio se desplegará en Amazon Elastic Beanstalk. Finalizado este paso, la aplicación estará desplegada con errores, debido a que no hemos configurado las variables de entorno para la conexión a la base de datos, la cola de SNS y la cola de SQS. Las variables que se necesitan parametrizar son listadas a continuación y seguidamente indicamos cómo recuperar los valores correspondientes para cada una de ellas:

POSTGRES_HOST=XXXXX

AWS_REGION=

AWS_ACCESS_KEY_ID= AWS_SECRET_ACCESS_KEY=

AWS_SQS_URL=XXXXX

AWS_SNS_ORIGIN=XXXXX

AWS_SESSION_TOKEN=

Para <REGION>, <AWS_ACCESS_KEY_ID>, <AWS_SECRET_ACCESS_KEY> , <AWS_SESSION_TOKEN> utilice lo valores que anotó previamente.

Para el XXXXX de POSTGRES_HOST utilice "db_instance_endpoint" sin el puerto. Este dato lo obtuvo como respuesta cuando aprovisionó la base de datos.

Para el XXXXX de AWS_SQS_URL diríjase a la interfaz gráfica de AWS. Para esto desde el Learner Lab, de clic en AWS como se muestra a continuación, esto abrirá la interfaz gráfica Web de AWS en el navegador.

Estando en la interfaz gráfica de AWS, vaya al servicio de SQS y seleccione order-service:

Como resultado, se desplegará la información que se muestra seguidamente. Copie el valor de la URL para usarlo en AWS_SQS_URL.

Para el XXXXX de AWS_SNS_ORIGIN, estando en la interfaz gráfica de AWS, diríjase al servicio de SNS. Haga clic en el número debajo del label Topics (similar al que se ve a continuación).

Copie el valor del ARN orders para usarlo en AWS_SNS_ORIGIN.

Desde la terminal de comandos de su máquina estudiante, ejecute el comando eb setenv que iniciará "order-service" en BeansTalk. Antes de ejecutarlo asegúrese de reemplazar los valores <REGION>, <AWS_ACCESS_KEY_ID>, <AWS_SECRET_ACCESS_KEY> y XXXXX por los valores que recopiló previamente.

eb setenv POSTGRES_HOST=XXXXX POSTGRES_PORT=5432 POSTGRES_USERNAME=daytrader POSTGRES_PASSWORD=daytraderpassword POSTGRES_DATABASE=order_service PGSSLMODE=no-verify AWS_REGION= <REGION> AWS_API_VERSION=2012-11-05 AWS_ACCESS_KEY_ID= <AWS_ACCESS_KEY_ID> AWS_SECRET_ACCESS_KEY=<AWS_SECRET_ACCESS_KEY> AWS_SQS_URL=XXXXX AWS_SNS_ORIGIN=XXXXX  AWS_SESSION_TOKEN=<AWS_SESSION_TOKEN>

Para verificar que order-service se está ejecutando correctamente diríjase nuevamente a la interfaz gráfica de AWS. Vaya a "Elastic Beanstalk">"Environments". Busque el "enviroment" que ha creado y revise que "Health" esté en estado "Ok" como se ve a continuación:

Ahora copie la URL que aparece en "Domain" y ábrala en su navegador. Si la puesta en ejecución de "order-service" fue exitosa, entonces, debe poder ver un "Hello World" en la pantalla cuando abra la URL en el navegador. No olvide anotar esta URL que aparece en "Domain", ya que se va a usar más adelante, en particular, al momento de desplegar el Day Trader legado. Recuerde que en este experimento el Day Trader legado sigue exponiendo la capa de presentación, es decir, las peticiones de compra/venta son capturadas desde allá, se hacen validaciones y si estas pasan se envía un mensaje al "order-service" nuevo para que éste cree la orden.

Para confirmar que order-service se está conectado exitosamente a la base Postgres, abra la siguiente dirección en su navegador: http://<order_service_url> /orders , donde <order_service_url> corresponde a la URL que recuperó previamente en el "Domain" del "enviroment" de Beanstalk. Esta URL invoca el endpoint "getOrders" de "order-service", es decir, la funcionalidad que lista todas las órdenes de la tabla de órdenes de la base de datos. Como la tabla está vacía en este punto, solo podrá ver una lista vacía en pantalla :

Desde la terminal de comandos de su máquina estudiante, clone el proyecto:

https://github.com/SELF-Software-Evolution-Lab/experimento-daytrader

Configure las siguientes variables de entorno en su máquina reemplazando por los valores que usamos en los pasos anteriores.

export AWS_REGION_KEY=REGION
export SQS_URL=sqs_url
export SNS_ARN=sns_arn
export ORDER_SERVICE_URL=http://order_service_url/orders

Compile ahora la aplicación en su máquina estudiante ejecutando el siguiente comando

mvn clean package liberty:run

Ahora proceda a crear y compilar una imagen de Docker pasando las variables de entorno como parámetros para el build.

sudo docker build --build-arg AWS_ACCESS_KEY=$AWS_ACCESS_KEY --build-arg AWS_SECRET_KEY=$AWS_SECRET_KEY --build-arg AWS_REGION_KEY=$AWS_REGION_KEY --build-arg SQS_URL=$SQS_URL --build-arg SNS_ARN=$SNS_ARN --build-arg ORDER_SERVICE_URL=$ORDER_SERVICE_URL -t daytrader-gateway .

Corra el contenedor de Docker ejecutando el siguiente comando:

sudo docker run -d -p 9080:9080 -e AWS_ACCESS_KEY=$AWS_ACCESS_KEY -e AWS_SECRET_KEY=$AWS_SECRET_KEY -e AWS_REGION_KEY=$AWS_REGION_KEY -e SQS_URL=$SQS_URL -e SNS_ARN=$SNS_ARN -e ORDER_SERVICE_URL=$ORDER_SERVICE_URL daytrader-gateway

Con esto, Daytrader ya debería estar corriendo en un contenedor de Docker desde su máquina. En uno de los navegadores de su máquina, coloque la url http://localhost:9080/daytrader/ . Como resultado debe obtener una interfaz como la que sigue.

Figure 2.Captura de pantalla de la interfaz de DayTrader al acceder a la url indicada.

El video que sigue ilustra el funcionamiento de Day Trader legado en convivencia con el Order-Service modernizada.

Enlace al video

A continuación reportamos las recomendaciones y el esfuerzo real del experimento.

Recomendaciones

El experimento validó la viabilidad técnica de la arquitectura to-be propuesta para Daytrader, separando la funcionalidad del dominio de órdenes de compra/venta en un servicio independiente. Un paso a seguir es realizar dos pruebas de carga, una sobre el Day Trader original y otra sobre el Day Trader modernizado para evaluar si la nueva arquitectura permite que el servicio de órdenes sea más escalable comparado con el legado. Es decir, que el nuevo servicio permite recibir una mayor cantidad de órdenes sin degradar su operación.

El experimento se centró en la ejecución del proceso de compra/venta siguiendo lo que comúnmente llamamos en la industria el "happy path", es decir, asumiendo que el flujo de compra no va a tener errores y el usuario puede comprar y vender sin ninguna restricción. Para una mejor implementación en las siguientes iteraciones del proyecto, se debe pensar en una implementación que pueda tolerar eventuales fallas del proceso de compra/venta. Como en la arquitectura to-be deseable cada servicio tiene su propia base de datos, se sugiere aplicar el patrón de manejo de datos SAGAS que permitan revertir procesos realizados en pasos anteriores para mantener la integridad de los datos del sistema.

Esfuerzo real

La tabla que sigue lista los requisitos y otras tareas que se estimaron en el pre-experimento Day Trader. Por cada una de ellas aparece el esfuerzo real empleado y observaciones si hubo desviaciones con respecto a lo esperado.