Projete visualmente seu aplicativo com o AWS Application Composer

O AWS Application Composer permite que você projete e crie aplicativos visualmente usando 13 tipos de recursos do AWS CloudFormation. Atualmente, o serviço expande o suporte para todos os tipos de recursos disponíveis do CloudFormation.

Visão geral

O AWS Application Composer fornece uma tela interativa para projetar visualmente seus aplicativos. Você usa uma interface de arrastar e soltar para criar um design de aplicativo do zero ou importar uma definição de aplicativo existente para editá-la.

Os aplicativos modernos orientados a eventos são baseados em muitos serviços. A visualização de uma arquitetura ajuda você a entender melhor a relação entre esses serviços e a identificar lacunas e áreas de melhorias.

Você pode usar o AWS Application Composer no modo de sincronização local para se conectar ao seu sistema de arquivos local. Dessa forma, suas alterações são atualizadas em seu sistema de arquivos. Dessa forma, você pode se integrar aos sistemas de controle de versão existentes e ao fluxo de trabalho de desenvolvimento e implantação.

O AWS Application Composer fornece uma visualização em tela de arrastar e soltar e uma visualização de modelo de editor de código. As alterações feitas em uma visualização refletem na outra. Da mesma forma, as alterações feitas no AWS Application Composer são refletidas em seu editor de código local e vice-versa.

O que a AWS está lançando hoje?

O AWS Application Composer já oferece suporte a 13 tipos de recursos sem servidor. Para esses tipos de recursos, o AWS Application Composer fornece “cards” (cartões) de componentes avançados.

Os “cards” de componentes avançados permitem que você configure e junte componentes. A versão de hoje permite arrastar e soltar 1.134 tipos de recursos na tela e configurá-los usando o painel de configuração de recursos.

Esta postagem do blog mostra como você pode criar uma arquitetura computacional tolerante a falhas envolvendo um Application Load Balancer, duas instâncias do Amazon Elastic Compute Cloud (EC2) em diferentes zonas de disponibilidade e uma instância do Amazon Relational Database Service (RDS).

Conceitualmente, esse é o design do aplicativo:

Projetando uma pilha de computação escalável e tolerante a falhas

Para esta postagem do blog, você cria uma pilha computacional tolerante a falhas que consiste em um ALB, duas instâncias do EC2 em duas zonas de disponibilidade diferentes com recursos de escalabilidade automática e uma instância do RDS.

1. Navegue até o serviço AWS Application Composer no Console de Gerenciamento da AWS. Crie um novo projeto escolhendo Criar projeto.
2. Se você estiver usando um dos navegadores que oferecem suporte à sincronização local (Google Chrome e Microsoft Edge no momento), você pode conectar o projeto ao sistema de arquivos local e editar usando a interface de linha de comando ou o ambiente de desenvolvimento integrado. Para fazer isso:
   1. Escolha Menu e Sincronização local.
   2. Selecione uma pasta no seu sistema de arquivos e conceda as permissões necessárias do navegador quando solicitado.
3. Alguns componentes em diagramas de arquitetura, como grupos de segurança, podem ser visualizados na tela, mas você não quer necessariamente representá-los como parte importante das arquiteturas. Portanto, para resumir, em vez de arrastar e soltar, você só os configura no modo modelo.

1. 1. Escolha Modelo para alternar para a visualização do modelo.
   2. Cole o código a seguir no editor de modelos:

Resources:
  DBEC2SecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupDescription: Open database for access
      SecurityGroupIngress:
        - IpProtocol: tcp
          FromPort: '3306'
          ToPort: '3306'
          SourceSecurityGroupId: !Ref WebServerSecurityGroup
      VpcId:
        ParameterId: VpcId
        Format: AWS::EC2::VPC::Id
  WebServerSecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupDescription: Enable HTTP access via port 80 locked down to the load balancer + SSH access.
      SecurityGroupIngress:
        - IpProtocol: tcp
          FromPort: '80'
          ToPort: '80'
          SourceSecurityGroupId: !Select
            - 0
            - !GetAtt LoadBalancer.SecurityGroups
        - IpProtocol: tcp
          FromPort: '22'
          ToPort: '22'
          CidrIp:
            ParameterId: SSHLocation
            Format: String
            Default: 0.0.0.0/0
      VpcId:
        ParameterId: VpcId
        Format: AWS::EC2::VPC::Id
  WebServerGroup:
    Type: AWS::AutoScaling::AutoScalingGroup
    Properties:
      VPCZoneIdentifier:
        ParameterId: Subnets
        Format: List<AWS::EC2::Subnet::Id>
      LaunchConfigurationName: !Ref LaunchConfiguration
      MinSize: '1'
      MaxSize: '5'
      DesiredCapacity:
        ParameterId: WebServerCapacity
        Format: Number
        Default: '1'
      TargetGroupARNs:
        - !Ref TargetGroup

1. 1. No painel de recursos à esquerda, digite loadbalancer na barra de pesquisa.
   2. Arraste e solte AWS: :ElasticLoadBalancingV2: :LoadBalancer do painel de recursos para a tela.

5. Repita essas etapas para outros quatro tipos de recursos. Escolha Organizar. Sua tela agora aparece da seguinte forma:

6. Comece a configurar as placas de componentes restantes. Você pode conectar duas placas visualmente conectando a porta de conexão direita de uma placa à porta de conexão esquerda de outra placa. No momento, nem todas as placas de componentes oferecem suporte à conectividade visual. Para essas placas, você pode estabelecer conectividade usando o painel de configuração de recursos. Você também pode atualizar o código do modelo diretamente. De qualquer forma, a conectividade é refletida na tela.

4. Você configura os componentes na arquitetura usando o painel Configuração de recursos. Primeiro, configure o ouvinte do Application Load Balancer:

1. 1. Escolha o Listener Card na tela.
   2. Escolha Detalhes.
   3. Cole o código a seguir na seção Configuração de recursos:

DefaultActions:
     Type: forward
TargetGroupArn: !Ref TargetGroup
LoadBalancerArn: !Ref LoadBalancer
Port: '80'
Protocol: HTTP

9. O código do cartão Target Group é:

HealthCheckPath: /
HealthCheckIntervalSeconds: 10
HealthCheckTimeoutSeconds: 5
HealthyThresholdCount: 2
Port: 80
Protocol: HTTP
UnhealthyThresholdCount: 5
VpcId:
  ParameterId: VpcId
  Format: AWS::EC2::VPC::Id
TargetGroupAttributes:
  - Key: stickiness.enabled
    Value: 'true'
  - Key: stickiness.type
    Value: lb_cookie
  - Key: stickiness.lb_cookie.duration_seconds
    Value: '30'

10. Esse é o código para a configuração do Launch. <image-id>Substitua pelo ID de imagem correto para sua região.

ImageId: <image-id>
InstanceType: t2.small
SecurityGroups: !Ref WebServerSecurityGroup

11. O código para DBInstance é:

DBName:
  ParameterId: DBName
  Format: String
  Default: wordpressdb
Engine: MySQL
MultiAZ:
  ParameterId: MultiAZDatabase
  Format: String
  Default: 'false'
MasterUsername:
  ParameterId: DBUser
  Format: String
MasterUserPassword:
  ParameterId: DBPassword
  Format: String
DBInstanceClass:
  ParameterId: DBClass
  Format: String
  Default: db.t2.small
AllocatedStorage:
  ParameterId: DBAllocatedStorage
  Format: Number
  Default: '5'
VPCSecurityGroups:
  - !GetAtt DBEC2SecurityGroup.GroupId

12. Escolha Organizar. Sua tela tem a seguinte aparência:

13. Isso completa a parte de visualização da arquitetura do aplicativo. Você pode exportar essa visualização usando a opção Exportar tela no menu.

Adicionando observabilidade

Depois de adicionar os componentes principais do aplicativo, agora você adiciona a observabilidade ao seu aplicativo. A observabilidade permite que você colete e analise eventos e métricas importantes para seus aplicativos.

Para ser notificado sobre qualquer alteração na configuração do banco de dados do RDS, use um padrão de design sem servidor para evitar a execução de instâncias quando elas não forem necessárias. Conceitualmente, sua pilha de observabilidade se parece com:

1. O Amazon EventBridge captura os eventos emitidos pelo Amazon RDS.
2. Para qualquer evento que corresponda à regra do EventBridge, o EventBridge invoca o AWS Lambda.
3. O Lambda executa a lógica personalizada e envia um e-mail para um tópico do Amazon Simple Notification Service (SNS). Você pode inscrever as partes interessadas neste tópico do SNS.

Agora há dois conjuntos distintos de componentes na arquitetura. Um conjunto de componentes compreende o aplicativo principal, enquanto outro compreende a lógica de observabilidade.

O AWS Application Composer permite que você organize diferentes componentes em grupos. Isso permite que você e sua equipe se concentrem em uma parte da arquitetura por vez. Antes de adicionar componentes de observabilidade, primeiro crie um grupo dos componentes existentes.

1. Selecione uma “cart” de componente.
2. Enquanto segura a tecla ‘shift’, selecione as outras “cart” (cartas). Depois que todos os recursos forem selecionados, selecione Ação de grupo.

Depois que o grupo for criado, siga estas etapas para renomear o grupo.

1. Selecione o “cart” de grupo.
2. Renomeie o grupo para Application Stack.
3. Escolha Salvar.

Agora, adicione os componentes de observabilidade. Repita o processo de pesquisa e, em seguida, arraste e solte os seguintes componentes do painel Recursos para a tela fora do grupo Application Stack.

• 1. Regra de eventos do EventBridge
  2. Função Lambda
  3. Tópico do SNS
  4. Assinatura SNS

Repita o processo para agrupar esses 4 componentes em um grupo com o nome Observabilidade.

Alguns dos componentes têm um pequeno círculo nas laterais. Essas são portas de conector. Uma porta no lado direito de um cartão indica uma oportunidade para o cartão invocar outro cartão. Uma porta no lado esquerdo indica a oportunidade de um cartão ser invocado por outro cartão. Você pode conectar dois “cards” clicando na porta direita de um “cards”  e arrastando para a porta esquerda de outro “cards”.

Crie a pilha de observabilidade seguindo as seguintes etapas:

1. Conecte a porta direita da placa EventBridge Event Rule à porta esquerda da placa de função Lambda. Isso torna a função Lambda um alvo para a regra EventBridge.
2. Conecte a porta direita da função Lambda à porta esquerda do tópico do SNS. Isso adiciona as políticas de permissões e a variável de ambiente necessárias do AWS Identity and Management (IAM) à função Lambda para fornecer a capacidade de interagir com o tópico do SNS.
3. Selecione o cartão de regra de evento do EventBridge e substitua o código do padrão do evento no painel de propriedades do recurso pelo código a seguir. Esse padrão de evento monitora a instância do RDS em busca de um evento de alteração de instância e envia esse evento para o Lambda.

source:
  - aws.rds
detail-type:
  - RDS DB Instance Event

4. Selecione a assinatura do SNS para ver o painel de configuração do recurso. Adicione o código a seguir à configuração do recurso. Substitua test@example.com pelo seu endereço de e-mail.

Endpoint: test@example.com
    Protocol: email
    TopicArn: !Ref Topic

5. Repita as etapas de criação do grupo para criar um grupo de observabilidade composto por uma regra de evento do EventBridge, uma função Lambda, um tópico do SNS e uma assinatura do SNS. Nomeie o grupo como Observabilidade. Seu grupo aparece da seguinte forma:

Implantando sua arquitetura da AWS

Antes de provisionar os recursos para sua arquitetura, você deve fazer as alterações na configuração de acordo com as melhores práticas de desenvolvimento e implantação em sua organização.

Por exemplo, você deve fornecer uma senha de banco de dados forte e nomear os recursos de acordo com as convenções de nomenclatura da sua organização. Você também deve adicionar o código Lambda com sua lógica personalizada.

O AWS Application Composer oferece a capacidade de configurar cada recurso por meio do painel de configuração de recursos. Isso permite que você permaneça sempre no contexto enquanto cria uma arquitetura complexa. Você pode encontrar rapidamente o recurso que deseja editar em vez de percorrer um grande arquivo de modelo. Se você preferir editar o arquivo de modelo diretamente, você pode usar a visualização de modelo do AWS Application Composer.

Como alternativa, se você tiver habilitado a sincronização local, poderá editar o arquivo diretamente em seu ambiente de desenvolvimento integrado (IDE), onde as alterações feitas no AWS Application Composer são salvas em tempo real. Se você não tiver ativado a sincronização local, poderá exportar o modelo usando a opção Salvar arquivo de modelo no menu. Depois de concluir suas alterações, você pode provisionar a infraestrutura da AWS usando o console do AWS CloudFormation ou a interface da linha de comando.

Preços

O AWS Application Composer não provisiona nenhum recurso da AWS. Usar o AWS Application Composer para projetar sua arquitetura de aplicativos é gratuito. Você só é cobrado quando provisiona recursos da AWS usando o arquivo de modelo (template) criado pelo AWS Application Composer.

Conclusão

Este blog post mostra como usar o AWS Application Composer para criar e atualizar uma arquitetura de aplicativo usando qualquer um dos 1.134 tipos de recursos do CloudFormation. Ele aborda como configurar o modo de sincronização local para integrar o aplicativo da AWS ao seu fluxo de trabalho de desenvolvimento. A postagem demonstra como organizar sua arquitetura em dois grupos distintos. As alterações feitas na visualização do Canvas são refletidas na visualização do modelo e vice-versa.

Para saber mais sobre o AWS Application Composer, visite https://aws.amazon.com/application-composer/.

Para obter mais recursos de aprendizado sem servidor, visite Serverless Land.