Jonathan Johnson
Software Architectures ★ Presenter ★ Kubernetes & Java Specialist
Actions
Jonathan Johnson is an independent software architect with a concentration on helping others unpack the riches in the cloud native and Kubernetes ecosystems.
Jonathan is halfway into his second score of engineering commercial software, driven by his desire to design helpful software to move us forward. His applications began with laboratory instrument software and managing its data. Jonathan was enticed by the advent of object-oriented design to develop personal banking software. Banking soon turned to the internet, and enterprise applications took off. Java exploded onto the scene, and since then he has inhabited that ecosystem. At 454 Life Sciences and Roche Diagnostics, Jonathan returned to laboratory software and leveraged Java-based state machines and enterprise services to manage the terabytes of data flowing out of DNA sequencing instruments. Then as a hands-on architect at Thermo Fisher Scientific, he applied the advantages of microservices, containers, and Kubernetes to their laboratory management platform.
Jonathan enjoys comparing and sharing his adventures with peers. He shares ways to modernize application architectures while adhering to the fundamentals of high modularity and low coupling.
Links
Understanding Kubernetes: Container Patterns
Prerequisite: If you are unfamiliar with Kubernetes be sure to attend: Understanding Kubernetes: Fundamentals
Aha moments with apps in containers can be quite liberating. The mobile space is saturated with "there's an app for that". For us, we now expect "there's a container for that". "Write once, run anywhere" (WORA) has changed to "Package once, run anywhere" (PORA). As the community of containers is riding up the hype curve we will look at some of those top aha moments together.
• Go rouge with Java 9+
• Polyglot microservices
• RabbitMQ broker in 2 minutes
• Private Docker hub in a container
• Composing a Pod with multiple containers
• Database flavors for integration testing
The epiphanies come from the modular simplicity. Leveraging namespaces and using cgroups, these apps share a common kernel without polluting the host OS. This simplifies installation, conflicts and uninstalls. The barriers to getting something running are decreased and normalized to a container run command. This is subtly powerful and liberating. With this simplicity comes complexity such as shared resources, file systems, mounts, networking, and overall cluster management.
Your software package delivery and installation is no longer an rpm, deb, dmg, jar, war, native executable or a run script, it is simply an image that has a common run container command.
Lastly, we will explore how containers can help and hurt your team if you are not careful. What goes into a container is a reflection of a team's skills. Should a team make each tech stack different, or should you standardize? External processes affect your tech stack choices inside your container such as static code analysis, code beautifiers, CI/CD, tracing, logging, and monitoring. Exercise caution as standardization and frameworks can lead to coupling. Your tech stack details can change from version to version so get your SemVer and API versioning right. Finally, containers can be a vehicle to introduce new technologies to those that are conservative and risk avoiders.
During the presentation, we will explore some example on Katacoda.
Understanding Kubernetes: Fundamentals
So you have some code and it is in a bounded context with a REST API. You are on your way to Microservices. Next you wrap it in a container and now it is an image that others can run. Simple. Now what? No service is an island. Your service needs to log information, needs to scale and load balance between its clones. Your service needs environment and metadata way outside its context. What about where the service will run? Who starts it? What monitors its health? What about antifragility? Updates? Networking? Oh my.
Services live in clusters and clusters live in data centers. Many concepts overlap with the features of cloud management. But don't get too flustered since, fundamentally, services are managed by clusters. There are several approaches to cluster management such as Docker Swarm, Mesos with Marathon and Kubernetes.
Minikube with Kubernetes is an approachable technique to set up a local cluster that is easy to understand and get started. Whether you have a simple service or a Web application with a set of services, you can develop much of it on Kubernetes with Minikube. We will run some practical examples. Once you understand the mechanics of the tools, we will explore how it works, sort through the terminology and share ideas about practical uses for this technology.
Afterward, you will understand how to run your personal cluster with your Linux, OS X or Windows laptop to further enjoy unraveling the mysteries of running applications in a cluster.
Kubernetes Operator Pattern
There are some straightforward and declarative techniques to request Kubernetes to run your applications. Typically, YAML declarations or Helm charts are sufficient to define your applications. Especially simple applications that are stateless. But more complex applications that are stateful, have persistence or change over time need a more dynamic management style. The Operator pattern has emerged as the way to control applications that not only run but also scale, backup, restore, adapt, update, and manage their more complex features.
One fundamental nature of Kubernetes is its extensibility. By leveraging Custom Resource Definitions (CRDs) and extending the controllers, the Operator pattern was born.
In this session, you will see how this pattern emerged. We will explore how the architecture works natively on Kubernetes. We will see numerous open-source Operators available for you to apply. There are a variety of ways to develop Operators to meet your business requirements. We will unpack the choices and advantages of the different development technique. The session will conclude by exploring a series of examples on how to write your custom Operators.
Learn how to extend Kubernetes with Operators to support the solutions for your business needs.
Embrace, extend and embellish. That whole extinguish thing was so 90s.
Meshing Around with Observability
Kubernetes is a complex container management system. Your application running in containers is also a complex system as it embraces the distributed architecture of highly modular and cohesive services. As these containers run, things may not always behave as smoothly as you hope. Embracing the notions of antifragility and designing a system to be resilient despite the realities of resource limitations, network failures, hardware failures, and failed software logic. All of this demands a robust monitoring system to open views into the behaviors and health of your applications running in a cluster.
Three important aspects to observe are log streams, tracing, and metrics.
In this session, we look at some example microservices running in containers on Kubernetes. We add Istio to the cluster for meshing. We observe how logs are gathered, We see transactions are traced and measured between services. We inspect metrics and finally add alerts when metrics are indicating a problem.
Understanding Kubernetes: Meshing Around with Istio
Kubernetes out of the box is a strong platform for running and coordinating large collections of services, containers, and applications. As is, Kubernetes is powerful for many solutions. Remember Underdog? He was a mild-mannered dog, but when stress and conflict were introduced to the plot he took a magic pill, he became a superhero. Istio is a superhero for Kubernetes.
Istio is an open, platform-independent service mesh that manages communications between services in a transparent way. With a distributed architecture many things can fail, slow down and become less secure. Istio provides solutions to those stresses in our plot toward this architecture style:
- Traffic management
- Observability
- Policy enforcement
- Service identity and security
We will explore these benefits with Istio through some working examples on Kubernetes. The key point is this meshing solution allows your code to be less coupled to the inherent weaknesses of a distributed platform.
Understanding Kubernetes: Serverless
Prerequisite: If you are unfamiliar with Kubernetes be sure to attend: Understanding Kubernetes: Fundamentals
From operating system on bare metal, to virtual machines on hypervisors, to containers orchestration platforms. How we run our code and bundle our applications continues to evolve. Serverless computing continuous our evolutionary path for our architectures.
Kubernetes provides an ideal, vendor-agnostic platform for serverless computing. Serverless promises to developers that we can worry less about the cluster and focus more on their logic. Based on your Kubernetes knowledge we will discover the various contributors of serverless frameworks on Kubernetes. Specifically, we will unpack how two open source serverless frameworks, Kubeless and OpenFaaS, leverage Kubernetes to achieve their promises. We will explore how Knative is helping the serverless providers evolve to the next levels sophistication.
Jonathan Johnson
Software Architectures ★ Presenter ★ Kubernetes & Java Specialist
Links
Actions
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