Appels de procédures distantes (RPC)

Imagine you have two Erlang programs running on different machines, or even on the same machine but in separate Erlang "nodes." How do they talk?

Remote Procedure Call (RPC) is a way for one program (the client) to ask another program (the server) to execute a function, just like it would call a local function. The client doesn't need to know the details of network communication.

Erlang makes distributed computing easy with its built-in rpc module. This module provides functions to call or cast computations on remote Erlang nodes.

• rpc:call/4: For synchronous calls, meaning the client waits for a reply.
• rpc:cast/4: For asynchronous calls, where the client doesn't wait for a reply.

These are powerful tools for building distributed applications.

Before we can use RPC, we need at least two Erlang nodes connected. Each node needs a name and a shared cookie for authentication.

Open two separate terminal windows and start Erlang nodes like this:

• Node 1: erl -sname server_node -setcookie mysecret
• Node 2: erl -sname client_node -setcookie mysecret

Make sure they can ping each other: net_adm:ping(server_node@yourhostname).

The rpc:call/4 function is used when you need an immediate answer from the remote node. It takes four arguments:

• Node: The name of the remote Erlang node.
• Module: The module on the remote node where the function resides.
• Function: The name of the function to execute.
• Args: A list of arguments for the function.

The calling process will block until it receives a reply or an error.

Let's create a simple module math_server.erl. Save this code and compile it on server_node:

1. Save as math_server.erl

2. Compile on server_node: c(math_server).

Now, from client_node, we can call the math_server:add/2 function remotely! Remember to replace yourhostname with your actual machine's hostname.

Type this into client_node's Erlang shell:

When you execute rpc:call/4, Erlang handles the network communication for you. The result of the remote function call is returned directly to the calling process.

If the remote node doesn't exist, the module isn't loaded, or the function crashes, rpc:call/4 will return an error tuple like {badrpc, Reason}. This helps you manage potential issues in your distributed system.

Sometimes you don't need an immediate response from a remote call. You just want to send a request and continue your work. This is where rpc:cast/4 comes in.

rpc:cast/4 works similarly to rpc:call/4 but it's a "fire and forget" operation. The client sends the message and does not wait for a reply, making it non-blocking.

Let's create a simple logger module. Save this as logger.erl and compile it on server_node:

1. Save as logger.erl

2. Compile on server_node: c(logger).

Now, from client_node, use rpc:cast/4 to send a log message to server_node. Notice that client_node doesn't wait for a response.

Type this into client_node's Erlang shell (replace yourhostname):

You'll see the log message appear on server_node's console!

You've learned about synchronous and asynchronous remote procedure calls in Erlang.

In this lesson, you explored how Erlang's built-in rpc module enables seamless function execution across different nodes.

• We learned about rpc:call/4 for synchronous, blocking calls when a result is needed.
• We also covered rpc:cast/4 for asynchronous, non-blocking calls when no immediate reply is required.
• Setting up connected nodes with shared cookies is crucial for RPC to work.

RPC simplifies distributed programming, allowing you to build applications that leverage multiple Erlang nodes easily.