Erlang OTP: programmeren van gedistribueerde en fouttolerante systemen · Les

Netwerkpartities afhandelen

Verken strategieën om netwerkopsplitsingen en -herenigingen in een gedistribueerd Erlang-cluster gecontroleerd af te handelen en de systeemintegriteit te behouden.

Les 1 van 410 stappen

Netwerkpartities afhandelen is een gratis Erlang OTP: programmeren van gedistribueerde en fouttolerante systemen-les op CoddyKit. Dit is les 1 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Erlang OTP: programmeren van gedistribueerde en fouttolerante systemen. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Erlang OTP: programmeren van gedistribueerde en fouttolerante systemen bevat in totaal 4 lessen.

Netwerkpartitionering begrijpen

In gedistribueerde systemen ontstaat een netwerkpartitie wanneer delen van het systeem door netwerkstoringen niet meer met elkaar kunnen communiceren. Je kunt het vergelijken met een ingestorte brug die een stad opsplitst in van elkaar afgesloten wijken.

Dit kan leiden tot een scenario met een "split-brain", waarin verschillende delen van je Erlang-cluster denken dat zij het enige actieve deel zijn. Dit veroorzaakt vaak inconsistenties in gegevens en onderbrekingen van services.

Erlang-nodeconnectiviteit

Erlang-nodes communiceren door samen een gedistribueerd systeem te vormen. Ze maken verbinding met elkaar via een proces met de naam net_kernel. Wanneer een node wordt gestart, probeert deze andere bekende nodes te vinden en ermee te verbinden.

Gebruik -sname voor korte namen (lokaal netwerk).
Gebruik -name voor volledige namen (tussen netwerken).
Alle nodes moeten voor de beveiliging dezelfde magische cookie delen.

Hieronder staat een eenvoudige module. Compileer deze en voer MyNode.get_name(). uit in de Erlang-shell nadat je bent gestart met erl -sname mynode:

-module(my_node).
-export([get_name/0]).

get_name() ->
    node().

De status van nodes bewaken

Erlang biedt ingebouwde mechanismen om te detecteren wanneer een node de verbinding verbreekt. Met de functie monitor_node/2 kan een proces berichten ontvangen wanneer de status van een andere node verandert, bijvoorbeeld naar actief of inactief.

Dit is essentieel om te kunnen reageren op onverwachte nodefouten of netwerkproblemen. Bekijk hoe een proces een andere node kan bewaken:

-module(node_monitor).
-export([start/1]).

start(OtherNode) ->
    Pid = spawn(fun() -> init(OtherNode) end),
    {ok, Pid}.

init(OtherNode) ->
    io:format("~p monitoring ~p~n", [self(), OtherNode]),
    erlang:monitor_node(OtherNode, true),
    receive
        {nodeup, Node} ->
            io:format("Node ~p is UP~n", [Node]);
        {nodedown, Node} ->
            io:format("Node ~p is DOWN!~n", [Node])
    end,
    io:format("Monitor process ~p exiting.~n", [self()]).

Verder dan een eenvoudige verbroken verbinding

Hoewel monitor_node krachtig is, geeft het voornamelijk aan of een TCP-verbinding met een node is verbroken. Dat betekent niet altijd dat er sprake is van een volledige "partitie".

Korte netwerkstoringen of een traag netwerk kunnen tijdelijke verbroken verbindingen veroorzaken, wat tot foutpositieven leidt. Een echte partitie betekent dat groepen nodes gedurende langere tijd niet met elkaar kunnen communiceren.

Netwerkvertraging kan de detectie vertragen.
Korte storingen rechtvaardigen mogelijk geen reactie van het volledige systeem.
Vaak zijn gezondheidscontroles op toepassingsniveau nodig.

Quorum en meerderheid wint

Om een "split-brain" tijdens een netwerkpartitie te voorkomen, gebruiken gedistribueerde systemen vaak een quorum. Een quorum is het minimumaantal nodes dat het eens moet zijn over een bewerking, of simpelweg bereikbaar moet zijn, voordat die als geldig wordt beschouwd.

De strategie "de meerderheid wint" is een veelgebruikte quorumbenadering:

Alleen de partitie met meer dan de helft van alle nodes mag doorgaan met bewerkingen.
Andere partities, de minderheid, moeten stoppen of alleen-lezen worden.

Zo voorkom je conflicterende updates en behoud je consistente gegevens.

Actieve deelnemers bijhouden

Om "de meerderheid wint" te implementeren, moet elke node de totale clustergrootte weten en weten welke nodes momenteel bereikbaar zijn. Zo ontstaat een "lidmaatschapsorakel".

Hoewel een volledige implementatie complex is, kunnen we een eenvoudige bereikbaarheidscontrole simuleren door elke node periodiek bekende andere nodes te laten "pingen". Als een node een meerderheid van zijn andere nodes kan bereiken, beschouwt hij zichzelf als "actief".

Hieronder staat een conceptuele module waarmee een node andere nodes kan pingen:

-module(ping_checker).
-export([start/2, ping_peers/1]).

start(KnownPeers, Interval) ->
    Pid = spawn(fun() -> init(KnownPeers, Interval) end),
    {ok, Pid}.

init(KnownPeers, Interval) ->
    ping_peers(KnownPeers),
    timer:sleep(Interval),
    init(KnownPeers, Interval).

ping_peers(Peers) ->
    io:format("~p: Pinging peers: ~p~n", [node(), Peers]),
    ActivePeers = lists:filter(fun(Peer) ->
        case net_adm:ping(Peer) of
            pong -> true;
            pang -> false
        end
    end, Peers),
    io:format("~p: Reachable peers: ~p~n", [node(), ActivePeers]),
    TotalNodes = length(Peers) + 1, % Include self
    ReachableCount = length(ActivePeers) + 1,
    if
        ReachableCount > TotalNodes / 2 ->
            io:format("~p: I am in the MAJORITY partition!~n", [node()]);
        true ->
            io:format("~p: I am in the MINORITY partition or isolated.~n", [node()])
    end.

Afscherming voor veiligheid

Wanneer er een netwerkpartitie optreedt en een minderheidspartitie wordt vastgesteld, is het cruciaal om te voorkomen dat deze schade veroorzaakt, bijvoorbeeld door conflicterende gegevens te schrijven. Dit proces wordt afscherming genoemd.

Afscherming zorgt ervoor dat alleen de "winnende" partitie, de meerderheid, kan blijven werken en de gedeelde status kan wijzigen. Veelgebruikte acties voor afscherming zijn:

Services in de minderheidspartitie afsluiten.
Schrijfbewerkingen uitschakelen.
Resources isoleren, bijvoorbeeld toegang tot een database.

Het doel is te voorkomen dat een "split-brain" gegevens beschadigt.

Uiteenlopende statussen verzoenen

Nadat een netwerkpartitie is hersteld en nodes opnieuw verbinding hebben gemaakt, kunnen hun statussen uiteenlopen. Dat komt doordat de actieve partitie is doorgegaan met bewerkingen, terwijl de geïsoleerde nodes inactief waren of andere acties uitvoerden.

Gegevensverzoening is het proces waarbij deze conflicten worden opgelost en alle nodes weer in een consistente status worden gebracht. Veelgebruikte strategieën zijn:

Last Write Wins (LWW): de meest recente update, gebaseerd op een tijdstempel, wordt gekozen.
Functies voor conflictoplossing: toepassingsspecifieke logica om gegevens samen te voegen.

Ontwerpen voor uiteindelijke consistentie is essentieel.

Controle van de partitiestrategie

Stel je een Erlang-cluster met vijf nodes voor. Er treedt een netwerkpartitie op, waardoor het cluster in twee groepen wordt gesplitst: Node A en B (groep 1) en Node C, D en E (groep 2). Welke van de volgende uitspraken over het afhandelen van deze partitie zijn over het algemeen WAAR om de integriteit en beschikbaarheid van gegevens te behouden?

Beantwoord dit in de interactieve les

Samenvatting: veerkrachtige partities

We hebben onderzocht hoe je netwerkpartities kunt afhandelen, een essentieel aspect van het bouwen van veerkrachtige gedistribueerde Erlang-toepassingen. De belangrijkste punten zijn:

Detectie: naast eenvoudige verbroken verbindingen ook gezondheidscontroles op toepassingsniveau gebruiken.
Quorum: strategieën zoals "de meerderheid wint" toepassen om ervoor te zorgen dat slechts één partitie actief is.
Afscherming: voorkomen dat minderheidspartities inconsistenties in gegevens veroorzaken.
Verzoening: strategieën gebruiken om uiteenlopende statussen samen te voegen wanneer partities herstellen.

Deze principes helpen je Erlang-systemen beschikbaar en consistent te houden, zelfs bij instabiele netwerken.

Gratis beginnen

Leer Erlang met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 12
Lessen: 48

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Netwerkpartities afhandelen” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Erlang OTP: programmeren van gedistribueerde en fouttolerante systemen, waaronder “Netwerkpartities afhandelen”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Erlang OTP: programmeren van gedistribueerde en fouttolerante systemen bevat in totaal 4 lessen.

Wat leer ik in “Netwerkpartities afhandelen”?

Verken strategieën om netwerkopsplitsingen en -herenigingen in een gedistribueerd Erlang-cluster gecontroleerd af te handelen en de systeemintegriteit te behouden. Je oefent met Erlang OTP: programmeren van gedistribueerde en fouttolerante systemen door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Erlang OTP: programmeren van gedistribueerde en fouttolerante systemen te beginnen?

Ervaring vooraf is niet nodig. Erlang OTP: programmeren van gedistribueerde en fouttolerante systemen op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.

Hoe lang duurt de les “Netwerkpartities afhandelen”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Erlang OTP: programmeren van gedistribueerde en fouttolerante systemen?

Ja. Elke les over Erlang OTP: programmeren van gedistribueerde en fouttolerante systemen bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

Netwerkpartities afhandelen
Gedistribueerde gegevens met ETS en Mnesia
Ontwerp voor schaalbaarheid en veerkracht
Load balancing en failover tussen nodes

← Terug naar Erlang OTP: programmeren van gedistribueerde en fouttolerante systemen