Crear contenedores con usuarios sin privilegios utilizando LXC en Ubuntu

Introducción

Los contenedores creados por usuarios sin privilegios son muchos mas seguros en comparación con su contraparte creados por el usuario root ya que su administrador no corresponde directamente con el usuario administrador del huésped sino que sus usuarios son mapeados por unos UID y GID diferentes.  Por ejemplo, el root (0) de un contenedor será mapeado el huésped por un UID como 100000 por lo tanto, en el peor caso en que un atacante lograra salir del contenedor hasta el huésped, lo haría como un usuario sin privilegios.

Esto también trae consigo como efecto colateral negativo que las siguientes operaciones no sean permitidas.

  1. Montar la mayoría de sistemas de archivos.
  2. Crear dispositivos de nodo.
  3. Cualquier operación realizada por un uid/gid que no se encuentre en la lista de mapeo.

Adicionalmente esto produce que las plantillas de las distribuciones no funcionen y sea necesario utilizar la plantilla download que permite descargar imagenes preconstruidas de las distribuciones que funcionan en este tipo de ambiente.

Configuración para permitir contenedores por usuarios sin privilegios

$ mkdir -p ~/.config/lxc
$ echo "lxc.id_map = u 0 100000 65536" > ~/.config/lxc/default.conf
$ echo "lxc.id_map = g 0 100000 65536" >> ~/.config/lxc/default.conf
$ echo "lxc.network.type = veth" >> ~/.config/lxc/default.conf
$ echo "lxc.network.link = lxcbr0" >> ~/.config/lxc/default.conf
$ echo "$USER veth lxcbr0 10" | sudo tee -a /etc/lxc/lxc-usernet

Si se desea puede tomarse al archivo /etc/lxc/default.conf  como plantilla para la preparación del archivo de configuración local del usuario ~/.config/lxc/default.conf.

Los valores de lxc.id_map tanto para el grupo como para el usuario deberán coincidir con los registrados en and /etc/subgid y /etc/subuid respectivamente.  En caso que requiera ajustar estos rangos utilizar el siguiente comando.

$ sudo usermod -v 100000-200000 -w 100000-200000 NOMBRE_USUARIO

Comúnmente es necesario cerrar y volver a abrir la sesión del usuario actual o inclusive, reiniciar el sistema operativo para garantizar que el usuario se encuentre correctamente asignado a sus respectivos cgroups
(esto es especialmente importante si cgmanager no se había instalado antes de la instalación de LXC).

En caso de ser necesario, ajuste el permiso de ejecución en el directorio bajo el cual se almacena la configuración y los sistemas de archivos de los contenedores: ~/.local/share/lxc/.

$ sudo chmod -R o+X ~/.local

Administración de los contenedores

La administración de los contenedores se realiza tal y como se reseña en un artículo anterior, esta vez sin la necesidad del sudo ya que son contenedores creados por usuarios sin privilegios de administración.

A continuación se reseñan los comandos principales.

$ lxc-create -t download -n NOMBRE_CONTENEDOR — -d PLANTILLA -r VERSION -a ARQUITECTURA Crear un nuevo contenedor
$ lxc-start -n NOMBRE_CONTENEDOR -d Iniciar un contenedor
$ lxc-attach -n NOMBRE_CONTENEDOR
Acceder al shell de un contenedor desde el actual
$ lxc-stop -n NOMBRE_CONTENEDOR
Detener a un contenedor
$ lxc-destroy -n NOMBRE_CONTENEDOR
Destruir (remover) un contenedor existente

Recursos

  1. LXC in Ubuntu’s Server Guide
    https://help.ubuntu.com/lts/serverguide/lxc.html
  2. LXC Getting Started in Linux Containers
    https://linuxcontainers.org/lxc/getting-started/

Los primeros 10 minutos con LXC en Ubuntu

Rutas

/var/cache/lxc Imágenes de sistemas operativos descargados a partir de un template
/etc/lxc Configuración general
/var/lib/lxc/ Contenedores creados por root
/var/lib/lxc/NOMBRE_CONTENEDOR/config Configuración específica del contenedor
~/.local/share/lxc Contenedores creados por usuarios sin privilegios

Instalación

Instalación de los paquetes básicos.

$ sudo aptitude install lxc lxc-templates

De acuerdo al sistema operativo (template) que se desee instalar también será necesario uno de los siguientes paqutes.

ArchLinux arch-install-scripts
Debian/Ubuntu debootstrap
CentOS yum

Una vez instalado probar el ambiente disponible.

$ lxc-checkconfig

Kernel configuration not found at /proc/config.gz; searching...
Kernel configuration found at /boot/config-3.13.0-37-generic
--- Namespaces ---
Namespaces: enabled
Utsname namespace: enabled
Ipc namespace: enabled
Pid namespace: enabled
User namespace: enabled
Network namespace: enabled
Multiple /dev/pts instances: enabled

--- Control groups ---
Cgroup: enabled
Cgroup clone_children flag: enabled
Cgroup device: enabled
Cgroup sched: enabled
Cgroup cpu account: enabled
Cgroup memory controller: enabled
Cgroup cpuset: enabled

--- Misc ---
Veth pair device: enabled
Macvlan: enabled
Vlan: enabled
File capabilities: enabled

Note : Before booting a new kernel, you can check its configuration
usage : CONFIG=/path/to/config /usr/bin/lxc-checkconfig

Comandos principales

Listar los templates disponibles

$ ls /usr/share/lxc/templates

    lxc-alpine    lxc-archlinux  lxc-centos  lxc-debian    lxc-fedora  lxc-openmandriva  lxc-oracle  lxc-sshd    lxc-ubuntu-cloud
 lxc-altlinux  lxc-busybox    lxc-cirros  lxc-download  lxc-gentoo  lxc-opensuse      lxc-plamo   lxc-ubuntu

Crear un contenedor (usuario con privilegios)

$ sudo lxc-create -n NOMBRE_CONTENEDOR -t NOMBRE_TEMPLATE

Para especificar una versión (release) específico del template que se desea instalar.  Por ejemplo, si se desea elegir ubuntu lucid específicamente se debe ejecutar el siguiente comando.

$ sudo lxc-create -t ubuntu -n NOMBRE_CONTENEDOR -- -r lucid

Si se desea crear un contenedor de 32 bits en una máquina de 64 bits es necesario agregar el parámetro -a de la sigiuente manera.

$ sudo lxc-create -n NOMBRE_CONTENEDOR -t NOMBRE_TEMPLATE -a i386

Información de los contenedores

$ lxc-ls --fancy

Obtener información ampliada de un contenedor específico

$ lxc-info --name NOMBRE_CONTENEDOR

Iniciar un contenedor

$ lxc-start -n NOMBRE_CONTENEDOR -d

Acceder a la consola de un contenedor

$ lxc-console -n NOMBRE_CONTENEDOR

Para salir de la consola es necesario presionar la secuencia de teclas Ctrl+A Q.

Para acceder al shell del contenedor desde el mismo shell actual, ejecutar el siguiente comando.

$ lxc-attach -n NOMBRE_CONTENEDOR

Suspender (congelar) la ejecución de un contenedor

$ lxc-freeze -n NOMBRE_CONTENEDOR

Reanudar (descongelar) la ejecución de un contenedor

$ lxc-unfreeze -n NOMBRE_CONTENEDOR

Finalizar la ejecución de un contenedor

Realizar una finalización segura (apagado).

$ lxc-shutdown -n NOMBRE_CONTENEDOR

Realizar un apagado abrupto (halar del cable).

$ lxc-stop -n NOMBRE_CONTENEDOR

Destruir un contenedor

Esta acción elimina los archivos asociados con el contenedor.

$ lxc-destroy -n NOMBRE_CONTENEDOR

Recursos

Los primeros 10 minutos con LXD el hypervisor de contenedores en Ubuntu

Instalación

$ sudo add-apt-repository ppa:ubuntu-lxc/lxd-git-master

$ sudo apt-get update

$ sudo apt-get install lxd

El proceso de instalación incluye la creación del grupo lxd al que deberán pertenecer todos los usuarios que interactúen con los contenedores.  Inicialmente se agregan a este grupo todos los usuarios que pertenecían a admin y sudoers en el momento de la instalación.

Una vez realizada la instalación es necesario cerrar y volver a abrir la sesión de usuario para que la inscripción en el grupo lxd sea tomada en cuenta.  Si se desea obviar esto, ejecute el siguiente comando para incluir al usuario en el grupo mencionado sobre la sesión actual.

$ newgrp lxd

Gestión de imágenes

Agregar el repositorio de linuxcontainers.org.

$ lxc remote add lxc-org images.linuxcontainers.org

$ lxc remote list

+---------+-----------------------------------------+--------+
|  NAME   |                   URL                   | PUBLIC |
+---------+-----------------------------------------+--------+
| local   | unix:///var/lib/lxd/unix.socket         | NO     |
| lxc-org | https://images.linuxcontainers.org:8443 | YES    |
+---------+-----------------------------------------+--------+

Importar imágenes para tenerlas disponibles localmente.

# Ubuntu Cloud
$ lxd-images import ubuntu --alias ubuntu-cloud

# Debian 8 64 bits
$ lxc image copy lxc-org:/debian/jessie/amd64 local: --alias=jessie-amd64

Consultar mas información acerca de las imágenes disponibles en el repositorio de linuxcontainers.org.

Listar las imágenes disponibles en un repositorio remoto

$ lxc image list lxc-org:

+--------------------------------+--------------+--------+-------------------------+---------+-------------------------------+
|             ALIAS              | FINGERPRINT  | PUBLIC |       DESCRIPTION       |  ARCH   |          UPLOAD DATE          |
+--------------------------------+--------------+--------+-------------------------+---------+-------------------------------+
|                                | ee326b31ae93 | yes    | Debian squeeze (amd64)  | x86_64  | Oct 1, 2015 at 6:17pm (COT)   |
|                                | cd3f30323ce2 | yes    | Centos 6 (amd64)        | x86_64  | Oct 1, 2015 at 10:17pm (COT)  |
|                                | b6a940bfe3a4 | yes    | Plamo 5.x (amd64)       | x86_64  | Sep 30, 2015 at 5:23pm (COT)  |
|                                | 5351e4792a81 | yes    | Plamo 5.x (amd64)       | x86_64  | Oct 1, 2015 at 5:24pm (COT)   |
|                                | 02a8d955bc82 | yes    | Plamo 5.x amd64 (mini)  | x86_64  | Sep 30, 2015 at 5:50pm (COT)  |
|                                | 5df2ba98422b | yes    | Plamo 5.x amd64 (mini)  | x86_64  | Oct 1, 2015 at 5:50pm (COT)   |

...

Listar las imágenes disponibles localmente

$ lxc image list

+--------------+--------------+--------+------------------------------------+--------+------------------------------+
|    ALIAS     | FINGERPRINT  | PUBLIC |            DESCRIPTION             |  ARCH  |         UPLOAD DATE          |
+--------------+--------------+--------+------------------------------------+--------+------------------------------+
| jessie-amd64 | 87c085189294 | yes    | Debian jessie (amd64)              | x86_64 | Oct 3, 2015 at 1:40am (COT)  |
| ubuntu-cloud | a1448d43bb7c | no     | Ubuntu 14.04 LTS server (20150930) | x86_64 | Oct 3, 2015 at 12:49am (COT) |
+--------------+--------------+--------+------------------------------------+--------+------------------------------+

Obtener información de una imagen disponible localmente.

$ lxc image info jessie-amd64

Fingerprint: 87c085189294cd6a316dbefe1e235f9b9e69aa1b049df4ddce2202ad0f9c56ab
Size: 1e+02MB
Architecture: x86_64
Public: no
Timestamps:
    Created: 2015/10/02 23:30 UTC
    Uploaded: 2015/10/03 06:40 UTC
    Expires: never
Properties:
    description: Debian jessie (amd64)
Aliases:
    - jessie-amd64

Remover una imagen dispoible localmente.

$ lxc image delete jessie-amd64

Sincronizar la versión de las imágenes locales con la disponible en los repositorios.

$ lxd-images sync

Es posible agregar la opción --sync durante la importación de la imagen para mantenerla actualizada automáticamente.

Gestión de contenedores

Crear un nuevo contenedor a partir de una imagen disponible localmente.

$ lxc launch ubuntu-cloud myContainer

Si la imagen solicitada, ubuntu-cloud en este caso, no se encuentra disponible localmente, esta es importada automáticamente y puesta en el caché por 10 días.

Listar los contenedores disponibles y su estado.

$ lxc list

Iniciar un contenedor explícito.

$ lxc start myContainer

Consultar el registro (log) de un contenedor explícito.

$ lxc info --show-log myContainer

Detener a un contenedor explícito.

$ lxc stop myContainer

Destruir (remover) a un contenedor explícito.

$ lxc delete myContainer

Interacción con el contenedor

Ejecutar un comando en un contenedor específico.

$ lxc exec myContainer -- COMANDO

Acceder al shell del contenedor.

$ lxc exec myContainer -- /bin/bash

Transferir un archivo hacia el contenedor.

$ lxc file push ARCHIVO myContainer/ruta/de/destino

Transferir un archivo desde el contenedor.

$ lxc file pull myContainer/ruta/de/origen .

Recursos

  1. What’s LXD?
    https://linuxcontainers.org/lxd/introduction/
  2. LXD – The Linux container hypervisor
    http://www.ubuntu.com/cloud/tools/lxd
  3. Getting started with LXD – the container lightervisor
    https://insights.ubuntu.com/2015/04/28/getting-started-with-lxd-the-container-lightervisor/
  4. Installing LXD and the command line tool
    https://insights.ubuntu.com/2015/03/20/installing-lxd-and-the-command-line-tool/
  5. Infographic: LXD Machine containers from Ubuntu
    https://insights.ubuntu.com/2015/09/23/infographic-lxd-machine-containers-from-ubuntu/
  6. Repositorio de LXD en GitHub
    https://github.com/lxc/lxd

Los primeros 10 minutos con Vagrant

Instalación

Instalar Virtualbox como prerequisito si aún no se cuenta con este software.

$ sudo aptitude install dkms virtualbox

Es recomendable instalar su correspondiente Extension Pack.

Para el caso de Ubuntu/Debian descargar el archivo .deb correspondiente a la arquitectura desada del sitio web de descargas e instalarlo localmente.

$ sudo dpkg -i vagrant_*.deb

Obtener la caja (box) a obtenerse

Una box hace referencia a la máquina virtual base que se utilizará para crear la que se asociará al proyecto.

$ vagrant box add ubuntu/trusty32

En este caso ubuntu/trusty32 hace referencia al nombre de la imagen que va a descargarse.  Pueden  utilizarse otras imágenes que se encuentran en linea gracias al repositorio oficial de Vagrant.

Los archivos asociados a estas imágenes son descargados bajo el directorio ~/.vagrant.d/boxes.

Crear el archivo de configuración

En el directorio del proyecto ejecutar el siguiente comando

$ vagrant init ubuntu/trusty32

Esto básicamente crea una versión base del archivo Vagrantfile para configurar la máquina virtual y asigna automáticamente la box a utilizarse en el proyecto.

$ vi VagrantFile

   ...
   config.vm.box = "ubuntu/trusty32"
   ...

Una vez se cree la máquina virtual por primera vez (con el primer vagrant up) sus archivos quedarán por defecto bajo ~/VirtualBox\ VMs/.

Reenvío de puertos

Para configurar el reenvío de puertos entre la máquina virtual y la máquina física se deben agregar una o mas opciones config.vm.network al archivo Vagrantfile.

$ vi VagrantFile

   ...
   config.vm.network :forwarded_port, guest: 80, host: 8080
   config.vm.network :forwarded_port, guest: 443, host: 80443
   ...

Configurar la interfaz de red

El acceso a la red de la máquina virtual puede configurarse de manera privada (sólo el host y otras máquinas pueden acceder a ella) o de manera pública en la cual cualquier equipo en la red puede interactúar con la máquina virtual.

Configuración privada

Es posible utilizar una dirección IP estática de la siguiente manera.

$ vi VagrantFile

   ...
   config.vm.network "private_network", ip: "192.168.1.100"
   ...

O una dirección IP dinámica.

$ vi VagrantFile

   ...
   config.vm.network "private_network", type: "dhcp"
   ...

Configuración pública

Al igual que con la configuración privada, es posible asignar una dirección IP estática.

$ vi VagrantFile

   ...
   config.vm.network "public_network", ip: "192.168.1.100"
   ...

O una dirección IP dinámica basada en el DHCP de la red.

$ vi VagrantFile

   ...
   config.vm.network "public_network"
   ...

Directorios sincronizados

Por defecto el directorio /vagrant de la máquina virtual se encuentra sincronizado con el directorio del proyecto en la máquina física, es decir, en este directorio se deberán ubicar los archivos que deberán perdurar en el tiempo.

Es posible especificar otros directorios sincronizados mediante diferentes métodos.

Gestión de la máquina virtual

Iniciar la máquina virtual

$ vagrant up

Acceder a la máquina virtual a través de una sessión de SSH

$ vagrant ssh

Suspender una máquina virtual activa

$ vagrant suspend

En este caso el estado de la máquina en memoria (además de sus archivos) es almacenado en disco.  Su reinicio es muy rápido (entre 5 y 10 segundos).

Detener una máquina virtual activa

$ vagrant halt

Este comando realiza un apagado limpio de la máquina virtual.  El reinicio de la máquina toma un poco mas de tiempo.

Destruir una máquina virtual

$ vagrant destroy

Este comando apaga abruptamente la máquina virtual si esta se encuentra activa y remueve todos los archivos asociados a la misma sin incluir las carpetas compartidas (/vagrant).

Obtener ayuda de los comandos vagrant

Para listar los comandos disponibles utilice el siguiente comando.

$ vagrant list-commands

Para obtener ayuda adicional sobre un comando en especial utilice la siguiente variante.

$ vagrant COMANDO -h

Recursos

Instalando KVM con Libvirt y la interfaz de red en puente bajo Ubuntu 11.10

Introducción

Desde la versión 9.10 de Ubuntu no había actualizado el proceso de instalación de KVM y de la interfaz de red en puente que realizo en mi servidor de desarrollo.  En este caso estoy utilizando la versión 11.10 y a continuación describo el procedimiento seguido para instalar KVM utilizando el metapaquete del repositorio estándar, crear la interfaz de red e instalar una máquina virtual inicial.

Instalación de KVM con Libvirt

$ sudo aptitude install ubuntu-virt-server

Es necesario que los usuarios que vayan a interactuar con las máquinas virtuales pertenezcan al grupo de libvirtd.  En el caso de la instalación es necesario que el usuario actual termine su sesión y la inicie nuevamente para que su suscripción al grupo sea tenida en cuenta.

Creación del puente en la interfaz de red

Asignar los permisos de manipulación de red requeridos al usuario que se encontrará activo durante la creación del puente.

$ sudo setcap cap_net_admin=ei /usr/bin/qemu-system-x86_64

Agregar el nombre de usuario elegido frente a la propiedad cap_net_admin.

$ sudo vi /etc/security/capability.conf

    cap_net_admin        USUARIO

Actualizar la configuración de las interfaces de red.

$ sudo vi /etc/network/interfaces

    auto lo
    iface lo inet loopback

    auto eth0
    iface eth0 inet manual

    auto br0
    iface br0 inet static
    address 192.168.1.250
    network 192.168.1.0
    netmask 255.255.255.0
    broadcast 192.168.1.255
    gateway 192.168.1.254
    bridge_ports eth0
    bridge_stp off
    bridge_fd 0
    bridge_maxwait 0

Reiniciar el servicio de red para que los cambios anteriores sean tenidos en cuenta.

$ sudo /etc/init.d/networking restart

Creación de una máquina virtual desde línea de comando

En el servidor instalar la herramienta de virt-install para la creación de máquinas virtuales desde la línea de comando.

$ sudo aptitude install virtinst

Solicitar la creación de la máquina virtual a partir de su configuración básica.

En este caso se va a instalar un Scientific Linux 5.7 llamada SL_57_x64_Generic con 384MB de RAM, un disco duro de 7GB y utilizará la interfaz de red en puente creada anteriormente.

$ virt-install 
    --connect qemu:///system 
    -n SL_57_x64_Generic 
    -r 384 
    --os-type linux 
    --os-variant generic26 
    --hvm 
    --cdrom /b1/ISO/SL.57.090911.DVD.x86_64.disc1.iso 
    --network bridge:br0 
    --disk path=/home/vms/SL_57_x64_Generic.img,size=7 
    --vnc --noautoconsole 
    --accelerate

Desde el cliente donde se deseen administrar las máquinas virtuales ejecutar el siguiente comando para conectarse a la máquina virtual recién creada para realizar el proceso de instalación.

$ virt-viewer -c qemu+ssh://SERVIDOR/system SL_57_x64_Generic

Enlaces

Instalando libvirt en ArchLinux

Introducción

Libvirt es un API de código abierto y una herramienta de administración para diferentes sistemas de virtualización entre los que se encuentran Xen, OpenVZ, Virtualbox, VMWare, Microsoft Hyper-V y por supuesto KVM/Qemu instalado en el servidor de desarrollo previamente.

Este software es ideal para la gestión de las máquinas virtuales y su administración remota a través de conexiones seguras con SSH.  Además incluye una librería en C para el desarrollo de aplicaciones e incluye además interfaces para diversos lenguajes como Python, Perl, Ruby, Java y PHP.

Instalación del software

Instalar los paquetes del repositorio oficial.

# pacman -S libvirt urlgrabber dnsmasq bridge-utils

Inicio automático del demonio

Configurar el demonio de libvirtd para que se inicie automáticamente junto con el sistema operativo.

# vi /etc/rc.conf

DAEMONS = (… libvirtd …)

Debe tenerse en cuenta que el demonio libvirtd requiere ser invocado después de dbus y avahi-daemon.

Autorizar la administración a usuarios sin privilegios

Si se desea que usuarios sin privilegios (diferentes de root) administren las máquinas virtuales, estos deberán ser explícitamente autorizados de la siguiente manera.

# vi /etc/polkit-1/localauthority/50-local.d/org.libvirt.unix.manage.pkla

[Allow a user to manage virtual machines]
Identity=unix-user:jimezam
Action=org.libvirt.unix.manage
ResultAny=yes
ResultInactive=yes
ResultActive=yes

Si en lugar de administración se desea conceder la autorización para monitorear las máquinas se deberá especificar la siguiente acción.

org.libvirt.unix.monitor

Permitir el acceso a través de SSH

Para permitir el acceso a las máquinas virtuales a través de herramientas como virsh o virt-viewer a través del protocolo SSH (qemu+ssh) es necesario contar con paquete netcat de OpenBSD instalado de la siguiente manera.

$ sudo pacman -S openbsd-netcat

Si se cuenta adicionalmente con el paquete netcat convencional instalado es posible que este se haya apoderado del enlace /usr/bin/nc y libvirt intente utilizarlo erróneamente generando el siguiente mensaje de error.

error: server closed connection: nc: invalid option — ‘U’
Try `nc –help’ for more information.
error: failed to connect to the hypervisor

En ese caso es necesario indicarle a libvirt cual es la versión de netcat que debe utilizar.  Esto se puede realizar desde los parámetros extra del URI en cada invocación de acceso de la siguiente manera.

$ virsh -d 0 –connect qemu+ssh://usuario@servidor/system?netcat=/usr/bin/nc.openbsd

O de manera permanente modificando en el servidor el enlace /usr/bin/nc de la siguiente manera.

$ sudo mv /usr/bin/nc /usr/bin/nc.orig

$ sudo ln -s /usr/bin/nc.openbsd /usr/bin/nc

Enlaces

Instalando KVM en ArchLinux

Introducción

Por fin he destinado el tiempo necesario para reintalar mi servido de desarrollo, esta vez utilizando ArchLinux.  Había utilizado con éxito esta distribución en un par de ocasiones sin embargo no había tenido la oportunidad de explorarla con mayor profundidad.

A continuación se describen los pasos que se siguieron para instalar KVM en ArchLinux.

Verificaciones preliminares

Se requiere de un versión de kernel igual o superior a la 2.6.22.

# uname -a

Linux ivy.jorgeivanmeza.com 3.1.1-1-ARCH #1 SMP PREEMPT Fri Nov 11 22:28:29 CET 2011 x86_64 AMD Phenom(tm) 9650 Quad-Core Processor AuthenticAMD GNU/Linux

De igual manera se requiere que el procesador cuente con soporte físico para virtualización: VMX (Intel) o SVM (AMD).

# grep -E “(vmx|svm)” –color=always /proc/cpuinfo

flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush mmx fxsr sse sse2 ht syscall nx mmxext fxsr_opt pdpe1gb rdtscp lm 3dnowext 3dnow constant_tsc rep_good nopl nonstop_tsc extd_apicid pni monitor cx16 popcnt lahf_lm cmp_legacy svm extapic cr8_legacy abm sse4a misalignsse 3dnowprefetch osvw ibs npt lbrv svm_lock

Instalación del software

Instalar los paquetes del repositorio oficial.

# pacman -S qemu-kvm

Agregar las cuentas de los usuarios que utilizarán el software al grupo kvm para que puedan acceder a /dev/kvm.

# gpasswd -a jimezam kvm

Verificar la carga de los módulos de kernel dependiendo del proveedor del procesador.

Para Intel Para AMD

# modprobe kvm

# modprobe kvm-intel

# modprobe kvm

# modprobe kvm-amd

Una vez cargados deberán aparecer en el listado de módulos activos.

# modprobe -l ‘kvm*’

kernel/arch/x86/kvm/kvm-amd.ko.gz
kernel/arch/x86/kvm/kvm.ko.gz

En caso de fallar la carga pero haber pasado la verificación inicial, verificar en la configuración de la BIOS si las extensiones de virtualización se encuentran desactivadas.

Configurar la carga automática de los módulos del kernel.

# vi /etc/rc.conf

MODULES=(kvm kvm-amd)

Enlaces