Praktijkvoorbeelden van Erlang OTP
Analyseer praktijkvoorbeelden en best practices uit grootschalige Erlang OTP-implementaties en leer van successen uit de sector.
Praktijkvoorbeelden van Erlang OTP is een gratis Erlang OTP: programmeren van gedistribueerde en fouttolerante systemen-les op CoddyKit. Dit is les 3 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.
Leren van de giganten van Erlang
Waarom wordt Erlang gekozen voor bedrijfskritieke systemen? De unieke sterke punten ervan – gelijktijdigheid, fouttolerantie en distributie – maken het ideaal voor toepassingen die vrijwel altijd beschikbaar moeten zijn.
Vandaag bekijken we hoe grote projecten uit de praktijk deze functies van Erlang/OTP gebruiken om zeer robuuste en schaalbare systemen te bouwen.
Ericsson AXD 301: betrouwbaarheid in telecommunicatie
Ericssons AXD 301, een enorme ATM-switch, was een van Erlangs eerste en bekendste succesverhalen. Het systeem bereikte een beschikbaarheid van "five nines" (99,999%), wat neerkomt op minder dan 5 minuten downtime per jaar.
Deze indrukwekkende betrouwbaarheid was grotendeels te danken aan:
- Fouttolerantie: Supervisors starten uitgevallen componenten automatisch opnieuw.
- Hot code-upgrades: Software bijwerken zonder de service te onderbreken.
- Procesisolatie: Storingen in één onderdeel leggen niet het hele systeem plat.
De veerkracht van AXD 301 simuleren
De veerkracht van de AXD 301 kwam voort uit processen die konden uitvallen en door supervisors opnieuw konden worden gestart. Dit kleine voorbeeld toont een worker die opzettelijk crasht, waarna de supervisor deze onmiddellijk opnieuw start. Zo wordt een kernprincipe van Ericsson gedemonstreerd.
-module(crash_demo).
-behaviour(gen_server).
-export([start_link/0, init/1, handle_call/3, handle_cast/2, handle_info/2, terminate/2, code_change/3]).
-export([crash_me/0, main/0]).
%% Worker functions (behaves as a gen_server)
start_link() -> gen_server:start_link({local, ?MODULE}, ?MODULE, [], []).
init([]) -> io:format("Worker started!~n"), {ok, nil}.
crash_me() -> gen_server:call(?MODULE, crash).
handle_call(crash, _From, State) ->
io:format("Worker intentionally crashing!~n"),
exit(i_crashed), %% Simulate a crash
{reply, ok, State};
handle_call(_Req, _From, State) -> {reply, ok, State}.
handle_cast(_Msg, State) -> {noreply, State}.
handle_info(_Info, State) -> {noreply, State}.
terminate(_Reason, _State) -> io:format("Worker terminating.~n").
code_change(_OldVsn, State, _Extra) -> {ok, State}.
%% Supervisor part (embedded for this demo)
start_supervisor() ->
supervisor:start_link({local, demo_sup}, ?MODULE, supervisor). %% Pass 'supervisor' as InitArgs
%% This init/1 is for the supervisor behavior callback
init(supervisor) ->
SupFlags = #{strategy => one_for_one, intensity => 1, period => 5},
ChildSpecs = [
#{id => my_worker,
start => {?MODULE, start_link, []}, %% Start the worker part of this module
restart => permanent,
shutdown => 5000,
type => worker,
modules => [?MODULE]}
],
{ok, {SupFlags, ChildSpecs}}.
%% Main entry point for runnable
main() ->
io:format("Starting supervisor and worker...~n"),
{ok, _SupPid} = start_supervisor(),
timer:sleep(100), %% Give worker time to start
io:format("Worker PID before crash: ~p~n", [whereis(?MODULE)]),
crash_me(), %% Trigger crash of the worker part
timer:sleep(100), %% Give supervisor time to restart
io:format("Worker PID after restart: ~p~n", [whereis(?MODULE)]),
ok.WhatsApp: miljarden berichten
WhatsApp verwerkte dagelijks miljarden berichten met een relatief klein engineeringteam, grotendeels dankzij Erlang. De architectuur beheerde enorme aantallen gelijktijdige gebruikersverbindingen efficiënt met behulp van:
- Massale gelijktijdigheid: De lichtgewicht processen van Erlang (miljoenen per knooppunt) maakten het mogelijk talloze gelijktijdige gebruikers te verwerken.
- Berichten doorgeven: Asynchroon berichten doorgeven tussen processen bootste de communicatie in de echte wereld na.
- Distributie: De ingebouwde distributie van Erlang maakte naadloze schaalvergroting over meerdere serverknooppunten mogelijk.
De kern van WhatsApp: eenvoudige berichtenuitwisseling
In de kern draait WhatsApp om processen die berichten versturen. Dit fragment toont twee processen die met elkaar communiceren en illustreert de fundamentele bouwsteen van hun systeem.
-module(messenger).
-export([start_sender/1, start_receiver/0, main/0]).
%% Receiver process
start_receiver() ->
spawn(fun() -> receiver_loop() end).
receiver_loop() ->
receive
{message, From, Msg} ->
io:format("Receiver (~p) got: ~s from ~p~n", [self(), Msg, From]),
From ! {ack, self()},
receiver_loop();
_ ->
io:format("Receiver got unknown message.~n"),
receiver_loop()
end.
%% Sender process
start_sender(ReceiverPid) ->
spawn(fun() -> sender_loop(ReceiverPid) end).
sender_loop(ReceiverPid) ->
Msg = "Hello from sender!",
io:format("Sender (~p) sending '~s' to ~p~n", [self(), Msg, ReceiverPid]),
ReceiverPid ! {message, self(), Msg},
receive
{ack, _Receiver} ->
io:format("Sender (~p) received acknowledgement.~n", [self()]);
_ ->
io:format("Sender got unexpected reply.~n")
end,
timer:sleep(100),
ok. %% Only send one message for this demo
%% Main entry point for runnable
main() ->
io:format("Starting messaging demo...~n"),
Receiver = start_receiver(),
timer:sleep(50), %% Give receiver a moment to start
Sender = start_sender(Receiver),
io:format("Sender PID: ~p, Receiver PID: ~p~n", [Sender, Receiver]),
timer:sleep(500), %% Allow messages to exchange
ok.RabbitMQ: betrouwbare berichtenwachtrijen
RabbitMQ, een veelgebruikte open-sourceberichtenbroker, leunt sterk op Erlang/OTP voor zijn robuustheid en schaalbaarheid. Het biedt belangrijke functies zoals:
- Betrouwbaarheid: Persistente berichtenwachtrijen zorgen ervoor dat berichten niet verloren gaan, zelfs als de server crasht.
- Clustering: Meerdere RabbitMQ-knooppunten kunnen dankzij de distributie van Erlang een cluster vormen en wachtrijen en gegevens delen.
- Fouttolerantie: Supervisors beheren interne componenten en zorgen voor continue werking en automatisch herstel.
Best practice: omarm 'crash first'
Een belangrijke les uit deze praktijkvoorbeelden is Erlangs filosofie van "crash first". In plaats van elke fout te proberen voorkomen, worden systemen ontworpen om netjes te crashen en door een supervisor opnieuw te worden gestart. Deze aanpak leidt tot:
- Eenvoudigere logica voor foutafhandeling.
- Robuustere systemen die automatisch herstellen.
- Gemakkelijkere identificatie van de onderliggende oorzaken dankzij crashrapporten.
Best practice: naadloze hot-upgrades
Een andere krachtige functie die wordt gebruikt in systemen met hoge beschikbaarheid, zoals die van Ericsson, is hot code laden en upgraden. Met Erlang kun je actieve codemodules vervangen zonder de toepassing te stoppen of de status ervan te verliezen.
- Essentieel voor systemen die continu beschikbaar moeten zijn.
- Beperkt onderhoudsvensters tot een minimum.
- Maakt het mogelijk om oplossingen en nieuwe functies snel uit te rollen.
Best practice: schaal met distributie
De ingebouwde ondersteuning van Erlang voor gedistribueerd rekenen is essentieel voor het schalen van systemen zoals WhatsApp en RabbitMQ. Hierdoor kunnen toepassingen naadloos meerdere machines of nodes gebruiken.
- Communicatie tussen nodes: Processen op verschillende machines kunnen communiceren alsof ze lokaal draaien.
- Globale registratie: Registreer procesnamen globaal, zodat ze in het hele cluster vindbaar zijn.
- Fouttolerantie: Verdeel de werklast en zorg dat het uitvallen van één node niet het hele systeem neerhaalt.
Controleer je begrip
Welke van de volgende punten zijn, op basis van de besproken praktijkvoorbeelden, belangrijke voordelen van Erlang/OTP voor het bouwen van zeer beschikbare en schaalbare systemen?
Samenvatting: leren van succes
We hebben onderzocht hoe grote projecten zoals Ericsson AXD 301, WhatsApp en RabbitMQ de unieke sterke punten van Erlang/OTP benutten.
- Fouttolerantie via supervisie zorgt ervoor dat systemen automatisch van fouten kunnen herstellen.
- Hot-code-upgrades maken continue dienstverlening zonder uitvaltijd mogelijk, wat cruciaal is voor kritieke systemen.
- Massale gelijktijdigheid en distributie zijn essentieel voor het schalen van toepassingen en het bouwen van veerkrachtige architecturen.
Deze principes staan centraal bij het ontwerpen en bouwen van robuuste Erlang-toepassingen voor de praktijk.
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 “Praktijkvoorbeelden van Erlang OTP” gratis?
Ja — je kunt hier op het web alle 3 lessen van het leerpad Erlang OTP: programmeren van gedistribueerde en fouttolerante systemen, waaronder “Praktijkvoorbeelden van Erlang OTP”, 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 “Praktijkvoorbeelden van Erlang OTP”?
Analyseer praktijkvoorbeelden en best practices uit grootschalige Erlang OTP-implementaties en leer van successen uit de sector. 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 3 van 4.
Hoe lang duurt de les “Praktijkvoorbeelden van Erlang OTP”?
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
- Ontwerpen voor hoge beschikbaarheid
- Patronen voor gedistribueerde consensus
- Praktijkvoorbeelden van Erlang OTP
- Backpressure- en loadregulatiepatronen