Using RabbitMQ with Go

What is RabbitMQ?

RabbitMQ is an open-source message broker that enables applications to communicate with each other through message passing. It supports various messaging protocols, including AMQP (Advanced Message Queuing Protocol), and is known for its reliability, scalability, and flexibility.

RabbitMQ is widely used in distributed systems for decoupling components, enabling asynchronous processing, and enhancing system scalability. It ensures that messages are not lost and can be processed even if the receiver is not available when the message is sent.

Use Cases:

  • Asynchronous Task Processing: Delaying operations like sending emails or processing large data files.
  • System Decoupling: Allowing parts of a system to operate independently and communicate through messages.
  • Load Balancing: Distributing tasks across multiple worker nodes to balance the load.

Step-by-Step Guide for RabbitMQ with Go


Creating a Producer in Go

Step 1: Import the AMQP Package

First, get the amqp package:

go get

Then, import it in your Go file:

import (

Step 2: Connect to RabbitMQ Server

Establish a connection to the RabbitMQ server:

conn, err := amqp.Dial("amqp://guest:guest@localhost:5672/")
failOnError(err, "Failed to connect to RabbitMQ")
defer conn.Close()

Step 3: Open a Channel

Open a channel, which is where most of the API for getting things done resides:

ch, err := conn.Channel()
failOnError(err, "Failed to open a channel")
defer ch.Close()

Step 4: Declare a Queue

Declare a queue to send messages to:

q, err := ch.QueueDeclare(
    "hello", // name
    false,   // durable
    false,   // delete when unused
    false,   // exclusive
    false,   // no-wait
    nil,     // arguments
failOnError(err, "Failed to declare a queue")

Step 5: Publish a Message

Publish a message to the declared queue:

body := "Hello World!"
err = ch.Publish(
    "",     // exchange
    q.Name, // routing key
    false,  // mandatory
    false,  // immediate
        ContentType: "text/plain",
        Body:        []byte(body),
failOnError(err, "Failed to publish a message")

Creating a Consumer in Go

Step 1: Follow Steps 1 to 4 from Producer Setup

The consumer setup begins similarly, by connecting to RabbitMQ, opening a channel, and declaring the same queue as used by the producer.

Step 2: Start Consuming Messages

Register a consumer to the queue:

msgs, err := ch.Consume(
    q.Name, // queue
    "",     // consumer
    true,   // auto-ack
    false,  // exclusive
    false,  // no-local
    false,  // no-wait
    nil,    // args
failOnError(err, "Failed to register a consumer")

Step 3: Handle Received Messages

Create a Go channel to receive messages and process them:

forever := make(chan bool)

go func() {
    for d := range msgs {
        log.Printf("Received a message: %s", d.Body)
log.Printf(" [*] Waiting for messages. To exit press CTRL+C")


Using RabbitMQ with Go enables efficient message-based communication between different parts of your application or across different applications. This setup is ideal for building scalable, distributed, and decoupled systems.

RabbitMQ's integration with Go, facilitated by the amqp package, makes it easy to implement robust message queuing functionalities in Go applications.