`, que es el nombre de recurso de Amazon (ARN) del bucket que creó con anterioridad.Argumento 2= su nombre de Firehose (este piloto utiliza `firehose_to_s3_stream`).Argumento 3 = su nombre de rol de IAM (Este piloto utiliza `firehose_to_s3`).python CreateFireHoseToS3.py firehose_to_s3_stream firehose_to_s3
Si el rol de IAM especificado no existe, el script creará un rol de asunción con una política de relaciones de confianza, así como una política que conceda suficientes permisos de Amazon S3. Para ver ejemplos de estas políticas, consulte la sección *Información adicional*. | Arquitecto de la nube, desarrollador de aplicaciones |
| Verifique el flujo de entrega de Firehose. | Describa el flujo de entrega de Firehose mediante la AWS CLI para verificar si el flujo de entrega se creó correctamente.aws firehose describe-delivery-stream --delivery-stream-name firehose_to_s3_stream
| Arquitecto de la nube, desarrollador de aplicaciones |
### Crear una función de Lambda para procesar el flujo de entrega de Firehose
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Cree una política de confianza para la función de Lambda. | Cree un archivo de política de confianza con la siguiente información. {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
} Esto le concederá a su función permiso para acceder a los recursos de AWS. | Arquitecto de la nube, desarrollador de aplicaciones |
| Cree un rol de ejecución para la función de Lambda. | Para crear el rol de ejecución, ejecute el siguiente código.aws iam create-role --role-name lambda-ex --assume-role-policy-document file://TrustPolicy.json
| Arquitecto de la nube, desarrollador de aplicaciones |
| Agregue permisos al rol. | Para agregar permisos al rol, use el comando `attach-policy-to-role`.aws iam attach-role-policy --role-name lambda-ex --policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
aws iam attach-role-policy --role-name lambda-ex --policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaDynamoDBExecutionRole
aws iam attach-role-policy --role-name lambda-ex --policy-arn arn:aws:iam::aws:policy/AmazonKinesisFirehoseFullAccess
aws iam attach-role-policy --role-name lambda-ex --policy-arn arn:aws:iam::aws:policy/IAMFullAccess
| Arquitecto de la nube, desarrollador de aplicaciones |
| Creación de una función de Lambda. | Ejecute el siguiente comando para comprimir el archivo `LambdaStreamProcessor.py` del repositorio de código.zip function.zip LambdaStreamProcessor.py
Cuando cree la función de Lambda, necesitará el ARN del rol de ejecución de Lambda. Para obtener el ARN, ejecute el siguiente código.aws iam get-role \
--role-name lambda-ex
Para crear la función de Lambda, ejecute el siguiente código.# Review the environment variables and replace them with your values.
aws lambda create-function --function-name LambdaStreamProcessor \
--zip-file fileb://function.zip --handler LambdaStreamProcessor.handler --runtime python3.8 \
--role {Your Lamda Execution Role ARN}\
--environment Variables="{firehose_name=firehose_to_s3_stream,bucket_arn = ,iam_role_name = firehose_to_s3, batch_size=400}"
| Arquitecto de la nube, desarrollador de aplicaciones |
| Configure el desencadenador de la función de Lambda. | Utilice la CLI de AWS para configurar el desencadenador (DynamoDB Streams), que invoca la función de Lambda. El tamaño del lote de 400 es para evitar problemas de simultaneidad de Lambda.aws lambda create-event-source-mapping --function-name LambdaStreamProcessor \
--batch-size 400 --starting-position LATEST \
--event-source-arn
| Arquitecto de la nube, desarrollador de aplicaciones |
### Probar la funcionalidad
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Añada elementos con marcas de tiempo vencidas a la tabla de Reserva. | Para probar la funcionalidad, añada a la tabla `Reservation` los elementos con marcas de tiempo epoch vencidos. El TTL eliminará automáticamente los elementos en función de la marca de tiempo. La función de Lambda se inicia con las actividades de DynamoDB Stream y filtra el evento para identificar la actividad `REMOVE` o los elementos eliminados. A continuación, permite colocar los registros en el flujo de entrega de Firehose en formato de lote.El flujo de entrega de Firehose transfiere los elementos a un bucket de S3 de destino con el prefijo `firehosetos3example/year=current year/month=current month/ day=current day/hour=current hour/`.Para optimizar la recuperación de datos, configure Amazon S3 con `Prefix` y `ErrorOutputPrefix` que se detallan en la sección *Información adicional*. | Arquitecto de la nube |
### Limpiar los recursos
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Elimine todos los recursos. | Elimine todos los recursos para asegurarse de que no se le cobre por ningún servicio que no utilice. | Arquitecto de la nube, desarrollador de aplicaciones |
## Recursos relacionados
+ [Administración del ciclo de vida del almacenamiento](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/create-lifecycle.html)
+ [Clases de almacenamiento de Amazon S3](https://aws.amazon.com/s3/storage-classes/)
+ [Documentación de AWS SDK para Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html)
## Información adicional
**Creación y configuración de un flujo de entrega deFirehose: ejemplos de políticas**
*Documento de ejemplo de política de relaciones de confianza de Firehose*
```
firehose_assume_role = {
'Version': '2012-10-17',
'Statement': [
{
'Sid': '',
'Effect': 'Allow',
'Principal': {
'Service': 'firehose.amazonaws.com'
},
'Action': 'sts:AssumeRole'
}
]
}
```
*Ejemplos de políticas de permisos de S3*
```
s3_access = {
"Version": "2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Action": [
"s3:AbortMultipartUpload",
"s3:GetBucketLocation",
"s3:GetObject",
"s3:ListBucket",
"s3:ListBucketMultipartUploads",
"s3:PutObject"
],
"Resource": [
"{your s3_bucket ARN}/*",
"{Your s3 bucket ARN}"
]
}
]
}
```
**Probar la funcionalidad: configuración de Amazon S3**
Se elige la configuración de Amazon S3 con el siguiente `Prefix` y `ErrorOutputPrefix` para optimizar la recuperación de datos.
*Prefijo*
```
firehosetos3example/year=! {timestamp: yyyy}/month=! {timestamp:MM}/day=! {timestamp:dd}/hour=!{timestamp:HH}/
```
Firehose primero crea una carpeta base llamada `firehosetos3example` directamente debajo del bucket de S3. A continuación, evalúa las expresiones`!{timestamp:yyyy}`, `!{timestamp:MM}``!{timestamp:dd}`, y `!{timestamp:HH}` para indicar el año, el mes, el día y la hora con el [DateTimeFormatter](https://docs.oracle.com/javase/8/docs/api/java/time/format/DateTimeFormatter.html)formato Java.
Por ejemplo, una marca de tiempo de llegada aproximada de 1604683577 en tiempo de época de Unix se evalúa como `year=2020`, `month=11`, `day=06` y `hour=05`. Por lo tanto, se evalúa en `firehosetos3example/year=2020/month=11/day=06/hour=05/` la ubicación de Amazon S3 en la que se entregan los registros de datos.
*ErrorOutputPrefix*
```
firehosetos3erroroutputbase/!{firehose:random-string}/!{firehose:error-output-type}/!{timestamp:yyyy/MM/dd}/
```
Los `ErrorOutputPrefix` generan una carpeta base llamada `firehosetos3erroroutputbase` directamente debajo del bucket de S3. La expresión `!{firehose:random-string}` se evalúa como una cadena aleatoria de 11 caracteres, como `ztWxkdg3Thg`. Se podría evaluar como `firehosetos3erroroutputbase/ztWxkdg3Thg/processing-failed/2020/11/06/` la ubicación de un objeto de Amazon S3 en la que se entregan los registros fallidos.
# Cree una arquitectura sin servidor multiusuario en Amazon Service OpenSearch
*Tabby Ward y Nisha Gambhir, Amazon Web Services*
## Resumen
Amazon OpenSearch Service es un servicio gestionado que facilita la implementación, el funcionamiento y el escalado de Elasticsearch, un popular motor de búsqueda y análisis de código abierto. OpenSearch El servicio ofrece una búsqueda de texto libre, así como una recopilación y un panel de control prácticamente en tiempo real para la transmisión de datos, como registros y métricas.
Los proveedores de software como servicio (SaaS) suelen utilizar el OpenSearch Servicio para abordar una amplia gama de casos de uso, como obtener información sobre los clientes de forma escalable y segura y, al mismo tiempo, reducir la complejidad y el tiempo de inactividad.
El uso del OpenSearch servicio en un entorno multiusuario introduce una serie de consideraciones que afectan a la partición, el aislamiento, la implementación y la administración de su solución SaaS. Los proveedores de SaaS deben considerar cómo escalar de manera efectiva sus clústeres de Elasticsearch con cargas de trabajo en constante cambio. También deben tener en cuenta cómo pueden afectar la estratificación y el ruido aledaño a su modelo de particionamiento.
Este patrón revisa los modelos empleados para representar y aislar los datos de los usuarios con constructos de Elasticsearch. Además, el patrón se centra en una arquitectura de referencia sencilla y sin servidor como ejemplo para demostrar la indexación y la búsqueda mediante OpenSearch Service en un entorno multiusuario. Implementa el modelo de particionamiento de datos de grupos, que comparte un mismo índice entre todos los usuarios y, al mismo tiempo, mantiene el aislamiento de los datos de los mismos. Este patrón utiliza los siguientes AWS servicios: Amazon API Gateway AWS Lambda, Amazon Simple Storage Service (Amazon S3) y Service. OpenSearch
Para obtener más información sobre el modelo de grupo y otros modelos de particionamiento de datos, consulte la sección de [Información adicional](#build-a-multi-tenant-serverless-architecture-in-amazon-opensearch-service-additional).
## Requisitos previos y limitaciones
**Requisitos previos **
+ Un activo Cuenta de AWS
+ [AWS Command Line Interface (AWS CLI) versión 2.x](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv2.html), instalada y configurada en macOS, Linux o Windows
+ [Python versión 3.9](https://www.python.org/downloads/release/python-3921/)
+ [pip3](https://pip.pypa.io/en/stable/): el código fuente de Python se proporciona como un archivo .zip para implementarlo en una función de Lambda. Si quiere usar el código localmente o personalizarlo, siga estos pasos para desarrollar y recompilar el código fuente:
1. Genere el archivo `requirements.txt` ejecutando el siguiente comando en el mismo directorio que los scripts de Python: `pip3 freeze > requirements.txt`
1. Instale las dependencias: `pip3 install -r requirements.txt`
**Limitaciones**
+ Este código se ejecuta en Python y, actualmente, no es compatible con otros lenguajes de programación.
+ La aplicación de ejemplo no incluye compatibilidad AWS entre regiones ni con la recuperación ante desastres (DR).
+ Este patrón sólo pretende servir de ejemplo. No está pensado para ser utilizado en un entorno de producción.
## Arquitectura
El siguiente diagrama ilustra la arquitectura de alto nivel de este patrón. La arquitectura incluye lo siguiente:
+ Lambda para indexar y consultar el contenido
+ OpenSearch Servicio para realizar búsquedas
+ API Gateway para proporcionar a la API interacción con el usuario
+ Amazon S3, para almacenar datos sin procesar (no indexados)
+ Amazon CloudWatch supervisará los registros
+ AWS Identity and Access Management (IAM) para crear las funciones y políticas de los inquilinos
![\[Arquitectura multiusuario sin servidor de alto nivel\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/750196bb-03f6-4b6e-92cd-eb7141602547/images/1a8501e7-0776-4aca-aed3-28e3ada1d15d.png)
**Automatización y escala**
Para simplificar, el patrón se utiliza AWS CLI para aprovisionar la infraestructura e implementar el código de muestra. Puede crear una CloudFormation plantilla o AWS Cloud Development Kit (AWS CDK) scripts para automatizar el patrón.
## Tools (Herramientas)
**Servicios de AWS**
+ [AWS CLI](https://aws.amazon.com/cli/)es una herramienta unificada para administrar Servicios de AWS los recursos mediante el uso de comandos en el shell de la línea de comandos.
+ [Lambda](https://aws.amazon.com/lambda/) es un servicio informático que permite ejecutar código sin aprovisionar ni administrar servidores. Lambda ejecuta su código solo cuando es necesario y escala de manera automática, desde unas pocas solicitudes por día hasta miles por segundo.
+ [API Gateway](https://aws.amazon.com/api-gateway/) es Servicio de AWS para crear, publicar, mantener, monitorear y proteger REST, HTTP y WebSocket APIs a cualquier escala.
+ [Amazon S3](https://aws.amazon.com/s3/) es un servicio de almacenamiento de objetos que permite almacenar y recuperar cualquier cantidad de información en cualquier momento y desde cualquier lugar de la web.
+ OpenSearch El [servicio](https://aws.amazon.com/opensearch-service/) es un servicio totalmente gestionado que facilita la implementación, la protección y la ejecución de Elasticsearch a escala y de forma rentable.
**Código**
El archivo adjunto incluye archivos de muestra para este patrón. Entre ellos se incluyen:
+ `index_lambda_package.zip`— La función Lambda para indexar datos en OpenSearch Service mediante el modelo de grupo.
+ `search_lambda_package.zip`— La función Lambda para buscar datos en OpenSearch Service.
+ `Tenant-1-data` — Muestra de datos sin procesar (no indexados) para Usuario-1.
+ `Tenant-2-data`: muestra de datos sin procesar (no indexados) para Usuario-2.
**importante**
Las historias de este patrón incluyen ejemplos de AWS CLI comandos formateados para Unix, Linux y macOS. Para Windows, sustituya la barra diagonal invertida (\$1) utilizada como carácter de continuación de Unix al final de cada línea por el signo de intercalación (^).
**nota**
En AWS CLI los comandos, sustituya todos los valores entre los corchetes angulares (<>) por los valores correctos.
## Epics
### Creación y configuración de un bucket de S3
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Cree un bucket de S3. | Cree un bucket de S3 en su. Región de AWS Este bucket contendrá los datos de usuarios no indexados de la aplicación de muestra. Asegúrese de que el nombre del bucket de S3 sea único a nivel mundial, ya que todos comparten el espacio de nombres. Cuentas de AWSPara crear un bucket de S3, puedes usar el comando AWS CLI [create-bucket](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/create-bucket.html) de la siguiente manera:aws s3api create-bucket \
--bucket \
--region
donde `tenantrawdata` es el nombre de bucket de S3. (Puede usar cualquier nombre único que siga las [pautas de nomenclatura de buckets](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucketnamingrules.html)). | Arquitecto de la nube, administrador de la nube |
### Cree y configure un clúster de Elasticsearch
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Cree un dominio de OpenSearch servicio. | Ejecute el AWS CLI [create-elasticsearch-domain](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/es/create-elasticsearch-domain.html)comando para crear un dominio OpenSearch de servicio:aws es create-elasticsearch-domain \
--domain-name vpc-cli-example \
--elasticsearch-version 7.10 \
--elasticsearch-cluster-config InstanceType=t3.medium.elasticsearch,InstanceCount=1 \
--ebs-options EBSEnabled=true,VolumeType=gp2,VolumeSize=10 \
--domain-endpoint-options "{\"EnforceHTTPS\": true}" \
--encryption-at-rest-options "{\"Enabled\": true}" \
--node-to-node-encryption-options "{\"Enabled\": true}" \
--advanced-security-options "{\"Enabled\": true, \"InternalUserDatabaseEnabled\": true, \
\"MasterUserOptions\": {\"MasterUserName\": \"KibanaUser\", \
\"MasterUserPassword\": \"NewKibanaPassword@123\"}}" \
--vpc-options "{\"SubnetIds\": [\"\"], \"SecurityGroupIds\": [\"\"]}" \
--access-policies "{\"Version\": \"2012-10-17\", \"Statement\": [ { \"Effect\": \"Allow\", \
\"Principal\": {\"AWS\": \"*\" }, \"Action\":\"es:*\", \
\"Resource\": \"arn:aws:es:::domain\/vpc-cli-example\/*\" } ] }"
El número de instancias está establecido en 1, ya que el dominio se usa para realizar pruebas. Debe habilitar un control de acceso detallado mediante el parámetro `advanced-security-options`, ya que los detalles no se pueden cambiar una vez creado el dominio. Este comando crea un nombre de usuario maestro (`KibanaUser`) y una contraseña que le permitirá iniciar sesión en la consola de Kibana.Como el dominio forma parte de una nube privada virtual (VPC), debe asegurarse de poder acceder a la instancia de Elasticsearch especificando la política de acceso que va a usar.Para obtener más información, consulta Cómo [lanzar tus dominios de Amazon OpenSearch Service dentro de una VPC](https://docs.aws.amazon.com/elasticsearch-service/latest/developerguide/es-vpc.html) en la AWS documentación. | Arquitecto de la nube, administrador de la nube |
| Instale un host bastión. | Configura una instancia Windows de Amazon Elastic Compute Cloud (Amazon EC2) como host bastión para acceder a la consola de Kibana. El grupo de seguridad de Elasticsearch debe permitir el tráfico del grupo de EC2 seguridad de Amazon. Para obtener instrucciones, consulte la entrada del blog Cómo [controlar el acceso a la red a las EC2 instancias mediante un servidor Bastion](https://aws.amazon.com/blogs/security/controlling-network-access-to-ec2-instances-using-a-bastion-server/).Cuando se haya configurado el host bastión y tenga disponible el grupo de seguridad asociado a la instancia, utilice el AWS CLI [authorize-security-group-ingress](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/authorize-security-group-ingress.html)comando para añadir permiso al grupo de seguridad de Elasticsearch a fin de permitir el puerto 443 del grupo de seguridad de Amazon EC2 (host bastión).aws ec2 authorize-security-group-ingress \
--group-id \
--protocol tcp \
--port 443 \
--source-group
| Arquitecto de la nube, administrador de la nube |
### Crear y configurar la función de índice de Lambda
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Para crear el rol de ejecución de Lambda | Ejecute el comando AWS CLI [create-role](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/create-role.html) para conceder a la función de índice Lambda acceso a los recursos y a los recursos: Servicios de AWS aws iam create-role \
--role-name index-lambda-role \
--assume-role-policy-document file://lambda_assume_role.json
donde `lambda_assume_role.json` es un documento JSON que concede permisos de `AssumeRole` a la función de Lambda, de la siguiente manera:{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
} | Arquitecto de la nube, administrador de la nube |
| Adjunte políticas gestionadas al rol de Lambda. | Ejecute el AWS CLI [attach-role-policy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/attach-role-policy.html)comando para adjuntar las políticas administradas al rol creado en el paso anterior. Estas dos políticas otorgan al rol permisos para crear una interfaz de red elástica y escribir CloudWatch registros en Logs.aws iam attach-role-policy \
--role-name index-lambda-role \
--policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
aws iam attach-role-policy \
--role-name index-lambda-role \
--policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaVPCAccessExecutionRole
| Arquitecto de la nube, administrador de la nube |
| Cree una política para dar permisos a la función de índice de Lambda de modo que pueda leer los objetos de S3. | Ejecute el comando AWS CLI [create-policy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/create-policy.html) para dar `s3:GetObject` permiso a la función de índice de Lambda para leer los objetos del bucket de S3:aws iam create-policy \
--policy-name s3-permission-policy \
--policy-document file://s3-policy.json
El archivo `s3-policy.json` es un documento JSON que se muestra a continuación y que concede permisos de `s3:GetObject` para permitir el acceso de lectura a los objetos de S3. Si ha usado un nombre diferente al crear el bucket de S3, proporcione el nombre de bucket correcto en sección de `Resource `:{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "s3:GetObject",
"Resource": "arn:aws:s3:::/*"
}
]
} | Arquitecto de la nube, administrador de la nube |
| Adjunte la política de permisos de Amazon S3 al rol de ejecución de Lambda. | Ejecute el AWS CLI [attach-role-policy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/attach-role-policy.html)comando para adjuntar la política de permisos de Amazon S3 que creó en el paso anterior a la función de ejecución de Lambda:aws iam attach-role-policy \
--role-name index-lambda-role \
--policy-arn
donde `PolicyARN` es el Nombre de recurso de Amazon (ARN) de la política de permisos de Amazon S3. Puede obtener este valor del resultado del comando anterior. | Arquitecto de la nube, administrador de la nube |
| Cree la función de indexar de Lambda. | Ejecute el comando AWS CLI [create-function](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-function.html) para crear la función de índice Lambda, que accederá al servicio: OpenSearch aws lambda create-function \
--function-name index-lambda-function \
--zip-file fileb://index_lambda_package.zip \
--handler lambda_index.lambda_handler \
--runtime python3.9 \
--role "arn:aws:iam::account-id:role/index-lambda-role" \
--timeout 30 \
--vpc-config "{\"SubnetIds\": [\"", \"\"], \
\"SecurityGroupIds\": [\"\"]}"
| Arquitecto de la nube, administrador de la nube |
| Permita que Amazon S3 llame a la función de índice de Lambda. | Ejecute el comando AWS CLI [add-permission](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/add-permission.html) para conceder a Amazon S3 el permiso de llamar a la función de índice Lambda:aws lambda add-permission \
--function-name index-lambda-function \
--statement-id s3-permissions \
--action lambda:InvokeFunction \
--principal s3.amazonaws.com \
--source-arn "arn:aws:s3:::" \
--source-account ""
| Arquitecto de la nube, administrador de la nube |
| Añada un desencadenante de Lambda para el evento de Amazon S3. | Ejecute el AWS CLI [put-bucket-notification-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/put-bucket-notification-configuration.html)comando para enviar notificaciones a la función de índice Lambda cuando se detecte el `ObjectCreated` evento de Amazon S3. La función de índice se ejecuta cada vez que se carga un objeto en el bucket de S3. aws s3api put-bucket-notification-configuration \
--bucket \
--notification-configuration file://s3-trigger.json
El archivo `s3-trigger.json` es un documento JSON de la carpeta actual que añade la política de recursos a la función de Lambda cuando se produce el evento `ObjectCreated` de Amazon S3. | Arquitecto de la nube, administrador de la nube |
### Crear y configurar la función de búsqueda de Lambda
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Para crear el rol de ejecución de Lambda | Ejecute el comando AWS CLI [create-role](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/create-role.html) para conceder a la función de búsqueda de Lambda acceso a los recursos: Servicios de AWS aws iam create-role \
--role-name search-lambda-role \
--assume-role-policy-document file://lambda_assume_role.json
donde `lambda_assume_role.json` es un documento JSON en la carpeta actual que concede permisos de `AssumeRole` a la función de Lambda, de la siguiente manera:{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
} | Arquitecto de la nube, administrador de la nube |
| Adjunte políticas gestionadas al rol de Lambda. | Ejecute el AWS CLI [attach-role-policy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/attach-role-policy.html)comando para adjuntar las políticas administradas al rol creado en el paso anterior. Estas dos políticas otorgan al rol permisos para crear una interfaz de red elástica y escribir CloudWatch registros en Logs.aws iam attach-role-policy \
--role-name search-lambda-role \
--policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
aws iam attach-role-policy \
--role-name search-lambda-role \
--policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaVPCAccessExecutionRole
| Arquitecto de la nube, administrador de la nube |
| Cree la función de búsqueda de Lambda. | Ejecute el comando AWS CLI [create-function](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-function.html) para crear la función de búsqueda de Lambda, que accederá al servicio: OpenSearch aws lambda create-function \
--function-name search-lambda-function \
--zip-file fileb://search_lambda_package.zip \
--handler lambda_search.lambda_handler \
--runtime python3.9 \
--role "arn:aws:iam::account-id:role/search-lambda-role" \
--timeout 30 \
--vpc-config "{\"SubnetIds\": [\"", \"\"], \
\"SecurityGroupIds\": [\"\"]}"
| Arquitecto de la nube, administrador de la nube |
### Cree y configure los roles de usuario
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Cree roles de IAM para los usuarios. | Ejecute el comando AWS CLI [create-role](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/create-role.html) para crear dos roles arrendatarios que se utilizarán para probar la funcionalidad de búsqueda:aws iam create-role \
--role-name Tenant-1-role \
--assume-role-policy-document file://assume-role-policy.json
aws iam create-role \
--role-name Tenant-2-role \
--assume-role-policy-document file://assume-role-policy.json
El archivo `assume-role-policy.json` es un documento JSON en la carpeta actual que concede permisos de `AssumeRole` al rol de ejecución de Lambda:{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "",
"AWS": ""
},
"Action": "sts:AssumeRole"
}
]
} | Arquitecto de la nube, administrador de la nube |
| Crear una política de IAM de usuario. | Ejecuta el comando AWS CLI [create-policy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/create-policy.html) para crear una política de inquilinos que otorgue acceso a las operaciones de Elasticsearch:aws iam create-policy \
--policy-name tenant-policy \
--policy-document file://policy.json
El archivo `policy.json` es un documento JSON en la carpeta actual que concede permisos en Elasticsearch:{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"es:ESHttpDelete",
"es:ESHttpGet",
"es:ESHttpHead",
"es:ESHttpPost",
"es:ESHttpPut",
"es:ESHttpPatch"
],
"Resource": [
""
]
}
]
} | Arquitecto de la nube, administrador de la nube |
| Adjunte la política de IAM del usuario a los roles del usuario. | Ejecute el AWS CLI [attach-role-policy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/attach-role-policy.html)comando para adjuntar la política de IAM de inquilinos a las dos funciones de inquilino que creó en el paso anterior:aws iam attach-role-policy \
--policy-arn arn:aws:iam::account-id:policy/tenant-policy \
--role-name Tenant-1-role
aws iam attach-role-policy \
--policy-arn arn:aws:iam::account-id:policy/tenant-policy \
--role-name Tenant-2-role
La política ARN procede de lo obtenido en el paso anterior. | Arquitecto de la nube, administrador de la nube |
| Cree una política de IAM para conceder permisos de asunción de rol a Lambda. | Ejecute el comando AWS CLI [create-policy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/create-policy.html) para crear una política para que Lambda asuma el rol de inquilino:aws iam create-policy \
--policy-name assume-tenant-role-policy \
--policy-document file://lambda_policy.json
El archivo `lambda_policy.json` es un documento JSON en la carpeta actual que concede permisos a `AssumeRole`:{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "sts:AssumeRole",
"Resource": ""
}
]
}En `Resource`, puede usar un carácter comodín para evitar crear una nueva política para cada usuario. | Arquitecto de la nube, administrador de la nube |
| Cree una política de IAM para conceder permisos al rol de indexación de Lambda para acceder a Amazon S3. | Ejecute el comando AWS CLI [create-policy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/create-policy.html) para dar permiso al rol de índice de Lambda para acceder a los objetos del bucket de S3:aws iam create-policy \
--policy-name s3-permission-policy \
--policy-document file://s3_lambda_policy.json
El archivo `s3_lambda_policy.json` es el siguiente documento de política de JSON de la carpeta actual:{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "s3:GetObject",
"Resource": "arn:aws:s3:::tenantrawdata/*"
}
]
} | Arquitecto de la nube, administrador de la nube |
| Adjunte la política al rol de ejecución de Lambda. | Ejecute el AWS CLI [attach-role-policy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/attach-role-policy.html)comando para adjuntar la política creada en el paso anterior al índice Lambda y a las funciones de ejecución de búsquedas que creó anteriormente:aws iam attach-role-policy \
--policy-arn arn:aws:iam::account-id:policy/assume-tenant-role-policy \
--role-name index-lambda-role
aws iam attach-role-policy \
--policy-arn arn:aws:iam::account-id:policy/assume-tenant-role-policy \
--role-name search-lambda-role
aws iam attach-role-policy \
--policy-arn arn:aws:iam::account-id:policy/s3-permission-policy \
--role-name index-lambda-role
La política ARN procede de lo obtenido en el paso anterior. | Arquitecto de la nube, administrador de la nube |
### Cree y configure una API de búsqueda
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Cree una API de REST en API Gateway. | Ejecute el AWS CLI [create-rest-api](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/create-rest-api.html)comando para crear un recurso de API REST:aws apigateway create-rest-api \
--name Test-Api \
--endpoint-configuration "{ \"types\": [\"REGIONAL\"] }"
En el tipo de configuración de punto de conexión, puede especificar `EDGE` en lugar de `REGIONAL` para usar ubicaciones periféricas en lugar de una Región de AWS concreta.Anote el valor del campo `id` en el resultado del comando. Esta es la ID de API que usará en los siguientes comandos. | Arquitecto de la nube, administrador de la nube |
| Cree un recurso para la API de búsqueda. | El recurso de la API de búsqueda inicia la función de búsqueda de Lambda con el nombre de recurso `search`. (No es necesario crear una API para la función de índice de Lambda, ya que se ejecuta automáticamente cuando se cargan objetos en el bucket de S3).[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/build-a-multi-tenant-serverless-architecture-in-amazon-opensearch-service.html) | Arquitecto de la nube, administrador de la nube |
| Cree un método GET para la API de búsqueda. | Ejecuta el comando AWS CLI [put-method](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/put-method.html) para crear un `GET ` método para la API de búsqueda:aws apigateway put-method \
--rest-api-id \
--resource-id \
--http-method GET \
--authorization-type "NONE" \
--no-api-key-required
Para `resource-id`, especifique la ID de lo obtenido del comando `create-resource`. | Arquitecto de la nube, administrador de la nube |
| Cree un método de respuesta para la API de búsqueda. | Ejecuta el AWS CLI [put-method-response](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/put-method-response.html)comando para añadir una respuesta de método para la API de búsqueda:aws apigateway put-method-response \
--rest-api-id \
--resource-id \
--http-method GET \
--status-code 200 \
--response-models "{\"application/json\": \"Empty\"}"
En `resource-id`, especifique el ID del resultado del anterior comando `create-resource`. | Arquitecto de la nube, administrador de la nube |
| Configure una integración de Lambda proxy para la API de búsqueda. | Ejecute el comando AWS CLI [put-integration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/put-integration.html) para configurar una integración con la función de búsqueda de Lambda:aws apigateway put-integration \
--rest-api-id \
--resource-id \
--http-method GET \
--type AWS_PROXY \
--integration-http-method GET \
--uri arn:aws:apigateway:region:lambda:path/2015-03-31/functions/arn:aws:lambda:::function:/invocations
En `resource-id`, especifique la ID del anterior comando `create-resource`. | Arquitecto de la nube, administrador de la nube |
| Otorgue permiso a API Gateway para llamar a la función de búsqueda de Lambda. | Ejecute el comando AWS CLI [add-permission](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/add-permission.html) para conceder permiso a API Gateway para usar la función de búsqueda:aws lambda add-permission \
--function-name \
--statement-id apigateway-get \
--action lambda:InvokeFunction \
--principal apigateway.amazonaws.com \
--source-arn "arn:aws:execute-api:::api-id/*/GET/search
Cambie la ruta `source-arn` si ha usado un nombre de recurso de API en lugar de `search`. | Arquitecto de la nube, administrador de la nube |
| Implemente la API de búsqueda. | Ejecute el comando AWS CLI [create-deployment](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/create-deployment.html) para crear un recurso de etapa denominado: `dev`aws apigateway create-deployment \
--rest-api-id \
--stage-name dev
Si actualizas la API, puedes usar el mismo AWS CLI comando para volver a implementarla en la misma etapa. | Arquitecto de la nube, administrador de la nube |
### Crear y configurar roles de Kibana
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Inicie sesión en la consola Kibana. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/build-a-multi-tenant-serverless-architecture-in-amazon-opensearch-service.html) | Arquitecto de la nube, administrador de la nube |
| Cree y configure roles de Kibana. | Para aislar los datos y garantizar que un usuario no pueda recuperar los datos de otro, debe proteger los documentos con seguridad. Así, los usuarios podrán acceder únicamente a aquellos documentos que contienen su ID de usuario.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/build-a-multi-tenant-serverless-architecture-in-amazon-opensearch-service.html) | Arquitecto de la nube, administrador de la nube |
| Asigne usuarios a los roles. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/build-a-multi-tenant-serverless-architecture-in-amazon-opensearch-service.html)Le recomendamos que automatice la creación de los roles de usuario y roles de Kibana en el momento de la incorporación del usuario. | Arquitecto de la nube, administrador de la nube |
| Cree el índice de datos de usuarios. | En el panel de navegación, en **Administración**, seleccione **Herramientas de desarrollo** y, a continuación, ejecute el siguiente comando. Este comando crea el índice `tenant-data` para definir la asignación de la propiedad `TenantId`.PUT /tenant-data
{
"mappings": {
"properties": {
"TenantId": { "type": "keyword"}
}
}
}
| Arquitecto de la nube, administrador de la nube |
### Cree puntos de enlace de VPC para Amazon S3 y AWS STS
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Crear un punto de conexión de VPC para Amazon S3 . | Ejecute el AWS CLI [create-vpc-endpoint](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-vpc-endpoint.html)comando para crear un punto de enlace de VPC para Amazon S3. El punto de conexión permite que la función de índice de Lambda de la VPC acceda a Amazon S3.aws ec2 create-vpc-endpoint \
--vpc-id \
--service-name com.amazonaws.us-east-1.s3 \
--route-table-ids
En `vpc-id`, especifique la VPC que está usando para la función de índice de Lambda. En `service-name`, use la URL correcta del punto de conexión Amazon S3. En `route-table-ids`, especifique la tabla de enrutamiento asociada al punto de conexión de VPC. | Arquitecto de la nube, administrador de la nube |
| Cree un punto final de VPC para. AWS STS | Ejecute el AWS CLI [create-vpc-endpoint](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-vpc-endpoint.html)comando para crear un punto final de VPC para AWS Security Token Service ()AWS STS. El punto de conexión permite que las funciones de índice y búsqueda de Lambda en la VPC accedan al servicio AWS STS. Las funciones AWS STS se utilizan cuando asumen la función de IAM.aws ec2 create-vpc-endpoint \
--vpc-id \
--vpc-endpoint-type Interface \
--service-name com.amazonaws.us-east-1.sts \
--subnet-id \
--security-group-id
Para `vpc-id`, especifique la VPC que va a utilizar para las funciones de índice y búsqueda de Lambda. En `subnet-id`, proporcione la subred en la que se debe crear este punto de conexión. En `security-group-id`, especifique el grupo de seguridad al que desea asociar este punto de conexión. (Puede ser el mismo que el grupo de seguridad que usa Lambda). | Arquitecto de la nube, administrador de la nube |
### Pruebe el multiusuario y el aislamiento de datos
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Actualice los archivos de Python para las funciones de índice y búsqueda. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/build-a-multi-tenant-serverless-architecture-in-amazon-opensearch-service.html)Puedes obtener el punto final de Elasticsearch desde la pestaña **Descripción general de la consola** de servicio. OpenSearch Tiene el formato `.es.amazonaws.com`. | Arquitecto de la nube, desarrollador de aplicaciones |
| Actualizar el código de Lambda. | Use el AWS CLI [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)comando para actualizar el código Lambda con los cambios que realizó en los archivos de Python:aws lambda update-function-code \
--function-name index-lambda-function \
--zip-file fileb://index_lambda_package.zip
aws lambda update-function-code \
--function-name search-lambda-function \
--zip-file fileb://search_lambda_package.zip
| Arquitecto de la nube, desarrollador de aplicaciones |
| Cargue los datos sin procesar en el bucket de S3. | Use el comando AWS CLI [cp](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3/cp.html) para cargar los datos de los objetos Tenant-1 y Tenant-2 al `tenantrawdata` bucket (especifique el nombre del bucket S3 que creó para este propósito):aws s3 cp tenant-1-data s3://tenantrawdata
aws s3 cp tenant-2-data s3://tenantrawdata
El bucket de S3 está configurado para ejecutar la función de índice de Lambda siempre que se carguen datos, de modo que el documento se indexe en Elasticsearch. | Arquitecto de la nube, administrador de la nube |
| Busque datos desde la consola de Kibana. | En la consola de Kibana, ejecute la siguiente consulta:GET tenant-data/_search
Esta consulta muestra todos los documentos indexados en Elasticsearch. En este caso, debería ver dos documentos separados para Inquilino-1 e Inquilino-2. | Arquitecto de la nube, administrador de la nube |
| Pruebe la API de búsqueda desde API Gateway. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/build-a-multi-tenant-serverless-architecture-in-amazon-opensearch-service.html)Para ver una ilustración de la pantalla, consulte la sección de [Información adicional](#build-a-multi-tenant-serverless-architecture-in-amazon-opensearch-service-additional). | Arquitecto de la nube, desarrollador de aplicaciones |
| Eliminación de recursos. | Limpie todos los recursos que haya creado para evitar cargos adicionales en su cuenta. | AWS DevOps, arquitecto de nube, administrador de nube |
## Recursos relacionados
+ [AWS SDK para Python (Boto)](https://aws.amazon.com/sdk-for-python/)
+ [AWS Lambda documentación](https://docs.aws.amazon.com/lambda/)
+ [Documentación de API Gateway](https://docs.aws.amazon.com/apigateway/)
+ [Documentación de Amazon S3](https://docs.aws.amazon.com/s3/)
+ [Documentación OpenSearch de Amazon Service](https://docs.aws.amazon.com/elasticsearch-service/)
+ [Control de acceso detallado en Amazon Service OpenSearch ](https://docs.amazonaws.cn/en_us/elasticsearch-service/latest/developerguide/fgac.html)
+ [Creación de una aplicación de búsqueda con Amazon OpenSearch Service](https://docs.aws.amazon.com/elasticsearch-service/latest/developerguide/search-example.html)
+ [Lanzamiento de tus dominios OpenSearch de Amazon Service dentro de una VPC](https://docs.aws.amazon.com/elasticsearch-service/latest/developerguide/es-vpc.html)
## Información adicional
**Modelos de particionamiento de datos**
Hay tres modelos comunes de particionamiento de datos que se emplean en los sistemas multiusuario: silos, agrupados e híbridos. El modelo que elija dependerá de las necesidades de cumplimiento, ruido, operaciones y aislamiento de su entorno.
*Modelo de silo*
En el modelo de silo, los datos de cada usuario se almacenan en un área de almacenamiento distinta, por lo que los datos de los usuarios no se mezclan. Puede utilizar dos enfoques para implementar el modelo de silo con OpenSearch Service: dominio por inquilino e índice por inquilino.
+ **Dominio por inquilino**: puedes usar un dominio de OpenSearch servicio independiente (sinónimo de un clúster de Elasticsearch) por inquilino. Tener a cada usuario en su propio dominio proporciona todos los beneficios de tener los datos en un constructo independiente. Sin embargo, este enfoque presenta desafíos de gestión y agilidad. Su naturaleza distribuida dificulta la agregación y la evaluación del estado operativo y la actividad de los usuarios. Se trata de una opción costosa que requiere que cada dominio de OpenSearch servicio tenga como mínimo tres nodos principales y dos nodos de datos para las cargas de trabajo de producción.
![\[Modelo de silo de dominio por inquilino para arquitecturas de varios inquilinos sin servidor.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/750196bb-03f6-4b6e-92cd-eb7141602547/images/c2195f82-e5ed-40bb-b76a-3b0210bf1254.png)
+ **Índice por inquilino**: puede colocar los datos del inquilino en índices separados dentro de un clúster de OpenSearch servicios. Con este enfoque, se usa un identificador de inquilino al crear y asignar un nombre al índice, anteponiendo el identificador de inquilino al nombre del índice. El enfoque de índice por usuario le ayuda a alcanzar sus objetivos de compartimentación sin tener que introducir un clúster completamente separado para cada usuario. Sin embargo, si aumenta el número de índices, es posible que la memoria se agote, ya que este enfoque requiere más particiones y el nodo maestro tiene que gestionar una mayor asignación y reequilibrio.
![\[Modelo de silo por inquilino para arquitecturas de varios inquilinos sin servidor\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/750196bb-03f6-4b6e-92cd-eb7141602547/images/354a9463-25bb-422b-84de-d4875a7c8ea2.png)
**Modelo de aislamiento en silo**: en el modelo de silo, se emplean políticas de IAM para aislar los dominios o índices que contienen los datos de cada usuario. Estas políticas impiden que un usuario acceda a los datos de otro. Para implementar su modelo de aislamiento en silos, puede crear una política basada en recursos que controle el acceso al recurso de su usuario. Suele ser una política de acceso al dominio que especifica qué acciones puede realizar un principal en los subrecursos del dominio, incluidos los índices de Elasticsearch y. APIs Con las políticas de IAM basadas en la identidad, puede especificar las acciones *permitidas* o *denegadas en el dominio, los índices* o dentro del Servicio. APIs OpenSearch El elemento `Action` de una política de IAM describe la acción o acciones específicas permitidas y denegadas por la política. El elemento `Principal ` especifica las cuentas, usuarios o roles afectados.
El siguiente ejemplo de política otorga a Usuario-1 acceso total (según lo especificado en `es:*`) únicamente a los subrecursos del dominio `tenant-1`. El `/*` de seguimiento en el elemento `Resource` indica que esta política se aplica a los sub-recursos del dominio, no al dominio en sí. Cuando esta política esté en vigor, los usuarios no podrán crear un dominio nuevo ni modificar la configuración de un dominio existente.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam:::user/Tenant-1"
},
"Action": "es:*",
"Resource": "arn:aws:es:::domain/tenant-1/*"
}
]
}
```
Para implementar el modelo de silo de índice por inquilino, tendrá que modificar este ejemplo de política para restringir aún más a Inquilino-1 al índice o índices especificados, indicando el nombre del índice. El siguiente ejemplo de política restringe a Usuario-1 al índice `tenant-index-1`.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::123456789012:user/Tenant-1"
},
"Action": "es:*",
"Resource": "arn:aws:es:::domain/test-domain/tenant-index-1/*"
}
]
}
```
*Modelo de grupo*
En el modelo de grupo, todos los datos de los usuarios se almacenan en un índice dentro del mismo dominio. El identificador del usuario se incluye en los datos (documento) y se usa como clave de partición, de modo que puede determinar qué datos pertenecen a cada usuario. Este modelo reduce la sobrecarga de administración. Operar y administrar un índice agrupado es más fácil y eficiente que administrar varios índices. Sin embargo, dado que los datos de los usuarios están mezclados en el mismo índice, se pierde el aislamiento natural de los usuarios que proporciona el modelo de silos. Este enfoque también podría reducir el rendimiento debido al efecto de ruido aledaño.
![\[Modelo común para arquitecturas de varios inquilinos sin servidor\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/750196bb-03f6-4b6e-92cd-eb7141602547/images/c2c3bb0f-6ccd-47a7-ab67-e7f3f8c7f289.png)
**Aislamiento de usuarios en el modelo de grupo**: en general, el aislamiento de usuarios es difícil de implementar en el modelo de grupo. El mecanismo de IAM usado con el modelo de silo no permite describir el aislamiento en función del identificador de usuario almacenado en el documento.
Un enfoque alternativo consiste en usar el [control de acceso detallado](https://docs.aws.amazon.com/elasticsearch-service/latest/developerguide/fgac.html) (FGAC) que proporciona Open Distro para Elasticsearch. El FGAC permite controlar los permisos a nivel de índice, documento o campo. En cada solicitud, el FGAC evalúa las credenciales del usuario y autentica o deniega el acceso. Si el FGAC autentica al usuario, obtiene todos los roles mapeados a ese usuario y utiliza el conjunto completo de permisos para determinar cómo gestionar la solicitud.
Para lograr el aislamiento requerido en el modelo agrupado, puede usar [seguridad a nivel de documento](https://opendistro.github.io/for-elasticsearch-docs/docs/security/access-control/document-level-security/), que le permite restringir un rol a un subconjunto de documentos de un índice. El siguiente ejemplo de rol restringe las consultas a Usuario-1. Al aplicar este rol a Usuario-1, puede lograr el aislamiento necesario.
```
{
"bool": {
"must": {
"match": {
"tenantId": "Tenant-1"
}
}
}
}
```
*Modelo híbrido*
El modelo híbrido emplea una combinación de los modelos de silo y grupo en el mismo entorno para ofrecer experiencias únicas a cada nivel de usuario (como los niveles gratuito, estándar y prémium). Cada nivel sigue el mismo perfil de seguridad que se usó en el modelo de grupo.
![\[Modelo híbrido para arquitecturas de varios inquilinos sin servidor\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/750196bb-03f6-4b6e-92cd-eb7141602547/images/e7def98a-38ef-435a-9881-7e95ae4d4940.png)
**Aislamiento de usuarios en el modelo híbrido**: en el modelo híbrido, se sigue el mismo perfil de seguridad que en el modelo de grupo. El uso del modelo de seguridad FGAC a nivel de documento proporciona aislamiento a los usuarios. Si bien esta estrategia simplifica la administración de clústeres y ofrece agilidad, complica otros aspectos de la arquitectura. Por ejemplo, el código requiere una complejidad adicional para determinar qué modelo está asociado a cada usuario. También deberá asegurarse de que las consultas de un solo usuario no saturen todo el dominio ni degraden la experiencia de otros usuarios.
**Pruebas en API Gateway**
*Ventana de prueba para consulta de Usuario-1*
![\[Ventana de prueba para consulta de Inquilino-1\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/750196bb-03f6-4b6e-92cd-eb7141602547/images/a6757d3f-977a-4ecc-90cb-83ab7f1c3588.png)
*Ventana de prueba para consulta de Usuario-2*
![\[Ventana de prueba para consulta de Inquilino-2\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/750196bb-03f6-4b6e-92cd-eb7141602547/images/31bfd656-33ca-4750-b6e6-da4d703c2071.png)
## Conexiones
Para acceder al contenido adicional asociado a este documento, descomprima el archivo: [attachment.zip](samples/p-attach/750196bb-03f6-4b6e-92cd-eb7141602547/attachments/attachment.zip)
# Implemente aplicaciones de varias pilas mediante AWS CDK con TypeScript
*Dr. Rahul Sharad Gaikwad, Amazon Web Services*
## Resumen
Este patrón proporciona un step-by-step enfoque para la implementación de aplicaciones en Amazon Web Services (AWS) mediante el AWS Cloud Development Kit (AWS CDK) con TypeScript. Por ejemplo, el patrón implementa una aplicación de análisis en tiempo real sin servidor.
El patrón crea e implementa aplicaciones de pila anidada. La CloudFormation pila de AWS principal llama a las pilas secundarias o anidadas. Cada pila secundaria crea e implementa los recursos de AWS que se definen en la CloudFormation pila. AWS CDK Toolkit, el comando de la interfaz de línea de comandos (CLI)`cdk`, es la interfaz principal de las CloudFormation pilas.
## Requisitos previos y limitaciones
**Requisitos previos **
+ Una cuenta de AWS activa
+ Una nube privada virtual (VPC) y subredes existentes
+ Kit de herramientas de AWS CDK instalado y configurado
+ Un usuario con permisos de administrador y un conjunto de claves de acceso.
+ Node.js
+ Interfaz de la línea de comandos de AWS (AWS CLI)
**Limitaciones**
+ Como la CDK de AWS utiliza AWS CloudFormation, las aplicaciones de la CDK de AWS están sujetas a cuotas de CloudFormation servicio. Para obtener más información, consulte [ CloudFormation Cuotas de AWS](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cloudformation-limits.html).
**Versiones de producto**
Este patrón se ha creado y probado usando las siguientes herramientas y versiones.
+ Kit de herramientas de AWS CDK 1.83.0
+ Node.js 14.13.0
+ npm 7.0.14
El patrón debería funcionar con cualquier versión de AWS CDK o npm. Tenga en cuenta que las versiones 13.0.0 a 13.6.0 de Node.js no son compatibles con AWS CDK.
## Arquitectura
**Pila de tecnología de destino**
+ Consola de AWS Amplify
+ Amazon API Gateway
+ AWS CDK
+ Amazon CloudFront
+ Amazon Cognito
+ Amazon DynamoDB
+ Amazon Data Firehose
+ Amazon Kinesis Data Streams
+ AWS Lambda
+ Amazon Simple Storage Service (Amazon S3)
**Arquitectura de destino**
En el siguiente diagrama se muestra la implementación de aplicaciones de varias pilas mediante AWS CDK con. TypeScript
![\[Arquitectura de pilas en la VPC, con una pila principal y dos pilas secundarias que contienen recursos.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/0ac29a11-1362-4084-92ed-6b85205763ca/images/8f92e86a-aa3d-4f8a-9b11-b92c52a7226c.png)
En el siguiente diagrama se muestra la arquitectura de la aplicación en tiempo real sin servidor de ejemplo.
![\[Arquitectura de la aplicación en la región.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/0ac29a11-1362-4084-92ed-6b85205763ca/images/2df00faf-f871-4aec-9655-19ba2eb14cf8.png)
## Tools (Herramientas)
**Herramientas**
+ La [Consola de AWS Amplify](https://docs.aws.amazon.com/amplify/latest/userguide/welcome.html) es el centro de control para las implementaciones de aplicaciones web y móviles de pila completa en AWS. El alojamiento de la consola de Amplify proporciona un flujo de trabajo basado en Git para alojar aplicaciones web sin servidor de pila completa con implementación continua. La interfaz de usuario de administración es una interfaz visual para que los desarrolladores de frontend web y móvil puedan crear y administrar el backend de aplicaciones fuera de la Consola de AWS.
+ [Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/welcome.html) es un servicio de AWS para crear, publicar, mantener, supervisar y proteger REST, HTTP y WebSocket APIs a cualquier escala.
+ [AWS Cloud Development Kit (AWS CDK)](https://docs.aws.amazon.com/cdk/latest/guide/home.html) es un marco de desarrollo de software que le ayuda a definir y aprovisionar la infraestructura de la nube de AWS en código.
+ El [Kit de herramientas de AWS CDK](https://docs.aws.amazon.com/cdk/latest/guide/cli.html) es un kit de desarrollo en la nube de línea de comandos que le ayuda a interactuar con su aplicación AWS CDK. El comando `cdk` de la CLI es la herramienta principal para interactuar con su aplicación AWS CDK. Ejecuta su aplicación, interroga el modelo de aplicación que ha definido y produce e implementa las CloudFormation plantillas de AWS generadas por la CDK de AWS.
+ [Amazon CloudFront](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/Introduction.html) es un servicio web que acelera la distribución de contenido web estático y dinámico, como .html, .css, .js y archivos de imagen. CloudFront entrega su contenido a través de una red mundial de centros de datos denominados ubicaciones perimetrales para reducir la latencia y mejorar el rendimiento.
+ [Amazon Cognito](https://docs.aws.amazon.com/cognito/latest/developerguide/what-is-amazon-cognito.html) ofrece autenticación, autorización y administración de usuarios para sus aplicaciones móviles y web. Sus usuarios pueden iniciar sesión directamente o a través de un tercero.
+ [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) es un servicio de base de datos NoSQL totalmente administrado que ofrece un rendimiento rápido y predecible, así como una perfecta escalabilidad.
+ [Amazon Data Firehose](https://docs.aws.amazon.com/firehose/latest/dev/what-is-this-service.html) es un servicio totalmente gestionado para entregar [datos de streaming](https://aws.amazon.com/streaming-data/) en tiempo real a destinos como Amazon S3, Amazon Redshift, OpenSearch Amazon Service, Splunk y cualquier punto de enlace HTTP personalizado o punto de enlace HTTP propiedad de proveedores de servicios externos compatibles.
+ [Amazon Kinesis Data Streams](https://docs.aws.amazon.com/streams/latest/dev/introduction.html) es un servicio que permite recopilar y procesar grandes flujos de registros de datos en tiempo real.
+ [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) es un servicio de computación que permite ejecutar código sin aprovisionar ni administrar servidores. Lambda ejecuta su código solo cuando es necesario y escala de manera automática, desde unas pocas solicitudes por día hasta miles por segundo. Solo pagará por el tiempo de computación que consuma, no se aplican cargos cuando el código no se está ejecutando.
+ [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) es un servicio de almacenamiento de objetos basado en la nube que lo ayuda a almacenar, proteger y recuperar cualquier cantidad de datos.
**Código**
Se adjunta el código de este patrón.
## Epics
### Instalación del kit de herramientas de AWS CDK
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Instale el kit de herramientas de AWS CDK. | Para instalar el kit de herramientas de AWS CDK a nivel global, ejecute el siguiente comando.`npm install -g aws-cdk` | DevOps |
| Verificar la versión. | Para verificar la versión del kit de herramientas de AWS CDK, ejecute el siguiente comando. `cdk --version` | DevOps |
### Configuración de las credenciales de AWS
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Configurar las credenciales. | Para configurar las credenciales, ejecute el comando `aws configure` y siga las instrucciones.$aws configure
AWS Access Key ID [None]:
AWS Secret Access Key [None]: your_secret_access_key
Default region name [None]:
Default output format [None]:
| DevOps |
### Descarga del código del proyecto
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Descargar el código del proyecto adjunto. | Para obtener más información sobre la estructura de los directorios y archivos, consulte la sección *Información adicional*. | DevOps |
### Inicie el entorno de AWS CDK
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Inicie el entorno. | Para implementar la CloudFormation plantilla de AWS en la cuenta y la región de AWS que desee usar, ejecute el siguiente comando.`cdk bootstrap /`Para obtener más información, consulte la [documentación de AWS](https://docs.aws.amazon.com/cdk/latest/guide/bootstrapping.html). | DevOps |
### Crear e implementar el proyecto
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Compilar el proyecto. | Para compilar el código del proyecto, ejecute el comando `npm run build`. | DevOps |
| Implementar el proyecto. | Para implementar el código del proyecto, ejecute el comando `cdk deploy`. | |
### Verificación de resultados
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Verificar la creación de la pila. | En la consola de administración de AWS, elija **CloudFormation**. En las pilas del proyecto, verifique que se hayan creado una pila principal y dos pilas secundarias. | DevOps |
### Pruebe la aplicación
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Enviar datos a Kinesis Data Streams. | Configure su cuenta de AWS para enviar datos a Kinesis Data Streams mediante Amazon Kinesis Data Generator (KDG). Para obtener más información, consulte [Amazon Kinesis Data Generator](https://awslabs.github.io/amazon-kinesis-data-generator/web/help.html). | DevOps |
| Crear un usuario de Amazon Cognito. | [Para crear un usuario de Amazon Cognito, descargue la plantilla cognito-setup.json de la sección Crear un *usuario de Amazon Cognito de CloudFormation la página de ayuda del generador de datos de Kinesis*.](https://awslabs.github.io/amazon-kinesis-data-generator/web/help.html) Inicie la plantilla y, a continuación, introduzca su nombre de **usuario** y **contraseña** de Amazon Cognito.La pestaña **Salidas** muestra la URL de Kinesis Data Generator. | DevOps |
| Inicio de sesión en Kinesis Data Generator | Para iniciar sesión en KDG, utilice las credenciales de Amazon Cognito que ha introducido y la URL de Kinesis Data Generator. | DevOps |
| Probar la aplicación. | En KDG, en **Plantilla de registro**, **Plantilla 1**, pegue el código de prueba de la sección *Información adicional* y seleccione **Enviar datos**. | DevOps |
| Probar API Gateway. | Una vez incorporados los datos, pruebe API Gateway mediante el método `GET` para recuperar los datos. | DevOps |
## Recursos relacionados
**Referencias**
+ [AWS Cloud Development Kit](https://aws.amazon.com/cdk/)
+ [AWS CDK en GitHub](https://github.com/aws/aws-cdk)
+ [Uso de pilas anidadas](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-nested-stacks.html)
+ [Ejemplo de muestra de AWS: análisis en tiempo real sin servidor](https://github.com/aws-samples/serverless-realtime-analytics)
## Información adicional
**Detalles del directorio y el archivo**
Este patrón configura las tres siguientes pilas.
+ `parent-cdk-stack.ts`: esta pila actúa como pila principal y llama a las dos aplicaciones secundarias como pilas anidadas.
+ `real-time-analytics-poc-stack.ts`: esta pila anidada contiene la infraestructura y el código de la aplicación.
+ `real-time-analytics-web-stack.ts`: esta pila anidada contiene únicamente el código estático de la aplicación web.
*Archivos importantes y su funcionalidad*
+ `bin/real-time-analytics-poc.ts`: punto de entrada de la aplicación AWS CDK. Carga todas las pilas definidas en `lib/`.
+ `lib/real-time-analytics-poc-stack.ts`: definición de la pila de la aplicación AWS CDK (`real-time-analytics-poc`).
+ `lib/real-time-analytics-web-stack.ts`: definición de la pila de la aplicación AWS CDK (`real-time-analytics-web-stack`).
+ `lib/parent-cdk-stack.ts`: definición de la pila de la aplicación AWS CDK (`parent-cdk`).
+ `package.json`: manifiesto del módulo npm, que incluye el nombre, la versión y las dependencias de la aplicación.
+ `package-lock.json`: mantenimiento por parte de npm.
+ `cdk.json`: kit de herramientas para ejecutar la aplicación.
+ `tsconfig.json`— La TypeScript configuración del proyecto.
+ `.gitignore`: lista de archivos que Git debe excluir del control de código de origen.
+ `node_modules`: mantenimiento por parte de npm; incluye las dependencias del proyecto.
La siguiente sección de código de la pila principal llama a las aplicaciones secundarias como pilas anidadas de AWS CDK.
```
import * as cdk from '@aws-cdk/core';
import { Construct, Stack, StackProps } from '@aws-cdk/core';
import { RealTimeAnalyticsPocStack } from './real-time-analytics-poc-stack';
import { RealTimeAnalyticsWebStack } from './real-time-analytics-web-stack';
export class CdkParentStack extends Stack {
constructor(scope: Construct, id: string, props?: StackProps) {
super(scope, id, props);
new RealTimeAnalyticsPocStack(this, 'RealTimeAnalyticsPocStack');
new RealTimeAnalyticsWebStack(this, 'RealTimeAnalyticsWebStack');
}
}
```
**Código para realizar pruebas**
```
session={{date.now('YYYYMMDD')}}|sequence={{date.now('x')}}|reception={{date.now('x')}}|instrument={{random.number(9)}}|l={{random.number(20)}}|price_0={{random.number({"min":10000, "max":30000})}}|price_1={{random.number({"min":10000, "max":30000})}}|price_2={{random.number({"min":10000, "max":30000})}}|price_3={{random.number({"min":10000, "max":30000})}}|price_4={{random.number({"min":10000, "max":30000})}}|price_5={{random.number({"min":10000, "max":30000})}}|price_6={{random.number({"min":10000, "max":30000})}}|price_7={{random.number({"min":10000, "max":30000})}}|price_8={{random.number({"min":10000, "max":30000})}}|
```
**Pruebas de API Gateway**
En la consola de API Gateway, pruebe API Gateway mediante el método `GET`.
![\[La consola de API Gateway con GET se selecciona en OPCIONES.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/0ac29a11-1362-4084-92ed-6b85205763ca/images/452e5b8f-6d61-401d-8484-e5a436cb6f1b.png)
## Conexiones
Para acceder al contenido adicional asociado a este documento, descomprima el archivo: [attachment.zip](samples/p-attach/0ac29a11-1362-4084-92ed-6b85205763ca/attachments/attachment.zip)
# Automatice la implementación de aplicaciones anidadas mediante SAM de AWS
*Dr. Rahul Sharad Gaikwad, Ishwar Chauthaiwale, Dmitry Gulin y Tabby Ward, Amazon Web Services*
## Resumen
En Amazon Web Services (AWS), el AWS Serverless Application Model (AWS SAM) es un marco de código abierto que proporciona una sintaxis abreviada para expresar funciones APIs, bases de datos y mapeos de fuentes de eventos. Con solo unas pocas líneas para cada recurso, puede definir la aplicación que desee y modelarla mediante YAML. Durante la implementación, SAM transforma y expande la sintaxis de SAM en una CloudFormation sintaxis de AWS que puede usar para crear aplicaciones sin servidor con mayor rapidez.
SAM de AWS simplifica el desarrollo, la implementación y la administración de aplicaciones sin servidor en la plataforma AWS. Proporciona un marco estandarizado, una implementación más rápida, capacidades de pruebas locales, administración de recursos, una integración perfecta con las herramientas de desarrollo y una comunidad de apoyo. Estas características lo convierten en una herramienta valiosa para crear aplicaciones sin servidor de manera eficiente y eficaz.
Este patrón utiliza plantillas SAM de AWS para automatizar la implementación de aplicaciones anidadas. Una aplicación anidada es una aplicación dentro de otra aplicación. Las aplicaciones principales llaman a las aplicaciones secundarias. Se trata de componentes con acoplamiento flexible de una arquitectura sin servidor.
Con aplicaciones anidadas, puede crear rápidamente arquitecturas sin servidor altamente sofisticadas mediante la reutilización de servicios o componentes que se crean y mantienen de forma independiente, pero que se componen con SAM de AWS y Repositorio de aplicaciones sin servidor. Las aplicaciones anidadas le ayudan a crear aplicaciones más potentes, evitar la duplicación del trabajo y garantizar la coherencia y las prácticas recomendadas en todos sus equipos y organizaciones. Para mostrar las aplicaciones anidadas, el patrón implementa un ejemplo de aplicación de carrito de [compras sin servidor de AWS](https://github.com/aws-samples/aws-sam-nested-stack-sample).
## Requisitos previos y limitaciones
**Requisitos previos **
+ Una cuenta de AWS activa
+ Una nube privada virtual (VPC) y subredes existentes
+ Un entorno de desarrollo integrado como Visual Studio Code (para obtener más información, consulte [Herramientas para crear en AWS](https://aws.amazon.com/getting-started/tools-sdks/#IDE_and_IDE_Toolkits))
+ Biblioteca de ruedas de Python instalada con pip install wheel, si aún no está instalada
**Limitaciones**
+ El número máximo de aplicaciones que se pueden anidar en una aplicación sin servidor es de 200.
+ El número máximo de parámetros que puede tener una aplicación anidada es 60.
**Versiones de producto**
+ Esta solución se basa en la versión 1.21.1 de la interfaz de la línea de comandos de SAM de AWS (CLI de SAM de AWS), pero esta arquitectura debería funcionar con versiones posteriores de la CLI de SAM de AWS.
## Arquitectura
**Pila de tecnología de destino**
+ Amazon API Gateway
+ SAM de AWS
+ Amazon Cognito
+ Amazon DynamoDB
+ AWS Lambda
+ Cola de Amazon Simple Queue Service (Amazon SQS)
**Arquitectura de destino**
El siguiente diagrama muestra cómo se realizan las solicitudes de los usuarios a los servicios de compras llamando por teléfono APIs. La solicitud del usuario, incluida toda la información necesaria, se envía a Amazon API Gateway y al autorizador de Amazon Cognito, que ejecuta los mecanismos de autenticación y autorización para el. APIs
Cuando se agrega, elimina o actualiza un elemento en DynamoDB, se coloca un evento en DynamoDB Streams, que a su vez inicia una función de Lambda. Para evitar la eliminación inmediata de elementos antiguos como parte de un flujo de trabajo sincrónico, los mensajes se colocan en una cola de SQS, lo que inicia una función de trabajo para eliminarlos.
![\[Operaciones POST y PUT de API Gateway para funciones de Lambda, DynamoDB y Product Service.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/218adecc-b5b8-4193-9012-b5d584e2e128/images/5b454bae-5fd4-405d-a37d-6bafc3fcf889.png)
En esta configuración de solución, la CLI de AWS SAM sirve de interfaz para las CloudFormation pilas de AWS. Las plantillas SAM de AWS implementan automáticamente aplicaciones anidadas. La plantilla SAM principal llama a las plantillas secundarias y la CloudFormation pila principal implementa las pilas secundarias. Cada pila secundaria crea los recursos de AWS que se definen en las CloudFormation plantillas de AWS SAM.
![\[Proceso de cuatro pasos mediante la CLI de AWS SAM con una pila principal y tres secundarias CloudFormation .\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/218adecc-b5b8-4193-9012-b5d584e2e128/images/5828026e-72ad-4a3f-a5f2-bffac0f13e42.png)
1. Genere e implemente las pilas.
1. La CloudFormation pila de autenticación contiene Amazon Cognito.
1. La CloudFormation pila de productos contiene una función Lambda y Amazon API Gateway
1. La CloudFormation pila de compras contiene una función Lambda, Amazon API Gateway, la cola SQS y la base de datos Amazon DynamoDB.
## Tools (Herramientas)
**Herramientas**
+ [Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/welcome.html) le ayuda a crear, publicar, mantener, supervisar y proteger REST, HTTP y WebSocket APIs a cualquier escala.
+ [AWS](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html) le CloudFormation ayuda a configurar los recursos de AWS, aprovisionarlos de forma rápida y coherente y gestionarlos durante todo su ciclo de vida en todas las cuentas y regiones de AWS.
+ [Amazon Cognito](https://docs.aws.amazon.com/cognito/latest/developerguide/what-is-amazon-cognito.html) ofrece autenticación, autorización y administración de usuarios para aplicaciones móviles y web.
+ [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) es un servicio de base de datos de NoSQL completamente administrado que ofrece un rendimiento rápido, predecible y escalable.
+ [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) es un servicio de computación que ayuda a ejecutar código sin necesidad de aprovisionar ni administrar servidores. Ejecuta el código solo cuando es necesario y amplía la capacidad de manera automática, por lo que solo pagará por el tiempo de procesamiento que utilice.
+ [AWS Serverless Application Model (AWS SAM)](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/what-is-sam.html) es un marco de código abierto que permite crear aplicaciones sin servidor en la nube de AWS.
+ [Amazon Simple Queue Service (Amazon SQS)](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/welcome.html) ofrece una cola alojada segura, duradera y disponible que le permite integrar y desacoplar sistemas y componentes de software distribuidos.
**Código**
El código de este patrón está disponible en el repositorio de [muestras de GitHub AWS SAM Nested Stack](https://github.com/aws-samples/aws-sam-nested-stack-sample).
## Epics
### Instalar la CLI de SAM de AWS
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Instalar la CLI de SAM de AWS. | Para instalar la CLI de SAM de AWS, siga las instrucciones de la [documentación de SAM de AWS](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html). | DevOps ingeniero |
| Configure las credenciales de AWS. | Para configurar las credenciales de AWS para que la CLI de SAM de AWS pueda realizar llamadas a los servicios de AWS en su nombre, ejecute el comando `aws configure` y siga las instrucciones.$aws configure
AWS Access Key ID [None]:
AWS Secret Access Key [None]: your_secret_access_key
Default region name [None]:
Default output format [None]:
Para obtener más información sobre cómo configurar sus credenciales, consulte [credenciales de autenticación y acceso](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-authentication.html). | DevOps ingeniero |
### Inicie el proyecto SAM de AWS
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Clone el repositorio de código de SAM de AWS. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/automate-deployment-of-nested-applications-using-aws-sam.html) | DevOps ingeniero |
| Implemente plantillas para iniciar el proyecto. | Ejecute el comando `SAM init` para iniciar el proyecto. Cuando se le pida que elija una fuente de plantilla, elija `Custom Template Location`. | DevOps ingeniero |
### Compile y cree el código de la plantilla SAM
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Revise las plantillas de aplicaciones SAM de AWS. | Revise las plantillas de las aplicaciones anidadas. En este ejemplo se utilizan las siguientes plantillas de aplicaciones anidadas:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/automate-deployment-of-nested-applications-using-aws-sam.html) | DevOps ingeniero |
| Revise la plantilla principal. | Revise la plantilla que invocará las plantillas de aplicación anidadas. En este ejemplo, la plantilla principal es `template.yml`. Todas las aplicaciones independientes están anidadas en la plantilla principal única `template.yml`. | DevOps ingeniero |
| Compile y cree el código de la plantilla SAM de AWS. | Ejecute el siguiente comando utilizando la CLI de SAM de AWS.sam build
| DevOps ingeniero |
### Implemente la plantilla SAM de AWS
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Implemente las aplicaciones. | Para lanzar el código de plantilla SAM que crea las CloudFormation pilas de aplicaciones anidadas y despliega el código en el entorno de AWS, ejecute el siguiente comando.sam deploy --guided --stack-name shopping-cart-nested-stack --capabilities CAPABILITY_IAM CAPABILITY_AUTO_EXPAND
El comando aparecerá con algunas preguntas. Responda a todas las preguntas con `y`. | DevOps ingeniero |
### Verifique la implementación
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Verifique las pilas. | Para revisar las CloudFormation pilas de AWS y los recursos de AWS que se definieron en las plantillas de AWS SAM, haga lo siguiente:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/automate-deployment-of-nested-applications-using-aws-sam.html) | DevOps ingeniero |
## Recursos relacionados
**Referencias**
+ [AWS Serverless Application Model (AWS SAM)](https://aws.amazon.com/serverless/sam/#:~:text=The%20AWS%20Serverless%20Application%20Model,and%20model%20it%20using%20YAML.)
+ [AWS SAM en GitHub](https://github.com/aws/serverless-application-model)
+ [Microservicio de carrito de compras sin servidor](https://github.com/aws-samples/aws-serverless-shopping-cart) (ejemplo de aplicación de AWS)
**Tutoriales y videos**
+ [Cree una aplicación sin servidor](https://youtu.be/Hv3YrP8G4ag)
+ [Charlas técnicas online de AWS: creación e implementación de aplicaciones sin servidor con SAM de AWS](https://youtu.be/1NU7vyJw9LU)
## Información adicional
Una vez colocado todo el código, el ejemplo tiene la siguiente estructura de directorios:
+ [sam\$1stacks](https://docs.aws.amazon.com/lambda/latest/dg/chapter-layers.html): esta carpeta contiene la capa `shared.py`. Una capa es un archivo que contiene bibliotecas, un tiempo de ejecución personalizado u otras dependencias. Con las capas, puede utilizar las bibliotecas en la función sin necesidad de incluirlas en el paquete de implementación.
+ *product-mock-service*— Esta carpeta contiene todos los archivos y funciones de Lambda relacionados con el producto.
+ *shopping-cart-service*— Esta carpeta contiene todas las funciones y archivos de Lambda relacionados con las compras.
# Implemente el aislamiento de inquilinos de SaaS para Amazon S3 mediante una máquina expendedora de AWS Lambda fichas
*Tabby Ward, Thomas Davis y Sravan Periyathambi, Amazon Web Services*
## Resumen
Las aplicaciones SaaS multiusuario deben implementar sistemas para garantizar que se mantenga el aislamiento de los usuarios. Cuando almacenas datos de inquilinos en el mismo AWS recurso (por ejemplo, cuando varios inquilinos almacenan datos en el mismo depósito de Amazon Simple Storage Service (Amazon S3), debes asegurarte de que no se pueda producir el acceso entre inquilinos. Las máquinas expendedoras de fichas (TVMs) son una forma de aislar los datos de los inquilinos. Estas máquinas proporcionan un mecanismo para obtener tokens y, al mismo tiempo, simplifican la complejidad inherente a la creación de dichos tokens. Los desarrolladores pueden usar una TVM sin tener un conocimiento detallado de cómo la máquina produce los tokens.
Este patrón implementa una TVM mediante el uso de. AWS Lambda La TVM genera un token con credenciales del servicio de token de seguridad (STS) temporales que limitan el acceso a los datos de un único usuario de SaaS en un bucket de S3.
TVMs, y el código que se proporciona con este patrón, se suelen utilizar con afirmaciones derivadas de los JSON Web Tokens (JWTs) para asociar las solicitudes de AWS recursos a una política orientada a los inquilinos AWS Identity and Access Management (IAM). Puede usar el código de este patrón como base para implementar una aplicación SaaS que genere credenciales STS temporales y limitadas en función de las afirmaciones proporcionadas en un token JWT.
## Requisitos previos y limitaciones
**Requisitos previos **
+ Un activo. Cuenta de AWS
+ AWS Command Line Interface (AWS CLI) [versión 1.19.0 o posterior](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv1.html), instalada y configurada en macOS, Linux o Windows. Como alternativa, puede utilizar la AWS CLI [versión 2.1 o posterior](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv2.html).
**Limitaciones**
+ Este código se ejecuta en Java y, actualmente, no es compatible con otros lenguajes de programación.
+ La aplicación de ejemplo no incluye compatibilidad AWS entre regiones ni con la recuperación ante desastres (DR).
+ Este patrón demuestra cómo puede proporcionar acceso limitado a los usuarios una TVM de Lambda para una aplicación SaaS. Este patrón no está diseñado para usarse en entornos de producción sin pruebas de seguridad adicionales como parte de su aplicación o caso de uso específicos.
## Arquitectura
**Pila de tecnología de destino**
+ AWS Lambda
+ Amazon S3
+ IAM
+ AWS Security Token Service (AWS STS)
**Arquitectura de destino**
![\[Generación de un token para obtener credenciales de STS temporales para acceder a los datos de un bucket de S3.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/97a34c8e-d04e-40b6-acbf-1baa176d22a9/images/14d0508a-703b-4229-85e6-c5094de7fe01.png)
## Tools (Herramientas)
**Servicios de AWS**
+ [AWS Command Line Interface (AWS CLI)](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) es una herramienta de código abierto que te ayuda a interactuar Servicios de AWS mediante comandos en el shell de la línea de comandos.
+ [AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) le ayuda a administrar de forma segura el acceso a sus AWS recursos al controlar quién está autenticado y autorizado a usarlos.
+ [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) es un servicio de computación que ayuda a ejecutar código sin necesidad de aprovisionar ni administrar servidores. Ejecuta el código solo cuando es necesario y amplía la capacidad de manera automática, por lo que solo pagará por el tiempo de procesamiento que utilice.
+ [AWS Security Token Service (AWS STS)](https://docs.aws.amazon.com/STS/latest/APIReference/welcome.html) le ayuda a solicitar credenciales temporales con privilegios limitados para los usuarios.
+ [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) es un servicio de almacenamiento de objetos basado en la nube que lo ayuda a almacenar, proteger y recuperar cualquier cantidad de datos.
**Código**
El código fuente de este patrón está disponible como archivo adjunto, e incluye los siguientes archivos:
+ `s3UploadSample.jar` proporciona el código fuente de una función de Lambda que carga un documento JSON en un bucket de S3.
+ `tvm-layer.zip` proporciona una biblioteca Java reutilizable que suministra un token (credenciales temporales de STS) para que la función de Lambda acceda al bucket de S3 y cargue el documento JSON.
+ `token-vending-machine-sample-app.zip` proporciona el código fuente usado para crear estos artefactos y las instrucciones de compilación.
Para usar el código de muestra, siga las instrucciones de la siguiente sección.
## Epics
### Determine los valores de las variables
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Determine los valores de las variables. | La implementación de este patrón incluye varios nombres de variables que deben usarse de manera coherente. Determine los valores a usar para cada variable y proporcione cada valor cuando se le solicite en los siguientes pasos.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/implement-saas-tenant-isolation-for-amazon-s3-by-using-an-aws-lambda-token-vending-machine.html) | Administrador de la nube |
### Creación de un bucket de S3
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Cree un bucket de S3 para la aplicación de ejemplo. | Usa el siguiente AWS CLI comando para crear un bucket de S3. Proporcione el valor de ``** **en el fragmento de código:aws s3api create-bucket --bucket
La aplicación de ejemplo de Lambda carga archivos JSON en este bucket. | Administrador de la nube |
### Creación de una política y un rol de IAM TVM
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Crear un rol de TVM. | Utilice uno de los siguientes AWS CLI comandos para crear un rol de IAM. Proporcione el valor de ``** **en el comando.Para los intérprete de comandos para macOS o Linux:aws iam create-role \
--role-name \
--assume-role-policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"sts:AssumeRole"
],
"Principal": {
"Service": [
"lambda.amazonaws.com"
]
},
"Condition": {
"StringEquals": {
"aws:SourceAccount": ""
}
}
}
]
}'
En la línea de comandos de Windows:aws iam create-role ^
--role-name ^
--assume-role-policy-document "{\"Version\": \"2012-10-17\", \"Statement\": [{\"Effect\": \"Allow\", \"Action\": [\"sts:AssumeRole\"], \"Principal\": {\"Service\": [\"lambda.amazonaws.com\"]}, \"Condition\": {\"StringEquals\": {\"aws:SourceAccount\": \"\"}}}]}"
La aplicación de ejemplo de Lambda asume este rol cuando se invoca la aplicación. La capacidad de asumir el rol de aplicación con una política específica otorga al código permisos más amplios para acceder al bucket de S3. | Administrador de la nube |
| Cree una política de rol de TVM en línea. | Utilice uno de los siguientes AWS CLI comandos para crear una política de IAM. Proporcione los valores de ``,** **`` y `` en el comando.Para los intérprete de comandos para macOS o Linux:aws iam put-role-policy \
--role-name \
--policy-name assume-app-role \
--policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "sts:AssumeRole",
"Resource": "arn:aws:iam:::role/"
}
]}'
En la línea de comandos de Windows:aws iam put-role-policy ^
--role-name ^
--policy-name assume-app-role ^
--policy-document "{\"Version\": \"2012-10-17\", \"Statement\": [{\"Effect\": \"Allow\", \"Action\": \"sts:AssumeRole\", \"Resource\": \"arn:aws:iam:::role/\"}]}"
Esta política está asociada al rol de TVM. Proporciona la capacidad de asumir el rol de aplicación que otorga permisos más amplios para acceder al bucket de S3. | Administrador de la nube |
| Adjunte la política de Lambda gestionada. | Utilice el siguiente AWS CLI comando para adjuntar la política de `AWSLambdaBasicExecutionRole` IAM. Proporcione el valor de `` en el comando:aws iam attach-role-policy \
--role-name \
--policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
En la línea de comandos de Windows:aws iam attach-role-policy ^
--role-name ^
--policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
Esta política gestionada se adjunta a la función TVM para permitir que Lambda envíe registros a Amazon. CloudWatch | Administrador de la nube |
### Cree la política y el rol de aplicación de IAM
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Crear el rol de la aplicación. | Utilice uno de los siguientes AWS CLI comandos para crear un rol de IAM. Proporcione los valores de ``, `` y `` en el comando.Para los intérprete de comandos para macOS o Linux:aws iam create-role \
--role-name \
--assume-role-policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Effect":
"Allow",
"Principal": {
"AWS": "arn:aws:iam:::role/"
},
"Action": "sts:AssumeRole"
}
]}'
En la línea de comandos de Windows:aws iam create-role ^
--role-name ^
--assume-role-policy-document "{\"Version\": \"2012-10-17\", \"Statement\": [{\"Effect\": \"Allow\",\"Principal\": {\"AWS\": \"arn:aws:iam:::role/\"},\"Action\": \"sts:AssumeRole\"}]}"
La aplicación de ejemplo de Lambda asume esta función con una política específica para obtener acceso basado en usuario a un bucket de S3. | Administrador de la nube |
| Cree una política de rol de aplicación en línea. | Utilice uno de los siguientes comandos para crear una AWS CLI política de IAM. Proporcione los valores de `` y ``** **en el comando.Para los intérprete de comandos para macOS o Linux:aws iam put-role-policy \
--role-name \
--policy-name s3-bucket-access \
--policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:GetObject",
"s3:DeleteObject"
],
"Resource": "arn:aws:s3:::/*"
},
{
"Effect": "Allow",
"Action": ["s3:ListBucket"],
"Resource": "arn:aws:s3:::"
}
]}'
En la línea de comandos de Windows:aws iam put-role-policy ^
--role-name ^
--policy-name s3-bucket-access ^
--policy-document "{\"Version\": \"2012-10-17\", \"Statement\": [{\"Effect\": \"Allow\", \"Action\": [\"s3:PutObject\", \"s3:GetObject\", \"s3:DeleteObject\"], \"Resource\": \"arn:aws:s3:::/*\"}, {\"Effect\": \"Allow\", \"Action\": [\"s3:ListBucket\"], \"Resource\": \"arn:aws:s3:::\"}]}"
Esta política está asociada al rol de la aplicación. Proporciona un acceso amplio a los objetos del bucket de S3. Cuando la aplicación de ejemplo asume el rol, estos permisos se asignan a un usuario específico con la política de TVM generada de forma dinámica. | Administrador de la nube |
### Cree la aplicación de muestra de Lambda con TVM
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Descargue los archivos fuente compilados. | Descargue los archivos `s3UploadSample.jar` y `tvm-layer.zip`****, que se incluyen como adjuntos. El código fuente utilizado para crear estos artefactos y las instrucciones de compilación se proporcionan en `token-vending-machine-sample-app.zip`. | Administrador de la nube |
| Cree la capa de Lambda. | Utilice el siguiente AWS CLI comando para crear una capa Lambda, que haga que Lambda pueda acceder a la TVM. Si no ejecuta este comando desde la ubicación en la que descargó ` tvm-layer.zip`, indique la ruta correcta a `tvm-layer.zip` en el parámetro `--zip-file`. aws lambda publish-layer-version \
--layer-name sample-token-vending-machine \
--compatible-runtimes java11 \
--zip-file fileb://tvm-layer.zip
En la línea de comandos de Windows:aws lambda publish-layer-version ^
--layer-name sample-token-vending-machine ^
--compatible-runtimes java11 ^
--zip-file fileb://tvm-layer.zip
Este comando crea una capa de Lambda que contiene la biblioteca TVM reutilizable. | Administrador de la nube, desarrollador de aplicaciones |
| Crear la función de Lambda. | Utilice el siguiente AWS CLI comando para crear una función Lambda. Proporcione los valores de ``, ``, ``, ``, `` y `` en el comando. Si no ejecuta este comando desde la ubicación en la que descargó `s3UploadSample.jar`, indique la ruta correcta a `s3UploadSample.jar` en el parámetro `--zip-file`. aws lambda create-function \
--function-name \
--timeout 30 \
--memory-size 256 \
--runtime java11 \
--role arn:aws:iam:::role/ \
--handler com.amazon.aws.s3UploadSample.App \
--zip-file fileb://s3UploadSample.jar \
--layers arn:aws:lambda:::layer:sample-token-vending-machine:1 \
--environment "Variables={S3_BUCKET=,
ROLE=arn:aws:iam:::role/}"
En la línea de comandos de Windows:aws lambda create-function ^
--function-name ^
--timeout 30 ^
--memory-size 256 ^
--runtime java11 ^
--role arn:aws:iam:::role/ ^
--handler com.amazon.aws.s3UploadSample.App ^
--zip-file fileb://s3UploadSample.jar ^
--layers arn:aws:lambda:::layer:sample-token-vending-machine:1 ^
--environment "Variables={S3_BUCKET=,ROLE=arn:aws:iam:::role/}"
Este comando crea una función de Lambda con el código de la aplicación de ejemplo y la capa de TVM adjunta. También establece dos variables de entorno: `S3_BUCKET` y `ROLE`. La aplicación de ejemplo usa estas variables para determinar el rol que debe asumir y el bucket de S3 en el que se deben cargar los documentos JSON. | Administrador de la nube, desarrollador de aplicaciones |
### Pruebe la aplicación de muestra y TVM
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Invoque la aplicación de ejemplo de Lambda. | Utilice uno de los siguientes AWS CLI comandos para iniciar la aplicación de ejemplo de Lambda con la carga útil esperada. Proporcione los valores de `` y `` en el comando.Para intérprete de comandos macOS y Linux:aws lambda invoke \
--function \
--invocation-type RequestResponse \
--payload '{"tenant": ""}' \
--cli-binary-format raw-in-base64-out response.json
En la línea de comandos de Windows:aws lambda invoke ^
--function ^
--invocation-type RequestResponse ^
--payload "{\"tenant\": \"\"}" ^
--cli-binary-format raw-in-base64-out response.json
Este comando llama a la función de Lambda y devuelve el resultado en un documento `response.json`. En muchos sistemas basados en Unix, puede cambiar `response.json` a `/dev/stdout` para enviar los resultados directamente a su intérprete de comandos sin necesidad de crear otro archivo. Si cambia el valor de `` en las siguientes invocaciones de esta función de Lambda, se modificará la ubicación del documento JSON y los permisos proporcionados por el token. | Administrador de la nube, desarrollador de aplicaciones |
| Acceda al bucket de S3 para ver los objetos creados. | Acceda al bucket de S3 (``) que creó anteriormente. Este bucket contiene un prefijo de objeto de S3 con el valor de ``. Bajo ese prefijo, encontrará un documento JSON denominado con un UUID. Si invoca la aplicación de ejemplo varias veces, se añadirán más documentos JSON. | Administrador de la nube |
| Vea los registros de la aplicación de muestra en CloudWatch Logs. | Vea los registros que están asociados a la función Lambda nombrada `` en CloudWatch Logs. Para obtener instrucciones, consulte [Envío de registros de funciones de Lambda a CloudWatch registros](https://docs.aws.amazon.com/lambda/latest/dg/monitoring-cloudwatchlogs.html) en la documentación de Lambda. En estos registros puede ver la política basada en usuario generada por la TVM. Esta política dirigida al inquilino otorga permisos para la aplicación de ejemplo a Amazon S3 **PutObject**,, y **GetObject**DeleteObject**ListBucket****** APIs, pero solo para el prefijo de objeto al que está asociado. `` En las siguientes invocaciones de la aplicación de muestra, si cambia ``, la TVM actualizará la política con el ámbito de aplicación para adaptarla al inquilino proporcionado en la carga útil de invocación. Esta política generada dinámicamente muestra cómo se puede mantener el acceso basado en usuario con una TVM en aplicaciones SaaS. La funcionalidad de TVM se proporciona en una capa de Lambda. Así, es posible adjuntarla a otras funciones de Lambda usadas por una aplicación sin tener que replicar el código.Para ver un ejemplo de la política generada dinámicamente, consulte la sección de [Información adicional](#implement-saas-tenant-isolation-for-amazon-s3-by-using-an-aws-lambda-token-vending-machine-additional). | Administrador de la nube |
## Recursos relacionados
+ [Aislar a los usuarios con políticas de IAM generadas dinámicamente](https://aws.amazon.com/blogs/apn/isolating-saas-tenants-with-dynamically-generated-iam-policies/) (publicación del blog)
+ [Applying Dynamically Generated Isolation Policies in SaaS Environments](https://aws.amazon.com/blogs/apn/applying-dynamically-generated-isolation-policies-in-saas-environments/) (entrada en el blog)
+ [SaaS en AWS](https://aws.amazon.com/saas/)
## Información adicional
En el siguiente registro se muestra la política generada de forma dinámica y creada por el código de la TVM de este patrón. En esta captura de pantalla, `` es `DOC-EXAMPLE-BUCKET` y `` es `test-tenant-1`. Las credenciales de STS emitidas por esta política limitada no pueden realizar ninguna acción en los objetos del bucket de S3, excepto en aquellos objetos asociados al prefijo de clave de objeto `test-tenant-1`.
![\[Registro en el que se muestra una política generada de forma dinámica y creada por el código de la TVM.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/97a34c8e-d04e-40b6-acbf-1baa176d22a9/images/d4776ebe-fb8f-41ac-b8c5-b4f97a821c8c.png)
## Conexiones
Para acceder al contenido adicional asociado a este documento, descomprima el archivo: [attachment.zip](samples/p-attach/97a34c8e-d04e-40b6-acbf-1baa176d22a9/attachments/attachment.zip)
# Implementar el patrón saga sin servidor mediante AWS Step Functions
*Tabby Ward, Joe Kern y Rohan Mehta, Amazon Web Services*
## Resumen
En una arquitectura de microservicios, el objetivo principal es crear componentes disociados e independientes para promover la agilidad, la flexibilidad y reducir el tiempo de comercialización de sus aplicaciones. Como resultado del desacoplamiento, cada componente del microservicio tiene su propia capa de persistencia de datos. En una arquitectura distribuida, las transacciones comerciales pueden abarcar varios microservicios. Como estos microservicios no pueden utilizar una sola transacción de atomicidad, coherencia, aislamiento y durabilidad (ACID), es posible que acabe con transacciones parciales. En este caso, se necesita alguna lógica de control para deshacer las transacciones que ya se han procesado. El patrón saga distribuido se utiliza normalmente para este propósito.
El patrón saga es un patrón de gestión de fallos que ayuda a establecer la coherencia en las aplicaciones distribuidas y coordina las transacciones entre varios microservicios para mantener la coherencia de los datos. Si se utiliza el patrón «saga», cada servicio que realiza una transacción publica un evento que desencadena que los servicios subsiguientes realicen la siguiente transacción de la cadena. Esto continúa hasta que se complete la última transacción de la cadena. Si una transacción comercial fracasa, Saga organiza una serie de transacciones compensatorias que anulan los cambios introducidos en las transacciones anteriores.
Este patrón demuestra cómo automatizar la configuración y el despliegue de una aplicación de muestra (que gestiona las reservas de viajes) con tecnologías sin servidor, como AWS Step Functions, AWS Lambda y Amazon DynamoDB. La aplicación de ejemplo también utiliza Amazon API Gateway y Amazon Simple Notification Service (Amazon SNS) para implementar un coordinador de ejecución de saga. El patrón se puede implementar con un marco de infraestructura como código (IaC), como el AWS Cloud Development Kit (AWS CDK), el AWS Serverless Application Model (AWS Serverless Application Model SAM) o Terraform.
## Requisitos previos y limitaciones
**Requisitos previos**
+ Una cuenta de AWS activa.
+ Permisos para crear una CloudFormation pila de AWS. Para obtener más información, consulte [Controlar el acceso](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html) en la CloudFormation documentación.
+ El marco de IaC de su elección (AWS CDK, AWS SAM o Terraform) se configuró con su cuenta de AWS para que pueda usar la CLI del marco para implementar la aplicación.
+ NodejS, utilizado para compilar la aplicación y ejecutarla localmente.
+ Un editor de código de su elección (como Visual Studio Code, Sublime o Atom).
**Versiones de producto**
+ [NodeJS versión 14](https://nodejs.org/en/download/)
+ [AWS CDK versión 2.37.1](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html#getting_started_install)
+ [AWS SAM versión 1.71.0](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/install-sam-cli.html)
+ [Terraform versión 1.3.7](https://developer.hashicorp.com/terraform/tutorials/aws-get-started/install-cli)
**Limitaciones**
El abastecimiento de eventos es una forma natural de implementar el patrón de orquestación de la saga en una arquitectura de microservicios en la que todos los componentes están acoplados de forma flexible y no se conocen directamente entre sí. Si su transacción incluye un número reducido de pasos (de tres a cinco), el patrón saga podría ser una buena opción. Sin embargo, la complejidad aumenta con el número de microservicios y el número de pasos.
Las pruebas y la depuración pueden resultar difíciles cuando se utiliza este diseño, ya que es necesario tener todos los servicios en ejecución para poder simular el patrón de transacciones.
## Arquitectura
**Arquitectura de destino**
La arquitectura propuesta utiliza AWS Step Functions para crear un patrón de saga para reservar vuelos, reservar alquileres de vehículos y procesar los pagos de las vacaciones.
El siguiente diagrama de flujo de trabajo ilustra el flujo típico del sistema de reservas de viajes. El flujo de trabajo consiste en reservar un viaje en avión (» ReserveFlight «), reservar un automóvil (» ReserveCarRental «), procesar los pagos (» ProcessPayment «), confirmar las reservas de vuelos (» ConfirmFlight «) y confirmar el alquiler de vehículos (» ConfirmCarRental «), seguido de una notificación de éxito cuando se hayan completado estos pasos. Sin embargo, si el sistema detecta algún error al ejecuter alguna de estas transacciones, empezará a fallar hacia atrás. Por ejemplo, un error en el procesamiento del pago (» ProcessPayment «) desencadena un reembolso (» RefundPayment «), que luego desencadena la cancelación del coche de alquiler y del vuelo (» CancelRentalReservation "y CancelFlightReservation «), lo que finaliza toda la transacción con un mensaje de error.
Este patrón implementa funciones Lambda independientes para cada tarea que se resalta en el diagrama, así como tres tablas de DynamoDB para vuelos, alquileres de vehículos y pagos. Cada función de Lambda crea, actualiza o elimina las filas de las tablas de DynamoDB respectivas, en función de si la transacción se confirma o se revierte. El patrón utiliza Amazon SNS para enviar mensajes de texto (SMS) a los suscriptores y notificarles las transacciones fallidas o satisfactorias.
![\[Flujo de trabajo para un sistema de reservas de viajes basado en el patrón saga.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/fec0789c-d9b1-4d80-b179-dd9a7ecbec07/images/daad3e8e-6e6b-41c2-95c1-ca79d53ead64.png)
**Automatización y escala**
Puede crear la configuración de esta arquitectura mediante uno de los marcos de IaC. Utilice uno de los siguientes enlaces para su iAC preferido.
+ [Implementar con AWS CDK](https://serverlessland.com/workflows/saga-pattern-cdk)
+ [Implementar con AWS SAM](https://serverlessland.com/workflows/saga-pattern-sam)
+ [Implementar con Terraform](https://serverlessland.com/workflows/saga-pattern-tf)
## Tools (Herramientas)
**Servicios de AWS**
+ [AWS Step Functions](https://aws.amazon.com/step-functions/) es un servicio de orquestación sin servidor que le permite combinar funciones de AWS Lambda y otros servicios de AWS para crear aplicaciones esenciales desde el punto de vista empresarial. A través de la consola gráfica Step Functions, puede ver el flujo de trabajo de su aplicación como una serie de pasos basados en eventos.
+ [Amazon DynamoDB](https://aws.amazon.com/dynamodb/) es un servicio de base de datos NoSQL totalmente administrado que ofrece un rendimiento rápido y predecible, así como una perfecta escalabilidad. Puede utilizar DynamoDB para crear una tabla de base de datos capaz de almacenar y recuperar cualquier cantidad de datos, así como de atender cualquier nivel de tráfico de solicitudes.
+ [AWS Lambda](https://aws.amazon.com/lambda/) es un servicio de computación que permite ejecutar código sin aprovisionar ni administrar servidores. Lambda ejecuta su código solo cuando es necesario y escala de manera automática, desde unas pocas solicitudes por día hasta miles por segundo.
+ [Amazon API Gateway](https://aws.amazon.com/api-gateway/) es un servicio de AWS para crear, publicar, mantener, supervisar y proteger REST, HTTP y WebSocket APIs a cualquier escala.
+ [Amazon Simple Notification Service (Amazon SNS)](https://aws.amazon.com/sns/) es un servicio administrado que proporciona la entrega de mensajes de los publicadores a los suscriptores.
+ El [AWS Cloud Development Kit (AWS CDK)](https://aws.amazon.com/cdk/) es un marco de desarrollo de software para definir los recursos de las aplicaciones en la nube mediante lenguajes de programación conocidos TypeScript, como Python JavaScript, Java y C\$1/.Net.
+ [AWS Serverless Application Model (AWS SAM)](https://aws.amazon.com/serverless/sam/) es un marco de código abierto que permite crear aplicaciones sin servidor. Proporciona una sintaxis abreviada para expresar funciones, bases de datos y mapeos de fuentes de APIs eventos.
**Código**
El código de una aplicación de ejemplo que muestra el patrón saga, incluida la plantilla IaC (AWS CDK, AWS SAM o Terraform), las funciones de Lambda y las tablas de DynamoDB, se encuentra en los siguientes enlaces. Siga las instrucciones de la primera epic para instalarlos.
+ [Implementar con AWS CDK](https://serverlessland.com/workflows/saga-pattern-cdk)
+ [Implementar con AWS SAM](https://serverlessland.com/workflows/saga-pattern-sam)
+ [Implementar con Terraform](https://serverlessland.com/workflows/saga-pattern-tf)
## Epics
### Instalar paquetes, compilar y compilar
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Instalar los paquetes NPM. | Cree un directorio nuevo, navegue hasta ese directorio en una terminal y clone el GitHub repositorio que prefiera en la sección de *código* que aparece anteriormente en este patrón.En la carpeta raíz que contiene el archivo `package.json`, ejecute el siguiente comando para descargar e instalar todos los paquetes de Node Package Manager (NPM):npm install
| Desarrollador, arquitecto de la nube |
| Compilar scripts. | En la carpeta raíz, ejecute el siguiente comando para indicar al TypeScript transpilador que cree todos los archivos necesarios: JavaScript npm run build
| Desarrollador, arquitecto de la nube |
| Esté atento a los cambios y vuelva a compilar. | En la carpeta raíz, ejecute el siguiente comando en una ventana de terminal independiente para comprobar si hay cambios en el código y compílalo cuando lo detecte:npm run watch
| Desarrollador, arquitecto de la nube |
| Ejecute pruebas unitarias (solo AWS CDK). | Si utiliza el CDK de AWS, en la carpeta raíz, ejecute el siguiente comando para realizar las pruebas unitarias de Jest:npm run test
| Desarrollador, arquitecto de la nube |
### Implemente recursos en la cuenta de AWS de destino
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Implemente la pila de demostración en AWS. | La aplicación es independiente de la región de AWS. Si utiliza un perfil, debe declarar la región de forma explícita en el perfil de la [interfaz de la línea de comandos de AWS (AWS CLI)](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html) o mediante variables de [entorno de la CLI de AWS](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-envvars.html).En la carpeta raíz, ejecute el siguiente comando para crear un ensamblaje de implementación e implementarlo en la cuenta y región de AWS predeterminadas.AWS CDK:cdk bootstrap
cdk deploy
AWS SAM:sam build
sam deploy --guided
Terraform:terraform init
terraform apply
Este paso puede tardar varios minutos en completarse. Este comando usa las credenciales predeterminadas que se configuraron para la AWS CLI.Anote la URL de API Gateway que se muestra en la consola una vez completada la implementación. Necesitará esta información para probar el flujo de ejecución de la saga. | Desarrollador, arquitecto de la nube |
| Compare la pila implementada con el estado actual. | En la carpeta raíz, ejecute el siguiente comando para comparar la pila implementada con el estado actual después de realizar cambios en el código fuente:AWS CDK:cdk diff
AWS SAM:sam deploy
Terraform:terraform plan
| Desarrollador, arquitecto de la nube |
### Pruebe el flujo de ejecución
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Probar el flujo de ejecución de la saga. | Navegue hasta la URL de API Gateway que indicó en el paso anterior, cuando implementó la pila. Esta URL activa el inicio de la máquina de estados. Para obtener más información sobre cómo manipular el flujo de la máquina de estados pasando diferentes parámetros de URL, consulte la sección de [Información adicional](#implement-the-serverless-saga-pattern-by-using-aws-step-functions-additional).Para ver los resultados, inicie sesión en la consola de administración de AWS y vaya a la consola de Step Functions. Aquí puede ver todos los pasos de la saga State Machine. También puede ver la tabla de DynamoDB para ver los registros insertados, actualizados o eliminados. Si actualiza la pantalla con frecuencia, puede ver cómo el estado de la transacción cambia de a`pending`. `confirmed` Puede suscribirse al tema de las redes sociales actualizando el código del archivo `stateMachine.ts` con su número de teléfono móvil para recibir mensajes SMS cuando las reservas se hayan realizado o no se hayan realizado correctamente. Para obtener más información, consulte *Amazon SNS* en la sección [Información adicional](#implement-the-serverless-saga-pattern-by-using-aws-step-functions-additional). | Desarrollador, arquitecto de la nube |
### Limpieza
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Limpiar recursos. | Para limpiar los recursos desplegados para esta aplicación, puede usar uno de los siguientes comandos.AWS CDK:cdk destroy
AWS SAM:sam delete
Terraform:terraform destroy
| Desarrollador de aplicaciones, arquitecto de la nube |
## Recursos relacionados
**Documentos técnicos**
+ [Implementación de microservicios en AWS](https://docs.aws.amazon.com/pdfs/whitepapers/latest/microservices-on-aws/microservices-on-aws.pdf)
+ [Aplicaciones sin servidor](https://docs.aws.amazon.com/wellarchitected/latest/serverless-applications-lens/welcome.html)
**Documentación de servicio de AWS**
+ [Introducción a los AWS SDK](https://docs.aws.amazon.com/cdk/latest/guide/getting_started.html)
+ [Introducción a AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-getting-started.html)
+ [AWS Step Functions](https://docs.aws.amazon.com/step-functions/)
+ [Amazon DynamoDB](https://docs.aws.amazon.com/dynamodb/)
+ [AWS Lambda](https://docs.aws.amazon.com/lambda/)
+ [Amazon API Gateway](https://docs.aws.amazon.com/apigateway/)
+ [Amazon SNS](https://docs.aws.amazon.com/sns/)
**Tutoriales**
+ [Talleres prácticos sobre informática sin servidor](https://aws.amazon.com/serverless-workshops/)
## Información adicional
**Código**
Con fines de prueba, este patrón implementa API Gateway y una función de Lambda de prueba que activa la máquina de estados Step Functions. Con Step Functions, puede controlar la funcionalidad del sistema de reservas de viajes pasando un `run_type` parámetro para imitar los errores en «ReserveFlightReserveCarRental,»»» ProcessPaymentConfirmFlight,»» y «»ConfirmCarRental.
La `saga`función de Lambda (`sagaLambda.ts`) toma la entrada de los parámetros de consulta de la URL de la API Gateway, crea el siguiente objeto JSON y lo pasa a Step Functions para su ejecución:
```
let input = {
"trip_id": tripID, // value taken from query parameter, default is AWS request ID
"depart_city": "Detroit",
"depart_time": "2021-07-07T06:00:00.000Z",
"arrive_city": "Frankfurt",
"arrive_time": "2021-07-09T08:00:00.000Z",
"rental": "BMW",
"rental_from": "2021-07-09T00:00:00.000Z",
"rental_to": "2021-07-17T00:00:00.000Z",
"run_type": runType // value taken from query parameter, default is "success"
};
```
Puede experimentar con diferentes flujos de la máquina de estados Step Functions pasando los siguientes parámetros de URL:
+ **Ejecución correcta**: https://\$1api gateway url\$1
+ Error en la **reserva del vuelo** ─ https://\$1api gateway url\$1? **Tipo de ejecución = failFlightsReservation**
+ **Confirma el error del vuelo** ─ https://\$1api gateway url\$1? **Tipo de ejecución = failFlightsConfirmation**
+ Error al **alquilar un coche al reservar** ─ https://\$1api gateway url\$1? **RunType = Reserva failCarRental**
+ **Confirme que el alquiler del vehículo ha fallado** ─ https://\$1api gateway url\$1? **RunType = Confirmación failCarRental**
+ **Error al procesar el pago**: https://\$1api gateway url\$1?**runType=failPayment**
+ **Pasar un identificador de viaje**: https://\$1api gateway url\$1? **tripID=** \$1de forma predeterminada, el ID de viaje será el ID de solicitud de AWS\$1
**Plantillas de iAC**
Los repositorios enlazados incluyen plantillas de IaC que puede utilizar para crear toda la aplicación de reserva de viajes de muestra.
+ [Implementar con AWS CDK](https://serverlessland.com/workflows/saga-pattern-cdk)
+ [Implementar con AWS SAM](https://serverlessland.com/workflows/saga-pattern-sam)
+ [Implementar con Terraform](https://serverlessland.com/workflows/saga-pattern-tf)
**Tablas de DynamoDB**
Estos son los modelos de datos para las tablas de vuelos, alquileres de coches y pagos.
```
Flight Data Model:
var params = {
TableName: process.env.TABLE_NAME,
Item: {
'pk' : {S: event.trip_id},
'sk' : {S: flightReservationID},
'trip_id' : {S: event.trip_id},
'id': {S: flightReservationID},
'depart_city' : {S: event.depart_city},
'depart_time': {S: event.depart_time},
'arrive_city': {S: event.arrive_city},
'arrive_time': {S: event.arrive_time},
'transaction_status': {S: 'pending'}
}
};
Car Rental Data Model:
var params = {
TableName: process.env.TABLE_NAME,
Item: {
'pk' : {S: event.trip_id},
'sk' : {S: carRentalReservationID},
'trip_id' : {S: event.trip_id},
'id': {S: carRentalReservationID},
'rental': {S: event.rental},
'rental_from': {S: event.rental_from},
'rental_to': {S: event.rental_to},
'transaction_status': {S: 'pending'}
}
};
Payment Data Model:
var params = {
TableName: process.env.TABLE_NAME,
Item: {
'pk' : {S: event.trip_id},
'sk' : {S: paymentID},
'trip_id' : {S: event.trip_id},
'id': {S: paymentID},
'amount': {S: "750.00"}, // hard coded for simplicity as implementing any monetary transaction functionality is beyond the scope of this pattern
'currency': {S: "USD"},
'transaction_status': {S: "confirmed"}
}
};
```
**Funciones de Lambda**
Se crearán las siguientes funciones para respaldar el flujo y la ejecución de la máquina de estados en Step Functions:
+ **Reservar vuelos**: introduzca un registro en la tabla de vuelos de DynamoDB con `transaction_status` un `pending` de para reservar un vuelo.
+ **Confirmar vuelo**: actualiza el registro de la tabla de vuelos de DynamoDB para establecer `transaction_status` en `confirmed`, para confirmar el vuelo.
+ **Cancelar reserva de vuelos**: elimina el registro de la tabla de vuelos de DynamoDB para cancelar el vuelo pendiente.
+ **Reserve vehículos de alquiler**: inserta un registro en la tabla de CarRentals DynamoDB con `transaction_status` un `pending` de para reservar un alquiler de vehículos.
+ **Confirmar alquileres de vehículos**: actualiza el registro de la tabla de CarRentals DynamoDB para `transaction_status` `confirmed` establecerlo en y confirmar el alquiler de vehículos.
+ **Cancelar reserva de vehículos de alquiler:** elimina el registro de la tabla de CarRentals DynamoDB para cancelar el alquiler de vehículos pendiente.
+ **Procesar pago**: inserta un registro en la tabla de pagos de DynamoDB para el pago.
+ **Cancelar pago**: elimina el registro del pago de la tabla de pagos de DynamoDB.
**Amazon SNS**
La aplicación de ejemplo crea el tema y la suscripción siguientes para enviar mensajes SMS y notificar al cliente si las reservas se han realizado o no se han realizado correctamente. Si desea recibir mensajes de texto mientras prueba la aplicación de ejemplo, actualice la suscripción de SMS con su número de teléfono válido en el archivo de definición de la máquina de estados.
Fragmento de CDK de AWS (añada el número de teléfono en la segunda línea del siguiente código):
```
const topic = new sns.Topic(this, 'Topic');
topic.addSubscription(new subscriptions.SmsSubscription('+11111111111'));
const snsNotificationFailure = new tasks.SnsPublish(this ,'SendingSMSFailure', {
topic:topic,
integrationPattern: sfn.IntegrationPattern.REQUEST_RESPONSE,
message: sfn.TaskInput.fromText('Your Travel Reservation Failed'),
});
const snsNotificationSuccess = new tasks.SnsPublish(this ,'SendingSMSSuccess', {
topic:topic,
integrationPattern: sfn.IntegrationPattern.REQUEST_RESPONSE,
message: sfn.TaskInput.fromText('Your Travel Reservation is Successful'),
});
```
Fragmento de SAM de AWS (sustituya las cadenas `+1111111111` por su número de teléfono válido):
```
StateMachineTopic11111111111:
Type: 'AWS::SNS::Subscription'
Properties:
Protocol: sms
TopicArn:
Ref: StateMachineTopic
Endpoint: '+11111111111'
Metadata:
'aws:sam:path': SamServerlessSagaStack/StateMachine/Topic/+11111111111/Resource
```
Fragmento de Terraform (sustituya la cadena `+111111111` por su número de teléfono válido):
```
resource "aws_sns_topic_subscription" "sms-target" {
topic_arn = aws_sns_topic.topic.arn
protocol = "sms"
endpoint = "+11111111111"
}
```
**Reservas realizadas satisfactoriamente**
En el siguiente flujo se muestra una reserva correcta con los caracteres "ReserveFlight,»ReserveCarRental,» y "" seguidos de ProcessPayment "" y ConfirmFlight "». ConfirmCarRental Se notifica al cliente que la reserva se ha realizado correctamente mediante mensajes SMS que se envían al suscriptor del tema de las redes sociales.
![\[Ejemplo de una reserva exitosa implementada por Step Functions mediante el patrón saga.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/fec0789c-d9b1-4d80-b179-dd9a7ecbec07/images/f58c894e-7721-4bc7-8f7d-29f23faa5dc1.png)
**Reservas fallidas**
Este flujo es un ejemplo de fracaso en el patrón de la saga. Si, después de reservar vuelos y alquileres de vehículos, "ProcessPayment" falla, los pasos se cancelan en orden inverso. Se cancelan las reservas y se notifica al cliente del error mediante mensajes SMS que se envían al suscriptor del tema de las redes sociales.
![\[Ejemplo de una reserva fallida implementada por Step Functions mediante el patrón saga.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/fec0789c-d9b1-4d80-b179-dd9a7ecbec07/images/7c64d326-be27-42c3-b03f-d677efedb9a7.png)
# Gestión de las aplicaciones de contenedores en las instalaciones mediante la configuración de Amazon ECS Anywhere con AWS CDK
*Dr. Rahul Sharad Gaikwad, Amazon Web Services*
## Resumen
[Amazon ECS Anywhere](https://aws.amazon.com/ecs/anywhere/) es una extensión de Amazon Elastic Container Service (Amazon ECS). Puede usar ECS Anywhere para implementar tareas nativas de Amazon ECS en un entorno en las instalaciones o administrado por el cliente. Esta característica ayuda a reducir los costos y a mitigar la compleja orquestación y las operaciones de los contenedores locales. Puede usar ECS Anywhere para implementar y ejecutar aplicaciones de contenedor tanto en entornos en las instalaciones como en la nube. Evita que su equipo tenga que aprender varios dominios y conjuntos de habilidades, o administrar software complejo por su cuenta.
Este patrón muestra los pasos para configurar ECS Anywhere mediante pilas del AWS Cloud Development Kit ([AWS CDK](https://aws.amazon.com/cdk/)).
## Requisitos previos y limitaciones
**Requisitos previos**
+ Una cuenta de AWS activa.
+ Interfaz de la línea de comandos de AWS (AWS CLI) instalada y configurada. (Consulte [Instalación, actualización y desinstalación de la CLI de AWS](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) en la documentación de la CLI de AWS).
+ Kit de herramientas de AWS CDK, instalado y configurado. (Consulte [Kit de Herramientas CDK de AWS](https://docs.aws.amazon.com/cdk/v2/guide/cli.html) en la documentación de AWS CDK y siga las instrucciones para instalar la versión 2 de forma global).
+ Administrador de paquetes de nodos (npm), instalado y configurado para la AWS CDK en. TypeScript (Consulte [Descargar e instalar Node.js y npm](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm) en la documentación de npm).
**Limitaciones**
+ Para ver las limitaciones y consideraciones, consulte [Instancias externas (Amazon ECS Anywhere)](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-anywhere.html#ecs-anywhere-considerations) en la documentación de Amazon ECS.
**Versiones de producto**
+ Kit de Herramientas CDK de AWS, versión 2
+ npm versión 7.20.3 o posterior
+ Node.js versión 16.6.1 o posterior
## Arquitectura
**Pila de tecnología de destino**
+ AWS CloudFormation
+ AWS CDK
+ Amazon ECS Anywhere
+ AWS Identity y Access Management (IAM)
**Arquitectura de destino**
El siguiente diagrama ilustra una arquitectura de sistema de alto nivel de la configuración de ECS Anywhere que utiliza la AWS CDK con TypeScript, tal como se implementa mediante este patrón.
1. Al implementar la pila de CDK de AWS, se crea una CloudFormation pila en AWS.
1. La CloudFormation pila aprovisiona un clúster de Amazon ECS y los recursos de AWS relacionados.
1. Para registrar una instancia externa en un clúster de Amazon ECS, debe instalar AWS Systems Manager Agent (SSM Agent) en su máquina virtual (VM) y registrar la VM como instancia administrada por AWS Systems Manager.
1. También debe instalar el agente de contenedores de Amazon ECS y Docker en su máquina virtual para registrarla como instancia externa en el clúster de Amazon ECS.
1. Cuando la instancia externa está ya registrada y configurada con el clúster de Amazon ECS, puede ejecutar varios contenedores en su máquina virtual, registrada como instancia externa.
![\[Configuración de ECS Anywhere mediante AWS CDK con TypeScript.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/3ed63c00-40e7-4831-bb9d-63049c3490aa/images/ff7dc774-830d-4b9f-8262-7314afe7a033.png)
**Automatización y escala**
El [GitHub repositorio](https://github.com/aws-samples/amazon-ecs-anywhere-cdk-samples/) que se proporciona con este patrón utiliza la CDK de AWS como herramienta de infraestructura como código (IaC) para crear la configuración de esta arquitectura. AWS CDK le ayuda a orquestar los recursos y configurar ECS Anywhere.
## Tools (Herramientas)
+ [AWS Cloud Development Kit (AWS CDK)](https://docs.aws.amazon.com/cdk/latest/guide/home.html) es un marco de desarrollo de software que le ayuda a definir y aprovisionar la infraestructura de la nube de AWS en código.
+ La [interfaz de la línea de comandos de AWS (AWS CLI)](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) es una herramienta de código abierto que le permite interactuar con los servicios de AWS mediante comandos en su intérprete de comandos de línea de comandos.
**Código**
El código fuente de este patrón está disponible en el GitHub repositorio de [muestras de CDK de Amazon ECS Anywhere](https://github.com/aws-samples/amazon-ecs-anywhere-cdk-samples). Para clonar y utilizar el repositorio, siga las instrucciones de la siguiente sección.
## Epics
### Verificar la configuración de AWS CDK
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Verifique la versión de AWS CDK. | Compruebe la versión del kit de herramientas de AWS CDK mediante el siguiente comando:cdk --version
Este patrón requiere la versión 2 de AWS CDK. Si tiene una versión anterior de AWS CDK siga las instrucciones de la [documentación de AWS CDK](https://docs.aws.amazon.com/cdk/v2/guide/cli.html) para actualizarla. | DevOps ingeniero |
| Configure las credenciales de AWS. | Para configurar las credenciales, ejecute el comando `aws configure` y siga las instrucciones:$aws configure
AWS Access Key ID [None]:
AWS Secret Access Key [None]:
Default region name [None]:
Default output format [None]:
| DevOps ingeniero |
### Inicie el entorno de AWS CDK
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Clonar el repositorio de código de AWS CDK. | Clona el repositorio de GitHub código de este patrón mediante el comando:git clone https://github.com/aws-samples/amazon-ecs-anywhere-cdk-samples.git
| DevOps ingeniero |
| Arranque el entorno de . | Para implementar la CloudFormation plantilla de AWS en la cuenta y la región de AWS que desee usar, ejecute el siguiente comando:cdk bootstrap /
Para obtener más información, consulte [Proceso de arranque](https://docs.aws.amazon.com/cdk/latest/guide/bootstrapping.html) en la documentación de AWS CDK. | DevOps ingeniero |
### Crear e implementar el proyecto
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Instale las dependencias de los paquetes y compile TypeScript los archivos. | Instale las dependencias del paquete y compile los TypeScript archivos ejecutando los siguientes comandos:$cd amazon-ecs-anywhere-cdk-samples
$npm install
$npm fund
Estos comandos instalan todos los paquetes del repositorio de muestra. Si se muestra algún error acerca de paquetes que faltan, utilice uno de los siguientes comandos:$npm ci
—o—$npm install -g @aws-cdk/
Para obtener más información, consulte [npm ci](https://docs.npmjs.com/cli/v7/commands/npm-ci) y [npm install](https://docs.npmjs.com/cli/v7/commands/npm-install) en la documentación de npm. | DevOps ingeniero |
| Compilar el proyecto. | Ejecute el siguiente comando para compilar el código del proyecto:npm run build
Para obtener más información sobre la compilación e implementación del proyecto, consulte [Su primera aplicación de AWS CDK](https://docs.aws.amazon.com/cdk/latest/guide/hello_world.html#:~:text=the%20third%20parameter.-,Synthesize%20an%20AWS%20CloudFormation%20template,-Synthesize%20an%20AWS) en la documentación de AWS CDK. | DevOps ingeniero |
| Implementar el proyecto. | Para implementar el código del proyecto, ejecute el comando:cdk deploy
| DevOps ingeniero |
| Verifique la creación y el resultado de la pila. | Abra la CloudFormation consola de AWS en [https://console.aws.amazon.com/cloudformation****](https://console.aws.amazon.com/cloudformation/) y elija la `EcsAnywhereStack` pila. La pestaña **Salidas** muestra los comandos que se deben ejecutar en su máquina virtual externa. | DevOps ingeniero |
### Configuración de una máquina en las instalaciones
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Configure su máquina virtual mediante Vagrant. | Con fines de demostración, puede usar [HashiCorp Vagrant](https://www.vagrantup.com/) para crear una máquina virtual. Vagrant es una utilidad de código abierto para compilar y mantener entornos de desarrollo de software virtual portátiles. Cree una máquina virtual Vagrant ejecutando el comando `vagrant up` desde el directorio raíz donde se encuentra Vagrantfile. Para obtener más información, consulte la [documentación de Vagrant](https://www.vagrantup.com/docs/cli/up). | DevOps ingeniero |
| Registre su máquina virtual como instancia externa. | 1. Inicie sesión en la máquina virtual de Vagrant mediante el comando `vagrant ssh`. Para obtener más información, consulte la [documentación de Vagrant](https://www.vagrantup.com/docs/cli/ssh).2. Cree un código de activación y una ID que usará para registrar su máquina virtual en AWS Systems Manager y activar su instancia externa. El resultado de este comando incluye valores `ActivationId` y `ActivationCode`: aws ssm create-activation --iam-role EcsAnywhereInstanceRole | tee ssm-activation.json
3. Exporte el ID de activación y los valores del código:export ACTIVATION_ID=
export ACTIVATION_CODE=
4. Descargar el script de instalación en el servidor ubicado en las instalaciones o en la máquina virtual (VM):curl -o "ecs-anywhere-install.sh" "https://amazon-ecs-agent.s3.amazonaws.com/ecs-anywhere-install-latest.sh" && sudo chmod +x ecs-anywhere-install.sh
5. Ejecute el script de instalación en el servidor ubicado en las instalaciones o en la máquina virtual (VM).sudo ./ecs-anywhere-install.sh \
--cluster test-ecs-anywhere \
--activation-id $ACTIVATION_ID \
--activation-code $ACTIVATION_CODE \
--region
Para obtener más información sobre la configuración y el registro de su máquina virtual, consulte [Registrar una instancia externa en un clúster](https://docs.amazonaws.cn/en_us/AmazonECS/latest/developerguide/ecs-anywhere-registration.html) en la documentación de Amazon ECS. | DevOps ingeniero |
| Verifique el estado de ECS Anywhere y de la máquina virtual externa. | Para verificar si su caja virtual está conectada al plano de control de Amazon ECS y en funcionamiento, utilice los siguientes comandos:aws ssm describe-instance-information
aws ecs list-container-instances --cluster $CLUSTER_NAME
| DevOps ingeniero |
### Limpieza
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Limpie y elimine recursos. | Después de seguir este patrón, debe eliminar los recursos que ha creado para evitar incurrir en cargos adicionales. Para limpiar, ejecute el comando:cdk destroy
| DevOps ingeniero |
## Recursos relacionados
+ [Documentación de Amazon ECS Anywhere](https://aws.amazon.com/ecs/anywhere/)
+ [Amazon ECS Anywhere Demo](https://www.youtube.com/watch?v=-eud6yUXsJM)
+ [Muestras de talleres sobre Amazon ECS Anywhere](https://github.com/aws-samples/aws-ecs-anywhere-workshop-samples)
# Modernizar las aplicaciones de ASP.NET Web Forms en AWS
*Vijai Anand Ramalingam y Sreelaxmi Pai, Amazon Web Services*
## Resumen
En este patrón se describen los pasos para modernizar una aplicación heredada y monolítica de ASP.NET Web Forms mediante su migración a ASP.NET Core en AWS.
La migración de las aplicaciones de ASP.NET Web Forms a ASP.NET Core le ayuda a aprovechar el rendimiento, el ahorro de costos y el sólido ecosistema de Linux. Sin embargo, puede suponer un esfuerzo manual considerable. En este patrón, la aplicación heredada se moderniza gradualmente mediante un enfoque gradual y, a continuación, se divide en contenedores en la nube de AWS.
Pensemos en una aplicación heredada y monolítica para un carrito de compras. Supongamos que se creó como una aplicación de ASP.NET Web Forms y consta de páginas .aspx con un archivo de código subyacente (`aspx.cs`). El proceso de modernización consta de estos pasos:
1. Divida el monolito en microservicios utilizando los patrones de descomposición adecuados. Para obtener más información, consulte la guía [Cómo descomponer monolitos en microservicios](https://docs.aws.amazon.com/prescriptive-guidance/latest/modernization-decomposing-monoliths/) en el sitio web de Recomendaciones de AWS.
1. Transfiera su aplicación heredada de ASP.NET Web Forms (.NET Framework) a ASP.NET Core en .NET 5 o posterior. En este patrón, usted utiliza el Asistente de portabilidad para .NET para analizar su aplicación ASP.NET Web Forms e identificar las incompatibilidades con ASP.NET Core. Esto reduce el esfuerzo de portabilidad manual.
1. Vuelva a desarrollar la capa de interfaz de usuario de Web Forms mediante React. Este patrón no cubre la remodelación de la interfaz de usuario. Para obtener instrucciones, consulte [Crear una nueva aplicación de React](https://reactjs.org/docs/create-a-new-react-app.html) en la documentación de React.
1. Vuelva a desarrollar el archivo de código subyacente de Web Forms (interfaz empresarial) como una API web de ASP.NET Core. Este patrón utiliza NDepend informes para ayudar a identificar los archivos y las dependencias necesarios.
1. Actualice shared/common los proyectos, como Business Logic y Data Access, de su aplicación antigua a .NET 5 o posterior mediante Porting Assistant para .NET.
1. Añada servicios de AWS para complementar su aplicación. Por ejemplo, puede usar [Amazon CloudWatch Logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/WhatIsCloudWatchLogs.html) para monitorear, almacenar y acceder a los registros de su aplicación, y [AWS Systems Manager](https://aws.amazon.com/systems-manager/) para almacenar la configuración de la aplicación.
1. Ponga en contenedores la aplicación ASP.NET Core modernizada. Este patrón crea un archivo Docker orientado a Linux en Visual Studio y usa Docker Desktop para probarlo localmente. En este paso se supone que la aplicación antigua ya se está ejecutando en una instancia local o en una instancia Windows de Amazon Elastic Compute Cloud (Amazon EC2). Para obtener más información, consulte el patrón [Ejecutar un contenedor Docker de la API web de ASP.NET Core en una instancia de Amazon EC2 Linux.](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/run-an-asp-net-core-web-api-docker-container-on-an-amazon-ec2-linux-instance.html)
1. Implemente la aplicación principal ASP.NET modernizada en Amazon Elastic Container Service (Amazon ECS). Este patrón no cubre el paso de implementación. Para obtener instrucciones, consulte el [Taller de Amazon ECS](https://ecsworkshop.com/).
**nota**
Este patrón no cubre los pasos de desarrollo de la interfaz de usuario, modernización de bases de datos o de implementación de contenedores.
## Requisitos previos y limitaciones
**Requisitos previos **
+ [Visual Studio](https://visualstudio.microsoft.com/downloads/) o [Visual Studio Code](https://code.visualstudio.com/download), descargados e instalados.
+ Acceso a una cuenta de AWS mediante la Consola de administración de AWS y la Interfaz de la línea de comandos de AWS (AWS CLI) versión 2. (Consulte las [Instrucciones para configurar la CLI de AWS](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv2.html)).
+ El Kit de herramientas de AWS para Visual Studio (consulte las [instrucciones de configuración](https://docs.aws.amazon.com/toolkit-for-visual-studio/latest/user-guide/setup.html)).
+ Docker Desktop, [descargado](https://www.docker.com/products/docker-desktop) e instalado.
+ .NET SDK, [descargado](https://download.visualstudio.microsoft.com/download/pr/4263dc3b-dc67-4f11-8d46-cc0ae86a232e/66782bbd04c53651f730b2e30a873f18/dotnet-sdk-5.0.203-win-x64.exe) e instalado.
+ NDepend herramienta, [descargada e instalada](https://www.ndepend.com/download). Para instalar la NDepend extensión para Visual Studio, ejecute `NDepend.VisualStudioExtension.Installer` ([consulte las instrucciones](https://www.ndepend.com/docs/getting-started-with-ndepend#Part1)). Puede seleccionar Visual Studio 2019 o 2022, según sus necesidades.
+ Asistente de portabilidad para .NET, [descargado](https://aws.amazon.com/porting-assistant-dotnet/) e instalado.
## Arquitectura
**Modernización de la aplicación de carrito de compras**
El siguiente diagrama ilustra el proceso de modernización de una aplicación heredada de carrito de compras de ASP.NET.
![\[Modernización de una aplicación de carrito de compras heredada\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/36cda8e6-f2cb-4f1a-b37f-fa3045cc5ba1/images/4367e259-9bb3-4eb6-a54d-1c1e2dece7d4.png)
**Arquitectura de destino**
En el siguiente diagrama se ilustra la arquitectura de la aplicación de carrito de compras modernizada en AWS. La web de ASP.NET Core APIs se implementa en un clúster de Amazon ECS. Los servicios de registro y configuración los proporcionan Amazon CloudWatch Logs y AWS Systems Manager.
![\[Arquitectura de destino para la aplicación ASP.NET Web Forms en AWS\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/36cda8e6-f2cb-4f1a-b37f-fa3045cc5ba1/images/ed6d65ec-0dc9-43ab-ac07-1f172e089399.png)
## Tools (Herramientas)
**Servicios de AWS**
+ [Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/Welcome.html): Amazon Elastic Container Service (Amazon ECS) es un servicio de administración de contenedores altamente escalable y rápido para ejecutar, detener y administrar contenedores en un clúster. Las tareas y los servicios se pueden ejecutar en una infraestructura sin servidor administrada por AWS Fargate. Como alternativa, para tener más control sobre su infraestructura, puede ejecutar sus tareas y servicios en un clúster de EC2 instancias que administre.
+ [Amazon CloudWatch Logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/WhatIsCloudWatchLogs.html): Amazon CloudWatch Logs centraliza los registros de todos los sistemas, aplicaciones y servicios de AWS que utilice. Esto le permite consultarlos, buscar códigos de error o patrones específicos, filtrarlos en función de campos específicos o archivarlos de forma segura para análisis futuros.
+ [AWS Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/what-is-systems-manager.html): AWS Systems Manager es un servicio que puede utilizar para ver y controlar su infraestructura en AWS. Mediante la consola de Systems Manager, puede ver los datos operativos de varios servicios de AWS y automatizar las tareas operativas en sus recursos de AWS. Systems Manager le ayuda a mantener la seguridad y la conformidad mediante el análisis de sus instancias administradas y el informe sobre las infracciones de las políticas que detecte (o la toma de medidas correctivas con respecto a estas).
**Herramientas**
+ [Visual Studio](https://visualstudio.microsoft.com/) o [Visual Studio Code](https://code.visualstudio.com/): herramientas para crear aplicaciones.NET APIs, sitios web y otros programas.
+ [AWS Toolkit for Visual Studio](https://docs.aws.amazon.com/toolkit-for-visual-studio/latest/user-guide/welcome.html) – Una extensión para Visual Studio que ayuda a desarrollar, depurar e implementar aplicaciones .NET que utilizan servicios de AWS.
+ [Docker Desktop](https://www.docker.com/products/docker-desktop) – Una herramienta que simplifica la compilación e implementación de aplicaciones en contenedores.
+ [NDepend](https://www.ndepend.com/features/)— Un analizador que supervisa el código.NET para detectar dependencias, problemas de calidad y cambios en el código.
+ [Asistente de portabilidad para .NET](https://aws.amazon.com/porting-assistant-dotnet/) – Una herramienta de análisis que escanea el código.NET para identificar incompatibilidades con .NET Core y estimar el esfuerzo de migración.
## Epics
### Transfiera su aplicación heredada a .NET 5 o a una versión posterior
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Actualice su aplicación heredada de.NET Framework a .NET 5. | Puede usar el Asistente de portabilidad para .NET para convertir su aplicación heredada de ASP.NET Web Forms a .NET 5 o posterior. Siga las instrucciones de la [documentación del Asistente de portabilidad para .NET](https://docs.aws.amazon.com/portingassistant/latest/userguide/porting-assistant-getting-started.html). | Desarrollador de aplicaciones |
| Genere informes NDepend . | Al modernizar la aplicación ASP.NET Web Forms descomponiéndola en microservicios, es posible que no necesite todos los archivos .cs de la aplicación heredada. Puede utilizarlos NDepend para generar un informe para cualquier archivo con código subyacente (.cs), a fin de obtener todas las personas que llaman y las que llaman. Este informe le ayuda a identificar y usar solo los archivos necesarios en sus microservicios.Tras la instalación NDepend (consulte la sección [Requisitos previos](#modernize-asp-net-web-forms-applications-on-aws-prereqs)), abra la solución (archivo.sln) para la aplicación antigua en Visual Studio y siga estos pasos:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/modernize-asp-net-web-forms-applications-on-aws.html)Este proceso genera un informe para el archivo con el código subyacente en el que se enumeran todas los emisores y destinatarios de llamadas. Para obtener más información sobre el gráfico de dependencias, consulte la [NDepend documentación](https://www.ndepend.com/docs/visual-studio-dependency-graph). | Desarrollador de aplicaciones |
| Cree una nueva solución .NET 5. | Para crear una estructura nueva.NET 5 (o posterior) para su web ASP.NET Core modernizada: APIs[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/modernize-asp-net-web-forms-applications-on-aws.html)Para obtener más información acerca de la creación de proyectos y soluciones, consulte la [documentación de Visual Studio](https://docs.microsoft.com/en-us/visualstudio/ide/creating-solutions-and-projects).A medida que cree la solución y compruebe su funcionalidad, es posible que identifique varios archivos adicionales para añadirlos a la solución, además de los archivos que la NDepend identificaron. | Desarrollador de aplicaciones |
### Actualice su código de la aplicación.
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Implemente la web APIs con ASP.NET Core. | Supongamos que uno de los microservicios que identificó en su aplicación heredada de carrito de compras monolítico es *Productos*. Usted creó un nuevo proyecto de API web de ASP.NET Core para *Productos* en la épica anterior. En este paso, usted identificará y modernizará todos los formularios web (páginas .aspx) relacionados con los *Productos*. Supongamos que *Productos* consta de cuatro formularios web, tal y como se ha ilustrado anteriormente en la sección de [Arquitectura](#modernize-asp-net-web-forms-applications-on-aws-architecture):[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/modernize-asp-net-web-forms-applications-on-aws.html)Debe analizar cada formulario web, identificar todas las solicitudes que se envían a la base de datos para realizar alguna lógica y obtener respuestas. Puede implementar cada solicitud como un punto de conexión de la API web. Gracias a sus formularios web, los *productos* pueden tener los siguientes puntos de conexión posibles:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/modernize-asp-net-web-forms-applications-on-aws.html)Como se mencionó anteriormente, también puede reutilizar todos los demás proyectos que haya actualizado a .NET 5, incluidos Business Logic, Data Access y los shared/common proyectos. | Desarrollador de aplicaciones |
| Configura Amazon CloudWatch Logs. | Puedes usar [Amazon CloudWatch Logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/WhatIsCloudWatchLogs.html) para monitorear, almacenar y acceder a los registros de tu aplicación. Puede registrar datos en Amazon CloudWatch Logs mediante un SDK de AWS. También puede integrar aplicaciones de.NET con CloudWatch Logs utilizando los marcos de registro de.NET más populares [NLog](https://www.nuget.org/packages/AWS.Logger.NLog/), como [Log4Net](https://www.nuget.org/packages/AWS.Logger.Log4net/) y [ASP.NET Core](https://www.nuget.org/packages/AWS.Logger.AspNetCore/).Para obtener más información sobre este paso, consulte la entrada del blog [Amazon CloudWatch Logs y.NET Logging Frameworks](https://aws.amazon.com/blogs/developer/amazon-cloudwatch-logs-and-net-logging-frameworks/). | Desarrollador de aplicaciones |
| Configurar el almacén de parámetros de AWS Systems Manager. | Puede usar el [Almacén de parámetros de AWS Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-paramstore.html) para almacenar la configuración de la aplicación, como las cadenas de conexión, de forma separada del código de la aplicación. El NuGet paquete [Amazon.Extensions.Configuration. SystemsManager](https://www.nuget.org/packages/Amazon.Extensions.Configuration.SystemsManager/)simplifica la forma en que su aplicación carga estos ajustes del AWS Systems Manager Parameter Store al sistema de configuración .NET Core. Para obtener más información sobre este paso, consulte la entrada del blog [Proveedor de configuración .NET Core para AWS Systems Manager](https://aws.amazon.com/blogs/developer/net-core-configuration-provider-for-aws-systems-manager/). | Desarrollador de aplicaciones |
### Cómo añadir autenticación y autorización
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Utilice una cookie compartida para la autenticación. | La modernización de una aplicación heredada monolítica es un proceso iterativo y requiere que el monolito y su versión modernizada coexistan. Puede usar una cookie compartida para lograr una autenticación perfecta entre las dos versiones. La aplicación ASP.NET heredada sigue validando las credenciales de los usuarios y emite la cookie, mientras que la aplicación ASP.NET Core modernizada valida la cookie. Para obtener instrucciones y un código de muestra, consulte el [ GitHub proyecto de ejemplo](https://github.com/aws-samples/dotnet-share-auth-cookie-between-monolith-and-modernized-apps). | Desarrollador de aplicaciones |
### Compilación y ejecución del contenedor de forma local
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Cree una imagen de Docker con Visual Studio. | En este paso, usted crea un archivo de Docker mediante la API web de Visual Studio para .NET Core.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/modernize-asp-net-web-forms-applications-on-aws.html)Visual Studio crea un archivo de Docker para su proyecto. Para ver un archivo de muestra de Docker, consulte [Herramientas de contenedor de Visual Studio para Docker](https://docs.microsoft.com/en-us/visualstudio/containers/overview) en el sitio web de Microsoft. | Desarrollador de aplicaciones |
| Cree y ejecute el contenedor mediante Docker Desktop. | Ahora puede compilar, crear y ejecutar el contenedor en Docker Desktop.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/modernize-asp-net-web-forms-applications-on-aws.html) | Desarrollador de aplicaciones |
## Recursos relacionados
+ [Ejecute un contenedor Docker de la API web de ASP.NET Core en una instancia de Amazon EC2 Linux](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/run-an-asp-net-core-web-api-docker-container-on-an-amazon-ec2-linux-instance.html) (AWS Prescriptive Guidance)
+ [Taller de Amazon ECS](https://ecsworkshop.com/)
+ [Realice blue/green implementaciones de ECS CodeDeploy mediante AWS CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/blue-green.html) ( CloudFormation documentación de AWS)
+ [Cómo empezar con NDepend](https://www.ndepend.com/docs/getting-started-with-ndepend) (NDepend documentación)
+ [Asistente de portabilidad para .NET](https://aws.amazon.com/porting-assistant-dotnet/)
## Información adicional
En las tablas siguientes se proporcionan ejemplos de proyectos de muestra para una aplicación de carrito de compras heredada y los proyectos equivalentes de una aplicación ASP.NET Core modernizada.
**Solución heredada:**
|
|
| Nombre del proyecto | Plantilla de proyecto | Target framework |
| --- |--- |--- |
| Interfaz empresarial | Biblioteca de clases | .NET Framework |
| BusinessLogic | Biblioteca de clases | .NET Framework |
| WebApplication | Aplicación web ASP.NET Framework | .NET Framework |
| UnitTests | NUnit Proyecto de prueba | .NET Framework |
| Compartido ->Común | Biblioteca de clases | .NET Framework |
| Compartido ->Marco | Biblioteca de clases | .NET Framework |
**Nueva solución:**
|
|
| Nombre del proyecto | Plantilla de proyecto | Target framework |
| --- |--- |--- |
| BusinessLogic | Biblioteca de clases | .NET 5.0 |
| | API web ASP.NET Core | .NET 5.0 |
| . UnitTests | NUnit 3 Proyecto de prueba | .NET 5.0 |
| Compartido ->Común | Biblioteca de clases | .NET 5.0 |
| Compartido ->Marco | Biblioteca de clases | .NET 5.0 |
# Incorporación de inquilinos en la arquitectura SaaS para el modelo de silo mediante C\$1 y AWS CDK
*Tabby Ward, Susmitha Reddy Gankidi y Vijai Anand Ramalingam, Amazon Web Services*
## Resumen
Las aplicaciones de software como servicio (SaaS) se pueden crear con una variedad de modelos arquitectónicos diferentes. El *modelo de silo* se refiere a una arquitectura en la que los inquilinos reciben recursos específicos.
Las aplicaciones SaaS se basan en un modelo sencillo para introducir nuevos inquilinos en su entorno. Esto suele requerir la orquestación de varios componentes para aprovisionar y configurar correctamente todos los elementos necesarios para crear un nuevo inquilino. Este proceso, en la arquitectura SaaS, se denomina incorporación de inquilinos. La incorporación debe automatizarse por completo en todos los entornos de SaaS y utilizar la infraestructura como código en el proceso de incorporación.
Este patrón le guía a través de un ejemplo de creación de un inquilino y aprovisionamiento de una infraestructura básica para el inquilino en Amazon Web Services (AWS). El patrón utiliza C\$1 y el AWS Cloud Development Kit (AWS CDK).
Como este patrón crea una alarma de facturación, le recomendamos implementar la pila en la región Este de EE. UU. (Norte de Virginia) o us-east-1 de AWS. Para obtener más información, consulte la [documentación de AWS](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/monitor_estimated_charges_with_cloudwatch.html).
## Requisitos previos y limitaciones
**Requisitos previos**** **
+ Una [cuenta de AWS](https://aws.amazon.com/account/) activa.
+ Una entidad principal de AWS Identity and Access Management (IAM) con acceso suficiente de IAM para crear recursos de AWS para este patrón. Para obtener más información, consulte [Roles de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html).
+ [Instale Amazon Command Line Interface (AWS CLI)](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) y [configure la CLI de AWS](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html) para realizar la implementación de la CDK de AWS.
+ [Visual Studio 2022](https://visualstudio.microsoft.com/downloads/) descargado o instalado o [Visual Studio Code](https://code.visualstudio.com/download) descargado o instalado.
+ Configuración de [AWS Toolkit para Visual Studio](https://docs.aws.amazon.com/toolkit-for-visual-studio/latest/user-guide/setup.html).
+ [.NET Core 3.1 o posterior](https://dotnet.microsoft.com/download/dotnet-core/3.1) (necesario para las aplicaciones de AWS CDK de C\$1)
+ [Amazon.Lambda.Tools](https://github.com/aws/aws-extensions-for-dotnet-cli#aws-lambda-amazonlambdatools) instalado.
**Limitaciones**** **
+ La CDK de AWS utiliza [AWS CloudFormation](https://aws.amazon.com/cloudformation/), por lo que las aplicaciones de la CDK de AWS están sujetas a cuotas de CloudFormation servicio. Para obtener más información, consulte [ CloudFormation Cuotas de AWS](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cloudformation-limits.html).
+ La CloudFormation pila de inquilinos se crea con un rol de CloudFormation servicio `infra-cloudformation-role` con caracteres comodín en las acciones (`sns`\$1 y`sqs*`), pero con los recursos limitados al `tenant-cluster` prefijo. Para un caso de uso de producción, evalúe esta configuración y proporcione únicamente el acceso obligatorio a este rol de servicio. La función `InfrastructureProvision` Lambda también usa un carácter comodín (`cloudformation*`) para aprovisionar la CloudFormation pila, pero con los recursos limitados al prefijo. `tenant-cluster`
+ La compilación de docker de este ejemplo de código utiliza `--platform=linux/amd64` para forzar imágenes basadas en `linux/amd64`. Esto es para garantizar que los artefactos de imagen finales sean adecuados para Lambda, que de forma predeterminada utiliza una arquitectura x86-64. Si necesita cambiar la arquitectura Lambda de destino, asegúrese de cambiar los códigos CDK de Dockerfiles y de AWS. Para obtener más información, consulte esta entrada en el blog: [Migrating AWS Lambda functions to Arm-based AWS Graviton2 processors](https://aws.amazon.com/blogs/compute/migrating-aws-lambda-functions-to-arm-based-aws-graviton2-processors/).
+ El proceso de eliminación de la pila no limpiará CloudWatch los registros (grupos de registros y registros) generados por la pila. Debe limpiar los registros manualmente a través de la consola de administración de AWS, la CloudWatch consola Amazon o la API.
Este patrón se configura a modo de ejemplo. Para su uso en producción, evalúe las siguientes configuraciones y realice los cambios en función de los requisitos de su empresa:
+ Para simplificar, el bucket de [AWS Simple Storage Service (Amazon S3)](https://aws.amazon.com/s3/) de este ejemplo no tiene habilitado el control de versiones. Evalúe y actualice la configuración según sea necesario.
+ Para simplificar, en este ejemplo se configuran los puntos de conexión de la API de REST de [Amazon API Gateway](https://aws.amazon.com/api-gateway/) sin autenticación, autorización ni limitación. Para uso en producción, recomendamos integrar el sistema con la infraestructura de seguridad empresarial. Evalúe esta configuración y añada la configuración de seguridad necesaria según sea necesario.
+ Para este ejemplo de infraestructura de inquilinos, [Amazon Simple Notification Service (Amazon SNS)](https://aws.amazon.com/sns/) y [Amazon Simple Queue Service (Amazon SQS)](https://aws.amazon.com/sqs/) solo tienen configuraciones mínimas. El [AWS Key Management Service (AWS KMS)](https://aws.amazon.com/kms/) de cada inquilino permite que los servicios de [Amazon CloudWatch](https://aws.amazon.com/cloudwatch/) y Amazon SNS de la cuenta los consuman según la política de [claves de AWS KMS](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-key-management.html#compatibility-with-aws-services). La configuración es solo un marcador de posición de ejemplo. Ajuste las configuraciones según sea necesario en función de su caso de uso empresarial.
+ Toda la configuración, que incluye, entre otros, el aprovisionamiento y la eliminación de los puntos de enlace de la API y los inquilinos de backend mediante AWS CloudFormation, cubre únicamente el caso básico de la ruta feliz. Evalúe y actualice la configuración con la lógica de reintentos necesaria, la lógica adicional de gestión de errores y la lógica de seguridad en función de las necesidades de su empresa.
+ En el momento de escribir este artículo, el código de ejemplo se ha probado con up-to-date [cdk-nag](https://github.com/cdklabs/cdk-nag) para comprobar si existen políticas. Es posible que se apliquen nuevas políticas en el futuro. Es posible que estas nuevas políticas requieran que modifique manualmente la pila en función de las recomendaciones antes de poder implementarla. Revise el código existente para asegurarse de que se ajusta a los requisitos de su empresa.
+ El código se basa en la CDK de AWS para generar un sufijo al azar en lugar de depender de nombres físicos estáticos asignados a la mayoría de los recursos creados. Esta configuración sirve para garantizar que estos recursos sean únicos y no entren en conflicto con otras pilas. Para obtener más información, consulte la [documentación de AWS CDK](https://docs.aws.amazon.com/cdk/v2/guide/resources.html#resources_physical_names). Ajústelo en función de los requisitos de su empresa.
+ Este código de ejemplo empaqueta artefactos .NET Lambda en imágenes basadas en Docker y se ejecuta con el [Tiempo de ejecución de imágenes de contenedor](https://docs.aws.amazon.com/lambda/latest/dg/csharp-image.html) proporcionado por Lambda. El tiempo de ejecución de la imagen del contenedor presenta ventajas como mecanismo estándar de transferencia y almacenamiento (registros de contenedores) y entornos de prueba locales más precisos (a través de la imagen del contenedor). Puede cambiar el proyecto para que utilice los [tiempos de ejecución de .NET proporcionados por Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-csharp.html) para reducir el tiempo de compilación de las imágenes de Docker, pero después tendrá que configurar los mecanismos de transferencia y almacenamiento y asegurarse de que la configuración local coincida con la configuración de Lambda. Ajuste el código para adaptarlo a los requisitos empresariales de los usuarios.
**Versiones de producto**
+ CDK de AWS, versión 2.45.0 o posterior
+ Visual Studio 2022
## Arquitectura
**Pila de tecnología**
+ Amazon API Gateway
+ AWS CloudFormation
+ Amazon CloudWatch
+ Amazon DynamoDB
+ AWS Identity y Access Management (IAM)
+ AWS KMS
+ AWS Lambda
+ Amazon S3
+ Amazon SNS
+ Amazon SQS
**Arquitectura**
En el siguiente diagrama se muestra el flujo de creación de la pila de inquilinos. Para obtener más información sobre los paquetes de tecnología del plano de control y del inquilino, consulte la sección de *Información adicional*.
![\[Flujo de trabajo para crear un inquilino y aprovisionar una infraestructura básica para el inquilino en AWS.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/5baef800-fe39-4eb8-b11d-2c23eb3175fc/images/0b579484-b87c-4acb-8c60-8c33c18370e3.png)
**Flujo de creación de pilas de inquilinos**
1. El usuario envía una solicitud de API POST con la carga útil del nuevo inquilino (nombre del inquilino, descripción del inquilino) en JSON a una API de REST alojada en Amazon API Gateway. La API de puerta de enlace procesa la solicitud y la reenvía a la función de Lambda backend de incorporación de inquilinos. En este ejemplo, no hay autorización ni autenticación. En una configuración de producción, esta API debe integrarse con el sistema de seguridad de la infraestructura SaaS.
1. La función de incorporación de inquilinos verifica la solicitud. A continuación, intenta almacenar el registro del inquilino, que incluye el nombre del inquilino, el identificador único universal (UUID) generado y la descripción del inquilino, en la tabla de incorporación de inquilinos de Amazon DynamoDB.
1. Una vez que DynamoDB almacena el registro, una transmisión de DynamoDB inicia la función de infraestructura de inquilinos de Lambda descendente.
1. La función de Lambda de la infraestructura de inquilino actúa en función de la transmisión de DynamoDB recibida. Si la transmisión es para el evento INSERT, la función utiliza la NewImage sección de la transmisión (registro de última actualización, campo Nombre del inquilino) CloudFormation para crear una nueva infraestructura de arrendatario utilizando la plantilla que está almacenada en el bucket de S3. La CloudFormation plantilla requiere el parámetro Tenant Name.
1. AWS CloudFormation crea la infraestructura de inquilinos en función de la CloudFormation plantilla y los parámetros de entrada.
1. Cada configuración de infraestructura arrendataria tiene una CloudWatch alarma, una alarma de facturación y un evento de alarma.
1. El evento de alarma se convierte en un mensaje dirigido a un tema de SNS, que se cifra con la clave de AWS KMS del inquilino.
1. El tema de SNS reenvía el mensaje de alarma recibido a la cola de SQS, que está cifrada por la clave de cifrado AWS KMS del inquilino.
Se pueden integrar otros sistemas con Amazon SQS para realizar acciones basadas en los mensajes en cola. En este ejemplo, para mantener el código genérico, los mensajes entrantes permanecen en cola y es necesario eliminarlos manualmente.
**Flujo de eliminación de pilas de inquilinos**
1. El usuario envía una solicitud de DELETE API con la carga útil del nuevo inquilino (nombre del inquilino, descripción del inquilino) en JSON a la API de REST alojada por Amazon API Gateway, que procesará la solicitud y la reenviará a la función de incorporación de inquilino. En este ejemplo, no hay autorización ni autenticación. En una configuración de producción, esta API se integrará con el sistema de seguridad de la infraestructura SaaS.
1. La función de incorporación de inquilinos verificará la solicitud y, a continuación, intentará eliminar el registro del inquilino (nombre del inquilino) de la tabla de incorporación de inquilinos.
1. Una vez que DynamoDB elimina el registro correctamente (el registro existe en la tabla y se elimina), una transmisión de DynamoDB inicia la función de infraestructura de inquilinos de Lambda descendente.
1. La función de Lambda de la infraestructura de inquilino actúa en base a la transmisión de DynamoDB recibida. Si la transmisión es para el evento REMOVE, la función utiliza la OldImage sección del registro (información del registro y campo Nombre del inquilino, antes del último cambio, que es eliminar) para iniciar la eliminación de una pila existente en función de la información de ese registro.
1. AWS CloudFormation elimina la pila de inquilinos de destino en función de la entrada.
## Tools (Herramientas)
**Servicios de AWS**
+ [Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/welcome.html) le ayuda a crear, publicar, mantener, supervisar y proteger REST, HTTP y WebSocket APIs a cualquier escala.
+ [AWS Cloud Development Kit (AWS CDK)](https://docs.aws.amazon.com/cdk/v2/guide/home.html) es un marco de desarrollo de software que le ayuda a definir y aprovisionar la infraestructura de la nube de AWS en código.
+ [Kit de herramientas de AWS CDK](https://docs.aws.amazon.com/cdk/v2/guide/cli.html) es un kit de desarrollo en la nube de línea de comandos que ayuda a interactuar con la aplicación AWS Cloud Development Kit (AWS CDK).
+ La [interfaz de la línea de comandos de AWS (AWS CLI)](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) es una herramienta de código abierto que le permite interactuar con los servicios de AWS mediante comandos en su intérprete de comandos de línea de comandos.
+ [AWS](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html) le CloudFormation ayuda a configurar los recursos de AWS, aprovisionarlos de forma rápida y coherente y gestionarlos durante todo su ciclo de vida en todas las cuentas y regiones de AWS.
+ [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) es un servicio de base de datos de NoSQL completamente administrado que ofrece un rendimiento rápido, predecible y escalable.
+ [AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) le permite administrar de forma segura el acceso a los recursos de AWS mediante el control de quién está autenticado y autorizado a utilizarlos.
+ [AWS Key Management Service (AWS KMS)](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html) facilita poder crear y controlar claves criptográficas para proteger los datos.
+ [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) es un servicio de computación que ayuda a ejecutar código sin necesidad de aprovisionar ni administrar servidores. Ejecuta el código solo cuando es necesario y amplía la capacidad de manera automática, por lo que solo pagará por el tiempo de procesamiento que utilice.
+ [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) es un servicio de almacenamiento de objetos basado en la nube que le ayuda a almacenar, proteger y recuperar cualquier cantidad de datos.
+ [Amazon Simple Notification Service (Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/welcome.html)) le permite coordinar y administrar el intercambio de mensajes entre publicadores y clientes, incluidos los servidores web y las direcciones de correo electrónico.
+ [Amazon Simple Queue Service (Amazon SQS)](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/welcome.html) ofrece una cola alojada segura, duradera y disponible que le permite integrar y desacoplar sistemas y componentes de software distribuidos.
+ [AWS Toolkit para Visual Studio](https://docs.aws.amazon.com/toolkit-for-visual-studio/latest/user-guide/welcome.html) es un complemento para el entorno de desarrollo integrado (IDE) de Visual Studio. El Toolkit para Visual Studio permite desarrollar, depurar e implementar aplicaciones .NET que utilizan los servicios de AWS.
**Otras herramientas**
+ [Visual Studio](https://docs.microsoft.com/en-us/visualstudio/ide/whats-new-visual-studio-2022?view=vs-2022) es un entorno de desarrollo integrado (IDE) que incluye compiladores, herramientas de finalización de código, diseñadores gráficos y otras características que facilitan el desarrollo de software.
**Código**
El código de este patrón se encuentra en el repositorio de [Incorporación de inquilinos en la arquitectura SaaS para el modelo silo Ejemplo APG](https://github.com/aws-samples/tenant-onboarding-in-saas-architecture-for-silo-model-apg-example).
## Epics
### Configure AWS CDK
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Compruebe la instalación de Node.js. | Para comprobar que Node.js esté instalado en su equipo local, ejecute el siguiente comando.node --version
| Administrador de AWS, AWS DevOps |
| Instale el kit de herramientas de AWS CDK. | Para instalar el kit de herramientas de AWS CDK en su equipo local, ejecute el siguiente comando.npm install -g aws-cdk
Si npm no está instalado, puede instalarlo desde el [sitio Node.js](https://nodejs.org/en/download/package-manager/). | Administrador de AWS, AWS DevOps |
| Compruebe la versión del kit de herramientas de AWS CDK. | Para comprobar que la versión del kit de herramientas de AWS CDK esté instalada correctamente en su equipo, ejecute el siguiente comando. cdk --version
| Administrador de AWS, AWS DevOps |
### Revise el código del plano de control de incorporación del inquilino
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Clonar el repositorio. | Clone el [repositorio](https://github.com/aws-samples/tenant-onboarding-in-saas-architecture-for-silo-model-apg-example) y navegue hasta la carpeta `\tenant-onboarding-in-saas-architecture-for-silo-model-apg-example`.Abra la solución `\src\TenantOnboardingInfra.sln` en Visual Studio 2022. Abra el archivo `TenantOnboardingInfraStack.cs` y revise el código.Los siguientes recursos se crean como parte de esta pila:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/tenant-onboarding-in-saas-architecture-for-the-silo-model-using-c-and-aws-cdk.html) | Administrador de AWS, AWS DevOps |
| Revise la CloudFormation plantilla. | En la `\tenant-onboarding-in-saas-architecture-for-silo-model-apg-example\template` carpeta`infra.yaml`, abra y revise la CloudFormation plantilla. Esta plantilla se completará con el nombre del inquilino obtenido de la tabla de DynamoDB de incorporación de inquilinos.La plantilla proporciona la infraestructura específica para cada inquilino. En este ejemplo, aprovisiona la clave AWS KMS, Amazon SNS, Amazon SQS y la alarma. CloudWatch | Desarrollador de aplicaciones, AWS DevOps |
| Revise la función de incorporación de inquilinos. | Abra `Function.cs` y revise el código de la función de incorporación de inquilinos, que se crea con la plantilla AWS Lambda Project (.NET Core- C\$1) de Visual Studio con el esquema .NET 6 (Imagen contenedora).Abra `Dockerfile` y revise el código. `Dockerfile` es un archivo de texto que contiene instrucciones para crear la imagen del contenedor de Lambda.Tenga en cuenta que los siguientes NuGet paquetes se añaden como dependencias al `TenantOnboardingFunction` proyecto:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/tenant-onboarding-in-saas-architecture-for-the-silo-model-using-c-and-aws-cdk.html) | Desarrollador de aplicaciones, AWS DevOps |
| Revise la InfraProvisioning función Tenant. | Vaya a `\tenant-onboarding-in-saas-architecture-for-silo-model-apg-example\src\InfraProvisioningFunction`.Abra `Function.cs` y revise el código de la función de aprovisionamiento de la infraestructura inquilina, que se crea con la plantilla AWS Lambda Project (.NET Core- C\$1) de Visual Studio con el esquema .NET 6 (Imagen contenedora).Abra `Dockerfile` y revise el código. Tenga en cuenta que los siguientes NuGet paquetes se agregan como dependencias al `InfraProvisioningFunction` proyecto:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/tenant-onboarding-in-saas-architecture-for-the-silo-model-using-c-and-aws-cdk.html) | Desarrollador de aplicaciones, AWS DevOps |
### Implementar recursos de AWS
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Compilar la solución. | Para crear la solución, siga los pasos que se indican a continuación:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/tenant-onboarding-in-saas-architecture-for-the-silo-model-using-c-and-aws-cdk.html)Asegúrese de actualizar el paquete `Amazon.CDK.Lib NuGet` a la última versión del proyecto `\tenant-onboarding-in-saas-architecture-for-silo-model-apg-example\src\TenantOnboardingInfra` antes de crear la solución. | Desarrollador de aplicaciones |
| Inicie el entorno de AWS CDK. | Abra la línea de comandos de Windows y vaya a la carpeta raíz de la aplicación AWS CDK donde está disponible el archivo `cdk.json` (`\tenant-onboarding-in-saas-architecture-for-silo-model-apg-example`). Ejecute el siguiente comando para el arranque.cdk bootstrap
Si ha creado un perfil de AWS para las credenciales, utilice el comando con su perfil.cdk bootstrap --profile
| Administrador de AWS, AWS DevOps |
| Enumere las pilas de CDK de AWS. | Para obtener una lista de todas las pilas que se van a crear como parte de este proyecto, ejecute el siguiente comando.cdk ls
cdk ls --profile
Si ha creado un perfil de AWS para las credenciales, utilice el comando con su perfil.cdk ls --profile
| Administrador de AWS, AWS DevOps |
| Revise qué recursos de AWS se crearán. | Para revisar todos los recursos de AWS que se crearán como parte de este proyecto, ejecute el siguiente comando.cdk diff
Si ha creado un perfil de AWS para las credenciales, utilice el comando con su perfil.cdk diff --profile
| Administrador de AWS, AWS DevOps |
| Implemente todos los recursos de AWS mediante AWS CDK. | Use el siguiente comando para implementar todos los recursos de AWS.cdk deploy --all --require-approval never
Si ha creado un perfil de AWS para las credenciales, utilice el comando con su perfil.cdk deploy --all --require-approval never --profile
Una vez completada la implementación, copie la URL de la API de la sección de resultados de la línea de comandos, como se muestra en el siguiente ejemplo.Outputs:
TenantOnboardingInfraStack.TenantOnboardingAPIEndpoint42E526D7 = https://j2qmp8ds21i1i.execute-api.us-west-2.amazonaws.com/prod/
| Administrador de AWS, AWS DevOps |
### Verificar la funcionalidad
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Cree un nuevo inquilino. | Para crear el nuevo inquilino, envíe la siguiente solicitud de curl.curl -X POST tenant -d '{"Name":"Tenant123", "Description":"Stack for Tenant123"}'
Cambie el marcador de posición `` por el valor real de AWS CDK, como se muestra en el siguiente ejemplo.curl -X POST https://j2qmp8ds21i1i.execute-api.us-west-2.amazonaws.com/prod/tenant -d '{"Name":"Tenant123", "Description":"test12"}'En el siguiente ejemplo, se muestra el resultado.{"message": "A new tenant added - 5/4/2022 7:11:30 AM"} | Desarrollador de aplicaciones, administrador de AWS, AWS DevOps |
| Compruebe los detalles del inquilino recién creado en DynamoDB. | Para comprobar los detalles del inquilino recién creado en DynamoDB, siga estos pasos.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/tenant-onboarding-in-saas-architecture-for-the-silo-model-using-c-and-aws-cdk.html) | Desarrollador de aplicaciones, administrador de AWS, AWS DevOps |
| Verifique la creación de la pila para el nuevo inquilino. | Compruebe que la nueva pila se haya creado correctamente y se haya aprovisionado con la infraestructura para el inquilino recién creado de acuerdo con la CloudFormation plantilla.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/tenant-onboarding-in-saas-architecture-for-the-silo-model-using-c-and-aws-cdk.html) | Desarrollador de aplicaciones, administrador de AWS, AWS DevOps |
| Elimine la pila de inquilinos. | Para eliminar la nueva pila de inquilinos, envíe la siguiente solicitud de curl.curl -X DELETE tenant/
Cambie el marcador de posición `` por el valor real de AWS CDK y cambie `` por el valor real del paso anterior de creación del inquilino, como se muestra en el siguiente ejemplo.curl -X DELETE https://j2qmp8ds21i1i.execute-api.us-west-2.amazonaws.com/prod/tenant/Tenant123
En el siguiente ejemplo, se muestra el resultado.{"message": "Tenant destroyed - 5/4/2022 7:14:48 AM"} | Desarrollador de aplicaciones, AWS DevOps, administrador de AWS |
| Verifique la eliminación de la pila para el inquilino existente. | Para comprobar que se ha eliminado la pila de inquilinos existente, siga estos pasos:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/tenant-onboarding-in-saas-architecture-for-the-silo-model-using-c-and-aws-cdk.html) | Desarrollador de aplicaciones, administrador de AWS, AWS DevOps |
### Limpieza
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Destruya el entorno. | Antes de limpiar la pila, asegúrese de lo siguiente:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/tenant-onboarding-in-saas-architecture-for-the-silo-model-using-c-and-aws-cdk.html)Una vez finalizadas las pruebas, se puede usar AWS CDK para destruir todas las pilas y los recursos relacionados mediante la ejecución del siguiente comando.cdk destroy --all;
Si ha creado un perfil de AWS para las credenciales, utilice el perfil.Confirme la solicitud de eliminación de la pila para eliminarla. | Administrador de AWS, AWS DevOps |
| Limpia Amazon CloudWatch Logs. | El proceso de eliminación de la pila no limpiará CloudWatch los registros (grupos de registros y registros) generados por la pila. Limpie los CloudWatch recursos manualmente mediante la CloudWatch consola o la API. | Desarrollador de aplicaciones, AWS DevOps, administrador de AWS |
## Recursos relacionados
+ [Taller sobre AWS CDK .NET](https://cdkworkshop.com/40-dotnet.html)
+ [Utilización de AWS CDK en C\$1](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-csharp.html)
+ [Referencia de CDK .NET](https://docs.aws.amazon.com/cdk/api/v2/dotnet/api/index.html)
## Información adicional
**Conjunto de tecnologías de plano de control**
El código CDK escrito en .NET se utiliza para aprovisionar la infraestructura del plano de control, que consta de los siguientes recursos:
1. **API Gateway**
Sirve como punto de entrada de la API de REST para la pila del plano de control.
1. **Función de Lambda de incorporación de inquilinos**
La puerta de enlace de API inicia esta función de Lambda mediante el método m.
Una solicitud de API del método POST hace que (`tenant name`, `tenant description`) se inserte en la tabla de DynamoDB `Tenant Onboarding`.
En este ejemplo de código, el nombre del inquilino también se usa como parte del nombre de la pila de inquilinos y de los nombres de los recursos de esa pila. Esto es para facilitar la identificación de estos recursos. El nombre de este inquilino debe ser único en la configuración para evitar conflictos o errores. La configuración detallada de la validación de entradas se explica en la documentación sobre los [roles de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) y en la sección de *Limitations* (Limitaciones).
El proceso de persistencia en la tabla de DynamoDB solo tendrá éxito si el nombre del inquilino no se utiliza en ningún otro registro de la tabla.
En este caso, el nombre del inquilino es la clave de partición de esta tabla, ya que solo la clave de partición se puede usar como expresión de condición `PutItem`.
Si el nombre del inquilino nunca se registró antes, el registro se guardará correctamente en la tabla.
Sin embargo, si un registro existente de la tabla ya utiliza el nombre del inquilino, la operación fallará e iniciará una excepción de DynamoDB `ConditionalCheckFailedException`. La excepción se utilizará para devolver un mensaje de error (`HTTP BadRequest`) que indique que el nombre del inquilino ya existe.
Una solicitud de API de método `DELETE` eliminará el registro de un nombre de inquilino específico de la tabla `Tenant Onboardin`.
La eliminación del registro de DynamoDB en este ejemplo se realizará correctamente aunque el registro no exista.
Si el registro de destino existe y se elimina, se creará un registro de transmisión de DynamoDB. De lo contrario, no se creará ningún registro posterior.
1. **Incorporación de DynamoDB por parte del inquilino, con Amazon DynamoDB Streams habilitado**
Esto registra la información de los metadatos del inquilino y cualquier registro que se guarde o elimine enviará un flujo descendente a la función de Lambda `Tenant Infrastructure`.
1. **Función de Lambda de infraestructura inquilina**
Esta función de Lambda la inicia el registro de flujo de DynamoDB del paso anterior. Si el registro corresponde a un `INSERT` evento, invoca CloudFormation a AWS para crear una nueva infraestructura de inquilinos con la CloudFormation plantilla almacenada en un bucket de S3. Si el registro es para `REMOVE`, se inicia la eliminación de una pila existente en función del campo del registro de transmisión `Tenant Name`.
1. **Bucket de S3**
Esto sirve para almacenar la CloudFormation plantilla.
1. **Funciones de IAM para cada función de Lambda y una función de servicio para CloudFormation**
Cada función de Lambda tiene su rol de IAM único con [permisos de privilegio mínimo](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege) para realizar su tarea. Por ejemplo, la función `Tenant On-boarding` Lambda tiene read/write acceso a DynamoDB y la función `Tenant Infrastructure` Lambda solo puede leer el flujo de DynamoDB.
Se crea un rol de CloudFormation servicio personalizado para el aprovisionamiento de la pila de inquilinos. Esta función de servicio contiene permisos adicionales para el aprovisionamiento de CloudFormation pilas (por ejemplo, la clave de AWS KMS). Esto divide las funciones entre Lambda y CloudFormation evita todos los permisos en una sola función (función de Infraestructura Lambda).
Los permisos que permiten realizar acciones poderosas (como crear y eliminar CloudFormation pilas) están bloqueados y solo se permiten en los recursos que comienzan con. `tenantcluster-` La excepción es AWS KMS, debido a su convención de nomenclatura de recursos. El nombre del inquilino introducido por la API irá precedido de `tenantcluster-` así como otras comprobaciones de validación (alfanuméricas solo con guiones y limitadas a menos de 30 caracteres para que quepan en la mayoría de los nombres de los recursos de AWS). Esto garantiza que el nombre del inquilino no provoque una interrupción accidental de los recursos o las pilas de la infraestructura principal.
**Pila de tecnología para inquilinos**
La CloudFormation plantilla se almacena en el depósito de S3. [La plantilla proporciona la clave de AWS KMS específica del inquilino, una CloudWatch alarma, un tema de SNS, una cola de SQS y una política de SQS.](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-using-identity-based-policies.html)
Amazon SNS y Amazon SQS utilizan la clave de AWS KMS para el cifrado de datos de sus mensajes. Las prácticas de seguridad para [AwsSolutions(SNS2 y AwsSolutions) SQS2](https://github.com/cdklabs/cdk-nag/blob/main/RULES.md) recomiendan configurar Amazon SNS y Amazon SQS con cifrado. Sin embargo, CloudWatch las alarmas no funcionan con Amazon SNS cuando se utiliza una clave gestionada por AWS, por lo que debe utilizar una clave gestionada por el cliente en este caso. Para obtener más información, consulte el [Centro de conocimientos de AWS](https://aws.amazon.com/premiumsupport/knowledge-center/cloudwatch-receive-sns-for-alarm-trigger/).
La política de SQS se utiliza en la cola de Amazon SQS para permitir que el tema de SNS creado entregue el mensaje a la cola. Sin la política SQS, se denegará el acceso. Para obtener más información, consulte la [documentación de Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/subscribe-sqs-queue-to-sns-topic.html#SendMessageToSQS.sqs.permissions).
# Descomponga monolitos en microservicios mediante CQRS y abastecimiento de eventos
*Rodolfo Jr. Cerrada, Dmitry Gulin y Tabby Ward, Amazon Web Services*
## Resumen
Este patrón combina dos patrones y emplea tanto el patrón de división de responsabilidad por consultas de comandos (CQRS) como el patrón de abastecimiento de eventos. El patrón CQRS divide las responsabilidades de los modelos de comando y consulta. El patrón de abastecimiento de eventos aprovecha la comunicación asincrónica basada en eventos para mejorar la experiencia general del usuario.
Puede usar servicios de CQRS y Amazon Web Services (AWS) para mantener y escalar cada modelo de datos de forma independiente y, al mismo tiempo, refactorizar su aplicación monolítica en una arquitectura de microservicios. Después, puede usar el patrón de abastecimiento de eventos para sincronizar los datos de la base de datos de comandos con la base de datos de consultas.
Este patrón emplea un código de ejemplo que incluye un archivo de solución (\$1.sln) que puede abrir con la versión más reciente de Visual Studio. El ejemplo contiene el código de la API Reward para mostrar el funcionamiento de CQRS y el abastecimiento de eventos en aplicaciones de AWS sin servidor y aplicaciones tradicionales o en las instalaciones.
Para obtener más información sobre CQRS y el abastecimiento de eventos, consulte la sección de [Información adicional](#decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing-additional).
## Requisitos previos y limitaciones
**Requisitos previos **
+ Una cuenta de AWS activa
+ Amazon CloudWatch
+ Tablas de Amazon DynamoDB
+ Amazon DynamoDB Streams
+ Clave de acceso y clave secreta de AWS Identity and Access Management (IAM); para obtener más información, consulte el video de la sección de *Recursos relacionados*
+ AWS Lambda
+ Familiaridad con Visual Studio
+ Familiaridad con el kit de herramientas de AWS para Visual Studio; para obtener más información, consulte el video de *demostración del Kit de herramientas de AWS para Visual Studio* en la sección de *Recursos relacionados*
**Versiones de producto**
+ [Microsoft Visual Studio 2019 Community Edition](https://visualstudio.microsoft.com/downloads/).
+ [AWS Toolkit para Visual Studio 2019](https://aws.amazon.com/visualstudio/).
+ .NET Core 3.1. Este componente es una opción de la instalación de Visual Studio. Para incluir .NET Core durante la instalación, seleccione **desarrollo multiplataforma de NET Core**.
**Limitaciones**
+ El código de ejemplo de aplicación tradicional en las instalaciones (ASP.NET Core Web API y objetos de acceso a datos) no incluye base de datos. Sin embargo, incluye el objeto en memoria `CustomerData`, que actúa como base de datos simulada. El código proporcionado es suficiente para probar el patrón.
## Arquitectura
**Pila de tecnología de origen**
+ Proyecto ASP.NET Core Web API
+ Servidor web IIS
+ Objeto de acceso a datos
+ Modelo CRUD
**Arquitectura de origen**
En la arquitectura de origen, el modelo CRUD contiene interfaces de comandos y consultas en una sola aplicación. Para ver un código de ejemplo, consulte `CustomerDAO.cs` (adjunto).
![\[Conexiones entre la aplicación, la interfaz de servicio, el modelo CRUD del cliente y la base de datos.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/9f1bc700-def4-4201-bb2d-f1fa27404f15/images/1cd3a84c-12c7-4306-99aa-23f2c53d3cd3.png)
**Pila de tecnología de destino**
+ Amazon DynamoDB
+ Amazon DynamoDB Streams
+ AWS Lambda
+ (Opcional) Amazon API Gateway
+ (Opcional) Amazon Simple Notification Service (Amazon SNS)
**Arquitectura de destino**
En la arquitectura de destino, las interfaces de comando y consulta están separadas. La arquitectura que se muestra en el siguiente diagrama se puede ampliar con puerta de enlace API y Amazon SNS. Para obtener más información, consulte la sección [Información adicional](#decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing-additional).
![\[Aplicación que se conecta con los microservicios de comandos del cliente y consultas del cliente sin servidor.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/9f1bc700-def4-4201-bb2d-f1fa27404f15/images/1c665697-e3ac-4ef4-98d0-86c2cbf164c1.png)
1. Las funciones de comandos de Lambda realizan operaciones de escritura, como crear, actualizar o eliminar, en la base de datos.
1. Las funciones de consulta de Lambda realizan operaciones de lectura, como obtener o seleccionar, en la base de datos.
1. Esta función de Lambda procesa los flujos de DynamoDB de la base de datos de comandos y actualiza la base de datos de consultas con los cambios.
## Tools (Herramientas)
**Herramientas**
+ [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html): Amazon DynamoDB es un servicio de base de datos NoSQL totalmente administrado que ofrece un rendimiento rápido y predecible, así como una perfecta escalabilidad.
+ [Amazon DynamoDB Streams](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Streams.html): DynamoDB Streams captura una secuencia en orden cronológico de las modificaciones de los elementos en una tabla de DynamoDB. Este servicio posteriormente almacena esta información en un registro durante un máximo de 24 horas. El cifrado en reposo cifra los datos en DynamoDB streams.
+ [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html): AWS Lambda es un servicio de computación que permite ejecutar código sin aprovisionar ni administrar servidores. Lambda ejecuta su código solo cuando es necesario y escala de manera automática, desde unas pocas solicitudes por día hasta miles por segundo. Solo pagará por el tiempo de computación que consuma, no se aplican cargos cuando el código no se está ejecutando.
+ [La consola de administración de AWS](https://docs.aws.amazon.com/awsconsolehelpdocs/latest/gsg/learn-whats-new.html): la consola de administración de AWS es una aplicación web que engloba y hace referencia a un amplio conjunto de consolas de servicios para la administración de recursos de AWS.
+ [Visual Studio 2019 Community Edition](https://visualstudio.microsoft.com/downloads/): Visual Studio 2019 es un entorno de desarrollo integrado (IDE). La Community Edition es gratuita para colaboradores de código abierto. En este patrón usará Visual Studio 2019 Community Edition para abrir, compilar y ejecutar código de ejemplo. Solo con fines de visualización, puede usar cualquier editor de texto o [Visual Studio Code](https://docs.aws.amazon.com/toolkit-for-vscode/latest/userguide/welcome.html).
+ [AWS Toolkit para Visual Studio](https://docs.aws.amazon.com/toolkit-for-visual-studio/latest/user-guide/welcome.html): el AWS Toolkit para Visual Studio es un complemento para el IDE de Visual Studio. El AWS Toolkit para Visual Studio facilita el desarrollo, la depuración y la implementación de aplicaciones .NET que utilizan servicios de AWS.
**Código**
Se adjunta el código de ejemplo. Para obtener más instrucciones sobre cómo implementar el código de ejemplo, consulta la sección *Epics*.
## Epics
### Abra y cree la solución
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Abra la solución. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html) | Desarrollador de aplicaciones |
| Cree la solución. | Abra el menú contextual (clic derecho) de la solución y elija **Compilar solución**. Esto generará y compilará todos los proyectos de la solución. La compilación debería realizarse correctamente.Visual Studio Solution Explorer mostrará la estructura de directorios.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html) | Desarrollador de aplicaciones |
### Cree tablas de DynamoDB
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Proporcionar credenciales. | Si aún no tiene una clave de acceso, consulte el video de la sección de *Recursos relacionados*.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html) | Desarrollador de aplicaciones, ingeniero de datos, administrador de base de datos |
| Compilar el proyecto. | Para compilar el proyecto, abra el menú contextual (clic derecho) del proyecto **AwS.APG.CQRSES.Build** y seleccione **Compilar**. | Desarrollador de aplicaciones, ingeniero de datos, administrador de base de datos |
| Cree y rellene las tablas. | Para compilar las tablas y rellenarlas con datos iniciales, abra el menú contextual (clic derecho) del proyecto **AwS.APG.CQRSES.Build** y seleccione **Depurar**, **Iniciar nueva instancia**. | Desarrollador de aplicaciones, ingeniero de datos, administrador de base de datos |
| Verifique la construcción de la tabla y los datos. | Para comprobarlo, acceda al **Explorador de AWS** y expanda **Amazon DynamoDB**. Se mostrarán las tablas. Abra cada tabla para mostrar los datos de ejemplo. | Desarrollador de aplicaciones, ingeniero de datos, administrador de base de datos |
### Ejecute pruebas locales
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Crear el proyecto CQRS. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html) | Desarrollador de aplicaciones, ingeniero de pruebas |
| Cree el proyecto de abastecimiento de eventos. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html) | Desarrollador de aplicaciones, ingeniero de pruebas |
| Ejecutar las pruebas. | Para ejecutar todas las pruebas, seleccione **Ver**, **Explorador de pruebas** y, a continuación, seleccione **Ejecutar todas las pruebas a la vista**. Todas las pruebas resultarán correctas. El sistema lo indicará con un icono de marca de verificación verde. | Desarrollador de aplicaciones, ingeniero de pruebas |
### Publique las funciones de Lambda de CQRS en AWS
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Publica la primera función de Lambda. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html) | Desarrollador de aplicaciones, DevOps ingeniero |
| Verifique la carga de la función. | (Opcional) Para comprobar que la función se ha cargado correctamente, acceda al Explorador de AWS y expanda **AWS Lambda**. Para abrir la ventana de prueba, seleccione la función de Lambda (doble clic). | Desarrollador de aplicaciones, DevOps ingeniero |
| Pruebe la función de Lambda. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html)Todos los proyectos Lambda de CQRS se encuentran en las carpetas de soluciones `CQRS AWS Serverless\CQRS\Command Microservice` y ` CQRS AWS Serverless\CQRS\Command Microservice`. Para ver el directorio de soluciones y los proyectos, consulte el **Directorio de códigos fuente** en la sección de [Información adicional](#decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing-additional). | Desarrollador de aplicaciones, DevOps ingeniero |
| Publique las funciones restantes. | Repita los pasos previos para los siguientes proyectos:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html) | Desarrollador de aplicaciones, DevOps ingeniero |
### Configure la función de Lambda como oyente de eventos
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Publique los controladores de eventos Customer y Reward Lambda. | Para publicar cada controlador de eventos, siga los pasos de la épica anterior.Los proyectos se encuentran en las carpetas de soluciones `CQRS AWS Serverless\Event Source\Customer Event` y `CQRS AWS Serverless\Event Source\Reward Event`. Para obtener más información, consulte *Directorio de código fuente* en la sección [Información adicional](#decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing-additional). | Desarrollador de aplicaciones |
| Adjunte el oyente de Lambda detector de eventos. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html)Una vez que el oyente se haya adjuntado correctamente a la tabla de DynamoDB, se mostrará en la página del diseñador de Lambda. | Desarrollador de aplicaciones |
| Publique y adjunte la EventSourceReward función Lambda. | Para publicar y adjuntar la función `EventSourceReward` Lambda, repita los pasos de las dos historias anteriores y selecciónela en la lista desplegable **cqrses-reward-cmd**de tablas de **DynamoDB**. | Desarrollador de aplicaciones |
### Pruebe y valide los flujos de DynamoDB y el desencadenante de Lambda
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Pruebe la transmisión y el desencadenante de Lambda. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html) | Desarrollador de aplicaciones |
| Valide usando la tabla de consultas de recompensas de DynamodDB. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html) | Desarrollador de aplicaciones |
| Valide mediante CloudWatch registros. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html) | Desarrollador de aplicaciones |
| Valide el EventSourceCustomer disparador. | Para validar el `EventSourceCustomer` disparador, repite los pasos de esta epopeya utilizando la tabla de clientes y los CloudWatch registros respectivos del `EventSourceCustomer` disparador. | Desarrollador de aplicaciones |
## Recursos relacionados
**Referencias**
+ [Descargas de Visual Studio 2019 Community Edition](https://visualstudio.microsoft.com/downloads/)
+ [Descargar AWS Toolkit para Visual Studio](https://aws.amazon.com/visualstudio/)
+ [Guía del usuario de AWS Toolkit para Visual Studio](https://docs.aws.amazon.com/toolkit-for-visual-studio/latest/user-guide/welcome.html)
+ [Sin servidor en AWS](https://aws.amazon.com/serverless/)
+ [Casos de uso y patrones de diseño de DynamoDB](https://aws.amazon.com/blogs/database/dynamodb-streams-use-cases-and-design-patterns/)
+ [CQRS Martin Fowler](https://martinfowler.com/bliki/CQRS.html)
+ [Aprovisionamiento de eventos Martin Fowler](https://martinfowler.com/eaaDev/EventSourcing.html)
**Videos**
+ [Demo de AWS Toolkit para Visual Studio](https://www.youtube.com/watch?v=B190tcu1ERk)
+ [¿Cómo creo una ID de clave de acceso para un nuevo usuario de IAM?](https://www.youtube.com/watch?v=665RYobRJDY)
## Información adicional
**CQRS y abastecimiento de eventos**
*CQRS*
El patrón CQRS separa un único modelo de operaciones conceptual, como un modelo CRUD (creación, lectura, actualización, eliminación) único de objetos de acceso a datos, en modelos de operaciones de comando y consulta. El modelo de comandos hace referencia a cualquier operación, como crear, actualizar o eliminar, que cambia el estado. El modelo de consulta hace referencia a cualquier operación que devuelva un valor.
![\[Arquitectura con interfaz de servicio, modelo CRUD y base de datos.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/9f1bc700-def4-4201-bb2d-f1fa27404f15/images/3f64756d-681e-4f0e-8034-746263d857b2.png)
1. El modelo CRUD del cliente incluye las siguientes interfaces:
+ `Create Customer()`
+ `UpdateCustomer()`
+ `DeleteCustomer()`
+ `AddPoints()`
+ `RedeemPoints()`
+ `GetVIPCustomers()`
+ `GetCustomerList()`
+ `GetCustomerPoints()`
Cuando sus necesidades sean más complejas, podrá superar este enfoque de modelo único. El CQRS emplea un modelo de comandos y un modelo de consulta para separar las responsabilidades de escribir y leer los datos. De esta forma, los datos se pueden mantener y gestionar de forma independiente. Con una clara separación de responsabilidades, las mejoras de cada modelo no afectan al otro. Esta separación mejora el mantenimiento y el rendimiento, y reduce la complejidad de la aplicación a medida que crece.
![\[La aplicación se divide en modelos de comandos y consultas, y comparte una única base de datos.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/9f1bc700-def4-4201-bb2d-f1fa27404f15/images/12db023c-eb81-4c27-bbb9-b085b13176ae.png)
1. Interfaces en el modelo de comandos del cliente:
+ `Create Customer()`
+ `UpdateCustomer()`
+ `DeleteCustomer()`
+ `AddPoints()`
+ `RedeemPoints()`
1. Interfaces en el modelo de consultas del cliente:
+ `GetVIPCustomers()`
+ `GetCustomerList()`
+ `GetCustomerPoints()`
+ `GetMonthlyStatement()`
Para ver código de ejemplo, consulte el *Directorio de códigos fuente*.
A continuación, el patrón CQRS desacopla la base de datos. Esta disociación posibilita la independencia total de cada servicio, que es el ingrediente principal de la arquitectura de microservicios.
![\[Bases de datos independientes para los modelos de comandos y consultas.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/9f1bc700-def4-4201-bb2d-f1fa27404f15/images/016dbfa8-3bd8-42ee-afa1-38a98986c7d5.png)
Al usar CQRS en la nube de AWS, puede optimizar aún más cada servicio. Por ejemplo, puede establecer diferentes configuraciones informáticas, o elegir entre un microservicio sin servidor o uno basado en contenedores. Puedes sustituir el almacenamiento en caché local por Amazon. ElastiCache Si tiene una publish/subscribe mensajería local, puede sustituirla por Amazon Simple Notification Service (Amazon SNS). Además, puede aprovechar los pay-as-you-go precios y la amplia gama de servicios de AWS, que solo paga por lo que utiliza.
CQRS ofrece los siguientes beneficios:
+ Escalado independiente: la estrategia de escalado de cada modelo se puede adaptar para satisfacer los requisitos y la demanda del servicio. Al igual que en las aplicaciones de alto rendimiento, separar la lectura y la escritura permite escalar el modelo de forma independiente para satisfacer cada demanda. También puede agregar o reducir recursos de cómputo para satisfacer la demanda de escalabilidad de un modelo sin afectar al otro.
+ Mantenimiento independiente: la separación de los modelos de consulta y comando mejora la capacidad de mantenimiento de los modelos. Puede realizar cambios en el código y mejoras en un modelo sin que ello afecte al otro.
+ Seguridad: es más fácil aplicar los permisos y las políticas a modelos separados para lectura y escritura.
+ Lecturas optimizadas: puede definir un esquema optimizado para las consultas. Por ejemplo, puede definir un esquema para datos agregados y un esquema independiente para tablas de hechos.
+ Integración: CQRS se adapta bien a los modelos de programación basados en eventos.
+ Complejidad gestionada: la separación en modelos de consulta y comando es adecuada para dominios complejos.
Al utilizar CQRS, tenga en cuenta lo siguiente:
+ El patrón de CQRS se aplica solo a una parte específica de una aplicación, y no a su conjunto. La implementación en un dominio inadecuado para el patrón puede reducir la productividad, aumentar el riesgo e introducir complejidad.
+ El patrón funciona mejor en modelos de uso frecuente que presentan un desequilibrio en las operaciones de lectura y escritura.
+ En el caso de aplicaciones de lectura intensiva, como informes de gran tamaño que tardan en procesarse, CQRS le ofrece la opción de seleccionar la base de datos adecuada y crear un esquema para almacenar los datos agregados. Esto mejora el tiempo de respuesta en la lectura y visualización del informe, ya que procesa los datos del informe solo una vez y los coloca en la tabla agregada.
+ En el caso de las aplicaciones de escritura intensiva, puede configurar la base de datos para operaciones de escritura y permitir que el microservicio de comandos se escale de forma independiente cuando aumente la demanda de escritura. Para ver ejemplos, consulte los microservicios `AWS.APG.CQRSES.CommandRedeemRewardLambda` y `AWS.APG.CQRSES.CommandAddRewardLambda`.
*Aprovisionamiento de eventos*
El siguiente paso consiste en usar el abastecimiento de eventos para sincronizar la base de datos de consultas cuando se ejecuta un comando. Por ejemplo, considere los siguientes eventos:
+ Al añadir un punto de recompensa, es necesario actualizar sus puntos de recompensa totales o agregados en la base de datos de consultas.
+ El apellido del cliente se actualiza en la base de datos de comandos, y es necesario actualizar la información del cliente en la base de datos de consultas.
En un modelo CRUD tradicional, se garantiza la coherencia de los datos al bloquearlos hasta que finalice la transacción. En el abastecimiento de eventos, los datos se sincronizan publicando una serie de eventos que el suscriptor utilizará para actualizar sus datos respectivos.
El patrón de abastecimiento de eventos garantiza y registra una serie completa de acciones realizadas con los datos, y las publica a través de una secuencia de eventos. Estos eventos representan un conjunto de cambios en los datos que los suscriptores de ese evento deben procesar para mantener su registro actualizado. El suscriptor consume estos eventos y sincroniza los datos en la base de datos del suscriptor. En este caso, es la base de datos de consultas.
El siguiente diagrama muestra el abastecimiento de eventos con CQRS en AWS.
![\[Arquitectura de microservicios para CQRS y patrones de abastecimiento de eventos mediante servicios sin servidor de AWS.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/9f1bc700-def4-4201-bb2d-f1fa27404f15/images/cc9bc84a-60b4-4459-9a5c-2334c69dbb4e.png)
1. Las funciones de comandos de Lambda realizan operaciones de escritura, como crear, actualizar o eliminar, en la base de datos.
1. Las funciones de consulta de Lambda realizan operaciones de lectura, como obtener o seleccionar, en la base de datos.
1. Esta función de Lambda procesa los flujos de DynamoDB de la base de datos de comandos y actualiza la base de datos de consultas con los cambios. También puede usar esta función para publicar un mensaje en Amazon SNS y que los suscriptores puedan procesar los datos.
1. (Opcional) El suscriptor del evento de Lambda procesa el mensaje publicado por Amazon SNS y actualiza la base de datos de consultas.
1. (Opcional) Amazon SNS envía una notificación por correo electrónico de la operación de escritura.
En AWS, DynamoDB Streams puede sincronizar la base de datos de consultas. DynamoDB captura una secuencia en orden cronológico de las modificaciones de los elementos en la tabla de DynamoDB en tiempo casi real y almacena la información de forma duradera en un plazo máximo de 24 horas.
La activación de DynamoDB Streams permite a la base de datos publicar una secuencia de eventos que posibilita el patrón de abastecimiento de eventos. El patrón de abastecimiento de eventos añade al suscriptor del evento. La aplicación del suscriptor del evento consume el evento y lo procesa en función de la responsabilidad del suscriptor. En el diagrama anterior, el suscriptor del evento envía los cambios a la base de datos de Query DynamoDB para mantener los datos sincronizados. El uso de Amazon SNS, el agente de mensajes y la aplicación de suscripción de eventos mantiene la arquitectura desacoplada.
El abastecimiento de eventos ofrece los siguientes beneficios:
+ Coherencia de los datos transaccionales
+ Un registro de auditoría fiable y un historial de las acciones que permite supervisar las medidas adoptadas en los datos
+ Las aplicaciones distribuidas, como los microservicios, pueden sincronizar sus datos en todo el entorno
+ Publicación fiable de los eventos siempre que cambie el estado
+ Reconstrucción o reproducción de estados anteriores
+ Entidades con acoplamiento flexible que intercambian eventos para migrar de una aplicación monolítica a microservicios
+ Reducción de los conflictos causados por actualizaciones simultáneas; el abastecimiento de eventos evita la necesidad de actualizar los objetos directamente en el almacén de datos
+ Flexibilidad y extensibilidad, ya que la tarea se desvincula del evento
+ Actualizaciones externas del sistema
+ Gestión de múltiples tareas en un solo evento
Cuando use abastecimiento de eventos, tenga en cuenta los siguientes puntos:
+ Como existe cierto retardo en la actualización de los datos entre las bases de datos de suscriptor de origen, la única forma de deshacer un cambio es añadir un evento de compensación al almacén de eventos.
+ La implementación del abastecimiento de eventos tiene cierta curva de aprendizaje, ya que su estilo de programación es diferente.
**Datos de prueba**
Use los siguientes datos de prueba para probar la función de Lambda tras una implementación correcta.
**CommandCreate Cliente**
```
{ "Id":1501, "Firstname":"John", "Lastname":"Done", "CompanyName":"AnyCompany", "Address": "USA", "VIP":true }
```
**CommandUpdate Cliente**
```
{ "Id":1501, "Firstname":"John", "Lastname":"Doe", "CompanyName":"Example Corp.", "Address": "Seattle, USA", "VIP":true }
```
**CommandDelete Cliente**
Introduzca la ID del cliente como dato de solicitud. Por ejemplo, si la ID de cliente es 151, introduzca 151 como dato de solicitud.
```
151
```
**QueryCustomerList**
Está en blanco. Cuando se invoca, devuelve a todos los clientes.
**CommandAddReward**
Añade 40 puntos al cliente con la ID 1 (Richard).
```
{
"Id":10101,
"CustomerId":1,
"Points":40
}
```
**CommandRedeemReward**
Esto reducirá 15 puntos al cliente con la ID 1 (Richard).
```
{
"Id":10110,
"CustomerId":1,
"Points":15
}
```
**QueryReward**
Introduzca la ID del cliente. Por ejemplo, introduzca 1 para Richard, 2 para Arnav y 3 para Shirley.
```
2
```
**Directorio de códigos fuente**
Use la siguiente tabla como guía de estructura de directorios de la solución de Visual Studio.
*Ejemplo de código de muestra de directorio CQRS en las instalaciones*
![\[Se ha ampliado el directorio de soluciones con los servicios de comando y consulta.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/9f1bc700-def4-4201-bb2d-f1fa27404f15/images/4811c2c0-643b-410f-bb87-0b86ec5e194c.png)
**Modelo CRUD de cliente**
Proyecto CQRS On-Premises Code Sample\$1CRUD Model\$1AWS.APG.CQRSES.DAL
**Versión CQRS del modelo CRUD del cliente**
+ Comando del cliente: proyecto `CQRS On-Premises Code Sample\CQRS Model\Command Microservice\AWS.APG.CQRSES.Command`
+ Consulta del cliente: proyecto `CQRS On-Premises Code Sample\CQRS Model\Query Microservice\AWS.APG.CQRSES.Query`
**Microservicios de comando y consulta**
El microservicio de comandos se encuentra en la carpeta de soluciones `CQRS On-Premises Code Sample\CQRS Model\Command Microservice`:
+ El proyecto de API ASP.NET Core `AWS.APG.CQRSES.CommandMicroservice` actúa como punto de entrada desde el que los consumidores interactúan con el servicio.
+ El proyecto .NET Core `AWS.APG.CQRSES.Command` es un objeto que aloja objetos e interfaces relacionados con comandos.
El microservicio de consultas se encuentra en la carpeta de soluciones `CQRS On-Premises Code Sample\CQRS Model\Query Microservice`:
+ El proyecto de API ASP.NET Core `AWS.APG.CQRSES.QueryMicroservice` actúa como punto de entrada desde el que los consumidores interactúan con el servicio.
+ El proyecto .NET Core `AWS.APG.CQRSES.Query` es un objeto que aloja objetos e interfaces relacionados con consultas.
*Directorio de soluciones de código CQRS AWS sin servidor*
![\[Directorio de soluciones que muestra tanto los microservicios como el origen de eventos ampliado.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/9f1bc700-def4-4201-bb2d-f1fa27404f15/images/23f8655c-95ad-422c-b20a-e29dc145e995.png)
Este código es la versión de AWS del código en las instalaciones que emplea los servicios sin servidor de AWS.
En C\$1 .NET Core, cada función de Lambda está representada por un proyecto .NET Core. En el código de ejemplo de este patrón, hay un proyecto independiente para cada interfaz en los modelos de comandos y consultas.
**Uso de los servicios de AWS por CQRS**
Puede encontrar el directorio raíz de soluciones para CQRS con servicios sin servidor de AWS en la carpeta `CQRS AWS Serverless\CQRS`. El ejemplo incluye dos modelos: Customer y Reward.
El comando de funciones de Lambda para Customer y Reward se encuentra en las carpetas `CQRS\Command Microservice\Customer` y `CQRS\Command Microservice\Reward`. Contienen los siguientes proyectos de Lambda:
+ Comando Customer: `CommandCreateLambda`, `CommandDeleteLambda` y `CommandUpdateLambda`
+ Comando Reward: `CommandAddRewardLambda` y `CommandRedeemRewardLambda`
Las funciones de Lambda de consulta para Customer y Reward se encuentra en las carpetas `CQRS\Query Microservice\Customer` y `CQRS\QueryMicroservice\Reward`. Contienen los proyectos de Lambda `QueryCustomerListLambda` and `QueryRewardLambda`.
**Proyecto de prueba de CQRS**
El proyecto de prueba se encuentra en la carpeta `CQRS\Tests`. Este proyecto contiene un script de prueba para automatizar las pruebas de las funciones de Lambda de CQRS.
**Abastecimiento de eventos mediante servicios de AWS**
Las transmisiones de DynamoDB Customer y Reward inician los siguientes controladores de eventos de Lambda para procesar y sincronizar los datos de las tablas de consultas.
+ La función de Lambda `EventSourceCustomer` se asigna al flujo de DynamoDB de la tabla Customer (`cqrses-customer-cmd`).
+ La función de Lambda `EventSourceReward` se asigna al flujo de DynamoDB de la tabla Customer (`cqrses-reward-cmd`).
## Conexiones
Para acceder al contenido adicional asociado a este documento, descomprima el archivo: [attachment.zip](samples/p-attach/9f1bc700-def4-4201-bb2d-f1fa27404f15/attachments/attachment.zip)
# Más patrones
**Topics**
+ [Acceda a aplicaciones de contenedores de forma privada en Amazon EKS mediante AWS PrivateLink y un Network Load Balancer](access-container-applications-privately-on-amazon-eks-using-aws-privatelink-and-a-network-load-balancer.md)
+ [Automatice la adición o actualización de entradas de registro de Windows con AWS Systems Manager](automate-adding-or-updating-windows-registry-entries-using-aws-systems-manager.md)
+ [Automatización de la conmutación por error y la conmutación por recuperación entre regiones mediante DR Orchestrator Framework](automate-cross-region-failover-and-failback-by-using-dr-orchestrator-framework.md)
+ [Cree e implemente automáticamente una aplicación Java en Amazon EKS mediante una CI/CD canalización](automatically-build-and-deploy-a-java-application-to-amazon-eks-using-a-ci-cd-pipeline.md)
+ [Cree CI/CD canalizaciones y clústeres de Amazon ECS de forma automática para microservicios mediante AWS CDK](automatically-build-ci-cd-pipelines-and-amazon-ecs-clusters-for-microservices-using-aws-cdk.md)
+ [Copia de seguridad y archivo de datos de mainframe en Amazon S3 mediante BMC AMI Cloud Data](back-up-and-archive-mainframe-data-to-amazon-s3-using-bmc-ami-cloud-data.md)
+ [Cree un PAC de servidor empresarial Micro Focus con Amazon EC2 Auto Scaling y Systems Manager](build-a-micro-focus-enterprise-server-pac-with-amazon-ec2-auto-scaling-and-systems-manager.md)
+ [Cree una malla de datos empresarial con Amazon DataZone y AWS CDK AWS CloudFormation](build-enterprise-data-mesh-amazon-data-zone.md)
+ [Almacenamiento en contenedores de las cargas de trabajo de mainframe que Blu Age ha modernizado](containerize-mainframe-workloads-that-have-been-modernized-by-blu-age.md)
+ [Convierta y desempaquete datos EBCDIC a ASCII en AWS mediante Python](convert-and-unpack-ebcdic-data-to-ascii-on-aws-by-using-python.md)
+ [Convertir archivos de datos de mainframe con diseños de registros complejos mediante Micro Focus](convert-mainframe-data-files-with-complex-record-layouts-using-micro-focus.md)
+ [Cree un portal para microinterfaces mediante Angular AWS Amplify y Module Federation](create-amplify-micro-frontend-portal.md)
+ [Implementar contenedores mediante Elastic Beanstalk](deploy-containers-by-using-elastic-beanstalk.md)
+ [Emule Oracle DR mediante una base de datos global de Aurora compatible con PostgreSQL](emulate-oracle-dr-by-using-a-postgresql-compatible-aurora-global-database.md)
+ [Genere información de datos mediante AWS Mainframe Modernization Amazon Q en Quick Sight](generate-data-insights-by-using-aws-mainframe-modernization-and-amazon-q-in-quicksight.md)
+ [Genere información sobre z/OS datos de Db2 mediante AWS Mainframe Modernization Amazon Q en Quick Sight](generate-db2-zos-data-insights-aws-mainframe-modernization-amazon-q-in-quicksight.md)
+ [Identificación automática de las imágenes de contenedor duplicadas al migrar a un repositorio de Amazon ECR](identify-duplicate-container-images-automatically-when-migrating-to-ecr-repository.md)
+ [Implementación de diagnósticos y solución de problemas de Kubernetes con tecnología de IA con la integración de K8sGPT y Amazon Bedrock](implement-ai-powered-kubernetes-diagnostics-and-troubleshooting-with-k8sgpt-and-amazon-bedrock-integration.md)
+ [Implemente la autenticación basada en Microsoft Entra ID en una aplicación de mainframe modernizada de AWS Blu Age](implement-entra-id-authentication-in-aws-blu-age-modernized-mainframe-application.md)
+ [Implementación del control de versiones de API basado en rutas mediante dominios personalizados en Amazon API Gateway](implement-path-based-api-versioning-by-using-custom-domains.md)
+ [Migración gradual de Amazon RDS para Oracle a Amazon RDS para PostgreSQL con Oracle SQL Developer y AWS SCT](incrementally-migrate-from-amazon-rds-for-oracle-to-amazon-rds-for-postgresql-using-oracle-sql-developer-and-aws-sct.md)
+ [Integrar el controlador universal Stonebranch con AWS Mainframe Modernization](integrate-stonebranch-universal-controller-with-aws-mainframe-modernization.md)
+ [Administre los productos de AWS Service Catalog en varias cuentas y regiones de AWS](manage-aws-service-catalog-products-in-multiple-aws-accounts-and-aws-regions.md)
+ [Migrar una cuenta de AWS miembro de AWS Organizations a AWS Control Tower](migrate-an-aws-member-account-from-aws-organizations-to-aws-control-tower.md)
+ [Migración y réplica de archivos VSAM a Amazon RDS o Amazon MSK mediante Connect de Precisely](migrate-and-replicate-vsam-files-to-amazon-rds-or-amazon-msk-using-connect-from-precisely.md)
+ [Migración de SAP ASE a Amazon RDS para SQL Server utilizando AWS DMS](migrate-from-sap-ase-to-amazon-rds-for-sql-server-using-aws-dms.md)
+ [Migración de tablas externas de Oracle a Amazon Aurora compatible con PostgreSQL](migrate-oracle-external-tables-to-amazon-aurora-postgresql-compatible.md)
+ [Modernice la aplicación de CardDemo mainframe mediante AWS Transform](modernize-carddemo-mainframe-app.md)
+ [Modernice e implemente aplicaciones de mainframe con Terraform AWS Transform](modernize-mainframe-app-transform-terraform.md)
+ [Modernice las cargas de trabajo de impresión por lotes de mainframe AWS mediante Rocket Enterprise Server y LRS VPSX/MFI](modernize-mainframe-batch-printing-workloads-on-aws-by-using-rocket-enterprise-server-and-lrs-vpsx-mfi.md)
+ [Modernizar las cargas de trabajo de impresión en línea de mainframe en AWS mediante Micro Focus Enterprise Server y LRS VPSX/MFI](modernize-mainframe-online-printing-workloads-on-aws-by-using-micro-focus-enterprise-server-and-lrs-vpsx-mfi.md)
+ [Modernice la administración de la producción del mainframe AWS mediante Rocket Enterprise Server y LRS X PageCenter](modernize-mainframe-output-management-on-aws-by-using-rocket-enterprise-server-and-lrs-pagecenterx.md)
+ [Mover los archivos de mainframe directamente a Amazon S3 mediante Transfer Family](move-mainframe-files-directly-to-amazon-s3-using-transfer-family.md)
+ [Optimice las implementaciones sin servidor con varias cuentas mediante los flujos de trabajo y Actions AWS CDK GitHub](optimize-multi-account-serverless-deployments.md)
+ [Optimice el rendimiento de su aplicación modernizada AWS Blu Age](optimize-performance-aws-blu-age-modernized-application.md)
+ [Automatice blue/green las implementaciones de las bases de datos globales de Amazon Aurora mediante los principios de la IaC](p-automate-blue-green-deployments-aurora-global-databases-iac.md)
+ [Replicar bases de datos de unidades centrales en AWS mediante Precisely Connect](replicate-mainframe-databases-to-aws-by-using-precisely-connect.md)
+ [Ejecute tareas de Amazon ECS en Amazon WorkSpaces con Amazon ECS Anywhere](run-amazon-ecs-tasks-on-amazon-workspaces-with-amazon-ecs-anywhere.md)
+ [Envíe datos de telemetría desde y AWS Lambda OpenSearch para análisis y visualización en tiempo real](send-telemetry-data-from-lambda-to-opensearch-for-analytics-visualization.md)
+ [Configure la detección de CloudFormation desviaciones en una organización multirregional y multicuenta](set-up-aws-cloudformation-drift-detection-in-a-multi-region-multi-account-organization.md)
+ [Estructure un proyecto de Python en una arquitectura hexagonal con AWS Lambda](structure-a-python-project-in-hexagonal-architecture-using-aws-lambda.md)
+ [Pruebe AWS la infraestructura mediante LocalStack Terraform Tests](test-aws-infra-localstack-terraform.md)
+ [Transforma Easytrieve a idiomas modernos mediante el uso personalizado AWS Transform](transform-easytrieve-modern-languages.md)
+ [Actualice los clústeres de SAP Pacemaker de a ENSA1 ENSA2](upgrade-sap-pacemaker-clusters-from-ensa1-to-ensa2.md)
+ [Uso de Amazon Q Developer como asistente de codificación para aumentar la productividad](use-q-developer-as-coding-assistant-to-increase-productivity.md)
+ [Validar Account Factory para el código Terraform (AFT) localmente](validate-account-factory-for-terraform-aft-code-locally.md)