Eu sou novo no docker. Eu apenas tentei usar o docker na minha máquina local (Ubuntu 16.04) com o Jenkins.

Eu configurei um novo trabalho com o script de pipeline abaixo.

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

Mas falha com erro abaixo.

O usuário jenkinsprecisa ser adicionado ao grupo docker:

sudo usermod -a -G docker jenkins

Em seguida, reinicie o Jenkins.

Editar

Se você chegar a essa questão do estouro de pilha porque recebe esta mensagem do docker, mas não usa o jenkins, provavelmente o erro é o mesmo: seu usuário não privilegiado não pertence ao grupo do docker.

Você pode fazer:

sudo usermod -a -G docker alice

ou qualquer que seja seu nome de usuário.

Você pode verificá-lo no final grep docker /etc/groupe ver algo assim:

docker:x:998:alice

em uma das linhas.

Altere seu ID do grupo de usuários para docker:

newgrp docker

Minhas primeiras soluções foram:

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

Mas nenhum deles funciona para mim, tentei:

chmod 777 /var/run/docker.sock

Isso funciona, mas não sei se é a decisão certa.

Sucesso para mim

sudo usermod -a -G docker $USER
reboot

19/08/2018

Estou parado há dias neste e como não encontrei uma resposta completa com o porquê e como, vou postar um para outras pessoas que tropeçam no mesmo problema e as respostas acima não funcionam.

Estas são as três etapas cruciais ao executar o Jenkins dentro da janela de encaixe:

1. Você monta o soquete /var/run/docker.sockno contêiner jenkins para poder usar a janela de encaixe do host.
2. Você precisa instalar a janela de encaixe dentro do contêiner para poder usá-lo. Este é um excelente e simples artigo sobre como fazer isso. Observe que as versões mais recentes já podem ter o docker instalado
3. Você executa sudo usermod -a -G docker jenkinspara adicionar jenkins ao grupo de janelas de encaixe. No entanto, aqui você pode ter um problema de permissão se a janela de encaixe host e a janela de encaixe de contêiner não tiverem o mesmo ID de grupo, portanto , é muito importante ajustar o gid da janela de encaixe para que seja o mesmo que o de janela de encaixe host

Você pode fazer isso como parte de um script de lançamento ou simplesmente usando exece fazê-lo manualmente: groupmod -g <YOUR_HOST_DOCKER_GID> docker.

Além disso, não altere as permissões do /var/run/docker.sockpara 777 ou coisas assim, porque esse é um grande risco de segurança, você está basicamente dando permissão a todos para usar o docker em sua máquina

Espero que isto ajude

Eu adicionei o usuário jenkins ao grupo raiz e reiniciei o jenkins e ele começou a funcionar.

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

Alterar a permissão de acesso do arquivo docker.sock

chmod 777 /var/run/docker.sock

ou você pode usar sudono início do comando.

chmod 777permitirá todas as ações para todos os usuários, enquanto chmod 666permitirá que todos os usuários leiam e gravem, mas não podem executar o arquivo.

Simplesmente adicionando dockercomo um grupo suplementar para o jenkinsusuário

sudo usermod -a -G docker jenkins

nem sempre é suficiente ao usar uma imagem do Docker como o Jenkins Agent . Ou seja, se você Jenkinsfilecomeçar com pipeline{agent{dockerfileou pipeline{agent{image:

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

Isso ocorre porque Jenkins executa um docker runcomando, o que resulta em três problemas.

• O agente (provavelmente) não terá os programas do Docker instalados.
• O agente não terá acesso ao soquete do daemon do Docker e tentará executar o Docker-in-Docker, o que não é recomendado .
• Jenkins fornece o ID do usuário numérico e o ID do grupo numérico que o Agente deve usar. O agente não terá nenhum grupo suplementar, porque docker runnão faz logon no contêiner (é mais como um sudo).

Instalando o Docker para o agente

Para disponibilizar os programas do Docker na imagem do Docker, basta executar as etapas de instalação do Docker no seu 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

...

Compartilhando o soquete do daemon do Docker

Como já foi dito anteriormente , corrigir o segundo problema significa executar o contêiner Jenkins Docker para que ele compartilhe o soquete do daemon Docker com o daemon Docker que está fora do contêiner. Portanto, você precisa dizer ao Jenkins para executar o contêiner Docker com esse compartilhamento, assim:

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

Definindo UIDs e GIDs

A solução ideal para o terceiro problema seria a criação de grupos suplementares para o agente. Isso não parece possível. A única correção que tenho conhecimento é executar o agente com o Jenkins UID e o Docker GID (o soquete possui permissão de gravação em grupo e pertence a ele root.docker). Mas, em geral, você não sabe quais são esses IDs (eles foram alocados quando useradd ... jenkinse groupadd ... dockerexecutados quando Jenkins e Docker foram instalados no host). E você não pode simplesmente dizer ao Jenkins para usuário jenkinse grupodocker

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

porque isso instrui o Docker a usar o usuário e o grupo que estão nomeados jenkinse docker dentro da imagem , e sua imagem do Docker provavelmente não tem o jenkinsusuário e o grupo e, mesmo que existisse, não haveria garantia de que teria o mesmo UID e GID que o host, e também não há garantia de que o dockerGID seja o mesmo

Felizmente, Jenkins executa o docker buildcomando para o seu Dockerfile em um script, para que você possa executar alguma mágica de script de shell para passar essas informações à medida que o Docker cria 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'
        }
    }

Isso usa o idcomando para obter o UID e o GID do jenkinsusuário e o statcomando para obter informações sobre o soquete do Docker.

Seu Dockerfile pode usar essa informação para configurar um jenkinsusuário e dockergrupo para o agente, usando groupadd, groupmode 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

Eu tenho o Jenkins rodando no Docker e o Jenkins conectado está usando o soquete do Docker da máquina host Ubuntu 16.04 via volume para /var/run/docker.sock.

Para mim, a solução foi:

1) Dentro do contêiner Docker de Jenkins ( docker exec -it jenkins bashna 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) Na máquina host:

sudo service docker restart

664 significa - ler e escrever (mas não executar) para o proprietário e os usuários do grupo.

Ao fazer a configuração de produção, obtive o problema de permissão. Tentei a solução abaixo para resolver o problema.

Mensagem de erro

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'.

Solução: permissões do soquete indicadas na mensagem de erro /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

Após alterar a permissão para docket.sock, execute o comando abaixo para verificar as permissões.

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/

No meu caso, não foi apenas necessário adicionar jenkinsusuário ao dockergrupo, mas tornar esse grupo o grupo principal do jenkinsusuário.

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

Não se esqueça de reconectar o nó escravo jenkins ou reiniciar o servidor jenkins, dependendo do seu caso.

16/02/2019

A maioria dos passos foram os mesmos para mim, como os outros escreveram. No entanto, não consegui adicionar jenkins à janela de encaixe do grupo usando o usermod com as soluções mencionadas.

Tentei o seguinte comando no host do docker e no contêiner do docker em execução :

sudo usermod -a -G docker jenkins

(Entrei no contêiner do estivador em execução com o seguinte comando do host do estivador :

docker exec -t -i my_container_id_or_name /bin/bash

)

Recebido do host do docker :

usermod: o usuário 'jenkins' não existe

Recebido do contêiner do docker :

Confiamos que você recebeu a palestra habitual do Administrador do Sistema local. Geralmente, tudo se resume a essas três coisas:

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

[sudo] senha para jenkins:

Eu não sabia a senha.

Sem a sudoparte do comando, no container docker , recebi:

usermod: permissão negada. usermod: não pode bloquear / etc / passwd; tente mais tarde.

Solução: Entrei no contêiner do estivador em execução a partir do host do estivador com o seguinte comando:

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

Agora, entrei como root e emiti o seguinte comando:

usermod -a -G docker jenkins

Em seguida, no host da janela de encaixe , reiniciei meu contêiner em execução com o seguinte comando:

docker restart my_container_id_or_name

Depois disso, iniciei o trabalho de Jenkins e terminei com sucesso.

Eu usei apenas o usuário root para emitir o usermodcomando para o usuário jenkins.

2019-05-26

Isso funcionou para mim!

Exemplo 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"

Eu enfrentei um problema semelhante, que é um problema de permissão, e a causa desse problema é que o daemon / servidor do Docker sempre é executado como rootusuário e deseja que você sempre anteceda o comando do docker sudo.

O daemon do Docker se liga a um soquete Unix em vez de uma porta TCP. Por padrão, o soquete Unix é de propriedade do usuário roote outros usuários só podem acessá-lo usandosudo .

Para corrigir isso, aqui está o que funcionou para mim:

Primeiro, verifique se você já possui um grupo de janelas de encaixe:

cat /etc/group

Se você não encontrar dockerna lista exibida, será necessário criar uma:

sudo groupadd docker

Em seguida, confirme seu usere você groupusando o comando abaixo:

cat /etc/group

Role para ver o grupo da janela de encaixe. Deve ser deste formato

docker:x:140:promisepreston

onde dockerestá o meu groupepromisepreston é meuuser

Agora podemos adicionar seu usuário ao grupo de janelas de encaixe

Apenas para arquivos de contêiner do Docker:

Copie e execute o comando abaixo no seu terminal exatamente como ele é declarado sem modificá-lo, independentemente da imagem do docker / contêiner / comando que você deseja executar ou está tentando executar ou está apresentando o problema de permissão:

sudo usermod -aG docker $USER

Depois de executar o comando acima, você precisará fazer logoff e logon novamente, para que sua associação ao grupo seja reavaliada. No entanto, no Linux, você também pode executar o seguinte comando abaixo para ativar as alterações nos grupos ( copie e execute o comando abaixo em seu terminal exatamente como ele é declarado sem modificá-lo de qualquer maneira, independentemente da imagem do docker / container / comando que você deseja executar ou está tentando executar ou está apresentando o problema de permissão ):

newgrp docker 

Agora você pode verificar se é possível executar comandos do docker sem permissões do sudo, executando o comando que está causando o problema de permissões novamente, diga ( Substitua my-commandpelo nome da sua imagem / contêiner / comando ):

docker run my-command

Para arquivos do sistema de arquivos Docker e Local:

Se você tiver uma cópia dos arquivos no sistema de arquivos local, poderá alterar a propriedade do diretório do aplicativo em que os arquivos do aplicativo estão armazenados, usando este formato:

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

Então, no meu caso, será:

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

Nota: Execute este comando dentro do diretório pai que abriga o diretório do aplicativo.

Isso é tudo.

Eu espero que isso ajude

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

Estou executando o Jenkins dentro de um contêiner. A solução mais simples para mim foi criar uma imagem personalizada que defina dinamicamente o 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

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

Como alternativa, você pode iniciar o jenkins com as seguintes opções:

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

Isso pressupõe que sua imagem jenkins tenha o cliente docker instalado. Consulte: https://getintodevops.com/blog/the-simple-way-to-run-docker-in-docker-for-ci

Se você receber erros como abaixo,

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

ou

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"

Apenas tente executar os seguintes comandos,

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

Estou usando a imagem oficial do docker jenkins ( https://hub.docker.com/r/jenkins/jenkins ), mas acho que esta solução é aplicável à maioria dos casos de uso em que queremos executar o Docker dentro de um contêiner do Docker.

A maneira recomendada de usar o Docker dentro de um contêiner do Docker é usar o deamon do Docker do sistema host. Bom artigo sobre isso: https://itnext.io/docker-in-docker-521958d34efd .

O segredo para lidar com o problema de permissão, que é a questão, é adicionar permissões para o usuário do contêiner dentro do contêiner, não para o sistema host . Somente o usuário root tem permissões para fazer isso por padrão, portanto

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

vai fazer isso. Lembre-se de reiniciar o contêiner.

Eu acho que a maneira mais simples de conseguir isso é criar um 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

Se alguém ainda estiver enfrentando o problema em sua máquina local (Ubuntu), tente o comando abaixo:

sudo chmod 666 /var/run/docker.sock

No meu caso, isso funcionará com sucesso. navegue no seu repositório local e insira este comando.

sudo chmod 666 /var/run/docker.sock

No servidor em que o Jenkins está sendo executado, eu usei

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

E, em seguida, execute cada contêiner de docker com

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

O uso de setfacl parece uma opção melhor e não é necessário "-u user". Os contêineres são executados como o mesmo usuário que está executando o Jenkins. Mas gostaria de receber qualquer feedback dos especialistas em segurança.

use abaixo 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

no meu caso, estava apenas iniciando o serviço docker:

sudo service docker start

geralmente é necessário reiniciar para entrar em vigor no novo grupo e usuário.

Se você estiver executando o Jenkins dentro de um contêiner de docker e seu Jenkins estiver vinculado à janela de encaixe host, será possível corrigir isso apenas no Dockerfile abaixo:

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

Talvez você deva executar a janela de encaixe com a opção "-u root" desde o início

Pelo menos isso resolveu meu problema