In a command terminal, enter the following command to verify that Maven is using OpenJDK 11 or 17 and that the Maven version is 3.8.4 or later:

mvn --version

If the preceding command does not return OpenJDK 11 or 17, add the path to OpenJDK 11 or 17 to the PATH environment variable and enter the preceding command again.

To use the Quarkus Maven plug-in to create a project, use one of the following methods:

• Enter the following command:

  mvn com.redhat.quarkus.platform:quarkus-maven-plugin:2.7.7.Final-redhat-00005:create \
      -DprojectGroupId=<project_group_id> \
      -DprojectArtifactId=<project_artifact_id> \
      -DplatformGroupId=com.redhat.quarkus.platform \
      -DplatformArtifactId=quarkus-bom \
      -DplatformVersion=2.7.7.Final-redhat-00005

  In this command, replace the following values:

  • <project_group_id>: A unique identifier of your project

  • <project_artifact_id>: The name of your project and your project directory

• Create the project in interactive mode:

  mvn com.redhat.quarkus.platform:quarkus-maven-plugin:2.7.7.Final-redhat-00005:create

  When prompted, enter the required attribute values.

  Alternatively, you can create your project using the default values for the project attributes by entering the following command:

  mvn com.redhat.quarkus.platform:quarkus-maven-plugin:2.7.7.Final-redhat-00005:create -B

• Optionally, use the Quarkus CLI to enter the following command:

  quarkus create app my-groupId:my-artifactId

  • You can also get the list of available options with:

    quarkus create app --help

Open the pom.xml file in a text editor.

Add the configuration properties that contain the following items:

<properties>
    <quarkus.platform.version>2.7.7.Final-redhat-00005</quarkus.platform.version>
    <quarkus.platform.artifact-id>quarkus-bom</quarkus.platform.artifact-id>
    <quarkus.platform.group-id>com.redhat.quarkus.platform</quarkus.platform.group-id>
    <surefire-plugin.version>3.0.0-M5</surefire-plugin.version>
</properties>

Add the Quarkus GAV (group, artifact, version) and use the quarkus-bom file to omit the versions of the different Quarkus dependencies:

<dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>${quarkus.platform.group-id}</groupId>
        <artifactId>${quarkus.platform.artifact-id}</artifactId>
        <version>${quarkus.platform.version}</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
    </dependencies>
  </dependencyManagement>

Add the Quarkus Maven plug-in:

<build>
    <plugins>
        <plugin>
            <groupId>${quarkus.platform.group-id}</groupId>
            <artifactId>quarkus-maven-plugin</artifactId>
            <version>${quarkus.platform.version}</version>
            <executions>
                <execution>
                    <goals>
                        <goal>build</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
        <plugin>
            <artifactId>maven-surefire-plugin</artifactId>
            <version>${surefire-plugin.version}</version>
            <configuration>
                <systemPropertyVariables>
                    <java.util.logging.manager>org.jboss.logmanager.LogManager</java.util.logging.manager>
                    <maven.home>${maven.home}</maven.home>
                </systemPropertyVariables>
            </configuration>
        </plugin>
    </plugins>
</build>

Optional: To build a native application, add a specific native profile that includes the Maven Failsafe Plugin:

<profiles>
    <profile>
        <id>native</id>
        <properties>
            <quarkus.package.type>native</quarkus.package.type>
        </properties>
        <build>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-failsafe-plugin</artifactId>
                    <version>${surefire-plugin.version}</version>
                    <executions>
                        <execution>
                            <goals>
                                <goal>integration-test</goal>
                                <goal>verify</goal>
                            </goals>
                            <configuration>
                                <systemProperties>
                                    <native.image.path>${project.build.directory}/${project.build.finalName}-runner</native.image.path>
                                </systemProperties>
                            </configuration>
                        </execution>
                    </executions>
                </plugin>
            </plugins>
        </build>
    </profile>
</profiles>

• Tests that include IT in their names and contain the @NativeImageTest annotation are run against the native executable.

• For more details about how native mode differs from JVM mode, see Difference between JVM and native mode in the Quarkus Getting Started guide.

On your web browser, navigate to https://code.quarkus.redhat.com.

Specify basic details about your project:

1. Enter a group name for your project. The name format follows the Java package naming convention, for example, org.acme.

2. Enter a name that you want to use for Maven artifacts generated from your project, for example, code-with-quarkus.

3. Select the build tool you want to use to compile and start your application. The build tool that you choose determines the following setups:

   • The directory structure of your generated project

   • The format of configuration files used in your generated project

   • The custom build script and command for compiling and starting your application that code.quarkus.redhat.com displays for you after you generate your project

     Red Hat provides support for using code.quarkus.redhat.com to create Quarkus Maven projects only.

     

Specify additional details about your application project:

1. To display the fields that contain further application details, select More options.

2. Enter a version that is used in artifacts generated from your project. The default value of this field is 1.0.0-SNAPSHOT. Using semantic versioning is recommended, but you can use a different type of versioning if you prefer.

3. Select whether you want code.quarkus.redhat.com to add starter code to your project. When you add extensions that are marked with CODE to your project from the list of extensions, you can enable this option to automatically create example class files and resource files for those extensions when you generate your project. However, this option does not affect your generated project when you do not add any extensions that provide an example code.

   

   The code.quarkus.redhat.com repository automatically uses the latest release of Red Hat build of Quarkus. You can manually change the BOM version in the pom.xml file after you generate your project.

Select the extensions you want to use. The extensions that you select are included as dependencies of your Quarkus application and the Quarkus platform also ensures that the extensions are compatible in future versions.

The quark icon () next to an extension indicates that the extension is part of the Red Hat build of Quarkus platform release. Red Hat recommends that you use extensions from the same platform, because they are tested and verified together, and are therefore easier to use and upgrade.

You can enable the option to automatically generate starter code for extensions that are marked with STARTER-CODE.

To confirm your choices, select Generate your application. The download link for the archive that contains your generated project displays. The custom command that you can use to compile and start your application also displays.

To save the archive with the generated project files to your machine, select Download the ZIP.

Extract the contents of the archive.

Navigate to the directory that contains your extracted project files:

cd <directory_name>

To compile and start your application in development mode, use one of the following ways:

• Using Maven:

  ./mvnw quarkus:dev

• Using the Quarkus CLI:

  quarkus dev

Navigate to your Quarkus project directory.

List all of the available extensions by using one of the following ways:

• Using Maven:

  ./mvnw quarkus:list-extensions

• Using the Quarkus CLI:

  quarkus extension --installable

Add an extension to your project by using one of the following ways:

• Using Maven, enter the following command where <extension> is the group, artifact, version (GAV) of the extension that you want to add:

  ./mvnw quarkus:add-extension -Dextensions="<extension>"

  For example, to add the Agroal extension, enter the following command:

  ./mvnw quarkus:add-extension -Dextensions="io.quarkus:quarkus-agroal"

• Using the Quarkus CLI, enter the following command where <extension> is the group, artifact, version (GAV) of the extension that you want to add:

  quarkus extension add "<extension>"

To search for a specific extension, enter the extension name or partial name after -Dextensions=. The following example searches for extensions that contain the text jdbc, agroal, and non-exist-ent in the name:

./mvnw quarkus:add-extension -Dextensions=jdbc,agroal,non-exist-ent

This command returns the following result:

❌ Multiple extensions matching 'jdbc'
    * io.quarkus:quarkus-jdbc-h2
    * io.quarkus:quarkus-jdbc-mariadb
    * io.quarkus:quarkus-jdbc-postgresql
    Be more specific, for example, by using the exact name or the full GAV.
✅ Adding extension io.quarkus:quarkus-agroal
❌ Cannot find a dependency matching 'non-exist-ent', maybe a typo?
[...]

In CodeReady Studio or Eclipse, click File → Import.

Select Maven → Existing Maven Project.

On the next screen, select the root location of the project. A list of the available modules appears.

Select the generated project and click Finish.

To compile and start your application, use one of the following ways:

• Using Maven:

  ./mvnw quarkus:dev

• Using the Quarkus CLI:

  quarkus dev

In IntelliJ, complete one of the following tasks:

• Select File → New → Project From Existing Sources.

• On the Welcome page, select Import project.

Select the project root directory.

Select Import project from external model, and then select Maven.

Review the options, and then click Next.

Click Finish.

To compile and start your application, use one of the following ways:

• Using Maven:

  ./mvnw quarkus:dev

• Using the Quarkus CLI:

  quarkus dev

Select File → Open Project.

Select the project root directory.

Click Open Project.

To compile and start your application, use one of the following ways:

• Using Maven:

  ./mvnw quarkus:dev

• Using the Quarkus CLI:

  quarkus dev

Install the Java Extension Pack.

In Visual Studio Code, open your project directory.

Open the application.properties file in a text editor.

TIP: You can find the application.properties file in the {project}/src/main/resources folder.

Edit the values of properties that you want to change and save the file.

The following table list the properties that you can change:

Open the pom.xml file and verify that the native profile has the following elements:

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-failsafe-plugin</artifactId>
    <version>${surefire-plugin.version}</version>
    <executions>
        <execution>
            <goals>
                <goal>integration-test</goal>
                <goal>verify</goal>
            </goals>
            <configuration>
                <systemPropertyVariables>
                    <native.image.path>${project.build.directory}/${project.build.finalName}-runner</native.image.path>
                    <java.util.logging.manager>org.jboss.logmanager.LogManager</java.util.logging.manager>
                    <maven.home>${maven.home}</maven.home>
                </systemPropertyVariables>
            </configuration>
        </execution>
    </executions>
</plugin>

The Maven Failsafe plug-in (maven-failsafe-plugin) runs the integration test and also indicates the location of the native executable that is generated.

Open the src/test/java/org/acme/quickstart/NativeGreetingResourceIT.java file and verify that it includes the following content:

package org.acme.quickstart;


import io.quarkus.test.junit.NativeImageTest;

@NativeImageTest 1
public class NativeGreetingResourceIT extends GreetingResourceTest { 2

    // Run the same tests

}

Run the test:

./mvnw verify -Pnative

The following example shows the output of this command:

./mvnw verify -Pnative
...
[getting-started-1.0-SNAPSHOT-runner:18820]     universe:     587.26 ms
[getting-started-1.0-SNAPSHOT-runner:18820]      (parse):   2,247.59 ms
[getting-started-1.0-SNAPSHOT-runner:18820]     (inline):   1,985.70 ms
[getting-started-1.0-SNAPSHOT-runner:18820]    (compile):  14,922.77 ms
[getting-started-1.0-SNAPSHOT-runner:18820]      compile:  20,361.28 ms
[getting-started-1.0-SNAPSHOT-runner:18820]        image:   2,228.30 ms
[getting-started-1.0-SNAPSHOT-runner:18820]        write:     364.35 ms
[getting-started-1.0-SNAPSHOT-runner:18820]      [total]:  52,777.76 ms
[INFO]
[INFO] --- maven-failsafe-plugin:2.22.1:integration-test (default) @ getting-started ---
[INFO]
[INFO] -------------------------------------------------------
[INFO]  T E S T S
[INFO] -------------------------------------------------------
[INFO] Running org.acme.quickstart.NativeGreetingResourceIT
Executing [/data/home/gsmet/git/quarkus-quickstarts/getting-started/target/getting-started-1.0-SNAPSHOT-runner, -Dquarkus.http.port=8081, -Dtest.url=http://localhost:8081, -Dquarkus.log.file.path=build/quarkus.log]
2019-04-15 11:33:20,348 INFO  [io.quarkus] (main) Quarkus 999-SNAPSHOT started in 0.002s. Listening on: http://[::]:8081
2019-04-15 11:33:20,348 INFO  [io.quarkus] (main) Installed features: [cdi, resteasy]
[INFO] Tests run: 2, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 1.387 s - in org.acme.quickstart.NativeGreetingResourceIT
...

./mvnw verify -Pnative -Dquarkus.test.wait-time=<duration>

Switch to the directory that contains your Quarkus application pom.xml file.

To compile and start your Quarkus application in development mode, use one of the following methods:

• Using Maven:

  ./mvnw quarkus:dev

• Using the Quarkus CLI:

  quarkus dev

Make changes to your application and save the files.

Refresh the browser to trigger a scan of the workspace.

If any changes are detected, the Java files are recompiled and the application is redeployed. Your request is then serviced by the redeployed application. If there are any issues with compilation or deployment, an error page appears.

In development mode, the debugger is activated and listens on port 5005.

Optional: To wait for the debugger to attach before running the application, include -Dsuspend:

./mvnw quarkus:dev -Dsuspend

Optional: To prevent the debugger from running, include -Ddebug=false:

./mvnw quarkus:dev -Ddebug=false

Change one of the following values of the debug system property where PORT is the port that the debugger is listening on:

• false: The JVM starts with debug mode disabled.

• true: The JVM starts in debug mode and is listening on port 5005.

• client: The JVM starts in client mode and tries to connect to localhost:5005.

• PORT: The JVM starts in debug mode and is listening on PORT.

To suspend the JVM while running in debug mode, set the value of the suspend system property to one of the following values:

• y or true: The debug mode JVM launch suspends.

• n or false: The debug mode JVM starts without suspending.