Docker y --userns-remap, ¿cómo administrar los permisos de volumen para compartir datos entre el host y el contenedor?

En la ventana acoplable, los archivos creados dentro de los contenedores tienden a tener una propiedad impredecible al inspeccionarlos desde el host. El propietario de los archivos en un volumen es root (uid 0) por defecto, pero tan pronto como las cuentas de usuario no root están involucradas en el contenedor y escriben en el sistema de archivos, los propietarios se vuelven más o menos aleatorios desde la perspectiva del host.

Es un problema cuando necesita acceder a los datos de volumen desde el host utilizando la misma cuenta de usuario que llama a los comandos de la ventana acoplable.

Las soluciones típicas son

• forzar los UID de los usuarios en el momento de la creación en Dockerfiles (no portátil)
• pasar el UID del usuario del host al docker runcomando como una variable de entorno y luego ejecutar algunos chowncomandos en los volúmenes en un script de punto de entrada.

Ambas soluciones pueden dar cierto control sobre los permisos reales fuera del contenedor.

Esperaba que los espacios de nombres de usuario fueran la solución final a este problema. He ejecutado algunas pruebas con la versión 1.10 publicada recientemente y --userns-remap configurado en mi cuenta de escritorio. Sin embargo, no estoy seguro de que pueda hacer que la propiedad de archivos en volúmenes montados sea más fácil de manejar, me temo que en realidad podría ser lo contrario.

Supongamos que comienzo este contenedor básico

docker run -ti -v /data debian:jessie /bin/bash
echo 'hello' > /data/test.txt
exit

Y luego inspecciona el contenido del host:

ls -lh /var/lib/docker/100000.100000/volumes/<some-id>/_data/

-rw-r--r-- 1 100000 100000 6 Feb  8 19:43 test.txt

Este número '100000' es un sub-UID de mi usuario de host, pero como no se corresponde con el UID de mi usuario, todavía no puedo editar test.txt sin privilegios. Este subusuario no parece tener ninguna afinidad con mi usuario habitual real fuera de Docker. No está mapeado.

Las soluciones alternativas mencionadas anteriormente en esta publicación, que consistían en alinear los UID entre el host y el contenedor, ya no funcionan debido a la UID->sub-UIDasignación que se produce en el espacio de nombres.

Entonces, ¿hay alguna manera de ejecutar la ventana acoplable con el espacio de nombres de usuario habilitado (para mejorar la seguridad), y al mismo tiempo hacer posible que el usuario host que ejecuta la ventana acoplable posea los archivos generados en los volúmenes?

Si puede preorganizar usuarios y grupos con anticipación, entonces es posible asignar UID y GID de una manera tan específica para que los usuarios del host se correspondan con los usuarios con espacios de nombres dentro de los contenedores.

Aquí hay un ejemplo (Ubuntu 14.04, Docker 1.10):

1. Cree algunos usuarios con ID numéricos fijos:

   useradd -u 5000 ns1
   
   groupadd -g 500000 ns1-root
   groupadd -g 501000 ns1-user1
   
   useradd -u 500000 -g ns1-root ns1-root
   useradd -u 501000 -g ns1-user1 ns1-user1 -m
   

2. Edite manualmente los rangos de ID subordinados generados automáticamente en archivos /etc/subuidy /etc/subgid:

   ns1:500000:65536
   

   (tenga en cuenta que no hay registros para ns1-rooty ns1-user1debido MAX_UIDy MAX_GIDlímites en /etc/login.defs)

3. Habilite los espacios de nombres de usuario en /etc/default/docker:

   DOCKER_OPTS="--userns-remap=ns1"
   

   Reinicie el demonio service docker restart, asegúrese de que /var/lib/docker/500000.500000se crea el directorio.

   Ahora, dentro de los contenedores tiene rooty user1, y en el host, ns1-rooty ns1-user1, con ID coincidentes

   ACTUALIZACIÓN: para garantizar que los usuarios no root tengan ID fijos en los contenedores (por ejemplo, user1 1000: 1000), créelos explícitamente durante la creación de la imagen.

Prueba de conducción:

1. Prepare un directorio de volumen

   mkdir /vol1
   chown ns1-root:ns1-root /vol1
   

2. Pruébalo en un recipiente

   docker run --rm -ti -v /vol1:/vol1 busybox sh
   echo "Hello from container" > /vol1/file
   exit
   

3. Prueba del anfitrión

   passwd ns1-root
   login ns1-root
   cat /vol1/file
   echo "can write" >> /vol1/file
   

No es portátil y parece un truco, pero funciona.

Una solución es asignar dinámicamente el uid del usuario en el tiempo de compilación para que coincida con el host.

Ejemplo Dockerfile:

FROM ubuntu
# Defines argument which can be passed during build time.
ARG UID=1000
# Create a user with given UID.
RUN useradd -d /home/ubuntu -ms /bin/bash -g root -G sudo -u $UID ubuntu
# Switch to ubuntu user by default.
USER ubuntu
# Check the current uid of the user.
RUN id
# ...

Luego construye como:

docker build --build-arg UID=$UID -t mycontainer .

y ejecutar como:

docker run mycontainer

Si tiene un contenedor existente, cree un contenedor de envoltura con lo siguiente Dockerfile:

FROM someexistingcontainer
ARG UID=1000
USER root
# This assumes you've the existing user ubuntu.
RUN usermod -u $UID ubuntu
USER ubuntu

Esto se puede envolver docker-compose.ymlcomo:

version: '3.4'
services:
  myservice:
    command: id
    image: myservice
    build:
      context: .
    volumes:
    - /data:/data:rw

Luego compile y ejecute como:

docker-compose build --build-arg UID=$UID myservice; docker-compose run myservice

Puede evitar problemas de permisos utilizando el docker cpcomando .

La propiedad se establece para el usuario y el grupo principal en el destino. Por ejemplo, los archivos copiados a un contenedor se crean con UID:GIDel usuario root. Los archivos copiados a la máquina local se crean con el nombre UID:GIDdel usuario que invocó el docker cpcomando.

Aquí está su ejemplo cambiado para usar docker cp:

$ docker run -ti -v /data debian:jessie /bin/bash
root@e33bb735a70f:/# echo 'hello' > /data/test.txt
root@e33bb735a70f:/# exit
exit
$ docker volume ls
DRIVER              VOLUME NAME
local               f073d0e001fb8a95ad8d919a5680e72b21a457f62a40d671b63c62ae0827bf93
$ sudo ls -l /var/lib/docker/100000.100000/volumes/f073d0e001fb8a95ad8d919a5680e72b21a457f62a40d671b63c62ae0827bf93/_data
total 4
-rw-r--r-- 1 100000 100000 6 Oct  6 10:34 test.txt
$ docker ps -a
CONTAINER ID        IMAGE               COMMAND             CREATED              STATUS                          PORTS               NAMES
e33bb735a70f        debian:jessie       "/bin/bash"         About a minute ago   Exited (0) About a minute ago                       determined_hypatia
$ docker cp determined_hypatia:/data/test.txt .
$ ls -l test.txt 
-rw-r--r-- 1 don don 6 Oct  6 10:34 test.txt
$ cat test.txt
hello
$ 

Sin embargo, si solo desea leer archivos de un contenedor, no necesita el volumen con nombre. Este ejemplo usa un contenedor con nombre en lugar de un volumen con nombre:

$ docker run -ti --name sandbox1 debian:jessie /bin/bash
root@93d098233cf3:/# echo 'howdy' > /tmp/test.txt
root@93d098233cf3:/# exit
exit
$ docker cp sandbox1:/tmp/test.txt .
$ ls -l test.txt
-rw-r--r-- 1 don don 6 Oct  6 10:52 test.txt
$ cat test.txt
howdy
$ 

Encuentro que los volúmenes con nombre son útiles cuando quiero copiar archivos en un contenedor, como se describe en esta pregunta .