Elixir og Phoenix: Skalerbar backendutvikling · leksjon

Distribuert Elixir og klyngedannelse

Koble sammen flere Elixir-noder til en klynge for å muliggjøre distribuert prosesskommunikasjon og ressursdeling.

Leksjon 1 av 411 trinn

Distribuert Elixir og klyngedannelse er en gratis leksjon i Elixir og Phoenix: Skalerbar backendutvikling på CoddyKit. Dette er leksjon 1 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Elixir og Phoenix: Skalerbar backendutvikling, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Elixir og Phoenix: Skalerbar backendutvikling inneholder totalt 4 leksjoner.

Hvorfor distribuere Elixir?

Velkommen til distribuert Elixir! Denne kraftige funksjonen lar applikasjonene Deres kjøre på flere maskiner og danne en klynge av sammenkoblede noder.

Hvorfor er dette viktig? Det gir:

Feiltoleranse: Hvis én node svikter, kan andre fortsette eller ta over.
Skalerbarhet: Fordel arbeidet på mange CPU-er eller servere.
Samtidighet: Håndter mange samtidige operasjoner med isolerte prosesser.

Denne funksjonen bygger på Erlang Virtual Machine (BEAM), som Elixir kjører på.

Hva er en Elixir-node?

I Elixir er en «node» en kjørende instans av Erlang VM, som vanligvis er vert for Elixir-applikasjonen Deres. Når De starter iex, starter De én Elixir-node.

I distribuerte systemer må nodene kunne finne og kommunisere med hverandre. Dette gjøres ved å gi dem unike navn.

Gi noden et navn

For å aktivere kommunikasjon må hver node ha et navn. De kan starte iex med et navn ved å bruke enten --sname (kort navn) eller --name (fullt navn).

--sname: Brukes for noder på samme vert (for eksempel node1@localhost).
--name: Brukes for noder på forskjellige verter (for eksempel node1@your_server_ip).

I denne leksjonen bruker vi --sname fordi vi simulerer noder på den lokale maskinen Deres.

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

Sikre nodetilkoblinger: cookien

Før noder kan koble til hverandre, må de autentisere hverandre ved hjelp av en «magisk cookie». Dette er en delt hemmelig streng.

Hvis to noder har forskjellige cookies, kan de ikke koble til hverandre. Dette er en viktig sikkerhetsfunksjon som hindrer uautoriserte noder i å bli med i klyngen Deres.

De angir cookien når De starter iex ved å bruke flagget --setcookie, som vist i forrige eksempel.

Få nodene til å snakke sammen: Koble til

Når De har to navngitte iex-økter som kjører med samme cookie, kan De koble dem sammen med Node.connect/1. Argumentet er det fullstendige atomnavnet til målnoden.

Prøv å kjøre dette i node1-økten Deres i IEx:

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

Kontrollere nodestatus

Etter at De har forsøkt å koble til, kan De kontrollere hvilke noder som er koblet til den gjeldende noden, med Node.list/0. De kan også hente navnet på den gjeldende noden med Node.self/0.

Kjør dette i en hvilken som helst tilkoblet IEx-økt:

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

Sende meldinger mellom noder

Når noder er koblet sammen, kan prosesser på forskjellige noder sende meldinger til hverandre akkurat som lokale prosesser. De trenger bare PID-en til den eksterne prosessen.

La oss se hvordan en prosess på node2 oppretter en prosess og deretter sender en melding tilbake til node1. Kjør første del i node2 og deretter den andre delen i 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

Starte prosesser eksternt

De kan også eksplisitt starte en ny prosess på en ekstern node med Node.spawn_link/2 (eller Node.spawn/2). Dette er en grunnleggende måte å fordele arbeid på i klyngen Deres.

Det første argumentet er navnet på den eksterne noden, og det andre er en fun (anonym funksjon) som skal kjøres på denne noden.

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

Globale navn for global tilgang

For at prosesser enkelt skal kunne finnes ved navn på tvers av alle tilkoblede noder, kan De bruke :global.register_name/2. Dette gjør en prosess globalt søkbar under det registrerte navnet, uavhengig av hvilken node den befinner seg på.

Dette kan sammenlignes med Process.register/2, som bare registrerer et navn lokalt på én 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

Kontroll av distribuerte konsepter

På tide med en kort kontroll av det De har lært om å koble sammen Elixir-noder!

Besvar den i den interaktive leksjonen

Oppsummering av distribuert Elixir

Godt jobbet! I denne leksjonen har De lært det grunnleggende om distribuert Elixir:

Hva Elixir-noder er, og hvorfor de har navn.
Hvor viktig «magic cookie» er for sikre forbindelser.
Hvordan koble til noder ved hjelp av Node.connect/1.
Hvordan kontrollere tilkoblede noder med Node.list/0.
Sende meldinger og starte prosesser på tvers av ulike noder.
Bruke :global.register_name/2 til å finne prosesser i hele klyngen.

Disse konseptene er byggesteinene for å lage svært tilgjengelige og skalerbare Elixir-applikasjoner!

Gratis å komme i gang

Lær deg Elixir med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 12
Leksjoner: 48

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Distribuert Elixir og klyngedannelse» gratis?

Ja – hele teksten i «Distribuert Elixir og klyngedannelse» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Elixir og Phoenix: Skalerbar backendutvikling-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Elixir og Phoenix: Skalerbar backendutvikling inneholder totalt 4 leksjoner.

Hva lærer jeg i «Distribuert Elixir og klyngedannelse»?

Koble sammen flere Elixir-noder til en klynge for å muliggjøre distribuert prosesskommunikasjon og ressursdeling. Du øver på Elixir og Phoenix: Skalerbar backendutvikling med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Elixir og Phoenix: Skalerbar backendutvikling?

Ingen tidligere erfaring er nødvendig. Elixir og Phoenix: Skalerbar backendutvikling på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 1 av 4.

Hvor lang tid tar leksjonen «Distribuert Elixir og klyngedannelse»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Elixir og Phoenix: Skalerbar backendutvikling-leksjonen?

Ja. Alle Elixir og Phoenix: Skalerbar backendutvikling-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til Elixir og Phoenix: Skalerbar backendutvikling