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

Question

Pulumi · Accepted Answer

To deploy the `java-app` Helm chart on Google Kubernetes Engine (GKE), you will need to complete several steps:

1. **Create a GKE cluster**: You need a Kubernetes cluster running on GKE where your Helm chart will be deployed.
2. **Install and configure Helm**: Helm is a tool for managing Kubernetes packages called charts. You'll use Helm to deploy your `java-app` chart.
3. **Deploy the Helm chart**: Once Helm is set up, you can deploy your Helm chart to the GKE cluster.

Below is a Pulumi program written in TypeScript that demonstrates how to accomplish these tasks. This program assumes that you have already configured Pulumi with GCP credentials and have set up the necessary prerequisites to use Pulumi with GCP.

First, let's break down the steps of what we're going to do in our Pulumi program:

- We will create a `gcp.container.Cluster` resource to provision a new GKE cluster.
- Next, we will create a `kubernetes.Provider` resource which allows Pulumi to interact with the created GKE cluster.
- Finally, we will deploy the `java-app` Helm chart using the `kubernetes.helm.v3.Chart` resource, leveraging the GKE cluster we provisioned and the kubernetes provider we configured.

### Pulumi Program (TypeScript)

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

// Create a GCP GKE cluster
const cluster = new gcp.container.Cluster("gke-cluster", {
    initialNodeCount: 2,
    nodeVersion: "latest",
    minMasterVersion: "latest",
    nodeConfig: {
        machineType: "n1-standard-1", // Change to desired machine type
        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"
        ],
    },
});

// Create a Kubernetes Provider to interact with the GKE cluster
const k8sProvider = new k8s.Provider("gke-k8s", {
    kubeconfig: cluster.endpoint.apply(endpoint => JSON.stringify({
        "apiVersion": "v1",
        "clusters": [{
            "name": "gke-cluster",
            "cluster": {
                "server": `https://${endpoint}`, // Connection address for the Kubernetes API server
                "certificate-authority-data": cluster.masterAuth[0].clusterCaCertificate, // CA certificate for the cluster
            },
        }],
        "contexts": [{
            "name": "gke-cluster",
            "context": {
                "cluster": "gke-cluster",
                "user": "gke-cluster",
            },
        }],
        "current-context": "gke-cluster",
        "users": [{
            "name": "gke-cluster",
            "user": {
                "auth-provider": {
                    "name": "gcp",
                },
            },
        }],
    })),
});

// Deploy the 'java-app' Helm chart using Helm release resource
const javaAppChart = new k8s.helm.v3.Chart("java-app", {
    chart: "java-app",
    // If required, you may need to specify a repo or a chart version.
    // For example:
    // version: "1.0.0",
    // fetchOpts:{
    //      repo: "http://your-chart-repo/",
    // },
}, { provider: k8sProvider });

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

// Export the public endpoint of the GKE cluster
export const gkeClusterEndpoint = cluster.endpoint;

// Export the name of the Helm release
export const helmReleaseName = javaAppChart.name;
```

Let me explain what each section of this program does:

- In the beginning, we import the required Pulumi packages for GCP (`@pulumi/gcp`) and Kubernetes (`@pulumi/kubernetes`).
- We set up a new GKE cluster using `gcp.container.Cluster`. We specify the initial node count, the version of the nodes and the master, and the node configuration which includes machine type and OAuth scopes. You may need to adjust the `machineType` and `oauthScopes` according to the resources required by your `java-app`.
- Using the generated kubeconfig from GKE, a `kubernetes.Provider` is created. This provider is used to interact with the Kubernetes cluster.
- The `java-app` Helm chart is deployed with `k8s.helm.v3.Chart`. You need to specify the chart name, and optionally, the chart version and repository URL if the chart is not present in the local Helm repository or you want a specific version.
- We export the kubeconfig, GKE cluster endpoint, and the name of the Helm release as stack outputs. These can be used to access the Kubernetes cluster and verify the status of the deployed resources.

Following this program, the `java-app` Helm chart will be deployed onto a newly provisioned GKE cluster. Ensure that the Helm chart name and settings match those of the `java-app` chart you intend to deploy. If the chart you're using is in a custom or private repository, you will also need to specify the `version` and `fetchOpts.repo` options with appropriate values.