Deploy the openwhisk helm chart on Azure Kubernetes Service (AKS)

Question

Pulumi · Accepted Answer

To accomplish your goal of deploying the OpenWhisk Helm chart on an Azure Kubernetes Service (AKS) cluster, you'll need to:

1. Create an AKS cluster on Azure.
2. Configure the Kubernetes provider to connect to your AKS cluster.
3. Use the Helm Chart resource from the Kubernetes provider to deploy OpenWhisk on your cluster.

Let me walk you through step by step.

**Step 1: Create an AKS Cluster**

You are going to use the `azure-native` package, specifically the `ManagedCluster` resource, which is responsible for creating an AKS cluster.

**Step 2: Configure Kubernetes Provider**

Once the AKS cluster is ready, you'll grab its kubeconfig and use it to configure the Kubernetes provider. This allows Pulumi to connect to your AKS cluster and manage Kubernetes resources.

**Step 3: Deploy OpenWhisk Using Helm Chart**

This is where you'll use the Kubernetes provider to deploy OpenWhisk using its Helm chart. The `Chart` resource from the `kubernetes` package helps you deploy Helm charts to your cluster.

Below is the TypeScript program to deploy OpenWhisk to AKS with Pulumi:

```typescript
import * as pulumi from '@pulumi/pulumi';
import * as azure_native from '@pulumi/azure-native';
import * as kubernetes from '@pulumi/kubernetes';

// Create an AKS cluster.
const aksCluster = new azure_native.containerservice.ManagedCluster('aksCluster', {
    resourceGroupName: 'myResourceGroup', // Replace with the name of your resource group
    kubernetesVersion: '1.21.9', // Specify your desired Kubernetes version
    agentPoolProfiles: [{
        count: 2, // Specify the number of nodes in the node pool
        vmSize: 'Standard_DS2_v2', // Specify the size of each node
        mode: 'System',
        name: 'agentpool',
    }],
    // Specify additional settings such as identity, network configuration, etc. (if required)
});

// Export the kubeconfig for the AKS cluster.
export const kubeconfig = aksCluster.kubeconfig.apply(c => c);

// Create a Kubernetes provider instance using the kubeconfig from the AKS cluster.
const k8sProvider = new kubernetes.Provider('k8sProvider', {
    kubeconfig: kubeconfig,
});

// Deploy the OpenWhisk Helm chart using the Kubernetes provider.
const openWhiskChart = new kubernetes.helm.v3.Chart('openwhisk', {
    chart: 'openwhisk', // Replace with the correct chart name if it's different
    version: '1.0', // Specify the version of the chart
    fetchOpts: {
        repo: 'https://openwhisk.apache.org/charts', // Official OpenWhisk Helm repository
    },
}, { provider: k8sProvider });

// Export the IP address or hostname by which OpenWhisk can be accessed.
export const openWhiskUrl = openWhiskChart.getResourceProperty('v1/Service', 'openwhisk-nginx', 'status')
    .apply(status => status.loadBalancer.ingress[0].ip || status.loadBalancer.ingress[0].hostname);
```

**Explanation of the Resources:**

- `ManagedCluster`: Creates a new AKS cluster within the specified resource group, with a specified version of Kubernetes and a configurable number of nodes.

- `Provider`: The Kubernetes provider allows Pulumi to perform actions on the Kubernetes cluster created by `ManagedCluster`. Here it is configured with the `kubeconfig` output from the AKS cluster.

- `Chart`: This deploys a Helm chart to the cluster. Helm is a package manager for Kubernetes, and we're specifying the OpenWhisk chart from its official repository.

Make sure to replace the placeholder values such as `'myResourceGroup'` with the actual names of your Azure resources.

After writing this code to a `index.ts` file in a Pulumi project, you can deploy the resources by running `pulumi up` from the command line. Pulumi will prompt you with a summary of the resources to be created and ask for confirmation before proceeding with the deployment.

The export statements at the end of the code snippet provide you with outputs that you can use to interact with your AKS cluster and OpenWhisk deployment. `kubeconfig` would be used to configure `kubectl` if you want to interact with your cluster via the command line. `openWhiskUrl` provides the URL to access the OpenWhisk API once it's deployed.

Remember to have the Azure CLI logged in and Pulumi configured with an account to run the commands properly.