Como baixar e usar imagens prontas do repositório Docker

Neste post introdutório vou mostrar como trabalhar com as imagens do Docker Hub.
Tanto é possível usar imagens prontas, como alterá-las e criar novas a partir do zero.
Esta última opção é voltada para usuários mais avançados.
A primeira, permite que usuários novatos possam trabalhar com imagens feitas por profissionais e que podem ser encontradas no repositório oficial do Docker — ou Docker Hub.
Na primeira vez em que você roda uma imagem do Docker Hub, ela é baixada para o seu computador — o Docker usa a cópia local para trabalhar.
Se você ainda não instalou o Docker, confira estes métodos de instalação.
logo docker com bombas nos contêineres
Use o comando docker images para listar (se houver) imagens armazenadas localmente no seu sistema.
O diretório de armazenamento das suas imagens é o ‘/var/lib/docker’, caso você esteja curioso.

O que é possível encontrar no Docker Hub

É possível baixar uma das várias imagens prontas do repositório do Docker. Entre elas, há de várias distribuições, tais como Ubuntu, CentOS, Arch Linux, Debian etc.
Você pode baixar também uma imagem vazia, adequada para quem deseja um modelo (ou esqueleto) para construir a sua própria, “do zero”.
Entre recursos e funcionalidades, o hub oferece os seguintes itens:

  • Repositórios de imagens — encontre, gerencie, armazene suas imagens e baixe outras – da comunidade, privadas ou oficiais.
  • Builds automatizados — crie novas imagens automaticamente durante a mudança de repositório fonte GitHub/Bitbucket.
  • Webhooks — um dos recursos dos builds automatizados, permite disparar ações programadas após uma transferência de sucesso a um repositório.
  • Organizações — cria grupos de trabalho para gerenciar acesso de usuário a repositórios de imagens.
  • Integração ao GitHub e ao Bitbucket — adiciona o Hub e suas imagens Docker ao seu fluxo de trabalho (workflow) atual.

Você pode buscar e baixar imagens públicas do Docker Hub livremente.
Contudo, para enviar e armazenar suas imagens no hub é necessário ter uma conta e assinar o serviço.

Como acessar os repositórios de imagens do Docker

O Hub oferece um local onde desenvolvedores podem montar e armazenar imagens Docker — que podem ser distribuídas publicamente ou apenas dentro da sua equipe de trabalho.
Você pode fazer uma busca por imagens no repositório público com o comando search. Veja um exemplo de busca por imagens relacionadas a distro Linux CentOS:

docker search centos
NAME                          DESCRIPTION                                     STARS     OFFICIAL   AUTOMATED
centos                        The official build of CentOS.                   1960      [OK]       
jdeathe/centos-ssh            CentOS-6 6.7 x86_64 / SCL/EPEL/IUS Repos /...   15                   [OK]
million12/centos-supervisor   Base CentOS-7 with supervisord launcher, h...   9                    [OK]
blalor/centos                 Bare-bones base CentOS 6.5 image                8                    [OK]
nimmis/java-centos            This is docker images of CentOS 7 with dif...   7                    [OK]
torusware/speedus-centos      Always updated official CentOS docker imag...   7                    [OK]
centos/mariadb55-centos7                                                      3                    [OK]
nathonfowlie/centos-jre       Latest CentOS image with the JRE pre-insta...   3                    [OK]
nickistre/centos-lamp         LAMP on centos setup                            3                    [OK]
consol/sakuli-centos-xfce     Sakuli end-2-end testing and monitoring co...   2                    [OK]
feduxorg/centos-postgresql    Centos Image with postgres                      1                    [OK]
softvisio/centos              Centos                                          1                    [OK]
layerworx/centos              CentOS container with etcd, etcdctl, confd...   1                    [OK]
darksheer/centos              Base Centos Image -- Updated hourly             1                    [OK]
lighthopper/orientdb-centos   A Dockerfile for creating an OrientDB imag...   1                    [OK]
yajo/centos-epel              CentOS with EPEL and fully updated              1                    [OK]
ericuni/centos                centos dev                                      0                    [OK]
blacklabelops/centos          CentOS Base Image! Built and Updates Daily!     0                    [OK]
ustclug/centos                 USTC centos                                    0                    [OK]
januswel/centos               yum update-ed CentOS image                      0                    [OK]
jsmigel/centos-epel           Docker base image of CentOS w/ EPEL installed   0                    [OK]
grayzone/centos               auto build for centos.                          0                    [OK]
lighthopper/openjdk-centos    A Dockerfile for creating an OpenJDK image...   0                    [OK]
insaneworks/centos            CentOS 6.5 x86_64 + @update                     0                    [OK]
timhughes/centos              Centos with systemd installed and running       0                    [OK]

Você também pode fazer uma busca no website oficial do Docker. Repositórios privados não serão listados.
No próximo exemplo vou mostrar como baixar uma imagem do Alpine Linux:

docker pull alpine

Veja o resultado do meu download, abaixo:

latest: Pulling from library/alpine
ee54741ab35b: Pull complete 
Digest: sha256:24a36bbc059b1345b7e8be0df20f1b23caa3602e85d42fff7ecd9d0bd255de56
Status: Downloaded newer image for alpine:latest

Neste momento, já é possível ver a imagem na relação de disponíveis localmente:

docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
alpine              latest              90239124c352        9 days ago          4.79 MB

O Alpine é uma distro GNU/Linux construída em torno das bibliotecas musl, libc e do Busybox.
Estas características permitem que seja bastante pequena e muito eficiente em termos de uso de recursos do sistema.
Para rodar no Docker, o contêiner não requer mais do que 8 MB.

Para rodar a imagem, use o comando run.
Uma vez que o Alpine é baseado no Busybox, é fácil iniciar esta imagem rodando-o:

docker run -t -i alpine busybox

Dá para fazer mais do que isto.
Nos exemplos abaixo, determinamos a versão do Alpine em uso no contêiner:

docker run -t -i alpine cat /etc/alpine-release
3.3.1

Quando uma imagem não é encontrada localmente, ela é baixada automaticamente, pelo Docker.
Se você quiser rodar uma shell dentro do contêiner Alpine, use o ash (semelhante ao Bash):

docker run -t -i alpine /bin/ash

Como rodar um servidor LAMP dentro do Docker

Eu sei, eu sei… este assunto merece um post só para ele — ainda assim, insisto em usar este exmplo pra ilustrar a utilidade das imagens prontas do Docker. 😉
Você pode montar o seu próprio servidor LAMP dentro do Docker. Mas também pode baixar uma imagem em que ele já venha pronto.
Neste caso, sugiro a imagem do usuário nickistre, com o CentOS rodando um servidor Linux, Apache, MySQL e PHP.
Baixe a imagem e veja como proceder:

docker pull nickistre/centos

A seguir rode a imagem, com o comando ifconfig (para você saber exatamente em qual IP encontrar o servidor)

docker run -t -i nickistre/centos-lamp ifconfig

Veja o meu resultado:

eth0      Link encap:Ethernet  HWaddr 02:42:AC:11:00:03  
          inet addr:172.17.0.3  Bcast:0.0.0.0  Mask:255.255.0.0
          inet6 addr: fe80::42:acff:fe11:3/64 Scope:Link
          UP BROADCAST MULTICAST  MTU:1500  Metric:1
          RX packets:1 errors:0 dropped:0 overruns:0 frame:0
          TX packets:2 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:0 
          RX bytes:90 (90.0 b)  TX bytes:180 (180.0 b)

lo        Link encap:Local Loopback  
          inet addr:127.0.0.1  Mask:255.0.0.0
          inet6 addr: ::1/128 Scope:Host
          UP LOOPBACK RUNNING  MTU:65536  Metric:1
          RX packets:0 errors:0 dropped:0 overruns:0 frame:0
          TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:0 
          RX bytes:0 (0.0 b)  TX bytes:0 (0.0 b)

Na segunda linha, acima, se encontra o endereço IP, que eu devo acessar, do meu navegador: inet addr:172.17.0.3
Coloque-o no ar e acesse o IP informado no seu navegador favorito:

docker run -t -i nickistre/centos-lamp

Apache server running on CentOS
Esta é uma entre várias formas de se usar imagens prontas em contêineres Docker.
Desenvolvedores web podem achar mais interessante rodar seus servidores desta forma, do que instalar o LAMP inteiro em sua máquina — além de tudo, este método permite alterar e testar diferentes configurações do servidor, sem bagunçar o seu sistema.

Referẽncias

Como instalar e usar o Docker.
https://docs.docker.com/docker-hub/overview/.
http://www.alpinelinux.org/about/.

Como converter uma imagem RAW para QCOW2 e vice-versa.

Cada padrão tem suas aplicações, vantagens e desvantagens.
Quando necessário, é possível fazer a conversão entre eles — o que permite testar e analisar qual o melhor para você.
As imagens RAW são muito simples para se trabalhar, mas tem a desvantagem de usar muito espaço no disco. São uma boa opção se você pretende trabalhar com outras plataformas de virtualização, uma vez que todas reconhecem o formato RAW.
O QCOW2 é um formato feito para uso no QEMU. O nome é uma sigla para QEMU Copy On Write.

O formato QCOW usa uma estratégia de otimização do armazenamento que permite expandir o tamanho do disco virtual com o uso — até chegar ao tamanho máximo, definido na sua criação.

O formato QCOW2 usa compressão zlib e tem a opção de ativar a criptografia de seus dados via AES 128 bits.
No artigo Como criar uma máquina virtual Debian em 5 minutos, usamos uma imagem QCOW2 — que permite transmitir uma imagem de 25 GiB dentro de um arquivo de algumas centenas de MiB.

Como converter do formato RAW para QCOW2

Use o qemu-img com a opção ‘convert’ para realizar a tarefa. Veja um exemplo:

qemu-img convert -O qcow2 imagem-original.raw imagem-convertida.qcow2

A seguir, use a opção ‘info’, para obter informações sobre a nova imagem:

qemu-img info imagem-convertida.qcow2

Note, abaixo, que a imagem tem um tamanho virtual de 10GiB, contra apenas 1.3GiB de tamanho físico.

image: image-convertida.qcow2
file format: qcow2
virtual size: 10.0G (2147483648 bytes)
disk size: 1.3G
cluster_size: 65536
Format specific information:
    compat: 1.1
    lazy refcounts: false

Como converter uma imagem QCOW2 para RAW

Ao converter uma imagem QCOW2 para RAW, tenha em mente que ela tem o potencial de se expandir até o tamanho planejado na sua criação. Portanto, use a opção ‘info’ para saber que tamanho é este e certifique-se de que tem espaço em disco físico suficiente para comportar o novo tamanho.

As imagens RAW ocupam todo o espaço físico alocado imediatamente.
As imagens QCOW2 começam usando apenas um espaço pequeno (o necessário) e vão aumentando até o seu tamanho predeterminado, com o tempo.

O processo de conversão é semelhante ao anterior. Veja:

qemu-img convert -O raw imagem-original.qcow2 imagem-convertida.raw

Obtenha informações sobre a imagem:

$ qemu-img info imagem-convertida.raw
image: imagem-convertida.raw
file format: raw
virtual size: 10G (10737418240 bytes)
disk size: 10G

Como criar em 5 minutos uma máquina virtual Debian com o qemu

Você pode criar e começar a usar uma máquina virtual GNU/Linux (Debian ou outra distro Linux) quase instantaneamente, se usar uma imagem pronta, baixada da web.
Com este procedimento, você pula o processo de especificar exatamente o hardware (com todas as suas características e periféricos) a ser emulado e começa a usar uma máquina genérica e pronta pra rodar.
Nada impede que você altere as especificações de hardware depois.
Leve em conta que o tempo dado no título deste post pode ser menor ou maior — depende da velocidade da sua conexão à internet, antes que você me chame de mentiroso.
Debian girl mini

O que você precisa ter para executar a máquina virtual

Você precisa ter uma imagem customizada do seu sistema operacional rodando sobre uma arquitetura.
Você pode encontrar as imagens desejadas em vários lugares da web. Neste artigo, vou usar uma das que estão no site https://people.debian.org/~aurel32/qemu/.
Se você for lá, vai ver que há várias opções, todas Debian, para várias arquiteturas.
Ao terminar este tutorial, nada impede que você experimente outras, dentre as arquiteturas de hardware disponíveis.
Além da imagem escolhida, é necessário ter o programa QEMU instalado no seu sistema.
Recomendo um espaço em disco de 30 GiB livres — uma vez que a imagem usada neste tutorial pode chegar a 25 GiB.

Como executar uma imagem do qemu

Abra um terminal e comece fazendo (se já não o fez) o download da imagem do Debian:

wget https://people.debian.org/~aurel32/qemu/i386/debian_squeeze_i386_standard.qcow2
_

Em seguida, carregue a imagem:

qemu-system-i386 -hda debian_squeeze_i386_standard.qcow2
_

E pronto.

O QCOW é um formato de arquivo para guardar imagens de discos, para uso do QEMU.
Trata-se de uma abreviatura para “QEMU Copy On Write”.
O sistema faz uso de uma estratégia de otimização do armazenamento que “segura” a alocação dos dados a serem gravados até o momento em que sejam necessários.

Uma nova tela deve surgir, com o Debian em execução:
Tela do Qemu executando o Debian 6.0 Squeeze

Detalhes do sistema

Este sistema Debian 6.0 Squeeze vem dentro de uma imagem com 25 GiB, em formato QCOW2.
A imagem standard, corresponde a uma instalação Debian padrão, sem o ambiente gráfico — com apenas 128 MiB de memória RAM, esta situação seria sofrível, para dizer o mínimo.
Se você faz questão do ambiente gráfico, você pode instalá-lo ou optar pela outra imagem https://people.debian.org/~aurel32/qemu/i386/debian_squeeze_i386_desktop.qcow2.
Enfim, os nomes de usuário e senhas:

  • Usuário: root e senha: root.
  • Usuário: user e senha: user.

O teclado padrão é o dos Estados Unidos.
Se você quiser aumentar a quantidade de memória, use a opção -m, assim:

qemu-system-i386 -m 256 -hda debian_squeeze_i386_standard.qcow2

Divirta-se!

Fonte: https://people.debian.org/~aurel32/qemu/i386/README.txt