Menggunakan kunci SSH di dalam wadah buruh pelabuhan

Saya memiliki aplikasi yang menjalankan berbagai hal menyenangkan dengan Git (seperti menjalankan git clone & git push) dan saya mencoba untuk merevisinya.

Saya mengalami masalah meskipun di mana saya harus dapat menambahkan kunci SSH ke wadah untuk 'pengguna' wadah untuk digunakan.

Saya mencoba menyalinnya ke dalam /root/.ssh/, mengubah $HOME, membuat bungkus git ssh, dan masih belum berhasil.

Berikut adalah Dockerfile untuk referensi:

#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 menjalankan perintah git like git pull

Ini masalah yang lebih sulit jika Anda perlu menggunakan SSH saat membangun. Misalnya jika Anda menggunakan git clone, atau dalam kasus saya pipdan npmuntuk mengunduh dari repositori pribadi.

Solusi yang saya temukan adalah menambahkan kunci Anda menggunakan --build-argbendera. Kemudian Anda dapat menggunakan --squashperintah eksperimental baru (ditambahkan 1,13) untuk menggabungkan lapisan sehingga tombol tidak lagi tersedia setelah penghapusan. Inilah solusi saya:

Bangun perintah

$ 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

Pembaruan: Jika Anda menggunakan Docker 1.13 dan memiliki fitur eksperimental pada Anda dapat menambahkan --squashke perintah build yang akan menggabungkan lapisan, menghapus kunci SSH dan menyembunyikannya docker history.

Ternyata saat menggunakan Ubuntu, ssh_config tidak benar. Anda perlu menambahkan

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

ke Dockerfile Anda agar bisa mengenali kunci ssh Anda.

Catatan : hanya gunakan pendekatan ini untuk gambar yang bersifat pribadi dan akan selalu !

Kunci ssh tetap tersimpan di dalam gambar, bahkan jika Anda menghapus kunci dalam perintah lapisan setelah menambahkannya (lihat komentar di posting ini ).

Dalam kasus saya ini tidak apa-apa, jadi ini yang saya gunakan:

# 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

Jika Anda menggunakan buruh pelabuhan menulis pilihan mudah adalah untuk meneruskan agen SSH seperti itu:

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

Memperluas jawaban Peter Grainger saya dapat menggunakan multi-stage build yang tersedia sejak Docker 17.05. Status halaman resmi:

Dengan pembuatan multi-tahap, Anda menggunakan beberapa FROMpernyataan di Dockerfile Anda. Setiap FROMinstruksi dapat menggunakan basis yang berbeda, dan masing-masing memulai tahap baru pembangunan. Anda dapat secara selektif menyalin artefak dari satu tahap ke tahap lainnya, meninggalkan semua yang tidak Anda inginkan dalam gambar akhir.

Ingatlah ini di sini adalah contoh saya Dockerfiletermasuk tiga tahap membangun. Ini dimaksudkan untuk membuat gambar produksi aplikasi web klien.

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

.dockerignoremengulangi isi .gitignorefile (mencegah node_modulesdan mengakibatkan distdirektori proyek tidak disalin):

.idea
dist
node_modules
*.log

Contoh perintah untuk membuat gambar:

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

Jika kunci SSH pribadi Anda tidak memiliki frasa sandi, cukup tentukan SSH_KEY_PASSPHRASEargumen kosong .

Begini Cara kerjanya:

1). Pada tahap pertama saja package.json, yarn.lockfile dan kunci SSH pribadi disalin ke gambar perantara pertama bernama sources. Untuk menghindari frasa sandi kunci SSH yang diminta, secara otomatis ditambahkan ssh-agent. Akhirnya yarnperintah menginstal semua dependensi yang diperlukan dari NPM dan klon repositori private git dari Bitbucket melalui SSH.

2). Tahap kedua membangun dan memperkecil kode sumber aplikasi web dan menempatkannya di distdirektori gambar perantara berikutnya bernama production. Perhatikan bahwa kode sumber yang diinstal node_modulesdisalin dari gambar bernama sourcesdiproduksi pada tahap pertama oleh baris ini:

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

Mungkin itu juga bisa menjadi baris berikut:

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

Kami hanya memiliki node_modulesdirektori dari gambar perantara pertama di sini, tidak ada SSH_KEYdan SSH_KEY_PASSPHRASEargumen lagi. Semua yang dibutuhkan untuk membangun disalin dari direktori proyek kami.

3). Pada tahap ketiga kami mengurangi ukuran gambar akhir yang akan ditandai sebagai ezze/geoport:0.6.0dengan hanya memasukkan distdirektori dari gambar perantara kedua bernama productiondan menginstal Node Express untuk memulai server web.

Listing gambar memberikan output seperti ini:

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

di mana gambar yang tidak di-tag terhubung ke tahap pembuatan lanjutan pertama dan kedua.

Jika Anda berlari

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

Anda tidak akan melihat menyebutkan dari SSH_KEYdan SSH_KEY_PASSPHRASEpada gambar akhir.

Untuk menyuntikkan kunci ssh Anda, dalam sebuah wadah, Anda memiliki beberapa solusi:

1. Menggunakan Dockerfile dengan ADDinstruksi, Anda bisa menyuntikkannya selama proses build Anda

2. Cukup melakukan sesuatu seperti cat id_rsa | docker run -i <image> sh -c 'cat > /root/.ssh/id_rsa'

3. Menggunakan docker cpperintah yang memungkinkan Anda untuk menyuntikkan file saat wadah sedang berjalan.

Salah satu solusi lintas-platform adalah menggunakan bind mount untuk membagikan .sshfolder host ke kontainer:

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

Mirip dengan penerusan agen pendekatan ini akan membuat kunci publik dapat diakses oleh wadah. Sisi positif tambahannya adalah ia bekerja dengan pengguna non-root juga dan akan membuat Anda terhubung ke GitHub. Satu peringatan untuk dipertimbangkan, bagaimanapun, adalah bahwa semua konten (termasuk kunci pribadi) dari .sshfolder akan dibagikan sehingga pendekatan ini hanya diinginkan untuk pengembangan dan hanya untuk gambar kontainer tepercaya.

Kontainer Docker harus dilihat sebagai 'layanan' mereka sendiri. Untuk memisahkan masalah Anda harus memisahkan fungsi:

1) Data harus dalam wadah data: gunakan volume tertaut untuk mengkloning repo. Wadah data itu kemudian dapat dihubungkan ke layanan yang membutuhkannya.

2) Gunakan sebuah wadah untuk menjalankan tugas kloning git, (yaitu hanya pekerjaan kloning) yang menghubungkan wadah data ke dalamnya ketika Anda menjalankannya.

3) Sama untuk ssh-key: letakkan itu volume (seperti yang disarankan di atas) dan tautkan ke layanan git clone saat Anda membutuhkannya

Dengan begitu, baik tugas kloning dan kuncinya adalah fana dan hanya aktif bila diperlukan.

Sekarang jika aplikasi Anda sendiri adalah antarmuka git, Anda mungkin ingin mempertimbangkan API REST github atau bitbucket secara langsung untuk melakukan pekerjaan Anda: untuk itulah mereka dirancang.

Baris ini merupakan masalah:

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

Saat menentukan file yang ingin Anda salin ke dalam gambar, Anda hanya dapat menggunakan jalur relatif - relatif terhadap direktori tempat Dockerfile Anda berada. Jadi, Anda sebaiknya menggunakan:

ADD id_rsa /root/.ssh/id_rsa

Dan letakkan file id_rsa ke direktori yang sama dengan Dockerfile Anda.

Lihat ini untuk lebih jelasnya: http://docs.docker.io/reference/builder/#add

Kami memiliki masalah yang sama ketika melakukan npm install di docker build time.

Terinspirasi dari solusi dari Daniel van Flymen dan menggabungkannya dengan git url menulis ulang , kami menemukan metode yang lebih sederhana untuk mengotentikasi instalasi npm dari repositori github pribadi - kami menggunakan token oauth2 alih-alih kunci.

Dalam kasus kami, dependensi npm ditentukan sebagai "git + https://github.com/ ..."

Untuk otentikasi dalam wadah, url harus ditulis ulang agar sesuai untuk otentikasi ssh (ssh: //[email protected]/) atau otentikasi token (https: // $ {GITHUB_TOKEN} @ github.com /)

Membangun perintah:

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

Sayangnya, saya di buruh pelabuhan 1.9, jadi --squash opsi belum ada, akhirnya perlu ditambahkan

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

Teruskan soket otentikasi ssh ke wadah:

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

Script Anda akan dapat melakukan a git clone .

Ekstra: Jika Anda ingin file yang dikloning milik pengguna tertentu yang perlu Anda gunakan chownkarena menggunakan pengguna lain selain root di dalam wadah akan membuatgit gagal.

Anda dapat melakukan penerbitan ini ke lingkungan kontainer beberapa variabel tambahan:

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

Setelah Anda mengkloning, Anda harus menjalankan chown $OWNER_USER:$OWNER_GROUP -R <source_folder>untuk mengatur kepemilikan yang tepat sebelum Anda meninggalkan wadah sehingga file dapat diakses oleh pengguna non-root di luar wadah.

Seperti eczajk sudah mengomentari jawaban Daniel van Flymen itu tampaknya tidak aman untuk menghapus kunci dan menggunakan --squash, karena mereka masih akan terlihat dalam sejarah ( docker history --no-trunc).

Sebagai gantinya dengan Docker 18.09, Anda sekarang dapat menggunakan fitur "build secrets". Dalam kasus saya, saya menggandakan repo git pribadi menggunakan kunci SSH host saya dengan yang berikut di Dockerfile saya:

# syntax=docker/dockerfile:experimental

[...]

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

[...]

Untuk dapat menggunakan ini, Anda harus mengaktifkan backend BuildKit baru sebelum menjalankan docker build:

export DOCKER_BUILDKIT=1

Dan Anda perlu menambahkan --ssh defaultparameter kedocker build .

Info lebih lanjut tentang ini di sini: https://medium.com/@tonistiigi/build-secrets-and-ssh-forwarding-in-docker-18-09-ae8161d066

Masalah ini benar-benar menyebalkan. Karena Anda tidak dapat menambahkan / menyalin file apa pun di luar konteks dockerfile, yang berarti tidak mungkin untuk hanya menautkan ~ / .ssh / id_rsa ke /root/.ssh/id_rsa gambar, dan ketika Anda benar-benar memerlukan kunci untuk melakukan beberapa hal sshed seperti git klon dari tautan repo pribadi ..., selama pembuatan gambar buruh pelabuhan Anda.

Bagaimanapun, saya menemukan solusi untuk menyelesaikannya, tidak begitu membujuk tetapi berhasil bagi saya.

1. di dockerfile Anda:

   • tambahkan file ini sebagai /root/.ssh/id_rsa
   • lakukan apa yang Anda inginkan, seperti git clone, komposer ...
   • rm /root/.ssh/id_rsa di akhir

2. skrip yang harus dilakukan dalam satu pemotretan:

   • cp kunci Anda ke folder holding dockerfile
   • membangun buruh pelabuhan
   • rm kunci yang disalin

3. kapan saja Anda harus menjalankan sebuah wadah dari gambar ini dengan beberapa persyaratan ssh, cukup tambahkan -v untuk perintah jalankan, seperti:

   run docker -v ~ / .ssh / id_rsa: /root/.ssh/id_rsa - nama perintah wadah image

Solusi ini tidak menghasilkan kunci pribadi di sumber proyek Anda dan gambar buruh pelabuhan yang dibangun, jadi tidak ada masalah keamanan yang perlu dikhawatirkan lagi.

Saya mengalami masalah yang sama hari ini dan sedikit memodifikasi versi dengan posting sebelumnya saya menemukan pendekatan ini lebih bermanfaat bagi saya

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

(Perhatikan bahwa hanya baca flag sehingga kontainer tidak akan mengacaukan kunci ssh saya.)

Di dalam wadah sekarang saya dapat menjalankan:

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

Jadi saya tidak mendapatkan Bad owner or permissions on /root/.ssh/..kesalahan yang dicatat oleh @kross

'Anda dapat secara selektif membiarkan server jauh mengakses agen ssh lokal Anda seolah-olah itu berjalan di server'

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

Anda juga dapat menautkan direktori .ssh Anda antara tuan rumah dan wadah, saya tidak tahu apakah metode ini memiliki implikasi keamanan tetapi mungkin metode yang paling mudah. Sesuatu seperti ini seharusnya bekerja:

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

Ingatlah bahwa buruh pelabuhan menjalankan dengan sudo (kecuali jika Anda tidak), jika ini adalah kasus Anda akan menggunakan kunci ssh root.

Mulai dari docker API 1.39+(Periksa versi API dengan docker version) docker build memungkinkan --sshopsi dengan soket agen atau kunci untuk memungkinkan Docker Engine meneruskan koneksi agen SSH.

Bangun Komando

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

Info lebih lanjut:

• 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

Jika Anda tidak peduli dengan keamanan kunci SSH Anda, ada banyak jawaban bagus di sini. Jika ya, jawaban terbaik yang saya temukan adalah dari tautan di komentar di atas ke komentar GitHub ini oleh diegocsandrim . Sehingga orang lain lebih mungkin melihatnya, dan kalau-kalau repo itu hilang, berikut adalah versi yang diedit dari jawaban itu:

Sebagian besar solusi di sini akhirnya meninggalkan kunci pribadi dalam gambar. Ini buruk, karena siapa pun yang memiliki akses ke gambar memiliki akses ke kunci pribadi Anda. Karena kita tidak cukup tahu tentang perilakusquash , ini mungkin masih menjadi masalah bahkan jika Anda menghapus kunci dan menekan lapisan itu.

Kami membuat URL pre-sign untuk mengakses kunci dengan aws s3 cli, dan membatasi akses selama sekitar 5 menit, kami menyimpan URL pre-sign ini ke dalam file di direktori repo, kemudian di dockerfile kami menambahkannya ke gambar.

Di dockerfile kami memiliki perintah RUN yang melakukan semua langkah ini: gunakan URL pra-sing untuk mendapatkan kunci ssh, jalankan npm install, dan hapus kunci ssh.

Dengan melakukan ini dalam satu perintah tunggal kunci ssh tidak akan disimpan dalam lapisan apa pun, tetapi URL pra-tandatangan akan disimpan, dan ini bukan masalah karena URL tidak akan valid setelah 5 menit.

Skrip build terlihat seperti:

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

Dockerfile terlihat seperti ini:

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

Dalam versi selanjutnya dari buruh pelabuhan (17.05) Anda dapat menggunakan multi stage builds . Yang merupakan opsi paling aman karena bangunan sebelumnya hanya dapat digunakan oleh bangunan berikutnya dan kemudian dihancurkan

Lihat jawaban untuk pertanyaan stackoverflow saya untuk info lebih lanjut

Tinjauan singkat tentang tantangan SSH di dalam wadah Docker dirinci di sini . Untuk menghubungkan ke remote yang terpercaya dari dalam sebuah wadah tanpa membocorkan rahasia ada beberapa cara:

• Penerusan agen SSH (khusus Linux, tidak langsung)
• SSH bawaan dengan BuildKit (Eksperimental, belum didukung oleh Compose)
• Menggunakan bind mount untuk mengekspos ~/.sshke wadah. (Hanya pengembangan, berpotensi tidak aman)
• Rahasia Docker (Cross-platform, menambah kompleksitas)

Selain itu ada juga kemungkinan menggunakan key-store yang berjalan di wadah buruh pelabuhan terpisah yang dapat diakses saat runtime saat menggunakan Compose. Kelemahan di sini adalah kompleksitas tambahan karena mesin yang diperlukan untuk membuat dan mengelola keystore seperti Vault oleh HashiCorp .

Untuk penggunaan kunci SSH dalam wadah Docker yang berdiri sendiri lihat metode yang ditautkan di atas dan pertimbangkan kelemahan masing-masing tergantung pada kebutuhan spesifik Anda. Namun, jika Anda menjalankan di dalam Compose dan ingin membagikan kunci ke aplikasi saat runtime (mencerminkan praktik OP) coba ini:

• Buat docker-compose.envfile dan tambahkan ke file Anda.gitignore file .
• Perbarui docker-compose.ymldan tambahkanenv_file layanan yang memerlukan kunci.
• Akses kunci publik dari lingkungan saat runtime aplikasi, misalnya process.node.DEPLOYER_RSA_PUBKEYdalam kasus aplikasi Node.js.

Pendekatan di atas ideal untuk pengembangan dan pengujian dan, meskipun bisa memenuhi persyaratan produksi, dalam produksi Anda lebih baik menggunakan salah satu metode lain yang diidentifikasi di atas.

Sumber daya tambahan:

• Docker Docs: Gunakan bind mounts
• Docker Docs: Kelola data sensitif dengan rahasia Docker
• Stack Overflow: Menggunakan kunci SSH di dalam wadah buruh pelabuhan
• Stack Overflow: Menggunakan ssh-agent dengan buruh pelabuhan di macOS

Anda dapat menggunakan multi stage build untuk membangun kontainer Ini adalah pendekatan yang dapat Anda ambil: -

Tahap 1 membangun gambar dengan 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

Tahap 2: bangun wadah Anda

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

tambahkan atribut env di file penulisan Anda:

   environment:
      - SSH_PRIVATE_KEY=${SSH_PRIVATE_KEY}

lalu berikan args dari skrip build seperti ini:

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

Dan lepaskan wadah perantara untuk keamanan. Ini akan membantu Anda bersorak.

Cara sederhana dan aman untuk mencapai ini tanpa menyimpan kunci Anda di lapisan gambar Docker, atau melalui senam ssh_agent adalah:

1. Sebagai salah satu langkah di Anda Dockerfile, buat .sshdirektori dengan menambahkan:

   RUN mkdir -p /root/.ssh

2. Di bawah ini menunjukkan bahwa Anda ingin memasang direktori ssh sebagai volume:

   VOLUME [ "/root/.ssh" ]

3. Pastikan bahwa wadah Anda ssh_configtahu di mana menemukan kunci publik dengan menambahkan baris ini:

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

4. Paparkan .sshdirektori pengguna lokal Anda ke wadah saat runtime:

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

   Atau di dockerCompose.ymladd Anda ini di bawah tombol volume layanan:

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

Final Anda Dockerfileharus berisi sesuatu seperti:

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

Saya mencoba mengatasi masalahnya dengan cara lain: menambahkan kunci ssh publik ke gambar. Tetapi dalam percobaan saya, saya menemukan bahwa "buruh pelabuhan cp" adalah untuk menyalin DARI wadah ke host. Butir 3 dalam jawaban dengan berderit sepertinya mengatakan Anda dapat menggunakan buruh pelabuhan untuk menyuntikkan file ke dalam wadah. Lihat https://docs.docker.com/engine/reference/commandline/cp/

kutipan

Salin file / folder dari sistem file wadah ke jalur host. Path relatif terhadap root sistem file.

  Usage: docker cp CONTAINER:PATH HOSTPATH

  Copy files/folders from the PATH to the HOSTPATH

Anda bisa memasukkan kunci yang diotorisasi ke wadah Anda menggunakan folder bersama dan mengatur izin menggunakan file buruh pelabuhan seperti ini:

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

Dan menjalankan docker Anda berisi sesuatu seperti berikut ini untuk berbagi direktori auth pada host (memegang authorised_keys) dengan wadah kemudian buka port ssh yang akan dapat diakses melalui port 7001 pada host.

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

Anda mungkin ingin melihat https://github.com/jpetazzo/nsenter yang tampaknya merupakan cara lain untuk membuka shell pada wadah dan menjalankan perintah dalam wadah.

Terlambat untuk pesta, bagaimana dengan ini yang akan membuat kunci sistem operasi host Anda tersedia untuk root di dalam wadah, dengan cepat:

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

Saya tidak mendukung penggunaan Dockerfile untuk menginstal kunci karena iterasi wadah Anda dapat meninggalkan kunci pribadi.

Anda dapat menggunakan rahasia untuk mengelola data sensitif apa pun yang dibutuhkan wadah saat runtime tetapi Anda tidak ingin menyimpannya di dalam gambar atau dalam kontrol sumber, seperti:

• Nama pengguna dan kata sandi
• Sertifikat dan kunci TLS
• Kunci SSH
• Data penting lainnya seperti nama database atau server internal
• String umum atau konten biner (berukuran hingga 500 kb)

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

Saya mencoba mencari cara menambahkan kunci masuk ke wadah untuk digunakan selama runtime (bukan membangun) dan menemukan pertanyaan ini. Rahasia Docker tampaknya menjadi solusi untuk kasus penggunaan saya, dan karena tidak ada yang menyebutkannya, saya akan menambahkannya.

Dalam kasus saya, saya punya masalah dengan nodejs dan 'npm i' dari repositori jarak jauh. Saya memperbaikinya menambahkan pengguna 'simpul' ke wadah nodejs dan 700 ke ~ / .ssh dalam wadah.

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

setelah itu mulai bekerja

Cara paling sederhana, dapatkan akun launchpad dan gunakan: ssh-import-id

Dalam wadah buruh pelabuhan yang sedang berjalan, Anda dapat mengeluarkan ssh-keygen dengan opsi buruh pelabuhan -i (interaktif). Ini akan meneruskan wadah meminta untuk membuat kunci di dalam wadah buruh pelabuhan.

Untuk debian / root / berwenang_kunci:

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