This talk focuses on architectural changes and new tools we should adopt to be able to tackle the problems presented by a demand for modern, responsive, fault tolerant and elastic systems. It is based on the material published in The DevOps 2.1 Toolkit: Building, testing, deploying, and monitoring services inside Docker Swarm clusters.

Viktor will share with you the whole microservices development lifecycle. He'll start from the very beginning and define and design architecture. From there on you'll move from requirements, technological choices and development environment setup, through coding and testing all the way until the final deployment to production. Viktor won’t stop there. Once your new services are up and running you’ll learn how to maintain them, scale them depending on resource utilization and response time, and recover them in case of failures. You’ll try to balance the need for creative manual work and the need to automate as much of the process as possible.

The goal is to design a fully automated continuous deployment (CDP) pipeline. You will learn how microservices fit into CDP and immutable containers concepts and why the best results are obtained when those three are combined into one unique framework.

Kubernetes, with its API-driven design, is the latest in a series of technological advancements bringing us ever closer to the vision of fully automated infrastructure. Kubernetes Operators, or the automation of operational knowledge atop Kubernetes, represents a bold and ambitious attempt to automate that which was previously in the heads of high "bus-factor" SysAdmins: operating stateful services. In this talk Luke will introduce the concept of Kubernetes Operators, discuss the various patterns found in the wild for their implementation, and show how one may be built in Golang.

How do you survive a cloud provider outage? In this talk you will look at a pattern to deploy a single cluster across multiple cloud providers giving you the ultimate high availability. You will learn how you can leverage the power of HashiCorp's Nomad to run a single cluster across multiple cloud providers and how Vault can keep your application secure.

Cloud provider outages are rare but the do occur, by the end of this presentation you will learn that it is a simple process to avoid these outages and how you can make your application cluster implement the ultimate in high availability.

This presentation will be part live demonstration and part technical theory, Nic will share how to build a multi-cloud cluster live on stage and demonstrate that when a cloud provider fails, the cluster continues to serve your workload.

With the proliferation of container orchestrators and people comparing and evaluating them for fitness concerning the workloads they wish to run on them, one topic has so far been neglected: benchmarking. When Michael was still at Mesosphere, they started a project called 'Cloud Native Benchmarking Group' with the goal to provide a vendor-neutral benchmark for cloud native systems. Now, at Red Hat, the work continues.

The first of these benchmark focuses on orchestrators (see the initial work here: https://github.com/cnbm/container-orchestration) and in this talk Michael will talk about design considerations for the benchmark, how to make it modular and extensible and he will also share the challenges involved establishing a benchmark in an objective manner. Initial talks with the CNCF were positive, so they hope once the benchmark is completed (in mid 2017) and other parties start contributing to it that it will find a home in the CNCF.

Containers are bordering on mainstream for building and deploying, but running containers in production at scale is still a challenge. One of the main adoption barriers is the lack of production grade storage, especially for enterprise.

Traditional enterprise storage is inflexible, expensive and hard to manage and automate. In this presentation, you’ll learn about alternatives for container storage and how to evaluate them for your production needs.

There’s no such thing as a “stateless” architecture. It’s just somebody else’s problem.

Istio is an open platform to connect, manage, and secure microservices.

As monolithic applications transition towards a distributed microservice architecture they become more difficult to manage and understand. These architectures need basic necessities such as discovery, load balancing, failure recovery, metrics and monitoring, and more complex operational requirements such as A/B testing, canary releases, rate limiting, access control, and end-to-end authentication. The term 'service mesh' is used to describe the network of microservices that make up applications and the interactions between them.

As the service mesh grows in size and complexity, it becomes harder to understand and manage. Learn how Lyft, IBM and Google have teamed up to solve this problem.

Rancher, the leading open source complete container management platform, is focusing on Kubernetes management and user experience in the upcoming 2.0 release. Shannon Williams, co-founder of Rancher, will talk through and demo how this will enable organisations to easily deploy and manage multiple Kubernetes clusters.

In this Lightning Talk Stuart will share with you a live demo on Drone.io.

Anil has been working on unikernels and related technologies for a few years now, and wanted to deliver a broader update on how adoption has been going in the last couple of years. Unikernels have been successfully integrated into the fabric of some popular systems -- most notably Docker for Desktop -- and are also usable out of the box in the new LinuxKit distribution. Anil will share with you their efforts to make server-side unikernels really easy to use out of the box in LinuxKit, including the new Solo5/UKVM hypervisor that lets them be managed just like normal containers. Anil will also discuss their emergence in the ARM space as the most viable way to deploy a trusted fabric of computing for the next trillion embedded devices.

Implementing a continuous delivery (CD) pipeline is not trivial, and the introduction of container technology to the development stack can introduce additional challenges and requirements. In this talk you will look at the high-level steps that are essential for creating an effective pipeline for creating and deploying containerized applications.

Topic covered include:

• The impact of containers on CD
• Adding metadata to container images
• Validating NFR changes imposed by executing Java applications within a container
• Lessons learned the hard way (in production)

A supporting O'Reilly report "Containerizing Continuous Delivery in Java" will also be available, and this contains instructions and code for how to create a Jenkins-based continuous delivery pipeline that takes a series of Java applications and containerizes them, ready for functional and nonfunctional testing, and ultimately, deployment.

Modern microservices architectures are awesome for developers, but the demands it places upon the network are also greatly increased - it needs to scale further, be more dynamic, and more finely secured. Matt will share how these complex meshes of services can be connected simply, while maintaining the security needed to protect your users and data.

You will learn about evolving overlay / underlay requirements, the newly GA in Kubernetes 1.7 v1 NetworkPolicy API, and how Istio complements and can automate elements of your container network.

Matt will look at examples from real world user case studies and a live demo, sharing how anyone - not just network geeks - can easily manage, secure and scale their Kubernetes network.

First, containers radically changed how you could get visibility into your applications. As developers have started to leverage orchestration systems on top of containers, the game is changing yet again. What was a simple application on a host before is now a sophisticated, dynamically orchestrated, multi-container architecture. It’s amazing for development - but introduces a whole new set of challenges for monitoring.

In this talk you will lay out a few key principles for monitoring microservices and the containers they are based on. These principles are based on Jorge's experience, but also leverage the wisdom of hundreds of organizations that are currently monitoring microservices with Docker and orchestrators like Kubernetes and DC/OS.

Jorge will address issues such as: Do host-based metrics matter any more? If so, when? What techniques can be used to extract application data from inside containers? How do you resolve tricky issues like greedy containers? When can you leverage orchestrator metadata to solve problems? How do you alert on elastic services that are growing and shrinking on-demand?

You’ll walk away with a good understanding of the challenges of monitoring microservices and how you can set your team up for success. During this talk Jorge will also share open source tools you can use that are designed to monitor and troubleshoot your microservices.

Containers are the next model of compute, after VMs and bare metal. And you all know containers are here to stay. They're the leaner, faster and more portable alternative, and one day every app will run in a container. Containers will be ubiquitous because of the wide range of problems they solve, and the huge ecosystem that's making the solutions.

The core concepts in container platforms are all open - the image and runtime specifications, the registry, the engines and the orchestrators. The promise of portability makes containers a safe choice for the next generation of software delivery. Companies are making that choice and investing in containers for everything from legacy apps to new cloud-native projects.

At Docker they work with major enterprises on their container adoption programs, and they see five major use cases. Elton will walk through each of the use cases, showing and sharing with you the type of problems containers solve, and the value they bring. And you'll see that those use cases cover pretty much every activity in the software industry, which is why containers will take over the world.

Running compute clusters at a low hardware utilization is wasteful. Oversubscription of resources promises to increase utilization, but can be pretty challenging in the presence of tight latency objectives. Fortunately, there seems to be a feasible middle ground.

In this talk, Stephan will explore the Apache Mesos oversubscription primitives and how they leverage them in a simple threshold-based solution. Stephan will explain why this approach works for him and his team and what they have learned so far. In order to provide sufficient context, the talk will also shortly discuss Linux cgroups and relevant service-level monitoring signals.

As their code is open-source, Stephan and his team hope that others can immediately profit from their work and cut down your hardware spending as well.

With the rise of DevOps, containers are at the brink of becoming a pervasive technology in Enterprise IT to accelerate application delivery for the business. When it comes to adopting containers in the enterprise, Security is the highest adoption barrier. Is your organization ready to address the security risks with containers for your DevOps environment?

In this presentation, you'll learn about:

• The top security risks with containers and how to manage theses risks at scale including Images, Builds, Registry, Deployment, Hosts, Network, Storage, APIs, Monitoring/Logging, Federation.
• How to make your Container enabled DevOps workflow more secure without slowing down your CI/CD pipeline
• Automating security vulnerability management and compliance checking for container images

Also, Chris will share with you a demo of Kubernetes managing the container image lifecycle, automating container security scans, and deployment strategies for security updates at scale including Canary, Blue/Green deployments and A/B testing.

This session will provide insights into implementing API Management: what is API Management, why is it important for Microservices, how to Implement, what Devops tooling is needed, and key learnings to use on your own projects.

A lot of talks will tell you how to setup systems correctly. This talk is about what not to do with your Cluster.

Jörg will share with you some of his favorite/scariest support stories covering typical system-setup, configuration, and application pitfalls for new (and not-so-new) Mesos and DC/OS operators. And he will give you some hints about how to debug those pitfalls if you do encounter them, resulting in fewer nightmares.