Soy nuevo en Docker. Intenté usar Docker en mi máquina local (Ubuntu 16.04) con Jenkins.

Configuré un nuevo trabajo con el siguiente script de canalización.

node {
    stage('Build') {
      docker.image('maven:3.3.3').inside {
        sh 'mvn --version'
      }
    }
}

Pero falla con el siguiente error.

El usuario jenkinsdebe ser agregado al grupo docker:

sudo usermod -a -G docker jenkins

Luego reinicie Jenkins.

Editar

Si llega a esta pregunta de desbordamiento de pila porque recibe este mensaje de Docker, pero no utiliza jenkins, lo más probable es que el error sea el mismo: su usuario no privilegiado no pertenece al grupo de Docker.

Tu puedes hacer:

sudo usermod -a -G docker alice

o sea cual sea tu nombre de usuario.

Puede verificarlo al final grep docker /etc/groupy ver algo como esto:

docker:x:998:alice

en una de las lineas.

Luego cambie su ID de grupo de usuarios a docker:

newgrp docker

Mis primeras soluciones fueron:

usermod -aG docker jenkins
usermod -aG root jenkins
chmod 664 /var/run/docker.sock

Pero ninguno de ellos funciona para mí, intenté:

chmod 777 /var/run/docker.sock

Eso funciona, pero no sé si es la decisión correcta.

Éxito para mi

sudo usermod -a -G docker $USER
reboot

2018-08-19

He estado atrapado durante días en este caso y, como no he encontrado una respuesta completa con el por qué y cómo, publicaré una para otras personas que tropiezan con el mismo problema y las respuestas de arriba no funcionan.

Estos son los 3 pasos cruciales al ejecutar Jenkins dentro de la ventana acoplable:

1. Usted monta el zócalo /var/run/docker.socken el contenedor jenkins para poder usar el acoplador desde el host.
2. Debe instalar la ventana acoplable dentro del contenedor para poder usarlo. Este es un excelente y simple artículo sobre cómo hacerlo. Tenga en cuenta que es posible que las versiones más nuevas ya tengan instalado Docker
3. Se ejecuta sudo usermod -a -G docker jenkinspara agregar jenkins al grupo de acopladores. Sin embargo, aquí puede encontrar un problema de permisos si la ventana acoplable de host y la ventana acoplable de contenedor no tienen la misma identificación de grupo, por lo que es muy importante ajustar el gid de docker del contenedor para que sea el mismo que el gid de docker de host

Puede hacer esto como parte de un script de inicio o simplemente usándolo execy haciéndolo manualmente:groupmod -g <YOUR_HOST_DOCKER_GID> docker .

Además, no cambie los permisos del /var/run/docker.sock777 o cosas por el estilo, ya que es un gran riesgo de seguridad, básicamente le está dando a todos permiso a para usar Docker en su máquina

Espero que esto ayude

Agregué el usuario jenkins al grupo raíz y reinicié el jenkins y comenzó a funcionar.

sudo usermod -a -G root jenkins
sudo service jenkins restart

Cambiar el permiso de acceso del archivo docker.sock

chmod 777 /var/run/docker.sock

o puede usar sudoal comienzo del comando.

chmod 777permitirá todas las acciones para todos los usuarios, mientras chmod 666que permitirá a todos los usuarios leer y escribir, pero no puede ejecutar el archivo.

Simplemente agregando dockercomo un grupo suplementario para el jenkinsusuario

sudo usermod -a -G docker jenkins

no siempre es suficiente cuando se usa una imagen Docker como el Agente Jenkins . Es decir, si Jenkinsfilecomienza con pipeline{agent{dockerfileo pipeline{agent{image:

pipeline {
    agent {
        dockerfile {
            filename 'Dockerfile.jenkinsAgent'
        }
    }
    stages {

Esto se debe a que Jenkins ejecuta un docker runcomando, lo que resulta en tres problemas.

• El Agente (probablemente) no tendrá instalados los programas Docker.
• El agente no tendrá acceso al socket del demonio Docker, por lo que intentará ejecutar Docker-in-Docker, lo que no se recomienda .
• Jenkins proporciona el ID de usuario numérico y el ID de grupo numérico que el Agente debe usar. El agente no tendrá ningún grupo suplementario, ya docker runque no inicia sesión en el contenedor (es más como un sudo).

Instalación de Docker para el agente

Hacer que los programas Docker estén disponibles dentro de la imagen Docker simplemente requiere ejecutar los pasos de instalación de Docker en su Dockerfile:

# Dockerfile.jenkinsAgent
FROM debian:stretch-backports
# Install Docker in the image, which adds a docker group
RUN apt-get -y update && \
 apt-get -y install \
   apt-transport-https \
   ca-certificates \
   curl \
   gnupg \
   lsb-release \
   software-properties-common

RUN curl -fsSL https://download.docker.com/linux/debian/gpg | apt-key add -
RUN add-apt-repository \
   "deb [arch=amd64] https://download.docker.com/linux/debian \
   $(lsb_release -cs) \
   stable"

RUN apt-get -y update && \
 apt-get -y install \
   docker-ce \
   docker-ce-cli \
   containerd.io

...

Compartir el socket del demonio Docker

Como se ha dicho antes , solucionar el segundo problema significa ejecutar el contenedor Docker de Jenkins para que comparta el socket del demonio Docker con el demonio Docker que está fuera del contenedor. Por lo tanto, debe decirle a Jenkins que ejecute el contenedor Docker con ese intercambio, por lo tanto:

pipeline {
    agent {
        dockerfile {
            filename 'Dockerfile.jenkinsAgent'
            args '-v /var/run/docker.sock:/var/run/docker.sock'
        }
    }

Configuración de UID y GID

La solución ideal para el tercer problema sería establecer grupos suplementarios para el Agente. Eso no parece posible. La única solución que conozco es ejecutar el Agente con el UID de Jenkins y el GID de Docker (el socket tiene permiso de escritura grupal y es propiedad de root.docker). Pero, en general, no sabe cuáles son esas identificaciones son (fueron asignados cuando el useradd ... jenkinsy groupadd ... dockercorrió cuando Jenkins y estibador se han instalado en el host). Y no puede simplemente decirle a Jenkins que use usuario jenkinsy grupodocker

args '-v /var/run/docker.sock:/var/run/docker.sock -u jenkins:docker'

porque eso le dice a Docker que use el usuario y el grupo que están nombrados jenkinsy docker dentro de la imagen , y su imagen de Docker probablemente no tenga el jenkinsusuario y el grupo, e incluso si lo tuviera, no habría garantía de que tendría el mismo UID y GID que el host, y tampoco hay garantía de que el dockerGID sea el mismo

Afortunadamente, Jenkins ejecuta el docker buildcomando para su Dockerfile en un script, por lo que puede hacer algo de magia de script de shell para pasar esa información a medida que Docker construye argumentos:

pipeline {
    agent {
        dockerfile {
            filename 'Dockerfile.jenkinsAgent'
            additionalBuildArgs  '--build-arg JENKINSUID=`id -u jenkins` --build-arg JENKINSGID=`id -g jenkins` --build-arg DOCKERGID=`stat -c %g /var/run/docker.sock`'
            args '-v /var/run/docker.sock:/var/run/docker.sock -u jenkins:docker'
        }
    }

Que utiliza el idcomando para obtener el UID y GID del jenkinsusuario y el statcomando para obtener información sobre el zócalo Docker.

Su Dockerfile puede utilizar esa información para configurar un jenkinsusuario o dockergrupo para el agente, usando groupadd, groupmody useradd:

# Dockerfile.jenkinsAgent
FROM debian:stretch-backports
ARG JENKINSUID
ARG JENKINSGID
ARG DOCKERGID
...
# Install Docker in the image, which adds a docker group
RUN apt-get -y update && \
 apt-get -y install \
   apt-transport-https \
   ca-certificates \
   curl \
   gnupg \
   lsb-release \
   software-properties-common

RUN curl -fsSL https://download.docker.com/linux/debian/gpg | apt-key add -
RUN add-apt-repository \
   "deb [arch=amd64] https://download.docker.com/linux/debian \
   $(lsb_release -cs) \
   stable"

RUN apt-get -y update && \
 apt-get -y install \
   docker-ce \
   docker-ce-cli \
   containerd.io

...
# Setup users and groups
RUN groupadd -g ${JENKINSGID} jenkins
RUN groupmod -g ${DOCKERGID} docker
RUN useradd -c "Jenkins user" -g ${JENKINSGID} -G ${DOCKERGID} -M -N -u ${JENKINSUID} jenkins

Tengo a Jenkins ejecutándose en Docker y Jenkins conectado está usando el socket Docker desde la máquina host Ubuntu 16.04 a través del volumen a /var/run/docker.sock.

Para mí la solución fue:

1) Dentro del contenedor Docker de Jenkins ( docker exec -it jenkins bashen la máquina host)

usermod -a -G docker jenkins
chmod 664 /var/run/docker.sock
service jenkins restart (or systemctl restart jenkins.service)
su jenkins

2) En la máquina host:

sudo service docker restart

664 significa: leer y escribir (pero no ejecutar) para el propietario y los usuarios del grupo.

Mientras hacía la configuración de producción, recibí el problema de permiso. Intenté la siguiente solución para resolver el problema.

Mensaje de error

ubuntu@node1:~$ docker run hello-world
docker: Got permission denied while trying to connect to the Docker daemon socket at unix:///var/run/docker.sock: Post http://%2Fvar%2Frun%2Fdocker.sock/v1.38/containers/create: dial unix /var/run/docker.sock: connect: permission denied.
See 'docker run --help'.

Solución: permisos del socket indicado en el mensaje de error, /var/run/docker.sock:

ubuntu@ip-172-31-21-106:/var/run$ ls -lrth docker.sock
srw-rw---- 1 root root 0 Oct 17 11:08 docker.sock
ubuntu@ip-172-31-21-106:/var/run$ sudo chmod 666 /var/run/docker.sock
ubuntu@ip-172-31-21-106:/var/run$ ls -lrth docker.sock
srw-rw-rw- 1 root root 0 Oct 17 11:08 docker.sock

Después de cambiar el permiso para docket.sock, ejecute el siguiente comando para verificar los permisos.

ubuntu@ip-172-31-21-106:/var/run$ docker run hello-world
Unable to find image 'hello-world:latest' locally
latest: Pulling from library/hello-world
1b930d010525: Pull complete
Digest: sha256:c3b4ada4687bbaa170745b3e4dd8ac3f194ca95b2d0518b417fb47e5879d9b5f
Status: Downloaded newer image for hello-world:latest

Hello from Docker!
This message shows that your installation appears to be working correctly.

To generate this message, Docker took the following steps:
 1. The Docker client contacted the Docker daemon.
 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
    (amd64)
 3. The Docker daemon created a new container from that image which runs the
    executable that produces the output you are currently reading.
 4. The Docker daemon streamed that output to the Docker client, which sent it
    to your terminal.

To try something more ambitious, you can run an Ubuntu container with:
 $ docker run -it ubuntu bash

Share images, automate workflows, and more with a free Docker ID:
 https://hub.docker.com/

For more examples and ideas, visit:
 https://docs.docker.com/get-started/

En mi caso, no solo era necesario agregar un jenkinsusuario al dockergrupo, sino que ese grupo era el grupo principal del jenkinsusuario.

# usermod -g docker jenkins
# usermod -a -G jenkins jenkins

No olvide volver a conectar el nodo esclavo jenkins o reiniciar el servidor jenkins, según su caso.

2019-02-16

La mayoría de los pasos fueron los mismos para mí que los otros han escrito. Sin embargo, no pude agregar jenkins al acoplador de grupo usando usermod con las soluciones mencionadas.

Intenté el siguiente comando desde el host de Docker y desde el contenedor de Docker en ejecución :

sudo usermod -a -G docker jenkins

( Ingresé al contenedor de Docker en ejecución con el siguiente comando del host de Docker :

docker exec -t -i my_container_id_or_name /bin/bash

)

Recibido del host docker :

usermod: el usuario 'jenkins' no existe

Recibido del contenedor acoplable :

Confiamos en que haya recibido la conferencia habitual del administrador del sistema local. Por lo general, se reduce a estas tres cosas:

#1) Respect the privacy of others.
#2) Think before you type.
#3) With great power comes great responsibility.

[sudo] contraseña para jenkins:

No sabía la contraseña.

Sin la sudoparte del comando, en el contenedor docker que recibí:

usermod: permiso denegado. usermod: no puede bloquear / etc / passwd; intente nuevamente más tarde.

Solución: entré al contenedor ventana acoplable funcionamiento del anfitrión ventana acoplable con el siguiente comando:

docker exec -t -i -u root my_container_id_or_name /bin/bash

Ahora, ingresé como root y emití el siguiente comando:

usermod -a -G docker jenkins

Luego, desde el host Docker , reinicié mi contenedor Docker en ejecución con el siguiente comando:

docker restart my_container_id_or_name

Después de eso, comencé el trabajo de jenkins y terminó con éxito.

Solo utilicé el usuario raíz para emitir el usermodcomando para el usuario jenkins.

2019-05-26

¡Esto funcionó para mí!

Ejemplo de docker-compose:

version: "3"
services:
  jenkins:
    image: jenkinsci/blueocean
    privileged: true
    ports:
      - "8080:8080"
    volumes:
      - $HOME/learning/jenkins/jenkins_home:/var/jenkins_home
    environment:
      - DOCKER_HOST=tcp://socat:2375
    links:
      - socat

  socat:
     image: bpack/socat
     command: TCP4-LISTEN:2375,fork,reuseaddr UNIX-CONNECT:/var/run/docker.sock
     volumes:
        - /var/run/docker.sock:/var/run/docker.sock
     expose:
        - "2375"

Me enfrenté a un problema similar, que es un problema de permisos y la causa de este problema se debe a que el demonio / servidor Docker siempre se ejecuta como el rootusuario, y quiere que siempre introduzca el comando docker sudo.

Docker daemon se une a un socket Unix en lugar de un puerto TCP. Por defecto, el socket Unix es propiedad del usuario rooty otros usuarios solo pueden acceder a él usando sudo.

Para solucionar esto, esto es lo que funcionó para mí:

En primer lugar, verifique si ya ha creado un grupo de acopladores:

cat /etc/group

Si no encuentra dockeren la lista que se muestra, deberá crear uno:

sudo groupadd docker

A continuación, confirme su usery su grouputilizando el siguiente comando:

cat /etc/group

Desplácese para ver el grupo de Docker. Debe ser de este formato.

docker:x:140:promisepreston

dónde docker esta mi groupy promiseprestones miuser

Ahora podemos agregar su usuario al grupo acoplable

Solo para archivos de contenedor Docker:

Copie y ejecute el siguiente comando en su terminal exactamente como se indica sin modificarlo de ninguna manera, independientemente de la imagen / contenedor / comando de la ventana acoplable que desea ejecutar o está intentando ejecutar o está causando el problema de permiso:

sudo usermod -aG docker $USER

Después de ejecutar el comando anterior, deberá cerrar sesión y volver a iniciarla para que su membresía de grupo sea reevaluada. Sin embargo, en Linux, también puede ejecutar el siguiente comando a continuación para activar los cambios en los grupos ( Copie y ejecute el siguiente comando en su terminal exactamente como se indica sin modificarlo de ninguna manera, independientemente de la imagen / contenedor / comando del acoplador que desea ejecutar o está intentando ejecutar o está causando problemas de permisos ):

newgrp docker 

Ahora puede verificar que puede ejecutar comandos de Docker sin permisos de sudo, ejecutando el comando que está causando el problema de permisos nuevamente, diga ( Reemplazar my-commandcon el nombre de su imagen / contenedor / comando ):

docker run my-command

Para los archivos del sistema de archivos Docker y Local:

Si tiene una copia de los archivos en su sistema de archivos local, puede cambiar la propiedad del directorio de la aplicación donde se almacenan los archivos de la aplicación, utilizando este formato:

sudo​​ ​ chown​​ ​ <your_user>:<your_group>​​ ​ -R​​ my-app-directory/

Entonces en mi caso será:

sudo chown promisepreston:docker -R my-app-directory/

Nota: ejecute este comando dentro del directorio principal que contiene el directorio de la aplicación.

Eso es todo.

espero que esto ayude

sudo usermod -a -G docker jenkins
sudo service jenkins restart

Estoy ejecutando Jenkins dentro de un contenedor acoplable. La solución más simple para mí fue hacer una imagen personalizada que establezca dinámicamente el GID, como:

FROM jenkins/jenkins:lts
...
CMD DOCKER_GID=$(stat -c '%g' /var/run/docker.sock) && \
    groupadd -for -g ${DOCKER_GID} docker && \
    usermod -aG docker jenkins && \
    sudo -E -H -u jenkins bash -c /usr/local/bin/jenkins.sh

Ver: https://github.com/jenkinsci/docker/issues/263

Alternativamente, puede iniciar jenkins con las siguientes opciones:

-v /var/run/docker.sock:/var/run/docker.sock \
-u jenkins:$(getent group docker | cut -d: -f3)

Esto supone que su imagen jenkins tiene instalado el cliente Docker. Ver: https://getintodevops.com/blog/the-simple-way-to-run-docker-in-docker-for-ci

Si puede obtener errores como a continuación,

Got permission denied while trying to connect to the Docker daemon socket at unix:///var/run/docker.sock

o

level=error msg="failed to dial gRPC: cannot connect to the Docker daemon. Is 'docker daemon' running on this host?: dial unix /var/run/docker.sock: connect: permission denied"

Solo intenta ejecutar los siguientes comandos,

$ sudo su - jenkins
$ sudo usermod -a -G docker $USER
$ sudo chown jenkins:docker /var/run/docker.sock

Estoy usando la imagen oficial de jenkins docker ( https://hub.docker.com/r/jenkins/jenkins ) pero creo que esta solución es aplicable a la mayoría de los casos de uso en los que queremos ejecutar Docker dentro de un contenedor Docker.

La forma recomendada para usar Docker dentro de un contenedor Docker es usar el demonio Docker del sistema host. Buen artículo al respecto: https://itnext.io/docker-in-docker-521958d34efd .

El secreto para manejar el problema de los permisos, del que trata esta pregunta, es agregar permisos para el usuario del contenedor dentro del contenedor, no para el sistema host . Solo el usuario root tiene permisos para hacerlo de forma predeterminada, por lo que

docker exec -it -u root <container-name> bash
usermod -a -G docker <username>

lo haré. Recuerde reiniciar el contenedor.

Supongo que la forma más sencilla de lograr esto es crear un Dockerfile personalizado:

# Official jenkins image
FROM jenkins/jenkins:lts
# Swith to root to be able to install Docker and modify permissions
USER root
RUN apt-get update
# Install docker
RUN curl -sSL https://get.docker.com/ | sh
# Add jenkins user to docker group
RUN usermod -a -G docker jenkins
# Switch back to default user
USER jenkins

# Bild the image:
# sudo docker build -t yourusername/imagename .
# Run the image and mount with the followin bind mount option:
# sudo docker run --name imagename -d -p8080:8080 -v /var/run/docker.sock:/var/run/docker.sock yourusername/imagename

Si alguien aún enfrenta el problema en su máquina local (Ubuntu), intente con el siguiente comando:

sudo chmod 666 /var/run/docker.sock

En mi caso, esto funcionará con éxito. navegue por su repositorio local e ingrese este comando.

sudo chmod 666 /var/run/docker.sock

En el servidor donde se ejecuta Jenkins, solía

sudo setfacl -m user:tomcat:rw /var/run/docker.sock

Y luego ejecute cada contenedor acoplable con

-v /var/run/docker.sock:/var/run/docker.sock

Usar setfacl parece una mejor opción, y no se necesita ningún "usuario -u". Los contenedores se ejecutan como el mismo usuario que ejecuta Jenkins. Pero agradecería cualquier comentario de los expertos en seguridad.

utilizar debajo de dockerfile

FROM jenkins/jenkins

USER root

# Install Docker
RUN apt-get update && \
    apt-get -y install apt-transport-https \
    ca-certificates \
    curl \
    gnupg2 \
    software-properties-common && \
    curl -fsSL https://download.docker.com/linux/$(. /etc/os-release; echo "$ID")/gpg > /tmp/dkey; apt-key add /tmp/dkey && \
    add-apt-repository \
    "deb [arch=amd64] https://download.docker.com/linux/$(. /etc/os-release; echo "$ID") \
    $(lsb_release -cs) \
    stable" && \
    apt-get update && \
    apt-get -y install docker-ce


# Compose
RUN curl -L "https://github.com/docker/compose/releases/download/1.22.0/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose && chmod +x /usr/local/bin/docker-compose



RUN usermod -aG docker jenkins
RUN usermod -aG root jenkins

USER jenkins

en mi caso solo estaba comenzando el servicio de docker:

sudo service docker start

a menudo es necesario reiniciar para que surta efecto en el nuevo grupo de usuarios y usuario.

Si está ejecutando Jenkins dentro de un contenedor acoplable y su Jenkins se está vinculando al acoplador host, puede solucionarlo solo con el Dockerfile a continuación:

FROM jenkins/jenkins:2.179
USER root
RUN groupadd docker && usermod -a -G docker jenkins
USER jenkins 

Tal vez deberías ejecutar la ventana acoplable con la opción "-u root" desde el principio

Al menos eso resolvió mi problema