Sono nuovo di docker. Ho appena provato a usare la finestra mobile nella mia macchina locale (Ubuntu 16.04) con Jenkins.

Ho configurato un nuovo lavoro con lo script della pipeline di seguito.

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

Ma fallisce con l'errore di seguito.

L'utente jenkinsdeve essere aggiunto al gruppo docker:

sudo usermod -a -G docker jenkins

Quindi riavviare Jenkins.

modificare

Se si arriva a questa domanda di overflow dello stack perché si riceve questo messaggio dalla finestra mobile, ma non si utilizza jenkins, molto probabilmente l'errore è lo stesso: l'utente non privilegiato non appartiene al gruppo della finestra mobile.

Tu puoi fare:

sudo usermod -a -G docker alice

o qualunque sia il tuo nome utente.

Puoi controllarlo alla fine facendo grep docker /etc/groupe vedere qualcosa del genere:

docker:x:998:alice

in una delle righe.

Quindi modifica l'ID del gruppo di utenti in docker:

newgrp docker

Le mie prime soluzioni sono state:

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

Ma nessuno di loro lavora per me, ho provato:

chmod 777 /var/run/docker.sock

Funziona, ma non so se è la chiamata giusta.

Successo per me

sudo usermod -a -G docker $USER
reboot

2018/08/19

Sono stato bloccato per giorni su questo e poiché non ho trovato una risposta completa con il perché e come, ne posterò uno per altre persone che inciampano sullo stesso problema e le risposte dall'alto non funzionano.

Questi sono i 3 passaggi cruciali quando si esegue Jenkins all'interno della finestra mobile:

1. Montare il socket /var/run/docker.socksul contenitore jenkins per poter utilizzare la finestra mobile dall'host.
2. È necessario installare la finestra mobile all'interno del contenitore per poterlo utilizzare. Questo è un grande e semplice articolo su come farlo. Si noti che le versioni più recenti potrebbero già aver installato la finestra mobile
3. Si esegue sudo usermod -a -G docker jenkinsper aggiungere Jenkins al gruppo finestra mobile. Tuttavia, qui potresti riscontrare un problema di autorizzazione se la finestra mobile host e la finestra mobile contenitore non hanno lo stesso ID gruppo, quindi è molto importante regolare il gid della finestra mobile contenitore in modo che sia uguale al gid della finestra mobile host

Si può fare questo come parte di uno script di lancio o semplicemente utilizzando exece farlo manualmente: groupmod -g <YOUR_HOST_DOCKER_GID> docker.

Inoltre, non modificare le autorizzazioni della /var/run/docker.socka 777 o cose del genere, perché questo è un grosso rischio per la sicurezza, si sono fondamentalmente dando tutti il permesso di utilizzare finestra mobile sulla vostra macchina

Spero che questo ti aiuti

Ho aggiunto l'utente jenkins al gruppo principale e ho riavviato jenkins e ha iniziato a funzionare.

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

Modifica l'autorizzazione di accesso al file docker.sock

chmod 777 /var/run/docker.sock

oppure puoi usare sudo all'inizio del comando.

chmod 777consentirà tutte le azioni per tutti gli utenti mentre chmod 666consentirà a tutti gli utenti di leggere e scrivere ma non è possibile eseguire il file.

Aggiungendo semplicementedocker come gruppo supplementare per l' jenkinsutente

sudo usermod -a -G docker jenkins

non è sempre sufficiente quando si utilizza un'immagine Docker come agente Jenkins . Cioè, se Jenkinsfileinizi con pipeline{agent{dockerfileo pipeline{agent{image:

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

Questo perché Jenkins esegue un docker runcomando, il che comporta tre problemi.

• L'agente (probabilmente) non avrà i programmi Docker installati.
• L'agente non avrà accesso al socket del demone Docker, quindi tenterà di eseguire Docker-in-Docker, che non è raccomandato .
• Jenkins fornisce l'ID utente numerico e l'ID gruppo numerico che l'agente deve utilizzare. L'agente non avrà gruppi supplementari, perché docker runnon effettua un login al contenitore (è più simile a un sudo).

Installazione di Docker per l'agente

Per rendere disponibili i programmi Docker nell'immagine Docker è sufficiente eseguire i passaggi dell'installazione Docker nel file Docker:

# 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

...

Condivisione del socket del demone Docker

Come è stato detto prima , risolvere il secondo problema significa eseguire il contenitore Docker Jenkins in modo che condivida il socket del demone Docker con il demone Docker che si trova all'esterno del contenitore. Quindi devi dire a Jenkins di eseguire il contenitore Docker con quella condivisione, quindi:

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

Impostazione di UID e GID

La soluzione ideale per il terzo problema sarebbe istituire gruppi supplementari per l'agente. Questo non sembra possibile. L'unica correzione di cui sono a conoscenza è l'esecuzione dell'agente con l'UID Jenkins e il GID Docker (il socket ha l'autorizzazione di scrittura di gruppo ed è di proprietà di root.docker). Ma in generale, non si conoscono gli ID (sono stati allocati quando useradd ... jenkinse groupadd ... dockersono stati eseguiti quando Jenkins e Docker sono stati installati sull'host). E non puoi semplicemente dire a Jenkins l'utente jenkinse il gruppo dell'utentedocker

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

perché ciò dice a Docker di usare l'utente e il gruppo che sono nominati jenkinse docker all'interno dell'immagine , e l'immagine Docker probabilmente non ha l' jenkinsutente e il gruppo, e anche se lo facesse non ci sarebbe alcuna garanzia che avrebbe lo stesso UID e GID di l'host, e allo stesso modo non vi è alcuna garanzia che il filedocker GID sia lo stesso

Fortunatamente, Jenkins esegue il docker buildcomando per il tuo Dockerfile in uno script, quindi puoi fare un po 'di magia shell-script per passare attraverso quelle informazioni come argomenti di costruzione Docker:

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

Che utilizza il idcomando per ottenere l' UID e GID del jenkinsutente e lastat comando per ottenere informazioni circa la presa di Docker.

Il tuo Dockerfile può utilizzare queste informazioni per impostare un jenkinsutente e dockerdi gruppo per l'agente, utilizzando 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

Ho Jenkins in esecuzione su Docker e collegato Jenkins sta usando Docker socket dalla macchina host Ubuntu 16.04 tramite volume a /var/run/docker.sock.

Per me la soluzione era:

1) All'interno del contenitore Docker di Jenkins ( docker exec -it jenkins bashsulla macchina host)

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

2) Sulla macchina host:

sudo service docker restart

664 significa: leggi e scrivi (ma non esegui) per il proprietario e gli utenti del gruppo.

Durante la configurazione della produzione ho riscontrato il problema con l'autorizzazione. Ho provato la soluzione seguente per risolvere il problema.

Messaggio di errore

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

Soluzione: autorizzazioni del socket indicate nel messaggio di errore, /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

Dopo aver modificato le autorizzazioni per docket.sock, eseguire il comando seguente per verificare le autorizzazioni.

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/

Nel mio caso, non è stato solo necessario aggiungere l' jenkinsutente al dockergruppo, ma rendere quel gruppo il gruppo principale jenkinsdell'utente.

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

Non dimenticare di ricollegare il nodo slave jenkins o riavviare il server jenkins, a seconda del caso.

2019/02/16

La maggior parte dei passaggi sono stati gli stessi per gli altri scritti dagli altri. Tuttavia, non sono stato in grado di aggiungere jenkins alla finestra mobile del gruppo usando usermod con le soluzioni menzionate.

Ho provato il seguente comando dall'host docker e dal contenitore docker in esecuzione :

sudo usermod -a -G docker jenkins

(Sono entrato nel contenitore della finestra mobile in esecuzione con il seguente comando dall'host della finestra mobile :

docker exec -t -i my_container_id_or_name /bin/bash

)

Ricevuto dall'host docker :

usermod: l'utente 'jenkins' non esiste

Ricevuto dal contenitore docker :

Confidiamo che tu abbia ricevuto la solita lezione dall'amministratore di sistema locale. Di solito si riduce a queste tre cose:

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

[sudo] password per jenkins:

Non conoscevo la password.

Senza la sudoparte del comando, nel contenitore della finestra mobile ho ricevuto:

codice utente: autorizzazione negata. codice utente: impossibile bloccare / etc / passwd; riprovare più tardi.

Soluzione: sono entrato nel contenitore della finestra mobile in esecuzione dall'host della finestra mobile con il seguente comando:

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

Ora, sono entrato come root ed ho dato il seguente comando:

usermod -a -G docker jenkins

Quindi, dall'host docker , ho riavviato il mio contenitore docker in esecuzione con il seguente comando:

docker restart my_container_id_or_name

Successivamente, ho iniziato il lavoro di jenkins e si è concluso con successo.

Ho usato solo l' utente root per emettere il usermodcomando per l'utente jenkins.

2019/05/26

Questo ha funzionato per me!

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

Ho riscontrato un problema simile, che è un problema di autorizzazione e la causa di questo problema è perché il daemon / server Docker funziona sempre come rootutente e vuole che tu prepari sempre il comando docker consudo .

Il daemon Docker si collega a un socket Unix anziché a una porta TCP. Per impostazione predefinita, il socket Unix è di proprietà dell'utente roote gli altri utenti possono accedervi solo tramite sudo.

Per risolvere questo problema, ecco cosa ha funzionato per me:

Innanzitutto, controlla se hai già creato un gruppo docker:

cat /etc/group

Se non lo trovi dockernell'elenco visualizzato, dovrai crearne uno:

sudo groupadd docker

Quindi, conferma tu usere il tuo groupusando il comando qui sotto:

cat /etc/group

Scorri per vedere il gruppo per la finestra mobile. Dovrebbe essere di questo formato

docker:x:140:promisepreston

dov'è il dockermio grouped promiseprestonè il miouser

Ora possiamo aggiungere il tuo utente al gruppo docker

Solo per i file contenitore Docker:

Copia ed esegui il comando qui sotto nel tuo terminale esattamente come viene indicato senza modificarlo in alcun modo, indipendentemente dall'immagine / contenitore / comando docker che si desidera eseguire o che sta tentando di eseguire o sta riscontrando il problema dell'autorizzazione:

sudo usermod -aG docker $USER

Dopo aver eseguito il comando sopra, è necessario disconnettersi e riconnettersi in modo da rivalutare l'appartenenza al gruppo. Tuttavia, su Linux, puoi anche eseguire il comando seguente per attivare le modifiche ai gruppi ( Copia ed esegui il comando di seguito nel tuo terminale esattamente come è stato dichiarato senza modificarlo in alcun modo, indipendentemente dall'immagine docker / contenitore / comando che si desidera eseguire o si sta tentando di eseguire o sta riscontrando il problema di autorizzazione ):

newgrp docker 

Ora puoi verificare che puoi eseguire i comandi docker senza le autorizzazioni sudo, eseguendo nuovamente il comando che causa nuovamente il problema delle autorizzazioni, ad esempio ( Sostituisci my-commandcon il nome dell'immagine / contenitore / comando ):

docker run my-command

Per file Docker e file system locale:

Se hai una copia dei file sul tuo filesystem locale, puoi cambiare la proprietà della directory dell'applicazione in cui sono memorizzati i file dell'applicazione, usando questo formato:

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

Quindi nel mio caso sarà:

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

Nota: eseguire questo comando nella directory principale che contiene la directory dell'applicazione.

È tutto.

Spero che aiuti

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

Sto facendo funzionare Jenkins in un container mobile. La soluzione più semplice per me era creare un'immagine personalizzata che imposta dinamicamente il GID, come:

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

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

In alternativa, puoi avviare jenkins con le seguenti opzioni:

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

Ciò presuppone che nell'immagine jenkins sia installato il client docker. Vedi: https://getintodevops.com/blog/the-simple-way-to-run-docker-in-docker-for-ci

Se potresti ricevere errori come di seguito,

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"

Prova a eseguire i seguenti comandi,

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

Sto usando l' immagine docker ufficiale di jenkins ( https://hub.docker.com/r/jenkins/jenkins ) ma penso che questa soluzione sia applicabile alla maggior parte dei casi d'uso in cui vogliamo far funzionare Docker all'interno di un contenitore Docker.

Il modo raccomandato per usare Docker all'interno di un container Docker è usare il Deamon Docker del sistema host. Buon articolo a riguardo: https://itnext.io/docker-in-docker-521958d34efd .

Il segreto per gestire il problema delle autorizzazioni, di cui si tratta questa domanda, è quello di aggiungere autorizzazioni per l'utente del contenitore all'interno del contenitore, non per il sistema host . Solo l'utente root ha le autorizzazioni per farlo per impostazione predefinita, quindi

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

lo farà. Ricorda di riavviare il contenitore.

Immagino che il modo più semplice per raggiungere questo obiettivo sia quello di creare un Dockerfile personalizzato:

# 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 qualcuno sta ancora affrontando il problema sul proprio computer locale (Ubuntu), prova sotto il comando:

sudo chmod 666 /var/run/docker.sock

Nel mio caso questo funzionerà correttamente. navigare nel repository locale e immettere questo comando.

sudo chmod 666 /var/run/docker.sock

Sul server su cui è in esecuzione Jenkins, l'ho usato

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

E quindi eseguire ogni contenitore finestra mobile con

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

L'uso di setfacl sembra un'opzione migliore e non è necessario "utente -u". I contenitori vengono quindi eseguiti come lo stesso utente che esegue Jenkins. Gradirei comunque qualsiasi feedback dagli esperti di sicurezza.

utilizzare sotto il file docker

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

nel mio caso era appena stato avviato il servizio docker:

sudo service docker start

spesso è necessario riavviare per rendere effettivi il nuovo gruppo utenti e l'utente.

Se stai eseguendo Jenkins all'interno di un contenitore docker e Jenkins si collega alla finestra mobile host, puoi risolverlo semplicemente tramite il file Docker di seguito:

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

Forse dovresti eseguire la finestra mobile con l'opzione "-u root" fin dall'inizio

Almeno questo ha risolto il mio problema