Clonar repositorio privado de git con dockerfile

He copiado este código de lo que parecen ser varios dockerfiles de trabajo, aquí está el mío:

FROM ubuntu

MAINTAINER Luke Crooks "[email protected]"

# Update aptitude with new repo
RUN apt-get update

# Install software 
RUN apt-get install -y git python-virtualenv

# Make ssh dir
RUN mkdir /root/.ssh/

# Copy over private key, and set permissions
ADD id_rsa /root/.ssh/id_rsa
RUN chmod 700 /root/.ssh/id_rsa
RUN chown -R root:root /root/.ssh

# Create known_hosts
RUN touch /root/.ssh/known_hosts

# Remove host checking
RUN echo "Host bitbucket.org\n\tStrictHostKeyChecking no\n" >> /root/.ssh/config

# Clone the conf files into the docker container
RUN git clone [email protected]:Pumalo/docker-conf.git /home/docker-conf

Esto me da el error

Step 10 : RUN git clone [email protected]:Pumalo/docker-conf.git /home/docker-conf
 ---> Running in 0d244d812a54
Cloning into '/home/docker-conf'...
Warning: Permanently added 'bitbucket.org,131.103.20.167' (RSA) to the list of known hosts.
Permission denied (publickey).
fatal: Could not read from remote repository.

Please make sure you have the correct access rights
and the repository exists.
2014/04/30 16:07:28 The command [/bin/sh -c git clone [email protected]:Pumalo/docker-conf.git /home/docker-conf] returned a non-zero code: 128

Esta es la primera vez que uso dockerfiles, pero por lo que he leído (y tomado de las configuraciones de trabajo) no puedo ver por qué esto no funciona.

Mi id_rsa está en la misma carpeta que mi dockerfile y es una copia de mi clave local que puede clonar este repositorio sin problema.

Editar:

En mi dockerfile puedo agregar:

RUN cat /root/.ssh/id_rsa

E imprime la clave correcta, así que sé que se está copiando correctamente.

También intenté hacer lo que Noah me aconsejó y corrí:

RUN echo "Host bitbucket.org\n\tIdentityFile /root/.ssh/id_rsa\n\tStrictHostKeyChecking no" >> /etc/ssh/ssh_config

Esto lamentablemente tampoco funciona.

Mi clave estaba protegida con contraseña, lo que estaba causando el problema, un archivo de trabajo ahora se enumera a continuación (para ayuda de futuros googlers)

FROM ubuntu

MAINTAINER Luke Crooks "[email protected]"

# Update aptitude with new repo
RUN apt-get update

# Install software 
RUN apt-get install -y git
# Make ssh dir
RUN mkdir /root/.ssh/

# Copy over private key, and set permissions
# Warning! Anyone who gets their hands on this image will be able
# to retrieve this private key file from the corresponding image layer
ADD id_rsa /root/.ssh/id_rsa

# Create known_hosts
RUN touch /root/.ssh/known_hosts
# Add bitbuckets key
RUN ssh-keyscan bitbucket.org >> /root/.ssh/known_hosts

# Clone the conf files into the docker container
RUN git clone [email protected]:User/repo.git

Debe crear un nuevo conjunto de claves SSH para esa imagen de Docker, ya que probablemente no desee incrustar allí su propia clave privada. Para que funcione, tendrá que agregar esa clave a las claves de implementación en su repositorio git. Aquí está la receta completa:

1. Genere claves ssh con las ssh-keygen -q -t rsa -N '' -f repo-keyque obtendrá archivos repo-key y repo-key.pub.

2. Agregue repo-key.pub a las claves de implementación de su repositorio.
   En GitHub, vaya a [su repositorio] -> Configuración -> Implementar claves

3. Agregue algo como esto a su Dockerfile:

   AGREGAR clave de repositorio /
   CORRER \
     chmod 600 / repo-key && \  
     echo "IdentityFile / repo-key" >> / etc / ssh / ssh_config && \  
     echo -e "StrictHostKeyChecking no" >> / etc / ssh / ssh_config && \  
     // tus comandos de git clone aquí ...
   

Tenga en cuenta que lo anterior desactiva StrictHostKeyChecking, por lo que no necesita .ssh / known_hosts. Aunque probablemente me guste más la solución con ssh-keyscan en una de las respuestas anteriores.

No hay necesidad de jugar con configuraciones ssh. Use un archivo de configuración (no un Dockerfile) que contenga variables de entorno y haga que un script de shell actualice su archivo docker en tiempo de ejecución. Mantiene los tokens fuera de sus Dockerfiles y puede clonar sobre https (no es necesario generar o pasar claves ssh).

Vaya a Configuración> Tokens de acceso personal

• Genere un token de acceso personal con el repoalcance habilitado.
• Clonar así: git clone https://[email protected]/user-or-org/repo

Algunos comentaristas han notado que si usa un Dockerfile compartido, esto podría exponer su clave de acceso a otras personas en su proyecto. Si bien esto puede o no ser una preocupación para su caso de uso específico, aquí hay algunas formas en que puede lidiar con eso:

• Use un script de shell para aceptar argumentos que puedan contener su clave como variable. Reemplace una variable en su Dockerfile con sedo similar, es decir, llamando al script con el sh rundocker.sh MYTOKEN=fooque reemplazaría https://{{MY_TOKEN}}@github.com/user-or-org/repo. Tenga en cuenta que también puede usar un archivo de configuración (en .yml o el formato que desee) para hacer lo mismo pero con variables de entorno.
• Cree un usuario github (y genere un token de acceso para) solo para ese proyecto

Otra opción es utilizar una construcción de acoplador de varias etapas para garantizar que sus claves SSH no se incluyan en la imagen final.

Como se describe en mi publicación , puede preparar su imagen intermedia con las dependencias necesarias para git clone y luego COPYlos archivos necesarios en su imagen final.

Además, si tenemos LABELnuestras capas intermedias, incluso podemos eliminarlas de la máquina cuando haya terminado.

# Choose and name our temporary image.
FROM alpine as intermediate
# Add metadata identifying these images as our build containers (this will be useful later!)
LABEL stage=intermediate

# Take an SSH key as a build argument.
ARG SSH_KEY

# Install dependencies required to git clone.
RUN apk update && \
    apk add --update git && \
    apk add --update openssh

# 1. Create the SSH directory.
# 2. Populate the private key file.
# 3. Set the required permissions.
# 4. Add github to our list of known hosts for ssh.
RUN mkdir -p /root/.ssh/ && \
    echo "$SSH_KEY" > /root/.ssh/id_rsa && \
    chmod -R 600 /root/.ssh/ && \
    ssh-keyscan -t rsa github.com >> ~/.ssh/known_hosts

# Clone a repository (my website in this case)
RUN git clone [email protected]:janakerman/janakerman.git

# Choose the base image for our final image
FROM alpine

# Copy across the files from our `intermediate` container
RUN mkdir files
COPY --from=intermediate /janakerman/README.md /files/README.md

Entonces podemos construir:

MY_KEY=$(cat ~/.ssh/id_rsa)
docker build --build-arg SSH_KEY="$MY_KEY" --tag clone-example .

Prueba que nuestras claves SSH se han ido:

docker run -ti --rm clone-example cat /root/.ssh/id_rsa

Limpie las imágenes intermedias de la máquina de compilación:

docker rmi -f $(docker images -q --filter label=stage=intermediate)

Para el repositorio de bitbucket, genere la contraseña de la aplicación (configuración de Bitbucket -> Gestión de acceso -> Contraseña de la aplicación, vea la imagen) con acceso de lectura al repositorio y al proyecto.

Entonces el comando que debes usar es:

git clone https://username:[email protected]/reponame/projectname.git

A menudo no desea realizar un git clonerepositorio privado desde la compilación de la ventana acoplable. Hacer el clon allí implica colocar las credenciales ssh privadas dentro de la imagen para que luego puedan ser extraídas por cualquier persona con acceso a su imagen.

En cambio, la práctica común es clonar el repositorio git desde fuera de la ventana acoplable en la herramienta de CI que elija, y simplemente COPYlos archivos en la imagen. Esto tiene un segundo beneficio: el almacenamiento en caché de la ventana acoplable. El almacenamiento en caché de Docker analiza el comando que se ejecuta, las variables de entorno que incluye, los archivos de entrada, etc., y si son idénticos a una compilación anterior del mismo paso principal, reutiliza esa caché anterior. Con un git clonecomando, el comando en sí es idéntico, por lo que Docker reutilizará el caché incluso si se cambia el repositorio externo de git. Sin embargo, un COPYcomando mirará los archivos en el contexto de compilación y podrá ver si son idénticos o si se han actualizado, y usará la memoria caché solo cuando sea apropiado.

Si va a agregar credenciales a su compilación, considere hacerlo con una compilación de varias etapas, y solo coloque esas credenciales en una etapa temprana que nunca se etiquete y empuje fuera de su host de compilación. El resultado se ve así:

FROM ubuntu as clone

# Update aptitude with new repo
RUN apt-get update \
 && apt-get install -y git
# Make ssh dir
# Create known_hosts
# Add bitbuckets key
RUN mkdir /root/.ssh/ \
 && touch /root/.ssh/known_hosts \
 && ssh-keyscan bitbucket.org >> /root/.ssh/known_hosts

# Copy over private key, and set permissions
# Warning! Anyone who gets their hands on this image will be able
# to retrieve this private key file from the corresponding image layer
COPY id_rsa /root/.ssh/id_rsa

# Clone the conf files into the docker container
RUN git clone [email protected]:User/repo.git

FROM ubuntu as release
LABEL maintainer="Luke Crooks <[email protected]>"

COPY --from=clone /repo /repo
...

Más recientemente, BuildKit ha estado probando algunas características experimentales que le permiten pasar una clave ssh como una montura que nunca se escribe en la imagen:

# syntax=docker/dockerfile:experimental
FROM ubuntu as clone
LABEL maintainer="Luke Crooks <[email protected]>"

# Update aptitude with new repo
RUN apt-get update \
 && apt-get install -y git

# Make ssh dir
# Create known_hosts
# Add bitbuckets key
RUN mkdir /root/.ssh/ \
 && touch /root/.ssh/known_hosts \
 && ssh-keyscan bitbucket.org >> /root/.ssh/known_hosts

# Clone the conf files into the docker container
RUN --mount=type=secret,id=ssh_id,target=/root/.ssh/id_rsa \
    git clone [email protected]:User/repo.git

Y puedes construir eso con:

$ DOCKER_BUILDKIT=1 docker build -t your_image_name \
  --secret id=ssh_id,src=$(pwd)/id_rsa .

Tenga en cuenta que esto aún requiere que su clave ssh no esté protegida por contraseña, pero al menos puede ejecutar la compilación en una sola etapa, eliminando un comando COPY y evitando que la credencial ssh forme parte de una imagen.

BuildKit también agregó una característica solo para ssh que le permite tener sus claves ssh protegidas con contraseña, el resultado es el siguiente:

# syntax=docker/dockerfile:experimental
FROM ubuntu as clone
LABEL maintainer="Luke Crooks <[email protected]>"

# Update aptitude with new repo
RUN apt-get update \
 && apt-get install -y git

# Make ssh dir
# Create known_hosts
# Add bitbuckets key
RUN mkdir /root/.ssh/ \
 && touch /root/.ssh/known_hosts \
 && ssh-keyscan bitbucket.org >> /root/.ssh/known_hosts

# Clone the conf files into the docker container
RUN --mount=type=ssh \
    git clone [email protected]:User/repo.git

Y puedes construir eso con:

$ eval $(ssh-agent)
$ ssh-add ~/.ssh/id_rsa
(Input your passphrase here)
$ DOCKER_BUILDKIT=1 docker build -t your_image_name \
  --ssh default=$SSH_AUTH_SOCK .

Nuevamente, esto se inyecta en la compilación sin escribirse nunca en una capa de imagen, lo que elimina el riesgo de que la credencial se filtre accidentalmente.

Para forzar a Docker a ejecutar git cloneincluso cuando las líneas anteriores se han almacenado en caché, puede inyectar un ARG de compilación que cambia con cada compilación para romper el caché. Eso parece como:

# inject a datestamp arg which is treated as an environment variable and
# will break the cache for the next RUN command
ARG DATE_STAMP
# Clone the conf files into the docker container
RUN git clone [email protected]:User/repo.git

Luego, inyecta ese cambio de arg en el comando de construcción docker:

date_stamp=$(date +%Y%m%d-%H%M%S)
docker build --build-arg DATE_STAMP=$date_stamp .

Las soluciones anteriores no funcionaron para bitbucket. Me imaginé que esto funciona:

RUN ssh-keyscan bitbucket.org >> /root/.ssh/known_hosts \
    && eval `ssh-agent` \
    && ssh-add ~/.ssh/[key] \
    && git clone [email protected]:[team]/[repo].git