Procedure

1. Add the dev.snowdrop:snowdrop-dependencies artifact to the <dependencyManagement> section of the pom.xml of your project, and specify the values of the <type> and <scope> attributes:

   <project>
     ...
     <dependencyManagement>
       <dependencies>
         <dependency>
           <groupId>dev.snowdrop</groupId>
           <artifactId>snowdrop-dependencies</artifactId>
           <version>2.3.10.Final-redhat-00004</version>
           <type>pom</type>
           <scope>import</scope>
         </dependency>
       </dependencies>
     </dependencyManagement>
     ...
   </project>

2. Include the following properties to track the version of the Spring Boot Maven Plugin that you are using:

   <project>
     ...
     <properties>
       <spring-boot-maven-plugin.version>2.3.10.RELEASE</spring-boot-maven-plugin.version>
     </properties>
     ...
   </project>

3. Specify the names and URLs of repositories containing the BOM and the supported Spring Boot Starters and the Spring Boot Maven plugin:

     <!-- Specify the repositories containing Spring Boot 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>

4. Add spring-boot-maven-plugin as the plugin that Maven uses to package your application.

   <project>
     ...
     <build>
        ...
       <plugins>
           ...
           <plugin>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-maven-plugin</artifactId>
             <version>${spring-boot-maven-plugin.version}</version>
             <executions>
               <execution>
                   <goals>
                       <goal>repackage</goal>
                   </goals>
               </execution>
             </executions>
               <configuration>
                 <redeploy>true</redeploy>
               </configuration>
         </plugin>
         ...
       </plugins>
      ...
     </build>
     ...
   </project>

Procedure

1. Add the dev.snowdrop:snowdrop-dependencies artifact to the <parent> section of the pom.xml:

   <project>
     ...
     <parent>
       <groupId>dev.snowdrop</groupId>
       <artifactId>snowdrop-dependencies</artifactId>
       <version>2.3.10.Final-redhat-00004</version>
     </parent>
     ...
   </project>

2. Add spring-boot-maven-plugin as the plugin that Maven uses to package your application to the <build> section of the pom.xml. The plugin version is automatically managed by the parent BOM.

   <project>
     ...
     <build>
        ...
       <plugins>
           ...
         <plugin>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-maven-plugin</artifactId>
           <executions>
               <execution>
                   <goals>
                       <goal>repackage</goal>
                   </goals>
               </execution>
           </executions>
           <configuration>
               <redeploy>true</redeploy>
           </configuration>
         </plugin>
         ...
       </plugins>
      ...
     </build>
     ...
   </project>

Procedure

1. Add the Dekorate OpenShift Spring Starter to the pom.xml file of your application to enable Dekorate to porcess your application source code and resource files:

   <project>
     ...
     <dependencies>
        ...
       <dependency>
         <!-- The OpenShift Spring Starter automatically imports the "io.dekorate:openshift-annotations" dependency. -->
         <groupId>io.dekorate</groupId>
         <artifactId>openshift-spring-starter</artifactId>
       </dependency>
       ...
     </dependencies>
   ...
   <project>

2. Add the @SpringBootApplication annotation to the main class file of your application project:

   package org.acme;
   
   @SpringBootApplication
   public class Application {
   }

3. Package your application to process you application code and resource files with Dekorate

   mvn clean package

4. Navigate to the target/classes/META-INF/dekorate directory that contains the generated OpenShift manifests.

Procedure

1. Add the Dekorate OpenShift Annotations module as a dependency in the pom.xml file of your application:

   <project>
     ...
     <dependencies>
        ...
       <dependency>
         <groupId>io.dekorate</groupId>
         <artifactId>openshift-spring-starter</artifactId>
       </dependency>
       ...
     </dependencies>
   ...
   <project>

2. Configure the default number of replicas that your application starts with when deployed to OpenShift:

   1. Add the @OpenshiftApplication annotation to the main source file of your application and set number of replicas to 2. When you build and deploy your application, it automatically starts with 2 replicas of the main application container running:

      package org.acme;
      
      import io.dekorate.openshift.annotation.OpenshiftApplication;
      
      // include the parameter for the number of replicas to
      @OpenshiftApplication(replicas=2)
      @SpringBootApplication
      public class Application {
      }

   2. Alternatively, set the dekorate.openshift.replicas=2 property in the application.properties file of your application.

      /src/main/resources/application.properties

      dekorate.openshift.replicas=2

3. Package your application:

   mvn clean package

4. Navigate to the target/classes/META-INF/dekorate view the manifests generated by Dekorate. The number of replicas in the deployment configuration YAML template is set to 2:

   ...
   spec:
     replicas: 2
     selector:
       matchLabels:
         app: acme
   ...

Procedure

1. Add the following dependencies in the pom.xml file of your application:

   <project>
     ...
     <dependencies>
       ...
       <!-- The OpenShift Spring Starter automatically adds "io.dekorate:openshift-annotations" as a transitive dependency -->
       <dependency>
         <groupId>io.dekorate</groupId>
         <artifactId>openshfit-spring-starter</artifactId>
       </dependency>
       ...
     </dependencies>
   ...
   <project>

2. Add Dekorate configuration properties to the application.properties or application.yml file in your project. You do not have to add any Dekorate property annotations to your source files. Note, that you can still use annotations in your source files, but if you do so, Dekorate overwrites parameters provided in annotations with the parameters provided in the application.properties or application.yml files.

3. Package your application:

   mvn clean package

   When you build your application Dekorate parses the configuration in the following resources within your application project. The configuration resources are parsed in an increasing order of priority. This means that if 2 different resources of different type present different values for the same configuration parameter, Dekorate uses the value obtained from a resource that is higher on the list of priorities. For example, if an annotation in your source specifies a parameter value, but a different value is specified for the same parameter in your application.yml, Dekorate uses the value it obtains from application.yml. Dekorate parses your project resources in the following order of priority:

   1. Annotations
   2. application.properties
   3. application.yaml
   4. application.yml
4. Navigate to the target/classes/META-INF/dekorate directory that contains the generated openshift.json and openshift.yml manifest files.

Procedure

1. Add the Dekorate OpenShift Spring Starter as a dependency to the pom.xml file of your application. Note, that this module is included as a transitive dependency in all Dekorate OpenShift Starters:

   <project>
     ...
     <dependencies>
        ...
       <dependency>
         <groupId>io.dekorate</groupId>
         <artifactId>openshift-spring-starter</artifactId>
       </dependency>
       ...
     </dependencies>
   ...
   <project>

2. Build and Deploy your application. Include the -Ddekorate.build=true property to execute the container image build after Maven compiles your application. Note that the functionality that automatically executes the Source-to-image build is provided as Technology Preview.

   $ mvn clean install -Ddekorate.build=true

   You can also execute the Source-to-image build manually from the command line after you compile your application with Maven:

   # Process your application YAML template that is generated by Dekorate:
   $ oc apply -f target/classes/META-INF/dekorate/openshift.yml
   # Execute the Source-to-image build and deploy your application to the OpenShift cluster:
   $ oc start-build example --from-dir=./target --follow

1. You can use the openshift-spring-stater in an application.
2. Dekorate can automaticaly identify the type of the application and configure OpenShift service routes and probes accordingly.
3. You can set up your application to trigger a source-to-image build after Maven compiles your application.

4. Prerequisites

   • A Maven-based application project configured to use Spring Boot and Dekorate
   • The @SpringBootApplication annotation added to the source files in your project
   • Java JDK 8 or JDK 11 installed
   • Maven installed
   • oc command-line tool installed
   • You are logged in to an OpenShift cluster using oc command-line tool

Procedure

1. Add the Dekorate Spring Starter as a dependency in the pom.xml file of your application project.

   pom.xml

   <project>
     ...
     <dependencies>
        ...
       <dependency>
         <groupId>io.dekorate</groupId>
         <artifactId>openshift-spring-starter</artifactId>
       </dependency>
       ...
     </dependencies>
   ...
   <project>

2. Add the @SpringBootApplication annotation to your Main.java class. This enables the source-to-image build to start when the application is compiled:

   /src/main/java/io/dekorate/example/sbonopenshift/Main.java

   package io.dekorate.example.sbonopenshift;
   
   import org.springframework.boot.SpringApplication;
   import org.springframework.boot.autoconfigure.SpringBootApplication;
   
   @SpringBootApplication
   public class Main {
   
     public static void main(String[] args) {
       SpringApplication.run(Main.class, args);
     }
   
   }

3. Add a Rest controller to your application:

   /src/main/java/io/dekorate/example/sbonopenshift/Controller.java

   package io.dekorate.example.sbonopenshift;
   
   import org.springframework.web.bind.annotation.RequestMapping;
   import org.springframework.web.bind.annotation.RestController;
   
   @RestController
   public class Controller {
   
     @RequestMapping("/")
     public String hello() {
       return "Hello world";
     }
   }

   The Spring application processor provided by the the Dekorate Spring starter automatically detects the Rest controller and identifies the application type as a web application. For a web application, Dekorate automatically generate the OpenShift application template and configures:

   • the OpenShift Service route for your application
   • exposes a service on the route of your application
   • configures liveness and readiness probe settings
4. Build and deploy your application. Include the -Ddekorate.deploy=true property to automatically execute the source-to-image build after Maven compiles your application.