Deploy the static-site helm chart on Rancher

Question

Pulumi · Accepted Answer

In order to deploy a static-site Helm chart on a Rancher-managed Kubernetes cluster using Pulumi, you need to perform a series of steps. These involve setting up the required infrastructure on Rancher, installing the Helm chart, and appropriately configuring it for a static site deployment.

Here's how you can accomplish this using Pulumi with TypeScript:

1. **Set Up Rancher Kubernetes Cluster**: Before you deploy any application, you need a Kubernetes cluster managed by Rancher. You can create one using Pulumi's `rancher2` provider, which is tailored for managing Rancher resources.

2. **Install Helm Chart**: Once you have a Kubernetes cluster managed by Rancher, you can deploy your static-site using a Helm chart. Helm charts define, install, and upgrade even the most complex Kubernetes applications.

The following Pulumi program in TypeScript:

- Sets up a Kubernetes cluster in Rancher (I'll use a placeholder configuration for the cluster, as the specific details will be highly dependent on your environment and preferences).
- Installs a Helm chart for a static site.

Please replace the placeholders with your actual configuration details where applicable.

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

// Create a new Rancher v2 Kubernetes cluster
const cluster = new rancher2.Cluster("my-cluster", {
    // You would typically define configuration parameters here.
    // This can include the Rancher Kubernetes Engine (RKE) version,
    // node sizes, the number of nodes, and various other settings.
    // The following is a logical placeholder.
    rkeConfig: {
        // ... RKE configuration ...
    },
    // Additional cluster settings...
});

// Once the cluster is provisioned, we can configure the Pulumi Kubernetes provider to deploy
// resources to that cluster.
const k8sProvider = new k8s.Provider("k8s-provider", {
    kubeconfig: cluster.kubeConfigRaw,
});

// Install a Helm chart for a static website. You can find static site charts in Helm repositories or create your own.
const staticSiteChart = new k8s.helm.v3.Chart("static-site", {
    chart: "my-static-site", // This should be the name of your Helm chart for a static website.
    // Define values for the Helm chart, such as image repository, service type, etc.
    values: {
        // ... chart values ...
    },
    // Indicate that this Helm chart should be installed in the Kubernetes cluster that we have just created.
}, { provider: k8sProvider });

// Export the public URL through which the static site is accessible.
export const staticSiteUrl = staticSiteChart.getResourceProperty("v1/Service", "my-static-site", "status").apply(status => status.loadBalancer.ingress[0].ip);
```

In the code above:

- We import the `@pulumi/pulumi`, `@pulumi/rancher2`, and `@pulumi/kubernetes` packages. These are used to interact with Pulumi, Rancher, and Kubernetes resources respectively.
- We create a new Rancher-managed Kubernetes cluster using `rancher2.Cluster`, where you would define your desired configuration.
- We set up a Pulumi Kubernetes provider pointing to the Rancher Kubernetes cluster's kubeconfig.
- We then declare a Helm chart resource for our static site using `k8s.helm.v3.Chart`. This assumes you have a Helm chart named `my-static-site`, which you need to replace with the actual chart you intend to use.
- Finally, we export the URL of the static site using `staticSiteChart.getResourceProperty`. This assumes that the Helm chart includes a `Service` with a `loadBalancer` that provides an IP address or hostname.

Remember to replace `"my-static-site"`, `rkeConfig`, and `chart values` with the actual details that correspond to your Helm chart and Rancher cluster configuration.

To run this Pulumi program:

1. Ensure you have Pulumi installed and configured with the necessary cloud credentials.
2. Save the code in a file with a `.ts` extension, like `index.ts`.
3. Run `pulumi up` from the command line in the same directory as your code file. Pulumi will perform the deployment according to your code.

This will provision the necessary resources in Rancher and deploy the static site Helm chart. You'll be able to see the outputs and the URL endpoint where the static site can be accessed once the deployment completes.