Using kubernetes traefik.containo.us with rabbitmq.com

Question

Pulumi · Accepted Answer

When using Kubernetes to deploy applications, it's common to use an ingress controller to manage external access to the services running inside the cluster. Traefik is a popular choice for an ingress controller as it can handle dynamic configuration and comes with features like load balancing, SSL termination, and more.

RabbitMQ, on the other hand, is a widely used open-source message broker software that accepts and forwards messages. It's robust and ideal for complex routing, with various plugins available, including one for Kubernetes.

Here's how you can use them together:

1. Set up a Kubernetes cluster if you haven't done so already.
2. Deploy RabbitMQ on Kubernetes.
3. Install and configure Traefik as your ingress controller.
4. Define the rules for routing traffic to RabbitMQ through Traefik using Kubernetes resources like `Ingress`.

Below is a Pulumi TypeScript program that could create a Traefik ingress controller and a RabbitMQ service in Kubernetes. The example sets up a basic configuration to demonstrate the relationship between these components:

- **Traefik Ingress Controller**: This will route incoming requests to the correct services in the cluster.
- **RabbitMQ Service**: The application deployed on Kubernetes that will be accessible via the Traefik Ingress.

Make sure you have Pulumi installed and configured to manage resources in your Kubernetes cluster and let's start with the code:

```typescript
import * as k8s from '@pulumi/kubernetes';

// Create a namespace for your ingress resources
const ns = new k8s.core.v1.Namespace('ingress-ns', {
  metadata: { name: 'traefik-rabbitmq' },
});

// Deploy Traefik using the Helm chart
const traefik = new k8s.helm.v3.Chart('traefik', {
  namespace: ns.metadata.name,
  chart: 'traefik',
  fetchOpts: {
    repo: 'https://helm.traefik.io/traefik',
  },
}, { provider: clusterProvider }); // Assuming you have a `clusterProvider` configured

// Deploy RabbitMQ using the Helm chart
const rabbitmq = new k8s.helm.v3.Chart('rabbitmq', {
  namespace: ns.metadata.name,
  chart: 'rabbitmq',
  fetchOpts: {
    repo: 'https://charts.bitnami.com/bitnami',
  },
  values: {
    ingress: {
      enabled: true,
      hostname: 'rabbitmq.example.com', // Put your desired hostname here
      annotations: {
        'kubernetes.io/ingress.class': 'traefik',
      },
    },
  },
}, { provider: clusterProvider });

// Export the hostname to access RabbitMQ
export const rabbitMqHostname = rabbitmq.getResourceProperty('v1/Service', 'rabbitmq', 'status').apply(status => status.loadBalancer.ingress[0].hostname);

```

This code does the following:

- It imports the necessary Pulumi and Kubernetes packages.
- Creates a new Kubernetes namespace for the ingress resources.
- Uses the Pulumi Kubernetes provider to deploy Traefik from its Helm chart into the cluster.
- Deploys RabbitMQ from its Helm chart as well, enabling ingress and specifying annotations that tell Traefik to manage its routes.
- At the end, we export the RabbitMQ hostname that will be used to access the message broker externally.

You will need to replace the placeholder `clusterProvider` with your Kubernetes cluster provider configuration, and `rabbitmq.example.com` with the domain you plan to use for RabbitMQ.

Before running this Pulumi code, make sure Helm charts for Traefik and RabbitMQ are available and provide the functionality in the versions that you are using. You might need to adjust Helm chart values or versions for your specific use case.

When applying this Pulumi program, it will set up both Traefik and RabbitMQ in your Kubernetes cluster, with Traefik configured to route incoming HTTP requests to the RabbitMQ service using the domain specified.

Keep in mind that this example is for demonstration purposes and may require further configuration, including setting up DNS and SSL/TLS for secure communication. Additionally, ensure you check the RabbitMQ Helm chart configurations and tune them according to your requirements.