Deploy the jenkins-weekly helm chart on Kubernetes

Question

Pulumi · Accepted Answer

Deploying a Helm chart on Kubernetes using Pulumi involves a few steps:

Set up your Kubernetes cluster where Jenkins will deploy. Depending on your environment, this could be a managed Kubernetes service like Amazon EKS, Google GKE, Microsoft AKS, or a self-hosted one.
Install Pulumi CLI and configure it to use the desired Kubernetes cluster. Ensure you have kubectl installed and configured to interact with your cluster as Pulumi uses it to communicate with Kubernetes.
Write a Pulumi program in TypeScript to specify the deployment of the Jenkins Helm chart.

Let's go through a sample Pulumi program in TypeScript to deploy the jenkins-weekly Helm chart.

Before running the code, make sure that:

You have a Kubernetes cluster running and kubectl is configured to connect to it.
Helm is installed if you want to manage Helm repository configurations outside Pulumi.
You have Pulumi installed and logged in (run pulumi login).

Here is a detailed Pulumi program that deploys a Jenkins Helm chart onto a Kubernetes cluster:

import * as kubernetes from "@pulumi/kubernetes";

// Create an instance of the Kubernetes provider.
const provider = new kubernetes.Provider("provider", { kubeconfig: "<your-kubeconfig-here>" });

// Deploy Jenkins using the Helm Chart.
const jenkinsChart = new kubernetes.helm.v3.Chart("jenkins", {
    chart: "jenkins",
    // Specify the Helm repository where the chart is located.
    fetchOpts: {
        repo: "https://charts.jenkins.io"
    },
    // Use version to specify a specific chart version.
    version: "weekly", // Or use a specific version number if preferred.
    // Provide values for the Helm chart.
    values: {
        // You can override default values here, for example, you can enable persistence:
        persistence: {
            enabled: true,
            storageClass: "my-storage-class", // Specify your storage class
            size: "8Gi", // Specify the size of the storage
        },
        // Custom Jenkins configuration here...
    },
}, { provider });

// Export the Jenkins instance's IP to access it later.
export const jenkinsIp = jenkinsChart.getResourceProperty("v1/Service", "jenkins", "status")
    .apply(status => status.loadBalancer.ingress[0].ip);

This program does the following:

It imports the necessary Pulumi Kubernetes package.
A Kubernetes provider instance is created. You need to replace "<your-kubeconfig-here>" with your actual kubeconfig file contents for Pulumi to connect to your cluster.
It sets up a new Helm chart resource for Jenkins. The chart parameter specifies the name of the chart ("jenkins"), and fetchOpts.repo points to the Helm repository URL where the chart is stored, which in this case, is the official Jenkins chart repository.
In the values section, you can override default Helm chart values. Here, it shows an example of enabling persistent storage, assigning a storage class, and defining the size of the persistent volume.
The provider specifies which Kubernetes cluster to deploy to.
Once the deployment is complete, the program exports the external IP address of the Jenkins service, assuming it's exposed via a LoadBalancer. In cases where LoadBalancer is not used, you might need to adapt this part to fit your setup, like exporting a NodePort or a ClusterIP.

To run this Pulumi program:

Save this TypeScript code to a file called index.ts.
Run pulumi up to preview and deploy the changes.

After the deployment, you can access Jenkins using the external IP address provided as the stack output. Remember to set up any necessary firewall rules or access policies to allow traffic to Jenkins.