La entrada Gestión de Recursos en Entornos Virtualizados: Técnicas y Buenas Prácticas se publicó primero en Aprende IT.

En este artículo, te mostraremos cómo montar un disco en WSL y acceder a él desde Linux. Sigue leyendo para aprender más.

¿Qué es WSL?

WSL es una función de Windows que permite a los usuarios ejecutar una distribución de Linux en Windows. WSL es una capa de compatibilidad que traduce las llamadas del sistema Linux en llamadas del sistema Windows, lo que permite a los usuarios ejecutar aplicaciones Linux en Windows.

WSL es una característica extremadamente útil para los desarrolladores que necesitan trabajar en proyectos de Linux mientras utilizan Windows como sistema operativo principal. La capacidad de acceder a los archivos de Windows desde Linux en WSL es una de las ventajas de esta característica.

Cómo montar un disco en WSL

Montar un disco en WSL es un proceso sencillo que se puede hacer con unos pocos comandos en la línea de comandos.

Abre la aplicación «Terminal» en WSL. Si no tienes instalado WSL, puedes descargarlo desde la Microsoft Store.

Escribe el siguiente comando en la terminal para asegurarte de que tienes los permisos necesarios para montar el disco:

sudo mkdir /mnt/e

Este comando creará una carpeta llamada «e» en la ubicación /mnt. El prefijo «sudo» te dará permisos de administrador para ejecutar el comando.

A continuación, monta el disco E: en la carpeta /mnt/e con el siguiente comando:

sudo mount -t drvfs E: /mnt/e

Este comando utiliza la herramienta «mount» para montar el disco E: en la carpeta /mnt/e. El parámetro «-t drvfs» indica que se está utilizando el controlador de sistema de archivos de Windows para montar el disco.

Ahora deberías poder acceder al disco E: desde la terminal de WSL en la carpeta /mnt/e. Puedes cambiar al directorio E: con el siguiente comando:

cd /mnt/e

Cómo acceder a un disco montado en WSL desde la terminal

Una vez que hayas montado el disco en WSL, puedes acceder a él desde la terminal de Linux.

Abre la terminal de Linux en WSL.

Para acceder al disco E:, cambia al directorio /mnt/e con el siguiente comando:

cd /mnt/e

Ahora deberías poder ver los archivos y carpetas en el disco E: desde la terminal de Linux en WSL. Puedes utilizar los comandos habituales de Linux para trabajar con estos archivos y carpetas.
Cómo desmontar un disco en WSL

Para desmontar un disco en WSL, utiliza el siguiente comando:

sudo umount /mnt/e

Este comando desmontará el disco E: de la carpeta /mnt/e en WSL.

La entrada Cómo montar un disco en WSL y acceder a él desde la terminal se publicó primero en Aprende IT.

¿Qué es Vagrant y por qué deberías usarlo?

Vagrant es una herramienta de código abierto que nos permite crear, configurar y gestionar entornos de desarrollo virtualizados. Con Vagrant, podemos tener un entorno de desarrollo uniforme y controlado en nuestra máquina, independientemente del sistema operativo que utilicemos. Así, evitamos problemas de compatibilidad y podemos centrarnos en lo realmente importante: ¡desarrollar!

Pero, ¿qué ventajas tiene Vagrant? Pues bien, algunas de ellas son:

1. Facilita la colaboración entre desarrolladores, ya que todos pueden trabajar en el mismo entorno.
2. Simplifica la configuración y administración de máquinas virtuales.
3. Permite automatizar la creación y el aprovisionamiento de entornos de desarrollo.
4. Fomenta el uso de buenas prácticas en el desarrollo, como la infraestructura como código.

Instalación y configuración de Vagrant

Para instalar Vagrant, primero necesitamos tener un proveedor de virtualización en nuestra máquina. Uno de los más populares es VirtualBox, pero también podemos utilizar VMware, Hyper-V, entre otros. En este artículo, nos centraremos en VirtualBox. Para instalarlo, simplemente sigue las instrucciones en la página oficial de VirtualBox.
Una vez instalado el proveedor de virtualización, podemos descargar Vagrant desde su página oficial. Allí encontraremos versiones para Windows, macOS y Linux. Descarga e instala la versión adecuada para tu sistema operativo.

Primeros pasos con Vagrant

Ahora que tenemos Vagrant instalado, vamos a crear nuestro primer entorno de desarrollo virtualizado. Para ello, seguiremos estos pasos:

Abre una terminal y crea un nuevo directorio para nuestro proyecto:

mkdir mi-primer-entorno-vagrant
cd mi-primer-entorno-vagrant

Inicializa Vagrant en el directorio:

vagrant init

Este comando creará un archivo llamado Vagrantfile en nuestro directorio. Este archivo es la clave para configurar y personalizar nuestro entorno de desarrollo virtualizado.

Edita el Vagrantfile con tu editor de texto favorito y añade la siguiente línea:

config.vm.box = "hashicorp/bionic64"

Esta línea indica que vamos a utilizar la imagen «hashicorp/bionic64» como base para nuestra máquina virtual. Esta imagen es una versión de Ubuntu 18.04 (Bionic Beaver) de 64 bits. Hay muchas otras imágenes disponibles en el catálogo oficial de Vagrant, que puedes explorar en Vagrant Cloud.

Arranca la máquina virtual con el comando:

vagrant up

Vagrant descargará la imagen (si aún no lo ha hecho) y creará una nueva máquina virtual basada en ella. Este proceso puede tardar un poco, dependiendo de la velocidad de tu conexión a Internet y de tu equipo.

Una vez que la máquina virtual esté en funcionamiento, podemos conectarnos a ella mediante SSH:

vagrant ssh

¡Felicidades! Ahora estás conectado a tu primer entorno de desarrollo virtualizado con Vagrant. Puedes comenzar a instalar software, desarrollar aplicaciones y experimentar sin miedo a romper tu entorno local.

Provisionamiento de entornos

Una de las características más interesantes de Vagrant es el provisionamiento, que nos permite automatizar la configuración y la instalación de software en nuestras máquinas virtuales. Vagrant es compatible con varios sistemas de provisionamiento, como Shell, Puppet, Ansible y Chef, entre otros.
Para ilustrar cómo funciona el provisionamiento, vamos a utilizar un simple script de Shell. Añade las siguientes líneas a tu Vagrantfile, justo debajo de config.vm.box = «hashicorp/bionic64»:

config.vm.provision "shell", inline: <<-SHELL
    sudo apt-get update
    sudo apt-get install -y git nginx
SHELL

Estas líneas indican que Vagrant debe ejecutar un script de Shell que actualiza los repositorios de paquetes de Ubuntu e instala Git y Nginx. Para aplicar estos cambios, debemos volver a aprovisionar nuestra máquina virtual con el comando:

vagrant reload --provision

Una vez que el proceso haya finalizado, nuestra máquina virtual tendrá Git y Nginx instalados.

Comandos básicos de Vagrant

Aquí tienes una lista de algunos comandos básicos de Vagrant que te serán útiles en tu día a día:

• vagrant init: Inicializa un nuevo entorno de Vagrant en el directorio actual.
• vagrant up: Arranca la máquina virtual.
• vagrant ssh: Conéctate a la máquina virtual mediante SSH.
• vagrant halt: Apaga la máquina virtual.
• vagrant reload: Reinicia la máquina virtual.
• vagrant destroy: Elimina la máquina virtual y todos sus recursos.
• vagrant status: Muestra el estado de la máquina virtual.
• vagrant global-status: Muestra el estado de todas las máquinas virtuales en tu sistema.
• vagrant box: Gestiona las imágenes de máquinas virtuales (boxes) en tu sistema.

Trabajar con múltiples máquinas virtuales

Vagrant nos permite gestionar fácilmente múltiples máquinas virtuales en un mismo proyecto. Para ello, simplemente debemos añadir una nueva definición de máquina virtual en nuestro Vagrantfile. Por ejemplo, si queremos añadir una segunda máquina virtual con CentOS 7, podríamos hacer lo siguiente:

config.vm.define "centos" do |centos|
    centos.vm.box = "centos/7"
    centos.vm.hostname = "centos.local"
    centos.vm.network "private_network", ip: "192.168.33.20"
end

Con esta configuración, hemos creado una nueva máquina virtual llamada «centos» basada en la imagen «centos/7». Además, le hemos asignado un nombre de host y una dirección IP en una red privada.

Para arrancar ambas máquinas virtuales, simplemente ejecutamos el comando `vagrant up`. Si queremos arrancar solo una de ellas, podemos especificar su nombre:

vagrant up centos

Podemos conectarnos a la máquina virtual de CentOS mediante SSH con el siguiente comando:

vagrant ssh centos

Sincronización de archivos entre el host y la máquina virtual

Vagrant facilita la sincronización de archivos entre nuestra máquina host y las máquinas virtuales. Por defecto, el directorio en el que se encuentra nuestro `Vagrantfile` se sincroniza automáticamente con el directorio `/vagrant` dentro de la máquina virtual. Esto nos permite compartir archivos fácilmente entre ambos entornos.

Si queremos configurar una carpeta compartida personalizada, podemos hacerlo añadiendo la siguiente línea a nuestro `Vagrantfile`:

config.vm.synced_folder "mi-carpeta-local", "/mi-carpeta-remota"

Esta línea indica que la carpeta «mi-carpeta-local» en nuestra máquina host se sincronizará con la carpeta «/mi-carpeta-remota» en la máquina virtual. Vagrant se encargará de mantener ambos directorios sincronizados automáticamente.

Redes en Vagrant

Vagrant nos ofrece varias opciones para configurar la red en nuestras máquinas virtuales. Algunas de las más comunes son:

– Red privada: Permite a las máquinas virtuales comunicarse entre sí y con el host a través de una red privada. Para configurar una red privada, añade la siguiente línea a tu `Vagrantfile`:

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

– Red pública: Conecta la máquina virtual directamente a la red pública, permitiendo a otras máquinas en la red acceder a ella. Para configurar una red pública, añade la siguiente línea a tu `Vagrantfile`:

config.vm.network "public_network"

– Redireccionamiento de puertos: Permite acceder a servicios en la máquina virtual a través de un puerto específico en el host. Para configurar el reenvío de puertos, añade la siguiente línea a tu `Vagrantfile`:

config.vm.network "forwarded_port", guest: 80, host: 8080

Esta línea indica que el puerto 80 en la máquina virtual se redireccionará al puerto 8080 en nuestra máquina host.

La entrada Introducción a Vagrant: gestión de entornos de desarrollo virtualizados se publicó primero en Aprende IT.

Antes de comenzar, es importante destacar que el monitoreo de los recursos de tu ESX es crucial para asegurar que tu infraestructura esté funcionando de manera eficiente y evitar problemas de rendimiento y tiempo de inactividad. Además, al automatizar este proceso con un script en Python, podrás ahorrar tiempo y esfuerzo al no tener que hacerlo manualmente.

Ahora bien, para comenzar con el proceso de monitoreo de los recursos de tu ESX desde Python, necesitarás instalar las siguientes librerías:

• pyVmomi: es una librería de Python que proporciona una API para interactuar con vSphere y ESX.
• ssl: es una librería de Python que proporciona funcionalidades de seguridad de capa de sockets.

Una vez que hayas instalado estas librerías, podrás comenzar a escribir tu script para monitorear los recursos de tu ESX. El script que utilizaremos en este artículo se conectará a tu ESX y recuperará la información de hardware del host, así como la información de las máquinas virtuales en ejecución. Luego, calculará la cantidad total de CPU y RAM asignada a las máquinas virtuales y mostrará los resultados en la salida.

¡Pero no te preocupes si todo esto parece un poco complicado! Te explicaré cómo funciona el script paso a paso.

En primer lugar, importamos las librerías que necesitamos y establecemos las credenciales de inicio de sesión de nuestro hypervisor ESX:

import ssl
from pyVim.connect import SmartConnect, Disconnect
from pyVmomi import vim

# Información de inicio de sesión en el hypervisor ESX
hostname = 'esx_hostname_or_ip'
username = 'username'
password = 'password'

A continuación, creamos un contexto SSL personalizado que nos permitirá conectarnos al hypervisor ESX:

# Crear un contexto SSL personalizado
context = ssl.create_default_context()
context.check_hostname = False
context.verify_mode = ssl.CERT_NONE

# Conexión al hypervisor ESX con el contexto SSL personalizado
si = SmartConnect(host=hostname, user=username, pwd=password, sslContext=context)
content = si.RetrieveContent()

Luego, recuperamos la información de hardware del host utilizando el objeto content que creamos en el paso anterior:

# Obtener la información de hardware del host
host_system = content.rootFolder.childEntity[0].hostFolder.childEntity[0].host[0].summary.hardware
num_cpu_cores = host_system.numCpuCores
num_cpu_threads = host_system.numCpuThreads
total_memory = host_system.memorySize / (1024 ** 3)
cpu_model = host_system.cpuModel

Después, recuperamos la información de las máquinas virtuales en ejecución utilizando el objeto content nuevamente:

# Obtener la información de las máquinas virtuales en ejecución
vm_properties = ['name', 'config.hardware.numCPU', 'config.hardware.memoryMB']
vm_view = content.viewManager.CreateContainerView(content.rootFolder, [vim.VirtualMachine], True)
vms = vm_view.view
vm_view.Destroy()

A continuación, calculamos la cantidad total de CPU y RAM asignada a las máquinas virtuales en ejecución y la mostramos en la salida:

# Calcular la cantidad total de CPU y RAM asignada a las máquinas virtuales
num_vcpu_assigned = sum(vm.config.hardware.numCPU for vm in vms if vm.summary.runtime.powerState == vim.VirtualMachinePowerState.poweredOn)
total_memory_assigned = sum(vm.config.hardware.memoryMB for vm in vms if vm.summary.runtime.powerState == vim.VirtualMachinePowerState.poweredOn) / 1024

print(f"Tipo de procesador del host: {cpu_model}")
print(f"Número de núcleos con hyperthreading disponibles: {num_cpu_threads}")
print(f"Cantidad total de CPU asignada a las máquinas virtuales: {num_vcpu_assigned}")
print(f"Cantidad total de memoria asignada a las máquinas virtuales: {total_memory_assigned:.2f} GB")
print(f"Memoria total del host: {total_memory:.2f} GB")

Finalmente, cerramos la conexión al hypervisor ESX:

# Desconectar del hypervisor ESX
Disconnect(si)

Con este script, podremos obtener información valiosa sobre los recursos de nuestro ESX y asegurarnos de que todo esté funcionando correctamente. Además, al utilizar un script en Python para monitorear los recursos de nuestro ESX, podemos automatizar este proceso y ahorrar tiempo y esfuerzo.

En resumen, la supervisión de los recursos de CPU y RAM de tu ESX es fundamental para asegurar que tu infraestructura esté funcionando de manera eficiente y evitar problemas de rendimiento y tiempo de inactividad. Al automatizar este proceso con un script en Python, podrás ahorrar tiempo y esfuerzo al no tener que hacerlo manualmente. ¡Espero que este artículo te haya sido útil y te animo a probar este script en tu propio entorno!

La entrada Cómo supervisar los recursos de CPU y RAM de tu ESX desde Python se publicó primero en Aprende IT.

esxcli network ip interface ipv4 set -i vmnic0 -I 192.168.1.100 -N 255.255.255.0 -G 192.168.1.1

esxcli network vswitch standard add -v vSwitch1

esxcli network vswitch standard uplink add -u vmnic0 -v vSwitch1

esxcli network firewall set --enabled true

esxcli network firewall ruleset list

esxcli network firewall ruleset rule add -r sshServer -p TCP -o inbound -y allow

esxcli storage nmp device list

esxcli storage san fc list

esxcli storage vmfs extent list

esxcli network vswitch standard portgroup set -p "Management Network" -v vSwitch0

esxcli network vswitch standard portgroup policy security set -p "Management Network" -m promiscuous-mode -M accept

esxcli network vswitch standard portgroup policy vlan set -p "Management Network" -v 4095

esxcli storage nmp satp rule add -s "VMW_SATP_ALUA" -V "VMW_VAAI_NFS" -M "VMW_NMP_ALUA_DSS"

esxcli storage core adapter list

esxcli storage core device list -d naa.600601602ac0000000120000035000001

La entrada Comandos de red y FC para ESXi se publicó primero en Aprende IT.

En la instalación que ejecutaremos todo se gestionará desde CLI por lo que es valido tanto para sistemas de escritorio como para servidores.

¡Empezamos!

Compilar libvirt

Empezamos compilando e instalando libvirt. Para ello tenemos que instalar distintas dependencias dependiendo del sistema. Mostraremos como hacerlo tanto en CentOS como en Ubuntu. Antes de empezar, el sistema tiene que estar actualizado lo máximo posible.

Ubuntu:

apt install  ninja-build automake gcc  make zlib1g zlib1g-dev libpixman-1-0 libpixman-1-dev flex bison  numad libnuma-dev numactl  libtool gnutls-bin libghc-gnutls-dev libnl-genl-3-dev libxml2-dev  libtirpc-dev python3-docutils libdevmapper-dev libpciaccess-dev  rpcbind  libreadline-dev libyajl-dev libxslt-dev bzip2 meson libssh-4 libssh-dev libiscsi-bin libiscsi-dev xsltproc libcurl-ocaml libcurl-ocaml-dev fuse libfuse-dev libglusterfs-dev libgfapi0 libssh2-1 libssh2-1-dev libdevmapper-dev libparted-dev libxml2-utils pkg-config libglib2.0-dev

pip install -U meson==0.54.0

pip install ninja -U

groupadd --system libvirt
usermod -a -G libvirt $(whoami)
useradd -s /usr/bin/nologin libvirt-qemu

Centos7

yum install -y automake gcc  make glibc glibc-utils glib2-devel zlib-devel pixman-devel flex bison  numad numactl-devel numactl-libs numactl  libtool gnutls-utils  gnutls-devel  libnl3-devel libxml2-devel  libtirpc-devel python3-docutils device-mapper-devel libpciaccess-devel  rpcbind  readline-devel rpcgen yajl-devel libxslt-devel bzip2 meson libssh libssh-devel libiscsi libiscsi-devel

pip3 install rst2html5

pip install -U meson==0.54.0

pip install ninja -U

systemctl stop libvirtd

Ahora compilamos libvirt:

wget https://libvirt.org/sources/libvirt-6.9.0.tar.xz
tar xvfz libvirt-6.9.0.tar.xz 
xzcat libvirt-6.9.0.tar.xz | tar xv 
cd libvirt-6.9.0

meson build -D libssh2=enabled -D libssh=enabled -D glusterfs=enabled -D driver_qemu=enabled -D driver_vmware=enabled -D storage_mpath=enabled -D storage_lvm=enabled -D storage_iscsi=enabled -D storage_gluster=enabled -D storage_fs=enabled -D storage_disk=enabled -D driver_esx=enabled -D readline=enabled -D numad=enabled -D docs=disabled -D init_script=systemd -D system=true -D driver_qemu=enabled -D fuse=enabled -D prefix=/usr -D sharedstatedir=/var/lib -D localstatedir=/var -D curl=enabled -D sysctl_config=enabled

ninja -C build
sudo ninja -C build install

systemctl daemon-reload
systemctl start libvirtd-tcp.socket
systemctl enable libvirtd-tcp.socket
systemctl start libvirtd

Para poder hacer migraciones en caliente entre varios servidores de una forma rapida, configuraremos la migración sin autenticación.

[root@hypervisor1 libvirt-6.9.0]# cat /etc/libvirt/libvirtd.conf | grep auth_tcp
#auth_tcp = "sasl"
auth_tcp = "none"

También es necesario configurar la variable mech_list:

[root@hypervisor1 libvirt-6.9.0]# cat /etc/sasl2/libvirt.conf |grep -v "^#" |grep -v "^$"
mech_list: gssapi
[root@hypervisor1 libvirt-6.9.0]# 

Si reiniciamos libvirt-tcp.socket

[root@hypervisor1 libvirt-6.9.0]# systemctl restart libvirtd-tcp.socket
[root@hypervisor1 libvirt-6.9.0]# ss -putan|grep 16509
tcp LISTEN 0 4096 *:16509 *:* users:(("systemd",pid=1,fd=42))     

Qemu

Ahora que ya tenemos instalado libvirt, vamos a compilar Qemu a prepararlo para funcionar con libvirt. Al igual que ocurre en la compilación de livirt, para la compilación e instalación debemos realizar unos pasos previos que son distintos dependiendo del sistema operativo:

CentOS

 yum install -y spice-server spice-protocol SDL2-devel spice-protocol-devel spice-server-devel libusb libusb-devel libusb libusb-devel  usbredir usbredir-devel libnfs libnfs-devel wget; 

Ubuntu

apt install libcacard-dev libcacard0 pkg-config ninja-build libcurl-ocaml libcurl-ocaml-dev  libglib2.0-0 libglib2.0-dev libspice-server1 libspice-server-dev libusb-1.0-0 libusb-1.0-0-dev libusbredirhost1 libusbredirhost-dev libnfs-dev meson libpixman-1-0 libpixman-1-dev libsdl2-2.0-0 libsdl2-dev wget

Después debemos descargar el paquete de Qemu que vamos a compilar:

wget https://download.qemu.org/qemu-5.2.0.tar.xz
tar xvJf qemu-5.2.0.tar.xz
cd qemu-5.2.0

Ya estando dentro del directorio vamos a compilar con el siguiente comando:

./configure --prefix=/usr/local/qemu-kvm --enable-vhost-net --enable-kvm --enable-smartcard --enable-attr --enable-spice --enable-pie --enable-linux-user --enable-curl --enable-vnc --enable-sdl --enable-libusb --enable-usb-redir --enable-libnfs --enable-tools && make -j 20 && make install

Para finalizar tenemos que generar el enlace simbolico que hará que nuestro libvirt use la versión de qemu que acabamos de compilar e instalar:

ln -sf /usr/local/qemu-kvm/bin/qemu-system-x86_64 /usr/libexec/qemu-kvm

Para finalizar, debemos crear un enlace

Enlaces de interés

https://libvirt.org/sources/
https://libvirt.org/compiling.html#compiling
https://mesonbuild.com/Running-Meson.html

La entrada Compilar e instalar qemu-kvm y libvirt se publicó primero en Aprende IT.

ESXi Shell

Lo primero que debemos hacer es habilitar la shell de ESXi, normalmente está deshabilitada por defecto por seguridad. Para hacerlo tienes que seguir los pasos que el fabricante especifica en este enlace https://kb.vmware.com/s/article/2004746

Una vez habilitada la shell podras conectarte mediante SSH con el usuario root o cualquier otro con privilegios similares. Otra forma de acceder es desde la pantalla de la consola de la maquin ESXi (La pantalla amarilla y gris) presionando ALT+F1.

Utilizando ESXCLI

Cuando accedemos a la shell de ESXi uno de las herramientas que mas nos pueden ayudar es esxcli.
Esta herramienta viene preinstalada en los sistemas ESXi. Tiene una serie de namespaces dependiendo de para que queramos utilizarla. A continuación los namespaces disponibles en ESXi 6.5, si se quieren ver todos los namespaces disponibles solo hay que ejecutar esxcli sin parámetros:

• esxcli device: Nos devuelve las opciones de este comando para dispositivos.
• esxcli elxnet: Lista las opciones de este comando para el administrar los drivers Emulex elxnet.
• esxcli esxcli: Facilita el listado de opciones del comando esxcli.
• esxcli fcoe: Comandos para administrar FCOE (Fibre Channel Over Ethernet).
• esxcli graphics: Comandos para graficos
• esxcli hardware: Se usa principalmente para ver la información de hardware.
• esxcli iscsi: Comandos para administrar y monitorizar iSCSI.
• esxcli network: Comandos para administrar la red (incluyendo vSwitches y vmKernel).
• esxcli nvme: Administración de NVME.
• esxcli rdma: Comandos para monitorizar RDMA.
• esxcli sched: Administra los espacios de intercambio del sistema.
• esxcli software: Namespace de Software. Administra e instala software en el sistema.
• esxcli storage: Comandos para administrar el almacenamiento.
• esxcli system: Comandos para administrar y monitorizar el sistema.
• esxcli vm: Comandos para listar y administrar maquinas virtuales.
• esxcli vsan: Administración de vSAN.

Los 20 comandos de ESXCLI prometidos

Comandos para el sistema

esxcli system version get
Devuelve la version de ESXi

esxcli system hostname get
Devuelve el hostname y el FQDN del host.

esxcli system stats installtime get
Devuelve la fecha de instalación de ESXi.

esxcli system account list
Lista los usuarios locales.

esxcli system account add -d=»Mi User» -i=»user1″ -p=»MiPas$.word45″ -c=»MiPas$.word45″
Crea un usuario llamado user1 con contraseña MiPas$.word45

esxcli system maintenanceMode set –enable true
Habilita el modo mantenimiento en el host.

esxcli system shutdown reboot -d 10 -r «Razon del reinicio»
Reinicia el sistema en 10 segundos. El sistema debe haberse puesto primero en modo mantenimiento

Comandos para la red

esxcli network firewall get
Devuelve el estado del firewall. La accion por defecto el bloquear trafico que no esté permitido por una regla especifica.

esxcli network firewall set –enabled true | false
Este comando habilita o deshabilita el firewall.

esxcli network firewall ruleset list | awk ‘$2 ==»true»‘
Devuelve una lista de reglas habilitadas.

esxcli network ip interface ipv4 get
Nos da la configuración IPV4 de todas las interfaces de este nodo.

Comandos para software

esxcli software vib list
Lista VIBs instalados. Un VIB es un formato de paquete para distribuir software en ESXi.

esxcli software vib update -d «/tmp/paquete.zip»
Este comando actualiza un software ya instalado en el sistema.

esxcli software vib install /tmp/paquete.zip
Instala software nuevo en el sistema.

Comandos para maquinas virtuales

esxcli vm process list
Lista las maquinas virtuales que están corriendo en el sistema. El ID se puede usar para realizar tareas sobre una maquina virtual en concreto.

esxcli vm process kill -w ID_DE_LA_MAQUINA -t soft
Mata una maquina con el ID optenido en el comando anterior. Para forzar esta operación hay que modificar el parametro -t por hard y ejecutará un kill -9 a esa maquina.

Comandos para almacenamiento

esxcli storage vmfs extent list
Facilita un listado de cada volumen con su mapping.

esxcli storage filesystem list
Devuelve un listado de volumenes o datastores accesibles por el host. En el listado vendrá el nombre, el tipo de sistema de ficheros, el path y el UUID.

Comandos para iSCSI

esxcli iscsi software set –enabled true && esxcli iscsi software get
Son dos comandos concatenados, el primero habilita el adaptador iSCSI y el segundo verifica su estado.

esxcli iscsi adapter param get -A vmhba65
Este comando devuelve métricas de un adaptador especifico, en este caso vmhba65

La entrada 20 comandos de ESXCLI que te serán de utilidad se publicó primero en Aprende IT.

Lo primero, ¿Qué es systemd?

Como dice en su web oficial:
systemd es un conjunto de bloques de construcción básicos para un sistema Linux. Proporciona un administrador de sistemas y servicios que se ejecuta como PID 1 e inicia el resto del sistema.

Puedes ver como crear un servicio en systemd pinchando aquí

¿Está bien usar systemd en un contenedor docker?

Siempre que se utilice en un entorno local o de desarrollo no hay ningún problema, pero no es algo que yo recomiende para un servidor de producción siempre y cuando existan otras alternativas.

¿Por qué usar un contenedor docker que use systemd?

En ocasiones necesitamos hacer pruebas con una aplicación que utiliza systemd en vez de sysvinit, si queremos hacer las pruebas en un entorno basado en docker por defecto no podemos ya que requiere que que es sistema donde se ejecuta sea capaz de instalar servicios de systemd.

También nos puede venir bien de cara a simular un sistema mas completo pero sin consumir tantos recursos como una virtualización.

Creand el contenedor con systemd incluido

En un contenedor con una imagen de CentOS no es necesario crear el dockerfile para crear una imagen con systemd incluido ya que por defecto viene incluido en la imagen y solo debemos levantarlo con la sentencia docker run que enseñaremos mas tarde.

Para ubuntu crearemos el siguiente dockerfile para incluir soporte de systemd, crearemos un fichero llamado «ubuntu-systemd-dockerfile»:

FROM ubuntu:latest

#BASE INSTALL 


RUN export DEBIAN_FRONTEND=noninteractive;ln -fs /usr/share/zoneinfo/America/New_York /etc/localtime;apt-get update && apt-get install tzdata && apt-get install -y vim autotools-dev dosfstools libmailtools-perl kmod net-tools apt-utils bind9utils binutils bsdmainutils bsdutils coreutils debianutils diffutils dnsutils docutils-common docutils-doc findutils iputils-ping iputils-tracepath klibc-utils libkeyutils1:amd64 libpaper-utils sensible-utils sysvinit-utils xz-utils systemd systemd-sysv 

RUN ln -f /usr/bin/systemd /sbin/init 

## for apt to be noninteractive 
ENV DEBIAN_FRONTEND noninteractive 
ENV DEBCONF_NONINTERACTIVE_SEEN true 
STOPSIGNAL SIGRTMIN+3 
CMD [ "/sbin/init" ]

Para crear la imagen ubuntu:systemd tenemos que ejecutar la siguiente sentencia desde el mismo directorio donde tenemos el fichero Dockerfile con nombre ubuntu-systemd-dockerfile que hemos creado:

docker build -f Dockerfile -t "ubuntu:systemd" .

Lo haremos como se puede ver en:

root@ger:/tmp# mkdir ubuntu-systemd
root@ger:/tmp# cd ubuntu-systemd/
root@ger:/tmp/ubuntu-systemd# vi ubuntu-systemd-dockerfile 
root@ger:/tmp/ubuntu-systemd# docker build -f ubuntu-systemd-dockerfile -t "ubuntu:systemd" .
Sending build context to Docker daemon   2.56kB
Step 1/7 : FROM ubuntu:latest
 ---> 1e4467b07108
Step 2/7 : RUN export DEBIAN_FRONTEND=noninteractive;ln -fs /usr/share/zoneinfo/America/New_York /etc/localtime;apt-get update && apt-get install tzdata && apt-get install -y vim autotools-dev dosfstools libmailtools-perl kmod net-tools apt-utils bind9utils binutils bsdmainutils bsdutils coreutils debianutils diffutils dnsutils docutils-common docutils-doc findutils iputils-ping iputils-tracepath klibc-utils libkeyutils1:amd64 libpaper-utils sensible-utils sysvinit-utils xz-utils systemd systemd-sysv
 ---> Using cache
 ---> 27e6132e5c37
Step 3/7 : RUN ln -f /usr/bin/systemd /sbin/init
 ---> Using cache
 ---> 0e1242818129
Step 4/7 : ENV DEBIAN_FRONTEND noninteractive
 ---> Using cache
 ---> ad16907c6036
Step 5/7 : ENV DEBCONF_NONINTERACTIVE_SEEN true
 ---> Using cache
 ---> 6c27cc829879
Step 6/7 : STOPSIGNAL SIGRTMIN+3
 ---> Using cache
 ---> 2fc7405c18d1
Step 7/7 : CMD [ "/sbin/init" ]
 ---> Using cache
 ---> 5ba555ffd849
Successfully built 5ba555ffd849
Successfully tagged ubuntu:systemd
root@ger:/tmp/ubuntu-systemd# 

Una vez creada la imagen ubuntu:systemd podemos ejecutar la siguiente sentencia para crear el contenedor:

docker run -it -d --tmpfs=/run --tmpfs=/run/lock -v /sys/fs/cgroup:/sys/fs/cgroup:ro --name mitest --hostname mitest ubuntu:systemd /sbin/init

Este es un ejemplo de la ejecución anterior:

root@ger:/tmp/ubuntu-systemd# docker run -it -d --tmpfs=/run --tmpfs=/run/lock -v /sys/fs/cgroup:/sys/fs/cgroup:ro --name mitest --hostname mitest centos /sbin/init
243f2021ec3921aad4f34bc05eac034d91143f4ad2a3bc61fc47ad136370c3be
root@ger:/tmp/ubuntu-systemd# docker exec -it mitest su -
[root@mitest ~]# systemctl |more      
  UNIT                                   LOAD   ACTIVE SUB       DESCRIPTION
  -.mount                                loaded active mounted   /
  dev-mqueue.mount                       loaded active mounted   POSIX Message Queue File System
  etc-hostname.mount                     loaded active mounted   /etc/hostname
  etc-hosts.mount                        loaded active mounted   /etc/hosts
  etc-resolv.conf.mount                  loaded active mounted   /etc/resolv.conf
  proc-acpi.mount                        loaded active mounted   /proc/acpi
  proc-asound.mount                      loaded active mounted   /proc/asound
  proc-bus.mount                         loaded active mounted   /proc/bus
  proc-fs.mount                          loaded active mounted   /proc/fs
  proc-irq.mount                         loaded active mounted   /proc/irq
  proc-kcore.mount                       loaded active mounted   /proc/kcore
  proc-keys.mount                        loaded active mounted   /proc/keys
  proc-sched_debug.mount                 loaded active mounted   /proc/sched_debug
  proc-scsi.mount                        loaded active mounted   /proc/scsi
  proc-sysrq\x2dtrigger.mount            loaded active mounted   /proc/sysrq-trigger
  proc-timer_list.mount                  loaded active mounted   /proc/timer_list
  run-lock.mount                         loaded active mounted   /run/lock
  sys-firmware.mount                     loaded active mounted   /sys/firmware
● sys-fs-fuse-connections.mount          loaded failed failed    FUSE Control File System
  systemd-ask-password-console.path      loaded active waiting   Dispatch Password Requests to Console Directory Watch
  systemd-ask-password-wall.path         loaded active waiting   Forward Password Requests to Wall Directory Watch
  session-c1.scope                       loaded active running   Session c1 of user root
  dbus.service                           loaded active running   D-Bus System Message Bus
  systemd-hwdb-update.service            loaded active exited    Rebuild Hardware Database
  systemd-journal-catalog-update.service loaded active exited    Rebuild Journal Catalog
  systemd-journal-flush.service          loaded active exited    Flush Journal to Persistent Storage
  systemd-journald.service               loaded active running   Journal Service
  systemd-logind.service                 loaded active running   Login Service
  systemd-random-seed.service            loaded active exited    Load/Save Random Seed
  systemd-readahead-collect.service      loaded active exited    Collect Read-Ahead Data
  systemd-tmpfiles-setup.service         loaded active exited    Create Volatile Files and Directories
  systemd-update-done.service            loaded active exited    Update is Completed
  systemd-update-utmp.service            loaded active exited    Update UTMP about System Boot/Shutdown
  systemd-user-sessions.service          loaded active exited    Permit User Sessions
  -.slice                                loaded active active    Root Slice
  system-getty.slice                     loaded active active    system-getty.slice
  system.slice                           loaded active active    System Slice
  user-0.slice                           loaded active active    User Slice of root
[root@mitest ~]# 

Crear un contenedor basado en CentOS con soporte para systemd

Como decíamos antes, si necesitamos crear un contenedor basado en CentOS o en otra imagen que ya incluya soporte para systemd no es necesario hacer el proceso anterior, solo debemos ejecutar:

docker run -it -d --tmpfs=/run --tmpfs=/run/lock -v /sys/fs/cgroup:/sys/fs/cgroup:ro --name mitest --hostname mitest centos /sbin/init

Como se puede ver a continuación:

root@ger:/tmp/ubuntu-systemd# docker run -it -d --tmpfs=/run --tmpfs=/run/lock -v /sys/fs/cgroup:/sys/fs/cgroup:ro --name mitest2 --hostname mitest2 centos /sbin/init
00ebdd7192062fe15b54b9a6ae7ed5eae979b1560a3dd82127f8fe9dc30afa43
root@ger:/tmp/ubuntu-systemd# docker exec -it mitest2 su -
[root@mitest2 ~]# systemctl|more
  UNIT                                   LOAD   ACTIVE SUB       DESCRIPTION
  -.mount                                loaded active mounted   /
  dev-mqueue.mount                       loaded active mounted   POSIX Message Queue File System
  etc-hostname.mount                     loaded active mounted   /etc/hostname
  etc-hosts.mount                        loaded active mounted   /etc/hosts
  etc-resolv.conf.mount                  loaded active mounted   /etc/resolv.conf
  proc-acpi.mount                        loaded active mounted   /proc/acpi
  proc-asound.mount                      loaded active mounted   /proc/asound
  proc-bus.mount                         loaded active mounted   /proc/bus
  proc-fs.mount                          loaded active mounted   /proc/fs

Se pueden ver mas parámetros interesantes en la documentación oficial de docker pinchando aquí

Si estás interesado en aprender Docker puedes puedes adquirir nuestro libro aquí.

Docker para novatos

La entrada Cómo crear un contenedor que soporte systemd con docker se publicó primero en Aprende IT.

Voy a explicar cómo darle uso desde Linux sin reiniciar, utilizando QEMU + Virt Manager, con algunas optimizaciones para que vaya maś rápido y sin perder la licencia de Windows.

En mi caso, tengo Windows instalado en /dev/sda, adapta la ruta de estos ejemplos porque lo que vamos a hacer es arrancar un emulador (QEMU) directamente sobre esa partición. Mi tabla de particiones de ese disco sda (un disco SSD en realidad) es la siguiente:

Es sencillo arrancar una máquina virtual con QEMU utilizando “sda” como disco. Lo difícil es optimizar para que no se pierda mucho rendimiento respecto a un arranque normal.

Necesitaréis los paquetes de vuestra distribución de qemu-kvm, libvirtd, y virt-manager, aunque este último es casi mejor instalarlo bajando el git y ejecutando “python3 setup.py install” como root.

git clone https://github.com/virt-manager/virt-manager.git

Lo primero es dar permisos a Libvirt para que pueda acceder al disco. Hay una manera muy fácil de hacerlo que es arrancar el servicio Libvirt con un SUID. Esto se hace editando el fichero /etc/libvirt/qemu.conf y modificando la configuración con “user = +0”, como muestro en la siguiente captura. Luego tan solo hay que reiniciar libvirtd utilizando “systemctl restart libvirtd” o “systemctl restart libvirt-daemon”, dependiendo de vuestra distribución de Linux.

Ahora hay que ir a Windows, para obtener un dato necesario para no perder la licencia. De manera que reinicia, y, abriendo una consola de comandos como administrador, vamos a buscar el UUID real de esa instalación utilizando el comando:

wmic csproduct get uuid

En este punto puedes aprovechar e instalar los drivers que van a hacer falta luego. QEMU “simula” tarjetas de red, gráficas y tiene drivers pensados para optimizar la velocidad de acceso a disco que tienen un gran impacto luego en el rendimiento.

La ISO con los drivers se puede conseguir en:

https://fedorapeople.org/groups/virt/virtio-win/direct-downloads/archive-virtio/virtio-win-0.1.173-9/

La última versión siempre estará disponible en:

https://fedorapeople.org/groups/virt/virtio-win/direct-downloads/archive-virtio/

Dentro viene un instalador para poder instalar la mayor parte de los drivers de una vez.

Aunque lo mejor a veces es ir carpeta por carpeta (amd64 será la arquitectura de tu PC salvo extrañas excepciones) y, pulsando con el botón derecho del ratón, seleccionar “Install”.

Ahora, ya con el UUID para no perder la licencia y los drivers instalados, vamos de vuelta a Linux.

En mi PC tengo dos GPUS (Tarjetas gráficas). Una de marca NVidia que tengo colocada en un PCI y otra que viene integrada en placa base. Hay que decidir cual usamos en Linux y cual en nuestros Windows simulado. No es 100% obligatorio porque QEMU os mostrará la salida por pantalla como una ventana más dentro de Linux, usad esto si se quiere tener la salida por un monitor específico directamente de la tarjeta secundaria.

Los pasos para habilitar ambas tarjetas a la vez no son sencillos. Lo voy a explicar de manera breve porque depende completamente de tu distribución de Linux y de tu modelo de placa base y tarjetas gráficas. Lo primero de todo es ir a la BIOS y habilitar que ambas tarjetas puedan funcionar a la vez. Esta opción depende de la BIOS de tu placa base.

En Linux, recomiendo utilizar un módulo llamado VFIO. Hay muchos tutoriales que explican cómo hacerlo. Si tan solo queréis usar la tarjeta gráfica que viene emulada en QEMU, no hace falta seguir estos pasos, que consisten en configurar el ID PCI de la tarjeta gráfica secundaria en VFIO y luego evitar que Linux cargue el módulo para controlarla, dejándola libre para que QEMU la pueda usar.

Al final, como en mi caso, ambas tarjetas os tienen que aparecer disponibles en el comando PCI. En la siguiente captura podemos ver mi tarjeta NVidia y la Intel que viene con mi placa base.

En mi caso, el módulo que controla la tarjeta gráfica Intel en Linux es el “i915”. Para deshabilitar este módulo creo un fichero vfio.conf en /etc/modprobe.d.

options vfio-pci ids=8086:3e98
blacklist i915

Una vez ya has terminado con las tarjetas, puedes arrancar el gestor de máquinas virtuales “virt-manager”. Al pulsar sobre el botón de “Crear nueva máquina virtual”, aparecerá un asistente. La opción que buscamos es la última “Import Existing Disk Image”, o “Importar disco existente”.

Ahora, seleccionamos “/dev/sda” o el disco en donde tengamos la instalación de Windows. En la selección de sistema operativo seleccionamos Windows 10, porque esto habilita ciertas optimizaciones desde el inicio.

En el siguiente paso seleccionamos el número de cores y memoria. Mi PC tiene 32 GB de RAM y 8 cores, pero habilito 8 GB de RAM y 4 cores para la máquina virtual. Esto no significa que los vaya a tener siempre en uso. Los compartirá con tu sistema operativo Linux.

En el paso final, marcamos “Customize installation before install” o “Personalizar instalación antes de instalar”. No os asustéis, que no vamos a “instalar” nada, se refiere enteramente a crear la máquina virtual.

En el siguiente paso, previo a arrancar la máquina virtual, selecciono mi tarjeta secundaria Intel en la lista de “Add Hardware” (Añadir Hardware), en la sección de “PCI Host Device”, y buscando en la lista mi tarjeta Intel.

Los discos inicialmente estarán en modo SATA. No es para nada el más rápido, pero antes de que Windows pueda reconocer los discos en modo Virtio, que es el más rápido, hay que usar un truco.

Añade un segundo disco duro, esta vez en modo Virtio, en esta misma ventana, en la secció de Storage. Modifica también las opciones de arranque en “Boot Options” para que arranque del disco real donde está Windows.

Y ahora, ya le puedes dar al botón de Play para arrancar tu máquina virtual.

El primer arranque va a tardar un rato, porque tiene que configurar todas los dispositivos nuevos que se encuentra al arrancar con QEMU. No os preocupéis, que luego podréis arrancar en modo normal Windows como siempre, e igual de rápido.

Tras el primer arranque, si habéis usado el truco de colocar un disco secundario en modo Virtio, es posible modificar el disco raíz a VirtIO también, haciendo que vaya más rápido. Esto se hace en las propiedades del disco en Virt-Manager.

También habrá que modificar el “IO Mode” a “hypervisor default”.

En estos experimentos siempre dejo el modo de caché a “writeback”, porque hace que vayan mucho más rápidas las escrituras.

También es posible modificar el tipo de tarjeta de red a Virtio. Esto se nota cuando se transfieren grandes archivos, y es el modo recomendado para simular máquinas con Windows y QEMU.

Ahora, el último paso. Recordad que al principio nos guardamos un UUID usando el comando “wmic” en Windows para poder mantener la instalación de Windows como válida y que nos permita instalar actualizaciones, etc…

Hay que seguir los siguientes pasos, como usuario root. En mi caso mi servidor se llama “win10”. Primero exporto el fichero XML de configuración a un fichero de texto “win10.xml”. Dentro de ese fichero modifico donde pone “UUID” y cambio el que viene por el que me guardé de Windows. Luego redefino la máquina virtual Win10 en Libvirt usando el XML con el UUID modificado. Estos son los comandos a ejecutar. Si no sabéis cual es el nombre de vuestra máquina virtual, podéis ejecutar “virsh list –all”.

virsh dumpxml win10 > win10.xml

vi win10.xml (or use your favourite editor)

virsh undefine win10

virsh define win10.xml

Y ya está. Ya puedes arrancar tu Windows desde tu Linux sin tener que reiniciar.

Más optimizaciones
Las optimizaciones que explico ahora son para tipos de máquina QEMU llamadas “q35”. El tipo de máquina aparece en la información de tu VM en Libvirt o bien dentro del fichero XML. De hecho, lo mejor para modificar la configuración a veces es exportar la configuración XML a fichero de texto, modificarlo, luego cargarlo en Libvirt con “virsh define”.

hvm

Siempre es interesante tener un backup del fichero XML antes de tocar nada 😉

Dos opciones básicas, que yo añadiría son:

<vmport state=’off’/>

<ioapic driver=’kvm’/>

Existe un modo de acelerar el acceso a la memoria RAM utilizando “Transparent Huge Pages”, que es una funcionalidad del kernel de Linux. Para habilitarlo, configuramos a “always” el fichero:

echo always > /sys/kernel/mm/transparent_hugepage/mm/transparent_hugepage/enabled

En el fichero XML de configuración también puedes definir muchas funcionalidades del simulador. Cuidado con estas opciones porque pueden hacer que vuestro Windows no arranque correctamente. En mi caso, tengo estas. Pero hay posibilidades

Además tengo modificado el modelo de reloj de CPU que utiliza mi máquina virtual.

También hay una optimización para la CPU que funciona directamente y mejora entre un 5% y un 15% el rendimiento, que consiste en copiar el modelo de CPU directamente en la máquina virtual (normalmente QEMU utiliza un tipo de CPU simulada)

Una optimización sencilla que muchas veces se nos escapa. En la mayor parte de los PCs o portátiles las opciones de ahorrar energía suelen estar activadas. Seleccionar el perfil de mayor rendimiento tiene un impacto bastante serio en las máquinas virtuales.

cpupower frequency-set -r -g powersave

Y para terminar, os voy a ahorrar horas de búsqueda si no os funciona el puntero del ratón. Descargad los drivers de esta web y utilizad en vuestro Linux un servicio llamado “spice-vdagent”. Se utiliza para que el puntero del ratón no se quede bloqueado en vuestra máquina virtual y mejora la velocidad.

https://www.spice-space.org/download.html

La entrada Cómo aprovechar tu Windows abandonado en una partición con QEMU se publicó primero en Aprende IT.

Te agradecemos que compartas este artículo en tus redes sociales y/o dejes un comentario.

¡Empezamos!

1- ¿Qué es docker?

Hay gente que considera que docker es un sistema de virtualización como KVM, Vmware, etc. Esto es falso. Docker es un sistema de contenedores como LXC pero mas avanzado. Tiene mejor gestión de las instancias levantadas y tiene un sistemade gestión plantillas.

Es decir, docker es un sistema para abstraer la aplicación y hacer su ecosistema independiente del sistema operativo. Haciendo que todo lo configurado dentro de un contenedor se ejecute correctamente en cualquier sistema operativo con docker instalado.

2- ¿Qué ventajas tiene?

Las ventajas son varias dependiendo de con que lo comparemos.

Si lo comparamos con ejecutar aplicaciones en un sistema directamente, la principal ventaja es la compatibilidad, ya que lo que se ha probado en el contenedor, en el mismo contenedor de otro sistema funcionará igual.

Si nos referimos a ventaja respecto a utilizar una virtualización completa, principal ventaja es que cada contenedor utiliza prácticamente la memoria de la aplicación  mientras que una instancia de KVM, Vmware, etc requiere también  consumo de memoria para el kernel del sistema virtual, etc

Otra ventaja es que se pueden ejecutar aplicaciones como si tuviésemos otro sistema distinto. Es decir, en el sistema anfitrión tenemos un sistema CentOS por ejemplo y en el contenedor podemos tener, Free BSD o Debian, o Arch o cualquier otro. Por lo que si en un sistema funciona mejor que en el anfitrión podemos utilizar esta ventaja.

3- ¿Cómo puedo utilizarlo?

Bien se puede utilizar para crear entornos de desarrollo y luego subir el contenedor a producción (hay que tener en cuenta que antes de poner nada en producción con docker se debe securizar el anfitrión y el contenedor para evitar problemas). Así podemos evitar problemas en despliegues de códigos

Lo primero es instalar docker. En CentOS se hace de la siguiente forma: #yum install docker -y

En debian y derivados: #apt install docker.io

Después de instalarlo, si es un sistema moderno, basado en systemd, levantamos el servicio: #systemctl start docker

Si no tiene systemd, ejecutamos: #service docker start

4- Comandos útiles

Arrancar contenedores (aunque no se hayan descargado la imágenes):

docker run -i -t -d   IMAGEN:VERSION

Donde la imagen y la versión se pueden especificar así:

docker run -i -t -d   centos:latest

Podemos definir un nombre para el contenedor con –name NOMBRE

[root@localhost ~]# docker run -i -t -d --name testing debian:9
Unable to find image 'debian:9' locally
Trying to pull repository docker.io/library/debian ... 
9: Pulling from docker.io/library/debian
54f7e8ac135a: Pull complete 
Digest: sha256:df6ebd5e9c87d0d7381360209f3a05c62981b5c2a3ec94228da4082ba07c4f05
Status: Downloaded newer image for docker.io/debian:9
b6f568b78470b417b8a141f4b7c5686420df7cc1050402239ab1847310a67116
[root@localhost ~]# 

Se puede especificar un puerto que será redirigido desde la maquina anfitrión al contenedor:

docker run -i -t -d -p PUERTO_EXTERIOR:INTERIOR IMAGEN

O también se puede hacer especificando la ip del anfitrion:

docker run -i -t -d -p IP_ANFITRION:PUERTO_EXTERIOR:INTERIOR IMAGEN

Añadiendo «–restart always» a la ecuación, se consigue que siempre que se pare el contenedor, se reinicie. Incluso en el reinicio del anfitrión:

docker run -i -t -d -p PUERTO_EXTERIOR:INTERIOR --restart always IMAGEN

Para crear un contenedor y no levantarlo de forma inmediata:

docker create -i -t centos:6 /bin/bash

Descargar imagenes y gestionarlas

Para descargar una imagen y tenerla disponible a la hora de levantar un nuevo contenedor sin tener que esperar a que se descargue de docker-hub, solamente tenemos que hacer lo siguiente:

docker pull IMAGEN:VERSION

O también:

docker pull IMAGEN

Por ejemplo:

#Eligiendo version
docker pull centos:7
#o seleccionando la ultima disponible
docker pull centos:latest

También podemos ver las imágenes disponibles en local ejecutando:

docker images

Por ejemplo:

ger@portatil$ sudo docker images
[sudo] contraseña para ger: 
REPOSITORY                                  TAG                 IMAGE ID            CREATED             SIZE
debian                                      9                   4879790bd60d        9 days ago          101MB
ubuntu                                      18.04               ea4c82dcd15a        5 weeks ago         85.8MB
centos                                      6                   0cbf37812bff        6 weeks ago         194MB
centos                                      7                   75835a67d134        6 weeks ago         200MB
ubuntu                                      17.04               fe1cc5b91830        11 months ago       95.6MB

Podemos buscar las imágenes disponibles en docker hub:

ger@portatil$ sudo docker search ubuntu
NAME                                                   DESCRIPTION                                     STARS               OFFICIAL            AUTOMATED
ubuntu                                                 Ubuntu is a Debian-based Linux operating sys…   8793                [OK]                
dorowu/ubuntu-desktop-lxde-vnc                         Ubuntu with openssh-server and NoVNC            244                                     [OK]
rastasheep/ubuntu-sshd                                 Dockerized SSH service, built on top of offi…   184                                     [OK]
consol/ubuntu-xfce-vnc                                 Ubuntu container with "headless" VNC session…   136                                     [OK]
ansible/ubuntu14.04-ansible                            Ubuntu 14.04 LTS with ansible                   95                                      [OK]
ubuntu-upstart                                         Upstart is an event-based replacement for th…   92                  [OK]                
neurodebian                                            NeuroDebian provides neuroscience research s…   55                  [OK]                
1and1internet/ubuntu-16-nginx-php-phpmyadmin-mysql-5   ubuntu-16-nginx-php-phpmyadmin-mysql-5          47                                      [OK]
ubuntu-debootstrap                                     debootstrap --variant=minbase --components=m…   40                  [OK]                
nuagebec/ubuntu                                        Simple always updated Ubuntu docker images w…   23                                      [OK]
tutum/ubuntu                                           Simple Ubuntu docker images with SSH access     18                                      
i386/ubuntu                                            Ubuntu is a Debian-based Linux operating sys…   15                                      

Podemos importar una imagen personalizada: docker import /path/to/exampleimage.tgz:

[root@localhost ~]# docker import /tmp/debian-personalizado.tgz
[root@localhost ~]#

Ver el estado de los contenedores y sus datos

Para ver los contenedores creados y su estado actual solo tenemos que ejecutar:

docker ps -a

Por ejemplo:

[root@localhost ~]# docker ps -a
CONTAINER ID        IMAGE               COMMAND             CREATED              STATUS              PORTS               NAMES
b6f568b78470        debian:9            "bash"              About a minute ago   Up About a minute                       testing
[root@localhost ~]# 

Para levantar una maquina solo tenemos que ejecutar docker start ID-DEL-CONTENEDOR el ID lo podemos encontrar ejecutando docker ps -a :

[root@localhost ~]# docker start b6f568b78470
b6f568b78470
[root@localhost ~]#

Gestionar contenedores

Para parar un contenedor docker stop id-del-container:

[root@localhost ~]# docker stop b6f568b78470
b6f568b78470
[root@localhost ~]#

Y para eliminar un contenedor docker stop id-del-container:

[root@localhost ~]# docker rm b6f568b78470
b6f568b78470
[root@localhost ~]#

Podemos hacer una copia de un contenedor ejecutando: docker export -o filesystem.tar ID_DE_CONTAINER:

[root@localhost ~]# docker export -o filesystem.tar b6f568b78470
[root@localhost ~]#

Podemos acceder a una consola del contenedor: docker exec -it «id of running container» bash:

[root@localhost ~]# docker exec -it b6f568b78470 bash
[root@b6f568b78470 ~]#

Si estás interesado en aprender Docker puedes puedes adquirir nuestro libro aquí.

Docker para novatos

Y esto ha sido todo sobre como empezar con docker, en un siguiente post, trataremos sobre como manejar docker con python.

Recuerda que si te ha gustado este post te agradecemos que compartas en tus redes sociales y/o comentes la publicación.

¡Nos vemos!

La entrada Cómo empezar con docker se publicó primero en Aprende IT.