Elixir & Phoenix: Pembangunan Bahagian Belakang Boleh Skala · Pelajaran

Elixir Teragih dan Pengelompokan

Sambungkan berbilang nod Elixir untuk membentuk kelompok yang membolehkan komunikasi proses teragih dan perkongsian sumber.

Pelajaran 1 daripada 411 langkah

Elixir Teragih dan Pengelompokan ialah pelajaran Elixir & Phoenix: Pembangunan Bahagian Belakang Boleh Skala percuma di CoddyKit. Ini ialah pelajaran 1 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Elixir & Phoenix: Pembangunan Bahagian Belakang Boleh Skala, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Elixir & Phoenix: Pembangunan Bahagian Belakang Boleh Skala merangkumi sejumlah 4 pelajaran.

Mengapa Mengagihkan Elixir?

Selamat datang ke Elixir teragih! Ciri hebat ini membolehkan aplikasi anda berjalan pada berbilang mesin dan membentuk kelompok nod yang saling berhubung.

Mengapa perkara ini penting? Ia menyediakan:

Toleransi Kegagalan: Jika satu nod gagal, nod lain boleh terus berjalan atau mengambil alih.
Kebolehskalaan: Agihkan kerja merentasi banyak CPU atau pelayan.
Keserentakan: Urus banyak operasi serentak dengan proses yang terasing.

Keupayaan ini dibina berasaskan Mesin Maya Erlang (BEAM), yang digunakan oleh Elixir.

Apakah Nod Elixir?

Dalam Elixir, 'nod' ialah tika VM Erlang yang sedang berjalan dan biasanya menjadi hos kepada aplikasi Elixir anda. Apabila anda memulakan iex, anda sedang memulakan satu nod Elixir.

Bagi sistem teragih, nod perlu dapat mencari dan berkomunikasi antara satu sama lain. Hal ini dilakukan dengan memberikan nama unik kepada nod tersebut.

Menamakan Nod Anda

Untuk membolehkan komunikasi, setiap nod mesti mempunyai nama. Anda boleh memulakan iex dengan nama menggunakan sama ada --sname (nama pendek) atau --name (nama penuh).

--sname: Digunakan untuk nod pada hos yang sama (contohnya, node1@localhost).
--name: Digunakan untuk nod pada hos yang berbeza (contohnya, node1@your_server_ip).

Untuk pelajaran ini, kami akan menggunakan --sname kerana kami akan mensimulasikan nod pada mesin tempatan anda.

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

Melindungi Sambungan Nod: Kuki

Sebelum nod boleh bersambung, nod tersebut perlu mengesahkan satu sama lain menggunakan 'kuki ajaib'. Kuki ini ialah rentetan rahsia yang dikongsi.

Jika dua nod mempunyai kuki yang berbeza, kedua-duanya tidak dapat bersambung. Ini ialah ciri keselamatan penting untuk menghalang nod yang tidak dibenarkan daripada menyertai kelompok anda.

Anda menetapkan kuki semasa memulakan iex menggunakan bendera --setcookie, seperti yang ditunjukkan dalam contoh sebelumnya.

Membolehkan Nod Berkomunikasi: Connect

Selepas dua sesi iex bernama berjalan dengan kuki yang sama, anda boleh menyambungkannya menggunakan Node.connect/1. Argumen tersebut ialah nama atom penuh nod sasaran.

Cuba jalankan ini dalam sesi IEx node1 anda:

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

Menyemak Status Nod

Selepas mencuba sambungan, anda boleh mengesahkan nod yang disambungkan kepada nod semasa anda menggunakan Node.list/0. Anda juga boleh mendapatkan nama nod semasa anda dengan Node.self/0.

Jalankan ini dalam mana-mana sesi IEx yang bersambung:

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

Pemesejan Merentas Nod

Selepas nod disambungkan, proses pada nod yang berbeza boleh menghantar mesej kepada satu sama lain seperti proses tempatan. Anda hanya memerlukan PID proses jauh tersebut.

Mari lihat proses pada node2 menghasilkan proses baharu, kemudian menghantar mesej kembali kepada node1. Jalankan bahagian pertama dalam node2, kemudian bahagian kedua dalam 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

Memulakan Proses dari Jauh

Anda juga boleh memulakan proses baharu secara jelas pada nod jauh menggunakan Node.spawn_link/2 (atau Node.spawn/2). Ini ialah cara asas untuk mengagihkan kerja merentasi kelompok anda.

Argumen pertama ialah nama nod jauh, manakala argumen kedua ialah fungsi (fungsi tanpa nama) untuk dilaksanakan pada nod tersebut.

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

Nama Global untuk Capaian Global

Untuk membolehkan proses dicari dengan mudah mengikut nama merentasi semua nod yang bersambung, anda boleh menggunakan :global.register_name/2. Ini menjadikan proses boleh ditemui secara global melalui nama berdaftarnya, tanpa mengira nod tempat proses itu berada.

Bandingkan hal ini dengan Process.register/2, yang hanya mendaftarkan nama secara tempatan pada satu nod.

# 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

Semakan Konsep Teragih

Masanya untuk semakan pantas tentang perkara yang telah anda pelajari mengenai penyambungan nod Elixir!

Jawab dalam pelajaran interaktif

Ulang Kaji Elixir Teragih

Tahniah! Dalam pelajaran ini, anda telah mempelajari asas Elixir teragih:

Apakah nod Elixir dan sebab nod tersebut dinamakan.
Kepentingan 'kuki ajaib' untuk sambungan yang selamat.
Cara menyambungkan nod menggunakan Node.connect/1.
Cara menyemak nod yang disambungkan dengan Node.list/0.
Menghantar mesej dan menghasilkan proses merentas nod yang berbeza.
Menggunakan :global.register_name/2 untuk mencari proses di seluruh kelompok.

Konsep-konsep ini ialah asas untuk membina aplikasi Elixir yang sangat tersedia dan boleh diskalakan!

Percuma untuk bermula

Pelajari Elixir dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 12
Pelajaran: 48

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Elixir Teragih dan Pengelompokan” percuma?

Ya — teks penuh “Elixir Teragih dan Pengelompokan” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Elixir & Phoenix: Pembangunan Bahagian Belakang Boleh Skala, tingkat taraf kepada CoddyKit PRO. Kursus Elixir & Phoenix: Pembangunan Bahagian Belakang Boleh Skala merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Elixir Teragih dan Pengelompokan”?

Sambungkan berbilang nod Elixir untuk membentuk kelompok yang membolehkan komunikasi proses teragih dan perkongsian sumber. Anda berlatih Elixir & Phoenix: Pembangunan Bahagian Belakang Boleh Skala menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Elixir & Phoenix: Pembangunan Bahagian Belakang Boleh Skala?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Elixir & Phoenix: Pembangunan Bahagian Belakang Boleh Skala di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 1 daripada 4.

Berapa lamakah pelajaran “Elixir Teragih dan Pengelompokan” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Elixir & Phoenix: Pembangunan Bahagian Belakang Boleh Skala ini?

Ya. Setiap pelajaran Elixir & Phoenix: Pembangunan Bahagian Belakang Boleh Skala menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke Elixir & Phoenix: Pembangunan Bahagian Belakang Boleh Skala