Volúmenes

Comandos:

$ docker volume ls (listo los volumes)
$ docker volume create dbdata (creo un volume)
$ docker run -d --name db --mount src=dbdata,dst=/data/db mongo (corro la BBDD y monto el volume)
$ docker inspect db (veo la información detallada del contenedor)
$ mongo (me conecto a la BBDD)

shows dbs (listo las BBDD)
use platzi ( creo la BBDD platzi)
db.users.insert({“nombre”:“guido”}) (inserto un nuevo dato)
db.users.find() (veo el dato que cargué)

Los comandos de esta clase

si les sale error en windows “docker: Error response from daemon: invalid mount config for type “volume”: invalid mount path: ‘C:/Program Files/Git/data/db’ mount path must be absolute.” , el comando correcto es: docker run -d --name db --mount src=dbdata,dst=//data/db mongo

Bind mount and volumes
When we use a container the data generated is deleted when the container is stopped or removed, so how we can save the data, there are two ways to do it bind mount and volumes.

**Bind mount **helps us to bind a directory in our machine to a directory in a container. This allows saving data in our directory and use the same data each time we use the container.

But it can be dangerous because we are allowing the container to have access to one spot in our machine and if the container is malicious it can use in a bad way whatever info we had in that directory.

**Volumes **are the evolution of the bind mount. Volumes solve the problems of security and privacy that were found in bind mounts. How does it work? The disc part we share with docker is completely managed by docker, and we don’t have access unless we have privileges, but it is very convenient because we have only one place where our docker’s data is stored, and only docker can perform modifications on it.

Ojo que el contenido de los volúmenes “aministrados por Docker” sí se puede acceder desde fuera… Simplemente hay que hacer docker volume inspect VOLUME_NAME, ahí aparecerá el “Mountpoint” del volumen (path en el disco local), y si nos dirigimos allí (con usuario administrador o sudo en sistemas UNIX) podremos ver todo el contenido y gestionarlo.

14. Usar volúmenes, conservar datos dentro fuera de los contenedores
¿Qué son los volume?
Los volúmenes son el mecanismo preferido para conservar los datos generados y utilizados por los contenedores de Docker. Si bien los montajes de enlace dependen de la estructura del directorio y el sistema operativo de la máquina host, Docker administra completamente los volúmenes. Los volúmenes tienen varias ventajas sobre los montajes vinculantes:
Ventajas

• Mayor seguridad al compartir archivos entre contenedores, los archivos los maneja directamente docker esto implica que, cualquier persona no puedes acceder a estos archivos.
• Los volúmenes son más fáciles de respaldar o migrar que enlazar montajes.
• Puede administrar volúmenes mediante los comandos de la CLI de Docker o la API de Docker.
• Los volúmenes funcionan tanto en contenedores de Linux como de Windows.
• Los volúmenes se pueden compartir de forma más segura entre varios contenedores.
• Los controladores de volumen le permiten almacenar volúmenes en hosts remotos o proveedores en la nube, para cifrar el contenido de los volúmenes o para agregar otras funciones.
• Los nuevos volúmenes pueden tener su contenido pre cargado por un contenedor.
• Los volúmenes en Docker Desktop tienen un rendimiento mucho mayor que los montajes de enlace de hosts de Mac y Windows.
• Además, los volúmenes suelen ser una mejor opción que los datos persistentes en la capa de escritura de un contenedor, porque un volumen no aumenta el tamaño de los contenedores que lo usan y el contenido del volumen existe fuera del ciclo de vida de un contenedor determinado.
  Desventajas
• Una de las desventajas es que si se desea visualizar los archivos desde la máquina hosts es mucho más complicado.
  Referencia:
  https://docs.docker.com/storage/volumes/
  Pasos para conservar datos fuera de los contenedores con volúmenes.

1. crear el volumen
2. verificar que el volumen fue creado
3. crear un nuevo contenedor basado en una imagen de mongo e indicarle que guardará o usará los datos de un volumen
4. Es opcional, pero se puede inspeccionar el contenedor para visualizar si el volumen quedo configurado.
5. Acceder al bash de nuestro contenedor,
6. Acceder a mongo
7. Crear una bases de datos y usarla
8. Realizar una inserción de datos en la base de datos
9. Confirmar la inserción en la base de datos
10. Salir del contenedor
11. borrar contenedor.
    Pasos para crear un nuevo contenedor y usar un volumen anteriormente creado.
12. Crear un nuevo contenedor basado en una imagen de mongo e indicarle que guardará o usará los datos de un volumen anteriormente creado
13. Acceder al bash de nuestro contenedor,
14. Acceder a mongo
15. Usar la bases de datos creadas
16. Confirmar la inserción en la base de datos, que fue realizada anteriormente

Ejecución de los pasos para conservar datos fuera de los contenedores con usando volúmenes,

1. $ sudo docker volume create dbdata
2. $ sudo docker volume ls
3. $ sudo docker run -d --name db --mount src =dbdata,dst=/data/db mongo
4. $ sudo docker inspect db
5. $ sudo docker exec -it db bash
6. $ mongo

7. use platzi

8. db.users.insert({“nombre”:“guido”})

9. db.users.find()

10. $ exit
11. sudo docker rm -f

Ejecución de los pasos para crear un nuevo contenedor y usar un volumen anteriormente creado.

1. $ sudo docker run -d --name db --mount src=dbdata,dst=/data/db mongo
2. $ sudo docker exec -it db bash
3. $ mongo
4. show dbs

5. use platzi

6. db.users.find()

Explicación de los comandos de volumen
Asignar un volume aun contenedor
$ docker run -d --name <nombre c> --mount src =<carpeta L>,dst=<carpeta C> <nombre i>

parámetros

	<nombre c>: 
		nombre del contenedor, así se llamará localmente
<path L>: 
	directorio local
<path C>: 
	directorio del contenedor
< nombre i>:
	nombre de la imagen

flag
--name: 
	asigna un nombre de forma local a nuestro contenedor
-d or --detach: 
	Inicia un contenedor sin asociar el input/output del contenedor al terminal.
    --mount  src =<volume F>,dst=<Carpeta d>:
	Se indica  el  src es igual al volumen fuente, dst es igual a la carpeta destino, es decir a la carpeta del contenedor donde se genera los datos 

Ejemplo:

$ sudo docker run -d --name db --mount  src =dbdata,dst=/data/db mongo

Crear un volumen
$ sudo docker volume create <nombre de volumen>

volume create:
	Crear volumen 
<nombre de volumen>:
	Nombre Volumen

Ejemplo:
$ sudo docker volume create dbdata

Listar los volúmenes creados
$ sudo docker volume ls

volumen ls:

listar o mostrar los volúmenes
Ejemplo:
$ sudo docker volume ls

Crear un volumen:
docker volume create [nombre_del_volument]

Listar los volúmenes
docker volume ls

**Montamos el contenedor especificándole el volumen **
entre la coma en src y dst no poner espacio. Puede que nos de un error docker: invalid refence format
docker run -d --name db --mount src=dbdata (que_queremos_montar),dst=(destino) /data/db mongo

Entramo en el cliente de mongo
docker exec -it db bash
mongo

Borramo el contenedor anteriormente creado
docker rm -f db

Montamos otro contenedor con el mismo nombre, mismo lugar (src,dst)
docker run -d --name db --mount src=dbdata,dst=/data/db mongo
docker exec -it db bash
mongo

Para entrar directamente al mongo

docker exec -it db mongo

Me parece mejor este curso que el del 2018 pero en este video al profesor se le olvido limpiar la terminal y hace muy complicado ver la info con la interfaz del reproductor

Sumando a las notas de Gastón:
Existe otra manera diferente de manejar datos. La más común son los volúmenes.
La parte del disco donde docker crea los volúmenes es accesible sólo por docker, por lo tanto es más seguro y ordenado.

Para ver los volúmenes creados:
$ docker volume ls

para crear el volumen de nombre “dbdata”
$ docker volume create dbdata

Si queremos montarle el volumen “dbdata” al contenedor en el destino /data/db y correr la base de datos:
$ docker run -d --name db --mount src=dbdata,dst=/data/db mongo

ahora, corremos bask:
$ docker exec -it db bash

ahora, ingresamos un dato en la base de datos:
$ mongo #me conecto a la BBDD
shows dbs #listo las BBDD
use platzi #creo la BBDD platzi
db.users.insert({“nombre”:“guido”}) #inserto un nuevo dato
db.users.find() #veo el dato que cargué

Ahora, al crear un nuevo contenedor, siempre debo usar el mismo
$ docker run -d --name db --mount src=dbdata,dst=/data/db mongo

https://docs.docker.com/storage/volumes/

Volume: Storing Data in a Docker Volume

The problem with bind mount is that you are giving Docker access to a part of the system, this is not always the right thing. That’s why volumes appeared in Docker, which work the same way as bind mount, but the difference is that that space where the files are going to be stored is managed by Docker. Therefore, the rest of the host processes should not be able to access it.

For example, if you have created a volume and you want to assign it to a database, you will do it in the following way:

docker run -d --name <container-name> --mount src=<volume-name>,dst=<container-path> image

Main commands related to volumes:

• List volumes

docker volume ls

• Purging volumes

docker volume prune  

• Create volumes

docker volume create name

• Linking volume to container

In order to associate the directory of a container to a volume, the --mount parameter is used, then src to indicate the volume where the information will be saved, and then dst to indicate the destination or directory of the container that will be mounted on the volume indicated in src

docker run -d --name db --mount src=<volume_name>,dst=<place_of_the_filesystem_that_we_want_to_link>

Example

docker run -d --name db --mount src=dbdata,dst=/data/db mongo

• Inspect a volume:

`$ docker volume inspect my-vol
[ {
"Driver": "local", "Labels": {}, 
"Mountpoint": "/var/lib/docker/volumes/my-vol/_data", 
"Name": "my-vol", 
"Options": {}, 
"Scope": "local" 
}
]`

• Remove a volume:

docker volume rm my-vol

Volume with specific storage capacity

docker volume create --driver local \
    --opt type=tmpfs \
    --opt device=tmpfs \
    --opt o=size=100m,uid=1000 \
    nombredelvolumen

Si no les funciona el comando “mongo” en el contenedor, prueben con:

• mongosh

Source: https://www.cherryservers.com/blog/how-to-install-and-start-using-mongodb-on-ubuntu-20-04

– Listar volumenes

docker volume ls

– Creamos un volumen

docker volume create dbdata

– Creamos un contenedor con este volumen

docker run -d --name db --mount src=dbdata,dst=/data/db mongo

– inspeccionamos el contenedor

docker inspect db

– insertamos datos

docker exec -it db bash
# mongo
> use platzi
> db.users.insert({"nombre": "Boris"})
> db.users.find()
> exit
# exit
docker rm -f db

– verificamos

docker run -d --name db --mount src=dbdata,dst=/data/db mongo
docker exec -it db bash
# mongo
> use platzi
> db.users.find()

Desde windows los volumenes son creados en:

\\wsl$\docker-desktop-data\version-pack-data\community\docker\volumes\shared_data\_data

Al utilizar la integración WSL, docker crea dos ubicaciones

• docker-desktop
• docker-desktop-data

Se puede acceder a ellas mediante:

\\wsl$\docker-desktop
\\wsl$\docker-desktop-data

que curioso que los mounts se escriban con -v en cambio los volumes se escriben con -mount, que loco 😄

Volúmenes Docker

Para listar volúmenes de Docker

$ docker volume ls

Para crear un volumen de Docker

$ docker volume create dbdata

Para crear un contenedor que corra mongo y utilice un volumen, al contenedor se le asigna db como nombre.
el comando --mount tiene como parámetros:
src (para establecer el source <fuente> del volumen)
dst (para establecer destination, directorio dentro del contenedor)

$ docker run -d --name db --mount src=dbdata,dst=/data/db mongo

Para ver información detallada del contenedor

$ docker inspect db

Ahora nos conectamos por terminal al contenedor llamado db, que está corriendo mongo

$ docker exec -it db bash

comando para conectarnos a la base de datos mongo, desde linea de comandos

$ mongo

comando mongo para listar las bases de datos

> show dbs

comando mongo para crear una base de datos de nombre platzi

> use platzi

comando mongo para insertar datos a la base de datos

> db.users.insert({“nombre”:“walter”})

comando para acceder a los datos:

> db.users.find()

Para crear volumenes en una ruta especifica
docker volume create -o type=none -o o=bind -o device=$(pwd) my-vol

Los que quieran leer mas sobre los beneficios de Volumenes vs Bind Mounts, la documentación de docker es muy clara y completa 😃) https://docs.docker.com/storage/volumes/

Para revisar si el docker volume fue montado correctamente en el contenedor

$ docker inspect nombre-del-contenedor | grep Mount

el comando grep sirve para buscar coincidencias y monstrar el resultado en el terminal.

documentación sobre los volumenes
https://docs.docker.com/storage/volumes/

Veo que hay más gente que ha tenido el siguiente error al intentar montar un volumen en el contendor:

docker run -d --name db --mount src=dbdata,dst=/data/db mongo

docker: Error response from daemon: invalid mount config for type "volume": invalid mount path: 'C:/Program Files/Git/data/db' mount path must be absolute.
See 'docker run --help'.

Para mi la solución fue añadir una segunda / en la ruta de destino:

docker run -d --name db --mount src=dbdata,dst=//data/db mongo

Así me funcionó, la razón no la se, si alguien puede arrojar un poco de luz se agradecería.

• docker volume, para ver los volumenes creados por docker en el OS.
• docker volume prune, para depurar volumen que ya no se usan.
• docker volume create namevolume, para crear un nuevo volumen de nombre namevolume, para ser usado por docker.
• docker run -d --name db --mount src=namevolume,dst=/data/db mongo, creamos un nuevo container de imagen mongo, de nombre db, que no muestre el output del comando que ejecuta y que use el volumen volumename del host ligado con la ruta /data/db del container.

Una evolucion de bind mounts son los volúmenes ya que estos no están expuestos a la maquina anfitrion sino que docker los administra de forma interna, algunos comandos para volúmenes son:

$ docker volume ls (listar los volumenes)
$ docker volume create <nombre-volumen> (crea un nuevo volumen con el nombre especifico)
$ docker run -d --name monguito --mount src=<nombre-volumen>,sdt=/data/db mongo (corre un contenedor de mongo asignando un volumen)

Pasos para crear un volumen:

1. Crear volumen

docker volume create dbdata

1. Correr contenedor y añadir volumen

docker run -d --name db --mount src=dbdata,dst=/data/db mongo

1. Entrar al contenedor

docker exec -it db bash

Datos administrados por Docker.

• Volume Mount es la manera más estándar de manejar datos en Docker de forma más segura y es la evolución del Bind Mount.
• La parte del disco que afecta al Volumen Mount es manejada enteramente por Docker y por nosotros como super usuarios.
• Creamos el Volume Mount con docker volume create <nameVolume>
  –

docker run --mount src=nameVolume,dst=/data/db mongo: esta línea de comando es para crear y ejecutar un contenedor ( docker run ) con un Volume Mount (esta bandera --mount especifica que queremos un Volume Mount).
Luego la fuente (container) src=nameVolume (que se encargaría de crear la base de datos si no existiera) y por último el destino dst=/data/db mongo

Alguien por el reto de observabilidad?

Compartir datos entre contenedores con volúmenes.

Compartir datos de contenedores entre ellos con volumenes

Por seguridad entonces se debe utilizar volúmenes aunque sea un poco más compleja su posterior manipulación.

Me encontre con un problema ya que no me aceptaba el parametro --mount , busque sobre el problema y encontre que tenia la version 13 y este comando esta disponible a partir de la 17… Realice la actualizacion a la version 20 y me funciono.

Excelente gracias

Buenas. Estoy usando una cuenta gratuita de AWS, tengo una instancia de Ubuntu, tiene que ver con el uso de AWS, que al volver a montar el volumen en el contenedor, y haga el find(), no me aparezca nada?
Gracias.

Todos los archivos de los volumenes los podemos encontrar en el directorio /var/lib/docker/volumes, pero tenemos que tener permisos de administrador para poder acceder a ellos

Los volúmenes son una evolución de los bind mounth

Qué buena clase!! Me encantó Docker… Ya estoy pensando en qué voy a usarlos

Nice

–La parte del disco que afecta a los volumenes es manejada por docker y no tenemos acceso a menos que tengamos accesos privilegiados en el sistema, es practico para disponer de un lugar donde docker almacena datos y nadie mas los puede tocar excepto docker–
docker volume ls (mostrar los volumes)
docker volume create <name_volume> (crear un volume)
docker run -d --name <name_container> --mount src=<name_volume>,dst=/data/db mongo (crear contenedor y monto el volume que creé en caso de que el volumen no exista docker lo crea)
docker inspect <name_container> (veo la información detallada del contenedor)
docker exec -it <name_container> bash (entro al bash del contenedor)
mongo (me conecto al cliente de mongo db)
shows dbs (muestro las BD)
use <name_db> ( creo la BD)
db.users.insert({“nombre”:“ivan”}) (inserto un nuevo dato)
db.users.find() (veo el dato que cargué)
—Como extra podemos validar que el volumen funciona

1. Borramos el contenedor docker rm -f <name_container> (lo para y lo borra)
2. Creamos un nuevo contenedor con el mismo volumen y en el mismo lugar
3. Ejecutamos el proceso de entrar a Shell, cliente de mongo y consulta a la BD
   Notaremos que la información está disponible, porque toda la data está almacenada en un volumen administrado por docker–

el ejemplo unico con mongo… pero mysql y postgres que creo que son comerciales como me entero de su carpeta de data… ?

Al correr el comando, me sale este error, alguien sabe porque ?
$ docker run -d --name db --mount src=dbdata,dst=/data/db mongo

docker: Error response from daemon: invalid mount config for type “volume”: invalid mount path: ‘C:/Program Files/Git/data/db’ mount path must be absolute.

super… vamos aprendiendo!

en los ejemplos se tapa la visual con la barra de progreso del video

They are the SAME

• docker run --name db -d --mount type=bind,src=<local-path>,dst=/data/db mongo
• docker run --name db -d -v <local-path>:/data/db mongo
  🔗 Choose the -v or --mount flag

Si tienen un error que dice “mount path must be absolute” ejecuten el comando poniendo doble barra inclinada en la tupla dst:

docker run -d --name db --mount type=volume,src=dbdata,dst=//db//data mongo

El comando actual debe ser lo siguiente para no tener errores de formato.

docker run -d --name db --mount 'src=dbdata,dst=/data/db' mongo

❤

Por si alguien más tuvo el problema de --mount es porque este comando es soportado desde la versión 17.06 en adelante. Probablemente tengas una versión mas antigua.

Solución: actualizarlo
o adaptar el código a algo como esto

$docker run -d --name db -v dbdata:/data/db mongo

podman run -d --name db --mount type=volume,source=dbdata,target=/data/db mongo

Pueden inspeccionar el volumen creado, asi…

docker volume inspect db_data_mongo

Volúmenes

• Una evolución desarrollada para darles más seguridad a los usuarios que ejecutan docker en ambientes productivos.
• La parte del disco que afecta a los volúmenes es manejada íntegramente por docker y solo tienen acceso usuarios privilegiados del sistema.
• Es práctico para almacenar datos que nadie debe tocar más que docker, ayuda a tener un orden de los archivos generados por los contenedores

Manejo de datos Bind mount and volumes

Los volumenes los podemos ver como procesos, ver los volumenes:

docker volume ls

Crear un volumen y asociarlo a un contenedor

docker volume create dbdata
docker run -d --name db --mount src=dbdata,dst=/data/db mongo

Data interesante cuando usemos el mount y es que no puede existir un espacio entre la coma.

Fecha 2020/3/29
si tienen problemas con alguna imagen que no levanta, pueden ver el problema con más detalle con:

docker logs -f <nameContainer> 

esto es muy útil, en mi caso, estaba siguiendo la clase y mongo no levantaba porque está en su versión 5 y para ello necesitas tener una CPU con AVX

oooo it’s awesome

Entendido

docker inspect nombredelcontenedor = inspecciona el contenedor indicado

docker run -d --name db --mount src=dbdata,dst=/data/db bitnami/mongodb = crea un contenedor y con el parametro src monta un volume que se llamado dbdata y extrae los datos desde /data/db indicados por el parametro dst

docker volume create nombredelvolumen = crea un volumen nuevo.

docker volume ls = lista los volumenes que hemos creado.

Docker command to create volumes

Docker command to create volumes

si tienen el error:
invalid argument “src=dbdata,” for “–mount” flag: invalid field ‘’ must be a key=value pair
See ‘docker run --help’.

colocar entre comillas ‘src=<VOLUMEN>,dst=/data/db’ todo pegado y sin espacios

resumen:

VOLUMENES
La manera mas estándar de manejar datos de docker, no es la primera que ocurrió. Los volúmenes fueron una evolución para dar mas seguridad a personas que ejecutan docker en entornos productivos.
La parte del disco que afecta a los volúmenes en docker es manejada enteramente por docker, amenos que seamos usuarios privilegiados del sistema, entonces es muy practico disponer de un lugar donde docker va a almacenar datos y que nadie mas pueda tocar excepto docker, y nos ayuda a ser ordenados y no tener archivos generados por los contenedores tirados por cualquier parte de nuestro disco.

-> Listar los volúmenes:
docker volume ls

-> Crear un nuevo volumen:
Docker volume create nombre_volumen

-> crear un contenedor con el volumen creado:
docker run -d --name nombre_contenedor --mount src=nombre_volumen,dst=/data/db mongo

VOLUMENES

#Listar volumenes
docker volume ls

#Crear volumen
$ docker volume create <volume-name>

#Montar contenedor con volumen
$ docker run -d --name <container-name> --mount src=<volumen>,dst=<container-path> <image>
 

Mi aporte: Link.
Es una automatización de los comandos vistos en clase.

• Docker crea el volumen especificado en src= si es que este no está previamente creado.

Mucha, pero mucha teoría, exagerado según yo. Si bien es importante, creo que más practicases mejor y se entiende de igual forma. Ojalá modifiquen el curso para que hagan ejemplos y laboratorio que refuercen lo que explica el instructor

interesante el el manejo de los volumenes

**** seria bueno que cuando se realizan practicas en CLI que no este al borde por que los controles del video se sobre ponen con lo que se va escribiendo y cuando lo detenemos para apuntar lo que escribe no se ve

Entre más avanza el curso, más se esta viendo el poder de docker, muero por usarlo ya en un proyecto 😮

Uso del --mount

Manera para anexar datos a un volumen desde docker: docker run -d --name [nombre-contenedor] --mount src=[nombre-volumen],dst=/data/[nombre del contenedor que se creará en esta misma linea] mongo Nota: si no existe el volumen especificado, se creara

docker volume create dbdata

Sirve para crear un volumen

docker run -d --name db --mount src=dbdata,dst=/data/db mongo

–mount es para asignar un volumen al contenedor, usando src le decimos que volumen es y dst (de destino) la ubicacion en el contenedor, mongo es la imagen.

Esta implementación es una evolución que Docker desarrolló para darle más seguridad a las personas que ejecutan Docker en entornos productivos.

La parte del disco que afectan a los volúmenes en Docker es manejada internamente por Docker; de manera que no tenemos acceso a ello a menos que seamos usuarios privilegiados del sistema. Por ello, es muy práctico para disponer un lugar donde Docker almacenará datos y que nadie pueda tocarlo excepto Docker. Esto también nos ayuda a ser ordenados y a no tener datos que utiliza Docker dispersados por cualquier parte del disco.

Comandos:

• docker volume ls: Listar volúmenes creados.
• docker volume create $VOLUME_NAME: Crear un volumen.
• docker run --mount src=$VOLUME_NAME,dst=$CONTAINER_PATH $IMAGE_NAME: Así le asignamos un volumen a un contenedor.