Fabric8 Developer Platform

This project generates the distribution of the fabric8 developer platform

To install the early access of this on Minishift check out the installation guide

Fabric8 Platform Overview

From version 4.x onwards of the fabric8 platform there are a core set of shared services which are shared by all users then a set of services created for each user/team which we refer to as tenant services.

Shared Services

• fabric8-ui provides the HTML / CSS / JavaScript from end using Angular and PatternFly to the system
• keycloak KeyCloak manages SSO
• fabric8-tenant manages installing and upgrading tenant services as users login etc
• fabric8-wit Work Item Tracker (database and REST API for spaces, work items etc)
• forge via the backend and forge addon implements wizards for new projects or import projects etc. Reuses the RHOAR quickstarts and uses the fabric8-jenkinsfiles-library to add pipelines for CI / CD to projects.

when installing on premise we also use these microservices:

• exposecontroller exposes services as public URLs on kubernetes or openshift clusters via various strategies (Route, Ingress, NodePort, LoadBalancer) depending on the cluster and injects public URLs into ConfigMaps
• configmapcontroller automates rolling upgrades as ConfigMaps are changed (either by users or via the exposecontroller

Tenant Services

Each user/team can get their own Jenkins, Che and Content Repository.

Our Jenkins image includes the jenkins sync plugin and kubernetes-pipeline-plugin along with the fabric8-pipeline-library

Other components

• fabric8-platform creates the various distributions (openshift + kubernetes manifests, templates etc)
• gofabric8 is a go based CLI tool for installing and managing fabric8

Changes in 4.x

Version 4.x of fabric8 differs a little bit from previous 3.x releases as follows:

• a separation between shared services (like KeyCloak and the console) from tenant services (each tenant (user/team) gets its own jenkins master)
• SSO is enabled on Kubernetes and OpenShift for using the console, Jenkins and GitHub (with more services coming soon)
• defaults to using GitHub as the git hosting OOTB; we're hoping to add gogs/gitea/gitlab back soon as soon as the SSO is working
• integrated issue tracker / kanban board / planning / work item tracking
• integrated IDE via eclipse Che
• integrated analytics to help developers get insight into their code and libraries and versions they are using or should consider
• new improved UI which covers project plannning, creation, analytics, editing/debugging, CI/CD

Github Organisations

There are lots of github repositories which make up the full platform!

To make things easier to navigate we've created a few different organisations to contain the various parts of fabric8:

• fabric8-analytics the Fabric8 Analytics projects
• fabric8-ide the Fabric8 IDE projects (e.g. Eclipse Che related repos)
• fabric8-quickstarts the fabric8 community quickstarts
• fabric8-services various Services used in the fabric8 platform
• fabric8io-images various docker images
• fabric8-ui contains all the HTML / CSS / JavaScript / Angular modules to create the web console for fabric8: fabric8-ui
• fabric8io general purpose organisation contains various things like the Java kubernetes-client, fabric8-maven-plugin, jenkins pipeline libraries but also numerous other things. Longer term stuff from here should probably move to more focussed organisations

Detailed List of Projects

The fabric8 developer platform is based on lots of different open source projects. Here's the main repositories:

Maven Tooling

• fabric8-maven-plugin provides Apache Maven support for Kubernetes, OpenShift and Fabric8

Developer Console

Version 4.x or later

The new shiny Angular console is here fabric8-ui along with a bunch of other NPM modules in the fabric8-ui organisation

The new console works directly with

• kubernetes/openshift REST API for kubernetes/openshift resources
• fabric8-wit for spaces and issue tracking
• forge for new/import project wizards via the backend and forge addon

Version 3.x and earlier

The angular JS 1.x version of the Developer Console is made up of:

• fabric8-console the web console for fabric8
• fabric8-forge contains the main JBoss Forge addons and REST service which provides developer wizards to create and edit projects

CI / CD

• fabric8-pipeline-library provides a set of reusable Jenkins Pipeline steps and functions that you can reuse inside your Jenkinsfile via the @Library annotation
• fabric8-jenkinsfiles-library provides a set of reusable Jenkinsfile files you can use on your projects. The Jenkisnfiles resue the [fabric8-pipeline-library](https://github.com/fabric8io/fabric8-pipeline-library and they are used by the Developer Console when creating projects or choosing pipelines.
• kubernetes-plugin is the Jenkins plugin which adds native Kubernetes support for defining build slave pods with custom pods, images, volumes and secrets. Its reused by the fabric8-jenkinsfiles-library
• kubernetes-pipeline-plugin contains additional Jenkins Pipeline steps for working with fabric8

DevOps

• fabric8-devops contains the main DevOps microservices for the Developer Platform

iPaaS

• fabric8-ipaas contains the main iPaaS applications
• ipaas-quickstarts contains the quickstarts and archetypes for the iPaaS

kubeflix

• kubeflix provides Kubernetes integration with Netflix OSS like Hystrix, Ribbon and Turbine

Tools

• gofabric8 is a go based CLI tool for installing and managing fabric8

Suppport for non-docker

Some folks have work loads they need to orchestrate on operating systems that don't yet have production quality docker support (e.g. Windows, AIX, Solaris, HPUX).

• kansible lets you orchestrate operating system processes on Windows or any Unix in the same way as you orchestrate your Docker containers with Kubernetes by using Ansible to provision the software onto hosts and Kubernetes to orchestrate the processes and the containers in a single system

Java Libraries

If you want to write any Java/JVM based tools to interact with Kubernetes we have a number of libraries to help:

Kubernetes

Kubernetes provides the main REST API for working with the Kubernetes Platform. It should provide all you need for writing most services and plugins for Kubernetes.

• kubernetes-model the Java DTOs for working with kubernetes and OpenShift which are generated from the go source code in kubernetes and OpenShift

• kubernetes-client provides a Java API for working with the Kubernetes and OpenShift REST API (pods, replication controllers, services etc)

• fabric8 contains the main java libraries such as:

• kubernetes-api provides helper APIs around the kubernetes-client for working with Kubernetes and OpenShift

• kubernetes-jolokia makes it easy to work with the Jolokia Client API and Java containers running in Pods inside Kubernetes which expose the Jolokia port

Testing

• fabric8-arquillian provides a plugin for Arquillian for integration testing Apps on top of Kubernetes; using Kubernetes to provision and orchestrate the containers and then making assertions that the required resources startup correctly.
• fabric8-selenium provides a library to make it easier to create Selenium WebDriver based integration and system tests on Kubernetes using fabric8-arquillian
• kubernetes-assertions provides a set of assertj assertions of the form assertThat(kubernetesResource) for working with the kubernetes-api
• jolokia-assertions makes it easy to perform assertions on remote JVMs via JMX using Jolokia over HTTP/JSON

 Spring

• spring-cloud-kubernetes provides Kubernetes integration with Spring Cloud
• kubernetes-zipkin provides Kubernetes integration with Zipkin for tracing microservices

ActiveMQ

• mq-client provides the the io.fabric8.mq.core.MQConnectionFactory class which implements the JMS ConnectionFactory to connect to Apache ActiveMQ Artemis using the Kubernetes Service discovery mechanism which requires no user configuration (other than a single environment variable if you wish to switch to a non default service implementation)

Camel

• camel-amq provides the Camel amq: component which uses the Kubernetes Service discovery mechanism to discover and connect to the ActiveMQ Artemis brokers so that no configuration is required (other than a single environment variable if you wish to switch to a non default service implementation)

• camel-master provides the Camel master: component which provides a locking mechanism to ensure that only one pod implements a consumer at any time; if that pod dies then another one takes over.

CDI

• fabric8-cdi provides an easy way to work with Kubernetes services using the CDI Dependency Injection approach
• fabric8-apt provides an APT code generator to create a JSON Schema file for each environment variable injected by the @ConfigProperty annotation from deltaspike - giving dteails of the name, type, default value and description. This can then be used by the fabric8:json maven goal to list all of the environment variables and their

DevOps

• fabric8-devops-connector provides a Java library for connecting the various DevOps services like git hosting, chat, issue tracking and jenkins for a project reusing the optional fabric8.yml file

 Git Repos

• gitrepo-api provides a Java API for working with git repositories such as gogs or github

 Hubot

• hubot-api provides a Java API for working with the Hubot chat bot for sending notifications to chat services like Lets Chat, IRC, Slack, HipChat and Campfire

 Letschat

• letschat-api provides a Java API for working with the Let's Chat to auto-create rooms etc.

 Taiga

• taiga-api provides a Java API for working with the Taiga issue tracker / kanban / scrum management system

Additional projects

The web console uses many different hawtio 2 modules. In particular the main dependency of is hawtio-kubernetes

Docker images

There are numerous docker images created via separate github repositories such as the following:

• docker-gerrit
• docker-grafana
• docker-gogs
• docker-prometheus
• nexus-docker
• hubot-irc
• hubot-lets-chat
• hubot-slack
• fabric8-eclipse-orion
• fabric8-kiwiirc
• jenkins-docker
• lets-chat
• taiga-docker
• openshift-auth-proxy

Base images

The above-packaged docker images leverage some of these base Docker images:

Java Alpine Linux

• docker.io/fabric8/java-alpine-openjdk8-jdk
• docker.io/fabric8/java-alpine-openjdk8-jre
• docker.io/fabric8/java-alpine-openjdk7-jdk
• docker.io/fabric8/java-alpine-openjdk7-jre

Java Centos Linux

• docker.io/fabric8/java-centos-openjdk8-jdk
• docker.io/fabric8/java-centos-openjdk8-jre
• docker.io/fabric8/java-centos-openjdk7-jdk
• docker.io/fabric8/java-centos-openjdk7-jre

JBoss

• docker.io/fabric8/java-jboss-openjdk8-jdk

Jetty

• docker.io/fabric8/jetty-9
• docker.io/fabric8/jetty-8

Karaf

• docker.io/fabric8/karaf-2.4
• docker.io/fabric8/karaf-3.0

Tomcat

• docker.io/fabric8/tomcat-8.0
• docker.io/fabric8/tomcat-7.0

s2i

• docker.io/fabric8/s2i-java
• docker.io/fabric8/s2i-karaf

v 4.x pre-release development

Steps to run the in development 4.x fabric8-platform using the latest mnishift please see the new Install Guide

Here's the old way we were installing it via gofabric8:

minishift  start --vm-driver=xhyve --memory=6144 --cpus=4 --disk-size=50g --openshift-version=v3.6.0-alpha.1
minishift openshift config set --patch '{"corsAllowedOrigins": [".*"]}'
oc new-project fabric8
git clone https://github.com/fabric8io/fabric8-platform.git
cd fabric8-platform
mvn clean install -DskipTests=true
gofabric8 deploy --package=packages/fabric8-system/target/classes/META-INF/fabric8/openshift.yml

Pods may be restarted a few times whilst configuration is updated and applied.

Once all pods are seen running with oc get pods

NOTE these next steps will be automated soon

Apply manual step as an admin user:

oc login -u system:admin
cat <<EOF | oc create -f -
kind: OAuthClient
apiVersion: v1
metadata:
  name: fabric8-online-platform
secret: fabric8
redirectURIs:
- "https://$(oc get route keycloak -o jsonpath="{.spec.host}")/auth/realms/fabric8/broker/openshift-v3/endpoint"
grantMethod: prompt
EOF
oc adm policy add-cluster-role-to-user cluster-admin system:serviceaccount:fabric8:init-tenant
oc login -u developer -p developer

Configure Keycloak

We now have GitHub integration which for now requires a manual OAuth setup to obtain a clientid and secret that we will give to keycloak. Follow these steps using the output of:

echo https://$(oc get route keycloak -o jsonpath="{.spec.host}")/auth/realms/fabric8/broker/github/endpoint

as the Authorization callback URL and http://fabric8.io as a sample homepage URL.

https://developer.github.com/apps/building-integrations/setting-up-and-registering-oauth-apps/registering-oauth-apps/

open https://$(oc get route keycloak -o jsonpath="{.spec.host}")

Log in with username admin and password admin

Now in Keycloak navigate to the GitHub Identity Provider and edit now you can replace the Client ID and Secret with the values you get from the GitHub setup above.