Fabric8 Maven Plugin

The fabric8-maven-plugin includes several default generators that examine your build information to automatically generate Docker build configurations on the fly. Each generator is designed for specific application types and can be configured using generator-specific options.

Available default generators include:

• Java Applications (java-exec): Generic generator for flat classpath and fat-jar Java applications.
• Spring Boot (spring-boot): Specific generator for Spring Boot applications.
• Wildfly Swarm (wildfly-swarm): Generator for Wildfly Swarm apps.
• Thorntail v2 (thorntail-v2): Generator for Thorntail v2 apps.
• Vert.x (vertx): Generator for Vert.x applications.
• Karaf (karaf): Generator for Karaf based apps.
• Web applications (webapps): Generator for WAR based applications supporting Tomcat, Jetty, and Wildfly base images.
• Open Liberty (webapps): Generator for Open Liberty applications.

Resource Fragments allow you to use standard Kubernetes/OpenShift YAML files located in src/main/fabric8. The plugin enriches these files with build metadata (like image names and labels) and combines them into a single deployment manifest.

Key behaviors:

• Automatic Kind derivation: The Kind of the resource is derived from the filename (e.g., deployment.yml becomes a Deployment).
• Automatic Metadata: You do not need to provide a metadata section; the plugin adds it automatically.
• Naming: If you name a file myapp-deployment.yml, the resource name will be myapp. Otherwise, it defaults to the Maven artifactId.
• Sidecars: To ensure a container is treated as a sidecar rather than being merged into the main application container, ensure it has a unique name or override the default main container name using the fabric8.generator.alias property.

# src/main/fabric8/deployment.yml
spec:
  replicas: 1
  template:
    spec:
      volumes:
        - name: config
          gitRepo:
            repository: 'https://github.com/jstrachan/sample-springboot-config.git'
            revision: 667ee4db6bc842b127825351e5c9bae5a4fb2147
            directory: .
      containers:
        - volumeMounts:
            - name: config
              mountPath: /app/config
          env:
            - name: KUBERNETES_NAMESPACE
              valueFrom:
                fieldRef:
                  apiVersion: v1
                  fieldPath: metadata.namespace
        serviceAccount: ribbon

Profiles are named combinations of generators and enrichers defined in YAML. They allow you to bundle specific resource generation and enrichment logic under a single referable name, making it easy to apply consistent configurations to your Kubernetes/OpenShift resources.

Key components of a profile include:

• name: The unique identifier for the profile. You can extend predefined profiles by using the same name.
• generator: Defines which generators to use to create resources.
• enricher: Defines which enrichers to use to modify or add to existing resources.
• order: An integer used to resolve conflicts when multiple profiles with the same name are merged. Higher order takes precedence.
• extends: (Optional) Allows a profile to inherit generators and enrichers from another profile to avoid repetition.

- name: my-spring-boot-apps
  generator:
    includes:
      - spring-boot
  enricher:
    includes:
      - fmp-controller
      - fmp-service
    excludes:
      - f8-icon
    config:
      fmp-service:
        type: NodePort
  order: 10

The fabric8-maven-plugin provides two extension mechanisms to customize the creation of Docker images and Kubernetes resource descriptors:

Generators

Generators are used to automatically create or customize image configurations during Docker image creation. They function similarly to Spring Boot Generator POMs: they can be enabled or disabled by declaring a Maven dependency.

Generators can inspect the build environment to detect specific features (for example, determining if a build is a Spring Boot application or a plain WAR file). Based on this detection, they can automatically select base images or configure exposed ports for the image build configuration. Generators are primarily intended for Zero-Config use cases.

Enrichers

Enrichers are used to customize Kubernetes resource descriptors. They can add build metadata as labels or automatically create resources like ReplicaSet or Service based on the image configuration.

Like Generators, Enrichers can be toggled via Maven dependencies or XML configuration. Unlike Generators, Enrichers are useful across all configuration variants, not just Zero-Config setups.

The java-exec generator is a generic generator used to start arbitrary Java applications within a container. It supports two primary deployment patterns:

1. Fat-jar applications: A single JAR containing the application and all dependencies, with a Main-Class entry in META-INF/MANIFEST.MF.
2. Flat classpath applications: A main class is explicitly provided, and the image includes the application JAR plus all separate dependency JARs.

Main Class Detection Logic

If you do not explicitly configure the mainClass option, the generator follows this priority:

1. Fat-jar detection: It looks for a JAR file with a Main-Class in its manifest. If multiple exist, the largest one is selected.
2. Automatic scanning: If no fat-jar is found, it scans target/classes for exactly one class containing public static void main(String args[]). If zero or multiple classes are found, the generator does nothing.
3. Explicit configuration: If you provide the mainClass option, the generator skips detection and builds a flat classpath image containing the application and its dependencies.

Including Additional Files

You can add custom files to the generated image by placing them in the following directory structure:

• src/main/fabric8-includes: Files placed here are added with mode 0644.
• src/main/fabric8-includes/bin: Files placed here are added with mode 0755 (executable).