Name: RabbitMQ Fundamentals (Beginner)
Availability: InStock

RabbitMQ Fundamentals (Beginner)

Elevate your team’s messaging know-how with a practical, instructor-led introduction to RabbitMQ. Designed for true beginners, this course builds a solid foundation in message-queuing concepts, AMQP 0-9-1, and day-to-day RabbitMQ usage through short explanations and guided walkthroughs.

What will you learn?

Unlock the value of decoupled, reliable systems by learning how and when to use RabbitMQ in real projects. You’ll get comfortable with core AMQP concepts, exchange types, routing, acknowledgments, durability, and simple monitoring—without getting lost in enterprise-only features.

After this training you will be confident in:

• Explaining messaging basics and the AMQP 0-9-1 model.

• Setting up RabbitMQ locally (installer or Docker) and navigating the Management UI.

• Building simple producers and consumers (sample code in Python/Node/Java).

• Using exchange types (direct, fanout, topic, headers) and routing keys correctly.

• Making messages reliable with durability, persistence, acks, and dead-lettering.

• Applying basic flow control (prefetch/QoS) and work-queue patterns.

• Monitoring, troubleshooting common errors, and applying minimal security (users, vhosts, permissions).

Requirements:

• Basic programming experience (any language).

• Familiarity with command line fundamentals.

• Laptop with admin rights; Docker Desktop optional but helpful.

Course Outline*:

*We know each team has their own needs and specifications. That is why we can modify the training outline per need.

Module 1: Messaging 101 & RabbitMQ Overview

Why messaging? Use cases, patterns, and vocabulary (broker, producer, consumer).
AMQP 0-9-1 in plain English: exchanges, queues, bindings, routing keys.
RabbitMQ architecture at a glance (nodes, vhosts, permissions).
Guided setup: install RabbitMQ (native or Docker) and explore the Management UI.

Module 2: First Producers & Consumers

Hello, Queue: sending and receiving messages.
Auto-ack vs. manual acknowledgments; when each is appropriate.
Message payloads and metadata (properties, headers).
Walkthrough: minimal producer and consumer using trainer-provided templates (Python/Node/Java).

Module 3: Exchange Types & Routing Made Simple

Direct vs. fanout vs. topic vs. headers exchanges—when to use each.
Routing keys and binding patterns (e.g., logs.*, *.payments).
Practical topologies: one-to-one, pub/sub, selective broadcast.
Walkthrough: three routing scenarios verified via the Management UI.

Module 4: Reliability Basics — Durability, Persistence, and Retries

Durable exchanges/queues vs. transient; persistent messages.
At-least-once delivery in practice; idempotency basics.
Dead-Letter Exchanges (DLX) for safe retries and parking failed messages.
Configuration example: durable queues, persistent messages, DLX retry flow.

‍

Module 5: Throughput & Flow Control for Work Queues

Fair dispatch with basic.qos (prefetch) to prevent consumer overload.
Competing consumers and scaling out workers.
Simple performance tips: connection/channel reuse, basic batching/publisher confirms (intro).
Configuration example: converting a basic pipeline into a robust work queue with tuned prefetch.

Module 6: Operating RabbitMQ — Monitoring, Security, and Troubleshooting

Everyday operations: users, roles, vhosts, permissions.
Health checks and metrics in the Management UI; reading logs.
Common pitfalls: unacked build-up, blocked connections, mismatched durability.
Backup/restore basics and safe config changes; minimal hardening.

Module 7: Conclusion & Next Steps

Recap of key concepts and patterns.
When to consider publisher confirms, streams, or clustering (high-level preview).
Suggested learning path and resources for intermediate topics.

Hands-on learning with expert instructors at your location for organizations.

3.072€*