Elixir & Phoenix: Scalable Backend Development · 강의

브로드캐스팅과 Pub/Sub 메시징

Phoenix의 Pub/Sub 시스템을 사용해 연결된 클라이언트에 메시지를 브로드캐스트하여 실시간 업데이트를 구현합니다.

브로드캐스팅과 Pub/Sub 메시징은(는) CoddyKit의 무료 Elixir & Phoenix: Scalable Backend Development 강의입니다. 이것은 4개 중 2번째 강의입니다. 아래에서 전체 강의를 무료로 읽을 수 있으며, 내장 코드 에디터와 24/7 AI 튜터와 함께 브라우저에서 직접 실습할 수 있습니다. 이 강의는 Elixir & Phoenix: Scalable Backend Development 학습 경로의 일부이며, 진행 상황이 웹과 CoddyKit 앱에 동기화됩니다. Elixir & Phoenix: Scalable Backend Development 강의에는 총 4개의 강의가 포함되어 있습니다.

이 강의의 일부는 아직 번역되지 않았으며 영어로 표시됩니다.

Real-time Updates & Broadcasting

Imagine a chat app or a live dashboard. How do all users see new messages or data instantly?

This magic happens through real-time updates, and a key technique behind it is broadcasting. Broadcasting means sending a message to many recipients at once.

Phoenix Pub/Sub Explained

Phoenix provides a powerful Pub/Sub (Publish/Subscribe) system, built on top of Erlang's distributed capabilities, called Phoenix.PubSub.

It allows different parts of your application (or even different nodes in a cluster!) to communicate without direct knowledge of each other.
Think of it as a central message broker: publishers send messages to 'topics', and subscribers receive messages from topics they're interested in.

Topics: Message Channels

In Pub/Sub, a topic is simply a string or atom that categorizes messages. It's like a channel or a subject line for your messages.

For a chat app, topics might be "chat_room:lobby" or "user:123:notifications".
Clients (via Phoenix Channels) subscribe to these topics to receive updates.

Subscribing to Topics

Before a process can receive broadcasted messages, it must subscribe to a topic. In Phoenix Channels, when a client joins a channel, the channel process itself often subscribes to relevant Pub/Sub topics.

The function for this is typically Phoenix.PubSub.subscribe(pubsub_server, topic).

Code: Subscribing (Mocked)

Here's how a process would conceptually subscribe to a topic. We use a mock to make it runnable, but Phoenix.PubSub.subscribe works similarly.

defmodule MockPubSub do
  def subscribe(topic) do
    IO.puts "  [MockPubSub] Process #{inspect(self())} subscribing to :#{topic}"
    # In a real Phoenix.PubSub, this registers the process.
    :ok
  end

  def broadcast(topic, message) do
    IO.puts "  [MockPubSub] Broadcasting '#{message}' to :#{topic}"
    :ok
  end
end

defmodule Main do
  def main() do
    IO.puts "Starting Subscription Demo..."

    # Simulate a process subscribing
    spawn(fn -> 
      MockPubSub.subscribe(:news_feed)
      # In a real app, this process would now await messages
    end)

    Process.sleep(100) # Give time for spawn
    IO.puts "Demo complete."
  end
end

Publishing/Broadcasting Messages

Once processes are subscribed, any part of your application can broadcast a message to a topic. All processes subscribed to that topic will receive the message.

The key function is Phoenix.PubSub.broadcast(pubsub_server, topic, message).

pubsub_server: Usually YourApp.PubSub.
topic: The topic string or atom.
message: Any Elixir term (map, list, string, etc.) to send.

Code: Broadcasting (Mocked)

Let's see how easy it is to broadcast a message using our mock. In a real Phoenix app, you'd use YourApp.PubSub instead of MockPubSub.

defmodule MockPubSub do
  def subscribe(topic) do
    IO.puts "  [MockPubSub] Process #{inspect(self())} subscribing to :#{topic}"
    :ok
  end

  def broadcast(topic, message) do
    IO.puts "  [MockPubSub] Broadcasting '#{message}' to :#{topic}"
    :ok
  end
end

defmodule Main do
  def main() do
    IO.puts "Starting Broadcast Demo..."

    # Simulate broadcasting a message to a 'chat_room:general' topic
    MockPubSub.broadcast(:"chat_room:general", "Hello everyone in the chat!")

    # Another example: sending a notification
    MockPubSub.broadcast(:"user:123:notifications", %{type: :new_message, from: "Alice"})

    IO.puts "Demo complete."
  end
end

Channels & Pub/Sub Integration

Phoenix Channels often act as the bridge between client-side WebSockets and the server-side Pub/Sub system.

When a client sends a message to a channel (e.g., a new chat message), the channel receives it.
The channel then uses Phoenix.PubSub.broadcast/3 to send that message to the relevant topic.
All other channels subscribed to that topic will receive the broadcast and push it down to their connected clients.

Code: Channel Broadcasting Logic

This snippet shows the core logic within a Phoenix Channel's handle_in/3 callback. Remember, MockPubSub stands in for your actual YourApp.PubSub module.

defmodule MockPubSub do
  def broadcast(topic, message) do
    IO.puts "  [MockPubSub] Broadcasting '#{inspect(message)}' to :#{topic}"
    :ok
  end
end

defmodule MyAppWeb.ChatChannel do
  # This simulates a Phoenix Channel module

  @doc "Handles incoming client messages and broadcasts them."
  def handle_in("new_msg", %{"body" => msg_body}, socket) do
    room_id = "general"
    topic = "chat_room:#{room_id}"

    # Construct the message to broadcast
    full_message = %{sender: "client_user", body: msg_body, timestamp: System.system_time(:millisecond)}

    # Broadcast the message to all subscribers of this topic
    MockPubSub.broadcast(topic, full_message)

    # Acknowledge receipt to the client (in a real channel, this is `{:reply, ...}` or `{:noreply, ...}`)
    IO.puts "Channel received message: \"#{msg_body}\". Broadcasting..."
    {:noreply, socket} # In a real channel, this would be the return value
  end

  def main() do
    IO.puts "Simulating a client sending a message to a channel..."
    # Simulate a call to handle_in
    handle_in("new_msg", %{"body" => "Hello from the client!"}, :some_socket_state)
    IO.puts "Demo complete."
  end
end

Pub/Sub Flow Check

Consider a Phoenix application. What is the correct sequence of events when a user sends a chat message that needs to be seen by all other users in the same chat room?

Recap: Broadcasting with Pub/Sub

You've learned how Phoenix's Pub/Sub system enables powerful real-time communication!

Broadcasting sends messages to many recipients via topics.
Phoenix.PubSub is the core module for this.
Processes (like Channels) subscribe to topics to receive messages.
Any part of your app can broadcast to a topic using Phoenix.PubSub.broadcast/3.
Phoenix Channels commonly integrate with Pub/Sub to pass client messages to other connected clients.

Next, we'll explore more advanced real-time features like presence tracking!

자주 묻는 질문

“브로드캐스팅과 Pub/Sub 메시징” 강의는 무료인가요?

네 — “브로드캐스팅과 Pub/Sub 메시징” 전체 내용을 이 웹사이트에서 무료로 읽을 수 있습니다. 인터랙티브하게 실습하려면(내장 코드 에디터와 24/7 AI 튜터), CoddyKit PRO로 업그레이드하면 Elixir & Phoenix: Scalable Backend Development 강의 전체를 잠금 해제할 수 있습니다. Elixir & Phoenix: Scalable Backend Development 강의에는 총 4개의 강의가 포함되어 있습니다.

“브로드캐스팅과 Pub/Sub 메시징”에서 뭘 배우나요?

Phoenix의 Pub/Sub 시스템을 사용해 연결된 클라이언트에 메시지를 브로드캐스트하여 실시간 업데이트를 구현합니다. 브라우저에서 직접 실행하는 실습 코드로 Elixir & Phoenix: Scalable Backend Development을(를) 배우며, 24/7 AI 튜터가 강의를 진행하면서 질문에 답변해줍니다.

Elixir & Phoenix: Scalable Backend Development을(를) 시작하는 데 경험이 필요한가요?

사전 경험은 필요하지 않습니다. CoddyKit의 Elixir & Phoenix: Scalable Backend Development은(는) 초급자부터 고급 학습자까지를 위해 구성되어 있으므로, 여기서 시작하거나 처음부터 시작할 수 있으며 자신의 속도대로 진행할 수 있습니다. 이것은 4개 중 2번째 강의입니다.

“브로드캐스팅과 Pub/Sub 메시징” 강의는 얼마나 걸리나요?

대부분의 CoddyKit 강의는 약 5~10분이 소요됩니다. 각 강의는 간결하고 인터랙티브하여 꾸준한 진행이 가능하며, 웹과 앱에서 중단한 부분부터 바로 시작할 수 있습니다.

이 Elixir & Phoenix: Scalable Backend Development 강의에서 코드를 작성하고 실행할 수 있나요?

네. 모든 Elixir & Phoenix: Scalable Backend Development 강의에는 내장 코드 에디터가 포함되어 있으므로, 브라우저에서 바로 실제 코드를 작성하고 실행한 후 즉시 AI 피드백을 받을 수 있습니다 — 로컬 설정이 필요 없습니다.

이 강의의 모든 강의

← Elixir & Phoenix: Scalable Backend Development(으)로 돌아가기