So for anyone following the fabric8 videos, blogs or old tweets I just wanted to mention that I’ve not been at Red Hat or worked on fabric8 in a year and instead have been working on Jenkins X instead — automated CI/CD for any kubernetes cluster — and so far its way way more awesome than fabric8 ever was!

e.g. Jenkins X supports many clouds and platforms (such as on Google, Amazon, Azure, OpenShift, Pivotal, IBM Cloud) has pluggable build packs and integrated Preview Environments and DevPods!

Meanwhile fabric8 as an OSS CI/CD platform has been effectively dead for over a year — its a little cryptic but you can see from the home page — message ‘gofabric8 is now sandboxed’ basically means there’s no longer a way to install fabric8 as a CI/CD platform ;).

The core team behind fabric8 left Red Hat a year ago to join CloudBees and work on Jenkins X.

There are still some sub projects within fabric8 that have not been archived like the fabric8-maven-plugin but mostly fabric8 is now a dead OSS project.

So if you want an OSS project that does automated CI/CD for any kubernetes cluster (such as on Google, Amazon, Azure, OpenShift, Pivotal, IBM Cloud etc) with automated GitOps promotion through your environments and Preview Environments on your Pull Requests then please do checkout Jenkins X. Its awesome!

Since joining CloudBees at the end of last year we’ve been working on an automated CI/CD solution for Kubernetes called: Jenkins X.

You can check out the introduction blog post for more background.

Our aim is basically:

• to automate CI/CD for folks on Kubernetes or the cloud so they can focus on developing apps and not worry about Docker, kubernetes YAML, helm charts, managing/configuring Jenkins or writing Jenkins pipelines, promotion/GitOps or setting up environments. Effectively turning any kubernetes cluster with Jenkins X installed into a serverless style platform; just add code, get CI/CD and GitOps promotion — then win ;)
• reimagine the Jenkins that most of us all know and use as a more cloud native and kubernetes native set of microservices with elasticity, no SPOF and Custom Resources all the way down

I’ve just come back from KubeCon which was totally amazing! I was lucky enough to get to present Jenkins X there:

we managed to fill one of the biggest rooms and folks were being turned away! (sorry about that, not my call!)

If you missed it you can watch the presentation yourself here:

If you happen to be going to DevOxx UK this week, in Islington, London (where I lived happily for 20 years), then I’ll be presenting Jenkins X there and I’ll get much more time to chat and demo. So if you’re around please pop by and say hello, I’d love to chat and get your feedback on what we’re doing & see how we can improve!

Otherwise come find us in the community and lets chat!

Let your naval, pipe smoking butler, Jenkins X, help you go faster with automated CI/CD on kubernetes and the cloud! Full speed ahead!

I’d like to say a big thank you to everyone at Red Hat, our customers and all the upstream communities I’ve had the pleasure to work with over the last decade or so. Its been great fun and we’ve all learnt a lot together.

I’ll blog again early in the new year to talk about my next journey. I’m super excited and can’t wait to get started, its going to be so much fun! 2018 is gonna be an amazing year & so much cool open source is coming soon…

Until then please have a lovely break over winter & I hope to see more of you on this blog in 2018 — cheers!

OpenShift.io is designed for developers who want to get started fast developing in the cloud with containers & kubernetes and it includes all the necessary tools such as planning, analytics, a web based IDE and full CI / CD. Whats even better is it comes with a completely free tier too ;).

As you can imagine we have lots of demand and its gonna take a while to onboard everyone. Please register now if you are interested; the earlier you register the quicker you’ll get in!

This video gives a quick sneak peek at how the CI and CD is completely integrated into a single pane of glass check out this video:

The video walks you through:

• creating a new project
• forking it
• submitting a PullRequest and triggering CI and reporting back to the PR
• once a merge to master happens the CD pipeline is triggered

We’re continuing to improve the features and UX; our aim is to make the entire lifecycle of development super slick and simple with lots of nice feedback.

Any thoughts or feedback please let us know by raising an issue. Thanks! Hope to see you on OpenShift.io soon!

OpenShift.io: fully integrated CI / CD in a single pane of glass was originally published in fabric8 io on Medium, where people are continuing the conversation by highlighting and responding to this story.

OpenShift.io is designed for developers who want to get started fast developing in the cloud with containers & kubernetes and it includes all the necessary tools such as planning, analytics, a web based IDE and full CI / CD. Whats even better is it comes with a completely free tier too ;).

As you can imagine we have lots of demand and its gonna take a while to onboard everyone. Please register now if you are interested; the earlier you register the quicker you’ll get in!

To give you a sneak peek at how the CI and CD is completely integrated into a single pane of glass check out this video:

For folks who want to try this out right now on their laptops using MiniShift we’re putting together a similar experience using the upstream fabric8 project. At Red Hat all products are open source and have an upstream open source project; fabric8 is the upstream open source project for everything at OpenShift.io.

Its taking us a little while to update the new 4.x version of the fabric8 distribution to include all the new OpenShift.io features as quite a few things have changed from a traditional fabric8 distribution. e.g. there’s a brand new web console developed in angular 4, a fully integrated planner/issue tracker, web based IDE (based on eclipse che), analytics and using KeyCloak for all SSO and unifying tokens between OpenShift clusters and github, separate tenant manager to spin up users/teams with their own Jenkins/Che etc).

However we have an early access install script for MiniShift you can try right now by following these instructions.

Warning its still early access; we’re hoping to get the install script more bullet proof and easier to use ASAP along with working on other OpenShift clusters and ultimately any kubernetes cluster too (thats gonna take a little more work but hopefully soon…).

Obviously its much easier to just use OpenShift.io as there’s no need to install anything; its all hosted and managed for you in the cloud! But if you want to try run the upstream open source bits on premise try these instructions.

Please do take it for a spin and let us know what you think. Any feedback please raise an issue! Thanks!

early access to the OpenShift.io experience on MiniShift using the upstream fabric8 was originally published in fabric8 io on Medium, where people are continuing the conversation by highlighting and responding to this story.

For those who missed it, here’s the video of my talk:

or you can browse the slides

fabric8 microservices and go faster at DevOxx was originally published in fabric8 io on Medium, where people are continuing the conversation by highlighting and responding to this story.

thoughts on CoreOS Operators

I’m particularly looking forward to a ZooKeeper Operator that works like CoreOS’s etcd operator so you can easily just scale up or down the size of your ZooKeeper cluster by changing 1 simple number via the CLI, REST API or UI and the operator figures out the detail of how to update quorum, services/DNS, state and so forth.

Though as an end user, I’d kinda like to have regular Kubernetes Deployment semantics for etcd or ZooKeeper pods and scale it in the usual way (e.g. via kubectl scale) and the Operator take over and wire up the cluster after the Deployment size changes — rather than scaling via changing the ThirdPartyResource for the Operator — then Kubernetes feels a bit more polymorphic and its easier for tools to work with all scalable Operators; but I realise that might be harder as the Operator may want to do things before the Deployment controller scales up; though could that be done with init containers?

Fabric8 Controllers

We’ve been using the term controllers in fabric8 rather than operators; but I thought I’d mention a few of the ones we’ve created to help us automatically configure and manage our microservices inside the fabric8 developer platform.

Here’s the controllers we’ve created so far:

expose controller

The expose controller takes care of exposing services externally which have the label:

expose=true

With the Kubernetes ecosystem there are various ways to expose services:

• Ingress on Kubernetes
• Routes on OpenShift (which pre-date Ingress and may be replaced long term by Ingress)
• LoadBalancer types on public cloud providers like GKE which then uses a cloud provider generated public IP (which adds cost)
• NodePort if developing on your laptop which uses ports on a host node to avoid needing DNS and/or a load balancer

So rather than hard coding your app to pick one of the above, we tend to make our microservices just use the expose=true label and run the expose controller microservice as part of fabric8.

Then when running on OpenShift we default to Routes; on Kubernetes to Ingress or on minikube or minishift we default to NodePorts as we avoid having to run routers, wildcard DNS and so forth (which can be flaky on laptops).

Another feature of expose controller is to inject into a ConfigMap external URLs to services. For example when you run a git hosting service like gogs or gitlab you need to tell it the public URL to the service so that its web application can tell you how to type in a git clone from your laptop. Also web consoles which want to use OAuth to log clients in need to know where the OAuth authorize URL is.

So expose controller can inject these values at runtime if the ConfigMap for an exposed service is annotated with the expose controller annotations.

configmap controller

One issue of using expose controller is that after an app is deployed, the external URL will change as, say, an Ingress is created, leading to a change in the ConfigMap for the app. However sometimes the values in the ConfigMap are used as environment variables so that the pod will be running with old configuration.

To fix this the configmap controller will automatically trigger a rolling update of the application whenever its ConfigMap changes.

This turns out to be really handy for any app that uses a ConfigMap to store configuration which is loaded on startup (rather than mounting the ConfigMap as a volume and then watching the file system for changes inside the pod).

To see this in action check out this spring boot web MVC application. It loads an application.properties from the ConfigMap by mounting it as a volume which spring boot then loads on startup. It reads this configuration on startup. So if we edit the ConfigMap (e.g. via the kubectl command line or via the fabric8 developer console) by default the app would keep running with the old configuration.

However if we add the configmap.fabric8.io/update-on-change annotation to the Deployment like this:

metadata:
  annotations:
    configmap.fabric8.io/update-on-change: "foo"

Then whenever the ConfigMap changes its configuration data, the configmap controller will update the Deployment to add/update an environment variable with the configuration contents which then triggers a rolling upgrade of your application! Neat eh!

git controller

The git controller is like the configmap controller but for when your Deployment is mounting a revision of a git repository into a volume — e.g. configuration files or CMS web content. The idea of the git controller is it will watch all the git repositories of all the git repositories used by your Deployments and if a git commit occurs in the branch of a repo, it will perform a rolling upgrade on the Deployment by pointing the git repository volume to the new commit version.

So its very much like the configmap controller but has the added benefit of having a change audit log, history and an easy way to revert changes.

summary

So those are the 3 controllers we’ve created so far on the fabric8 project. I’m sure we’ll create more as and when required.

One of the things I particularly love about kubernetes is it promotes a very unix like philosophy of creating lots of small microservices that solve particular problems; then they are super easy to compose and reuse across projects, languages and frameworks!

Have you created any custom controllers for kubernetes or thinking of any? Any controllers you wish you had? Let us know!

additional kubernetes controllers from fabric8 you can use with your microservice was originally published in fabric8 io on Medium, where people are continuing the conversation by highlighting and responding to this story.

Thankfully minikube has really helped make it easy to install fabric8 inside a single node kubernetes cluster on your laptop for Windows, OS X and Linux. Though there’s still the issue of how to install a real kubernetes cluster with fabric8 on a public cloud like AWS, Azure, Google Cloud or Digital Ocean.

Thats all now changed thanks to the nice folks at Stack Point Cloud.

Literally in a few clicks you can select the public cloud of your choice (AWS, Azure, Google Cloud or Digital Ocean), enter your credentials, pick your kubernetes cluster and hardware size, then select fabric8 as a solution and you’re done!

Here’s a video showing how super simple this is!!

Huge thanks to the Stack Point Cloud folks for doing this! Its really gonna help folks who want to use fabric8 on the public cloud get started super quickly and easily! Plus you can install a vanilla kubernetes cluster with Stack Point Cloud too or install other off the shelf solutions.

So what are you waiting for? Click here to spin up your own kubernetes cluster with fabric8 now!

the easiest way to get started with fabric8 on the public cloud is now StackPointCloud! was originally published in fabric8 io on Medium, where people are continuing the conversation by highlighting and responding to this story.

there’s some awesome icons there!

But for me there was a major missing icon — the fabric8 Microservices platform:

Why? Because it gives you an out of the box fully integrated Java Opinionated Container Stack (JOCS) in an easy to use package with a lovely developer console that provides a single pane of glass for all your tools.

So what’s included out of the box if you install the fabric8 Microservices platform?

• Kubernetes which is best container orchestration platform
• Docker as the most popular container runtime
• Jenkins for CI and CD pipelines
• Nexus as the artifact repository
• Gogs for on premise git repository hosting
• Developer console to provide a single pane of glass to both all of your development tools but also your projects, environments and apps
• JBoss Forge with the fabric8 forge addons for new project wizards and tools to import and migrate projects together with quickstarts for creating Java projects with Spring Boot, CDI or Wildfly Swarm
• A selection of additional optional microservices you can easily run for the Run.. button in the developer console such as Chaos Monkey, Hystrix Dashboard, centralised logging and metrics (Elasticsearch, Kibana, Prometheus, Grafana), Artifactory, Gitlab, Gerrit, Sonarqube, Kafka, Cassandra, Chatops tools and many other things.

e.g. here’s a small selection of some of the additional container based apps you can run in one click:

So isn’t that just a few of the icons from Arun’s picture? Yeah kinda. There are 2 big differences though:

• all the services are packaged and installed out of the box for you
• all the services are deeply integrated together.

So creating a new project will create a git repository in Gogs, wire the webhooks with Jenkins to trigger jobs on git push and all Jenkins build reuse the local Nexus as a proxy when building (so you have a nice nexus proxy cache) and all releases are staged or released into your Nexus with shared secrets.

i.e. there’s no need for you the Java developer to figure out how to download and install all of these tools, then try configure them to work together. They are all integrated for you OOTB!

So this isn’t just a bunch of off the shelf components; its a fully integrated and packaged platform!

How to get started

OK that sounds like an awesome way to go fast if you’re a Java developer and want a great JOCS. But how do you get started getting running fabric8 on your laptop?

Try this:

• download the latest binary of gofabric8 for your platform
• run the following command on a command line

./gofabric8 start

if you are not already connected to a kubernetes cluster it will download minikube and start that up — which installs a single VM cluster of kubernetes and docker running right on your laptop.

It may take a little while as its going to be downloading some command line tools (like kubectl), spinning up the kubernetes cluster and downloading a bunch of docker images. But eventually you should get the fabric8 developer console opened up in your browser!

You can watch the progress of how things are going with:

kubectl get pod -w

Now you should have all the JOCS up and running on your laptop ready to play with!

Want a create, build, test, stage and release a Java based Microservice? Sure just use the web console like this video:

Or are you more of a command line / maven type of developer? Thats cool too — check out this blog on how you can take any existing Java project and build, run, test and debug it all from maven

So there you have it — the easiest way to get an awesome Java Opinionated Container Stack (JOCS) running on your laptop!

Please give it a try and see how you get on. Any issues join the community and chat or email us or raise an issue.

In my next blog next week I’ll show you how to get an awesome Java Opinionated Container Stack (JOCS) running on any public cloud in a few clicks! Stay tuned!

How to run an awesome Java Opinionated Container Stack (JOCS) on your laptop was originally published in fabric8 io on Medium, where people are continuing the conversation by highlighting and responding to this story.

On the fabric8 project we’ve been focussed on making it easy for developers to create, build, deploy and manage microservices on top of Kubernetes for some time.

Up to now we’ve mostly focussed on the end to end lifecycle of creating new microservices, then changing code through continuous delivery then having continuous improvement. Lately we’ve been focussed more on the pre-git-push phase. Where you’re hacking code on your laptop and trying things out before you want to commit and push into your git repository.

Lots of Java developers are used to using application servers, creating deployment units (jars/wars), deploying them and running them in app servers using Maven. Then they can use Maven from the command line or easily inside their IDE to do most of the work.

So we figured, why not make Kubernetes look and feel like an application server to a Java developer? So you build and deploy your application from maven like you would with other maven plugins like spring-boot, tomcat, jetty, wildfly, karaf et al. Then you can get started quickly by just treating Kubernetes as a kind of application server.

Kubernetes is actually way more awesome than an application server; its more like an application cloud as:

• kubernetes can keep running multiple instances of each of your apps including automatic restarts on software or hardware failures
• automatic load balancing when invoking your apps
• each app instance is isolated as a separate process so its much easier to monitor metrics and logs

Setup your maven project

Do you have an existing maven project for your Java app? Maybe its a Spring Boot or WildFly Swarm app; or a flat classpath, fat jar? If you don’t have a maven app to hand, visit start.spring.io and create one.

To enable fabric8 on your project just type this fabric8:setup command which adds the fabric8-maven-plugin to your pom.xml like this example.

mvn io.fabric8:fabric8-maven-plugin:3.2.8:setup

Note that all the fabric8 quickstarts already have the fabric8 maven plugin enabled so you don’t need to do the above!

Now that we have enabled the fabric8 maven plugin for our project we can have some fun!

Starting and stopping a local kubernetes cluster

To develop on kubernetes you will need a kubernetes cluster; just like you need an instance of an application server to deploy your app. If someone in your organisation has provided you with a kubernetes cluster then feel free to use that; you just need to connect to it via the kubectl too.

However if you don’t have any kubernetes clusters to hand its very easy to spin up your own local cluster. Using a local kubernetes cluster is really handy for development; it lets you build your app and run it locally before you do a git commit and trigger the CI / CD pipeline.

Before you start please make sure you have the prerequisites installed for your platform (basically a recent Apache Maven distro and have a working hypervisor for your platform like xhyve, hyper-v or kvm).

Now with the fabric8-maven-plugin you just use the goal fabric8:cluster-start to spin up a local cluster:

mvn fabric8:cluster-start

Wait a few minutes for some stuff to download and then you’ve now got a local installation of a Kubernetes cluster running on your machine! No installation of Docker, VirtualBox or Vagrant is required!

Under the covers this downloaded gofabric8 and ran gofabric8 start which then downloaded minikube and kubectl binaries and installs them into ~/.fabric8/bin

Want to use OpenShift instead of Kubernetes? Use this command instead:

mvn fabric8:cluster-start -Dfabric8.cluster.kind=openshift

You can now use the kubectl command line to get pods and whatnot:

kubectl get pod

When you’re done and want to stop the kubernetes cluster just use fabric8:cluster-stop

mvn fabric8:cluster-stop

you can restart it again at any time via fabric8:cluster-start

Running your app

The simplest way to run your app is via fabric8:run

mvn fabric8:run

This will build your app (compile code, run tests, generate the jar and package it up into an immutable docker image), generate the kubernetes manifest and deploy it then tail the log output so you can see how your app behaves. If you hit Ctrl-C it then terminates the app.

So that the fabric8:run goal works kinda like other run goals in other maven projects like spring-boot, tomcat, jetty, karaf and wildfly.

Deploy or undeploy your app

Deploying your app is a little like running fabric8:run in the background.

To deploy your app into kubernetes you use the fabric8:deploy goal

mvn fabric8:deploy

This will build your java code and run your unit tests, generate the docker image, create the kubernetes manifest and deploy them into kubernetes.

To remove our app from kubernetes just use the fabric8:undeploy goal

mvn fabric8:undeploy

Viewing logs

Once you’ve deployed your app you probably want to check its logs. So you can type:

mvn fabric8:log

then hit Ctrl-C to terminate tailing the log.

If you don’t want to keep tailing the log and just want to see the current log output try this:

mvn fabric8:log -Dfabric8.log.follow=false

Start and stop

If you have deployed your app you sometimes want to stop it running so that you can later on start it again. e.g. since its using up resources on your laptop or its invoking some other microservice that you wish to take offline.

To stop your application just use the fabric8:stop and fabric8:start goal:

mvn fabric8:stop

…

mvn fabric8:start

All the fabric8:start and fabric8:stop goals do is to scale your application on Kubernetes — as in set the number of expected replicas — the number of running processes of your app.

You can also use fabric8:start to scale up your app to more than one pod if you wish

mvn fabric8:start -Dfabric8.replicas=2

You can also use the kubectl command line too:

kubectl scale — replicas=2 deployment myappname

Debugging

Outside of unit tests we highly recommend you try and run your apps and do all your integration and system testing inside Kubernetes. Then you are spending most of your time using a production-like environment (rather than your laptop with its different operating system, networks and storage etc). It also means you can easily deploy multiple microservices into the same namespace and test combinations of microservices easily.

To debug your app, just run the fabric8:debug goal

mvn fabric8:debug

This will use the default Java remote debugging port of 5005. You can specify a different port if you wish

mvn fabric8:debug -Dfabric8.debug.port=8000

Once that goal is running the debug port will be open on your laptop (localhost) which then connects using port forwarding to your most recent running pod for your app.

So you can now just start a Remote debug execution in your IDE (like you do to debug remote application server instances) and you can set breakpoints and debug your pod while its inside kubernetes.

e.g. in IntelliJ here’s how you add a Run/Debug execution:

To see this in action check out the video below.

Continuous Delivery and Releasing

Once you are ready to start releasing your code run this command:

mvn fabric8:import

This will import your local project into fabric8.

If your code is not already hosted in a git repository it will create a new git repository and import your code. Then it’ll show you a link to open the project in the fabric8 console so you can add a Continuous Delivery pipeline to your project to enable a Jenkins build for full CI / CD

Demo

To see all of these maven goals in action check out this short video:

Summary

So once you’ve started a cluster (cluster-start) the fabric8 maven goals are very similar to other application server based maven plugins; run, deploy/undeploy, start/stop are the main goals with log and debug pretty handy too.

Once you are familiar with those and you’ve done some development on kubernetes with the fabric8 maven plugin you might start to try out using the kubectl tool also which is handy for querying or watching the state of kubernetes, performing updates to them. e.g. to watch pods start and stop type:

kubectl get pod -w

Please try out the fabric8 maven plugin and let us know what you think via the community or the issue tracker! Can you think of any way to make it even more awesome? If so let us know!

A busy Java developers guide to developing microservices on Kubernetes and docker was originally published in fabric8 io on Medium, where people are continuing the conversation by highlighting and responding to this story.