Matthias Haeussler
Chief Technologist at Novatec
Stuttgart, Germany
Actions
Matthias Haeussler is Chief Technologist at Novatec Consulting, university lecturer for distributed systems, awarded ambassador of Cloud Foundry and the organizer of the Stuttgart Cloud Foundry Meetup. He advises clients on Cloud strategies and supports implementations and migrations. Prior to that he was employed at IBM R&D Germany for more than 15 years. He has teaching experience from lectures at multiple universities in Stuttgart (DHBW, HSE, HfT). Besides that he is frequent speaker at various national and international conferences and meetups. (e.g. Spring One Platform, Open Source Summit, Cloud Foundry Summit, Spring IO, IBM InterConnect, WJAX).
Awards
Area of Expertise
Topics
Howto: Options Galore to Get from Source Code to Container
A typical workflow in a modern software dev project can look like: Build code, put built artifact into container image, put container image into registry, 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 standardisation.
Dockerfiles seems to be the choice with the highest adoption when it comes to containerizing code artifacts. However there are options, which might remove some of the pitfalls and standardize the entire process even more.
The talk will give deeper insights by comparing (multi-stage) Dockerfiles to Cloud-Native Buildpacks (buildpacks.io/paketo.io) and Google’s JIB under the evaluation criteria of build time, build size, standardisation, robustness and security. The examples and live demo will have certain focus on Java-based frameworks (Spring Boot, Quarkus, Java EE), but coverage of other languages will also be included and highlighted.
The intended take-away of the session is a better overview of container building and deployment options along with understanding of requirements, advantages and drawbacks.
What's going on in my cluster?
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 in and around the cluster can be challenging. How can you quickly and easily tell if the cluster is healthy, well utilised and if all applications are running fine?
This talk intends to look at the various aspects of Kubernetes observability and to introduce and compares multiple Open Source tools to achieve that. The range of tools covers different observability levels and requirements of different user groups.
It starts with tools simply querying the Kubernetes API and delivering the outputs in an easy-to-understand UI, goes over the possibilities of services meshes and ends with application-side logging and monitoring. For each level of observability the user has to pay a certain price in terms of configuration and runtime overhead. In turn the quality and depth of the information is different.
The intended take-away is to get a feeling which type of tooling is the right one for a given purpose. The options will be mostly demonstrated in a live demonstration.
Distributed applications and Kubernetes: Better off with frameworks, service meshes or both
Software Development based on a distributed (microservice) architecture provides both several advantages and new challenges.
In order to take advantage of the distribution it requires implementation of service discovery, routing, load-balancing, resilience mechanisms and more.
Java frameworks like Micronaut, Quarkus or Spring Boot provide dedicated implementations for API Gateways, Service Registries, Circuit Breakers and many more.
These functionalities are declared as code dependencies and need to be set at build time.
If the architecture is running on top of Kubernetes there are alternative options to address these problems.
So-called service mesh implementations do not have to be part of the actual application code, but can happen on a the network level of the container.
A fairly new approach is emerging with the eBPF technology, which claims to enable service meshes with minimal overhead.
With this talk I want to compare the approaches to figure out if one, the other or a combination of them might make sense.
The talk is split into a theoretical and a live-demo part.
Please note that Sessionize is not responsible for the accuracy or validity of the data provided by speakers. If you suspect this profile to be fake or spam, please let us know.
Jump to top