Deploy the openwhisk helm chart on Rancher

Question

Pulumi · Accepted Answer

Deploying an OpenWhisk helm chart on a Rancher-managed Kubernetes cluster involves several steps. The Rancher 2.x platform simplifies Kubernetes cluster management and Helm is a package manager for Kubernetes, which allows you to deploy applications like OpenWhisk. Below is a guide on how you might approach this task using Pulumi with TypeScript.

### Prerequisites

Before you start, make sure that you have:

1. A Rancher-managed Kubernetes cluster up and running.
2. Pulumi CLI installed and configured with your cloud provider credentials.
3. `kubectl` configured to interact with your Rancher cluster.
4. Helm CLI installed, if you plan to run Helm commands locally.

For the sake of this guide, we will assume that the Rancher cluster is already set up and configured, and that you have administrative access to it.

### Step 1: Set up Pulumi and Install the Rancher 2 Provider

First, install the required Pulumi packages for interacting with Rancher 2.

```bash
# Install the Pulumi Rancher2 provider package
npm install @pulumi/rancher2
```

### Step 2: Write the Pulumi Program

The following TypeScript program outlines how you could use Pulumi to deploy the OpenWhisk helm chart onto a Rancher-managed Kubernetes cluster:

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

// First, we instantiate a provider to interact with your Rancher installation.
// It assumes that you have the Rancher API details and authentication tokens available in your environment.

const rancherProvider = new rancher2.Provider("my-rancher-provider", {
    api_url: process.env.RANCHER_API_URL,
    accessKey: process.env.RANCHER_ACCESS_KEY,
    secretKey: process.env.RANCHER_SECRET_KEY,
});

// Next, we'll fetch the cluster where we want to deploy OpenWhisk.
// Replace 'example-cluster' with the actual name or ID of your Rancher-managed cluster.

const cluster = rancher2.getCluster({ name: "example-cluster" }, { provider: rancherProvider });

// Once we have the cluster information, we will create a Pulumi Kubernetes provider.
// This will be used to deploy resources on this specific cluster.

const k8sProvider = new k8s.Provider("k8s-provider", {
    kubeconfig: cluster.kubeConfig,
});

// Now we can deploy the OpenWhisk helm chart.
// Make sure you have the correct chart name and version, as well as any values you want to override in the `values` property.

const openwhiskChart = new k8s.helm.v3.Chart("openwhisk", {
    chart: "openwhisk",
    version: "0.1.0", // Replace this with the actual chart version
    fetchOpts: {
        repo: "https://openwhisk.apache.org/charts", // Helm chart repository
    }, 
    values: {
        // Place your custom chart values here, if any
    },
}, { provider: k8sProvider });

// Export any necessary resources, such as URLs or IPs to access OpenWhisk.
export const openwhiskApiGatewayUrl = openwhiskChart.getResourceProperty("v1/Service", "openwhisk-nginx", "status").apply(status => status.loadBalancer.ingress[0].ip);
```

This program will set up a provider to interact with your Rancher cluster, fetch the cluster configuration to communicate with Kubernetes, and finally deploy OpenWhisk using its Helm chart.

### Step 3: Run Pulumi

To execute the Pulumi program, save the code in a file named `index.ts` and run the following commands:

```bash
# Install the dependencies
npm install

# Login to the Pulumi service
pulumi login

# Create a new Pulumi stack, if needed
pulumi stack init dev

# Preview the deployment plan
pulumi preview

# Execute the deployment
pulumi up
```

When you run `pulumi up`, Pulumi will reach out to your Rancher-managed cluster and apply the Helm chart for OpenWhisk, provisioning it with all necessary Kubernetes resources, such as Deployments, Services, ConfigMaps, and others.

### Step 4: Verifying Deployment

After the deployment is successful, Pulumi will output any exported resources, like the API gateway URL for OpenWhisk. You can use the `kubectl` command to further verify the state and health of the OpenWhisk deployment on your Rancher cluster.

```bash
# Example: Checking deployments with kubectl
kubectl get deployments
```

### Troubleshooting

If you encounter issues:

- Check that your Pulumi stack configuration values are correct.
- Verify that you have the necessary permissions on the Rancher cluster.
- Make sure the OpenWhisk Helm chart version is correct and available in the repository.
- Review the Pulumi logs for detailed error messages.

Deploying applications using Pulumi with Rancher and Helm streamline the deployment process and codify your infrastructure, making it easily reproducible and version controlled.