Hantera nätverkspartitioner
Utforska strategier för att hantera nätverksdelningar och sammanslagningar i ett distribuerat Erlang-kluster på ett kontrollerat sätt och bevara systemets integritet.
Hantera nätverkspartitioner är en gratis lektion i Erlang OTP: Programmering av distribuerade och feltoleranta system på CoddyKit. Detta är lektion 1 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Erlang OTP: Programmering av distribuerade och feltoleranta system, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Erlang OTP: Programmering av distribuerade och feltoleranta system innehåller totalt 4 lektioner.
Förstå nätverkspartitioner
I distribuerade system uppstår en nätverkspartition när delar av systemet inte längre kan kommunicera med varandra på grund av nätverksfel. Föreställ er att en bro rasar och delar upp en stad i frånkopplade stadsdelar.
Detta kan leda till ett scenario med "split brain", där olika delar av ert Erlang-kluster tror att de är de enda aktiva delarna. Det leder ofta till inkonsekventa data och störningar i tjänsterna.
Anslutning mellan Erlang-noder
Erlang-noder kommunicerar genom att bilda ett distribuerat system. De ansluter till varandra med hjälp av en process som heter net_kernel. När en nod startar försöker den hitta och ansluta till andra kända noder.
- Använd
-snameför korta namn (lokalt nätverk). - Använd
-nameför fullständiga namn (mellan nätverk). - Alla noder måste ha samma magic cookie av säkerhetsskäl.
Här är en enkel modul. Kompilera den och kör MyNode.get_name(). i Erlang-skalet efter att ni har startat med erl -sname mynode:
-module(my_node).
-export([get_name/0]).
get_name() ->
node().Övervaka nodstatus
Erlang har inbyggda mekanismer för att upptäcka när en nod kopplas från. Funktionen monitor_node/2 gör det möjligt för en process att ta emot meddelanden när statusen för en annan nod ändras (till exempel upp eller ned).
Detta är avgörande för att reagera på oväntade nodfel eller nätverksproblem. Så här kan en process övervaka en annan nod:
-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()]).Bortom enkel frånkoppling
Även om monitor_node är kraftfullt informerar det er främst om att en TCP-anslutning till en nod har brutits. Det behöver inte alltid innebära en fullständig "partition".
Korta nätverksstörningar eller ett långsamt nätverk kan orsaka tillfälliga frånkopplingar, vilket leder till falska positiva resultat. En verklig partition innebär en ihållande oförmåga att kommunicera mellan grupper av noder.
- Nätverksfördröjningar kan fördröja upptäckten.
- Kortvariga avbrott behöver inte motivera en fullständig reaktion från systemet.
- Hälsokontroller på applikationsnivå behövs ofta.
Kvorum och majoriteten vinner
För att undvika "split brain" vid en nätverkspartition använder distribuerade system ofta kvorum. Ett kvorum är det minsta antal noder som måste godkänna en åtgärd (eller helt enkelt vara nåbara) för att den ska anses giltig.
Strategin "majoriteten vinner" är ett vanligt sätt att använda kvorum:
- Endast den partition som innehåller mer än hälften av det totala antalet noder får fortsätta utföra operationer.
- Övriga partitioner (minoriteter) bör stanna eller bli skrivskyddade.
Detta förhindrar motstridiga uppdateringar och säkerställer datakonsistens.
Spåra aktiva medlemmar
För att implementera "majoriteten vinner" behöver varje nod känna till klustrets totala storlek och vilka noder som för närvarande är nåbara. Detta skapar en "medlemskapsorakel".
En fullständig implementation är komplex, men vi kan simulera en enkel nåbarhetskontroll genom att låta varje nod regelbundet "pinga" sina kända grannar. Om en nod kan nå en majoritet av sina grannar betraktar den sig själv som "aktiv".
Här är en konceptuell modul som låter en nod pinga andra noder:
-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.Avskärmning för säkerhet
När en nätverkspartition uppstår och en minoritetpartition identifieras är det viktigt att förhindra att den orsakar skada (till exempel genom att skriva motstridiga data). Denna process kallas avskärmning.
Avskärmning säkerställer att endast den "vinnande" partitionen (majoriteten) kan fortsätta att fungera och ändra delat tillstånd. Vanliga åtgärder för avskärmning är:
- Stänga av tjänster i minoritetspartitionen.
- Inaktivera skrivoperationer.
- Isolera resurser (till exempel databasåtkomst).
Målet är att förhindra att "split brain" förvanskar data.
Samordna divergerande tillstånd
När en nätverkspartition har återhämtat sig och noderna ansluter igen kan deras tillstånd ha utvecklats åt olika håll. Det beror på att den aktiva partitionen fortsatte att utföra operationer medan de isolerade noderna var inaktiva eller utförde andra åtgärder.
Datasamordning är processen att lösa dessa konflikter och återföra alla noder till ett konsekvent tillstånd. Vanliga strategier är:
- Senaste skrivningen vinner (LWW): Den senaste uppdateringen (baserat på tidsstämpeln) väljs.
- Funktioner för konfliktlösning: Applikationsspecifik logik för att slå samman data.
Det är viktigt att utforma systemet för eventual consistency.
Kontroll av partitionsstrategi
Anta ett Erlang-kluster med fem noder. En nätverkspartition uppstår och delar upp klustret i två grupper: nod A och B (grupp 1) samt nod C, D och E (grupp 2). Vilka av följande påståenden om hantering av denna partition är i allmänhet SANT för att upprätthålla dataintegritet och tillgänglighet?
Sammanfattning: motståndskraftiga partitioner
Vi har gått igenom hur nätverkspartitioner hanteras, vilket är en viktig del av att bygga motståndskraftiga distribuerade Erlang-applikationer. Viktiga slutsatser är:
- Upptäckt: Använd hälsokontroller på applikationsnivå utöver enkel frånkoppling.
- Kvorum: Använd strategier som "majoriteten vinner" för att säkerställa att endast en partition är aktiv.
- Avskärmning: Förhindra att minoritetspartitioner orsakar datainkonsekvenser.
- Samordning: Använd strategier för att slå samman divergerande tillstånd när partitioner återhämtar sig.
Dessa principer hjälper era Erlang-system att förbli tillgängliga och konsekventa även vid instabila nätverk.
Lär dig Erlang 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
- 48
Vanliga frågor
Är lektionen ”Hantera nätverkspartitioner” gratis?
Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Erlang OTP: Programmering av distribuerade och feltoleranta system, inklusive ”Hantera nätverkspartitioner”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Erlang OTP: Programmering av distribuerade och feltoleranta system innehåller totalt 4 lektioner.
Vad lär jag mig i ”Hantera nätverkspartitioner”?
Utforska strategier för att hantera nätverksdelningar och sammanslagningar i ett distribuerat Erlang-kluster på ett kontrollerat sätt och bevara systemets integritet. Ni övar på Erlang OTP: Programmering av distribuerade och feltoleranta system 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 Erlang OTP: Programmering av distribuerade och feltoleranta system?
Du behöver inga förkunskaper. Utbildningen i Erlang OTP: Programmering av distribuerade och feltoleranta system 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 1 av 4.
Hur lång tid tar lektionen ”Hantera nätverkspartitioner”?
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 Erlang OTP: Programmering av distribuerade och feltoleranta system-lektionen?
Ja. Varje Erlang OTP: Programmering av distribuerade och feltoleranta system-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
- Hantera nätverkspartitioner
- Distribuerade data med ETS och Mnesia
- Design för skalbarhet och motståndskraft
- Lastbalansering och failover mellan noder