Presentación del T3: Cloud Computing. Contenedores. Docker. Cloud Computing del Máster en Informática (UGR)

1. Cloudcomputing
Máster Profesionalizante Ingeniería
Informática 2015-2016
María Isabel García Arenas
8 de diciembre de 2015

2. Contenedores: Objetivos
1)Conocer las diferentes tecnologías y herramientas de virtualización tanto
para procesamiento, comunicación y almacenamiento.
2)Instalar, configurar, evaluar y optimizar las prestaciones de un servidor
virtual.
3)Configurar los diferentes dispositivos físicos para acceso a los servidores
virtuales: acceso de usuarios, redes de comunicaciones o entrada/salida.
4)Diseñar, implementar y construir un centro de procesamiento de datos virtual.
5)Documentar y mantener una plataforma virtual.
6)Optimizar aplicaciones sobre plataformas virtuales.
7)Conocer diferentes tecnologías relacionadas con la virtualización
(Computación Nube, Utility Computing, Software as a Service) e
implementaciones tales como Google AppSpot, OpenShift o Heroku.
8)Realizar tareas de administración en infraestructura virtual.

3. Contenedores: Objetivos específicos
1)Entender cómo las diferentes tecnologías de virtualización se integran en la
creación de contenedores.
2) Crear infraestructuras virtuales completas.
3) Comprender los pasos necesarios para la configuración automática de las
mismas.

4. Contenedores: Aislamiento de procesos
●
Desde los 80 se aislan procesos en Unix
●
El ejemplo más antiguo es Chroot http://es.wikipedia.org/wiki/Chroot (5
minutos)
●
Ejercicio: Explicar con vuestras propias palabras qué hace Chroot
●
Ejemplo: Establecer un entorno aislado para el comando ls (siguiente
transparencia)
●
Comprobación, intentar ir a vuestro directorio $HOME, una vez creada la
jaula
●
El proceso que hace chroot simplemente protege partes del sistema de
archivos, aunque esta protección es fácil saltarsela, pero el proceso de
aislamiento está hecho, es lo que se dice una virtualización ligera.

5. prompt% JAULA = $HOME/jaula
echo $JAULA
mkdir ­p $JAULA
mkdir ­p $JAULA/{bin,lib64,lib} ' creamos estos tres directorios
cp ­v /bin/{bash,ls} $JAULA/bin ' copiamos el bash y el comando ls a nuestra jaula
ls ­l $JAULA/bin/ ' deben aparecer bash y ls
ldd /bin/bash ' consultamos las dependencias de librerías de bash y según su salida, copiamos las librerías
correspondientes dentro de la jaula, en mi caso la salida es
linux­vdso.so.1 => (0x00007ffef11ad000)
libtinfo.so.5 => /lib/x86_64­linux­gnu/libtinfo.so.5 (0x00007f2aa5a70000)
libdl.so.2 => /lib/x86_64­linux­gnu/libdl.so.2 (0x00007f2aa586b000)
libc.so.6 => /lib/x86_64­linux­gnu/libc.so.6 (0x00007f2aa54a6000)
/lib64/ld­linux­x86­64.so.2 (0x00007f2aa5cba000)
cp ­v /lib64/ld­linux­x86­64.so.2 $JAULA/lib64/
cp ­v /lib/x86_64­linux­gnu/libtinfo.so.5 $JAULA/lib
cp ­v /lib/x86_64­linux­gnu/libdl.so.2 $JAULA/lib
cp ­v /lib/x86_64­linux­gnu/libc.so.6 $JAULA/lib
ldd /bin/ls ' consultamos las dependencias de ls y la salida es
linux­vdso.so.1 => (0x00007ffc52d25000)
libselinux.so.1 => /lib/x86_64­linux­gnu/libselinux.so.1 (0x00007ff1952b4000)
libacl.so.1 => /lib/x86_64­linux­gnu/libacl.so.1 (0x00007ff1950ab000)
libc.so.6 => /lib/x86_64­linux­gnu/libc.so.6 (0x00007ff194ce6000)
libpcre.so.3 => /lib/x86_64­linux­gnu/libpcre.so.3 (0x00007ff194aa8000)
libdl.so.2 => /lib/x86_64­linux­gnu/libdl.so.2 (0x00007ff1948a3000)
/lib64/ld­linux­x86­64.so.2 (0x00007ff1954f8000)
libattr.so.1 => /lib/x86_64­linux­gnu/libattr.so.1 (0x001007ff19469e000)
cp ­v /lib/x86_64­linux­gnu/libselinux.so.1 $JAULA/lib
cp ­v /lib/x86_64­linux­gnu/libacl.so.1 $JAULA/lib
cp ­v /lib/x86_64­linux­gnu/libc.so.6 $JAULA/lib
cp ­v /lib/x86_64­linux­gnu/libpcre.so.3 $JAULA/lib
cp ­v /lib/x86_64­linux­gnu/libdl.so.2 $JAULA/lib
cp ­v /lib64/ld­linux­x86­64.so.2 $JAULA/lib
cp ­v /lib/x86_64­linux­gnu/libattr.so.1 $JAULA/lib
sudo chroot $JAULA /bin/bash

6. Contenedores: Para qué una virtualización ligera
●
Para crear entornos de prueba
●
Para aislar las consecuencias que se pueden producir al utilizar algún
programa arriesgado
●
Para determinar perfectamente las dependencias de algún programa y
comprobar qué librerías necesita (ldd)
●
Por ejemplo, podríais montar dentro de una jaula un servidor web y
comprobar contra qué tipo de ataques está protegido metiéndolo en una jaula
chroot (está relacionado con uno de los ejercicios propuestos)
●
Problemas de las jaulas chroot: Dejan al descubierto el conjunto de usuarios,
los grupos, los procesos en ejecución, el subsistema de red donde esté el
servidor alojado, etc.

7. Contenedores: Jaulas BSD
●
Son jaulas más robustas que las creadas con chroot
●
Fueron creadas en FreeBSD a partir de la versión 4.X por Poul-Henning Kamp
●
En Linux no están disponibles hasta los 90.
●
https://en.wikipedia.org/wiki/FreeBSD_jail (5 minutos)
●
Una Jaula BSD crea un entorno que no se distingue de una máquina real
puesto que es una virtualización a nivel del sistema operativo.
●
El sistema operativo permite crear varias instancias de espacios de usuario
que desde el punto de vista de los usuarios son exactamente iguales que una
máquina real.
●
Esos espacios de usuario se pueden llamar: Jaulas, Contenedores, Servidores
virtuales privados (virtual private servers) o Motores de virtualización
(virtualization engines).

8. Contenedores: Jaulas BSD
●
Para entender el concepto es como un chroot, pero con algunos añadidos:
●
Control de los recursos del sistema
●
Limitación del impacto de las acciones realizadas dentro de la jaula
●
Elementos de una jaula
1)Subárbol de directorios: punto de entrada a la jaula
2)Un nombre de máquina, hostname
3)Una dirección IP que no debe cambiarse durante el tiempo de vida de la
jaula
4)Un comando con una ruta relativa al punto de entrada de la jaula para poder
ser ejecutado
●
Pueden tener sus propios usuarios y su propio root. El root de una jaula será
root, pero sólo dentro de ella, y no fuera.

9. Contenedores: Jaulas BSD
●
Las herramientas que equivalen a una jaula BSD en linux son:
●
-vServers:
●
OpenVZ
●
XLC
●
Las tres herramientas dan soporte y gesionan las jaulas con sus
particularidades, pero todas se ajustan a lo que hemos entendido como una
Jaula BSD o un contenedor.
●
Las jaulas BSD sólo tienen dos restricciones:
●
Comparten el kernel del sistema operativo con la máquina que aloja la jaula
●
Comparte la misma CPU

10. Contenedores: vServers
●
https://en.wikipedia.org/wiki/Linux-VServer
●
Fue creado por Jacques Gélinas y lo mantiene Herbert Pötzl
●
Es una herramienta Open Source que permite controlar el acceso de una jaula
a la memoria, el tiempo de CPU, al direccionamiento de la red además del
control de acceso al sistema de ficheros.
●
Podéis tener una visión completa en http://linux-vserver.org/Overview
Ejemplo (http://crysol.org/es/node/378) : con un kernel de sistema que lo
soporte como linux-image-2.6.17-2-vserver-686 ( en una máquina virtual)
●
sudo apt­get install util­vserver
●
sudo apt­get install vserver­debiantools
●
cat /etc/vservers/newvserver­vars ' la salida debe ser: # Configuration file for newvserver
# See man newvserver for the variables that you can set here.
DIST="lucid"
MIRROR="http://es.archive.ubuntu.com/ubuntu/"
●
newvserver ­­hostname JaulaVServer ­­domain midominio.local ­­ip 10.10.10.15

11. Contenedores: openVZ
●
https://es.wikipedia.org/wiki/OpenVZ (5 minutos)
●
Es software Libre con licencia GPL
●
Las características son (https://openvz.org/Main_Page):
●
Se ejecuta de forma independiente cada jaula
●
Se pueden reiniciar las jaulas
●
Tiene soporte para root en cada jaula
●
Gestión de usuarios propios de la jaula
●
Gesión de Ips, procesos, ficheos aplicaciones, librerías y ficheros de
configuración
●
Su versión comercial es Virtuozzo
●
Ejemplo en
http://www.unixmen.com/install-and-configure-openvz-in-ubuntu/ para
Ubuntu 14.04

12. Contenedores: LXC
●
https://es.wikipedia.org/wiki/LXC
●
Proporciona otra herramienta para crear jaulas BSD.
●
Utiliza la utilidad que proporciona cgroups, control groups, (
https://en.wikipedia.org/wiki/Cgroups) que permite limitar el uso de algunas
cuentas aislando el uso de CPU, de la memoria, de operaciones de disco, de
red, etc. Fue creado por Paul Menage y Rohit Seth y ahora lo mantiene el
equipo de freedesktop.org y de kernel.org.
●
La mayoría de sus partes tienen licencia LGPLv2.1 menos una parte que por
compatibilidad con Android tiene licencia BSD o GPLv2
●
El objetivo de LXC es crear un entorno lo más parecido a una máquina virtual
pero manteniendo el mismo kernel que la máquina donde se aloja la jaula

13. Contenedores: LXC
●
Se ha extendido más que los anteriores porque utiliza herramientas sencillas
como bloques que son:
●
La librería liblxc
●
APIs como punto de unión a lenguajes como python3, lua, Go, ruby,
python2 y Haskell
●
Herramientas de control de las jaulas
●
Soporte para creación de plantillas de contenedores
●
Actualmente existe una versión evolucionada, todavía no muy extendida que
es LXD que está aún en desarrollo
●
El ejercicio 1 está en
https://fortinux.com/ubuntu/tutorial-instalar-lxc-en-gnulinux/

14. Contenedores: LXC

15. Contenedores: Utilidades LXC
●
La creación de contenedores con LXC es bastante sencilla
●
Además provee de varias herramientas útiles, por ejemplo:
●
Listar los contenedores ejecutándose: sudo lxc-ls
●
Parar contenedores lxc-stop
●
Lxc-clone
●
Lxc-info -n <nombre del contenedor> (muestra información diferente si el
contenedor está en funcionamiento o no
●
… podéis ver en la consola los diferentes comandos que empiezan por lxc...
●
En general tenéis un repaso de todos los comandos en
http://websetnet.com/es/how-to-manage-linux-containers-using-lxc/

16. Contenedores: Utilidades LXC
●
Otras características
●
Al arrancar el contenedor se levanta un interfaz de red que dará servicio al
contenedor (interfaz lxcbr0 y veth??????) (comprobarlo con ifconfig)
●
El contenedor tiene conexión de red (hacer ping a alguna parte)
●
Ejercicio: iniciar dos contenedores del mismo tipo en dos ventanas
diferentes y utilizar lxc-stop -n nombre_contenedor. ¿Os da eso alguna idea
de cómo deben ser los nombres de los contenedores?
●
Lxc-webpanel: http://lxc-webpanel.github.io/

17. Contenedores: Utilidades LXC
●
Lxc-webpanel: http://lxc-webpanel.github.io/
●
Ejecutar: sudo wget https://lxc-webpanel.github.io/tools/install.sh -O - | sudo
bash

18. Contenedores: Aplicaciones
●
Las aplicaciones dentro de un contenedor tienen una peculiaridad y es que
pueden utilizarse para configurar el hardware que supuestamente tiene
asignado el contenedor mediante software (Software configuration
management -
https://en.wikipedia.org/wiki/Software_configuration_management)
●
Cuando se instala una aplicación en un contenedor, hay que tener claro que
todas las dependencias de esta están cubiertas
●
Herramientas CMS:
●
Salt
●
Ansible
●
Chef
●
Juju
●
Puppet

19. Contenedores: Juju
●
https://jujucharms.com/
●
JuJu permite desplegar, configurar y mantener, en general, servicios cloud
●
Tiene interfaz texto y gráfica
●
Necesita: Máquina con Ubuntu o con Window, un par de claves ssh (ssh-
keygen -t rsa -b 2048), un entorno donde se pueda ofertar un servicio cloud
cuando se necesite
●
Podéis ver cual es su filosofía y como funciona utilizando la demo
https://demo.jujucharms.com/inspector/19862227$/machine/

20. Contenedores: Juju
●
Echar un ojo a los comandos con juju –help commands o juju –help local-
provider
●
Ejemplo
sudo add-apt-repository ppa:juju/stable
sudo apt-get update && sudo apt-get install juju-core juju-local
juju init (editar el fichero que genera y poner “default: local”)
juju switch local
sudo apt-get install mongodb-server MongoDB (resuelto en juju-local)
juju bootstrap (que crea el contenedor (juju-agent-mgarenas-local))
Juju deploy <servicio> (y después juju expose)
Echarle un ojo al directorio que ha creado en ~/.juju/local
●
El ejercicio de juju sería:

21. Contenedores: Juju
●
Para verlo todo de forma gráfica, el propio juju ofrece un servicio que podemos
desplegar y utilizar, es juju-gui
●
Instalar el paquete juju-quickstart
●
Desplegar el servicio juju-gui
●
Exponer el servicio juju-gui
●
Mirar en qué IP está disponible con juju-status y acceder a él.
●
Seguir las instrucciones para obtener el password del usuario admin
●
Curiosear a ver qué se puede hacer y cómo

22. Contenedores: Hipervisores
●
Un supervisor es un gestor de contenedores. Presentan los sistemas operativos
virtualizados y evitan que el sistema virtual pueda acceder al hardwre.
●
Existen tres tipos de hipervisores:
●
Hipervisores bare-metal (también llamados nativos o unhosted). Se
caracteriza porque se ejecuta directamente sobre el hardware de la máquina.
Ejemplo: VMWare. Pueden ser monolíticos (administran el hardware de la
máquina y emulan el hardware de las MV) o de microkernel (reparten el
sistema físico entre las máquinas virutales)
●
Hipervisores tipo 2 o hosted. En este tipo el software del hipervisor se
ejecuta directamente sobre el sistema operativo de la máquina física y lo que
gestiona, los contenedores, van por encima, osea que se crea una estructura
de tres niveles. La máquina virtual de java, lleva este sistema
●
Hipervisores híbridos: tanto el S.O. como el hipervisor tienen acceso al
hardware de la máquina, por ejemplo VirtualBox utiliza este enfoque

23. Contenedores: Hipervisores
http://www.datakeeper.es/?p=716

24. Contenedores: Hipervisores
●
El modo de operación de los monolíticos es:
●
El hardware que el hipervisor simula, tiene que capturar las peticiones de las
máquinas virtuales existentes hacia el harware que ellas ven.
●
Se redirige la llamada interceptada hacia el driver del hipervisor lo que
provoca muchos cambios de contexto.
●
El driver del hipervisor redirige la llamada al driver físico
●
El modo de operación de los hipervisores los drivers están en las própias
máquinas virtuales y en realidad son, en muchos casos, enlaces al driver físico.
●

25. Contenedores: Hipervisores
●
Estos hipervisores pueden ser gestionados y programados mediante una API.
●
La utilidad que trae Linux para ello es la librería libvirt
●
●
●
●
Hay que reiniciar la sesión de usuario para que tome efecto
●
Las máquinas virtuales existentes, no siempre las ve, pero las creadas con lxc
parece que no tiene problemas, siempre que estés en el directorio donde está
instalada
https://help.ubuntu.com/14.04/serverguide/libvirt.html

26. Contenedores: Hipervisores
●
En este punto, el hipervisor tiene conciencia de que la máquina virtual
container-test es para gestionarla él.
●
Podéis ver más información de cómo utilizar virsh en
http://libvirt.org/drvlxc.html

27. Contenedores: Docker
●
El papá de los gestores de contenedores es Docker
●
Soporta grandes volúmenes de datos para gestionar, por lo que tiene bastante
expansión en los últimos tiempos.
●
Docker permite no sólo gestionar contenedores, sino también orquestarlos.
●
Es Open Source
●
Sus principales características:
●
Es portable
●
Es ligero (Comparado con VirtualBox es aproximadamente un 90% más
ligero)
●
No necesita ninguna otra herramienta adicional, ya que sólo incluye las
librerías y archivos propios de la máquina virtual que gestiona, por lo que no
se duplica al completo el sistema operativo.
●
Algunos defienden que es Lxc v.2.0

28. Contenedores: Docker
●
Incluso algunos gigantes del Cloud tienen previsto soportarlo como Google (
http://googlecloudplatform.blogspot.com.es/2013/12/google-compute-engine-
is-now-generally-available.html
)
●
Instalación:
●
http://docker-ee.blogspot.com.es/2014/08/instalar-docker-en-ubuntu-1404.
html
●
Comprobación de que funciona todo OK (como root)
●
Ahora ya sólo nos falta jugar con él

29. Contenedores: Docker
●
Bajarse una imagen de ubuntu: docker pull ubuntu
●
Existen ya numerosas imágenes subidas en https://hub.docker.com/
●
Ejecutar una orden dentro de una imagen ya instalada: docker run ubuntu ls
●
Ver las imágenes creadas: docker images o docker images –no-trunc
●
●
Abrir una consola en un determinado contenedor:

30. Contenedores: Docker
●
Comandos de docker (docker --help)
●
Hacer un ifconfig dentro y fuera del contenedor y ver qué ha pasado.
●
Podemos instalar dentro de una de las imágenes un servidor web, por ejemplo
nginx (apt-get install nginx)-> docker run -i -t ubuntu /bin/bash
●
Y un cliente ssh para comunicarnos con el contenedor
●
Para ver el estado y las características de cada contedor, usar docker inspect
ID_LARGO (transparencia anterior)
●
Abrir una cuenta en https://hub.docker.com/ y crear un repositorio para
poder subir las imágenes que queráis y podáis recuperarlas cuando queráis.
En mi caso se llama ubuntucc
●
Usando mi usuario del hub que es mgarenas y mi repositorio que es ubuntu cc
le pongo un tag a mi imagen local con: docker tag d55e68e6cc9c
mgarenas/ubuntucc:latest (https://docs.docker.com/mac/step_six/)

31. Contenedores: Docker
●
Una vez asignado el tag, ya podemos ver el contenedor con docker images
●
●
●
●
Hacemos login en remoto al repositorio
●
●
●
Para hacer una imag:en
●
Inicializamos un terminal dentro del contenedor donde vayamos a crear la
imagen con docker run -i -t ubuntu /bin/bash
●
Instalamos lo que necesitemos dentro y sin salir.
●
En otro terminal hacemos un commit, y luego un push al dockerHub

32. Contenedores: Docker
●

33. Contenedores: Docker