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

Question

Pulumi · Accepted Answer

To deploy a Spring Boot application via a Helm chart on Google Kubernetes Engine (GKE), you’ll typically proceed with the following steps:

1. **Set up a GKE Cluster**: Begin by creating a managed Kubernetes cluster within GKE. Google Cloud manages the Kubernetes master node for you, taking care of provisioning, upgrading, and securing your cluster's control plane.

2. **Install and Configure Helm**: Helm is a package manager for Kubernetes. With Helm, you package your Kubernetes resources into a chart, which is a collection of files that describe a related set of Kubernetes resources. Helm also manages the deployment of these charts onto Kubernetes.

3. **Deploy Your Helm Chart**: With the cluster set up and Helm installed, you can now deploy your Spring Boot application by installing the Helm chart into the cluster.

Below is a Pulumi TypeScript program that accomplishes these steps:

- It creates a GKE cluster using the `@pulumi/google-native` provider.
- It installs a Helm chart representing the Spring Boot application using the `@pulumi/kubernetes` provider.
  
```typescript
import * as gcp from '@pulumi/gcp';
import * as k8s from '@pulumi/kubernetes';

// Create a GKE cluster
const cluster = new gcp.container.Cluster("gke-cluster", {
    initialNodeCount: 2,
    minMasterVersion: "latest",
    nodeVersion: "latest",
    nodeConfig: {
        preemptible: true,
        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 Cluster name
export const clusterName = cluster.name;

// Export the Kubernetes config
export const kubeconfig = cluster.name.apply(name => {
    return gcp.container.getCluster({
        name: name,
        location: cluster.location,
    }).then(cluster => {
        const context = `${gcp.config.project}_${cluster.location}_${cluster.name}`;
        return `apiVersion: v1
clusters:
- cluster:
    certificate-authority-data: ${cluster.masterAuth.clusterCaCertificate}
    server: https://${cluster.endpoint}
  name: ${context}
contexts:
- context:
    cluster: ${context}
    user: ${context}
  name: ${context}
current-context: ${context}
kind: Config
preferences: {}
users:
- name: ${context}
  user:
    auth-provider:
      config:
        access-token: ${gcp.config.accessToken}
        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("gke-k8s", {
    kubeconfig: kubeconfig
});

// Deploy the Spring Boot Helm chart using the Kubernetes provider.
const springBootRelease = new k8s.helm.v3.Chart("springboot-chart", {
    chart: "spring-boot",
    // This assumes you have a Helm chart for Spring Boot in a repository accessible by Helm.
    // Replace "repoUrl" with the actual repository URL.
    repositoryOpts: {
        repo: "repoUrl"
    },
    // Specify the values for your Spring Boot chart.
    values: {
        service: {
            type: "LoadBalancer"
        }
    },
}, { provider: clusterProvider });

// Export the Spring Boot service IP
export const springBootIp = springBootRelease.getResourceProperty("v1/Service", "springboot-service", "status")
    .apply(status => status.loadBalancer.ingress[0].ip);
```

Here's a breakdown of the Pulumi program:

- Firstly, we establish communication with the GKE API and create a cluster with two initial nodes. We ensure the nodes are pre-emptible to reduce costs and specify the OAuth scopes the node will have, which should have the minimum required permissions for functioning correctly.
- Once the cluster is provisioned, we generate the kubeconfig file necessary to interact with the cluster via `kubectl`. We're extracting that information from the output of our cluster creation, and we construct a kubeconfig string in the required format.
- We then initialize a Pulumi Kubernetes provider using the kubeconfig of the newly created GKE cluster.
- Next, we use the Kubernetes provider to deploy the Helm chart for the Spring Boot application. We specify the chart name, the repository where the Helm chart is located, and some example values that might be needed for the chart deployment (like specifying that the service type should be `LoadBalancer`).
- Finally, we export the IP address of the LoadBalancer service associated with our Spring Boot application. This IP address will be the entry point to access our Spring Boot application.

This Pulumi program should be placed in a directory with a `Pulumi.yaml` manifest that specifies the project's name and runtime (TypeScript in this case). Once you run `pulumi up` with this code and the Pulumi CLI installed, Pulumi will create the resources in Google Cloud and print out the LoadBalancer IP address once the deployment is complete.

Remember to replace `"repoUrl"` with the actual URL of the Helm chart repository that hosts the Spring Boot Helm chart and provide any other necessary chart values specific to your Spring Boot application.