Workshop: 12 Factor Apps Workshop
- Understand the properties and limitations of Twelve-Factor Applications.
- Work with a real microservice based system consisting of multiple services that implement Twelve-Factor principles in different programming languages.
- Get insights how such applications can be managed with Kubernetes.
- Learn about patterns and tools to overcome the most serious limitation of Twelve-Factor: statelessness.
- Experiment with a distributed, stateful service using such a pattern, to experience possible failure modes and learn how to fix them.
- WiFi-enabled laptop with SSH client.
- Basic knowledge of Docker and Linux. S
- ome programming experience in the field of web applications.
The principles behind "Twelve-Factor Apps" are considered good practices or even requirements to develop software for Platform-as-a-Service (PaaS) environments, and lately for container based platforms, such as Kubernetes.
Notable principles include:
- execution as stateless processes with no direct access to the host's file system
- disposable processes that can be started and stopped at any time
- scale out by launching additional, identical processes
- strict separation between configuration and code
- strict separation between build and run stages with no changes to code at runtime
The most restrictive principle is the requirement of stateless processes, as the underlying platforms may preempt your application processes and re-start them elsewhere at any time. This leads to anything stored in a processes memory or the local filesystem being lost. Therefore, anything resembling a database is off-limits. Common advice is using 3rd party services to store state, such as the Database-as-a-Service (DBaaS) offerings of major cloud providers. This, however, comes with some major downsides:
- You can't replicate the full system for local development.
- You might be locked into the managed service of your cloud vendor.
- Your technology of choice might not be supported, like modern graph databases or new search engines.
In this workshop, we will first discuss how the original Twelve-Factor principles came about and how they have evolved in times of "Cloud Native" application development. We then work with a real microservice based system, consisting of multiple services that were developed following these principles. You will see the different approaches used in various programming language (Go, Node.js and Java). As we work with those services, you'll also learn how to interact with a Kubernetes cluster to deploy and update them. For this, we use the OpenSource "Socks-Shop" Microservice Reference application.
In the second part of the workshop, we will cover various approaches to run stateful applications on container based platforms. We'll specifically look into the "Autopilot Pattern" and "StatefulSets" of Kubernetes, but also glance over other approaches. In the hands-on part, we'll enhance one stateful service to run in a distributed, fault-tolerant way. We then try to break it to experience different failure modes and see if it can recover on it's own.
We finish the workshop with a brief outlook to "Serverless" (or "Function-as-a-Service"), which is sometimes touted as evolutionary step after Twelve-Factor. We look into options to build "Serverless" platforms on top of Kubernetes (instead of using the well-known cloud offerings from Amazon and Google) and launch a simple Function into our workshop clusters.
Hands-on vs. Lecture: 70% / 30%
Architecting for Failure
Building fault tolerate systems that are truly resilient
Architectures You've Always Wondered about
QCon classic track. You know the names. Hear their lessons and challenges.
Modern Distributed Architectures
Migrating, deploying, and realizing modern cloud architecture.
Fast & Furious: Ad Serving, Finance, & Performance
Learn some of the tips and technicals of high speed, low latency systems in Ad Serving and Finance
Java - Performance, Patterns and Predictions
Skills embracing the evolution of Java (multi-core, cloud, modularity) and reenforcing core platform fundamentals (performance, concurrency, ubiquity).
Performance myths that need busting and the tools & techniques to get there
Dark Code: The Legacy/Tech Debt Dilemma
How do you evolve your code and modernize your architecture when you're stuck with part legacy code and technical debt? Lessons from the trenches.
Modern CS in the Real World
Applied, practical, & real-world dive into industry adoption of modern CS ideas
Modern Learning Systems
Real world use of the latest machine learning technologies in production environments
Containers - State Of The Art
What is the state of the art, what's next, & other interesting questions on containers.
Data Engineering : Where the Rubber meets the Road in Data Science
Science does not imply engineering. Engineering tools and techniques for Data Scientists
Observability Done Right: Automating Insight & Software Telemetry
Tools, practices, and methods to know what your system is doing
Practical Cryptography & Blockchains: Beyond the Hype
Looking past the hype of blockchain technologies, alternate title: Weaselfree Cryptography & Blockchain
Workhorse Languages, Not Called Java
Workhorse languages not called Java.
Security: Lessons Learned From Being Pwned
How Attackers Think. Penetration testing techniques, exploits, toolsets, and skills of software hackers
Engineering Culture @ <insert cool company names here>
Culture, Organization Structure, Modern Agile War Stories
Softskills: Essential Skills for Developers
Skills for the developer in the workplace