Lastbalans med Docker

När du kör en webbapplikation vill du normalt få ut så mycket som möjligt av dina resurser utan att behöva konvertera din programvara till att använda multithreading eller komplexa händelseloopar. Docker erbjuder dock ett enkelt sätt för dig att lastbalansera din applikation internt för att få ut det mesta av serverresurserna. Den här artikeln kommer att visa dig hur du använder Nginx för att lastbalansera din webbapplikation med Docker på CentOS.

Steg 1: Skapa en enkel applikation

Vi kommer att använda rost för att bygga denna enkla applikation. Förutsatt att du har installerat rost, kör cargo new webapp –bin. Efter framgång kommer du att se en katalog som heter webapp. Inuti webappkommer du att se en fil som heter Cargo.toml. Lägg till följande rader till den:

[dependencies.iron]
version = "*"

Ta sedan src/main.rsbort allt inuti filen och fyll i den med följande:

extern crate iron;

use iron::prelude::*;
use iron::status;

fn main() {
    Iron::new(|_: &mut Request| {
        Ok(Response::with((status::Ok, "Hello Vultr :)")))
    }).http("0.0.0.0:3000").unwrap();
}

Obs: Ändra inte IP-adressen i programmet. Detta är konfigurerat så att Docker kan lyssna på din applikation.

När du är klar kompilerar du programmet genom att köra cargo build –release. Beroende på din server kan det ta några minuter. Om det inte finns några fel, testa programmet genom att följa dessa steg:

• Kör target/release/webapp.
• Navigera till http://0.0.0.0:3000/i din webbläsare. Ersätt 0.0.0.0med din servers IP-adress.

Om allt fungerade korrekt kommer du att se "Hej Vultr :)" på sidan.

Steg 2: Skapa Docker-behållare

Skapa en Dockerfileoch fyll i den med följande:

FROM centos:latest
MAINTAINER User <user@localhost>
RUN yum update -y
COPY ./webapp/target/release/webapp /opt/
EXPOSE 3000
WORKDIR /opt
CMD ./webapp

Spara filen. Skapa sedan en fil som heter deploy.shoch fyll i den med följande:

DEFAULT_PORT=45710
APP_PORT=3000
DEPLOY=5
NAME="webapp"
docker build -t webapp:example . 

for ((i=0; i<DEPLOY; i++)); do
        docker kill $NAME$i ; docker rm $NAME$i
        docker run --name $NAME$i -p 127.0.0.1:$(((i * 1000) + DEFAULT_PORT)):$APP_PORT -d webapp:example
done

När du kör det här skriptet kommer det att bygga bilden och distribuera behållaren baserat på mängden du har angett (standard är 5). Om behållaren finns kommer den att döda och ta bort den från registret innan den distribueras igen.

Steg 3: Konfigurera Nginx

Skapa nu en Nginx-konfigurationsfil och fyll i den med följande:

upstream application {
    server localhost:45710;
    server localhost:46710;
    server localhost:47710;
    server localhost:48710;
    server localhost:49710;
}

server {
    listen 0.0.0.0:80;    
    location / {
    expires 1w;
        proxy_pass http://application;
        proxy_redirect off;
        proxy_http_version 1.1;
        proxy_set_header X-Forwarded-Host $host;
        proxy_set_header Host $host;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

Ersätt 0.0.0.0med din servers IP-adress.

Starta om Nginx genom att göra systemctl restart nginx. Åtgärda eventuella fel och fortsätt sedan till nästa steg.

Steg 4: Implementera applikationen

Distribuera programmet genom att köra bash ./deploy.sh.

Du kan kontrollera statusen för din ansökan med docker ps- det kommer att skapas 5 bilder som börjar med webapp. Nu, navigera till http://0.0.0.0:3000/i din webbläsare, kommer du att se meddelandet "Hej, Vultr :)" igen.

Så, exakt vilken skillnad gör detta?

Om du kör ett benchmarktest mot belastningsbalanseringskonfigurationen, skulle du märka att fler av dina serverresurser används, vilket är vad du skulle vilja, speciellt om din applikation är byggd i språk som Node där den normalt skulle vara entrådad. Om du någonsin behöver uppgradera din applikation kan du göra det och köra om för deploy.shatt bygga om bilden och distribuera dina behållare.