Elixir & Phoenix: Scalable Backend Development · Pelajaran

Elixir Terdistribusi dan Pengelompokan

Hubungkan beberapa node Elixir untuk membentuk klaster yang memungkinkan komunikasi proses terdistribusi dan berbagi sumber daya.

Elixir Terdistribusi dan Pengelompokan adalah pelajaran Elixir & Phoenix: Scalable Backend Development gratis di CoddyKit. Ini adalah pelajaran 1 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Elixir & Phoenix: Scalable Backend Development, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Elixir & Phoenix: Scalable Backend Development mencakup 4 pelajaran total.

Bagian dari pelajaran ini belum diterjemahkan dan ditampilkan dalam bahasa Inggris.

Why Distribute 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.

What is an Elixir Node?

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.

Naming Your Node

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.

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

Secure Node Connections: The Cookie

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.

Making Nodes Talk: Connect

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:

# 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')}")

Checking Node Status

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:

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']

Messaging Across Nodes

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.

# 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

Starting Processes Remotely

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.

# 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)}")

Global Names for Global Access

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.

# 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

Distributed Concepts Check

Time for a quick check on what you've learned about connecting Elixir nodes!

Distributed Elixir Recap

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!

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Elixir Terdistribusi dan Pengelompokan” gratis?

Ya — teks lengkap “Elixir Terdistribusi dan Pengelompokan” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Elixir & Phoenix: Scalable Backend Development, upgrade ke CoddyKit PRO. Kursus Elixir & Phoenix: Scalable Backend Development mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Elixir Terdistribusi dan Pengelompokan”?

Hubungkan beberapa node Elixir untuk membentuk klaster yang memungkinkan komunikasi proses terdistribusi dan berbagi sumber daya. Kamu berlatih Elixir & Phoenix: Scalable Backend Development dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Elixir & Phoenix: Scalable Backend Development?

Tidak diperlukan pengalaman sebelumnya. Elixir & Phoenix: Scalable Backend Development di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 1 dari 4.

Berapa lama pelajaran “Elixir Terdistribusi dan Pengelompokan” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Elixir & Phoenix: Scalable Backend Development ini?

Ya. Setiap pelajaran Elixir & Phoenix: Scalable Backend Development menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Elixir & Phoenix: Scalable Backend Development