Implementar a aplicação Rails com o Amazon ECS

Vamos criá-lo executando carris nova aplicação de carris de amostrae, em seguida, gerar uma ação básica do controlador rails g controlador Índice de boas-vindas e definindo rotas para o caminho raiz como `root to: welcome#index".

O nosso objetivo é que esta página de boas-vindas seja implementada utilizando o ECS.

Criar um repositório com o Amazon Elastic Container Registry (ECR)

Amazon ECR é um registo de contentores. Iremos utilizá-lo para armazenar as imagens da nossa aplicação e retirá-las para que sejam executadas no ECS.

Ir para o seu AWS painelprocurar Contentor elástico
Registo e clicar em Começar a trabalhar. Aparecerá o ecrã abaixo:

Vamos criar um repositório privado e dar-lhe o nome aplicação de carris de amostra.

O repositório está lá, mas está vazio. Queremos que ele contenha a imagem da nossa aplicação. Este é o próximo passo.

# lança erros se o Gemfile tiver sido modificado desde Gemfile.lock

RUN bundle config --global frozen 1

WORKDIR /app

COPY Gemfile Gemfile.lock ./

EXECUTAR a instalação do pacote

COPY . .

CMD ["rails", "server", "-b", "0.0.0.0"]

Depois, devemos criar uma imagem e enviá-la para o repositório ECR.

Antes disso, vamos pré-compilar os assets com `rails assets:precompile`.

Agora, aceda ao repositório criado. Na parte superior do ecrã, verá um Ver comandos push com pormenores sobre como o fazer.

No meu caso (Linux), executo-o com estas instruções do AWS:

aws ecr get-login-password --region eu-central-1 | doca login --username AWS --password-stdin 212516879399.dkr.ecr.eu-central-1.amazonaws.com

docker build -t sample-rails-app .

docker tag sample-rails-app:latest 212516879399.dkr.ecr.eu-central-1.amazonaws.com/sample-rails-app:latest

docker push 212516879399.dkr.ecr.eu-central-1.amazonaws.com/sample-rails-app:latest

Certifique-se de que o utilizador tem permissão para efetuar esta operação. Adicionei a política AmazonElasticContainerRegistryPowerUser ao meu utilizador, que tem o seguinte aspeto:

{
    "Versão": "2012-10-17",
    "Declaração": [
        {
            "Sid": "VisualEditor0",
            "Efeito": "Permitir",
            "Ação": [
                "ecr:GetRegistryPolicy",
                "ecr:DescribeRegistry",
                "ecr:GetAuthorizationToken",
                "ecr:DeleteRegistryPolicy",
                "ecr:PutRegistryPolicy",
                "ecr:PutReplicationConfiguration"
            ],
            "Recurso": "*"
        },
        {
            "Sid": "VisualEditor1",
            "Efeito": "Permitir",
            "Ação": "ecr:*",
            "Recurso": "arn:aws:ecr:*:212516879399:repository/*"
        }
    ]
}

Temos a nossa imagem docker preparada.

Criando o balanceador de carga de aplicativos

Quero que o mundo exterior possa se conectar apenas ao meu balanceador de carga de aplicativo. Ele passará o tráfego para contêineres que estão sendo executados dentro do nosso cluster ECS.

Ir para Serviços EC2 -> Balanceamento de carga -> Balanceadores de carga, clique Criar balanceador de carga, selecionar Balanceador de carga de aplicações e clicar no botão Criar botão.

Definir o seu nome para sample-rails-app-albutilize a sua VPC predefinida e selecione todas as suas sub-redes.

Ficamos com Grupos de segurança e Ouvintes e encaminhamento secções.

Grupos de segurança

Vamos criar um novo grupo de segurança para o nosso balanceador de carga. Ele funciona como um firewall; definiremos as regras para o tráfego de entrada e de saída. Queremos aceitar o tráfego http de entrada (porta TCP 80) e permitir todo o tráfego de saída. 

Para o fazer, clique no botão "Criar um novo grupo de segurança" ligação.

Na secção "Detalhes básicos", definir o nome e a descrição, deixar a VPC predefinida.

No meu caso - nome: "amostra-carris-app-alb-sg", descrição: "http do exterior, tudo do interior"

Adicione a regra de entrada com Type: HTTP e Fonte: Qualquer lugar-IPv4. Deixar as regras de saída como estão.

Clicar criar grupo de segurançaEm seguida, volte ao separador onde estava a criar o Application Load Balancer, actualize os grupos de segurança e adicione o grupo que acabámos de criar, removendo o grupo predefinido.

Ouvintes e encaminhamento

Nesta secção, vamos definir para onde queremos que o balanceador de carga passe o tráfego. Sair Ouvinte Protocolo e Porto como HTTP e 80, pois é exatamente isso que queremos, e clique em "Criar um grupo-alvo" ligação.

Definir o nome para "sample-rails-app-alb-tg". A única alteração é o número da porta. Vamos passá-lo para a porta 3000, uma vez que esta é a porta da nossa aplicação Rails. Ignore o próximo passo (Objectivos registados) e criar o grupo-alvo.

Agora volte ao separador onde estávamos a criar o Application Load Balancer, actualize o grupo de destino e selecione o que acabámos de criar.

Temos o nosso Application Load Balancer pronto, agora vamos brincar com o ECS.

Criação de um cluster ECS

Vai ver uma série de termos assustadores - cluster, tarefas, definição de tarefas, serviços. Para simplificar, pense no cluster como um grupo de servidores (instâncias EC2). Em cada um deles, executamos tarefas, que são apenas um grupo de contentores a funcionar em conjunto. A definição da tarefa descreve que contentores estão num determinado grupo e que recursos gostaríamos de lhes atribuir (memória, CPU). Os serviços controlam estas tarefas para se certificarem de que existe sempre um número correto de tarefas saudáveis em execução no nosso cluster.

Com isto em mente, vamos criar o nosso cluster.

Aceder à página ECS e clicar no botão Aglomerados ligação e Criar cluster botão. Selecionar a opção "Rede EC2 + Linux" um e clique Próxima etapa. 

Definir o nome do cluster para "amostra-rails-app-cluster". Escolha o tipo de instância EC2, eu escolhi o t2-micro porque está disponível no plano Free Tier. Deixe o número de instâncias como 1. 

Na secção de rede, utilize a sua VPC predefinida e selecione todas as respectivas sub-redes. Clique em criar, aguarde um pouco e pronto, temos um novo ECS Cluster criado.

Definição da tarefa

Clicar no botão Definições de tarefas ligação, então Criar nova definição de tarefa botão. Selecione o botão EC2 e clique em Próxima etapa. A aplicação que vamos executar é muito simples, pelo que precisamos apenas de algumas opções. 

Conjunto Definição da tarefa nome para "aplicação de carris de amostra", depois vá diretamente para o Definições de contentores secção e clique em "Adicionar contentor". Designar o contentor como "aplicação de carris de amostra", e definir a localização da imagem no formato "repositório-url/imagem:tag". No novo separador do browser, ir ao ECR para copiar o URI da imagem. No meu caso, era: "212516879399.dkr.ecr.eu-central-1.amazonaws.com/sample-rails-app:latest".

Defina o seu limite de memória para os 300-500MiB recomendados. Agora, a coisa mais complicada - Mapeamento de portas.

A nossa aplicação é executada dentro de um contentor na porta 3000. Portanto, coloque 3000 como a porta do contêiner. Introduziremos 0 como porta do host, o que basicamente significa que ele seleciona uma porta aleatória. Felizmente, nosso balanceador de carga de aplicativo conhecerá esse mapeamento de porta e será capaz de direcionar o tráfego corretamente. Podemos até mesmo executar várias tarefas nessa única instância. 

Adicionar a variável de ambiente FERROVIÁRIOS_ENV e definir o valor para produção.

Agora clique em Adicionar para adicionar a nossa definição de contentor e clique em Criar para terminar a configuração da Definição de Tarefas.

Serviço

Temos o nosso cluster, o balanceador de carga e a definição de tarefas. Agora temos que executar essas tarefas de alguma forma dentro do nosso cluster. Esta é a função dos serviços. Aceda ao cluster recém-criado, selecione a opção Serviços e clicar no separador Criar botão. 

Defina o tipo de lançamento como EC2, adicione o nome "amostra de serviço de aplicação de carris". Definir o número de tarefas para 1 e clicar em Próxima etapa. Nesta página, selecione o botão de opção Application Load Balancer e escolha a função IAM existente para o mesmo. Na secção "Container to load balance", já deve ter introduzido um contentor correto "sample-rails-app:0:3000" e, em seguida, clique em "Add to load balancer".

Para "Production listener port" (Porta do ouvinte de produção), escolha 80:HTTP; como nome do grupo de destino, utilize o que criámos anteriormente - "sample-rails-app-alb-tg" e clique em Próxima etapa. Partir Escala automática opções tal como estão, clique em Próxima etapa e Criar serviço.

Atualizar o grupo de segurança do ECS

Pode ir à página do cluster criado e verificar o Tarefas deve haver uma tarefa em execução. O serviço iniciou-a. Agora vá para a página de serviço do EC2, clique em Load Balancers e veja os detalhes do nosso Application Load Balancer. Deverá ter aí o seu nome DNS. Copie-o e abra-o no navegador. Deve direccioná-lo para a nossa aplicação. Infelizmente, recebemos a mensagem "504 Tempo limite do gateway" erro. 

O problema está no grupo de segurança do nosso cluster. As suas regras de entrada não permitem o tráfego proveniente do equilibrador de carga. Para corrigir isso, volte ao painel EC2 e clique no botão Grupos de segurança ligação. Existe um novo grupo que foi criado durante o processo de criação do cluster. Ele deve ter o nome começando com "EC2ContainerService-sample-rails-app-cluster". Clique nele e edite as regras de entrada. Como queremos permitir qualquer tráfego da nossa VPC, aceda ao painel Amazon VPC e verifique qual é o CIDR IPv4 da sua VPC. Defina o tipo de regra como "Todo o tráfego" e a fonte para IPv4 CIDR. Guarde esta regra e tente carregar o nome DNS do equilibrador. 

Espero que vejam como eu vejo 🙂

Ler mais

Ruby GraphQL. E quanto ao desempenho?

Carris e outros meios de transporte

Desenvolvimento Rails com TMUX, Vim, Fzf + Ripgrep