Erlang OTP: programmeren van gedistribueerde en fouttolerante systemen · Les

Gedistribueerde Mnesia en replicatie

Configureer Mnesia voor gedistribueerde werking, inclusief gegevensreplicatie en fouttolerante opslag in een cluster.

Les 3 van 412 stappen

Gedistribueerde Mnesia en replicatie 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.

Introductie tot gedistribueerde Mnesia

Welkom bij de laatste les over Mnesia! Tot nu toe hebben we de basis van Mnesia verkend en geleerd hoe je gegevens met transacties beheert. Nu ontsluiten we de echte kracht ervan: gedistribueerde werking.

Met gedistribueerde Mnesia kan je database zich over meerdere Erlang-knooppunten uitstrekken. Dat biedt grote voordelen op het gebied van fouttolerantie en schaalbaarheid. Stel je voor dat je gegevens beschikbaar blijven, zelfs als sommige servers uitvallen!

Kernconcept: knooppuntenlijst

Om Mnesia over meerdere knooppunten te laten werken, moet de database weten welke knooppunten deel uitmaken van het cluster. Dit wordt beheerd met een expliciete knooppuntenlijst.

Elke Mnesia-instantie op een knooppunt is op de hoogte van de andere knooppunten.
De instantie gebruikt het ingebouwde distributiemechanisme van Erlang om te communiceren.
Gegevens kunnen naar specifieke knooppunten in deze lijst worden gerepliceerd of daar worden opgeslagen.

Zonder deze configuratie draait Mnesia alleen lokaal op één knooppunt.

Een gedistribueerde database initialiseren

Het instellen van een gedistribueerd Mnesia-cluster bestaat uit enkele belangrijke stappen:

Erlang-knooppunten starten: Start elke Erlang-VM met een unieke naam (bijvoorbeeld erl -sname node1@host -setcookie mysecret).
Knooppunten verbinden: Zorg dat alle knooppunten met net_adm:ping/1 met elkaar kunnen communiceren.
Schema maken: Gebruik mnesia:create_schema/1 op alle deelnemende knooppunten en geef een lijst met alle knooppuntnamen door.
Mnesia starten: Roep mnesia:start/0 aan op elk knooppunt.

Hiermee leg je de basis voor je gedistribueerde database.

Code: Mnesia eenvoudig starten

Dit voorbeeld laat de basisstappen zien voor het initialiseren en starten van Mnesia. In een echte gedistribueerde configuratie voer je deze stappen uit op elk verbonden knooppunt nadat je het schema hebt gemaakt.

-module(mnesia_starter).
-export([start/0, stop/0, create_schema/0]).

% To run this in a shell:
% erl -sname mynode@localhost -setcookie mysecret
% c(mnesia_starter).
% mnesia_starter:create_schema().
% mnesia_starter:start().

create_schema() ->
    io:format("Creating Mnesia schema on ~p...\n", [node()]),
    % For a multi-node setup, list all node names here:
    % mnesia:create_schema(['node1@host', 'node2@host']).
    mnesia:create_schema([node()]).

start() ->
    io:format("Starting Mnesia on ~p...\n", [node()]),
    mnesia:start().

stop() ->
    io:format("Stopping Mnesia on ~p...\n", [node()]),
    mnesia:stop().

Gedistribueerde tabellen maken

Zodra je Mnesia-cluster is ingesteld, definieer je de tabellen. Het belangrijkste verschil voor gedistribueerde tabellen is dat je bij het maken ervan de node_list opgeeft.

Het attribuut node_list bepaalt welke knooppunten kopieën van de tabel opslaan.
Je kunt voor elk knooppunt verschillende kopietypen opgeven (disc_copies, ram_copies, disc_only_copies).
Zo krijg je nauwkeurige controle over de plaatsing en replicatie van gegevens.

Mnesia zorgt ervoor dat het tabelschema consistent is op alle knooppunten in de node_list.

Code: definitie van een gedistribueerde tabel

In dit voorbeeld ziet u hoe u een tabel definieert en opgeeft dat deze schijfkopieën op specifieke knooppunten moet hebben. In een praktijksituatie zouden 'node1@host' en 'node2@host' echte Erlang-knooppuntnamen zijn.

-module(distributed_table_def).
-export([create_user_table/0, start_mnesia/0, stop_mnesia/0]).

create_user_table() ->
    io:format("Attempting to create 'user_info' table...\n"),
    % In a distributed system, this list would contain
    % actual node names, e.g., ['node1@host', 'node2@host'].
    % For this runnable demo, we'll use the current node.
    NodeList = [node()], 

    mnesia:create_table(user_info, [
        {attributes, [id, name, email]},
        {disc_copies, NodeList} % Data stored on these nodes
    ]),
    io:format("Table 'user_info' created (or already exists) \n    with disc_copies on ~p.\n", [NodeList]).

start_mnesia() ->
    mnesia:start().

stop_mnesia() ->
    mnesia:stop().

% To run this:
% 1. Start Erlang shell: erl -sname mynode@localhost -setcookie mysecret
% 2. Compile: c(distributed_table_def).
% 3. Run: distributed_table_def:start_mnesia().
% 4. Run: distributed_table_def:create_user_table().

Replicatietypen: schijf versus RAM

Mnesia biedt verschillende replicatiestrategieën voor uw tabelkopieën:

disc_copies: Gegevens worden op schijf opgeslagen en bij het opstarten in RAM geladen. Dit biedt persistentie en fouttolerantie.
ram_copies: Gegevens worden alleen in RAM opgeslagen. De snelste toegang, maar gegevens gaan verloren als het knooppunt crasht, tenzij ze elders zijn gerepliceerd.
disc_only_copies: Gegevens worden alleen op schijf opgeslagen en niet in RAM geladen. De langzaamste toegang, maar met minimaal RAM-gebruik.

Het juiste type hangt af van uw vereisten voor persistentie, prestaties en geheugen.

Consistentie van gedistribueerde gegevens

Wanneer u gegevens naar een gedistribueerde Mnesia-tabel schrijft, garandeert Mnesia atomiciteit op alle knooppunten die bij de transactie betrokken zijn. Dit betekent:

Een transactie wordt óf op alle relevante knooppunten succesvol vastgelegd, óf op alle knooppunten teruggedraaid.
Mnesia handelt de complexiteit van tweefasige commitprotocollen op de achtergrond af.

Zo blijft uw data consistent, zelfs wanneer deze over een cluster is verspreid.

Clusterlidmaatschap beheren

De dynamische aard van Erlang geldt ook voor Mnesia-clusters. U kunt knooppunten aan een actief systeem toevoegen of eruit verwijderen zonder downtime.

Gebruik mnesia:change_table_copy_type/3 of mnesia:add_table_copy/2 om nieuwe kopieën van een tabel aan een knooppunt toe te voegen.
Gebruik mnesia:delete_table_copy/2 om een kopie van een knooppunt te verwijderen.

Met deze bewerkingen kunt u uw Mnesia-cluster horizontaal schalen of onderhoud uitvoeren.

Fouttolerantie door replicatie

Hierin komt gedistribueerde Mnesia echt tot zijn recht! Door gegevens over meerdere knooppunten te repliceren, wordt uw systeem zeer fouttolerant.

Als een knooppunt met een tabel van het type disc_copies uitvalt, kunnen andere knooppunten met kopieën verzoeken blijven afhandelen.
Mnesia synchroniseert de gegevens automatisch wanneer een uitgevallen knooppunt herstelt en opnieuw aan het cluster deelneemt.
U kunt uw systeem zo ontwerpen dat het bestand is tegen meerdere uitgevallen knooppunten, afhankelijk van uw replicatiestrategie.

Deze mogelijkheid om altijd actief te blijven is cruciaal voor kritieke toepassingen.

Controleer uw begrip

Welk type Mnesia-tabelkopie biedt de snelste lees- en schrijftoegang, maar verliest gegevens als het knooppunt crasht en er geen andere kopieën bestaan?

Beantwoord dit in de interactieve les

Samenvatting: gedistribueerde Mnesia

Gefeliciteerd! U hebt nu geleerd hoe u gedistribueerde Mnesia configureert en beheert.

We hebben besproken hoe u Mnesia instelt op meerdere Erlang-knooppunten.
U hebt gezien hoe u tabellen definieert met node_list voor distributie.
We hebben verschillende replicatietypen verkend: disc_copies, ram_copies en disc_only_copies.
Tot slot begrijpt u hoe Mnesia consistentie garandeert en door replicatie fouttolerantie biedt.

Mnesia is een krachtig hulpmiddel voor het bouwen van robuuste, schaalbare en fouttolerante gedistribueerde toepassingen in Erlang.

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 “Gedistribueerde Mnesia en replicatie” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Erlang OTP: programmeren van gedistribueerde en fouttolerante systemen, waaronder “Gedistribueerde Mnesia en replicatie”, 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 “Gedistribueerde Mnesia en replicatie”?

Configureer Mnesia voor gedistribueerde werking, inclusief gegevensreplicatie en fouttolerante opslag in een cluster. 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 “Gedistribueerde Mnesia en replicatie”?

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

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