Deploy the shellbox helm chart on Rancher

Question

Pulumi · Accepted Answer

To deploy the Shellbox Helm chart on a Rancher-managed Kubernetes cluster, you would typically follow these steps:

1. Set up your Rancher server and create a Kubernetes cluster.
2. Use Rancher to configure access to this cluster with `kubectl`, the Kubernetes command-line tool.
3. Add the repository hosting the Shellbox Helm chart to your Helm configuration.
4. Deploy the Shellbox Helm chart to your cluster using Helm commands.

However, since you are interested in doing this programmatically with Pulumi, I will guide you through the process using TypeScript, and the Rancher2 Pulumi provider to interact with Rancher clusters. This example assumes you have a Rancher-managed Kubernetes cluster already provisioned and you have access to it.

First, make sure you have the Pulumi CLI installed and configured for use with your desired cloud provider, and you have installed `node` and `npm` to run TypeScript programs.

Firstly, install the necessary Pulumi packages by running:

```bash
npm install @pulumi/pulumi
npm install @pulumi/rancher2
```

Now, let's write the Pulumi program in TypeScript:

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

// Configuration variables for the Helm chart and Rancher
const chartName = "shellbox";
const chartVersion = "1.0.0"; // Replace with your desired chart version
const chartRepo = "https://charts.example.com/"; // Replace with your chart's repository URL
const namespace = "default"; // The Kubernetes namespace where the chart will be installed
const projectName = "project-name"; // Replace with your Rancher project name
const clusterId = "cluster-id"; // Replace with your Rancher cluster ID

// Fetch the Rancher project ID using the project name and cluster ID
const rancherProject = new rancher2.Project("project", {
    clusterId: clusterId,
    name: projectName,
});

// Deploy the Shellbox Helm chart using Rancher's App resource
const shellboxApp = new rancher2.App("shellbox-app", {
    projectId: rancherProject.id,
    name: chartName,
    targetNamespace: namespace,
    externalId: pulumi.interpolate`catalog://?catalog=helm&template=${chartName}&version=${chartVersion}&namespace=${namespace}`,
});

// Export the name of the deployed app
export const appName = shellboxApp.name;
```

In the above program:

- We import the `@pulumi/pulumi` and `@pulumi/rancher2` packages to interact with the Pulumi platform and Rancher respectively.

- We define several configuration variables such as the name, version, and repository URL of the Helm chart we wish to deploy, as well as the target namespace within Kubernetes where the chart will be installed.

- We create a new Rancher project resource which references an existing project within our Rancher setup.

- We then deploy the Shellbox Helm chart using the `rancher2.App` resource, which encapsulates deploying third-party applications within Rancher-managed clusters.

- Finally, we export the name of our deployed app so that it can be easily queried with the Pulumi CLI after deployment.

To run this program:

1. Save the TypeScript code to a file, for instance `index.ts`.
2. Create a new Pulumi stack if you haven't already:

```bash
   pulumi stack init shellbox-deploy
   ```

3. Run `pulumi up` to preview and deploy the changes:

```bash
   pulumi up
   ```

4. Once the deployment is complete, the output `appName` will display the name of the deployed Helm chart.

Remember to replace placeholder values such as `chartVersion`, `chartRepo`, `projectName`, and `clusterId` with actual values from your own setup.

Also note, this example assumes you have sufficient permissions to deploy applications to the Rancher cluster, and that your Pulumi setup has the correct credentials to interact with Rancher. If any of this is not already configured, you will need to set up the necessary credentials and permissions first.