Deploy the nfs-provisioner helm chart on Rancher

Question

Pulumi · Accepted Answer

To deploy the nfs-provisioner Helm chart on a Rancher-managed Kubernetes cluster using Pulumi, you would typically take the following steps:

1. Ensure you have a Kubernetes cluster managed by Rancher and the cluster is accessible via `kubectl`.
2. Have access to your Rancher instance, including necessary permissions to deploy applications.
3. If you're deploying a chart from a Helm repository that's not already added in Rancher, you might need to add that repository first.
4. Use Pulumi's `rancher2` package to interact with Rancher resources.

In Pulumi, deploying a Helm chart to a Rancher-managed cluster involves using the `helm` module from `@pulumi/kubernetes`. However, since managing Rancher resources directly may sometimes require more specialized resources, and at the time of writing, the Pulumi Registry doesn't present a dedicated Helm chart deployment resource for Rancher, we will use the generic Helm chart resource from the Pulumi Kubernetes provider.

Below is the TypeScript program that demonstrates how to deploy an nfs-provisioner Helm chart:

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

// Cluster information; replace these with your actual cluster info.
const clusterName = "my-rancher-cluster";
const clusterId = "my-cluster-id"; // Rancher cluster ID, which you can obtain from the Rancher UI.

// Here we set up necessary configuration for accessing the Rancher-managed cluster.
const rancherConfig = new pulumi.Config("rancher2");
const adminToken = rancherConfig.requireSecret("adminToken");
const rancherApiUrl = rancherConfig.require("apiUrl");

// Instantiate a Rancher2 provider to interact with your Rancher instance.
const rancherProvider = new rancher2.Provider("rancherProvider", {
    apiUrl: rancherApiUrl,
    tokenKey: adminToken,
});

// Get the cluster object from Rancher.
const cluster = rancher2.getCluster({
    name: clusterName,
}, { id: clusterId });

// kubeconfig to interact with the cluster.
const kubeconfig = pulumi.secret(cluster.kubeConfig);

// Create a Provider resource to manage resources in the cluster obtained from Rancher.
const k8sProvider = new k8s.Provider("k8sProvider", {
    kubeconfig: kubeconfig,
});

// Define the nfs-provisioner helm chart and release version.
const nfsProvisionerChart = "nfs-provisioner";
const nfsProvisionerVersion = "1.0.0"; // Use the actual chart version you want to deploy.
const nfsProvisionerRepo = "https://kubernetes-charts.storage.googleapis.com/"; // The chart repository.

// Deploy nfs-provisioner using a Helm Chart.
const nfsProvisioner = new k8s.helm.v3.Chart("nfs-provisioner", {
    fetchOpts: {
        repo: nfsProvisionerRepo,
    },
    chart: nfsProvisionerChart,
    version: nfsProvisionerVersion,
    namespace: "default", // Target namespace, change if needed.
}, { provider: k8sProvider });

// Export the name of the cluster
export const k8sClusterName = clusterName;
```

This program performs the following actions:

1. Imports required packages from Pulumi.
2. Defines the configuration settings such as cluster name, cluster ID, Rancher API URL, and admin token. You should replace these with actual values from your environment.
3. Sets up the Rancher provider using the configuration values. The provider is used to interact with Rancher API and manage resources.
4. Retrieves the Kubernetes cluster object from Rancher using `getCluster`.
5. Sets up the Kubernetes provider using the kubeconfig obtained from the Rancher cluster object. This provider is used to deploy the nfs-provisioner Helm chart.
6. Defines the nfs-provisioner Helm chart deployment using Pulumi Kubernetes provider. This includes specifying the chart repository, chart name, and version. The namespace is set to `default`, but you may need to update this if you're deploying to a different namespace.
7. The Helm chart resource is created, and managed by the Kubernetes provider (`k8sProvider`), which interacts with the Rancher-managed cluster.

Ensure you replace the placeholder values with actual information from your Rancher and Kubernetes setup. Before executing the program, install the necessary Pulumi packages using `npm` or `yarn`. You also need to set up Pulumi configuration values for the `rancher2` configuration keys, such as `adminToken` and `apiUrl`. Use the Pulumi CLI commands (`pulumi config set`) to set these values securely.

After preparing this TypeScript program, deploy it using the Pulumi CLI commands: `pulumi up`. This will provision the nfs-provisioner Helm chart in your specified Rancher-managed Kubernetes cluster.