Speaker Details

Matthias Haeussler
Novatec Consulting GmbH
Matthias Haeussler is Chief Technologist at Novatec Consulting, university lecturer for modern software architecture and distributed systems, awarded ambassador of Cloud Foundry and the organizer of the Stuttgart Cloud Foundry Meetup. He advises and enables clients on their cloud-native journey, supports implementations and legacy migrations. Prior to that he was employed at IBM R&D Germany for more than 15 years. He has teaching experience from various client trainings and lectures at mulitple universities in Stuttgart (DHBW, HSE, HfT). Besides that he is frequent speaker at various national and international conferences and meetups. (e.g. KubeCon, Devoxx, OSS Summit, Cloud Foundry Summit, Spring IO).
Understanding Kubernetes can be hard. Not only in the initial learning and understanding of the concepts, but also the aspect of keeping an overview of what is happening inside at the workloads of the cluster can be challenging.
How can you quickly and easily tell if your apps are healthy, well utilised and running fine?
Observability is an essential component in software development in general. With the change to cloud-native/microservice approaches on the one hand and the runtime with containers and Kubernetes on the other has even increased the necessity and complexity.
In this deep dive, we'll look at various aspects of Kubernetes observability, and present multiple OSS solutions from the CNCF landscape and beyond to achieve that.
We will start with tools simply querying the Kubernetes API and delivering the outputs in an easy-to-understand UI (e.g. Skooner, k9s), go over sidecar-based and eBPF-based services meshes (e.g. Istio/Kiali, Cilium/Hubble UI) and end with application-side logging, monitoring, and tracing (e.g. OpenTelemetry, fluentd, Jaeger, Grafana).
Each level of observability demands a certain price in terms of configuration and runtime overhead. In turn, the quality and depth of the information is different. We will also provide a dedicated section about the generic roles of Prometheus and Grafana in this context.
The major part of this deep dive will be live demonstrated. This does not only include the usage, but also the setup and configuration of the tools.
The intended take-away is to get a feeling of which type of tooling is the right one for a given purpose. Some of the technologies have a polyglot aspect and can be applied independent of the framework, but the talk has a strong focus on JVM-based applications.
A typical workflow in a modern software dev project often looks like: Build code, put the built artifact into a container image, put the container image into a registry and deploy to Kubernetes. Each step has it’s own requirements and pitfalls alike. The overall goal is most often to bake those steps into easily repeatable pipelines and enable a high degree of automation and standardization.
Dockerfiles seems to be the choice with the highest adoption when it comes to containerizing code artefacts. However most Dockerfiles (and also most sample's of Dockerfiles you find in tutorials) do not exploit it to the full potential.
There are a lot of improvements to be done in how to build and optimize for Java-based applications.
The talk will give deeper insights by comparing (simple and multi-stage) Dockerfiles to Cloud-Native Buildpacks (buildpacks.io/paketo.io), Google’s JIB and Source2Image under the evaluation criteria of build time, build size, standardization, robustness, memory configuration and security. The examples and live demo will have certain focus on Java-based frameworks (Spring Boot, Quarkus, Micronaut), but coverage of other languages will also be included and highlighted.
The intended take-away of the session is a better overview of Open Source technologies for container building and deployment options along with understanding of requirements, advantages and drawbacks.