Deploy the rabbitping helm chart on Digital Ocean Kubernetes Service

Question

Pulumi · Accepted Answer

To deploy the RabbitMQ Helm chart named "rabbitping" on Digital Ocean Kubernetes Service (DOKS), you'll need to follow a series of steps, which I'll outline for you. The process involves creating a Kubernetes cluster on Digital Ocean, installing and configuring Helm, and then using Helm to deploy RabbitMQ.

Here's a Pulumi program in TypeScript that does just that:

1. **Set up a new Digital Ocean Kubernetes cluster** using the `digitalocean.KubernetesCluster` resource. This will be the cluster where your RabbitMQ instance will run.
2. **Create a Kubernetes provider** that points to the new DOKS cluster.
3. **Use the Kubernetes provider** to install the RabbitMQ Helm chart using the `kubernetes.helm.v3.Chart` resource.

Let's go through the code that accomplishes these steps:

```typescript
// Import necessary libraries
import * as pulumi from '@pulumi/pulumi';
import * as digitalocean from '@pulumi/digitalocean';
import * as kubernetes from '@pulumi/kubernetes';

// Create a DigitalOcean Kubernetes cluster
const cluster = new digitalocean.KubernetesCluster('do-cluster', {
    region: digitalocean.Regions.NYC3,
    version: 'latest',
    nodePool: {
        name: 'default',
        size: 's-2vcpu-2gb',
        nodeCount: 3,
    },
});

// Export the DigitalOcean Kubernetes cluster's kubeconfig
export const kubeconfig = cluster.kubeConfigs[0].rawConfig;

// Create a Kubernetes Provider instance that uses the returned kubeconfig
const k8sProvider = new kubernetes.Provider('do-k8s', {
    kubeconfig: cluster.kubeConfigs[0].rawConfig,
});

// Deploy the RabbitMQ Helm chart using the Kubernetes Provider
const rabbitmqChart = new kubernetes.helm.v3.Chart('rabbitping', {
    chart: 'rabbitmq',
    // If needed, specify the repository or version here.
    // repo: 'https://charts.bitnami.com/bitnami',
    // version: '8.0.1',
    values: {
        // Here you can specify configuration values.
        // For example, to enable persistence:
        // persistence: {
        //     enabled: true,
        //     size: "10Gi"
        // },
    },
    namespace: 'default', // You can specify a namespace or choose a different one
}, { provider: k8sProvider });

// Export the RabbitMQ service URL by querying the deployed services
export const rabbitmqServiceUrl = rabbitmqChart.getResourceProperty(
    'v1/Service', 'rabbitping-rabbitmq', 'status'
).apply(status => {
    const port = status.loadBalancer.ingress[0].port;
    return `http://${status.loadBalancer.ingress[0].ip}:${port}`;
});
```

Here's what's happening in the code above:

- We start by importing the Pulumi SDK and the specific Digital Ocean and Kubernetes libraries required for the deployment.
- We then define a Pulumi resource to create a new DOKS cluster. You can change the region, version, and node pool specifications to match your requirements.
- The `kubeconfig` is exported so that you can access your Kubernetes cluster using the kubectl CLI or any other tool that interacts with Kubernetes.
- We create a Kubernetes provider which knows how to communicate with the Kubernetes cluster using credentials from the `kubeconfig`.
- Using this provider, we deploy the RabbitMQ Helm chart. In the `values` field, you can provide any overrides to the default configuration that the chart provides. For example, enabling persistence and setting its size.

Remember, to deploy this, you should have the Pulumi CLI installed and configured with Digital Ocean access tokens set up. After running `pulumi up` with this code, Pulumi will create the resources in the correct order, ultimately deploying the RabbitMQ service on DOKS. You can then use the URL that is exported as `rabbitmqServiceUrl` to access your new RabbitMQ service.