Bilanciamento del carico con Docker

• Passaggio 1: creare una semplice applicazione
• Passaggio 2: creare contenitori Docker
• Passaggio 3: configura Nginx
• Passaggio 4: distribuire l'applicazione

Quando si esegue un'applicazione Web, in genere si desidera ottenere il massimo dalle proprie risorse senza dover convertire il software per utilizzare il multithreading o loop di eventi complessi. Docker, tuttavia, fornisce un modo semplice per bilanciare il carico dell'applicazione internamente per ottenere il massimo dalle risorse del server. Questo articolo ti mostrerà come usare Nginx per bilanciare il carico della tua applicazione web usando Docker su CentOS.

Passaggio 1: creare una semplice applicazione

Useremo rust per costruire questa semplice applicazione. Supponendo che tu abbia installato ruggine, corri cargo new webapp –bin. In caso di successo, vedrai una directory chiamata webapp. All'interno di webapp, vedrai un file chiamato Cargo.toml. Aggiungi le seguenti righe:

[dependencies.iron]
version = "*"

Quindi, all'interno del src/main.rsfile, rimuovi tutto e popolalo con il seguente:

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();
}

Nota: non modificare l'IP all'interno dell'applicazione. Questo è configurato in modo che Docker possa ascoltare la tua applicazione.

Al termine, compilare l'applicazione eseguendo cargo build –release. A seconda del server, potrebbero essere necessari alcuni minuti. Se non ci sono errori, prova l'applicazione seguendo questi passaggi:

• Corri target/release/webapp.
• Vai a http://0.0.0.0:3000/nel tuo browser. Sostituisci 0.0.0.0con l'indirizzo IP del tuo server.

Se tutto ha funzionato correttamente, vedrai "Hello Vultr :)" sulla pagina.

Passaggio 2: creare contenitori Docker

Creare un Dockerfilee popolarlo con il seguente:

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

Salva il file. Quindi creare un file chiamato deploy.she popolarlo con il seguente:

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

Quando si esegue questo script, verrà creata l'immagine e distribuito il contenitore in base all'importo impostato (il valore predefinito è 5). Se il contenitore esiste, lo ucciderà e lo rimuoverà dal registro prima che venga nuovamente distribuito.

Passaggio 3: configura Nginx

Ora, crea un file di configurazione Nginx e popolalo con il seguente:

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;
    }
}

Sostituisci 0.0.0.0con l'indirizzo IP del tuo server.

Riavvia Nginx facendo systemctl restart nginx. Risolvi eventuali errori, quindi procedi al passaggio successivo.

Passaggio 4: distribuire l'applicazione

Distribuire l'applicazione eseguendo bash ./deploy.sh.

Puoi controllare lo stato della tua applicazione con docker ps- ci saranno 5 immagini create che iniziano con webapp. Ora, vai http://0.0.0.0:3000/nel tuo browser, vedrai di nuovo il messaggio "Ciao, Vultr :)".

Quindi, che differenza fa esattamente?

Se si esegue un test di riferimento sulla configurazione del bilanciamento del carico, si noterà che vengono utilizzate più risorse del server, che è ciò che si desidera, soprattutto se l'applicazione è costruita in lingue come Nodo in cui verrebbe normalmente a thread singolo. Se è necessario aggiornare l'applicazione, è possibile farlo ed eseguire nuovamente deploy.shper ricostruire l'immagine e distribuire i contenitori.