Deploy the jx-app-fossa helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy a Helm chart on Google Kubernetes Engine (GKE), we need to follow these steps:

1. **Set up a GKE cluster**: We’ll use a managed Kubernetes cluster provided by Google Cloud. A GKE cluster will provide the environment where our Helm chart will be deployed.

2. **Install and configure Helm**: Helm is a package manager for Kubernetes that allows you to define, install, and upgrade even the most complex Kubernetes applications.

3. **Deploy the Helm chart**: With our Kubernetes cluster up and running and Helm ready, we can deploy our Helm chart to the cluster.

For this task, we'll use Pulumi with TypeScript to automate the setup and deployment process. Pulumi is an infrastructure as code tool that allows us to define and manage infrastructure using code. In this example, we will use several Pulumi resources:

- `google-native.container/v1beta1.Cluster`: to create a new GKE cluster.
- `kubernetes.helm.sh/v3.Release`: to deploy the Helm chart onto our GKE cluster.

The following program in TypeScript shows how you can accomplish this task using Pulumi:

```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("my-gke-cluster", {
    initialNodeCount: 2,
    nodeVersion: "latest",
    minMasterVersion: "latest",
    location: "us-central1",
    nodeConfig: {
        machineType: "n1-standard-1", // Choose an appropriate machine type as needed
        oauthScopes: [
            "https://www.googleapis.com/auth/cloud-platform",
        ],
    },
});

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

// Export the Kubeconfig to access the Cluster
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: gcloud
`;
    });

// Initialize a Kubernetes provider with the created cluster's kubeconfig
const k8sProvider = new k8s.Provider("gkeK8s", {
    kubeconfig: kubeconfig,
});

// Deploy the Helm chart
const helmRelease = new k8s.helm.v3.Release("jx-app-fossa", {
    chart: "jx-app-fossa",
    // Fetch the Helm chart from a repository. Replace with the repository where jx-app-fossa is stored.
    repositoryOpts: {
        repo: "https://charts.jenkins-x.io",
    },
    version: "1.0.0", // Replace with the specific version you want to deploy
    namespace: "default",
}, { provider: k8sProvider });

// Export the Helm release status
export const helmReleaseStatus = helmRelease.status;
```

Here's a brief explanation of what each part of this code does:

- The `gcp.container.Cluster` constructor creates a new GKE cluster. We specify some properties such as the number of nodes, and machine types.
  
- We then export the `clusterName` and `kubeconfig`, which are needed to interact with your cluster using `kubectl`, Pulumi, or any other tool that communicates with the cluster.

- To communicate with your new cluster, you’ll be using a `k8s.Provider` which needs the generated `kubeconfig`.

- Finally, the `k8s.helm.v3.Release` resource is used to deploy the Helm chart. We specify the chart name, version, and the repository where the chart is located.

To run the Pulumi program, you will need to have Pulumi CLI installed and authenticated with Google Cloud, as well as configured access to the GCP. After that, you can run `pulumi up` to create the cluster and deploy the chart.