Bob Glithero contributed to this article.
Today we’re announcing the general availability of VMware Tanzu RabbitMQ for Kubernetes. Based on the widely popular open source RabbitMQ messaging system, Tanzu RabbitMQ for Kubernetes is designed to work seamlessly with Tanzu Editions and also run on any certified Kubernetes distribution, including OpenShift. Tanzu RabbitMQ for Kubernetes provides an easy, automated way to deploy and manage RabbitMQ brokers for reliable event and message distribution.
You can also review our recent blog for more about the enterprise features of the Tanzu RabbitMQ broker.
Enterprise messaging on-demand, virtually anywhere
Migration to the cloud and adoption of cloud native architectures remains incomplete. Many organizations are still hampered by the slow, ticket-based provisioning and limited automation of traditional middleware and data services in the data center. To gain agility and speed, enterprises want:
Self-service, application-oriented programming interface-based data services, on any cloud
Developers empowered to deploy and manage data services (Day 1 operations) using automation, without the manual involvement of IT operators or DevOps
A way to self-manage and upgrade (Day 2 operations) with a high degree of automation
The ability to easily scale application data services when demand increases
Applications that run the latest secured version of services with zero downtime
So how can we get cloud benefits to developers and operators—self-service provisioning, consistency in deployment, automated operations, and business continuity features—in virtually any environment?
Kubernetes offers a declarative way to deploy consistent, containerized services virtually, anywhere. After being initially developed with a focus on stateless workloads, newer features like stateful sets and persistent volumes have since been created for basic stateful workloads. But to support more sophisticated applications like message queues, the basic resources of Kubernetes with specific workload logic need to be extended. How? With a custom operator that translates user declarative commands into complex workflows, combining workload-specific best practices with Kubernetes vanilla actions. Want to deploy, manage, or upgrade your stateful workload? Just tell Kubernetes what your desired state is and it will perform the operation for you. Kubernetes will watch and automatically reconcile to that state as pods fail or changes are published to the operator’s custom resource definition (CRD). The operator tells Kubernetes which objects to create and watch. Tanzu RabbitMQ uses the operator pattern to bring messaging, on-demand, anywhere that Kubernetes runs.
Deploy Tanzu RMQ on Kubernetes
Tanzu RabbitMQ for Kubernetes allows users to deploy both the open source version of RabbitMQ as well as Tanzu RabbitMQ, which is a commercially curated version enhanced by VMware’s RabbitMQ engineering experts. Either way, developers can now manage their messaging systems with the same low-code approach virtually anywhere, leveraging simple and fast deployment to Kubernetes, low levels of DevOps maintenance, and access to the Kubernetes ecosystem for logging, monitoring, and tracking.
Expert knowledge codified in an operator
According to the Kubernetes documentation,“The Operator pattern aims to capture the key aim of a human operator who is managing a service or set of services.” The Tanzu RabbitMQ operator codifies the engineering knowledge needed to deploy and operate Tanzu RabbitMQ. It also automates operational flows using Kubernetes primitives (e.g., stateful sets and persistent volumes), which allows specific RabbitMQ configuration options and commands to be managed via the Kubernetes API.
The Tanzu RabbitMQ operator specifies the desired deployment state. It consists of a CRD and a custom controller. A custom resource extends the basic capabilities of Kubernetes and can be managed the same as any other Kubernetes object. A CRD file defines these objects in YAML for Kubernetes to create and watch.
How the Tanzu RabbitMQ operator reconciles state
The controller regulates the state of the custom objects and, via the API server, performs the actions necessary to reconcile the actual state of the cluster to the desired state. The operator can also react and reconcile the cluster state whenever a user applies changes to the CRD via a YAML manifest. The result? High-performance messaging as code via the Tanzu RabbitMQ Kubernetes operator.
Benefits of this approach include:
Faster and simpler operations
Consistency, with functions that are easy to test and that reduce the need for manual operations and the possibility of human error
Support for GitOps-style development and deployment
With the Tanzu RabbitMQ operator, managing RabbitMQ clusters becomes easier and more automated as scaling and healing is relegated to Kubernetes’ own state reconciliation mechanisms. Watch the video to see it in action:
Now, let's take a closer look at Tanzu RabbitMQ’s key features.
Rapid, self-service provisioning wherever Kubernetes is deployed
Using the Tanzu RabbitMQ for Kubernetes convenience CLI or kubectl directly, developers can provision a deployment with the configuration and size they need in a matter of seconds. The Tanzu RabbitMQ CLI wraps the Kubernetes API with a convenient layer of simplified commands.
By building on existing examples, users can quickly modify the Kubernetes deployment manifest to use any Tanzu RabbitMQ plugin and configuration option.
Safe for production
In combination with the Tanzu RabbitMQ Open Container Initiative (OCI) image, Tanzu RabbitMQ for Kubernetes allows developers to provision clusters with production-safe defaults. It also provides production manifest examples for many configurations.
Developers can deploy the cluster in a way that promotes business continuity. For example, the operator uses the disruption budget of Kubernetes to limit the number of concurrent disruptions that your deployment experiences. This means that you will never end up shutting down your entire cluster when performing changes like upgrades.
You can also constrain pods to particular nodes with anti-affinity policies between Tanzu RabbitMQ nodes, using the Kubernetes taints and tolerations configurations.
Rolling upgrades made easier
Rolling upgrades of a running deployment can be performed by simply updating the Kubernetes deployment manifest. Once this happens, the cluster operator component will act on each node in turn to:
Safely stop message processing, shifting queues to other nodes as appropriate
Update the node to the new version of Tanzu RabbitMQ
Restart the Tanzu RabbitMQ nodes
Rebalance replicated queues to improve resilience
The operator covers a variety of upgrade scenarios, among them:
Placing specific deployments on a deny list from automatic upgrade
Upgrading the operator, then upgrading deployments not on the deny list
Maintaining multiple versions in the fleet
Users will periodically upgrade the operator to get the latest features. The Tanzu RabbitMQ operator is upgradeable using a single command, and involves no downtime for any of the managed deployments. Newer versions of the operator maintain backwards compatibility to manage existing deployments.
Security is a major concern in both cloud and shared infrastructure environments. Tanzu RabbitMQ for Kubernetes helps developers secure their applications for zero-trust configurations with a variety of measures:
Running the operator under the service account (non-root)
Limiting the scope to watch resources in specific namespaces
Running clusters under a non-privileged daemon user
Implementing zero-trust mTLS-encrypted communication between clients and the deployment
Implementing optional zero-trust mTLS-encrypted communications between nodes
Implementing Oauth support
Supported by VMware experts
Tanzu RabbitMQ for Kubernetes was created by VMware experts with years of experience deploying it in enterprise environments in order to make going to production safer and easier. Enterprise support plans give you peace of mind around the clock.
Where do I start?
If you are new to K8s, start with learning the basics of it and kubectl before attempting to use the operator. You can also visit the KubeAcademy for more in-depth primers. Watch this episode of TGIR to see how easy it is to deploy and monitor a RabbitMQ cluster with the operator. Or you can try the quick start guide on GitHub. You will have the operator and your first instance of an operator-created RabbitMQ cluster within minutes. Need more help? Look at the operator YAML examples to see how to deploy sophisticated clusters.