Programmering av WebSockets og sanntidssystemer · leksjon

Lastbalansering av WebSocket

Konfigurer lastbalanserere (for eksempel Nginx og HAProxy) slik at de håndterer klebrige økter og WebSocket-oppgraderinger korrekt.

Leksjon 2 av 411 trinn

Lastbalansering av WebSocket er en gratis leksjon i Programmering av WebSockets og sanntidssystemer på CoddyKit. Dette er leksjon 2 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Programmering av WebSockets og sanntidssystemer, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Programmering av WebSockets og sanntidssystemer inneholder totalt 4 leksjoner.

Skalering av WebSockets med lastbalanserere

Når WebSocket-applikasjonen vokser, er det ikke sikkert at én server kan håndtere alle tilkoblingene effektivt. Lastbalansering hjelper ved å fordele disse tilkoblingene mellom flere servere.

Dette forbedrer ytelsen og påliteligheten og gjør at applikasjonen kan håndtere flere brukere. Det er et viktig trinn for sanntidssystemer med mye trafikk, slik at de er tilgjengelige og svarer raskt.

WebSocket-håndtrykket

I motsetning til vanlige HTTP-tilkoblinger starter WebSockets med en spesiell «handshake»-prosess som bruker HTTP. Klienten sender en innledende HTTP-forespørsel til serveren og ber om å «oppgradere» tilkoblingen.

Forespørselen inneholder bestemte HTTP-headere som signaliserer at protokollen skal byttes. Hvis serveren godtar dette, svarer den med HTTP-statusen 101 Switching Protocols, og tilkoblingen blir deretter en full-dupleks WebSocket-tilkobling.

Lastbalanserere og oppgraderingsheadere

En standard HTTP-lastbalanserer håndterer kanskje ikke WebSocket-oppgraderingsforespørselen riktig. Den må konfigureres spesielt for å videresende de spesielle HTTP-headerne som er nødvendige for håndtrykket. Disse headerne omfatter:

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

Uten riktig videresending vil WebSocket-håndtrykket mislykkes, slik at tilkoblingen ikke kan opprettes.

Sticky sessions: avgjørende for WebSockets

Når en WebSocket-tilkobling er opprettet, er den vedvarende. Det er ofte avgjørende at alle påfølgende meldinger fra en klient går til den samme backend-serveren som håndterte det innledende håndtrykket og opprettet tilkoblingen.

Dette kalles «sticky session» eller «session persistence». Hvis klientens meldinger rutes til en annen server, vil tilkoblingen brytes eller oppføre seg uforutsigbart, fordi den nye serveren ikke kjenner igjen den eksisterende WebSocket-sesjonen.

Slik fungerer sticky sessions

Lastbalanserere bruker ulike metoder for å sikre sticky sessions:

IP-hash: Lastbalansereren bruker klientens IP-adresse til konsekvent å rute klienten til den samme backend-serveren. Dette er enkelt, men mindre effektivt hvis mange brukere deler en IP-adresse, for eksempel bak en NAT.
Cookie-basert: Lastbalansereren setter en spesiell informasjonskapsel i klientens nettleser. Påfølgende forespørsler inkluderer denne informasjonskapselen, slik at lastbalansereren kan rute dem til riktig server. Denne metoden er vanligvis mer robust.

Nginx: Proxy for WebSocket-oppgraderinger

Nginx er en populær webserver med høy ytelse som også fungerer svært godt som reverse proxy og lastbalanserer. For å håndtere WebSockets må Nginx konfigureres slik at oppgraderingsheaderne videresendes riktig, slik at det innledende HTTP-håndtrykket fullføres.

proxy_set_header-direktivene for Upgrade og Connection er avgjørende. Det anbefales også en lang proxy_read_timeout for vedvarende WebSocket-tilkoblinger.

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: Implementering av sticky sessions

For å sikre sticky sessions med Nginx kan du bruke direktivet ip_hash i upstream-blokken. Dette direktivet sørger for at forespørsler fra samme klient-IP-adresse konsekvent rutes til den samme backend-serveren.

Dette er enkelt å sette opp, men husk at IP-hash kanskje ikke er ideelt i alle scenarier, særlig når flere brukere deler én offentlig IP-adresse.

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: Grunnleggende WebSocket-konfigurasjon

HAProxy er en annen kraftig og mye brukt lastbalanserer med åpen kildekode, særlig kjent for høy tilgjengelighet og avanserte rutingsfunksjoner. Konfigurering av HAProxy for WebSockets innebærer å angi riktig driftsmodus (mode http) og opprette regler for å identifisere og rute WebSocket-trafikk.

En Access Control List (ACL) brukes ofte til å oppdage headeren Upgrade: websocket og dirigere trafikken til en bestemt backend-servergruppe.

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-baserte sticky sessions

For mer robuste sticky sessions kan HAProxy sette inn en informasjonskapsel i klientens nettleser som identifiserer den bestemte backend-serveren klienten er koblet til. Klienten sender deretter denne informasjonskapselen med alle påfølgende forespørsler, slik at de konsekvent rutes til den samme serveren.

Denne metoden gir bedre binding enn IP-hash, særlig i miljøer der klientens IP-adresse kan endres eller deles.

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

Sjekk forståelsen din

Hvilke av de følgende punktene er viktige å ta hensyn til når du konfigurerer en lastbalanserer for WebSocket-trafikk?

Besvar den i den interaktive leksjonen

Oppsummering av lastbalansering for WebSockets

I denne leksjonen så vi på de viktigste aspektene ved lastbalansering av WebSocket-applikasjoner:

WebSockets starter med et HTTP-oppgraderingshåndtrykk, og bestemte headere må derfor videresendes riktig av lastbalansereren.
Sticky sessions er avgjørende for at en klient skal beholde den vedvarende tilkoblingen til den samme backend-serveren gjennom hele tilkoblingens levetid.
Lastbalanserere som Nginx og HAProxy kan konfigureres til å håndtere WebSocket-oppgraderinger og implementere sticky sessions ved hjelp av metoder som IP-hash eller cookie-basert ruting.

Å beherske disse konfigurasjonene er avgjørende for å bygge skalerbare, robuste og høytytende sanntidssystemer.

Gratis å komme i gang

Lær deg Programmering av WebSockets og sanntidssystemer med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 12
Leksjoner: 47

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Lastbalansering av WebSocket» gratis?

Ja – hele teksten i «Lastbalansering av WebSocket» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Programmering av WebSockets og sanntidssystemer-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Programmering av WebSockets og sanntidssystemer inneholder totalt 4 leksjoner.

Hva lærer jeg i «Lastbalansering av WebSocket»?

Konfigurer lastbalanserere (for eksempel Nginx og HAProxy) slik at de håndterer klebrige økter og WebSocket-oppgraderinger korrekt. Du øver på Programmering av WebSockets og sanntidssystemer med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Programmering av WebSockets og sanntidssystemer?

Ingen tidligere erfaring er nødvendig. Programmering av WebSockets og sanntidssystemer på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 2 av 4.

Hvor lang tid tar leksjonen «Lastbalansering av WebSocket»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Programmering av WebSockets og sanntidssystemer-leksjonen?

Ja. Alle Programmering av WebSockets og sanntidssystemer-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til Programmering av WebSockets og sanntidssystemer