it-swarm.com.de

Verwenden von SSH-Schlüsseln im Docker-Container

Ich habe eine App, die verschiedene lustige Sachen mit Git ausführt (wie z. B. git clone & git Push ausführen), und ich versuche, es zu andocken.

Ich habe jedoch ein Problem, bei dem ich in der Lage sein muss, dem Container einen SSH-Schlüssel hinzuzufügen, den der Container "user" verwenden kann.

Ich habe versucht, es in /root/.ssh/ zu kopieren, $HOME zu ändern, einen git ssh-Wrapper zu erstellen und trotzdem kein Glück. 

Hier ist das Dockerfile 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 git pull aus.

232
ebensing

Bei der Verwendung von Ubuntu stellt sich heraus, dass ssh_config nicht korrekt ist. Sie müssen hinzufügen 

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

zu Ihrem Dockerfile, damit es Ihren SSH-Schlüssel erkennt.

77
ebensing

Es ist ein schwierigeres Problem, wenn Sie zum Erstellungszeitpunkt SSH verwenden müssen. Zum Beispiel, wenn Sie git clone verwenden oder in meinem Fall pip und npm, um sie aus einem privaten Repository herunterzuladen.

Die Lösung, die ich gefunden habe, besteht darin, Ihre Schlüssel mit dem Flag --build-arg hinzuzufügen. Dann können Sie den neuen experimentellen --squash-Befehl (hinzugefügt 1.13) verwenden, um die Ebenen so zusammenzuführen, dass 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 --squash an den Build-Befehl anhängen, der die Ebenen zusammenführt, die SSH-Schlüssel entfernt und sie vor docker history versteckt.

79

Note: Verwenden Sie diesen Ansatz nur für Bilder, die private sind und immer sind!

Der ssh-Schlüssel bleibt im Bild gespeichert, auch wenn Sie den Schlüssel in einem Ebenenbefehl entfernen, nachdem Sie ihn hinzugefügt haben (siehe Kommentare in diesem Beitrag ).

In meinem Fall ist das ok, also verwende ich:

# 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
71
yellowcap

Wenn Sie docker compose verwenden, können Sie den SSH-Agenten wie folgt weiterleiten:

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

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

  1. Wenn Sie eine Docker-Datei mit der Anweisung ADD verwenden, können Sie sie während des Build-Prozesses einfügen

  2. Mach einfach etwas wie cat id_rsa | docker run -i <image> sh -c 'cat > /root/.ssh/id_rsa'

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

39
creack

Erweiterung Peter Graingers Antwort Ich konnte mehrstufiges Build verwenden verfügbar seit Docker 17.05. Offizielle Seite heißt:

Bei mehrstufigen Builds verwenden Sie mehrere FROM-Anweisungen in Ihrer Dockerfile. Jede FROM-Anweisung kann eine andere Basis verwenden, und jede von ihnen beginnt eine neue Stufe des Builds. Sie können Artefakte selektiv von einer Stufe zur nächsten kopieren und alles hinterlassen, was Sie im endgültigen Bild nicht möchten.

Dies zu berücksichtigen, ist mein Beispiel für Dockerfile, das drei Aufbaustufen enthält. Es soll ein Produktionsabbild einer 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"]

.dockerignore wiederholt den Inhalt der .gitignore-Datei (es verhindert, dass node_modules und die daraus resultierenden dist-Verzeichnisse 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 enthält, geben Sie einfach das leere SSH_KEY_PASSPHRASE-Argument an.

So funktioniert es:

1). In der ersten Stufe werden nur package.json-, yarn.lock-Dateien und der private SSH-Schlüssel in das erste Zwischenabbild mit dem Namen sources kopiert. Um weitere Aufforderungen zur Eingabe der SSH-Schlüssel zu vermeiden, werden diese automatisch zu ssh-agent hinzugefügt. Schließlich installiert der Befehl yarn alle erforderlichen Abhängigkeiten von NPM und die privaten Git-Repositorys von Bitbucket über SSH.

2). In der zweiten Stufe wird der Quellcode der Webanwendung erstellt und minimiert und im dist-Verzeichnis des nächsten Zwischenimages mit dem Namen production abgelegt. Beachten Sie, dass der Quellcode des installierten node_modules aus dem Image namens sources kopiert wird, das auf der ersten Stufe mit dieser Zeile erzeugt wird:

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

Wahrscheinlich könnte es auch folgende Zeile sein:

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

Wir haben hier nur node_modules-Verzeichnis vom ersten Zwischenbild, keine SSH_KEY- und SSH_KEY_PASSPHRASE-Argumente mehr. Der gesamte Rest, der für Build benötigt wird, wird aus unserem Projektverzeichnis kopiert.

3). Auf der dritten Stufe reduzieren wir die Größe des endgültigen Images, das als ezze/geoport:0.6.0 markiert wird, indem wir nur das dist-Verzeichnis aus dem zweiten Zwischenimage mit dem Namen production einschließen und Node Express zum Starten eines Webservers installieren.

Wenn Sie Bilder anzeigen, erhalten Sie eine Ausgabe wie diese:

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 gekennzeichnete Bilder der ersten und der zweiten Zwischenbaustufe.

Wenn du läufst

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

im endgültigen Bild werden keine Erwähnungen von SSH_KEY und SSH_KEY_PASSPHRASE angezeigt.

26
Ezze

Diese Zeile ist ein Problem:

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

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

ADD id_rsa /root/.ssh/id_rsa

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

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

15
Dan Keder

Docker-Container sollten als eigene Dienste betrachtet werden. Um Bedenken zu trennen, sollten Sie die Funktionalitäten 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-Klon-Task auszuführen (d. H., Es ist nur der Job, der geklont wird), indem Sie den Daten-Container beim Ausführen damit verknüpfen.

3) Das Gleiche gilt für den ssh-key: Setzen Sie ein Volume (wie oben vorgeschlagen) und verknüpfen Sie es mit dem Git-Clone-Dienst, wenn Sie ihn benötigen

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

Wenn es sich bei Ihrer App selbst um eine git-Schnittstelle handelt, sollten Sie die APIs github oder bitbucket REST direkt für Ihre Arbeit in Betracht ziehen. Dafür wurden sie entwickelt.

13
MrE

Wir hatten ein ähnliches Problem bei der npm-Installation in der Docker-Build-Zeit.

Inspiriert von der Lösung von Daniel van Flymen und der Kombination mit git url rewrite , fanden wir eine etwas einfachere Methode für die Authentifizierung von npm install aus privaten Github-Repos. Statt der Schlüssel verwendeten wir oauth2-Tokens.

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

Für die Authentifizierung in Containern müssen die URLs umgeschrieben werden, damit sie entweder für die ssh-Authentifizierung (ssh: //[email protected]/) oder für die Tokenauthentifizierung (https: // $ {GITHUB_TOKEN} @ github.com/geeignet ist. 

Befehl erstellen:

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

Leider bin ich auf Docker 1.9, also ist die Option -squash noch nicht vorhanden, eventuell muss sie 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
11
Markko Paas

Diese Ausgabe ist wirklich nervig. Da Sie keine Datei außerhalb des Dockerfile-Kontexts hinzufügen oder kopieren können, ist es unmöglich, ~/.ssh/id_rsa nur mit /root/.ssh/id_rsa des Images zu verknüpfen wie git clone von einem privaten Repo-Link ..., während Sie Ihr Docker-Image erstellen.

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

  1. in deiner dockerfile:

    • fügen Sie diese Datei als /root/.ssh/id_rsa hinzu
    • tun, was Sie wollen, wie Git Klon, Komponist ...
    • rm /root/.ssh/id_rsa am Ende
  2. ein Skript, das Sie in einem Dreh machen können:

    • cp Ihren Schlüssel zum Ordner mit der Docker-Datei
    • docker bauen
    • rm den kopierten Schlüssel
  3. immer wenn Sie einen Container von diesem Image aus mit einigen ssh-Anforderungen ausführen müssen, fügen Sie einfach -v für den run-Befehl hinzu:

    docker-Befehl -v ~/.ssh/id_rsa: /root/.ssh/id_rsa --name Container-Imagebefehl

Diese Lösung führt dazu, dass sowohl in der Projektquelle als auch im integrierten Docker-Image kein privater Schlüssel vorhanden ist, sodass sich keine Sicherheitslücken mehr ergeben.

10
ImLeo

Leiten Sie das SSH-Authentifizierungs-Socket 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 einen git clone ausführen.

Zusatz: Wenn Sie möchten, dass geklonte Dateien zu einem bestimmten Benutzer gehören, müssen Sie chown verwenden, da die Verwendung eines anderen Benutzers als root im Container git fehlschlägt.

Sie können diese Veröffentlichung in der Umgebung des Containers mit einigen zusätzlichen Variablen durchführen:

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

Nach dem Klonen müssen Sie chown $OWNER_USER:$OWNER_GROUP -R <source_folder> ausführen, um den richtigen Besitz festzulegen, bevor Sie den Container verlassen, sodass die Dateien für einen Benutzer ohne Rootberechtigung außerhalb des Containers zugänglich sind.

8
edupo

'Sie können Remote-Servern selektiv Zugriff auf Ihren lokalen SSH-Agenten erlauben, als ob sie auf dem Server laufen würden'

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

7
arreche

Eine Lösung besteht darin, die SSH-Schlüssel von Host mit folgenden Optionen in das Andockfenster einzuhängen:

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

Ähnlich der obigen Lösung. Funktioniert aber mit einem Benutzer ohne Rootberechtigung. Arbeite perfekt mit Github.

6
Mohammad Azim

Sie können auch das .ssh-Verzeichnis zwischen dem Host und dem Container verknüpfen. Ich weiß nicht, ob diese Methode Auswirkungen auf die Sicherheit hat, aber es ist 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 (sofern Sie dies nicht tun). Wenn dies der Fall ist, verwenden Sie die Root-SSH-Schlüssel.

6
Luis Elizondo

Ich bin heute auf das gleiche Problem gestoßen und etwas modifizierte Version mit vorherigen Posts fand ich 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 Readonly-Flag auf jeden Fall meinen ssh-Schlüssel nicht durcheinander bringt.)

Im Container kann ich jetzt laufen:

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

Ich bekomme also nicht diesen Bad owner or permissions on /root/.ssh/..-Fehler, den @kross bemerkt hat

5
tojo

Wie eczajk bereits in Daniel van Flymens Antwort kommentiert hat, scheint es nicht sicher zu sein, die Schlüssel zu entfernen und --squash zu verwenden, da sie im Verlauf weiterhin sichtbar sind (docker history --no-trunc).

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

# syntax=docker/dockerfile:experimental

[...]

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

[...]

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

export DOCKER_BUILDKIT=1

Und Sie müssen den Parameter --ssh default zu docker build hinzufügen.

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

2
frsc

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

Siehe die Antwort auf meine Stackoverflow-Frage für weitere Informationen

1
Peter Grainger

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

Ihr Docker-Lauf enthält ungefähr das Folgende, um ein Auth-Verzeichnis auf dem Host (mit den Authorized_keys) für den Container freizugeben, und dann den SSH-Port zu öffnen, auf den über Port 7001 des Host zugegriffen werden kann.

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

Vielleicht möchten Sie unter https://github.com/jpetazzo/nsenter nachsehen. Dies scheint eine andere Möglichkeit zu sein, eine Shell in einem Container zu öffnen und Befehle innerhalb eines Containers auszuführen.

1
andrew pate

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

Bei den meisten Lösungen bleibt der private Schlüssel im Bild. Dies ist schlecht, da jeder, der Zugriff auf das Image hat, Zugriff auf Ihren privaten Schlüssel hat. Da wir nicht genug über das Verhalten von squash wissen, kann dies auch dann der Fall sein, wenn Sie den Schlüssel löschen und die betreffende Ebene quetschen.

Wir generieren eine Vorzeichen-URL, um auf den Schlüssel mit aws s3 cli zuzugreifen, und beschränken den Zugriff für etwa 5 Minuten. Wir speichern diese Vorzeichen-URL in einer Datei im Repo-Verzeichnis und fügen sie in der Docker-Datei zum Bild hinzu.

In dockerfile haben wir einen RUN-Befehl, der alle diese Schritte ausführt: Verwenden Sie die pre-sing-URL, um den ssh-Schlüssel abzurufen, führen Sie npm install aus und entfernen Sie den ssh-Schlüssel.

Wenn Sie dies in einem einzigen Befehl ausführen, wird der ssh-Schlüssel nicht in einer beliebigen Ebene gespeichert. Die Vorzeichen-URL wird jedoch gespeichert. Dies ist kein Problem, da die URL nach 5 Minuten nicht 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 so 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"]
1
Sam H.

Ich versuche, das Problem anders zu bearbeiten: Hinzufügen eines öffentlichen SSH-Schlüssels zu einem Bild. In meinen Versuchen entdeckte ich jedoch, dass "docker cp" zum Kopieren von FROM-Containern 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 Host-Pfad . Pfade sind relativ zum Stamm des Dateisystems.

  Usage: docker cp CONTAINER:PATH HOSTPATH

  Copy files/folders from the PATH to the HOSTPATH
1
EricGreg

Eine einfache und sichere Möglichkeit, dies zu erreichen, ohne Ihren Schlüssel in einer Docker-Image-Ebene zu speichern oder ssh_agent-Gymnastik zu absolvieren, ist:

  1. Erstellen Sie als einen der Schritte in Ihrer Dockerfile ein .ssh-Verzeichnis, indem Sie Folgendes hinzufügen:

    RUN mkdir -p /root/.ssh

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

    VOLUME [ "/root/.ssh" ]

  3. Stellen Sie sicher, dass der ssh_config Ihres Containers weiß, wo die öffentlichen Schlüssel zu finden sind, indem Sie diese Zeile hinzufügen:

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

  4. Stellen Sie das Verzeichnis .ssh Ihres lokalen Benutzers zur Laufzeit für den Container bereit:

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

    Oder fügen Sie dies in Ihrem dockerCompose.yml unter dem Lautstärkeschlüssel des Dienstes hinzu:

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

Ihre endgültige Dockerfile sollte etwa Folgendes enthalten:

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" ]
1
Buchanora

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
  • Allgemeine Zeichenfolgen oder binärer Inhalt (bis zu 500 KB)

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

Ich habe versucht, herauszufinden, wie einem Container Signaturschlüssel hinzugefügt werden können, die zur Laufzeit (nicht zum Erstellen) verwendet werden sollen, 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.

0
Travis Britz

Am einfachsten erhalten Sie ein Launchpad-Konto und verwenden Sie: ssh-import-id

0
Sam Saffron

Spät zur Party, wie wäre es damit, dass die Schlüssel Ihres Host-Betriebssystems für den Root innerhalb des Containers verfügbar sind:

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

Ich bin nicht für die Verwendung von Dockerfile zum Installieren von Schlüsseln, da Iterationen Ihres Containers möglicherweise private Schlüssel hinterlassen.

0
Jepper

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
0
StanislavKo