Deploy the jira-service-desk-operator helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy the `jira-service-desk-operator` Helm chart on Google Kubernetes Engine (GKE), we will be performing the following steps:

1. Create a GKE cluster to host our application.
2. Install and configure the Helm chart on the created GKE cluster.

First, ensure that you have Pulumi installed and configured to use the Google Cloud Platform. You'll need to have your GCP credentials configured for Pulumi via the `gcloud` CLI or the respective environment variables.

In this program, we will use the `@pulumi/gcp` package to create a GKE cluster and `@pulumi/kubernetes` to deploy the Helm chart. Since Helm charts are a standard way to package and deploy Kubernetes applications, Pulumi can manage this as part of its infrastructure as code approach.

**Creating a GKE Cluster:**

We will define a GKE cluster using the `google-native.container/v1beta1.Cluster` resource. This will give us a Kubernetes cluster in Google Cloud with the specified configuration.

**Deploying Helm Chart to GKE:**

To deploy the Helm chart, we will instantiate a `kubernetes.helm.v3.Chart` resource, which will essentially `helm install` the jira-service-desk-operator chart into our GKE cluster. For this to work, you will need to have the Helm CLI installed and any necessary repositories added on the machine where you'll be running Pulumi.

Here's the TypeScript program that accomplishes this:

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

// Create a GKE cluster
const cluster = new gcp.container.Cluster("jira-service-desk-cluster", {
    initialNodeCount: 2,
    minMasterVersion: "latest",
    nodeVersion: "latest",
    nodeConfig: {
        machineType: "n1-standard-1", // Adjust machine type as necessary
        oauthScopes: [
            "https://www.googleapis.com/auth/compute",
            "https://www.googleapis.com/auth/devstorage.read_only",
            "https://www.googleapis.com/auth/logging.write",
            "https://www.googleapis.com/auth/monitoring"
        ],
    },
});

// Export the Cluster name
export const clusterName = cluster.name;

// Export the Kubeconfig to access the cluster using kubectl
export const kubeconfig = pulumi.
    all([cluster.name, cluster.endpoint, cluster.masterAuth]).
    apply(([name, endpoint, masterAuth]) => {
        const context = `${gcp.config.project}_${gcp.config.zone}_${name}`;
        return `apiVersion: v1
clusters:
- cluster:
    certificate-authority-data: ${masterAuth.clusterCaCertificate}
    server: https://${endpoint}
  name: ${context}
contexts:
- context:
    cluster: ${context}
    user: ${context}
  name: ${context}
current-context: ${context}
kind: Config
preferences: {}
users:
- name: ${context}
  user:
    auth-provider:
      config:
        cmd-args: config config-helper --format=json
        cmd-path: gcloud
        expiry-key: '{.credential.token_expiry}'
        token-key: '{.credential.access_token}'
      name: gcp
`;
    });

// Create a Kubernetes provider instance that uses our cluster from above.
const clusterProvider = new k8s.Provider("gkeK8s", {
    kubeconfig: kubeconfig,
});

// Deploy the helm chart for Jira Service Desk Operator into the cluster
const jiraServiceDeskChart = new k8s.helm.v3.Chart("jira-service-desk-operator", {
    chart: "jira-service-desk-operator", // Replace this with the right chart name if different
    version: "x.y.z", // Replace this with the specific chart version
    fetchOpts:{
        repo: "https://helm-repo-url/", // Specify the URL of the chart repository
    },
}, { provider: clusterProvider });
```

In this program:

- We declare a GKE cluster with a specific node count and machine type. You can adjust these parameters based on your needs.
- We export the cluster name and a generated kubeconfig. This kubeconfig will be used to interact with the cluster via `kubectl` and the Kubernetes API.
- We create a Kubernetes Provider that uses the kubeconfig of the cluster we created.
- We then declare a Helm chart resource. We specify the chart name and version. Ensure that you replace `chart`, `version`, and `repo` with values that correspond to the `jira-service-desk-operator` Helm chart you want to deploy.

Before running this code with Pulumi, make sure you:

1. Install the Pulumi CLI and log in to the Pulumi service.
2. Have the `gcloud` CLI installed and authenticated.
3. Ensure Helm is installed on your system if you plan to use the local Helm CLI for chart repository management.

To apply the Pulumi program:

1. Run `pulumi new typescript` in a new directory to create a new Pulumi TypeScript project.
2. Replace the contents of `index.ts` with the code above.
3. Run `npm install` to fetch the necessary Pulumi libraries.
4. Deploy the program with `pulumi up`.

The `pulumi up` command will provision the required infrastructure on GCP and deploy the Jira Service Desk Operator into your new GKE cluster. You can see the infrastructure created and manage it through the Pulumi CLI.

The Kubernetes resources described by your Helm chart will be managed by Pulumi as part of your infrastructure, which allows you to manage and maintain your cloud resources and Kubernetes deployments in a consistent and declarative manner.