LXD

De castillowiki
Saltar a: navegación, buscar

LXD és un hypervisor de contenidors LXC. Conceptualment es situa per damunt oferint una millor experiència d'usuari. Baix la superfície, LXD utilitza la biblioteca liblxc per gestionar els contenidors. Amés, afegeix la possibilitat de gestionar-los en una xarxa.

No podem pensar en LXC o LXD com una màquina virtual o un gestor de màquines virtuals. La manera en la que funciona no és exactament la virtualització, Si no que fa ús dels namespaces del kernel de Linux per poder compartir amb l'amfitrió el nucli del sistema operatiu però que funcione virtualment independent.

Un contenidor gestionat per LXD ocupa menys disc i, sobretot, menys memòria i processador que una màquina virtual. Amés, l'interacció amb els contenidors és directa i més còmoda.

En els fòrums trobarem molta ajuda per a LXC, però no tota val per a LXD

Les principals característiques de LXD respecte a LXC inclouen:

  • Prioritat a Contenidors sense privilegis (seguretats per defecte).
  • Un client de línia d'ordres (lxc) interactua amb un dimoni (LXD).
  • La configuració és intuïtiva i seqüencial a través de perfils en cascada.
  • Els canvis de configuració es realitzen amb la comanda lxc (no els arxius de configuració).
  • Diversos hosts poden estar federats junts (amb un sistema de confiança basada en certificats).
  • Una configuració federada significa que els contenidors poden ser llançats en les màquines remotes i viure-migrar entre hosts (usant la tecnologia CRIU).
  • Es pot utilitzar com un hipervisor autònom o integrat amb Openstack nova

Instal·lació

En principi, en Ubuntu Server ja ve instal·lat de zero, però per si el tenim que reinstal·lar:

 sudo apt-get install lxd
 newgrp lxd

En ubuntu, els usuaris han de formar part del grup LXD per poder utilitzar-lo.

Observem que passa si fem lxc sense paràmetres:

Description:
  Command line client for LXD

  All of LXD's features can be driven through the various commands below.
  For help with any of those, simply call them with --help.

Usage:
  lxc [command]

Available Commands:
  alias       Manage command aliases
  cluster     Manage cluster members
  config      Manage container and server configuration options
  console     Attach to container consoles
  copy        Copy containers within or in between LXD instances
  delete      Delete containers and snapshots
  exec        Execute commands in containers
  file        Manage files in containers
  help        Help about any command
  image       Manage images
  info        Show container or server information
  launch      Create and start containers from images
  list        List containers
  move        Move containers within or in between LXD instances
  network     Manage and attach containers to networks
  operation   List, show and delete background operations
  profile     Manage profiles
  publish     Publish containers as images
  remote      Manage the list of remote servers
  rename      Rename containers and snapshots
  restart     Restart containers
  restore     Restore containers from snapshots
  snapshot    Create container snapshots
  start       Start containers
  stop        Stop containers
  storage     Manage storage pools and volumes
  version     Show local and remote versions

Flags:
      --all           Show less common commands
      --debug         Show all debug messages
      --force-local   Force using the local unix socket
  -h, --help          Print help
  -v, --verbose       Show all information messages
      --version       Print version number

Use "lxc [command] --help" for more information about a command.

Ens interessa fer una configuració prèvia per a crear els contenidors correctament:

root@server:~# lxd init
Would you like to use LXD clustering? (yes/no) [default=no]: yes
What name should be used to identify this node in the cluster? [default=server]: 
What IP address or DNS name should be used to reach this node? [default=10.0.2.15]: 
Are you joining an existing cluster? (yes/no) [default=no]: no
Setup password authentication on the cluster? (yes/no) [default=yes]: 
Trust password for new clients: 
Again: 
Do you want to configure a new local storage pool? (yes/no) [default=yes]: 
Name of the storage backend to use (btrfs, dir, lvm) [default=btrfs]: 
Create a new BTRFS pool? (yes/no) [default=yes]: 
Would you like to use an existing block device? (yes/no) [default=no]: 
Size in GB of the new loop device (1GB minimum) [default=15GB]: 
Do you want to configure a new remote storage pool? (yes/no) [default=no]: 
Would you like to connect to a MAAS server? (yes/no) [default=no]: 
Would you like to create a new network bridge? (yes/no) [default=yes]: 
What should the new bridge be called? [default=lxdbr0]: 
What IPv4 address should be used? (CIDR subnet notation, “auto” or “none”) [default=auto]: 
What IPv6 address should be used? (CIDR subnet notation, “auto” or “none”) [default=auto]: 
Would you like stale cached images to be updated automatically? (yes/no) [default=yes] 
Would you like a YAML "lxd init" preseed to be printed? (yes/no) [default=no]: 

Observa que demana coses molt concretes que seran distintes en cada cas. Algunes d'aquestes coses estan desenvolupades en aquest manual.

Si creem contenidors, aquest assistent deixa de funcionar i apareix açò:

sudo lxd init
LXD init cannot be used at this time.
However if all you want to do is reconfigure the network,
you can still do so by running "sudo dpkg-reconfigure -p medium lxd"

error: You have existing containers or images. lxd init requires an empty LXD.

Podem executar el comandament que ens recomana per a reconfigurar la xarxa o qualsevol altre paràmetre.

Contenidors i imatges

Si fem:

$ lxc image list
Generating a client certificate. This may take a minute...
If this is your first time using LXD, you should also run: sudo lxd init
To start your first container, try: lxc launch ubuntu:16.04

+-------+-------------+--------+--------------+-----+---------+-------------+
| ALIAS | FINGERPRINT | PUBLIC | DESCRIPCIÓN | ARQ | TAMAÑO | UPLOAD DATE |
+-------+-------------+--------+--------------+-----+---------+-------------+

Encara no tenim descarregada ninguna imatge, però ens dona l'opció de configurar en lxd init i de llançar un contenidor en lxc launch ubuntu:16.04.

jose@server:~$ lxc launch ubuntu:16.04
Creando sandless-yair
Retrieving image: 100%
Iniciando sandless-yair
jose@server:~$ lxc list
+---------------+---------+------+------+------------+-----------+
|    NOMBRE     | ESTADO  | IPV4 | IPV6 |    TIPO    | SNAPSHOTS |
+---------------+---------+------+------+------------+-----------+
| sandless-yair | RUNNING |      |      | PERSISTENT | 0         |
+---------------+---------+------+------+------------+-----------+
jose@server:~$ lxc image list
+-------+--------------+--------+---------------------------------------------+--------+----------+------------------------------+
| ALIAS | FINGERPRINT  | PUBLIC |                DESCRIPCIÓN                 |  ARQ   | TAMAÑO  |         UPLOAD DATE          |
+-------+--------------+--------+---------------------------------------------+--------+----------+------------------------------+
|       | de051f59f701 | no     | ubuntu 16.04 LTS amd64 (release) (20161011) | x86_64 | 143.12MB | Oct 14, 2016 at 9:43am (UTC) |
+-------+--------------+--------+---------------------------------------------+--------+----------+------------------------------+

Mirem cóm ha descarregat la imatge, ha creat el contenidor i la imatge està disponible ja en el sistema.

Per veure les imatges que tenim disponibles a Internet:

$ lxc image list images:
$ lxc image list images: 'alpine'

Backend

LXD pot anar directament al sistema d'arxius en /var/lib/lxd. No obstant, és més interessant utilitzar ZFS o Btrfs per els avantatges que proporciona.

En principi, instal·lant ZFS ja es pot utilitzar i permet crear volumens mentres es fa el lxd init.

ZFS és millor que en directoris perquè és com un sistema d'arxius similar a ext4 sobre un LVM i té aquestes propietats:

  • Permet fer snapshots dels contenidors.
  • Clona amb una tècnica anomenada copy-on-write. Bàsicament significa que no copia tot el contenidors, si no que apunta al mateix lloc de memòria fins que van fent-se canvis en els arxius.
  • Està contínuament comprovant per si el sistema està corrupte.
  • Se repara automàticament.
  • Té una compressió de les dades eficient.

Sols cal instal·lar zfsutils-linux [1]

Ús dels contenidors

  • Llistar contenidors
 	
 lxc list # Llista dels contenidors instal·lats
 lxc image list ubuntu: # Llista de les imatges d'ubuntu disponibles
 lxc image alias list ubuntu:
 lxc list --fast
 lxc list --fast ubuntu
 lxc list --format json | jq '.[]'    # En format json. Amb el programa [[jq]] es pot formatar l'eixida.

lxc list en detall:

Si fem lxc list sense més, el que ens mostra és una taula amb unes columnes predefinides: ns46tS. I si el fem en --fast ens mostra les columnes: nsacPt. Aqueste lletres corresponen a aquest llistat:

    4 - IPv4 address
    6 - IPv6 address
    a - Architecture
    b - Storage pool
    c - Creation date
    d - Description
    l - Last used date
    n - Name
    N - Number of Processes
    p - PID of the container's init process
    P - Profiles
    s - State
    S - Number of snapshots
    t - Type (persistent or ephemeral)
    L - Location of the container (e.g. its cluster member)

Si volem mostrar unes columnes en concret, podem fer-ho en -c:

$ lxc list -c n,s,4

Però els contenidors tenen moltes més característiques que es poden llistar. Les que no estan predefinides es poden demanar literalment:

$ lxc list -c n,volatile.base_image:"BASE IMAGE":0,s46,volatile.eth0.hwaddr:MAC
              |                    |                |                   |
  Nom (Columna prefefinida)        |           Estat, ipv4, ipv6     mac (clau:nom columna)
                                   |
                            Nom de la imatge (clau:nom de la columna:ample màxim columna)

El --format ens permet tindre una eixida en altres formats per fer coses en ella. Permet csv,json,table i yaml

  • Crear un contenidor sense llançar-lo:
 $ lxc init ubuntu:18.04 servidor1
  • Llançar un contenidor nou
 	
 $ lxc launch <imagen> [nombre]
  • Obtindre informació del contenidor: lxc info <container>
$ lxc info u1
Nombre: u1
Arquitectura: x86_64
Creación: 2016/10/19 16:17 UTC
Estado: Running
Type: persistent
Perfiles: default
PID: 20968
Ips:
  eth0:	inet	10.243.177.208	vethB8LY7C
  eth0:	inet6	fe80::216:3eff:fe35:d02b	vethB8LY7C
  lo:	inet	127.0.0.1
  lo:	inet6	::1
Resources:
  Procesos: 25
  Disk usage:
    root: 7.14MB
  Memory usage:
    Memory (current): 48.40MB
    Memory (peak): 169.30MB
  Network usage:
    eth0:
      Bytes received: 1.53kB
      Bytes sent: 1.34kB
      Packets received: 15
      Packets sent: 11
    lo:
      Bytes received: 248 bytes
      Bytes sent: 248 bytes
      Packets received: 4
      Packets sent: 4
  • Detindre un contenidor
 $ lxc stop servidor1
 $ lxc exec servidor1 -- shutdown 0

Detindre tots els que estan en marxa:

 $ for i in $(lxc list | grep RUNNING | cut -d"|" -f2 | tr  -d " "); do lxc stop $i; done
 $ lxc list --format csv | grep 'RUNNING' | cut -d"," -f1 | while read i; do lxc stop $i; done
  • Encendre un contenidor
lxc start servidor1
  • Pausar un contenidor:
lxc pause servidor1
  • Obtindre un shell en un contenidor
lxc exec servidor1 -- /bin/bash

Aquest shell no és exactament com connectar-se per SSH, ja que els comandaments no s'executen dins dels contenidor. Per tant, no coneix configuracions del shell o variables d'entorn. Sempre s'executen con al root del contenidor (que no és el mateix que el de la màquina).

Altres combinacions:

 lxc exec servidor1 bash
 # Alguns necessiten un separador
 lxc exec servidor1 -- ls -lh /
  • Esborrar un contenidor o snapshot:
lxc delete servidor1

Configuracions

Els contenidors es poden configurar de múltiples maneres possibles. LXD permet fer la configuració amb comandaments (molt útil per fer scripts) o editant fitxers de text en YAML que pot servir per fer configuracions més complexes.

Es poden crear perfils per a configurar varis contenidors de la mateixa manera amb profiles:

 lxc profile list
 lxc profile show <profile>
 lxc profile edit <profile>
 lxc profile apply <container> <profile1>,<profile2>,<profile3>,...

Si volem configurar un sol contenidor no té sentit fer un profile. Cal cridar a:

 lxc config edit <container> # Per editar el YAML
 lxc config set <container> <key> <value>
 lxc config device add my-container kvm unix-char path=/dev/kvm
 lxc config show <container>
 lxc config show --expanded <container>

En qualsevol cas, si no sabem cóm utilitzar config, es pot executar:

 lxc help config
 lxc help profile
Aquestes configuracions es poden aplicar sense tindre que parar els contenidors

Configuracions en detall:

Configuracions per clau/valor:

  • boot: Configuracions relacionades amb l'arranc.
    • boot.autostart: Si ha d'arrancar quan arranca el servei LXD o s'ha encendre manualment.
    • boot.autostart.delay: Se li passa un número i diu els segons que ha d'esperar fins arrancar.
    • boot.autostart.priority: També accepta un número i indica la prioritat o l'ordre a l'hora de l'autoarranc.
    • boot.host_shutdown_timeout: Temps que ha d'esperar per a que apague correctament abans de matar el contenidor.
    • boot.stop.priority: Ordre de parada dels contenidors en cas de parar el servei LXD.
 $ lxc config set {vm-name} {key} {value}
 $ lxc config set {vm-name} boot.autostart {true|false}
 $ lxc config set {vm-name} boot.autostart.priority integer
 $ lxc config set {vm-name} boot.autostart.delay integer

Aquest script permet observar aquests valors en els contenidors que tenim: (font [2])

#!/bin/bash
x=$(lxc list -c n | awk '{ print $2}'  | sed -e '/^$/d' -e '/^NAME/d')
echo 'The current values of each vm boot parameters:'
for c in $x
do
   echo "*** VM: $c ***"
   for v in boot.autostart boot.autostart.priority boot.autostart.delay 
   do
      echo "Key: $v => $(lxc config get $c $v)"
   done
      echo ""
done
  • enviroment.*: Variables d'entorn que comparteixen el contenidor i l'amfitrió. [3]
  • limits: Limitació de recursos de maquinari per als contenidors. ( veure Quotes )


Dispositius: Per configurar dispositius en els contenidors o profiles s'ha d'utilitzar lxd config device. Amb el dispositius es pot: Afegir un nou dispositiu:

 lxc config device add [<remote>:]<container|profile> <device> <type> [key=value...] [flags]

Per exemple:

 lxc config device add [<remote>:]container1 <device-name> disk source=/share/c1 path=opt

Munta el directori /share/c1 al directori /opt de dins del container. Aquests són els tipus de dispositius que pot gestionar LXD:

  • 0 none Aquest dispositiu no crea res, però serveix per limitar l'herència dels perfils.
  • 1 nic Interficie de xarxa. A continuació cal ficar nictype:
    • physical: Utilitza una interfície de l'amfitrió i la deixa inaccessible per a l'amfitrió.
    • bridged: Utilitza un bridge de Linux per crear una xarxa virtual amb una connexió per al contenidor i una possible per a l'amfitrió. A aquest bridge es poden connectar altres contenidors i, si no es connecta a l'exterior es queda com una xarxa privada.
    • macvlan: Crea una interfície virtual amb una interfície existent i un altra MAC.
    • p2p: Crea un dispositiu virtual amb un extrem al contenidor i un altre a l'amfitrió.
    • sriov: Un dispositiu SR-IOV
lxc config device add <container> <device-name> nic nictype=macvlan name=eth1 parent=eth0
  • 2 disk Punt de muntatge dins del contenidor.
  • 3 unix-char Dispositiu Unix per caràcters.
  • 4 unix-block Dispositiu Unix per blocs.
  • 5 usb Dispositiu USB
  • 6 gpu
  • 7 infiniband
  • 8 proxy: Permet reenviar les connexions entre el contenidor i l'amfitrió. Permet redirigir tràfic d'una adreça fins a un contenidor o d'un contenidor a l'exterior.
lxc config device add <container> <device-name> proxy listen=<type>:<addr>:<port> connect=<type>:<addr>:<port> bind=<host/container>

Exemples

Fer que un contenidor arranque a l'inici:

 $ lxc config set container_name boot.autostart 1

Permetre el nesting. És a dir, contenidors dins de contenidors:

 $ lxc config set u1 security.nesting true

Snapshots

Crear el Snapshot:

 lxc snapshot <container>
 lxc snapshot <container> <snapshot name>

Llistar els snapshots d'un contenidor:

 lxc info <container>

Restaurar un snapshot:

 lxc restore <container> <snapshot name>

Renombrar un snapshot:

 lxc move <container>/<snapshot name> <container>/<new snapshot name>

Crear un contenidor a partir d'un snapshot. Sols canvia la MAC:

 lxc copy <container> / <snapshot name> <destination container>

Esborrar un snapshot:

 lxc delete <container>/<snapshot name>

Moure contenidors

Clonar un contenidor:

 lxc copy <container> <destination container>

Reanomenar el contenidor:

 lxc move <old name> <new name>

Servidors remots i migració

En el servidor remot:

jose@svr2:~$ lxc config set core.https_address [::]:8443
jose@svr2:~$ lxc config set core.trust_password 123456

En el servidor local:

jose@server:~$ lxc config set core.https_address [::]:8443
jose@server:~$ lxc remote add dos 192.168.0.219
Certificate fingerprint: cb055f5997d93da42d284bf9a47de1f21d1a24f9a0dceac1d0cd10d89d1d575e
ok (y/n)? y
Admin password for dos: 
Client certificate stored at server:  dos
jose@server:~$ lxc launch ubuntu:16.04 dos:c3
Creando c3
Iniciando c3

jose@server:~$ lxc list
+---------------+---------+------+------+------------+-----------+
|    NOMBRE     | ESTADO  | IPV4 | IPV6 |    TIPO    | SNAPSHOTS |
+---------------+---------+------+------+------------+-----------+
| gw            | STOPPED |      |      | PERSISTENT | 0         |
+---------------+---------+------+------+------------+-----------+
| sandless-yair | STOPPED |      |      | PERSISTENT | 0         |
+---------------+---------+------+------+------------+-----------+
jose@server:~$ lxc list dos:
+--------+---------+------+------+------------+-----------+
| NOMBRE | ESTADO  | IPV4 | IPV6 |    TIPO    | SNAPSHOTS |
+--------+---------+------+------+------------+-----------+
| c3     | RUNNING |      |      | PERSISTENT | 0         |
+--------+---------+------+------+------------+-----------+
| u2     | STOPPED |      |      | PERSISTENT | 0         |
+--------+---------+------+------+------------+-----------+

Observem cóm han confiat un en l'altre a través d'un contrasenya i un fingerprint. Després hem llançat un container remot i podem fer qualsevol cosa en els containers remots ficant el prefixe dos:

També es poden fer copies, snapshots i demés:

 $ lxc exec dos:c3 bash
 $ lxc copy dos:c3 c2
 $ lxc snapshot dos:c3 current
 $ lxc copy dos:c3/current c3

També podem moure els contenidors (Si estan parats):

 $ lxc stop dos:c1
 $ lxc move foo:c1 local:

Deixar de confiar

Es pot esborrar un remote. Però si s'ha confiat en el seu fingerprint, cal primer esborrar el trust:

jose@server:~$ lxc config trust list dos
+--------------+-------------+------------------------------+------------------------------+
| FINGERPRINT  | COMMON NAME |          ISSUE DATE          |     FECHA DE VENCIMIENTO     |
+--------------+-------------+------------------------------+------------------------------+
| 0d7542b1261f | jose@server | Oct 14, 2016 at 9:39am (UTC) | Oct 12, 2026 at 9:39am (UTC) |
+--------------+-------------+------------------------------+------------------------------+
jose@server:~$ lxc config trust remove dos 0d7542b1261f
jose@server:~$ lxc remote remove dos

Clustering

A partir de la versió 3.0 de LXD es pot fer clústers en ells. Això permet que dos contenidors igualment configurats puguen ser units formant un clúster i aparentar ser un únic servidor de cara a l'exterior.

Es recomana fer clústers de al menys 3 nodes LXD. Aquests han de ser idèntics en xarxa i emmagatzemament. Sols poden ser diferents en els dispositius físics que formen el emmagatzemament secundari i la xarxa. Els tres clústers comparteixen la mateixa configuració en les instàncies compartint una base de dades SQLite amb l'algorisme Raft.

L'assistent lxd init ens guia per a fer el clúster i unir varis servidors a ell. [4] [5]

Copiar fitxers

Per a extraure un fitxer d'un contenidor:

 lxc file pull <container>/<path> <dest>

Mostrar un fitxer per eixida estàndar:

 lxc file pull zerotier/etc/hosts -

Copiar un fitxer dins:

 lxc file push <origen> <container>/<path>

Editar dirèctament un fitxer:

 lxc file edit <container>/<path>

El problema és que no actualitza el fitxer fins que no tanques l'editor. Per tant, es pot fer un push en una altra terminal del fitxer creat en /tmp. Exemple:

 lxc file push lxd_file_edit_718115826 xamp/var/www/html/tema6/scripts/script.js


 # off-topic: Canviar el editor per defecte
 sudo update-alternatives --install /usr/bin/editor editor /usr/bin/gedit 10
 sudo update-alternatives --config editor

Exemples:

Establir la mateixa configuració de contrasenya i de ssh per a tots els contenidors:

 for i in {1..16}; do echo $i; lxc file push shadow container$i/etc/shadow; lxc file push sshd_config container$i/etc/ssh/sshd_config; done

Crear i gestionar imatges i tarballs

Abans de res, la manera adequada de veure que es pot fer en les imatges:

 $ lxc image help

Tots els contenidors es creen a partir d'una imatge. La imatge pot vindre d'un servidor remot i pot estar pujada utilitzant un alias o dos tipus de hash.

La primera vegada que llancem un launch, es descarrega la imatge i la guarda en una cache local. Desprès, si no ha sigut actualitzada en origen, utilitza la imatge local per crear nous contenidors.

$ lxc image list
+-------+--------------+--------+---------------------------------------------+--------+----------+------------------------------+
| ALIAS | FINGERPRINT  | PUBLIC |                DESCRIPCIÓN                 |  ARQ   | TAMAÑO  |         UPLOAD DATE          |
+-------+--------------+--------+---------------------------------------------+--------+----------+------------------------------+
|       | 315bedd32580 | no     | ubuntu 16.04 LTS amd64 (release) (20161020) | x86_64 | 144.29MB | Oct 22, 2016 at 7:32am (UTC) |
+-------+--------------+--------+---------------------------------------------+--------+----------+------------------------------+

Si volem crear un altre contenidor sense comprovar si està actualitzat, podem utilitzar el fingerprint:

 $ lxc launch 315bedd32580 c4

En qualsevol cas, si la imatge té un alias, es pot crear amb el alias.

Podem guardar imatges en el nostre servidor sense necessitar de crear inmediatament un contenidor:

 $ lxc image copy ubuntu:14.04 local: --alias ubuntu-vell

O guardar i copiar els alies:

 $ lxc image copy ubuntu:15.10 local: --copy-aliases

Se pot actualitzar la imatge automàticament:

 $ lxc image copy images:gentoo/current/amd64 local: --alias gentoo --auto-update

Si ens envien una imatge en un tarball, és a dir, un fitxer comprimit:

 $ lxc image import <tarball> --alias random-image

Podem modificar la configuració bàsica de la imatge amb:

 $ lxc image edit <alias or fingerprint>

Crear una imatge

Podem crear una imatge com un tarball a partir d'un contenidor ja configurat:

 $ lxc publish my-container --alias my-new-image
 # En el cas d'un snapshot:
 $ lxc publish my-container/some-snapshot --alias some-image

Llançar moltes imatges en molts contenidors a la vegada

Per a preparar una pràctica hem tingut que afegir una contenidor a tots els contenidors dels alumnes. Per fer-ho, hem creat un contenidor de forma normal, hem configurat al nostre gust i l'hem parat. Ara cal fer una imatge:

$ lxc publish examen --alias examen
Container published with fingerprint: 4bcbc242c612eee6f5cb0936daec873521dd369bbceb1a1fe74b27417a59aff4

$ lxc image export examen
Output is in 4bcbc242c612eee6f5cb0936daec873521dd369bbceb1a1fe74b27417a59aff4.tar.gz

$ for i in {201..216}; do scp 4bcbc242c612eee6f5cb0936daec873521dd369bbceb1a1fe74b27417a59aff4.tar.gz ubuntu@192.168.9.${i}:/home/ubuntu; done
The authenticity of host '192.168.9.201 (192.168.9.201)' can't be established.
ECDSA key fingerprint is SHA256:cz0hy57e88efc+OaOi1+SeQm9a2y/rM7LIi9xkz4jvE.
Are you sure you want to continue connecting (yes/no)? yes
Warning: Permanently added '192.168.9.201' (ECDSA) to the list of known hosts.
ubuntu@192.168.9.201's password: 
4bcbc242c612eee6f5cb0936daec873521dd369bbceb1a1fe74b27417a59aff4.tar.gz                                                                                                                         100%  225MB 224.5MB/s   00:01    
The authenticity of host '192.168.9.202 (192.168.9.202)' can't be established.
.....

D'aquesta manera hem transferit per scp la imatge a tots els altres contenidors. Un altra opció és amb push.

Ara cal activar llançar la imatge en tots els contenidors. Para fer-ho creem un script:

#!/bin/bash
for i in {2..16}
do
lxc exec alumne$i -- lxc image import /home/ubuntu/4bcbc242c612eee6f5cb0936daec873521dd369bbceb1a1fe74b27417a59aff4.tar.gz --alias examen
lxc exec alumne$i -- lxc launch examen examen
done

Usuaris

https://help.ubuntu.com/lts/serverguide/lxd.html#lxd-uid

Si fem un htop en la màquina amfitrió trobem processos amb UIDs per damunt de 100000. Els usuaris van, per defecte, de 10000 a 165535. Aquests usuaris, dins del contenidor tenen el UID menys 100000. És a dir, l'usuari del sistema 100022 és l'usuari 22 dins del contenidor.

Els criteris de cóm mapar els usuaris està en /etc/subuid and /etc/subgid.

Com que és complicat saber quin contenidor està consumint més sols amb els UIDs, es pot fer htop > F2 > Columns > CGROUP. Els CGROUP sí que mostra el nom del contenidor.

Podem fer que no mape els UIDs, es pot executar:

$ lxc config set c1 security.privileged true

Però al ser contenidor privilegiat, el root de dins és el root de fora. Això no es recomana per seguretat.

Quotes

LXC permet controlar quotes per a quasi tot. Algunes vegades pot fallar, com quant volem assignar menys memòria de la que està utilitzant. No obstant, LXD ho intenta. Aquestes limitacions es poden aplicar en temps d'execució.

Aquestes limitacions també es poden aplicar als profiles.

De disc

Les limitacions de disc funcionen totalment si el backend està en ZFS, ja que altres sistemes de fitxers no suporten la limitació per ruta de directoris directament.

# Sols funciona amb ZFS
$ lxc config device set my-container root size 20GB

De CPU

Dins de les limitacions de CPU hi ha varis tipus:

  • Donar X CPUs: De manera que el contenidor sols veu X nuclis.
$ cat /proc/cpuinfo | grep processor
processor	: 0
processor	: 1
processor	: 2
processor	: 3
processor	: 4
processor	: 5
processor	: 6
processor	: 7
$ lxc config set c4 limits.cpu 2
$ lxc exec c4 -- cat /proc/cpuinfo | grep processor
processor	: 0
processor	: 1
  • Donar un grup de CPUs: De manera que el contenidor sempre té eixos nuclis i no depén de la càrrega com l'opció de dalt.
$ lxc config set c4 limits.cpu 1,3
  • Donar el % de càrrega: De manera que si li dones un 20%, el contenidor tindrà eixe 20% quant el processador està molt ocupat. Quant el processador està ociós, el contenidor tindrà tot el que necessite.
$ lxc config set c4 limits.cpu.allowance 10%
  • De cada 200ms, donar 50ms: Encara que el processador estiga ociós, sols li correspon 50ms de cada 200ms. Durant eixe temps té tots els nuclis. Això garantís un rendiment més determinista.
$ lxc config set c4 limits.cpu.allowance 25ms/200ms
  • Reduir la prioritat del procés:
$ lxc config set c4 limits.cpu.priority 0

De RAM

Les limitacions de memòria també pareixen fàcils, però no ho són.

Per una banda està la possibilitat o no d'utilitzar swap.

$ lxc config set my-container limits.memory.swap false

Si un contenidor es queda sense RAM pot tindre dos comportaments:

  • Amb límit hard: El kernel mata processos per buidar. (Per defecte)
  • Amb límit soft: Deixa un cert marge per ampliar un moment la RAM disponible.
$ lxc config set my-container limits.memory.enforce soft

Exemple:

$ lxc exec c4 -- free -h
              total        used        free      shared  buff/cache   available
Mem:            17G         21M         17G         73M          0B         17G
Swap:          952M          0B        952M
$ lxc config set c4 limits.memory 256MB
$ lxc exec c4 -- free -h
              total        used        free      shared  buff/cache   available
Mem:           256M         21M        234M         73M          0B        234M
Swap:          952M          0B        952M

De xarxa

Es pot controlar els bits/s d'entrada o eixida en les xarxes bridged o p2p.

$ lxc profile device set default eth0 limits.ingress 100Mbit
$ lxc profile device set default eth0 limits.egress 100Mbit

També es pot controlar la prioritat en cas de targetes de xarxa saturades.

$ lxc config set my-container limits.network.priority 5

D'entrada/Eixida

Es pot, per exemple, limitar la velocitat de lectura o escriptura del disc:

$ lxc config device set my-container limits.read 30MB
$ lxc config device set my-container limits.write 10MB

Amb:

$ lxc info c4

Podem veure els recursos utilitzats.

Gestionar discos

Xarxa

Quant creem un contenidor, la seua configuració de xarxa està especificada en /etc/default/lxd-bridge.

Observem el que passa al fer ifconfig:

jose@server:~$ ifconfig 
enp0s3    Link encap:Ethernet  direcciónHW 08:00:27:e8:3b:93  
          Direc. inet:10.0.2.15  Difus.:10.0.2.255  Másc:255.255.255.0
          Dirección inet6: fe80::a00:27ff:fee8:3b93/64 Alcance:Enlace
          ACTIVO DIFUSIÓN FUNCIONANDO MULTICAST  MTU:1500  Métrica:1
          Paquetes RX:211835 errores:0 perdidos:0 overruns:0 frame:0
          Paquetes TX:105051 errores:0 perdidos:0 overruns:0 carrier:0
          colisiones:0 long.colaTX:1000 
          Bytes RX:165676776 (165.6 MB)  TX bytes:6341150 (6.3 MB)

lo        Link encap:Bucle local  
          Direc. inet:127.0.0.1  Másc:255.0.0.0
          Dirección inet6: ::1/128 Alcance:Anfitrión
          ACTIVO BUCLE FUNCIONANDO  MTU:65536  Métrica:1
          Paquetes RX:160 errores:0 perdidos:0 overruns:0 frame:0
          Paquetes TX:160 errores:0 perdidos:0 overruns:0 carrier:0
          colisiones:0 long.colaTX:1 
          Bytes RX:11840 (11.8 KB)  TX bytes:11840 (11.8 KB)

lxdbr0    Link encap:Ethernet  direcciónHW fe:ef:19:c3:53:10  
          Dirección inet6: fe80::7875:78ff:fe2e:d0f5/64 Alcance:Enlace
          Dirección inet6: fe80::1/64 Alcance:Enlace
          ACTIVO DIFUSIÓN FUNCIONANDO MULTICAST  MTU:1500  Métrica:1
          Paquetes RX:8 errores:0 perdidos:0 overruns:0 frame:0
          Paquetes TX:5 errores:0 perdidos:0 overruns:0 carrier:0
          colisiones:0 long.colaTX:1000 
          Bytes RX:536 (536.0 B)  TX bytes:470 (470.0 B)

vethGNE6GU Link encap:Ethernet  direcciónHW fe:ef:19:c3:53:10  
          Dirección inet6: fe80::fcef:19ff:fec3:5310/64 Alcance:Enlace
          ACTIVO DIFUSIÓN FUNCIONANDO MULTICAST  MTU:1500  Métrica:1
          Paquetes RX:8 errores:0 perdidos:0 overruns:0 frame:0
          Paquetes TX:8 errores:0 perdidos:0 overruns:0 carrier:0
          colisiones:0 long.colaTX:1000 
          Bytes RX:648 (648.0 B)  TX bytes:648 (648.0 B)

A banda de la targeta real (enp0s3) i la de loopback, trobem un pont anomenat lxdbr0 i una targeta amb un nom extrany. El pont el proporciona lxd i funciona com a NAT cap a l'exterior. La targeta extranya ès la eth0 de dins del contenidor i està visible al fer ifconfig perquè els contenidors comparteixen el Kernel amb el sistema operatiu.

Al instal·lar LXD, per defecte crea el pont lxdbr0 que sols proporciona connectivitat IPv6 amb el host. Per activar la IPv4 i la possibilitat de connectar a Internet, cal executar el lxd init abans de tot o el dpkg-reconfigure -p medium lxd

LXD proporciona varies maneres de configurar la xarxa.

Per defecte ens dona una xarxa tipus bridged que funciona correctament per a la majoria dels casos. La xarxa bridged es connecta al pont lxdbr0 i aquest fa un NAT amb l'exterior. Poden haver problemes amb els DNS i, sobretot, per connectar de l'exterior al contenidor.

Anem a veure els tipus de xarxa que es poden configurar:

LXD supports different kind of network devices:
- physical: Straight physical device passthrough from the host. The targeted device will vanish from the host and appear in the container.
- bridged: Uses an existing bridge on the host and creates a virtual device pair to connect the host bridge to the container.
- macvlan: Sets up a new network device based on an existing one but using a different MAC address.
- p2p: Creates a virtual device pair, putting one side in the container and leaving the other side on the host.
  • Bridged: Una xarxa pont utilitza les funcionalitats dels ponts de xarxa que proporciona Linux. Aquests es comporten de manera molt pareguda a la d'un switch, inclús tenen algoritmes per evitar bucles, entre antres. Com que és un switch, aquest pot estar connectat a una targeta de xarxa real o a un pont virtual que permet l'accés a l'exterior amb NAT. La xarxa bridged és la que va per defecte i LXD automàticament pot proporcional servei DHCP i NAT a aquest pont.
  • Macvlan: En aquest mode, la targeta física obté una nova MAC i un altra IP amb les sub-interfaces macvlan. Açò és diferent de crear una vlan en una interficie, ja que aquestes vlan comparteixen MAC i macvlan té una MAC distinta per a cadascuna.

Utilitzarem bridged quant necessitem escenaris complexos on connectem els contenidors entre d'ells o necessitem configuracions de nivel 2 en el pont. Al funcionar en NAT, no afegeix complexitat a la xarxa externa, però complica la connexió amb l'interior. Utilitzarem macvlan quant vulguem fer un servidor connectat directament amb la xarxa externa del host.

Referències [6][7][8]

Crear un nou nic

En un sol contenidor

$ lxc config device add xamp eth1 nic nictype=bridged parent=lxdbr0
Device eth1 added to xamp
$ lxc config show --expanded xamp
name: xamp
profiles:
- default
config:
  volatile.base_image: 6f25adef061c3f2186c6910bff8cacd0c63e1493e3f8b616e52eb84076890bd1
  volatile.eth0.hwaddr: 00:16:3e:11:3d:0a
  volatile.eth1.hwaddr: 00:16:3e:05:3e:90
  volatile.eth1.name: eth1
  volatile.last_state.idmap: '[{"Isuid":true,"Isgid":false,"Hostid":296608,"Nsid":0,"Maprange":65536},{"Isuid":false,"Isgid":true,"Hostid":296608,"Nsid":0,"Maprange":65536}]'
devices:
  eth0:
    name: eth0
    nictype: bridged
    parent: lxdbr0
    type: nic
  eth1:
    nictype: bridged
    parent: lxdbr0
    type: nic
  root:
    path: /
    type: disk
ephemeral: false

També es pot executar

$ lxc config edit xamp

I afegir el nic. D'aquesta manera és més sencill i evitar errades en el comandament. No obstant el comandament anterior permet executar-lo en un script.

Si volem que tinga una MAC determinada:

 lxc config set container_name volatile.eth0.hwaddr yo:ur:ma:ca:dd:ress

En molts contenidors

Es pot crear i editar un perfil:

$ lxc profile create bridged
$ lxc profile device add bridged eth0 nic nictype=bridged parent=br0
$ lxc launch ubuntu:16.04 test --profile=bridged

o afegir a contenidors existents:

$ lxc profile apply xamp default,bridged

Accedir de l'exterior

En xarxa Bridged

Amb IPtables

Imaginem que tenim un servidor web que escolta al port 80:

En el servidor que continga LXD:

# iptables -t nat -A PREROUTING -i enp0s3 -p tcp --dport 80 -j DNAT --to 10.243.177.135:80
# iptables -t nat -A PREROUTING -i enp0s3 -p tcp --dport 443 -j DNAT --to 10.243.177.135:443
# iptables-save >  /etc/iptables/rules.v4

En cas de que el servidor estiga en una màquina virtual en Virtualbox:

Reenviamentportsvirtualbox.png

Ara podem accedir amb el navegador web amb: localhost:8080

Amb ponts

Un altra manera és creant un nou pont:

auto br0
iface br0 inet manual
bridge-ports eth1
$ dpkg-reconfigure lxd
previament necessitem instal·lar bridge-utils

En xarxa physical

En principi funcionarà dirèctament, ja que deixa al host sense targeta i la clava dins del contenidor. No és recomanable, ja que pots deixar el servidor sense xarxa. Sols en cas d'us servici molt intensiu en un servidor en varies targetes dedicades.

En xarxa macvlan

També pot funcionar directament.

$ lxc profile device set default eth0 nictype macvlan
$ lxc profile device set default eth0 parent eth1
Tant la solució amb ponts com macvlan no ha funcionat en les nostres proves en Virtualbox en targetes en mode pont. Sí funciona en mode xarxa lan o interna. En màquines físiques funciona tot. Edició: Si funciona si fiques la targeta PCnet-FAST III i mode promiscu

Configuració IP

Quan iniciem LXD ens demana algunes configuracions, però no totes. Aquestes configuracions i altres estan en el fitxer /etc/default/lxd-bridge.

IP fixa en lxdbr0

Tenim que configurar el DHCP que té LXD per defecte. Per a fer-ho, creem un fitxer: /etc/default/lxd-static-ip.conf. En ell escrivim:

# dhcp-host=<containername>,<static-ipaddress>
dhcp-host=cont1,10.0.0.1/16

I ara cal dir al fitxer de configuració que ha de fer cas a aquest fitxer addicional. En /etc/default/lxd-bridge modifiquen la línia:

LXD_CONFILE="/etc/default/lxd-static-ip.conf"

IP estàtica en qualsevol targeta

Com que els containers poden ser de moltes distribucions, el que es recomana és configurar internament el container. És a dir, manipular /etc/network/interfaces. Encara que es pot fer en un comandament amb lxc file push:

echo -e "\n\nauto eth2\niface eth2 inet static\naddress 192.168.9.9\nnetmask 255.255.255.0" > /tmp/eth2.cfg && lxc file push /tmp/eth2.cfg u1/etc/network/interfaces.d/

Canviar nic de pont

lxc config device set u1 eth2 parent br1

Comandes de gestió de la xarxa

A partir de la versió 2.3, accepta comandes per a gestionar la xarxa de manera més natural que amb lxd init.

Es pot crear una nova xarxa:

lxc network create testbr0
lxc network show testbr0
lxc network list

Aquest comandament crea un pont nou amb IP aleatòria, DHCP i NAT.

lxc network create testbr0 ipv6.address=none ipv4.address=10.0.3.1/24 ipv4.nat=true

Amb aquest comandament hem fet una xarxa sense IPv6, amb una adreça fixa i amb NAT.

lxc network create testbr0 ipv4.address=none ipv6.address=none bridge.external_interfaces=eth0

Aquest crea una xarxa sols amb un pont en una interfície externa sense DHCP ni NAT.

lxc network attach-profile testbr0 default eth0

Aquest comandament afegeix aquesta xarxa al profile default diguent que serà la eth0 en els contenidors.

lxc network attach testbr0 my-container deth0 eth0

Aquest sols l'afegix a un contenidor.

lxc config device set c1 eth0 ipv4.address 10.0.3.123

Aquest comandament configura el DHCP del contenidor per a que li done una IP fixa. De manera més simple que editant els fitxers de dins.

Veure també

LXC, Control Aula, LXD per a SX, Proxmox

Enllaços