在 docker 容器中使用 SSH 密钥

Question

我有一个应用程序可以使用 Git 执行各种有趣的东西（例如运行 git clone 和 git push），我正在尝试对其进行 docker 化。

我遇到了一个问题，虽然我需要能够将 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

Answer 1

如果您需要在构建时使用 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

---

更新：如果您使用的是 Docker 1.13 并且具有实验性功能，则可以将 --squash 附加到将合并层的构建命令中，删除 SSH 密钥并将它们隐藏在 @987654332 中@。

Answer 2

原来在使用 Ubuntu 时，ssh_config 不正确。你需要添加

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

到您的 Dockerfile 以使其识别您的 ssh 密钥。

Answer 3

注意：仅将这种方法用于私有且永远是的图像！

ssh 密钥仍存储在映像中，即使您在添加后在层命令中删除了该密钥（请参阅this post 中的 cmets）。

在我的情况下这没问题，所以这就是我正在使用的：

# 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

Answer 4

如果您使用的是docker compose，一个简单的选择是像这样转发 SSH 代理：

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

Answer 5

扩展 Peter Grainger's answer 我能够使用自 Docker 17.05 起可用的 multi-stage build。官方页面声明：

对于多阶段构建，您可以在 Dockerfile 中使用多个 FROM 语句。每条FROM 指令都可以使用不同的基础，并且它们中的每一个都开始构建的新阶段。您可以选择性地将工件从一个阶段复制到另一个阶段，从而在最终图像中留下您不想要的所有内容。

记住这一点是我的Dockerfile 示例，包括三个构建阶段。它旨在创建客户端 Web 应用程序的生产映像。

# 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 命令从 NPM 安装所有必需的依赖项，并通过 SSH 从 Bitbucket 克隆私有 git 存储库。

2)。第二阶段构建并缩小 Web 应用程序的源代码，并将其放置在名为 production 的下一个中间图像的 dist 目录中。请注意，安装的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)。在第三阶段，我们通过仅包含名为 production 的第二个中间映像中的 dist 目录并安装 Node Express 以启动 Web 服务器来减小将标记为 ezze/geoport:0.6.0 的最终映像的大小。

列出图像给出如下输出：

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。

Answer 6

为了在容器中注入 ssh 密钥，您有多种解决方案：

1. 使用带有 ADD 指令的 Dockerfile，您可以在构建过程中注入它

2. 只需做类似cat id_rsa | docker run -i <image> sh -c 'cat > /root/.ssh/id_rsa'的事情

3. 使用docker cp 命令允许您在容器运行时注入文件。

Answer 7

一种跨平台解决方案是使用bind mount 将主机的.ssh 文件夹共享给容器：

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

与代理转发类似，这种方法将使容器可以访问公钥。另一个好处是它也可以与非 root 用户一起使用，并且可以让你连接到 GitHub。然而，需要考虑的一个警告是，.ssh 文件夹中的所有内容（包括私钥）都将被共享，因此这种方法仅适用于开发并且仅适用于受信任的容器映像。

Answer 8

从docker API 1.39+ 开始（使用docker version 检查API 版本）docker build 允许--ssh 选项与代理套接字或密钥一起允许Docker 引擎转发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

更多信息：

• 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

Answer 9

Docker 容器应该被视为它们自己的“服务”。要分离关注点，您应该分离功能：

1) 数据应位于数据容器中：使用链接卷将存储库克隆到其中。然后可以将该数据容器链接到需要它的服务。

2) 使用容器运行 git 克隆任务，（即它的唯一工作是克隆）在运行时将数据容器链接到它。

3) ssh-key 也一样：把它作为一个卷（如上面建议的那样）并在需要时将其链接到 git clone 服务

这样，克隆任务和密钥都是短暂的，仅在需要时才处于活动状态。

现在，如果您的应用程序本身是一个 git 接口，您可能需要考虑直接使用 github 或 bitbucket REST API 来完成您的工作：这就是它们的设计目的。

Answer 10

将 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，因为在容器内使用除 root 以外的其他用户会使git 失败。

您可以将一些附加变量发布到容器的环境中：

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

克隆后，您必须在离开容器之前执行chown $OWNER_USER:$OWNER_GROUP -R <source_folder> 设置正确的所有权，以便容器外的非root 用户可以访问这些文件。

Answer 11

这一行有问题：

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

在指定要复制到映像中的文件时，您只能使用相对路径 - 相对于 Dockerfile 所在的目录。所以你应该改用：

ADD id_rsa /root/.ssh/id_rsa

并将 id_rsa 文件放入 Dockerfile 所在的同一目录中。

查看更多详情：http://docs.docker.io/reference/builder/#add

Answer 12

我们在 docker build time 执行 npm install 时遇到了类似的问题。

受Daniel van Flymen 的解决方案的启发，并将其与git url rewrite 相结合，我们找到了一种更简单的方法来验证来自私有 github 存储库的 npm install - 我们使用 oauth2 令牌而不是密钥。

在我们的例子中，npm 依赖被指定为“git+https://github.com/...”

对于容器中的身份验证，需要重写 url 以适合 ssh 身份验证 (ssh://git@github.com/) 或令牌身份验证 (https://${GITHUB_TOKEN}@github.com/ )

构建命令：

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

不幸的是，我在 docker 1.9 上，所以 --squash 选项还没有，最终需要添加它

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

Answer 13

我今天遇到了同样的问题，我发现这个方法对我更有用

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

（请注意 readonly 标志，因此容器在任何情况下都不会弄乱我的 ssh 密钥。）

现在我可以在容器内运行：

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

所以我没有得到@kross 指出的Bad owner or permissions on /root/.ssh/.. 错误

Answer 14

从 18.09 版本开始就可以使用了！

根据documentation：

docker build 有一个 --ssh 选项以允许 Docker 引擎 转发 SSH 代理连接。

以下是容器中使用 SSH 的 Dockerfile 示例：

# syntax=docker/dockerfile:experimental
FROM alpine

# Install ssh client and git
RUN apk add --no-cache openssh-client git

# Download public key for github.com
RUN 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

创建 Dockerfile 后，使用 --ssh 选项连接 SSH 代理：

$ docker build --ssh default .

另外，看看https://medium.com/@tonistiigi/build-secrets-and-ssh-forwarding-in-docker-18-09-ae8161d066

Answer 15

您可以使用多阶段构建来构建容器 这是您可以采取的方法：-

第 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)"

并移除中间容器以确保安全。 这将帮助你欢呼。

Answer 16

正如 eczajk 已经在 Daniel van Flymen 的回答中评论的那样，删除密钥并使用 --squash 似乎并不安全，因为它们仍然会在历史记录中可见 (docker history --no-trunc)。

现在，您可以使用“构建机密”功能，而不是 Docker 18.09。在我的情况下，我使用我的主机 SSH 密钥克隆了一个私有 git repo，并在我的 Dockerfile 中包含以下内容：

# syntax=docker/dockerfile:experimental

[...]

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

[...]

为了能够使用它，您需要在运行 docker build 之前启用新的 BuildKit 后端：

export DOCKER_BUILDKIT=1

并且你需要将--ssh default参数添加到docker build。

在此处了解更多信息：https://medium.com/@tonistiigi/build-secrets-and-ssh-forwarding-in-docker-18-09-ae8161d066

Answer 17

这个问题真的很烦人。由于您无法在 dockerfile 上下文之外添加/复制任何文件，这意味着无法仅将 ~/.ssh/id_rsa 链接到图像的 /root/.ssh/id_rsa 中，并且当您肯定需要密钥来做一些 sshed 事情时就像来自私人仓库链接的 git clone ...，在构建 docker 映像期间。

无论如何，我找到了一个解决方法，虽然不是那么有说服力，但确实对我有用。

1. 在您的 dockerfile 中：

   • 将此文件添加为 /root/.ssh/id_rsa
   • 随心所欲，如 git clone、composer...
   • rm /root/.ssh/id_rsa 结尾

2. 一次性完成的脚本：

   • cp 保存 dockerfile 的文件夹的密钥
   • docker 构建
   • rm 复制的密钥

3. 任何时候你必须从这个镜像运行一个容器并且有一些 ssh 要求，只需在运行命令中添加 -v，比如：

   docker run -v ~/.ssh/id_rsa:/root/.ssh/id_rsa --name 容器镜像命令

此解决方案导致您的项目源和构建的 docker 映像中没有私钥，因此无需担心安全问题。

Answer 18

'您可以有选择地让远程服务器访问您的本地 ssh-agent，就像它在服务器上运行一样'

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

Answer 19

您也可以在主机和容器之间链接您的 .ssh 目录，我不知道这种方法是否有任何安全隐患，但它可能是最简单的方法。像这样的东西应该可以工作：

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

请记住，docker 使用 sudo 运行（除非您不这样做），如果是这种情况，您将使用根 ssh 密钥。

Answer 20

关于 Docker 容器中的 SSH 挑战的简要概述是 detailed here。为了在不泄露机密的情况下从容器内连接到受信任的遥控器，有几种方法：

• SSH agent forwarding（仅限 Linux，不直接）
• Inbuilt SSH with BuildKit（实验性，not yet supported 由 Compose）
• Using a bind mount 将 ~/.ssh 暴露给容器。 （仅限开发，可能不安全）
• Docker Secrets（跨平台，增加复杂性）

除此之外，还可以使用在使用 Compose 时在运行时可访问的单独 docker 容器中运行的密钥库。这里的缺点是额外的复杂性，因为创建和管理密钥库（例如 Vault by HashiCorp）所需的机制。

对于在独立 Docker 容器中使用 SSH 密钥，请参阅上面链接的方法，并根据您的具体需求考虑每种方法的缺点。但是，如果您在 Compose 中运行并希望在运行时共享应用程序的密钥（反映 OP 的实用性），请尝试以下操作：

• 创建一个docker-compose.env 文件并将其添加到您的.gitignore 文件中。
• 更新您的 docker-compose.yml 并添加 env_file 以获取需要密钥的服务。
• 在应用程序运行时从环境访问公钥，例如process.node.DEPLOYER_RSA_PUBKEY 对于 Node.js 应用程序。

上述方法非常适合开发和测试，虽然它可以满足生产要求，但在生产中最好使用上面确定的其他方法之一。

其他资源：

• Docker Docs: Use bind mounts
• Docker Docs: Manage sensitive data with Docker secrets
• Stack Overflow: Using SSH keys inside docker container
• Stack Overflow: Using ssh-agent with docker on macOS

Answer 21

如果您不关心 SSH 密钥的安全性，这里有很多很好的答案。如果你这样做了，我发现的最佳答案是从上面评论中的链接到this GitHub commentdiegocsandrim。为了让其他人更有可能看到它，并且以防该 repo 消失，这里是该答案的编辑版本：

这里的大多数解决方案最终都会将私钥留在映像中。这很糟糕，因为任何有权访问图像的人都可以访问您的私钥。由于我们对squash 的行为知之甚少，因此即使您删除密钥并挤压该层，情况仍可能如此。

我们生成一个预签名 URL 来使用 aws s3 cli 访问密钥，并限制访问大约 5 分钟，我们将此预签名 URL 保存到 repo 目录中的文件中，然后在 dockerfile 中将其添加到图片。

在 dockerfile 中，我们有一个 RUN 命令来执行所有这些步骤：使用预唱 URL 获取 ssh 密钥，运行 npm install，然后删除 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"]

Answer 22

在不将密钥保存在 Docker 映像层或通过 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" ]

Answer 23

我整理了一个非常简单的解决方案，适用于我的用例，我使用“构建器”docker 映像来构建单独部署的可执行文件。换句话说，我的“构建器”映像永远不会离开我的本地计算机，并且只需要在构建阶段访问私有存储库/依赖项。

您无需为此解决方案更改 Dockerfile。

当您运行容器时，挂载您的 ~/.ssh 目录（这样可以避免将密钥直接烘焙到映像中，而是确保它们在构建过程中的短时间内仅可用于单个容器实例阶段）。就我而言，我有几个构建脚本可以自动化我的部署。

在我的 build-and-package.sh 脚本中，我像这样运行容器：

# 之前做一些脚本的东西 ... 码头运行--rm \ -v ~/.ssh:/root/.ssh \ -v "$workspace":/工作空间\ -w /工作区构建器\ bash -cl "./scripts/build-init.sh $executable" ... # 之后做一些脚本的事情（即将构建的可执行文件拉出工作区等）

build-init.sh 脚本如下所示：

#!/bin/bash

set -eu

executable=$1

# start the ssh agent
eval $(ssh-agent) > /dev/null

# add the ssh key (ssh key should not have a passphrase)
ssh-add /root/.ssh/id_rsa

# execute the build command
swift build --product $executable -c release

因此，我们不是直接在docker run 命令中执行swift build 命令（或任何与您的环境相关的构建命令），而是执行启动ssh-agent 的build-init.sh 脚​​本，然后添加我们的ssh密钥，最后执行我们的swift build 命令。

注意 1：为此，您需要确保您的 ssh 密钥没有密码，否则 ssh-add /root/.ssh/id_rsa 行将要求输入密码并中断构建脚本。

注意 2：确保您对脚本文件设置了正确的文件权限，以便它们可以运行。

希望这能为其他有类似用例的人提供一个简单的解决方案。

Answer 24

起初，一些元噪音

这里有两个高度赞成的答案中有一个危险的错误建议。

我发表了评论，但由于我为此浪费了很多天，请注意：

不要将私钥回显到文件中（意思是：echo "$ssh_prv_key" > /root/.ssh/id_ed25519）。至少在我的情况下，这将破坏所需的行格式。

请改用COPY 或ADD。详情请见Docker Load key “/root/.ssh/id_rsa”: invalid format。

另一位用户也确认了这一点：

我收到错误加载密钥“/root/.ssh/id_ed25519”：格式无效。回声会 为我删除换行符/双引号。这是否仅适用于 ubuntu 还是 alpine:3.10.3 有什么不同？

---

1。一种将私钥保存在映像中的工作方式（不太好！）

如果镜像中存储了私钥，需要注意从git网站删除公钥，或者不要发布镜像。如果你照顾好这个，这是安全的。请参阅下面的 (2.) 以了解更好的方法，您也可以“忘记关注”。

Dockerfile 如下所示：

FROM ubuntu:latest
RUN apt-get update && apt-get install -y git
RUN mkdir -p /root/.ssh && chmod 700 /root/.ssh
COPY /.ssh/id_ed25519 /root/.ssh/id_ed25519
RUN chmod 600 /root/.ssh/id_ed25519 && \
    apt-get -yqq install openssh-client && \
    ssh-keyscan -t ed25519 -H gitlab.com >> /root/.ssh/known_hosts
RUN git clone git@gitlab.com:GITLAB_USERNAME/test.git
RUN rm -r /root/.ssh

---

2。一种不将私钥保留在图像中的工作方式（好！）

以下是同一件事的更安全的方法，改为使用“多阶段构建”。 如果您需要具有 git repo 目录的图像其中一个层中没有存储私钥，则需要两个图像，最后只使用第二个。也就是说，你需要两次FROM，然后你可以copy only the git repo directory from the first to the second image，见official guide "Use multi-stage builds"。

我们使用“alpine”作为最小的基础镜像，它使用apk 而不是apt-get；您也可以在上面的代码中使用apt-get，而不是使用FROM ubuntu:latest。

Dockerfile 如下所示：

# first image only to download the git repo
FROM alpine as MY_TMP_GIT_IMAGE

RUN apk add --no-cache git
RUN mkdir -p /root/.ssh &&  chmod 700 /root/.ssh
COPY /.ssh/id_ed25519 /root/.ssh/id_ed25519
RUN chmod 600 /root/.ssh/id_ed25519

RUN apk -yqq add --no-cache openssh-client && ssh-keyscan -t ed25519 -H gitlab.com >> /root/.ssh/known_hosts
RUN git clone git@gitlab.com:GITLAB_USERNAME/test.git
RUN rm -r /root/.ssh


# Start of the second image
FROM MY_BASE_IMAGE
COPY --from=MY_TMP_GIT_IMAGE /MY_GIT_REPO ./MY_GIT_REPO

我们在这里看到FROM 只是一个名称空间，它就像它下面的行的标题，可以用别名来寻址。如果没有别名，--from=0 将是第一个图像（=FROM 命名空间）。

您现在可以发布或共享第二张图片，因为私钥不在其层中，并且您不必在使用一次后从 git 网站中删除公钥！ 因此，您不需要在每次克隆存储库时创建新的密钥对。当然，请注意，如果有人可能以另一种方式获取您的数据，那么无密码的私钥仍然是不安全的。 如果您对此不确定，最好在使用后从服务器中删除公钥，并在每次运行时使用新的密钥对。

---

如何从 Dockerfile 构建镜像的指南

• 安装 Docker 桌面；或者在 VirtualBox 中使用 WSL2 或 Linux 中的 docker；或者在独立的 Linux 分区/硬盘中使用 docker。

• 打开命令提示符（PowerShell、终端等）。

• 进入 Dockerfile 的目录。

• 创建一个子文件夹“.ssh/”。

• 出于安全原因，为 每个 Dockerfile 运行创建一个新 公有和私有 SSH 密钥对 - 即使您已经有另一个密钥对。在命令提示符下，在 Dockerfile 的文件夹中，输入（注意，这会覆盖而不询问）：

    Write-Output "y" | ssh-keygen -q -t ed25519 -f ./.ssh/id_ed25519 -N '""'
  

  （如果您使用 PowerShell）或

    echo "y" | ssh-keygen -q -t ed25519 -f ./.ssh/id_ed25519 -N ''
  

  （如果您不使用 PowerShell）。

  您的密钥对现在将位于子文件夹 .ssh/ 中。是否使用该子文件夹取决于您，您也可以将代码更改为COPY id_ed25519 /root/.ssh/id_ed25519；那么你的私钥需要在你所在的 Dockerfile 目录中。

• 在编辑器中打开公钥，复制内容并将其发布到您的服务器（例如 GitHub / GitLab --> 个人资料 --> SSH 密钥）。您可以选择任何名称和结束日期。公钥字符串的最终可读注释（如果您没有在ssh-keygen 的参数中添加-C 注释，通常是您的计算机名称）并不重要，只需将其留在那里即可。

• 开始（不要忘记末尾的“.”，它是构建上下文）：

  docker build -t 测试。

仅适用于 1.)：

• 运行后，从服务器中删除公钥（最重要，最多一次）。该脚本会从映像中删除私钥，您也可以从本地计算机中删除私钥，因为您不应再次使用该密钥对。原因：有人可以get the private key from the image even if it was removed from the image。引用a user's评论：

  如果有人掌握了你的 图像，他们可以检索密钥...即使您删除该文件 后面的层，b/c 当你添加它时，他们可以回到第 7 步

  攻击者可以使用此私钥等待，直到您再次使用该密钥对。

仅适用于 2.)：

• 运行后，由于第二个映像是构建后唯一剩余的映像，因此我们不一定需要从客户端和主机中删除密钥对。我们仍然有一个小风险，即无密码私钥是从某处的本地计算机获取的。这就是为什么您仍然可以从 git 服务器中删除公钥的原因。您还可以删除任何存储的私钥。但在许多主要目标是自动构建映像而不是安全性的项目中可能不需要它。

---

最后，再来点元噪音

至于此处两个高度赞成的答案中的危险错误建议，它们使用了有问题的私钥回声方法，以下是撰写本文时的投票： p>

• https://stackoverflow.com/a/42125241/11154841 176 票（前 1 名）
• https://stackoverflow.com/a/48565025/11154841 55 票（前 5 名）
• 虽然这个问题有 326k 的浏览量，但获得了更多：376 次投票

我们在这里看到，答案肯定有问题，因为前 1 名的答案投票至少不是问题投票的水平。

在前 1 个答案的评论列表末尾只有一个小的且未投票的评论，命名相同的私钥回显问题（此答案中也引用了该问题）。并且：这个批评性评论是在回答三年后发表的。

我自己投票选出了前 1 个答案。我后来才意识到它对我不起作用。因此，群体智能正在发挥作用，但在低火上？如果有人可以向我解释为什么回显私钥可能对其他人有用，但对我无效，请发表评论。否则，326k 视图（减去 2 cmets ;)）会忽略或忽略前 1 个答案的错误。 如果那个回显私钥代码行不会花费我很多工作日，我不会在这里写这么长的文本，而且从网上的所有东西中挑选代码绝对令人沮丧。

Answer 25

在更高版本的 docker (17.05) 中，您可以使用multi stage builds。这是最安全的选择，因为以前的构建只能由后续构建使用，然后被销毁

更多信息请见the answer to my stackoverflow question

Answer 26

我正在尝试以另一种方式解决问题：将公共 ssh 密钥添加到图像。但在我的试验中，我发现“docker cp”用于从容器复制到主机。 creak 的回答中的第 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

Answer 27

您可以使用共享文件夹将授权密钥传递到您的容器中，并使用 docker 文件设置权限，如下所示：

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 run 包含类似以下内容，用于与容器共享主机上的 auth 目录（保存授权密钥），然后打开可通过主机上的端口 7001 访问的 ssh 端口。

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

您可能想查看https://github.com/jpetazzo/nsenter，这似乎是在容器上打开外壳并在容器内执行命令的另一种方式。

Answer 28

诚然，聚会迟到了，这样可以让您的主机操作系统密钥在容器内即时可用：

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

我不赞成使用 Dockerfile 来安装密钥，因为容器的迭代可能会留下私钥。

Answer 29

就我而言，我遇到了来自远程存储库的 nodejs 和“npm i”问题。我修复了它在 nodejs 容器中添加了“节点”用户，在容器中添加了 700 到 ~/.ssh。

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

之后就开始工作了

Answer 30

这是我在使用 docker composer 构建映像期间使用 ssh 密钥的方法：

.env

SSH_PRIVATE_KEY=[base64 encoded sshkey]

docker-compose.yml

version: '3'
services:
  incatech_crawler:
    build:
      context: ./
      dockerfile: Dockerfile
      args:
        SSH_PRIVATE_KEY: ${SSH_PRIVATE_KEY} 

码头文件： ...

# Set the working directory to /app
WORKDIR /usr/src/app/
ARG SSH_PRIVATE_KEY 
 
RUN mkdir /root/.ssh/  
RUN echo -n ${SSH_PRIVATE_KEY} | base64 --decode > /root/.ssh/id_rsa_wakay_user