This talk will walk through Kubernetes’ current capabilities for persistent storage, including Volumes and PersistentVolumes and the various drivers. It will look closely at how common SQL and NoSQL databases, such as PostgreSQL and MongoDB for example, can work on a Kubernetes cluster. We will highlight the good and the not so good in these solutions and importantly look to the future with in-flight and proposed developments in the project.

One common approach for multi-tenant networking is to deploy a virtual network using VXLAN overlays and an SDN controller. VXLAN segmentation provides the isolation necessary for network multi-tenancy and enables policy based security and traffic management. However, building and managing overlay virtual networks is complex and introduces a number of difficult operational challenges.

In this session, we introduce Romana, a new open source SDN solution that lets operators build Cloud Native Networks without the complexity of virtual network overlays. Romana networks provide multi-tenancy directly on the physical network, which makes them easier to operate and perform better than overlay virtual networks.

We will also show Kubernetes with multi-tenant networks and how to apply network security policies using CNI and the new NetworkPolicy Third Party Resource in Kubernetes 1.2.

From there, we’ll look at a real world use case, where a small team went through the process of deploying a production service on AWS (full disclosure: it was one of our own internal product teams). At the time, we had limited exposure to the Kubernetes deployment process. We’ll give you a “behind the scenes” look into our team’s journey.

Our initial use case was simple: build a few microservices backed by Amazon Relational Database Services (RDS), and run them on Kubernetes. Our goal was to have the ability to run the cluster in any environment, from Amazon, Google and Microsoft public clouds; developer laptops; and dedicated on-premise deployments.

Join this session to learn how to make Kubernetes deployment easier - plus a few fun (potentially embarrassing!) stories as we made our way through the Kubernetes production experience.

We will conclude the talk by discussing various challenges one can come across when contributing to a high velocity OSS project of Kubernetes' size which can help you avoid the pain and enjoy the path.

This talk will describe how rkt works, some of the features that make it unique as a container runtime, and some of the process of integrating an alternative container runtime with Kubernetes, as well as the latest state of "rktnetes."Introduction to rkt, including special/unique features

At Appsembler, we offer customers a fully managed and supported Open edX stack, all the way from the frontend web application to the backend services like ElasticSearch, MySQL, and MongoDB. With so many moving parts, we have come to realize the value of a multi-container, microservices-oriented architecture using Kubernetes. In contrast to a single-container deployment of the Open edX stack, a Kubernetes-based approach allows us to scale different services independently; improves robustness since we can simply spin up new copies of containers if they go down; and results in improved security through greater segmentation and isolation. In addition to discussing these benefits, we'll also cover Kubernetes’ integration with Google Cloud services like Cloud SQL and Cloud Logging.

Our previous experience with infrastructure may be a familiar one: an unruly number of virtual machines, which led us to containers. Containers give our web developers who are not infrastructure engineers the opportunity to configure and launch their applications with little oversight.

Kubernetes offers us an infrastructure for our numerous applications at scale. Leveraging the Kubernetes API, we’ve built a self-service admin interface for developers (not sysadmins) to configure and launch their applications at scale, similar to the Kubernetes Dashboard project, tailored to our development workflow.

We built a Kubernetes cluster in an AWS group which auto-scales based on load. We used replication controllers to process the data. Every three hours ingestion jobs are added to a queue and the number of ingestion containers are set in proportion to the queue length. Each worker completes exactly one ingestion job from the queue and then exits, at which point Kubernetes creates a new one to process the next message. This has allowed us to remove the lifespan logic from the containers and keep them light, fast and massively scalable. We are now in the process of using this in our production systems.

We are using a version of GitHub Flow for our development process. That means all new features goes in a branch, someone opens a pull request and we merge continuously from master into the feature branch. When we have something that is ready to deploy to a server we trigger a deploy of the branch to a test environment. When the new feature gets verified it gets deployed to production, gets verified again, and then merged back into master. This workflow enables us to maintain a clean master branch so we can roll back in case something fails.

In this demo-driven presentation, Luca will cover the current state of the art of container and microservice monitoring, including the pros and cons of some popular approaches. Using real tools running in live environments, he will demonstrate how to effectively monitor, explore and troubleshoot highly scaled containerized environments, while leveraging the metadata provided by Kubernetes and GKE.

The presentation will feature live interaction with a Kubernetes-orchestrated container environment and live demos of all tools and techniques discussed. Special emphasis will be put on sysdig, an open source container and system troubleshooting tool developed by the presenter.

This presentation will cover Apcera's journey in its container instrumentation. Beginning with the pre-Docker landscape, how it grew over the course of 3+ years, and the "next-gen" adaption of it, where the base container instrumentation has been adapted to stand as its own open source project, and growing it to be used beyond just Apcera's own usage.

Kurma incorporates a lot of lessons learned with both development and operations of a container platform, including building modular vs monolith, extensibility being built in vs built on, and managing a cluster of hosts and containers.

We'll also cover our experiences with introducing it to Kubernetes as another first class runtime provider. Taking how Kurma works and have it work with Kubernetes, and how we'd like to see Kubernetes grow in some of the areas we see Kurma growing.

In this panel, the community managers and project leads will discuss how to contribute to their Kubenetes work streams, their road maps and explain why you should work on their work streams.

Kubernetes works well for everyone, from individual developers to the largest companies in the cloud space. Kubernetes has an active global community of contributors, and a myriad of areas in which you can contribute. There are also dozens of projects that upstream Kubernetes who lean on features and functions to deliver value adds.

In this panel, the community managers and project leads will discuss how to contribute to their Kubenetes work streams, their road maps and explain why you should work on their work streams.

Panelists will join from Google, Juniper Networks, OpenStack Foundation, OpenShift (Red Hat) and DEIS (Engine Yard).

This represents the story to date of an in-flight engineering project to modernise the digital estate of a global enterprise organisation and how scale of the operation is leading us to challenge many established beliefs. Attendees will walk away with everything from workflows to code which they can use to get started in their own endeavors.

We will share whole concept and architecture of SmartCity project, which covers deployment of more than 3000 endpoints, both sensoric and reactive devices, and about 30 smart gateways running in HA mode on Kubernetes Nodes.

During this presentation, the author of the Job resource in Kubernetes will guide you through several techniques for performing anything ranging from simple Pi calculations to rendering a movie. No matter if you're a data scientist running large scale calculations across several data centers or a hobby programmer running simple day-to-day tasks, this presentation is to teach you how to efficiently use Kubernetes Jobs on their own or as the building blocks of something bigger.

This presentation will feature a number of live demos to help illustrate the various ways that you can put Jobs to work. Don’t miss out on learning about one of the coolest features of Kubernetes!

At the UK Home Office, we run Kubernetes in production. This talk is about how we got there, where we came from, where we are right now and where do we want to go from here. We will also cover what things worked out and which things didn't.

From on-boarding projects into Kubernetes to continous delivery, this talk will give you a good understanding of what lies ahead if you decided to take the road to schedule containers in production.

This presentation will describe the integration of trusted computing technologies into Kubernetes, making it possible to define policies that provide fine-grained access control to cluster resources and distribute secrets in a secure manner. It will then introduce functionality added to the rkt runtime, making it possible to extend trusted computing from initial system state to validation of individual containers.

I’ll start with brief overview of the pieces of Kubernetes needed (rc, manifest, etc) and a running cluster as a prerequisite. I’ll show off a simple go app with a web server. I’ll add a /healthz endpoint, build and push my image to a registry. I’ll reference my new image in the manifest. I will then deploy my manifest into my cluster to create a pod. I’ll show the audience how to talk to my /healthz endpoint. I’ll then go back and introduce the liveness probe and put the liveness probe definition into the manifest, delete my existing rc, re-deploy my new manifest, and show off the logs for the pod confirming that the health check is being performed at the specified intervals.

Let's look at real world examples of various visual Kubernetes tools and see if we can draw common patterns and ideas, merge them with our own experiences and help provide the development team the feedback they need to deliver an amazing application.

This talk will be hands on at command line, using open source tools and include anecdotes from real world experience.

Along with making it easier to efficiently use server hardware, Kubernetes has created a standardized deployment model that makes it easy to control and get interesting information about your cluster. Metrics about the containers in the cluster such as how many are running, where they are running, how much CPU and memory they consume, and progress on rolling updates or deployments are all possible using the API. At the same time, new developments in IoT and easy to use prototyping kits have opened up new possibilities for interesting hardware based interfaces. In this talk we’ll combine Kubernetes with hardware in interesting ways to provide useful visualizations and controls for your container clusters and have a lot of fun on the way! We will discuss how the Kubernetes API standardizes deployment and thus opens up new possibilities in terms of applications. Then we’ll demonstrate a number of interactive & engaging hardware devices that make use of the Kubernetes API. Finally, we’ll look at how we used the API and discuss the possibilities for other kinds of software and hardware based apps.