Elixir แบบกระจายและการจัดกลุ่ม

Welcome to distributed Elixir! This powerful feature allows your applications to run across multiple machines, forming a cluster of interconnected nodes.

Why is this important? It provides:

• Fault Tolerance: If one node fails, others can continue or take over.
• Scalability: Distribute work across many CPUs or servers.
• Concurrency: Manage many concurrent operations with isolated processes.

This capability is built upon the Erlang Virtual Machine (BEAM), which Elixir runs on.

In Elixir, a 'node' is a running instance of the Erlang VM, typically hosting your Elixir application. When you start iex, you're starting a single Elixir node.

For distributed systems, nodes need to be able to find and communicate with each other. This is done by giving them unique names.

To enable communication, each node must have a name. You can start iex with a name using either --sname (short name) or --name (full name).

• --sname: Used for nodes on the same host (e.g., node1@localhost).
• --name: Used for nodes across different hosts (e.g., node1@your_server_ip).

For this lesson, we'll use --sname as we'll simulate nodes on your local machine.

Before nodes can connect, they need to authenticate each other using a 'magic cookie'. This is a shared secret string.

If two nodes have different cookies, they will not be able to connect. This is a vital security feature to prevent unauthorized nodes from joining your cluster.

You set the cookie when starting iex using the --setcookie flag, as shown in the previous example.

Once you have two named iex sessions running with the same cookie, you can connect them using Node.connect/1. The argument is the full atom name of the target node.

Try running this in your node1 IEx session:

After attempting a connection, you can verify which nodes are connected to your current node using Node.list/0. You can also get the name of your current node with Node.self/0.

Run this in any connected IEx session:

Once nodes are connected, processes on different nodes can send messages to each other just like local processes. You just need the remote process's PID.

Let's see a process on node2 spawn, then send a message back to node1. Run the first part in node2, then the second in node1.

You can also explicitly start a new process on a remote node using Node.spawn_link/2 (or Node.spawn/2). This is a fundamental way to distribute work across your cluster.

The first argument is the remote node's name, and the second is a fun (anonymous function) to execute on that node.

For processes to be easily found by name across all connected nodes, you can use :global.register_name/2. This makes a process globally discoverable by its registered name, regardless of which node it's on.

Contrast this with Process.register/2, which only registers a name locally on a single node.

Great job! In this lesson, you've learned the fundamentals of distributed Elixir:

• What Elixir nodes are and why they are named.
• The importance of the 'magic cookie' for secure connections.
• How to connect nodes using Node.connect/1.
• How to check connected nodes with Node.list/0.
• Sending messages and spawning processes across different nodes.
• Using :global.register_name/2 for cluster-wide process discovery.

These concepts are the building blocks for creating highly available and scalable Elixir applications!