Tutorial
Docker Explicado: Cómo crear Contenedores de Docker corriendo en Memcached
Introducción
Para la mayoría de las aplicaciones web, es extremadamente raro encontrar que el CPU sea el culpable de las peticiones abandonadas de HTTP o la sobrecarga de peticiones en el servidor web. Usualmente suele ser debido a una instalación de baja ingeniería sin capa de almacenamiento en caché, consumiendo todos los recursos de la memoria de datos en backend (es decir, la base de datos de su preferencia).
Memcached - Que en estos momentos no debería necesitar ninguna introducción - puede aumentar el rendimiento de implementación de la pila de aplicaciones en gran medida sin hacer modificaciones a los recursos disponibles (lo que le permite exprimir hasta la última gota de su jugo).
En este artículo de DigitalOcean, sobre todo teniendo en cuenta los que albergan múltiples aplicaciones web (por ejemplo, múltiples instancias de WordPress, Aplicaciones Python, etc.), vamos a crear imágenes de Docker corriendo (sobre demanda) contenedores en Memcached que pueden ser operados individualmente. Estos contenedores, guardados y asegurados dentro de sus propios entornos, trabajarán con la aplicación para ayudarlas a funcionar mejor y más rápido.
Glosario
1. Docker en breve
2. Memcached en breve
3. Instalación de Docker en Ubuntu
4. Comandos básicos de Docker
- Ejecutar el demonio de Docker y el uso de la línea de comandos
- Comandos de Docker
5. Introducción a creación de imágenes de Memcached
- Recapitulación rápida: ¿Qué son los Dockerfile?
- Información general sobre comandos Dockerfile
- Creación de un archivo Dockerfile
- El Dockerfile final
- Creación de la imagen Docker para contenedores en Memcached
6. Correr Contenedores dockerised Memcached
- Creación de un contenedor instalado en Memcached
- Limitando la memoria para un contenedor en Memcached
- Prueba del contenedor en Memcached
Docker en Breve
El proyecto Docker ofrece herramientas de más alto nivel, trabajando en conjunto, que se construyen en la parte superior de algunas de las características del kernel de Linux. El objetivo es ayudar a los desarrolladores y administradores de sistemas a presentar aplicaciones - con todas sus dependencias conjuntamente - y conseguir que se ejecute a través de sistemas y máquinas - sin dolores de cabeza.
Docker logra esto mediante la creación segura de LXC (es decir, contenedores de Linux) basados en entornos para aplicaciones llamadas contenedores de Docker. Estos contenedores se crean usando imágenes de Docker, que se pueden construir, ya sea mediante la ejecución de comandos manualmente o automáticamente a través Dockerfile.
Nota: Para obtener más información sobre Docker y sus partes (por ejemplo, el demonio de Docker, línea de comandos, imágenes, etc.), echa un vistazo a nuestro artículo de introducción al proyecto: Explicando Docker Primeros pasos.
Memcached en Breve
Memcached es un motor de almacenamiento de datos distribuido de código libre. Fue diseñado para almacenar ciertos tipos de datos en la RAM (en lugar de los discos tradicionales a ritmo más lento) para recuperaciones muy rápidas de aplicaciones, disminuyendo la cantidad de tiempo que se necesita para procesar las solicitudes mediante la reducción del número de consultas realizadas contra conjuntos de datos más pesados o APIs tales como bases de datos tradicionales (por ejemplo, MySQL).
Mediante la introducción de un mecanismo de almacenamiento en caché inteligente, bien planificado y optimizado, es posible manejar una mayor cantidad aparentemente de solicitudes y realizar más procedimientos por las aplicaciones. Este es el caso de uso más importante de Memcached, como lo es con cualquier otra aplicación o componente de almacenamiento en caché.
Fuertemente invocado y utilizado en la producción de sitios web y otras aplicaciones, Memcached se ha convertido en una de las herramientas para aumentar el rendimiento - necesariamente - sin tener la necesidad de utilizar más hardware (por ejemplo, más servidores o recursos del servidor).
Su trabajo consiste en el almacenamiento de claves y con sus respectivos valores (hasta 1 MB de tamaño) en una matriz asociativa (es decir tabla hash), que se pueden ampliar y distribuir a través de un gran número de servidores virtuales.
Instalación de Docker en Ubuntu (más reciente)
Para empezar a utilizar Docker en tu VPS, puedes utilizar la imagen de DigitalOcean de Docker, para Ubuntu 13.04, o instalarlo tu mismo. En esta sección, vamos a ir rápidamente sobre las instrucciones básicas de instalación para Docker 0.7.1.
Instrucciones de instalación para Ubuntu
Actualizar tu droplet:
sudo aptitude update
sudo aptitude -y upgrade
Asegúrate que el soporte de aufs está disponible:
sudo aptitude install linux-image-extra-`uname -r`
Añadir la clave del repositorio Docker a la lista de APT para la verificación del paquete
sudo sh -c "wget -qO- https://get.docker.io/gpg | apt-key add -"
Añadir el repositorio de Docker a las fuentes de aptitude:
sudo sh -c "echo deb http://get.docker.io/ubuntu docker main\
> /etc/apt/sources.list.d/docker.list"
Actualizar el repositorio con la nueva adición:
sudo aptitude update
Por último, descarga e instala Docker:
sudo aptitude install lxc-docker
El cortafuegos por defecto de Ubuntu (UFW : Firewall sin complicaciones) niega todo el tráfico de reenvío por defecto, que es necesario por Docker.
Habilitar el reenvío con UFW:
Editar configuración de UFW usando el editor de textos nano.
sudo nano /etc/default/ufw
Desplázate hacia abajo y busca la línea que comienza con DEFAULTFORWARDPOLICY.
Reemplazar:
DEFAULT_FORWARD_POLICY="DROP"
Con:
DEFAULT_FORWARD_POLICY="ACCEPT"
Presiona CTRL+X y aprueba los cambios con Y para guardar y cerrar.
Por último, vuelve a cargar UFW:
sudo ufw reload
Comandos básicos de Docker
Antes de comenzar a trabajar con Docker, vamos a repasar rápidamente sus comandos disponibles para refrescar nuestra memoria desde nuestro primer artículo Primeros pasos..
Ejecutar el demonio de Docker y el uso de la línea de comandos
Tras la instalación, el demonio Docker debe estar ejecutándose en segundo plano, listo para aceptar comandos enviados por el cliente de la línea de comandos de Docker. Para ciertas situaciones en las que podría ser necesario ejecutar manualmente Docker, utiliza lo siguiente.
Ejecutar el demonio Docker:
sudo docker -d &
Uso del cliente de la línea de comandos de Docker:
sudo docker [opción] [comando] [argumentos]
Nota: Docker necesita privilegios de administrador para poder trabajar.
Comandos de Docker
He aquí un resumen actual (versión 0.7.1) de los comandos de Docker:
attach
Adjunta a un contenedor corriendo
build
Construye un contenedor de un archivo Docker
commit
Crea una nueva imagen de los cambios del contenedor
cp
Copia archivos/carpetas de los contenedores del sistema de archivos a la ruta de host
diff
Inspecciona los cambios en el sistema de archivos de un contenedor
events
Obtiene eventos en tiempo real desde el servidor
export
Transmite el contenido de un contenedor como un archivo tar
history
Muestra el historial de una imagen
images
Lista las imágenes
import
Crea una nueva imagen del sistema de archivos de los contenidos a partir de un archivo tar
info
Muestra el sistema de información de la pantalla
insert
Inserta un archivo en una imagen
inspect
Regresa información de bajo nivel en un contenedor
kill
Mata a un contenedor en ejecución (corriendo)
load
Carga una imagen desde un archivo tar
login
Registra la sesión para el servidor de registro de Docker
logs
Obtiene los registros de un contenedor
port
Busca el puerto público el cual está NAT-eado y lo hace privado (PRIVATE_PORT)
ps
Lista los Contenedores
pull
Descarga una imagen o un repositorio del servidor de registros Docker
push
Empuja una imagen o un repositorio del servidor de registro Docker
restart
Reinicia un contenedor en ejecución (corriendo)
rm
Elimina uno o más contenedores
rmi
Elimina una o más imágenes
run
Ejecuta un comando en un contenedor
save
Guarda una imagen en un archivo tar
search
Busca una imagen en el índice de Docker
start
Inicia un contenedor detenido
stop
Detiene un contenedor en ejecución (corriendo)
tag
Etiqueta una imagen en un repositorio
top
Busca los procesos en ejecución de un contenedor
versión
Muestra la información de versión de Docker
Introducción a creación de imágenes de Memcached
Sobre la base de nuestro conocimiento adquirido en los artículos anteriores de la serie Docker, vamos a profundizar directamente en la construcción de un archivo Dockerfile para tener un Docker construido automáticamente con Memcached instalando imágenes (que se utiliza para ejecutar instancias de Memcached en espacio aislado).
Recapitulación rápida: ¿Qué son los Dockerfile?
Dockerfiles son scripts que contienen comandos declarados sucesivamente que serán ejecutados, en el orden dado, por Docker para crear automáticamente una nueva imagen Docker. Estos ayudan en gran medida durante los despliegues.
Estos archivos siempre comienzan con la definición de una imagen base utilizando el comando FROM. A partir de ahí, el proceso de construcción se inicia y cada siguiente acción tomada forma finalizando con commits (guardando el estado de imagen) en el host.
Uso:
# Construir una imagen mediante el archivo Dockerfile en la ubicación actual
# Marcar la imagen final con [nombre] (por ejemplo, *nginx*)
# Ejemplo: sudo docker build -t [nombre] .
sudo docker build -t memcached_img .
Nota: Para obtener más información sobre archivos Dockerfiles, echa un vistazo a nuestro artículo: Explicando Docker: El Uso de archivos Dockerfiles para automatizar la creación de imágenes.
Información general sobre comandos Dockerfile
Add
Copia un archivo desde el host en el contenedor
CMD
Configura comandos por defecto para ser ejecutado, o se pasa al punto de entrada ENTRYPOINT
ENTRYPOINT
Ajusta el punto de entrada por defecto de la aplicación desde el contenedor
ENV
Inicializa variables de entorno (por ejemplo, “clave=valor”)
EXPOSE
Expone un puerto al exterior
FROM
Configura la imagen base para usar
MAINTAINER
Establece los datos de autor/propietario del archivo Dockerfile
RUN
Ejecuta un comando y cambia (commit) el resultado de la la imagen final (contenedor)
USER
Establece el usuario para ejecutar los contenedores de la imagen
VOLUMEN
Monta un directorio desde el host al contenedor
WORKDIR
Establece el directorio para las directivas de CMD que se ejecutarán
Creación de un archivo Dockerfile
Dado que los archivos Dockerfile son documentos de texto sin formato, puedes crear uno desde tu editor de texto favorito y escribir los comandos que deseas que Docker ejecute con el fin de construir una imagen. Después de empezar a trabajar en el archivo, continúa con la adición de todo el contenido a continuación (uno tras otro) antes de guardar el resultado final.
Nota: Puedes ver como luce un archivo final de Docker al finalizar esta sección.
Vamos a crear un archivo Dockerfile vacío utilizando el editor de texto nano:
nano Dockerfile
Necesitamos tener todas las instrucciones (comandos) y directivas enumeradas sucesivamente. Sin embargo, todo comienza con la construcción de una imagen base (configurado con el comando FROM).
Vamos a definir el propósito de nuestro archivo Dockerfile y declarar la imagen base para usar:
#############################################################
# Archivo Dockerfile para ejecutar contenedores en Memcached
# Basado en una imagen de Ubuntu
#############################################################
# Establece la imagen de base a utilizar para Ubuntu
FROM ubuntu
# Establece el autor (maintainer) del archivo (tu nombre - el autor del archivo)
MAINTAINER nombre del autor
Después de este bloque inicial de comandos y declaraciones, podemos empezar listando las instrucciones para la instalación de Memcached.
# Actualización de la lista de fuentes del repositorio de aplicaciones por defecto
RUN apt-get update
# Instalar Memcached
RUN apt-get install -y memcached
Debes establecer el puerto por defecto para ser expuesto al exterior del contenedor:
# Puerto para exponer (por defecto: 11211)
EXPOSE 11211
Establecer el comando de ejecución por defecto y el punto de entrada (es decir demonio Memcached):
# Comando Memcached por defecto con algunos argumentos
CMD ["-u", "root", "-m", "128"]
# Establece el usuario para ejecutar el demonio Memcached
USER daemon
# Establece el punto de entrada para los binarios de Memcached
ENTRYPOINT memcached
El Dockerfile final
#############################################################
# Archivo Dockerfile para ejecutar contenedores en Memcached
# Basado en una imagen de Ubuntu
#############################################################
# Establece la imagen de base a utilizar para Ubuntu
FROM ubuntu
# Establece el autor (maintainer) del archivo (tu nombre - el autor del archivo)
MAINTAINER nombre del autor
# Actualización de la lista de fuentes del repositorio de aplicaciones por defecto
RUN apt-get update
# Instalar Memcached
RUN apt-get install -y memcached
# Puerto para exponer (por defecto: 11211)
EXPOSE 11211
# Comando Memcached por defecto con algunos argumentos
CMD ["-u", "root", "-m", "128"]
# Establece el usuario para ejecutar el demonio Memcached
USER daemon
# Establece el punto de entrada para los binarios de Memcached
ENTRYPOINT memcached
Después de tener todo por escrito dentro del archivo Dockerfile, lo guardas y salimos pulsando CTRL+X seguido por Y.
¡Usando este Dockerfile, estamos listos para empezar a trabajar con contenedores Memcached dockerizados!
Creación de la imagen Docker para contenedores en Memcached
Ahora podemos crear nuestra primera imagen Memcached siguiendo las instrucciones de uso explicadas en la sección de archivos Dockfile básicos.
Ejecuta el siguiente comando para crear una imagen, etiquetandolo como “memcached_img”:
sudo docker build -t memcached_img .
Nota: No olvides el punto . para que Docker pueda encontrar el archivo Dockerfile.
Correr Contenedores dockerised Memcached
Es muy simple crear cualquier número de instancias memcached perfectamente aislados y autónomos - ahora - gracias a la imagen que hemos obtenido en la sección anterior. Todo lo que tenemos que hacer es crear un nuevo contenedor con docker run.
Creación de un contenedor instalado en Memcached
Para crear un nuevo contenedor, utiliza el siguiente comando, modificándolo para que se adapte a tus necesidades siguiendo este ejemplo:
# Ejemplo: sudo docker run -name [nombre del contenedor] -p [puerto de acceso: puerto expuesto] -i -t [nombre de imagen memcached]
sudo docker run -name memcached_ins -d -p 45001:11211 memcached_img
Ahora tendremos un Docker llamado “memcached_ins”, accesible desde el puerto 45001, córrelo ()run) utilizando nuestra imagen etiquetada como “memcached img”, que hemos construido con anterioridad.
Limitando la memoria para un contenedor en Memcached
Con el fin de limitar la cantidad de memoria de procesos del contenedor Docker que se puede usar, basta con ejecutar -m [cantidad de memoria] marcando así el límite.
Para ejecutar un contenedor con memoria limitada a 256 MB:
# Ejemplo: sudo docker run -name [nombre] -m [Memory (int)][memory unit (b, k, m or g)] -d (para correr no adjuntar) -p (para configurar el acceso y exponer los puertos) [ID de la imagen]
sudo docker run -name memcached_ins -m 256m -d -p 45001:11211 memcached_img
Para confirmar el límite de memoria, puedes inspeccionar el contenedor:
# Ejemplo: docker inspect [ID del contenedor] | grep Memory
sudo docker inspect memcached_ins | grep Memory
Nota: El comando anterior toma la información de la memoria relacionada desde la salida de inspección. Para ver toda la información relevante acerca de tu contenedor, puedes optar por sudo docker inspect [ID del contenedor].
Prueba del contenedor en Memcached
Hay varias maneras de probar tu contenedor(es) recién creado(s) corriendo en Memcached. Vamos a utilizar una sencilla aplicación cliente en Phyton para esto. Sin embargo, puedes llevarlo a producción con la aplicación utilizando complementos de caché, frameworks o librerías.
Asegúrate de que tu host tiene las librerías necesarias para Python/Memcached:
sudo apt-get update && sudo apt-get -y upgrade
sudo apt-get install -y python-pip
pip install python-memcached
Vamos a crear un sencillo script de Python llamado “cache.py” usando nano:
nano cache.py
Copiando y pegando el siguiente contenido (explicado por sí mismo) en el interior:
# Importar python-memcache y sys por argumentos
import memcache
import sys
# Establece la dirección de acceso para la instancia de Memcached
addr = 'localhost'
# Toma los numeros de argumentos
# Formato esperado: python cache.py [puerto memcached] [clave] [valor]
len_argv = len(sys.argv)
# Al menos el número puerto y una clave debe ser proporcionados
if len_argv < 3:
sys.exit("No hay suficientes argumentos")
# El puerto y la clave son suministrados - ¡Vamos a conectarnos!
port = sys.argv[1]
cache = memcache.Client(["{0}:{1}".format(addr, port)])
# Obtener la Clave
key = str(sys.argv[2])
# Si también se proporciona un valor, ajustar para clave-valor
if len_argv == 4:
value = str(sys.argv[3])
cache.set(key, value)
print "¡Valor para {0} establecido!".format(key)
# Si no se proporciona un valor, devuelve el valor de la clave:
value = cache.get(key)
print "¡Valor para {0} es {1}!".format(key, value)
Presiona CTRL+X y aprueba los cambios con Y para guardar y cerrar.
Para probar una instancia de Docker en memcached mediante el script anterior ejecutamos en el host:
# Ejemplo: python cache.py [puerto] [clave] [valor]
python cache.py 45001 mi_clave_prueba valor_prueba
# Regresa: Valor para mi_clave_prueba configurado
# Consulta si la clave esta establecida:
python cache.py 45001 mi_clave_prueba
# Regresa: Valor para mi_clave_prueba es valor_prueba
Para el conjunto completo de instrucciones para instalar y utilizar Docker, revisa la documentación de Docker en docker.io.
