Red Hat Summit Red Hat SummitSupportConsoleDevelopersStart a trialContact

Chapter 4. Developing and deploying Eclipse Vert.x runtime application

In addition to using an example, you can create a new Eclipse Vert.x application and deploy it to OpenShift or stand-alone Red Hat Enterprise Linux.

4.1. Developing Eclipse Vert.x application
Copy link

For a basic Eclipse Vert.x application, you need to create the following:

  • A Java class containing Eclipse Vert.x methods.
  • A pom.xml file containing information required by Maven to build the application.

The following procedure creates a simple Greeting application that returns "Greetings!" as response.

Note

For building and deploying your applications to OpenShift, Eclipse Vert.x 4.0 only supports builder images based on OpenJDK 8 and OpenJDK 11. Oracle JDK and OpenJDK 9 builder images are not supported.

Prerequisites

  • OpenJDK 8 or OpenJDK 11 installed.
  • Maven installed.

Procedure

  1. Create a new directory myApp, and navigate to it. 

    $ mkdir myApp
$ cd myApp
    Copy to Clipboard Toggle word wrap

    This is the root directory for the application.

  2. Create directory structure src/main/java/com/example/ in the root directory, and navigate to it. 

    $ mkdir -p src/main/java/com/example/
$ cd src/main/java/com/example/
    Copy to Clipboard Toggle word wrap

  3. Create a Java class file MyApp.java containing the application code. 

    package com.example;

import io.vertx.core.AbstractVerticle;
import io.vertx.core.Promise;

public class MyApp extends AbstractVerticle {

    @Override
    public void start(Promise<Void> promise) {
        vertx
            .createHttpServer()
            .requestHandler(r ->
                r.response().end("Greetings!"))
            .listen(8080, result -> {
                if (result.succeeded()) {
                    promise.complete();
                } else {
                    promise.fail(result.cause());
                }
            });
    }
}
    Copy to Clipboard Toggle word wrap

  4. Create a pom.xml file in the application root directory myApp with the following content: 

    <?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.example</groupId>
  <artifactId>my-app</artifactId>
  <version>1.0.0-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>My Application</name>
  <description>Example application using Vert.x</description>

  <properties>
    <vertx.version>4.0.3.redhat-00002</vertx.version>
    <vertx-maven-plugin.version>1.0.24</vertx-maven-plugin.version>
    <vertx.verticle>com.example.MyApp</vertx.verticle>

    <!-- Specify the JDK builder image used to build your application. -->
    <jkube.generator.from>registry.access.redhat.com/ubi8/openjdk-11</jkube.generator.from>

    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
  </properties>

  <!-- Import dependencies from the Vert.x BOM. -->
  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>io.vertx</groupId>
        <artifactId>vertx-dependencies</artifactId>
        <version>${vertx.version}</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
    </dependencies>
  </dependencyManagement>

  <!-- Specify the Vert.x artifacts that your application depends on. -->
  <dependencies>
    <dependency>
      <groupId>io.vertx</groupId>
      <artifactId>vertx-core</artifactId>
    </dependency>
    <dependency>
      <groupId>io.vertx</groupId>
      <artifactId>vertx-web</artifactId>
    </dependency>
  </dependencies>

  <!-- Specify the repositories containing Vert.x artifacts. -->
  <repositories>
    <repository>
      <id>redhat-ga</id>
      <name>Red Hat GA Repository</name>
      <url>https://maven.repository.redhat.com/ga/</url>
    </repository>
  </repositories>

  <!-- Specify the repositories containing the plugins used to execute the build of your application. -->
  <pluginRepositories>
    <pluginRepository>
      <id>redhat-ga</id>
      <name>Red Hat GA Repository</name>
      <url>https://maven.repository.redhat.com/ga/</url>
    </pluginRepository>
  </pluginRepositories>

  <!-- Configure your application to be packaged using the Vert.x Maven Plugin. -->
  <build>
    <plugins>
      <plugin>
        <groupId>io.reactiverse</groupId>
        <artifactId>vertx-maven-plugin</artifactId>
        <version>${vertx-maven-plugin.version}</version>
        <executions>
          <execution>
            <id>vmp</id>
            <goals>
              <goal>initialize</goal>
              <goal>package</goal>
            </goals>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>
</project>
    Copy to Clipboard Toggle word wrap

  5. Build the application using Maven from the root directory of the application. 

    $ mvn vertx:run
    Copy to Clipboard Toggle word wrap

  6. Verify that the application is running.

    Using curl or your browser, verify your application is running at http://localhost:8080. 

    $ curl http://localhost:8080
Greetings!
    Copy to Clipboard Toggle word wrap

Additional information

  • As a recommended practice, you can configure liveness and readiness probes to enable health monitoring for your application when running on OpenShift. To learn how application health monitoring on OpenShift works, try the Health Check example.

To deploy your Eclipse Vert.x application to OpenShift, configure the pom.xml file in your application and then use the OpenShift Maven plugin.

Note

The Fabric8 Maven plugin is no longer supported. Use the OpenShift Maven plugin to deploy your Eclipse Vert.x applications on OpenShift. For more information, see the section migrating from Fabric8 Maven Plugin to Eclipse JKube.

You can specify a Java image by replacing the jkube.generator.from URL in the pom.xml file. The images are available in the Red Hat Ecosystem Catalog. 

<jkube.generator.from>IMAGE_NAME</jkube.generator.from>
Copy to Clipboard Toggle word wrap

For example, the Java image for RHEL 7 with OpenJDK 8 is specified as: 

<jkube.generator.from>registry.access.redhat.com/redhat-openjdk-18/openjdk18-openshift:latest</jkube.generator.from>
Copy to Clipboard Toggle word wrap

4.2.1. Supported Java images for Eclipse Vert.x
Copy link

Eclipse Vert.x is certified and tested with various Java images that are available for different operating systems. For example, Java images are available for RHEL 7 with OpenJDK 8 or OpenJDK 11.

Eclipse Vert.x introduces support for building and deploying Eclipse Vert.x applications to OpenShift with OCI-compliant Universal Base Images for Red Hat OpenJDK 8 and Red Hat OpenJDK 11 on RHEL 8.

Similar images are available on IBM Z and IBM Power Systems.

You require Docker or podman authentication to access the RHEL 8 images in the Red Hat Ecosystem Catalog.

The following table lists the images supported by Eclipse Vert.x for different architectures. It also provides links to the images available in the Red Hat Ecosystem Catalog. The image pages contain authentication procedures required to access the RHEL 8 images.

4.2.1.1. Images on x86_64 architecture
Copy link

Expand
OSJavaRed Hat Ecosystem Catalog

RHEL 7

OpenJDK 8

RHEL 7 with OpenJDK 8

RHEL 7

OpenJDK 11

RHEL 7 with OpenJDK 11

RHEL 8

OpenJDK 8

RHEL 8 Universal Base Image with OpenJDK 8

RHEL 8

OpenJDK 11

RHEL 8 Universal Base Image with OpenJDK 11

Note

The use of a RHEL 8-based container on a RHEL 7 host, for example with OpenShift 3 or OpenShift 4, has limited support. For more information, see the Red Hat Enterprise Linux Container Compatibility Matrix.

4.2.1.2. Images on s390x (IBM Z) architecture
Copy link

Expand
OSJavaRed Hat Ecosystem Catalog

RHEL 8

Eclipse OpenJ9 11

RHEL 8 with Eclipse OpenJ9 11

Expand
OSJavaRed Hat Ecosystem Catalog

RHEL 8

Eclipse OpenJ9 11

RHEL 8 with Eclipse OpenJ9 11

Note

The use of a RHEL 8-based container on a RHEL 7 host, for example with OpenShift 3 or OpenShift 4, has limited support. For more information, see the Red Hat Enterprise Linux Container Compatibility Matrix.

For deploying your Eclipse Vert.x application to OpenShift, it must contain:

  • Launcher profile information in the application’s pom.xml file.

In the following procedure, a profile with OpenShift Maven plugin is used for building and deploying the application to OpenShift.

Prerequisites

Procedure

  1. Add the following content to the pom.xml file in the application root directory: 

    <!-- Specify the JDK builder image used to build your application. -->
<properties>
  <jkube.generator.from>registry.access.redhat.com/redhat-openjdk-18/openjdk18-openshift:latest</jkube.generator.from>
</properties>

...

<profiles>
    <profile>
      <id>openshift</id>
      <build>
        <plugins>
          <plugin>
            <groupId>org.eclipse.jkube</groupId>
            <artifactId>openshift-maven-plugin</artifactId>
            <version>1.1.1</version>
            <executions>
              <execution>
                <goals>
                  <goal>resource</goal>
                  <goal>build</goal>
                  <goal>apply</goal
                </goals>
              </execution>
            </executions>
          </plugin>
        </plugins>
      </build>
    </profile>
</profiles>
    Copy to Clipboard Toggle word wrap

  2. Replace the jkube.generator.from property in the pom.xml file to specify the OpenJDK image that you want to use.

    • x86_64 architecture

      • RHEL 7 with OpenJDK 8 

        <jkube.generator.from>registry.access.redhat.com/redhat-openjdk-18/openjdk18-openshift:latest</jkube.generator.from>
        Copy to Clipboard Toggle word wrap

      • RHEL 7 with OpenJDK 11 

        <jkube.generator.from>registry.access.redhat.com/openjdk/openjdk-11-rhel7:latest</jkube.generator.from>
        Copy to Clipboard Toggle word wrap

      • RHEL 8 with OpenJDK 8 

        <jkube.generator.from>registry.access.redhat.com/ubi8/openjdk-8:latest</jkube.generator.from>
        Copy to Clipboard Toggle word wrap

      • RHEL 8 with OpenJDK 11 

        <jkube.generator.from>registry.access.redhat.com/ubi8/openjdk-11:latest</jkube.generator.from>
        Copy to Clipboard Toggle word wrap

    • s390x (IBM Z) architecture

      • RHEL 8 with Eclipse OpenJ9 11 

        <jkube.generator.from>registry.access.redhat.com/openj9/openj9-11-rhel8:latest</jkube.generator.from>
        Copy to Clipboard Toggle word wrap

    • ppc64le (IBM Power Systems) architecture

      • RHEL 8 with Eclipse OpenJ9 11 

        <jkube.generator.from>registry.access.redhat.com/openj9/openj9-11-rhel8:latest</jkube.generator.from>
        Copy to Clipboard Toggle word wrap

To deploy your Eclipse Vert.x application to OpenShift, you must perform the following:

  • Log in to your OpenShift instance.
  • Deploy the application to the OpenShift instance.

Prerequisites

  • oc CLI client installed.
  • Maven installed.

Procedure

  1. Log in to your OpenShift instance with the oc client. 

    $ oc login ...
    Copy to Clipboard Toggle word wrap

  2. Create a new project in the OpenShift instance. 

    $ oc new-project MY_PROJECT_NAME
    Copy to Clipboard Toggle word wrap

  3. Deploy the application to OpenShift using Maven from the application’s root directory. The root directory of an application contains the pom.xml file. 

    $ mvn clean oc:deploy -Popenshift
    Copy to Clipboard Toggle word wrap

    This command uses the OpenShift Maven plugin to launch the S2I process on OpenShift and start the pod.

  4. Verify the deployment.

    1. Check the status of your application and ensure your pod is running. 

      $ oc get pods -w
NAME                             READY     STATUS      RESTARTS   AGE
MY_APP_NAME-1-aaaaa               1/1       Running     0          58s
MY_APP_NAME-s2i-1-build           0/1       Completed   0          2m
      Copy to Clipboard Toggle word wrap

      The MY_APP_NAME-1-aaaaa pod should have a status of Running once it is fully deployed and started.

      Your specific pod name will vary.

    2. Determine the route for the pod.

      Example Route Information

      $ oc get routes
NAME                 HOST/PORT                                                     PATH      SERVICES        PORT      TERMINATION
MY_APP_NAME         MY_APP_NAME-MY_PROJECT_NAME.OPENSHIFT_HOSTNAME      MY_APP_NAME      8080
      Copy to Clipboard Toggle word wrap

      The route information of a pod gives you the base URL which you use to access it.

      In this example, http://MY_APP_NAME-MY_PROJECT_NAME.OPENSHIFT_HOSTNAME is the base URL to access the application.

    3. Verify that your application is running in OpenShift. 

      $ curl http://MY_APP_NAME-MY_PROJECT_NAME.OPENSHIFT_HOSTNAME
Greetings!
      Copy to Clipboard Toggle word wrap

To deploy your Eclipse Vert.x application to stand-alone Red Hat Enterprise Linux, configure the pom.xml file in the application, package it using Maven and deploy using the java -jar command.

Prerequisites

  • RHEL 7 or RHEL 8 installed.

For deploying your Eclipse Vert.x application to stand-alone Red Hat Enterprise Linux, you must first package the application using Maven.

Prerequisites

  • Maven installed.

Procedure

  1. Add the following content to the pom.xml file in the application’s root directory: 

      ...
  <build>
    <plugins>
      <plugin>
        <groupId>io.reactiverse</groupId>
        <artifactId>vertx-maven-plugin</artifactId>
        <version>1.0.24</version>
        <executions>
          <execution>
            <id>vmp</id>
            <goals>
              <goal>initialize</goal>
              <goal>package</goal>
            </goals>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>
  ...
    Copy to Clipboard Toggle word wrap

  2. Package your application using Maven. 

    $ mvn clean package
    Copy to Clipboard Toggle word wrap

    The resulting JAR file is in the target directory.

To deploy your Eclipse Vert.x application to stand-alone Red Hat Enterprise Linux, use java -jar command.

Prerequisites

  • RHEL 7 or RHEL 8 installed.
  • OpenJDK 8 or OpenJDK 11 installed.
  • A JAR file with the application.

Procedure

  1. Deploy the JAR file with the application. 

    $ java -jar my-app-fat.jar
    Copy to Clipboard Toggle word wrap

  2. Verify the deployment.

    Use curl or your browser to verify your application is running at http://localhost:8080: 

    $ curl http://localhost:8080
    Copy to Clipboard Toggle word wrap
Back to top
Red Hat logoGithubredditYoutubeTwitter

Learn

Try, buy, & sell

Communities

About Red Hat Documentation

We help Red Hat users innovate and achieve their goals with our products and services with content they can trust. Explore our recent updates.

Making open source more inclusive

Red Hat is committed to replacing problematic language in our code, documentation, and web properties. For more details, see the Red Hat Blog.

About Red Hat

We deliver hardened solutions that make it easier for enterprises to work across platforms and environments, from the core datacenter to the network edge.

Theme

© 2025 Red Hat