diff --git a/page-data/quickstarts/page-data.json b/page-data/quickstarts/page-data.json
index b1520b7..c6da566 100644
--- a/page-data/quickstarts/page-data.json
+++ b/page-data/quickstarts/page-data.json
@@ -1 +1 @@
-{"componentChunkName":"component---src-pages-quickstarts-index-jsx","path":"/quickstarts/","result":{"data":{"allQuickstart":{"nodes":[{"id":"f0f3fc59-ac46-5830-a5b5-b83e862d40d3","artifactId":"eclipse-jkube-sample-custom-enricher-parent","name":"Kit :: Custom Istio Enricher Parent","description":"Eclipse JKube Kit example to build and use a Custom Enricher in a SpringBoot Application. It will demonstrate how you can extend Eclipse JKube Kit's Enricher API to make your own enricher and use it to enrich or generate manifests as per your requirements.","technologies":[],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/kit/custom-istio-enricher/"},{"id":"520432b9-a1bf-58f3-8339-9823de83727a","artifactId":"docker-image","name":"Kit :: Docker Image","description":"Eclipse JKube Kit example showing how to generate a Docker image by using Eclipse JKube in standalone mode.","technologies":[],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/kit/docker-image/"},{"id":"dc64b9d1-1cee-53ff-8f64-4661d6c05ba5","artifactId":"dynamic-docker-image-file-multi-layer","name":"Kit :: Docker Image from Multilayer Dockerfile","description":"Eclipse JKube Kit example showing how to Dynamically generate a Docker image.\n    The generated image contains multiple COPY statements which allows the generation of a multilayered container image.","technologies":[],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/kit/dynamic-docker-image-file-multi-layer/"},{"id":"0804f96e-3214-5c96-8dd1-8214974f71fa","artifactId":"docker-file-provided","name":"Maven :: Docker File Provided","description":"This quick start showcases how to use Eclipse JKube with external Docker files.\n        There are several profiles highlighting the different configuration modes available.","technologies":["Kubernetes","Spring"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/docker-file-provided/"},{"id":"55060235-c1f0-5465-988f-0f16577b004b","artifactId":"docker-file-simple","name":"Maven :: Dockerfile :: Simple","description":"This quickstart showcases how to use Eclipse JKube with external Docker files without any additional configuration.\n        Docker file mode is automatically selected when a Dockerfile is detected in the project's root directory.","technologies":["Kubernetes","Spring"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/docker-file-simple/"},{"id":"6cc272ac-8e68-5339-abd5-f85c274b6ff6","artifactId":"external-resources","name":"Maven :: External Resources","description":"Simple Spring Boot application which demonstrates how you can use Eclipse JKube's resource fragments.\n    Fragments in `src/main/jkube` directory are detected and picked up by JKube.\n    These fragments are then merged with the JKube generated cluster configuration manifests (YAML).","technologies":["Kubernetes","OpenShift","Spring"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/external-resources/"},{"id":"f990a28d-9017-5c42-b8c4-9ff539bc4ae8","artifactId":"helloworld","name":"Maven :: Hello World","description":"Demo project for getting started with Eclipse JKube.\n    It just prints \"Hello World\" on command line and exits.","technologies":["Kubernetes"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/hello-world/"},{"id":"01d769fd-227e-570f-8207-3e7d376665e7","artifactId":"javaee8-webprofile-liberty","name":"Maven :: JavaEE 8 WebProfile","description":"Demo project for Jakarta EE 8 WebProfile, IBM WebSphere Liberty is used as a Jakarta EE implementation.\n        On Windows or Mac if VirtualBox is used, run the tests using:\n        $ mvn clean verify -DtestProxyHost=192.168.99.100","technologies":["Kubernetes"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/ibm-javaee8-webprofile-liberty/"},{"id":"60181794-b5b0-52b9-803b-ab12cc0ee81b","artifactId":"karaf-camel-log","name":"Maven :: Karaf Camel Log","description":"Simple Apache Camel application on top of Apache Karaf that logs a series of messages to the Server log.\n    The application also generates and processes random orders using Camel routes.","technologies":["Kubernetes","OpenShift","ApacheCamel","ApacheKaraf"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/karaf-camel-log/"},{"id":"a0f117e8-cdcc-5805-838d-19af11c629fb","artifactId":"micronaut","name":"Maven :: Micronaut","description":"Micronaut application featuring REST endpoints (micronaut-http) with validation (micronaut-validation).","technologies":["Kubernetes","OpenShift"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/micronaut/"},{"id":"ff6f0023-3bbe-5ee0-8bba-9396f5bfc90c","artifactId":"micronaut-customized-image","name":"Maven :: Micronaut customized Image","description":"Micronaut application featuring REST endpoints (micronaut-http) with validation (micronaut-validation).\n\n    Includes configuration to enable health check probes (livenessProbe & readinessProbe) using JKube's\n    powerful resource fragments and micronaut-management feature.\n\n    XML based image configuration compatible with OpenShift and Kubernetes.","technologies":["Kubernetes","OpenShift"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/micronaut-customized-image/"},{"id":"d2af8513-0c9b-511d-8734-cf26543e8cf4","artifactId":"openliberty","name":"Maven :: Open Liberty","description":"JAX-RS application deployed with OpenLiberty and Eclipse JKube.\n        The application contains a single endpoint (/hello) that prints 'Hello, World.'.\n        An Arquillian based Integration Test is also included.","technologies":["OpenShift","OpenLiberty"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/openliberty/"},{"id":"fbeb2e9f-89cc-57ff-bac8-3cec8050add4","artifactId":"openliberty-microprofile","name":"Maven :: Open Liberty & MicroProfile","description":"How to integrate Eclipse JKube into an OpenLiberty-MicroProfile project as downloaded from start.microprofile.io.\n    Includes a JAX-RS endpoint, sample CDI injected configuration, and Liveness and Readiness probes.","technologies":["Kubernetes","OpenShift"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/openliberty-microprofile/"},{"id":"78a4f290-7bfb-501b-87b2-06056fe1737c","artifactId":"quarkus","name":"Maven :: Quarkus","description":"Quarkus application with a single JAX-RS endpoint.\n    Demonstrates how to package the project using JVM mode or Native image mode.\n    Demonstrates how to build a Quarkus project container with Eclipse JKube's S2I, Docker and JIB build strategies.","technologies":["Kubernetes","OpenShift","Quarkus"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/quarkus/"},{"id":"8c69d157-2ed8-5d45-92bd-7868217ff5f8","artifactId":"quarkus-customized-image","name":"Maven :: Quarkus customized Image","description":"Quarkus application with a single JAX-RS endpoint.\n    Demonstrates how to build a Quarkus container image based on a Red Hat container image private registry.\n    Uses a pull secret from Red Hat Registry Service Accounts to authenticate.","technologies":["OpenShift","Quarkus"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/quarkus-customized-image/"},{"id":"26ea4bda-5c68-51f8-8265-81b7e04e883f","artifactId":"spring-boot","name":"Maven :: Spring Boot Web","description":"Spring Boot Web application with a single @RestController.\n    Shows how to deploy Spring Boot applications to Kubernetes (-Pkubernetes) and OpenShift (-Popenshift) using Eclipse JKube.","technologies":["Kubernetes","OpenShift","Spring"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot/"},{"id":"d14e03d9-b464-5a7e-98c8-4a6952addc01","artifactId":"spring-boot-camel-complete","name":"Maven :: Spring Boot - Camel","description":"Spring Boot application with Camel Spring Boot integration.\n    Programmatically (RouteBuilder) declares 2 routes to log messages and process orders.\n    Declares an Apache Camel servlet REST endpoint.","technologies":["Kubernetes","OpenShift","ApacheCamel","Spring"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot-camel-complete/"},{"id":"413dce2e-a064-5b79-9369-5722f8a56caa","artifactId":"spring-boot-crd","name":"Maven :: Spring Boot - Custom Resources","description":"Spring Boot application using K8s Custom Resources.\n    Declares a \"Framework\" Custom Resource Definition.\n    Initializes cluster with sample data.\n    Declares an endpoint to consume Custom Resource data stored in the cluster.","technologies":["Kubernetes","OpenShift","Spring"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot-crd/"},{"id":"e9737f7f-a8d0-565b-91e0-963df0f85015","artifactId":"spring-boot-dekorate","name":"Maven :: Spring Boot - Dekorate","description":"Spring Boot application with Dekorate integration.\n    Eclipse JKube uses Dekorate generated cluster configuration manifests.","technologies":["Kubernetes","OpenShift","Spring"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot-dekorate/"},{"id":"b58e5dae-59e1-50fb-8bb5-ef9a0b87a977","artifactId":"spring-boot-helm","name":"Maven :: Spring Boot - Helm","description":"Spring Boot application with a single REST endpoint.\n    Demonstrates how to generate Helm chart (YAML) files using Eclipse JKube's k8s:helm Maven goal.","technologies":["Kubernetes","OpenShift","Spring"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot-helm/"},{"id":"dc5cf0bd-c1a7-540f-aac3-2bb5f5d80f6b","artifactId":"spring-boot-watch","name":"Maven :: Spring Boot Watch","description":"Spring Boot application with a single REST endpoint.\n    Demonstrates how to watch for source changes using Eclipse JKube's k8s:watch goal.\n    Application gets live reloaded in the cluster each time the project is recompiled (mvn package).","technologies":["Kubernetes","Spring"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot-watch/"},{"id":"d6658bfe-e1c0-5e9d-bf68-72899c9bf00b","artifactId":"eclipse-jkube-sample-spring-boot-jib","name":"Maven :: Spring Boot JIB","description":"Spring Boot application with a single REST endpoint.\n        Demonstrates how to build a project using Eclipse JKube JIB build strategy.","technologies":["Kubernetes","Spring"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot-with-jib/"},{"id":"5f84f68f-8cd3-5c66-9b4f-d0b237d4b403","artifactId":"thorntail","name":"Maven :: Thorntail","description":"Java web application with a single JAX-RS endpoint packaged with Thorntail.","technologies":["Kubernetes","OpenShift","Thorntail"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/thorntail/"},{"id":"cb0b8a1e-7023-54d9-a075-b99f36362d71","artifactId":"vertx","name":"Maven :: Vertx Web","description":"Eclipse Vert.x example application declaring a Simple AbstractVerticle.","technologies":["Kubernetes","OpenShift","Vertx"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/vertx/"},{"id":"5192d8ac-da6f-5a42-aff0-ea2f7473fb56","artifactId":"webapp","name":"Maven :: Webapp","description":"Java Web Application with a static index.html resource.\n    Demonstrates how to create a container image with an embedded Apache Tomcat server using Eclipse JKube.","technologies":["Kubernetes","OpenShift"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/webapp/"},{"id":"a8104be8-b753-5914-adf9-b34a70f0d39d","artifactId":"webapp-jetty","name":"Maven :: Webapp Jetty","description":"Java Web Application with a static index.html resource.\n    Demonstrates how to create a container image with an embedded Eclipse Jetty server using Eclipse JKube.\n    Jetty is used instead of Apache Tomcat because there is a Jetty specific configuration file (jetty-logging.properties).\n    Eclipse JKube detects this file and chooses a Jetty specific base container image.","technologies":["Kubernetes","OpenShift"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/webapp-jetty/"},{"id":"08e2ebe5-1f38-5ded-abb4-95bba5f3fd3a","artifactId":"jkube-maven-sample-webapp-wildfly","name":"Maven :: Webapp :: Wildfly","description":"Java Web Application with a static index.html resource.\n    Demonstrates how to create a container image with an embedded WildFly server using Eclipse JKube.\n    WildFly is used instead of Apache Tomcat because there is a WildFly specific plugin configuration.\n    Eclipse JKube detects this plugin and chooses a WildFly specific base container image.","technologies":["Kubernetes","OpenShift"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/webapp-wildfly/"},{"id":"260eef06-4578-55bf-bd76-c3987e8b9fb1","artifactId":"wildfly-jar","name":"Maven :: Wildfly JAR","description":"Java web application with a single JAX-RS endpoint packaged with WildFly Jar Maven Plugin.","technologies":["Kubernetes","OpenShift"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/wildfly-jar/"},{"id":"eea78d7b-2789-5078-b88d-3a90556c08e2","artifactId":"wildfly-jar-slim","name":"Maven :: Wildfly JAR","description":"Java web application with a single JAX-RS endpoint packaged with WildFly Jar Maven Plugin.","technologies":["Kubernetes","OpenShift"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/wildfly-jar-slim/"},{"id":"d8e92d51-4e49-55d6-a753-98a7f9c7b68e","artifactId":"xml-config","name":"Maven :: XML configuration","description":"Apache Camel application.\n    Demonstrates how to configure Eclipse JKube build and resource properties using XML elements in the project's pom.xml plugin configuration.","technologies":["Kubernetes","ApacheCamel"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/xml-config/"},{"id":"b0f9e1cc-7c39-58c3-95ec-2e3614b17c38","artifactId":"yaml","name":"Maven :: Yaml","description":"Example showing how to use Eclipse JKube Maven Plugins to deploy cluster configuration YAML files.\n    Example with Yaml only resources","technologies":["Kubernetes"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/yaml-only/"},{"id":"8083fab0-707d-55a1-8927-f78e6b4e7208","artifactId":"jkube-maven-sample-zero-config","name":"Maven :: Zero-Config","description":"Spring Boot application with a single REST endpoint.\n    Demonstrates Eclipse JKube Zero Configuration capabilities.\n    All configurations to create the container image and resource manifests are inferred from the project and its dependencies.","technologies":["Kubernetes","OpenShift","Spring"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/zero-config/"}]}},"pageContext":{"slug":"/quickstarts/","langKey":"en"}},"staticQueryHashes":[]}
\ No newline at end of file
+{"componentChunkName":"component---src-pages-quickstarts-index-jsx","path":"/quickstarts/","result":{"data":{"allQuickstart":{"nodes":[{"id":"f0f3fc59-ac46-5830-a5b5-b83e862d40d3","artifactId":"eclipse-jkube-sample-custom-enricher-parent","name":"Kit :: Custom Istio Enricher Parent","description":"Eclipse JKube Kit example to build and use a Custom Enricher in a SpringBoot Application. It will demonstrate how you can extend Eclipse JKube Kit's Enricher API to make your own enricher and use it to enrich or generate manifests as per your requirements.","technologies":[],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/kit/custom-istio-enricher/"},{"id":"520432b9-a1bf-58f3-8339-9823de83727a","artifactId":"docker-image","name":"Kit :: Docker Image","description":"Eclipse JKube Kit example showing how to generate a Docker image by using Eclipse JKube in standalone mode.","technologies":[],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/kit/docker-image/"},{"id":"dc64b9d1-1cee-53ff-8f64-4661d6c05ba5","artifactId":"dynamic-docker-image-file-multi-layer","name":"Kit :: Docker Image from Multilayer Dockerfile","description":"Eclipse JKube Kit example showing how to Dynamically generate a Docker image.\n    The generated image contains multiple COPY statements which allows the generation of a multilayered container image.","technologies":[],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/kit/dynamic-docker-image-file-multi-layer/"},{"id":"0804f96e-3214-5c96-8dd1-8214974f71fa","artifactId":"docker-file-provided","name":"Maven :: Docker File Provided","description":"This quick start showcases how to use Eclipse JKube with external Docker files.\n        There are several profiles highlighting the different configuration modes available.","technologies":["Kubernetes","Spring"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/docker-file-provided/"},{"id":"55060235-c1f0-5465-988f-0f16577b004b","artifactId":"docker-file-simple","name":"Maven :: Dockerfile :: Simple","description":"This quickstart showcases how to use Eclipse JKube with external Docker files without any additional configuration.\n        Docker file mode is automatically selected when a Dockerfile is detected in the project's root directory.","technologies":["Kubernetes","Spring"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/docker-file-simple/"},{"id":"6cc272ac-8e68-5339-abd5-f85c274b6ff6","artifactId":"external-resources","name":"Maven :: External Resources","description":"Simple Spring Boot application which demonstrates how you can use Eclipse JKube's resource fragments.\n    Fragments in `src/main/jkube` directory are detected and picked up by JKube.\n    These fragments are then merged with the JKube generated cluster configuration manifests (YAML).","technologies":["Kubernetes","OpenShift","Spring"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/external-resources/"},{"id":"f990a28d-9017-5c42-b8c4-9ff539bc4ae8","artifactId":"helloworld","name":"Maven :: Hello World","description":"Demo project for getting started with Eclipse JKube.\n    It just prints \"Hello World\" on command line and exits.","technologies":["Kubernetes"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/hello-world/"},{"id":"01d769fd-227e-570f-8207-3e7d376665e7","artifactId":"javaee8-webprofile-liberty","name":"Maven :: JavaEE 8 WebProfile","description":"Demo project for Jakarta EE 8 WebProfile, IBM WebSphere Liberty is used as a Jakarta EE implementation.\n        On Windows or Mac if VirtualBox is used, run the tests using:\n        $ mvn clean verify -DtestProxyHost=192.168.99.100","technologies":["Kubernetes"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/ibm-javaee8-webprofile-liberty/"},{"id":"60181794-b5b0-52b9-803b-ab12cc0ee81b","artifactId":"karaf-camel-log","name":"Maven :: Karaf Camel Log","description":"Simple Apache Camel application on top of Apache Karaf that logs a series of messages to the Server log.\n    The application also generates and processes random orders using Camel routes.","technologies":["Kubernetes","OpenShift","ApacheCamel","ApacheKaraf"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/karaf-camel-log/"},{"id":"a0f117e8-cdcc-5805-838d-19af11c629fb","artifactId":"micronaut","name":"Maven :: Micronaut","description":"Micronaut application featuring REST endpoints (micronaut-http) with validation (micronaut-validation).","technologies":["Kubernetes","OpenShift"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/micronaut/"},{"id":"ff6f0023-3bbe-5ee0-8bba-9396f5bfc90c","artifactId":"micronaut-customized-image","name":"Maven :: Micronaut customized Image","description":"Micronaut application featuring REST endpoints (micronaut-http) with validation (micronaut-validation).\n\n    Includes configuration to enable health check probes (livenessProbe & readinessProbe) using JKube's\n    powerful resource fragments and micronaut-management feature.\n\n    XML based image configuration compatible with OpenShift and Kubernetes.","technologies":["Kubernetes","OpenShift"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/micronaut-customized-image/"},{"id":"d2af8513-0c9b-511d-8734-cf26543e8cf4","artifactId":"openliberty","name":"Maven :: Open Liberty","description":"JAX-RS application deployed with OpenLiberty and Eclipse JKube.\n        The application contains a single endpoint (/hello) that prints 'Hello, World.'.\n        An Arquillian based Integration Test is also included.","technologies":["OpenShift","OpenLiberty"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/openliberty/"},{"id":"fbeb2e9f-89cc-57ff-bac8-3cec8050add4","artifactId":"openliberty-microprofile","name":"Maven :: Open Liberty & MicroProfile","description":"How to integrate Eclipse JKube into an OpenLiberty-MicroProfile project as downloaded from start.microprofile.io.\n    Includes a JAX-RS endpoint, sample CDI injected configuration, and Liveness and Readiness probes.","technologies":["Kubernetes","OpenShift"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/openliberty-microprofile/"},{"id":"78a4f290-7bfb-501b-87b2-06056fe1737c","artifactId":"quarkus","name":"Maven :: Quarkus","description":"Quarkus application with a single JAX-RS endpoint.\n    Demonstrates how to package the project using JVM mode or Native image mode.\n    Demonstrates how to build a Quarkus project container with Eclipse JKube's S2I, Docker and JIB build strategies.","technologies":["Kubernetes","OpenShift","Quarkus"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/quarkus/"},{"id":"8c69d157-2ed8-5d45-92bd-7868217ff5f8","artifactId":"quarkus-customized-image","name":"Maven :: Quarkus customized Image","description":"Quarkus application with a single JAX-RS endpoint.\n    Demonstrates how to build a Quarkus container image based on a Red Hat container image private registry.\n    Uses a pull secret from Red Hat Registry Service Accounts to authenticate.","technologies":["OpenShift","Quarkus"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/quarkus-customized-image/"},{"id":"26ea4bda-5c68-51f8-8265-81b7e04e883f","artifactId":"spring-boot","name":"Maven :: Spring Boot Web","description":"Spring Boot Web application with a single @RestController.\n    Shows how to deploy Spring Boot applications to Kubernetes (-Pkubernetes) and OpenShift (-Popenshift) using Eclipse JKube.","technologies":["Kubernetes","OpenShift","Spring"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot/"},{"id":"d14e03d9-b464-5a7e-98c8-4a6952addc01","artifactId":"spring-boot-camel-complete","name":"Maven :: Spring Boot - Camel","description":"Spring Boot application with Camel Spring Boot integration.\n    Programmatically (RouteBuilder) declares 2 routes to log messages and process orders.\n    Declares an Apache Camel servlet REST endpoint.","technologies":["Kubernetes","OpenShift","ApacheCamel","Spring"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot-camel-complete/"},{"id":"413dce2e-a064-5b79-9369-5722f8a56caa","artifactId":"spring-boot-crd","name":"Maven :: Spring Boot - Custom Resources","description":"Spring Boot application using K8s Custom Resources.\n    Declares a \"Framework\" Custom Resource Definition.\n    Initializes cluster with sample data.\n    Declares an endpoint to consume Custom Resource data stored in the cluster.","technologies":["Kubernetes","OpenShift","Spring"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot-crd/"},{"id":"e9737f7f-a8d0-565b-91e0-963df0f85015","artifactId":"spring-boot-dekorate","name":"Maven :: Spring Boot - Dekorate","description":"Spring Boot application with Dekorate integration.\n    Eclipse JKube uses Dekorate generated cluster configuration manifests.","technologies":["Kubernetes","OpenShift","Spring"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot-dekorate/"},{"id":"b58e5dae-59e1-50fb-8bb5-ef9a0b87a977","artifactId":"spring-boot-helm","name":"Maven :: Spring Boot - Helm","description":"Spring Boot application with a single REST endpoint.\n    Demonstrates how to generate Helm chart (YAML) files using Eclipse JKube's k8s:helm Maven goal.","technologies":["Kubernetes","OpenShift","Spring"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot-helm/"},{"id":"dc5cf0bd-c1a7-540f-aac3-2bb5f5d80f6b","artifactId":"spring-boot-watch","name":"Maven :: Spring Boot Watch","description":"Spring Boot application with a single REST endpoint.\n    Demonstrates how to watch for source changes using Eclipse JKube's k8s:watch goal.\n    Application gets live reloaded in the cluster each time the project is recompiled (mvn package).","technologies":["Kubernetes","Spring"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot-watch/"},{"id":"d6658bfe-e1c0-5e9d-bf68-72899c9bf00b","artifactId":"eclipse-jkube-sample-spring-boot-jib","name":"Maven :: Spring Boot JIB","description":"Spring Boot application with a single REST endpoint.\n        Demonstrates how to build a project using Eclipse JKube JIB build strategy.","technologies":["Kubernetes","Spring"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot-with-jib/"},{"id":"5f84f68f-8cd3-5c66-9b4f-d0b237d4b403","artifactId":"thorntail","name":"Maven :: Thorntail","description":"Java web application with a single JAX-RS endpoint packaged with Thorntail.","technologies":["Kubernetes","OpenShift","Thorntail"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/thorntail/"},{"id":"cb0b8a1e-7023-54d9-a075-b99f36362d71","artifactId":"vertx","name":"Maven :: Vertx Web","description":"Eclipse Vert.x example application declaring a Simple AbstractVerticle.","technologies":["Kubernetes","OpenShift","Vertx"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/vertx/"},{"id":"5046adc6-558a-588c-a703-447be31d6e31","artifactId":"vertx-4","name":"Maven :: Vertx 4 Web","description":"Eclipse Vert.x 4 example application declaring a Simple AbstractVerticle.","technologies":["Kubernetes","OpenShift","Vertx"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/vertx4/"},{"id":"5192d8ac-da6f-5a42-aff0-ea2f7473fb56","artifactId":"webapp","name":"Maven :: Webapp","description":"Java Web Application with a static index.html resource.\n    Demonstrates how to create a container image with an embedded Apache Tomcat server using Eclipse JKube.","technologies":["Kubernetes","OpenShift"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/webapp/"},{"id":"a8104be8-b753-5914-adf9-b34a70f0d39d","artifactId":"webapp-jetty","name":"Maven :: Webapp Jetty","description":"Java Web Application with a static index.html resource.\n    Demonstrates how to create a container image with an embedded Eclipse Jetty server using Eclipse JKube.\n    Jetty is used instead of Apache Tomcat because there is a Jetty specific configuration file (jetty-logging.properties).\n    Eclipse JKube detects this file and chooses a Jetty specific base container image.","technologies":["Kubernetes","OpenShift"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/webapp-jetty/"},{"id":"08e2ebe5-1f38-5ded-abb4-95bba5f3fd3a","artifactId":"jkube-maven-sample-webapp-wildfly","name":"Maven :: Webapp :: Wildfly","description":"Java Web Application with a static index.html resource.\n    Demonstrates how to create a container image with an embedded WildFly server using Eclipse JKube.\n    WildFly is used instead of Apache Tomcat because there is a WildFly specific plugin configuration.\n    Eclipse JKube detects this plugin and chooses a WildFly specific base container image.","technologies":["Kubernetes","OpenShift"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/webapp-wildfly/"},{"id":"260eef06-4578-55bf-bd76-c3987e8b9fb1","artifactId":"wildfly-jar","name":"Maven :: Wildfly JAR","description":"Java web application with a single JAX-RS endpoint packaged with WildFly Jar Maven Plugin.","technologies":["Kubernetes","OpenShift"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/wildfly-jar/"},{"id":"eea78d7b-2789-5078-b88d-3a90556c08e2","artifactId":"wildfly-jar-slim","name":"Maven :: Wildfly JAR","description":"Java web application with a single JAX-RS endpoint packaged with WildFly Jar Maven Plugin.","technologies":["Kubernetes","OpenShift"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/wildfly-jar-slim/"},{"id":"d8e92d51-4e49-55d6-a753-98a7f9c7b68e","artifactId":"xml-config","name":"Maven :: XML configuration","description":"Apache Camel application.\n    Demonstrates how to configure Eclipse JKube build and resource properties using XML elements in the project's pom.xml plugin configuration.","technologies":["Kubernetes","ApacheCamel"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/xml-config/"},{"id":"b0f9e1cc-7c39-58c3-95ec-2e3614b17c38","artifactId":"yaml","name":"Maven :: Yaml","description":"Example showing how to use Eclipse JKube Maven Plugins to deploy cluster configuration YAML files.\n    Example with Yaml only resources","technologies":["Kubernetes"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/yaml-only/"},{"id":"8083fab0-707d-55a1-8927-f78e6b4e7208","artifactId":"jkube-maven-sample-zero-config","name":"Maven :: Zero-Config","description":"Spring Boot application with a single REST endpoint.\n    Demonstrates Eclipse JKube Zero Configuration capabilities.\n    All configurations to create the container image and resource manifests are inferred from the project and its dependencies.","technologies":["Kubernetes","OpenShift","Spring"],"url":"https://github.com/eclipse/jkube/tree/master/quickstarts/maven/zero-config/"}]}},"pageContext":{"slug":"/quickstarts/","langKey":"en"}},"staticQueryHashes":[]}
\ No newline at end of file
diff --git a/quickstarts/index.html b/quickstarts/index.html
index 08fa787..15af84d 100644
--- a/quickstarts/index.html
+++ b/quickstarts/index.html
@@ -48,4 +48,4 @@
         }
       }
     })
-  </script><link as="script" rel="preload" href="/jkube/webpack-runtime-20c402a54de81cfc0620.js"/><link as="script" rel="preload" href="/jkube/framework-5e01c8af6b1735c9eaa3.js"/><link as="script" rel="preload" href="/jkube/app-59faa9989d677dd59195.js"/><link as="script" rel="preload" href="/jkube/styles-e9d24b1846c7d6eb9685.js"/><link as="script" rel="preload" href="/jkube/commons-ee34cd715ab4f7da30e0.js"/><link as="script" rel="preload" href="/jkube/component---src-pages-quickstarts-index-jsx-8b53e5455e208a3e59b9.js"/><link as="fetch" rel="preload" href="/jkube/page-data/quickstarts/page-data.json" crossorigin="anonymous"/><link as="fetch" rel="preload" href="/jkube/page-data/app-data.json" crossorigin="anonymous"/></head><body><div id="___gatsby"><div style="outline:none" tabindex="-1" id="gatsby-focus-wrapper"><div class="eclipse-jkube"><header class="eclipse-jkube__header"><div class="eclipse-jkube__header-container"><a class="eclipse-jkube__header-logo" href="/jkube/"><div class="eclipse-jkube__header-logo-eclipse-image"><img src="/jkube/static/EF_WHT-OR_png-d0fd43ad31261ee9693a060be920e71e.png" alt="Eclipse Foundation"/></div><div class="eclipse-jkube__header-logo-jkube"><img class="eclipse-jkube__header-logo-jkube-image" src="data:image/svg+xml;base64,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" alt="JKube"/><span class="eclipse-jkube__header-trade-mark">™</span></div></a><div class="eclipse-jkube__header-content"><ul><li><a href="/jkube/docs">Docs</a></li><li><a href="/jkube/demos">Demos</a></li><li><a href="/jkube/community">Community</a></li><li><a href="/jkube/contributing">Contributing</a></li><li><a class="eclipse-jkube__header-stars" href="https://github.com/eclipse/jkube" title="eclipse/jkube" target="_blank" rel="nofollow noopener noreferrer"><img src="https://img.shields.io/github/stars/eclipse/jkube?style=social" alt="eclipse/jkube stargazers"/></a></li></ul></div></div></header><div class="eclipse-jkube__main"><div class="eclipse-jkube__content"><div class="hero"><div class="hero-content"><h1>Quickstarts</h1><p>Eclipse JKube Quickstarts and examples</p></div></div><ul class="eclipse-jkube__quickstarts" itemscope="" itemType="http://schema.org/SoftwareApplication"><meta itemProp="name" content="Eclipse JKube"/><meta itemProp="applicationCategory" content="Developer Tools"/><meta itemProp="operatingSystem" content="Linux,Windows,OSX,Mac"/><meta itemProp="downloadUrl" content="https://github.com/eclipse/jkube"/><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content=""/><meta itemProp="name" content="Kit :: Custom Istio Enricher Parent"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/kit/custom-istio-enricher/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/kit/custom-istio-enricher/" itemProp="url">Kit :: Custom Istio Enricher Parent</a></h3><ul class="quick-start-card__technologies"></ul><div class="quick-start-card__description" itemProp="description"><p>Eclipse JKube Kit example to build and use a Custom Enricher in a SpringBoot Application. It will demonstrate how you can extend Eclipse JKube Kit&#x27;s Enricher API to make your own enricher and use it to enrich or generate manifests as per your requirements.</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/kit/custom-istio-enricher/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content=""/><meta itemProp="name" content="Kit :: Docker Image"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/kit/docker-image/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/kit/docker-image/" itemProp="url">Kit :: Docker Image</a></h3><ul class="quick-start-card__technologies"></ul><div class="quick-start-card__description" itemProp="description"><p>Eclipse JKube Kit example showing how to generate a Docker image by using Eclipse JKube in standalone mode.</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/kit/docker-image/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content=""/><meta itemProp="name" content="Kit :: Docker Image from Multilayer Dockerfile"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/kit/dynamic-docker-image-file-multi-layer/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/kit/dynamic-docker-image-file-multi-layer/" itemProp="url">Kit :: Docker Image from Multilayer Dockerfile</a></h3><ul class="quick-start-card__technologies"></ul><div class="quick-start-card__description" itemProp="description"><p>Eclipse JKube Kit example showing how to Dynamically generate a Docker image.</p><p>The generated image contains multiple COPY statements which allows the generation of a multilayered container image.</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/kit/dynamic-docker-image-file-multi-layer/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="Kubernetes,Spring"/><meta itemProp="name" content="Maven :: Docker File Provided"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/docker-file-provided/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/docker-file-provided/" itemProp="url">Maven :: Docker File Provided</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-kubernetes"></i>Kubernetes</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-spring"></i>Spring</li></ul><div class="quick-start-card__description" itemProp="description"><p>This quick start showcases how to use Eclipse JKube with external Docker files.</p><p>There are several profiles highlighting the different configuration modes available.</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/docker-file-provided/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="Kubernetes,Spring"/><meta itemProp="name" content="Maven :: Dockerfile :: Simple"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/docker-file-simple/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/docker-file-simple/" itemProp="url">Maven :: Dockerfile :: Simple</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-kubernetes"></i>Kubernetes</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-spring"></i>Spring</li></ul><div class="quick-start-card__description" itemProp="description"><p>This quickstart showcases how to use Eclipse JKube with external Docker files without any additional configuration.</p><p>Docker file mode is automatically selected when a Dockerfile is detected in the project&#x27;s root directory.</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/docker-file-simple/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="Kubernetes,OpenShift,Spring"/><meta itemProp="name" content="Maven :: External Resources"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/external-resources/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/external-resources/" itemProp="url">Maven :: External Resources</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-kubernetes"></i>Kubernetes</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-redhat"></i>OpenShift</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-spring"></i>Spring</li></ul><div class="quick-start-card__description" itemProp="description"><p>Simple Spring Boot application which demonstrates how you can use Eclipse JKube&#x27;s resource fragments.</p><p>Fragments in `src/main/jkube` directory are detected and picked up by JKube.</p><p>These fragments are then merged with the JKube generated cluster configuration manifests (YAML).</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/external-resources/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="Kubernetes"/><meta itemProp="name" content="Maven :: Hello World"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/hello-world/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/hello-world/" itemProp="url">Maven :: Hello World</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-kubernetes"></i>Kubernetes</li></ul><div class="quick-start-card__description" itemProp="description"><p>Demo project for getting started with Eclipse JKube.</p><p>It just prints &quot;Hello World&quot; on command line and exits.</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/hello-world/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="Kubernetes"/><meta itemProp="name" content="Maven :: JavaEE 8 WebProfile"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/ibm-javaee8-webprofile-liberty/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/ibm-javaee8-webprofile-liberty/" itemProp="url">Maven :: JavaEE 8 WebProfile</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-kubernetes"></i>Kubernetes</li></ul><div class="quick-start-card__description" itemProp="description"><p>Demo project for Jakarta EE 8 WebProfile, IBM WebSphere Liberty is used as a Jakarta EE implementation.</p><p>On Windows or Mac if VirtualBox is used, run the tests using:</p><p>$ mvn clean verify -DtestProxyHost=192.168.99.100</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/ibm-javaee8-webprofile-liberty/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="Kubernetes,OpenShift,ApacheCamel,ApacheKaraf"/><meta itemProp="name" content="Maven :: Karaf Camel Log"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/karaf-camel-log/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/karaf-camel-log/" itemProp="url">Maven :: Karaf Camel Log</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-kubernetes"></i>Kubernetes</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-redhat"></i>OpenShift</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-apache"></i>ApacheCamel</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-apache"></i>ApacheKaraf</li></ul><div class="quick-start-card__description" itemProp="description"><p>Simple Apache Camel application on top of Apache Karaf that logs a series of messages to the Server log.</p><p>The application also generates and processes random orders using Camel routes.</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/karaf-camel-log/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="Kubernetes,OpenShift"/><meta itemProp="name" content="Maven :: Micronaut"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/micronaut/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/micronaut/" itemProp="url">Maven :: Micronaut</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-kubernetes"></i>Kubernetes</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-redhat"></i>OpenShift</li></ul><div class="quick-start-card__description" itemProp="description"><p>Micronaut application featuring REST endpoints (micronaut-http) with validation (micronaut-validation).</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/micronaut/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="Kubernetes,OpenShift"/><meta itemProp="name" content="Maven :: Micronaut customized Image"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/micronaut-customized-image/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/micronaut-customized-image/" itemProp="url">Maven :: Micronaut customized Image</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-kubernetes"></i>Kubernetes</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-redhat"></i>OpenShift</li></ul><div class="quick-start-card__description" itemProp="description"><p>Micronaut application featuring REST endpoints (micronaut-http) with validation (micronaut-validation).</p><p></p><p>Includes configuration to enable health check probes (livenessProbe &amp; readinessProbe) using JKube&#x27;s</p><p>powerful resource fragments and micronaut-management feature.</p><p></p><p>XML based image configuration compatible with OpenShift and Kubernetes.</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/micronaut-customized-image/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="OpenShift,OpenLiberty"/><meta itemProp="name" content="Maven :: Open Liberty"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/openliberty/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/openliberty/" itemProp="url">Maven :: Open Liberty</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-redhat"></i>OpenShift</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-java"></i>OpenLiberty</li></ul><div class="quick-start-card__description" itemProp="description"><p>JAX-RS application deployed with OpenLiberty and Eclipse JKube.</p><p>The application contains a single endpoint (/hello) that prints &#x27;Hello, World.&#x27;.</p><p>An Arquillian based Integration Test is also included.</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/openliberty/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="Kubernetes,OpenShift"/><meta itemProp="name" content="Maven :: Open Liberty &amp; MicroProfile"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/openliberty-microprofile/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/openliberty-microprofile/" itemProp="url">Maven :: Open Liberty &amp; MicroProfile</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-kubernetes"></i>Kubernetes</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-redhat"></i>OpenShift</li></ul><div class="quick-start-card__description" itemProp="description"><p>How to integrate Eclipse JKube into an OpenLiberty-MicroProfile project as downloaded from start.microprofile.io.</p><p>Includes a JAX-RS endpoint, sample CDI injected configuration, and Liveness and Readiness probes.</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/openliberty-microprofile/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="Kubernetes,OpenShift,Quarkus"/><meta itemProp="name" content="Maven :: Quarkus"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/quarkus/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/quarkus/" itemProp="url">Maven :: Quarkus</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-kubernetes"></i>Kubernetes</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-redhat"></i>OpenShift</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-quarkus"></i>Quarkus</li></ul><div class="quick-start-card__description" itemProp="description"><p>Quarkus application with a single JAX-RS endpoint.</p><p>Demonstrates how to package the project using JVM mode or Native image mode.</p><p>Demonstrates how to build a Quarkus project container with Eclipse JKube&#x27;s S2I, Docker and JIB build strategies.</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/quarkus/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="OpenShift,Quarkus"/><meta itemProp="name" content="Maven :: Quarkus customized Image"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/quarkus-customized-image/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/quarkus-customized-image/" itemProp="url">Maven :: Quarkus customized Image</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-redhat"></i>OpenShift</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-quarkus"></i>Quarkus</li></ul><div class="quick-start-card__description" itemProp="description"><p>Quarkus application with a single JAX-RS endpoint.</p><p>Demonstrates how to build a Quarkus container image based on a Red Hat container image private registry.</p><p>Uses a pull secret from Red Hat Registry Service Accounts to authenticate.</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/quarkus-customized-image/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="Kubernetes,OpenShift,Spring"/><meta itemProp="name" content="Maven :: Spring Boot Web"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot/" itemProp="url">Maven :: Spring Boot Web</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-kubernetes"></i>Kubernetes</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-redhat"></i>OpenShift</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-spring"></i>Spring</li></ul><div class="quick-start-card__description" itemProp="description"><p>Spring Boot Web application with a single @RestController.</p><p>Shows how to deploy Spring Boot applications to Kubernetes (-Pkubernetes) and OpenShift (-Popenshift) using Eclipse JKube.</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="Kubernetes,OpenShift,ApacheCamel,Spring"/><meta itemProp="name" content="Maven :: Spring Boot - Camel"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot-camel-complete/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot-camel-complete/" itemProp="url">Maven :: Spring Boot - Camel</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-kubernetes"></i>Kubernetes</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-redhat"></i>OpenShift</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-apache"></i>ApacheCamel</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-spring"></i>Spring</li></ul><div class="quick-start-card__description" itemProp="description"><p>Spring Boot application with Camel Spring Boot integration.</p><p>Programmatically (RouteBuilder) declares 2 routes to log messages and process orders.</p><p>Declares an Apache Camel servlet REST endpoint.</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot-camel-complete/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="Kubernetes,OpenShift,Spring"/><meta itemProp="name" content="Maven :: Spring Boot - Custom Resources"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot-crd/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot-crd/" itemProp="url">Maven :: Spring Boot - Custom Resources</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-kubernetes"></i>Kubernetes</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-redhat"></i>OpenShift</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-spring"></i>Spring</li></ul><div class="quick-start-card__description" itemProp="description"><p>Spring Boot application using K8s Custom Resources.</p><p>Declares a &quot;Framework&quot; Custom Resource Definition.</p><p>Initializes cluster with sample data.</p><p>Declares an endpoint to consume Custom Resource data stored in the cluster.</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot-crd/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="Kubernetes,OpenShift,Spring"/><meta itemProp="name" content="Maven :: Spring Boot - Dekorate"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot-dekorate/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot-dekorate/" itemProp="url">Maven :: Spring Boot - Dekorate</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-kubernetes"></i>Kubernetes</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-redhat"></i>OpenShift</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-spring"></i>Spring</li></ul><div class="quick-start-card__description" itemProp="description"><p>Spring Boot application with Dekorate integration.</p><p>Eclipse JKube uses Dekorate generated cluster configuration manifests.</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot-dekorate/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="Kubernetes,OpenShift,Spring"/><meta itemProp="name" content="Maven :: Spring Boot - Helm"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot-helm/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot-helm/" itemProp="url">Maven :: Spring Boot - Helm</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-kubernetes"></i>Kubernetes</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-redhat"></i>OpenShift</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-spring"></i>Spring</li></ul><div class="quick-start-card__description" itemProp="description"><p>Spring Boot application with a single REST endpoint.</p><p>Demonstrates how to generate Helm chart (YAML) files using Eclipse JKube&#x27;s k8s:helm Maven goal.</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot-helm/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="Kubernetes,Spring"/><meta itemProp="name" content="Maven :: Spring Boot Watch"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot-watch/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot-watch/" itemProp="url">Maven :: Spring Boot Watch</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-kubernetes"></i>Kubernetes</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-spring"></i>Spring</li></ul><div class="quick-start-card__description" itemProp="description"><p>Spring Boot application with a single REST endpoint.</p><p>Demonstrates how to watch for source changes using Eclipse JKube&#x27;s k8s:watch goal.</p><p>Application gets live reloaded in the cluster each time the project is recompiled (mvn package).</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot-watch/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="Kubernetes,Spring"/><meta itemProp="name" content="Maven :: Spring Boot JIB"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot-with-jib/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot-with-jib/" itemProp="url">Maven :: Spring Boot JIB</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-kubernetes"></i>Kubernetes</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-spring"></i>Spring</li></ul><div class="quick-start-card__description" itemProp="description"><p>Spring Boot application with a single REST endpoint.</p><p>Demonstrates how to build a project using Eclipse JKube JIB build strategy.</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot-with-jib/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="Kubernetes,OpenShift,Thorntail"/><meta itemProp="name" content="Maven :: Thorntail"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/thorntail/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/thorntail/" itemProp="url">Maven :: Thorntail</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-kubernetes"></i>Kubernetes</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-redhat"></i>OpenShift</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-java"></i>Thorntail</li></ul><div class="quick-start-card__description" itemProp="description"><p>Java web application with a single JAX-RS endpoint packaged with Thorntail.</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/thorntail/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="Kubernetes,OpenShift,Vertx"/><meta itemProp="name" content="Maven :: Vertx Web"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/vertx/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/vertx/" itemProp="url">Maven :: Vertx Web</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-kubernetes"></i>Kubernetes</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-redhat"></i>OpenShift</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-eclipseide"></i>Vertx</li></ul><div class="quick-start-card__description" itemProp="description"><p>Eclipse Vert.x example application declaring a Simple AbstractVerticle.</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/vertx/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="Kubernetes,OpenShift"/><meta itemProp="name" content="Maven :: Webapp"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/webapp/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/webapp/" itemProp="url">Maven :: Webapp</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-kubernetes"></i>Kubernetes</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-redhat"></i>OpenShift</li></ul><div class="quick-start-card__description" itemProp="description"><p>Java Web Application with a static index.html resource.</p><p>Demonstrates how to create a container image with an embedded Apache Tomcat server using Eclipse JKube.</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/webapp/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="Kubernetes,OpenShift"/><meta itemProp="name" content="Maven :: Webapp Jetty"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/webapp-jetty/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/webapp-jetty/" itemProp="url">Maven :: Webapp Jetty</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-kubernetes"></i>Kubernetes</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-redhat"></i>OpenShift</li></ul><div class="quick-start-card__description" itemProp="description"><p>Java Web Application with a static index.html resource.</p><p>Demonstrates how to create a container image with an embedded Eclipse Jetty server using Eclipse JKube.</p><p>Jetty is used instead of Apache Tomcat because there is a Jetty specific configuration file (jetty-logging.properties).</p><p>Eclipse JKube detects this file and chooses a Jetty specific base container image.</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/webapp-jetty/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="Kubernetes,OpenShift"/><meta itemProp="name" content="Maven :: Webapp :: Wildfly"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/webapp-wildfly/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/webapp-wildfly/" itemProp="url">Maven :: Webapp :: Wildfly</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-kubernetes"></i>Kubernetes</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-redhat"></i>OpenShift</li></ul><div class="quick-start-card__description" itemProp="description"><p>Java Web Application with a static index.html resource.</p><p>Demonstrates how to create a container image with an embedded WildFly server using Eclipse JKube.</p><p>WildFly is used instead of Apache Tomcat because there is a WildFly specific plugin configuration.</p><p>Eclipse JKube detects this plugin and chooses a WildFly specific base container image.</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/webapp-wildfly/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="Kubernetes,OpenShift"/><meta itemProp="name" content="Maven :: Wildfly JAR"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/wildfly-jar/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/wildfly-jar/" itemProp="url">Maven :: Wildfly JAR</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-kubernetes"></i>Kubernetes</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-redhat"></i>OpenShift</li></ul><div class="quick-start-card__description" itemProp="description"><p>Java web application with a single JAX-RS endpoint packaged with WildFly Jar Maven Plugin.</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/wildfly-jar/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="Kubernetes,OpenShift"/><meta itemProp="name" content="Maven :: Wildfly JAR"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/wildfly-jar-slim/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/wildfly-jar-slim/" itemProp="url">Maven :: Wildfly JAR</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-kubernetes"></i>Kubernetes</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-redhat"></i>OpenShift</li></ul><div class="quick-start-card__description" itemProp="description"><p>Java web application with a single JAX-RS endpoint packaged with WildFly Jar Maven Plugin.</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/wildfly-jar-slim/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="Kubernetes,ApacheCamel"/><meta itemProp="name" content="Maven :: XML configuration"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/xml-config/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/xml-config/" itemProp="url">Maven :: XML configuration</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-kubernetes"></i>Kubernetes</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-apache"></i>ApacheCamel</li></ul><div class="quick-start-card__description" itemProp="description"><p>Apache Camel application.</p><p>Demonstrates how to configure Eclipse JKube build and resource properties using XML elements in the project&#x27;s pom.xml plugin configuration.</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/xml-config/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="Kubernetes"/><meta itemProp="name" content="Maven :: Yaml"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/yaml-only/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/yaml-only/" itemProp="url">Maven :: Yaml</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-kubernetes"></i>Kubernetes</li></ul><div class="quick-start-card__description" itemProp="description"><p>Example showing how to use Eclipse JKube Maven Plugins to deploy cluster configuration YAML files.</p><p>Example with Yaml only resources</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/yaml-only/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="Kubernetes,OpenShift,Spring"/><meta itemProp="name" content="Maven :: Zero-Config"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/zero-config/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/zero-config/" itemProp="url">Maven :: Zero-Config</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-kubernetes"></i>Kubernetes</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-redhat"></i>OpenShift</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-spring"></i>Spring</li></ul><div class="quick-start-card__description" itemProp="description"><p>Spring Boot application with a single REST endpoint.</p><p>Demonstrates Eclipse JKube Zero Configuration capabilities.</p><p>All configurations to create the container image and resource manifests are inferred from the project and its dependencies.</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/zero-config/"><i class="cib-github"></i> GitHub repository</a></div></div></li></ul></div></div><div class="eclipse-jkube-footer"><div class="eclipse-jkube-footer__logo-jkube"><a href="/jkube/"><img class="eclipse-jkube-footer__logo-jkube-image" src="data:image/svg+xml;base64,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" alt="JKube"/></a><span class="eclipse-jkube-footer__logo-jkube-tagline">Cloud-Native Java Applications without a hassle</span></div><div class="eclipse-jkube-footer__links"><ul class="eclipse-jkube-footer__links-list"><li><a href="/jkube/docs#getting-started">Get Started</a></li><li><a href="/jkube/docs">Docs</a></li><li><a href="/jkube/quickstarts">Quickstarts</a></li><li><a href="/jkube/docs#katacoda-courses">Katacoda Courses</a></li><li><a href="/jkube/demos">Demos</a></li></ul><ul class="eclipse-jkube-footer__links-list"><li><a href="/jkube/community">Community</a></li><li><a href="/jkube/community#planning-and-meetings">Get Involved</a></li><li><a href="/jkube/contributing">Contributing</a></li></ul><ul class="eclipse-jkube-footer__links-list"><li><a href="https://www.eclipse.org" target="_blank" rel="nofollow noopener noreferrer">Eclipse Foundation</a></li><li><a href="https://www.eclipse.org/legal/privacy.php" target="_blank" rel="nofollow noopener noreferrer">Privacy Policy</a></li><li><a href="https://www.eclipse.org/legal/termsofuse.php" target="_blank" rel="nofollow noopener noreferrer">Terms of Use</a></li><li><a href="https://www.eclipse.org/legal/copyright.php" target="_blank" rel="nofollow noopener noreferrer">Copyright Agent</a></li><li><a href="https://www.eclipse.org/legal" target="_blank" rel="nofollow noopener noreferrer">Legal Resources</a></li></ul></div><div class="eclipse-jkube-footer__copyright">Copyright © Eclipse Foundation 2020</div></div></div></div><div id="gatsby-announcer" style="position:absolute;top:0;width:1px;height:1px;padding:0;overflow:hidden;clip:rect(0, 0, 0, 0);white-space:nowrap;border:0" aria-live="assertive" aria-atomic="true"></div></div><script id="gatsby-script-loader">/*<![CDATA[*/window.pagePath="/quickstarts/";/*]]>*/</script><script id="gatsby-chunk-mapping">/*<![CDATA[*/window.___chunkMapping={"polyfill":["/polyfill-e4957c11759bdfc149d9.js"],"app":["/app-59faa9989d677dd59195.js"],"component---src-pages-quickstarts-index-jsx":["/component---src-pages-quickstarts-index-jsx-8b53e5455e208a3e59b9.js"],"component---src-templates-doc-jsx":["/component---src-templates-doc-jsx-21a94bb36ef3df298f42.js"],"component---src-templates-main-jsx":["/component---src-templates-main-jsx-8853cf342e1cf1bead5c.js"]};/*]]>*/</script><script src="/jkube/polyfill-e4957c11759bdfc149d9.js" nomodule=""></script><script src="/jkube/component---src-pages-quickstarts-index-jsx-8b53e5455e208a3e59b9.js" async=""></script><script src="/jkube/commons-ee34cd715ab4f7da30e0.js" async=""></script><script src="/jkube/styles-e9d24b1846c7d6eb9685.js" async=""></script><script src="/jkube/app-59faa9989d677dd59195.js" async=""></script><script src="/jkube/framework-5e01c8af6b1735c9eaa3.js" async=""></script><script src="/jkube/webpack-runtime-20c402a54de81cfc0620.js" async=""></script></body></html>
\ No newline at end of file
+  </script><link as="script" rel="preload" href="/jkube/webpack-runtime-20c402a54de81cfc0620.js"/><link as="script" rel="preload" href="/jkube/framework-5e01c8af6b1735c9eaa3.js"/><link as="script" rel="preload" href="/jkube/app-59faa9989d677dd59195.js"/><link as="script" rel="preload" href="/jkube/styles-e9d24b1846c7d6eb9685.js"/><link as="script" rel="preload" href="/jkube/commons-ee34cd715ab4f7da30e0.js"/><link as="script" rel="preload" href="/jkube/component---src-pages-quickstarts-index-jsx-8b53e5455e208a3e59b9.js"/><link as="fetch" rel="preload" href="/jkube/page-data/quickstarts/page-data.json" crossorigin="anonymous"/><link as="fetch" rel="preload" href="/jkube/page-data/app-data.json" crossorigin="anonymous"/></head><body><div id="___gatsby"><div style="outline:none" tabindex="-1" id="gatsby-focus-wrapper"><div class="eclipse-jkube"><header class="eclipse-jkube__header"><div class="eclipse-jkube__header-container"><a class="eclipse-jkube__header-logo" href="/jkube/"><div class="eclipse-jkube__header-logo-eclipse-image"><img src="/jkube/static/EF_WHT-OR_png-d0fd43ad31261ee9693a060be920e71e.png" alt="Eclipse Foundation"/></div><div class="eclipse-jkube__header-logo-jkube"><img class="eclipse-jkube__header-logo-jkube-image" src="data:image/svg+xml;base64,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" alt="JKube"/><span class="eclipse-jkube__header-trade-mark">™</span></div></a><div class="eclipse-jkube__header-content"><ul><li><a href="/jkube/docs">Docs</a></li><li><a href="/jkube/demos">Demos</a></li><li><a href="/jkube/community">Community</a></li><li><a href="/jkube/contributing">Contributing</a></li><li><a class="eclipse-jkube__header-stars" href="https://github.com/eclipse/jkube" title="eclipse/jkube" target="_blank" rel="nofollow noopener noreferrer"><img src="https://img.shields.io/github/stars/eclipse/jkube?style=social" alt="eclipse/jkube stargazers"/></a></li></ul></div></div></header><div class="eclipse-jkube__main"><div class="eclipse-jkube__content"><div class="hero"><div class="hero-content"><h1>Quickstarts</h1><p>Eclipse JKube Quickstarts and examples</p></div></div><ul class="eclipse-jkube__quickstarts" itemscope="" itemType="http://schema.org/SoftwareApplication"><meta itemProp="name" content="Eclipse JKube"/><meta itemProp="applicationCategory" content="Developer Tools"/><meta itemProp="operatingSystem" content="Linux,Windows,OSX,Mac"/><meta itemProp="downloadUrl" content="https://github.com/eclipse/jkube"/><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content=""/><meta itemProp="name" content="Kit :: Custom Istio Enricher Parent"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/kit/custom-istio-enricher/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/kit/custom-istio-enricher/" itemProp="url">Kit :: Custom Istio Enricher Parent</a></h3><ul class="quick-start-card__technologies"></ul><div class="quick-start-card__description" itemProp="description"><p>Eclipse JKube Kit example to build and use a Custom Enricher in a SpringBoot Application. It will demonstrate how you can extend Eclipse JKube Kit&#x27;s Enricher API to make your own enricher and use it to enrich or generate manifests as per your requirements.</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/kit/custom-istio-enricher/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content=""/><meta itemProp="name" content="Kit :: Docker Image"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/kit/docker-image/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/kit/docker-image/" itemProp="url">Kit :: Docker Image</a></h3><ul class="quick-start-card__technologies"></ul><div class="quick-start-card__description" itemProp="description"><p>Eclipse JKube Kit example showing how to generate a Docker image by using Eclipse JKube in standalone mode.</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/kit/docker-image/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content=""/><meta itemProp="name" content="Kit :: Docker Image from Multilayer Dockerfile"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/kit/dynamic-docker-image-file-multi-layer/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/kit/dynamic-docker-image-file-multi-layer/" itemProp="url">Kit :: Docker Image from Multilayer Dockerfile</a></h3><ul class="quick-start-card__technologies"></ul><div class="quick-start-card__description" itemProp="description"><p>Eclipse JKube Kit example showing how to Dynamically generate a Docker image.</p><p>The generated image contains multiple COPY statements which allows the generation of a multilayered container image.</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/kit/dynamic-docker-image-file-multi-layer/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="Kubernetes,Spring"/><meta itemProp="name" content="Maven :: Docker File Provided"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/docker-file-provided/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/docker-file-provided/" itemProp="url">Maven :: Docker File Provided</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-kubernetes"></i>Kubernetes</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-spring"></i>Spring</li></ul><div class="quick-start-card__description" itemProp="description"><p>This quick start showcases how to use Eclipse JKube with external Docker files.</p><p>There are several profiles highlighting the different configuration modes available.</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/docker-file-provided/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="Kubernetes,Spring"/><meta itemProp="name" content="Maven :: Dockerfile :: Simple"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/docker-file-simple/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/docker-file-simple/" itemProp="url">Maven :: Dockerfile :: Simple</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-kubernetes"></i>Kubernetes</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-spring"></i>Spring</li></ul><div class="quick-start-card__description" itemProp="description"><p>This quickstart showcases how to use Eclipse JKube with external Docker files without any additional configuration.</p><p>Docker file mode is automatically selected when a Dockerfile is detected in the project&#x27;s root directory.</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/docker-file-simple/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="Kubernetes,OpenShift,Spring"/><meta itemProp="name" content="Maven :: External Resources"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/external-resources/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/external-resources/" itemProp="url">Maven :: External Resources</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-kubernetes"></i>Kubernetes</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-redhat"></i>OpenShift</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-spring"></i>Spring</li></ul><div class="quick-start-card__description" itemProp="description"><p>Simple Spring Boot application which demonstrates how you can use Eclipse JKube&#x27;s resource fragments.</p><p>Fragments in `src/main/jkube` directory are detected and picked up by JKube.</p><p>These fragments are then merged with the JKube generated cluster configuration manifests (YAML).</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/external-resources/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="Kubernetes"/><meta itemProp="name" content="Maven :: Hello World"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/hello-world/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/hello-world/" itemProp="url">Maven :: Hello World</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-kubernetes"></i>Kubernetes</li></ul><div class="quick-start-card__description" itemProp="description"><p>Demo project for getting started with Eclipse JKube.</p><p>It just prints &quot;Hello World&quot; on command line and exits.</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/hello-world/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="Kubernetes"/><meta itemProp="name" content="Maven :: JavaEE 8 WebProfile"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/ibm-javaee8-webprofile-liberty/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/ibm-javaee8-webprofile-liberty/" itemProp="url">Maven :: JavaEE 8 WebProfile</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-kubernetes"></i>Kubernetes</li></ul><div class="quick-start-card__description" itemProp="description"><p>Demo project for Jakarta EE 8 WebProfile, IBM WebSphere Liberty is used as a Jakarta EE implementation.</p><p>On Windows or Mac if VirtualBox is used, run the tests using:</p><p>$ mvn clean verify -DtestProxyHost=192.168.99.100</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/ibm-javaee8-webprofile-liberty/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="Kubernetes,OpenShift,ApacheCamel,ApacheKaraf"/><meta itemProp="name" content="Maven :: Karaf Camel Log"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/karaf-camel-log/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/karaf-camel-log/" itemProp="url">Maven :: Karaf Camel Log</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-kubernetes"></i>Kubernetes</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-redhat"></i>OpenShift</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-apache"></i>ApacheCamel</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-apache"></i>ApacheKaraf</li></ul><div class="quick-start-card__description" itemProp="description"><p>Simple Apache Camel application on top of Apache Karaf that logs a series of messages to the Server log.</p><p>The application also generates and processes random orders using Camel routes.</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/karaf-camel-log/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="Kubernetes,OpenShift"/><meta itemProp="name" content="Maven :: Micronaut"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/micronaut/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/micronaut/" itemProp="url">Maven :: Micronaut</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-kubernetes"></i>Kubernetes</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-redhat"></i>OpenShift</li></ul><div class="quick-start-card__description" itemProp="description"><p>Micronaut application featuring REST endpoints (micronaut-http) with validation (micronaut-validation).</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/micronaut/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="Kubernetes,OpenShift"/><meta itemProp="name" content="Maven :: Micronaut customized Image"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/micronaut-customized-image/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/micronaut-customized-image/" itemProp="url">Maven :: Micronaut customized Image</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-kubernetes"></i>Kubernetes</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-redhat"></i>OpenShift</li></ul><div class="quick-start-card__description" itemProp="description"><p>Micronaut application featuring REST endpoints (micronaut-http) with validation (micronaut-validation).</p><p></p><p>Includes configuration to enable health check probes (livenessProbe &amp; readinessProbe) using JKube&#x27;s</p><p>powerful resource fragments and micronaut-management feature.</p><p></p><p>XML based image configuration compatible with OpenShift and Kubernetes.</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/micronaut-customized-image/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="OpenShift,OpenLiberty"/><meta itemProp="name" content="Maven :: Open Liberty"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/openliberty/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/openliberty/" itemProp="url">Maven :: Open Liberty</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-redhat"></i>OpenShift</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-java"></i>OpenLiberty</li></ul><div class="quick-start-card__description" itemProp="description"><p>JAX-RS application deployed with OpenLiberty and Eclipse JKube.</p><p>The application contains a single endpoint (/hello) that prints &#x27;Hello, World.&#x27;.</p><p>An Arquillian based Integration Test is also included.</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/openliberty/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="Kubernetes,OpenShift"/><meta itemProp="name" content="Maven :: Open Liberty &amp; MicroProfile"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/openliberty-microprofile/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/openliberty-microprofile/" itemProp="url">Maven :: Open Liberty &amp; MicroProfile</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-kubernetes"></i>Kubernetes</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-redhat"></i>OpenShift</li></ul><div class="quick-start-card__description" itemProp="description"><p>How to integrate Eclipse JKube into an OpenLiberty-MicroProfile project as downloaded from start.microprofile.io.</p><p>Includes a JAX-RS endpoint, sample CDI injected configuration, and Liveness and Readiness probes.</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/openliberty-microprofile/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="Kubernetes,OpenShift,Quarkus"/><meta itemProp="name" content="Maven :: Quarkus"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/quarkus/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/quarkus/" itemProp="url">Maven :: Quarkus</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-kubernetes"></i>Kubernetes</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-redhat"></i>OpenShift</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-quarkus"></i>Quarkus</li></ul><div class="quick-start-card__description" itemProp="description"><p>Quarkus application with a single JAX-RS endpoint.</p><p>Demonstrates how to package the project using JVM mode or Native image mode.</p><p>Demonstrates how to build a Quarkus project container with Eclipse JKube&#x27;s S2I, Docker and JIB build strategies.</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/quarkus/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="OpenShift,Quarkus"/><meta itemProp="name" content="Maven :: Quarkus customized Image"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/quarkus-customized-image/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/quarkus-customized-image/" itemProp="url">Maven :: Quarkus customized Image</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-redhat"></i>OpenShift</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-quarkus"></i>Quarkus</li></ul><div class="quick-start-card__description" itemProp="description"><p>Quarkus application with a single JAX-RS endpoint.</p><p>Demonstrates how to build a Quarkus container image based on a Red Hat container image private registry.</p><p>Uses a pull secret from Red Hat Registry Service Accounts to authenticate.</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/quarkus-customized-image/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="Kubernetes,OpenShift,Spring"/><meta itemProp="name" content="Maven :: Spring Boot Web"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot/" itemProp="url">Maven :: Spring Boot Web</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-kubernetes"></i>Kubernetes</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-redhat"></i>OpenShift</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-spring"></i>Spring</li></ul><div class="quick-start-card__description" itemProp="description"><p>Spring Boot Web application with a single @RestController.</p><p>Shows how to deploy Spring Boot applications to Kubernetes (-Pkubernetes) and OpenShift (-Popenshift) using Eclipse JKube.</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="Kubernetes,OpenShift,ApacheCamel,Spring"/><meta itemProp="name" content="Maven :: Spring Boot - Camel"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot-camel-complete/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot-camel-complete/" itemProp="url">Maven :: Spring Boot - Camel</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-kubernetes"></i>Kubernetes</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-redhat"></i>OpenShift</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-apache"></i>ApacheCamel</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-spring"></i>Spring</li></ul><div class="quick-start-card__description" itemProp="description"><p>Spring Boot application with Camel Spring Boot integration.</p><p>Programmatically (RouteBuilder) declares 2 routes to log messages and process orders.</p><p>Declares an Apache Camel servlet REST endpoint.</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot-camel-complete/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="Kubernetes,OpenShift,Spring"/><meta itemProp="name" content="Maven :: Spring Boot - Custom Resources"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot-crd/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot-crd/" itemProp="url">Maven :: Spring Boot - Custom Resources</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-kubernetes"></i>Kubernetes</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-redhat"></i>OpenShift</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-spring"></i>Spring</li></ul><div class="quick-start-card__description" itemProp="description"><p>Spring Boot application using K8s Custom Resources.</p><p>Declares a &quot;Framework&quot; Custom Resource Definition.</p><p>Initializes cluster with sample data.</p><p>Declares an endpoint to consume Custom Resource data stored in the cluster.</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot-crd/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="Kubernetes,OpenShift,Spring"/><meta itemProp="name" content="Maven :: Spring Boot - Dekorate"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot-dekorate/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot-dekorate/" itemProp="url">Maven :: Spring Boot - Dekorate</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-kubernetes"></i>Kubernetes</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-redhat"></i>OpenShift</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-spring"></i>Spring</li></ul><div class="quick-start-card__description" itemProp="description"><p>Spring Boot application with Dekorate integration.</p><p>Eclipse JKube uses Dekorate generated cluster configuration manifests.</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot-dekorate/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="Kubernetes,OpenShift,Spring"/><meta itemProp="name" content="Maven :: Spring Boot - Helm"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot-helm/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot-helm/" itemProp="url">Maven :: Spring Boot - Helm</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-kubernetes"></i>Kubernetes</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-redhat"></i>OpenShift</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-spring"></i>Spring</li></ul><div class="quick-start-card__description" itemProp="description"><p>Spring Boot application with a single REST endpoint.</p><p>Demonstrates how to generate Helm chart (YAML) files using Eclipse JKube&#x27;s k8s:helm Maven goal.</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot-helm/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="Kubernetes,Spring"/><meta itemProp="name" content="Maven :: Spring Boot Watch"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot-watch/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot-watch/" itemProp="url">Maven :: Spring Boot Watch</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-kubernetes"></i>Kubernetes</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-spring"></i>Spring</li></ul><div class="quick-start-card__description" itemProp="description"><p>Spring Boot application with a single REST endpoint.</p><p>Demonstrates how to watch for source changes using Eclipse JKube&#x27;s k8s:watch goal.</p><p>Application gets live reloaded in the cluster each time the project is recompiled (mvn package).</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot-watch/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="Kubernetes,Spring"/><meta itemProp="name" content="Maven :: Spring Boot JIB"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot-with-jib/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot-with-jib/" itemProp="url">Maven :: Spring Boot JIB</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-kubernetes"></i>Kubernetes</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-spring"></i>Spring</li></ul><div class="quick-start-card__description" itemProp="description"><p>Spring Boot application with a single REST endpoint.</p><p>Demonstrates how to build a project using Eclipse JKube JIB build strategy.</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/spring-boot-with-jib/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="Kubernetes,OpenShift,Thorntail"/><meta itemProp="name" content="Maven :: Thorntail"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/thorntail/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/thorntail/" itemProp="url">Maven :: Thorntail</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-kubernetes"></i>Kubernetes</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-redhat"></i>OpenShift</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-java"></i>Thorntail</li></ul><div class="quick-start-card__description" itemProp="description"><p>Java web application with a single JAX-RS endpoint packaged with Thorntail.</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/thorntail/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="Kubernetes,OpenShift,Vertx"/><meta itemProp="name" content="Maven :: Vertx Web"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/vertx/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/vertx/" itemProp="url">Maven :: Vertx Web</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-kubernetes"></i>Kubernetes</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-redhat"></i>OpenShift</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-eclipseide"></i>Vertx</li></ul><div class="quick-start-card__description" itemProp="description"><p>Eclipse Vert.x example application declaring a Simple AbstractVerticle.</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/vertx/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="Kubernetes,OpenShift,Vertx"/><meta itemProp="name" content="Maven :: Vertx 4 Web"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/vertx4/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/vertx4/" itemProp="url">Maven :: Vertx 4 Web</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-kubernetes"></i>Kubernetes</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-redhat"></i>OpenShift</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-eclipseide"></i>Vertx</li></ul><div class="quick-start-card__description" itemProp="description"><p>Eclipse Vert.x 4 example application declaring a Simple AbstractVerticle.</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/vertx4/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="Kubernetes,OpenShift"/><meta itemProp="name" content="Maven :: Webapp"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/webapp/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/webapp/" itemProp="url">Maven :: Webapp</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-kubernetes"></i>Kubernetes</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-redhat"></i>OpenShift</li></ul><div class="quick-start-card__description" itemProp="description"><p>Java Web Application with a static index.html resource.</p><p>Demonstrates how to create a container image with an embedded Apache Tomcat server using Eclipse JKube.</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/webapp/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="Kubernetes,OpenShift"/><meta itemProp="name" content="Maven :: Webapp Jetty"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/webapp-jetty/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/webapp-jetty/" itemProp="url">Maven :: Webapp Jetty</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-kubernetes"></i>Kubernetes</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-redhat"></i>OpenShift</li></ul><div class="quick-start-card__description" itemProp="description"><p>Java Web Application with a static index.html resource.</p><p>Demonstrates how to create a container image with an embedded Eclipse Jetty server using Eclipse JKube.</p><p>Jetty is used instead of Apache Tomcat because there is a Jetty specific configuration file (jetty-logging.properties).</p><p>Eclipse JKube detects this file and chooses a Jetty specific base container image.</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/webapp-jetty/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="Kubernetes,OpenShift"/><meta itemProp="name" content="Maven :: Webapp :: Wildfly"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/webapp-wildfly/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/webapp-wildfly/" itemProp="url">Maven :: Webapp :: Wildfly</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-kubernetes"></i>Kubernetes</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-redhat"></i>OpenShift</li></ul><div class="quick-start-card__description" itemProp="description"><p>Java Web Application with a static index.html resource.</p><p>Demonstrates how to create a container image with an embedded WildFly server using Eclipse JKube.</p><p>WildFly is used instead of Apache Tomcat because there is a WildFly specific plugin configuration.</p><p>Eclipse JKube detects this plugin and chooses a WildFly specific base container image.</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/webapp-wildfly/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="Kubernetes,OpenShift"/><meta itemProp="name" content="Maven :: Wildfly JAR"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/wildfly-jar/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/wildfly-jar/" itemProp="url">Maven :: Wildfly JAR</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-kubernetes"></i>Kubernetes</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-redhat"></i>OpenShift</li></ul><div class="quick-start-card__description" itemProp="description"><p>Java web application with a single JAX-RS endpoint packaged with WildFly Jar Maven Plugin.</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/wildfly-jar/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="Kubernetes,OpenShift"/><meta itemProp="name" content="Maven :: Wildfly JAR"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/wildfly-jar-slim/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/wildfly-jar-slim/" itemProp="url">Maven :: Wildfly JAR</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-kubernetes"></i>Kubernetes</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-redhat"></i>OpenShift</li></ul><div class="quick-start-card__description" itemProp="description"><p>Java web application with a single JAX-RS endpoint packaged with WildFly Jar Maven Plugin.</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/wildfly-jar-slim/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="Kubernetes,ApacheCamel"/><meta itemProp="name" content="Maven :: XML configuration"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/xml-config/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/xml-config/" itemProp="url">Maven :: XML configuration</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-kubernetes"></i>Kubernetes</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-apache"></i>ApacheCamel</li></ul><div class="quick-start-card__description" itemProp="description"><p>Apache Camel application.</p><p>Demonstrates how to configure Eclipse JKube build and resource properties using XML elements in the project&#x27;s pom.xml plugin configuration.</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/xml-config/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="Kubernetes"/><meta itemProp="name" content="Maven :: Yaml"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/yaml-only/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/yaml-only/" itemProp="url">Maven :: Yaml</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-kubernetes"></i>Kubernetes</li></ul><div class="quick-start-card__description" itemProp="description"><p>Example showing how to use Eclipse JKube Maven Plugins to deploy cluster configuration YAML files.</p><p>Example with Yaml only resources</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/yaml-only/"><i class="cib-github"></i> GitHub repository</a></div></div></li><li class="eclipse-jkube__quickstarts-item"><div class="quick-start-card" itemscope="" itemType="http://schema.org/SoftwareSourceCode"><meta itemProp="programmingLanguage" content="Java"/><meta itemProp="codeSampleType" content="full (compile ready) solution"/><meta itemProp="keywords" content="Kubernetes,OpenShift,Spring"/><meta itemProp="name" content="Maven :: Zero-Config"/><meta itemProp="codeRepository" content="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/zero-config/"/><h3 class="quick-start-card__title"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/zero-config/" itemProp="url">Maven :: Zero-Config</a></h3><ul class="quick-start-card__technologies"><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-kubernetes"></i>Kubernetes</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-redhat"></i>OpenShift</li><li class="quick-start-card__technologies-item"><i class="quick-start-card__technologies-item-icon cib-spring"></i>Spring</li></ul><div class="quick-start-card__description" itemProp="description"><p>Spring Boot application with a single REST endpoint.</p><p>Demonstrates Eclipse JKube Zero Configuration capabilities.</p><p>All configurations to create the container image and resource manifests are inferred from the project and its dependencies.</p></div><div class="quick-start-card__links"><a href="https://github.com/eclipse/jkube/tree/master/quickstarts/maven/zero-config/"><i class="cib-github"></i> GitHub repository</a></div></div></li></ul></div></div><div class="eclipse-jkube-footer"><div class="eclipse-jkube-footer__logo-jkube"><a href="/jkube/"><img class="eclipse-jkube-footer__logo-jkube-image" src="data:image/svg+xml;base64,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" alt="JKube"/></a><span class="eclipse-jkube-footer__logo-jkube-tagline">Cloud-Native Java Applications without a hassle</span></div><div class="eclipse-jkube-footer__links"><ul class="eclipse-jkube-footer__links-list"><li><a href="/jkube/docs#getting-started">Get Started</a></li><li><a href="/jkube/docs">Docs</a></li><li><a href="/jkube/quickstarts">Quickstarts</a></li><li><a href="/jkube/docs#katacoda-courses">Katacoda Courses</a></li><li><a href="/jkube/demos">Demos</a></li></ul><ul class="eclipse-jkube-footer__links-list"><li><a href="/jkube/community">Community</a></li><li><a href="/jkube/community#planning-and-meetings">Get Involved</a></li><li><a href="/jkube/contributing">Contributing</a></li></ul><ul class="eclipse-jkube-footer__links-list"><li><a href="https://www.eclipse.org" target="_blank" rel="nofollow noopener noreferrer">Eclipse Foundation</a></li><li><a href="https://www.eclipse.org/legal/privacy.php" target="_blank" rel="nofollow noopener noreferrer">Privacy Policy</a></li><li><a href="https://www.eclipse.org/legal/termsofuse.php" target="_blank" rel="nofollow noopener noreferrer">Terms of Use</a></li><li><a href="https://www.eclipse.org/legal/copyright.php" target="_blank" rel="nofollow noopener noreferrer">Copyright Agent</a></li><li><a href="https://www.eclipse.org/legal" target="_blank" rel="nofollow noopener noreferrer">Legal Resources</a></li></ul></div><div class="eclipse-jkube-footer__copyright">Copyright © Eclipse Foundation 2020</div></div></div></div><div id="gatsby-announcer" style="position:absolute;top:0;width:1px;height:1px;padding:0;overflow:hidden;clip:rect(0, 0, 0, 0);white-space:nowrap;border:0" aria-live="assertive" aria-atomic="true"></div></div><script id="gatsby-script-loader">/*<![CDATA[*/window.pagePath="/quickstarts/";/*]]>*/</script><script id="gatsby-chunk-mapping">/*<![CDATA[*/window.___chunkMapping={"polyfill":["/polyfill-e4957c11759bdfc149d9.js"],"app":["/app-59faa9989d677dd59195.js"],"component---src-pages-quickstarts-index-jsx":["/component---src-pages-quickstarts-index-jsx-8b53e5455e208a3e59b9.js"],"component---src-templates-doc-jsx":["/component---src-templates-doc-jsx-21a94bb36ef3df298f42.js"],"component---src-templates-main-jsx":["/component---src-templates-main-jsx-8853cf342e1cf1bead5c.js"]};/*]]>*/</script><script src="/jkube/polyfill-e4957c11759bdfc149d9.js" nomodule=""></script><script src="/jkube/component---src-pages-quickstarts-index-jsx-8b53e5455e208a3e59b9.js" async=""></script><script src="/jkube/commons-ee34cd715ab4f7da30e0.js" async=""></script><script src="/jkube/styles-e9d24b1846c7d6eb9685.js" async=""></script><script src="/jkube/app-59faa9989d677dd59195.js" async=""></script><script src="/jkube/framework-5e01c8af6b1735c9eaa3.js" async=""></script><script src="/jkube/webpack-runtime-20c402a54de81cfc0620.js" async=""></script></body></html>
\ No newline at end of file
