Deploy the grafana-mixin helm chart on Rancher

Question

Pulumi · Accepted Answer

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

1. **Set up a Rancher Kubernetes cluster**: Ensure you have a Kubernetes cluster managed by Rancher. You can use the `rancher2.Cluster` resource type to create or manage existing clusters in a Rancher environment.
2. **Add a catalog containing the Helm chart**: Use the `rancher2.CatalogV2` resource to add a Helm chart repository as a catalog in Rancher.
3. **Deploy the Helm chart**: With the catalog added, you can use the `helm` package from Pulumi to deploy the Grafana Mixin Helm chart using `helm.v3.Chart` resource type.

Below is a Pulumi program written in TypeScript that illustrates these steps. You'll need to have Pulumi installed and set up with the necessary cloud provider configuration.

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

// Replace these values with the appropriate cluster ID,
// Helm chart repository URL, and chart details.
const clusterId = "your-cluster-id";
const catalogName = "grafana";
const catalogUrl = "https://grafana.github.io/helm-charts";

// Step 1: Create or reference an existing Rancher-managed Kubernetes cluster
// The resource rancher2.Cluster can be used to create a new cluster or manage an existing one.
// For simplicity, assume we reference an existing cluster by its ID.
const cluster = new rancher2.Cluster("my-cluster", {
    // This is a pseudo-configuration as the real setup will be specific to your needs.
});

// Step 2: Add a Helm chart repository as a catalog in Rancher using the rancher2.CatalogV2 resource
const catalog = new rancher2.CatalogV2("grafana-catalog", {
    // Use the reference to the cluster where the catalog should be added
    clusterId: clusterId,
    url: catalogUrl,
    // Specify the branch if necessary, default is usually 'master'
    gitBranch: "master",
});

// Once the catalog is added, we can deploy Helm charts from it.
// Note that Pulumi's Helm support is based on the infrastructure as code approach, where deployment is described declaratively.

// Step 3: Deploy Grafana Mixin Helm chart
// Here we assume that the chart is available in the catalog and that you know the chart name and version.
const helmChartName = "grafana-mixin"; // Replace with the actual chart name
const helmChartVersion = "x.y.z"; // Replace with the actual chart version

// Pulumi's 'k8s.Provider' allows us to instantiate a Kubernetes provider that targets the Rancher kubeconfig endpoint
const k8sProvider = new k8s.Provider("k8s-provider", {
    kubeconfig: cluster.kubeConfig, // This assumes cluster.kubeConfig provides the kubeconfig
});

// Deploy the helm chart into the Kubernetes cluster with helm.v3.Chart
const grafanaChart = new helm.v3.Chart("grafana-mixin-chart", {
    chart: helmChartName,
    version: helmChartVersion,
    // This fetchOpts part is very important, as it configures Pulumi to fetch the chart from the catalog repository previously added
    fetchOpts: {
        repo: catalogUrl
    },
    namespace: "default",
}, { provider: k8sProvider });

// Output the status URL of Grafana
export const grafanaUrl = pulumi.interpolate `http://${grafanaChart.getResource("v1/Service", "default", "grafana").status.loadBalancer.ingress[0].hostname}`;

```

This program carries out the following actions:

- **Defines necessary imports**: The script starts by importing necessary modules from Pulumi and Kubernetes.
- **Sets up a reference to an existing Rancher-managed Kubernetes cluster**: this would be your target Rancher Kubernetes cluster that you want to deploy Grafana to.
- **Adds a catalog to Rancher**: This catalog points to the repository where the Grafana Helm charts are located.
- **Creates a Kubernetes provider**: This targets your Rancher Kubernetes cluster, using the kubeconfig information from `cluster`.
- **Deploys the Grafana Mixin Helm chart**: Finally, the specified version of the Grafana Mixin Helm chart is deployed to the default namespace of your cluster. You might want to customize the namespaces and other chart values depending on your exact needs.
- **Exports Grafana URL**: After deployment, the program exports the URL where Grafana can be accessed if it's using a LoadBalancer service.

To execute the aforementioned Pulumi program:

1. Save the code in a file with a `.ts` extension, for example, `deployGrafana.ts`.
2. Run `pulumi up` within the directory where the file is located.

Note that the above program doesn't create a Rancher cluster but assumes you already have one. If you need to create a Rancher cluster, that would require a more complex setup, and you would typically set that up separately from deploying applications on top of it.

Remember to replace placeholders such as `your-cluster-id`, `helmChartName`, and `helmChartVersion` with actual values specific to your context. Additionally, ensure you're logged into the correct Pulumi stack and have the appropriate access to the cluster.