Qu'est-ce que la (meilleure) façon de gérer les autorisations pour Docker volumes partagés?

Mise à JOUR 2016-03-02: Comme de Docker 1.9.0, Docker a nommé volumes qui remplacer les données de la seule conteneurs. La réponse ci-dessous, ainsi que mon lié billet de blog, a encore de la valeur dans le sens de comment penser les données à l'intérieur de docker mais pensez à utiliser nommé volumes à mettre en œuvre le modèle décrit ci-dessous, plutôt que de conteneurs de données.

---

Je crois que la manière canonique de résoudre ce problème est en utilisant les données seulement des conteneurs. Avec cette approche, tous les accès aux données du volume via les conteneurs qui utilisent -volumes-from le conteneur de données, afin que l'hôte uid/gid n'a pas d'importance.

Par exemple, un cas d'utilisation donné dans la documentation est la sauvegarde d'un volume de données. Pour ce faire, un autre conteneur est utilisé pour faire la sauvegarde via tar, et il utilise -volumes-from afin de monter le volume. Donc, je pense que le point clé de grok est: plutôt que de penser comment faire pour obtenir l'accès aux données sur l'hôte avec les autorisations appropriées, pensez à la façon de faire tout ce dont vous avez besoin, les sauvegardes, la navigation, etc. -- via un autre récipient. Les conteneurs eux-mêmes besoin d'utiliser cohérente uid/gid, mais ils n'ont pas besoin de carte pour quoi que ce soit sur l'ordinateur hôte, ce qui est portable.

C'est relativement nouveau pour moi, mais si vous avez un cas d'utilisation particulier n'hésitez pas à commenter et je vais essayer d'étoffer la réponse.

Mise à JOUR: Pour le cas d'utilisation dans les commentaires, vous pourriez avoir une image some/graphite pour exécuter graphite, et une image some/graphitedata que le conteneur de données. Donc, en ignorant les ports et ces, Dockerfile de l'image some/graphitedata est quelque chose comme:

FROM debian:jessie
# add our user and group first to make sure their IDs get assigned consistently, regardless of other deps added later
RUN groupadd -r graphite \
  && useradd -r -g graphite graphite
RUN mkdir -p /data/graphite \
  && chown -R graphite:graphite /data/graphite
VOLUME /data/graphite
USER graphite
CMD ["echo", "Data container for graphite"]

Construire et de créer le conteneur de données:

docker build -t some/graphitedata Dockerfile
docker run --name graphitedata some/graphitedata

La some/graphite Dockerfile devrait également obtenir le même uid/gid, par conséquent, il pourrait ressembler à quelque chose comme ceci:

FROM debian:jessie
# add our user and group first to make sure their IDs get assigned consistently, regardless of other deps added later
RUN groupadd -r graphite \
  && useradd -r -g graphite graphite
# ... graphite installation ...
VOLUME /data/graphite
USER graphite
CMD ["/bin/graphite"]

Et il serait de fonctionner comme suit:

docker run --volumes-from=graphitedata some/graphite

Ok, maintenant que nous donne notre graphite conteneur et de données associées,-seul un récipient avec le bon utilisateur/groupe (remarque vous pouvez ré-utiliser le some/graphite conteneur pour le conteneur de données ainsi, en substituant les entrypoing/cmd lors de l'exécution, mais le fait d'avoir que des images distinctes de l'OMI est plus clair).

Maintenant, disons que vous souhaitez modifier quelque chose dans le dossier de données. Donc, plutôt que de lier le montage du volume de l'hôte et de l'édition il y, créer un nouveau conteneur pour faire ce travail. Appelons cela some/graphitetools. Permet également de créer des utilisateur/groupe, tout comme le some/graphite image.

FROM debian:jessie
# add our user and group first to make sure their IDs get assigned consistently, regardless of other deps added later
RUN groupadd -r graphite \
  && useradd -r -g graphite graphite
VOLUME /data/graphite
USER graphite
CMD ["/bin/bash"]

Vous pourriez faire de ce SEC en héritant de some/graphite ou some/graphitedata dans le Dockerfile, ou au lieu de créer une nouvelle image, tout simplement ré-utiliser l'un de ceux déjà existants (en ignorant point d'entrée/cmd en tant que de besoin).

Maintenant, il vous suffit d'exécuter:

docker run -ti --rm --volumes-from=graphitedata some/graphitetools

et puis vi /data/graphite/whatever.txt. Cela fonctionne parfaitement, parce que tous les conteneurs ont les mêmes graphite utilisateur avec appariement des uid/gid.

Puisque vous ne jamais monter /data/graphite à partir de l'hôte, vous ne se soucient pas de savoir comment l'hôte uid/gid cartes à l'uid/gid définie à l'intérieur de la graphite et graphitetools conteneurs. Ces conteneurs peuvent désormais être déployées à tout hôte, et ils vont continuer à fonctionner parfaitement.

La chose intéressante à ce sujet est que graphitetools pourrait avoir toutes sortes d'informations utiles des services publics et des scripts, que vous pouvez maintenant également déployer d'une manière portable.

Mise à JOUR 2: Après avoir écrit cette réponse, j'ai décidé d'écrire un plus complet post de blog sur cette approche. J'espère que cela aide.

Mise à JOUR 3: j'ai corrigé cette réponse et a ajouté plus de détails. Elle contenait auparavant des hypothèses erronées au sujet de la propriété et permanentes -- la propriété est généralement attribué à la création d'un volume heure c'est à dire dans le conteneur de données, parce que c'est lorsque le volume est créé. Voir ce blog. Ce n'est pas une obligation si -- vous pouvez simplement utiliser le conteneur de données de référence/de la poignée" et définissez la propriété/perms dans un autre récipient au moyen d'un chown dans un point d'entrée, qui se termine avec gosu pour exécuter la commande que l'utilisateur approprié. Si quelqu'un est intéressé par cette démarche, s'il vous plaît commentaire et je peut fournir des liens vers d'un échantillon à l'aide de cette approche.

Ce n'est sans doute pas le meilleur façon pour la plupart des circonstances, mais il n'est pas encore été mentionnés donc peut-être que cela aidera quelqu'un.

1. Lier mont volume hôte

   Host folder FOOBAR is mounted in container /volume/FOOBAR

2. Modifier votre contenant du script de démarrage pour trouver le GID du volume vous intéresse

   $ TARGET_GID=$(stat -c "%g" /volume/FOOBAR)

3. Assurer que votre utilisateur appartient à un groupe avec ce GID (vous pourriez avoir à créer un nouveau groupe). Pour cet exemple, je vais faire semblant de mon logiciel s'exécute en tant que nobody utilisateur lorsqu'à l'intérieur du conteneur, donc je veux m'assurer nobody appartient à un groupe avec un id de groupe égal à TARGET_GID

  EXISTS=$(cat /etc/group | grep $TARGET_GID | wc -l)

  # Create new group using target GID and add nobody user
  if [ $EXISTS == "0" ]; then
    groupadd -g $TARGET_GID tempgroup
    usermod -a -G tempgroup nobody
  else
    # GID exists, find group name and add
    GROUP=$(getent group $TARGET_GID | cut -d: -f1)
    usermod -a -G $GROUP nobody
  fi

J'aime cela parce que je peux facilement modifier les autorisations de groupe sur mon hôte, des volumes et de savoir que ceux mis à jour autorisations s'appliquent à l'intérieur du conteneur docker. Cela se produit sans la permission ou la propriété des modifications à mon hôte de dossiers/fichiers, ce qui me rend heureux.

Je n'aime pas cela parce qu'il assume qu'il y a pas de danger à ajouter vous-même à l'arbitraire d'un des groupes à l'intérieur du conteneur qui se trouvent être en utilisant un GID vous le souhaitez. Il ne peut pas être utilisé avec un USER clause dans un Dockerfile (à moins que l'utilisateur dispose des privilèges root, je suppose). Aussi, il hurle hack travail 😉

Si vous voulez être hardcore vous pouvez évidemment prolonger de plusieurs façons - par exemple, rechercher tous les groupes sur tous les sous-fichiers, plusieurs volumes, etc.

Essayez d'ajouter une commande à Dockerfile

RUN usermod -u 1000 www-data

crédits va à https://github.com/denderello/symfony-docker-example/issues/2#issuecomment-94387272

Ici est une approche qui utilise encore un seul conteneur, mais n'en a pas besoin pour être synchronisés avec le conteneur de l'application (en termes d'avoir le même uid/gid).

Sans doute, vous voulez exécuter une application dans le conteneur en tant que non-root $UTILISATEUR sans un shell de connexion.

Dans le Dockerfile:

RUN useradd -s /bin/false myuser

# Set environment variables
ENV VOLUME_ROOT /data
ENV USER myuser

...

ENTRYPOINT ["./entrypoint.sh"]

Puis, dans entrypoint.sh:

chown -R $USER:$USER $VOLUME_ROOT
su -s /bin/bash - $USER -c "cd $repo/build; $@"

Image De Base

Utiliser cette image: https://hub.docker.com/r/reduardo7/docker-host-user

ou

Important: ce qui détruit conteneur de portabilité entre les hôtes.

1) init.sh

#!/bin/bash

if ! getent passwd $DOCKDEV_USER_NAME > /dev/null
  then
    echo "Creating user $DOCKDEV_USER_NAME:$DOCKDEV_GROUP_NAME"
    groupadd --gid $DOCKDEV_GROUP_ID -r $DOCKDEV_GROUP_NAME
    useradd --system --uid=$DOCKDEV_USER_ID --gid=$DOCKDEV_GROUP_ID \
        --home-dir /home --password $DOCKDEV_USER_NAME $DOCKDEV_USER_NAME
    usermod -a -G sudo $DOCKDEV_USER_NAME
    chown -R $DOCKDEV_USER_NAME:$DOCKDEV_GROUP_NAME /home
  fi

sudo -u $DOCKDEV_USER_NAME bash

2) Dockerfile

FROM ubuntu:latest
# Volumes
    VOLUME ["/home/data"]
# Copy Files
    COPY /home/data/init.sh /home
# Init
    RUN chmod a+x /home/init.sh

3) run.sh

#!/bin/bash

DOCKDEV_VARIABLES=(\
  DOCKDEV_USER_NAME=$USERNAME\
  DOCKDEV_USER_ID=$UID\
  DOCKDEV_GROUP_NAME=$(id -g -n $USERNAME)\
  DOCKDEV_GROUP_ID=$(id -g $USERNAME)\
)

cmd="docker run"

if [ ! -z "${DOCKDEV_VARIABLES}" ]; then
  for v in ${DOCKDEV_VARIABLES[@]}; do
    cmd="${cmd} -e ${v}"
  done
fi

# /home/usr/data contains init.sh
$cmd -v /home/usr/data:/home/data -i -t my-image /home/init.sh

4) Construire avec docker

4) lancez-vous!

sh run.sh

Dans mon cas précis, j'ai essayé de construire mon node package avec le nœud de menu fixe de l'image, de sorte que je n'aurais pas à installer la ngp sur le serveur de déploiement. Il a bien fonctionné jusqu'à ce que, à l'extérieur le récipient et sur la machine hôte, j'ai essayé de déplacer un fichier dans le répertoire node_modules que le nœud de menu fixe l'image avait créé, à laquelle j'ai refusé les autorisations, car il a été possédé par la racine. J'ai réalisé que je pouvais contourner ce problème en copiant le répertoire le contenant sur la machine hôte. Via docker docs...

Les fichiers copiés sur l'ordinateur local sont créés avec l'UID:GID de l'
l'utilisateur qui a invoqué le docker commande cp.

C'est du bash code que j'ai utilisé pour changer le propriétaire du répertoire créé par et à l'intérieur du conteneur docker.

NODE_IMAGE=node_builder
docker run -v $(pwd)/build:/build -w="/build" --name $NODE_IMAGE node:6-slim npm i --production
# node_modules is owned by root, so we need to copy it out 
docker cp $NODE_IMAGE:/build/node_modules build/lambda 
# you might have issues trying to remove the directory "node_modules" within the shared volume "build", because it is owned by root, so remove the image and its volumes
docker rm -vf $NODE_IMAGE || true

Si nécessaire, vous pouvez supprimer le répertoire avec un deuxième conteneur docker.

docker run -v $(pwd)/build:/build -w="/build" --name $RMR_IMAGE node:6-slim rm -r node_modules

Si vous utilisez le Panneau de Composer, démarrer le conteneur en previleged mode:

wordpress:
    image: wordpress:4.5.3
    restart: always
    ports:
      - 8084:80
    privileged: true