Deploy the javawebapp helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy the `javawebapp` Helm chart on Google Kubernetes Engine (GKE), we need to perform a few steps:

1. We will create a GKE cluster using Pulumi with the `google-native.container/v1beta1.Cluster` resource.
2. We will then use the `kubernetes.helm.v3.Chart` resource from Pulumi's Kubernetes provider to deploy the `javawebapp` Helm chart to the GKE cluster.

Before starting, make sure you have [installed Pulumi](https://www.pulumi.com/docs/get-started/install/), set up the [Google Cloud SDK](https://cloud.google.com/sdk), authenticated with the `gcloud` tool, and configured your Pulumi program to use your Google Cloud project and desired region/zone settings.

Below is the TypeScript program that will perform these steps:

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

// Create a GKE cluster.
const cluster = new gcp.container.Cluster("my-gke-cluster", {
    initialNodeCount: 3,
    minMasterVersion: "latest",
    nodeVersion: "latest",
    nodeConfig: {
        machineType: "n1-standard-1",
        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 Kubeconfig so we can 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 k8sProvider = new k8s.Provider("my-k8s-provider", {
    kubeconfig: kubeconfig
});

// Deploy the `javawebapp` Helm chart.
const javaWebAppChart = new k8s.helm.v3.Chart("javawebapp-chart", {
    chart: "javawebapp",
    version: "1.0.0", // Replace with the desired chart version
    fetchOpts: {
        // We need to provide the repo URL containing the chart 
        repo: "http://your-helm-chart-repository/", // Replace with your chart's repository URL
    },
}, { provider: k8sProvider });

// Export the web app's service endpoint
export const javaWebAppService = javaWebAppChart.getResourceProperty("v1/Service", "javawebapp-chart-javawebapp", "status").apply(status => status.loadBalancer.ingress[0].ip);
```

In this program:

- We declare a GKE cluster with three nodes of type `n1-standard-1`.
- We generate a Kubeconfig. This is used by Pulumi to communicate with your GKE cluster through the Kubernetes provider.
- We create an instance of the `k8s.Provider` which encapsulates information about our Kubernetes environment, notably how to access it.
- We deploy the `javawebapp` Helm chart. You should replace `http://your-helm-chart-repository/` with the URL to your Helm chart's repository and set the desired version of the Helm chart in `version`.

Lastly, we export the IP address of the deployed Java web application service. Once the Pulumi program runs successfully, you will see the service's IP address in the outputs. You can use this IP address to navigate to your Java web application in a web browser.

To run the program, save it to a file with a `.ts` extension (like `index.ts`), then execute it using the Pulumi CLI:

```sh
pulumi up
```

This command will provision the resources as defined in your program. It will show you a preview of the changes and prompt you to confirm before making any changes to your infrastructure.