डॉक कंटेनर के अंदर एसएसएच कुंजी का उपयोग करना

324

मेरे पास एक ऐप है जो Git के साथ विभिन्न मज़ेदार चीज़ों को निष्पादित करता है (जैसे कि git क्लोन और git पुश चलाना) और मैं इसे docker-ize करने की कोशिश कर रहा हूं।

मैं एक ऐसे मुद्दे पर चल रहा हूं, जहां मुझे कंटेनर 'उपयोगकर्ता' के उपयोग के लिए कंटेनर में SSH कुंजी जोड़ने में सक्षम होने की आवश्यकता है।

मैंने इसे कॉपी करने की कोशिश की /root/.ssh/, बदलते हुए $HOME, एक git ssh आवरण, और फिर भी कोई भाग्य नहीं बना।

यहाँ संदर्भ के लिए Dockerfile है:

#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 जैसे git कमांड चलाता है git pull

ssh-keys  docker 
— ebensing
स्रोत
3
इस सवाल के करीब पहुंचने वाले किसी भी व्यक्ति को यह सोचना चाहिए कि आखिरकार सुरक्षा छेद बनाना कितना आसान है और अगर आप सावधान नहीं हैं तो यहां भूल जाते हैं। सभी उत्तर पढ़ें और बुद्धिमानी से चुनें।
— जोश हब्दास

जवाबों:

144

यदि आप SSH का निर्माण समय पर उपयोग करना चाहते हैं तो यह एक कठिन समस्या है। उदाहरण के लिए यदि आप उपयोग कर रहे हैं git clone, या मेरे मामले में pipऔर npmएक निजी भंडार से डाउनलोड करने के लिए।

मैंने जो समाधान पाया वह --build-argध्वज का उपयोग करके अपनी चाबियाँ जोड़ने के लिए है । फिर आप --squashपरतों को मर्ज करने के लिए नए प्रायोगिक कमांड (1.13 जोड़ा) का उपयोग कर सकते हैं ताकि चाबियाँ हटाने के बाद उपलब्ध न हों। यहाँ मेरा समाधान है:

कमांड बनाएँ

$ 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

अद्यतन: यदि आप 1.13 डॉकर का उपयोग कर रहे हैं और आप पर प्रायोगिक सुविधाएँ हैं, तो आप --squashउस कमांड को बना सकते हैं, जो लेयर्स को मर्ज करेगी, SSH कुंजियों को हटाकर उन्हें छिपाएगी docker history।

— डैनियल वैन फ्लाईमेन
स्रोत
13
यह GitHub मुद्दा थ्रेड इंगित करेगा कि यह दृष्टिकोण अभी भी सुरक्षित नहीं है। इसी तरह के एक और समाधान के लिए यह टिप्पणी देखें ।
— एक्जाजक
4
स्क्वैश करने के बजाय एक और उपाय है कि उसी RUN कमांड में कुंजी को जोड़ना और हटाना, और जोड़ने और हटाने के बीच में आप इसका उपयोग उस चीज के लिए करें जिसकी आपको आवश्यकता है।
— बेंजामिन हैमर नोरगार्ड
2
हो सकता है कि आप id_rsa.pubफ़ाइल बनाने के लिए लाइनों को हटा दें क्योंकि इसकी आवश्यकता नहीं है।
— एलसीबी
1
स्क्वैशिंग करने के बजाय, मल्टी स्टेज इमेज बिल्ड का उपयोग करें ।
— रिचर्ड कीफर
यदि आपकी कुंजी पासवर्ड संरक्षित है, तो $(openssl rsa -in ~/.ssh/id_rsa)इसके बजाय का उपयोग करें
— BroiSatse
89

उबंटू का उपयोग करते समय पता चला कि ssh_config सही नहीं है। आपको जोड़ने की आवश्यकता है

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

अपने Sock कुंजी को पहचानने के लिए इसे पाने के लिए अपने Dockerfile को।

— ebensing
स्रोत
2
आपको शायद इस तरह सही उपयोगकर्ता नाम सेट करने की आवश्यकता हैRUN echo " Host example.com" >> /root/.ssh/config RUN echo " User <someusername>" >> /root/.ssh/config
— monofone
1
कोई व्यक्ति किसी होस्ट मशीन से कंटेनर में निजी कुंजी की नकल क्यों करेगा। कमांड ठीक है, लेकिन मुझे उपरोक्त
— बातें
12
यह सुरक्षित नहीं है! डॉकर के नवीनतम 1.13 संस्करण के लिए नीचे मेरा समाधान देखें। @ebensing
— डेनियल वैन फ्लाईमेन
1
@VladimirDjuricic परिनियोजन कुंजी जैसी चीजें हैं।
— ज़ेल्फ़िर कलस्तहल
वास्तव में आपको ubuntu न्यूनतम कंटेनर पर ठीक से सेटअप करने के लिए ssh-keygen -A को चलाने की आवश्यकता है। फिर आप पब / निजी कुंजी जोड़ सकते हैं और sshd शुरू कर सकते हैं। मेरे पास मेरे डॉकफ़ाइल में यह प्रविष्टि है: 'RUN ssh-keygen -A' एक चरण के रूप में।
— प्यूटरेक्ट
84

नोट : केवल निजी और हमेशा होगी छवियों के लिए इस दृष्टिकोण का उपयोग करें !

Ssh कुंजी छवि के भीतर संग्रहीत रहती है, भले ही आप इसे जोड़ने के बाद एक लेयर कमांड में कुंजी को हटा दें ( इस पोस्ट में टिप्पणियां देखें )।

मेरे मामले में यह ठीक है, इसलिए मैं इसका उपयोग कर रहा हूं:

# 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
— yellowcap
स्रोत
91
यह आपकी कुंजी को छवि में रखेगा, ऐसा न करें।
— CppLearner
12
@CppLearner आप सही हैं, यह छवि में कुंजी संग्रहीत करता है, और यह कुछ मामलों में एक सुरक्षा मुद्दा हो सकता है। उस पर प्रकाश डालने के लिए धन्यवाद। हालांकि, कई स्थितियां हैं जहां यह पूरी तरह से बचा है। उदाहरण के लिए उन चित्रों के लिए जो एक निजी भंडार में संग्रहीत हैं, या ऐसी छवियां जो सीधे उत्पादन सर्वर पर बनाई जाती हैं जो छवि की स्थानीय कुंजी की नकल करती हैं।
— yellowcap
2
इसके अलावा, यदि आप अपने विक्रेताओं को डॉकरफाइल के भीतर स्थापित करते हैं, तो विक्रेताओं को स्थापित करने के बाद आपको ssh कुंजी को हटाने से रोक नहीं सकता है।
— सेबस्कॉफर
2
@SebScoFr, जाहिरा तौर पर चाबियाँ परतों में से एक में संग्रहीत की जाएंगी, भले ही आप उन्हें बाद की कमांड में हटा दें (अपडेट किए गए उत्तर में लिंक देखें)। तो छवि हमेशा ssh कुंजी को उजागर करेगी, और समाधान केवल निजी छवियों के लिए उपयोग किया जाना चाहिए!
— yellowcap
1
@yellowcap अगर तुम नहीं
— Anoyz
56

यदि आप docker का उपयोग कर रहे हैं, तो एक आसान विकल्प यह है कि SSH एजेंट को आगे बढ़ाएं:

something:
    container_name: something
    volumes:
        - $SSH_AUTH_SOCK:/ssh-agent # Forward local machine SSH key to docker
    environment:
        SSH_AUTH_SOCK: /ssh-agent
— Aistis
स्रोत
23
बस ध्यान दें कि यह मैक मेजबानों के लिए काम नहीं करता है, चाहे डॉक-मशीन (वर्चुअलबॉक्स के माध्यम से) या मैक के लिए डॉकर (जो xhyve का उपयोग करता है) का उपयोग कर रहा है क्योंकि यूनिक्स डोमेन सॉकेट अनुमानित नहीं हैं।
— जो शॉ
SSH_AUTH_SOCKएक चर है, जिसमें ssh-agent का एक पथ है
— Aistis
2
— JuanPablo
1
ssh- फ़ॉरवर्डिंग को अब macOS होस्ट्स पर भी सपोर्ट किया जाता है - इसके रास्ते $SSH_AUTH_SOCKको माउंट करने के बजाय , आपको इस रास्ते को माउंट करना होगा - /run/host-services/ssh-auth.sock।
— जैकब कुकुल
47

पीटर ग्रिंगर के जवाब का विस्तार करते हुए मैं डॉक 17.05 के बाद से उपलब्ध मल्टी-स्टेज बिल्ड का उपयोग करने में सक्षम था । आधिकारिक पृष्ठ की स्थिति:

मल्टी-स्टेज बिल्ड के साथ, आप FROMअपने डॉकरीफाइल में कई स्टेटमेंट का उपयोग करते हैं । प्रत्येक FROMनिर्देश एक अलग आधार का उपयोग कर सकता है, और उनमें से प्रत्येक निर्माण का एक नया चरण शुरू करता है। आप चुनिंदा कलाकृतियों को एक चरण से दूसरे चरण में कॉपी कर सकते हैं, जो आपको अंतिम छवि में नहीं चाहिए।

इसे ध्यान में रखते हुए Dockerfileतीन बिल्ड चरणों को शामिल करने का मेरा उदाहरण है । यह ग्राहक वेब एप्लिकेशन की एक उत्पादन छवि बनाने के लिए है।

# 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.gitignoreफ़ाइल की सामग्री दोहराता है (यह परियोजना की निर्देशिकाओं को रोकता है node_modulesऔर जिसके परिणामस्वरूप distप्रतिलिपि बनाई जा रही है):

.idea
dist
node_modules
*.log

एक छवि बनाने के लिए कमांड उदाहरण:

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

यदि आपकी निजी SSH कुंजी में पासफ़्रेज़ नहीं है तो केवल खाली SSH_KEY_PASSPHRASEतर्क निर्दिष्ट करें ।

यह इस तरह काम करता है:

1)। केवल पहले चरण में package.json, yarn.lockफाइल और निजी SSH कुंजी को पहले इंटरमीडिएट इमेज नाम से कॉपी किया जाता है sources। आगे SSH कुंजी पासफ़्रेज़ से बचने के लिए यह स्वचालित रूप से जोड़ा जाता है ssh-agent। अंत में yarnकमांड एनपीएम से सभी आवश्यक निर्भरता स्थापित करता है और एसएसबी के ऊपर बिटबकैट से निजी गिट रिपॉजिटरी क्लोन करता है।

2)। दूसरा चरण वेब एप्लिकेशन के स्रोत कोड का निर्माण करता है और उसे distनामांकित करता है और इसे अगली इंटरमीडिएट इमेज नाम की निर्देशिका में रखता है production। ध्यान दें कि इंस्टॉल node_modulesकिए गए स्रोत कोड को sourcesइस लाइन द्वारा पहले चरण में निर्मित छवि से कॉपी किया गया है:

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

संभवतः यह निम्न पंक्ति भी हो सकती है:

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

हमारे node_modulesयहाँ पहले मध्यवर्ती छवि से केवल निर्देशिका है, कोई SSH_KEYऔर SSH_KEY_PASSPHRASEतर्क नहीं। बिल्ड के लिए आवश्यक सभी शेष हमारी परियोजना निर्देशिका से कॉपी किए गए हैं।

3)। तीसरे चरण में हम अंतिम छवि के एक आकार को कम करते हैं, जिसे वेब निर्देशिका शुरू करने के लिए नामांकित दूसरी इंटरमीडिएट छवि से ezze/geoport:0.6.0केवल distनिर्देशिका productionऔर नोड एक्सप्रेस स्थापित करके शामिल किया जाएगा ।

छवियों को सूचीबद्ध करना इस तरह एक आउटपुट देता है:

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

जहां गैर-टैग की गई छवियां पहले और दूसरे मध्यवर्ती बिल्ड चरणों के लिए संक्षिप्त हैं।

अगर तुम दौड़ते हो

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

आपको SSH_KEYऔर SSH_KEY_PASSPHRASEअंतिम छवि में कोई उल्लेख नहीं दिखाई देगा ।

— Ezze
स्रोत
पुरानी पोस्ट, लेकिन मैं इस पर जोर देना चाहता हूं कि यह 18.09 से पहले का सबसे अच्छा तरीका है। स्क्वैश अनावश्यक है, और जोखिम प्रवण है। बहु-मंच के साथ, आप जानते हैं कि आप केवल उन कलाकृतियों को ला रहे हैं जो आप चाहते हैं। उन फ़ाइलों के ऑप्ट-आउट के रूप में स्क्वैश के बारे में सोचें जो आप नहीं चाहते हैं, और ऑप्ट-इन के रूप में मल्टीस्टेज करें। इस उत्तर को अधिक होना चाहिए। छवि में अपनी ssh कुंजियों को सेंकना भयानक अभ्यास है।
— मैरिटलियन
@ezze आपको इस बहुत उपयोगी पोस्ट के लिए बहुत बहुत धन्यवाद :) SSH- एजेंट मुझे पागल कर रहा है, मैंने कुछ ऐसा ही किया जैसा कि आपने किया: मैं सही ढंग से docker build लॉग में देखता Identity added: /root/.ssh/id_rsa (/root/.ssh/id_rsa)हूं लेकिन जब मैं किसी दूसरे RUN में या फिर उसी RUN में चेक करता हूं ssh-add -lयह करके कमांड मुझे बताता है कि "एजेंट की कोई पहचान नहीं है"। मेरे बाल खींचना शुरू करना, कोई विचार?
— एलेक्स
40

कंटेनर के भीतर आपको ssh कुंजी इंजेक्ट करने के लिए, आपके पास कई समाधान हैं:

  1. ADDनिर्देश के साथ डॉकरफाइल का उपयोग करके , आप इसे अपनी निर्माण प्रक्रिया के दौरान इंजेक्ट कर सकते हैं

  2. जैसे कुछ कर रहे हों cat id_rsa | docker run -i <image> sh -c 'cat > /root/.ssh/id_rsa'

  3. docker cpकमांड का उपयोग करना जो आपको कंटेनर चलाने के दौरान फाइलों को इंजेक्ट करने की अनुमति देता है।

— creack
स्रोत
2
इसलिए, अब तक, मैंने इसे /root/.ssh/id_rsa में कॉपी करने की कोशिश की है, लेकिन फिर भी "प्राप्त" कुंजी कुंजी सत्यापन विफल हो गया है। घातक: रिमोट एंड अनपेक्षित रूप से अनपेक्षित रूप से "Git से त्रुटियां, जो मुझे यकीन है कि इसका मतलब है। जो भी कारण के लिए कुंजी का उपयोग नहीं कर रहा है। तो मैं सोच रहा हूँ कि कुछ और है जो मुझे वास्तव में करने के लिए सिस्टम को बताने की आवश्यकता है क्योंकि यह ssh कुंजी है? यकीन नहीं है कि यह कैसे डीबग करें। (और मैं इस कुंजी काम करता है क्योंकि यह मेजबान से इस मुद्दे के बिना चलाता जानते हैं)
— ebensing
क्या आप सुनिश्चित कर सकते हैं कि / etc / ssh / ssh_config सही कुंजी फ़ाइल को लक्षित करें?
— 23
1
क्या डॉकटर कंटेनर की फ़ाइलों का निरीक्षण करने का एक अच्छा तरीका है? या क्या मुझे मान्य कॉन्फ़िगरेशन में बस कोशिश करनी चाहिए और कॉपी करना चाहिए?
— ebensing
3
मैंने बस 'आधार' छवि के साथ कोशिश की, कर apt-get install openssh-serverरहा हूं और /root/.ssh/id_rsa में अपनी कुंजी डाल रहा हूं और यह ठीक काम कर रहा है। आप किस छवि का उपयोग कर रहे हैं?
— क्रीक
यदि आपको एक कंटेनर की फ़ाइल का निरीक्षण करने की आवश्यकता है, तो सबसे अच्छा तरीका 'बिल्ली' के साथ परिणामी छवि को कमिट करना और चलाना होगा।
— क्रीक
15

एक क्रॉस-प्लेटफ़ॉर्म समाधान है होस्ट के फ़ोल्डर को कंटेनर में साझा करने के लिए बाइंड माउंट का उपयोग करना .ssh:

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

इस दृष्टिकोण को आगे बढ़ाने वाले एजेंट के समान सार्वजनिक कुंजी को कंटेनर तक पहुंच योग्य बना देगा। एक अतिरिक्त उल्टा यह है कि यह एक गैर-रूट उपयोगकर्ता के साथ भी काम करता है और आपको GitHub से कनेक्ट करेगा। हालांकि, यह विचार करने के लिए एक चेतावनी है कि .sshफ़ोल्डर से सभी सामग्री (निजी कुंजी सहित) साझा की जाएगी, इसलिए यह दृष्टिकोण केवल विकास के लिए और केवल विश्वसनीय कंटेनर छवियों के लिए वांछनीय है।

— मोहम्मद अजीम
स्रोत
1
यह काम कर सकता है, लेकिन docker buildकेवल दौरान नहींdocker run
— अलेक्जेंडर मिल्स
3
ठीक यही बात है। आप अपनी ssh कीज़ को डॉक फ़ाइल के अंदर नहीं रखना चाहते हैं।
— मोहम्मद अज़ीम
2
यह देखते हुए कि SSH एजेंट फॉरवर्डिंग लिनक्स के बाहर काम नहीं करता है, यह विकास के माहौल में बहुत अधिक उपद्रव के बिना उठने-बैठने के लिए एक अच्छा समाधान बनाता है।
— जोश हब्दास
मैं docker-compose upअपने स्थानीय विंडोज 10 का उपयोग करके डॉक कर रहा हूं। मुझे उस परिदृश्य में आपके समाधान का उपयोग कैसे करना चाहिए?
— लालू
अनिवार्य रूप से आप पूछ रहे हैं कि डॉक कंपोज़ में वॉल्यूम कैसे मैप करें। इसके ऊपर एक उत्तर है जिसका उत्तर दिया गया है। विशेष रूप से विंडोज के लिए यह stackoverflow.com/questions/41334021/…
— मोहम्मद अजीम
14

डॉकटर कंटेनरों को स्वयं की 'सेवाओं' के रूप में देखा जाना चाहिए। अलग-अलग चिंताओं के लिए आपको अलग-अलग कार्य करना चाहिए:

1) डेटा एक डेटा कंटेनर में होना चाहिए: रेपो को क्लोन करने के लिए एक लिंक की गई मात्रा का उपयोग करें। उस डेटा कंटेनर को फिर उस सेवा से जोड़ा जा सकता है जिसकी उसे आवश्यकता है।

2) गिट क्लोनिंग कार्य को चलाने के लिए एक कंटेनर का उपयोग करें, (जब आप इसे चलाते हैं, तो डेटा कंटेनर को इससे लिंक करते हुए)

3) ssh-key के लिए समान: इसे लगाओ एक वॉल्यूम है (जैसा कि ऊपर बताया गया है) और इसे git क्लोन सेवा से लिंक करें जब आपको इसकी आवश्यकता हो

इस तरह, क्लोनिंग कार्य और कुंजी दोनों अल्पकालिक हैं और केवल तभी सक्रिय होते हैं जब जरूरत हो।

अब यदि आपका ऐप स्वयं एक git इंटरफ़ेस है, तो आप अपने काम को करने के लिए सीधे github या bitbucket REST API पर विचार करना चाह सकते हैं: यही वह है जिसके लिए वे डिज़ाइन किए गए थे।

— MRE
स्रोत
13

यह लाइन एक समस्या है:

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

उन फ़ाइलों को निर्दिष्ट करते समय, जिन्हें आप छवि में कॉपी करना चाहते हैं, आप केवल सापेक्ष रास्तों का उपयोग कर सकते हैं - उस निर्देशिका के सापेक्ष जहां आपका डॉकरफाइल है। इसलिए आपको इसके बजाय उपयोग करना चाहिए:

ADD id_rsa /root/.ssh/id_rsa

और id_rsa फ़ाइल को उसी डाइरेक्टरी में रखें जहाँ आपकी Dockerfile है।

अधिक जानकारी के लिए इसे देखें: http://docs.docker.io/reference/builder/#add

— दान केदार
स्रोत
4
यह सुरक्षा समस्या भी है क्योंकि यह एक निजी कुंजी को एक छवि में रखता है जिसे आसानी से भुलाया जा सकता है।
— माइक डी
docker cpबस कंटेनर में रखता है और छवि नहीं, है ना?
— अलेक्जेंडर मिल्स
13

हमें इसी तरह की समस्या थी जब dopm build time में npm install करना।

डैनियल वैन फ्लाईमेन के समाधान से प्रेरित होकर और इसे git url rewrite के साथ जोड़कर , हमने निजी github repos से npm इंस्टॉल को प्रमाणित करने के लिए थोड़ा सरल तरीका खोजा - हमने कुंजी के बजाय oauth2 टोकन का उपयोग किया।

हमारे मामले में, npm निर्भरता को "git + https://github.com/ ..." के रूप में निर्दिष्ट किया गया था।

कंटेनर में प्रमाणीकरण के लिए, यूआरएल को ssh प्रमाणीकरण (ssh: //git@github.com/) या टोकन प्रमाणीकरण के लिए उपयुक्त होने के लिए फिर से लिखना होगा (https: // $ {GITHUB_TOKEN} @ github.com / /

कमांड बनाएँ:

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

दुर्भाग्य से, मैं 1.9 पर काम कर रहा हूं, इसलिए - विकल्प का विकल्प अभी तक नहीं है, आखिरकार इसे जोड़ने की आवश्यकता है

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

कंटेनर में ssh प्रमाणीकरण सॉकेट अग्रेषित करें:

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

आपकी स्क्रिप्ट एक प्रदर्शन करने में सक्षम होगी git clone।

अतिरिक्त: यदि आप एक विशिष्ट उपयोगकर्ता से संबंधित क्लोन फाइलें चाहते हैं, जिसका आपको उपयोग करने की आवश्यकता है chown , तो कंटेनर के अंदर रूट की तुलना में अन्य उपयोगकर्ता का उपयोग करना gitविफल हो जाएगा ।

आप इस प्रकाशन को कंटेनर के वातावरण में कुछ अतिरिक्त चर कर सकते हैं:

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

आपके द्वारा क्लोन करने के बाद आपको chown $OWNER_USER:$OWNER_GROUP -R <source_folder>कंटेनर छोड़ने से पहले उचित स्वामित्व सेट करने के लिए निष्पादित करना होगा ताकि कंटेनर के बाहर गैर-रूट उपयोगकर्ता द्वारा फाइलें सुलभ हों।

— edupo
स्रोत
1
नए डॉकर संस्करणों में आप -u root:$(id -u $USER)कम से कम उन फाइलों को पास कर सकते हैं जो आपके उपयोगकर्ता के समान प्राथमिक समूह के पास हैं, जो कि उन सभी को कम से कम पठनीय बनाना चाहिए sudoजब तक कि कुछ उन्हें 0600अनुमतियों के साथ नहीं बना रहा है।
— ड्रैगन 788
@ dragon788 मुझे लगता है कि आप लिखने में कोई त्रुटि है: -u root:$(id -u $USER)होना चाहिए -g।
— 15
अच्छा निर्णय! मैं इसे मोबाइल से ठीक करने में सक्षम नहीं लगता, जल्द ही डेस्कटॉप पर कोशिश करूंगा।
— ड्रैगन 788
/tmp/ssh_auth.sock: No such file or directoryअब मेरे पास /tmp/ssh-vid8Zzi8UILE/agent.46016मेरी मेजबान मशीन है
— vladkras
@vladkras त्रुटि बहुत सामान्य है। /tmpआपके कंटेनर के अंदर अनुमतियों के कारण हो सकता है । या डॉक रन कमांड पर टाइपो। सुनिश्चित करें कि बाँध कथन सही है -v $SSH_AUTH_SOCK:/tmp/ssh_auth.sock: आदेश महत्वपूर्ण है और अर्धविराम भी महत्वपूर्ण है। कृपया आगे की मदद के लिए डॉकटर दस्तावेज देखें ।
— edupo
10

जैसा कि एक्जाजक ने पहले से ही डैनियल वैन फ्लाईमेन के जवाब में कहा था कि यह चाबी निकालने और उपयोग करने के लिए सुरक्षित नहीं लगता है --squash, क्योंकि वे अभी भी इतिहास में दिखाई देंगे (docker history --no-trunc ) ।

डॉकर 18.09 के बजाय, अब आप "बिल्ड सीक्रेट्स" सुविधा का उपयोग कर सकते हैं। मेरे मामले में मैंने अपने डॉकरीफाइल में निम्नलिखित के साथ अपने मेजबान SSH कुंजी का उपयोग करके एक निजी git रेपो क्लोन किया:

# syntax=docker/dockerfile:experimental

[...]

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

[...]

इसका उपयोग करने में सक्षम होने के लिए, आपको चलने से पहले नए बिल्डकिट बैकएंड को सक्षम करने की आवश्यकता है docker build:

export DOCKER_BUILDKIT=1

और आपको --ssh defaultपैरामीटर को जोड़ने की आवश्यकता हैdocker build ।

इसके बारे में अधिक जानकारी यहाँ: https://medium.com/@tonistiigi/build-secrets-and-ssh-forwarding-in-docker-18-09-ae8161d066

— FRSC
स्रोत
1
सबसे अच्छा समाधान IMHO। मुझे इसे काम करने के लिए दो और चीजें करनी थीं: 1) ssh-agent के साथ मेरी निजी कुंजी ssh-add ~/.ssh/id_rsaजोड़ें और 2) git होस्ट को ज्ञात_हॉट्स में जोड़ें, अर्थात बिटबकेट के लिए:RUN ssh-keyscan -H bitbucket.org >> ~/.ssh/known_hosts
— Moritz Ringler
मुझे यह काम करने के लिए बिल्कुल भी नहीं मिला है। मुझे अभी भी अनुमति त्रुटियां मिल रही हैं: Permission denied (publickey). fatal: Could not read from remote repository. Please make sure you have the correct access and the repository exists.यह --ssh defaultमेरे डॉक बिल्ड में ध्वज को पारित करने के बावजूद , और --mount=type=sshरन कमांड में उपयोग कर रहा है जहां मैं git clone। मैं बनाने की मशीन पर कोई समस्या नहीं रेपो क्लोन करने में सक्षम हूँ। यह केवल डॉक बिल्ड कंटेनर में विफल रहता है। मुझे संदेह है कि डॉकर का मैक संस्करण वास्तव में ssh क्लाइंट के साथ नहीं गुजर रहा है।
— PMende
@PMende क्या आप इस मुद्दे का पता लगाने में सक्षम थे क्योंकि मैं भी उसी का सामना कर रहा हूं।
— सदन ए।
@SadanArshad यह पता चलता है कि यह कार्यक्षमता वर्तमान में केवल तभी समर्थित है जब आप लिनक्स मशीन से डोकर चला रहे हों। यह काम नहीं करता है यदि आप अपने डॉकर कमांड को मैक से चला रहे हैं (और शायद विंडोज, साथ ही, हालांकि मैं पुष्टि नहीं कर सकता)।
— PMende
बहुत बुरा है कि docker-
— एलेक्सिस विल्के
9

यह मुद्दा वास्तव में एक कष्टप्रद है। चूंकि आप dockerfile संदर्भ के बाहर किसी भी फ़ाइल को जोड़ / कॉपी नहीं कर सकते हैं, जिसका अर्थ है कि यह असंभव है ~ ~ .ssh / id_rsa को छवि के /root/.ssh/id_rsa में लिंक करना, और जब आपको निश्चित रूप से कुछ sshed चीज़ करने के लिए कुंजी की आवश्यकता हो एक निजी रेपो लिंक से git क्लोन की तरह ..., आपके docker की छवि के निर्माण के दौरान।

वैसे भी, मुझे हल करने के लिए हल मिला है, इसलिए राजी नहीं था लेकिन मेरे लिए काम किया।

  1. अपने कामचोर में:

    • इस फाइल को /root/.ssh/id_rsa के रूप में जोड़ें
    • क्या आप चाहते हैं, जैसे गिट क्लोन, संगीतकार ...
    • rm /root/.ssh/id_rsa अंत में

  2. एक शूटिंग में एक स्क्रिप्ट करने के लिए:

    • dockerfile को पकड़कर फ़ोल्डर में अपनी कुंजी cp करें
    • docker बिल्ड
    • नकल की कुंजी rm

  3. कभी-कभी आपको कुछ ssh आवश्यकताओं के साथ इस छवि से एक कंटेनर चलाना होगा, बस रन कमांड के लिए -v जोड़ें, जैसे:

    docker run -v ~ / .ssh / id_rsa: /root/.ssh/id_rsa - टैबलेट कंटेनर कमांड

यह समाधान आपके प्रोजेक्ट स्रोत और निर्मित डॉकटर छवि दोनों में कोई निजी कुंजी नहीं है, इसलिए अब कोई चिंता का विषय नहीं है।

— ImLeo
स्रोत
1
"जब से आप डॉकटराइल संदर्भ के बाहर किसी भी फाइल को जोड़ / कॉपी नहीं कर सकते," क्या आपने देखा है docker cp? इसका उपयोग "कंटेनर और आपके होस्ट के बीच फ़ाइलों / फ़ोल्डरों को कॉपी करने के लिए" किया जाता है।
— जोनाथन रेनहार्ट
@JonathonReinhart, इस ओर इशारा करने के लिए धन्यवाद। हाँ, docker cpचाल कर सकता है। हालाँकि इस स्थिति में, मुझे छवि के निर्माण के दौरान ssh_key की आवश्यकता थी, और उस समय कोई कंटेनर नहीं है ... मेरी अस्पष्ट अभिव्यक्ति को अपडेट करेगा, धन्यवाद वैसे भी।
— ImLeo
9

मैं आज उसी समस्या में भाग गया और पिछले पोस्टों के साथ थोड़ा संशोधित संस्करण मैंने पाया कि यह दृष्टिकोण मेरे लिए अधिक उपयोगी है

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

(ध्यान दें कि आसानी से झंडा इसलिए कंटेनर किसी भी स्थिति में मेरी ssh कुंजी को गड़बड़ नहीं करेगा।)

कंटेनर के अंदर मैं अब चला सकता हूं:

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

इसलिए मुझे वह Bad owner or permissions on /root/.ssh/..त्रुटि नहीं मिली जो @kross द्वारा नोट की गई थी

— Tojo
स्रोत
धन्यवाद! यह मेरे लिए इसे प्राप्त करने की कुंजी थी: ssh-agent और ssh-add को एक ही कमांड में रखना जैसे ssh-agent bash -c "ssh-add...":। मैं उस अधिकार को docker चलाने में पास कर सकता हूं। मेरे eval ssh-agentद्वारा उपयोग किए गए सभी पिछले उदाहरण , ssh-add द्वारा पीछा किए गए और मैं evaldocker रन कमांड के माध्यम से इसे पारित करने का एक तरीका नहीं निकाल सका ।
— 14
7

'यदि आप चुनिंदा दूरस्थ सर्वरों को अपने स्थानीय ssh-Agent तक पहुंचने दे सकते हैं जैसे कि वह सर्वर पर चल रहा था'

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

— arreche
स्रोत
4
docker run -i -t -v $ (readlink -f $ SSH_AUTH_SOCK): / ssh-agent -e SSH_AUTH_SOCK = / ssh-agent ubuntu / bin / bash
— Pavel Hlobil
1
fruitl00p ने कुछ इस तरह से डॉक-टनल कंटेनर बनाया है: github.com/kingsquare/docker-tunnel
— Martin Suchanek
6

आप अपने .ssh निर्देशिका को होस्ट और कंटेनर के बीच भी लिंक कर सकते हैं, मुझे नहीं पता कि इस पद्धति का कोई सुरक्षा निहितार्थ है या नहीं, लेकिन यह सबसे आसान तरीका हो सकता है। कुछ इस तरह काम करना चाहिए:

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

याद रखें कि docker sudo के साथ चलता है (जब तक कि आप नहीं करते हैं), यदि यह मामला है तो आप रूट ssh कुंजियों का उपयोग करेंगे।

— लुइस एलैकोंडो
स्रोत
इस विधि का उपयोग करना डॉकटर 0.11 के साथ काम करता है लेकिन अगर आप अंजीर का उपयोग करते हैं, तो यह एक पैनिक एरर फेंक देगा। मुझे नहीं पता कि क्यों
— लुइस एलैकोंडो
3
यह एक पसंदीदा तरीका होगा, यह ट्रिक मेरे अप्रकाशित होस्ट उपयोगकर्ता की कुंजियों को कंटेनर के रूट के रूप में उपयोग करने के लिए होगी। जैसा कि आप उल्लेख करते हैं, यह मेजबान रूट उपयोगकर्ता की पैदावार के रूप में नहीं करने की कोशिश कर रहा है Bad owner or permissions on /root/.ssh/config।
— स्थाई
यह केवल दौरान उपयोग किया जा सकता है docker run, लेकिन दौरान नहीं docker build।
— ccpizza
3
@ccpizza, मुझे लगता है कि एक लाभ के रूप में। इनमें से कई उत्तर एक छवि में संग्रहीत निजी कुंजी छोड़ते हैं; कुंजी आपके द्वारा बाद की परत कमांड में कुंजी को हटाने के बाद भी संग्रहीत रहती है। केवल चलाने (निर्माण नहीं) के दौरान निजी चाबियों को शुरू करने से, वे केवल कंटेनर में मौजूद हो सकते हैं (छवि नहीं)।
— काउलिनेटर
6

डॉक निर्माण के docker API 1.39+साथ (एपीआई संस्करण की जाँच करें docker version) से शुरू होकर --sshडॉक इंजन को एसएसएच एजेंट कनेक्शनों को आगे बढ़ाने की अनुमति देने के लिए एक एजेंट सॉकेट या कुंजियों के साथ विकल्प की अनुमति देता है ।

कमांड बनाएँ

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 git@github.com:myorg/myproject.git myproject

और जानकारी:

— एडिसन अरेंजो
स्रोत
1
टिल्ड विस्तार ने मेरे लिए काम नहीं किया; मुझे मिल गया: could not parse ssh: [default=~/.ssh/id_rsa]: stat ~/.ssh/id_rsa: no such file or directory। पूर्ण पथ का उपयोग करें यदि यह काम नहीं करता है।
— slhck
3

यदि आप अपने SSH कुंजी की सुरक्षा के बारे में परवाह नहीं करते हैं, तो यहां कई अच्छे उत्तर हैं। यदि आप करते हैं, सबसे अच्छा जवाब मैंने पाया करने के लिए ऊपर एक टिप्पणी में एक लिंक से था इस GitHub टिप्पणी द्वारा diegocsandrim । ताकि दूसरों को इसे देखने की अधिक संभावना हो, और सिर्फ इस मामले में कि रेपो कभी दूर चला जाता है, यहां उस उत्तर का एक संपादित संस्करण है:

यहां अधिकांश समाधान छवि में निजी कुंजी को छोड़कर समाप्त होते हैं। यह बुरा है, क्योंकि छवि तक पहुंच रखने वाले किसी व्यक्ति के पास आपकी निजी कुंजी तक पहुंच है। चूंकि हम व्यवहार के बारे में पर्याप्त नहीं जानते हैंsquash , यह तब भी हो सकता है जब आप उस परत को हटा दें और स्क्वैश करें।

हम a3 s3 क्ली के साथ कुंजी को एक्सेस करने के लिए एक प्री-साइन URL जनरेट करते हैं, और लगभग 5 मिनट तक एक्सेस को सीमित करते हैं, हम इस प्री-साइन URL को रेपो डायरेक्टरी में एक फाइल में सेव करते हैं, फिर डॉकटरफाइल में हम इसे इमेज में जोड़ते हैं।

Dockerfile में हमारे पास एक RUN कमांड है जो इन सभी चरणों को करती है: ssh कुंजी प्राप्त करने के लिए प्री-सिंग URL का उपयोग करें, npm इंस्टॉल रन करें, और ssh कुंजी निकालें।

एक एकल आदेश में ऐसा करने से ssh कुंजी किसी भी परत में संग्रहीत नहीं होगी, लेकिन पूर्व-साइन URL संग्रहीत किया जाएगा, और यह कोई समस्या नहीं है क्योंकि URL 5 मिनट के बाद मान्य नहीं होगा।

बिल्ड स्क्रिप्ट इस तरह दिखती है:

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

Dockerfile इस तरह दिखता है:

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 git@github.com || true && \
    npm install --production && \
    rm ./my_key && \
    rm -rf ~/.ssh/*

ENTRYPOINT ["npm", "run"]

CMD ["start"]
— सैम एच।
स्रोत
1
इस समाधान के साथ समस्या यह है कि क्योंकि pre_sign_url हर बार बदल जाएगा, npm इंस्टाल को कैश नहीं किया जा सकता है यहां तक ​​कि संकुल में कोई परिवर्तन नहीं है। फ़ाइल को खोलें। बिल्ड.श में कुंजी प्राप्त करना बेहतर है और इसे बिल्ड तर्क के रूप में सेट करें ताकि यह हर बार बदल न जाए
— यॉर्क यांग
3

Docker (17.05) के बाद के संस्करणों में आप मल्टी स्टेज बिल्ड का उपयोग कर सकते हैं । जो सबसे सुरक्षित विकल्प है क्योंकि पिछले बिल्ड केवल बाद के बिल्ड द्वारा उपयोग किए जा सकते हैं और फिर नष्ट हो जाते हैं

अधिक जानकारी के लिए मेरे स्टैकओवरफ़्लो प्रश्न का उत्तर देखें

— पीटर ग्रिंगर
स्रोत
3

Docker कंटेनरों के अंदर SSH की चुनौतियों का संक्षिप्त अवलोकन यहाँ विस्तृत है । गुप्त रिसाव के बिना एक कंटेनर के भीतर से विश्वसनीय रिमोट से कनेक्ट करने के लिए कुछ तरीके हैं:

इनसे परे कंपोज का उपयोग करते समय रनटाइम पर एक अलग डॉक कंटेनर में चल रहे की-स्टोर का उपयोग करने की संभावना भी है। यहाँ दोष यह है कि हाशीकार्प द्वारा वॉल्ट जैसे कीस्टोर बनाने और प्रबंधित करने के लिए आवश्यक मशीनरी के कारण अतिरिक्त जटिलता है ।

स्टैंड-अलोन डॉकटर कंटेनर में SSH कुंजी के उपयोग के लिए ऊपर दिए गए तरीकों को देखें और अपनी विशिष्ट आवश्यकताओं के आधार पर प्रत्येक की कमियों पर विचार करें। यदि, हालांकि, आप कम्पोज़ के अंदर चल रहे हैं और रनटाइम पर एक ऐप की कुंजी साझा करना चाहते हैं (ओपी की व्यावहारिकताओं को दर्शाते हुए):

  • एक docker-compose.envफ़ाइल बनाएँ और इसे अपने में जोड़ें.gitignore फ़ाइल में ।
  • अपना अपडेट करें docker-compose.ymlऔर जोड़ेंenv_file कुंजी की आवश्यकता वाली सेवा के लिए ।
  • अनुप्रयोग क्रम में पर्यावरण से सार्वजनिक कुंजी एक्सेस करें, जैसे process.node.DEPLOYER_RSA_PUBKEYकि Node.js अनुप्रयोग के मामले में।

उपरोक्त दृष्टिकोण विकास और परीक्षण के लिए आदर्श है और, जबकि यह उत्पादन आवश्यकताओं को पूरा कर सकता है, उत्पादन में आप ऊपर बताए गए अन्य तरीकों में से एक का उपयोग करके बेहतर हैं।

अतिरिक्त संसाधन:

— जोश हबदास
स्रोत
3

कंटेनर बनाने के लिए आप मल्टी स्टेज बिल्ड का उपयोग कर सकते हैं यह वह तरीका है जिसे आप अपना सकते हैं: -

चरण 1 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

स्टेज 2: अपने कंटेनर का निर्माण करें

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

अपनी रचना फ़ाइल में env विशेषता जोड़ें:

   environment:
      - SSH_PRIVATE_KEY=${SSH_PRIVATE_KEY}

फिर इस तरह से स्क्रिप्ट बनाने से पास पास:

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

और सुरक्षा के लिए मध्यवर्ती कंटेनर को हटा दें। यह आपकी सहायता करेगा।

— देवेश
स्रोत
2

डोकर छवि परत में अपनी कुंजी को सहेजे बिना, या ssh_agent जिम्नास्टिक के माध्यम से इसे प्राप्त करने का एक सरल और सुरक्षित तरीका:

  1. आपके चरणों में से एक के रूप में Dockerfile, .sshजोड़कर एक निर्देशिका बनाएँ :

    RUN mkdir -p /root/.ssh

  2. नीचे बताया गया है कि आप ssh डायरेक्टरी को वॉल्यूम के रूप में माउंट करना चाहेंगे:

    VOLUME [ "/root/.ssh" ]

  3. सुनिश्चित करें कि आपके कंटेनर ssh_configको पता है कि इस पंक्ति को जोड़कर सार्वजनिक कुंजियाँ कहाँ मिलेंगी:

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

  4. .sshरनटाइम के दौरान कंटेनर में स्थानीय उपयोगकर्ता की निर्देशिका का खुलासा करें :

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

    या dockerCompose.ymlसेवा की मात्रा कुंजी के तहत इसे अपने ऐड में दें :

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

आपके अंतिम Dockerfileमें कुछ ऐसा होना चाहिए:

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" ]
— Buchanora
स्रोत
1

मैं समस्या को दूसरे तरीके से काम करने की कोशिश कर रहा हूं: एक छवि के लिए सार्वजनिक ssh कुंजी जोड़ना। लेकिन मेरे परीक्षणों में, मुझे पता चला कि "docker cp" एक होस्ट से FROM को कॉपी करने के लिए है। क्रेक द्वारा उत्तर में आइटम 3 कह रहा है कि आप कंटेनर में फ़ाइलों को इंजेक्ट करने के लिए docker cp का उपयोग कर सकते हैं। Https://docs.docker.com/engine/reference/commandline/cp/ देखें

अंश

एक कंटेनर के फाइल सिस्टम से होस्ट पथ पर फ़ाइलों / फ़ोल्डरों को कॉपी करें। पथ फाइल सिस्टम की जड़ के सापेक्ष हैं।

  Usage: docker cp CONTAINER:PATH HOSTPATH

  Copy files/folders from the PATH to the HOSTPATH
— EricGreg
स्रोत
यह URL अब टूटा हुआ प्रतीत होता है।
— SLM
यह अप्रचलित या गलत है। यह नवीनतम 1.8.2 के अनुसार दिशा को कॉपी कर सकता है।
— जोनाथन रेनहार्ट
1

आप एक साझा फ़ोल्डर का उपयोग करके अपने कंटेनर में अधिकृत कुंजी को पास कर सकते हैं और इस तरह डॉकटर फ़ाइल का उपयोग करके अनुमतियाँ सेट कर सकते हैं:

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

और आपके docker रन में कुछ ऐसा है, जिसमें कंटेनर पर होस्ट के साथ ऑथराइज्ड डायरेक्टरी को साझा करने के लिए कंटेनर के साथ एक ऑथराइज्ड डायरेक्टरी (शेयर होल्डिंग) है, फिर ssh पोर्ट को खोलें, जो होस्ट पर पोर्ट 7001 के माध्यम से एक्सेस किया जा सकेगा।

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

आप https://github.com/jpetazzo/nsenter को देखना चाहते हैं जो कंटेनर पर शेल खोलने और कंटेनर के भीतर कमांड निष्पादित करने का एक और तरीका प्रतीत होता है।

— andrew pate
स्रोत
1

पार्टी के लिए देर से, कैसे इस बारे में जो आपके मेजबान ऑपरेटिंग सिस्टम कुंजी को कंटेनर के अंदर रूट करने के लिए उपलब्ध कराएगा, मक्खी पर:

docker run -v ~/.ssh:/mnt -it my_image /bin/bash -c "ln -s /mnt /root/.ssh; ssh user@10.20.30.40"

मैं कुंजियों को स्थापित करने के लिए Dockerfile का उपयोग करने के पक्ष में नहीं हूं क्योंकि आपके कंटेनर का पुनरावृत्तियों निजी कुंजी को पीछे छोड़ सकता है।

— Jepper
स्रोत
0

आप किसी भी संवेदनशील डेटा को प्रबंधित करने के लिए रहस्यों का उपयोग कर सकते हैं, जिसे एक कंटेनर को रनटाइम की आवश्यकता होती है, लेकिन आप छवि या स्रोत नियंत्रण में संग्रहीत नहीं करना चाहते हैं, जैसे:

  • उपयोगकर्ता नाम और पासवर्ड
  • टीएलएस प्रमाण पत्र और चाबियाँ
  • एसएसएच कुंजी
  • अन्य महत्वपूर्ण डेटा जैसे डेटाबेस या आंतरिक सर्वर का नाम
  • सामान्य तार या द्विआधारी सामग्री (आकार में 500 केबी तक)

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

मैं यह पता लगाने की कोशिश कर रहा था कि रनटाइम (निर्माण नहीं) के दौरान उपयोग करने के लिए कंटेनर में साइनिंग कीज़ को कैसे जोड़ा जाए और इस सवाल पर आया। डॉकर रहस्य मेरे उपयोग के मामले का समाधान प्रतीत होते हैं, और चूंकि किसी ने भी इसका उल्लेख नहीं किया है, इसलिए मैं इसे जोड़ूंगा।

— ट्रैविस ब्रिटज़
स्रोत
0

मेरे मामले में मुझे दूरस्थ रिपॉजिटरी से नोडज और 'एनपीएम आई' की समस्या थी। मैंने तय किया कि यह 'नोड' यूजर को कंटेनर में नोडजेस और 700 से ~ / .shsh जोड़ा है।

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

डोकर-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

इसके बाद इसने काम शुरू किया

— Дмитрий Урбанович
स्रोत
-1

सबसे सरल तरीका है, एक लॉन्चपैड खाता प्राप्त करें और उपयोग करें: ssh-import-id

— सैम केसर
स्रोत
8
सवाल निजी चाबियों का था। ssh-import-idऐसा लगता है कि यह केवल सार्वजनिक कुंजी आयात करता है।
— cddr
-1

एक चल रहे डॉकटर कंटेनर में, आप docker -i (संवादात्मक) विकल्प के साथ ssh-keygen जारी कर सकते हैं। यह अग्रेषित करेगा कंटेनर docker कंटेनर के अंदर कुंजी बनाने का संकेत देता है।

— जेरोम एंथोनी
स्रोत
1
और फिर क्या? आप इसके बाद कुछ नहीं कर सकते, क्योंकि आपके पास ऐसा करने की अनुमति नहीं है।
— जोनाथन रेइनहर्ट
-1

डेबियन / रूट / अधिकृत_के लिए:

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
— StanislavKo
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.