Elixir en Phoenix: schaalbare backendontwikkeling · Les

Gedistribueerd Elixir en clustering

Verbind meerdere Elixir-nodes tot een cluster, zodat gedistribueerde procescommunicatie en het delen van resources mogelijk worden.

Les 1 van 411 stappen

Gedistribueerd Elixir en clustering is een gratis Elixir en Phoenix: schaalbare backendontwikkeling-les op CoddyKit. Dit is les 1 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Elixir en Phoenix: schaalbare backendontwikkeling. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Elixir en Phoenix: schaalbare backendontwikkeling bevat in totaal 4 lessen.

Waarom Elixir distribueren?

Welkom bij gedistribueerd Elixir! Met deze krachtige functie kunnen je toepassingen op meerdere machines draaien en een cluster van onderling verbonden nodes vormen.

Waarom is dit belangrijk? Het biedt:

Fouttolerantie: als één node uitvalt, kunnen andere nodes doorgaan of de taak overnemen.
Schaalbaarheid: verdeel werk over meerdere CPU's of servers.
Gelijktijdigheid: beheer veel gelijktijdige bewerkingen met geïsoleerde processen.

Deze mogelijkheid is gebaseerd op de Erlang Virtual Machine (BEAM), waarop Elixir draait.

Wat is een Elixir-node?

In Elixir is een 'node' een actieve instantie van de Erlang VM, die doorgaans je Elixir-toepassing host. Wanneer je iex start, start je één Elixir-node.

Voor gedistribueerde systemen moeten nodes elkaar kunnen vinden en met elkaar kunnen communiceren. Dit gebeurt door ze unieke namen te geven.

Je node een naam geven

Om communicatie mogelijk te maken, moet elke node een naam hebben. Je kunt iex met een naam starten met --sname (korte naam) of --name (volledige naam).

--sname: wordt gebruikt voor nodes op dezelfde host (bijvoorbeeld node1@localhost).
--name: wordt gebruikt voor nodes op verschillende hosts (bijvoorbeeld node1@your_server_ip).

Voor deze les gebruiken we --sname, omdat we nodes op je lokale machine simuleren.

iex --sname node1 --setcookie mysecret
# In another terminal:
iex --sname node2 --setcookie mysecret

Beveiligde nodeverbindingen: de cookie

Voordat nodes verbinding kunnen maken, moeten ze elkaar verifiëren met een 'magische cookie'. Dit is een gedeelde geheime tekenreeks.

Als twee nodes verschillende cookies hebben, kunnen ze geen verbinding maken. Dit is een belangrijke beveiligingsfunctie die voorkomt dat onbevoegde nodes zich bij je cluster aansluiten.

Je stelt de cookie in wanneer je iex start met de vlag --setcookie, zoals in het vorige voorbeeld wordt getoond.

Nodes laten communiceren: verbinden

Zodra je twee benoemde iex-sessies met dezelfde cookie hebt draaien, kun je ze verbinden met Node.connect/1. Het argument is de volledige atomnaam van de doelnode.

Probeer dit uit te voeren in je node1-IEx-sessie:

# In node1's IEx session:
Node.connect(:'node2@localhost')

# This attempts to connect to 'node2@localhost'.
# Make sure 'node2' is running with a matching cookie!
IO.puts("Connected to node2: #{Node.connected?(:'node2@localhost')}")

De status van nodes controleren

Na een verbindingspoging kun je met Node.list/0 controleren welke nodes met je huidige node zijn verbonden. Je kunt ook de naam van je huidige node ophalen met Node.self/0.

Voer dit uit in een willekeurige verbonden IEx-sessie:

IO.puts("My node: #{inspect(Node.self())}")
IO.puts("Connected nodes: #{inspect(Node.list())}")

# If node1 and node2 are connected,
# Node.list() on node1 would show [:'node2@localhost']

Berichten tussen nodes verzenden

Zodra nodes verbonden zijn, kunnen processen op verschillende nodes net als lokale processen berichten naar elkaar verzenden. Je hebt alleen de PID van het externe proces nodig.

Laten we een proces op node2 starten en vervolgens een bericht terug naar node1 laten verzenden. Voer het eerste deel uit in node2 en het tweede deel in node1.

# In node2's IEx session:
pid_on_node2 = spawn(fn ->
  send(self(), {:hello_from_node2, self()})
  receive do
    {:reply, msg} -> IO.puts("Node2 received reply: #{msg}")
  end
end)
IO.puts("Node2 process ready: #{inspect(pid_on_node2)}")

# In node1's IEx session:
# (assuming node1 received the pid from node2)
receive do
  {:hello_from_node2, pid_on_node2} ->
    IO.puts("Received from Node2: #{inspect(pid_on_node2)}")
    send(pid_on_node2, {:reply, "Thanks, Node2!"})
  after 1000 ->
    IO.puts("No message received from Node2 yet.")
end

Processen op afstand starten

Je kunt ook expliciet een nieuw proces op een externe node starten met Node.spawn_link/2 (of Node.spawn/2). Dit is een fundamentele manier om werk over je cluster te verdelen.

Het eerste argument is de naam van de externe node en het tweede is een fun (anonieme functie) die op die node moet worden uitgevoerd.

# In node1's IEx session:
remote_process_pid = Node.spawn_link(:'node2@localhost', fn ->
  IO.puts("I am a process running on #{inspect(Node.self())}!")
  Process.sleep(2000) # Simulate work
  IO.puts("Process on Node2 finished.")
end)
IO.puts("Spawned process on Node2: #{inspect(remote_process_pid)}")

Globale namen voor globale toegang

Om processen op alle verbonden nodes eenvoudig op naam te kunnen vinden, kun je :global.register_name/2 gebruiken. Hiermee wordt een proces wereldwijd vindbaar via de geregistreerde naam, ongeacht op welke node het zich bevindt.

Vergelijk dit met Process.register/2, waarmee een naam alleen lokaal op één node wordt geregistreerd.

# In node2's IEx session:
:global.register_name(:my_global_worker, self())
IO.puts("Node2 registered :my_global_worker: #{inspect(self())}")

# In node1's IEx session:
# Give a moment for registration to propagate
Process.sleep(100)
worker_pid = :global.whereis_name(:my_global_worker)
IO.puts("Found global worker from Node1: #{inspect(worker_pid)}")

# Now you can send messages to it from Node1
if worker_pid do
  send(worker_pid, "Hello from Node1 to global worker!")
end

Controle van gedistribueerde concepten

Tijd voor een snelle controle van wat je hebt geleerd over het verbinden van Elixir-nodes!

Beantwoord dit in de interactieve les

Samenvatting van gedistribueerd Elixir

Goed gedaan! In deze les heb je de basisprincipes van gedistribueerd Elixir geleerd:

Wat Elixir-nodes zijn en waarom ze een naam hebben.
Het belang van de 'magische cookie' voor veilige verbindingen.
Hoe je nodes verbindt met Node.connect/1.
Hoe je verbonden nodes controleert met Node.list/0.
Berichten verzenden en processen starten op verschillende nodes.
:global.register_name/2 gebruiken om processen in het hele cluster te vinden.

Deze concepten vormen de basis voor het maken van zeer beschikbare en schaalbare Elixir-applicaties!

Gratis beginnen

Leer Elixir 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 “Gedistribueerd Elixir en clustering” gratis?

Ja — de volledige tekst van “Gedistribueerd Elixir en clustering” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Elixir en Phoenix: schaalbare backendontwikkeling wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Elixir en Phoenix: schaalbare backendontwikkeling bevat in totaal 4 lessen.

Wat leer ik in “Gedistribueerd Elixir en clustering”?

Verbind meerdere Elixir-nodes tot een cluster, zodat gedistribueerde procescommunicatie en het delen van resources mogelijk worden. Je oefent met Elixir en Phoenix: schaalbare backendontwikkeling 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 Elixir en Phoenix: schaalbare backendontwikkeling te beginnen?

Ervaring vooraf is niet nodig. Elixir en Phoenix: schaalbare backendontwikkeling 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 “Gedistribueerd Elixir en clustering”?

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 Elixir en Phoenix: schaalbare backendontwikkeling?

Ja. Elke les over Elixir en Phoenix: schaalbare backendontwikkeling 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 Elixir en Phoenix: schaalbare backendontwikkeling