0Pricing
Elixir & Phoenix: Scalable Backend Development · Lesson

Broadcasting and Pub/Sub Messaging

Implement real-time updates by broadcasting messages to connected clients using Phoenix's Pub/Sub system.

Broadcasting and Pub/Sub Messaging is a free Elixir & Phoenix: Scalable Backend Development lesson on CoddyKit — lesson 2 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Elixir & Phoenix: Scalable Backend Development learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

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!

Frequently asked questions

Is the “Broadcasting and Pub/Sub Messaging” lesson free?

Yes — the full text of “Broadcasting and Pub/Sub Messaging” is free to read here on the web, and the Elixir & Phoenix: Scalable Backend Development course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Elixir & Phoenix: Scalable Backend Development course, upgrade to CoddyKit PRO.

What will I learn in “Broadcasting and Pub/Sub Messaging”?

Implement real-time updates by broadcasting messages to connected clients using Phoenix's Pub/Sub system. You practise Elixir & Phoenix: Scalable Backend Development with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Elixir & Phoenix: Scalable Backend Development?

No prior experience is required. Elixir & Phoenix: Scalable Backend Development on CoddyKit is structured for beginners through advanced learners; this is — lesson 2 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Broadcasting and Pub/Sub Messaging” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Elixir & Phoenix: Scalable Backend Development lesson?

Yes. Every Elixir & Phoenix: Scalable Backend Development lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

  1. Introduction to Phoenix Channels
  2. Broadcasting and Pub/Sub Messaging
  3. Presence and Live Data Updates
  4. Channel Authentication and Authorization
← Back to Elixir & Phoenix: Scalable Backend Development