runC 1.0.0-rc2

 + {create,run}: add --no-new-keyring flag so that a new session keyring
   is not created for the container and the calling process's keyring is
 + restore: add --empty-ns flag to tell CRIU to only create a network
   namespace for a container and not populate it (allowing higher levels
   to correctly handle re-creating the network namespace).
 + {create,start}: use a FIFO rather than signals to signal the starting
   of a container. This removes the Go version restriction, and also
   avoids potential issues with Go's signal handling.
 + exec: allow additional groups to be overridden.
 + delete: add --force flag.
 - exec: disable the subreaper option entirely, because the option
   causes many issues with reparenting in the context of containers.
   This is not a complete fix, which is intended to land for -rc3. Using
   the removed option will be silently ignored by runC.
 + {create,run}: add support for masking directories with MaskPaths.
 + delete: allow for the deletion of multiple containers in one cmdline.
 + build: add `make release` for distributions.

 * Major improvements and fixes to CLI handling. Now commands like
   `runc ps` and `runc exec` will act sanely when you're trying to use
   flags that are not meant to be parsed by runC.
 * Set the cp.rt_* cgroup options correctly so that runC running in
   SCHED_RR (realtime) mode can operate properly.
 * Massive improvements to kmem limit detection to ensure that we only
   attempt to change memory.kmem.* if it is safe to do so.
 * Part of a major cleanup of the nsenter code, with more intended to
   land before -rc3.
 * Restored containers now have a start time, which is the time that the
   new container was started (not when the original container was
 * Fix the default cgroupPath behaviour, so that we actually attach to
   subcgroups of all of the caller's current cgroups (rather than using
   the devices cgroup path for all other cgroups)
 + Support 32bit UIDs on i386 with the setuid32(2) syscall.
 + Add /proc/timer_list to the set of default masked paths.
 - Do not create /dev/fuse by default.
 * Parse cgroupPath correctly if it contains ':'.
 * Add some more debugging information for the test suite, along with
   fixes for race conditions and other issues. In addition, add more
   integration tests for edge conditions.
 * Improve script to handle more cases.
 * Fix incorrect type when setting of net_cls classid.
 * Lots of fixes to help pages and man pages.
 + *: append -dirty to the version if the git repo is unclean.
 * Fix the JSON tags for CpuRt* options.
 * Cleanups to the rootfs setup code.
 * Improve error messages related to SELinux.

Thanks to all of the contributors that made this release possible:

 * Akihiro Suda <>
 * Aleksa Sarai <>
 * Alexander Morozov <>
 * Andrew Vagin <>
 * Ben <>
 * Buddha Prakash <>
 * Carl Henrik Lunde <>
 * Christian Brauner <>
 * Dam Thomason <>
 * Dan Walsh <>
 * Daniel, Dao Quang Minh <>
 * Davanum Srinivas <>
 * Euan Kemp <>
 * Guilherme Rezende <>
 * Haiyan Meng <>
 * Hushan Jia <>
 * Jiuyue Ma <>
 * Johnny Bieren <>
 * Jonathan Boulle <>
 * Justin Cormack <>
 * Kenfe-Mickael Laventure <>
 * Michael Crosby <>
 * Mike Brown <>
 * Mrunal Patel <>
 * Peng Gao <>
 * Petar Petrov <>
 * Phil Estes <>
 * Qiang Huang <>
 * Serge Hallyn <>
 * Seth Jennings <>
 * Shukui Yang <>
 * Tristan Cacqueray <>
 * Vishnu kannan <>
 * Wang Long <>
 * Yang Hongyang <>
 * Yen-Lin Chen <>
 * Yuanhong Peng <>
 * Zhang Wei <>
 * Zhao Lei <>
 * rajasec <>
 * xiekeyang <>
Merge pull request #1088 from crosbymichael/rc2

Bump spec and version to rc2
tree: e5ea13abd62da59560dd6a07e57055018ead43a0
  1. contrib/
  2. Godeps/
  3. libcontainer/
  4. man/
  5. script/
  6. tests/
  7. .gitignore
  8. .pullapprove.yml
  9. checkpoint.go
  11. create.go
  12. delete.go
  13. Dockerfile
  14. events.go
  15. exec.go
  16. kill.go
  18. list.go
  19. main.go
  20. main_solaris.go
  21. main_unix.go
  22. main_unsupported.go
  25. Makefile
  26. NOTICE
  27. pause.go
  29. ps.go
  31. restore.go
  32. rlimit_linux.go
  33. run.go
  34. signals.go
  35. spec.go
  36. start.go
  37. state.go
  38. tty.go
  39. update.go
  40. utils.go
  41. utils_linux.go

[![Build Status]( Master)]( Master)


runc is a CLI tool for spawning and running containers according to the OCI specification.


runc depends on and tracks the runtime-spec repository. We will try to make sure that runc and the OCI specification major versions stay in lockstep. This means that runc 1.0.0 should implement the 1.0 version of the specification.

You can find official releases of runc on the release page.


runc currently supports the Linux platform with various architecture support. It must be built with Go version 1.6 or higher in order for some features to function properly.

# create a '' in your GOPATH/src
git clone
cd runc

sudo make install

runc will be installed to /usr/local/sbin/runc on your system.

In order to enable seccomp support you will need to install libseccomp on your platform. If you do not want to build runc with seccomp support you can add BUILDTAGS="" when running make.

Build Tags

runc supports optional build tags for compiling support of various features. To add build tags to the make option the BUILDTAGS variable must be set.

make BUILDTAGS='seccomp apparmor'
Build TagFeatureDependency
seccompSyscall filteringlibseccomp
selinuxselinux process and mount labeling
apparmorapparmor profile supportlibapparmor

Running the test suite

runc currently supports running its test suite via Docker. To run the suite just type make test.

make test

There are additional make targets for running the tests outside of a container but this is not recommended as the tests are written with the expectation that they can write and remove anywhere.

You can run a specific test case by setting the TESTFLAGS variable.

# make test TESTFLAGS="-run=SomeTestFunction"

Using runc

Creating an OCI Bundle

In order to use runc you must have your container in the format of an OCI bundle. If you have Docker installed you can use its export method to acquire a root filesystem from an existing Docker container.

# create the top most bundle directory
mkdir /mycontainer
cd /mycontainer

# create the rootfs directory
mkdir rootfs

# export busybox via Docker into the rootfs directory
docker export $(docker create busybox) | tar -C rootfs -xvf -

After a root filesystem is populated you just generate a spec in the format of a config.json file inside your bundle. runc provides a spec command to generate a base template spec that you are then able to edit. To find features and documentation for fields in the spec please refer to the specs repository.

runc spec

Running Containers

Assuming you have an OCI bundle from the previous step you can execute the container in two different ways.

The first way is to use the convenience command run that will handle creating, starting, and deleting the container after it exits.

cd /mycontainer

runc run mycontainerid

If you used the unmodified runc spec template this should give you a sh session inside the container.

The second way to start a container is using the specs lifecycle operations. This gives you move power of how the container is created and managed while it is running. This will also launch the container in the background so you will have to edit the config.json to remove the terminal setting for the simple examples here. Your process field in the config.json should look like this below with "terminal": false and "args": ["sleep", "5"].

        "process": {
                "terminal": false,
                "user": {
                        "uid": 0,
                        "gid": 0
                "args": [
                        "sleep", "5"
                "env": [
                "cwd": "/",
                "capabilities": [
                "rlimits": [
                                "type": "RLIMIT_NOFILE",
                                "hard": 1024,
                                "soft": 1024
                "noNewPrivileges": true

Now we can go though the lifecycle operations in your shell.

cd /mycontainer

runc create mycontainerid

# view the container is created and in the "created" state
runc list

# start the process inside the container
runc start mycontainerid

# after 5 seconds view that the container has exited and is now in the stopped state
runc list

# now delete the container
runc delete mycontainerid

This adds more complexity but allows higher level systems to manage runc and provides points in the containers creation to setup various settings after the container has created and/or before it is deleted. This is commonly used to setup the container‘s network stack after create but before start where the user’s defined process will be running.


runc can be used with process supervisors and init systems to ensure that containers are restarted when they exit. An example systemd unit file looks something like this.

Description=Start My Container

ExecStart=/usr/local/sbin/runc run -d --pid-file /run/ mycontainerid
ExecStopPost=/usr/local/sbin/runc delete mycontainerid