Deploy the Wordpress helm chart on Rancher

Question

Pulumi · Accepted Answer

Deploying a Helm chart on Rancher using Pulumi involves several steps, which include setting up a Rancher-managed Kubernetes cluster and then deploying the chart using the `rancher2` Pulumi provider. Below I will provide a detailed guide on how to execute these steps using Pulumi's TypeScript SDK.

### Prerequisites

Before you begin, you should have the following prerequisites in place:

1. **Pulumi CLI Installed**: Make sure you have the Pulumi CLI installed. If not, please follow the [installation guide](https://www.pulumi.com/docs/get-started/install/).
2. **Rancher Server Ready**: You need to have access to a Rancher server with the necessary permissions to create clusters and workloads.
3. **Pulumi Account**: You'll need a Pulumi account to save and manage your states. Sign up for free [here](https://app.pulumi.com/signup).
4. **Rancher2 Provider Setup**: The `rancher2` Pulumi provider plugin should be configured with credentials to communicate with your Rancher server. This typically involves setting the `RANCHER_URL`, `RANCHER_ACCESS_KEY`, and `RANCHER_SECRET_KEY` environment variables.

### Setup the Rancher2 Provider

First, you will need to set up the `rancher2` provider in your Pulumi program. You can do this by using the `pulumi.Config` class to retrieve necessary configuration values that will be initialized as environment variables.

### Define the Rancher Kubernetes Cluster

Then, you can use the `rancher2.Cluster` resource to create a new Kubernetes cluster managed by Rancher. With Pulumi, a resource instance represents an actual instance of the resource which will be provisioned on running `pulumi up`.

### Deploy WordPress Helm Chart

After you have a Kubernetes cluster ready, you can deploy applications using Helm charts with the rancher2 provider. The `rancher` provider supports deploying Helm charts through its `AppsV1` resource. You can specify the necessary details for the Wordpress chart, such as the name, namespace, and chart values.

Now, let's write the TypeScript code for these steps.

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

// Set up a Pulumi program configuration, where you might store sensitive settings
const config = new pulumi.Config();

// For example, to create a Rancher2 Cluster, you could use the following configuration values
// Note: Replace these placeholder values with your actual data.
const rancherUrl = config.requireSecret("rancherUrl"); // Rancher Server URL
const accessKey = config.requireSecret("accessKey");   // Your Rancher Access Key
const secretKey = config.requireSecret("secretKey");   // Your Rancher Secret Key

// Set up the Rancher2 provider using the credentials obtained from the config
const rancher2Provider = new rancher2.Provider("rancher-provider", {
    apiUrl: rancherUrl,
    accessKey: accessKey,
    secretKey: secretKey,
});

// Here we create a new Kubernetes cluster managed by Rancher
const cluster = new rancher2.Cluster("my-wordpress-cluster", {
    // Configure your cluster as needed
    rkeConfig: {
        // Note: The actual configuration might vary based on your Rancher setup and the Kubernetes version being used
    },
    // More settings ...,
}, { provider: rancher2Provider });

// After the cluster is ready, deploy WordPress Helm chart
const wordpressApp = new rancher2.AppV2("wordpress", {
    clusterId: cluster.id,
    namespace: "default",
    repoName: "stable", // Assuming 'stable' repo is configured in your Rancher server
    chartName: "wordpress",
    chartVersion: "9.0.3", // Use the version of the chart you want to deploy
    values: `
        image:
          repository: bitnami/wordpress
          tag: 5.7.1-debian-10-r0
        # ... other chart values
    `,
}, { provider: rancher2Provider, dependsOn: [cluster] });

// Export the cluster's kubeconfig
export const kubeconfig = cluster.kubeConfig;
```

### Explanation

In the code above:

1. We create a Pulumi project configuration to securely handle sensitive values using `config.requireSecret`.
2. We instantiate the `rancher2.Provider` with the necessary credentials, pointing at the target Rancher server.
3. We define a Rancher `Cluster` resource, specifying any necessary RKE (Rancher Kubernetes Engine) settings. You will need to fill this out based on the details of your Rancher setup.
4. We create an `AppV2` resource for the WordPress Helm chart. The `clusterId` is derived from the cluster resource, and we specify the chart details including the repository, name, and version.

You'll need to fill in details specific to your Rancher setup, especially within `rkeConfig` since this dictates how your Kubernetes nodes will be provisioned.

### Running the Program

To run the program, navigate to the directory containing your Pulumi program and run:

```bash
pulumi up
```

This command will provision the cluster as defined and then deploy the specified WordPress Helm chart. The output will provide details of the resources created and the `kubeconfig` needed to interact with your Kubernetes cluster directly.