Deploy the ts-server helm chart on Rancher

Question

Pulumi · Accepted Answer

Deploying a Helm chart on Rancher using Pulumi involves several steps. You will need to set up a Rancher cluster, install the Rancher2 provider, configure your Pulumi code to connect to the Rancher server, and then deploy the Helm chart.

The following program in TypeScript demonstrates how to deploy a Helm chart on Rancher. We will be using the `rancher2` provider to interact with your Rancher server. The `Cluster` and `AppV2` resources are particularly important for this task. The `Cluster` resource represents a Rancher Cluster that is to be targeted for the Helm chart deployment, and the `AppV2` resource represents the deployment of the Helm chart on the specified Rancher Cluster.

Please note that this code assumes that you have a Rancher server already running and accessible. You will need to provide the required information (like cluster name, catalog name, and version of the Helm chart) yourself. Replace the placeholders with your actual details.

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

// Initialize a `Cluster` resource using the `rancher2` provider that represents the target Rancher cluster.
const cluster = new rancher2.Cluster("ts-server-cluster", {
    // You need to specify the `rkeConfig`, which should match with your actual infrastructure.
    rkeConfig: {
        // The specific `nodes`, `network`, `services`, etc., that will form part of your cluster.
        // For example, the configuration below is quite basic and for demonstration purposes only.
        nodes: [
            {
                address: "nodeIp",
                internalAddress: "nodeInternalIp",
                user: "rancher",
                roles: ["controlplane", "etcd", "worker"],
                sshKey: "ssh-rsa AAAAB3NzaC1yc2EAAAAD...",
            },
        ],
        services: {
            etcd: {
                // Etcd Service configuration properties can be set here.
            },
            // Define kube-api, kubelet, etc., as needed.
        },
        // Additional configurations related to network plugins, ingress controllers, etc.
    },
    // Assume you want to deploy on the local cluster,
    // normally you would setup a cluster using `RKE` or a cloud provider's Kubernetes service.
});

// Create a namespace for your Helm chart.
const namespace = new rancher2.Namespace("ts-server-namespace", {
    name: "ts-server-ns",
    projectId: pulumi.output(cluster.id).apply(id => `local:${id}`), // Relate namespace to cluster
});

// Now, deploy the Helm chart into the Rancher cluster using the `AppV2` resource.
const tsServerChart = new rancher2.AppV2("ts-server", {
    clusterId: pulumi.output(cluster.id), // The ID of your cluster
    namespace: namespace.name,
    repoName: "ts-server-repo", // The name of the Helm chart repository
    chartName: "ts-server-chart",
    chartVersion: "1.0.0", // Set the version of the chart you want to deploy
    // Values here represent Helm's values.yaml file and will vary based on chart's requirements.
    values: pulumi.output({
        service: {
            type: "ClusterIP",
            port: 80,
        },
        // You can include any other necessary values here.
    }).apply(values => JSON.stringify(values)),
});

// Export the URL to access the deployed application
export const url = pulumi.interpolate`http://${tsServerChart.status.namespace}.${tsServerChart.status.name}`;

```

In this TypeScript program, you need to replace placeholder values such as `nodeIp`, `ssh-rsa AAAAB3...`, `ts-server-repo`, `ts-server-chart`, and other details specific to your Rancher setup and the Helm chart you are deploying. The `values` field in the `AppV2` resource is structured similarly to a Helm `values.yaml` file and should be adjusted based on the specifics of the `ts-server` Helm chart you are using.

Please ensure that you have set up `pulumi` and have the necessary provider configurations in place before running this code. Once you deploy this Pulumi program with `pulumi up`, it will provision a new namespace and deploy your Helm chart into your Rancher cluster.

Let's break down some parts of the program:

- We define a `Cluster` resource, which signifies the target environment for our Helm deployment. In this case, I've used placeholders; you will have to set it up according to your Rancher environment.
- A `Namespace` specific to our application is created within Rancher to isolate our deployment.
- We then define an `AppV2`, specifying the Helm chart we wish to deploy (`ts-server`), the namespace to deploy into, and other configurations like values normally found in a Helm `values.yaml`.

Finally, we export a computed URL where the deployed service should be accessible, assuming that the service type is set to `ClusterIP` and is being exposed within the cluster. If your service type is `LoadBalancer` or `NodePort`, you might want to modify the export statement to reflect how you can access the service.