Deploy the eventstreams helm chart on Rancher

Question

Pulumi · Accepted Answer

To deploy an Event Streams Helm chart on Rancher using Pulumi, you can take advantage of the Rancher2 provider. This allows you to interact with Rancher’s API to manage resources within a Rancher server.

Below is an outline of the steps we're going to take in the Pulumi program:

1. **Set Up a Rancher Server**: Before you can deploy the Helm chart, ensure that you have access to a Rancher server and the necessary permissions to deploy applications. Find the `clusterId` that you wish to deploy the application in.

2. **Install the Rancher2 Pulumi Provider**: This provider is necessary to interact with the Rancher2 platform. You can install it by adding `@pulumi/rancher2` to your `package.json` file.

3. **Namespace**: Namespaces are a way to divide cluster resources between multiple users. You may or may not create a new namespace for your chart deployment, depending on your needs.

4. **Catalog**: If the Helm chart for Event Streams is located in a Helm repository that is not already added to Rancher, you will need to add a Catalog resource pointing to the Helm repository.

5. **App**: The Helm chart will be deployed as an application within Rancher. You will specify the Helm chart details and settings in this resource.

Let's go through the Pulumi TypeScript code to achieve the deployment:

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

// Assume that the user has already set up Pulumi with the necessary credentials
// and has a kubeconfig file pointing to the Rancher-managed Kubernetes cluster.

// Create a new Rancher project to contain our app
const project = new rancher2.Project("my-project", {
    clusterId: "cluster-id", // Replace with your cluster ID
    description: "Project to handle eventstreams",
});

// If you do not have a namespace and you want to create one specifically for the eventstreams helm chart
const appNamespace = new rancher2.Namespace("app-namespace", {
    projectId: project.id,
    name: "eventstreams",
});

// If the Helm chart you want to use is not in a catalog that Rancher is already aware of
// you need to create a new catalog and point it to the location of the Helm chart repository
const eventStreamsCatalog = new rancher2.CatalogV2("eventstreams-catalog", {
    clusterId: "cluster-id", // Replace with your cluster ID
    url: "https://charts.mycompany.com/", // Replace with your Helm chart repository URL
    branch: "master", // The branch of the Helm repo if applicable. Default is master
});

// Deploy the Helm chart using the app resource in the Rancher project and namespace created.
const eventStreamsApp = new rancher2.App("eventstreams-app", {
    projectId: project.id,
    name: "eventstreams",
    targetNamespace: appNamespace.name,
    catalogName: eventStreamsCatalog.name,
    chart: "eventstreams", // Replace with the name of your chart
    // You can customize the chart values by providing a `valuesYaml` string.
    // The format is the same as the values.yaml file used when installing Helm charts manually.
    valuesYaml: `
      replicaCount: 1
      image:
        repository: mycompany/eventstreams
        tag: "1.2.3"
      service:
        type: ClusterIP
        port: 80
    `,
});

// Export the app's name.
export const appName = eventStreamsApp.name;
```

In the above Pulumi program, we first create a new Rancher project to segregate our application from others. After that, we optionally create a Kubernetes namespace if required. Then, if needed, we add a new Catalog resource that points to the Event Streams Helm chart repository. Finally, we deploy the Helm chart as an application within our Rancher setup.

Please replace placeholders like `"cluster-id"`, `"https://charts.mycompany.com/"`, and the `valuesYaml` content with your specific configuration details.

After you write this code to a `.ts` file, you can run it using Pulumi commands to perform the deployment:

1. Initialize a new Pulumi stack, if you haven't already: `pulumi stack init`
2. Install the required node modules: `npm install`
3. Preview the deployment plan: `pulumi preview`
4. Deploy your stack: `pulumi up`

After running `pulumi up`, the resources defined in your code will be created in your Rancher cluster. The `export` statement at the end is to output the name of the deployed application which can be useful when you need to reference the application later on for updates or diagnostics.