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 multicluster support.

Prerequisites #

A Google Cloud Platform (GCP) account. Create an account at cloud.google.com/gcp.
The Google Cloud CLI to interact with Google Cloud services from the terminal. (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.

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 that you will containerize and deploy to Google Cloud Run. You can use the GCN Launcher, or the built-in GCN project creation wizard in VS Code.

Go to View, Command Palette, search for “gcn”, and invoke the 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) or Maven
- 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.) Add the following GCP module configuration:

Gradle
Maven

build.gradle

tasks.named("dockerfile") {
         args("-Xmx128m")
         instruction """FROM --platform=linux/amd64 eclipse-temurin:17-jre-focal
             WORKDIR /home/app
             COPY layers/libs /home/app/libs
             COPY layers/classes /home/app/classes
             COPY layers/resources /home/app/resources
             COPY layers/application.jar /home/app/application.jar
         """
     }

pom.xml

<from>
         <image>openjdk:17-oracle</image>
         <platforms>
             <platform>
                 <architecture>amd64</architecture>
                 <os>linux</os>
             </platform>
         </platforms>
     </from>

This configuration that Gradle/Maven tools build a container image using the openjdk:17-slim base image (it defaults to openjdk:17-alpine which is not multiplatform).

Open a new Terminal window in VS Code (Terminal > New Terminal). Build the project and run the application from a 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 a GKE Cluster #

Set your compute region in Google Cloud CLI with:
```
 gcloud config set compute/region <REGION>`
```
Create an auto-scaling Kubernetes cluster that will manage your nodes/pods using the Google Cloud CLI:
```
 gcloud container clusters create-auto <clusterName> --region=<regionName>
```
Follow any additional instructions if prompted. For example, you might be 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.

Establish a connection to your GKE cluste:

 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 a baseline number of deployment replicas to 3 for autoscaling:
```
 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 list the created 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.