Programmering av WebSockets och system i realtid · Lektion

Lastbalansering av WebSockets

Konfigurera lastbalanserare (t.ex. Nginx, HAProxy) så att de hanterar sticky sessions och WebSocket-upgrades korrekt.

Lektion 2 av 411 steg

Lastbalansering av WebSockets är en gratis lektion i Programmering av WebSockets och system i realtid på CoddyKit. Detta är lektion 2 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Programmering av WebSockets och system i realtid, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Programmering av WebSockets och system i realtid innehåller totalt 4 lektioner.

Skala WebSockets med lastbalanserare

När din WebSocket-applikation växer kanske en enda server inte kan hantera alla anslutningar effektivt. Lastbalansering hjälper genom att fördela anslutningarna mellan flera servrar.

Detta förbättrar prestanda och tillförlitlighet och gör att applikationen kan hantera fler användare. Det är ett viktigt steg för realtidssystem med hög trafik, så att de förblir tillgängliga och svarar snabbt.

WebSocket-handshaken

Till skillnad från vanliga HTTP-anslutningar börjar WebSockets med en särskild ”handshake”-process som använder HTTP. Klienten skickar en inledande HTTP-begäran till servern och ber att anslutningen ska ”uppgraderas”.

Begäran innehåller särskilda HTTP-huvuden som signalerar att protokollet ska bytas. Om servern godkänner svarar den med HTTP-statusen 101 Switching Protocols, och anslutningen blir då en full duplex-WebSocket-anslutning.

Lastbalanserare och upgrade-huvuden

En vanlig HTTP-lastbalanserare kanske inte behandlar WebSocket-begäran om uppgradering korrekt. Den behöver särskild konfiguration för att vidarebefordra de speciella HTTP-huvuden som krävs för handshaken. Dessa huvuden omfattar:

Connection: Upgrade
Upgrade: websocket
Sec-WebSocket-Key
Sec-WebSocket-Version

Utan korrekt vidarebefordran misslyckas WebSocket-handshaken, vilket hindrar anslutningen från att upprättas.

Sticky sessions: avgörande för WebSockets

När en WebSocket-anslutning har upprättats är den bestående. Det är ofta avgörande att alla efterföljande meddelanden från en klient går till samma backend-server som hanterade den inledande handshaken och upprättade anslutningen.

Detta kallas ”sticky session” eller ”session persistence”. Om klientens meddelanden dirigeras till en annan server bryts anslutningen eller fungerar oväntat, eftersom den nya servern inte känner igen den befintliga WebSocket-sessionen.

Så fungerar sticky sessions

Lastbalanserare använder olika metoder för att säkerställa sticky sessions:

IP Hash: Lastbalanseraren använder klientens IP-adress för att konsekvent dirigera klienten till samma backend-server. Det är enkelt, men mindre effektivt om många användare delar en IP-adress (till exempel bakom en NAT).
Cookie-baserad: Lastbalanseraren placerar en särskild cookie i klientens webbläsare. Efterföljande begäranden innehåller denna cookie, vilket gör att lastbalanseraren kan dirigera dem till rätt server. Den här metoden är vanligtvis mer robust.

Nginx: proxiera WebSocket-uppgraderingar

Nginx är en populär webbserver med hög prestanda som även fungerar utmärkt som reverse proxy och lastbalanserare. För att hantera WebSockets behöver Nginx konfigureras så att upgrade-huvudena vidarebefordras korrekt, vilket säkerställer att den inledande HTTP-handshaken slutförs utan problem.

Direktiven proxy_set_header för Upgrade och Connection är avgörande. Dessutom rekommenderas en lång proxy_read_timeout för bestående WebSocket-anslutningar.

http {
    upstream websocket_backend {
        server backend1.example.com;
        server backend2.example.com;
    }

    server {
        listen 80;
        server_name example.com;

        location /ws/ {
            proxy_pass http://websocket_backend;
            proxy_http_version 1.1;
            proxy_set_header Upgrade $http_upgrade;
            proxy_set_header Connection "upgrade";
            proxy_read_timeout 86400s; # Long timeout for WebSockets
        }
    }
}

Nginx: implementera sticky sessions

För att säkerställa sticky sessions med Nginx kan du använda direktivet ip_hash i ditt upstream-block. Direktivet säkerställer att begäranden från samma klient-IP-adress konsekvent dirigeras till samma backend-server.

Det är enkelt att använda, men kom ihåg att IP-hashning kanske inte är idealisk i alla scenarier, särskilt när flera användare delar en offentlig IP-adress.

http {
    upstream websocket_backend {
        ip_hash; # Enables sticky sessions by client IP
        server backend1.example.com;
        server backend2.example.com;
    }

    server {
        listen 80;
        server_name example.com;

        location /ws/ {
            proxy_pass http://websocket_backend;
            proxy_http_version 1.1;
            proxy_set_header Upgrade $http_upgrade;
            proxy_set_header Connection "upgrade";
            proxy_read_timeout 86400s;
        }
    }
}

HAProxy: grundläggande WebSocket-konfiguration

HAProxy är en annan kraftfull och välanvänd lastbalanserare med öppen källkod, som särskilt är känd för hög tillgänglighet och avancerade routningsfunktioner. Att konfigurera HAProxy för WebSockets innebär att du anger rätt driftläge (mode http) och skapar regler för att identifiera och dirigera WebSocket-trafik.

En Access Control List (ACL) används ofta för att identifiera huvudet Upgrade: websocket och dirigera trafiken till en specifik backend-serverpool.

frontend http_front
    bind *:80
    mode http
    default_backend ws_backend

backend ws_backend
    mode http
    option http-server-close
    acl is_websocket hdr(Upgrade) -i websocket
    use_backend ws_servers if is_websocket
    default-server inter 1s fall 2 rise 5

backend ws_servers
    mode http
    balance roundrobin
    server web1 192.168.1.1:8000 check
    server web2 192.168.1.2:8000 check

HAProxy: cookie-baserade sticky sessions

För mer robusta sticky sessions kan HAProxy infoga en cookie i klientens webbläsare som identifierar den specifika backend-server som klienten är ansluten till. Klienten skickar sedan denna cookie med alla efterföljande begäranden, vilket säkerställer att de konsekvent dirigeras till samma server.

Den här metoden ger bättre sessionsbeständighet än IP-hashning, särskilt i miljöer där klienternas IP-adresser kan ändras eller delas.

backend ws_servers
    mode http
    balance roundrobin
    cookie SERVERID insert indirect nocache # Insert a cookie
    server web1 192.168.1.1:8000 check cookie s1
    server web2 192.168.1.2:8000 check cookie s2

Kontrollera dina kunskaper

Vilka av följande är viktiga överväganden när du konfigurerar en lastbalanserare för WebSocket-trafik?

Besvara frågan i den interaktiva lektionen

Sammanfattning: lastbalansering av WebSockets

I den här lektionen utforskade vi de viktigaste aspekterna av lastbalansering för WebSocket-applikationer:

WebSockets initieras med en HTTP-upgrade-handshake, vilket kräver att specifika huvuden vidarebefordras korrekt av lastbalanseraren.
Sticky sessions är avgörande för att säkerställa att en klient behåller sin bestående anslutning till samma backend-server under hela anslutningens livscykel.
Lastbalanserare som Nginx och HAProxy kan konfigureras för att hantera WebSocket-uppgraderingar och implementera sticky sessions med metoder som IP-hashning eller cookie-baserad routning.

Att behärska dessa konfigurationer är nyckeln till att bygga skalbara, motståndskraftiga realtidssystem med hög prestanda.

Gratis att börja

Lär dig Programmering av WebSockets och system i realtid med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 12
Lektioner: 47

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Lastbalansering av WebSockets” gratis?

Ja – hela texten till ”Lastbalansering av WebSockets” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Programmering av WebSockets och system i realtid, kan Ni uppgradera till CoddyKit PRO. Kursen i Programmering av WebSockets och system i realtid innehåller totalt 4 lektioner.

Vad lär jag mig i ”Lastbalansering av WebSockets”?

Konfigurera lastbalanserare (t.ex. Nginx, HAProxy) så att de hanterar sticky sessions och WebSocket-upgrades korrekt. Ni övar på Programmering av WebSockets och system i realtid med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Programmering av WebSockets och system i realtid?

Du behöver inga förkunskaper. Utbildningen i Programmering av WebSockets och system i realtid på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 2 av 4.

Hur lång tid tar lektionen ”Lastbalansering av WebSockets”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Programmering av WebSockets och system i realtid-lektionen?

Ja. Varje Programmering av WebSockets och system i realtid-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Programmering av WebSockets och system i realtid