Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Curso de Docker

Curso de Docker

Guido Vilariño

Guido Vilariño

El sistema de capas

18/32
Recursos

Aportes 45

Preguntas 10

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

Docker commit tiene un funcionamiento muy parecido al commit de git.

Guarda el estado de la capa mutable en un tag de la imagen a partir de la cual se genero el contenedor creando una capa mas para crear uno o mas contenedores a partir de esta nueva imagen.

Instalacion de Dive

Comandos:

$ docker history ubuntu:platzi (veo la info de como se construyó cada capa)
$ dive ubuntu:platzi (veo la info de la imagen con el programa dive)

La importancia de entender el sistema de capas consiste en la optimización de la construcción del contenedor para reducir espacio ya que cada comando en el dockerfile crea una capa extra de código en la imagen.

Agregando Capas

Con docker commit se crea una nueva imagen con una capa adicional que modifica la capa base.

Ejemplo: crear una nueva imagen a partir de la imagen de Ubuntu.

docker pull ubuntu

docker images

docker run -it cf0f3ca922e0 bin/bash

(modificar el contenedor: Ej apt-get install nmap)

docker commit deddd39fa163 ubuntu-nmap

18. El sistema de capas
Las imágenes son un conjunto de capas, y a partir del Dockerfile se puede saber como está construido una imagen. Existen distintas maneras de ver las capas que conforman una imagen:

  1. Si la imagen es pública se puede visitar Dockerhub y buscar una imagen para ver su Dockerfile. Una vez encontrar la imagen buscamos en los tag y haciendo clic en los tag se mostrará el docker file para construir dicha imagen.

  2. Se puede hacer a través de la línea, esta opción no es muy cómoda. Es importante destaca que los cambios se presenta por filas y las filas más inferiores son los cambios más viejos y las que están más arriba son los cambios más recientes. el comando es:

$ sudo docker history <nombre imagen: nombre tag>
Ejemplo:
$ sudo docker history ubuntu:platzi

  1. Otra opción es una herramienta de terminal creada por un usuario llamada dive https://github.com/wagoodman/dive, al ejecutar esta herramienta se puede visualizar que del lado izquierdo las capas que tiene la imagen y del lado derecho se visualiza el detalle de cambios que genera cada capa. el comando es el siguiente:

$ sudo dive <nombre de imagen:nombre tag>
Ejemplo:
$ sudo dive ubuntu:platzi

Los cambios que se muestran en la terminal son de la siguiente forma, los más antiguos abajo y los más recientes arriba

En la construcción de una imagen Es importante tomar en cuenta lo siguiente:

En la construcción de una imagen, se puede optar por instalar paquetes o crear archivos en una capa y luego desinstalar los paquetes o eliminar los archivos en otra capa. Esto es poco óptimo porque las capas son inmutables y en este caso estaríamos desperdiciando espacios. El motivo de que las capas son inmutables es para que al momento de crear una imagen docker no agrega capas ya creadas.

Una estrategia para evitar desperdiciar espacio es que en la misma capa se cree o instalen los paquetes y luego de terminar la operación que esto realizan se desinstale o eliminen.

Otra estrategia de optimizar es que una vez creado el creada la imagen todas las operaciones se hagan desde un contenedor.

Para usar la herramienta hay que descargar el .exe, ponerlo en algun lado de preferencia cerca de c:/dive/dive.exe algo así y ejecutar

c:\dive\dive.exe ubuntu 

y cambia ubuntu por cualquier nombre de imagen y listo, también puedes agregarlo a variable de entorno y usar el powershell pero esto es más rápido

Instalar dive en Ubuntu

wget https://github.com/wagoodman/dive/releases/download/v0.9.2/dive_0.9.2_linux_amd64.deb

sudo apt install ./dive_0.9.2_linux_amd64.deb

Comandos de la clase

Wow, Docker está increíble, no sé cómo no lo aprendí antes, si hace cosas muy chulas jaja, el sistema de capas me parece algo genial, y veo que ya podemos ir instalando dependencias desde la creación de una capa, es decir, puedo crear mi propia imagen que ya tenga todo lo que mi servidor necesita partiendo desde Ubuntu, y simplemente en una nueva capa instalar todo 🤔

Para Windows se debe ejecutar de la siguiente manera la herramienta dive.exe:
dive.exe ubuntu:platzi

Esto super bueno, al crear las imagenes y ayuda mucho para depurar o mejorar el peso de las imagenes creadas

https://github.com/wagoodman/dive

En cualquier sistema operativo, no tienen que instalar Dive directamente, puede usarlo desde Docker con el comando:

docker run --rm -it -v /var/run/docker.sock:/var/run/docker.sock wagoodman/dive:latest ubuntu:platzi

En Windows pueden guardar la instrucción:

docker run --rm -it -v /var/run/docker.sock:/var/run/docker.sock wagoodman/dive:latest %1

Como un dive.bat y pueden registrar el directorio en PATH en las variables de entorno, para que puedan ejecutarlo así:

dive.bat ubuntu:platzi

¿Y como se instala dive?

Comandos basicos de Dive

View image history:

dive <image>:<label>

Exit to Dive interface: ctrl + c keys

Dive tiene dos secciones principales:

  • Layers (left section)
  • Current layer content (right section)

Puedes moverte entre esas secciones con: tab key

En Layers section: usa ↓ and ↑ para moverte entre capas

En Current layer content: usa ctrl + u para ocultar/mostrar los archivos sin modificar (unmodified)

Clase 18:
Historial de las capas de docker
docker history luiscordero29/ubuntu:platzi

Las imágenes de docker se me hacen muy parecidas a los PKBUILD de AUR en Arch Linux

docker commmit

Descripción: Crea una nueva imagen a partir de los cambios de un contenedor.

uso:
docker commit [OPTIONS] CONTAINER [REPOSITORY[:TAG]]

Documentación: https://docs.docker.com/engine/reference/commandline/commit/

Para agregar dive a las variables de entorno en windows, debemos descargar dive, poner dive en alguna parte de nuestro pc:
C:/Users/usuario/Dive/dive.exe

Luego vamos a nuestras variables de entorno (lo podemos buscar en la barra de windows por entorno), luego la agregamos a nuestro path.

¿para que instalar dive si podemos correrlo en un contenedor docker?

docker run --rm -it -v /var/run/docker.sock:/var/run/docker.sock wagoodman/dive:latest $IMAGE

Las capas son una estrategia eficiente para la administración de espacio en el equipo.

En realidad nunca se borra, solo cambia el estado por cada capa en la imagen.

docker dive

Si estas en Mac, puedes instalar Dice con Brew.

brew install dive

Si no tienes Brew, puedes instalarlo con este comando:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Fuente: https://brew.sh/index_es

Ya entendi porque las capas son inmutables, de esa forma docker se asegura de que cada vez que una capa es llamada el funcionamiento esta garantizado ademas permiter que sea mas eficiente la gestion del disco

Buena explicación de como funciona la arquitectura de docker 😃

docker dive

Cada uno de los comandos del Dockerfile genera una capa extra de codigo en nuestra imagen

Funcionamiento de capas

Creo que hay que hacer mejor control de calidad: El video tiene varias partes donde se nota que recortaron audio, no es el hecho de que está mal recortado, sino que pierde continuidad.

  1. Ver como esta hecho una imagen
docker history ubuntu:platzi 

No esta hecho para ver como esta hecho una imagen en si, sino para ver sus capas

  1. Para ver desde una mejor forma y detallada: https://github.com/wagoodman/dive

Es genial ver como los desarrolladores constantemente están actualizando sus repositorios de Docker y mejorando cada día, esto demuestra la importancia o la influencia que está teniendo Docker en nuestro día a día.

docker commit
Crear una nueva imagen a partir de los cambios de un contenedor.

docker commit [opciones] Contenedor [repositorio[:tag]]

Descripción ampliada

Puede ser útil confirmar los cambios o la configuración del archivo de un contenedor en una nueva imagen. Esto le permite depurar un contenedor ejecutando un shell interactivo o exportar un conjunto de datos de trabajo a otro servidor. Generalmente, es mejor usar Dockerfiles para administrar sus imágenes de una manera documentada y mantenible. Obtenga más información sobre nombres y etiquetas de imágenes válidos.

La operación de confirmación no incluirá ningún dato contenido en los volúmenes montados dentro del contenedor.

De forma predeterminada, el contenedor que se está confirmando y sus procesos se pausarán mientras se confirma la imagen. Esto reduce la probabilidad de encontrar corrupción de datos durante el proceso de creación de la confirmación. Si no desea este comportamiento, establezca la opción --pause en falso.

gracias por el dive muy util. en cuanto al docker commit es para persistir el cambio reliazado y lo guardamos de la siguiente manera. docker commit upbeat_panini testredis:example. aca dejo el link: https://www.cloudbees.com/blog/using-docker-commit-to-create-and-change-an-image

Commit

Excelente explicacion y ademas dominio de docker del profesor. A tomar en cuenta el tema de las capas para entender lo que sucede con cada linea de dockerfile.

Docker Commit, básicamente es igual que el commit de Git, simplemente realiza la confirmación de cambios de tu capa en un tag de la imagen que estas construyendo

Las imágenes son igual que las cebollas porque tienen capas

[https://www.youtube.com/watch?v=0ZCxoWEWBZk](Los ogros son igual que las cebollas porque tienene capas)

Las capas son inmutables, es decir no se pueden modificar. Si borramos un archivo que luego eliminamos en una capa posterior, en realidad se crean dos capas y no se elimina ninguna.

Yo he utilizado el docker cuando tengo una imagen base y empiezo a trabajar sobre ella con configuraciones especificas o personalizadas de software, ya una vez que estoy satisfecho con el software instalado en el contenedor corriendo salgo y ejecuto

docker commit <container-id> centos_ansible:v8

y listo ya genera la imagen

para instalar dive en Mac
https://formulae.brew.sh/formula/dive

cambios y aprovechamiento de imágenes

Installar dive ubuntu

wget https://github.com/wagoodman/dive/releases/download/v0.9.2/dive_0.9.2_linux_amd64.deb
sudo apt install ./dive_0.9.2_linux_amd64.deb
  • docker history --no-truc imagename:tag, para revisar el historial de las capas para la generación de una imagen.
  • dive imagename:tag, para ver de manera más detallada el historial de capas de una imagen.

FROM scratch, es la base para imágenes linux, que sólo contiene el kernel del OS.