Learn RabbitMQ - Prerequisite Skills & Environment Setup

#Introduction

Welcome to the Learn RabbitMQ series! This series will take you through mastering RabbitMQ — the most popular open-source message broker based on the Advanced Message Queuing Protocol (AMQP) — from the conceptual foundations to production readiness. There are 33 episodes in total, organized into six phases.

But before touching rabbitmq-server, there are some basic skills and software you must have. Why are these prerequisites important? Because RabbitMQ is not just an application you can install and immediately use. It is a distributed system that communicates over TCP/IP networks, stores messages, and is accessed by many clients in different languages. Without a basic understanding of how networking and message passing work, this entire series will feel confusing.

Episode 0 is your roadmap: we will make sure your basic skills are in place, set up the environment, install RabbitMQ along with Erlang/OTP, and do the first verification. Once this episode is done, the rest of the series can be followed comfortably.

#Essential Skills to Master

#Client-Server Architecture and Networking

RabbitMQ is a server that serves many clients. You must understand that clients connect to the server over a TCP port, send requests, then wait for responses. Also understand TCP/IP basics: what an IP address is, ports, and the TCP handshake. By default, RabbitMQ listens on port 5672 for AMQP.

Understanding asynchronous programming is also important. Publishers and consumers in RabbitMQ typically work without synchronously waiting for each other. Understand the concepts of event loop, callback, and promise — at least in one programming language.

#Distributed Systems, JSON, and HTTP/REST

Some distributed systems concepts you must understand: decoupling, fault tolerance, consistency, and eventual consistency. You don't need to be an expert — just understand why two services should not directly depend on each other.

Since RabbitMQ messages are often serialized as JSON, master the JSON syntax and the concept of serialization. Finally, basic HTTP/REST comes in handy when you use the Management API. Try inspecting the Management API endpoint:

curl -s -u guest:guest http://localhost:15672/api/overview | head -n 5

The curl command above uses the default guest:guest credentials, and we'll dig into the details in episode 3.

#Software and Tools to Prepare

#RabbitMQ Server and Erlang/OTP

RabbitMQ is built on top of Erlang/OTP, so both components must be installed and their versions must be compatible. For this series we use RabbitMQ version 3.13.x stable. Check the required Erlang version in the official RabbitMQ documentation before installing.

erl -version

If Erlang is not yet installed, install it via your system's package manager. The most practical alternative is to use Docker, since the official rabbitmq image already ships with a matching Erlang — this is the path we will use.

#Management Plugin, Docker, and Client SDK

Also prepare Docker and Docker Compose for the containerized setup in episodes 3 and 29:

docker --version
docker compose version

Choose one programming language for practice: Python with pika, Node.js with amqplib, or Go with amqp091-go. For testing the Management API, prepare cURL or Postman. Any text editor of your choice works — VS Code is enough for every episode.

#Minimum Hardware and Environment Verification

#Hardware Requirements

In general, the hardware needed for learning is fairly light: at least 2GB RAM (4GB or more recommended), at least 5GB of free storage, and a dual-core CPU minimum. If you run RabbitMQ inside Docker, make sure the container resources are not limited too much.

One important note: the hardware requirements above are for a single learning node. When you reach episodes 19-20 about clustering and quorum queues, those requirements multiply according to the number of nodes. For now, the minimum specs are more than enough to run all the examples in this series.

#Verifying the First Installation

Once RabbitMQ is running, make sure the node status is healthy:

rabbitmqctl status
rabbitmqctl list_queues name

The rabbitmqctl status command displays node information such as the Erlang version, memory, and disk. Also pay attention to the file descriptors section: the number in use is an indicator of how many connections are currently open. If everything runs smoothly, your environment is ready.

#Verifying Ports and Connectivity

Besides node status, make sure the ports in use are actually listening. AMQP defaults to port 5672, and the Management UI to port 15672:

ss -tlnp | grep -E '5672|15672'

If both ports appear in the list, the broker is ready to accept client connections. Conversely, if port 5672 does not appear, double-check whether the RabbitMQ service is actually running — the most common mistake at this stage is that RabbitMQ is installed but not started.

#Setting Up the Workspace and Project Structure

#Folder Structure for the Entire Series

Before moving to the next episode, get into the habit of setting up a tidy workspace. Every episode has its own code examples; store them in separate folders so they don't get mixed up. A simple recommended structure:

mkdir -p belajar-rabbitmq
cd belajar-rabbitmq
git init

With git initialized at the workspace level, every code change can be tracked and rolled back easily. You will also create a dedicated folder per episode when you start writing publisher and consumer examples in episode 4.

#Verification Checklist Before Moving On

Before closing episode 0, make sure every item below is satisfied:

• RabbitMQ is running and rabbitmqctl status shows a healthy node.
• Ports 5672 (AMQP) and 15672 (Management UI) are listening.
• Docker and Docker Compose are ready for a containerized setup.
• One client SDK is installed in your language of choice.
• The default guest:guest credentials can log in to the Management UI (episode 3 will create your own user).

If even one item is missing, don't continue to episode 1 yet. Incomplete prerequisites are the most common cause of confusion in the early episodes.

#Summary of Skills to Master

A recap of the prerequisites you have prepared in episode 0:

• Client-server architecture and basic networking: TCP/IP, ports, and protocols.
• Asynchronous programming in at least one language.
• Basics of distributed systems: decoupling, fault tolerance, consistency.
• JSON and serialization, plus basic HTTP/REST for the Management API.
• RabbitMQ 3.13.x + compatible Erlang/OTP, or Docker as an alternative.
• cURL, the Management Plugin, and one client SDK of your choice.
• Minimum hardware: 2GB RAM, 5GB storage, dual-core CPU.

If anything is missing, stop and complete it before continuing. A strong foundation will make the next 32 episodes feel much lighter.

#Conclusion

In episode 0 you have laid the groundwork for the entire series: understanding client-server and networking concepts, setting up RabbitMQ with Erlang/OTP, and verifying the first operation via rabbitmqctl status.

Key takeaways:

• RabbitMQ is a server that serves many clients over TCP/IP on port 5672.
• Master the basics of asynchronous programming before writing publishers and consumers.
• Erlang/OTP is the foundation of RabbitMQ, and the versions must be compatible.
• Docker is the fastest path to running a consistent RabbitMQ.
• rabbitmqctl status is your first gate to ensuring the node is healthy.
• Prepare one programming language and cURL for practice throughout the series.

In the next episode we will discuss the history, background, and why we need a message broker — from the evolution of direct communication toward message queuing, the birth of the AMQP protocol, to where RabbitMQ stands compared to Apache Kafka and other solutions. Make sure your environment is ready, because the Learn RabbitMQ journey is just beginning!