Loading…
This event has ended. View the official site or create your own event → Check it out
This event has ended. Create your own
View analytic

Sign up or log in to bookmark your favorites and sync them to your phone or calendar.

Thursday, March 10
 

08:30

Breakfast and Exhibit Hours
Thursday March 10, 2016 08:30 - 09:30
CodeNode ESC & Backspace

08:30

Registration
Thursday March 10, 2016 08:30 - 17:00
CodeNode ESC & Backspace

09:30

Day 1 Opening Keynote: Kubernetes Update
Speakers
avatar for Kelsey Hightower

Kelsey Hightower

Staff Developer Advocate, Google Cloud Platform, Google
Kelsey has worn every hat possible throughout his career in tech and enjoys leadership roles focused on making things happen and shipping software. Kelsey is a strong open source advocate focused on building simple tools that make people smile. When he is not slinging Go code you can catch him giving technical workshops covering everything from Programming to System Administration.


Thursday March 10, 2016 09:30 - 10:15
CodeNode - Ctrl 10 South Place, London, United Kingdom

10:15

Kubernetes State of the Union
Speakers
avatar for David Aronchick

David Aronchick

Senior Product Manager, Google
David Aronchick is a Senior Product Manager for the Google Container Engine, and leads product management on behalf of Google for Kubernetes. David has been helping to ship software for nearly 20 years, founding and being part of the management team for three different startups, as well as squeezing in time at Microsoft, Amazon, Chef, and now Google. |


Thursday March 10, 2016 10:15 - 10:45
CodeNode - Ctrl 10 South Place, London, United Kingdom

10:55

Kubernetes meets Finagle for Resilient Microservices
Abstract:
Finagle is an open-source, high-volume RPC client library, handling millions of QPS at companies like Twitter, Pinterest and Soundcloud. In this talk, we demonstrate how Finagle can be applied to Kubernetes applications via linkerd, an open-source, standalone Finagle proxy. By deploying linkerd as a sidecar container or with DaemonSets, we show how polyglot multi-service applications running in Kubernetes can be “wrapped” in Finagle’s operational model, adding connection pooling, load-balancing, failure detection, and failover mechanisms to existing applications with minimal code change. We demonstrate how linkerd communicates with the Kubernetes API and how the resulting systems perform under load and adverse conditions.

Outline:
  • Overview
  • Microservices on Kubernetes
  • Common problems at scale
  • Finagle's operational model
  • linkerd
  • Demotime!
  • Q&A

Speakers
avatar for Oliver Gould

Oliver Gould

CTO, Buoyant
Oliver is the CTO of Buoyant, where he leads open source development efforts. Prior to joining Buoyant, he was a staff infrastructure engineer at Twitter, where he was the technical lead of Observability, Traffic, and Configuration & Coordination teams, and helped the company migrate from a monolithic Rails application to a massively distributed microservice application running on Mesos. He is the creator of linkerd and a core contributor to... Read More →


Thursday March 10, 2016 10:55 - 11:35
CodeNode - Shift

10:55

Kubernetes and the Potential for Higher Level Interfaces
Abstract:
Kubernetes provides rock-solid APIs for building and running your distributed systems. Pods, Services and ReplicationControllers provide trustworthy and scalable abstractions that make solving real-world infrastructure problems simpler. But that doesn’t mean interacting with those low-level primitives will be the only option for developers and operators.

Outline:
  • Discuss why different user interfaces match different types of user or organisation
  • Show how Deis v2 uses Kubernetes, building a familiar imperative interface on top of the Kubernetes API
  • Explore the use of Puppet for managing Pods, Services and Replication Controllers in Kubernetes, and why a declarative language has its advantages over raw data
  • Look around at other opportunities for alternative interfaces like OpenShift, Helm and Fabric8, and explore the topic of interoperability

Speakers
avatar for Gareth Rushgrove

Gareth Rushgrove

Senior Software Engineer, Puppet Labs
Gareth Rushgrove is a senior software engineer at Puppet Labs. He works remotely from Cambridge, UK, building interesting tools for people to better manage infrastructure. Previously he worked for the UK Government Digital Service focused on infrastructure, operations and information security. When not working he can be found writing the Devops Weekly newsletter or hacking on software in new-fangled programming languages.


Thursday March 10, 2016 10:55 - 11:35
CodeNode - Alt Tab

10:55

Cloud Native SDN for Kubernetes
Abstract:
Today, Cloud Native applications have very simple network requirements: discoverable service endpoints with routable IP addresses. This allows Kubernetes to be deployed easily on any network, including public and private IaaS, and even across the Internet. However, as Kubernetes looks to introduce multi-tenancy, and as applications require more sophisticated access control and traffic management policies, network segmentation for isolation and traffic control will be necessary.

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.

Outline:
  • Introduction (1-2 mins)
  • Cloud Native SDN (8-10 mins)
  • Layer 3 tenancy model
  • Network isolation and multi-tenancy
  • Kubernetes 1.2 NetworkPolicy Objects
  • Demonstration (12-15 mins)
  • Multi-tenant Kubernetes
  • Applying Network Policy 
  • Service insertion

Speakers
avatar for Juergen Brendel

Juergen Brendel

Director of Engineering, Pani Networks
Juergen is Director of Engineering and co-founder at Pani Networks where he runs development of the Romana project. Prior to Pani Networks, Juergen was at Cisco working on OpenStack Neutron. Juergen joined Cisco through the acquisition of vCider a provider of virtual network overlay solutions for the public cloud where he was a co-founder. | | Juergen holds a number of patents in area of network server load balancing and virtual routing and... Read More →


Thursday March 10, 2016 10:55 - 11:35
CodeNode - Cmd

10:55

The State of State
Abstract:
A question many are now asking, especially with the increasing adoption of Kubernetes in the enterprise, is how to deal with state. Many containers can be ephemeral and immutable, but databases require persistence, it’s really pretty important!

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.

Outline:
  • Kubernetes current data volume capabilities:
  • Volume
  • PersistentVolume/PersistentVolumeClaim
  • Volume drivers (e.g. EBS, NFS, Flocker etc)
  • Status of running common database systems on Kubernetes - eg
  • Elasticsearch
  • PostgreSQL
  • Redis
  • MongoDB
  • MySQL
  • Summary of the workarounds and challenges
  • In-flight and proposed developments with volumes - and also wider capabilities for hosting distributed databases (ie leader election, pod hostnames/identity - petset/nominal services)

Speakers
avatar for Matthew Bates

Matthew Bates

Co-Founder, Jetstack
Matthew leads Engineering and Consulting for Jetstack. He has a background in solutions for the acquisition, management and exploitation of large-scale data, across industries including government, public sector and telco. HIs previous roles Solution Architect at MongoDB, and software engineering and consulting for consulting firms, and R&D for a major European telco. He writes Python, Go and Java software and has in the previous year been... Read More →


Thursday March 10, 2016 10:55 - 11:35
CodeNode - Ctrl 10 South Place, London, United Kingdom

11:45

What is OpenStack's role in a Kubernetes world?
Abstract:
OpenStack is a global open collaboration to produce an open source infrastructure stack. Since its creation 5 years ago, it moved from an open source compute / object storage IaaS solution to about 30 projects providing programmable infrastructure building blocks. How does this project fit in a container-driven future ? How complementary is it with Kubernetes ? In this talk, Thierry Carrez will detail the long-term vision for OpenStack: infrastructure for a programmable infrastructure world and an integration engine for future infrastructure technologies.

Outline:
  • History of the OpenStack project
  • The application developer top-down approach to infrastructure
  • The infrastructure provider bottom-up approach to infrastructure
  • The various ways of supporting containers and Kubernetes in OpenStack
  • The results of the OpenStack/Kubernetes collaboration
  • Why would you go through the hassle of OpenStack to do Kubernetes ?
  • OpenStack as an integration engine for infrastructure technologies to come

Speakers
avatar for Thierry Carrez

Thierry Carrez

Director of Engineering, OpenStack Foundation
Thierry Carrez is the Director of Engineering at the OpenStack Foundation, helping ensure the long-term health of the OpenStack upstream open source project. He has been the Release Manager for the OpenStack project since its inception, coordinating the effort and facilitating collaboration between contributors. He is the elected chair of the OpenStack Technical Committee, which is in charge of the technical direction of the project.


Thursday March 10, 2016 11:45 - 12:25
CodeNode - Shift

11:45

rktnetes: what's new with container runtimes and Kubernetes
Abstract:
rkt is a modern container runtime, built for security, efficiency, and composability. Kubernetes is a modern cluster orchestration system allowing users. Kubernetes doesn't directly execute application containers but instead delegate to a container runtime, which is integrated at the kubelet (node) level. When Kubernetes first launched, the only supported container runtime was Docker - but in recent months, we've been hard at work integrating rkt as an alternative container runtime, aka "rktnetes". The goal of "rktnetes" is to have first-class integration between rkt and the kubelet, and allow Kubernetes users to take advantage of some of rkt's unique features.

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

Outline:
  • Overview of how the kubelet manages pods and interacts with container runtimes
  • Detailed description of how rkt integrates with the kubelet
  • Comparison of using different container runtimes with the kubelet
  • Some of the challenges faced in adding support for a different container runtime to Kubernetes

Speakers
avatar for Jonathan Boulle

Jonathan Boulle

Developer / Team Lead, CoreOS
Jonathan Boulle works at CoreOS on all things distributed and all things contained. He's contributed heavily to etcd and fleet and lead the development of the App Container (appc) specification and rkt, the first appc runtime. He is actively involved in the upstream Kubernetes project. Prior to CoreOS, he worked at Twitter on their cluster management platform based on Mesos and Aurora. He's passionate about Linux, F/OSS, the Oxford comma, and... Read More →


Thursday March 10, 2016 11:45 - 12:25
CodeNode - Alt Tab

11:45

Custom Volume Plugins
Abstract:
This talk will introduce you to the concept of Kubernetes Volume plugins. We will not only help you understand the basic concepts, but more importantly, using practical examples, we will show how you can develop your own volume plugins and contribute them back to the community of the OSS project as large as Kubernetes.

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.

Outline:
  • Introduction to volume plugins
  • Parallelism with Docker Volume Plugins
  • Quickly preparation of the environment
  • Examples of code
  • Lessons learned

Speakers
avatar for Álex González

Álex González

Software Architect, jobandtalent.com
Currently working at jobandtalent.com as Software Architect he spends his free time playing around with Go & everything that smells as a container. In the past he developed a Kubernetes volume plugin that is available since 1.1. | | He also loves organising events and he has a good track with that co-organising GolangUK 2015, the Golang London User Group & PyGrunn in the Netherlands.


Thursday March 10, 2016 11:45 - 12:25
CodeNode - Cmd

11:45

If you can drink and watch Star Wars, you can handle Kubernetes in production (Because that’s exactly what we did)
Abstract:
Before deploying Kubernetes to production, there are complex choices to make upfront: which cloud platform, which Linux distribution, what are the best tools or methods to manage and monitor your app, and more. We’ll kick off this session by going through some of these decisions, and highlight a few options to consider for each.

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.

Outline:
  • Organizational challenges for adoption of Kubernetes
  • Refresh on Kubernetes cluster architecture
  • configuration challenges
  • infrastructure requirements
  • Decisions to be made when deploying a production cluster
  • monitoring
  • networking
  • storage
  • logging
  • Variety of existing community projects
  • What we ended-up doing

Speakers
avatar for Ilya Dmitrichenko

Ilya Dmitrichenko

Community Engineer / Chief Systems Juggler, Weaveworks
Ilya is a community evangelist and engineer at Weaveworks, focused on making the adoption of microservices easier. Prior to Weaveworks, Ilya worked at Xively, where he personally experienced the shift to a true DevOps culture. He began to shift focus down the stack, becoming one of the early evangelists of and contributors to open source projects in the emerging Docker/container ecosystem.
avatar for Tom Wilkie

Tom Wilkie

Software Engineer, Weaveworks
Tom is a Software Engineer at Weaveworks. Previously he was at Google as a Site Reliability Manager for Google Analytics. Before that he was Founder, VP Eng and CTO at Acunu, and before that a Software Engineer at XenSource. In his spare time, Tom likes to make craft beer and build home automation systems.



Thursday March 10, 2016 11:45 - 12:25
CodeNode - Ctrl 10 South Place, London, United Kingdom

12:30

Lunch and Exhibit Break
Thursday March 10, 2016 12:30 - 13:50
CodeNode - ESC & Backspace

14:00

Scaling Open edX with Kubernetes
Abstract:
Over the past few years, massive open online courses (MOOCs) powered by Open edX have become wildly popular, bringing free or low-cost education to millions of students around the world. Such success, however, presents a slew of challenging problems in terms of providing a scalable, robust, and secure platform.

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.

Outline:
  • Open edX background & architecture
  • Why we chose Kubernetes
  • Scaling & resiliency with Kubernetes
  • The challenge of deploying Open edX with Kubernetes
  • Architecture of Open edX running on Kubernetes
  • Lessons learned & conclusion

Speakers
avatar for Nate Aune

Nate Aune

Founder/CEO, Appsembler
I'm the CEO and Founder of Appsembler, a Boston-based company providing services around Open edX, an e-learning platform for easily authoring and delivering online courses. I like to talk with folks about Docker, PaaS, Open Source, Open edX, e-Learning, Django, jazz.
avatar for Morgan Robertson

Morgan Robertson

DevOps Engineer, Appsembler
Morgan is a DevOps engineer at Appsembler focused on building scalable and robust systems. In addition to Kubernetes, he also works with Docker Swarm, Consul, and Ansible and is an experienced Python developer.


Thursday March 10, 2016 14:00 - 14:40
CodeNode - Shift

14:00

A lightweight deployment system for appops
Abstract:
In this talk I'd like to introduce kploy (http://kubernetes.sh/kploy/), the opinionated Kubernetes deployment system for appops. I'll cover the motivation, practical usage examples and future directions for kploy and discuss the ecosystem and related projects (helm, servpeek, etc.)

Outline:
  • Motivation for writing kploy and design decisions
  • Life cycle management/the landscape
  • Basic usage
  • Advanced usage
  • Future steps

Note: 3. and 4. are based on a live demo


Speakers
avatar for Michael Hausenblas

Michael Hausenblas

Developer and Cloud Advocate, Mesosphere Inc
Michael is a Developer Advocate at Mesosphere where he helps appops to build and operate distributed applications. His background is in large-scale data integration, Hadoop, NoSQL datastores, IoT, as well as Web applications and he's experienced in advocacy and standardization at W3C and IETF. Michael contributes to open source software (Kubernetes, Apache Mesos, Apache Myriad, etc.) and shares his experience with distributed operating systems... Read More →


Thursday March 10, 2016 14:00 - 14:40
CodeNode - Alt Tab

14:00

Full Automatic Database: PostgreSQL HA with Kubernetes
Why pay for always-on relational database service when you can deploy it yourself so easily? This demo-heavy talk will show off a deceptively simple high availability stack for PostgreSQL, using Docker, Etcd, Kubernetes, Patroni and Atomic. Not only is this open source solution ready to go to give you HA Postgres right now, it represents an approach which can be adapted to other relational databases with replication.

Outline:

1. Introduction
2. First demo
2.1 spin-up
2.2 connecting an application
2.3 automated failover
2.4 redeployment
3. History
3.1 Handyrep
3.2 Zalando
3.3 Compose.io
3.4 AtomicDB
4. Design
4.2 the Patroni agent
4.2 use of Etcd/Zookeeper
4.3 Kubernetes service definitions
4.4 How failover works
5. 2nd Demo
5.1 Code and configuration tour
5.2 Repeat of failover demo
5.3 Requests from audience
6. Conclusion 

Speakers
avatar for Josh Berkus

Josh Berkus

Project Atomic, Red Hat
Josh works on Project Atomic at Red Hat, but is better known for his long work on the PostgreSQL Project. His passions are databases, containers, devops, cooking and pottery.


Thursday March 10, 2016 14:00 - 14:40
CodeNode - Cmd

14:00

Hybrid Apps: Orchestrating Cloud-Native and Traditional Application Architectures

The Fortune 500 has thousands of line-of-business applications that do not easily port to a cloud-native architecture. In order to deliver these next generation cloud native apps to market, developers typically need to coordination between various siloed groups. For example, one team may deliver Node.js as a front end while SQL Server/Oracle DBAs are needed for customer data and .NET/JEE developers are responsible for the back end. In this session, we solve this common problem by first using the Apprenda PaaS to cloud-enable the existing application components without re-architecting. Second, we will use continuous delivery tools (UrbanCode) to deploy front end Node.js components to Kubernetes (Google Container Engine) and traditional application EAR files and SQL Server components to Apprenda.

  • How to use CI/CD to orchestrate hybrid app components on different platforms
  • How to attach classical architectures and applications (JEE/Oracle/WebSphere etc) to cloud native components on Kubernetes (Google Container Engine)
  • How to use CI/CD with platform integration to coordinate deployments across different, siloed, teams in an organization

Speakers
avatar for Sinclair Schuller

Sinclair Schuller

Co-Founder and CEO, Apprenda
Sinclair Schuller is the CEO of Apprenda. With his two co-founders, Apprenda has secured $57M in venture capital from funds NEA, Ignition Partners, Safeguard Scientifics, and High Peak Ventures to deliver private and public PaaS to enterprise developers. Apprenda is the best way for enterprises to cloud enable existing and new applications on current and future infrastructure investments. Sinclair serves on multiple venture networks and speaks... Read More →


Thursday March 10, 2016 14:00 - 14:40
CodeNode - Ctrl 10 South Place, London, United Kingdom

14:50

Multi-Tenant Kubernetes
Abstract:
Today Kubernetes is mostly employed in single tenant deployment, either private cloud, or as a COE on top of IaaS. By leveraging virtualized container like Hyper, Kubernetes will be the core of multi-tenant Container-as-a-Service. This talk will present Hypernetes, a secure Kubernetes distro focusing on the public container hosting service.

Outline:
  • Single tenancy: how people use Kubernetes today, and why?
  • Hyper - the virtualized container
  • Hyperenetes, the multi-tenant Kubernetes
  • CaaS without IaaS

Speakers
avatar for James Kulina

James Kulina

COO, HyperHQ Inc.
James Kulina is currently Chief Operating Officer at HyperHQ, a startup working to bring secure Container-as-a-Service to the masses. Prior to HyperHQ, James worked at Red Hat in the Openstack product group focusing on devops solutions. Prior to Red Hat, James worked at Paris based Openstack professional services startup eNovance, which was acquired by Red Hat in 2014. Prior to eNovance, James worked at AT&T in variety of managerial and technical... Read More →


Thursday March 10, 2016 14:50 - 15:30
CodeNode - Shift

14:50

ChatOps and Automatic Deployment on Kubernetes
ChatOps is a term often credited to GitHub, and it is all about putting the tools in the middle of the conversations. At Unacast, most of our conversations go through Slack. When we integrated ChatOps into our workflow, we got the tools closer to the conversation.

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.
  • This talk is about how we set up our deployment pipeline to K8S with Circle CI, GCR, Heaven and Hubot. Be prepared to see mountains of bash, avalanches of YAML and a lot of plumbing. We have been running Kubernetes in production since September 2015, so all of the examples and code is production ready
  • Introduction to ChatOps with examples- Introduction to our application architecture
  • Description of the discrete parts of the deployment pipeline
  • Explanation of how a deployment is triggered from Slack and how it ends up deployed in production.
  • Details about the scripts that are used
  • Different caveats like the lack of a Deployment and what tasks need manual intervention.
  • LIVE DEMO

Speakers
avatar for Andreas Heim

Andreas Heim

Lead Platform Engineer, Unacast
Andreas Heim is Lead Platform Engineer at Norwegian startup Unacast and has 12+ years of software development and command line hacks. He is an ops minded developer with a passion for boring code and automated infrastructure. Before joining Unacast Andreas worked at BEKK Consulting in Oslo where he was the Practice Lead for NoSQL and Big Data.


Thursday March 10, 2016 14:50 - 15:30
CodeNode - Alt Tab

14:50

Killing containers to make weather beautiful
Abstract:
The Met Office Informatics Lab includes scientists, developers and designers. We build prototypes exploring new technologies to make environmental data useful. Here we describe a recent project to process multi-dimensional weather data to create a fully interactive 4D browser application. We used long-running containers to serve data and web pages and short-running processes to ingest and compress the data. Forecast data is issued every three hours so our data ingestion goes through regular and predictable bursts (i.e. perfect for autoscaling).

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.

Outline:
  • Introduce myself
  • Describe the Informatics Lab
  • Describe the problem (how to create a fully interactive browser application to explore 4D weather data)
  • Ingesting the data (supercomputer > binary files > pngs > videos > the browser)
  • Long container jobs (web servers)
  • Short container jobs (bin > png and png > video)
  • Optimising scalable hardware by mixing job types
  • Scaling Kubernetes based on message queues
  • Managing application lifecycle with Kubernetes
  • Persisting our data using Amazon Elastic Block Storage

Speakers
avatar for Jacob Tomlinson

Jacob Tomlinson

Senior System Engineer, Met Office Informatics Lab
The Met Office is a world leading weather forecasting and climate research organisation. It owns one of Europe’s largest supercomputers and generates data on the exabyte scale. Jacob Tomlinson is a developer and systems engineer at the Informatics Lab - the innovation unit within the Met Office. He leads their R&D efforts on new infrastructure technologies. Jacob uses Kubernetes and Docker to transform how the Met Office makes data accessible... Read More →


Thursday March 10, 2016 14:50 - 15:30
CodeNode - Cmd

14:50

Kubernetes in Production in The New York Times newsroom
The New York Times’ is a US media company serves digital journalism to millions of visitors every day. The format of our stories is constantly experimented with; for example we publish graphics based on election data ingested from APIs, question and answer led discussions, breaking news live coverage, and quizzes. This leads to a lot of applications.

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.
  • Different story formats of the NYT
  • Problems with our older VM infrastructure
  • Moving to containers, benefits for both the sysadmin and non-sysadmin team
  • Our brief usage of Fleet for application init and problems there
  • Adopting Kubernetes and the benefits 
  • Network architecture of how we run apps in Kube, our Kube Router
  • Demo of our custom dashboard for managing apps
  • Our move towards Kube Dashboard

Speakers
avatar for Eric Lewis

Eric Lewis

Web Developer, The New York Times
Eric Lewis is a developer on the Interactive News team at The New York Times. He supports open source communities and is a committer on the WordPress project.


Thursday March 10, 2016 14:50 - 15:30
CodeNode - Ctrl 10 South Place, London, United Kingdom

15:30

Break
Thursday March 10, 2016 15:30 - 16:00
CodeNode - ESC & Backspace

16:00

Bringing an open source Containerized Container Platform to Kubernetes
Abstract:
Kurma is a open source container runtime that is based on the container
instrumentation built into the Apcera Platform. Kurma, and its accompanied
"KurmaOS" is our vision of a lightweight, fully containerized operating system.

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.

Outline:
  • Discuss Apcera's journey with first building its existing platform, starting
  • in the pre-Docker landscape.
  • Lessons learned in platform architecture as the system grew (monolith vs
  • modular) and in improving it operationally.
  • Migrating Apcera's container runtime to its own project
  • Containerize everything, a container operating system
  • System services for syslog, ntp, etc
  • Operation access to the host without polluting it
  • Extensible network and storage instrumentation through containerized
  • managers
  • Extensible notion of clustering. A host is a building block. It is boring and
  • uninteresting. With many blocks, you can build something interesting.
  • Kurma is intended to have no remote API. But it can be given a list of
  • containers to run on boot, and it can entrust them with local API access.
  • Those initial containers can overlay clustering semantics. They instrument
  • authentication, authorization, and can define whether a container that comes
  • in remotely should be allowed to run privileged or not.
  • Bringing Kurma to Kubernetes
  • Experiences with extending the kubelet to kurma.
  • Ensuring compatibility/portability with a Docker de facto
  • Deployment and instrumentation handling

Speakers
avatar for Ken Robertson

Ken Robertson

Lead Architect, Apcera
As lead architect at Apcera, Ken builds, deploys, manages, and monitors applications and infrastructure at scale. He enjoys blurring the lines between architect, developer, and operations. An active open source contributor, Ken authored Kurma, one of the implementations of the App Container specification (appc) in 2015, and is an active maintainer on the project. Ken also guides Apcera’s work with the Open Container Initiative (OCI). His... Read More →


Thursday March 10, 2016 16:00 - 16:40
CodeNode - Shift

16:00

Monitoring Microservices: Docker, Kubernetes, and GKE Visibility at Scale
Microservices and containers are revolutionizing the way we deploy applications and maintain our infrastructure. But as many teams are starting to find out, containers still have a key problem: monitoring and troubleshooting them can be impractical, painful, and sometimes plain impossible. The good news is that the rise of microservice-based architectures and container orchestration tools such as Kubernetes and GKE can make these hairy tasks a little bit easier.

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.

GitHub link: https://github.com/draios/sysdig

Outline:

Specific topics will include:
* Visualizing the physical vs logical architecture of Kubernetes deployments
* Understanding performance at the holistic microservice/application level for orchestrated systems
* Leveraging Kubernetes metadata such as namespaces, services, replication controllers and labels for more intelligent troubleshooting
* Identifying and surfacing system activity of individual Docker containers
* Extracting process and application-level performance metrics from inside containers using non-intrusive methods
* Troubleshooting detailed network activity among distributed containers

Speakers
avatar for Luca Marturana

Luca Marturana

Developer, Sysdig
Luca Marturana is a developer at Sysdig where he wears many hats. He is a core developer of sysdig, an open source troubleshooting tool for Linux and containers, and he spends his days dealing with agent development, performance analysis and cloud infrastructure management. | He is also the author of redis3m, a C++ client for Redis. | He holds a MS in Computer Engineering from University of Catania, Italy.


Thursday March 10, 2016 16:00 - 16:40
CodeNode - Alt Tab

16:00

Simple, Scalable, Secure networking for Kubernetes
Abstract:
Why does the network matter and why does it need to be simple (the 3am test)? Why should we build networks that scale to the extremes and how can we do that with proven technologies? Finally, how can we secure microservices, why should we bother, and what does this mean for developers and operators?

Outline:
  • Background to virtual networking; we have an opportunity to avoid the pitfalls of building complex, hard-to-debug, overlay networks (such as those used by OpenStack). This is driven by the move to pure-IP connectivity and IP-per-container.
  • Why enterprises need to think about scalability in networking and how we can achieve it: we have a proven, scalable approach to crib from, the Internet itself.
  • Securing a modern microservices architecture. What do recent big headline security intrusions teach us, why microservices provide an opportunity to revolutionize our network security, where we are right now and where we’d like to get to. This section includes a demo.

Speakers
avatar for Shaun Crampton

Shaun Crampton

Software Development Manager, Metaswitch - Project Calico
Shaun is a core developer and evangelist at Project Calico. Before joining the Calico team, Shaun worked on a number of Software Defined Networking products and cloud scale applications. He holds a BA in Computer Science from Cambridge University.



Thursday March 10, 2016 16:00 - 16:40
CodeNode - Ctrl 10 South Place, London, United Kingdom

16:50

Kubernetes Documentation: Contributing, fixing issues, collecting bounties
Abstract:
I started as the lead tech writer for Kubernetes and Google Container Engine in January. We are currently redesigning the docs, moving to a strictly GitHub Pages-based documentation system that will make it easier than ever to contribute!

Outline:
  • Introduction
  • The state of the docs as I joined
  • The redesign: An overview
  • What the switch to GitHub Pages means
  • [DEMO] Making an edit with GitHub Pages and staging on github.io
  • Announcing: Bounties for solving our issues
  • How we track and solve documentation issues

Speakers
avatar for John	 Mulhausen

John Mulhausen

Technical Writing Lead, Google
John Mulhausen is the lead technical writer at Google for Kubernetes and Container Engine.


Thursday March 10, 2016 16:50 - 17:30
CodeNode - Shift

16:50

Leveraging ephemeral namespaces in a CI/CD pipeline
Abstract:
One of the most underrated features of Kubernetes is namespaces. In the market, instead of using this feature, people are still stuck with having different clusters for their environments. This talk will try to break this approach, and will introduce how we end up using ephemeral namespaces within our CI/CD pipeline. It will cover the architecture of our system for running the user acceptance tests on isolated ephemeral namespaces with every bits and pieces running within pods. While doing this, we will set up our CI/CD pipeline on top of TravisCI, GoCD, and Selenium that is controlled by Nightwatch.js.

Outline:
  • Discuss how you can start leveraging namespaces, and why it is important to use them.
  • Introduction to ephemeral namespaces. Build all your dependent services in a separate namespace, run through your tests and tear down everything whenever you are done. 
  • Making every step (building docker images, provisioning kubernetes files, running rolling updates etc) within the CI/CD pipeline manageable with GoCD.
  • Details about the complete isolation of all the components in each testing namespace, and having chance of running a bunch of different versions on a single kubernetes cluster. 
  • Showing how everything is a part of Kubernetes component: even run your Nightwatch test scripts in a pod. 
  • Demo of the whole process.

Speakers
avatar for Can Yücel

Can Yücel

Senior Software Engineer, LaunchPad Central
Can is a software engineer at LaunchPad Central. After architecting/building a wide variety of systems as monoliths, he started thinking in microservices, and then got himself focused more on management and deployment of the services within containers. Kubernetes has been one of the most impressive companions within this new journey.


Thursday March 10, 2016 16:50 - 17:30
CodeNode - Alt Tab

16:50

Creating an Advanced Load Balancing Solution for Kubernetes with NGINX
Abstract:
Load balancing is an important part of any resilient web application. Kubernetes supports a few options for external load balancing, but they are limited in features. After a brief discussion of those options and the features they lack, we’ll show how to build an advanced load balancing solution for Kubernetes on top of NGINX, utilizing Kubernetes features including Ingress, Annotations, and ConfigMap. We’ll conclude with a demo of how to use NGINX and NGINX Plus to expose services to the Internet.

Outline:
  • What is load balancing: basic and advanced features
  • The state of load balancing in Kubernetes now
  • Features that are missing in the current options
  • NGINX – an advanced Layer 4/Layer 7 load balancer, web server and cache
  • Ingress Resource
  • Integrating cleanly with Kubernetes and extending the features supported by Ingress
  • Implementing an Ingress controller for NGINX
  • Deploying NGINX to Kubernetes
  • Load balancing demo using NGINX and NGINX Plus to expose services to the Internet

Speakers
avatar for Andrew Hutchings

Andrew Hutchings

Technical Product Manager, NGINX
Andrew Hutchings (aka LinuxJedi) is a Technical Product Manager at NGINX Inc. specialising in third-party developer relations. He is physically based in the middle of nowhere in the United Kingdom but works with a global team. Before joining NGINX he worked for HP on the Advanced Technology Group and an OpenStack developer. He has also held development roles for several big Open Source projects and is a co-author of the book MySQL 5.1 Plugins... Read More →


Thursday March 10, 2016 16:50 - 17:30
CodeNode - Ctrl 10 South Place, London, United Kingdom

17:40

Panel: Communities, Contribution and Kubernetes
There is a broad group of companies working to make sure that 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. 

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).

Moderators
avatar for Sarah Novotny

Sarah Novotny

Kubernetes Community Lead, Google
Sarah Novotny leads the Kubernetes Community Program for Google. She has long been an Open Source community champion and ran large scale technology infrastructures before web-scale had a name. In 2001, she co-founded Blue Gecko, a remote database administration company which was sold to DatAvail in 2012. She has curated teams, been a leader in customer communities focused on high availability web application and platform delivery and is a program... Read More →

Speakers
avatar for Thierry Carrez

Thierry Carrez

Director of Engineering, OpenStack Foundation
Thierry Carrez is the Director of Engineering at the OpenStack Foundation, helping ensure the long-term health of the OpenStack upstream open source project. He has been the Release Manager for the OpenStack project since its inception, coordinating the effort and facilitating collaboration between contributors. He is the elected chair of the OpenStack Technical Committee, which is in charge of the technical direction of the project.
avatar for Michael Henkel

Michael Henkel

Software Engineer, Juniper Networks
Michael is a Senior Solutions Consultant and Enterprise Network Architect focusing on all the exciting and evolving new technologies such as Service Defined Networking (SDN), OpenFlow (OF) and OpenStack. He is evaluating how (and if) these technologies can play together with traditional networking concepts and technologies. As a big OpenSource fan, Michael really like the fact that most of these new developments were born in the OpenSource... Read More →
avatar for Diane Mueller-Klingspor

Diane Mueller-Klingspor

Director, Community Development, Red Hat OpenShift
Diane is Director, Community Development at Red Hat OpenShift (https://openshift.com) , the leading Open Source Paas that upstreams Kubernetes, supports Docker natively and runs on OpenStack (as well as AWS, GCP, Vmware, and bare metal). She also runs the OpenShift Commons (https://commons.openshift.org) and manages the cross-community collaboration with all the upstream projects and across the diverse and ever-expanding OpenShift eco-system... Read More →
avatar for Alexis Richardson

Alexis Richardson

CEO of Weaveworks and TOC Chair, Cloud Native Computing Foundation
Alexis Richardson is the co-founder and CEO of Weaveworks. Previously he was at Pivotal, as head of products for Spring, RabbitMQ, Redis, and vFabric. Alexis co-founded RabbitMQ, and was CEO of the Rabbit company acquired by VMware in 2010, where he worked on numerous cloud platforms. Rumours persist that he co-founded several other software companies including Cohesive Networks, after a career as a prop trader in fixed income derivatives, and... Read More →


Thursday March 10, 2016 17:40 - 18:40
CodeNode - Ctrl 10 South Place, London, United Kingdom

18:40

Evening Party and Exhibit Hours
Join us for the first-day evening party generously sponosred by WeaveWorks! 


Thursday March 10, 2016 18:40 - 21:30
CodeNode - ESC
 
Friday, March 11
 

08:30

Breakfast and Exhibit Hours
Friday March 11, 2016 08:30 - 09:30
CodeNode ESC & Backspace

08:30

Registration
Friday March 11, 2016 08:30 - 17:00
CodeNode ESC & Backspace

09:30

Day 2 Keynote: Pushing Kubernetes Forward
The Kubernetes community has aspirations of becoming the Linux kernel of distributed systems. Together we want to build a scalable, stable, and secure platform for distributed system that is the ubiquitous choice for people building server infrastructure. This talk will discuss the major community efforts made in recent months to deliver this goal and the work we need to do to continue our momentum.

Speakers

Friday March 11, 2016 09:30 - 10:30
CodeNode - Ctrl 10 South Place, London, United Kingdom

10:40

Using Traffic Control to Test Apps in Containers
Abstract:
Testing applications is important, as shown by the rise of continuous integration and automated testing. In this talk, I will focus on one area of testing that is difficult to automate: poor network connectivity. Developers usually work within reliable networking conditions so they might not notice issues that arise in other networking conditions. I will give examples of software that would benefit from test scenarios with varying connectivity. I will explain how traffic control on Linux can help to simulate various network connectivity. Finally, I will run a demo showing how an application running in Kubernetes behaves when changing network parameters.

Outline:
  • I will start by presenting what is traffic control, and what is the status of implementations in different parts of the software stack: in Linux, systemd, kubernetes, CNI.
  • Secondly, I'll explain what I would like to have in the context of testing and continuous integration
  • Thirdly, I will run a demo of using traffic control on Kubernetes

Speakers
avatar for Alban Crequy

Alban Crequy

Co-Founder & Software Engineer, Kinvolk GmbH
Alban is a founder and software enigineer at Kinvolk GmbH in Berlin. He's also currently the technical lead of rkt, an App Container runtime. | | Before falling into containers, Alban worked on various projects core to modern Linux; kernel IPC and storage, dbus performance and security, etc. His current technical interests revolve around networking, security, systemd and containers at the lower-levels of the system. | | Being an avid board game... Read More →


Friday March 11, 2016 10:40 - 11:20
CodeNode - Shift

10:40

Templatized Application Configuration on OpenShift and Kubernetes
Abstract:
Kubernetes gives developers a platform on which to run images and many configuration objects to control those images, but constructing a cohesive application made up of images and configuration objects is currently a challenge. Reconstructing or sharing that configuration can also be a challenge. This talk will cover the Template feature implemented in OpenShift to simplify the process of defining and repeatably deploying coordinated objects, discuss what is coming to Kubernetes with respect to this capability, and touch on several other existing projects that enable templatizing application definitions.

Outline:
  • Introduction to OpenShift templates
  • Discuss OpenShift template parameters
  • Go through a few example templates/use cases
  • Cover the current Kubernetes template proposal (https://github.com/kubernetes/kubernetes/pull/18215)
  • Differences/changes from OpenShift
  • Goals+use cases for the Kubernetes implementation
  • Brief discussion of other templating technologies available
  • Conclusion - templates are coming, they will make your life easier

Speakers
avatar for Ben Parees

Ben Parees

Principal Engineer, Red Hat
Ben Parees works for RedHat as a lead developer on the Kubernetes based OpenShift project which he has worked on for the last 2 years. His team focuses on workflows that take developers from source code to PaaS deployed Docker images.


Friday March 11, 2016 10:40 - 11:20
CodeNode - Alt Tab

10:40

SmartCity IoT on Kubernetes
Modern cities are rapidly adopting smart technologies to deliver realtime data about a number of city services. These technologies heavily rely on a high quality network interconnecting all sensors and reactors as lamps with controlling services. Many low level PLC systems solve the automation, but their purpose is limited to narrow areas of usage as these device have limited computational power. On the other hand, the rise of single-board computers as Raspberry Pi with multi-core processors and plenty of memory can serve as a platform for virtualized services based on Kubernetes. The distributed cluster across whole city on public streetlights gives operators the possibility to adapt to rapidly changing conditions. We propose distribution of HA clusters of single-board devices in key topological points of smart city mesh networks connected together by reliable SDN network. These virtualized services fulfill various tasks as data collection, data processing or and all of these services can rely on cloud backends, that provide much more computational and storage capacity. Services can be operated at both locations to serve local as well as foreign users. 

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.

Speakers
avatar for Jakub Pavlik

Jakub Pavlik

CTO, tcp cloud a.s.
Jakub Pavlik is chief architect of tcp cloud (http://tcpcloud.eu/en/ http://opentcpcloud.org). He is focused on building enteprise private cloud solutions based on OpenStack and Kubernetes. This includes vendors derivates, like Juniper OpenStack, Mirantis OpenStack or RedHat OpenStack. He is responsible for whole infrastructure solution (architecture, implementation, operation). Jakub is member of OpenContrail Advisory Board.
avatar for Adam Skotnicky

Adam Skotnicky

CEO, tcp cloud a.s.
Adam Skotnicky is the CEO of tcp cloud.


Friday March 11, 2016 10:40 - 11:20
CodeNode - Cmd

10:40

ITNW (If This Now What): Orchestrating an Enterprise
Abstract:
With growing demand for containers in the enterprise, build pipelines are a bottleneck to success. Traditional workflows can't release application candidates quickly enough to fulfill demand. With over 400 development teams across many different business units, Pearson had to move away from massive installs of traditional build pipeline tools and rethink the entire concept. In this talk we'll demonstrate how we have built in security compliance, performance testing, quality assurance, abstracted away complexity, reduced overhead, aim to recover 10% of developers time and turned build tools into cattle.

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.


Problem Statement of container builds at scale:
  • Significant developer time managing build process
  • Bottleneck across 400+ development teams
  • Lack of security compliance across the enterprise footprint
  • Little to no standardization
  • Significant resource consumption
  • Build pipelines are pets requiring constant attention
  • CAB approvals requiring weeks of effort to ensure stability
  • Manual processes contributing to stability issues
  • Development teams don't want to manage their own build process

Solution:
  • Standardized base images
  • Allows for deltas for additional libraries
  • Reduce time for testing with standard images being pretested
  • CISO requirements baked into base images
  • Pre-approved for deployment
  • Every dev team gets their own build tools
  • Prevents build process from bottlenecking other teams
  • Abstract build servers away and turn them into cattle
  • Build servers contain no long-term information
  • Configured through repos
  • Requires no direct dev interaction
  • Build done automatically on git push or timed event
  • Build pipeline deploys and kicks off QA/CISO/PERF tests automatically
  • Provides feedback loops to necessary engineers
  • Automated gates to approve/reject deployment
  • Automated processes establish confidence for CAB approval
  • Easy oversight to view process

Speakers
avatar for Michael Ward

Michael Ward

Principal Systems Architect, Pearson
Michael Ward is the Principal Systems Architect at Pearson responsible for leading technical design around enterprise Platform-as-a-Service based on Kubernetes. Prior to Pearson, Michael has spent many years in the industry in various roles including Chief of Site Reliability at Ping Identity, the Identity Security company. Take him for a beer and pick his brains on anything you like. You might even come away with something valuable. No... Read More →


Friday March 11, 2016 10:40 - 11:20
CodeNode - Ctrl 10 South Place, London, United Kingdom

11:30

Your App Is Alive
Many of us might just be getting started with Kubernetes. A really good way to do so is by creating a small web server in your language of choice with a simple health check. Doing so will give you an awesome playground so you put all of the documentation you’ve read into action.

In this talk, we'll do a brief overview of Kubernetes concepts needed and have a running Kubernetes cluster on GCE as a prerequisite. We'll learn about health checks the kubernetes way, how to use liveness and readiness probes, and logging our results. 

Speakers
avatar for Michelle Noorali

Michelle Noorali

Software Engineer, Deis
Core Maintainer on the Kubernetes Helm project


Friday March 11, 2016 11:30 - 12:10
CodeNode - Shift

11:30

Integrated trusted computing in Kubernetes
Abstract:
Being able to trust your containers requires that you be able to trust the systems your containers are running on. Trusted computing makes it possible for computers to prove what they’ve booted, making it practical for clusters to verify that systems haven’t been compromised, but up until now it’s been a heroic task to deploy a trusted computing environment.

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.

Outline:
  • Problem space: why do we care about system security, and what are the risks of it being compromised
  • Introduction to trusted computing: hardware requirements, OS support, what a TPM is, how attestation works
  • Integration of trusted computing in Kubernetes: The code added to Kubernetes in order to support verification of nodes at cluster admission time
  • Extending trust into containers: Discussion of how the container runtime can integrate with trusted computing

Speakers
avatar for Matthew Garrett

Matthew Garrett

Principal Security Software Engineer, CoreOS
Matthew Garrett is a security developer at CoreOS, specialising in the areas where software starts knowing a little more about hardware than you'd like. He implemented much of Linux's support for UEFI Secure Boot, does things with TPMs and has found more bugs in system firmware than he's entirely comfortable with.


Friday March 11, 2016 11:30 - 12:10
CodeNode - Alt Tab

11:30

Transforming the Government

This talk is documents the UK Home Office's cloud-native journey, changing how we did devops forever!

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.







Speakers
avatar for Ivan Pedrazas

Ivan Pedrazas

Software Engineer, Kubecast
Ivan has more than 17 years experience in the technology industry covering consulting, product development, architecture and solution deployment throughout the financial, telecoms and pharmaceutical industries with significant expertise in automation of data focused solutions. | | Currently working at the UKHome Office, Ivan is responsible for designing and implementing the CI/CD for their Digital Platform.


Friday March 11, 2016 11:30 - 12:10
CodeNode - Cmd

11:30

Getting the Jobs Done With Kubernetes
When you hear words such as Kubernetes or OpenShift you immediately start thinking
about long running processes you can easily scale at will. However, Kubernetes includes a lesser known feature which allows you to run pretty much anything from simple tasks up to highly-complicated ones.

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!

Outine:

1. What are batch jobs
* Definition and its purpose
* Possible usage areas
2. Job resource in Kubernetes
* Definition
* Working with jobs
* First example: Pi number
3. Job patterns - live demo
4. Future evolution
5. Q&A

Speakers
avatar for Maciej Szulik

Maciej Szulik

Software Engineer, Red Hat
Maciej is a passionate developer with over 10 years of experience in many languages. | | Currently he is working on OpenShift and Kubernetes for Red Hat and by night he is hacking on side projects and CPython's IMAP library. In his other spare time he organizes PyCon PL, talks at various events including PyCon PL, DevConf and local meet ups.


Friday March 11, 2016 11:30 - 12:10
CodeNode - Ctrl 10 South Place, London, United Kingdom

12:20

14:00

Making Sense of the Growing Kubernetes Community
Abstract:
We will explore the make up of the Kubernetes community and the adoption trends that we are tracking at RedMonk:
  • What is community
  • What is a contribution, its more than just code
  • Contributions and where they are coming from
  • Interest growth and crossing the chasm
  • Trajectory

Speakers
avatar for Fintan Ryan

Fintan Ryan

Industry Analyst, Redmonk
Fintan Ryan is an industry analyst at RedMonk, the developer focused industry analyst firm.  | | Fintan's research focuses on all things related to developers, from tooling to methodologies and the organizational aspects of software development. His primary research areas include cloud native computing architectures, analytics, software defined storage, DevOps and machine learning. | | Prior to joining RedMonk Fintan held senior roles... Read More →


Friday March 11, 2016 14:00 - 14:40
CodeNode - Shift

14:00

A Practical Guide to Container Scheduling
Abstract:
Containers are at the forefront of a new wave of technology innovation but the methods for scheduling and managing them are still new to most developers. In this talk we'll look at the kind of problems that container scheduling solves and at how maximising efficiency and maiximising QoS don't have to be exclusive goals. We'll take a behind the scenes look at the Kubernetes scheduler: How does it prioritize? What about node selection and external dependencies? How do you schedule based on your own specific needs? How does it scale and what’s in it both for developers already using containers and for those that aren't? We’ll use a combination of slides, code, demos to answer all these questions and hopefully all of yours.

Outline:
  • Quick intro to Container Scheduling at Google
  • The problems that containers scheduling solves 
  • Efficiency and QoS (includes demo)
  • The end of the Cluster Node
  • Scaling up and down automatically (includes demo)
  • Resources and Dependencies (includes demo)
  • Roll your own Scheduler (includes demo)


Speakers
avatar for Mandy Waite

Mandy Waite

Developer Relations Engineer, Google
Based in London, UK, Mandy is a Developer Relations Engineer at Google specializing in Container and Cloud technologies and working to make the world a better place for developers building Cloud based and Cloud Native apps.


Friday March 11, 2016 14:00 - 14:40
CodeNode - Alt Tab

14:00

My Microservices are not all stateless!
Managing a microservice-based deployment is complicated and Kubernetes helps tremendously but not all microservices are stateless! For the stateful services, we are encouraged to deploy a database per service - which increases complexity and leads on the the next question: Where does my state live?

Outline:

This talk will demonstrate several patterns to consider when using Kubernetes and its persistent volume feature. We will take a look at how to:
  • deploy stateful microservices that have a network attached block device for storage
  • move stateful containers around the cluster and have their storage volume follow
  • perform automatic fail-over with a stateful service
  • explore and configure the range of volume drivers available for Kubernetes

We will also take a deep-dive into how volume drivers work and discuss what the future holds for stateful containers being managed by Kubernetes.

Speakers
avatar for Kai Davenport

Kai Davenport

Developer Relations, ClusterHQ
Kai works on the Developer Relations team at ClusterHQ - the creators of Flocker. He has been busy working on the Docker volume plugin and previously was hard at work on Powerstrip - a prototyping tool for Docker extensions. In a previous life Kai was developing educational software and has been developing web-based software for 15 years.


Friday March 11, 2016 14:00 - 14:40
CodeNode - Cmd

14:00

Kubernetes Storage 101
Abstract:
You have deployed your application on Kube and now you want to actually do something permanent with it?? You will need STORAGE.

This talk will be a good introduction to using storage in Kubernetes. It will cover the use of EmptyDir, HostPath and Persistent Storage options. How to configure and use each type. This talk will also discuss the security features for storage in the open source OpenShift project.

Outline:
  • I. How does storage work in Kubernetes
  • II. What are the supported volume plugins
  • III. How do I configure a volume plugin in my pod
  • IV. How do I make my storage secure
  • V. Q&A

Speakers
avatar for Erin Boyd

Erin Boyd

Principal Software Engineer, Red Hat
Erin Boyd has been part of the Emerging Technology group at Red Hat for 3 years. Her current position is exploring and improving storage in Kubernetes & OpenShift. Prior to this position Erin worked as a committer to the Apache Ambari project to integrate Hadoop Compatible file systems for Big Data. Before working at Red Hat she worked at IBM for 13 years doing various analytics, integration services and embedded software development.


Friday March 11, 2016 14:00 - 14:40
CodeNode - Ctrl 10 South Place, London, United Kingdom

14:50

Distributed containers in the physical world
Abstract:
The building industry in the world today is at large, far behind the rest of the world, technically. Alongside this, it is at threat of being dominated by a small selection of software vendors. These vendors push specific software solutions to the technically unskilled consumers in the AEC industry. The software they provide however is monolithic, native and heavy. Containers, distributed computing, and open source microservices and applications offer a solution to turn the construction industries future on its head. When computing is ubiquitous in our buildings with the internet of things, the whole way we think about building design has to change. We need to think in advance about how our applications which will run our buildings are developed. Each building is bespoke and the offers currently on the software market simply wont fit the bill in the near future. We are trying to develop a kubernetes based platform to lay the foundations for the future of lightweight bespoke apps developed for our built environment.

Outline:

  • Introduction - An introduction to Jenca and Connor’s story in arriving at the current product offering and set of ideas, including kubernetes involvement.
  • The Built Environment - A small history of the development of the AEC industries and their technological use and development. This history will describe the steps taken and the problems Jenca have uncovered. Problems include the amount and quality of existing building stock, and the number of buildings required to meet demand over the next century, and the lack of necessary knowledge and skill to engage with the new world.
  • Microservices and web technologies - How the iterative, biomimetic steps that we see loosely in agile development and lean methodology help to evolve the best solution to these problems.
  • Open sourcing and Kubernetes - The importance of Kubernetes in the role of delivering the Jenca solution and the vitality of open sourcing the product.
  • Vision - Our long term vision, should the solution work as we hope.

Speakers
avatar for Connor Alexander

Connor Alexander

Co-Founder and CTO, Jenca
Connor is the CTO at Jenca. He is currently leading their flagship product, an opensource BIM (Building Information Modelling) opinionated PaaS based on Kubernetes and data flow pipeline logic. Connor studied architecture at uni but his lifelong passion has been technology and understanding system design, specifically applying computer science theories to help explain real world phenomenons.


Friday March 11, 2016 14:50 - 15:30
CodeNode - Shift

14:50

Interactive Monitoring for Kubernetes
Abstract:
The rise of “cloud native” applications (many targeting Kubernetes) has had knock-on effects on the ways development teams operate, and the complexity of monitoring your application. Order-of-magnitude increase in the number of moving parts and rate of change of the applications require us to reassess traditional techniques.

In this talk we will discuss some of the challenges raised and different approaches to solving them. We’ll discuss:

- the necessity for a common set of monitoring paradigms across all you microservices, and how this can reduce cognitive load and improve recovery-from-failure time.
- the increased importance of automated, interactive visualization tools now that responsibilities for system architecture have been devolved to individuals and teams.
- new exciting ideas in distributed tracing and how these can help deploy tracing across an ever-differentiated production environment.

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

Outline:
  • "monitoring" - ie timeseries metrics, considerations etc
  • "visualisation" - interactive visualisation of the architecture of running systems
  • "tracing" - distributed tracing, its importance, and how to etc.

Speakers
avatar for Tom Wilkie

Tom Wilkie

Software Engineer, Weaveworks
Tom is a Software Engineer at Weaveworks. Previously he was at Google as a Site Reliability Manager for Google Analytics. Before that he was Founder, VP Eng and CTO at Acunu, and before that a Software Engineer at XenSource. In his spare time, Tom likes to make craft beer and build home automation systems.


Friday March 11, 2016 14:50 - 15:30
CodeNode - Alt Tab

14:50

Kubernetes Dashboard Unleashed!
Abstract:
With the first release of the Kubernetes Dashboard project out of the door it's time to look at the challenges facing this young project and how as a community we can come together and help shape its goals.

What can the Kubernetes Dashboard potentially provide me if I'm:
- A developer?
- A operations engineer?
- A manager?

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.

Outline:

  • Introduction and Motivation
  • Highlight what's currently next for the project
  • Highlight the potential issues facing the project
  • Call-to-Action
  • What do you want to see from the project?
  • as a developer
  • as a operations engineer
  • as a manager
  • A brief look at current visualisation tools to highlight common patterns / ideas
  • Call-to-Action

Speakers
avatar for Christoph Held

Christoph Held

Cloud Architect, Fujitsu
As a cloud architect at Fujitsu, Christoph is passionate about OpenSource in the area of datacenter management. He was working in the OpenStack Monasca project and defined its logging-as-a-service component. Since late 2014, Christoph has been focusing on the usage of Kubernetes in large scale enterprise environments and is now deeply engaged in the Dashboard project.
avatar for David O'Dwyer

David O'Dwyer

Founder, LiveWyer
David O'Dwyer is the founder of LiveWyer, a London based consultancy which specialise in infrastructure development built on open-source technology. Drawing on his broad systems architecture background, David and his team have successfully deployed a number of customer solutions built around the lean, agile Kubernetes system. Having worked with a number of server management technologies he now firmly believes Kubernetes is a key piece in making... Read More →


Friday March 11, 2016 14:50 - 15:30
CodeNode - Ctrl 10 South Place, London, United Kingdom

15:40

Trading in the Kube
We will present the latest iteration of our sample trading application, Reactive Trader (previous iteration - http://adaptiveconsulting.github.io/ReactiveTraderJS). This is built on Google Cloud Platform, Kubernetes and Docker and has a Microservices architecture.

Outline:
About Adaptive
How do we build Trading Systems?
What's wrong with this?
How can a Microservices Architecture help?
How can we make it Resilient?
How can we make it Scalable?
Demonstration
Introducing Reactive Trader
What do all the bits do?
Application is resilient to Service failures
Deploy a new environment
Scale up a Service
Scale up all the Services
Observe Kubernetes increase the number of VMs
Destroy the environment
Conclusion
Announce Open Sourcing of Reactive Trader

Speakers
avatar for Thibault Deheurles

Thibault Deheurles

Director, Adaptive Consulting
avatar for John Marks

John Marks

Co-Founder and Director, Adaptive Financial
John Marks is one of the founding directors of Adaptive, a software consultancy specialising in building event-driven, distributed, fault-tolerant applications in the financial services space. He is a passionate technologist and a polymath programmer.


Friday March 11, 2016 15:40 - 16:20
CodeNode - Shift

15:40

From Heroku to Kubernetes
Abstract:
Arkena's video-on-demand platform is used as backend by major european channels (TF1 / beIN SPORTS / Elisa) to propose a non-linear experience to their customers.
Previously hosted on Heroku, the number of our users is increasing constantly. In order to optimize resources we decided to move on a baremetal infrastructure powered by kubernetes.
We'll share thoughts, feedbacks and technical details about this successful transition.- Presentation of Arkena's Video on demand plateform

Outline:
  • Former Hosting platform on Heroku, why to leave?
  • Key features of Heroku
  • Is kubernetes able to provide a similar flexilbilty on a bare-metal infrastructure?
  • Side by side comparison, pros & cons
  • Migration steps from Heroku to Kubernetes
  • Production feedbacks

Speakers
avatar for Smaine Kahlouch

Smaine Kahlouch

Devops, Morea
Smaine is a senior technical lead and devops engineer at Morea with 10 years experience in Devops, Linux and open source softwares.
avatar for Antoine Legrand

Antoine Legrand

Software Engineer, Arkena
I'm a software engineer at CoreOS working to integrate kpm into Quay. I'm dedicated to open source and cloud native software and he co-authored kargo and kpm, two projects that help to deploy kubernetes clusters and the applications that run on them.


Friday March 11, 2016 15:40 - 16:20
CodeNode - Alt Tab

15:40

Kubernetes Hardware Hacks: Exploring the Kubernetes API Through Knobs, Faders, and Sliders
Abstract:
Have you ever wanted to create a physical cockpit or replica of Homer Simpson’s dashboard to control your Kubernetes cluster? Of course you have!

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.

Outline:
  • Intro to the Kubernetes API
  • Deployment Standardization
  • Hardware demos!
  • Explore how we used the API
  • Possibilities for other apps

Speakers
avatar for Ian Lewis

Ian Lewis

Developer Advocate, Google
Ian is a developer Advocate on the Google Cloud Platform team working out of Tokyo. His mission is to help improve the lives of developers in the cloud. Ian focuses on Kubernetes, Storage, APIs, languages and everything in between. He loves Python and Go and helped found PyCon JP, largest Python conference in Japan.


Friday March 11, 2016 15:40 - 16:40
CodeNode - Ctrl 10 South Place, London, United Kingdom

16:40

Break
Friday March 11, 2016 16:40 - 17:00
CodeNode - ESC & Backspace

17:00

Panel: CNCF
Update on the CNCF and a special announcement!

Moderators
avatar for Sarah Novotny

Sarah Novotny

Kubernetes Community Lead, Google
Sarah Novotny leads the Kubernetes Community Program for Google. She has long been an Open Source community champion and ran large scale technology infrastructures before web-scale had a name. In 2001, she co-founded Blue Gecko, a remote database administration company which was sold to DatAvail in 2012. She has curated teams, been a leader in customer communities focused on high availability web application and platform delivery and is a program... Read More →

Speakers
avatar for Chris Aniszczyk

Chris Aniszczyk

VP of Developer Programs, The Linux Foundation
Chris Aniszczyk brings more than 15 years experience as The Linux Foundation’s vice president of Developer Programs. His work is focused on working with developer community to advance open source projects at scale. Previously Aniszczyk served as Twitter's head of open source, where he led a team of developer advocates and was responsible for Twitter's open source engineering, strategy and culture. He has also contributed to Gentoo Linux and... Read More →
avatar for Jonathan Boulle

Jonathan Boulle

Developer / Team Lead, CoreOS
Jonathan Boulle works at CoreOS on all things distributed and all things contained. He's contributed heavily to etcd and fleet and lead the development of the App Container (appc) specification and rkt, the first appc runtime. He is actively involved in the upstream Kubernetes project. Prior to CoreOS, he worked at Twitter on their cluster management platform based on Mesos and Aurora. He's passionate about Linux, F/OSS, the Oxford comma, and... Read More →
avatar for Alexis Richardson

Alexis Richardson

CEO of Weaveworks and TOC Chair, Cloud Native Computing Foundation
Alexis Richardson is the co-founder and CEO of Weaveworks. Previously he was at Pivotal, as head of products for Spring, RabbitMQ, Redis, and vFabric. Alexis co-founded RabbitMQ, and was CEO of the Rabbit company acquired by VMware in 2010, where he worked on numerous cloud platforms. Rumours persist that he co-founded several other software companies including Cohesive Networks, after a career as a prop trader in fixed income derivatives, and... Read More →


Friday March 11, 2016 17:00 - 18:00
CodeNode - Ctrl 10 South Place, London, United Kingdom