Docker: permissão negada ao tentar conectar-se ao soquete do daemon do Docker no unix: ///var/run/docker.sock

175

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.

insira a descrição da imagem aqui

Ponsuyambu Velladurai
fonte
1
é um Jenkins monolítico ou tem uma configuração mestre-escravo? Verifique com qual usuário você está executando o comando docker inspect. Veja se /var/run/docker.sock tem acesso RW ao grupo.
Ram Kamath
2
etapas de pós-instalação do docker: docs.docker.com/install/linux/linux-postinstall/…
radistao

Respostas:

294

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
austingray
fonte
88
e reconecte-se usuário
Ilya Kolesnikov
8
Boa resposta, mas para ser mais geral, poderíamos fazer isso: sudo usermod -a -G docker $USERe sair ou reiniciar. link
Julien Nyambal
10
Eu tive que reiniciar meu servidor para que isso realmente funcionasse.
18718 Etagwerker #
3
Eu tinha de desconexão / reconexão meus nós para que isso funcione (eles estão conectados via ssh)
GaspardP
28
Não é necessário fazer login novamente, basta usar newgrp dockerna mesma sessão do terminal.
C14L 06/04/19
69

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.

Kevin Garay
fonte
4
A razão pela qual falhou provavelmente é porque você teve que reabrir o terminal. Ele falhou depois de fazer 664, mas então eu abri um novo shell que funcionava.
PHGamer 10/10
1
Eu tentei reabrir, mas começou a trabalhar somente após a última chmod 777
irônico
o problema era que, após a reinicialização, o 777 foi redefinido para 660. O que corrigiu o problema para mim foi 'usermod -aG users jenkins'.
ironic
Sei que foi redefinido, mas não defina as permissões do docker.sock como 777. Isso dá a qualquer um root no sistema. Eles podem conversar com a janela de encaixe e criar contêineres privilegiados sem restrições.
Lance Hudson
3
Apesar disso ter funcionado para o autor e até para mim, dar mais acesso ao docker.sockarquivo não é a melhor solução, você só precisa executar as usermod... instruções e depois reiniciar o sistema, caso contrário não terá efeito
Mariano Ruiz
32

Sucesso para mim

sudo usermod -a -G docker $USER
reboot
shellhub
fonte
4
não há necessidade de reiniciar. Basta sair e entrar novamente. Estou a falar de usermod
Abdennour Toumi
1
No Ubuntu 18.04, tive que reiniciar para que a configuração funcionasse.
Nikhil
1
No Ubuntu 20.04, eu precisava da reinicialização. Fechar sessão não é suficiente.
framontb
Ou execute su $ {USER} em vez de sair
goonerify em
19

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

Urosh T.
fonte
1
Obrigado - observe que, para as imagens atuais do Jenkins Docker, os comandos do docker já estão instalados (e o apt-get não está.) local.
Steve Bonds
1
Salvei minha vida com o problema de identificação de grupo. Obrigado!
lenkovi 16/07
13

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
Ponsuyambu Velladurai
fonte
16
Esta é uma má prática de segurança. A abordagem preferida é essa resposta .
Kevindaub
11

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.

USMAN FAZIL
fonte
Era disso que eu precisava, obrigado!
crazynx 1/07
9

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
Raedwald
fonte
Esta é uma excelente solução abrangente e a única que funcionou para mim ao usar o soquete docker compartilhado com o docker via dockerfile. Deve ser seu próprio post no blog. Obrigado por isso!
Greg Olmstead
Parece que você poderia passar -u jenkins:$(getent group docker | cut -d: -f3)?
Gillespie
Ao passar os argumentos, provavelmente é melhor alterar a seguinte linha: args '-v /var/run/docker.sock:/var/run/docker.sock -u jenkins:docker'ao args '-v /var/run/docker.sock:/var/run/docker.sock -u jenkins:jenkins --group-add docker' passar -u jenkins: docker, você altera o grupo de usuários principal, o que significa que quando o usuário grava um arquivo, digamos na área de trabalho, ele define o arquivo usuário para jenkins e o grupo para janela de encaixe. O que provavelmente não é o que pretendemos.
Nicolas Forney
8

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.

heroína
fonte
Esta é a única solução que não requer um login / login, ou seja, a solução que funciona ao tentar executar isso em um script de shell.
PV
3

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/
Srikant Patra
fonte
2

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.

Camilo Silva
fonte
2

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.

Z3d4s
fonte
2

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"
pham cuong
fonte
2

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

Promise Preston
fonte
1
sudo usermod -a -G docker jenkins
sudo service jenkins restart
Frank Hou
fonte
1

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

Gillespie
fonte
1

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
lakshmikandan
fonte
O `sudo usermod -a -G docker $ USER 'solicitará a senha do jenkins, sem saber qual é a senha do usuário.
3lokh
Eu acho que você deve dar permissão ao sudo para o usuário Jenkins. ou você pode tentar com o seguinte comando no usuário root usermod -a -G docker jenkinsechown jenkins:docker /var/run/docker.sock
lakshmikandan
Você não deve alterar a propriedade do soquete para jenkins. E você deve executar o sudo como qualquer usuário normal que tenha acesso ao sudo, não como jenkins. O que essa resposta adiciona à resposta aceita?
Jim Stewart
1

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
albin
fonte
Não é necessário instalar uma janela de encaixe inteira na imagem de Jenkins, veja minha resposta
deFreitas
1

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
Keshari Nandan
fonte
1

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

sudo chmod 666 /var/run/docker.sock
ruwanmadushanka
fonte
0

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.

java4africa
fonte
0

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
Eslamspot
fonte
0

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

sudo service docker start
Badr Bellaj
fonte
0

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

Fahad
fonte
0

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 
deFreitas
fonte
-6

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

Pelo menos isso resolveu meu problema

Anders K.
fonte
1
Em seguida, você pode obter arquivos sendo criados como usuário root. Pelo menos foi o que aconteceu comigo com o Docker 18.06.1.
Ernst de Haan