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

Question

Pulumi · Accepted Answer

To deploy the Jenkins X minimal Helm chart on Azure Kubernetes Service (AKS), you will need to follow these steps:

1. **Create an AKS Cluster:** You'll start by creating an AKS cluster where your Jenkins X deployment will reside.

2. **Deploy the Helm Chart**: Once AKS is running, you will deploy the Jenkins X minimal Helm chart into the cluster.

Below is the Pulumi program in TypeScript that accomplishes these tasks. I'll briefly explain each part of the code.

First, you'll need to import the necessary modules from Pulumi and establish some basic configuration parameters, such as the desired region for your resources:

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

// Set the desired location for your AKS cluster
const location = "WestUS";
// Name of the AKS cluster
const clusterName = "jenkins-x-cluster";
// Name of the resource group where the AKS cluster will be located
const resourceGroupName = "jenkins-x-resources";
```

Next, you create a new resource group for your cluster:

```typescript
// Create a new resource group to contain the AKS cluster and related resources
const resourceGroup = new azure.core.ResourceGroup(resourceGroupName, { location });
```

Following the resource group, you will create the AKS cluster:

```typescript
// Create an AKS cluster
const cluster = new azure.containerservice.KubernetesCluster(clusterName, {
    // Reference to the created resource group
    resourceGroupName: resourceGroup.name,
    location: resourceGroup.location,
    defaultNodePool: {
        name: "aksagentpool",
        nodeCount: 2,
        vmSize: "Standard_DS2_v2",
    },
    dnsPrefix: `${pulumi.getStack()}-kube`,
    linuxProfile: {
        adminUsername: "adminuser",
        sshKey: {
            keyData: sshPublicKey,
        },
    },
    servicePrincipal: {
        clientId: clientId,
        clientSecret: clientSecret,
    },
    kubernetesVersion: "1.20.9",
});

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

The AKS cluster declaration includes key details like the node count, VM size, and Kubernetes version. Ensure you have the AWS cloud provider set up and the SSH public key, client ID, and client secret ready. Once the cluster is up, we export the kubeconfig, which allows us to interact with the cluster.

Now you are ready to deploy the Jenkins X Helm chart into your cluster:

```typescript
// Create a Kubernetes provider instance that uses the generated kubeconfig from the AKS cluster
const k8sProvider = new k8s.Provider(clusterName, {
    kubeconfig: cluster.kubeConfigRaw,
});

// Deploy Jenkins X Helm chart using the Kubernetes provider
const jenkinsXChart = new k8s.helm.v3.Chart("jenkins-x-minimal", {
    chart: "jenkins-x-platform",
    version: "2.0.1149",
    fetchOpts:{
        repo: "https://jenkins-x.github.io/jenkins-x-versions",
    },
}, { provider: k8sProvider });

// Export Jenkins X Helm chart resources
export const jenkinsResources = jenkinsXChart.resources;
```

In the Helm chart deployment section, we initialize a Kubernetes provider with the AKS kubeconfig. Then, we deploy the Jenkins X minimal Helm chart using its repository URL. We also export the resources created by the Helm chart, so you can monitor what has been deployed.

Here's the complete Pulumi program to deploy the Jenkins X minimal Helm chart on AKS:

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

// Set the desired location for your AKS cluster
const location = "WestUS";
// Name of the AKS cluster
const clusterName = "jenkins-x-cluster";
// Name of the resource group where the AKS cluster will be located
const resourceGroupName = "jenkins-x-resources";

// Create a new resource group to contain the AKS cluster and related resources
const resourceGroup = new azure.core.ResourceGroup(resourceGroupName, { location });

// Create an AKS cluster
const cluster = new azure.containerservice.KubernetesCluster(clusterName, {
    resourceGroupName: resourceGroup.name,
    location: resourceGroup.location,
    defaultNodePool: {
        name: "aksagentpool",
        nodeCount: 2,
        vmSize: "Standard_DS2_v2",
    },
    dnsPrefix: `${pulumi.getStack()}-kube`,
    linuxProfile: {
        adminUsername: "adminuser",
        sshKey: {
            keyData: sshPublicKey,
        },
    },
    servicePrincipal: {
        clientId: clientId,
        clientSecret: clientSecret,
    },
    kubernetesVersion: "1.20.9",
});

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

// Create a Kubernetes provider instance that uses the generated kubeconfig from the AKS cluster
const k8sProvider = new k8s.Provider(clusterName, {
    kubeconfig: cluster.kubeConfigRaw,
});

// Deploy Jenkins X Helm chart using the Kubernetes provider
const jenkinsXChart = new k8s.helm.v3.Chart("jenkins-x-minimal", {
    chart: "jenkins-x-platform",
    version: "2.0.1149",
    fetchOpts:{
        repo: "https://jenkins-x.github.io/jenkins-x-versions",
    },
}, { provider: k8sProvider });

// Export Jenkins X Helm chart resources
export const jenkinsResources = jenkinsXChart.resources;
```

Please replace `sshPublicKey`, `clientId`, and `clientSecret` with your actual SSH public key and your Azure client ID and secret for the service principal, respectively.

This code sets up your AKS cluster and deploys the Jenkins X minimal Helm chart on it. You can then use the outputted `kubeconfig` to interact with your Kubernetes cluster and see the list of resources created as part of the Jenkins X chart deployment. Remember that managing and maintaining a Jenkins X infrastructure requires a good understanding of both Kubernetes and Jenkins X itself.

For further reference on creating an AKS cluster using Pulumi you can check the Pulumi Azure documentation: [KubernetesCluster](https://www.pulumi.com/registry/packages/azure/api-docs/containerservice/kubernetescluster/). For deploying Helm charts with Pulumi, there is the Helm documentation: [Helm Chart](https://www.pulumi.com/registry/packages/kubernetes/api-docs/helm/v3/chart/).

This guide assumes that you have the Pulumi CLI installed and logged in to your Azure account, with the necessary permissions to create resources. If not, you can get started with Pulumi by installing the CLI from the Pulumi [Getting Started](https://www.pulumi.com/docs/get-started/azure/) guide and setting up your Azure credentials accordingly.