Difference between revisions of "Linux Containers"

From ArchWiki
Jump to: navigation, search
(Readying the host for virtualization: add solution for clean container shutdown)
(add link to AUR package)
 
(211 intermediate revisions by 52 users not shown)
Line 1: Line 1:
 
[[Category:Security]]
 
[[Category:Security]]
 
[[Category:Virtualization]]
 
[[Category:Virtualization]]
{{Stub|Currently just a rough draft... I think I will need to restructure this a bit and I have also noticed I have become a bit too verbose -_-;; I will be along shortly to complete this as well as clean it up.}}
+
[[ja:Linux Containers]]
 +
[[pt:Linux Containers]]
 +
{{Related articles start}}
 +
{{Related|AirVPN}}
 +
{{Related|ABS}}
 +
{{Related|Cgroups}}
 +
{{Related|Docker}}
 +
{{Related|LXD}}
 +
{{Related|OpenVPN}}
 +
{{Related|OpenVPN (client) in Linux containers}}
 +
{{Related|OpenVPN (server) in Linux containers}}
 +
{{Related|PeerGuardian Linux}}
 +
{{Related|systemd-nspawn}}
 +
{{Related articles end}}
  
==Introduction==
+
Linux Containers (LXC) is an operating-system-level virtualization method for running multiple isolated Linux systems (containers) on a single control host (LXC host). It does not provide a virtual machine, but rather provides a virtual environment that has its own CPU, memory, block I/O, network, etc. space and the resource control mechanism. This is provided by  [[Wikipedia:Linux namespaces|namespaces]] and [[cgroups]] features in Linux kernel on LXC host. It is similar to a chroot, but offers much more isolation.
  
===Synopsis===
+
Alternatives for using containers are [[systemd-nspawn]], [[docker]] or also the {{Pkg|rkt}} package.
  
Linux Containers (LXC) are an operating system-level virtualization method for running multiple isolated server installs (containers) on a single control host. LXC does not provide a virtual machine, but rather provides a virtual environment that has its own process and network space. It is similar to a chroot, but offers much more isolation.
+
== Privileged containers or unprivileged containers ==
 +
LXCs can be setup to run in either ''privileged'' or ''unprivileged'' configurations.
  
===About this HowTo===
+
In general, running an ''unprivileged'' container is [https://www.stgraber.org/2014/01/17/lxc-1-0-unprivileged-containers considered safer] than running a ''privileged'' container since ''unprivileged'' containers have an increased degree of isolation by virtue of their design.  Key to this is the mapping of the root UID in the container to a non-root UID on the host which makes it more difficult for a hack within the container to lead to consequences on host system.  In other words, if an attacker manages to escape the container, he or she should find themselves with no rights on the host.
  
This document is intended as an overview on setting up and deploying containers, and is not an in depth detailed instruction by instruction guide. A certain amount of prerequisite knowledge and skills are assumed (running commands as root, kernel configuration, mounting filesystems, shell scripting, chroot type environments, networking setup, etc).
+
The Arch packages currently provide out-of-the-box support for ''privileged'' containers only.  This is due to the current Arch {{pkg|linux}} kernel '''not''' shipping with user namespaces configured. This article contains information for users to run either type of container, but additional setup is required to use ''unprivileged'' containers at this time.
  
Much of this was taken verbatim from [http://lxc.teegra.net/ Dwight Schauer], [http://tuxce.selfip.org/informatique/conteneurs-linux-lxc Tuxce] and [http://artisan.karma-lab.net/node/1749 Ulhume]. It has been copied here both to enable to community to share their collective wisdom and to expand on a few points.
+
{{Note|A request has been filed to include user namespace support in the kernel: {{Bug|36969}}. However, the request has been closed because of the numerous security issues caused by user namespaces, which are frequently discovered.}}
  
===Less verbose tutorial===
+
=== An example to illustrate unprivileged containers ===
  
[[User:Delerious010|Delerious010]] 21:43, 1 December 2009 (EST) I have come to realize I have added a lot of text to this HowTo. If you would like something more streamlined, please head on over to [http://lxc.teegra.net/ http://lxc.teegra.net/] for Dwight's excellent guide.
+
To illustrate the power of UID mapping, consider the output below from a running, ''unprivileged'' container. Therein, we see the containerized processes owned by the containerized root user in the output of {{ic|ps}}:
  
===Testing capabilities===
+
[root@unprivileged_container /]# ps -ef | head -n 5
 +
UID        PID  PPID  C STIME TTY          TIME CMD
 +
root        1    0  0 17:49 ?        00:00:00 /sbin/init
 +
root        14    1  0 17:49 ?        00:00:00 /usr/lib/systemd/systemd-journald
 +
dbus        25    1  0 17:49 ?        00:00:00 /usr/bin/dbus-daemon --system --address=systemd: --nofork --nopidfile --systemd-activation
 +
systemd+    26    1  0 17:49 ?        00:00:00 /usr/lib/systemd/systemd-networkd
  
Once the lxc package is installed, running lxc-checkconfig will print out a list of your system's capabilities
+
On the host however, those containerized root processes are running as the mapped user (ID>100000) on the host, not as the root user on the host:
 +
[root@host /]# lxc-info -Ssip --name sandbox
 +
State:          RUNNING
 +
PID:            26204
 +
CPU use:        10.51 seconds
 +
BlkIO use:      244.00 KiB
 +
Memory use:    13.09 MiB
 +
KMem use:      7.21 MiB
  
==Host configuration==
+
[root@host /]# ps -ef | grep 26204 | head -n 5
 +
UID        PID  PPID  C STIME TTY          TIME CMD
 +
100000  26204 26200  0 12:49 ?        00:00:00 /sbin/init
 +
100000  26256 26204  0 12:49 ?        00:00:00 /usr/lib/systemd/systemd-journald
 +
100081  26282 26204  0 12:49 ?        00:00:00 /usr/bin/dbus-daemon --system --address=systemd: --nofork --nopidfile --systemd-activation
 +
100000  26284 26204  0 12:49 ?        00:00:00 /usr/lib/systemd/systemd-logind
  
===Control group filesystem===
+
== Setup ==
 +
=== Required software ===
 +
Installing {{Pkg|lxc}} and {{Pkg|arch-install-scripts}} will allow the host system to run privileged lxcs.
  
LXC depends on the control group filesystem being mounted. The standard location for it is {{ic|/sys/fs/cgroup}}. If you use systemd, the cgroup filesystem will be mounted automatically, including the default controllers, but with other initsystems you might have to do it yourself:
+
==== Enable support to run unprivileged contains (optional) ====
 +
Users wishing to run ''unprivileged'' containers need to complete several additional setup steps.
  
  mount -t tmpfs none /sys/fs/cgroup
+
Firstly, a custom kernel is required that has support for User namespaces. This option is available under '''General setup>Namespaces support>User namespace''' from an nconfig, or by simply modifying the kernel [[PKGBUILD]] with the following line inserted prior to the "make prepare" line:
 +
sed -i -e 's/# CONFIG_USER_NS is not set/CONFIG_USER_NS=y/' ./.config
  
===Userspace tools===
+
See, [[ABS]] for more on compiling a custom kernel.
  
Install {{Pkg|lxc}} from [community].
+
Secondly, modify {{ic|/etc/lxc/default.conf}} to contain the following lines:
 +
lxc.id_map = u 0 100000 65536
 +
lxc.id_map = g 0 100000 65536
  
===Bridge device setup===
+
Finally, create both {{ic|/etc/subuid}} and {{ic|/etc/subgid}} to contain the mapping to the containerized uid/gid pairs for each user who shall be able to run the containers.  The example below is simply for the root user (and systemd system unit):
  
The package {{pkg|bridge-utils}}, which provides the {{ic|brctl}} command, provides the ability to set up one or more network bridges to be used by LXC. You can use {{ic|brctl}} directly to set up the bridges, but the process is archaic and probably best avoided.
+
{{hc|/etc/subuid|<nowiki>
 +
root:100000:65536
 +
</nowiki>}}
  
If using netcfg, you could try to refer to the [[netcfg]] wiki page, but the bridge related documentation has been removed. So when using netcfg, you will be mostly on your own.
+
{{hc|/etc/subgid|<nowiki>
 +
root:100000:65536
 +
</nowiki>}}
  
OpenVPN has complete instructions for setting up a bridge, so it is probably your best option at the current. [[OpenVPN Bridge]]
+
=== Host network configuration ===
 +
LXCs support different virtual network types and devices (see [https://linuxcontainers.org/lxc/manpages//man5/lxc.container.conf.5.html lxc.container.conf(5)]). A bridge device on the host is required for most types of virtual networking.  Users are referred to the [[Network bridge]] article.
  
===Starting a container on boot with [[Systemd]]===
+
=== Container creation ===
 +
For ''privileged'' containers, simply select a template from {{ic|/usr/share/lxc/templates}} that matches the target distro to containerize.  Users wishing to containerize non-Arch distros will need additional packages on the host depending on the target distro:
 +
* Debian-based: {{Pkg|debootstrap}}
 +
* Fedora-based: {{AUR|yum}}
  
If you completed a container, starting it when the host boots is possible with the following systemd service template:
+
Run {{ic|lxc-create}} to create the container, which installs the root filesystem of the LXC to {{ic|/var/lib/lxc/CONTAINER_NAME/rootfs}} by default.  Example creating an Arch Linux LXC named "playtime":
 +
# lxc-create -n playtime -t /usr/share/lxc/templates/lxc-archlinux
  
{{bc|1=
+
Users wishing to run ''unprivileged'' containers should use the -t download directive and select from the images that are displayed.  For example:
[Unit]
+
# lxc-create -n playtime -t download
Description=Linux Container
 
After=network.target
 
  
[Service]
+
Alternatively, create a ''privileged'' container, and see: [[#Converting a privileged container to an unprivileged container]].
Type=forking
 
ExecStartPre=/bin/mount --make-rprivate /
 
ExecStart=/usr/bin/lxc-start -dn CONTAINER_NAME
 
ExecStop=/usr/bin/lxc-stop -n CONTAINER_NAME
 
  
[Install]
+
{{Tip|Users may optionally install {{Pkg|haveged}} and [[start]] {{ic|haveged.service}} to avoid a perceived hang during the setup process while waiting for system entropy to be seeded.  Without it, the generation of private/GPG keys can add a lengthy wait to the process.}}
WantedBy=multi-user.target
 
}}
 
Replace CONTAINER_NAME with the name of your container and save this file as /etc/systemd/system/lxc-CONTAINER_NAME.service
 
  
==Container setup==
+
{{Tip|Users of [[Btrfs]] can append {{ic|-B btrfs}} to create a Btrfs subvolume for storing containerized rootfs. This comes in handy if cloning containers with the help of {{ic|lxc-clone}} command. [[ZFS]] users may use {{ic|-B zfs}}, correspondingly.}}
  
'''Note''' Configuring a container that runs systemd requires specific configuration that is discussed [[lxc-systemd|here]].
+
=== Container configuration ===
 +
The examples below can be used with ''privileged'' and ''unprivileged'' containers alike.  Note that for unprivileged containers, additional lines will be present by default which are not shown in the examples, including the {{ic|1=lxc.id_map = u 0 100000 65536}} and the {{ic|1=lxc.id_map = g 0 100000 65536}} values optionally defined in the [[#Enable support to run unprivileged contains (optional)]] section.
  
There are various different means to do this
+
==== Basic config with networking ====
 +
System resources to be virtualized/isolated when a process is using the container are defined in {{ic|/var/lib/lxc/CONTAINER_NAME/config}}. By default, the creation process will make a minimum setup without networking support.  Below is an example config with networking:
  
===Creating the filesystem===
+
{{hc|/var/lib/lxc/playtime/config|<nowiki>
 +
# Template used to create this container: /usr/share/lxc/templates/lxc-archlinux
 +
# Parameters passed to the template:
 +
# For additional config options, please look at lxc.container.conf(5)
  
====Bootstrap====
+
## default values
Bootstrap an install ( [http://blog.mudy.info/tag/mkarchroot/ mkarchroot], [http://wiki.debian.org/Debootstrap debootstrap], [http://www.xen-tools.org/software/rinse/faq.html rinse], [[Install From Existing Linux]] ). You can also just copy/use an existing installation’s complete root filesystem.
+
lxc.rootfs = /var/lib/lxc/playtime/rootfs
 +
lxc.utsname = playtime
 +
lxc.arch = x86_64
 +
lxc.include = /usr/share/lxc/config/archlinux.common.conf
  
For example, install a small debian to /home/lxc/debianfs
+
## network
 +
lxc.network.type = veth
 +
lxc.network.link = br0
 +
lxc.network.flags = up
 +
lxc.network.name = eth0
 +
lxc.network.hwaddr = ee:ec:fa:e9:56:7d
 +
# uncomment the next two lines if static IP addresses are needed
 +
# leaving these commented will imply DHCP networking
 +
#
 +
#lxc.network.ipv4 = 192.168.0.3/24
 +
#lxc.network.ipv4.gateway = 192.168.0.1
 +
</nowiki>}}
  
yaourt -S debootstrap # install debootstrap from AUR
+
{{Note|The lxc.network.hwaddr entry is optional and if skipped, a random MAC address will be created automatically. It can be advantageous to define a MAC address for the container to allow the DHCP server to always assign the same IP to the container's NIC (beyond the scope of this article but worth mentioning).}}
  
# method 1:
+
==== Mounts within the container ====
sudo debootstrap wheezy /home/lxc/debianfst http://ftp.us.debian.org/debian  # use us mirror site install wheezy version
+
For ''privileged'' containers, one can select directories on the host to bind mount to the containerThis can be advantageous for example if the same architecture is being containerize and one wants to share pacman packages between the host and container. Another example could be shared directoriesThe syntax is simple:
  # or, method 2:  use faster tar ball method
 
sudo debootstrap --make-tarball wheezy.packages.tgz sid http://debian.osuosl.org/debian/
 
  sudo debootstrap --unpack-tarball wheezy.packages.tgz wheezy debianfs
 
  
====Download existing====
+
lxc.mount.entry = /var/cache/pacman/pkg var/cache/pacman/pkg none bind 0 0
You can download a base install tar ball. OpenVZ templates work just fine.
 
  
====Using the lxc tools====
+
{{Note|This will not work without filesystem permission modifications on the host if using ''unprivileged'' containers.}}
  /usr/bin/lxc-debian {create|destroy|purge|help}
+
==== Xorg program considerations (optional) ====
  /usr/bin/lxc-fedora {create|destroy|purge|help}
+
In order to run programs on the host's display, some bind mounts need to be defined so that the containerized programs can access the host's resources.  Add the following section to {{ic|/var/lib/lxc/playtime/config}}:
 +
## for xorg
 +
## fix overmounting see: https://github.com/lxc/lxc/issues/434
 +
lxc.mount.entry = tmpfs tmp tmpfs defaults
 +
lxc.mount.entry = /dev/dri dev/dri none bind,optional,create=dir
 +
lxc.mount.entry = /dev/snd dev/snd none bind,optional,create=dir
 +
  lxc.mount.entry = /tmp/.X11-unix tmp/.X11-unix none bind,optional,create=dir
 +
  lxc.mount.entry = /dev/video0 dev/video0 none bind,optional,create=file
  
Nowadays you can create small and simple archlinux container
+
If you still get a permission denied error in your LXC guest, then you may need to call {{ic|xhost +}} in your host to allow the guest to connect to the host's display server. Take note of the security concerns of opening up your display server by doing this.
# lxc-create -n containername -t archlinux -- -P vim,dhclient
 
  
with the template specific options ''-P'' you can add a list of packages to the installation.
+
{{Note|This will not work if using ''unprivileged'' containers.}}
 +
==== OpenVPN considerations ====
  
===Creating the device nodes===
+
Users wishing to run [[OpenVPN]] within the container are direct to either [[OpenVPN (client) in Linux containers]] and/or [[OpenVPN (server) in Linux containers]].
Since [[udev]] does not work within the container, you will want to make sure that a certain minimum amount of devices is created for it. This may be done with the following script:
 
#!/bin/bash
 
ROOT=$(pwd)
 
DEV=${ROOT}/dev
 
mv ${DEV} ${DEV}.old
 
mkdir -p ${DEV}
 
mknod -m 666 ${DEV}/null c 1 3
 
mknod -m 666 ${DEV}/zero c 1 5
 
mknod -m 666 ${DEV}/random c 1 8
 
mknod -m 666 ${DEV}/urandom c 1 9
 
mkdir -m 755 ${DEV}/pts
 
mkdir -m 1777 ${DEV}/shm
 
mknod -m 666 ${DEV}/tty c 5 0
 
mknod -m 600 ${DEV}/console c 5 1
 
mknod -m 666 ${DEV}/tty0 c 4 0
 
mknod -m 666 ${DEV}/full c 1 7
 
mknod -m 600 ${DEV}/initctl p
 
mknod -m 666 ${DEV}/ptmx c 5 2
 
  
==Container configuration==
+
== Managing containers ==
 +
=== Basic usage ===
 +
To list all installed LXC containers:
 +
# lxc-ls -f
  
===Configuration file===
+
Systemd can be used to [[start]] and to [[stop]] LXCs via {{ic|lxc@CONTAINER_NAME.service}}.  [[Enable]] {{ic|lxc@CONTAINER_NAME.service}} to have it start when the host system boots.
  
The main configuration files are used to describe how to originally create a container. Though these files may be located anywhere, /etc/lxc is probably a good place.
+
Users can also start/stop LXCs without systemd.
 +
Start a container:
 +
# lxc-start -n CONTAINER_NAME
  
'''23/Aug/2010: Be aware that the kernel may not handle additional whitespace in the configuration file. This has been experienced on "lxc.cgroup.devices.allow" settings but may also be true on other settings. If in doubt use only one space wherever whitespace is required.'''
+
Stop a container:
 +
# lxc-stop -n CONTAINER_NAME
  
====Basic settings====
+
To login into a container:
 +
# lxc-console -n CONTAINER_NAME
  
lxc.utsname = $CONTAINER_NAME<br>
+
If when login you get pts/0 and lxc/tty1 use:
  lxc.mount = $CONTAINER_FSTAB
+
  # lxc-console -n CONTAINER_NAME -t 0
lxc.rootfs = $CONTAINER_ROOTFS<br>
 
lxc.network.type = veth
 
lxc.network.flags = up
 
lxc.network.link = br0
 
lxc.network.hwaddr = $CONTAINER_MACADDR
 
lxc.network.ipv4 = $CONTAINER_IPADDR
 
lxc.network.name = $CONTAINER_DEVICENAME
 
  
=====Basic settings explained=====
+
Once logged, treat the container like any other linux system, set the root password, create users, install packages, etc.
  
'''lxc.utsname''' : This will be the name of the cgroup for the container. Once the container is started, you should be able to see a new folder named ''/cgroup/$CONTAINER_NAME''.
+
To attach to a container:
 +
# lxc-attach -n CONTAINER_NAME
  
Furthermore, this will also be the value returned by ''hostname'' from within the container. Assuming you have not removed access, the container may overwrite this with it's init script.
+
It works nearly the same as lxc-console, but you are automatically accessing root prompt inside the container, bypassing login.
  
'''lxc.mount''' : This points to an fstab formatted file that is a listing of the mount points used when ''lxc-start'' is called. This file is further explained [[#Configuring fstab|further]]
+
=== Advanced usage ===
  
====Terminal settings====
+
==== LXC clones ====
 +
Users with a need to run multiple containers can simplify administrative overhead (user management, system updates, etc.) by using snapshots.  The strategy is to setup and keep up-to-date a single base container, then, as needed, clone (snapshot) it.  The power in this strategy is that the disk space and system overhead are truly minimized since the snapshots use an overlayfs mount to only write out to disk, only the differences in data.  The base system is read-only but changes to it in the snapshots are allowed via the overlayfs.
  
The following configuration is optional. You may add them to your main configuration file if you wish to login via lxc-console, or through a terminal ( e.g.: {{Keypress|Ctrl+Alt+F1}} ).
+
For example, setup a container as outlined above. We will call it "base" for the purposes of this guide. Now create 2 snapshots of "base" which we will call "snap1" and "snap2" with these commands:
 +
# lxc-copy -n base -N snap1 -B overlayfs -s
 +
# lxc-copy -n base -N snap2 -B overlayfs -s
  
The container can be configured with virtual consoles (tty devices). These may be devices from the host that the container is given permission to use (by its configuration file) or they may be devices created locally within the container.
+
{{Note|If a static IP was defined for the "base" lxc, that will need to manually changed in the config for "snap1" and for "snap2" before starting them. If the process is to be automated, a script using sed can do this automatically although this is beyond the scope of this wiki section.}}
  
The host's virtual consoles are accessed using the key sequence {{Keypress|Alt+Fn}} (or {{Keypress|Ctrl+Alt+Fn}} from within an X11 session). The left {{Keypress|Alt}} key reaches consoles 1 through 12 and the right {{Keypress|Alt}} key reaches consoles 13 through 24. Further virtual consoles may be reached by the {{Keypress|Alt+→}} key sequence which steps to the next virtual console.
+
The snapshots can be started/stopped like any other container.  Users can optionally destroy the snapshots and all new data therein with the following command. Note that the underlying "base" lxc is untouched:
 +
# lxc-destroy -n snap1 -f
  
The container's local virtual consoles may be accessed using the "lxc-console" command.
+
Systemd units and wrapper scripts to manage snapshots for [[pi-hole]] and [[openvpn]] are available to automate the process in {{AUR|lxc-snapshots}}.
  
===== Host Virtual Consoles =====
+
=== Converting a privileged container to an unprivileged container ===
 +
Once the system has been configured to use unprivileged containers (see, [[#Enable support to run unprivileged contains (optional)]]), {{AUR|nsexec-bzr}} contains a utility called {{ic|uidmapshift}} which is able to convert an existing ''privileged'' container to an ''unprivileged'' container to avoid a total rebuild of the image.
  
The container may access the host's virtual consoles if the host is not using them and the container's configuration allows it. Typical container configuration would deny access to all devices and then allow access to specific devices like this:
+
{{Warning|It is recommended to backup the existing image before using this utility!}}
  
  lxc.cgroup.devices.deny = a          # Deny all access to devices
+
{{Warning|This util will not shift uid/gid in facl, if your rootfs have any files configured with facl (like archlinux), you need shift to it by your own}}
  lxc.cgroup.devices.allow = c 4:0 rwm # /dev/tty0
 
  lxc.cgroup.devices.allow = c 4:1 rwm # /dev/tty1
 
  lxc.cgroup.devices.allow = c 4:2 rwm # /dev/tty2
 
  
For a container to be able to use a host's virtual console it must not be in use by the host. This will most likely require the host's {{ic|/etc/inittab}} to be modified to ensure no getty or other process runs on any virtual console that is to be used by the container.
+
Invoke the utility to convert over like so:
 +
# uidmapshift -b /var/lib/lxc/foo 0 100000 65536
  
After editing the host's {{ic|/etc/inittab}} file, issung a {{ic|killall -HUP init}} will terminate any getty processes that are no longer configured and this will free up the virtual conosole for use by the container.
+
Additional options are available simply by calling {{ic|uidmapshift}} without any arguments.
  
Note that local virtual consoles take precedence over host virtual consoles. This is described in the next section.
+
== Running Xorg programs ==
 +
Either attach to or [[SSH]] into the target container and prefix the call to the program with the DISPLAY ID of the host's X session. For most simple setups, the display is always 0.
  
===== Local Virtual Consoles =====
+
An example of running Firefox from the container in the host's display:
 +
$ DISPLAY=:0 firefox
  
The number of local virtual consoles that the container has is defined in the container's configuration file (normally on the host in {{ic|/etc/lxc}}). It is defined thus:
+
Alternatively, to avoid directly attaching to or connecting to the container, the following can be used on the host to automate the process:
 +
# lxc-attach -n playtime --clear-env -- sudo -u YOURUSER env DISPLAY=:0 firefox
  
  lxc.tty = n
+
== Troubleshooting ==
  
where {{ic|n}} is the number of local virtual consoles required.
+
=== Root login fails ===
  
The local virtual consoles are numbered starting at tty1 and take precedence over any of the host's virtual consoles that the container might be entitled to use. This means that, for example, if n = 2 then the container will not be able to use the host's tty1 and tty2 devices even entitled to do so by its configuration file. Setting n to 0 will prevent local virtual consoles from being created thus allowing full access to any of host's virtual consoles that the container might be entitled to use.
+
If you get the following error when you try to login using lxc-console:
  
===== /dev/tty Device Files =====
+
login: root
The container must have a tty device file (e.g. {{ic|/dev/tty1}}) for each virtual console (host or local). These can be created thus:
+
  Login incorrect
  # mknod -m 666 /dev/tty1 c 4 1
 
# mknod -m 666 /dev/tty2 c 4 2
 
  
and so on...
+
And the container's {{ic|journalctl}} shows:
  
In the above, {{ic|c}} means character device, {{ic|4}} is the major device number (tty devices) and {{ic|1}}, {{ic|2}}, {{ic|3}}, etc., is the minor device number (specific tty device). Note that {{ic|/dev/tty0}} is special and always refers to the current virtual console.
+
pam_securetty(login:auth): access denied: tty 'pts/0' is not secure !
  
For further info on tty devices, read this: http://www.kernel.org/pub/linux/docs/device-list/devices.txt
+
Add {{ic|pts/0}} to the list of terminal names in {{ic|/etc/securetty}} on the '''container''' filesystem, see [http://unix.stackexchange.com/questions/41840/effect-of-entries-in-etc-securetty/41939#41939]. You can also opt to delete {{ic|/etc/securetty}} on the '''container''' to allow always root to login, see [https://github.com/systemd/systemd/issues/852].
  
'''If a virtual console's device file does not exist in the container, then the container cannot use the virtual console.'''
+
Alternatively, create a new user in lxc-attach and use it for logging in to the system, then switch to root.
  
===== Configuring Log-In Ability =====
+
# lxc-attach -n playtime
 +
[root@playtime]# useradd -m -Gwheel newuser
 +
[root@playtime]# passwd newuser
 +
[root@playtime]# passwd root
 +
[root@playtime]# exit
 +
# lxc-console -n playtime
 +
[newuser@playtime]$ su
  
The container's virtual consoles may be used for login sessions if the container runs "getty" services on their tty devices. This is normally done by the container's "init" process and is configured in the container's {{ic|/etc/inittab}} file using lines like this:
+
===No network-connection with veth in container config===
  
  c1:2345:respawn:/sbin/agetty -8 38400 tty1 linux
+
If you cannot access your LAN or WAN with a networking interface configured as '''veth''' and setup through {{ic|/etc/lxc/''containername''/config}}.
 +
If the virtual interface gets the ip assigned and should be connected to the network correctly.
 +
ip addr show veth0
 +
inet 192.168.1.111/24
 +
You may disable all the relevant static ip formulas and try setting the ip through the booted container-os like you would normaly do.
  
There is one line per device. The first part {{ic|c1}} is just a unique label, the second part defines applicable run levels, the third part tells init to start a new getty when the current one terminates and the last part gives the command line for the getty. For further information refer to {{ic|man init}}.
+
Example {{ic|''container''/config}}
  
If there is no getty process on a virtual console it will not be possible to log in via that virtual console. A getty is not required on a virtual console unless it is to be used to log in.
+
  ...
 
+
  lxc.network.type = veth
If a virtual console is to allow root logins it also needs to be listed in the container's {{ic|/etc/securetty}} file.
+
  lxc.network.name = veth0
 
+
  lxc.network.flags = up
===== Troubleshooting virtual consoles =====
+
  lxc.network.link = {{ic|bridge}}
 
+
  ...
If lxc.tty is set to a number, n, then no host devices numbered n or below will be accessible even if the above configuration is present because they will be replaced with local virtual consoles instead.
 
 
 
A tty device file's major number will change from 4 to 136 if it is a local virtual console. This change is visible within the container but not when viewing the container's devices from the host's filesystem. This information is useful when troubleshooting.
 
 
 
This can be checked from within a container thus:
 
 
 
  # ls -Al /dev/tty*
 
  crw------- 1 root root 136, 10 Aug 21 21:28 /dev/tty1
 
  crw------- 1 root root  4, 2  Aug 21 21:28 /dev/tty2
 
 
 
===== Pseudo Terminals =====
 
 
 
  lxc.pseudo = 1024
 
 
 
Maximum amount of pseudo terminals that may be created in {{ic|/dev/pts}}. Currently, assuming the kernel was compiled with {{ic|CONFIG_DEVPTS_MULTIPLE_INSTANCES}}, this tells lxc-start to mount the devpts filesystem with the newinstance flag.
 
 
 
====Host device access settings====
 
 
 
lxc.cgroup.devices.deny = a # Deny all access to devices<br>
 
lxc.cgroup.devices.allow = c 1:3 rwm # dev/null
 
lxc.cgroup.devices.allow = c 1:5 rwm # dev/zero<br>
 
lxc.cgroup.devices.allow = c 5:1 rwm # dev/console
 
lxc.cgroup.devices.allow = c 5:0 rwm # dev/tty
 
lxc.cgroup.devices.allow = c 4:0 rwm # dev/tty0<br>
 
  lxc.cgroup.devices.allow = c 1:9 rwm # dev/urandom
 
  lxc.cgroup.devices.allow = c 1:8 rwm # dev/random
 
  lxc.cgroup.devices.allow = c 136:* rwm # dev/pts/*
 
  lxc.cgroup.devices.allow = c 5:2 rwm # dev/pts/ptmx<br>
 
# No idea what this is .. dev/bsg/0:0:0:0 ???
 
  lxc.cgroup.devices.allow = c 254:0 rwm
 
 
 
=====Host device access settings explained=====
 
 
 
'''lxc.cgroup.devices.deny''' : By settings this to ''a'', we are stating that the container has access to no devices unless explicitely defined within the configuration file.
 
 
 
===Configuration file notes===
 
====At runtime /dev/ttyX devices are recreated====
 
If you have enabled multiple DevPTS instances in your kernel, lxc-start will recreate ''lxc.tty'' amount of {{ic|/dev/ttyX}} devices when it is executed.
 
 
 
This means that you will have ''lxc.tty'' amount of pseudo ttys. If you are planning on accessing the container via a "real" terminal ({{Keypress|Ctrl+Alt+FX}}), make sure that it is a number that is inferior to ''lxc.tty''.
 
 
 
To tell whether it has been re-created, just log in to the container via either lxc-console or SSH and perform a {{ic|ls -Al}} command on the tty. Devices with a major number of 4 are "real" tty devices whereas a major number of 136 indicates a pts.
 
 
 
Be aware that this is only visible from within the container itself and not from the host.
 
 
 
====Containers have access to host's TTY nodes====
 
 
 
If you do not properly restrict the container's access to the /dev/tty nodes, the container may have access to the host's.
 
 
 
Taking into consideration that, as previously mentioned, lxc-start recreates ''lxc.tty'' amount of /dev/tty devices, any tty nodes present in the container that are of a greater minor number than ''lxc.tty'' will be linked to the host's.
 
 
 
=====To access the container from a host TTY=====
 
 
 
# On the host, verify no getty is started for that tty by checking ''/etc/inittab''.
 
# In the container, start a getty for that tty.
 
 
 
=====To prevent access to the host TTY=====
 
 
 
Please have a look at the configuration statements found in [[#Host device access settings|host device access settings]].
 
 
 
Via the ''lxc.cgroup.devices.deny = a'' we are preventing access to all host level devices. And then, throuh ''lxc.cgroup.devices.allow = c 4:'''1''' rwm'' we are allowing access to the host's /dev/tty'''1'''. In the above example, simply removing all allow statements for major number 4 and minor > 1 should be sufficient.
 
 
 
=====To test this access=====
 
 
 
I may be off here, but looking at the output of the ''ls'' command below should show you both the ''major'' and ''minor'' device numbers. These are located after the user and group and represented as : 4, 2
 
 
 
# Set lxc.tty to 1
 
# Make there that the container has dev/tty1 and /dev/tty2
 
# ''lxc-start'' the container
 
# ''lxc-console'' into the container
 
# ''ls -Al /dev/tty''<br>crw------- 1 root root 4, 2 Dec  2 00:20 /dev/tty2
 
# ''echo "test output" > /dev/tty2''
 
# ''Ctrl+Alt+F2'' to view the host's second terminal
 
# You should see "test output" printed on the screen
 
 
 
====Configuration troubleshooting====
 
 
 
=====console access denied: Permission denied=====
 
 
 
If, when executing lxc-console, you receive the error ''lxc-console: console access denied: Permission denied'' you have most likely either omitted lxc.tty or set it to 0.
 
 
 
=====lxc-console does not provide a login prompt=====
 
 
 
Though you are reaching a tty on the container, it most likely is not running a getty. You will want to double check that you have a getty defined in the container's ''/etc/inittab'' for the specific tty.
 
 
 
If using '''systemd''' chances are that a problem with the ''getty@.service'' script will bite you. The script only starts a getty if ''/dev/tty0'' exists. And since this condition is not met in the container, you get no getty. Use this patch, to let ''lxc-console'' finally work.
 
 
 
<pre>
 
--- /usr/lib/systemd/system/getty@.service.orig 2013-05-30 12:55:28.000000000 +0000
 
+++ /usr/lib/systemd/system/getty@.service      2013-06-16 23:05:49.827146901 +0000
 
@@ -20,7 +20,8 @@
 
# On systems without virtual consoles, don't start any getty. (Note
 
# that serial gettys are covered by serial-getty@.service, not this
 
# unit
 
-ConditionPathExists=/dev/tty0
 
+ConditionVirtualization=|lxc
 
+ConditionPathExists=|/dev/tty0
 
 
[Service]
 
# the VT is cleared by TTYVTDisallocate
 
</pre>
 
 
 
For more than one getty you have to explicitly enable the needed service (and decrease ''lxc.tty'' in the container configuration). In the ''real'' system a configurable number of getty-services is automatically created from the ''systemd-logind.service''
 
 
 
===Configuring fstab===
 
none $CONTAINER_ROOTFS/dev/pts devpts defaults 0 0
 
none $CONTAINER_ROOTFS/proc    proc  defaults 0 0
 
none $CONTAINER_ROOTFS/sys    sysfs  defaults 0 0
 
none $CONTAINER_ROOTFS/dev/shm tmpfs  defaults 0 0
 
 
 
This fstab is used by lxc-start when mounting the container. As such, you can define any mount that would be possible on the host such as bind mounting to the host's own filesystem. However, please be aware of any and all security implications that this may have.
 
 
 
'''Warning''' : You certainly do not want to bind mount the host's /dev to the container as this would allow it to, amongst other things, reboot the host.
 
 
 
==Container Creation and Destruction==
 
 
 
===Creation===
 
  lxc-create -f $CONTAINER_CONFIGPATH -n $CONTAINER_NAME
 
 
 
''lxc-create'' will create /var/lib/lxc/$CONTAINER_NAME with a new copy of the container configuration file found in $CONTAINER_CONFIGPATH.
 
 
 
As such, if you need to make modifications to the container's configuration file, it's advisable to modify only the original file and then perform ''lxc-destroy'' and ''lxc-create'' operations afterwards. No data will be lost by doing this.
 
 
 
'''Note''' : When copying the file over, lxc-create will strip all comments from the file.
 
 
 
'''Note''' : As of lxc-git from atleast ''2009-12-01'', performing lxc-create no longer splits the config file into multiple files and folders. Therefore, we only have the configuration file to worry about.
 
 
 
===Destruction===
 
lxc-destroy -n $CONTAINER_NAME
 
 
 
This will delete /var/lib/lxc/$CONTAINER_NAME which only contains configuration files. No data will be lost.
 
 
 
==Readying the host for virtualization==
 
===/etc/inittab===
 
# Comment out any getty that are not required
 
  
===/etc/rc.sysinit replacement===
+
And then assign your IP through your preferred method '''inside''' the container, see also [[Network configuration#Configure the IP address]]{{Broken section link}}.
Since we are running in a virtual environment, a number of steps undertaken by rc.sysinit are superfluous and may even flat out fail or stall. As such, until the initscripts are made virtualization aware, this will take some hack and slash.
 
  
For now, simply replace the file :
+
===Cannot start unprivileged LXC due to newuidmap execution failure===
#!/bin/bash
 
# Whatever is needed to clean out old daemon/service pids from your container
 
rm -f $(find /var/run -name '*pid')
 
rm -f /var/lock/subsys/*<br>
 
# Configure network settings
 
## You can either use dhcp here, manually configure your
 
## interfaces or try to get the rc.d/network script working.
 
## There have been reports that network failed in this
 
## environment.
 
ip route add default via 192.168.10.1
 
echo > /etc/resolv.conf search your-domain
 
echo >> /etc/resolv.conf nameserver 192.168.10.1<br>
 
# Initally we do not have any container originated mounts
 
rm -f /etc/mtab
 
touch /etc/mtab
 
  
===/etc/rc.conf cleanup===
+
Unprivileged LXC cannot start with current shadow in official package, because of newuidmap and newgidmap is not setuid
You may want to remove any and all hardware related daemons from the DAEMONS line. Furthermore, depending on your situation, you may also want to remove the ''network'' daemon.
 
  
===TBC===
+
chmod u+s /usr/bin/newuidmap
 +
chmod u+s /usr/bin/newgidmap
  
==Known Problems==
+
This is a bug in upstream but still not cherry-picked in official repository
  
===Container cannot be shutdown if using systemd===
+
== See also ==
''lxc-shutdown'' should be used for clean shutdown or reboot of the container, but only the ''reboot'' is working out of the box when using systemd.
 
  
Shutdown will be signalled to the container with ''SIGPWR'' but current systemd doesn't have any services in place to handle the ''sigpwr.target''. But for the container we can simply reuse the ''poweroff.target'' and get exactly what we want.
+
* [https://www.stgraber.org/2013/12/20/lxc-1-0-blog-post-series/ LXC 1.0 Blog Post Series]
# ln -s /usr/lib/systemd/system/poweroff.target ${CONTAINER_RFS}/etc/systemd/system/sigpwr.target
+
* [http://www.ibm.com/developerworks/linux/library/l-lxc-containers/ LXC@developerWorks]
 +
* [http://docs.docker.io/en/latest/installation/archlinux/ Docker Installation on ArchLinux]

Latest revision as of 21:11, 21 July 2017

Linux Containers (LXC) is an operating-system-level virtualization method for running multiple isolated Linux systems (containers) on a single control host (LXC host). It does not provide a virtual machine, but rather provides a virtual environment that has its own CPU, memory, block I/O, network, etc. space and the resource control mechanism. This is provided by namespaces and cgroups features in Linux kernel on LXC host. It is similar to a chroot, but offers much more isolation.

Alternatives for using containers are systemd-nspawn, docker or also the rkt package.

Privileged containers or unprivileged containers

LXCs can be setup to run in either privileged or unprivileged configurations.

In general, running an unprivileged container is considered safer than running a privileged container since unprivileged containers have an increased degree of isolation by virtue of their design. Key to this is the mapping of the root UID in the container to a non-root UID on the host which makes it more difficult for a hack within the container to lead to consequences on host system. In other words, if an attacker manages to escape the container, he or she should find themselves with no rights on the host.

The Arch packages currently provide out-of-the-box support for privileged containers only. This is due to the current Arch linux kernel not shipping with user namespaces configured. This article contains information for users to run either type of container, but additional setup is required to use unprivileged containers at this time.

Note: A request has been filed to include user namespace support in the kernel: FS#36969. However, the request has been closed because of the numerous security issues caused by user namespaces, which are frequently discovered.

An example to illustrate unprivileged containers

To illustrate the power of UID mapping, consider the output below from a running, unprivileged container. Therein, we see the containerized processes owned by the containerized root user in the output of ps:

[root@unprivileged_container /]# ps -ef | head -n 5
UID        PID  PPID  C STIME TTY          TIME CMD
root         1     0  0 17:49 ?        00:00:00 /sbin/init
root        14     1  0 17:49 ?        00:00:00 /usr/lib/systemd/systemd-journald
dbus        25     1  0 17:49 ?        00:00:00 /usr/bin/dbus-daemon --system --address=systemd: --nofork --nopidfile --systemd-activation
systemd+    26     1  0 17:49 ?        00:00:00 /usr/lib/systemd/systemd-networkd

On the host however, those containerized root processes are running as the mapped user (ID>100000) on the host, not as the root user on the host:

[root@host /]# lxc-info -Ssip --name sandbox
State:          RUNNING
PID:            26204
CPU use:        10.51 seconds
BlkIO use:      244.00 KiB
Memory use:     13.09 MiB
KMem use:       7.21 MiB
[root@host /]# ps -ef | grep 26204 | head -n 5
UID        PID  PPID  C STIME TTY          TIME CMD
100000   26204 26200  0 12:49 ?        00:00:00 /sbin/init
100000   26256 26204  0 12:49 ?        00:00:00 /usr/lib/systemd/systemd-journald
100081   26282 26204  0 12:49 ?        00:00:00 /usr/bin/dbus-daemon --system --address=systemd: --nofork --nopidfile --systemd-activation
100000   26284 26204  0 12:49 ?        00:00:00 /usr/lib/systemd/systemd-logind

Setup

Required software

Installing lxc and arch-install-scripts will allow the host system to run privileged lxcs.

Enable support to run unprivileged contains (optional)

Users wishing to run unprivileged containers need to complete several additional setup steps.

Firstly, a custom kernel is required that has support for User namespaces. This option is available under General setup>Namespaces support>User namespace from an nconfig, or by simply modifying the kernel PKGBUILD with the following line inserted prior to the "make prepare" line:

sed -i -e 's/# CONFIG_USER_NS is not set/CONFIG_USER_NS=y/' ./.config

See, ABS for more on compiling a custom kernel.

Secondly, modify /etc/lxc/default.conf to contain the following lines:

lxc.id_map = u 0 100000 65536
lxc.id_map = g 0 100000 65536

Finally, create both /etc/subuid and /etc/subgid to contain the mapping to the containerized uid/gid pairs for each user who shall be able to run the containers. The example below is simply for the root user (and systemd system unit):

/etc/subuid
root:100000:65536
/etc/subgid
root:100000:65536

Host network configuration

LXCs support different virtual network types and devices (see lxc.container.conf(5)). A bridge device on the host is required for most types of virtual networking. Users are referred to the Network bridge article.

Container creation

For privileged containers, simply select a template from /usr/share/lxc/templates that matches the target distro to containerize. Users wishing to containerize non-Arch distros will need additional packages on the host depending on the target distro:

Run lxc-create to create the container, which installs the root filesystem of the LXC to /var/lib/lxc/CONTAINER_NAME/rootfs by default. Example creating an Arch Linux LXC named "playtime":

# lxc-create -n playtime -t /usr/share/lxc/templates/lxc-archlinux

Users wishing to run unprivileged containers should use the -t download directive and select from the images that are displayed. For example:

# lxc-create -n playtime -t download

Alternatively, create a privileged container, and see: #Converting a privileged container to an unprivileged container.

Tip: Users may optionally install haveged and start haveged.service to avoid a perceived hang during the setup process while waiting for system entropy to be seeded. Without it, the generation of private/GPG keys can add a lengthy wait to the process.
Tip: Users of Btrfs can append -B btrfs to create a Btrfs subvolume for storing containerized rootfs. This comes in handy if cloning containers with the help of lxc-clone command. ZFS users may use -B zfs, correspondingly.

Container configuration

The examples below can be used with privileged and unprivileged containers alike. Note that for unprivileged containers, additional lines will be present by default which are not shown in the examples, including the lxc.id_map = u 0 100000 65536 and the lxc.id_map = g 0 100000 65536 values optionally defined in the #Enable support to run unprivileged contains (optional) section.

Basic config with networking

System resources to be virtualized/isolated when a process is using the container are defined in /var/lib/lxc/CONTAINER_NAME/config. By default, the creation process will make a minimum setup without networking support. Below is an example config with networking:

/var/lib/lxc/playtime/config
# Template used to create this container: /usr/share/lxc/templates/lxc-archlinux
# Parameters passed to the template:
# For additional config options, please look at lxc.container.conf(5)

## default values
lxc.rootfs = /var/lib/lxc/playtime/rootfs
lxc.utsname = playtime
lxc.arch = x86_64
lxc.include = /usr/share/lxc/config/archlinux.common.conf

## network
lxc.network.type = veth
lxc.network.link = br0
lxc.network.flags = up
lxc.network.name = eth0
lxc.network.hwaddr = ee:ec:fa:e9:56:7d
# uncomment the next two lines if static IP addresses are needed
# leaving these commented will imply DHCP networking
#
#lxc.network.ipv4 = 192.168.0.3/24
#lxc.network.ipv4.gateway = 192.168.0.1
Note: The lxc.network.hwaddr entry is optional and if skipped, a random MAC address will be created automatically. It can be advantageous to define a MAC address for the container to allow the DHCP server to always assign the same IP to the container's NIC (beyond the scope of this article but worth mentioning).

Mounts within the container

For privileged containers, one can select directories on the host to bind mount to the container. This can be advantageous for example if the same architecture is being containerize and one wants to share pacman packages between the host and container. Another example could be shared directories. The syntax is simple:

lxc.mount.entry = /var/cache/pacman/pkg var/cache/pacman/pkg none bind 0 0
Note: This will not work without filesystem permission modifications on the host if using unprivileged containers.

Xorg program considerations (optional)

In order to run programs on the host's display, some bind mounts need to be defined so that the containerized programs can access the host's resources. Add the following section to /var/lib/lxc/playtime/config:

## for xorg
## fix overmounting see: https://github.com/lxc/lxc/issues/434
lxc.mount.entry = tmpfs tmp tmpfs defaults
lxc.mount.entry = /dev/dri dev/dri none bind,optional,create=dir
lxc.mount.entry = /dev/snd dev/snd none bind,optional,create=dir
lxc.mount.entry = /tmp/.X11-unix tmp/.X11-unix none bind,optional,create=dir
lxc.mount.entry = /dev/video0 dev/video0 none bind,optional,create=file

If you still get a permission denied error in your LXC guest, then you may need to call xhost + in your host to allow the guest to connect to the host's display server. Take note of the security concerns of opening up your display server by doing this.

Note: This will not work if using unprivileged containers.

OpenVPN considerations

Users wishing to run OpenVPN within the container are direct to either OpenVPN (client) in Linux containers and/or OpenVPN (server) in Linux containers.

Managing containers

Basic usage

To list all installed LXC containers:

# lxc-ls -f

Systemd can be used to start and to stop LXCs via lxc@CONTAINER_NAME.service. Enable lxc@CONTAINER_NAME.service to have it start when the host system boots.

Users can also start/stop LXCs without systemd. Start a container:

# lxc-start -n CONTAINER_NAME

Stop a container:

# lxc-stop -n CONTAINER_NAME

To login into a container:

# lxc-console -n CONTAINER_NAME

If when login you get pts/0 and lxc/tty1 use:

# lxc-console -n CONTAINER_NAME -t 0

Once logged, treat the container like any other linux system, set the root password, create users, install packages, etc.

To attach to a container:

# lxc-attach -n CONTAINER_NAME

It works nearly the same as lxc-console, but you are automatically accessing root prompt inside the container, bypassing login.

Advanced usage

LXC clones

Users with a need to run multiple containers can simplify administrative overhead (user management, system updates, etc.) by using snapshots. The strategy is to setup and keep up-to-date a single base container, then, as needed, clone (snapshot) it. The power in this strategy is that the disk space and system overhead are truly minimized since the snapshots use an overlayfs mount to only write out to disk, only the differences in data. The base system is read-only but changes to it in the snapshots are allowed via the overlayfs.

For example, setup a container as outlined above. We will call it "base" for the purposes of this guide. Now create 2 snapshots of "base" which we will call "snap1" and "snap2" with these commands:

# lxc-copy -n base -N snap1 -B overlayfs -s
# lxc-copy -n base -N snap2 -B overlayfs -s
Note: If a static IP was defined for the "base" lxc, that will need to manually changed in the config for "snap1" and for "snap2" before starting them. If the process is to be automated, a script using sed can do this automatically although this is beyond the scope of this wiki section.

The snapshots can be started/stopped like any other container. Users can optionally destroy the snapshots and all new data therein with the following command. Note that the underlying "base" lxc is untouched:

# lxc-destroy -n snap1 -f

Systemd units and wrapper scripts to manage snapshots for pi-hole and openvpn are available to automate the process in lxc-snapshotsAUR.

Converting a privileged container to an unprivileged container

Once the system has been configured to use unprivileged containers (see, #Enable support to run unprivileged contains (optional)), nsexec-bzrAUR contains a utility called uidmapshift which is able to convert an existing privileged container to an unprivileged container to avoid a total rebuild of the image.

Warning: It is recommended to backup the existing image before using this utility!
Warning: This util will not shift uid/gid in facl, if your rootfs have any files configured with facl (like archlinux), you need shift to it by your own

Invoke the utility to convert over like so:

# uidmapshift -b /var/lib/lxc/foo 0 100000 65536

Additional options are available simply by calling uidmapshift without any arguments.

Running Xorg programs

Either attach to or SSH into the target container and prefix the call to the program with the DISPLAY ID of the host's X session. For most simple setups, the display is always 0.

An example of running Firefox from the container in the host's display:

$ DISPLAY=:0 firefox

Alternatively, to avoid directly attaching to or connecting to the container, the following can be used on the host to automate the process:

# lxc-attach -n playtime --clear-env -- sudo -u YOURUSER env DISPLAY=:0 firefox

Troubleshooting

Root login fails

If you get the following error when you try to login using lxc-console:

login: root
Login incorrect

And the container's journalctl shows:

pam_securetty(login:auth): access denied: tty 'pts/0' is not secure !

Add pts/0 to the list of terminal names in /etc/securetty on the container filesystem, see [1]. You can also opt to delete /etc/securetty on the container to allow always root to login, see [2].

Alternatively, create a new user in lxc-attach and use it for logging in to the system, then switch to root.

# lxc-attach -n playtime
[root@playtime]# useradd -m -Gwheel newuser
[root@playtime]# passwd newuser
[root@playtime]# passwd root
[root@playtime]# exit
# lxc-console -n playtime
[newuser@playtime]$ su

No network-connection with veth in container config

If you cannot access your LAN or WAN with a networking interface configured as veth and setup through /etc/lxc/containername/config. If the virtual interface gets the ip assigned and should be connected to the network correctly.

ip addr show veth0 
inet 192.168.1.111/24

You may disable all the relevant static ip formulas and try setting the ip through the booted container-os like you would normaly do.

Example container/config

...
lxc.network.type = veth
lxc.network.name = veth0
lxc.network.flags = up
lxc.network.link = bridge
...

And then assign your IP through your preferred method inside the container, see also Network configuration#Configure the IP address[broken link: invalid section].

Cannot start unprivileged LXC due to newuidmap execution failure

Unprivileged LXC cannot start with current shadow in official package, because of newuidmap and newgidmap is not setuid

chmod u+s /usr/bin/newuidmap
chmod u+s /usr/bin/newgidmap

This is a bug in upstream but still not cherry-picked in official repository

See also