[lxc-devel] Linux Plumbers 2013 - Container mini-summit, (hopefully) final schedule

Tue Sep 17 01:01:04 UTC 2013

Hey everyone,

So I just went through everything the other track leads accepted over
the past couple of weeks and split the remaining time as well as
(unfortunately) reduced some of the current time allocation for some of
the talks.

Basically anyone who didn't directly ask for more, now got a 15min time
slot so that we can fit everything in the time that we've got allocated.

The event schedule is at:
http://www.linuxplumbersconf.org/2013/ocw/events/LPC2013/schedule

With our mini-summit there:
http://www.linuxplumbersconf.org/2013/ocw/events/LPC2013/tracks/153

The current schedule is as follow:
== On the road to LXC 1.0 ==
Presented by: Serge Hallyn and Stéphane Graber
Duration: 20 minutes
Excerpt:
 Overview of what features to expect for LXC 1.0 and hints on how to
 help us get there.
 .
 LXC upstream is currently doing a big development push to get LXC 1.0
 out in early 2014.
 We’re now half-way through the planned development time and a lot of
 exciting things have already been done with a whole lot more to come.
 .
 This talk will go through our goal for 1.0, what has been done so far
 and what else will be coming very soon.

== LXC and Android ==
Presented by: Stéphane Graber
Duration: 15 minutes
Excerpt:
 Ever wanted to run Android in a container or run a Linux distro in a
 container on Android?
 .
 This talk will present some of the work I’ve been doing to get LXC to
 run natively on Android, allowing the user to then start a standard
 Linux distro in a container without impacting Android.
 .
 I’ll also cover doing it the other way around, where we instead run
 Android in a container on a standard Linux distro and why that makes
 developing new phone operating systems much easier.

== Let Me Contain That For You! ==
Presented by: Rohit Jnagal
Duration: 20 minutes
Excerpt:
 We’ll demonstrate a redesign of container management solution built for
 use at Google. The talk highlights our design motivation and some of the
 differences from existing container management solutions. We cover some
 lessons learnt during re-design that help us adapt to what we believe
 are the workloads of tomorrow:
 .
  - Larger machine (more cores and memory) which leads to more
    containers. This requires a level of concurrency and scalability that
    doesn’t exist today.
  - Higher utilization of machines, being able to pack containers more
    tightly in order to use every last bit of resources available.
  - Priority bands for containers: Having different guarantees for
    containers of different priorities (e.g.: paying customers vs. free
    customers, latency sensitive vs. batch)
  - Hierarchical containment: There’s an increasing demand to run
    containers inside containers to manage resources allocated to a user by
    higher-level allocators e.g.: A container-based PaaS/IaaS letting users
    create subcontainers per db query type, nominate sacrificial loads, etc.
 .
  We hope that this talk would help guide the kernel and userspace
  containers support for future resource isolation needs.

== State of CRIU (Checkpoint Restart In Userspace) and integration with LXC ==
Presented by: Pavel Emlianov and Serge Hallyn
Duration: 20 minutes
Excerpt:
 The CRIU project implements ability to take a state-dump of running
 Linux processes and restore them later. This feature allows for such
 things as live-migration, fast kernel update, fast services start and
 others.
 .
 This talk is about to introduce CRIU to the audience by showing its
 basic features and discussing integration with LXC’s checkpoint/restart
 commands.

== TEA BREAK ==
Presented by: Linux Plumbers 2013
Duration: 15 minutes

== Device namespace ==
Presented by: Amir Goldstein and Oren Laadan
Duration: 15 minutes
Excerpt:
 We (cellrox) have been working on bringing lightweight virtualization to
 Linux-based mobile devices like Android (or other Linux-based devices with
 diverse I/O) and want to share our solution: device namespaces.
 .
 Imagine you could run several instances of your favorite mobile OS or other
 distributions in isolated containers, each under the impression of having
 exclusive access to device drivers; Interact and switch between them within
 a blink, no flashing, no reboot.
 .
 Device namespaces are an extension to existing Linux kernel namespaces
 that brings lightweight virtualization to Linux-based end-user devices,
 primarily mobile devices. Device namespaces introduce a private and
 virtual namespace for device drivers to create the illusion for a
 process group that it interacts exclusively with a set of drivers.
 Device namespaces also introduce the concepts of an “active” namespace
 with which a user interacts, vs “non-active” namespaces that run in the
 background, and the ability to switch between them.

== Fedora/systemd on LXC ==
Presented by: Michal H. Warfield
Duration: 15 minutes
Excerpt:
 Discuss plans to ensure systemd-based distros continue to work on lxc.
 .
 Systemd occasionally presents challenges to lxc container hosts and guests.

== User namespace work ==
Presented by: Serge Hallyn
Duration: 15 minutes
Excerpt:
 The goal in lxc is for unprivileged users to be able to safely create
 and use containers.
 .
 It will begin by explaining the user namespace functionality, the subuid
 shadow extensions, and the pieces already implemented and those needed
 in lxc to enable the unprivileged container use.

== Use Cases for Containers in OpenStack ==
Presented by: Daniel Salinas
Duration: 15 minutes
Excerpt:
 Discussion of how Rackspace uses OpenVZ containers and how we should
 expand nova for other container use cases

== Containers control tools: can we unify those? ==
Presented by: Kirill Kolyshkin and Stéphane Graber
Duration: 15 minutes
 Now that the kernel supports both LXC and OpenVZ do we really need two
 different tool sets? If not, how should we unify the user visible
 container control plane.
 .
 Hot Issues to sort out:
 .
  - Now that the kernel supports both LXC and OpenVZ do we really need
    two different tool sets? If not, how should we unify the user visible
    container control plane.
  - If we’re unifying the control plane, should we consider combining
    the projects? The containers we orchestrate are different, but they’re
    both using the same in-kernel functionality now.
 .
 Currently we have lxc tools (lxc) and OpenVZ tools (vzctl etc), plus
 libcgroup and systemd(?).

If you are a speaker, please remember that this is supposed to be a
mini-summit and not a lecture, so try to leave room for questions.
I realise that the limited time may make this hard, in which case we can
always overflow over the tea break and maybe talk some more after the
mini-summit is over.

Should anyone have any question, can't make it or need more time, please
let me know ASAP. I'll be travelling to New Orleans tomorrow but the
mini-summit is only on Thursday so we can only do some more last minute
tweaks to the schedule.

Thanks and see you all there!

-- 
Stéphane Graber
Ubuntu developer
http://www.ubuntu.com
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 836 bytes
Desc: Digital signature
URL: <http://lists.linuxcontainers.org/pipermail/lxc-devel/attachments/20130916/1766ef19/attachment.pgp>