Distribuera Rails-app med Amazon ECS

Låt oss skapa den genom att köra rails nytt exempel-rails-appoch genererar sedan en grundläggande styrenhetsåtgärd skenor g styrenhet Välkommen index och ställa in rutter till rotsökvägen som en "root to: welcome#index".

Vårt mål är att se denna välkomstsida distribueras med hjälp av ECS.

Skapa ett repository med Amazon Elastic Container Registry (ECR)

Amazon ECR är ett containerregister. Vi kommer att använda det för att lagra våra appavbildningar och hämta dem från det så att de körs på ECS.

Gå till din AWS-panel, leta efter Elastisk behållare
Register och klicka på Kom igång. Du kommer att se nedanstående skärm:

Vi skapar ett privat arkiv och döper det till prov-rails-app.

Förvaret finns där, men det är tomt. Vi vill att det ska innehålla vår apps bild. Detta är nästa steg.

# kastar fel om Gemfile har ändrats sedan Gemfile.lock

RUN bundle config --global frozen 1

ARBETSDATOR /app

COPY Gemfile Gemfile.lock ./

KÖR installation av paket

COPY . .

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

Sedan ska vi skapa en bild och skicka den till ECR-arkivet.

Innan dess, låt oss förkompilera tillgångar med `rails assets:precompile`.

Gå nu till det skapade förvaret. Längst upp på skärmen ser du en Visa push-kommandon knappen med information om hur du gör detta.

I mitt fall (Linux) kör jag det med dessa AWS-instruktioner:

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 exempel-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

Se till att din användare har behörighet att utföra den här åtgärden. Jag lade till AmazonElasticContainerRegistryPowerUser-policyn till min användare, som ser ut så här:

{
    "Version": "2012-10-17",
    "Uttalande": [
        {
            "Sid": "VisualEditor0",
            "Effekt": "Tillåt",
            "Åtgärd": [
                "ecr:GetRegistryPolicy",
                "ecr:DescribeRegistry",
                "ecr:GetAuthorizationToken",
                "ecr:DeleteRegistryPolicy", "ecr:PutRegistryPolicy
                "ecr:PutRegistryPolicy",
                "ecr:PutReplicationConfiguration"
            ],
            "Resource": "*"
        },
        {
            "Sid": "VisualEditor1",
            "Effekt": "Tillåt",
            "Action": "ecr:*",
            "Resource": "arn:aws:ecr:*:212516879399:repository/*"
        }
    ]
}

Vi har förberett vår dockeravbildning.

Skapa Application Load Balancer

Jag vill att omvärlden bara ska kunna ansluta till min Application Load Balancer. Den kommer att skicka trafik till containrar som körs inuti vårt ECS-kluster.

Gå till EC2-tjänster -> Lastbalansering -> Lastbalanserare, klicka Skapa lastbalanserare, välj Lastbalanserare för applikationer och klicka på Skapa knapp.

Sätt dess namn till prov-rails-app-albAnvänd din standard-VPC och välj alla dess subnät.

Vi är kvar med Säkerhetsgrupper och Lyssnare och routing sektioner.

Säkerhetsgrupper

Vi kommer att skapa en ny säkerhetsgrupp för vår lastbalanserare. Den fungerar som en brandvägg; vi kommer att sätta regler för inkommande och utgående trafik. Vi vill acceptera inkommande http-trafik (TCP-port 80) och tillåta all utgående trafik. 

För att göra detta klickar du på "Skapa en ny säkerhetsgrupp" länk.

I avsnittet "Grundläggande detaljer", ange namn och beskrivning, lämna standard-VPC.

I mitt fall - namn: "prov-rails-app-alb-sg", beskrivning: "http från utsidan, allt från insidan"

Lägg till en regel för inkommande med Type: HTTP och Källa: Var som helst-IPv4. Lämna utgående regler som de är.

Klicka på skapa säkerhetsgrupp, gå sedan tillbaka till fliken där du skapade Application Load Balancer, uppdatera säkerhetsgrupper och lägg till den vi just har skapat, ta bort standardgruppen.

Lyssnare och routing

I det här avsnittet definierar vi vart vi vill att lastbalanseraren ska skicka trafik. Lämna Lyssnare Protokoll och Port som HTTP och 80, eftersom det är precis vad vi vill ha, och klicka på "Skapa målgrupp" länk.

Ställ in namnet till "prov-rails-app-alb-tg". Den enda ändringen är portnumret. Vi kommer att skicka det till port 3000 eftersom det är den för vår Rails-app. Ignorera nästa steg (Registrerade mål) och skapa målgruppen.

Gå nu tillbaka till fliken där vi skapade Application Load Balancer, uppdatera målgruppen och välj den som vi just har skapat.

Vi har vår Application Load Balancer klar, låt oss nu leka med ECS.

Skapa ett ECS-kluster

Det finns en hel del skrämmande termer som du kommer att se - kluster, uppgifter, uppgiftsdefinition, tjänster. För att göra det enklare kan du tänka på klustret som en grupp servrar (EC2-instanser). På var och en av dem kör vi uppgifter, som bara är en grupp containrar som körs tillsammans. Uppgiftsdefinitionen beskriver vilka behållare som finns i en viss grupp och vilka resurser vi vill ge dem (minne, cpu). Tjänster håller ett öga på dessa uppgifter för att se till att det alltid finns rätt antal friska uppgifter som körs i vårt kluster.

Med detta i åtanke ska vi nu skapa vårt kluster.

Gå till ECS-sidan och klicka på Kluster länk och Skapa kluster knappen. Välj alternativet "EC2 + Linux Nätverk" ett och klicka Nästa steg. 

Ställ in klusternamnet till "exempel-rails-app-kluster". Välj EC2-instanstyp, jag tog t2-micro eftersom den är tillgänglig inom Free Tier-planen. Lämna antalet instanser som 1. 

I avsnittet om nätverk använder du din standard-VPC och väljer alla dess undernät. Klicka på create, vänta lite och voila, vi har skapat ett nytt ECS Cluster.

Definition av uppgift

Klicka på Definitioner av uppgifter länk, sedan Skapa en ny uppgiftsdefinition knappen. Välj den EC2 alternativet och klicka på Nästa steg. Den app som vi ska köra är mycket enkel, så vi behöver bara några få alternativ här. 

Ställ in Definition av uppgift namn till "prov-rails-app", gå sedan direkt till Definitioner av behållare avsnitt och klicka på "Lägg till behållare". Namnge behållaren som "prov-rails-app", och ange bildplats i formatet "repository-url/bild:tag". I den nya webbläsarfliken går du till ECR för att kopiera bildens URI. I mitt fall var det: "212516879399.dkr.ecr.eu-central-1.amazonaws.com/sample-rails-app:senaste".

Ställ in din minnesgräns till de rekommenderade 300-500MiB. Nu kommer det svåraste - portmappning.

Vår app körs i en container på port 3000. Så sätt 3000 som containerport. Vi kommer att ange 0 som värdport, vilket i princip innebär att den väljer en slumpmässig port. Lyckligtvis kommer vår Application Load Balancer att känna till denna portmappning och kommer att kunna dirigera trafiken korrekt. Vi kan till och med köra flera uppgifter på den här enda instansen. 

Lägg till miljövariabeln RAILS_ENV och ställ in den på produktion.

Klicka nu på Lägg till för att lägga till vår containerdefinition och klicka på Skapa för att avsluta installationen av Task Definition.

Service

Vi har vårt kluster, vår lastbalanserare och vår uppgiftsdefinition. Nu måste vi på något sätt köra dessa uppgifter i vårt kluster. Detta är tjänsternas jobb. Gå till det nyskapade klustret, välj Tjänster och klicka på fliken Skapa knapp. 

Ställ in lanseringstypen till EC2, lägg till namnet "exempel på järnväg-app-tjänst". Ställ in antalet uppgifter till 1 och klicka på Nästa steg. På den här sidan väljer du alternativknappen Application Load Balancer och väljer den befintliga IAM-rollen för den. I avsnittet "Container to load balance" bör du redan ha angett en korrekt container "sample-rails-app:0:3000", klicka sedan på "Add to load balancer".

För "Production listener port" väljer du 80:HTTP; som målgruppsnamn använder du det vi skapade tidigare - "prov-rails-app-alb-tg" och klicka på Nästa steg. Lämna Automatisk skalning alternativ som de är, klicka på Nästa steg och Skapa tjänst.

Uppdatering av ECS säkerhetsgrupp

Du kan gå till sidan för skapat kluster och kontrollera Uppgifter flikar, det borde finnas en uppgift som pågår. Tjänsten har startat den. Gå nu till EC2-tjänstesidan, klicka på Load Balancers och se vår Application Load Balancers detaljer. Du bör ha dess DNS-namn där. Kopiera det och öppna i webbläsaren. Det bör leda dig till vår app. Tyvärr får vi "504 tidsgräns för gateway" fel. 

Problemet ligger i säkerhetsgruppen i vårt kluster. Dess inkommande regler tillåter inte trafik som kommer in från lastbalanseraren. För att åtgärda det går du tillbaka till EC2-panelen och klickar på Säkerhetsgrupper länk. Det finns en ny grupp som skapades under processen för att skapa kluster. Den bör ha ett namn som börjar med "EC2C-containertjänst - exempel-rails-app-kluster". Klicka på den och redigera de inkommande reglerna. Eftersom vi vill tillåta all trafik från vår VPC, gå till Amazon VPC-panelen och kontrollera vad som är din VPC IPv4 CIDR. Ställ in regeltypen till "All trafik" och källan till IPv4 CIDR. Spara den här regeln och försök att läsa in balanseringssystemets DNS-namn. 

Förhoppningsvis ser du precis som jag 🙂

Läs mer om

GraphQL Ruby. Hur är det med prestanda?

Räls och andra transportmedel

Rails-utveckling med TMUX, Vim, Fzf + Ripgrep