Deploying a Java Application to Google Cloud Run in VS Code

This guide shows you how to create a Java application, containerize, and deploy it to Google Cloud Run using the Graal Cloud Native Tools for VS Code.

Google Cloud Run enables you to deploy containerized Java applications on a fully managed platform.

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 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-run-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-run-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 Push to a Container Repository #

Build a container image for your Java application. In your project’s root directory, run:
```
 ./gradlew dockerBuild
```
Use the docker images command to confirm that the container image was successful created. The gcn-to-gke-gcp container image is the one you will deploy to GKE.
```
 docker images
```
Tag your Docker image with Google Cloud’s registry address using the command:
```
 docker tag <docker image ID or name> gcr.io/<PROJECT ID>/<ImageName>
```
Save your credentials securely in the $HOME/.docker/config.json file using the Google Cloud CLI (only required for the first time):
```
 gcloud auth configure-docker
```
Authenticate Docker with the Google Cloud Platform from the terminal:
```
 gcloud auth login
```
It will enable you to push and pull images from Google Cloud.
Push your container image to the Google Cloud Artifact Registry:
```
 docker push gcr.io/<Project ID>/<ImageName>
```
Verify the successful creation of your container image in the Google Cloud Artifact Registry. Login to the console and check the creation of the repository:

4. Deploy to Google Cloud Run #

There are two ways to deploy a containerized application to Google Cloud Run: using the Google Cloud CLI or the Google Cloud console. Both are be described below.

Google Cloud CLI #

Run the following command to deploy your application to Google Cloud Run using the Google Cloud CLI. Specify a name for the service:

gcloud run deploy <service name> --image gcr.io/<ProjectID>/<ImageName>

You will be asked to provide the number of the region. Select “Yes” to allow unauthenticated requests, if necessary. Once completed, the application will be accessible from the Service URL printed to the console:

Service Created to Cloud Run

Google Cloud Console #

Perform the following steps to deploy your application to Google Cloud Run from the console:

Login to the Google Cloud console and open the menu.
Navigate to Cloud Run.
Click Create service.
Check “Deploy one revision from an existing container image”.
Select the Artifact Registry (or Container registry) where your container repository was created.
Select your container image from the repository and confirm the selection.
For authentication, select “Allow unauthenticated invocations.”
Finally, click Create.

Once created, open the Service URL in a browser to check that your application is successfully deployed and running on Google Cloud Platform.

Application Running

Summary #

This guide demonstrated how to easily deploy your container-based workload to Google Cloud Run services using the Graal Cloud Native tooling.