Deploy the terracotta helm chart on Kubernetes

Question

Pulumi · Accepted Answer

Deploying a Helm chart on Kubernetes with Pulumi involves several steps:

1. Setting up your Pulumi environment.
2. Writing the TypeScript code using the `@pulumi/kubernetes` package to define the Kubernetes resources required to deploy the Helm chart.
3. Running the Pulumi CLI commands to deploy the resources to your Kubernetes cluster.

If you're new to Pulumi, you should have Node.js installed and Pulumi CLI setup. You need to be authenticated to your Kubernetes cluster where you intend to deploy the Helm chart.

In the following program, we'll be using the `kubernetes.helm.v3.Chart` resource from the `@pulumi/kubernetes` package, which allows us to declare a Helm chart as part of our Pulumi infrastructure as code. We'll deploy a chart named 'terracotta', which should be available in a public or private Helm repository.

Here is how you can define a Pulumi program in TypeScript to deploy the 'terracotta' Helm chart:

```typescript
import * as kubernetes from "@pulumi/kubernetes";

// The namespace where the chart will be deployed.
const namespace = new kubernetes.core.v1.Namespace("terracotta-namespace", {
    metadata: { name: "terracotta" }
});

// Deploy the terracotta Helm chart.
const terracottaChart = new kubernetes.helm.v3.Chart("terracotta-chart", {
    namespace: namespace.metadata.name,
    chart: "terracotta",
    // Specify the repository where your Helm chart is located.
    // For example 'https://example.com/helm-charts'
    // If your chart is in a publicly accessible repository, 
    // you can also just provide the chart name if it's available in the default Helm repo.
    fetchOpts: {
        repo: "https://charts.bitnami.com/bitnami",
    },
    // You can specify the version of the chart you want to deploy.
    // If not specified, the latest version will be deployed.
    version: "1.0.0", 
    // The values here are the Helm chart values you wish to override.
    // For example, if you need to provide a custom configuration you would do it here.
    values: {
        service: {
            type: "ClusterIP",
        },
        // Add more overrides according to terracotta chart's configurable options.
    },
}, { dependsOn: namespace });

// Export the base URL of the terracotta service.
export const terracottaBaseUrl = terracottaChart.getResourceProperty("v1/Service", "terracotta", "status").apply(status => `http://${status.loadBalancer.ingress[0].hostname}`);
```

In this program:

- We start by importing the required Pulumi Kubernetes package.
- We create a Kubernetes namespace for the terracotta deployment.
- We then declare a new Helm chart resource that references the 'terracotta' chart.
- In the `fetchOpts`, we specify the Helm repository where the chart is located. Replace 'https://charts.bitnami.com/bitnami' with the repository URL where the 'terracotta' chart is hosted.
- In the `version`, we specify the version of the chart to deploy. This field is optional – if not set, the latest version will be deployed.
- In `values`, you can provide configuration options that should be applied to the Helm chart upon deployment. This field is used to override the default settings in the Helm chart.

Once this program is ready, you can deploy it using these Pulumi CLI commands in your terminal:

```sh
pulumi up
```

This command will create the defined resources in your currently configured Kubernetes cluster.

Please replace the placeholder values, especially the `repo` under `fetchOpts`, with the relevant information for the 'terracotta' chart you wish to deploy.

After the deployment, you can interact with your Kubernetes cluster as usual, using `kubectl` or any other tool you prefer, to manage the deployed Helm chart. The `terracottaBaseUrl` export is an example of how you can get information about the deployed resources; it assumes that the Helm chart creates a service of type LoadBalancer. If your service type is different or you have a more specific URL, you would need to adjust this export accordingly.