No CoreOS, configure seu próprio registro do Docker

• CoreOS + Docker
• Puxando e executando o registro mais recente
• Configuração do registro
• Cache Redis (opcional)
• Construindo o contêiner
• Configure seu cliente Docker local
• Qual é o próximo?

Todos conhecemos e amamos o Docker, uma plataforma para criar, gerenciar e distribuir contêineres de aplicativos em várias máquinas. A Docker Inc. fornece um serviço para hospedar contêineres de código aberto para serem baixados (ou extraídos) como um repositório git conhecido como "Registro do Docker". Pense nisso como um contêiner do GitHub for Docker.

Mas e se você quiser hospedar seu próprio registro separado do público? Bem, a Docker Inc. abriu seu aplicativo de registro no GitHub.

Este tutorial levará você ao processo de configuração de um registro privado do Docker usando o CoreOS em um novo VPS.

CoreOS + Docker

Não vamos gastar muito tempo analisando exatamente o que o Docker e o CoreOS podem fazer, pois está fora do escopo deste tutorial. Em essência, o CoreOS foi projetado para grandes clusters de servidores, é pequeno, rápido e recebe atualizações regulares de segurança automaticamente. Seu sistema de arquivos raiz também é somente leitura, o que significa que você deve usar o Docker para executar qualquer tipo de software que não esteja incluído na instalação base.

Isso faz do Core OS um sistema host perfeito para o Docker!

Puxando e executando o registro mais recente

A Docker Inc. forneceu o Registro como uma imagem de nível superior, isso significa que podemos removê-lo com uma simples:

docker pull registry

Isso pode levar alguns minutos, dependendo da velocidade da conexão.

Uma vantagem de ser uma imagem de nível superior também significa que ela recebe suporte e atualizações regulares.

Agora vamos testar o registro. Podemos criar um novo contêiner usando a imagem do registro:

docker run -p 5000:5000 -d --name=basic_registry registry

Para aqueles que não usaram muito o Docker, o -psinalizador significa PORT, ou seja, estamos expondo a porta 5000 do contêiner para a porta 5000 do host.

O -dsinalizador significa que daemonisso fará com que o contêiner seja executado em segundo plano e não imprima a saída na sessão SSH atual. Também queremos nomear esse contêiner de teste básico usando a --nameopção para que possamos gerenciá-lo facilmente mais tarde.

Verifique se o contêiner básico do registro está sendo executado docker ps. A saída deve ser semelhante a:

CONTAINER ID        IMAGE               COMMAND                CREATED             STATUS              PORTS                    NAMES
edfb54e4a8c4        registry:0.8.1      "/bin/sh -c 'exec do   7 seconds ago       Up 6 seconds        0.0.0.0:5000->5000/tcp   basic_registry

Além disso, visite http://YOUR_IP:5000seu navegador da Web e você receberá uma mensagem como a seguinte:

"docker-registry server (dev) (v0.8.1)"

Observe a palavra deventre parênteses. Isso significa que o servidor está atualmente executando a configuração do desenvolvedor. Veremos mais configurações em breve.

Agora você tem seu próprio registro de contêiner (muito básico) em execução! Mas ainda não terminamos.

Talvez você queira manter isso privado de olhares indiscretos, ou talvez armazene suas imagens no Amazon S3 em vez de armazenamento local. Vamos examinar as várias opções de configuração na próxima seção.

Antes de prosseguirmos, vamos matar o contêiner de teste para não encontrarmos portas conflitantes.

docker kill basic_registry

Configuração do registro

Há duas maneiras pelas quais podemos passar a configuração para o Docker Registry. Uma maneira é passar variáveis ​​de ambiente para um novo contêiner e a outra é adicionar um arquivo de configuração.

Aqui estão algumas das opções de configuração comuns que usaremos:

• loglevel- A quantidade mínima de informações para efetuar logon no console. O padrão é info.
• standalone- Este registro deve agir por conta própria? (Nunca consulta o registro público.) O padrão é true.
• index_endpoint- Se não for autônomo, que outro índice iremos consultar? Padrão index.docker.io.
• cachee cache_lru- Opções referentes ao uso de um cache Redis para arquivos pequenos, abordaremos isso mais adiante.
• storage- Que back-end de armazenamento devemos usar para este servidor? (Neste tutorial, usaremos local).
• storage_path - Se estiver usando armazenamento local, qual diretório devemos usar para manter os arquivos?

Antes de começarmos a trabalhar com a configuração, precisamos de um arquivo base para trabalhar. O arquivo do repositório do Docker Registry no GitHub funcionará perfeitamente:

wget https://raw.githubusercontent.com/docker/docker-registry/0.8/config/config_sample.yml

O arquivo deve ser salvo com êxito com uma saída como:

2014-09-14 14:09:01 (156 MB/s) - 'config_sample.yml' saved [5384/5384]

Ótimo! Agora podemos modificar esse arquivo para atender às nossas necessidades.

O único editor de texto que acompanha o Core OS é vim, mas não se preocupe se você nunca o usou antes, isso explicará passo a passo o que editar e como fazê-lo.

vim config_sample.yml

Depois de abrir o arquivo, pressione o Icanto inferior direito e deve aparecer: -- INSERT --no modo de inserção. Role até a parte inferior do arquivo usando as teclas de seta. Você verá uma seção rotulada prod.

Vamos mudar as duas linhas, as alterações estão abaixo

prod:
    <<: *local
    storage_path: _env:STORAGE_PATH:/data

O que fizemos foi alterar a prodconfiguração para derivar da localseção em vez da s3seção. Em seguida, substituímos o storage_pathpara usar o caminho /datadentro do novo contêiner.

Depois de confirmar que todas as alterações estão corretas, pressione ESCpara sair do modo de inserção e digite :wq(isso significa gravar as alterações no arquivo e sair do vim).

Agora vamos renomear o arquivo para apenas config.yml

mv config_sample.yml config.yml

Cache Redis (opcional)

Se você deseja usar o redis para acelerar o registro do contêiner, é tão simples quanto extrair um novo contêiner do registro público e adicionar mais algumas linhas de configuração.

Primeiro, puxe a imagem de nível superior do Redis:

docker pull redis

Depois que a imagem é extraída com êxito, podemos executá-la e nomeá-la exatamente como fizemos no registro de teste:

docker run -d --name registry-redis redis

Como o redis está na memória, não precisamos fazer nenhuma configuração, pois o vincularemos ao contêiner do registro nas etapas posteriores.

Mais uma vez, verifique se está sendo executado usando docker ps:

CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS               NAMES
54f65641eccf        redis:2.8           "redis-server"      2 seconds ago       Up 1 seconds        6379/tcp            registry-redis

Agora re-abrir o config.ymlem vime entrar modo de inserção apenas como a primeira vez que editou.

Adicione as seguintes linhas abaixo da prodseção, certificando-se de recuar corretamente. Desta vez, estamos apenas adicionando cachee cache_lru.

cache:
    host: _env:REDIS_PORT_6379_TCP_ADDR
    port: _env:REDIS_PORT_6379_TCP_PORT
    db: 0

cache_lru:
    host: _env:REDIS_PORT_6379_TCP_ADDR
    port: _env:REDIS_PORT_6379_TCP_PORT
    db: 1

As variáveis ​​de ambiente REDIS_PORT_6379_TCP_ADDRe REDIS_PORT_6379_TCP_PORTsão passadas para o contêiner do registro mediante ligação com o contêiner Redis.

Com isso, agora você configurou um contêiner Redis que funcionará lado a lado com o contêiner do registro. Agora, para criar o registro!

Construindo o contêiner

Temos todas as configurações definidas e prontas, agora precisamos construir o contêiner de registro real.

Inicie vim Dockerfilepara criar um novo Dockerfile. Entre no modo de inserção e siga as edições abaixo.

FROM registry:latest

# Add the custom configuration file we made 
ADD ./config.yml /docker-registry/config/config.yml

# Create the data directory
RUN mkdir /data

# Set the configuration file to config.yml
env DOCKER_REGISTRY_CONFIG /docker-registry/config/config.yml

# Make sure we use the prod configuration settings 
env SETTINGS_FLAVOR prod

O que fizemos acima é essencialmente estender a imagem do registro para que ele use nosso arquivo de configuração e configurações. Um Dockerfile é um conjunto de instruções de construção para o Docker ler e criar. Se você quiser saber mais sobre os Dockerfiles e sua sintaxe, consulte a documentação oficial do site Docker.

Em seguida, precisamos construir o contêiner para uso.

docker build -t my_registry .


Sending build context to Docker daemon 13.82 kB
Sending build context to Docker daemon 
Step 0 : FROM registry
 ---> e42d15ec8417
Step 1 : ADD ./config.yml /docker-registry/config/config.yml
 ---> 4339f026d459
Removing intermediate container 2d5138fbcd34
Step 2 : RUN mkdir /data
 ---> Running in a090f0bdbfd1
 ---> 8eb27ba6e12a
Removing intermediate container a090f0bdbfd1
Step 3 : env DOCKER_REGISTRY_CONFIG /docker-registry/config/config.yml
 ---> Running in 565b5bfb2b22
 ---> 914462e46dc0
Removing intermediate container 565b5bfb2b22
Step 4 : env SETTINGS_FLAVOR prod
 ---> Running in 31a92847b851
 ---> b5949575c374
Removing intermediate container 31a92847b851
Successfully built b5949575c374

Agora estamos prontos para correr!

Vamos criar um diretório em nosso sistema host para montar no contêiner como o /datavolume.

mkdir registry-data

Agora podemos girar um novo contêiner. Se você planeja usar o cache Redis, use o segundo comando abaixo.

# For a non-Redis cache registry
docker run -d -p 5000:5000 -v /home/core/registry-data:/data --name=private_reg my_registry

# For a Redis cached registry (Must have followed Redis Caching section above)
docker run -d -p 5000:5000 -v /home/core/registry-data:/data --name=private_reg --link registry-redis:redis my_registry

Para garantir que seu servidor esteja funcionando corretamente, visite http://YOUR_IP:5000. Você verá a seguinte mensagem:

"docker-registry server (prod) (v0.8.1)"

Observe o (prod)significado de nossas alterações na configuração!

Configure seu cliente Docker local

Agora que temos nosso próprio registro em execução, queremos que o cliente Docker em nossas máquinas locais comece a usá-lo. Normalmente você usaria o comando:, docker loginmas para nosso uso, precisamos adicionar mais um argumento ao comando login:

docker login YOUR_IP:5000

Digite um nome de usuário e senha (pense nisso como criar uma nova conta) e ignore a mensagem que indica que você deve ativá-la.

Em seguida, vamos puxar uma imagem de estoque e enviá-la para o nosso próprio repositório.

# Pull the busybox image from the public registry
docker pull busybox

# Tag it with our IP/URL
docker tag busybox YOUR_IP:5000/busybox

# Push it to our newly made registry
docker push YOUR_IP:5000/busybox

Se tudo correr corretamente, a mensagem final deve estar na linha de:

Pushing tag for rev [a9eb17255234] on 

Parabéns! Você configurou seu próprio repositório docker.

Qual é o próximo?

Aqui estão algumas idéias sobre como melhorar seu novo registro privado:

• Proxy reverso usando Nginx ou Apache para colocar segurança adicional à sua frente, como autenticação HTTP simples.
• Obtenha um domínio para o seu servidor e configure-o para que você possa acessar seu registro com algo como: registry.mysite.com
• Compre (ou faça sua autoassinatura) um certificado SSL para adicionar ainda mais proteção se seus contêineres contiverem informações confidenciais.