Jestem nowy w dockerze. Właśnie próbowałem użyć Dockera na moim lokalnym komputerze (Ubuntu 16.04) z Jenkinsem.

Skonfigurowałem nowe zadanie z poniższym skryptem potoku.

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

Ale kończy się niepowodzeniem z poniższym błędem.

Użytkownik jenkinsmusi zostać dodany do grupy docker:

sudo usermod -a -G docker jenkins

Następnie uruchom ponownie Jenkins.

Edytować

Jeśli dojdziesz do pytania o przepełnienie stosu, ponieważ otrzymujesz tę wiadomość od dockera, ale nie używasz jenkins, najprawdopodobniej błąd jest ten sam: twój nieuprzywilejowany użytkownik nie należy do grupy docker.

Możesz to zrobić:

sudo usermod -a -G docker alice

lub jakakolwiek jest twoja nazwa użytkownika.

Możesz to sprawdzić na końcu robiąc grep docker /etc/groupi zobaczyć coś takiego:

docker:x:998:alice

w jednej z linii.

Następnie zmień identyfikator grupy użytkowników na docker:

newgrp docker

Moje pierwsze rozwiązania to:

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

Ale żaden z nich nie działa dla mnie, próbowałem:

chmod 777 /var/run/docker.sock

To działa, ale nie wiem, czy to właściwe połączenie.

Sukces dla mnie

sudo usermod -a -G docker $USER
reboot

2018-08-19

Utknąłem na tym od wielu dni i ponieważ nie znalazłem pełnej odpowiedzi z wyjaśnieniem, dlaczego i jak, opublikuję jedną dla innych osób, które natkną się na ten sam problem, a odpowiedzi z góry nie działają.

Oto 3 kluczowe kroki podczas uruchamiania Jenkinsa w dockerze:

1. /var/run/docker.sockMontujesz gniazdo do kontenera Jenkinsa, aby móc korzystać z dockera z hosta.
2. Aby móc z niego korzystać, musisz zainstalować docker wewnątrz kontenera. To świetny i prosty artykuł o tym, jak to zrobić. Zauważ, że nowsze wersje mogą już mieć zainstalowany docker
3. Uruchomić sudo usermod -a -G docker jenkins, aby dodać Jenkins do grupy Döcker. Jednak w tym miejscu możesz napotkać problem z uprawnieniami, jeśli okno dokowane hosta i okno dokowane kontenera nie mają tego samego identyfikatora grupy, więc bardzo ważne jest, aby dostosować gid kontenera, aby był taki sam jak gid dokera hosta

Można to zrobić jako część skryptu uruchamiania lub po prostu za pomocą execi robi to ręcznie: groupmod -g <YOUR_HOST_DOCKER_GID> docker.

Ponadto, nie należy zmieniać uprawnienia Spośród /var/run/docker.sock777 lub takich rzeczach, bo to jest poważne zagrożenie bezpieczeństwa, to w zasadzie dając każdemu pozwolenie na używanie dokowanym na komputerze

Mam nadzieję że to pomoże

Dodałem użytkownika jenkins do grupy root i zrestartowałem jenkins i zaczęło działać.

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

Zmień uprawnienia dostępu do pliku docker.sock

chmod 777 /var/run/docker.sock

lub możesz użyć sudona początku polecenia.

chmod 777zezwoli na wszystkie akcje wszystkim użytkownikom, a wszystkim użytkownikom chmod 666pozwoli na odczyt i zapis, ale nie będzie mógł wykonać pliku.

Po prostu dodaj dockerjako dodatkową grupę dla jenkinsużytkownika

sudo usermod -a -G docker jenkins

nie zawsze wystarcza, gdy używasz obrazu Dockera jako agenta Jenkinsa . To znaczy, jeśli Jenkinsfilezaczynasz od pipeline{agent{dockerfilelub pipeline{agent{image:

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

Dzieje się tak, ponieważ Jenkins wykonuje docker runpolecenie, co powoduje trzy problemy.

• Agent (prawdopodobnie) nie będzie miał zainstalowanych programów Docker.
• Agent nie będzie miał dostępu do gniazda demona Dockera, więc spróbuje uruchomić Docker-in-Docker, co nie jest zalecane .
• Jenkins podaje numeryczny identyfikator użytkownika i numeryczny identyfikator grupy, których agent powinien używać. Agent nie będzie miał żadnych dodatkowych grup, ponieważ docker runnie będzie logował się do kontenera (to bardziej jak a sudo).

Instalowanie Dockera dla agenta

Udostępnienie programów platformy Docker w obrazie platformy Docker wymaga po prostu wykonania kroków instalacji platformy Docker w pliku 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

...

Udostępnianie gniazda demona platformy Docker

Jak wspomniano wcześniej , naprawienie drugiego problemu oznacza uruchomienie kontenera Jenkins Docker, tak aby współdzielił gniazdo demona Dockera z demonem Dockera znajdującym się poza kontenerem. Musisz więc powiedzieć Jenkinsowi, aby uruchomił kontener Docker z tym udostępnianiem, w ten sposób:

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

Ustawianie identyfikatorów UID i GID

Idealnym rozwiązaniem trzeciego problemu byłoby utworzenie dodatkowych grup dla Agenta. Wydaje się to niemożliwe. Jedyną znaną mi poprawką jest uruchomienie agenta z UID Jenkinsa i Docker GID (gniazdo ma uprawnienia do zapisu grupowego i jest własnością root.docker). Ale ogólnie rzecz biorąc, nie wiesz, jakie są te identyfikatory (zostały przydzielone, gdy useradd ... jenkinsi groupadd ... dockeruruchomiono, gdy Jenkins i Docker zostały zainstalowane na hoście). I nie możesz po prostu powiedzieć Jenkinsowi użytkownikowi jenkinsi grupiedocker

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

dlatego, że opowiada Döcker używać użytkowników i grup, które są o nazwie jenkinsi docker na obrazie , a Docker obraz prawdopodobnie nie ma jenkinsużytkowników i grup, a nawet jeśli tak nie byłoby gwarancji, że to mają takie same UID i GID jako hosta i podobnie nie ma gwarancji, że dockerGID jest taki sam

Na szczęście Jenkins uruchamia docker buildpolecenie dla twojego pliku Dockerfile w skrypcie, więc możesz wykonać magię skryptu powłoki, aby przekazać te informacje jako argumenty kompilacji Dockera:

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

Który korzysta z idkomendy, aby uzyskać UID i GID z jenkinsużytkownikiem i statpolecenia, aby uzyskać informacje na temat gniazda Docker.

Twój Dockerfile mogą wykorzystać te informacje do konfiguracji z jenkinsużytkownikiem i dockergrupy dla agenta, używając groupadd, groupmodi 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

Mam Jenkins działający w Dockerze i podłączony Jenkins używa gniazda Docker z komputera hosta Ubuntu 16.04 przez wolumin do /var/run/docker.sock.

Dla mnie rozwiązaniem było:

1) Wewnątrz kontenera Docker Jenkinsa ( docker exec -it jenkins bashna maszynie hosta)

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

2) Na komputerze głównym:

sudo service docker restart

664 oznacza - czytać i pisać (ale nie wykonywać) dla właściciela i użytkowników z grupy.

Podczas konfigurowania produkcji wystąpił problem z uprawnieniami, wypróbowałem poniższe rozwiązanie, aby rozwiązać problem.

Komunikat o błędzie

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

Rozwiązanie: uprawnienia gniazda wskazane w komunikacie o błędzie, /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

Po zmianie uprawnień dla docket.sock wykonaj poniższe polecenie, aby sprawdzić uprawnienia.

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/

W moim przypadku konieczne było nie tylko dodanie jenkinsużytkownika do dockergrupy, ale uczynienie z tej grupy podstawowej grupy jenkinsużytkownika.

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

Nie zapomnij o ponownym podłączeniu węzła jenkins slave lub zrestartowaniu serwera jenkins, w zależności od przypadku.

2019-02-16

Większość kroków była dla mnie taka sama, jak napisali inni. Nie udało mi się jednak dodać jenkinsa do grupy docker przy użyciu usermod z wymienionymi rozwiązaniami.

Wypróbowałem następujące polecenie z hosta platformy Docker iz uruchomionego kontenera platformy Docker :

sudo usermod -a -G docker jenkins

(Wszedłem do uruchomionego kontenera docker za pomocą następującego polecenia z hosta dockera :

docker exec -t -i my_container_id_or_name /bin/bash

)

Odebrane od hosta dockera :

usermod: użytkownik „jenkins” nie istnieje

Odebrane z kontenera dockera :

Ufamy, że otrzymałeś zwykły wykład od lokalnego administratora systemu. Zwykle sprowadza się do tych trzech rzeczy:

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

[sudo] hasło do jenkinsa:

Nie znałem hasła.

Bez sudoczęści polecenia w kontenerze docker otrzymałem:

usermod: Odmowa pozwolenia. usermod: nie można zablokować / etc / passwd; Spróbuj ponownie później.

Rozwiązanie: Wszedłem do uruchomiony pojemnika Döcker z hostem Döcker za pomocą następującego polecenia:

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

Teraz wszedłem jako root i wydałem następujące polecenie:

usermod -a -G docker jenkins

Następnie z hosta dockera zrestartowałem mój działający kontener docker za pomocą następującego polecenia:

docker restart my_container_id_or_name

Potem zacząłem pracę u Jenkinsa i zakończyła się sukcesem.

Użyłem użytkownika root tylko do wydania usermodpolecenia dla użytkownika jenkins.

2019-05-26

To zadziałało dla mnie!

Przykład 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"

Napotkałem podobny problem, który jest problemem z uprawnieniami, a przyczyną tego problemu jest to, że demon / serwer Docker zawsze działa jako rootużytkownik i chce, abyś zawsze poprzedzał polecenie docker sudo.

Demon Dockera wiąże się z gniazdem Unix zamiast portu TCP. Domyślnie to gniazdo Unix jest własnością użytkownika, roota inni użytkownicy mogą uzyskać do niego dostęp tylko za pomocą sudo.

Aby to naprawić, oto co zadziałało dla mnie:

Najpierw sprawdź, czy masz już utworzoną grupę docker:

cat /etc/group

Jeśli nie znajdziesz dockerna wyświetlonej liście, musisz ją utworzyć:

sudo groupadd docker

Następnie potwierdź swoje useri swoje, groupużywając poniższego polecenia:

cat /etc/group

Przewiń, aby zobaczyć grupę dla Dockera. Powinien mieć ten format

docker:x:140:promisepreston

gdzie dockerjest mój groupi promiseprestonjest mójuser

Teraz możemy dodać użytkownika do grupy docker

Tylko dla plików kontenerów platformy Docker:

Skopiuj i uruchom poniższe polecenie w swoim terminalu dokładnie tak, jak jest podane, bez modyfikowania go w żaden sposób, niezależnie od obrazu / kontenera / polecenia dockera, które chcesz uruchomić lub próbujesz uruchomić, lub jest to przypadek problemu z uprawnieniami:

sudo usermod -aG docker $USER

Po uruchomieniu powyższego polecenia musisz się wylogować i zalogować ponownie, aby ponownie ocenić członkostwo w grupie. Jednak w systemie Linux możesz również uruchomić następujące polecenie poniżej, aby aktywować zmiany w grupach ( Skopiuj i uruchom poniższe polecenie w terminalu dokładnie tak, jak jest podane, bez modyfikowania go w żaden sposób, niezależnie od obrazu / kontenera / polecenia dockera, które chcesz uruchomić lub próbujesz uruchomić, lub jest przyczyną problemu z uprawnieniami ):

newgrp docker 

Możesz teraz sprawdzić, czy możesz uruchamiać polecenia dockera bez uprawnień sudo, uruchamiając ponownie polecenie, które powoduje problem z uprawnieniami, powiedzmy ( Zastąp my-commandnazwą obrazu / kontenera / polecenia ):

docker run my-command

W przypadku plików Dockera i lokalnego systemu plików:

Jeśli masz kopię plików w lokalnym systemie plików, możesz zmienić prawo własności do katalogu aplikacji, w którym przechowywane są pliki aplikacji, używając następującego formatu:

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

Więc w moim przypadku będzie to:

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

Uwaga: uruchom to polecenie w katalogu nadrzędnym, w którym znajduje się katalog aplikacji.

To wszystko.

mam nadzieję, że to pomoże

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

Uruchamiam Jenkinsa w kontenerze Dockera. Najprostszym rozwiązaniem dla mnie było stworzenie niestandardowego obrazu, który dynamicznie ustawia GID, na przykład:

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

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

Alternatywnie możesz uruchomić jenkins z następującymi opcjami:

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

Zakłada się, że obraz Jenkins ma zainstalowanego klienta Docker. Zobacz: https://getintodevops.com/blog/the-simple-way-to-run-docker-in-docker-for-ci

Jeśli możesz otrzymać błędy takie jak poniżej,

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

lub

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"

Po prostu spróbuj wykonać następujące polecenia,

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

Używam oficjalnego obrazu Dockera Jenkinsa ( https://hub.docker.com/r/jenkins/jenkins ), ale myślę, że to rozwiązanie ma zastosowanie w większości przypadków użycia, w których chcemy uruchomić .

Zalecanym sposobem używania Dockera w kontenerze Docker jest użycie demona Dockera systemu hosta. Dobry artykuł na ten temat: https://itnext.io/docker-in-docker-521958d34efd .

Sekretem rozwiązania problemu uprawnień, którego dotyczy to pytanie, jest dodanie uprawnień dla użytkownika kontenera wewnątrz kontenera, a nie dla systemu hosta . Tylko użytkownik root ma do tego uprawnienia domyślnie, więc

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

zrobię to. Pamiętaj, aby ponownie uruchomić kontener.

Myślę, że najprostszym sposobem osiągnięcia tego jest utworzenie dostosowanego pliku Dockerfile:

# 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

Jeśli ktoś nadal napotyka problem na swoim komputerze lokalnym (Ubuntu), wypróbuj poniższe polecenie:

sudo chmod 666 /var/run/docker.sock

W moim przypadku to zadziała. przejdź do lokalnego repozytorium i wprowadź to polecenie.

sudo chmod 666 /var/run/docker.sock

Na serwerze, na którym działa Jenkins, użyłem

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

Następnie uruchom każdy kontener Dockera z

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

Używanie setfacl wydaje się lepszą opcją i nie jest potrzebne żadne "-u user". Kontenery są następnie uruchamiane jako ten sam użytkownik, na którym działa Jenkins. Byłbym jednak wdzięczny za wszelkie uwagi od ekspertów ds. Bezpieczeństwa.

użyj poniżej pliku 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

w moim przypadku był to dopiero start usługi dockera:

sudo service docker start

często konieczne jest ponowne uruchomienie, aby zastosować nową grupę użytkowników i użytkownika.

Jeśli używasz Jenkinsa w kontenerze dockera, a Twój Jenkins łączy się z dokerem hosta, możesz to naprawić za pomocą poniższego pliku Dockerfile:

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

Może powinieneś uruchomić docker od samego początku z opcją "-u root"

Przynajmniej to rozwiązało mój problem