She will explain things done well, how the cloudnative microservice is piece by piece moved to serverless by Strangler and Branch by Abstraction patterns, as well as how Event sourcing did help when they turned more applications to serverless. You will also learn about how network design, api manager, and general understanding of serverless offerings are so important that people may ignore them. Ebru will share her experience/lessons learned so you don’t have to repeat them.

One recommended model to successfully implement DevOps in your environment leverages GitOps and Infrastructure as Code. This session is focused on how one of Andrew's teams have leveraged this model and what a powerful impact it has had. You will discover and discuss the goals of the team, what problems they had before implementing this model, then the framework of what they implemented and operational model. Digital transformation through GitOps and Infrastructure as Code has been successful. They have seen:

• Improved collaboration, resulting in means less friction. • Ops team configures software and apps rapidly and more reliably • Reduced Errors • Dev produces higher-quality code that can be tested more often and released to production faster

During this talk you will:

• Understand the context and problem k8s is trying to solve
• Learn the basic building blocks and features of k8s
• Receive a list of resources to start your own journey with k8s

If you want your software to do the right things and correctly, you need to test it implacably.

The big problem is that companies see the testing phase as the bottleneck of the process, slowing down product release (which it is). To change that, there needs to be a new way of testing applications, making the release process a testing process as well, and involve everyone within the team from the beginning. QAs are not a separate team anymore (DevTestOps).

How does this affect the testing pyramid? In this session, you will discover and explore several techniques that you can use immediately following the session to start testing in production and speeding up your release cycle to unimaginable limits.

Of course, none of the benefits of microservices come without a cost. Networks are unreliable, and correlating thousands or millions of log entries between services can quickly become unmanageable. Therefore, understanding the source of an issue can be like finding a needle in a haystack. This is where distributed tracing comes in! Distributed tracing is the process of tracking requests through their lifetime within a complex distributed system, and has become a critical tool for debugging and understanding microservices.

In this session you will, explore the basics of distributed tracing, take a look at the OpenTracing standard (a vendor neutral framework for distributed tracing instrumentation) and finally be guided through a hands-on look at distributed tracing in action using Jaeger, a popular open source distributed tracing tool which is part of the Cloud Native Computing Foundation. By the end of this session you will not only have a good understanding of distributed tracing, but will be equipped with the knowledge and inspiration to introduce it within your own applications.

It's become a common practice in the microservice world to rely on log statements to identify if a piece of code is behaving as intended. But tools are coming out to make it easier to add breakpoints and debug running code in a Kubernetes Pod. In this session, you will explore an overview of some of the tools that make it easy to debug applications running in Kubernetes. You'll cover a few tools used to update the code that's running in a Pod (Draft/Skaffold/Ksync). And you'll also cover how to connect your IDE to the code and set breakpoints (with examples using both IntelliJ & VS Code).

However, it is not exactly that straight forward and in this session you will discover the development of Elastic's container strategy over time:

• Docker images: A new distribution model.
• Docker Compose: Local demos and a little more.
• Helm Chart: Going from demo to production.
• Kubernetes Operator: Full control with upgrades, scaling,...

Besides the strategy, you will also explore specific technical details and hurdles that appeared during the development. Or why the future will be a combination of Helm Chart and Operator (for now).

Learn how to explain Docker to your grandma through the story of Geeno: Geeno is a world famous Italian chef that’s often called to work in kitchens around the globe. Doing that he’s seen it all: poor conditions, different tools, different spoken languages. He’s had enough now and he wants to find a way to bring his laboratory wherever he goes. If you don’t know what Docker is you’ll get an explanation in plain English, and if you know already you may have a laugh at Geeno’s misadventures.

By leveraging well established event-driven microservice design principles and applying them to serverless functions you can build a homogenous ecosystem to run FaaS applications. Kafka’s natural ability to store and replay events means serverless functions can not only be replayed, but they can also be used to choreograph call chains or driven using orchestration. Kafka also means you can democratize and organize FaaS environments in a way that scales across the enterprise. Underpinning this mantra is the use of Cloud Events by the CNCF serverless working group (of which Confluent is an active member).

In his own words, he described the toaster as a partial success because “for about five seconds, the toaster toasted, but then unfortunately, the elements kind of melted itself”. He is right in the sense that his audacious attempt won him fame and attention, and his TED talk was viewed more than 1M times. But judging his creation on its own, it’s an abject failure that was 300 time more expensive than a commercial toaster, took too long to build and was utterly unfit for purpose.

As a business that is competing in an increasingly competitive world enabled by advancements in technology, the questions we should be asking ourselves are: “what are the business value, cost and risk in building our own infrastructure vs using a managed service?”. In this session, you will take an objective look at the ongoing debate of containers vs serverless and explore the arguments of control vs responsibility, vendor lock-in and more!

This session will focus on Kubeflow Pipelines, a platform to enable end-to-end orchestration of ML pipelines as well as easy experimentation and re-use. You'll learn how to build and manage machine learning workloads that can scale.

In DC/OS, the DC/OS commons SDK enables anyone to build service automation for DC/OS using just a declarative spec in most cases. The Kudo project can now leverage this set of automation expertise to enable automated creation of operators for Kubernetes. In this session, Matt will introduce the Kudo project, explore the conceptual similarities between Mesos frameworks and Kubernetes operators, and demo the creation of a Kubernetes operator using Kudo.

Service mesh implementations from open-source communities like Istio, Linkerd, and Consul have left us spoilt for choice. Sam Newman has defined “cloud native applications” as those applications that leverage the capabilities of the cloud-native platforms on which they’re deployed. So what happens if you deploy to a Kubernetes-based platform on-premises and leverage Istio for your service mesh, but also deploy to AWS infrastructure (including EKS) for your public-cloud solution? AWS has an out-of-the box service mesh called App Mesh so should you just leverage that? In this session, you will look at the harsh reality of solving service-to-service communication between services, between clusters, and potentially between platforms/clouds and how things like security, observability, and routing can be accomplished in this hybrid environment.

With Kubernetes emerging as the de facto standard for service orchestration, discussion is shifting from 'How does Kubernetes work?' to more specific concerns such as 'How do I achieve an optimal development workflow?' The answer lies in finding combinations of tools that work together in synergy. They should produce end to end workflows that perform effectively in the real world, while also covering a wide range of development stages—building, deploying, debugging, and so on. Goal in mind, let's dive into the tooling available in the current landscape—tools such as Helm, Draft, Skaffold, Forge, Telepresence, Garden, and Tilt. Ellen will share with you their capabilities to developer needs, then outline workflows you can use in practice right away.

Developed by Netifi in collaboration with Netflix, Facebook, Pivotal, Alibaba and others, RSocket combines messaging, stream processing and observability in a single, lightweight solution that provides the connectivity needed for today’s web, mobile and IoT applications. Unlike older technologies such as REST or gRPC, RSocket is equally adept at handling service calls as well as high-throughput streaming data and is at home in the datacenter as well as in the cloud, browsers and mobile/IoT devices.

In this session you will learn how Netifi is using RSocket to simplify the way enterprises architect for the cloud, enabling enterprise developers to build and operate complex networks of services with performance improvements of up to 400% and cost reductions of up to 90% compared to legacy technology.

During this Lightning Talk Pierre will share with you how they learnt on how relying on a global discovery can leverage new ways of uncoupling infrastructure from code. They call this Inversion of control: all the organization can now push and retrieve semantics to create new services easily:

• DNS/network provisioning

• Automatic weighted Load-Balancing

• Automatic alerting

• Security Scanners

• New cross-applications features

This new way of creating semantics free the SRE as well as the whole company from tools and allow the whole organization be be more agile and innovative.

Emma and her Team have calculated 31.4 trillion digits of Pi in 2019 and broke the world record in the Pi computation. The process took about four months and 200 TiB of storage. Record-breaking Pi calculations have traditionally been done on supercomputers and special-made hardware, but they did it on Cloud for the first time. This talk will explore the nature of the calculation, the architecture, challenges and techniques, and of course the brief history of Pi computation. Calculating Pi has been Emma's childhood dream and she will also share with you how the small dream grew to the new world record.

In this session, Ádám will share his story of how he helped create an enterprise-wide Cloud Native CI/CD platform for a highly regulated company in Germany. The failures, the successes, the decisions taken and the final result - a secure, multi-cluster, Openshift-based platform serving hundreds of developers every day. Assembled from opensource components, it’s flexible architecture can be reproduced and modified for use at any company.

The solution is a social responsibility project in AWS and has to be available all the time, cost effective, fast and most of all work at huge scale.

An API Gateway can decouple applications from external consumers, by routing ingress requests from end-users and third-parties to various internal applications, and by providing cross-cutting functionality like authentication, encryption, and rate limiting. A service mesh can decouple applications from internal consumers by dynamically routing inter-datacenter and service-to-service requests, regardless of where they are exposed on the network. The core concepts behind an API gateway and service mesh are not new, but the combination of current user requirements and modern cloud native technologies provide new constraints and new opportunities.

Join this session to:

• Learn the difference between using an API gateway for handling ingress, "north-south" traffic, and a service mesh for managing service-to-service, "east-west", traffic
• Understand how these technologies could be used within application modernisation programs, the trade-offs with deploying them, and when not to use a service mesh
• Explore how these technologies impact application architecture (such as the use of the sidecar pattern), and get an overview of the networking cross-functional requirements that these technologies provide
• Explore how the open source Envoy Proxy project has driven massive innovation within this space, and understand how it differs from existing proxies
• Gain a high-level overview of technology options currently available
• Watch a brief demo of the open source Ambassador API gateway and Consul service mesh being configured to work together in collaboration using a simple Kubernetes-based application

When your organisation has a lot of history, making changes to embrace new practices can be hard. Cloud adoption and DevOps can’t be successful with automation and technical tooling alone; it requires changes in how people work together and communicate. Ordnance Survey is an organisation with more history than most, with over 228 years of mapping for Great Britain. Join Andy and Phil to learn about Ordnance Survey's successes, failures, and lessons learned on the journey so far, focusing on how they began the journey and how they have supported changes to practices and processes. In this session, Andy and Phil will talk about the approach they have taken, and their experiences . Hear about the internal consultancy, the formation of their Common Engineering team, their cloud native approach, and their tooling that makes the DX of DevOps better.

Takeaways * An understanding of design patterns in relation to building and deploying Cloud Native systems * An understanding of where each pattern maps to the different elements of Cloud Native systems * Patterns and their relationship to strategic formulation and design * An understanding of success (and failure) at companies that succeed with Cloud Native and are not unicorns

The complexity in complex distributed systems isn’t in the code, it’s between the services or functions. And a lot of failures are hard to predict and maybe even hard to detect.

When your system is made up of multiple microservices or a bunch of lambdas and some queues, how do you know whether it’s working the way you think it should?

Quality in these systems isn’t so much about testing up front: if you’re releasing 20 times a day, you can’t pay the cost of running full regression tests every time. You need to have a risk-based approach and focus your testing effort on the things where it really matters. And more importantly, you need to be able to quickly find out when things are going wrong, and quickly fix them.

Your production system is the only place the full complexity comes into play, so you should be doing a lot of your quality work there. Make sure you can find out about problems as early as possible and do as much ‘testing’ here as you can.

During Sarah's keynote you will learn about:

• the importance of observability - building in log aggregation, metrics and tracing so you can tell what’s up
• business-focussed monitoring, including synthetic monitoring
• why documentation is important and how to encourage people to keep it up to date
• how chaos experiments help

You should go away knowing more about what it takes to make your complex distributed systems easier to build and to run with high quality and stability.