Jak skonfigurować RabbitMQ

RabbitMQ to jeden z najpopularniejszych brokerów wiadomości, szeroko wykorzystywany do budowy systemów opartych na architekturze mikroserwisowej. Dzięki niemu aplikacje mogą komunikować się asynchronicznie i przetwarzać zadania w swoim czasie.

W tym wpisie skupimy się na tym jak skonfigurować RabbitMQ lokalnie na swoim komputerze oraz podstawową obsługą wiadomości.

Instalacja RabbitMQ

Docker

Najprostszą opcją na skonfigurowanie RabbitMQ lokalnie na komputerze jest użycie narzędzia Docker. Jeśli masz dockera zainstalowanego lokalnie to wystarczy wywołać poniższą komende:

docker run -d --name rabbitmq -p 5672:5672 -p 15672:15672 rabbitmq:4.0-management

W powyższym przykładzie instalujemy RabbitMQ wersję 4, ale nic nie stoi na przeszkodzie, żeby ustawić inną dowolną. Listę dostępnych wersji obrazu można zawsze sprawdzić w repozytorium Dockera.

Po uruchomienie komendy, wchodząc na stronę localhost:15672 powinieneś zobaczyć stronę do logowania do panelu administracyjny RabbitMQ. Domyślnie login i hasło do guest. Po zalogowanie będziesz miał dostępny panel do zarządzania kolejkami.

Jeśli nie masz zainstalowanego lokalnie Dockera, warto rozważyć jego instalację. Jest to świetne narzędzie, które umożliwia szybkie i łatwe uruchamianie aplikacji w izolowanym środowisku. Dzięki temu nie zaśmiecamy systemu operacyjnego, instalując kolejne oprogramowanie czy biblioteki – wszystko jest odizolowane w kontenerach Dockera. Oczywiście Docker ma wiele innych zalet, takich jak eliminowanie problemów związanych z różnicami między środowiskami, ale tutaj chcę podkreślić, że nawet do samych testów różnych narzędzi jest to świetne rozwiązanie.

Ubuntu

Na początek instalujemy serwer RabitMQ:

sudo apt-get install rabbitmq-server

Już po wykaniu tego polecania mamy możliwość pracy z rabbitMQ. Natomiast dobrze byłoby mieć jest lokalnie postawiony panel administracyjny, który pozwoli nam na łatwiejsze zarządzanie tego co się dzieje na serwerze.

Na początek musimy zatrzymać serwer RabbitMQ, aby móc wykonać na nim operację dodatkowej konfiguracji:

sudo service rabbitmq-server stop

Włączamy panel administracyjny:

sudo rabbitmq-plugins enable rabbitmq_management

Na koniec musimy ponownie włączyć serwer:

sudo service rabbitmq-server start

Dzięki tym poleceniom możemy jak wyżej wejść na stronę localhost:15672 panelu administracyjnego.

Tworzenie kolejki w panelu administracyjnym

Na początek przedstawię tworzenie kolejek i wysłanie wiadomości z poziomu panelu administracyjnego.

Dodawanie centrali wiadomości – Exchange

RabbitMQ wykorzystuje Exchange, czyli centralę wiadomości, która kieruje wiadomości do odpowiednich kolejek (nie możemy bezpośrednio wysłać wiadomości na kolejkę).

1. Przejdź do zakładki Exchanges w panelu administracyjnym.
2. Kliknij Add a new exchange.
3. Wpisz nazwę, np. exchange.example.direct.
4. Wybierz typ:
   • direct – wiadomości trafiają do konkretnych kolejek na podstawie klucza routingu,
   • fanout – wiadomość trafia do wszystkich kolejek powiązanych z tą centralą,
   • topic – wiadomości są kierowane na podstawie wzorców (np. log.info lub log.*),
   • headers – routing na podstawie nagłówków wiadomości.
5. Kliknij Add exchange.

Tym sposobem utworzyliśmy centrale wiadomości!

Dodawanie kolejki – Queue

Teraz utworzymy kolejkę, która będzie odbierać wiadomości.

1. Przejdź do zakładki Queues and Streams (w starszych wersje jest samo Queues).
2. Kliknij Add a new queue.
3. Wpisz nazwę, np. example_queue.
4. Możesz zaznaczyć opcje jak durability – czy kolejka ma przetrwać restart serwera.
5. Kliknij Add queue.

Kolejka gotowa! Teraz trzeba ją połączyć z centralą wiadomości.

Wiązanie kolejki z centralą wiadomości – Binding

Aby RabbitMQ mógł przekazywać wiadomości z Exchange do Queue, musimy utworzyć Binding (powiązanie pomiędzy centralą, a kolejką).

1. Przejdź do zakładki Queues i kliknij nazwę example_queue.
2. Rozwiń sekcje Bindings.
3. Wybierz wcześniej utworzony Exchange exchange.example.direct.
4. Ustaw klucz routingu (np. example_routing_key) – wartość po jakiej centrali wiadomości powinna przekierowywać wiadomość do tej kolejki. Oczywiście parametry te powinny być ustawiane zgodnie z naszymi potrzebami oraz typem centrali wiadomości.
5. Kliknij Bind.

Teraz wszystkie wiadomości wysyłane do exchange.example.direct z kluczem example_routing_key trafią do example_queue.

Wysyłanie i pobieranie wiadomości

Publikować wiadomości możemy z dwóch miejsc. Możemy z poziomu szczegółów konkretnej centrali wiadomości lub samej kolejki (wtedy zostanie użyty domyślny exchange).

Będąc w szczegółach kolejki (w tym samym oknie gdzie wiązaliśmy wiadomość) możemy wysłać i pobrać wiadomość.

1. Możemy opublikować wiadomość rozwijając sekcje Publish message.
2. Po uzupełnieniu okna, wysłać wiadomość na kolejkę.
3. Na samej górze mamy wykres, w którym widać ile kolejka ma obecnie wiadomości. Będą tutaj wisieć do moment, aż nie zostaną pobrane z kolejki.

4. Po rozwinięciu sekcji Get messages można pobrać wiadomośc z kolejki.

Jeśli natomiast chcemy wysłać wiadomość z poziomie centrali wiadomości, tej którą wcześniej utworzyliśmy to musimy wejść w zakładkę Exchanges i wejść w szczegóły naszej centrali wiadomości.

1. Rozwiń sekcję Publish message.
2. Ustaw routing key, ten sam dla którego wiązaliśmy naszą kolejkę z centralą wiadomości: example_routing_key.
3. Ustaw treść wiadomości jaka ma zostać wysłana.
4. Wyślij wiadomość Publish message.

Teraz możesz wejść w szczegóły swojej kolejki i sprawdzić czy faktycznie wiadomość się wysłała na tą kolejkę!

Warto tutaj zerknąć na parametr Exchange, który mówi nam z jakiej centrali wiadomości przyszła do nas ta wiadomość.

Konfiguracja RabbitMQ z Spring Boot

W tej części skupimy się na tym jak skonfigurować RabbitMQ z frameworkiem Spring Boot.

Podstawowa konfiguracja

Na początek musimy dodać zależność do projektu

// Gradle
dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-amqp'
}

// Maven
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

Następnie dobrze byłoby skonfigurować połączenie. Warto zaznaczyć, że łączymy się do serwera przez co używamy innego portu niż do wchodzenia na panel administracyjny.

spring:
  rabbitmq:
    host: localhost
    port: 5672
    username: guest
    password: guest

A na koniec dynamiczne tworzenie centrali wiadomości, kolejki oraz powiązania przy starcie aplikacji.

import jakarta.annotation.PostConstruct;
import org.springframework.amqp.core.*;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitAdmin;
import org.springframework.context.annotation.Configuration;

@Configuration
class RabbitMQConfig {
    private static final String EXCHANGE_NAME = "exchange.example.direct";
    private static final String QUEUE_NAME = "example_queue";
    private static final String ROUTING_KEY = "example_routing_key";

    private final RabbitAdmin rabbitAdmin;

    RabbitMQConfig(ConnectionFactory connectionFactory) {
        this.rabbitAdmin = new RabbitAdmin(connectionFactory);
    }

    @PostConstruct
    public void init() {
        DirectExchange exchange = new DirectExchange(EXCHANGE_NAME);
        rabbitAdmin.declareExchange(exchange);
        
        Queue queue = new Queue(QUEUE_NAME, true); // Durable = true
        rabbitAdmin.declareQueue(queue);

        Binding binding = BindingBuilder.bind(queue).to(exchange).with(ROUTING_KEY);
        rabbitAdmin.declareBinding(binding);
    }
}

Publikowanie wiadomości – producent

Jak mamy już wszystko dobrze skonfigurowanie to nie pozostaje nic innego jak napisać serwis producenta, który umożliwi wysłanie wiadomości:

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.stereotype.Service;

@Service
public class RabbitMQSender {

    private final RabbitTemplate rabbitTemplate;
    private static final String EXCHANGE_NAME = "exchange.example.direct";
    private static final String ROUTING_KEY = "example_routing_key";

    public RabbitMQSender(RabbitTemplate rabbitTemplate) {
        this.rabbitTemplate = rabbitTemplate;
    }

    public void sendMessage(String message) {
        rabbitTemplate.convertAndSend(EXCHANGE_NAME, ROUTING_KEY, message);
    }
}

Odbieranie wiadomości – konsument

Jak została wysłana wiadomość na kolejkę to teraz potrzebujemy mieć konsumenta, który będzie wstanie odebrać taką wiadomość z kolejki i odpowiednio ją przetworzyć:

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Service;

@Service
public class RabbitMQReceiver {

    @RabbitListener(queues = "example_queue")
    public void receiveMessage(String message) {
        System.out.println("Odebrano wiadomość: " + message);
    }
}

Podsumowanie

W 5 minut (no może troszkę dłużej 😉) udało się:

✅ Zainstalować RabbitMQ.
✅ Włączyć panel zarządzania.
✅ Stworzyć kolejkę w panelu administracyjnym.
✅ Przygotować prosty przykład na wysłanie i odebranie wiadomości z poziomu kodu.

W tym wpisie pokazałem najprostszy możliwy sposób wykorzystania RabbitMQ. Jeśli chcesz więcej materiałów na ten temat – daj znać w komentarzu! 🚀