Deploy the project-origin-registry helm chart on Kubernetes

Question

Pulumi · Accepted Answer

To deploy a Helm chart on a Kubernetes cluster using Pulumi, you need to set up the cluster (or have access to an existing one), install the Pulumi CLI, and choose a programming language supported by Pulumi. For this task, we'll use TypeScript. I'll guide you through the deployment of the "project-origin-registry" Helm chart on Kubernetes with Pulumi.

First, ensure that you have the following prerequisites:

1. **Kubernetes Cluster**: You need access to a Kubernetes cluster with `kubeconfig` configured appropriately on your local machine.
2. **Pulumi CLI**: Install the [Pulumi CLI](https://www.pulumi.com/docs/get-started/install/) if you haven't already and log in to the Pulumi service.
3. **Node.js and npm**: Install [Node.js](https://nodejs.org/) which comes with npm, as we're using TypeScript for writing the Pulumi code.

With the prerequisites in place, you can write a Pulumi program to deploy your Helm chart. Here's a step-by-step TypeScript program:

### Installing Pulumi Libraries

Before running the TypeScript program, you should install the necessary Pulumi packages. You can do this by running:

```bash
npm init -y
npm install @pulumi/pulumi @pulumi/kubernetes
```

### Writing the Pulumi Program

Create a new file `index.ts` and put the following code into it:

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

// The name of the Helm chart you want to deploy.
// You will need to replace `project-origin-registry` with the actual name of your chart.
// If your Helm chart is from a custom repository, you must also provide the repository URL.
const chartName = 'project-origin-registry';
const chartVersion = '1.2.3'; // Specify the version of the chart you wish to deploy.
const releaseName = 'origin-registry-release'; // A name for the Helm release.

// Initialize a Kubernetes provider using the local kubeconfig.
const provider = new k8s.Provider('k8s-provider', {
  kubeconfig: pulumi.output(k8s.utils.kubeconfig.loadKubeconfig()).apply(JSON.stringify),
});

// Deploy the Helm chart using the k8s.helm.v3.Chart class.
const helmChart = new k8s.helm.v3.Chart(releaseName, {
  chart: chartName,
  version: chartVersion,
  // If you have a custom repository, you would add the `repo` attribute here as well.
  // For example: repo: 'http://charts.example.com/'
}, { provider });

// Export details about the deployment
export const chartDeploymentName = helmChart.getResourceProperty('v1/Service', `${releaseName}-${chartName}`, 'metadata.name');
```
This program does the following:

- Imports the necessary Pulumi Kubernetes libraries.
- Defines a Helm chart name, version, and release name. You need to replace these with the actual details of your Helm chart.
- Initializes a Kubernetes provider that uses the local `kubeconfig` file for connecting to your cluster.
- Deploys the Helm chart to your Kubernetes cluster with the `k8s.helm.v3.Chart` resource. If your Helm chart is hosted in a custom repository, you will need to specify the repository URL as well.
- Exports the name of the service created by the Helm chart so you can access its details later.

### Running the Program

After writing the program, run the following commands to preview and deploy the resources defined in your `index.ts`:

```bash
pulumi up
```

The above command will show you a preview of what Pulumi is about to do. If the preview looks good, select `yes` to proceed with the deployment.

Once deployed, you can inspect the state of the resources with Pulumi or directly via `kubectl` or other Kubernetes tools.

### Conclusion

With this Pulumi program, you've defined the deployment of a Helm chart on Kubernetes. Pulumi will handle the communication with the cluster and create the necessary resources as defined in the chart. Pulumi's expressive infrastructure as code allows you to easily manage the state, updates, and rollbacks of your Kubernetes applications.