Verwenden von SSH-Schlüsseln im Docker-Container

Ich habe eine App, die verschiedene lustige Dinge mit Git ausführt (wie das Ausführen von git clone & git push) und ich versuche, sie zu docken.

Ich stoße jedoch auf ein Problem, bei dem ich dem Container einen SSH-Schlüssel hinzufügen muss, damit der Container-Benutzer ihn verwenden kann.

Ich habe versucht, es zu kopieren /root/.ssh/, zu ändern $HOME, einen Git-SSH-Wrapper zu erstellen, und immer noch kein Glück.

Hier ist die Docker-Datei als Referenz:

#DOCKER-VERSION 0.3.4                                                           

from  ubuntu:12.04                                                              

RUN  apt-get update                                                             
RUN  apt-get install python-software-properties python g++ make git-core openssh-server -y
RUN  add-apt-repository ppa:chris-lea/node.js                                   
RUN  echo "deb http://archive.ubuntu.com/ubuntu precise universe" >> /etc/apt/sources.list
RUN  apt-get update                                                             
RUN  apt-get install nodejs -y                                                  

ADD . /src                                                                       
ADD ../../home/ubuntu/.ssh/id_rsa /root/.ssh/id_rsa                             
RUN   cd /src; npm install                                                      

EXPOSE  808:808                                                                 

CMD   [ "node", "/src/app.js"]

app.js führt die git-Befehle wie aus git pull

Es ist ein schwierigeres Problem, wenn Sie SSH zur Erstellungszeit verwenden müssen. Zum Beispiel, wenn Sie verwenden git cloneoder in meinem Fall pipund npmaus einem privaten Repository herunterladen.

Die Lösung, die ich gefunden habe, besteht darin, Ihre Schlüssel mithilfe des --build-argFlags hinzuzufügen . Anschließend können Sie den neuen experimentellen --squashBefehl (hinzugefügt 1.13) verwenden, um die Ebenen zusammenzuführen, sodass die Schlüssel nach dem Entfernen nicht mehr verfügbar sind. Hier ist meine Lösung:

Befehl erstellen

$ docker build -t example --build-arg ssh_prv_key="$(cat ~/.ssh/id_rsa)" --build-arg ssh_pub_key="$(cat ~/.ssh/id_rsa.pub)" --squash .

Dockerfile

FROM python:3.6-slim

ARG ssh_prv_key
ARG ssh_pub_key

RUN apt-get update && \
    apt-get install -y \
        git \
        openssh-server \
        libmysqlclient-dev

# Authorize SSH Host
RUN mkdir -p /root/.ssh && \
    chmod 0700 /root/.ssh && \
    ssh-keyscan github.com > /root/.ssh/known_hosts

# Add the keys and set permissions
RUN echo "$ssh_prv_key" > /root/.ssh/id_rsa && \
    echo "$ssh_pub_key" > /root/.ssh/id_rsa.pub && \
    chmod 600 /root/.ssh/id_rsa && \
    chmod 600 /root/.ssh/id_rsa.pub

# Avoid cache purge by adding requirements first
ADD ./requirements.txt /app/requirements.txt

WORKDIR /app/

RUN pip install -r requirements.txt

# Remove SSH keys
RUN rm -rf /root/.ssh/

# Add the rest of the files
ADD . .

CMD python manage.py runserver

Update: Wenn Sie Docker 1.13 verwenden und experimentelle Funktionen verwenden, können Sie --squashan den Build-Befehl anhängen, mit dem die Ebenen zusammengeführt, die SSH-Schlüssel entfernt und ausgeblendet werden docker history.

Es stellt sich heraus, dass bei Verwendung von Ubuntu die ssh_config nicht korrekt ist. Sie müssen hinzufügen

RUN  echo "    IdentityFile ~/.ssh/id_rsa" >> /etc/ssh/ssh_config

zu Ihrer Docker-Datei, damit diese Ihren SSH-Schlüssel erkennt.

Hinweis : Verwenden Sie diesen Ansatz nur für Bilder, die privat sind und immer sein werden !

Der SSH-Schlüssel bleibt im Bild gespeichert, auch wenn Sie den Schlüssel nach dem Hinzufügen in einem Ebenenbefehl entfernen (siehe Kommentare in diesem Beitrag ).

In meinem Fall ist das in Ordnung, also benutze ich Folgendes:

# Setup for ssh onto github
RUN mkdir -p /root/.ssh
ADD id_rsa /root/.ssh/id_rsa
RUN chmod 700 /root/.ssh/id_rsa
RUN echo "Host github.com\n\tStrictHostKeyChecking no\n" >> /root/.ssh/config

Wenn Sie Docker Compose verwenden , können Sie den SSH-Agenten einfach so weiterleiten:

something:
    container_name: something
    volumes:
        - $SSH_AUTH_SOCK:/ssh-agent # Forward local machine SSH key to docker
    environment:
        SSH_AUTH_SOCK: /ssh-agent

Erweiterung der Antwort von Peter Grainger Ich konnte den seit Docker 17.05 verfügbaren mehrstufigen Build verwenden . Offizielle Seite besagt:

Bei mehrstufigen Builds verwenden Sie mehrere FROMAnweisungen in Ihrer Docker-Datei. Jeder FROMBefehl kann eine andere Basis verwenden, und jeder von ihnen beginnt eine neue Phase des Builds. Sie können Artefakte selektiv von einer Stufe in eine andere kopieren und alles, was Sie nicht wollen, im endgültigen Bild zurücklassen.

Wenn ich dies hier berücksichtige, ist dies mein Beispiel für die Aufnahme von Dockerfiledrei Erstellungsphasen. Es soll ein Produktionsabbild der Client-Webanwendung erstellen.

# Stage 1: get sources from npm and git over ssh
FROM node:carbon AS sources
ARG SSH_KEY
ARG SSH_KEY_PASSPHRASE
RUN mkdir -p /root/.ssh && \
    chmod 0700 /root/.ssh && \
    ssh-keyscan bitbucket.org > /root/.ssh/known_hosts && \
    echo "${SSH_KEY}" > /root/.ssh/id_rsa && \
    chmod 600 /root/.ssh/id_rsa
WORKDIR /app/
COPY package*.json yarn.lock /app/
RUN eval `ssh-agent -s` && \
    printf "${SSH_KEY_PASSPHRASE}\n" | ssh-add $HOME/.ssh/id_rsa && \
    yarn --pure-lockfile --mutex file --network-concurrency 1 && \
    rm -rf /root/.ssh/

# Stage 2: build minified production code
FROM node:carbon AS production
WORKDIR /app/
COPY --from=sources /app/ /app/
COPY . /app/
RUN yarn build:prod

# Stage 3: include only built production files and host them with Node Express server
FROM node:carbon
WORKDIR /app/
RUN yarn add express
COPY --from=production /app/dist/ /app/dist/
COPY server.js /app/
EXPOSE 33330
CMD ["node", "server.js"]

.dockerignorewiederholt den Inhalt der .gitignoreDatei (verhindert, dass die node_modulesresultierenden distVerzeichnisse des Projekts kopiert werden):

.idea
dist
node_modules
*.log

Befehlsbeispiel zum Erstellen eines Images:

$ docker build -t ezze/geoport:0.6.0 \
  --build-arg SSH_KEY="$(cat ~/.ssh/id_rsa)" \
  --build-arg SSH_KEY_PASSPHRASE="my_super_secret" \
  ./

Wenn Ihr privater SSH-Schlüssel keine Passphrase hat, geben Sie einfach ein leeres SSH_KEY_PASSPHRASEArgument an.

So funktioniert es:

1). Nur in der ersten Phase package.jsonwerden yarn.lockDateien und der private SSH-Schlüssel in das erste benannte Zwischenbild kopiert sources. Um weitere Eingabeaufforderungen für SSH-Schlüssel zu vermeiden, wird diese automatisch hinzugefügt ssh-agent. Schließlich yarninstalliert der Befehl alle erforderlichen Abhängigkeiten von NPM und klont private Git-Repositorys von Bitbucket über SSH.

2). In der zweiten Phase wird der Quellcode der Webanwendung erstellt, minimiert und im distVerzeichnis des nächsten benannten Zwischenabbilds abgelegt production. Beachten Sie, dass der Quellcode der installierten node_modulesDatei aus dem sourcesin der ersten Phase erstellten Image mit der folgenden Zeile kopiert wird:

COPY --from=sources /app/ /app/

Wahrscheinlich könnte es auch die folgende Zeile sein:

COPY --from=sources /app/node_modules/ /app/node_modules/

Wir haben hier nur noch das node_modulesVerzeichnis vom ersten Zwischenbild, nein SSH_KEYund SSH_KEY_PASSPHRASEArgumente mehr. Der gesamte Rest, der für die Erstellung benötigt wird, wird aus unserem Projektverzeichnis kopiert.

3). In der dritten Stufe reduzieren wir die Größe des endgültigen Images, das als gekennzeichnet wird, ezze/geoport:0.6.0indem wir nur das distVerzeichnis des zweiten Zwischenabbilds mit dem Namen einschließen productionund Node Express zum Starten eines Webservers installieren.

Das Auflisten von Bildern ergibt eine Ausgabe wie folgt:

REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
ezze/geoport        0.6.0               8e8809c4e996        3 hours ago         717MB
<none>              <none>              1f6518644324        3 hours ago         1.1GB
<none>              <none>              fa00f1182917        4 hours ago         1.63GB
node                carbon              b87c2ad8344d        4 weeks ago         676MB

Dabei entsprechen nicht markierte Bilder der ersten und der zweiten Zwischenstufe.

Wenn du läufst

$ docker history ezze/geoport:0.6.0 --no-trunc

Sie werden keine Erwähnungen von SSH_KEYund SSH_KEY_PASSPHRASEim endgültigen Bild sehen.

Um Ihren SSH-Schlüssel in einen Container zu injizieren, haben Sie mehrere Lösungen:

1. Wenn Sie eine Docker-Datei mit der ADDAnweisung verwenden, können Sie diese während des Erstellungsprozesses einfügen

2. Einfach so etwas machen cat id_rsa | docker run -i <image> sh -c 'cat > /root/.ssh/id_rsa'

3. Verwenden des docker cpBefehls, mit dem Sie Dateien einfügen können, während ein Container ausgeführt wird.

Eine plattformübergreifende Lösung besteht darin, einen Bind-Mount zu verwenden, um den .sshOrdner des Hosts für den Container freizugeben:

docker run -v /home/<host user>/.ssh:/home/<docker user>/.ssh <image>

Ähnlich wie bei der Agentenweiterleitung werden durch diesen Ansatz die öffentlichen Schlüssel für den Container zugänglich. Ein weiterer Vorteil ist, dass es auch mit einem Nicht-Root-Benutzer funktioniert und Sie mit GitHub verbunden werden. Eine Einschränkung ist jedoch, dass alle Inhalte (einschließlich privater Schlüssel) aus dem .sshOrdner gemeinsam genutzt werden, sodass dieser Ansatz nur für die Entwicklung und nur für vertrauenswürdige Container-Images wünschenswert ist.

Docker-Container sollten als eigene "Dienste" angesehen werden. Um Bedenken zu trennen, sollten Sie Funktionen trennen:

1) Daten sollten sich in einem Datencontainer befinden: Verwenden Sie ein verknüpftes Volume, um das Repo zu klonen. Dieser Datencontainer kann dann mit dem Dienst verknüpft werden, der ihn benötigt.

2) Verwenden Sie einen Container, um die Git-Klonaufgabe auszuführen (dh der einzige Job ist das Klonen), indem Sie den Datencontainer beim Ausführen mit ihm verknüpfen.

3) Gleiches gilt für den SSH-Schlüssel: Legen Sie fest, dass es sich um ein Volume handelt (wie oben vorgeschlagen), und verknüpfen Sie es bei Bedarf mit dem Git-Klon-Dienst

Auf diese Weise sind sowohl die Klonaufgabe als auch der Schlüssel kurzlebig und nur bei Bedarf aktiv.

Wenn Ihre App selbst eine Git-Oberfläche ist, sollten Sie Github- oder Bitbucket-REST-APIs direkt in Betracht ziehen, um Ihre Arbeit zu erledigen: Dafür wurden sie entwickelt.

Diese Zeile ist ein Problem:

ADD ../../home/ubuntu/.ssh/id_rsa /root/.ssh/id_rsa

Wenn Sie die Dateien angeben, die Sie in das Bild kopieren möchten, können Sie nur relative Pfade verwenden - relativ zu dem Verzeichnis, in dem sich Ihre Docker-Datei befindet. Sie sollten stattdessen Folgendes verwenden:

ADD id_rsa /root/.ssh/id_rsa

Legen Sie die Datei id_rsa in demselben Verzeichnis ab, in dem sich Ihre Docker-Datei befindet.

Weitere Informationen finden Sie hier: http://docs.docker.io/reference/builder/#add

Wir hatten ein ähnliches Problem bei der Installation von npm in der Docker-Erstellungszeit.

Inspiriert von der Lösung von Daniel van Flymen und der Kombination mit dem Umschreiben von Git- URLs haben wir eine etwas einfachere Methode zur Authentifizierung der npm-Installation von privaten Github-Repos gefunden - wir haben oauth2-Token anstelle der Schlüssel verwendet.

In unserem Fall wurden die npm-Abhängigkeiten als "git + https://github.com/ ..." angegeben.

Für die Authentifizierung im Container müssen die URLs neu geschrieben werden, damit sie entweder für die SSH-Authentifizierung (ssh: //[email protected]/) oder die Token-Authentifizierung (https: // $ {GITHUB_TOKEN} @ github.com /) geeignet sind.

Build-Befehl:

docker build -t sometag --build-arg GITHUB_TOKEN=$GITHUB_TOKEN . 

Leider bin ich auf Docker 1.9, daher ist die Option --squash noch nicht vorhanden und muss eventuell hinzugefügt werden

Dockerfile:

FROM node:5.10.0

ARG GITHUB_TOKEN

#Install dependencies
COPY package.json ./

# add rewrite rule to authenticate github user
RUN git config --global url."https://${GITHUB_TOKEN}@github.com/".insteadOf "https://github.com/"

RUN npm install

# remove the secret token from the git config file, remember to use --squash option for docker build, when it becomes available in docker 1.13
RUN git config --global --unset url."https://${GITHUB_TOKEN}@github.com/".insteadOf

# Expose the ports that the app uses
EXPOSE 8000

#Copy server and client code
COPY server /server 
COPY clients /clients

Leiten Sie den SSH-Authentifizierungssocket an den Container weiter:

docker run --rm -ti \
        -v $SSH_AUTH_SOCK:/tmp/ssh_auth.sock \
        -e SSH_AUTH_SOCK=/tmp/ssh_auth.sock \
        -w /src \
        my_image

Ihr Skript kann a ausführen git clone.

Extra: Wenn geklonte Dateien zu einem bestimmten Benutzer gehören sollen, müssen Sie sie verwenden, chownda die Verwendung eines anderen Benutzers als root im Container gitfehlschlägt.

Sie können diese Veröffentlichung in der Containerumgebung einige zusätzliche Variablen durchführen:

docker run ...
        -e OWNER_USER=$(id -u) \
        -e OWNER_GROUP=$(id -g) \
        ...

Nachdem Sie geklont haben, müssen Sie ausführen chown $OWNER_USER:$OWNER_GROUP -R <source_folder>, um den richtigen Besitz festzulegen, bevor Sie den Container verlassen, damit ein Nicht-Root-Benutzer außerhalb des Containers auf die Dateien zugreifen kann.

Wie eczajk bereits in Daniel van Flymens Antwort kommentierte, scheint es nicht sicher zu sein, die Schlüssel zu entfernen und zu verwenden --squash, da sie in der Geschichte immer noch sichtbar sind (docker history --no-trunc ).

Stattdessen können Sie mit Docker 18.09 jetzt die Funktion "Geheimnisse erstellen" verwenden. In meinem Fall habe ich ein privates Git-Repo mit dem SSH-Schlüssel meines Hosts mit den folgenden Angaben in meiner Docker-Datei geklont:

# syntax=docker/dockerfile:experimental

[...]

RUN --mount=type=ssh git clone [...]

[...]

Um dies verwenden zu können, müssen Sie das neue BuildKit-Backend aktivieren, bevor Sie Folgendes ausführen können docker build:

export DOCKER_BUILDKIT=1

Und Sie müssen den --ssh defaultParameter hinzufügen docker build.

Weitere Informationen hierzu finden Sie hier: https://medium.com/@tonistiigi/build-secrets-and-ssh-forwarding-in-docker-18-09-ae8161d066

Dieses Problem ist wirklich ärgerlich. Da Sie keine Datei außerhalb des Dockerfile-Kontexts hinzufügen / kopieren können, ist es unmöglich, ~ / .ssh / id_rsa einfach mit /root/.ssh/id_rsa des Bildes zu verknüpfen, und wenn Sie definitiv einen Schlüssel benötigen, um etwas zu tun wie Git-Klon von einem privaten Repo-Link ..., während der Erstellung Ihres Docker-Images.

Wie auch immer, ich habe eine Lösung gefunden, die nicht so überzeugend war, aber für mich funktioniert hat.

1. in Ihrer Docker-Datei:

   • Fügen Sie diese Datei als /root/.ssh/id_rsa hinzu
   • mach was du willst, wie Git Clone, Komponist ...
   • rm /root/.ssh/id_rsa am Ende

2. ein Skript für einen Dreh:

   • cp Ihren Schlüssel zu dem Ordner mit Docker-Datei
   • Docker bauen
   • rm der kopierte Schlüssel

3. Wenn Sie aus diesem Image einen Container mit einigen SSH-Anforderungen ausführen müssen, fügen Sie einfach -v für den Befehl run hinzu, z.

   Docker führen Sie den Befehl -v ~ / .ssh / id_rsa: /root/.ssh/id_rsa --name container image aus

Diese Lösung führt dazu, dass sowohl in Ihrer Projektquelle als auch im erstellten Docker-Image kein privater Schlüssel vorhanden ist.

Ich bin heute auf das gleiche Problem gestoßen und habe die Version mit früheren Beiträgen etwas modifiziert. Ich fand diesen Ansatz für mich nützlicher

docker run -it -v ~/.ssh/id_rsa:/root/.my-key:ro image /bin/bash

(Beachten Sie, dass das schreibgeschützte Flag, damit der Container meinen SSH-Schlüssel auf keinen Fall durcheinander bringt.)

Im Container kann ich jetzt laufen:

ssh-agent bash -c "ssh-add ~/.my-key; git clone <gitrepourl> <target>"

Ich bekomme also nicht den Bad owner or permissions on /root/.ssh/..Fehler, der von @kross notiert wurde

"Sie können Remoteserver selektiv auf Ihren lokalen SSH-Agenten zugreifen lassen, als ob er auf dem Server ausgeführt würde."

https://developer.github.com/guides/using-ssh-agent-forwarding/

Sie können auch Ihr .ssh-Verzeichnis zwischen dem Host und dem Container verknüpfen. Ich weiß nicht, ob diese Methode Auswirkungen auf die Sicherheit hat, aber möglicherweise die einfachste Methode. So etwas sollte funktionieren:

$ sudo docker run -it -v /root/.ssh:/root/.ssh someimage bash

Denken Sie daran, dass Docker mit sudo ausgeführt wird (es sei denn, Sie tun dies nicht). In diesem Fall verwenden Sie die Root-SSH-Schlüssel.

Ausgehend von docker API 1.39+(API-Version docker versionprüfen mit ) Docker-Build ermöglicht das--ssh Option entweder mit einem Agent-Socket oder mit Schlüsseln verwendet werden, damit die Docker Engine SSH-Agentenverbindungen weiterleiten kann.

Build-Befehl

export DOCKER_BUILDKIT=1
docker build --ssh default=~/.ssh/id_rsa .

Dockerfile

# syntax=docker/dockerfile:experimental
FROM python:3.7

# Install ssh client (if required)
RUN apt-get update -qq
RUN apt-get install openssh-client -y

# Download public key for github.com
RUN --mount=type=ssh mkdir -p -m 0600 ~/.ssh && ssh-keyscan github.com >> ~/.ssh/known_hosts

# Clone private repository
RUN --mount=type=ssh git clone [email protected]:myorg/myproject.git myproject

Mehr Info:

• https://docs.docker.com/develop/develop-images/build_enhancements/#using-ssh-to-access-private-data-in-builds
• https://github.com/moby/buildkit/blob/master/frontend/dockerfile/docs/experimental.md#run---mounttypessh

Wenn Sie sich nicht um die Sicherheit Ihrer SSH-Schlüssel kümmern, finden Sie hier viele gute Antworten. Wenn Sie dies tun, war die beste Antwort, die ich gefunden habe, ein Link in einem Kommentar oben zu diesem GitHub-Kommentar von diegocsandrim . Damit andere es eher sehen und für den Fall, dass das Repo jemals verschwindet, hier eine bearbeitete Version dieser Antwort:

Die meisten Lösungen lassen den privaten Schlüssel im Bild. Dies ist schlecht, da jeder, der Zugriff auf das Bild hat, Zugriff auf Ihren privaten Schlüssel hat. Da wissen wir nicht genug über das Verhalten vonsquash , kann dies auch dann der Fall sein, wenn Sie den Schlüssel löschen und diese Ebene quetschen.

Wir generieren eine Pre-Sign-URL für den Zugriff auf den Schlüssel mit aws s3 cli und beschränken den Zugriff für ca. 5 Minuten. Wir speichern diese Pre-Sign-URL in einer Datei im Repo-Verzeichnis und fügen sie dann in der Docker-Datei dem Bild hinzu.

In Dockerfile haben wir einen RUN-Befehl, der alle folgenden Schritte ausführt: Verwenden Sie die Pre-Sing-URL, um den SSH-Schlüssel abzurufen, führen Sie die npm-Installation aus und entfernen Sie den SSH-Schlüssel.

Wenn Sie dies in einem einzigen Befehl tun, wird der SSH-Schlüssel in keiner Ebene gespeichert, aber die Vorzeichen-URL wird gespeichert. Dies ist kein Problem, da die URL nach 5 Minuten nicht mehr gültig ist.

Das Build-Skript sieht folgendermaßen aus:

# build.sh
aws s3 presign s3://my_bucket/my_key --expires-in 300 > ./pre_sign_url
docker build -t my-service .

Dockerfile sieht folgendermaßen aus:

FROM node

COPY . .

RUN eval "$(ssh-agent -s)" && \
    wget -i ./pre_sign_url -q -O - > ./my_key && \
    chmod 700 ./my_key && \
    ssh-add ./my_key && \
    ssh -o StrictHostKeyChecking=no [email protected] || true && \
    npm install --production && \
    rm ./my_key && \
    rm -rf ~/.ssh/*

ENTRYPOINT ["npm", "run"]

CMD ["start"]

In späteren Versionen von Docker (17.05) können Sie mehrstufige Builds verwenden . Dies ist die sicherste Option, da die vorherigen Builds immer nur vom nachfolgenden Build verwendet werden können und dann zerstört werden

Weitere Informationen finden Sie in der Antwort auf meine Frage zum Stapelüberlauf

Eine kurze Übersicht über die Herausforderungen von SSH in Docker-Containern finden Sie hier . Es gibt verschiedene Möglichkeiten, um innerhalb eines Containers eine Verbindung zu vertrauenswürdigen Fernbedienungen herzustellen, ohne Geheimnisse preiszugeben:

• SSH-Agentenweiterleitung (nur Linux, nicht einfach)
• Eingebautes SSH mit BuildKit (experimentell, noch nicht von Compose unterstützt)
• Verwenden einer Bindehalterung , um sie ~/.sshdem Container auszusetzen . (Nur Entwicklung, möglicherweise unsicher)
• Docker Secrets (plattformübergreifend, erhöht die Komplexität)

Darüber hinaus besteht die Möglichkeit, einen Schlüsselspeicher zu verwenden, der in einem separaten Docker-Container ausgeführt wird, auf den zur Laufzeit bei Verwendung von Compose zugegriffen werden kann. Der Nachteil hierbei ist die zusätzliche Komplexität aufgrund der Maschinen, die zum Erstellen und Verwalten eines Schlüsselspeichers wie Vault von HashiCorp erforderlich sind .

Informationen zur Verwendung von SSH-Schlüsseln in einem eigenständigen Docker-Container finden Sie in den oben verlinkten Methoden. Berücksichtigen Sie die jeweiligen Nachteile je nach Ihren spezifischen Anforderungen. Wenn Sie jedoch in Compose ausgeführt werden und zur Laufzeit einen Schlüssel für eine App freigeben möchten (dies spiegelt die praktischen Aspekte des OP wider), versuchen Sie Folgendes:

• Erstellen Sie eine docker-compose.envDatei und fügen Sie sie Ihrer .gitignoreDatei hinzu.
• Aktualisieren Sie Ihre docker-compose.ymlund fügen Sie sie env_filefür den Service hinzu, für den der Schlüssel erforderlich ist.
• Zugriff auf den öffentlichen Schlüssel aus der Umgebung zur Laufzeit der Anwendung, z. B. process.node.DEPLOYER_RSA_PUBKEYim Fall einer Node.js-Anwendung.

Der oben beschriebene Ansatz ist ideal für die Entwicklung und das Testen. Obwohl er die Produktionsanforderungen erfüllen könnte, ist es in der Produktion besser, eine der anderen oben genannten Methoden zu verwenden.

Zusätzliche Ressourcen:

• Docker-Dokumente: Verwenden Sie Bindungs-Mounts
• Docker-Dokumente: Verwalten Sie vertrauliche Daten mit Docker-Geheimnissen
• Stapelüberlauf: Verwenden von SSH-Schlüsseln im Docker-Container
• Stapelüberlauf: Verwenden von ssh-agent mit Docker unter macOS

Sie können einen mehrstufigen Build verwenden, um Container zu erstellen Dies ist der folgende Ansatz: -

Stufe 1 Erstellen eines Bildes mit ssh

FROM ubuntu as sshImage
LABEL stage=sshImage
ARG SSH_PRIVATE_KEY
WORKDIR /root/temp

RUN apt-get update && \
    apt-get install -y git npm 

RUN mkdir /root/.ssh/ &&\
    echo "${SSH_PRIVATE_KEY}" > /root/.ssh/id_rsa &&\
    chmod 600 /root/.ssh/id_rsa &&\
    touch /root/.ssh/known_hosts &&\
    ssh-keyscan github.com >> /root/.ssh/known_hosts

COPY package*.json ./

RUN npm install

RUN cp -R node_modules prod_node_modules

Stufe 2: Bauen Sie Ihren Container

FROM node:10-alpine

RUN mkdir -p /usr/app

WORKDIR /usr/app

COPY ./ ./

COPY --from=sshImage /root/temp/prod_node_modules ./node_modules

EXPOSE 3006

CMD ["npm", "run", "dev"] 

Fügen Sie in Ihrer Erstellungsdatei das env-Attribut hinzu:

   environment:
      - SSH_PRIVATE_KEY=${SSH_PRIVATE_KEY}

Übergeben Sie dann Argumente aus dem Build-Skript wie folgt:

docker-compose build --build-arg SSH_PRIVATE_KEY="$(cat ~/.ssh/id_rsa)"

Und entfernen Sie den Zwischenbehälter aus Sicherheitsgründen. Dies wird Ihnen helfen, zu jubeln.

Ein einfacher und sicherer Weg, dies zu erreichen, ohne Ihren Schlüssel in einer Docker-Bildebene zu speichern oder ssh_agent-Gymnastik zu durchlaufen, ist:

1. DockerfileErstellen Sie als einen Ihrer Schritte ein .sshVerzeichnis, indem Sie Folgendes hinzufügen:

   RUN mkdir -p /root/.ssh

2. Darunter geben Sie an, dass Sie das ssh-Verzeichnis als Volume bereitstellen möchten:

   VOLUME [ "/root/.ssh" ]

3. Stellen Sie sicher, dass Ihr Container ssh_configweiß, wo sich die öffentlichen Schlüssel befinden, indem Sie diese Zeile hinzufügen:

   RUN echo " IdentityFile /root/.ssh/id_rsa" >> /etc/ssh/ssh_config

4. Stellen Sie das .sshVerzeichnis Ihres lokalen Benutzers zur Laufzeit dem Container zur Verfügung:

   docker run -v ~/.ssh:/root/.ssh -it image_name

   Oder dockerCompose.ymlfügen Sie dies unter der Lautstärketaste des Dienstes hinzu:

   - "~/.ssh:/root/.ssh"

Dein Finale Dockerfilesollte etwas enthalten wie:

FROM node:6.9.1

RUN mkdir -p /root/.ssh
RUN  echo "    IdentityFile /root/.ssh/id_rsa" >> /etc/ssh/ssh_config

VOLUME [ "/root/.ssh" ]

EXPOSE 3000

CMD [ "launch" ]

Ich versuche, das Problem anders zu lösen: Hinzufügen eines öffentlichen SSH-Schlüssels zu einem Bild. In meinen Versuchen habe ich jedoch festgestellt, dass "Docker-CP" zum Kopieren von einem Container auf einen Host dient. Punkt 3 in der Antwort von Creak scheint zu sagen, dass Sie Docker CP verwenden können, um Dateien in einen Container zu injizieren. Siehe https://docs.docker.com/engine/reference/commandline/cp/

Auszug

Kopieren Sie Dateien / Ordner aus dem Dateisystem eines Containers in den Hostpfad. Pfade sind relativ zum Stammverzeichnis des Dateisystems.

  Usage: docker cp CONTAINER:PATH HOSTPATH

  Copy files/folders from the PATH to the HOSTPATH

Sie können die autorisierten Schlüssel mithilfe eines freigegebenen Ordners an Ihren Container übergeben und die Berechtigungen mithilfe einer Docker-Datei wie folgt festlegen:

FROM ubuntu:16.04
RUN apt-get install -y openssh-server
RUN mkdir /var/run/sshd
EXPOSE 22
RUN cp /root/auth/id_rsa.pub /root/.ssh/authorized_keys
RUN rm -f /root/auth
RUN chmod 700 /root/.ssh
RUN chmod 400 /root/.ssh/authorized_keys
RUN chown root. /root/.ssh/authorized_keys
CMD /usr/sbin/sshd -D

Und Ihr Docker-Lauf enthält etwa Folgendes, um ein Auth-Verzeichnis auf dem Host (mit den autorisierten Schlüsseln) für den Container freizugeben und dann den SSH-Port zu öffnen, auf den über Port 7001 auf dem Host zugegriffen werden kann.

-d -v /home/thatsme/dockerfiles/auth:/root/auth -–publish=127.0.0.1:7001:22

Möglicherweise möchten Sie sich https://github.com/jpetazzo/nsenter ansehen. Dies scheint eine weitere Möglichkeit zu sein, eine Shell in einem Container zu öffnen und Befehle in einem Container auszuführen.

Zugegeben, zu spät zur Party, wie wäre es damit, wenn die Schlüssel Ihres Host-Betriebssystems im laufenden Betrieb zum Rooten im Container verfügbar werden:

docker run -v ~/.ssh:/mnt -it my_image /bin/bash -c "ln -s /mnt /root/.ssh; ssh [email protected]"

Ich bin nicht dafür, Dockerfile zum Installieren von Schlüsseln zu verwenden, da Iterationen Ihres Containers möglicherweise private Schlüssel zurücklassen.

Sie können Geheimnisse verwenden, um vertrauliche Daten zu verwalten, die ein Container zur Laufzeit benötigt, die Sie jedoch nicht im Image oder in der Quellcodeverwaltung speichern möchten, z.

• Benutzernamen und Passwörter
• TLS-Zertifikate und Schlüssel
• SSH-Schlüssel
• Andere wichtige Daten wie der Name einer Datenbank oder eines internen Servers
• Generische Zeichenfolgen oder binäre Inhalte (bis zu 500 KB groß)

https://docs.docker.com/engine/swarm/secrets/

Ich habe versucht herauszufinden, wie man einem Container Signaturschlüssel hinzufügt, um sie zur Laufzeit zu verwenden (nicht zu erstellen), und bin auf diese Frage gestoßen. Docker-Geheimnisse scheinen die Lösung für meinen Anwendungsfall zu sein, und da es noch niemand erwähnt hat, werde ich es hinzufügen.

In meinem Fall hatte ich ein Problem mit nodejs und 'npm i' aus einem Remote-Repository. Ich habe behoben, dass 'node' user zu nodejs container und 700 zu ~ / .ssh im container hinzugefügt wurde.

Dockerfile:

USER node #added the part
COPY run.sh /usr/local/bin/
CMD ["run.sh"]

run.sh:

#!/bin/bash
chmod 700 -R ~/.ssh/; #added the part

docker-compose.yml:

nodejs:
      build: ./nodejs/10/
      container_name: nodejs
      restart: always
      ports:
        - "3000:3000"
      volumes:
        - ../www/:/var/www/html/:delegated
        - ./ssh:/home/node/.ssh #added the part
      links:
        - mailhog
      networks:
        - work-network

danach hat es angefangen zu funktionieren

Am einfachsten ist es, ein Launchpad-Konto zu erstellen und Folgendes zu verwenden: ssh-import-id

In einem laufenden Docker-Container können Sie ssh-keygen mit der Option docker -i (interaktiv) ausgeben. Dadurch werden die Eingabeaufforderungen des Containers weitergeleitet, um den Schlüssel im Docker-Container zu erstellen.

Für debian / root / authorized_keys:

RUN set -x && apt-get install -y openssh-server

RUN mkdir /var/run/sshd
RUN mkdir -p /root/.ssh
RUN sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config
RUN  echo "ssh-rsa AAAA....yP3w== rsa-key-project01" >> /root/.ssh/authorized_keys
RUN chmod -R go= /root/.ssh