Deploy the k8s-pvc helm chart on Kubernetes

Question

Pulumi · Accepted Answer

To deploy a Helm chart to a Kubernetes cluster using Pulumi, you'll need to use the `Chart` resource from the Pulumi Kubernetes provider. In this case, to deploy a "k8s-pvc" chart which might be a custom or community Helm chart that provides Persistent Volume Claims (PVCs) for Kubernetes, you'll need the following information:

1. The name of the chart (`k8s-pvc`).
2. The repository URL where the chart is located (if it's not a stable chart that's included by default).
3. Any custom values you want to override in the chart's default `values.yaml` file.
4. The namespace in which you want to deploy this chart (optional, default is `default`).

Let's say you've found your `k8s-pvc` Helm chart in a repository at `https://example.com/helm-charts`. You also want to place it in a namespace called `my-namespace`. No customization to the values is needed beyond what's provided by the chart.

Below is the Pulumi program written in TypeScript that fulfills these requirements:

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

// Replace the following line with the correct repository URL for your helm chart.
const repoUrl = "https://example.com/helm-charts";

// Create an instance of the Pulumi Kubernetes provider.
const provider = new k8s.Provider("k8s-provider", {
    // If you are targeting a specific Kubernetes context, you can set it here.
    // Otherwise, Pulumi will use the current context from your kubeconfig.
    // context: "your-kubeconfig-context-name",
});

// Deploy the 'k8s-pvc' Helm chart using the Chart resource.
const pvcChart = new k8s.helm.v3.Chart("k8s-pvc", {
    // Specify the chart repo and name.
    repo: "my-repo", // The name you want to give to the Helm chart repository.
    chart: "k8s-pvc",

// If the chart requires a specific namespace, set it here.
    namespace: "my-namespace",

// If you need to pass a custom values file or override settings, you can include them in the 'values' key.
    // For example, here's how you might customize the storage size for PVCs:
    // values: {
    //     storageSize: "10Gi",
    // },

// The repositoryOpts fetches the chart from the specified repository URL.
    fetchOpts: {
        repo: repoUrl,
    },
}, { provider });

// Export the chart's status (e.g., deployed version and namespace).
export const chartStatus = {
    name: pvcChart.name,
    version: pvcChart.getResourceProperty("v1/Service", "my-service", "spec.clusterIP"),
    namespace: pvcChart.namespace,
    // You can add more status properties you might need from the chart.
};

// Note: Depending on the actual content of your 'k8s-pvc' Helm chart, the resource types (e.g., "v1/Service") and
// property names (e.g., "spec.clusterIP") and any values (like "my-service") will vary.
```

Explanation:

1. First, we import the Pulumi Kubernetes provider library.
2. We then create a new instance of the Kubernetes provider. 
   - If you need to target a specific Kubernetes context, you can set it with the `context` property. By default, Pulumi interacts with the cluster configured in your kubeconfig.
3. We use `k8s.helm.v3.Chart` to create a new Helm chart instance.
   - `repoUrl` is the URL of the Helm chart repository.
   - The chart is deployed into the `my-namespace` namespace on your Kubernetes cluster.
   - If your chart requires custom configurations, you would include these in the `values` property in the `Chart` constructor (commented out in the example).
4. Finally, an export statement is used to output the deployment details.

This program will deploy the specified Helm chart to your Kubernetes cluster using Pulumi. To apply the configuration, you would typically run `pulumi up` in your command line from the same directory where this Pulumi program is saved.