LXD FAQ – часто задаваемые вопросы по LXD

Вопрос: Что такое LXD?
Ответ: LXD это гипервизор контейнеров на основе LXC. Три основные компоненты:
  • A system-wide daemon (lxd)
  • A command line client (lxc)
  • An OpenStack Nova plugin (nova-compute-lxd)


Вопрос: Как установить LXD на Ubuntu?
Ответ:
apt-get install lxd

После устновки создается группа "lxd" в которой находятся пользователи которым позволено общаться с lxd через локальный unix socket. Члены групп "admin" и "sudoers" автоматически добавляютсяв группу lxd. Если ваш пользователь не является членом этих групп, то вам надо вручную добавить его к группе "lxd". После добавления своего пользователя в группу нужно закрыть и снова открыть свои пользовательские сессии, либо дать команду newgrp lxd

После установки нужно произвести инициализацию:
sudo lxd init


Вопрос: Как получить справку?
Ответ:

LXC 1.0: Blog post series [0/10]
Серия статей LXC 1.0. от Стефана Грабера.
LXD 2.0: Blog post series [0/12] 

Механизмы контейнеризации: namespaces
Механизмы контейнеризации: cgroups
Управление контейнерами с LXD

Пошаговая инструкция настройки LXD на Ubuntu 16.04 
Linux-контейнеры дома: зачем и как
Проброс USB-принтера в контейнер LXD

https://wiki.alpinelinux.org/wiki/LXC

https://roots.io/linux-containers-lxd-as-an-alternative-to-virtualbox-for-wordpress-development/ 


# lxd --help
Usage: lxd [command] [options]                                                                                                                                   
                                                                                                                                                                 
Commands:                                                                                                                                                        
    activateifneeded                                                                                                                                             
        Check if LXD should be started (at boot) and if so, spawns it through socket activation                                                                  
    daemon [--group=lxd] (default command)                                                                                                                       
        Start the main LXD daemon                                                                                                                                
    init [--auto] [--network-address=IP] [--network-port=8443] [--storage-backend=dir]                                                                           
         [--storage-create-device=DEVICE] [--storage-create-loop=SIZE] [--storage-pool=POOL]                                                                     
         [--trust-password=]                                                                                                                                     
        Setup storage and networking                                                                                                                             
    ready                                                                                                                                                        
        Tells LXD that any setup-mode configuration has been done and that it can start containers.                                                              
    shutdown [--timeout=60]                                                                                                                                      
        Perform a clean shutdown of LXD and all running containers                                                                                               
    waitready [--timeout=15]                                                                                                                                     
        Wait until LXD is ready to handle requests                                                                                                               
    import <container name>                                                                                                                                      
        Import a pre-existing container from storage                                                                                                             
                                                                                                                                                                 
                                                                                                                                                                 
Common options:                                                                                                                                                  
    --debug                                                                                                                                                      
        Enable debug mode                                                                                                                                        
    --help                                                                                                                                                       
        Print this help message                                                                                                                                  
    --logfile FILE                                                                                                                                               
        Logfile to log to (e.g., /var/log/lxd/lxd.log)                                                                                                           
    --syslog                                                                                                                                                     
        Enable syslog logging                                                                                                                                    
    --verbose                                                                                                                                                    
        Enable verbose mode                                                                                                                                      
    --version                                                                                                                                                    
        Print LXD's version number and exit                                                                                                                      
                                                                                                                                                                 
Daemon options:                                                                                                                                                  
    --group GROUP                                                                                                                                                
        Group which owns the shared socket                                                                                                                       
                                                                                                                                                                 
Daemon debug options:                                                                                                                                            
    --cpuprofile FILE                                                                                                                                            
        Enable cpu profiling into the specified file                                                                                                             
    --memprofile FILE                                                                                                                                            
        Enable memory profiling into the specified file                                                                                                          
    --print-goroutines-every SECONDS                                                                                                                             
        For debugging, print a complete stack trace every n seconds                                                                                              
                                                                                                                                                                 
Init options:                                                                                                                                                    
    --auto                                                                                                                                                       
        Automatic (non-interactive) mode                                                                                                                         
                                                                                                                                                                 
Init options for non-interactive mode (--auto):                                                                                                                  
    --network-address ADDRESS                                                                                                                                    
        Address to bind LXD to (default: none)                                                                                                                   
    --network-port PORT                                                                                                                                          
        Port to bind LXD to (default: 8443)                                                                                                                      
    --storage-backend NAME                                                                                                                                       
        Storage backend to use (zfs or dir, default: dir)                                                                                                        
    --storage-create-device DEVICE                                                                                                                               
        Setup device based storage using DEVICE                                                                                                                  
    --storage-create-loop SIZE                                                                                                                                   
        Setup loop based storage with SIZE in GB                                                                                                                 
    --storage-pool NAME                                                                                                                                          
        Storage pool to use or create                                                                                                                            
    --trust-password PASSWORD                                                                                                                                    
        Password required to add new clients                                                                                                                     
                                                                                                                                                                 
Shutdown options:                                                                                                                                                
    --timeout SECONDS                                                                                                                                            
        How long to wait before failing                                                                                                                          
                                                                                                                                                                 
Waitready options:                                                                                                                                               
    --timeout SECONDS                                                                                                                                            
        How long to wait before failing                                                                                                                          
                                                                                                                                                                 
                                                                                                                                                                 
Internal commands (don't call these directly):                                                                                                                   
    forkexec                                                                                                                                                     
        Execute a command in a container                                                                                                                         
    forkgetnet                                                                                                                                                   
        Get container network information                                                                                                                        
    forkgetfile                                                                                                                                                  
        Grab a file from a running container                                                                                                                     
    forkmigrate                                                                                                                                                  
        Restore a container after migration                                                                                                                      
    forkputfile                                                                                                                                                  
        Push a file to a running container                                                                                                                       
    forkstart                                                                                                                                                    
        Start a container                                                                                                                                        
    callhook                                                                                                                                                     
        Call a container hook                                                                                                                                    
    migratedumpsuccess                                                                                                                                           
        Indicate that a migration dump was successful                                                                                                            
    netcat                                                                                                                                                       
        Mirror a unix socket to stdin/stdout




# man lxd
LXD(1)                                                                  User Commands                                                                 LXD(1)     
                                                                                                                                                                 
NAME                                                                                                                                                             
       lxd - The container hypervisor - daemon                                                                                                                   
                                                                                                                                                                 
SYNOPSIS                                                                                                                                                         
       lxd [command] [options]                                                                                                                                   
                                                                                                                                                                 
DESCRIPTION                                                                                                                                                      
   Commands:                                                                                                                                                     
              activateifneeded                                                                                                                                   
                                                                                                                                                                 
              Check if LXD should be started (at boot) and if so, spawns it through socket activation                                                            
                                                                                                                                                                 
              daemon [--group=lxd] (default command)                                                                                                             
                                                                                                                                                                 
              Start the main LXD daemon                                                                                                                          
                                                                                                                                                                 
              init [--auto] [--network-address=IP] [--network-port=8443] [--storage-backend=dir]                                                                 
                                                                                                                                                                 
              [--storage-create-device=DEVICE] [--storage-create-loop=SIZE] [--storage-pool=POOL] [--trust-password=]                                            
                                                                                                                                                                 
              Setup storage and networking                                                                                                                       
                                                                                                                                                                 
              ready                                                                                                                                              
                                                                                                                                                                 
              Tells LXD that any setup-mode configuration has been done and that it can start containers.                                                        
                                                                                                                                                                 
              shutdown [--timeout=60]                                                                                                                            
                                                                                                                                                                 
              Perform a clean shutdown of LXD and all running containers                                                                                         
                                                                                                                                                                 
              waitready [--timeout=15]                                                                                                                           
                                                                                                                                                                 
              Wait until LXD is ready to handle requests                                                                                                         
                                                                                                                                                                 
   Common options:                                                                                                                                               
       --debug                                                                                                                                                   
                                                                                                                                                                 
              Enable debug mode                                                                                                                                  
                                                                                                                                                                 
       --help                                                                                                                                                    
                                                                                                                                                                 
              Print this help message                                                                                                                            
                                                                                                                                                                 
       --logfile FILE                                                                                                                                            
                                                                                                                                                                 
              Logfile to log to (e.g., /var/log/lxd/lxd.log)                                                                                                     
                                                                                                                                                                 
       --syslog                                                                                                                                                  
                                                                                                                                                                 
              Enable syslog logging                                                                                                                              
                                                                                                                                                                 
       --verbose                                                                                                                                                 
                                                                                                                                                                 
              Enable verbose mode                                                                                                                                
                                                                                                                                                                 
       --version                                                                                                                                                 
                                                                                                                                                                 
              Print LXD's version number and exit                                                                                                                
                                                                                                                                                                 
   Daemon options:                                                                                                                                               
       --group GROUP                                                                                                                                             
                                                                                                                                                                 
              Group which owns the shared socket                                                                                                                 
                                                                                                                                                                 
   Daemon debug options:                                                                                                                                         
       --cpuprofile FILE                                                                                                                                         
                                                                                                                                                                 
              Enable cpu profiling into the specified file                                                                                                       
                                                                                                                                                                 
       --memprofile FILE                                                                                                                                         
                                                                                                                                                                 
              Enable memory profiling into the specified file                                                                                                    
                                                                                                                                                                 
       --print-goroutines-every SECONDS                                                                                                                          
                                                                                                                                                                 
              For debugging, print a complete stack trace every n seconds                                                                                        
                                                                                                                                                                 
   Init options:                                                                                                                                                 
       --auto                                                                                                                                                    
                                                                                                                                                                 
              Automatic (non-interactive) mode                                                                                                                   
                                                                                                                                                                 
   Init options for non-interactive mode (--auto):                                                                                                               
       --network-address ADDRESS                                                                                                                                 
                                                                                                                                                                 
              Address to bind LXD to (default: none)                                                                                                             
                                                                                                                                                                 
       --network-port PORT                                                                                                                                       
                                                                                                                                                                 
              Port to bind LXD to (default: 8443)                                                                                                                
                                                                                                                                                                 
       --storage-backend NAME                                                                                                                                    
                                                                                                                                                                 
              Storage backend to use (zfs or dir, default: dir)                                                                                                  
                                                                                                                                                                 
       --storage-create-device DEVICE                                                                                                                            
                                                                                                                                                                 
              Setup device based storage using DEVICE                                                                                                            
                                                                                                                                                                 
       --storage-create-loop SIZE                                                                                                                                
                                                                                                                                                                 
              Setup loop based storage with SIZE in GB                                                                                                           
                                                                                                                                                                 
       --storage-pool NAME                                                                                                                                       
                                                                                                                                                                 
              Storage pool to use or create                                                                                                                      
                                                                                                                                                                 
       --trust-password PASSWORD                                                                                                                                 
                                                                                                                                                                 
              Password required to add new clients                                                                                                               
                                                                                                                                                                 
   Shutdown options:                                                                                                                                             
       --timeout SECONDS                                                                                                                                         
                                                                                                                                                                 
              How long to wait before failing                                                                                                                    
                                                                                                                                                                 
   Waitready options:                                                                                                                                            
       --timeout SECONDS                                                                                                                                         
                                                                                                                                                                 
              How long to wait before failing                                                                                                                    
                                                                                                                                                                 
   Internal commands (don't call these directly):                                                                                                                
              forkexec                                                                                                                                           
                                                                                                                                                                 
              Execute a command in a container                                                                                                                   
                                                                                                                                                                 
              forkgetnet                                                                                                                                         
                                                                                                                                                                 
              Get container network information                                                                                                                  
                                                                                                                                                                 
              forkgetfile                                                                                                                                        
                                                                                                                                                                 
              Grab a file from a running container                                                                                                               
                                                                                                                                                                 
              forkmigrate                                                                                                                                        
                                                                                                                                                                 
              Restore a container after migration                                                                                                                
                                                                                                                                                                 
              forkputfile                                                                                                                                        
                                                                                                                                                                 
              Push a file to a running container                                                                                                                 
                                                                                                                                                                 
              forkstart                                                                                                                                          
                                                                                                                                                                 
              Start a container                                                                                                                                  
                                                                                                                                                                 
              callhook                                                                                                                                           
                                                                                                                                                                 
              Call a container hook                                                                                                                              
                                                                                                                                                                 
              migratedumpsuccess                                                                                                                                 
                                                                                                                                                                
                                                                                                                                                                 
              callhook                                                                                                                                           
                                                                                                                                                                 
              Call a container hook                                                                                                                              
                                                                                                                                                                 
              migratedumpsuccess                                                                                                                                 
                                                                                                                                                                 
              Indicate that a migration dump was successful                                                                                                      
                                                                                                                                                                 
              netcat                                                                                                                                             
                                                                                                                                                                 
              Mirror a unix socket to stdin/stdout                                                                                                               
                                                                                                                                                                 
lxd 2.0.9                                                               February 2017                                                                 LXD(1)


Вопрос: Как посмотреть какие есть образы на локальной машине для создания контейнеров?
Ответ:

# lxc image list                                                                                                                               
If this is your first time using LXD, you should also run: lxd init                                                                                              
To start your first container, try: lxc launch ubuntu:16.04                                                                                                      
                                                                                                                                                                 
+-------+-------------+--------+-------------+------+------+-------------+                                                                                       
| ALIAS | FINGERPRINT | PUBLIC | DESCRIPTION | ARCH | SIZE | UPLOAD DATE |                                                                                       
+-------+-------------+--------+-------------+------+------+-------------+


Вопрос: Как посмотреть какие есть образы на удаленных серверах?
По умолчанию LXD знает о 3 источниках откуда можно брать образы:
  • ubuntu: (стабильные образы Ubuntu)
  • ubuntu-daily: (ежедневные образы Ubuntu)
  • images: (другие дистрибутивы)
Просмотреть удаленный источник образов можно так:

# lxc image list ubuntu: | less
+--------------------+--------------+--------+-------------------------------------------------+---------+----------+-------------------------------+            
|       ALIAS        | FINGERPRINT  | PUBLIC |                   DESCRIPTION                   |  ARCH   |   SIZE   |          UPLOAD DATE          |            
+--------------------+--------------+--------+-------------------------------------------------+---------+----------+-------------------------------+            
| p (5 more)         | 973c3a42737a | yes    | ubuntu 12.04 LTS amd64 (release) (20170307)     | x86_64  | 156.00MB | Mar 7, 2017 at 12:00am (UTC)  |            
+--------------------+--------------+--------+-------------------------------------------------+---------+----------+-------------------------------+            
| p/armhf (2 more)   | 409243150c6a | yes    | ubuntu 12.04 LTS armhf (release) (20170307)     | armv7l  | 135.38MB | Mar 7, 2017 at 12:00am (UTC)  |            
+--------------------+--------------+--------+-------------------------------------------------+---------+----------+-------------------------------+            
| p/i386 (2 more)    | 06df589b0615 | yes    | ubuntu 12.04 LTS i386 (release) (20170307)      | i686    | 140.22MB | Mar 7, 2017 at 12:00am (UTC)  |            
+--------------------+--------------+--------+-------------------------------------------------+---------+----------+-------------------------------+            
| t (5 more)         | 8b51ee006f13 | yes    | ubuntu 14.04 LTS amd64 (release) (20170307)     | x86_64  | 119.52MB | Mar 7, 2017 at 12:00am (UTC)  |            
+--------------------+--------------+--------+-------------------------------------------------+---------+----------+-------------------------------+            
| t/arm64 (2 more)   | b5cebb89a089 | yes    | ubuntu 14.04 LTS arm64 (release) (20170307)     | aarch64 | 110.44MB | Mar 7, 2017 at 12:00am (UTC)  |            
+--------------------+--------------+--------+-------------------------------------------------+---------+----------+-------------------------------+            
| t/armhf (2 more)   | 11b1e5dff88c | yes    | ubuntu 14.04 LTS armhf (release) (20170307)     | armv7l  | 112.57MB | Mar 7, 2017 at 12:00am (UTC)  |            
:


Вопрос: Как создать контейнер из образа и запустить его?
Ответ:

# lxc launch --help                                                                                                                           
Usage: lxc launch [<remote>:]<image> [<remote>:][<name>] [--ephemeral|-e] [--profile|-p <profile>...] [--config|-c <key=value>...] [--network|-n <network>] [--storage|-s <pool>]                                                                                                                                                 
                                                                                                                                                                 
Create and start containers from images.                                                                                                                         
                                                                                                                                                                 
Not specifying -p will result in the default profile.                                                                                                            
Specifying "-p" with no argument will result in no profile.                                                                                                      
                                                                                                                                                                 
Examples:                                                                                                                                                        
    lxc launch ubuntu:16.04 u1                                                                                                                                   
                                                                                                                                                                 
Options:                                                                                                                                                         
    -c, --config  (= map[])                                                                                                                                      
        Config key/value to apply to the new container                                                                                                           
    --debug  (= false)                                                                                                                                           
        Enable debug mode                                                                                                                                        
    -e, --ephemeral  (= false)                                                                                                                                   
        Ephemeral container                                                                                                                                      
    --force-local  (= false)                                                                                                                                     
        Force using the local unix socket                                                                                                                        
    -n, --network (= "")                                                                                                                                         
        Network name                                                                                                                                             
    --no-alias  (= false)                                                                                                                                        
        Ignore aliases when determining what command to run                                                                                                      
    -p, --profile  (= [])                                                                                                                                        
        Profile to apply to the new container                                                                                                                    
    -s, --storage (= "")                                                                                                                                         
        Storage pool name                                                                                                                                        
    --verbose  (= false)                                                                                                                                         
        Enable verbose mode

Пример:

# lxc launch ubuntu:16.04 first                                                                                                               
If this is your first time using LXD, you should also run: lxd init                                                                                              
To start your first container, try: lxc launch ubuntu:16.04                                                                                                      
                                                                                                                                                                 
Creating first                                                                                                                                                   
Starting first

Чтобы получить лучшую из возможных версию Ubuntu надо дать команду:
lxc launch ubuntu:

Можно указать архитектуру:
lxc launch ubuntu:14.04/i386 c2

Чтобы просто создать контейнер без запуска:
lxc init ubuntu:

Еще варианты:


Вопрос: Как просмотреть список созданных контейнеров?
Ответ:

# lxc list                                                                                                                                    
+-------+---------+-----------------------+----------------------------------------------+------------+-----------+                                              
| NAME  |  STATE  |         IPV4          |                     IPV6                     |    TYPE    | SNAPSHOTS |                                              
+-------+---------+-----------------------+----------------------------------------------+------------+-----------+                                              
| first | RUNNING | 10.178.112.152 (eth0) | 2001:470:b368:1070:216:3eff:fe54:b5b3 (eth0) | PERSISTENT | 0         |                                              
+-------+---------+-----------------------+----------------------------------------------+------------+-----------+


Вопрос: Как просмотреть настройки контейнера?
Ответ: Используйте команды lxc info и lxc config show с именем контейнера в качестве аргумента к ним.

# lxc info first                                                                                                                              
Name: first                                                                                                                                                      
Remote: unix:/var/lib/lxd/unix.socket                                                                                                                            
Architecture: x86_64                                                                                                                                             
Created: 2017/03/18 11:09 UTC                                                                                                                                    
Status: Running                                                                                                                                                  
Type: persistent                                                                                                                                                 
Profiles: default                                                                                                                                                
Pid: 361                                                                                                                                                         
Ips:                                                                                                                                                             
  eth0: inet    10.178.112.152                                                                                                                                   
  eth0: inet6   2001:470:b368:1070:216:3eff:fe54:b5b3                                                                                                            
  eth0: inet6   fe80::216:3eff:fe54:b5b3                                                                                                                         
  lo:   inet    127.0.0.1                                                                                                                                        
  lo:   inet6   ::1                                                                                                                                              
Resources:                                                                                                                                                       
  Processes: 26                                                                                                                                                  
  CPU usage:                                                                                                                                                     
    CPU usage (in seconds): 7                                                                                                                                    
  Memory usage:                                                                                                                                                  
    Memory (current): 63.30MB                                                                                                                                    
    Memory (peak): 143.30MB                                                                                                                                      
  Network usage:                                                                                                                                                 
    eth0:                                                                                                                                                        
      Bytes received: 2.65kB                                                                                                                                     
      Bytes sent: 1.78kB                                                                                                                                         
      Packets received: 23                                                                                                                                       
      Packets sent: 17                                                                                                                                           
    lo:                                                                                                                                                          
      Bytes received: 0B                                                                                                                                         
      Bytes sent: 0B                                                                                                                                             
      Packets received: 0                                                                                                                                        
      Packets sent: 0                                                                                                                                            
root@tryit-cuddly:~# lxc config show first                                                                                                                       
architecture: x86_64                                                                                                                                             
config:                                                                                                                                                          
  image.architecture: amd64                                                                                                                                      
  image.description: ubuntu 16.04 LTS amd64 (release) (20170307)                                                                                                 
  image.label: release                                                                                                                                           
  image.os: ubuntu                                                                                                                                               
  image.release: xenial                                                                                                                                          
  image.serial: "20170307"                                                                                                                                       
  image.version: "16.04"                                                                                                                                         
  volatile.base_image: 2cab90c0c342346ea154bc2e8cacdae752a70747a755ce1f2970c9a9ebb5fe8c                                                                          
  volatile.eth0.hwaddr: 00:16:3e:54:b5:b3                                                                                                                        
  volatile.eth0.name: eth0                                                                                                                                       
  volatile.idmap.base: "0"                                                                                                                                       
  volatile.idmap.next: '[]'                                                                                                                                      
  volatile.last_state.idmap: '[]'                                                                                                                                
  volatile.last_state.power: RUNNING                                                                                                                             
devices: {}                                                                                                                                                      
ephemeral: false                                                                                                                                                 
profiles:                                                                                                                                                        
- default

Еще вариант:
lxc config show --expanded container


Вопрос: В чем разница между непривилегированным и привилегированным контейнерами?
Ответ:
Непривилегированные контейнеры самые защищенные. Они используют связи uid и gid для выделения диапазона uids и gids контейнеру. Это означает что uid 0 (root) в контейнере на самом деле что-то около uid 100000 вне контейнера. Так что стоит чему-то пойти не так и атакующий покинет контейнер, он увидит что имеет столько же прав как пользователь nobody.

Привилегированные контейнеры это контейнеры созданные root и запущенные от root.

Unprivileged does not mean that you could create it with an ordinary user. You still should build it with root privileges (and the examples in the wiki are executed by root).

Смотрите еще:


Вопрос: Как узнать в каком режиме работает контейнер: непривилегированным или привилегированном?
Ответ:
$ lxc config get your-container-name security.privileged
$ lxc list security.privileged=true

См. также:


Вопрос: Как создать непривилегированный контейнер?
Ответ:
Все контейнеры создаваемые с помощью LXD являются непривилегированными. Это можно проверить с помощью команды:
ps -ef


Вопрос: Как получить командную строку (shell) контейнера?
Пример: lxc exec first -- /bin/bash


Вопрос: Как выполнить команду внутри контейнера?
Пример: lxc exec first -- apt-get update

Commands executed through LXD will always run as the container’s root user (uid 0, gid 0) with a minimal PATH environment variable set and a HOME environment variable set to /root. (источник)


Вопрос: Как загрузить файл в контейнер или из контейнера?
Примеры:
lxc file pull first/etc/hosts .
lxc file push hosts first/tmp/


Вопрос: Как остановить контейнер?
Пример: lxc stop first


Вопрос: Как удалить контейнер?
Пример: lxc delete first


Question: So, is it possible by default, for unprivileged container, map current user from host to root inside guest?
Answer: LXD runs as root, so for it "current user" would be uid 0, which would be a really really bad idea, so no.


Вопрос: Как создавать вложенные контейнеры?
Ответ:
https://insights.ubuntu.com/2015/10/30/nested-containers-in-lxd/