Deploy the alt-verifier helm chart on Kubernetes

Question

Pulumi · Accepted Answer

Deploying a Helm chart on a Kubernetes cluster using Pulumi involves several steps. We'll go through how to set up a Pulumi project in TypeScript, install the required packages, and write the code to deploy the `alt-verifier` Helm chart.

First, ensure you have Pulumi and `kubectl` installed, as well as access to a Kubernetes cluster.

#### 1. Set up a new Pulumi TypeScript project:

Create a new directory for our project and initialize a new Pulumi project with TypeScript:

```sh
mkdir alt-verifier-deployment
cd alt-verifier-deployment
pulumi new typescript
```

You will be prompted for some configuration settings, like the project name and description. Follow the instructions on the screen.

#### 2. Install the Pulumi Kubernetes package:

Install the Kubernetes package which provides the resources to interact with a Kubernetes cluster.

```sh
npm install @pulumi/kubernetes
```

#### 3. Write the Pulumi code to deploy the Helm Chart:

Inside your Pulumi project, you will have an `index.ts` file. This is where you'll define your Kubernetes resources.

Replace the content of `index.ts` with the following TypeScript code. This code will deploy the `alt-verifier` Helm chart into your connected Kubernetes cluster.

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

// Define the settings of the alt-verifier Helm chart.
const altVerifierChart = new kubernetes.helm.v3.Chart("alt-verifier", {
    chart: "alt-verifier",
    // This assumes the chart is available in a helm repository.
    // If that's not the case, you may need to use a different option,
    // like a local path or a specific repository URL.
    fetchOpts: {
        repo: "https://charts.example.com/", // Replace with the actual Helm repository URL
    },
    // If `alt-verifier` requires any values to customize the deployment
    // they would be specified here, as an example:
    values: {
        service: {
            type: "LoadBalancer",
        },
        // ... more customized values
    },
    // Namespace where to deploy the Helm chart, if not specified, it defaults to 'default'
    namespace: "alt-verifier-ns",
});

// To interact with the deployed resources, you may wish to export their names for direct access.
// For example, the service endpoint if it's exposed:
export const altVerifierServiceEndpoint = altVerifierChart.getResourceProperty(
    "v1/Service", "alt-verifier-service", "status"
).apply(status => status.loadBalancer.ingress[0].hostname || status.loadBalancer.ingress[0].ip);
```

Make sure to replace `"https://charts.example.com/"` with the actual Helm repository URL which hosts the `alt-verifier` chart.

This code does the following:

- Imports the Pulumi Kubernetes package to deploy Kubernetes resources.
- Creates a new Helm chart resource using `kubernetes.helm.v3.Chart`, which signifies the deployment of a Helm chart.
- Defines the Helm chart name as `alt-verifier` and specifies its repository.
- If needed, customizes the Helm deployment by specifying values (under the `values` object), such as changing the service type to `LoadBalancer`.
- Sets a Kubernetes namespace for the deployment. A custom namespace `alt-verifier-ns` is used here; make sure to change or create this namespace as needed.
- Assumes that the Helm chart creates a Kubernetes service of type `LoadBalancer` and exports the endpoint as `altVerifierServiceEndpoint`.

Make sure your Kubernetes context is set to the cluster you wish to deploy to. You can verify your current context with `kubectl config current-context`.

Finally, run the Pulumi program to deploy the chart:

```sh
pulumi up
```

This will show you a preview of the resources Pulumi will create. If everything looks good, confirm the deployment by selecting `yes`.

The exported `altVerifierServiceEndpoint` will be displayed at the end of the deployment, which gives you the address to access the service (if it's exposed as a `LoadBalancer`).

Keep in mind that Helm charts may have mandatory values you must specify. Check the `alt-verifier` Helm chart documentation for any required values and adjust the `values` property accordingly.

Please make sure to check the access permissions, storage requirements, and other dependencies that might be required by the Helm chart you are deploying.

When you conclude with the deployment or if you wish to destroy the deployed resources, you can run:

```sh
pulumi destroy
```

This will remove the resources from your cluster. Before confirming, Pulumi will show you which resources will be deleted.