Clonar repositório git privado com dockerfile

Copiei esse código do que parece ser vários arquivos docker de trabalho, aqui está o meu:

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

Isso me dá o erro

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

É a primeira vez que uso dockerfiles, mas pelo que li (e extraí das configurações de trabalho) não consigo ver por que isso não funciona.

Meu id_rsa está na mesma pasta que meu dockerfile e é uma cópia da minha chave local que pode clonar este repositório sem problemas.

Editar:

No meu dockerfile, posso adicionar:

RUN cat /root/.ssh/id_rsa

E ela imprime a chave correta, para que eu saiba que está sendo copiada corretamente.

Também tentei fazer o que Noé recomendou e corri:

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

Infelizmente, isso também não funciona.

Minha chave foi protegida por senha, causando o problema. Agora, um arquivo de trabalho está listado abaixo (para obter ajuda 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

Você deve criar um novo conjunto de chaves SSH para essa imagem do Docker, pois provavelmente não deseja incorporar sua própria chave privada. Para fazê-lo funcionar, você precisará adicionar essa chave às chaves de implantação no seu repositório git. Aqui está a receita completa:

1. Gere chaves ssh com as ssh-keygen -q -t rsa -N '' -f repo-keyquais você fornecerá os arquivos repo-key e repo-key.pub.

2. Adicione repo-key.pub às chaves de implantação do repositório.
   No GitHub, vá para [seu repositório] -> Configurações -> Implementar chaves

3. Adicione algo assim ao seu Dockerfile:

   ADICIONAR repo-key /
   CORRE \
     chmod 600 / repo-key && \  
     echo "IdentityFile / repo-key" >> / etc / ssh / ssh_config && \  
     echo -e "StrictHostKeyChecking no" >> / etc / ssh / ssh_config && \  
     // seu git clone comanda aqui ...
   

Observe que acima desativa o StrictHostKeyChecking, assim você não precisa de .ssh / known_hosts. Embora eu provavelmente goste mais da solução com o ssh-keyscan em uma das respostas acima.

Não é necessário mexer nas configurações ssh. Use um arquivo de configuração (não um arquivo Docker) que contenha variáveis ​​de ambiente e faça com que um script de shell atualize seu arquivo docker em tempo de execução. Você mantém os tokens fora dos arquivos do Docker e pode clonar por https (não é necessário gerar ou passar chaves ssh).

Vá para Configurações> Tokens de acesso pessoal

• Gere um token de acesso pessoal com o repoescopo ativado.
• Clone assim: git clone https://[email protected]/user-or-org/repo

Alguns comentadores observaram que, se você usar um Dockerfile compartilhado, isso poderá expor sua chave de acesso a outras pessoas em seu projeto. Embora isso possa ou não ser uma preocupação para o seu caso de uso específico, aqui estão algumas maneiras de lidar com isso:

• Use um script de shell para aceitar argumentos que possam conter sua chave como uma variável. Substitua uma variável no seu Dockerfile por sedou similar, ou seja, chamando o script pelo sh rundocker.sh MYTOKEN=fooqual a substituição seria ativada https://{{MY_TOKEN}}@github.com/user-or-org/repo. Observe que você também pode usar um arquivo de configuração (em .yml ou em qualquer formato que desejar) para fazer a mesma coisa, mas com variáveis ​​de ambiente.
• Crie um usuário do github (e gere um token de acesso) apenas para esse projeto

Outra opção é usar uma janela de encaixe de vários estágios para garantir que suas chaves SSH não sejam incluídas na imagem final.

Conforme descrito no meu post, você pode preparar sua imagem intermediária com as dependências necessárias para o git clone e, em seguida, COPYos arquivos necessários na sua imagem final.

Além disso, se tivermos LABELnossas camadas intermediárias, podemos excluí-las da máquina quando terminar.

# 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

Podemos então construir:

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

Prove que nossas chaves SSH se foram:

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

Limpe imagens intermediárias da máquina de construção:

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

Para o repositório de bitbucket, gere a Senha do aplicativo (Configurações de Bitbucket -> Gerenciamento de acesso -> Senha do aplicativo, veja a imagem) com acesso de leitura ao repositório e projeto.

Em seguida, o comando que você deve usar é:

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

Geralmente, você não deseja executar um git clonerepo particular de dentro da construção da janela de encaixe. Fazer o clone lá envolve colocar as credenciais ssh privadas dentro da imagem, para que possam ser extraídas posteriormente por qualquer pessoa com acesso à sua imagem.

Em vez disso, a prática comum é clonar o repositório git de fora da janela de encaixe na sua ferramenta de CI preferida e simplesmente COPYos arquivos na imagem. Isso tem um segundo benefício: cache do docker. O armazenamento em cache do Docker examina o comando que está sendo executado, as variáveis ​​de ambiente que ele inclui, os arquivos de entrada etc., e se eles são idênticos a uma compilação anterior da mesma etapa pai, reutilizam esse cache anterior. Com um git clonecomando, o próprio comando é idêntico; portanto, o docker reutilizará o cache, mesmo que o repositório git externo seja alterado. No entanto, um COPYcomando examinará os arquivos no contexto de construção e poderá ver se eles são idênticos ou foram atualizados e usará o cache somente quando for apropriado.

Se você deseja adicionar credenciais à sua compilação, considere fazê-lo com uma compilação de vários estágios e apenas coloque essas credenciais em um estágio inicial que nunca seja marcado e enviado para fora do host da compilação. O resultado se parece com:

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
...

Mais recentemente, o BuildKit testou alguns recursos experimentais que permitem passar uma chave ssh como uma montagem que nunca é gravada na imagem:

# 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

E você pode criar isso com:

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

Observe que isso ainda exige que sua chave ssh não seja protegida por senha, mas você pode pelo menos executar a compilação em um único estágio, removendo um comando COPY e evitando que a credencial ssh faça parte de uma imagem.

O BuildKit também adicionou um recurso apenas para ssh, que permite que você ainda tenha suas chaves ssh protegidas por senha; o resultado é o seguinte:

# 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

E você pode criar isso com:

$ 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 .

Novamente, isso é injetado na compilação sem nunca ser gravado em uma camada de imagem, eliminando o risco de a credencial vazar acidentalmente.

Para forçar o docker a executar o git clonemesmo quando as linhas anteriores foram armazenadas em cache, você pode injetar um ARG de compilação que muda a cada compilação para interromper o cache. Isso se parece com:

# 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

Em seguida, você injeta a alteração do argumento no comando docker build:

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

As soluções acima não funcionaram para o bitbucket. Achei que isso funciona:

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