Neste módulo, você implantará o aplicativo node.js como um conjunto de serviços interconectados por trás de um Application Load Balancer (ALB). Depois, você usará o ALB para mudar facilmente o tráfego do monólito para os microsserviços. Comece a criar

Este é o processo que você seguirá para implantar os microsserviços e mudar com segurança o tráfego do aplicativo, deixando para trás o monólito.

visão geral da arquitetura
  1. Mude o tráfego
    Esta é a configuração inicial. O aplicativo monolítico node.js em execução em um contêiner no Amazon ECS.
  2. Inicie microsserviços
    Usando as três imagens de contêineres que você criou e enviou para o Amazon ECR no módulo anterior, você iniciará três microsserviços no cluster existente do Amazon ECS.
  3. Configure os grupos de destino
    Como no Módulo 2, você adicionará um grupo de destino para cada serviço e atualizará as regras do ALB para se conectar aos novos microsserviços.
  4. Desative o monólito
    Ao alterar uma regra no ALB, você iniciará o roteamento do tráfego para os microsserviços em execução. Após a verificação do redirecionamento do tráfego, desative o monólito.

Siga as instruções passo a passo abaixo para implantar os microsserviços. Selecione o número de cada etapa para expandir a seção.

break-the-monolith
  • Etapa 1. Gravar as definições de tarefas para seus serviços

    Você implantará três novos serviços no cluster que executou no Módulo 2. Como no módulo 2, você gravará Definições de tarefas para cada serviço.

    ⚐ NOTA: é possível adicionar vários contêineres a uma única definição de tarefa. Isso significa que você pode executar os três microsserviços como contêineres diferentes de um único serviço. Mas, esta abordagem ainda é monolítica pois cada contêiner precisaria estar escalado linearmente com o serviço. Sua meta é ter três serviços diferentes. Cada serviço exige que sua própria definição de tarefa execute um contêiner com a imagem do respectivo serviço.

    Você pode criar essas definições de tarefas no console do Amazon ECS ou acelerar as coisas gravando as definições como JSON. Para gravar a definição de tarefa como um arquivo JSON, siga estas etapas:

    1. No console do Amazon Container Services em Amazon ECS, selecione Definições de tarefas.
    2. Na página Task Definitions (Definições de tarefas), selecione o botão Create new Task Definition (Criar nova definição de tarefa).
    3. Na página Select launch type compatibility (Selecionar compatibilidade de tipo de execução), selecione a opção EC2 e Next step (Próxima etapa).
    4. Na página Configure task and container definitions (Configurar definições de tarefa e contêiner), role até a seção Volumes e selecione o botão Configure via JSON (Configurar via JSON).
    5. Copie e cole o trecho de código a seguir no campo do JSON, substituindo o código existente.
      Lembre-se de substituir os espaços reservados [nome-do-serviço], [ID-da-conta], [região] e [tag].

    ⚐ Nota: Os seguintes parâmetros são usados para a definição de tarefas:

    • Nome = [nome-do-serviço: posts, threads e users] 
    • Imagem = [URL da imagem do repositório do Amazon ECR]:latest 
    • cpu = 256 
    • memória = 256 
    • Porta do contêiner = 3.000 
    • Host Post = 0
    {
        "containerDefinitions": [
            {
                "name": "[service-name]",
                "image": "[account-id].dkr.ecr.[region].amazonaws.com/[service-name]:[tag]",
                "memoryReservation": "256",
                "cpu": "256",
                "essential": true,
                "portMappings": [
                    {
                        "hostPort": "0",
                        "containerPort": "3000",
                        "protocol": "tcp"
                    }
                ]
            }
        ],
        "volumes": [],
        "networkMode": "bridge",
        "placementConstraints": [],
        "family": "[service-name]"
    }

    ♻ Repita as etapas para criar uma definição de tarefa para cada serviço:

    • posts
    • threads
    • users
  • Etapa 2. Configurar o Application Load Balancer: grupos de destino

    Como no Módulo 2, configure um grupo de destino para cada serviço (posts, threads e users). Um grupo de destino permite que o tráfego chegue corretamente ao serviço especificado. Você configurará os grupos de destino usando a CLI da AWS. No entanto, antes de prosseguir, verifique se você tem o nome correto da VPC que está sendo usada neste tutorial:

    • Navegue até a Load Balancer section of the EC2 Console (seção Load Balancer do console do EC2).
    • Marque a caixa de seleção ao lado de demonstração, selecione a guia Descrição e localize o atributo da VPC (neste formato: vpc-xxxxxxxxxxxxxxxxx).
      ⚐ Nota: você precisará do atributo da VPC ao configurar os grupos de destino.

    Configure os grupos de destino

    No seu terminal, insira o comando a seguir para criar um grupo de destino para cada serviço (posts, threads e users). Além disso, você criará um grupo de destino (drop-traffic) para impedir que o tráfego alcance seu monólito quando os microsserviços estiverem em plena execução. Lembre-se de substituir os seguintes espaços reservados: [região], [nome-do-serviço] e [atributo-da-vpc].

    Nomes de serviços: posts, threads, users e drop-traffic

    aws elbv2 create-target-group --region [region] --name [service-name] --protocol HTTP --port 80 --vpc-id [vpc-attribute] --healthy-threshold-count 2 --unhealthy-threshold-count 2 --health-check-timeout-seconds 5 --health-check-interval-seconds 6
    grupos de destino
  • Etapa 3. Configurar regras do listener

    O listener verifica as solicitações de conexões recebidas no ALB para direcionar o tráfego adequadamente.

    Neste momento, todos os seus quatro serviços (monólito e três microsserviços) estão em execução subjacentes ao mesmo load balancer. Para fazer a transição de monólito para microsserviços, você precisará iniciar o roteamento de tráfego para seus microsserviços e parar o roteamento de tráfego para seu monólito.

    Acessar as regras do listener

    • Navegue até a Load Balancer section of the EC2 Console (seção Load Balancer do console do EC2).
    • Localize o load balancer chamado demonstração e marque a caixa de seleção ao lado dele para ver os detalhes.
    • Selecione a guia Listeners.

    Atualizar regras do listener

    Esta guia deve conter apenas um listener listado. Siga as etapas abaixo para editar as regras do listener:

    • Na coluna Rules (Regras), selecione View/edit rules (Exibir/editar regras).
    • Na página Rules (Regras), selecione o botão de mais (+).
      A opção para Insert Rule (Inserir regra) aparece na página. 
    • Use este modelo de regra para inserir as regras necessárias que incluem uma para manter o tráfego para o monólito e uma para cada microsserviço:
      • IF Path = /api/[nome-do-serviço]* THEN Forward to [nome-do-serviço]
        Por exemplo: IF Path = /api/posts* THEN Encaminha para posts
      • Insira as regras na seguinte ordem:
        • api: /api* encaminha para api
        • users: /api/users* encaminha para users
        • threads: /api/threads* encaminha para threads
        • posts: /api/posts*encaminha para posts
    • Selecione Salvar.
    • Selecione a seta preta no canto superior esquerdo da página para retornar ao console do load balancer.
    Configurar regras de listener do Application Load Balancer
  • Etapa 4. Implantar seus microsserviços

    Implante os três microsserviços (posts, threads e users) no seu cluster. Repita estas etapas para cada um dos três microsserviços:

    • Navegue até o Amazon ECS console (console do Amazon ECS) e selecione Clusters na barra de menu à esquerda.
    • Selecione o cluster BreakTheMonolith-Demo, a guia Services (Serviços) e Create (Criar).
    • Na página Configure service (Configurar serviço), edite os seguintes parâmetros (e mantenha os valores padrão para os parâmetros não listados abaixo):
      • Para o Launch type (Tipo de execução), selecione EC2.
      • Para a Task Definition (Definição de tarefa), selecione o botão Enter a value (Inserir um valor) para selecionar automaticamente o valor de revisão mais alto.
        Por exemplo, api:1 
      • Para o Service name (Nome do serviço), insira um nome de serviço (posts, threads ou users).
      • Para o Number of tasks (Número de tarefas), insira 1
    • Selecione Next step (Próxima etapa).
    • Na página Configure network (Configurar rede), seção Load balancing (Balanceamento de carga), faça o seguinte:
      • Para o Load balancer type (Tipo de load balancer), selecione Application Load Balancer.
      • Para a Service IAM role (Função do IAM do serviço), selecione BreakTheMonolith-Demo-ECSServiceRole.
      • Para o Load balancer name (Nome do load balancer), verifique se demo (demonstração) está selecionado.
      • Na seção Container to load balance (Contêiner para balancear carga), selecione o botão Add to load balancer (Adicionar ao load balancer) e faça as seguintes edições:
        • Para a Production listener port (Porta do listener de produção), defina como 80:HTTP.
        • Para o Target group name (Nome do grupo de destino), selecione o grupo apropriado: (posts, threads, ou users)
    • Selecione Next step (Próxima etapa).
    • Na página Set Auto Scaling (Definir Auto Scaling), selecione Next step (Próxima etapa).
    • Na página Review (Revisar), selecione Create Service (Criar serviço).
    • Selecione View Service (Visualizar serviço).

    Deve levar apenas alguns segundos para que todos os seus serviços sejam iniciados. Verifique novamente se todos os serviços e tarefas estão em execução e ativos antes de prosseguir.

    Amazon ECS: Implantar microsserviços
  • Etapa 5. Transferir o tráfego para seus microsserviços

    Seus microsserviços estão em execução no momento, mas todo o tráfego ainda está fluindo para o serviço de monólito. Para redirecionar o tráfego para os microsserviços, siga as etapas abaixo para atualizar as regras do listener:

    • Navegue até a Load Balancers section of the EC2 Console (seção Load Balancers do console do EC2).
    • Marque a caixa de seleção ao lado de demo (demonstração) para ver os detalhes do Load Balancer.
    • Selecione a guia Listeners.
      Deve haver apenas um listener listado.
    • Na coluna Rules (Regras), selecione View/edit rules (Exibir/editar regras).
    • Na página Rules (Regras), selecione o botão de menos (-) no menu superior.
    • Exclua a primeira regra (/api* encaminha para api) marcando as caixas de seleção ao lado da regra.
    • Selecione Delete (Excluir).
    • Atualize a regra padrão para encaminhar para drop-traffic:
      • Selecione o botão de edição (lápis) no menu superior.
      • Selecione o ícone de edição (lápis) ao lado da regra padrão (HTTP 80: ação padrão).
      • Selecione o ícone de edição (lápis) na coluna THEN para editar Forward to (Encaminhar para).
      • No campo Target group (Grupo de destino), selecione drop-traffic.
      • Selecione o botão Update (Atualizar).

    Consulte a captura de tela a seguir para ver um exemplo das regras atualizadas.

    Amazon EC2: Transferir o tráfego para seus microsserviços

    Desabilitar o monólito: com o tráfego agora fluindo para os microsserviços, você pode desabilitar o serviço de monólito.

    • Navegue de volta ao cluster do Amazon ECS BreakTheMonolith-Demo-ECSCluster.
    • Na guia Services (Serviços), marque a caixa de seleção ao lado de api e selecione Update (Atualizar).
    • Na página Configure service (Configurar serviço), localize Number of tasks (Número de tarefas) e insira 0.
    • Selecione Skip to review (Pular para análise).
    • Selecione Update Service (Atualizar serviço).

    Agora, o Amazon ECS esvaziará as conexões dos contêineres que o serviço implantou no cluster e interromperá os contêineres. Se você atualizar as listas de implantações ou tarefas após cerca de 30 segundos, verá que o número de tarefas cairá para 0. O serviço ainda está ativo. Então, se você precisar reverter por algum motivo, bastará atualizá-lo para implantar mais tarefas.

    Como opção, você pode excluir o serviço de api. Na guia Services (Serviços), marque a caixa de seleção ao lado de api, selecione Delete (Excluir) e confirme a exclusão.

    Você realizou a transição completa do node.js de um monólito para microsserviços, sem tempo de inatividade!

  • Etapa 6. Validar sua implantação

    Encontre o URL do seu serviço: é o mesmo URL usado no Módulo 2 deste tutorial.

    • Navegue até a Load Balancers section of the EC2 console (seção Load Balancers do console do EC2).
    • Marque a caixa de seleção ao lado de demo (demonstração) para ver os detalhes do Load Balancer.
    • Na guia Description (Descrição), localize o DNS name (Nome do DNS) e selecione o ícone de cópia no final do URL. 
    • Cole o nome do DNS em uma nova guia ou janela do navegador.

    Você deverá ver a mensagem 'Pronto para receber solicitações'.

    Veja os valores de cada microsserviço: seu ALB direciona o tráfego com base no URL solicitado. Para ver cada serviço, basta adicionar o nome do serviço ao final do nome do DNS:

    • http://[nome do DNS]/api/users
    • http://[nome do DNS]/api/threads
    • http://[nome do DNS]/api/posts
    veja os valores de cada microsserviço

    ⚐ NOTA: esses URLs são executados da mesma forma que quando o monólito é implantado. Isso é muito importante porque qualquer API ou consumidor que queira se conectar a este aplicativo não será afetado pelas alterações feitas. Ir de monólito para microsserviços não exigiu alteração de outras partes de sua infraestrutura.

    Você também pode usar ferramentas, como Postman para testar suas APIs.