Deploy the jenkins-x-platform helm chart on Azure Kubernetes Service (AKS)

Question

Pulumi · Accepted Answer

I'll provide you with a detailed explanation and a TypeScript program that deploys the Jenkins X platform Helm chart on an Azure Kubernetes Service (AKS) cluster using Pulumi.

### Overview

First, we'll create an AKS cluster by provisioning the necessary resources using the `azure-native` provider. This will involve setting up an AKS cluster, a resource group, and possibly other dependent resources like a service principal or identity if not otherwise specified.

Once the AKS cluster is up and running, we'll use the `kubernetes` provider to deploy the Jenkins X platform Helm chart onto our AKS cluster. The `kubernetes.helm.v3.Chart` resource will help us manage and deploy Helm charts.

Here's the general process we'll follow in the TypeScript code:

1. Set up an Azure resource group.
2. Create an AKS cluster.
3. Configure Pulumi to use the Kubernetes provider, which points to the AKS cluster.
4. Deploy the Jenkins X platform Helm chart using the `kubernetes.helm.v3.Chart` resource.

### Program Details

Below is the TypeScript program that you can use to deploy Jenkins X on an AKS cluster. Ensure that you have the required permissions to create these resources and that your Pulumi CLI is authenticated with Azure.

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

// Create an Azure Resource Group
const resourceGroup = new azure.core.ResourceGroup('jenkinsResourceGroup', {
    location: 'West US', // You can choose the appropriate Azure region
});

// Create an AKS cluster
const cluster = new azure.containerservice.KubernetesCluster('jenkinsCluster', {
    resourceGroupName: resourceGroup.name,
    defaultNodePool: {
        name: 'default',
        nodeCount: 2,
        vmSize: 'Standard_DS2_v2',
    },
    dnsPrefix: 'jenkins-aks', // Choose your own DNS prefix
    servicePrincipal: {
        clientId: process.env.AZURE_CLIENT_ID,     // Set your Azure Client ID
        clientSecret: process.env.AZURE_CLIENT_SECRET, // Set your Azure Client Secret
    },
});

// Export the AKS cluster kubeconfig
export const kubeconfig = cluster.kubeConfigRaw;

// Use the Kubernetes provider to interact with the AKS cluster
const k8sProvider = new k8s.Provider('k8sProvider', {
    kubeconfig: cluster.kubeConfigRaw,
});

// Deploy the Jenkins X platform using a Helm Chart
const jenkinsChart = new k8s.helm.v3.Chart('jenkins-x-platform', {
    chart: 'jenkins-x-platform',
    version: '2.0.2281', // Specify the version of the Jenkins X platform Helm chart
    fetchOpts: {
        repo: 'https://jenkins-x-charts.github.io/v2', // Jenkins X Helm repository
    },
}, { provider: k8sProvider });

// Export the Jenkins X Kubernetes service endpoint
export const jenkinsEndpoint = jenkinsChart.getResource('v1/Service', 'jenkins-x/jenkins-x-platform').status.loadBalancer.ingress[0].hostname;
```

### Explanation

- We import the necessary Pulumi packages to interact with Azure and Kubernetes.
- We create an Azure resource group to contain our infrastructure resources.
- We provision an AKS cluster within the created resource group, specifying the size and number of nodes, along with the service principal credentials necessary for AKS to manage Azure resources on your behalf.
- We export the raw kubeconfig of the cluster, which is used by the Pulumi Kubernetes provider to manage resources within the cluster.
- We instantiate the Kubernetes provider with the kubeconfig of the AKS cluster to communicate with the cluster.
- We create a new Helm chart resource which points to the Jenkins X platform chart in the official Jenkins X Helm repository, and we specify the version of the chart to deploy.
- Lastly, we export the endpoint of the Jenkins service deployed by the Helm chart, which you can use to access the Jenkins X dashboard.

Please ensure the version of the `jenkins-x-platform` chart is correct and update the repository URL if it changes. You need to have your Azure credentials (`AZURE_CLIENT_ID` and `AZURE_CLIENT_SECRET`) set in your environment for the AKS cluster to be created. Make sure to replace the placeholders with your actual credentials.

This program should be run with Pulumi CLI commands like `pulumi up`, which will perform the resource creation and deployment as indicated in the code. To access the Jenkins X dashboard, use the exported `jenkinsEndpoint` once the deployment is complete.