As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá. # Modernização **Topics** + [Arquivar automaticamente itens no Amazon S3 usando o DynamoDB TTL](automatically-archive-items-to-amazon-s3-using-dynamodb-ttl.md) + [Crie uma arquitetura sem servidor multilocatário no Amazon Service OpenSearch](build-a-multi-tenant-serverless-architecture-in-amazon-opensearch-service.md) + [Implante aplicativos de várias pilhas usando o AWS CDK com TypeScript](deploy-multiple-stack-applications-using-aws-cdk-with-typescript.md) + [Automatize a implantação de aplicativos aninhados usando o AWS SAM](automate-deployment-of-nested-applications-using-aws-sam.md) + [Implemente o isolamento de inquilinos de SaaS para o Amazon S3 usando uma máquina de venda automática de tokens AWS Lambda](implement-saas-tenant-isolation-for-amazon-s3-by-using-an-aws-lambda-token-vending-machine.md) + [Implementar o padrão de saga com tecnologia sem servidor usando o AWS Step Functions](implement-the-serverless-saga-pattern-by-using-aws-step-functions.md) + [Gerencie aplicativos de contêineres on-premises configurando o Amazon ECS Anywhere com o AWS CDK](manage-on-premises-container-applications-by-setting-up-amazon-ecs-anywhere-with-the-aws-cdk.md) + [Modernize aplicativos ASP.NET Web Forms na AWS](modernize-asp-net-web-forms-applications-on-aws.md) + [Integração de locatários na arquitetura de SaaS para o modelo de silo usando C\$1 e o AWS CDK](tenant-onboarding-in-saas-architecture-for-the-silo-model-using-c-and-aws-cdk.md) + [Decomponha monólitos em microsserviços usando o CQRS e o fornecimento de eventos](decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.md) + [Mais padrões](modernization-more-patterns-pattern-list.md) # Arquivar automaticamente itens no Amazon S3 usando o DynamoDB TTL *Tabby Ward, Amazon Web Services* ## Resumo Este padrão fornece etapas para remover dados antigos de uma tabela do Amazon DynamoDB e arquivá-los em um bucket do Amazon Simple Storage Service (Amazon S3) no Amazon Web Services (AWS) sem precisar gerenciar uma frota de servidores.  Este padrão usa a configuração de vida útil (TTL) do Amazon DynamoDB para excluir automaticamente itens antigos e o Amazon DynamoDB Streams para capturar itens com TTL expirado. Ele então conecta o DynamoDB Streams ao AWS Lambda, que executa o código sem provisionar ou gerenciar nenhum servidor.  Quando novos itens são adicionados ao fluxo do DynamoDB, a função do Lambda é inicializada e grava os dados em um fluxo de entrega do Amazon Data Firehose. O Firehose fornece uma solução simples e totalmente gerenciada para carregar os dados como um arquivo no Amazon S3. O DynamoDB é frequentemente usado para armazenar dados de séries temporais, como dados de fluxo de cliques em páginas da Web ou dados da Internet das Coisas (IoT) de sensores e dispositivos conectados. Em vez de excluir itens acessados com menos frequência, muitos clientes desejam arquivá-los para fins de auditoria. O TTL simplifica esse arquivamento excluindo automaticamente os itens com base no atributo timestamp.  Os itens excluídos pelo TTL podem ser identificados no DynamoDB Streams, que captura uma sequência em ordem temporal de modificações em nível de item e armazena a sequência em um log por até 24 horas. Esses dados podem ser consumidos por uma função do Lambda e arquivados em um bucket do Amazon S3 para reduzir o custo de armazenamento. [Para reduzir ainda mais os custos, as [regras de ciclo de vida do Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html) podem ser criadas para fazer a transição automática dos dados (assim que forem criados) para as classes de armazenamento de menor custo.](https://aws.amazon.com/s3/storage-classes/) ## Pré-requisitos e limitações **Pré-requisitos ** + Uma conta AWS ativa + [AWS Command Line Interface (AWS CLI) 1.7 ou mais recente](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv1.html), instalada e configurada em macOS, Linux ou Windows. + [Python 3.7](https://www.python.org/downloads/release/python-370/) ou mais recente. + [Boto3](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html), instalado e configurado. Se o Boto3 ainda não estiver instalado, execute o comando `python -m pip install boto3` para instalá-lo. ## Arquitetura **Pilha de tecnologia** + Amazon DynamoDB + Amazon DynamoDB Streams + Amazon Data Firehose + AWS Lambda + Amazon S3 ![\[Processo em quatro etapas do DynamoDB para o bucket do S3.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/9dbc833f-cf3c-4574-8f09-d0b81134fe41/images/50d9da65-5398-4a99-bc8f-58afc80e9d7b.png) 1. Os itens são excluídos pelo TTL. 1. O trigger do DynamoDB Streams invoca a função de processador de fluxo do Lambda. 1. A função do Lambda insere registros no fluxo de entrega do Firehose em formato de lote. 1. Os registros de dados são arquivados no bucket do S3. ## Ferramentas + [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html): o AWS Command Line Interface (AWS CLI) é uma ferramenta unificada para gerenciar os serviços da AWS. + [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html): o Amazon DynamoDB é um banco de dados de documentos e de chave-valor e documentos que oferece desempenho de um dígito em milissegundos em qualquer escala. + [Vida útil (TTL) do Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/howitworks-ttl.html): o Amazon DynamoDB ajuda a definir uma marca de hora por item para determinar quando um item não é mais necessário. + [Amazon DynamoDB Streams](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Types_Amazon_DynamoDB_Streams.html): o Amazon DynamoDB Streams captura uma sequência em ordem temporal de modificações em nível de item em qualquer tabela do DynamoDB e armazena essas informações em um log por até 24 horas. + [Amazon Data Firehose](https://docs.aws.amazon.com/firehose/latest/dev/what-is-this-service.html): o Amazon Data Firehose é a maneira mais fácil de carregar dados de streaming com confiabilidade em data lakes, repositórios de dados e serviços de analytics. + [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html): o AWS Lambda executa código sem a necessidade de provisionar ou gerenciar servidores. É cobrado apenas o tempo de computação consumido. + [Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/dev/Welcome.html): o Amazon Simple Storage Service (Amazon S3) é um serviço de armazenamento de objetos que oferece escalabilidade líder do setor, disponibilidade de dados, segurança e performance. **Código ** O código desse padrão está disponível no GitHub [Arquivamento de itens no S3 usando o repositório TTL do DynamoDB](https://github.com/aws-samples/automatically-archive-items-to-s3-using-dynamodb-ttl). ## Épicos ### Configure uma tabela do DynamoDB, TTL e um DynamoDB Streams | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Crie uma tabela do DynamoDB. | Use a AWS CLI para criar uma tabela no DynamoDB chamada `Reservation`. Escolha a unidade de capacidade de leitura aleatória (random read capacity unit, RCU) e a unidade de capacidade de gravação (write capacity unit, WCU) e atribua à sua tabela dois atributos: `ReservationID` e `ReservationDate`. 
aws dynamodb create-table \
--table-name Reservation \
--attribute-definitions AttributeName=ReservationID,AttributeType=S AttributeName=ReservationDate,AttributeType=N \
--key-schema AttributeName=ReservationID,KeyType=HASH AttributeName=ReservationDate,KeyType=RANGE \
--provisioned-throughput ReadCapacityUnits=100,WriteCapacityUnits=100
`ReservationDate` é um timestamp de época que será usado para ativar o TTL. | Arquiteto de nuvem, desenvolvedor de aplicativos | | Ative o TTL do DynamoDB | Use a AWS CLI para ativar o TTL do DynamoDB para o atributo `ReservationDate`.
aws dynamodb update-time-to-live \
--table-name Reservation\
  --time-to-live-specification Enabled=true,AttributeName=ReservationDate
| Arquiteto de nuvem, desenvolvedor de aplicativos | | Ative um DynamoDB Streams. | Use a AWS CLI para ativar um DynamoDB Streams para a tabela `Reservation` usando o tipo de fluxo `NEW_AND_OLD_IMAGES`. 
aws dynamodb update-table \
--table-name Reservation \
  --stream-specification StreamEnabled=true,StreamViewType=NEW_AND_OLD_IMAGES
Esse fluxo conterá registros de novos itens, itens atualizados, itens excluídos e itens excluídos pelo TTL. Os registros dos itens excluídos pelo TTL contêm um atributo de metadados adicional para diferenciá-los dos itens que foram excluídos manualmente. O campo `userIdentity` para exclusões de TTL indica que o serviço do DynamoDB executou a ação de exclusão. Nesse padrão, somente os itens excluídos pelo TTL são arquivados, mas você pode arquivar somente os registros onde `eventName` é `REMOVE` e `userIdentity` contém `principalId` igual a `dynamodb.amazonaws.com`. | Arquiteto de nuvem, desenvolvedor de aplicativos | ### Criação e configuração de um bucket do S3 | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Criar um bucket do S3. | Use a AWS CLI para criar um bucket S3 de destino na sua região da AWS, `us-east-1` substituindo-o pela sua região e amzn-s3- demo-destination-bucket pelo nome do seu bucket. 
aws s3api create-bucket \
--bucket amzn-s3-demo-destination-bucket \
--region us-east-1
Certifique-se de que o nome do seu bucket do S3 seja globalmente exclusivo, pois o namespace é compartilhado por todas as contas da AWS. | Arquiteto de nuvem, desenvolvedor de aplicativos | | Crie uma política de ciclo de vida de 30 dias para o bucket do S3. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/automatically-archive-items-to-amazon-s3-using-dynamodb-ttl.html) | Arquiteto de nuvem, desenvolvedor de aplicativos | ### Criação de um fluxo de entrega do Firehose | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Crie e configure um fluxo de entrega do Firehose. | Baixe e edite o exemplo de `CreateFireHoseToS3.py` código do GitHub repositório. Este código está escrito em Python e mostra como criar um fluxo de entrega do Firehose e um perfil do AWS Identity and Access Management (IAM). O perfil do IAM terá uma política que pode ser usada pelo Firehose para gravar no bucket do S3 de destino.Para executar o script, use o comando abaixo e os seguintes argumentos da linha de comando.Argumento 1=``, que é o nome do recurso da Amazon (ARN) do bucket criado anteriormenteArgumento 2 = o nome do seu Firehose (este teste experimental está usando `firehose_to_s3_stream`.)Argumento 3= nome do seu perfil do IAM (este piloto está usando`firehose_to_s3`.)
python CreateFireHoseToS3.py  firehose_to_s3_stream firehose_to_s3
Se o perfil do IAM especificado não existir, o script criará um perfil assumido com uma política de relacionamento confiável, bem como uma política que conceda permissão suficiente ao Amazon S3. Para obter exemplos dessas políticas, consulte a seção *Informações adicionais*. | Arquiteto de nuvem, desenvolvedor de aplicativos | | Verifique o fluxo de entrega do Firehose. | Descreva o fluxo de entrega do Firehose usando a AWS CLI para verificar se o fluxo de entrega foi criado com êxito.
aws firehose describe-delivery-stream --delivery-stream-name firehose_to_s3_stream
| Arquiteto de nuvem, desenvolvedor de aplicativos | ### Criação de uma função do Lambda para processar o fluxo de entrega do Firehose | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Crie uma política de confiança para a função do Lambda. | Crie um arquivo da política de confiança com as seguintes informações.
 {
     "Version": "2012-10-17",		 	 	 
     "Statement": [
      {
          "Effect": "Allow",
          "Principal": {
              "Service": "lambda.amazonaws.com"
           },
           "Action": "sts:AssumeRole"
      }
    ]
  }
Isso dá ao seu perfil permissão para acessar recursos da AWS. | Arquiteto de nuvem, desenvolvedor de aplicativos | | Crie um perfil de execução para a função do Lambda | Para criar o perfil de execução, execute o seguinte código.
aws iam create-role --role-name lambda-ex --assume-role-policy-document file://TrustPolicy.json
| Arquiteto de nuvem, desenvolvedor de aplicativos | | Adicione permissões ao perfil. | Para adicionar permissão para o perfil, use o 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
| Arquiteto de nuvem, desenvolvedor de aplicativos | | Crie uma função do Lambda. | Comprima o arquivo `LambdaStreamProcessor.py` do repositório de código executando o comando a seguir.
zip function.zip LambdaStreamProcessor.py
Ao criar a função do Lambda, você precisará do ARN do perfil de execução do Lambda. Para obter o ARN, execute o código a seguir.
aws iam get-role \
--role-name lambda-ex
Para criar a função do Lambda, execute o seguinte 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}"
| Arquiteto de nuvem, desenvolvedor de aplicativos | | Configure o trigger da função do Lambda. | Use a AWS CLI para configurar o trigger (DynamoDB Streams), que invoca a função do Lambda. O tamanho do lote ser de 400 é para evitar problemas de simultaneidade do Lambda.
aws lambda create-event-source-mapping --function-name LambdaStreamProcessor \
--batch-size 400 --starting-position LATEST \
--event-source-arn
| Arquiteto de nuvem, desenvolvedor de aplicativos | ### Teste a funcionalidade | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Adicione itens com timestamps expirados à tabela de reservas. | Para testar a funcionalidade, adicione itens com timestamps de época expirados à tabela `Reservation`. O TTL excluirá automaticamente os itens com base no timestamp. A função do Lambda é inicializada nas atividades do DynamoDB Stream e filtra o evento para identificar a atividade `REMOVE` ou itens excluídos. Em seguida, a função insere os registros no fluxo de entrega do Firehose em formato de lote.O fluxo de entrega do Firehose transfere os itens para um bucket do S3 de destino com o prefixo `firehosetos3example/year=current year/month=current month/ day=current day/hour=current hour/`.Para otimizar a recuperação de dados, configure o Amazon S3 com `Prefix` e o `ErrorOutputPrefix`, conforme detalhado na seção *Informações adicionais*. | Arquiteto de nuvem | ### Limpe os recursos | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Excluir todos os recursos. | Excluir todos os recursos para garantir que não será cobrado por nenhum serviço que não esteja usando.   | Arquiteto de nuvem, desenvolvedor de aplicativos | ## Recursos relacionados + [Gerenciando seu ciclo de vida de armazenamento](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/create-lifecycle.html) + [Classes de armazenamento do Amazon S3](https://aws.amazon.com/s3/storage-classes/) + [AWS SDK para Python (Boto3) documentation](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html) ## Mais informações **Criação e configuração de um fluxo de entrega do Firehose: exemplos de políticas** *Documento de exemplo de política de relacionamento confiável do Firehose* ``` firehose_assume_role = { 'Version': '2012-10-17', 'Statement': [ { 'Sid': '', 'Effect': 'Allow', 'Principal': { 'Service': 'firehose.amazonaws.com' }, 'Action': 'sts:AssumeRole' } ] } ``` *Exemplo de política de permissões do 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}" ] } ] } ``` **Teste a funcionalidade — configuração do Amazon S3** A configuração do Amazon S3 com os seguintes `Prefix` e `ErrorOutputPrefix` é escolhida para otimizar a recuperação de dados.  *prefix* ``` firehosetos3example/year=! {timestamp: yyyy}/month=! {timestamp:MM}/day=! {timestamp:dd}/hour=!{timestamp:HH}/ ``` Primeiro, o Firehose cria uma pasta base denominada `firehosetos3example` diretamente no bucket do S3. Em seguida, ele avalia as expressões `!{timestamp:yyyy}``!{timestamp:MM}`,`!{timestamp:dd}`,, e `!{timestamp:HH}` para ano, mês, dia e hora usando o [DateTimeFormatter](https://docs.oracle.com/javase/8/docs/api/java/time/format/DateTimeFormatter.html)formato Java. Por exemplo, um timestamp de chegada aproximado de 1604683577 no Unix epoch time avaliado como `year=2020`, `month=11`, `day=06` e `hour=05`. Portanto, a localização no Amazon S3, onde os registros de dados são entregues, é avaliada como `firehosetos3example/year=2020/month=11/day=06/hour=05/`. *ErrorOutputPrefix* ``` firehosetos3erroroutputbase/!{firehose:random-string}/!{firehose:error-output-type}/!{timestamp:yyyy/MM/dd}/ ``` Os resultados `ErrorOutputPrefix` em uma pasta base chamada `firehosetos3erroroutputbase` diretamente abaixo do bucket do S3. A expressão `!{firehose:random-string}` é avaliada como uma string aleatória de 11 caracteres, como `ztWxkdg3Thg`. A localização de um objeto do Amazon S3 onde os registros com falha são entregues pode ser avaliada como `firehosetos3erroroutputbase/ztWxkdg3Thg/processing-failed/2020/11/06/`. # Crie uma arquitetura sem servidor multilocatário no Amazon Service OpenSearch *Tabby Ward e Nisha Gambhir, Amazon Web Services* ## Resumo O Amazon OpenSearch Service é um serviço gerenciado que facilita a implantação, a operação e a escalabilidade do Elasticsearch, que é um popular mecanismo de pesquisa e análise de código aberto. OpenSearch O serviço fornece pesquisa de texto livre, bem como ingestão e painéis quase em tempo real para streaming de dados, como registros e métricas. Os provedores de software como serviço (SaaS) costumam usar o OpenSearch Serviço para lidar com uma ampla variedade de casos de uso, como obter informações sobre os clientes de forma escalável e segura, ao mesmo tempo em que reduzem a complexidade e o tempo de inatividade. Usar o OpenSearch serviço em um ambiente multilocatário introduz uma série de considerações que afetam o particionamento, o isolamento, a implantação e o gerenciamento de sua solução SaaS. Os provedores de SaaS precisam considerar como escalar efetivamente seus clusters do Elasticsearch com workloads em constante mudança. Eles também precisam considerar como a hierarquização e as condições ruidosas dos vizinhos podem afetar seu modelo de particionamento. Esse padrão analisa os modelos usados para representar e isolar dados de inquilinos com estruturas do Elasticsearch. Além disso, o padrão se concentra em uma arquitetura de referência simples sem servidor como exemplo para demonstrar a indexação e a pesquisa usando o OpenSearch Service em um ambiente multilocatário. Ele implementa o modelo de particionamento de dados do pool, que compartilha o mesmo índice entre todos os inquilinos, e mantém o isolamento dos dados do inquilino. Esse padrão usa os seguintes AWS serviços: Amazon API Gateway AWS Lambda, Amazon Simple Storage Service (Amazon S3) e Service. OpenSearch Para obter mais informações sobre o modelo de pool e outros modelos de particionamento de dados, consulte a seção [Informações adicionais](#build-a-multi-tenant-serverless-architecture-in-amazon-opensearch-service-additional). ## Pré-requisitos e limitações **Pré-requisitos ** + Um ativo Conta da AWS + [AWS Command Line Interface (AWS CLI) versão 2.x](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv2.html), instalada e configurada no macOS, Linux ou Windows + [Python versão 3.9](https://www.python.org/downloads/release/python-3921/) + [pip3](https://pip.pypa.io/en/stable/): o código-fonte do Python é fornecido como um arquivo .zip para ser implantado em uma função do Lambda. Se você quiser usar o código localmente ou personalizá-lo, siga estas etapas para desenvolver e recompilar o código-fonte: 1. Gere o `requirements.txt` arquivo executando o seguinte comando no mesmo diretório dos scripts do Python: `pip3 freeze > requirements.txt` 1. Instale as dependências: `pip3 install -r requirements.txt` **Limitações** + Esse código é executado em Python e atualmente não oferece suporte a outras linguagens de programação.  + O aplicativo de amostra não inclui suporte AWS entre regiões ou recuperação de desastres (DR).  + Este padrão é apenas para fins de demonstração. Não se destina a ser usado em ambientes de produção. ## Arquitetura O diagrama a seguir ilustra a arquitetura de alto nível de arquitetura deste padrão. A arquitetura inclui o seguinte: + Lambda para indexar e consultar o conteúdo  + OpenSearch Serviço para realizar pesquisas  + API Gateway para fornecer uma interação de API com o usuário + Amazon S3 para armazenar dados brutos (não indexados) + Amazon CloudWatch monitorará registros + AWS Identity and Access Management (IAM) para criar funções e políticas de inquilinos ![\[Arquitetura multilocatário com tecnologia sem servidor de alto nível.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/750196bb-03f6-4b6e-92cd-eb7141602547/images/1a8501e7-0776-4aca-aed3-28e3ada1d15d.png) **Automação e escala** Para simplificar, o padrão é usado AWS CLI para provisionar a infraestrutura e implantar o código de amostra. Você pode criar um CloudFormation modelo ou AWS Cloud Development Kit (AWS CDK) scripts para automatizar o padrão. ## Ferramentas **Serviços da AWS** + [AWS CLI](https://aws.amazon.com/cli/)é uma ferramenta unificada para gerenciamento Serviços da AWS e recursos usando comandos em seu shell de linha de comando. + O [Lambda](https://aws.amazon.com/lambda/) é um serviço de computação que permite a você executar o código sem provisionar ou gerenciar servidores. O Lambda executa o código somente quando necessário e dimensiona automaticamente, desde algumas solicitações por dia até milhares por segundo. + O [API Gateway](https://aws.amazon.com/api-gateway/) serve AWS service (Serviço da AWS) para criar, publicar, manter, monitorar e proteger REST, HTTP e WebSocket APIs em qualquer escala. + O [Amazon S3](https://aws.amazon.com/s3/) é um serviço de armazenamento de objetos que permite armazenar e recuperar qualquer quantidade de informações a qualquer momento, de qualquer lugar na web. + OpenSearch O [Service](https://aws.amazon.com/opensearch-service/) é um serviço totalmente gerenciado que facilita a implantação, a proteção e a execução do Elasticsearch de maneira econômica e em grande escala. **Código ** O anexo fornece arquivos de amostra para esse padrão. Isso inclui: + `index_lambda_package.zip`— A função Lambda para indexar dados no OpenSearch Service usando o modelo de pool. + `search_lambda_package.zip`— A função Lambda para pesquisar dados no OpenSearch Service. + `Tenant-1-data`: amostra de dados brutos (não indexados) para o Tenant-1. + `Tenant-2-data`: amostra de dados brutos (não indexados) para o Tenant-2. **Importante** As histórias desse padrão incluem exemplos de AWS CLI comandos formatados para Unix, Linux e macOS. Para Windows, substitua o caractere de continuação Unix de barra invertida (\$1) no final de cada linha por um circunflexo (^). **nota** Nos AWS CLI comandos, substitua todos os valores dentro dos colchetes angulares (<>) pelos valores corretos. ## Épicos ### Criação e configuração de um bucket do S3 | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Criar um bucket do S3. | Crie um bucket S3 no seu Região da AWS. Esse bucket conterá os dados não indexados do inquilino para o aplicativo de amostra. Certifique-se de que o nome do bucket do S3 seja globalmente exclusivo, pois o namespace é compartilhado por todos. Contas da AWSPara criar um bucket do S3, você pode usar o comando AWS CLI [create-bucket](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/create-bucket.html) da seguinte forma:
aws s3api create-bucket \
  --bucket  \
  --region
onde `tenantrawdata` é o nome do bucket do S3. (Você pode usar qualquer nome exclusivo que siga [as diretrizes de nomenclatura do bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucketnamingrules.html).) | Arquiteto de nuvem, administrador de nuvem | ### Criar e configurar um cluster Elasticsearch | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Crie um domínio OpenSearch de serviço. | Execute o AWS CLI [create-elasticsearch-domain](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/es/create-elasticsearch-domain.html)comando para criar um domínio OpenSearch de serviço:
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\/*\" } ] }"
A contagem de instâncias é definida como 1 porque o domínio é para fins de teste. Você precisa ativar o controle de acesso refinado usando o `advanced-security-options` parâmetro, pois os detalhes não podem ser alterados após a criação do domínio. Esse comando cria um nome de usuário principal (`KibanaUser`) e uma senha que você usará para fazer login no console do Kibana.Como o domínio faz parte de uma nuvem privada virtual (VPC), você precisa garantir que possa acessar a instância do Elasticsearch especificando a política de acesso a ser usada.Para obter mais informações, consulte [Lançamento de seus domínios do Amazon OpenSearch Service em uma VPC](https://docs.aws.amazon.com/elasticsearch-service/latest/developerguide/es-vpc.html) na AWS documentação. | Arquiteto de nuvem, administrador de nuvem | | Configurar um bastion host. | Configure uma instância Windows da Amazon Elastic Compute Cloud (Amazon EC2) como bastion host para acessar o console Kibana. O grupo de segurança do Elasticsearch deve permitir o tráfego do grupo de EC2 segurança da Amazon. Para obter instruções, consulte a postagem do blog [Como controlar o acesso à rede às EC2 instâncias usando um servidor Bastion.](https://aws.amazon.com/blogs/security/controlling-network-access-to-ec2-instances-using-a-bastion-server/)Quando o bastion host tiver sido configurado e você tiver o grupo de segurança associado à instância disponível, use o AWS CLI [authorize-security-group-ingress](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/authorize-security-group-ingress.html)comando para adicionar permissão ao grupo de segurança do Elasticsearch para permitir a porta 443 do grupo de segurança Amazon EC2 (bastion host).
aws ec2 authorize-security-group-ingress \
  --group-id  \ 
  --protocol tcp \
  --port 443 \
  --source-group
| Arquiteto de nuvem, administrador de nuvem | ### Criar e configurar a função do Lambda de índice | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Criar o perfil de execução do Lambda | Execute o comando AWS CLI [create-role](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/create-role.html) para conceder acesso e recursos à função de índice Lambda: Serviços da AWS 
aws iam create-role \
  --role-name index-lambda-role \
  --assume-role-policy-document file://lambda_assume_role.json
onde `lambda_assume_role.json` é um documento JSON que concede permissões `AssumeRole` para a função do Lambda, da seguinte forma:
{
     "Version": "2012-10-17",		 	 	 
     "Statement": [
         {
             "Effect": "Allow",
             "Principal": {
                 "Service": "lambda.amazonaws.com"
               },
             "Action": "sts:AssumeRole"
         }
     ]
 }
| Arquiteto de nuvem, administrador de nuvem | | Anexe as políticas gerenciadas à função do Lambda. | Execute o AWS CLI [attach-role-policy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/attach-role-policy.html)comando para anexar políticas gerenciadas à função criada na etapa anterior. Essas duas políticas dão à função permissões para criar uma interface de rede elástica e gravar CloudWatch registros em 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
| Arquiteto de nuvem, administrador de nuvem | | Criar uma política para dar permissão à função de índice Lambda para ler os objetos do S3. | Execute o comando AWS CLI [create-policy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/create-policy.html) para dar `s3:GetObject` permissão à função de índice Lambda para ler os objetos no bucket do S3:
aws iam create-policy \
  --policy-name s3-permission-policy \
  --policy-document file://s3-policy.json
O arquivo `s3-policy.json` é um documento JSON mostrado abaixo que concede permissões `s3:GetObject` para conceder o acesso de leitura aos objetos do S3. Se você usou um nome diferente ao criar o bucket do S3, forneça o nome correto do bucket na seção `Resource `:
{
    "Version": "2012-10-17",		 	 	 
    "Statement": [
        {
           "Effect": "Allow",
           "Action": "s3:GetObject",
           "Resource": "arn:aws:s3:::/*"
        }
    ]
}
| Arquiteto de nuvem, administrador de nuvem | | Anexar a política de permissões do Amazon S3 ao perfil de execução do Lambda. | Execute o AWS CLI [attach-role-policy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/attach-role-policy.html)comando para anexar a política de permissão do Amazon S3 que você criou na etapa anterior à função de execução do Lambda:
aws iam attach-role-policy \
  --role-name index-lambda-role \
  --policy-arn
onde `PolicyARN` é o nome de recurso da nome do recurso da Amazon (ARN) da política de permissões do Amazon S3. É possível obter esse valor na saída do comando anterior. | Arquiteto de nuvem, administrador de nuvem | | Criar a função do Lambda de índice. | Execute o comando AWS CLI [create-function](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-function.html) para criar a função de índice Lambda, que acessará o Service: 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\": [\"\"]}"
| Arquiteto de nuvem, administrador de nuvem | | Permitir que o Amazon S3 chame a função de índice Lambda. | Execute o comando AWS CLI [add-permission](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/add-permission.html) para dar ao Amazon S3 a permissão de chamar a função 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 ""
| Arquiteto de nuvem, administrador de nuvem | | Adicionar um gatilho Lambda para o evento Amazon S3. | Execute o AWS CLI [put-bucket-notification-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/put-bucket-notification-configuration.html)comando para enviar notificações para a função de índice do Lambda quando o evento do Amazon `ObjectCreated` S3 for detectado. A função de índice é executada sempre que um objeto é carregado no bucket do S3. 
aws s3api put-bucket-notification-configuration \
  --bucket  \
  --notification-configuration file://s3-trigger.json
O arquivo `s3-trigger.json` é um documento JSON na pasta atual que adiciona a política de recursos à função do Lambda quando ocorre o evento Amazon `ObjectCreated` S3. | Arquiteto de nuvem, administrador de nuvem | ### Criar e configurar a função do Lambda de pesquisa | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Criar o perfil de execução do Lambda | Execute o comando AWS CLI [create-role](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/create-role.html) para conceder acesso e recursos à função de pesquisa do Lambda: Serviços da AWS 
aws iam create-role \
  --role-name search-lambda-role \
  --assume-role-policy-document file://lambda_assume_role.json
onde `lambda_assume_role.json` é um documento JSON na pasta atual que concede `AssumeRole` permissões para a função do Lambda, da seguinte forma:
{
     "Version": "2012-10-17",		 	 	 
     "Statement": [
         {
             "Effect": "Allow",
             "Principal": {
                 "Service": "lambda.amazonaws.com"
               },
             "Action": "sts:AssumeRole"
         }
     ]
 }
| Arquiteto de nuvem, administrador de nuvem | | Anexe as políticas gerenciadas à função do Lambda. | Execute o AWS CLI [attach-role-policy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/attach-role-policy.html)comando para anexar políticas gerenciadas à função criada na etapa anterior. Essas duas políticas dão à função permissões para criar uma interface de rede elástica e gravar CloudWatch registros em 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
| Arquiteto de nuvem, administrador de nuvem | | Criar a função do Lambda de pesquisa. | Execute o comando AWS CLI [create-function](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-function.html) para criar a função de pesquisa do Lambda, que acessará o Serviço: 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\": [\"\"]}"
| Arquiteto de nuvem, administrador de nuvem | ### Criar e configurar funções de inquilino | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Crie o perfil do IAM de inquilino. | Execute o comando AWS CLI [create-role](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/create-role.html) para criar duas funções de inquilino que serão usadas para testar a funcionalidade de pesquisa:
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
O arquivo `assume-role-policy.json` é um documento JSON na pasta atual que concede `AssumeRole` permissões para o perfil de execução do Lambda:
{
    "Version": "2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": {
                 "AWS": "",
                 "AWS": ""
             },
            "Action": "sts:AssumeRole"
        }
    ]
}
| Arquiteto de nuvem, administrador de nuvem | | Criar uma nova política do IAM | Execute o comando AWS CLI [create-policy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/create-policy.html) para criar uma política de locatário que conceda acesso às operações do Elasticsearch:
aws iam create-policy \
  --policy-name tenant-policy \
  --policy-document file://policy.json
O arquivo `policy.json` é um documento JSON na pasta atual que concede permissões no Elasticsearch:
{
    "Version": "2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "es:ESHttpDelete",
                "es:ESHttpGet",
                "es:ESHttpHead",
                "es:ESHttpPost",
                "es:ESHttpPut",
                "es:ESHttpPatch"
            ],
            "Resource": [
                ""
            ]
        }
    ]
}
| Arquiteto de nuvem, administrador de nuvem | | Anexar a política do IAM do inquilino às funções do inquilino. | Execute o AWS CLI [attach-role-policy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/attach-role-policy.html)comando para anexar a política do IAM do inquilino às duas funções de inquilino que você criou na etapa 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
A ARN da política vem da saída na etapa anterior. | Arquiteto de nuvem, administrador de nuvem | | Criar uma política do IAM para conceder permissões ao Lambda para assumir a função. | Execute o comando AWS CLI [create-policy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/create-policy.html) para criar uma política para que o Lambda assuma a função de locatário:
aws iam create-policy \
  --policy-name assume-tenant-role-policy \
  --policy-document file://lambda_policy.json
O arquivo `lambda_policy.json` é um documento JSON na pasta atual que concede permissões para o `AssumeRole`:
{
    "Version": "2012-10-17",		 	 	 
    "Statement": [
       {
            "Effect": "Allow",
            "Action":  "sts:AssumeRole",
            "Resource": ""
       }
    ]
}
Pois`Resource`, você pode usar um caractere curinga para evitar a criação de uma nova política para cada inquilino. | Arquiteto de nuvem, administrador de nuvem | | Criar uma política do IAM para conceder à função do índice do Lambda a permissão para acessar o Amazon S3. | Execute o comando AWS CLI [create-policy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/create-policy.html) para dar permissão à função do índice Lambda para acessar os objetos no bucket do S3:
aws iam create-policy \
  --policy-name s3-permission-policy \
  --policy-document file://s3_lambda_policy.json
O arquivo `s3_lambda_policy.json` é o seguinte documento de política JSON na pasta atual:
{
    "Version": "2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "s3:GetObject",
            "Resource": "arn:aws:s3:::tenantrawdata/*"
        }
    ]
}
| Arquiteto de nuvem, administrador de nuvem | | Anexar a política a um perfil de execução do Lambda. | Execute o AWS CLI [attach-role-policy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/attach-role-policy.html)comando para anexar a política criada na etapa anterior ao índice Lambda e às funções de execução de pesquisa que você criou 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
A ARN da política vem da saída na etapa anterior. | Arquiteto de nuvem, administrador de nuvem | ### Criar e configurar uma API de pesquisa | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Criar uma API REST do API Gateway. | Execute o AWS CLI [create-rest-api](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/create-rest-api.html)comando para criar um recurso da API REST:
aws apigateway create-rest-api \
  --name Test-Api \
  --endpoint-configuration "{ \"types\": [\"REGIONAL\"] }"
Para o tipo de configuração de endpoint, você pode especificar `EDGE`, em vez de `REGIONAL`, para usar locais da borda, em vez de uma Região da AWS específica.Anote o valor do campo `id` na saída do comando. Esse é o ID da API que você usará nos comandos subsequentes. | Arquiteto de nuvem, administrador de nuvem | | Criar um recurso para a API de pesquisa. | O recurso da API de pesquisa inicia a função de pesquisa do Lambda com o nome do recurso. `search` (Você não precisa criar uma API para a função de índice do Lambda, porque ela é executada automaticamente quando os objetos são carregados no bucket do S3.)[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/build-a-multi-tenant-serverless-architecture-in-amazon-opensearch-service.html) | Arquiteto de nuvem, administrador de nuvem | | Criar um método GET para a API de pesquisa. | Execute o comando AWS CLI [put-method](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/put-method.html) para criar um `GET ` método para a API de pesquisa:
aws apigateway put-method \
  --rest-api-id  \
  --resource-id  \
  --http-method GET \
  --authorization-type "NONE" \
  --no-api-key-required
Para`resource-id`, especificar o ID da saída do `create-resource` comando. | Arquiteto de nuvem, administrador de nuvem | | Criar um método de resposta para a API de pesquisa. | Execute o AWS CLI [put-method-response](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/put-method-response.html)comando para adicionar uma resposta de método para a API de pesquisa:
aws apigateway put-method-response \
  --rest-api-id  \
  --resource-id   \
  --http-method GET \
  --status-code 200 \
  --response-models "{\"application/json\": \"Empty\"}"
Para `resource-id`, especifique o ID da saída do comando `create-resource` anterior. | Arquiteto de nuvem, administrador de nuvem | | Configurar uma integração de proxy Lambda para a API de pesquisa. | Execute o comando AWS CLI [put-integration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/put-integration.html) para configurar uma integração com a função de pesquisa do 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
Para`resource-id`, especifique o ID do `create-resource` comando anterior. | Arquiteto de nuvem, administrador de nuvem | | Conceder permissão para que o API Gateway possa invocar a função do Lambda. | Execute o comando AWS CLI [add-permission](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/add-permission.html) para dar permissão ao API Gateway para usar a função de pesquisa:
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
Alterar o `source-arn` caminho se você usou um nome de recurso de API diferente em vez de`search`. | Arquiteto de nuvem, administrador de nuvem | | Implantar a API de pesquisa. | Execute o comando AWS CLI [create-deployment](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/create-deployment.html) para criar um recurso de estágio chamado: `dev`
aws apigateway create-deployment \
  --rest-api-id  \
  --stage-name dev
Se você atualizar a API, poderá usar o mesmo AWS CLI comando para reimplantá-la no mesmo estágio. | Arquiteto de nuvem, administrador de nuvem | ### Criar e configurar funções do Kibana | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Fazer login no console do Kibana. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/build-a-multi-tenant-serverless-architecture-in-amazon-opensearch-service.html) | Arquiteto de nuvem, administrador de nuvem | | Criar e configurar perfis do Kibana | Para fornecer isolamento de dados e garantir que um inquilino não possa recuperar os dados de outro inquilino, você precisa usar a segurança de documentos, que permite que os inquilinos acessem somente documentos que contenham sua ID de inquilino.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/build-a-multi-tenant-serverless-architecture-in-amazon-opensearch-service.html) | Arquiteto de nuvem, administrador de nuvem | | Mapear usuários para funções. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/build-a-multi-tenant-serverless-architecture-in-amazon-opensearch-service.html)Recomendamos automatizar a criação das funções de inquilino e Kibana no momento da integração do inquilino. | Arquiteto de nuvem, administrador de nuvem | | Criar o índice de dados do inquilino. | No painel de navegação, em **Gerenciamento**, escolha **Dev Tools** e execute o seguinte comando. Esse comando cria o `tenant-data` índice para definir o mapeamento da `TenantId` propriedade.
PUT /tenant-data
{
  "mappings": {
    "properties": {
      "TenantId": { "type": "keyword"}
    }
  }
}
| Arquiteto de nuvem, administrador de nuvem | ### Crie endpoints VPC para o Amazon S3 e AWS STS | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Crie uma política de endpoint da VPC para o Amazon S3. | Execute o AWS CLI [create-vpc-endpoint](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-vpc-endpoint.html)comando para criar um VPC endpoint para o Amazon S3. O endpoint permite que a função de indexação do Lambda na VPC acesse o Amazon S3.
aws ec2 create-vpc-endpoint \
  --vpc-id  \
  --service-name com.amazonaws.us-east-1.s3 \
  --route-table-ids
Para`vpc-id`, especificar a VPC que você está usando para a função de índice Lambda. Para`service-name`, use a URL correta para o endpoint do Amazon S3. Para`route-table-ids`, especifique a tabela de rotas associada ao endpoint da VPC. | Arquiteto de nuvem, administrador de nuvem | | Crie um VPC endpoint para. AWS STS | Execute o AWS CLI [create-vpc-endpoint](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-vpc-endpoint.html)comando para criar um VPC endpoint para AWS Security Token Service ().AWS STS O endpoint permite que as funções de indexação e pesquisa do Lambda na VPC acessem o AWS STS. As funções são usadas AWS STS quando assumem a função do 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`, especificar a VPC que você está usando para a função do Lambda de índice e pesquisa. Para`subnet-id`, fornecer a sub-rede na qual esse endpoint deve ser criado. Para`security-group-id`, especifique o grupo de segurança ao qual associar esse endpoint. (Pode ser o mesmo que o grupo de segurança que o Lambda usa.) | Arquiteto de nuvem, administrador de nuvem | ### Testar a multilocação e o isolamento de dados | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Atualizar os arquivos Python para as funções de índice e pesquisa. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/build-a-multi-tenant-serverless-architecture-in-amazon-opensearch-service.html)Você pode obter o endpoint do Elasticsearch na guia **Visão geral do** console de serviços. OpenSearch Ele tem o formato `.es.amazonaws.com`. | Arquiteto de nuvem, desenvolvedor de aplicativos | | Criar o código do Lambda. | Use o AWS CLI [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)comando para atualizar o código Lambda com as alterações feitas nos arquivos 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
| Arquiteto de nuvem, desenvolvedor de aplicativos | | Fazer upload do arquivo de dados brutos em um bucket do S3. | Use o comando AWS CLI [cp](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3/cp.html) para carregar dados dos objetos Tenant-1 e Tenant-2 no `tenantrawdata` bucket (especifique o nome do bucket S3 que você criou para essa finalidade):
aws s3 cp tenant-1-data s3://tenantrawdata
aws s3 cp tenant-2-data s3://tenantrawdata
O bucket do S3 é configurado para executar a função de índice do Lambda sempre que os dados são carregados para que o documento seja indexado no Elasticsearch. | Arquiteto de nuvem, administrador de nuvem | | Pesquisar dados no console Kibana. | No console do Kibana, execute a seguinte consulta:
GET tenant-data/_search
Essa consulta exibe todos os documentos indexados no Elasticsearch. Nesse caso, você verá dois documentos separados para o Tenant-1 e o Tenant-2. | Arquiteto de nuvem, administrador de nuvem | | Testar a API de pesquisa do API Gateway. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/build-a-multi-tenant-serverless-architecture-in-amazon-opensearch-service.html)Para ver ilustrações de tela, consulte a seção [Informações adicionais](#build-a-multi-tenant-serverless-architecture-in-amazon-opensearch-service-additional). | Arquiteto de nuvem, desenvolvedor de aplicativos | | Limpe recursos. | Limpe todos os recursos que você criou para evitar cobranças adicionais em sua conta. | AWS DevOps, arquiteto de nuvem, administrador de nuvem | ## Recursos relacionados + [AWS SDK para Python (Boto)](https://aws.amazon.com/sdk-for-python/) + [AWS Lambda documentação](https://docs.aws.amazon.com/lambda/) + [Documentação do API Gateway](https://docs.aws.amazon.com/apigateway/) + [Documentação do Amazon S3](https://docs.aws.amazon.com/s3/) + [Documentação OpenSearch do Amazon Service](https://docs.aws.amazon.com/elasticsearch-service/) + [Controle de acesso refinado no Amazon Service OpenSearch ](https://docs.amazonaws.cn/en_us/elasticsearch-service/latest/developerguide/fgac.html) + [Criação de um aplicativo de pesquisa com o Amazon OpenSearch Service](https://docs.aws.amazon.com/elasticsearch-service/latest/developerguide/search-example.html) + [Lançamento de seus domínios OpenSearch do Amazon Service em uma VPC](https://docs.aws.amazon.com/elasticsearch-service/latest/developerguide/es-vpc.html) ## Mais informações **Modelos de particionamento de dados** Existem três modelos comuns de particionamento de dados usados em sistemas multilocatários: silo, pool e híbrido. O modelo escolhido depende das necessidades de conformidade, vizinhança ruidosa, operações e isolamento do seu ambiente. *Modelo de silo* No modelo de silo, os dados de cada inquilino são armazenados em uma área de armazenamento distinta, onde não há mistura de dados do inquilino. Você pode usar duas abordagens para implementar o modelo de silo com o OpenSearch Service: domínio por inquilino e índice por inquilino. + **Domínio por inquilino** — Você pode usar um domínio de OpenSearch serviço separado (sinônimo de um cluster do Elasticsearch) por locatário. Colocar cada inquilino em seu próprio domínio oferece todos os benefícios associados a ter dados em uma estrutura independente. No entanto, essa abordagem apresenta desafios de gerenciamento e agilidade. Sua natureza distribuída torna mais difícil agregar e avaliar a saúde operacional e a atividade dos inquilinos. Essa é uma opção cara que exige que cada domínio de OpenSearch serviço tenha, no mínimo, três nós principais e dois nós de dados para cargas de trabalho de produção. ![\[Modelo de silo de domínio por locatário para arquiteturas multilocatário com tecnologia sem servidor.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/750196bb-03f6-4b6e-92cd-eb7141602547/images/c2195f82-e5ed-40bb-b76a-3b0210bf1254.png) + **Índice por inquilino** — Você pode colocar os dados do inquilino em índices separados dentro de um OpenSearch cluster de serviços. Com essa abordagem, você usa um identificador de locatário ao criar e nomear o índice, pré-fixando o identificador do locatário ao nome do índice. A abordagem de índice por inquilino ajuda você a atingir suas metas de silo sem introduzir um cluster completamente separado para cada inquilino. No entanto, você pode enfrentar pressão de memória se o número de índices aumentar, porque essa abordagem requer mais fragmentos e o nó principal precisa lidar com mais alocação e rebalanceamento. ![\[Modelo de silo de índice por locatário para arquiteturas multilocatário com tecnologia sem servidor.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/750196bb-03f6-4b6e-92cd-eb7141602547/images/354a9463-25bb-422b-84de-d4875a7c8ea2.png) **Isolamento no modelo de silo**: no modelo de silo, você usa políticas do IAM para isolar os domínios ou índices que contêm os dados de cada inquilino. Essas políticas impedem que um inquilino acesse os dados de outro inquilino. Para implementar seu modelo de isolamento de silo, você pode criar uma política baseada em recursos que controle o acesso ao seu recurso de inquilino. Geralmente, essa é uma política de acesso ao domínio que especifica quais ações um principal pode realizar nos sub-recursos do domínio, incluindo índices do Elasticsearch e. APIs Com as políticas baseadas em identidade do IAM, você pode especificar ações *permitidas* ou *negadas* no domínio, nos índices ou no Serviço. APIs OpenSearch O `Action` elemento de uma política do IAM descreve a ação ou ações específicas que são permitidas ou negadas pela política, e o `Principal ` elemento especifica as contas, os usuários ou os papéis afetados. O exemplo de política a seguir concede ao Tenant-1 acesso total (conforme especificado por`es:*`) somente aos sub-recursos no `tenant-1` domínio. O `/*` no elemento `Resource` à direita é significativo e indica que as políticas se aplicam aos sub-recursos do domínio, e não ao próprio domínio. Quando essa política está em vigor, os inquilinos não têm permissão para criar um novo domínio ou modificar as configurações em um domínio 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 o modelo de silo de locatário por índice, você precisa modificar esse exemplo de política para restringir ainda mais o Tenant-1 ao índice ou índices especificados, especificando o nome do índice. O exemplo de política a seguir restringe o Tenant-1 ao í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 piscina* No modelo de pool, todos os dados do inquilino são armazenados em um índice dentro do mesmo domínio. O identificador do inquilino é incluído nos dados (documento) e usado como chave de partição, para que você possa determinar quais dados pertencem a qual inquilino. Esse modelo reduz a sobrecarga de gerenciamento. Operar e gerenciar o índice agrupado é mais fácil e eficiente do que gerenciar vários índices. No entanto, como os dados do inquilino são misturados no mesmo índice, você perde o isolamento natural do inquilino que o modelo de silo fornece. Essa abordagem também pode degradar o desempenho devido ao efeito de vizinhança ruidosa. ![\[Modelo de pool para arquiteturas multilocatário com tecnologia sem servidor.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/750196bb-03f6-4b6e-92cd-eb7141602547/images/c2c3bb0f-6ccd-47a7-ab67-e7f3f8c7f289.png) **Isolamento do inquilino no modelo do pool**: em geral, o isolamento do inquilino é um desafio de implementar no modelo do pool. O mecanismo do IAM usado com o modelo de silo não permite que você descreva o isolamento com base na ID do inquilino armazenada em seu documento. Uma abordagem alternativa é usar o suporte de [controle de acesso refinado](https://docs.aws.amazon.com/elasticsearch-service/latest/developerguide/fgac.html) (FGAC) fornecido pela Open Distro for Elasticsearch. O FGAC permite controlar permissões em um nível de índice, documento ou campo. Com cada solicitação, o FGAC avalia as credenciais do usuário e autentica o usuário ou nega o acesso. Se o FGAC autenticar o usuário, ele obterá todas as funções mapeadas para esse usuário e usará o conjunto completo de permissões para determinar como lidar com a solicitação.  Para obter o isolamento necessário no modelo agrupado, você pode usar a [segurança em nível de documento](https://opendistro.github.io/for-elasticsearch-docs/docs/security/access-control/document-level-security/), que permite restringir uma função a um subconjunto de documentos em um índice. O exemplo de função a seguir restringe as consultas ao Tenant-1. Ao aplicar essa função ao Tenant-1, você pode obter o isolamento necessário.  ``` { "bool": { "must": { "match": { "tenantId": "Tenant-1" } } } } ``` *Modelo híbrido* O modelo híbrido usa uma combinação dos modelos de silo e piscina no mesmo ambiente para oferecer experiências únicas para cada nível de inquilino (como níveis gratuito, padrão e premium). Cada camada segue o mesmo perfil de segurança usado no modelo de pool. ![\[Modelo híbrido para arquiteturas multilocatário com tecnologia sem servidor.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/750196bb-03f6-4b6e-92cd-eb7141602547/images/e7def98a-38ef-435a-9881-7e95ae4d4940.png) **Isolamento do inquilino no modelo híbrido**: no modelo híbrido, você segue o mesmo perfil de segurança do modelo de pool, em que o uso do modelo de segurança do FGAC no nível do documento proporcionou o isolamento do inquilino. Embora essa estratégia simplifique o gerenciamento de clusters e ofereça agilidade, ela complica outros aspectos da arquitetura. Por exemplo, seu código exige complexidade adicional para determinar qual modelo está associado a cada inquilino. Você também precisa garantir que as consultas de um único inquilino não saturem o domínio inteiro e prejudiquem a experiência de outros locatários.  **Teste no API Gateway** *Janela de teste para consulta Tenant-1* ![\[Janela de teste para consulta de Tenant-1.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/750196bb-03f6-4b6e-92cd-eb7141602547/images/a6757d3f-977a-4ecc-90cb-83ab7f1c3588.png) *Janela de teste para consulta Tenant-2* ![\[Janela de teste para consulta de Tenant-2.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/750196bb-03f6-4b6e-92cd-eb7141602547/images/31bfd656-33ca-4750-b6e6-da4d703c2071.png) ## Anexos Para acessar o conteúdo adicional associado a este documento, descompacte o seguinte arquivo: [ attachment.zip](samples/p-attach/750196bb-03f6-4b6e-92cd-eb7141602547/attachments/attachment.zip) # Implante aplicativos de várias pilhas usando o AWS CDK com TypeScript *Dr. Rahul Sharad Gaikwad, Amazon Web Services* ## Resumo Esse padrão fornece uma step-by-step abordagem para implantação de aplicativos na Amazon Web Services (AWS) usando o AWS Cloud Development Kit (AWS CDK) com TypeScript. Como exemplo, o padrão implanta um aplicativo de análise em tempo real com tecnologia sem servidor. O padrão cria e implanta aplicativos de pilha aninhados. A pilha principal da AWS chama a CloudFormation pilha secundária, ou aninhada, de pilhas.  Cada pilha secundária cria e implanta os recursos da AWS que estão definidos na pilha. CloudFormation O AWS CDK Toolkit, o comando da interface de linha de comando (CLI)`cdk`, é a interface principal das pilhas. CloudFormation ## Pré-requisitos e limitações **Pré-requisitos ** + Uma conta AWS ativa + Nuvem privada virtual (VPC) e sub-redes existentes + AWS CDK Toolkit instalado e configurado + Um usuário com permissões de administrador e um conjunto de chaves de acesso. + Node.js + AWS Command Line Interface (AWS CLI) **Limitações** + Como o AWS CDK usa a AWS CloudFormation, os aplicativos do AWS CDK estão sujeitos a cotas de CloudFormation serviço. Para obter mais informações, consulte [as CloudFormation cotas da AWS](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cloudformation-limits.html). **Versões do produto** Esse padrão foi criado e testado usando as seguintes ferramentas e versões. + Kit de ferramentas do AWS CDK 1.83.0 + Node.js 14.13.0 + npm 7.0.14 O padrão deve funcionar com qualquer versão do AWS CDK ou npm. Observe que as versões 13.0.0 a 13.6.0 do Node.js não são compatíveis com o AWS CDK. ## Arquitetura **Pilha de tecnologias de destino** + AWS Amplify Console + 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) **Arquitetura de destino** O diagrama a seguir mostra a implantação de aplicativos em várias pilhas usando o AWS CDK com. TypeScript ![\[Arquitetura de pilha na VPC, com uma pilha principal e duas pilhas secundárias que contêm recursos.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/0ac29a11-1362-4084-92ed-6b85205763ca/images/8f92e86a-aa3d-4f8a-9b11-b92c52a7226c.png) O diagrama a seguir mostra a arquitetura do exemplo de aplicação em tempo real com tecnologia sem servidor. ![\[Arquitetura de aplicativos na região.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/0ac29a11-1362-4084-92ed-6b85205763ca/images/2df00faf-f871-4aec-9655-19ba2eb14cf8.png) ## Ferramentas **Ferramentas** + O [AWS Amplify Console](https://docs.aws.amazon.com/amplify/latest/userguide/welcome.html) é o centro de controle para implantações completas de aplicativos móveis e web na AWS. O host do Amplify Console fornece um fluxo de trabalho baseado em git para hospedar aplicativos web fullstack com tecnologia sem servidor com implantação contínua. A UI Admin é uma interface visual para desenvolvedores web e móveis frontend criarem e gerenciarem backends de aplicativos fora do console da AWS. + [O Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/welcome.html) é um serviço da AWS para criar, publicar, manter, monitorar e proteger REST, HTTP e WebSocket APIs em qualquer escala. + O [AWS Cloud Development Kit (AWS CDK)](https://docs.aws.amazon.com/cdk/latest/guide/home.html) é uma estrutura de desenvolvimento de software que ajuda você a definir e provisionar a infraestrutura da Nuvem AWS em código. + [O AWS CDK Toolkit](https://docs.aws.amazon.com/cdk/latest/guide/cli.html) é um kit de desenvolvimento em nuvem de linha de comando que ajuda você a interagir com seu aplicativo AWS CDK. O comando `cdk` CLI é a principal ferramenta para interagir com seu aplicativo AWS CDK. Ele executa seu aplicativo, interroga o modelo de aplicativo que você definiu e produz e implanta os CloudFormation modelos da AWS gerados pelo CDK da AWS. + CloudFrontA [Amazon](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/Introduction.html) é um serviço web que acelera a distribuição de conteúdo web estático e dinâmico, como arquivos.html, .css, .js e imagens. CloudFront entrega seu conteúdo por meio de uma rede mundial de data centers chamados de pontos de presença para menor latência e melhor desempenho. + O [Amazon Cognito](https://docs.aws.amazon.com/cognito/latest/developerguide/what-is-amazon-cognito.html) fornece autenticação, autorização e gerenciamento de usuários para seus aplicativos Web e móveis. Seus usuários podem fazer login diretamente ou por meio de terceiros. + O [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) é um serviço de banco de dados NoSQL totalmente gerenciado que fornece uma performance rápida e previsível com escalabilidade integrada. + [O Amazon Data Firehose](https://docs.aws.amazon.com/firehose/latest/dev/what-is-this-service.html) é um serviço totalmente gerenciado para fornecer [dados de streaming](https://aws.amazon.com/streaming-data/) em tempo real para destinos como Amazon S3, Amazon Redshift, OpenSearch Amazon Service, Splunk e qualquer endpoint HTTP personalizado ou endpoints HTTP de propriedade de provedores de serviços terceirizados compatíveis. + O [Amazon Kinesis Data Streams](https://docs.aws.amazon.com/streams/latest/dev/introduction.html) é um serviço para coleta e processamento de grandes fluxos de registros de dados em tempo real. + O [‭‬AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html)‭ é um serviço de computação que permite a execução do código sem provisionar ou gerenciar servidores O Lambda executa o código somente quando necessário e dimensiona automaticamente, desde algumas solicitações por dia até milhares por segundo. Você paga apenas pelo tempo de computação consumido. Não haverá cobranças quando o código não estiver em execução. + O [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) é um serviço de armazenamento de objetos baseado na nuvem que ajuda você a armazenar, proteger e recuperar qualquer quantidade de dados. **Código ** O código desse padrão está anexado. ## Épicos ### Instale o AWS CDK Toolkit | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Instale o AWS CDK Toolkit. | Para instalar o AWS CDK Toolkit globalmente, execute o comando a seguir.`npm install -g aws-cdk` | DevOps | | Verificar a versão. | Para verificar a versão do AWS CDK Toolkit, execute o comando a seguir. `cdk --version` | DevOps | ### Configurar credenciais da AWS | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Configurar credenciais. | Para configurar as credenciais, execute o comando `aws configure` e siga as instruções.
$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 | ### Baixe o código do projeto | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Baixe o código do projeto em anexo. | Para obter mais informações sobre a estrutura de diretórios e arquivos, consulte a seção *Informações adicionais*. | DevOps | ### Faça o bootstrap do ambiente do AWS CDK | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Inicialize o ambiente do . | Para implantar o CloudFormation modelo da AWS na conta e na região da AWS que você deseja usar, execute o comando a seguir.`cdk bootstrap /`Para obter mais informações, consulte a [documentação da AWS](https://docs.aws.amazon.com/cdk/latest/guide/bootstrapping.html). | DevOps | ### Crie e implante o projeto | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Crie o projeto. | Para construir o código do projeto, execute o comando `npm run build`. | DevOps | | Implante o projeto. | Para implantar o código do projeto, execute o comando `cdk deploy`. | | ### Verificar as saídas | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Verifique a criação da pilha. | No AWS Management Console, escolha **CloudFormation**. Nas pilhas do projeto, verifique se uma pilha principal e duas pilhas secundárias foram criadas. | DevOps | ### Teste a aplicação | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Enviar dados ao Kinesis Data Streams. | Configure sua conta da AWS para enviar dados para o Kinesis Data Streams usando o Amazon Kinesis Data Generator (KDG). Para obter mais informações, consulte [Amazon Kinesis Data Generator](https://awslabs.github.io/amazon-kinesis-data-generator/web/help.html). | DevOps | | Crie um usuário do Amazon Cognito. | [Para criar um usuário do Amazon Cognito, baixe o CloudFormation modelo cognito-setup.json na seção *Criar um usuário do Amazon Cognito na página de ajuda do Kinesis Data Generator*.](https://awslabs.github.io/amazon-kinesis-data-generator/web/help.html) Inicie o modelo e, em seguida, insira seu **nome de usuário** e **senha** do Amazon Cognito.A guia **Outputs** (Saídas) lista o URL do Kinesis Data Generator. | DevOps | | Faça o login no Kinesis Data Generator | Para fazer login no KDG, use as credenciais do Amazon Cognito que você forneceu e o URL do Kinesis Data Generator. | DevOps | | Testar o aplicativo. | No KDG, em **Modelo de registro**, **Modelo 1**, cole o código de teste na seção *Informações adicionais* e selecione **Enviar** dados. | DevOps | | Teste o API Gateway. | Depois que os dados forem ingeridos, teste o API Gateway usando o método `GET` para recuperar dados. | DevOps | ## Recursos relacionados **Referências** + [Nuvem AWS Development Kit](https://aws.amazon.com/cdk/) + [AWS CDK em GitHub](https://github.com/aws/aws-cdk) + [Trabalhar com pilhas aninhadas](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-nested-stacks.html) + [Exemplo de exemplo da AWS – Análise em tempo real com tecnologia sem servidor](https://github.com/aws-samples/serverless-realtime-analytics) ## Mais informações **Detalhes do diretório e do arquivo** Esse padrão configura as três pilhas a seguir. + `parent-cdk-stack.ts`: essa pilha atua como pilha principal e chama os dois aplicativos secundários de pilhas aninhadas.  + `real-time-analytics-poc-stack.ts`: essa pilha aninhada contém a infraestrutura e o código do aplicativo. + `real-time-analytics-web-stack.ts`: essa pilha aninhada contém somente o código estático do aplicativo web. *Arquivos importantes e suas funcionalidades* + `bin/real-time-analytics-poc.ts`: ponto de entrada do aplicativo AWS CDK. Ele carrega todas as pilhas definidas em `lib/`. + `lib/real-time-analytics-poc-stack.ts`: definição da pilha (`real-time-analytics-poc`) do aplicativo AWS CDK. + `lib/real-time-analytics-web-stack.ts`: definição da pilha (`real-time-analytics-web-stack`) do aplicativo AWS CDK. + `lib/parent-cdk-stack.ts`: definição da pilha (`parent-cdk`) do aplicativo AWS CDK. + `package.json`: manifesto do módulo npm, que inclui o nome, a versão e as dependências do aplicativo. + `package-lock.json`: mantido pelo npm. + `cdk.json`: kit de ferramentas para executar o aplicativo. + `tsconfig.json`— A TypeScript configuração do projeto. + `.gitignore`: lista de arquivos que o Git deve excluir do controle de origem. + `node_modules`: mantido pelo npm; inclui as dependências do projeto. A seção de código a seguir na pilha principal chama os aplicativos secundários como pilhas de CDK aninhadas da AWS. ``` 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 teste** ``` 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})}}| ``` **Teste o API Gateway** No console do API Gateway, teste o API Gateway usando o método `GET`. ![\[Console do API Gateway, com a opção GET escolhida em OPTIONS.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/0ac29a11-1362-4084-92ed-6b85205763ca/images/452e5b8f-6d61-401d-8484-e5a436cb6f1b.png) ## Anexos Para acessar o conteúdo adicional associado a este documento, descompacte o seguinte arquivo: [ attachment.zip](samples/p-attach/0ac29a11-1362-4084-92ed-6b85205763ca/attachments/attachment.zip) # Automatize a implantação de aplicativos aninhados usando o AWS SAM *Dr. Rahul Sharad Gaikwad, Ishwar Chauthaiwale, Dmitry Gulin e Tabby Ward, Amazon Web Services* ## Resumo Na Amazon Web Services (AWS), o AWS Serverless Application Model (AWS SAM) é uma estrutura de código aberto que fornece sintaxe abreviada para expressar APIs funções, bancos de dados e mapeamentos de fontes de eventos. Com apenas algumas linhas para cada recurso, você pode definir o aplicativo desejado e modelá-lo usando YAML. Durante a implantação, o SAM transforma e expande a sintaxe do SAM na sintaxe da AWS CloudFormation , que você pode usar para criar aplicativos sem servidor com mais rapidez. O AWS SAM simplifica o desenvolvimento, a implantação e o gerenciamento de aplicativos com tecnologia sem servidor na plataforma da AWS. Ele fornece uma estrutura padronizada, implantação mais rápida, recursos de teste locais, gerenciamento de recursos, integração perfeita com ferramentas de desenvolvimento e uma comunidade de apoio. Esses recursos o tornam uma ferramenta valiosa para criar aplicativos com tecnologia sem servidor de forma eficiente e eficaz. Esse padrão usa modelos do AWS SAM para automatizar a implantação de aplicativos aninhados. Um aplicativo aninhado é um aplicativo dentro de outro aplicativo. Os aplicativos principais chamam os aplicativos secundários. Esses são componentes com acoplamento fraco de uma arquitetura com tecnologia sem servidor.  Usando aplicativos aninhados, você pode criar rapidamente arquiteturas com tecnologia sem servidor altamente sofisticadas reutilizando serviços ou componentes criados e mantidos de forma independente, mas compostos usando o AWS SAM e o Serverless Application Repository. Os aplicativos aninhados ajudam você a criar aplicativos mais poderosos, evitar a duplicação de trabalho e garantir a consistência e as melhores práticas em suas equipes e organizações. Para demonstrar aplicativos aninhados, o padrão implanta um exemplo de aplicativo de carrinho de compras [com tecnologia sem servidor da AWS](https://github.com/aws-samples/aws-sam-nested-stack-sample). ## Pré-requisitos e limitações **Pré-requisitos ** + Uma conta AWS ativa + Uma nuvem privada virtual (VPC) e sub-redes existentes + Um ambiente de desenvolvimento integrado, como o Visual Studio Code (para obter mais informações, consulte [Tools to Build on AWS](https://aws.amazon.com/getting-started/tools-sdks/#IDE_and_IDE_Toolkits)) + Biblioteca Python wheel instalada usando pip install wheel, se ainda não estiver instalada **Limitações** + O número máximo de aplicativos que podem ser aninhados em um aplicativo com tecnologia sem servidor é 200. + O número máximo de parâmetros para um aplicativo aninhado pode ter 60. **Versões do produto** + Essa solução foi criada na interface de linha de comando do AWS SAM (AWS SAM CLI) versão 1.21.1, mas essa arquitetura deve funcionar com versões posteriores da CLI do AWS SAM. ## Arquitetura **Pilha de tecnologias de destino** + Amazon API Gateway + AWS SAM + Amazon Cognito + Amazon DynamoDB + AWS Lambda + Fila do Amazon Simple Queue Service (Amazon SQS) **Arquitetura de destino** O diagrama a seguir mostra como as solicitações dos usuários são feitas aos serviços de compras por meio de chamadas APIs. A solicitação do usuário, incluindo todas as informações necessárias, é enviada ao Amazon API Gateway e ao autorizador do Amazon Cognito, que executa mecanismos de autenticação e autorização para o. APIs Quando um item é adicionado, excluído ou atualizado no DynamoDB, um evento é colocado no DynamoDB Streams, que por sua vez inicia uma função do Lambda. Para evitar a exclusão imediata de itens antigos como parte de um fluxo de trabalho síncrono, as mensagens são colocadas em uma fila SQS, que inicia uma função de trabalho para excluir as mensagens. ![\[Operações POST e PUT realizadas pelo API Gateway direcionadas às funções do Lambda, ao DynamoDB e ao Product Service.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/218adecc-b5b8-4193-9012-b5d584e2e128/images/5b454bae-5fd4-405d-a37d-6bafc3fcf889.png) Nessa configuração da solução, a CLI do AWS SAM serve como interface para pilhas da AWS CloudFormation . Os modelos do AWS SAM implantam automaticamente aplicativos aninhados. O modelo principal do SAM chama os modelos secundários e a pilha principal implanta as CloudFormation pilhas secundárias. Cada pilha secundária cria os recursos da AWS que são definidos nos modelos do AWS SAM CloudFormation . ![\[Processo de quatro etapas usando a CLI do AWS SAM com pilhas de pais e três CloudFormation filhos.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/218adecc-b5b8-4193-9012-b5d584e2e128/images/5828026e-72ad-4a3f-a5f2-bffac0f13e42.png) 1. Compile e implante as pilhas. 1. A CloudFormation pilha Auth contém o Amazon Cognito. 1. A CloudFormation pilha de produtos contém uma função Lambda e o Amazon API Gateway 1. A CloudFormation pilha de compras contém uma função Lambda, o Amazon API Gateway, a fila SQS e o banco de dados Amazon DynamoDB. ## Ferramentas **Ferramentas** + [O Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/welcome.html) ajuda você a criar, publicar, manter, monitorar e proteger REST, HTTP e WebSocket APIs em qualquer escala. + CloudFormationA [AWS](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html) ajuda você a configurar recursos da AWS, provisioná-los de forma rápida e consistente e gerenciá-los durante todo o ciclo de vida em todas as contas e regiões da AWS. + O [Amazon Cognito](https://docs.aws.amazon.com/cognito/latest/developerguide/what-is-amazon-cognito.html) fornece autenticação, autorização e gerenciamento de usuários para suas aplicações Web e móveis. + O [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) é um serviço de banco de dados NoSQL totalmente gerenciado que fornece performance rápida, previsível e escalável. + O [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) é um serviço de computação que ajuda você a executar código sem exigir provisionamento ou gerenciamento de servidores. Ele executa o código somente quando necessário e dimensiona automaticamente, assim, você paga apenas pelo tempo de computação usado. + O [AWS Serverless Application Model (AWS SAM)](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/what-is-sam.html) é uma estrutura de código aberto que ajuda na criação de aplicativos com tecnologia sem servidor na Nuvem AWS. + O [Amazon Simple Queue Service (Amazon SQS)](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/welcome.html) fornece uma fila hospedada segura, durável e disponível que ajuda a integrar e desacoplar sistemas e componentes de software distribuídos. **Código ** O código desse padrão está disponível no repositório GitHub [AWS SAM Nested Stack Sample](https://github.com/aws-samples/aws-sam-nested-stack-sample). ## Épicos ### Instalar a AWS SAM CLI | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Instale a AWS SAM CLI. | Para instalar a CLI do AWS SAM, consulte as instruções na [documentação do AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html). | DevOps engenheiro | | Configurar credenciais da AWS. | Para definir as credenciais da AWS para que a CLI do AWS SAM possa fazer chamadas para os serviços da AWS em seu nome, execute o comando `aws configure` e siga as instruções.
$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 obter mais informações sobre como configurar suas credenciais e autenticação, consulte [Credenciais de autenticação e acesso](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-authentication.html). | DevOps engenheiro | ### Inicialize o projeto AWS SAM | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Clone o repositório de códigos do AWS SAM. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/automate-deployment-of-nested-applications-using-aws-sam.html) | DevOps engenheiro | | Implante modelos para inicializar o projeto. | Para inicializar o projeto, execute o comando `SAM init`. Quando solicitado a escolher uma origem de modelo, escolha `Custom Template Location`. | DevOps engenheiro | ### Compile e crie o código do modelo SAM | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Analise os modelos de aplicativos do AWS SAM. | Analise os modelos dos aplicativos aninhados. Este exemplo usa os seguintes modelos de aplicativos aninhados:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/automate-deployment-of-nested-applications-using-aws-sam.html) | DevOps engenheiro | | Analise o modelo principal. | Analise o modelo que invocará os modelos de aplicativos aninhados. Neste exemplo, o modelo principal é `template.yml`. Todos os aplicativos separados estão aninhados no modelo pai único `template.yml`. | DevOps engenheiro | | Compile e crie o código do modelo do AWS SAM. | Usando a AWS SAM CLI, execute o comando a seguir.
sam build
| DevOps engenheiro | ### Implante o modelo AWS SAM | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Implante os aplicativos. | Para iniciar o código do modelo SAM que cria as CloudFormation pilhas de aplicativos aninhadas e implanta o código no ambiente da AWS, execute o comando a seguir.
sam deploy --guided --stack-name shopping-cart-nested-stack --capabilities CAPABILITY_IAM CAPABILITY_AUTO_EXPAND
O comando exibirá algumas perguntas. Responda a todas as perguntas com `y`. | DevOps engenheiro | ### Verificar a implantação | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Verificar as pilhas. | Para analisar as CloudFormation pilhas e os recursos da AWS que foram definidos nos modelos do AWS SAM, faça o seguinte:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/automate-deployment-of-nested-applications-using-aws-sam.html) | DevOps engenheiro | ## Recursos relacionados **Referências** + [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 ativado GitHub](https://github.com/aws/serverless-application-model) + [Microsserviço de carrinho de compras com tecnologia sem servidor](https://github.com/aws-samples/aws-serverless-shopping-cart) (exemplo de aplicativo da AWS) **Tutoriais e vídeos** + [Crie um aplicativo com tecnologia sem servidor](https://youtu.be/Hv3YrP8G4ag) + [Palestras técnicas on-line da AWS: criação e implantação de aplicativos com tecnologia sem servidor com o AWS SAM](https://youtu.be/1NU7vyJw9LU) ## Mais informações Depois que todo o código estiver pronto, o exemplo tem a seguinte estrutura de diretórios: + [sam\$1stacks](https://docs.aws.amazon.com/lambda/latest/dg/chapter-layers.html): essa pasta contém a camada `shared.py`. Uma camada é um arquivo que contém bibliotecas, um runtime personalizado ou outras dependências. Com camadas, você pode usar as bibliotecas na sua função sem a necessidade de incluí-las em um pacote de implantação. + *product-mock-service*— Essa pasta contém todas as funções e arquivos do Lambda relacionados ao produto. + *shopping-cart-service*— Essa pasta contém todas as funções e arquivos do Lambda relacionados a compras. # Implemente o isolamento de inquilinos de SaaS para o Amazon S3 usando uma máquina de venda automática de tokens AWS Lambda *Tabby Ward, Thomas Davis e Sravan Periyathambi, Amazon Web Services* ## Resumo Os aplicativos SaaS multilocação devem implementar sistemas para garantir que o isolamento dos inquilinos seja mantido. Quando você armazena dados de inquilinos no mesmo AWS recurso, como quando vários inquilinos armazenam dados no mesmo bucket do Amazon Simple Storage Service (Amazon S3), você deve garantir que o acesso entre inquilinos não ocorra. As máquinas de venda automática de tokens (TVMs) são uma forma de fornecer isolamento de dados do inquilino. Essas máquinas fornecem um mecanismo para obter tokens e, ao mesmo tempo, abstrair a complexidade de como esses tokens são gerados. Os desenvolvedores podem usar uma TVM sem ter conhecimento detalhado de como ela produz tokens. Esse padrão implementa um TVM usando. AWS Lambda A TVM gera um token que consiste em credenciais temporárias de serviço de token de segurança (STS) que limitam o acesso aos dados de um único inquilino SaaS em um bucket S3. TVMse o código fornecido com esse padrão são normalmente usados com declarações derivadas de JSON Web Tokens (JWTs) para associar solicitações de AWS recursos a uma política com escopo de inquilino (IAM AWS Identity and Access Management ). Você pode usar o código deste padrão como base para implementar um aplicativo SaaS que gera credenciais STS temporárias e com escopo com base nas declarações fornecidas em um token JWT. ## Pré-requisitos e limitações **Pré-requisitos ** + Um ativo Conta da AWS. + AWS Command Line Interface (AWS CLI) [versão 1.19.0 ou posterior](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv1.html), instalada e configurada no macOS, Linux ou Windows. Como alternativa, você pode usar a AWS CLI [versão 2.1 ou posterior](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv2.html). **Limitações** + Este código é executado em Java e atualmente não oferece suporte a outras linguagens de programação.  + O aplicativo de amostra não inclui suporte AWS entre regiões ou recuperação de desastres (DR).  + Este padrão demonstra como uma TVM do Lambda para um aplicativo SaaS pode fornecer acesso de inquilino com escopo definido. Este padrão não é recomendado para uso em ambientes de produção sem que testes de segurança adicionais sejam realizados como parte da sua aplicação ou do caso de uso específico. ## Arquitetura **Pilha de tecnologias de destino** + AWS Lambda + Amazon S3 + IAM + AWS Security Token Service (AWS STS) **Arquitetura de destino** ![\[Geração de um token para obter credenciais temporárias do STS e acessar os dados em um bucket do S3.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/97a34c8e-d04e-40b6-acbf-1baa176d22a9/images/14d0508a-703b-4229-85e6-c5094de7fe01.png) ## Ferramentas **Serviços da AWS** + [AWS Command Line Interface (AWS CLI)](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) é uma ferramenta de código aberto que ajuda você a interagir Serviços da AWS por meio de comandos em seu shell de linha de comando. + [AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) ajuda você a gerenciar com segurança o acesso aos seus AWS recursos controlando quem está autenticado e autorizado a usá-los. + O [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) é um serviço de computação que ajuda a executar código sem exigir provisionamento ou gerenciamento de servidores. Ele executa o código somente quando necessário e dimensiona automaticamente, assim, você paga apenas pelo tempo de computação usado. + [AWS Security Token Service (AWS STS)](https://docs.aws.amazon.com/STS/latest/APIReference/welcome.html) ajuda você a solicitar credenciais temporárias com privilégios limitados para os usuários. + O [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) é um serviço de armazenamento de objetos baseado na nuvem que ajuda você a armazenar, proteger e recuperar qualquer quantidade de dados. **Código ** O código-fonte deste padrão está disponível como anexo e inclui os seguintes arquivos: + `s3UploadSample.jar` fornece o código-fonte para uma função do Lambda que carrega um documento JSON em um bucket do S3. + `tvm-layer.zip` oferece uma biblioteca Java reutilizável que fornece um token (credenciais temporárias STS) para que a função do Lambda acesse o bucket do S3 e faça o upload do documento JSON. + `token-vending-machine-sample-app.zip` fornece o código-fonte usado para criar esses artefatos e instruções de compilação. Para usar esses arquivos, siga as instruções da próxima seção. ## Épicos ### Determinar os valores das variáveis | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Determinar os valores das variáveis. | A implementação deste padrão inclui vários nomes de variáveis que devem ser usados de forma consistente. Determine os valores que devem ser usados para cada variável e forneça esse valor quando solicitado nas etapas subsequentes.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/implement-saas-tenant-isolation-for-amazon-s3-by-using-an-aws-lambda-token-vending-machine.html) | Administrador de nuvem | ### Criar um bucket do S3. | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Criar um ambiente do bucket do S3 para o aplicativo de exemplo. | Use o AWS CLI comando a seguir para criar um bucket do S3. Forneça o valor de** **`` no trecho de código:
aws s3api create-bucket --bucket
O aplicativo de exemplo Lambda carrega arquivos JSON nesse bucket. | Administrador de nuvem | ### Criar uma política e um perfil do TVM do IAM | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Criar um perfil TVM. | Use um dos AWS CLI comandos a seguir para criar uma função do IAM. Forneça o valor de** **`` no comando.Para shells no macOS ou 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": ""
                }
            }
        }
    ]
}'
Para a linha de comando do 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\": \"\"}}}]}"
O aplicativo de exemplo do Lambda assume essa função quando o aplicativo é invocado. A capacidade de assumir o perfil do aplicativo com uma política de escopo fornece ao código permissões mais amplas para acessar o bucket do S3. | Administrador de nuvem | | Criar uma política de função de TVM em linha. | Use um dos AWS CLI comandos a seguir para criar uma política do IAM. Forneça os valores de ``,** **`` e `` no comando.Para shells no macOS ou 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/"
        }
    ]}'
Para a linha de comando do 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 é anexada à função da TVM. Dá ao código a capacidade de assumir o perfil do aplicativo que possui permissões mais amplas para acessar o bucket do S3. | Administrador de nuvem | | Anexar a política gerenciada do Lambda. | Use o AWS CLI comando a seguir para anexar a política `AWSLambdaBasicExecutionRole` do IAM. Forneça o valor de `` no comando:
aws iam attach-role-policy \
--role-name  \
--policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
Para a linha de comando do Windows:
aws iam attach-role-policy ^
--role-name  ^
--policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
Essa política gerenciada é anexada à função TVM para permitir que o Lambda envie registros para a Amazon. CloudWatch | Administrador de nuvem | ### Criar uma política e um perfil do aplicativo IAM | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Criar o perfil do aplicativo. | Use um dos AWS CLI comandos a seguir para criar uma função do IAM. Forneça os valores de ``, `` e `` no comando:Para shells no macOS ou 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"
        }
    ]}'
Para a linha de comando do 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\"}]}"
O aplicativo de exemplo Lambda assume essa função com uma política de escopo para obter acesso baseado em inquilinos a um bucket do S3. | Administrador de nuvem | | Criar uma política de função de aplicativo embutida. | Use um dos comandos a seguir AWS CLI para criar uma política do IAM. Forneça os valores de** **`` e `` no comando.Para shells no macOS ou 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:::"
        }
    ]}'
Para a linha de comando do 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 é anexada ao perfil do aplicativo. Ela fornece amplo acesso aos objetos no bucket do S3. Quando o aplicativo de exemplo assume o perfil, essas permissões são atribuídas a um inquilino específico com a política gerada dinamicamente pela TVM. | Administrador de nuvem | ### Crie o aplicativo de exemplo Lambda com a TVM | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Baixe os arquivos de origem compilados. | Baixe os arquivos `s3UploadSample.jar` e `tvm-layer.zip`****, que estão incluídos como anexos. O código-fonte usado para criar esses artefatos e instruções de compilação são fornecidos em `token-vending-machine-sample-app.zip`. | Administrador de nuvem | | Criar a camada do Lambda. | Use o AWS CLI comando a seguir para criar uma camada Lambda, que torna o TVM acessível ao Lambda. Se você não estiver executando este comando do local em que fez o download do arquivo ` tvm-layer.zip`, forneça o caminho correto para o arquivo `tvm-layer.zip` no parâmetro `--zip-file`. 
aws lambda publish-layer-version \
--layer-name sample-token-vending-machine \
--compatible-runtimes java11 \
--zip-file fileb://tvm-layer.zip
Para a linha de comando do Windows:
aws lambda publish-layer-version ^
--layer-name sample-token-vending-machine ^
--compatible-runtimes java11 ^
--zip-file fileb://tvm-layer.zip
Esse comando cria uma camada Lambda que contém a biblioteca TVM reutilizável. | Administrador da nuvem, desenvolvedor de aplicativos | | Criar a função do Lambda. | Use o AWS CLI comando a seguir para criar uma função Lambda. Forneça os valores de ``, ``, ``, ``, `` e `` no comando. Se você não estiver executando este comando do local em que fez o download do arquivo `s3UploadSample.jar`, forneça o caminho correto para o arquivo `s3UploadSample.jar` no 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/}"
Para a linha de comando do 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/}"
Esse comando cria uma função do Lambda com o código do aplicativo de exemplo e a camada TVM anexada. Ele também define duas variáveis de ambiente: `S3_BUCKET` e `ROLE`. O aplicativo de exemplo usa essas variáveis para determinar a função a ser assumida e o bucket do S3 para o qual carregar documentos JSON. | Administrador da nuvem, desenvolvedor de aplicativos | ### Testar o aplicativo de exemplo e a TVM | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Invocar o aplicativo de exemplo do Lambda. | Use um dos AWS CLI comandos a seguir para iniciar o aplicativo de amostra Lambda com a carga esperada. Forneça os valores de `` e `` no comando.Para shells no macOS ou Linux:
aws lambda invoke \
--function  \
--invocation-type RequestResponse \
--payload '{"tenant": ""}' \
--cli-binary-format raw-in-base64-out response.json
Para a linha de comando do Windows:
aws lambda invoke ^
--function  ^
--invocation-type RequestResponse ^
--payload "{\"tenant\": \"\"}" ^
--cli-binary-format raw-in-base64-out response.json
Esse comando chama a função do Lambda e retorna o resultado em um documento `response.json`. Em muitos sistemas baseados em Unix, você pode alterar `response.json` para `/dev/stdout` para enviar os resultados diretamente para o shell sem criar outro arquivo. Ao alterar o valor de `` nas invocações subsequentes desta função do Lambda, o local do documento em JSON e as permissões concedidas pelo token são alterados. | Administrador da nuvem, desenvolvedor de aplicativos | | Visualizar o bucket do S3 para ver os objetos criados. | Acesse o bucket do S3 (``) que você criou anteriormente. Este bucket contém um prefixo de objeto do S3 com o valor de ``. Sob esse prefixo, você encontrará um documento JSON chamado com um UUID. Invocar o aplicativo de exemplo várias vezes adiciona mais documentos JSON. | Administrador de nuvem | | Veja os registros do aplicativo de amostra em CloudWatch Logs. | Visualize os registros associados à função Lambda nomeada `` em CloudWatch Logs. Para obter instruções, consulte [Enviar registros da função Lambda para CloudWatch Logs na documentação](https://docs.aws.amazon.com/lambda/latest/dg/monitoring-cloudwatchlogs.html) do Lambda. Você pode visualizar a política com escopo de inquilino gerada pela TVM nesses logs. Essa política com escopo de locatário concede permissões para o aplicativo de amostra para o Amazon S3 **PutObject**,,, e **GetObject**DeleteObject**ListBucket****** APIs, mas somente para o prefixo de objeto associado a. `` Em invocações subsequentes da aplicação de amostra, se você alterar ``, a TVM atualiza a política com escopo para corresponder ao locatário fornecido na carga útil da invocação. Essa política gerada dinamicamente mostra como o acesso com escopo de inquilino pode ser mantido com uma TVM em aplicativos SaaS. A funcionalidade da TVM é fornecida em uma camada Lambda para que possa ser anexada a outras funções do Lambda usadas por um aplicativo sem precisar replicar o código.Para obter uma ilustração da política gerada dinamicamente, consulte a seção [Informações adicionais](#implement-saas-tenant-isolation-for-amazon-s3-by-using-an-aws-lambda-token-vending-machine-additional). | Administrador de nuvem | ## Recursos relacionados + [Isolar inquilinos com políticas do IAM geradas dinamicamente](https://aws.amazon.com/blogs/apn/isolating-saas-tenants-with-dynamically-generated-iam-policies/) (publicação do blog) + [Applying Dynamically Generated Isolation Policies in SaaS Environments](https://aws.amazon.com/blogs/apn/applying-dynamically-generated-isolation-policies-in-saas-environments/) (publicação do blog) + [SaaS ativado AWS](https://aws.amazon.com/saas/) ## Mais informações O log apresentado a seguir mostra a política gerada dinamicamente pelo código da TVM neste padrão. Nesta captura de tela, o `` é `DOC-EXAMPLE-BUCKET` e o `` é `test-tenant-1`. As credenciais STS retornadas por essa política de escopo não conseguem realizar nenhuma ação em objetos no bucket do S3, exceto os objetos associados ao prefixo da chave do objeto `test-tenant-1`. ![\[Log demonstrando uma política gerada dinamicamente pelo código da TVM.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/97a34c8e-d04e-40b6-acbf-1baa176d22a9/images/d4776ebe-fb8f-41ac-b8c5-b4f97a821c8c.png) ## Anexos Para acessar o conteúdo adicional associado a este documento, descompacte o seguinte arquivo:[ attachment.zip](samples/p-attach/97a34c8e-d04e-40b6-acbf-1baa176d22a9/attachments/attachment.zip) # Implementar o padrão de saga com tecnologia sem servidor usando o AWS Step Functions *Tabby Ward, Joe Kern e Rohan Mehta, Amazon Web Services* ## Resumo Em uma arquitetura de microsserviços, o objetivo principal é criar componentes desacoplados e independentes para promover agilidade, flexibilidade e menor tempo de comercialização de seus aplicativos. Como resultado do desacoplamento, cada componente de microsserviço tem sua própria camada de persistência de dados. Em uma arquitetura distribuída, as transações comerciais podem abranger vários microsserviços. Como esses microsserviços não podem usar uma única transação de atomicidade, consistência, isolamento e durabilidade (ACID), você pode acabar com transações parciais. Nesse caso, alguma lógica de controle é necessária para desfazer as transações que já foram processadas. O padrão de saga distribuída é normalmente usado para essa finalidade.  O padrão saga é um padrão de gerenciamento de falhas que ajuda a estabelecer a consistência em aplicativos distribuídos e coordena as transações entre vários microsserviços para manter a consistência de dados. Quando você usa o padrão de saga, cada serviço que realiza uma transação publica um evento que aciona serviços subsequentes para realizar a próxima transação na cadeia. Isso continua até que a última transação na cadeia seja concluída. Se uma transação comercial falhar, a saga orquestra uma série de transações compensatórias que desfazem as alterações feitas pelas transações anteriores. Esse padrão demonstra como automatizar a configuração e a implantação de um aplicativo de amostra (que lida com reservas de viagens) com tecnologias sem servidor, como AWS Step Functions, AWS Lambda e Amazon DynamoDB. O aplicativo de amostra também usa o Amazon API Gateway e o Amazon Simple Notification Service (Amazon SNS) para implementar um coordenador de execução da saga. O padrão pode ser implantado com uma estrutura de infraestrutura como código (IaC), como o AWS Cloud Development Kit (AWS CDK), o AWS Serverless Application Model (AWS SAM) ou o Terraform. ## Pré-requisitos e limitações **Pré-requisitos ** + Uma conta AWS ativa + Permissões para criar uma CloudFormation pilha da AWS. Para obter mais informações, consulte [Controle de acesso](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html) na CloudFormation documentação. + Estrutura de IaC de sua escolha (AWS CDK, AWS SAM ou Terraform) configurada com sua conta da AWS para que você possa usar a CLI da estrutura para implantar o aplicativo. + NodeJS, usado para criar o aplicativo e executá-lo localmente. + Um editor de código de sua escolha (como Visual Studio Code, Sublime ou Atom). **Versões do produto** + [NodeJS versão 14](https://nodejs.org/en/download/) + [AWS CDK versão 2.37.1](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html#getting_started_install) + [AWS SAM versão 1.71.0](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/install-sam-cli.html) + [Terraform versão 1.3.7](https://developer.hashicorp.com/terraform/tutorials/aws-get-started/install-cli) **Limitações** O fornecimento de eventos é uma forma natural de implementar o padrão de orquestração da saga em uma arquitetura de microsserviços em que todos os componentes estão com acoplamento fraco e não têm conhecimento direto uns dos outros. Se sua transação envolver um pequeno número de etapas (três a cinco), o padrão da saga pode ser uma ótima opção. No entanto, a complexidade aumenta com o número de microsserviços e o número de etapas.  Testar e depurar podem se tornar difíceis quando você usa esse design, porque você precisa ter todos os serviços em execução para simular o padrão da transação. ## Arquitetura **Arquitetura de destino** A arquitetura proposta usa o AWS Step Functions para criar um padrão de saga para reservar voos, reservar aluguéis de carros e processar pagamentos de férias. O diagrama de fluxo de trabalho a seguir ilustra o fluxo típico do sistema de reserva de viagens. O fluxo de trabalho consiste em reservar viagens aéreas (” ReserveFlight “), reservar um carro (” ReserveCarRental “), processar pagamentos (” ProcessPayment “), confirmar reservas de voos (” ConfirmFlight “) e confirmar aluguéis de carros (” “), seguido por uma notificação de sucesso quando essas etapas forem concluídas. ConfirmCarRental No entanto, se o sistema encontrar algum erro na execução de qualquer uma dessas transações, ele começará a falhar para trás. Por exemplo, um erro no processamento do pagamento (” ProcessPayment “) aciona um reembolso (” RefundPayment “), que então aciona o cancelamento do carro e do voo alugados (” CancelRentalReservation "e" CancelFlightReservation “), finalizando toda a transação com uma mensagem de falha. Esse padrão implanta funções do Lambda separadas para cada tarefa destacada no diagrama, bem como três tabelas do DynamoDB para voos, aluguel de carros e pagamentos. Cada função do Lambda cria, atualiza ou exclui as linhas nas respectivas tabelas do DynamoDB, dependendo se uma transação é confirmada ou revertida. O padrão usa o Amazon SNS para enviar mensagens de texto (SMS) aos assinantes, notificando-os sobre transações fracassadas ou bem-sucedidas.  ![\[Fluxo de trabalho para um sistema de reserva de viagens baseado no padrão saga.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/fec0789c-d9b1-4d80-b179-dd9a7ecbec07/images/daad3e8e-6e6b-41c2-95c1-ca79d53ead64.png) **Automação e escala** Você pode criar a configuração para essa arquitetura usando uma das estruturas do IaC. Para se conectar no IaC de sua preferência, use um dos links a seguir. + [Implemente com o AWS CDK](https://serverlessland.com/workflows/saga-pattern-cdk) + [Implemente com o AWS SAM](https://serverlessland.com/workflows/saga-pattern-sam) + [Implemente com o Terraform](https://serverlessland.com/workflows/saga-pattern-tf) ## Ferramentas **Serviços da AWS** + O [AWS Step Functions](https://aws.amazon.com/step-functions/) é um serviço de orquestração de tecnologia sem servidor que permite combinar funções do AWS Lambda e outros serviços da AWS para criar aplicações essenciais aos negócios. A partir do console gráfico do Step Functions, você vê o fluxo de trabalho do seu aplicativo como uma série de etapas orientadas por eventos. + O [Amazon DynamoDB](https://aws.amazon.com/dynamodb/) é um serviço de banco de dados NoSQL totalmente gerenciado que fornece uma performance rápida e previsível com escalabilidade integrada. Use o DynamoDB para criar uma tabela do banco de dados que possa armazenar e recuperar qualquer quantidade de dados e atender qualquer nível de tráfego solicitado. + O [AWS Lambda](https://aws.amazon.com/lambda/) é um serviço de computação que permite que você execute o código sem provisionar ou gerenciar servidores. O Lambda executa o código somente quando necessário e dimensiona automaticamente, desde algumas solicitações por dia até milhares por segundo. + [O Amazon API Gateway](https://aws.amazon.com/api-gateway/) é um serviço da AWS para criar, publicar, manter, monitorar e proteger REST, HTTP e WebSocket APIs em qualquer escala. + O [Amazon Simple Notification Service (Amazon SNS)](https://aws.amazon.com/sns/) é um serviço gerenciado que fornece entrega de mensagens de publicadores para assinantes. + [O AWS Cloud Development Kit (AWS CDK)](https://aws.amazon.com/cdk/) é uma estrutura de desenvolvimento de software para definir seus recursos de aplicativos em nuvem usando linguagens de programação conhecidas TypeScript, como Python JavaScript, Java e C\$1/.Net. + O [AWS Serverless Application Model (AWS SAM)](https://aws.amazon.com/serverless/sam/) é uma estrutura de código aberto para a criação de aplicativos com tecnologia sem servidor. Ele fornece sintaxe abreviada para expressar funções APIs, bancos de dados e mapeamentos de fontes de eventos. **Código** O código de um aplicativo de amostra que demonstra o padrão da saga, incluindo o modelo IaC (AWS CDK, AWS SAM ou Terraform), as funções do Lambda e as tabelas do DynamoDB, pode ser encontrado nos links a seguir. Siga as instruções no primeiro épico para instalá-los. + [Implemente com o AWS CDK](https://serverlessland.com/workflows/saga-pattern-cdk) + [Implemente com o AWS SAM](https://serverlessland.com/workflows/saga-pattern-sam) + [Implemente com o Terraform](https://serverlessland.com/workflows/saga-pattern-tf) ## Épicos ### Instale pacotes, compile e crie | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Instale os pacotes NPM. | Crie um novo diretório, navegue até esse diretório em um terminal e clone o GitHub repositório de sua escolha na seção *Código* anterior nesse padrão.Na pasta raiz que contém o arquivo `package.json`, execute o comando a seguir para baixar e instalar todos os pacotes do Node Package Manager (NPM):
npm install
| Desenvolvedor e arquiteto de nuvem | | Compile scripts. | Na pasta raiz, execute o comando a seguir para instruir o TypeScript transpilador a criar todos os arquivos necessários: JavaScript 
npm run build
| Desenvolvedor e arquiteto de nuvem | | Observe as alterações e recompile. | Na pasta raiz, execute o comando a seguir em uma janela de terminal separada para observar as alterações no código e compilar o código quando detectar uma alteração:
npm run watch
| Desenvolvedor e arquiteto de nuvem | | Execute testes de unidade (somente AWS CDK). | Se você estiver usando o AWS CDK, na pasta raiz, execute o seguinte comando para realizar os testes de unidade do Jest:
npm run test
| Desenvolvedor e arquiteto de nuvem | ### Implante recursos na conta da AWS de destino | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Implante a pilha de demonstração na AWS. | A aplicação é independente da região da AWS. Se você usar um perfil, deverá declarar a região explicitamente no [perfil da AWS Command Line Interface (AWS CLI)](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html) ou por meio de [variáveis de ambiente da AWS CLI.](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-envvars.html)Na pasta raiz, execute o comando a seguir para criar um conjunto de implantação e implantá-lo na conta e região padrão da AWS.AWS CDK:
cdk bootstrap
cdk deploy
AWS SAM:
sam build
sam deploy --guided
Terraform:
terraform init
terraform apply
Esta etapa pode demorar vários minutos para que seja concluída. Esse comando usa as credenciais padrão que foram configuradas para a AWS CLI.Observe o URL do API Gateway que é exibida no console após a conclusão da implantação. Você precisará dessas informações para testar o fluxo de execução da saga. | Desenvolvedor e arquiteto de nuvem | | Compare a pilha implantada com o estado atual. | Na pasta raiz, execute o comando a seguir para comparar a pilha implantada com o estado atual depois de fazer alterações no código-fonte:AWS CDK:
cdk diff
AWS SAM:
sam deploy
Terraform:
terraform plan
| Desenvolvedor e arquiteto de nuvem | ### Teste o fluxo de execução | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Teste o fluxo de execução da saga. | Navegue até o URL do API Gateway que você anotou na etapa anterior, ao implantar a pilha. Esse URL aciona a inicialização da máquina de estado. Para obter mais informações sobre como manipular o fluxo da máquina de estado passando parâmetros de URL diferentes, consulte a seção [Informações adicionais](#implement-the-serverless-saga-pattern-by-using-aws-step-functions-additional).Para ver os resultados, faça login no Console de Gerenciamento da AWS e navegue até o console do Step Functions. Aqui, você pode ver cada passo da máquina de estado da saga. Você também pode visualizar a tabela do DynamoDB para ver os registros inseridos, atualizados ou excluídos. Se você atualizar a tela com frequência, poderá observar a mudança do status da transação de `pending` para `confirmed`. Você pode assinar o tópico do SNS atualizando o código no arquivo `stateMachine.ts` com seu número de telefone celular para receber mensagens SMS em caso de reservas bem-sucedidas ou malsucedidas. Para obter mais informações, consulte *Amazon SNS* na seção [Informações adicionais](#implement-the-serverless-saga-pattern-by-using-aws-step-functions-additional). | Desenvolvedor e arquiteto de nuvem | ### Limpeza | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Limpar os recursos. | Para limpar os recursos implantados para esse aplicativo, você pode usar um dos seguintes comandos.AWS CDK:
cdk destroy
AWS SAM:
sam delete
Terraform:
terraform destroy
| Desenvolvedor de aplicativos, arquiteto de nuvem | ## Recursos relacionados **Artigos técnicos** + [Implementação de microsserviços na AWS](https://docs.aws.amazon.com/pdfs/whitepapers/latest/microservices-on-aws/microservices-on-aws.pdf) + [Perspectiva de aplicativos com tecnologia sem servidor ](https://docs.aws.amazon.com/wellarchitected/latest/serverless-applications-lens/welcome.html) **Documentação do serviço da AWS** + [Conceitos básicos do AWS CDK](https://docs.aws.amazon.com/cdk/latest/guide/getting_started.html) + [Conceitos básicos do 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/) **Tutoriais** + [Workshops práticos sobre computação com tecnologia sem servidor](https://aws.amazon.com/serverless-workshops/) ## Mais informações **Código** Para fins de teste, esse padrão implanta o API Gateway e uma função do Lambda de teste que aciona a máquina de estado Step Functions. Com o Step Functions, você pode controlar a funcionalidade do sistema de reserva de viagens passando um `run_type` parâmetro para simular falhas em "ReserveFlight,” "ReserveCarRental,” "ProcessPayment,”ConfirmFlight,” e "”ConfirmCarRental. A função do Lambda `saga` (`sagaLambda.ts`) recebe a entrada dos parâmetros de consulta no URL do API Gateway, cria o seguinte objeto JSON e o passa para o Step Functions para execução: ``` 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" }; ``` Você pode experimentar diferentes fluxos da máquina de estado Step Functions passando os seguintes parâmetros de URL: + **Execução bem-sucedida** ─ https://\$1api gateway url\$1 + **Falha no voo de reserva** ─ https://\$1api gateway url\$1? **Tipo de execução = failFlightsReservation** + **Confirme a falha do voo** ─ https://\$1api gateway url\$1? **Tipo de execução = failFlightsConfirmation** + **Falha na reserva do aluguel** de carros ─ https://\$1api gateway url\$1? **RunType= Reserva failCarRental** + **Confirme a falha no aluguel do carro** ─ https://\$1api gateway url\$1? **RunType= Confirmação failCarRental** + **Falha no processo de pagamento** ─ https://\$1api gateway url\$1?**runType=failPayment** + **Passe um ID de viagem** ─ https://\$1api gateway url\$1?**tripID=**\$1por padrão, o ID da viagem será o ID da solicitação da AWS\$1 **Modelos de IaC** Os repositórios vinculados incluem modelos de IaC que você pode usar para criar toda a amostra do aplicativo de reserva de viagens. + [Implemente com o AWS CDK](https://serverlessland.com/workflows/saga-pattern-cdk) + [Implemente com o AWS SAM](https://serverlessland.com/workflows/saga-pattern-sam) + [Implemente com o Terraform](https://serverlessland.com/workflows/saga-pattern-tf) **Tabelas do DynamoDB** Aqui estão os modelos de dados para as tabelas de voos, aluguéis de carros e pagamentos. ``` 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"} } }; ``` **Funções do Lambda** As seguintes funções serão criadas para suportar o fluxo e a execução da máquina de estado no Step Functions: + **Reservar voos**: insere um registro na tabela de voos do DynamoDB com um `transaction_status` de `pending`, para reservar um voo. + **Confirmar voo**: atualiza o registro na tabela de voos do DynamoDB, para definir `transaction_status` como `confirmed`, para confirmar o voo. + **Cancelar reserva de voos**: exclui o registro da tabela de voos do DynamoDB para cancelar o voo pendente. + **Reserve locações de veículos**: insere um registro na tabela do CarRentals DynamoDB com `transaction_status` um de, para reservar um aluguel `pending` de carro. + **Confirmar aluguel de carros**: atualiza o registro na tabela do CarRentals DynamoDB, para `transaction_status` definir como, `confirmed` para confirmar o aluguel do carro. + **Cancelar reserva de aluguel de carro:** exclui o registro da tabela do CarRentals DynamoDB para cancelar o aluguel de carro pendente. + **Processar pagamento**: insere um registro na tabela de pagamentos do DynamoDB para o pagamento. + **Cancelar pagamento**: exclui o registro do pagamento da tabela de pagamentos do DynamoDB. **Amazon SNS** O aplicativo de amostra cria o tópico e a assinatura a seguir para enviar mensagens SMS e notificar o cliente sobre reservas bem-sucedidas ou malsucedidas. Se você quiser receber mensagens de texto enquanto testa o aplicativo de amostra, atualize a assinatura de SMS com seu número de telefone válido no arquivo de definição da máquina de estado. Trecho do AWS CDK (adicione o número de telefone na segunda linha do código a seguir): ``` 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'), }); ``` Trecho do AWS SAM (substitua as strings `+1111111111` pelo seu número de telefone válido): ``` StateMachineTopic11111111111: Type: 'AWS::SNS::Subscription' Properties: Protocol: sms TopicArn: Ref: StateMachineTopic Endpoint: '+11111111111' Metadata: 'aws:sam:path': SamServerlessSagaStack/StateMachine/Topic/+11111111111/Resource ``` Trecho do Terraform (substitua a string `+111111111` pelo seu número de telefone válido): ``` resource "aws_sns_topic_subscription" "sms-target" { topic_arn = aws_sns_topic.topic.arn protocol = "sms" endpoint = "+11111111111" } ``` **Reservas bem-sucedidas** O fluxo a seguir ilustra uma reserva bem-sucedida com "ReserveFlight,” "ReserveCarRental,” e "ProcessPayment" seguido por "ConfirmFlight" e "”ConfirmCarRental. O cliente é notificado sobre a reserva bem-sucedida por meio de mensagens SMS enviadas ao assinante do tópico do SNS. ![\[Exemplo de uma reserva bem-sucedida implementada pelo Step Functions usando o padrão saga.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/fec0789c-d9b1-4d80-b179-dd9a7ecbec07/images/f58c894e-7721-4bc7-8f7d-29f23faa5dc1.png) **Reservas malsucedidas** Esse fluxo é um exemplo de falha no padrão da saga. Se, após a reserva de voos e aluguel de carros, "ProcessPayment" falhar, as etapas serão canceladas na ordem inversa.  As reservas são liberadas e o cliente é notificado da falha por meio de mensagens SMS que são enviadas ao assinante do tópico do SNS. ![\[Exemplo de uma reserva com falha implementada pelo Step Functions usando o padrão saga.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/fec0789c-d9b1-4d80-b179-dd9a7ecbec07/images/7c64d326-be27-42c3-b03f-d677efedb9a7.png) # Gerencie aplicativos de contêineres on-premises configurando o Amazon ECS Anywhere com o AWS CDK *Dr. Rahul Sharad Gaikwad, Amazon Web Services* ## Resumo O [Amazon ECS Anywhere](https://aws.amazon.com/ecs/anywhere/) é uma extensão do Amazon Elastic Container Service (Amazon ECS). Você pode usar o ECS Anywhere para implantar tarefas nativas do Amazon ECS em um ambiente on-premises ou gerenciado pelo cliente. Esse atributo ajuda a reduzir custos e mitigar operações e orquestrações complexas de contêineres locais. Você pode usar o ECS Anywhere para implantar e executar aplicativos de contêiner em ambientes on-premises e na nuvem. Isso elimina a necessidade de sua equipe aprender vários domínios e conjuntos de habilidades ou gerenciar softwares complexos por conta própria. Esse padrão demonstra as etapas para configurar o ECS Anywhere usando pilhas do AWS Cloud Development Kit ([AWS CDK](https://aws.amazon.com/cdk/)); ## Pré-requisitos e limitações **Pré-requisitos ** + Uma conta AWS ativa + AWS Command Line Interface (AWS CLI), instalada e configurada. (Consulte [Instalar, atualizar e desinstalar a AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) na documentação da AWS CLI.)  + AWS CDK Toolkit, instalado e configurado. (Consulte o [AWS CDK Toolkit](https://docs.aws.amazon.com/cdk/v2/guide/cli.html) na documentação do AWS CDK e siga as instruções para instalar a versão 2 globalmente.) + Gerenciador de pacotes Node (npm), instalado e configurado para o AWS CDK em. TypeScript (Consulte [Como baixar e instalar o Node.js e o npm ](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm) na documentação do npm.) **Limitações** + Para limitações e considerações, consulte [Instâncias externas (Amazon ECS Anywhere)](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-anywhere.html#ecs-anywhere-considerations) na documentação do Amazon ECS. **Versões do produto** + AWS CDK Toolkit versão 2 + npm versão 7.20.3 ou superior + Node.js versão 16.6.1 ou superior ## Arquitetura **Pilha de tecnologias de destino** + AWS CloudFormation + AWS CDK + Amazon ECS Anywhere + AWS Identity and Access Management (IAM) **Arquitetura de destino** O diagrama a seguir ilustra uma arquitetura de sistema de alto nível da configuração do ECS Anywhere usando o AWS CDK com TypeScript, conforme implementado por esse padrão. 1. Quando você implanta a pilha de CDK da AWS, ela cria uma CloudFormation pilha na AWS. 1. A CloudFormation pilha provisiona um cluster do Amazon ECS e recursos relacionados da AWS. 1. Para registrar uma instância externa com um cluster do Amazon ECS, você deve instalar o AWS Systems Manager Agent (SSM Agent) na sua máquina virtual (VM) e registrar a VM como uma instância gerenciada do AWS Systems Manager.  1. Você deve instalar o agente de contêiner do Amazon ECS e o Docker na sua VM para registrá-la como instância externa com o cluster do Amazon ECS. 1. Quando a instância externa é registrada e configurada com o cluster Amazon ECS, ela pode executar vários contêineres na sua VM, que é registrada como uma instância externa. ![\[Configuração do ECS Anywhere usando o AWS CDK com. TypeScript\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/3ed63c00-40e7-4831-bb9d-63049c3490aa/images/ff7dc774-830d-4b9f-8262-7314afe7a033.png) **Automação e escala** O [GitHub repositório](https://github.com/aws-samples/amazon-ecs-anywhere-cdk-samples/) fornecido com esse padrão usa o AWS CDK como uma ferramenta de infraestrutura como código (IaC) para criar a configuração dessa arquitetura. O AWS CDK ajuda você a orquestrar recursos e configurar o ECS Anywhere. ## Ferramentas + O [AWS Cloud Development Kit (AWS CDK)](https://docs.aws.amazon.com/cdk/latest/guide/home.html) é uma estrutura de desenvolvimento de software que ajuda você a definir e provisionar a infraestrutura da Nuvem AWS em código. + A [AWS Command Line Interface (AWS CLI)](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) é uma ferramenta de código aberto que permite que você interaja com serviços da AWS usando comandos no shell da linha de comando. **Código ** O código-fonte desse padrão está disponível no GitHub repositório [Amazon ECS Anywhere CDK](https://github.com/aws-samples/amazon-ecs-anywhere-cdk-samples) Samples. Para clonar e usar o repositório, siga as instruções na próxima seção. ## Épicos ### Verifique a configuração do AWS CDK | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Verifique a versão do AWS CDK. | Verifique a versão do AWS CDK Toolkit executando o seguinte comando:
cdk --version
Esse padrão requer o AWS CDK versão 2. Se você tiver uma versão anterior do AWS CDK, siga as instruções na [documentação do AWS CDK](https://docs.aws.amazon.com/cdk/v2/guide/cli.html) para atualizá-la. | DevOps engenheiro | | Configure as credenciais da AWS. | Para configurar as credenciais, execute o comando `aws configure` e siga as instruções:
$aws configure
AWS Access Key ID [None]: 
AWS Secret Access Key [None]: 
Default region name [None]: 
Default output format [None]:
| DevOps engenheiro | ### Faça o bootstrap do ambiente do AWS CDK | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Clone o repositório de códigos do AWS CDK. | Clone o repositório de GitHub código desse padrão usando o comando:
git clone https://github.com/aws-samples/amazon-ecs-anywhere-cdk-samples.git
| DevOps engenheiro | | Inicialize o ambiente do . | Para implantar o CloudFormation modelo da AWS na conta e na região da AWS que você deseja usar, execute o seguinte comando:
cdk bootstrap /
Para obter mais informações, consulte [Inicialização](https://docs.aws.amazon.com/cdk/latest/guide/bootstrapping.html) na documentação do AWS CDK. | DevOps engenheiro | ### Crie e implante o projeto | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Instale as dependências do pacote e compile TypeScript os arquivos. | Instale as dependências do pacote e compile os TypeScript arquivos executando os seguintes comandos:
$cd amazon-ecs-anywhere-cdk-samples
$npm install
$npm fund
Esses comandos instalam todos os pacotes do repositório de exemplo. Se você receber algum erro sobre pacotes ausentes, use um dos seguintes comandos:
$npm ci
—ou—
$npm install -g @aws-cdk/
Para obter mais informações, consulte [npm ci](https://docs.npmjs.com/cli/v7/commands/npm-ci) e  [npm install](https://docs.npmjs.com/cli/v7/commands/npm-install) na documentação do npm. | DevOps engenheiro | | Crie o projeto. | Para construir o código do projeto, execute o comando:
npm run build
Para obter mais informações sobre como criar e implantar o projeto, consulte [Seu primeiro aplicativo da 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) na documentação do AWS CDK. | DevOps engenheiro | | Implante o projeto. | Para implantar o código do projeto, execute o comando:
cdk deploy
| DevOps engenheiro | | Verifique a criação e a saída da pilha. | Abra o CloudFormation console da AWS em [https://console.aws.amazon.com/cloudformation****](https://console.aws.amazon.com/cloudformation/) e escolha a pilha. `EcsAnywhereStack` A guia **Saídas** mostra os comandos a serem executados em sua VM externa. | DevOps engenheiro | ### Configurar uma máquina on-premises | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Configure sua VM usando o Vagrant. | Para fins de demonstração, você pode usar o [HashiCorp Vagrant](https://www.vagrantup.com/) para criar uma VM. O Vagrant é um utilitário de código aberto para criar e manter ambientes portáteis de desenvolvimento de software virtual. Crie uma VM Vagrant executando o comando `vagrant up` a partir do diretório raiz em que o Vagrantfile está colocado. Para obter mais informações, consulte a [documentação do Vagrant](https://www.vagrantup.com/docs/cli/up). | DevOps engenheiro | | Registre sua VM como uma instância externa. | 1. Faça login na VM Vagrant usando o comando `vagrant ssh`. Para obter mais informações, consulte a [documentação do Vagrant](https://www.vagrantup.com/docs/cli/ssh).2. Crie um código de ativação e um ID que você possa usar para registrar sua VM no AWS Systems Manager e ativar sua instância externa. A saída desse comando inclui os valores `ActivationId` e `ActivationCode`: 
aws ssm create-activation --iam-role EcsAnywhereInstanceRole | tee ssm-activation.json
3. Exporte a ID de ativação e os valores do código:
export ACTIVATION_ID=
export ACTIVATION_CODE=
4. No servidor on-premises ou na máquina virtual (VM), baixe o script de instalação:
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. No servidor on-premises ou na máquina virtual (VM), execute o script de instalação:
sudo ./ecs-anywhere-install.sh \
    --cluster test-ecs-anywhere \
     --activation-id $ACTIVATION_ID \
     --activation-code $ACTIVATION_CODE \
    --region
Para obter mais informações sobre como configurar e registrar sua VM, consulte [Registro de uma instância externa em um cluster](https://docs.amazonaws.cn/en_us/AmazonECS/latest/developerguide/ecs-anywhere-registration.html) na documentação do Amazon ECS. | DevOps engenheiro | | Verifique o status do ECS Anywhere e da VM externa. | Para verificar se sua caixa virtual está conectada ao ambiente de gerenciamento do Amazon ECS e em execução, use os seguintes comandos:
aws ssm describe-instance-information
aws ecs list-container-instances --cluster $CLUSTER_NAME
| DevOps engenheiro | ### Limpeza | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Limpe e exclua recursos. | Depois de percorrer esse padrão, você deve remover os recursos criados para evitar cobranças adicionais. Para limpar, execute o comando:
cdk destroy
| DevOps engenheiro | ## Recursos relacionados + [Documentação do Amazon ECS Anywhere](https://aws.amazon.com/ecs/anywhere/)  + [Demonstração do Amazon ECS Anywhere](https://www.youtube.com/watch?v=-eud6yUXsJM) + [Exemplos de workshops do Amazon ECS Anywhere](https://github.com/aws-samples/aws-ecs-anywhere-workshop-samples) # Modernize aplicativos ASP.NET Web Forms na AWS *Vijai Anand Ramalingam e Sreelaxmi Pai, Amazon Web Services* ## Resumo Este padrão descreve as etapas necessárias para realizar a modernização de uma aplicação legada e monolítica do ASP.NET Web Forms, migrando-a para o ASP.NET Core na AWS. A portabilidade de aplicativos ASP.NET Web Forms para o ASP.NET Core ajuda você a aproveitar o desempenho, a redução de custos e o ecossistema robusto do Linux. No entanto, pode ser um esforço manual significativo. Nesse padrão, o aplicativo herdado é modernizado de forma incremental usando uma abordagem em fases e, em seguida, conteinerizado na Nuvem AWS. Considere um aplicativo monolítico antigo para um carrinho de compras. Vamos supor que ele foi criado como um aplicativo ASP.NET Web Forms e consiste em páginas.aspx com um arquivo code-behind (`aspx.cs`). O processo de modernização consiste em três etapas: 1. Divida o monólito em microsserviços usando os padrões de decomposição apropriados. Para obter mais informações, consulte o guia [Decomposição de monólitos em microsserviços](https://docs.aws.amazon.com/prescriptive-guidance/latest/modernization-decomposing-monoliths/) no site de Recomendações da AWS. 1. Porte seu aplicativo antigo ASP.NET Web Forms (.NET Framework) para o ASP.NET Core no.NET 5 ou superior. Nesse padrão, você usa o Assistente de Portabilidade para .NET para verificar seu aplicativo ASP.NET Web Forms e identificar incompatibilidades com o ASP.NET Core. Isso reduz o esforço de portabilidade manual. 1. Redesenvolva a camada de interface do usuário do Web Forms usando o React. Esse padrão não abrange a remodelação da interface do usuário. Para obter instruções, consulte [Criar um novo aplicativo React](https://reactjs.org/docs/create-a-new-react-app.html) na documentação do React. 1. Redesenvolva o arquivo code-behind do Web Forms (interface comercial) como uma API web do ASP.NET Core. Esse padrão usa NDepend relatórios para ajudar a identificar os arquivos e dependências necessários. 1. Atualize shared/common projetos, como Business Logic e Data Access, em seu aplicativo legado para o.NET 5 ou posterior usando o Porting Assistant para.NET.  1. Adicione serviços da AWS para complementar seu aplicativo. Por exemplo, você pode usar o [Amazon CloudWatch Logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/WhatIsCloudWatchLogs.html) para monitorar, armazenar e acessar os registros do seu aplicativo, e o [AWS Systems Manager](https://aws.amazon.com/systems-manager/) para armazenar as configurações do seu aplicativo. 1. Coloque o aplicativo ASP.NET Core modernizado em contêiner. Esse padrão cria um arquivo Docker que tem como destino o Linux no Visual Studio e usa o Docker Desktop para testá-lo localmente. Essa etapa pressupõe que seu aplicativo legado já esteja sendo executado em uma instância local ou no Amazon Elastic Compute Cloud (Amazon EC2) Windows. Para obter mais informações, consulte o padrão [Executar um contêiner Docker da API web ASP.NET Core em uma instância do 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. Implantar o aplicativo ASP.NET core modernizado no Amazon Elastic Container Service (Amazon ECS). Esse padrão não abrange a etapa de implantação. Para obter instruções, consulte o [Workshop do Amazon ECS](https://ecsworkshop.com/). **nota** Este padrão não abrange o desenvolvimento da interface do usuário, a modernização do banco de dados ou as etapas de implantação em contêineres. ## Pré-requisitos e limitações **Pré-requisitos ** + [Visual Studio](https://visualstudio.microsoft.com/downloads/) ou [Visual Studio Code](https://code.visualstudio.com/download), baixado e instalado. + Acesso a uma conta da AWS usando o Console de Gerenciamento da AWS e a AWS Command Line Interface (AWS CLI), versão 2. (Consulte [Instruções para configurar a AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv2.html).) + AWS Toolkit for Visual Studio (consulte [instruções de configuração](https://docs.aws.amazon.com/toolkit-for-visual-studio/latest/user-guide/setup.html)). + Docker Desktop, [baixado](https://www.docker.com/products/docker-desktop) e instalado. + .NET SDK, [baixado](https://download.visualstudio.microsoft.com/download/pr/4263dc3b-dc67-4f11-8d46-cc0ae86a232e/66782bbd04c53651f730b2e30a873f18/dotnet-sdk-5.0.203-win-x64.exe) e instalado. + NDepend ferramenta, [baixada](https://www.ndepend.com/download) e instalada. Para instalar a NDepend extensão para o Visual Studio, execute `NDepend.VisualStudioExtension.Installer` ([consulte as instruções](https://www.ndepend.com/docs/getting-started-with-ndepend#Part1)). Você pode selecionar o Visual Studio 2019 ou 2022, dependendo dos seus requisitos.  + Assistente de Portabilidade para .NET, [baixado](https://aws.amazon.com/porting-assistant-dotnet/) e instalado. ## Arquitetura **Modernizando o aplicativo do carrinho de compras** O diagrama a seguir ilustra o processo de modernização de um aplicativo antigo de carrinho de compras ASP.NET. ![\[Modernizando um aplicativo antigo de carrinho de compras\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/36cda8e6-f2cb-4f1a-b37f-fa3045cc5ba1/images/4367e259-9bb3-4eb6-a54d-1c1e2dece7d4.png) **Arquitetura de destino** O diagrama a seguir ilustra a arquitetura do aplicativo de carrinho de compras modernizado na AWS. O ASP.NET Core web APIs é implantado em um cluster Amazon ECS. Os serviços de registro e configuração são fornecidos pela Amazon CloudWatch Logs e pelo AWS Systems Manager. ![\[Arquitetura de destino para o aplicativo ASP.NET Web Forms na AWS\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/36cda8e6-f2cb-4f1a-b37f-fa3045cc5ba1/images/ed6d65ec-0dc9-43ab-ac07-1f172e089399.png) ## Ferramentas **Serviços da AWS** + [Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/Welcome.html): o Amazon Elastic Container Service (Amazon ECS) é um serviço de gerenciamento de contêineres altamente escalável e rápido para execução, interrupção e gerenciamento de contêineres em um cluster. Você pode executar tarefas e serviços em uma infraestrutura com tecnologia gerenciada pelo AWS Fargate. Como alternativa, para ter mais controle sobre sua infraestrutura, você pode executar suas tarefas e serviços em um cluster de EC2 instâncias que você gerencia. + [Amazon CloudWatch Logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/WhatIsCloudWatchLogs.html) — O Amazon CloudWatch Logs centraliza os registros de todos os seus sistemas, aplicativos e serviços da AWS que você usa. Você pode visualizar e monitorar os logs, pesquisá-los em busca de códigos de erro ou padrões específicos, filtrá-los com base em campos específicos ou arquivá-los com segurança para análise futura. + [AWS Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/what-is-systems-manager.html) ─ O AWS Systems Manager é um serviço da AWS que você pode usar para visualizar e controlar sua infraestrutura na AWS. Usando o console do Systems Manager, você pode visualizar dados operacionais de vários serviços da AWS e automatizar tarefas operacionais nos recursos da AWS. O Systems Manager ajuda você a manter a segurança e a conformidade verificando suas instâncias gerenciadas e gerando relatórios (ou tomando medidas corretivas) sobre quaisquer violações de políticas detectadas. **Ferramentas** + [Visual Studio](https://visualstudio.microsoft.com/) ou [Visual Studio Code](https://code.visualstudio.com/) — Ferramentas para criar aplicativos.NET APIs, web e outros programas. + [AWS Toolkit for Visual Studio](https://docs.aws.amazon.com/toolkit-for-visual-studio/latest/user-guide/welcome.html): uma extensão do Visual Studio que ajuda a desenvolver, depurarem e implantarem aplicações .NET que usam os serviços da AWS. + [Docker Desktop](https://www.docker.com/products/docker-desktop): uma ferramenta que simplifica a criação e a implantação de aplicativos em contêineres. + [NDepend](https://www.ndepend.com/features/)— Um analisador que monitora o código.NET em busca de dependências, problemas de qualidade e alterações no código. + [Assistente de Portabilidade para .NET](https://aws.amazon.com/porting-assistant-dotnet/): uma ferramenta de análise que escaneia o código .NET para identificar incompatibilidades com o.NET Core e estimar o esforço de migração. ## Épicos ### Porte seu aplicativo herdado para o.NET 5 ou versão posterior | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Atualize seu aplicativo herdado do .NET Framework para o .NET 5. | Você pode usar o Assistente de Portabilidade para .NET para converter seu aplicativo herdado ASP.NET Web Forms em .NET 5 ou superior. Siga as instruções na [documentação do Assistente de Portabilidade para .NET](https://docs.aws.amazon.com/portingassistant/latest/userguide/porting-assistant-getting-started.html). | Desenvolvedor de aplicativos | | Gere NDepend relatórios. | Ao modernizar seu aplicativo ASP.NET Web Forms decompondo-o em microsserviços, talvez você não precise de todos os arquivos.cs do aplicativo herdado. Você pode usar NDepend para gerar um relatório para qualquer arquivo code-behind (.cs), para obter todos os chamadores e chamadores. Esse relatório ajuda você a identificar e usar somente os arquivos necessários em seus microsserviços.Depois de instalar NDepend (consulte a seção [Pré-requisitos](#modernize-asp-net-web-forms-applications-on-aws-prereqs)), abra a solução (arquivo.sln) para seu aplicativo legado no Visual Studio e siga estas etapas:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/modernize-asp-net-web-forms-applications-on-aws.html)Esse processo gera um relatório para o arquivo code-behind que lista todos os chamadores e chamados. Para obter mais informações sobre o gráfico de dependências, consulte a [NDepend documentação](https://www.ndepend.com/docs/visual-studio-dependency-graph). | Desenvolvedor de aplicativos | | Criar uma nova solução .NET 5. | Para criar uma nova estrutura do.NET 5 (ou posterior) para sua web ASP.NET Core modernizada: APIs[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/modernize-asp-net-web-forms-applications-on-aws.html)Para obter mais informações sobre como criar projetos e soluções, consulte a [documentação do Visual Studio](https://docs.microsoft.com/en-us/visualstudio/ide/creating-solutions-and-projects).Ao criar a solução e verificar a funcionalidade, você pode identificar vários arquivos adicionais a serem adicionados à solução, além dos arquivos NDepend identificados. | Desenvolvedor de aplicativos | ### Atualize seu código de aplicativo. | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Implemente a web APIs com o ASP.NET Core. | Vamos supor que um dos microsserviços que você identificou em seu aplicativo antigo de carrinho de compras monolítico seja *Produtos*. Você criou um novo projeto de API web do ASP.NET Core para *Produtos* no épico anterior. Nesta etapa, você identifica e moderniza todos os formulários da web (páginas .aspx) relacionados aos *Produtos*. Vamos supor que os *Produtos* consistam em quatro formulários da web, conforme ilustrado anteriormente na seção [Arquitetura](#modernize-asp-net-web-forms-applications-on-aws-architecture):[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/modernize-asp-net-web-forms-applications-on-aws.html)Você deve analisar cada formulário da web, identificar todas as solicitações enviadas ao banco de dados para realizar alguma lógica e obter respostas. Você pode implementar cada solicitação como um endpoint de API da web. Com base em seus formulários na web, os *Produtos* podem ter os seguintes endpoints possíveis:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/modernize-asp-net-web-forms-applications-on-aws.html)Conforme mencionado anteriormente, você também pode reutilizar todos os outros projetos que você atualizou para o.NET 5, incluindo Business Logic, Data Access e shared/common projetos. | Desenvolvedor de aplicativos | | Configure o Amazon CloudWatch Logs. | Você pode usar o [Amazon CloudWatch Logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/WhatIsCloudWatchLogs.html) para monitorar, armazenar e acessar os registros do seu aplicativo. Você pode registrar dados no Amazon CloudWatch Logs usando um SDK da AWS. Você também pode integrar aplicativos.NET com o CloudWatch Logs usando estruturas de registro do.NET populares [NLog](https://www.nuget.org/packages/AWS.Logger.NLog/), como [Log4Net e [ASP.NET](https://www.nuget.org/packages/AWS.Logger.AspNetCore/)](https://www.nuget.org/packages/AWS.Logger.Log4net/) Core.Para obter mais informações sobre essa etapa, consulte a postagem no blog [Amazon CloudWatch Logs and .NET Logging Frameworks](https://aws.amazon.com/blogs/developer/amazon-cloudwatch-logs-and-net-logging-frameworks/). | Desenvolvedor de aplicativos | | Configure a AWS Systems Manager Parameter Store. | Você pode usar o [AWS Systems Manager Parameter Store](https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-paramstore.html) para armazenar configurações do aplicativo, como strings de conexão, separadamente do código do seu aplicativo. O NuGet pacote [Amazon.Extensions.Configuration. SystemsManager](https://www.nuget.org/packages/Amazon.Extensions.Configuration.SystemsManager/)simplifica a forma como seu aplicativo carrega essas configurações do AWS Systems Manager Parameter Store no sistema de configuração.NET Core. Para obter mais informações sobre essa etapa, consulte a postagem no blog [Provedor de configuração do .NET Core para o AWS Systems Manager](https://aws.amazon.com/blogs/developer/net-core-configuration-provider-for-aws-systems-manager/). | Desenvolvedor de aplicativos | ### Adicione autenticação e autorização | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Use um cookie compartilhado para autenticação. | Modernizar um aplicativo monolítico herdado é um processo iterativo e exige que o monólito e sua versão modernizada coexistam. Você pode usar um cookie compartilhado para obter uma autenticação perfeita entre as duas versões. O aplicativo ASP.NET herdado continua validando as credenciais do usuário e emite o cookie, enquanto o aplicativo ASP.NET Core modernizado valida o cookie. Para obter instruções e exemplos de código, consulte o [ GitHub projeto de amostra](https://github.com/aws-samples/dotnet-share-auth-cookie-between-monolith-and-modernized-apps). | Desenvolvedor de aplicativos | ### Compilar e executar o contêiner localmente | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Criar uma imagem do Docker usando o Visual Studio. | Nesta etapa, você cria um arquivo Docker usando a API web do Visual Studio for .NET Core.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/modernize-asp-net-web-forms-applications-on-aws.html)O Visual Studio cria um arquivo Docker para seu projeto. Para obter um exemplo de arquivo Docker, consulte [Visual Studio Container Tools for Docker](https://docs.microsoft.com/en-us/visualstudio/containers/overview) no site da Microsoft. | Desenvolvedor de aplicativos | | Crie e execute o contêiner usando o Docker Desktop. | Agora você pode compilar, criar e executar o contêiner no Docker Desktop.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/modernize-asp-net-web-forms-applications-on-aws.html) | Desenvolvedor de aplicativos | ## Recursos relacionados + [Execute um contêiner Docker da API web ASP.NET Core em uma instância 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) + [Workshop do Amazon ECS](https://ecsworkshop.com/) + [Execute blue/green implantações do ECS usando a CodeDeploy AWS (documentação CloudFormation da AWS](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/blue-green.html) CloudFormation ) + [Começando com NDepend](https://www.ndepend.com/docs/getting-started-with-ndepend) (NDepend documentação) + [Assistente de Portabilidade para .NET](https://aws.amazon.com/porting-assistant-dotnet/) ## Mais informações As tabelas a seguir fornecem exemplos de projetos para um aplicativo antigo de carrinho de compras e os projetos equivalentes em seu aplicativo ASP.NET Core modernizado. **Solução antiga:** | | | Nome do projeto | Modelo de projeto | Estrutura de destino | | --- |--- |--- | | Interface de negócios | Biblioteca de classes | NET Framework | | BusinessLogic | Biblioteca de classes | NET Framework | | WebApplication | Aplicativo Web do ASP.NET Framework | NET Framework | | UnitTests | NUnit Projeto de teste | NET Framework | | Compartilhado ->Comum | Biblioteca de classes | NET Framework | | Compartilhado ->Estrutura | Biblioteca de classes | NET Framework | **Nova solução:** | | | Nome do projeto | Modelo de projeto | Estrutura de destino | | --- |--- |--- | | BusinessLogic | Biblioteca de classes | .NET 5.0 | | | API Web do ASP.NET Core | .NET 5.0 | | . UnitTests | NUnit 3 Projeto de teste | .NET 5.0 | | Compartilhado ->Comum | Biblioteca de classes | .NET 5.0 | | Compartilhado ->Estrutura | Biblioteca de classes | .NET 5.0 | # Integração de locatários na arquitetura de SaaS para o modelo de silo usando C\$1 e o AWS CDK *Tabby Ward, Susmitha Reddy Gankidi e Vijai Anand Ramalingam, Amazon Web Services* ## Resumo Os aplicativos de software como serviço (SaaS) podem ser criados com uma variedade de modelos arquitetônicos diferentes. O *modelo de silo* se refere a uma arquitetura em que os locatários recebem recursos dedicados. Os aplicativos SaaS dependem de um modelo simples para introduzir novos locatários em seu ambiente. Isso geralmente requer a orquestração de vários componentes para provisionar e configurar com êxito todos os elementos necessários para criar um novo locatário. Esse processo, na arquitetura SaaS, é chamado de integração de locatários. A integração deve ser totalmente automatizada para cada ambiente SaaS, utilizando a infraestrutura como código em seu processo de integração. Esse padrão orienta você por meio de um exemplo de criação de um locatário e provisionamento de uma infraestrutura básica para o locatário na Amazon Web Services (AWS). O padrão usa C\$1 e o AWS Cloud Development Kit (AWS CDK). Como esse padrão cria um alarme de faturamento, recomendamos implantar a pilha na região da AWS do Leste dos EUA (Norte da Virgínia) ou us-east-1. Para obter mais informações, consulte a [documentação da AWS](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/monitor_estimated_charges_with_cloudwatch.html). ## Pré-requisitos e limitações **Pré-requisitos**** ** + Uma [conta AWS](https://aws.amazon.com/account/) ativa + Uma entidade principal do Identity and Access Management (IAM) da AWS com acesso suficiente ao IAM para criar recursos da AWS para esse padrão. Para obter mais informações, consulte os [perfis do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html). + [Instale a Amazon Command Line Interface (AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)) e [configure a AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html) para realizar a implantação do AWS CDK. + [Visual Studio 2022](https://visualstudio.microsoft.com/downloads/) baixado e instalado ou [Visual Studio Code](https://code.visualstudio.com/download) baixado e instalado. + Configuração do [AWS Toolkit for Visual Studio](https://docs.aws.amazon.com/toolkit-for-visual-studio/latest/user-guide/setup.html). + [.NET Core 3.1 ou superior](https://dotnet.microsoft.com/download/dotnet-core/3.1) (exigido para aplicativos C\$1 AWS CDK) + [Amazon.Lambda.Tools](https://github.com/aws/aws-extensions-for-dotnet-cli#aws-lambda-amazonlambdatools) instalado. **Limitações**** ** + O AWS CDK usa a [AWS CloudFormation](https://aws.amazon.com/cloudformation/), então os aplicativos do AWS CDK estão sujeitos às cotas de CloudFormation serviço. Para obter mais informações, consulte [as CloudFormation cotas da AWS](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cloudformation-limits.html).  + A CloudFormation pilha de inquilinos é criada com uma função CloudFormation de serviço `infra-cloudformation-role` com caracteres curinga nas ações (`sns`\$1 e`sqs*`), mas com recursos restritos ao prefixo. `tenant-cluster` Para um caso de uso de produção, avalie essa configuração e forneça somente o acesso necessário a esse perfil de serviço. A função `InfrastructureProvision` Lambda também usa um caractere curinga (`cloudformation*`) para provisionar a CloudFormation pilha, mas com recursos restritos ao prefixo. `tenant-cluster` + Este exemplo de código docker usa `--platform=linux/amd64` para forçar imagens baseadas em `linux/amd64`. Isso é para garantir que os artefatos finais da imagem sejam adequados para o Lambda que, por padrão, usa a arquitetura x86-64. Se você precisar alterar a arquitetura Lambda de destino, certifique-se de alterar os códigos do Dockerfiles e do AWS CDK. Para obter mais informações, consulte a publicação do blog [Migrar funções do Lambda AWS para processadores AWS Graviton2 baseados em ARM](https://aws.amazon.com/blogs/compute/migrating-aws-lambda-functions-to-arm-based-aws-graviton2-processors/). + O processo de exclusão da pilha não limpará CloudWatch os registros (grupos de registros e registros) gerados pela pilha. Você deve limpar manualmente os registros por meio do AWS Management Console, CloudWatch console da Amazon ou por meio da API. Esse padrão é configurado como exemplo. Para uso em produção, avalie as seguintes configurações e faça alterações com base nos requisitos da sua empresa: + O bucket do [AWS Simple Storage Service (Amazon S3)](https://aws.amazon.com/s3/) neste exemplo não tem o versionamento habilitado para simplificar. Avalie e atualize a configuração conforme necessário. + Este exemplo configura os endpoints da API REST do [Amazon API Gateway](https://aws.amazon.com/api-gateway/) sem autenticação, autorização ou controle de utilização para simplificar. Para uso em produção, recomendamos integrar o sistema à infraestrutura de segurança da empresa. Avalie essa configuração e adicione as configurações de segurança exigidas conforme necessário. + Para este exemplo de infraestrutura de locatários, o [Amazon Simple Notification Service (Amazon SNS)](https://aws.amazon.com/sns/) e o [Amazon Simple Queue Service (Amazon SQS) têm apenas configurações mínimas](https://aws.amazon.com/sqs/). [O [AWS Key Management Service (AWS KMS)](https://aws.amazon.com/kms/) de cada locatário abre os serviços da Amazon e do [Amazon CloudWatch](https://aws.amazon.com/cloudwatch/) SNS na conta para consumo com base na política de chaves do AWS KMS.](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-key-management.html#compatibility-with-aws-services) A configuração é apenas um exemplo de espaço reservado. Ajuste as configurações conforme necessário com base no seu caso de uso de negócios. + Toda a configuração, que inclui, mas não se limita a endpoints de API e inquilinos de back-end, provisionamento e exclusão usando a AWS CloudFormation, abrange apenas o caso básico do Happy Path. Avalie e atualize a configuração com a lógica de repetição necessária, a lógica adicional de tratamento de erros e a lógica de segurança com base nas necessidades de sua empresa. + O código de exemplo é testado com up-to-date [cdk-nag](https://github.com/cdklabs/cdk-nag) para verificar as políticas no momento da redação deste artigo. Novas políticas podem ser aplicadas no futuro. Essas novas políticas podem exigir que você modifique manualmente a pilha com base nas recomendações antes que a pilha possa ser implantada. Revise o código existente para garantir que ele esteja alinhado aos requisitos da sua empresa. + O código depende do AWS CDK para gerar um sufixo aleatório em vez de depender de nomes físicos atribuídos estáticos para a maioria dos recursos criados. Essa configuração é para garantir que esses recursos sejam exclusivos e não entrem em conflito com outras pilhas. Para obter mais informações, consulte a [documentação do AWS CDK](https://docs.aws.amazon.com/cdk/v2/guide/resources.html#resources_physical_names). Ajuste isso com base nos requisitos da sua empresa. + Este código de exemplo empacota artefatos do.NET Lambda em imagens baseadas em Docker e é executado com o [Runtime de imagem de contêiner](https://docs.aws.amazon.com/lambda/latest/dg/csharp-image.html) fornecido pelo Lambda. O runtime da imagem do contêiner tem vantagens para mecanismos padrão de transferência e armazenamento (registros de contêiner) e ambientes de teste locais mais precisos (por meio da imagem do contêiner). Você pode mudar o projeto para usar os [.NET runtimes fornecidos pelo Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-csharp.html) para reduzir o tempo de criação das imagens do Docker, mas precisará configurar mecanismos de transferência e armazenamento e garantir que a configuração local corresponda à configuração do Lambda. Ajuste o código de acordo com os requisitos comerciais dos usuários. **Versões do produto** + AWS CDK versão 2.45.0 ou superior + Visual Studio 2022 ## Arquitetura **Pilha de tecnologia** + Amazon API Gateway + AWS CloudFormation + Amazon CloudWatch + Amazon DynamoDB + AWS Identity and Access Management (IAM) + AWS KMS + AWS Lambda + Amazon S3 + Amazon SNS + Amazon SQS **Arquitetura** O diagrama a seguir mostra o fluxo de criação da pilha de locatários. Para obter mais informações sobre o ambiente de gerenciamento e as pilhas de tecnologia do locatário, consulte a seção *Informações adicionais*. ![\[Fluxo de trabalho para criar um locatário e provisionar uma infraestrutura básica para o locatário na AWS.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/5baef800-fe39-4eb8-b11d-2c23eb3175fc/images/0b579484-b87c-4acb-8c60-8c33c18370e3.png) **Fluxo de criação da pilha de locatários** 1. O usuário envia uma solicitação da API POST com a nova carga útil do locatário (nome do locatário, descrição do locatário) em JSON para uma API REST hospedada pelo Amazon API Gateway. O API Gateway processa a solicitação e a encaminha para a função de backend do Lambda Tenant Onboarding. Neste exemplo, não há autorização nem autenticação. Em uma configuração de produção, essa API deve ser integrada ao sistema de segurança da infraestrutura SaaS. 1. A função de integração do locatário verifica a solicitação. Em seguida, ele tenta armazenar o registro do locatário, que inclui o nome do locatário, o identificador único universal (UUID) gerado e a descrição do locatário, na tabela de integração de locatários do Amazon DynamoDB.  1. Depois que o DynamoDB armazena o registro, um stream do DynamoDB inicia a função downstream da Lambda Tenant Infrastructure. 1. A função do Lambda Tenant Infrastructure atua com base no stream recebido do DynamoDB. Se o stream for para o evento INSERT, a função usa a NewImage seção do stream (registro de atualização mais recente, campo Nome do inquilino) para invocar CloudFormation a criação de uma nova infraestrutura de locatário usando o modelo armazenado no bucket do S3. O CloudFormation modelo exige o parâmetro Nome do inquilino.  1. CloudFormation A AWS cria a infraestrutura do locatário com base no CloudFormation modelo e nos parâmetros de entrada. 1. Cada configuração de infraestrutura do inquilino tem um CloudWatch alarme, um alarme de cobrança e um evento de alarme. 1. O evento de alarme se torna uma mensagem para um tópico do SNS, que é criptografado pela chave do AWS KMS do locatário. 1. O tópico do SNS encaminha a mensagem de alarme recebida para a fila do SQS, que é criptografada pelo AWS KMS do locatário para a chave de criptografia. Outros sistemas podem ser integrados ao Amazon SQS para realizar ações com base nas mensagens na fila. Neste exemplo, para manter o código genérico, as mensagens recebidas permanecem na fila e exigem exclusão manual. **Fluxo de exclusão da pilha de locatários** 1. O usuário envia uma solicitação da API DELETE com a nova carga útil do locatário (nome do locatário, descrição do locatário) em JSON para a API REST hospedada pelo Amazon API Gateway, que processará a solicitação e encaminhará para a função de integração do locatário. Neste exemplo, não há autorização nem autenticação. Em uma configuração de produção, essa API será integrada ao sistema de segurança da infraestrutura SaaS. 1. A função de integração do locatário verificará a solicitação e, em seguida, tentará excluir o registro do locatário (nome do locatário) da tabela de integração do locatário.  1. Depois que o DynamoDB exclui o registro com sucesso (o registro existe na tabela e é excluído), um stream do DynamoDB inicia a função downstream do Lambda Tenant Infrastructure. 1. A função do Lambda Tenant Infrastructure atua com base no registro de stream recebido do DynamoDB. Se o stream for para o evento REMOVE, a função usa a OldImage seção do registro (informações do registro e campo Nome do inquilino, antes da última alteração, que é exclusão) para iniciar a exclusão de uma pilha existente com base nas informações desse registro. 1. A AWS CloudFormation exclui a pilha de inquilinos de destino de acordo com a entrada. ## Ferramentas **Serviços da AWS** + [O Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/welcome.html) ajuda você a criar, publicar, manter, monitorar e proteger REST, HTTP e WebSocket APIs em qualquer escala. + O [AWS Cloud Development Kit (AWS CDK)](https://docs.aws.amazon.com/cdk/v2/guide/home.html) é uma estrutura de desenvolvimento de software que ajuda você a definir e provisionar a infraestrutura da Nuvem AWS em código. + O [AWS CDK Toolkit](https://docs.aws.amazon.com/cdk/v2/guide/cli.html) é um kit de desenvolvimento de nuvem de linha de comando que ajuda você a interagir com seu aplicativo AWS Cloud Development Kit (AWS CDK). + A [AWS Command Line Interface (AWS CLI)](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) é uma ferramenta de código aberto que permite que você interaja com serviços da AWS usando comandos no shell da linha de comando. + CloudFormationA [AWS](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html) ajuda você a configurar recursos da AWS, provisioná-los de forma rápida e consistente e gerenciá-los durante todo o ciclo de vida em todas as contas e regiões da AWS. + O [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) é um serviço de banco de dados NoSQL totalmente gerenciado que fornece performance rápida, previsível e escalável. + O [AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) ajuda você a gerenciar com segurança o acesso aos seus recursos da AWS, controlando quem está autenticado e autorizado a usá-los. + O [AWS Key Management Service (AWS KMS) ](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html)ajuda você a criar e controlar chaves criptográficas para proteger seus dados. + O [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) é um serviço de computação que ajuda você a executar código sem exigir provisionamento ou gerenciamento de servidores. Ele executa o código somente quando necessário e dimensiona automaticamente, assim, você paga apenas pelo tempo de computação usado. + O [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) é um serviço de armazenamento de objetos baseado na nuvem que ajuda você a armazenar, proteger e recuperar qualquer quantidade de dados. + O [Amazon Simple Notification Service (Amazon SNS)](https://docs.aws.amazon.com/sns/latest/dg/welcome.html) ajuda você a coordenar e gerenciar a troca de mensagens entre publicadores e clientes, incluindo servidores web e endereços de e-mail. + O [Amazon Simple Queue Service (Amazon SQS)](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/welcome.html) oferece uma fila hospedada segura, durável e disponível que permite integrar e desacoplar sistemas de software e componentes distribuídos. + [O AWS Toolkit for Visual Studio](https://docs.aws.amazon.com/toolkit-for-visual-studio/latest/user-guide/welcome.html) é um plug-in para o ambiente de desenvolvimento integrado (IDE) do Visual Studio. O Toolkit for Visual Studio oferece suporte ao desenvolvimento, depuração e implantação de aplicativos.NET que usam serviços da AWS. **Outras ferramentas** + O [Visual Studio](https://docs.microsoft.com/en-us/visualstudio/ide/whats-new-visual-studio-2022?view=vs-2022) é um IDE que inclui compiladores, ferramentas de preenchimento de código, designers gráficos e outros atributos que oferecem suporte ao desenvolvimento de software. **Código ** O código desse padrão está no repositório de [exemplos de integração de locatários na arquitetura SaaS para modelo de silo do APG](https://github.com/aws-samples/tenant-onboarding-in-saas-architecture-for-silo-model-apg-example). ## Épicos ### Configurar o AWS CDK | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Verifique a instalação do Node.js. | Para verificar se o Node.js está instalado em sua máquina local, execute o comando a seguir.
node --version
| Administrador da AWS, AWS DevOps | | Instale o AWS CDK Toolkit. | Para instalar o AWS CDK Toolkit em sua máquina local, execute o comando a seguir.
npm install -g aws-cdk
Se o npm não estiver instalado, você poderá instalá-lo no [site Node.js](https://nodejs.org/en/download/package-manager/). | Administrador da AWS, AWS DevOps | | Verifique a versão do AWS CDK Toolkit. | Para verificar se a versão do AWS CDK Toolkit está instalada corretamente em sua máquina, execute o comando a seguir.  
cdk --version
| Administrador da AWS, AWS DevOps | ### Revise o código do ambiente de gerenciamento de integração do locatário | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Clonar o repositório. | Clone o [repositório](https://github.com/aws-samples/tenant-onboarding-in-saas-architecture-for-silo-model-apg-example) e navegue até a pasta `\tenant-onboarding-in-saas-architecture-for-silo-model-apg-example`.Abra a `\src\TenantOnboardingInfra.sln` solução no Visual Studio 2022. Abra o arquivo `TenantOnboardingInfraStack.cs` e revise o código.Os seguintes recursos são criados como parte dessa pilha:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/tenant-onboarding-in-saas-architecture-for-the-silo-model-using-c-and-aws-cdk.html) | Administrador da AWS, AWS DevOps | | Revise o CloudFormation modelo. | Na `\tenant-onboarding-in-saas-architecture-for-silo-model-apg-example\template` pasta`infra.yaml`, abra e revise o CloudFormation modelo. Esse modelo será hidratado com o nome do locatário recuperado da tabela de integração do locatário do DynamoDB.O modelo fornece a infraestrutura específica do locatário. Neste exemplo, ele provisiona a chave do AWS KMS, o Amazon SNS, o Amazon SQS e o alarme. CloudWatch | Desenvolvedor de aplicativos, AWS DevOps | | Analise a função de integração do locatário. | Abra `Function.cs` e revise o código da função de integração do locatário, que é criada com o modelo do Projeto AWS Lambda do Visual Studio (.NET Core- C\$1) com o blueprint .NET 6 (Contêiner Image).Abra o `Dockerfile` arquivo e revise o código. `Dockerfile` é um arquivo de texto que consiste em instruções para criar a imagem do contêiner Lambda.Observe que os seguintes NuGet pacotes foram adicionados como dependências ao `TenantOnboardingFunction` projeto:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/tenant-onboarding-in-saas-architecture-for-the-silo-model-using-c-and-aws-cdk.html) | Desenvolvedor de aplicativos, AWS DevOps | | Revise a InfraProvisioning função de inquilino. | Acesse `\tenant-onboarding-in-saas-architecture-for-silo-model-apg-example\src\InfraProvisioningFunction`.Abra `Function.cs` e revise o código da função de integração do locatário, que é criada com o modelo do Projeto AWS Lambda do Visual Studio (.NET Core- C\$1) com o esquema .NET 6 (Contêiner Image).Abra o `Dockerfile` arquivo e revise o código. Observe que os seguintes NuGet pacotes foram adicionados como dependências ao `InfraProvisioningFunction` projeto:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/tenant-onboarding-in-saas-architecture-for-the-silo-model-using-c-and-aws-cdk.html) | Desenvolvedor de aplicativos, AWS DevOps | ### Implantar os recursos da AWS | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Crie a solução. | Para criar a solução, siga estas etapas:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/tenant-onboarding-in-saas-architecture-for-the-silo-model-using-c-and-aws-cdk.html)Certifique-se de atualizar o pacote `Amazon.CDK.Lib NuGet` para a versão mais recente do projeto `\tenant-onboarding-in-saas-architecture-for-silo-model-apg-example\src\TenantOnboardingInfra` antes de criar a solução. | Desenvolvedor de aplicativos | | Faça o bootstrap do ambiente do AWS CDK. | Abra o prompt de comando do Windows e navegue até a pasta raiz do aplicativo AWS CDK em que o arquivo `cdk.json` está disponível (`\tenant-onboarding-in-saas-architecture-for-silo-model-apg-example`). Execute o comando a seguir para inicializar.
cdk bootstrap
Se você criou um perfil da AWS para as credenciais, use o comando com seu perfil.
cdk bootstrap --profile
| Administrador da AWS, AWS DevOps | | Liste as pilhas do AWS CDK. | Para listar todas as pilhas a serem criadas como parte desse projeto, execute o comando a seguir.
cdk ls
cdk ls --profile
Se você criou um perfil da AWS para as credenciais, use o comando com seu perfil.
cdk ls --profile
| Administrador da AWS, AWS DevOps | | Analise quais recursos da AWS serão criados. | Para analisar todos os recursos da AWS que serão criados como parte desse projeto, execute o comando a seguir.
cdk diff
Se você criou um perfil da AWS para as credenciais, use o comando com seu perfil.
cdk diff --profile
| Administrador da AWS, AWS DevOps | | Implante todos os recursos da AWS usando o AWS CDK. | Para implantar todos os recursos da AWS, execute o seguinte comando.
cdk deploy --all --require-approval never
Se você criou um perfil da AWS para as credenciais, use o comando com seu perfil.
cdk deploy --all --require-approval never --profile
Depois que a implantação for concluída, copie a URL da API da seção de saídas no prompt de comando, que é mostrada no exemplo a seguir.
Outputs:
TenantOnboardingInfraStack.TenantOnboardingAPIEndpoint42E526D7 = https://j2qmp8ds21i1i.execute-api.us-west-2.amazonaws.com/prod/
| Administrador da AWS, AWS DevOps | ### Verificação de funcionalidade | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Criar um novo locatário. | Para criar o novo locatário, envie a seguinte solicitação curl.
curl -X POST tenant -d '{"Name":"Tenant123", "Description":"Stack for Tenant123"}'
Altere o espaço reservado `` para o valor real do AWS CDK, conforme mostrado no exemplo a seguir.
curl -X POST https://j2qmp8ds21i1i.execute-api.us-west-2.amazonaws.com/prod/tenant -d '{"Name":"Tenant123", "Description":"test12"}'
O exemplo a seguir mostra a saída.
{"message": "A new tenant added - 5/4/2022 7:11:30 AM"}
| Desenvolvedor de aplicativos, administrador da AWS, AWS DevOps | | Verifique os detalhes do locatário recém-criado no DynamoDB. | Para verificar os detalhes do locatário recém-criado no DynamoDB, execute as etapas a seguir.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/tenant-onboarding-in-saas-architecture-for-the-silo-model-using-c-and-aws-cdk.html) | Desenvolvedor de aplicativos, administrador da AWS, AWS DevOps | | Verifique a criação da pilha para o novo locatário. | Verifique se a nova pilha foi criada e provisionada com sucesso com a infraestrutura para o inquilino recém-criado, de acordo com o modelo. CloudFormation [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/tenant-onboarding-in-saas-architecture-for-the-silo-model-using-c-and-aws-cdk.html) | Desenvolvedor de aplicativos, administrador da AWS, AWS DevOps | | Exclua a pilha de locatários. | Para excluir a pilha de locatários, envie a seguinte solicitação curl.
curl -X DELETE tenant/
Altere o espaço reservado `` para o valor real do AWS CDK e altere `` para o valor real da etapa anterior de criação do locatário, conforme mostrado no exemplo a seguir.
curl -X DELETE https://j2qmp8ds21i1i.execute-api.us-west-2.amazonaws.com/prod/tenant/Tenant123
O exemplo a seguir mostra a saída.
{"message": "Tenant destroyed - 5/4/2022 7:14:48 AM"}
| Desenvolvedor de aplicativos, AWS DevOps, administrador da AWS | | Verifique a exclusão da pilha para o locatário existente. | Para verificar se a pilha de locatários existente foi excluída, execute as etapas a seguir:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/tenant-onboarding-in-saas-architecture-for-the-silo-model-using-c-and-aws-cdk.html) | Desenvolvedor de aplicativos, administrador da AWS, AWS DevOps | ### Limpeza | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Destruir o ambiente. | Antes da limpeza da pilha, certifique-se do seguinte:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/tenant-onboarding-in-saas-architecture-for-the-silo-model-using-c-and-aws-cdk.html)Após a conclusão do teste, o AWS CDK pode ser usado para destruir todas as pilhas e recursos relacionados executando o comando a seguir.
cdk destroy --all;
Se você criou um perfil da AWS para as credenciais, use o perfil.Confirme o prompt de exclusão da pilha para excluir a pilha. | Administrador da AWS, AWS DevOps | | Limpe os Amazon CloudWatch Logs. | O processo de exclusão da pilha não limpará CloudWatch os registros (grupos de registros e registros) que foram gerados pela pilha. Limpe manualmente os CloudWatch recursos usando o CloudWatch console ou a API. | Desenvolvedor de aplicativos, AWS DevOps, administrador da AWS | ## Recursos relacionados + [Workshop sobre o AWS CDK.NET](https://cdkworkshop.com/40-dotnet.html) + [Trabalhar com o AWS CDK em C\$1](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-csharp.html) + [Referência do CDK.NET](https://docs.aws.amazon.com/cdk/api/v2/dotnet/api/index.html) ## Mais informações **Pilha de tecnologias de ambiente de gerenciamento** O código CDK escrito em.NET é usado para provisionar a infraestrutura do plano de controle, que consiste nos seguintes recursos: 1. **API Gateway** Serve como ponto de entrada da API REST para a pilha do plano de controle. 1. **Função do Lambda de integração do locatário** Essa função do Lambda é iniciada pelo API Gateway usando o método m. Uma solicitação de API do método POST resulta na inserção (`tenant name`,`tenant description`) na tabela `Tenant Onboarding` do DynamoDB. Neste exemplo de código, o nome do locatário também é usado como parte do nome da pilha do locatário e dos nomes dos recursos dentro dessa pilha. Isso é para facilitar a identificação desses recursos. Esse nome de locatário deve ser exclusivo em toda a configuração para evitar conflitos ou erros. A configuração detalhada da validação de entrada é explicada na documentação dos [perfis do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) e na seção *Limitações*. O processo de persistência na tabela do DynamoDB só será bem-sucedido se o nome do locatário não for usado em nenhum outro registro na tabela. O nome do locatário nesse caso é a chave de partição dessa tabela, pois somente a chave de partição pode ser usada como uma expressão da condição `PutItem`. Se o nome do locatário nunca tiver sido registrado antes, o registro será salvo na tabela com sucesso. No entanto, se o nome do locatário já for usado por um registro existente na tabela, a operação falhará e iniciará uma exceção do DynamoDB. `ConditionalCheckFailedException` A exceção será usada para retornar uma mensagem de falha (`HTTP BadRequest`) indicando que o nome do locatário já existe. Uma solicitação de API de método de `DELETE` removerá o registro de um nome de locatário específico da tabela `Tenant Onboardin` g. A exclusão do registro do DynamoDB neste exemplo será bem-sucedida mesmo que o registro não exista. Se o registro de destino existir e for excluído, ele criará um registro de stream do DynamoDB. Caso contrário, nenhum registro downstream será criado. 1. **Integração de locatários no DynamoDB, com o Amazon DynamoDB Streams habilitado** Isso registra as informações de metadados do locatário, e qualquer registro salvo ou excluído enviará um stream downstream para a `Tenant Infrastructure` função do Lambda.  1. A **Função do Lambda da infraestrutura do locatário** Essa função do Lambda é iniciada pelo registro de stream do DynamoDB da etapa anterior. Se o registro for de um `INSERT` evento, ele invoca CloudFormation a AWS para criar uma nova infraestrutura de locatários com o CloudFormation modelo armazenado em um bucket do S3. Se o registro for para `REMOVE`, ele iniciará a exclusão de uma pilha existente com base no campo do registro do stream `Tenant Name`. 1. **Bucket do S3** Isso é para armazenar o CloudFormation modelo. 1. **Funções do IAM para cada função do Lambda e uma função de serviço para CloudFormation** Cada função do Lambda tem seu perfil exclusivo do IAM com permissões de [privilégio mínimo para realizar](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege) sua tarefa. Por exemplo, a função `Tenant On-boarding` Lambda tem read/write acesso ao DynamoDB, e a função `Tenant Infrastructure` Lambda só pode ler o stream do DynamoDB. Uma função CloudFormation de serviço personalizada é criada para o provisionamento da pilha de inquilinos. Essa função de serviço contém permissões adicionais para provisionamento de CloudFormation pilhas (por exemplo, a chave AWS KMS). Isso divide as funções entre o Lambda CloudFormation e evita todas as permissões em uma única função (função do Lambda de infraestrutura). As permissões que permitem ações poderosas (como criar e excluir CloudFormation pilhas) são bloqueadas e permitidas somente em recursos que começam com. `tenantcluster-` A exceção é o AWS KMS, devido à sua convenção de nomenclatura de recursos. O nome do locatário ingerido pela API será anexado ao `tenantcluster-`, junto com outras verificações de validação (alfanumérico somente com hífen e limitado a menos de 30 caracteres para caber na maioria dos nomes de recursos da AWS). Isso garante que o nome do locatário não resulte acidentalmente na interrupção das pilhas ou dos recursos da infraestrutura principal. **Pilha de tecnologia para locatários** Um CloudFormation modelo é armazenado no bucket do S3. [O modelo provisiona a chave AWS KMS específica do inquilino, um CloudWatch alarme, um tópico do SNS, uma fila do SQS e uma política do SQS.](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-using-identity-based-policies.html) A chave do AWS KMS é usada para criptografia de dados pelo Amazon SNS e pelo Amazon SQS para suas mensagens. As práticas de segurança para [AwsSolutions— SNS2 e AwsSolutions — SQS2](https://github.com/cdklabs/cdk-nag/blob/main/RULES.md) recomendam que você configure o Amazon SNS e o Amazon SQS com criptografia. No entanto, CloudWatch os alarmes não funcionam com o Amazon SNS ao usar uma chave gerenciada pela AWS, então você deve usar uma chave gerenciada pelo cliente nesse caso. Para obter mais informações, consulte o [Centro de Conhecimentos da AWS](https://aws.amazon.com/premiumsupport/knowledge-center/cloudwatch-receive-sns-for-alarm-trigger/). A política do SQS é usada na fila do Amazon SQS para permitir que o tópico SNS criado entregue a mensagem à fila. Sem a política do SQS, o acesso será negado. Para obter mais informações, consulte a [documentação do Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/subscribe-sqs-queue-to-sns-topic.html#SendMessageToSQS.sqs.permissions). # Decomponha monólitos em microsserviços usando o CQRS e o fornecimento de eventos *Rodolfo Jr. Cerrada, Dmitry Gulin e Tabby Ward, Amazon Web Services* ## Resumo Esse padrão combina dois padrões, usando o padrão de separação de responsabilidade por consulta de comando (CQRS) e o padrão de fornecimento de eventos. O padrão CQRS separa as responsabilidades dos modelos de comando e consulta. O padrão de fornecimento de eventos aproveita a comunicação assíncrona orientada por eventos para melhorar a experiência geral do usuário. Você pode usar os serviços CQRS e Amazon Web Services (AWS) para manter e escalar cada modelo de dados de forma independente enquanto refatora seu aplicativo monolítico em arquitetura de microsserviços. Em seguida, você pode usar o padrão de fornecimento de eventos para sincronizar dados do banco de dados de comandos com o banco de dados de consulta. Esse padrão usa um código de exemplo que inclui um arquivo de solução (\$1.sln) que você pode abrir usando a versão mais recente do Visual Studio. O exemplo contém o código da API Reward para mostrar como o CQRS e o fornecimento de eventos funcionam em aplicativos com tecnologia sem servidor e sem servidor, tradicionais ou on-premises da AWS. Para saber mais sobre o CQRS e o fornecimento de eventos, consulte a seção [Informações adicionais](#decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing-additional). ## Pré-requisitos e limitações **Pré-requisitos ** + Uma conta AWS ativa + Amazon CloudWatch + Tabelas do Amazon DynamoDB + Amazon DynamoDB Streams + Chave de acesso e chave secreta do AWS Identity and Access Management (IAM); para obter mais informações, acesse o vídeo na seção *Recursos relacionados* + AWS Lambda + Familiaridade com o Visual Studio + *Familiaridade com o AWS Toolkit for Visual Studio; para obter mais informações, consulte *o vídeo de demonstração do AWS Toolkit for Visual Studio* na seção Recursos relacionados* **Versões do produto** + [Visual Studio 2019 Community Edition](https://visualstudio.microsoft.com/downloads/). + [AWS Toolkit for Visual Studio 2019](https://aws.amazon.com/visualstudio/). + .NET Core 3.1 Esse componente é uma opção na instalação do Visual Studio. Para incluir o .NET Core durante a instalação, selecione **Desenvolvimento multiplataforma NET Core**. **Limitações** + O código de exemplo para um aplicativo on-premises tradicional (ASP.NET Core Web API e objetos de acesso a dados) não vem com um banco de dados. No entanto, ele vem com o objeto `CustomerData` na memória, que atua como um banco de dados simulado. O código fornecido é suficiente para você testar o padrão. ## Arquitetura **Pilha de tecnologia de origem** + Projeto de API Web do ASP.NET Core + Servidor Web IIS + Objeto de acesso a dados + Modelo CRUD **Arquitetura de origem** Na arquitetura de origem, o modelo CRUD contém interfaces de comando e consulta em um aplicativo. Por exemplo, código, consulte `CustomerDAO.cs` (em anexo). ![\[Conexões entre aplicação, interface de serviço, modelo CRUD do cliente e banco de dados.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/9f1bc700-def4-4201-bb2d-f1fa27404f15/images/1cd3a84c-12c7-4306-99aa-23f2c53d3cd3.png) **Pilha de tecnologias de destino** + Amazon DynamoDB + Amazon DynamoDB Streams + AWS Lambda + Amazon API Gateway + (Opcional) Amazon Simple Notification Service (Amazon SNS) **Arquitetura de destino** Na arquitetura de destino, as interfaces de comando e consulta são separadas. A arquitetura mostrada no diagrama a seguir pode ser estendida com o API Gateway e o Amazon SNS. Para obter mais informações, consulte a seção [Informações adicionais](#decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing-additional). ![\[Aplicação conectada aos microsserviços Customer Command e Customer Query sem servidor.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/9f1bc700-def4-4201-bb2d-f1fa27404f15/images/1c665697-e3ac-4ef4-98d0-86c2cbf164c1.png) 1. As funções de comando do Lambda realizam operações de gravação, como criar, atualizar ou excluir, no banco de dados. 1. As funções de consulta do Lambda realizam operações de leitura, como obter ou selecionar, no banco de dados. 1. Essa função do Lambda processa os fluxos do DynamoDB do banco de dados Comando e atualiza o banco de dados Consulta para as alterações. ## Ferramentas **Ferramentas** + [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html): o Amazon DynamoDB é um serviço de banco de dados NoSQL totalmente gerenciado que fornece uma performance rápida e previsível com escalabilidade integrada. + [Amazon DynamoDB Streams](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Streams.html): o Amazon DynamoDB Streams captura uma sequência em ordem temporal de modificações em nível de item em qualquer tabela do Amazon DynamoDB. Esse serviço, então, armazena essas informações em um log por até 24 horas. A criptografia em repouso criptografa os dados em fluxos do DynamoDB. + [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html): o AWS Lambda é um serviço de computação que permite a execução do código sem provisionar ou gerenciar servidores O Lambda executa o código somente quando necessário e dimensiona automaticamente, desde algumas solicitações por dia até milhares por segundo. Você paga apenas pelo tempo de computação consumido. Não haverá cobranças quando o código não estiver em execução. + [Console de Gerenciamento da AWS](https://docs.aws.amazon.com/awsconsolehelpdocs/latest/gsg/learn-whats-new.html): o Console de Gerenciamento da AWS é uma aplicação web que compreende uma ampla coleção de consoles de serviço para gerenciar serviços da AWS. + [Visual Studio 2019 Community Edition](https://visualstudio.microsoft.com/downloads/): o Visual Studio 2019 é um ambiente de desenvolvimento integrado (IDE). A Community Edition é gratuita para colaboradores de código aberto. Nesse padrão, você usará o Visual Studio 2019 Community Edition para abrir, compilar e executar código de exemplo. Somente para visualização, você pode usar qualquer editor de texto ou o [Visual Studio Code](https://docs.aws.amazon.com/toolkit-for-vscode/latest/userguide/welcome.html). + [AWS Toolkit for Visual Studio](https://docs.aws.amazon.com/toolkit-for-visual-studio/latest/user-guide/welcome.html): o AWS Toolkit for Visual Studio é um plug-in para o Visual Studio IDE. O AWS Toolkit for Visual Studio facilita o desenvolvimento, a depuração e a implantação de aplicativos .NET que usam os serviços AWS. **Código ** O código de exemplo está anexado. Para obter instruções sobre como implantar o código de exemplo, consulte a seção *Épicos*. ## Épicos ### Abra e crie a solução | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Abra a solução. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html) | Desenvolvedor de aplicativos | | Crie a solução. | Abra o menu de contexto (clique com o botão direito do mouse) da solução e selecione **Criar soluções**. Isso criará e compilará todos os projetos na solução. Ele deve ser compilado com sucesso.O Visual Studio Solution Explorer deve mostrar a estrutura de diretórios.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html) | Desenvolvedor de aplicativos | ### Crie as tabelas do DynamoDB | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Forneça credenciais | Se você ainda não tem uma chave de acesso, assista ao vídeo na seção *Recursos relacionados*.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html) | Desenvolvedor de aplicativos, engenheiro de dados, DBA | | Crie o projeto. | **Para criar o projeto, abra o menu de contexto (clique com o botão direito do mouse) para o projeto **AwS.APG.CQRSES.Build** e selecione Construir**. | Desenvolvedor de aplicativos, engenheiro de dados, DBA | | Crie e preencha as tabelas. | Para criar as tabelas e preenchê-las com dados iniciais, abra o menu de contexto (clique com o botão direito do mouse) para o projeto **AwS.APG.CQRSES.Build** e então escolha **Depurar**,** Iniciar nova instância**. | Desenvolvedor de aplicativos, engenheiro de dados, DBA | | Verifique a construção da tabela e os dados. | Para verificar, navegue até o **AWS Explorer** e expanda o **Amazon DynamoDB**. Ele deve exibir as tabelas. Abra cada tabela para exibir os dados de exemplo. | Desenvolvedor de aplicativos, engenheiro de dados, DBA | ### Execute testes locais | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Crie o projeto do CQRS. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html) | Desenvolvedor de aplicativos, engenheiro de testes | | Crie o projeto de fornecimento de eventos. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html) | Desenvolvedor de aplicativos, engenheiro de testes | | Execute os testes. | Para executar todos os testes, escolha **Exibir**, **Explorador de testes** e, em seguida, escolha **Executar todos os testes na exibição**. Todos os testes devem ser aprovados, o que é indicado por um ícone de marca de seleção verde.  | Desenvolvedor de aplicativos, engenheiro de testes | ### Publique as funções do CQRS Lambda na AWS | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Publique a primeira função do Lambda. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html) | Desenvolvedor de aplicativos, DevOps engenheiro | | Verifique o upload da função. | (Opcional) Você pode verificar se a função foi carregada com sucesso navegando até o AWS Explorer e expandindo o **AWS Lambda**. Para abrir a janela de teste, escolha a função do Lambda (clique duas vezes). | Desenvolvedor de aplicativos, DevOps engenheiro | | Testar a função do Lambda. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html)Todos os projetos Lambda do CQRS são encontrados nas pastas de soluções `CQRS AWS Serverless\CQRS\Command Microservice` e ` CQRS AWS Serverless\CQRS\Command Microservice`. Para o diretório da solução e os projetos, consulte **Diretório de código-fonte** na seção [Informações adicionais](#decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing-additional). | Desenvolvedor de aplicativos, DevOps engenheiro | | Publique as funções restantes. | Repita as etapas anteriores para os seguintes projetos:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html) | Desenvolvedor de aplicativos, DevOps engenheiro | ### Configure a função do Lambda como um receptor de evento | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Publique os manipuladores de eventos Cliente and Recompensa do Lambda. | Para publicar cada manipulador de eventos, siga as etapas do épico anterior.Os projetos estão sob as pastas de soluções `CQRS AWS Serverless\Event Source\Customer Event` e `CQRS AWS Serverless\Event Source\Reward Event`. Para obter mais informações, consulte *Diretório de código-fonte* na seção [Informações adicionais](#decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing-additional). | Desenvolvedor de aplicativos | | Anexe o receptor de eventos Lambda de fornecimento de eventos. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html)Depois que o receptor for anexado com sucesso à tabela do DynamoDB, ele será exibido na página do designer do Lambda. | Desenvolvedor de aplicativos | | Publique e anexe a EventSourceReward função Lambda. | Para publicar e anexar a função `EventSourceReward` Lambda, repita as etapas nas duas histórias anteriores, selecionando na lista suspensa **cqrses-reward-cmd**da tabela do **DynamoDB**. | Desenvolvedor de aplicativos | ### Teste e valide os fluxos do DynamoDB e o gatilho do Lambda | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Teste o fluxo e o acionador do Lambda. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html) | Desenvolvedor de aplicativos | | Valide usando a tabela de consulta de recompensas do DynamodDB. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html) | Desenvolvedor de aplicativos | | Valide usando CloudWatch Logs. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html) | Desenvolvedor de aplicativos | | Valide o EventSourceCustomer gatilho. | Para validar o `EventSourceCustomer` gatilho, repita as etapas desse épico, usando a respectiva tabela de clientes e CloudWatch registros do `EventSourceCustomer` gatilho. | Desenvolvedor de aplicativos | ## Recursos relacionados **Referências** + [Downloads do Visual Studio 2019 Community Edition](https://visualstudio.microsoft.com/downloads/) + [Download do AWS Toolkit for Visual Studio](https://aws.amazon.com/visualstudio/) + [Guia do usuário do AWS Toolkit for Visual Studio](https://docs.aws.amazon.com/toolkit-for-visual-studio/latest/user-guide/welcome.html) + [Tecnologia sem servidor na AWS](https://aws.amazon.com/serverless/) + [Casos de uso e padrões de design do DynamoDB](https://aws.amazon.com/blogs/database/dynamodb-streams-use-cases-and-design-patterns/) + [Martin Fowler CQRS](https://martinfowler.com/bliki/CQRS.html) + [Fornecimento de eventos de Martin Fowler](https://martinfowler.com/eaaDev/EventSourcing.html) **Vídeos** + [Demo do AWS Toolkit for Visual Studio](https://www.youtube.com/watch?v=B190tcu1ERk) + [Como faço para criar um ID de chave de acesso para um novo usuário do IAM?](https://www.youtube.com/watch?v=665RYobRJDY) ## Mais informações **CQRS e fornecimento de eventos** *CQRS* O padrão CQRS separa um único modelo de operações conceituais, como um único modelo CRUD (criar, ler, atualizar, excluir) de objeto de acesso a dados, em modelos de operações de comando e consulta. O modelo de comando se refere a qualquer operação, como criar, atualizar ou excluir, que altera o estado. O modelo de consulta se refere a qualquer operação que retorna um valor. ![\[Arquitetura com interface de serviço, modelo CRUD e banco de dados.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/9f1bc700-def4-4201-bb2d-f1fa27404f15/images/3f64756d-681e-4f0e-8034-746263d857b2.png) 1. O modelo Cliente CRUD inclui as seguintes interfaces: + `Create Customer()` + `UpdateCustomer()` + `DeleteCustomer()` + `AddPoints()` + `RedeemPoints()` + `GetVIPCustomers()` + `GetCustomerList()` + `GetCustomerPoints()` À medida que seus requisitos se tornam mais complexos, você pode abandonar essa abordagem de modelo único. O CQRS usa um modelo de comando e um modelo de consulta para separar a responsabilidade pela gravação e leitura de dados. Dessa forma, os dados podem ser mantidos e gerenciados de forma independente. Com uma separação clara de responsabilidades, os aprimoramentos em cada modelo não afetam o outro. Essa separação melhora a manutenção e o desempenho e reduz a complexidade do aplicativo à medida que ele cresce. ![\[O aplicativo se separou em modelos de comando e consulta, compartilhando um banco de dados único.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/9f1bc700-def4-4201-bb2d-f1fa27404f15/images/12db023c-eb81-4c27-bbb9-b085b13176ae.png) 1. Interfaces no modelo Comando do cliente: + `Create Customer()` + `UpdateCustomer()` + `DeleteCustomer()` + `AddPoints()` + `RedeemPoints()` 1. Interfaces no modelo Consulta do cliente: + `GetVIPCustomers()` + `GetCustomerList()` + `GetCustomerPoints()` + `GetMonthlyStatement()` Por exemplo de código, consulte *Diretório de código-fonte*. O padrão CQRS então separa o banco de dados. Essa dissociação leva à total independência de cada serviço, que é o principal ingrediente da arquitetura de microsserviços. ![\[Bancos de dados separados para modelos de comando e consulta.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/9f1bc700-def4-4201-bb2d-f1fa27404f15/images/016dbfa8-3bd8-42ee-afa1-38a98986c7d5.png) Usando o CQRS na Nuvem AWS, você pode otimizar ainda mais cada serviço. Por exemplo, você pode definir configurações de computação diferentes ou escolher entre um microsserviço com tecnologia sem servidor ou baseado em contêiner. Você pode substituir seu armazenamento em cache local pela Amazon. ElastiCache Se você tiver um sistema de publish/subscribe mensagens local, poderá substituí-lo pelo Amazon Simple Notification Service (Amazon SNS). Além disso, você pode aproveitar os pay-as-you-go preços e a grande variedade de serviços da AWS que você paga somente pelo que usa. O CQRS inclui os seguintes benefícios: + Escalabilidade independente: cada modelo pode ter sua estratégia de escalabilidade ajustada para atender aos requisitos e à demanda do serviço. Semelhante aos aplicativos de alto desempenho, a separação de leitura e gravação permite que o modelo seja dimensionado de forma independente para atender a cada demanda. Você também pode adicionar ou reduzir recursos computacionais para atender à demanda de escalabilidade de um modelo sem afetar o outro. + Manutenção independente: a separação dos modelos de consulta e comando melhora a capacidade de manutenção dos modelos. Você pode fazer alterações e aprimoramentos no código de um modelo sem afetar o outro. + Segurança: é mais fácil aplicar as permissões e políticas a modelos separados para leitura e gravação. + Leituras otimizadas: você pode definir um esquema otimizado para consultas. Por exemplo, você pode definir um esquema para os dados agregados e um esquema separado para as tabelas de fatos. + Integração: o CQRS se encaixa bem com modelos de programação baseados em eventos. + Complexidade gerenciada: a separação em modelos de consulta e comando é adequada para domínios complexos. Ao usar o CQRS, tenha em mente as seguintes advertências: + O padrão CQRS se aplica somente a uma parte específica de um aplicativo e não a todo o aplicativo. Se implementado em um domínio que não se encaixa no padrão, ele pode reduzir a produtividade, aumentar o risco e introduzir complexidade. + O padrão funciona melhor para modelos usados com frequência que têm operações de leitura e gravação desequilibradas. + Para aplicativos que exigem muita leitura, como relatórios grandes que demoram para serem processados, o CQRS oferece a opção de selecionar o banco de dados correto e criar um esquema para armazenar seus dados agregados. Isso melhora o tempo de resposta da leitura e visualização do relatório processando os dados do relatório apenas uma vez e despejando-os na tabela agregada. + Para aplicativos com muita gravação, você pode configurar o banco de dados para operações de gravação e permitir que o microsserviço de comando seja escalado de forma independente quando a demanda por gravação aumentar. Para ver exemplos, consulte os microsserviços `AWS.APG.CQRSES.CommandRedeemRewardLambda` e `AWS.APG.CQRSES.CommandAddRewardLambda`. *Origens de eventos* A próxima etapa é usar o fornecimento de eventos para sincronizar o banco de dados de consultas quando um comando é executado. Por exemplo, considere os seguintes eventos: + É adicionado um ponto de recompensa do cliente que exige que os pontos de recompensa totais ou agregados do cliente no banco de dados de consulta sejam atualizados. + O sobrenome do cliente é atualizado no banco de dados de comandos, o que exige que as informações do cliente substituto no banco de dados de consulta sejam atualizadas. No modelo CRUD tradicional, você garante a consistência dos dados bloqueando os dados até que a transação seja concluída. No fornecimento de eventos, os dados são sincronizados por meio da publicação de uma série de eventos que serão consumidos por um assinante para atualizar seus respectivos dados. O padrão de fornecimento de eventos garante e registra uma série completa de ações realizadas nos dados e os publica por meio de uma sequência de eventos. Esses eventos representam um conjunto de alterações nos dados que os assinantes desse evento devem processar para manter seus registros atualizados. Esses eventos são consumidos pelo assinante, sincronizando os dados no banco de dados do assinante. Nesse caso, esse é o banco de dados de consultas. O diagrama a seguir mostra o fornecimento de eventos usado com o CQRS na AWS. ![\[Arquitetura de microsserviços para o CQRS e padrões de fornecimento de eventos usando serviços com tecnologia sem servidor da AWS.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/9f1bc700-def4-4201-bb2d-f1fa27404f15/images/cc9bc84a-60b4-4459-9a5c-2334c69dbb4e.png) 1. As funções de comando do Lambda realizam operações de gravação, como criar, atualizar ou excluir, no banco de dados. 1. As funções de consulta do Lambda realizam operações de leitura, como obter ou selecionar, no banco de dados. 1. Essa função do Lambda processa os fluxos do DynamoDB do banco de dados Comando e atualiza o banco de dados Consulta para as alterações. Você também pode usar essa função para publicar uma mensagem no Amazon SNS para que seus assinantes possam processar os dados. 1. (Opcional) O assinante do evento Lambda processa a mensagem publicada pelo Amazon SNS e atualiza o banco de dados Consulta. 1. (Opcional) O Amazon SNS envia uma notificação por e-mail sobre a operação de gravação. Na AWS, o banco de dados de consultas pode ser sincronizado pelo DynamoDB Streams. O DynamoDB captura uma sequência em ordem temporal de modificações em nível de item em uma tabela do DynamoDB em tempo quase real e armazena de forma durável as informações em 24 horas. A ativação do DynamoDB Streams permite que o banco de dados publique uma sequência de eventos que possibilita o padrão de fornecimento de eventos. O padrão de fornecimento de eventos adiciona o assinante do evento. O aplicativo de assinante do evento consome o evento e o processa de acordo com a responsabilidade do assinante. No diagrama anterior, o assinante do evento envia as alterações para o banco de dados do Query DynamoDB para manter os dados sincronizados. O uso do Amazon SNS, do agente de mensagens e do aplicativo de assinante de eventos mantém a arquitetura desacoplada. O fornecimento de eventos inclui os seguintes benefícios: + Consistência para dados transacionais + Uma trilha de auditoria confiável e um histórico das ações, que podem ser usados para monitorar as ações realizadas nos dados + Permite que aplicativos distribuídos, como microsserviços, sincronizem seus dados em todo o ambiente + Publicação confiável de eventos sempre que o estado mudar + Reconstruindo ou reproduzindo estados passados + Entidades fracamente acopladas que trocam eventos para migração de um aplicativo monolítico para microsserviços + Redução de conflitos causados por atualizações simultâneas; o fornecimento de eventos evita a necessidade de atualizar objetos diretamente no armazenamento de dados + Flexibilidade e extensibilidade ao desacoplar a tarefa e o evento + Atualizações externas do sistema + Gerenciamento de várias tarefas em um único evento Ao usar o fornecimento de eventos, lembre-se das seguintes ressalvas: + Como há algum atraso na atualização dos dados entre os bancos de dados dos assinantes de origem, a única maneira de desfazer uma alteração é adicionar um evento compensador ao armazenamento de eventos. + A implementação do sourcing de eventos tem uma curva de aprendizado devido ao seu estilo diferente de programação. **Dados de teste** Use os dados de teste a seguir para testar a função do Lambda após a implantação bem-sucedida. **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** Insira a ID do cliente como dados da solicitação. Por exemplo, se a ID do cliente for 151, insira 151 como dados da solicitação. ``` 151 ``` **QueryCustomerList** Isso está branco. Quando for invocado, ele retornará todos os clientes. **CommandAddReward** Isso adicionará 40 pontos ao cliente com ID 1 (Richard). ``` { "Id":10101, "CustomerId":1, "Points":40 } ``` **CommandRedeemReward** Isso deduzirá 15 pontos para o cliente com ID 1 (Richard). ``` { "Id":10110, "CustomerId":1, "Points":15 } ``` **QueryReward** Insira o ID do cliente. Por exemplo, insira 1 para Richard, 2 para Arnav e 3 para Shirley. ``` 2 ``` **Diretório de código-fonte** Use a tabela a seguir como guia para a estrutura de diretórios da solução Visual Studio.  *Diretório de soluções de amostra de código on-premises do CQRS* ![\[Diretório de soluções com serviços de Command e Query expandidos.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/9f1bc700-def4-4201-bb2d-f1fa27404f15/images/4811c2c0-643b-410f-bb87-0b86ec5e194c.png) **Modelo CRUD do cliente** Exemplo do código on-premises CQRS\$1CRUD Model\$1Projeto AWS.APG.CQRSES.DAL **Versão CQRS do modelo Customer CRUD** + Comando do cliente: projeto `CQRS On-Premises Code Sample\CQRS Model\Command Microservice\AWS.APG.CQRSES.Command` + Consulta do cliente: projeto `CQRS On-Premises Code Sample\CQRS Model\Query Microservice\AWS.APG.CQRSES.Query` **Microsserviços de comando e consulta** O microsserviço de comando está na pasta da solução `CQRS On-Premises Code Sample\CQRS Model\Command Microservice`: + O projeto `AWS.APG.CQRSES.CommandMicroservice` ASP.NET Core API atua como o ponto de entrada onde os consumidores interagem com o serviço. + O projeto `AWS.APG.CQRSES.Command` .NET Core é um objeto que hospeda objetos e interfaces relacionados a comandos. O microsserviço de consulta está na pasta da solução `CQRS On-Premises Code Sample\CQRS Model\Query Microservice`: + O projeto `AWS.APG.CQRSES.QueryMicroservice` ASP.NET Core API atua como o ponto de entrada onde os consumidores interagem com o serviço. + O projeto `AWS.APG.CQRSES.Query` .NET Core é um objeto que hospeda objetos e interfaces relacionados a consultas. *Diretório de soluções de código da tecnologia sem servidor CQRS AWS* ![\[Diretório de soluções mostrando os microsserviços e a fonte de eventos expandidos.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/9f1bc700-def4-4201-bb2d-f1fa27404f15/images/23f8655c-95ad-422c-b20a-e29dc145e995.png) Esse código é a versão da AWS do código on-premises usando os serviços com tecnologia sem servidor da AWS. Em C\$1 .NET Core, cada função do Lambda é representada por um projeto do.NET Core. No código de exemplo desse padrão, há um projeto separado para cada interface nos modelos de comando e consulta. **CQRS usando os serviços da AWS** Você pode encontrar o diretório raiz da solução para o CQRS usando os serviços com tecnologia sem servidor da AWS na pasta `CQRS AWS Serverless\CQRS`. O exemplo inclui dois modelos: Cliente e Recompensa. As funções de comando do Lambda para Cliente e Recompensa estão nas pastas `CQRS\Command Microservice\Customer` e `CQRS\Command Microservice\Reward`. Eles contêm os seguintes projetos Lambda: + Comando do cliente: `CommandCreateLambda`, `CommandDeleteLambda`, e `CommandUpdateLambda` + Comando de recompensa: `CommandAddRewardLambda` e `CommandRedeemRewardLambda` As funções de consulta do Lambda para Customer e Reward são encontradas nas pastas `CQRS\Query Microservice\Customer` e `CQRS\QueryMicroservice\Reward`. Eles contêm os projetos Lambda `QueryCustomerListLambda` e `QueryRewardLambda`. **Projeto de teste CQRS** O projeto de teste está na pasta `CQRS\Tests`. Este projeto contém um script de teste para automatizar o teste das funções do Lambda do CQRS. **Fornecimento de eventos usando serviços da AWS** Os seguintes manipuladores de eventos do Lambda são iniciados pelos fluxos Cliente e Recompensa do DynamoDB para processar e sincronizar os dados nas tabelas de consulta. + A função do Lambda `EventSourceCustomer` é mapeada para a tabela Cliente (`cqrses-customer-cmd`) do fluxo do DynamoDB. + A função do Lambda `EventSourceReward` é mapeada para a tabela Recompensa (`cqrses-reward-cmd`) do fluxo do DynamoDB. ## Anexos Para acessar o conteúdo adicional associado a este documento, descompacte o seguinte arquivo: [ attachment.zip](samples/p-attach/9f1bc700-def4-4201-bb2d-f1fa27404f15/attachments/attachment.zip) # Mais padrões **Topics** + [Acesse aplicativos de contêineres de forma privada no Amazon EKS usando a AWS PrivateLink e um Network Load Balancer](access-container-applications-privately-on-amazon-eks-using-aws-privatelink-and-a-network-load-balancer.md) + [Automatizar a adição ou atualização de entradas de registro do Windows usando o AWS Systems Manager](automate-adding-or-updating-windows-registry-entries-using-aws-systems-manager.md) + [Automatização do failover e do failback entre regiões usando o DR Orchestrator Framework](automate-cross-region-failover-and-failback-by-using-dr-orchestrator-framework.md) + [Crie e implante automaticamente um aplicativo Java no Amazon EKS usando um CI/CD pipeline](automatically-build-and-deploy-a-java-application-to-amazon-eks-using-a-ci-cd-pipeline.md) + [Crie CI/CD pipelines e clusters do Amazon ECS automaticamente para microsserviços usando o AWS CDK](automatically-build-ci-cd-pipelines-and-amazon-ecs-clusters-for-microservices-using-aws-cdk.md) + [Backup e arquivamento de dados do mainframe no Amazon S3 usando o BMC AMI Cloud Data](back-up-and-archive-mainframe-data-to-amazon-s3-using-bmc-ami-cloud-data.md) + [Crie um PAC de servidor corporativo da Micro Focus com o Amazon EC2 Auto Scaling e o Systems Manager](build-a-micro-focus-enterprise-server-pac-with-amazon-ec2-auto-scaling-and-systems-manager.md) + [Crie uma malha de dados corporativa com a Amazon DataZone, AWS CDK, e AWS CloudFormation](build-enterprise-data-mesh-amazon-data-zone.md) + [Containerize workloads de mainframe que foram modernizadas pela Blu Age](containerize-mainframe-workloads-that-have-been-modernized-by-blu-age.md) + [Converta e descompacte dados EBCDIC em ASCII na AWS usando Python](convert-and-unpack-ebcdic-data-to-ascii-on-aws-by-using-python.md) + [Converta arquivos de dados de mainframe com layouts de registro complexos usando o Micro Focus](convert-mainframe-data-files-with-complex-record-layouts-using-micro-focus.md) + [Crie um portal para microfrontends usando Angular e AWS Amplify Module Federation](create-amplify-micro-frontend-portal.md) + [Implantar contêineres usando o Elastic Beanstalk](deploy-containers-by-using-elastic-beanstalk.md) + [Emule o Oracle DR usando um banco de dados global Aurora compatível com PostgreSQL](emulate-oracle-dr-by-using-a-postgresql-compatible-aurora-global-database.md) + [Gere insights de dados usando o AWS Mainframe Modernization Amazon Q no Quick Sight](generate-data-insights-by-using-aws-mainframe-modernization-and-amazon-q-in-quicksight.md) + [Gere insights de z/OS dados do Db2 usando o AWS Mainframe Modernization Amazon Q no Quick Sight](generate-db2-zos-data-insights-aws-mainframe-modernization-amazon-q-in-quicksight.md) + [Identificação automática de imagens de contêineres duplicadas ao migrar para um repositório do Amazon ECR](identify-duplicate-container-images-automatically-when-migrating-to-ecr-repository.md) + [Implementação de diagnósticos e solução de problemas com base em IA no Kubernetes usando a integração do K8sGPT e do Amazon Bedrock](implement-ai-powered-kubernetes-diagnostics-and-troubleshooting-with-k8sgpt-and-amazon-bedrock-integration.md) + [Implemente a autenticação baseada no Microsoft Entra ID em um aplicativo de AWS mainframe modernizado da Blue Age](implement-entra-id-authentication-in-aws-blu-age-modernized-mainframe-application.md) + [Implementação do versionamento de APIs baseado em caminhos usando domínios personalizados no Amazon API Gateway](implement-path-based-api-versioning-by-using-custom-domains.md) + [Migre incrementalmente do Amazon RDS para Oracle para o Amazon RDS para PostgreSQL usando o Oracle SQL Developer e o AWS SCT](incrementally-migrate-from-amazon-rds-for-oracle-to-amazon-rds-for-postgresql-using-oracle-sql-developer-and-aws-sct.md) + [Integre o controlador universal Stonebranch com o AWS Mainframe Modernization](integrate-stonebranch-universal-controller-with-aws-mainframe-modernization.md) + [Gerencie produtos do AWS Service Catalog em várias contas e regiões da AWS](manage-aws-service-catalog-products-in-multiple-aws-accounts-and-aws-regions.md) + [Migrar uma conta de AWS membro de para AWS Organizations AWS Control Tower](migrate-an-aws-member-account-from-aws-organizations-to-aws-control-tower.md) + [Migre e replique arquivos VSAM para o Amazon RDS ou o Amazon MSK usando o Connect da Precisely](migrate-and-replicate-vsam-files-to-amazon-rds-or-amazon-msk-using-connect-from-precisely.md) + [Migre do SAP ASE para o Amazon RDS para SQL Server usando o AWS DMS](migrate-from-sap-ase-to-amazon-rds-for-sql-server-using-aws-dms.md) + [Migre tabelas externas da Oracle para a compatibilidade com o Amazon Aurora PostgreSQL](migrate-oracle-external-tables-to-amazon-aurora-postgresql-compatible.md) + [Modernize o aplicativo de CardDemo mainframe usando AWS Transform](modernize-carddemo-mainframe-app.md) + [Modernize e implante aplicativos de mainframe usando o Terraform AWS Transform](modernize-mainframe-app-transform-terraform.md) + [Modernize as cargas de trabalho de impressão em lote do mainframe AWS usando o Rocket Enterprise Server e o LRS VPSX/MFI](modernize-mainframe-batch-printing-workloads-on-aws-by-using-rocket-enterprise-server-and-lrs-vpsx-mfi.md) + [Modernize as workloads de impressão on-line de mainframe na AWS usando o Micro Focus Enterprise Server e o LRS VPSX/MFI](modernize-mainframe-online-printing-workloads-on-aws-by-using-micro-focus-enterprise-server-and-lrs-vpsx-mfi.md) + [Modernize o gerenciamento de saída do mainframe AWS usando o Rocket Enterprise Server e o LRS X PageCenter](modernize-mainframe-output-management-on-aws-by-using-rocket-enterprise-server-and-lrs-pagecenterx.md) + [Mova arquivos de mainframe diretamente para o Amazon S3 usando o Transfer Family](move-mainframe-files-directly-to-amazon-s3-using-transfer-family.md) + [Otimize implantações sem servidor de várias contas usando os fluxos de trabalho e Actions AWS CDK GitHub](optimize-multi-account-serverless-deployments.md) + [Otimize o desempenho do seu aplicativo modernizado AWS Blu Age](optimize-performance-aws-blu-age-modernized-application.md) + [Automatize blue/green as implantações dos bancos de dados globais do Amazon Aurora usando os princípios de IaC](p-automate-blue-green-deployments-aurora-global-databases-iac.md) + [Replique bancos de dados de mainframe para AWS usando o Precisely Connect](replicate-mainframe-databases-to-aws-by-using-precisely-connect.md) + [Execute tarefas do Amazon ECS na Amazon WorkSpaces com o Amazon ECS Anywhere](run-amazon-ecs-tasks-on-amazon-workspaces-with-amazon-ecs-anywhere.md) + [Envie dados de telemetria de AWS Lambda para OpenSearch para análise e visualização em tempo real](send-telemetry-data-from-lambda-to-opensearch-for-analytics-visualization.md) + [Configure a detecção de CloudFormation desvios em uma organização multirregional e com várias contas](set-up-aws-cloudformation-drift-detection-in-a-multi-region-multi-account-organization.md) + [Estruture um projeto Python em arquitetura hexagonal usando o AWS Lambda](structure-a-python-project-in-hexagonal-architecture-using-aws-lambda.md) + [Teste a AWS infraestrutura usando LocalStack e Terraform Tests](test-aws-infra-localstack-terraform.md) + [Transforme o Easytrieve em linguagens modernas usando linguagens personalizadas AWS Transform](transform-easytrieve-modern-languages.md) + [Atualize os clusters do SAP Pacemaker de para ENSA1 ENSA2](upgrade-sap-pacemaker-clusters-from-ensa1-to-ensa2.md) + [Uso do Amazon Q Developer como um assistente de codificação para aumentar a produtividade](use-q-developer-as-coding-assistant-to-increase-productivity.md) + [Valide o código do Account Factory for Terraform (AFT) localmente](validate-account-factory-for-terraform-aft-code-locally.md)