Red Hat Summit Red Hat SummitSupportConsoleDéveloppeursCommencer un essaiContact

Ce contenu n'est pas disponible dans la langue sélectionnée.

Chapter 3. Developing and deploying Thorntail application

In addition to using an example, you can create new Thorntail applications from scratch and deploy them to OpenShift.

3.1. Creating an application from scratch
Copier lien

Creating a simple Thorntail–based application with a REST endpoint from scratch.

Prerequisites

  • OpenJDK 8 or OpenJDK 11 installed
  • Maven 3.5.0 installed

Procedure

  1. Create a directory for the application and navigate to it: 

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

    We recommend you start tracking the directory contents with Git. For more information, see Git tutorial.

  2. In the directory, create a pom.xml file 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/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.example</groupId>
  <artifactId>restful-endpoint</artifactId>
  <version>1.0.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>Thorntail Example</name>

  <properties>
    <version.thorntail>{version}</version.thorntail>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
    <failOnMissingWebXml>false</failOnMissingWebXml>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

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

  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>io.thorntail</groupId>
        <artifactId>bom</artifactId>
        <version>${version.thorntail}</version>
        <scope>import</scope>
        <type>pom</type>
      </dependency>
    </dependencies>
  </dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>io.thorntail</groupId>
      <artifactId>jaxrs</artifactId>
    </dependency>
  </dependencies>

  <build>
    <finalName>restful-endpoint</finalName>
    <plugins>
      <plugin>
        <groupId>io.thorntail</groupId>
        <artifactId>thorntail-maven-plugin</artifactId>
        <version>${version.thorntail}</version>
        <executions>
          <execution>
            <goals>
              <goal>package</goal>
            </goals>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>

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

  <pluginRepositories>
    <pluginRepository>
      <id>redhat-ga</id>
      <name>Red Hat GA Repository</name>
      <url>https://maven.repository.redhat.com/ga/</url>
    </pluginRepository>
  </pluginRepositories>

</project>
    Copy to Clipboard Toggle word wrap

  3. Create a directory structure for your application: 

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

  4. In the src/main/java/com/example/rest directory, create the source files:

    • HelloWorldEndpoint.java with the class that serves the HTTP endpoint: 

      package com.example.rest;

import javax.ws.rs.Path;
import javax.ws.rs.core.Response;
import javax.ws.rs.GET;
import javax.ws.rs.Produces;

@Path("/hello")
public class HelloWorldEndpoint {

  @GET
  @Produces("text/plain")
  public Response doGet() {
    return Response.ok("Hello from Thorntail!").build();
  }
}
      Copy to Clipboard Toggle word wrap

    • RestApplication.java with the application context: 

      package com.example.rest;

import javax.ws.rs.core.Application;
import javax.ws.rs.ApplicationPath;

@ApplicationPath("/rest")
public class RestApplication extends Application {
}
      Copy to Clipboard Toggle word wrap

  5. Execute the application using Maven: 

    $ mvn thorntail:run
    Copy to Clipboard Toggle word wrap

Results

Accessing the http://localhost:8080/rest/hello URL in your browser should return the following message: 

Hello from Thorntail!
Copy to Clipboard Toggle word wrap

After finishing the procedure, there should be a directory on your hard drive with the following contents: 

myApp
├── pom.xml
└── src
    └── main
        └── java
            └── com
                └── example
                    └── rest
                        ├── HelloWorldEndpoint.java
                        └── RestApplication.java
Copy to Clipboard Toggle word wrap

3.2. Deploying Thorntail application to OpenShift
Copier lien

To deploy your Thorntail application to OpenShift, configure the pom.xml file in your application and then use the Fabric8 Maven plugin. You can specify a Java image by replacing the fabric8.generator.from URL in the pom.xml file.

The images are available in the Red Hat Ecosystem Catalog. 

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

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

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

3.2.1. Supported Java images for Thorntail
Copier lien

Thorntail is certified and tested with various Java images that are available for different operating systems. For example, Java images are available for RHEL 7 and RHEL 8 with OpenJDK 8 or OpenJDK 11. Similar images are available on IBM Z.

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 Thorntail 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.

3.2.1.1. Images on x86_64 architecture
Copier lien

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 with OpenJDK 8

RHEL 8

OpenJDK 11

RHEL 8 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.

3.2.1.2. Images on s390x (IBM Z) architecture
Copier lien

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 Thorntail application to OpenShift, it must contain:

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

In the following procedure, a profile with Fabric8 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: 

    ...

<profiles>
    <profile>
      <id>openshift</id>
      <build>
        <plugins>
          <plugin>
            <groupId>io.fabric8</groupId>
            <artifactId>fabric8-maven-plugin</artifactId>
            <version>4.3.0</version>
            <executions>
              <execution>
                <goals>
                  <goal>resource</goal>
                  <goal>build</goal>
                </goals>
              </execution>
            </executions>
          </plugin>
        </plugins>
      </build>
    </profile>
  </profiles>
    Copy to Clipboard Toggle word wrap

  2. Replace the fabric8.generator.from property in the pom.xml file to specify relevant Java image based on your architecture.

    • x86_64 architecture

      • RHEL 7 with OpenJDK 8 

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

      • RHEL 7 with OpenJDK 11 

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

      • RHEL 8 with OpenJDK 8 

        <fabric8.generator.from>registry.redhat.io/openjdk/openjdk-8-rhel8:latest</fabric8.generator.from>
        Copy to Clipboard Toggle word wrap

      • RHEL 8 with OpenJDK 11 

        <fabric8.generator.from>registry.redhat.io/openjdk/openjdk-11-rhel8:latest</fabric8.generator.from>
        Copy to Clipboard Toggle word wrap

    • s390x (IBM Z) architecture

      • RHEL 8 with Eclipse OpenJ9 11 

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

To deploy your Thorntail 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 fabric8:deploy -Popenshift
    Copy to Clipboard Toggle word wrap

    This command uses the Fabric8 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/rest/hello
Hello from Thorntail!
      Copy to Clipboard Toggle word wrap

To deploy your Thorntail 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 Thorntail 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.thorntail</groupId>
        <artifactId>thorntail-maven-plugin</artifactId>
        <version>${version.thorntail}</version>
        <executions>
          <execution>
            <goals>
              <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 Thorntail 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-thorntail.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
Retour au début
Red Hat logoGithubredditYoutubeTwitter

Apprendre

Essayez, achetez et vendez

Communautés

À propos de la documentation Red Hat

Nous aidons les utilisateurs de Red Hat à innover et à atteindre leurs objectifs grâce à nos produits et services avec un contenu auquel ils peuvent faire confiance. Découvrez nos récentes mises à jour.

Rendre l’open source plus inclusif

Red Hat s'engage à remplacer le langage problématique dans notre code, notre documentation et nos propriétés Web. Pour plus de détails, consultez le Blog Red Hat.

À propos de Red Hat

Nous proposons des solutions renforcées qui facilitent le travail des entreprises sur plusieurs plates-formes et environnements, du centre de données central à la périphérie du réseau.

Theme

© 2025 Red Hat