Deploy the tekton-pipeline helm chart on Azure Kubernetes Service (AKS)

Question

Pulumi · Accepted Answer

To deploy the Tekton Pipelines Helm chart on an Azure Kubernetes Service (AKS) cluster using Pulumi, you'll go through a series of steps:

1. Create an AKS cluster, if you don't already have one. This is where your Tekton Pipelines will be deployed.
2. Install the Tekton Pipelines Helm chart onto the AKS cluster.

In this guide, I'll show you how to programmatically achieve these steps using Pulumi with TypeScript. We'll use the `azure-native` package to create an AKS cluster and then utilize the Helm chart resource from the `kubernetes` provider to deploy Tekton Pipelines.

### Prerequisites

Before running your Pulumi program, you will need:

- Pulumi CLI installed and configured with an Azure account.
- Access to an Azure subscription and the necessary permissions to create resources.

### Program Explanation and Setup

1. **AKS Cluster Creation:** We'll create a managed Kubernetes cluster using Azure's native capabilities wrapped in Pulumi's API. We will specify the necessary inputs like the resource group, cluster size, and other configurations related to AKS.

2. **Tekton Pipelines Helm Chart Deployment:** Once the AKS cluster is up and running, we will configure Pulumi to interact with this cluster using the Pulumi Kubernetes provider. Then we'll deploy the Tekton Pipelines Helm chart which sets up Tekton Pipelines in the Kubernetes cluster so that you can start defining and running your CI/CD pipelines.

Now, let's move to the code.

### Pulumi Program to Deploy Tekton on AKS

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

// Step 1: Create an AKS cluster
const resourceGroupName = 'myResourceGroupName'; // Specify the name of the resource group
const resourceGroup = new azure_native.resources.ResourceGroup('myResourceGroup', {
    resourceGroupName: resourceGroupName,
});

const cluster = new azure_native.containerservice.ManagedCluster('myAKSCluster', {
    resourceGroupName: resourceGroupName,
    agentPoolProfiles: [{
        count: 3,
        maxPods: 110,
        mode: "System",
        osType: "Linux",
        vmSize: "Standard_DS2_v2",
        name: "agentpool",
    }],
    dnsPrefix: 'myakscluster',
    kubernetesVersion: '1.20.5',
    resourceName: 'myAKSCluster',
});

// Export the Kubeconfig file for the AKS cluster
export const kubeconfig = cluster.kubeConfig;

// Wait for the cluster to be created to set up the Kubeconfig
const k8sProvider = new k8s.Provider('k8sProvider', {
    kubeconfig: kubeconfig.apply(JSON.stringify),
});

// Step 2: Deploy Tekton Pipelines using Helm chart
const tektonChart = new k8s.helm.v3.Chart('tekton-pipelines', {
    chart: 'tekton-pipelines',
    version: '0.17.1', // Specify the version of the chart you want to use
    fetchOpts: {
        repo: 'https://tekton.dev/charts',
    },
    namespace: 'tekton-pipelines', // Specify the namespace to install the chart in
}, { provider: k8sProvider });

// Export the status
export const tektonStatus = tektonChart.status;
```

### Explanation of the Pulumi Program

In the program above, we've accomplished the following:

- Defined an Azure resource group where the Kubernetes cluster will reside.
- Created an AKS cluster with the desired size and configuration.
- Exported the kubeconfig required to interact with the AKS cluster using Kubernetes tools such as `kubectl`.
- Defined a K8s Provider, which is a way for Pulumi to communicate and manage resources on a Kubernetes cluster.
- Deployed the Tekton Pipelines Helm chart to the AKS cluster in the specified namespace using the Helm chart resource.

Remember to replace `'myResourceGroupName'`, `'myakscluster'`, and other placeholder strings with actual names and settings for your specific scenario.

After running this Pulumi program, you'll be able to use the exported `kubeconfig` to interact with your AKS cluster and see the status of the Tekton Pipelines deployment. You can now use `kubectl` to create and manage your CI/CD Tekton tasks and pipelines.