Distribuzione di un'applicazione Rails con Amazon ECS

Creiamolo eseguendo rails new sample-rails-appgenerando poi un'azione di base del controllore binari g controller Indice di benvenuto e impostare le rotte al percorso radice come "radice a: welcome#index".

Il nostro obiettivo è quello di vedere questa pagina di benvenuto implementata utilizzando ECS.

Creare un repository con Amazon Elastic Container Registry (ECR)

Amazon ECR è un registro di container. Lo useremo per memorizzare le immagini delle nostre applicazioni e per estrarle da esso in modo che vengano eseguite su ECS.

Andate al vostro Pannello AWS, cercare Contenitore elastico
Registro di sistema e fare clic su Iniziare. Verrà visualizzata la schermata seguente:

Creeremo un repository privato e lo chiameremo esempio di rotaie-app.

Il repository c'è, ma è vuoto. Vogliamo che contenga l'immagine della nostra applicazione. Questo è il passo successivo.

# lancia errori se il file di gemme è stato modificato dopo Gemfile.lock

RUN bundle config --global frozen 1

WORKDIR /app

COPIA il file Gemfile Gemfile.lock ./

ESEGUIRE l'installazione del bundle

COPIA .

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

Poi dovremmo creare un'immagine e inviarla al repository ECR.

Prima di questo, precompiliamo le risorse con `rails assets:precompile`.

A questo punto, andare al repository creato. Nella parte superiore della schermata, si vedrà un Visualizza i comandi push con i dettagli su come farlo.

Nel mio caso (Linux), lo eseguo con queste istruzioni di AWS:

aws ecr get-login-password --region eu-central-1 | docker 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

Assicurarsi che l'utente sia autorizzato a eseguire questa operazione. Ho aggiunto il criterio AmazonElasticContainerRegistryPowerUser al mio utente, che si presenta così:

{
    "Versione": "2012-10-17",
    "Dichiarazione": [
        {
            "Sid": "VisualEditor0",
            "Effetto": "Consenti",
            "Azione": [
                "ecr:GetRegistryPolicy",
                "ecr:DescribeRegistry",
                "ecr:GetAuthorizationToken",
                "ecr:DeleteRegistryPolicy",
                "ecr:PutRegistryPolicy",
                "ecr:PutReplicationConfiguration"
            ],
            "Resource": "*"
        },
        {
            "Sid": "VisualEditor1",
            "Effetto": "Consenti",
            "Azione": "ecr:*",
            "Risorsa": "arn:aws:ecr:*:212516879399:repository/*"
        }
    ]
}

Abbiamo preparato la nostra immagine docker.

Creazione del bilanciatore di carico delle applicazioni

Voglio che il mondo esterno possa connettersi solo al mio Application Load Balancer. Passerà il traffico ai container in esecuzione all'interno del cluster ECS.

Vai a Servizi EC2 -> Bilanciamento del carico -> Bilanciatori di carico, fare clic su Creare un bilanciatore di carico, selezionare Bilanciatore di carico dell'applicazione e fare clic sul pulsante Creare pulsante.

Impostare il nome a campione-rotaie-app-albutilizzare la VPC predefinita e selezionare tutte le sue sottoreti.

Rimane il fatto che Gruppi di sicurezza e Ascoltatori e routing sezioni.

Gruppi di sicurezza

Creeremo un nuovo gruppo di sicurezza per il nostro bilanciatore di carico. Funziona come un firewall; imposteremo le regole per il traffico in entrata e in uscita. Vogliamo accettare il traffico http in entrata (porta TCP 80) e consentire tutto il traffico in uscita. 

A tal fine, fare clic sul pulsante "Creare un nuovo gruppo di sicurezza" link.

Nella sezione "Dettagli di base", impostare nome e descrizione, lasciare la VPC predefinita.

Nel mio caso - nome: "campione-rotaie-app-alb-sg", descrizione: "http dall'esterno, tutto dall'interno"

Aggiungere la regola in entrata con Tipo: HTTP e Fonte: Ovunque-IPv4. Lasciare le regole in uscita così come sono.

Cliccare creare un gruppo di sicurezzaPoi tornate alla scheda in cui stavate creando l'Application Load Balancer, aggiornate i gruppi di sicurezza e aggiungete quello appena creato, rimuovendo quello predefinito.

Ascoltatori e routing

In questa sezione, definiremo dove vogliamo che il bilanciatore di carico passi il traffico. Lasciare Ascoltatore Protocollo e Porto come HTTP e 80, dato che è esattamente quello che vogliamo, e fare clic su "Creare un gruppo target" link.

Impostate il nome a "campione-rotaie-app-alb-tg". L'unica modifica è il numero di porta. Passeremo alla porta 3000, che è quella della nostra applicazione Rails. Ignorare il passo successivo (Obiettivi registrati) e creare il gruppo di destinazione.

Ora tornate alla scheda in cui stavamo creando l'Application Load Balancer, aggiornate il gruppo di destinazione e selezionate quello appena creato.

Il nostro Application Load Balancer è pronto, ora giochiamo con ECS.

Creazione di un cluster ECS

Si vedranno molti termini spaventosi: cluster, task, definizione dei task, servizi. Per semplificare, pensate al cluster come a un gruppo di server (istanze EC2). Su ognuna di esse vengono eseguiti i task, che sono semplicemente un gruppo di container in esecuzione insieme. La definizione dei task descrive quali container fanno parte di un determinato gruppo e quali risorse vogliamo assegnare loro (memoria, cpu). I servizi tengono d'occhio questi task per assicurarsi che ci sia sempre un numero corretto di task sani in esecuzione nel nostro cluster.

Con queste premesse, creiamo il nostro cluster.

Accedere alla pagina ECS e fare clic sul pulsante Cluster collegamento e Crea cluster pulsante. Scegliere la voce "EC2 + Linux Networking" e fare clic su Passo successivo. 

Impostare il nome del cluster su "cluster di app per le rotaie". Scegliere il tipo di istanza EC2, io ho scelto quella t2-micro perché è disponibile nel piano Free Tier. Lasciare il numero di istanze a 1. 

Nella sezione Rete, utilizzare la VPC predefinita e selezionare tutte le sue sottoreti. Fare clic su Crea, attendere un po' e voilà, ecco creato un nuovo cluster ECS.

Definizione del compito

Fare clic sul pulsante Definizioni dei compiti collegamento, quindi Creare una nuova definizione di attività pulsante. Selezionare l'opzione EC2 e fare clic su Passo successivo. L'applicazione che stiamo per eseguire è molto semplice, quindi abbiamo bisogno solo di poche opzioni. 

Set Definizione del compito a "app-rail-campione", quindi passare direttamente alla sezione Definizioni dei contenitori e fare clic su "Aggiungere un contenitore". Nominare il contenitore come "app-rail-campione", e impostare la posizione dell'immagine nel formato "repository-url/image:tag". Nella nuova scheda del browser, andare all'ECR per copiare l'URI dell'immagine. Nel mio caso, era: "212516879399.dkr.ecr.eu-central-1.amazonaws.com/sample-rails-app:latest".

Impostare il limite di memoria sui 300-500MiB raccomandati. Ora, la cosa più complicata: la mappatura delle porte.

La nostra applicazione viene eseguita all'interno di un contenitore sulla porta 3000. Quindi inserire 3000 come porta del contenitore. Inseriamo 0 come porta host, il che significa fondamentalmente che viene selezionata una porta a caso. Fortunatamente, il nostro Application Load Balancer conoscerà questa mappatura delle porte e sarà in grado di indirizzare correttamente il traffico. Possiamo anche eseguire più task su questa singola istanza. 

Aggiungere la variabile d'ambiente RAILS_ENV e impostarlo su produzione.

Ora fare clic su Aggiungi per aggiungere la definizione del nostro contenitore e fare clic su Creare per terminare l'impostazione di Task Definition.

Servizio

Abbiamo il nostro cluster, il bilanciatore di carico e la definizione dei task. Ora dobbiamo in qualche modo eseguire questi task all'interno del nostro cluster. Questo è il compito dei servizi. Andare al cluster appena creato, selezionare l'opzione Servizi e fare clic sulla scheda Creare pulsante. 

Impostare il tipo di lancio su EC2, aggiungere il nome "servizio-app-rotaie-campione". Impostate il numero di attività a 1 e fate clic su Passo successivo. In questa pagina, selezionare il pulsante di opzione Application Load Balancer e scegliere il ruolo IAM esistente. Nella sezione "Container to load balance", si dovrebbe aver già inserito un container corretto "sample-rails-app:0:3000", quindi fare clic su "Add to load balancer".

Per "Production listener port", scegliere 80:HTTP; come nome del gruppo Target, utilizzare quello creato in precedenza - "campione-rotaie-app-alb-tg" e fare clic su Passo successivo. Congedo Ridimensionamento automatico opzioni così come sono, fare clic su Passo successivo e Creare il servizio.

Aggiornare il gruppo di sicurezza ECS

Si può andare alla pagina del cluster creato e controllare il valore di Compiti schede, dovrebbe esserci un'attività in esecuzione. Il servizio è stato avviato. Ora andare alla pagina del servizio EC2, fare clic su Load Balancer e vedere i dettagli del nostro Application Load Balancer. Dovrebbe esserci il suo nome DNS. Copiarlo e aprirlo nel browser. Dovrebbe indirizzarvi alla nostra applicazione. Purtroppo, otteniamo il messaggio "504 time-out del gateway" errore. 

Il problema è nel gruppo di sicurezza del nostro cluster. Le sue regole in entrata non consentono il traffico in arrivo dal bilanciatore di carico. Per risolvere il problema, tornare al pannello EC2 e fare clic sul pulsante Gruppi di sicurezza link. C'è un nuovo gruppo che è stato creato durante il processo di creazione del cluster. Dovrebbe avere un nome che inizia con "EC2ContainerService-sample-rails-app-cluster". Fare clic su di esso e modificare le regole in entrata. Poiché vogliamo consentire il traffico dal nostro VPC, andare al pannello Amazon VPC e controllare il CIDR IPv4 del VPC. Impostare il tipo di regola su "Tutto il traffico" e l'origine in IPv4 CIDR. Salvare questa regola e provare a caricare il nome DNS del bilanciatore. 

Speriamo che tu veda come me 🙂

Per saperne di più

GraphQL Ruby. E le prestazioni?

Rotaie e altri mezzi di trasporto

Sviluppo di Rails con TMUX, Vim, Fzf + Ripgrep