Docker

De WikiSalud
Revisión a fecha de 10:40 3 dic 2019; Vmoran (Discusión | contribuciones)

(dif) ← Revisión anterior | Revisión actual (dif) | Revisión siguiente → (dif)
Saltar a: navegación, buscar

Contenido

Docker

Proporciona una forma de ejecutar aplicaciones aisladas de forma segura en un contenedor (container), empaquetado con todas sus dependencias y bibliotecas. Debido a que se ven como aplicaciones (App), siempre se puede ejecutar con el entorno que espera en la imagen de construcción, la prueba y el despliegue es más simple que nunca, ya que su compilación será completamente portátil y lista para ejecutarse como se ha diseñado en cualquier entorno. Y debido a que los contenedores son ligeros y se ejecutan sin la carga adicional de un hipervisor, puede ejecutar muchas aplicaciones que dependen de diferentes bibliotecas y entornos en un solo kernel, cada uno nunca interfiere con el otro. Esto le permite sacar más provecho de su Hardware cambiando la "unidad de escala" de su aplicación de una máquina virtual o física a una instancia de contenedor.


Docker diagram.png

Características

Ligero

Los contenedores que se ejecutan en una sola máquina comparten el mismo kernel del sistema operativo; Comienzan inmediatamente y utilizan menos RAM. Las imágenes se construyen a partir de sistemas de archivos en capas y comparten archivos comunes, haciendo que el uso del disco y las descargas de imágenes sean mucho más eficientes.


Abierto

Los contenedores Docker se basan en estándares abiertos, permitiendo que los contenedores se ejecuten en todas las distribuciones principales de Linux, Microsoft Windows, Mac, además de cualquier infraestructura AWS, AZURE.

Seguro por defecto

Los contenedores aíslan las aplicaciones entre sí y la infraestructura subyacente, a la vez que proporcionan una capa adicional de protección para la aplicación.

Instalación de Docker en Debian Jessie

Abrir una terminal y luego como usuario root ejecutamos:

1) Para obtener la versión de nuestro kernel:

uname -r

2) luego añadiremos a nuestro archivo sources.list la referencia al repositorio de docker así:

echo "deb https://apt.dockerproject.org/repo debian-jessie main" >> /etc/apt/sources.list

apt-get install apt-transport-https ca-certificates

3) Luego debemos agregar las llaves respectivas, para ello ejecutamos:

apt-key adv --keyserver hkp://p80.pool.sks-keyservers.net:80 --recv-keys 58118E89F3A912897C070ADBF76221572C52609D

4) Ahora instalaremos docker:

apt-get update

apt-get install docker-engine

5) Finalmente iniciamos el servicio de docker:

service docker start

Actualizar Docker

Abrir una terminal y como usuario root ejecutar:

apt-get upgrade docker-engine

Desintalar Docker

Abrir una terminal y como usuario root ejecutar:

apt-get purge docker-engine

Además eliminaremos las dependencias instaladas por docker

apt-get autoremove

Los comandos anteriores no eliminarán imágenes, contenedores, volúmenes o archivos de configuración creados por el usuario en el host. Si desea eliminar todas las imágenes, contenedores y volúmenes, ejecuta el siguiente comando:

rm -rf /var/lib/docker

Docker Hub

Docker Hub es un servicio de registro basado en la nube que te permite enlazar a repositorios de código, construir tus imágenes y probarlas, almacena manualmente imágenes y enlaces a Docker Cloud para que puedas desplegar imágenes en tus hosts. Proporciona un recurso centralizado para el descubrimiento de imágenes de contenedores, la distribución y la gestión del cambio, la colaboración de usuarios y equipos y la automatización del flujo de trabajo a lo largo del desarrollo.

a través del sitio https://hub.docker.com/explore/, puedes buscar y descargar las imágenes docker de los repositorios oficiales de programas como debian, wordpress, joomla, mysql, postgres, etc. así como también conocer como se estructura o se crear un archivo Dockerfile.


Dockerfile es un documento de texto que contiene todos los comandos que un usuario puede llamar en la línea de comandos para montar una imagen. El usuario puede utilizar este mecanismo para crear una compilación automatizada que ejecuta varias instrucciones de línea de comandos sucesivamente en una imagen creada para desplegar su aplicación.

Comandos Básicos

docker (lista de comandos de docker)

docker -v (saber la versión de docker instalada)

docker images (listar las imágenes de docker disponibles)

docker ps -a (lista los contenedores ejecutados o en ejecución)

docker ps -a -s ver el espacio consumido por los contenedores


docker run --help (obtener ayuda sobre como ejecutar los contenedores incluyendo parámetros)

docker start <container-id> (inicia el contenedor indicado según su ID)

docker stop <container-id> (detiene la ejecución del contenedor indicado según su ID)

docker restart <container-id> (reiniciar la ejecución del contenedor indicado según su ID)


docker rmi IMAGEN-ID Eliminar Imagen según su ID


docker rmi -f $(docker images | grep "^<none>" | awk '{print $3}') (elimina todas las imagenes con tag <none>)


docker rm <container-id> (elimina el contenedor indicado según el ID. Nota: debes detener el contenedor o verificar que no se este ejecutando)


Eliminar todos los contenedores CUIDADO

docker stop $(docker ps -a -q)

docker rm $(docker ps -a -q)



docker search <término> (permite buscar imágenes según la palabra indicada)

docker pull <imagen> (permite descargar y obtener la imagen con el nombre indicado desde dockerhub)

docker run -ti imagen /bin/bash (ejecuta el contenedor indicado en modo interactivo), pero el problema es que el mismo al terminar de ejecutar la tarea, finaliza ejemplo: docker run -ti mysql /bin/bash

docker inspect <container-id> (permite obtener datos sobre el contenedor indicado, incluyendo la ip) por ejemplo obteniendo la ip de un contenedor mysql podemos ingresar despúes así: mysql -h 172.17.0.2 -u root -p


Ejemplos Descargar imágenes:


abrir una terminal y como usuario root ejecutamos:

service docker start (iniciar el servicio de docker)

docker pull wordpress (descargar imagen de wordpress)

docker pull mysql (descargar imagen de mysql)

docker pull debian (descargar imagen de debian)

docker pull mysql:latest

docker images (listar las imágenes descargadas)

Ejecutar Docker como usuario normal

adduser <miusuario> docker

Trabajando con contenedores

docker images

docker pull debian

docker run -it debian /bin/bash

exit


docker pull mysql

docker ps -a

ahora crearemos nuestro primer contenedor a partir de la imagen mysql descargada así:


docker run --name mysql_ejemplo -e MYSQL_ROOT_PASSWORD=12345 -d mysql


docker ps -a

ahora ingresaremos al contenedor así

docker exec -it mysql_ejemplo mysql -uroot -p

indicar la clave: 12345

sin embargo el problema es que la detener el contenedor o borrarlo los datos se perderían, para ello es necesario definir con la directiva -v', que se refiere al volumen, la ruta local donde se guardar los datos.


Además si recibes un mensaje Can't connect to local MySQL server through socket '/var/run/mysqld/mysqld.sock, entonces debes conectarte de la siguiente manera:

docker exec -it mysql_ejemplo bash

mysql -u root -p

luego indica la clave, para nuestro ejemplo es 12345


Mejoras al ejecutar nuestro contenedor:

Tal y como hemos mencionado para que nuestros datos no se pierdan al eliminar o detener el contenedor, indicaremos el directorio donde se almacenarán nuestros datos. Para el ejemplo se almacenaran en /home/vladimir/datos2


docker run --name mysql_ejemplo -e MYSQL_ROOT_PASSWORD=12345 -v /home/vladimir/datos2/:/var/lib/mysql/ -d mysql

Trabajando con Postgres

1) Descargamos la imagen de postgres para el caso la versión 9.6

docker pull postgres:9.6

2) listar las imagenes filtrando con grep solo la correspondientes a postgres

docker images | grep postgres

3) crear el contenedor

indicaremos el puerto de exposición, un nombre personalizado, así como el volumen donde se almacenaran en mi disco duro y no en el contenedor.

mkdir dockerVolumenes/postgres96


docker run -p 5433:5432 --name postgres96 -v /home/vladimir/dockerVolumenes/postgres96:/var/lib/postgresql/data -e POSTGRES_PASSWORD=secret -d postgres:9.6


4) Ejecutar el comando psql desde el contenedor: docker exec -it postgres96 psql -U postgres

create database pruebas;

\c pruebas;

create table area (id serial not null,nombre character varying(200) not null);

insert into area (id,nombre) values (1,'DTIC');

select * from area;

\q

ls /home/vladimir/dockerVolumenes/postgres96


5) Detener el contenedor

docker ps

docker stop postgres96

docker ps -a

6) iniciar nuevamente el contenedor

docker start postgres96

docker exec -it postgres96 psql -U postgres


7) Borrar contenedor

docker rm postgres96


Trabajando con pgAdmin4

Para ello descargaremos la imagen de pgadmin4 ejecutando desde la terminal y como usuario normal el siguiente comando:

docker pull dpage/pgadmin4


Luego procederemos a ejecutar nuestro contenedor a partir de la imagen dpage/pgadmin4, asignando un nombre y las credenciales de acceso, así como el puerto 5050 para poder accederlo desde nuestro navegador

docker run -p 5050:80 --name=pgadmin4 -e "PGADMIN_DEFAULT_EMAIL=vmoran@salud.gob.sv" -e "PGADMIN_DEFAULT_PASSWORD=12345" -d dpage/pgadmin4


desde el navegador accedemos así:

http://localhost:5050


Si desemos detener el contenedor, desde la terminal ingresamos el siguiente comando:

docker stop pgadmin4


Si querremos volver a iniciar contenedor, desde la terminal ejecutamos el comando siguiente:

docker start pgadmin4

Luego desde el navegador accedemos a la siguiente dirección URL:

http://localhost:5050


Finalmente solo bastaría crear la conexión a la base de datos Postgres y realizar las consultas SQL o demás acciones de administración de base de datos que consideremos necesarias.

Creando una imagen personalizada a partir de un archivo 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.

También podemos decir que un Dockerfile es como una receta para crear nuestras imágenes, que servirán de forma posterior para correr nuestros contenedores


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


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)


crearemos dentro de un directorio un archivo Dockerfile Vacío así:

mkdir instalador

cd instalador

nano Dockerfile

luego debemos crear todas nuestras instrucciones de instalación




guardaremos nuestro archivo Dockerfile

Construir la imagen a partir de nuestro Dockerfile

una vez finalizada la incorporación de todas las instrucciones de nuestro archivo Dockerfile ejecutamos el comando siguiente utilizand por convención la sintaxis que se indica: 'docker build -t="username_docker/name_image:tag" .

ejemplo: docker build -t vmoran/debian:latest .

docker compose

"Docker Compose" es una herramienta para definir y correr aplicaciones Docker multi-contenedor. Docker Compose está pensado, sobre todo para el entorno de desarrollo y para cuando tenemos aplicaciones que empiezan a ser complejas porque raramente una aplicación la podemos correr con único ejecutable sino que tiene una serie de componentes de los que dependemos alrededor. Docker Compose se basa en un fichero YML en el que se definen todos los contenedores y las relaciones que tienen entre ellos. Podemos definir una serie de servicios diferentes cada uno con un contenedor diferente de los que podemos enlazar con contenedores locales que compilamos en el tiempo de ejecución o contenedores remotos que descargamos si fuera necesario en el momento que arrancáramos Compose. Podemos definir todas las opciones de Docker como los puertos que exponemos los volúmenes de donde cogemos los ficheros, etc. y todas las variables de entorno o cualquier configuración que pudiéramos necesitar. No está pensada para producción, pero nos permite con más facilidad que ir lanzando contenedores uno a uno a mano desde el terminal, poder lanzar una serie de aplicaciones complejas; en este caso, simplemente con el fichero de definición lanzamos el "docker-compose up" para levantar la producción se empieza a descargar toda las imágenes que no tengamos ejecuta la instalación de dependencias, que es un paso de nuestra imagen y ejecuta, tanto la imagen de redis como la del servidor web, para poder servir las peticiones. Vemos que con un solo comando hemos levantado todo el servicio, tanto la parte de redis como la parte de web, y que en el puerto 5000, si vamos al navegador ya estamos corriendo esta aplicación sencilla. En el momento que necesitamos otra dependencia podemos parar el servicio y editar el código con dependencias nuevas. La siguiente vez que levantamos el servicio se hará cargo de traerse todas las dependencias nuevas que tengamos dispuestas en nuestro Docker Compose. De nuevo, con un solo comando nos ha enlazado todas las imágenes y disponemos de todo el servicio en marcha redis, base de datos y servidor web. Lo dicho, no es un sistema para funcionar en producción quizá no se puede trabajar con las aplicaciones más complejas de todas pero es perfecto para trabajar con aplicaciones multi-contenedor en desarrollo y para poder hacer testing, unidades de test, etc.

Abrir la terminal y como usuario root ejecutaremos:

curl -L https://github.com/docker/compose/releases/download/1.18.0/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose

Luego asignaremos permisos de ejecución así:

chmod +x /usr/local/bin/docker-compose

Para verificar y conocer la versión de docker-compose, ejecutaremos el siguiente comando:

docker-compose --version

Definiendo el entorno de desarrollo con Docker Compose

Primero de todo vamos a crear una carpeta para nuestro proyecto, en el directorio que prefieras de tu máquina local. En el vamos a incluir un fichero Dockerfile, un fichero docker-compose.yml y una carpeta para el código fuente de nuestra aplicación que puede ser de nombre app/.

ejecutaremos: mkdir wordpresstest

cd wordpresstest

nano docker-compose.yml

version: '2' services:

 db:
   image: mysql:5.7
   volumes:
     - "./.data/db:/var/lib/mysql"
   restart: always
   environment:
     MYSQL_ROOT_PASSWORD: wordpress
     MYSQL_DATABASE: wordpress
     MYSQL_USER: wordpress
     MYSQL_PASSWORD: wordpress
 wordpress:
   depends_on:
     - db
   image: wordpress:latest
   links:
     - db
   ports:
     - "8000:80"
   restart: always
   environment:
     WORDPRESS_DB_HOST: db:3306
     WORDPRESS_DB_PASSWORD: wordpress

guardar el archivo y luego ejecutar:

docker-compose up -d

ahora desde nuestro navegador ejecutamos:

http://localhost:8000

y podremos ingresar al instalador de wordpress


Si necesitamos detener los contenedores de docker compose lo hacemos así:

cd wordpresstest/

docker-compose down

Creando Imágenes a partir de contenedores

lo primero es descargar una imagen y luego crear un contenedor a partir de esa imagen

docker pull debian

docker run -it --name neto -d debian:latest


Ahora ingresaremos al contenedor llamado neto así:

docker exec -it neto /bin/bash

apt update

luego dentro del contenedor instalaremos los paquetes o cambiaremos archivos de configuración

salimos del contenedor escribiendo exit

Ahora grabaremos nuestros cambios hechos en el contenedor y crearemos una imagen personalizada así:

docker ps -a

sintaxis:

docker commit <container tar or id> <new imagen name>


Ejemplo:

docker commit neto netov1

docker commit 085ac612d7c5 netov1

docker commit vladimir dtic/php5.6-apache2-buster
docker commit vladimir dtic:php5.6-apache2.4-buster

en ambos casos estamos guardando el contenedor, ya sea por su id de ejecución o tag asignado (neto) y guardaremos nuestros cambios a una imagen llamada netov1

Finalmente si deseamos crear un contenedor a partir de nuestra nueva imagen llamada netov1 ejecutaremos:

docker run -it --name netocontenedor -d netov1:latest

docker ps -a

si quieres ingresar al contenedor

docker exec -it netocontenedor /bin/bash

para salir del contenedor

exit ó salir del contenedor sin detenerlo Ctrl+P y Q presionadas (detach), para ingresar otra vez al contenedor (attach) ejecutaremos: docker attach netocontenedor

Si prefieres simplificar los pasos solo ejecuta:

docker run -it --name vladimir netov1:latest /bin/bash

apt update

Referencias

https://docs.docker.com

https://hub.docker.com/explore/

https://hub.docker.com/r/dpage/pgadmin4/

https://docs.docker.com/compose/install/#install-compose

https://openwebinars.net/blog/instalacion-de-wordpress-con-docker-compose/


Modeladores




Esta página fue modificada por última vez el  03 de agosto de 2019, a las 05:35

Herramientas personales
Espacios de nombres

Variantes
Acciones
Navegación
Herramientas