Deploying a Java Application to Google Kubernetes Engine in VS Code

This guide shows you how to create a Java application, containerize, and deploy it to Google Kubernetes Engine (GKE) from within VS Code, using the Graal Cloud Native Tools. The Micronaut Kubernetes module provides seamless integration with GKE.

Google Kubernetes Engine (GKE) is managed Kubernetes service with full Kubernetes API, four-way autoscaling, release channels, and multi-cluster support.

Prerequisites #

JDK 17 or higher. See Setting up Your Desktop.
A Google Cloud Platform (GCP) account. Create an account at cloud.google.com/gcp.
The Google Cloud CLI. (The CLI is part of the Google Cloud SDK; for more information, see Cloud SDK.)
A Docker-API compatible container runtime such as Rancher Desktop or Docker.
kubectl to deploy the application to GKE.

Note: This guide uses paid services; you may need to enable billing in Google Cloud to complete some steps in this guide.

1. Install Extensions #

Follow this guide to install the Graal Cloud Native (GCN) Tools and its dependencies in VS Code.

2. Create a Java Application Using GCN Tools #

Create a Java application to containerize and deploy to Google Kubernetes Engine (GKE) using GCN Tools.

Go to View, Command Palette, search for “gcn”, and invoke the OCI for GCN: Create GCN Project quick action:
Follow the command prompts to generate a new Maven or Gradle project. For example, to create a simple Java application:
- Pick Micronaut version: Default
- Pick application type: Application
- Pick project Java: GraalVM or Other Java
- Provide a project name: gcp-k8s-demo
- Provide base package: com.example
- Pick project services: none. Click OK to confirm
- Pick build tool: Gradle (Groovy)
- Pick test framework: JUnit
- Pick cloud platform: GCP. Click OK to confirm
Select the destination directory on your local disk and whether to open the project in a new window or add it to the current workspace. The wizard creates a directory named gcp-k8s-demo containing an application in a package named com.example.

(Required only for macOS AArch64) At the beginning of the configuration file, gcp/build.gradle, add the following dependency to use the appropriate version of JNA:

 buildscript {
     dependencies {
         classpath("com.github.docker-java:docker-java-transport-httpclient5:3.2.13") {
             because("macOS AArch64 needs a specific version of JNA")
         }
     }
 }

(Required only for macOS AArch64) At the end of the configuration file, gcp/build.gradle, add the following code so that Gradle builds a container image using the openjdk:17-slim base image (it defaults to openjdk:17-alpine which is not multiplatform).
```
 tasks.withType(com.bmuschko.gradle.docker.tasks.image.Dockerfile) {
     baseImage = 'openjdk:17-slim'
 }
```
Open a new Terminal window in VS Code (Terminal > New Terminal). Use the following command to build and run the application JAR file:
```
 ./gradlew :gcp:run
```

3. Build a Container Image and Create a Container Repository #

Build a container image for your Java application:
```
 ./gradlew dockerBuild
```
Use the docker images command to ensure that the container image is created. The gcn-to-gke-gcp container image is the one you will deploy to GKE.
```
 docker images
```

Create a container repository in the Google Cloud Artifact Registry using the Google Cloud CLI:

 gcloud artifacts repositories create <repoName> --repository-format=docker --location=<regionName> --description=<shortDescription>

Tag your container image:

 docker tag <dockerImageName/ID> <regionName>-docker.pkg.dev/<PROJECT_ID>/<repoName>/<appName>:<tagName>

Add the IAM policy binding using the Google Cloud CLI:

 gcloud artifacts repositories add-iam-policy-binding 
 <repoName> --location=<regionName>
 --member=serviceAccount:<PROJECT_NUMBER><-compute@developer.gserviceaccount.com>  
 --role="roles/artifactregistry.reader"

Run your container image locally, and access it from the browser at localhost:8080:

 docker run --rm -p 8080:8080 <regionName>-docker.pkg.dev/<PROJECT_ID>/<repositoryName/ID>/<appName>:<tagName>

Access a Running App from Browser

4. Push a Container Image #

Authenticate to the Google Cloud Artifact Registry using the Google Cloud CLI:
```
 gcloud auth configure-docker <regionName>-docker.pkg.dev
```
Push your container image to the container repository you created earlier in the Google Cloud Artifact Registry:
```
 docker push <regionName>-docker.pkg.dev/<PROJECT_ID>/<repositoryName/ID>/<appName>:<tagName>
```

Your container image is now stored in Google Cloud Artifact Registry, and you can deploy it to the Google Kubernetes Engine (GKE) cluster.

5. Deploy a Java Application to GKE Cluster #

Create a Kubernetes cluster that will manage your nodes/pods using the Google Cloud CLI:

 gcloud config set compute/region <regionName>

 gcloud container clusters create-auto <clusterName> --region=<regionName>

If you are asked to install the gcp-auth plugin, follow these instructions gke-gcloud-auth-plugin. This plugin automatically and dynamically configures pods to use your credentials, allowing the applications to access Google Cloud services as if they were running within Google Cloud.

Check if you are connected to a GKE cluster:

 gcloud container clusters get-credentials <ClusterName> --region <regionName>

Create a Kubernetes deployment:

 kubectl create deployment <deploymentName> --image=<regionName>-docker.pkg.dev/<PROJECT_ID>/<repoName>/<appName>:<tag>

Create a Kubernetes Deployment

Set baseline number of deployment replicas to 3:

 kubectl scale deployment <deploymentName> --replicas=3

Then create a Horizontal Pod Autoscaler resource for your deployment:

kubectl autoscale deployment <deploymentName> --cpu-percent=80 --min=1 --max=5

Run the next command to check the status of the pods:
```
 kubectl get pods
```

Expose the port so your application will be accessible from your cluster:

 kubectl expose deployment <deploymentName> --name=<serviceName> --type=LoadBalancer --port 80 --target-port 8080

Expose Port

List the services:
```
 kubectl get services
```
Copy the external IP and open it in a browser:

Summary #

This guide demonstrated how to easily containerize and deploy a Java microservice application to Google Kubernetes Engine from within VS Code, using the Graal Cloud Native tooling.