Deploy the vfc helm chart on Kubernetes

Question

Pulumi · Accepted Answer

To deploy a Helm chart on a Kubernetes cluster using Pulumi, you will need to use the Chart resource from the Pulumi Kubernetes provider. This resource allows you to deploy a Helm chart into your Kubernetes cluster by specifying the chart's name, version, and other optional parameters such as values to override the default chart values.

Before you begin, you'll need to have a few prerequisites in place:

A configured Kubernetes cluster where you have administrative access.
Pulumi CLI installed on your local machine (Installation Guide).
Helm and kubectl installed locally.
A Pulumi program setup for your Kubernetes cluster. You can follow the Pulumi's Kubernetes Getting Started guide to set up your Pulumi project.

Below is a Pulumi TypeScript program that deploys the vfc helm chart to a Kubernetes cluster. The example assumes you have a Helm chart named vfc available in a Helm repository or locally on your filesystem.

import * as k8s from "@pulumi/kubernetes";

// Create an instance of the k8s Provider to interact with your Kubernetes cluster.
const provider = new k8s.Provider("provider", {
  // Your Kubernetes config
  // - If you're running Pulumi from within a cluster (e.g. a pod in the cluster),
  //   you can omit the kubeconfig parameter.
  // - If you're running Pulumi outside of the cluster, specify your kubeconfig path.
  kubeconfig: "<your-kubeconfig-path>",
});

// Use the `Chart` resource from the Pulumi Kubernetes provider to deploy the `vfc` helm chart.
const vfcChart = new k8s.helm.v3.Chart("vfc", {
  // Replace with the correct chart name if it differs.
  chart: "vfc",
  // Specify version of the chart if needed.
  version: "<chart-version>",
  // Add namespace if you wish to deploy the chart within a specific namespace.
  namespace: "<namespace>",
  // To apply the values file, specify the values in this object. For example:
  // values: { ... }
  
  // If the chart is in a Helm repo that requires authentication or is private, use `fetchOpts`.
  // fetchOpts: {
  //   repo: "https://your.helm.repo/",
  //   username: "<your-username>",
  //   password: "<your-password>",
  // },
  
  // If the chart is stored locally on your filesystem, set `path` property with the local path.
  // path: "<path-to-your-chart>",
  
  // Pass in any required `values` as an object.
  // values: {
  //   key: "value",
  // },
}, { provider });

// Export the resources' properties to be accessed outside the Pulumi program.
export const chartName = vfcChart.metadata.name;
export const chartNamespace = vfcChart.metadata.namespace;

This program does the following:

It imports the necessary Pulumi Kubernetes SDK.
It creates an instance of the Kubernetes Provider to interact with the targeted Kubernetes cluster.
It then uses the Chart resource to deploy the 'vfc' Helm chart. You must provide the chart name and optionally the version. The namespace property is where you specify the Kubernetes namespace to deploy the chart into.
If the Helm chart requires special fetch options, like a private repository you need to authenticate against, you can specify those using the fetchOpts property.
You can also specify custom values for the Helm chart by providing an object to the values property. This object's keys and values should correspond to the chart's values that you wish to override.
Lastly, the program exports the name and namespace of the deployed chart so you can easily retrieve them from the command line after deployment by running pulumi stack output.

Make sure to replace <your-kubeconfig-path>, <namespace>, <your-helm-repo>, <your-username>, and <your-password> with the actual values relevant to your environment. If the chart is in a private Helm repository, you need to specify the Helm repository URL and authentication credentials if required.

To run this Pulumi program, save the code into a file named index.ts within your Pulumi project directory, and then execute the following commands in your terminal:

# Install the dependencies
npm install @pulumi/kubernetes

# Preview and run the update
pulumi up

This will provide you with a preview of the changes Pulumi will perform and, upon confirmation, apply the changes to your Kubernetes cluster. After successful deployment, you can use kubectl to verify that the Helm chart has been successfully deployed.