Complexe supervisiebomen
Ontwerp en implementeer ingewikkelde geneste supervisiehiërarchieën om dependencies en foutdomeinen effectief te beheren.
Complexe supervisiebomen 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.
Supervisiebomen: de basis
In Erlang zijn supervisors speciale processen die toezicht houden op andere processen, ook wel kinderen genoemd. Als een kindproces crasht, kan de supervisor het opnieuw starten, zodat de fouttolerantie behouden blijft.
Een supervisieboom ontstaat wanneer een supervisor zelf een kind van een andere supervisor wordt. Zo ontstaat een hiërarchie, vergelijkbaar met een organigram.
Waarom complexe bomen?
Naarmate toepassingen groeien, is één supervisor niet voldoende. Met complexe supervisiebomen kun je:
- Afhankelijkheden beheren: gerelateerde processen groeperen zodat ze samen starten en stoppen.
- Storingen isoleren: een crash in één deel van de boom hoeft geen niet-gerelateerde delen uit te schakelen.
- Modulariteit verbeteren: elke supervisor kan verantwoordelijk zijn voor een specifiek subsysteem, waardoor de toepassing gemakkelijker te begrijpen en te onderhouden is.
Kindspecificatie: werker versus supervisor
Elk proces dat een supervisor beheert, wordt gedefinieerd door een kindspecificatie. Een kindspecificatie vertelt de supervisor hoe het kindproces moet worden gestart, opnieuw gestart en afgesloten.
Belangrijk is dat een kind één van twee typen kan hebben:
worker: een regulier proces (zoals eengen_server) dat toepassingslogica uitvoert.supervisor: een ander supervisorproces dat een genest niveau in de boom vormt.
De werker: my_worker_module
Laten we beginnen met een eenvoudig werkerproces. Deze gen_server wordt het bladknooppunt in onze supervisieboom. Het print alleen berichten wanneer het start of aanroepen ontvangt.
-module(my_worker_module).
-behaviour(gen_server).
-export([start_link/1, init/1, handle_call/3, handle_cast/2, handle_info/2, terminate/2, code_change/3]).
start_link(Id) ->
gen_server:start_link(?MODULE, Id, []).
init(Id) ->
io:format("Worker ~p starting...~n", [Id]),
{ok, Id}.
handle_call(Req, _From, State) ->
io:format("Worker ~p received call: ~p~n", [State, Req]),
{reply, ok, State}.
handle_cast(Msg, State) ->
io:format("Worker ~p received cast: ~p~n", [State, Msg]),
{noreply, State}.
handle_info(Msg, State) ->
io:format("Worker ~p received info: ~p~n", [State, Msg]),
{noreply, State}.
terminate(_Reason, State) ->
io:format("Worker ~p terminating...~n", [State]).
code_change(_OldVsn, State, _Extra) ->
{ok, State}.De geneste supervisor: my_nested_sup
Deze supervisor beheert onze processen van my_worker_module. Hij definieert twee werkers, ‘WorkerA’ en ‘WorkerB’, elk met een iets andere strategie voor opnieuw starten.
Let op hoe de child_specs type => worker definiëren.
-module(my_nested_sup).
-behaviour(supervisor).
-export([start_link/0, init/1]).
start_link() ->
supervisor:start_link({local, ?MODULE}, ?MODULE, []).
init([]) ->
SupFlags = #{
strategy => one_for_one,
intensity => 10,
period => 1
},
ChildSpecs = [
#{
id => worker_A,
start => {my_worker_module, start_link, ["WorkerA"]},
type => worker,
restart => permanent,
shutdown => 5000,
modules => [my_worker_module]
},
#{
id => worker_B,
start => {my_worker_module, start_link, ["WorkerB"]},
type => worker,
restart => transient,
shutdown => 2000,
modules => [my_worker_module]
}
],
{ok, {SupFlags, ChildSpecs}}.De supervisor op het hoogste niveau: my_app_sup
Dit is de wortel van onze complexe boom. Hij houdt toezicht op my_nested_sup. Let op dat de child_spec voor my_nested_sup type => supervisor heeft. Zo bouw je geneste bomen!
-module(my_app_sup).
-behaviour(supervisor).
-export([start_link/0, init/1]).
start_link() ->
supervisor:start_link({local, ?MODULE}, ?MODULE, []).
init([]) ->
SupFlags = #{
strategy => one_for_one,
intensity => 10,
period => 1
},
ChildSpecs = [
#{
id => my_nested_sup_child,
start => {my_nested_sup, start_link, []},
type => supervisor,
restart => permanent,
shutdown => infinity,
modules => [my_nested_sup]
}
],
{ok, {SupFlags, ChildSpecs}}.De complexe boom uitvoeren
Als je onze boom in actie wilt zien, compileer je eerst alle drie de modules (my_worker_module.erl, my_nested_sup.erl, my_app_sup.erl) en start je daarna de supervisor op het hoogste niveau. Je ziet dan dat de werkers worden gestart!
Je kunt supervisor:which_children(PidOrName) gebruiken om de boom te inspecteren.
% In the Erlang shell:
c(my_worker_module).
c(my_nested_sup).
c(my_app_sup).
{ok, MySupPid} = my_app_sup:start_link().
% Check the children of the top-level supervisor:
supervisor:which_children(MySupPid).
% Find the nested supervisor's PID:
{_, NestedSupPid, _, _} = lists:keyfind(my_nested_sup_child, 1, supervisor:which_children(MySupPid)).
% Check the children of the nested supervisor:
supervisor:which_children(NestedSupPid).De hiërarchie visualiseren
Onze complexe supervisieboom ziet er zo uit:
my_app_sup(supervisor op het hoogste niveau)- houdt toezicht op
my_nested_sup(een kindsupervisor)- houdt toezicht op
worker_A(een werkerproces) - houdt toezicht op
worker_B(een werkerproces)
- houdt toezicht op
- houdt toezicht op
Deze structuur zorgt ervoor dat alleen my_nested_sup de crash van worker_A afhandelt. Als my_nested_sup zelf crasht, start my_app_sup deze opnieuw, waardoor worker_A en worker_B weer tot leven komen.
Voordelen van complexe bomen
Complexe supervisiebomen vormen een hoeksteen van robuuste Erlang-toepassingen. Ze bieden:
- Foutisolatie: storingen blijven beperkt tot specifieke takken.
- Logische groepering: onderdelen met verwante functies worden samen onder toezicht gehouden.
- Duidelijke verantwoordelijkheden: elke supervisor heeft een duidelijk afgebakende verzameling processen waarvoor hij verantwoordelijk is.
- Schaalbaarheid: subsystemen kunnen gemakkelijker worden toegevoegd of verwijderd zonder de hele toepassing te verstoren.
Korte controle: supervisiebomen
Welke van de volgende punten zijn belangrijke voordelen van het gebruik van complexe (geneste) supervisiebomen in Erlang?
Samenvatting: complexe supervisie
Vandaag hebben we complexe supervisiebomen in Erlang verkend. We hebben geleerd dat supervisors toezicht kunnen houden op andere supervisors, waardoor geneste hiërarchieën ontstaan. Dit krachtige patroon maakt robuuste fouttolerantie mogelijk door storingen te isoleren, afhankelijkheden te beheren en de modulariteit van je toepassingen te verbeteren. Door kindspecificaties te definiëren met type => supervisor, kun je ingewikkelde en veerkrachtige Erlang-systemen bouwen.
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
Veelgestelde vragen
Is de les “Complexe supervisiebomen” gratis?
Ja — je kunt hier op het web alle 3 lessen van het leerpad Erlang OTP: programmeren van gedistribueerde en fouttolerante systemen, waaronder “Complexe supervisiebomen”, 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 “Complexe supervisiebomen”?
Ontwerp en implementeer ingewikkelde geneste supervisiehiërarchieën om dependencies en foutdomeinen effectief te beheren. 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 “Complexe supervisiebomen”?
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
- Complexe supervisiebomen
- Dynamisch procesbeheer
- Geavanceerde herstartstrategieën
- Supervisor bridges en gemengde proceshiërarchieën