Remote Procedure Calls (RPC)
Voer functies uit op externe nodes met RPC, zodat gedistribueerde berekeningen en serviceaanroepen binnen een cluster mogelijk worden.
Remote Procedure Calls (RPC) is een gratis Erlang OTP: programmeren van gedistribueerde en fouttolerante systemen-les op CoddyKit. Dit is les 2 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.
Wat is een remote procedure call?
Stel dat je twee Erlang-programma's hebt die op verschillende machines draaien, of zelfs op dezelfde machine maar in afzonderlijke Erlang-"nodes". Hoe communiceren ze met elkaar?
Een remote procedure call (RPC) is een manier waarop het ene programma (de client) een ander programma (de server) vraagt om een functie uit te voeren, net zoals het een lokale functie zou aanroepen. De client hoeft de details van de netwerkcommunicatie niet te kennen.
De ingebouwde RPC-module van Erlang
Erlang maakt gedistribueerd rekenen eenvoudig met de ingebouwde module rpc. Deze module biedt functies om berekeningen op externe Erlang-nodes aan te roepen of te casten.
rpc:call/4: voor synchrone aanroepen, waarbij de client op een antwoord wacht.rpc:cast/4: voor asynchrone aanroepen, waarbij de client niet op een antwoord wacht.
Dit zijn krachtige hulpmiddelen voor het bouwen van gedistribueerde toepassingen.
RPC instellen
Voordat we RPC kunnen gebruiken, hebben we minstens twee verbonden Erlang-nodes nodig. Elke node heeft een naam en een gedeelde cookie nodig voor authenticatie.
Open twee afzonderlijke terminalvensters en start de Erlang-nodes als volgt:
- Node 1:
erl -sname server_node -setcookie mysecret - Node 2:
erl -sname client_node -setcookie mysecret
Controleer of ze elkaar kunnen pingen: net_adm:ping(server_node@yourhostname).
Synchrone RPC met `rpc:call/4`
De functie rpc:call/4 gebruik je wanneer je onmiddellijk een antwoord van de externe node nodig hebt. De functie accepteert vier argumenten:
Node: de naam van de externe Erlang-node.Module: de module op de externe node waarin de functie staat.Function: de naam van de functie die moet worden uitgevoerd.Args: een lijst met argumenten voor de functie.
Het aanroepende proces wordt geblokkeerd totdat het een antwoord of een fout ontvangt.
Voorbeeld van een RPC-aanroep: servermodule
We maken een eenvoudige module math_server.erl. Sla deze code op en compileer deze op server_node:
1. Sla het bestand op als math_server.erl
2. Compileer het op server_node: c(math_server).
-module(math_server).
-export([add/2, multiply/2]).
add(A, B) ->
A + B.
multiply(A, B) ->
A * B.Voorbeeld van een RPC-aanroep: clientinteractie
Nu kunnen we vanuit client_node de functie math_server:add/2 op afstand aanroepen! Vergeet niet yourhostname te vervangen door de werkelijke hostnaam van je machine.
Typ dit in de Erlang-shell van client_node:
rpc:call(server_node@yourhostname, math_server, add, [10, 5]).RPC-resultaten begrijpen
Wanneer je rpc:call/4 uitvoert, handelt Erlang de netwerkcommunicatie voor je af. Het resultaat van de externe functie-aanroep wordt rechtstreeks teruggegeven aan het aanroepende proces.
Als de externe node niet bestaat, de module niet is geladen of de functie vastloopt, retourneert rpc:call/4 een fouttuple zoals {badrpc, Reason}. Zo kun je mogelijke problemen in je gedistribueerde systeem afhandelen.
Asynchrone RPC met `rpc:cast/4`
Soms heb je geen onmiddellijk antwoord nodig van een externe aanroep. Je wilt alleen een verzoek versturen en doorgaan met je werk. Hiervoor gebruik je rpc:cast/4.
rpc:cast/4 werkt vergelijkbaar met rpc:call/4, maar is een bewerking van het type "versturen en vergeten". De client verstuurt het bericht en wacht niet op een antwoord, waardoor de bewerking niet-blokkerend is.
Voorbeeld van RPC-cast: logboekmodule
We maken een eenvoudige logboekmodule. Sla deze op als logger.erl en compileer de module op server_node:
1. Sla het bestand op als logger.erl
2. Compileer het op server_node: c(logger).
-module(logger).
-export([log_message/1]).
log_message(Message) ->
io:format("~p: Remote log: ~p~n", [self(), Message]).Voorbeeld van RPC-cast: clientinteractie
Gebruik nu vanuit client_node rpc:cast/4 om een logbericht naar server_node te sturen. Let erop dat client_node niet op een antwoord wacht.
Typ dit in de Erlang-shell van client_node (vervang yourhostname):
Je ziet het logbericht verschijnen in de console van server_node!
rpc:cast(server_node@yourhostname, logger, log_message, ["Hello from client!"]).Snelle controle van RPC
Je hebt geleerd over synchrone en asynchrone remote procedure calls in Erlang.
Samenvatting: RPC voor gedistribueerd Erlang
In deze les heb je ontdekt hoe de ingebouwde module rpc van Erlang ervoor zorgt dat functies naadloos op verschillende nodes kunnen worden uitgevoerd.
- We hebben
rpc:call/4behandeld voor synchrone, blokkerende aanroepen wanneer een resultaat nodig is. - We hebben ook
rpc:cast/4behandeld voor asynchrone, niet-blokkerende aanroepen wanneer geen onmiddellijk antwoord nodig is. - Verbonden nodes instellen met gedeelde cookies is essentieel om RPC te laten werken.
RPC vereenvoudigt gedistribueerd programmeren, zodat je eenvoudig toepassingen kunt bouwen die meerdere Erlang-nodes benutten.
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 “Remote Procedure Calls (RPC)” gratis?
Ja — je kunt hier op het web alle 3 lessen van het leerpad Erlang OTP: programmeren van gedistribueerde en fouttolerante systemen, waaronder “Remote Procedure Calls (RPC)”, 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 “Remote Procedure Calls (RPC)”?
Voer functies uit op externe nodes met RPC, zodat gedistribueerde berekeningen en serviceaanroepen binnen een cluster mogelijk worden. 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 2 van 4.
Hoe lang duurt de les “Remote Procedure Calls (RPC)”?
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
- Nodecommunicatie en configuratie
- Remote Procedure Calls (RPC)
- Globale procesregistratie
- Distributiebeveiliging en cookies