Gerenciar Contêineres Linux com Docker no Ubuntu

Versão: 1.0
Autores: Srijan Kishore
Última edição: 02 /Jul/2014

Este guia explica como instalar o Docker e gerenciar máquinas virtuais de forma eficaz. O Docker é uma plataforma de virtualização Linux de código aberto para desenvolvedores e administradores de sistema construírem, implantarem e executarem aplicativos distribuídos facilmente. O Docker consiste no Docker Engine, uma camada de execução leve e virtualização, ferramentas para empacotar e versionar máquinas virtuais semelhantes a um repositório de código-fonte e Docker Hub, um serviço na nuvem para compartilhar aplicativos e automatizar fluxos de trabalho. O Docker permite que aplicativos sejam rapidamente montados a partir de componentes e elimina a fricção entre ambientes de desenvolvimento, controle de qualidade e produção.

1 Nota Preliminar

No meu caso, tenho o Ubuntu 14.04 no qual vou instalar o docker. No mercado de software de virtualização, temos várias tecnologias de virtualização de hardware completo disponíveis, como KVM, Xen ou Hyper-V. Mas as visualizações completas são muito pesadas para virtualizar aplicativos únicos no Linux. Podemos superar essa situação usando Contêineres Linux, que é uma boa alternativa para a visualização em nível de sistema operacional. Os Contêineres Linux são muito úteis para ter um ambiente de desenvolvimento/teste em um conjunto seguro de contêineres. O Docker fornece um ambiente de Contêiner Linux para esse propósito.

2 Instalação

Como mencionei acima, tenho o Ubuntu no qual vou instalar o docker. Neste capítulo, mostrarei 2 opções para instalar o docker, na 2a uso a versão do docker do repositório do Ubuntu, esta versão é mantida pelo Ubuntu por 5 anos de suporte LTS, mas não é a versão mais recente. Na 2b, usarei a versão mais recente do repositório ppa do Ubuntu. Como o docker está em desenvolvimento intenso, a versão mais recente do Docker da 2b) provavelmente atenderá à maioria dos usuários. Por favor, use o método 2a ou 2b, mas não ambos ao mesmo tempo!

2a Instalar do repositório oficial do Ubuntu

Para instalar, use:

sudo apt-get update  
sudo apt-get install docker.io

e crie um symlink para facilitar o uso no shell.

sudo ln -sf /usr/bin/docker.io /usr/local/bin/docker  
sudo sed -i '$acomplete -F _docker docker' /etc/bash_completion.d/docker.io

2b Instalar a versão mais recente do docker

Para instalar a versão mais recente do docker do repositório docker.io, execute este comando

curl -s https://get.docker.io/ubuntu/ | sudo sh

3 Preparar o ambiente do shell

Agora vou adicionar meu usuário=srijan ao grupo docker

sudo usermod -a -G docker srijan

Ou use:

sudo usermod -a -G docker $USER

Aqui eu vou sair da minha sessão atual e fazer login novamente. Agora vou adicionar o arquivo de configuração do docker para notificar o sistema sobre sua localização.

sudo vi /etc/default/docker.io

| DOCKER="/usr/bin/docker.io" |

Agora reinicie o serviço da seguinte forma:

sudo service docker.io restart

4 Gerenciamento de Contêineres

Vou iniciar um contêiner com o sistema operacional Ubuntu. Vou baixar a imagem do docker da seguinte forma:

docker pull ubuntu

 Nota: pull é usado para puxar uma imagem ou um repositório do registro

Agora vou fazer login no shell bash do contêiner ubuntu usando:

docker run -i -t ubuntu /bin/bash

Apenas para confirmação, vou verificar meu IP do contêiner da seguinte forma:

root@fd98ee950252:/# ifconfig 
eth0      Link encap:Ethernet  HWaddr 5a:a6:c6:88:f2:48  
          inet addr:172.17.0.3  Bcast:0.0.0.0  Mask:255.255.0.0
          inet6 addr: fe80::58a6:c6ff:fe88:f248/64 Scope:Link
          UP BROADCAST RUNNING  MTU:1500  Metric:1
          RX packets:7 errors:0 dropped:2 overruns:0 frame:0
          TX packets:8 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000 
          RX bytes:558 (558.0 B)  TX bytes:648 (648.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:1500  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)

root@fd98ee950252:/#

Eu tenho um IP de 172.17.0.3 no meu contêiner. Da mesma forma, posso usar outros contêineres também. Para sair do contêiner, basta digitar:

exit

Da mesma forma, você pode ter outros contêineres de SO, por exemplo.

Quero usar o contêiner Debian, usarei o código:

docker run -i -t debian /bin/bash

Se você quiser ter uma distribuição específica, use:

docker run -i -t ubuntu:12.04 /bin/bash

Isso criará o contêiner ubuntu12.04. Vou verificar isso da seguinte forma:

root@44b56100fd1f:/# cat /etc/lsb-release 
DISTRIB_ID=Ubuntu
DISTRIB_RELEASE=12.04
DISTRIB_CODENAME=precise
DISTRIB_DESCRIPTION="Ubuntu 12.04.4 LTS"
root@44b56100fd1f:/#

4 Construindo nossas próprias imagens

Existem duas maneiras de criar uma imagem Docker:

Via o comando docker commit
Via o comando docker build com um Dockerfile

O método docker commit não é atualmente recomendado, pois construir com um Dockerfile é muito mais flexível e poderoso, mas vamos demonstrá-lo por uma questão de completude. Depois disso, focarei no método recomendado de construção de imagens Docker: escrever um Dockerfile e usar o comando docker build.

4.1 Usando Docker commit para criar imagens

Vou criar um contêiner, fazer alterações nesse contêiner como você faria ao alterar o código, e então comprometer essas alterações a uma nova imagem.

Vamos começar criando um contêiner a partir da imagem ubuntu que usamos no passado.

docker run -i -t ubuntu /bin/bash  
root@73527b8b4261:/#

Nota: Por favor, veja acima que root está mostrando o nome do host 73527b8b4261, é o nome do contêiner criado e ele diferirá no seu caso.

Além disso, vou instalar o apache nele:

apt-get install apache2

Eu lancei o contêiner e então instalei o Apache dentro dele. Agora vou usar este contêiner como um servidor web, então vou salvá-lo em seu estado atual.
Isso nos salvará de ter que reconstruí-lo com Apache toda vez que eu criar um novo contêiner. Para fazer isso, vou sair do contêiner, usando o comando exit,
e usar o comando docker commit.

exit

docker commit 73527b8b4261 srijan/apache2 8ce0ea7a1528

Nota: aqui 73527b8b4261 é o nome do meu contêiner e estou usando 8ce0ea7a1528 como Tag para o contêiner, você pode dar qualquer nome de tag ou usar o mesmo.

Suponha que você esqueceu o id do último contêiner criado, você pode usar:

docker ps -l -q

Isso resultará em 73527b8b4261

Nota: 73527b8b4261 é o nome do seu último contêiner criado, ele diferirá no seu caso.*

Vamos olhar para nossa nova imagem. Isso pode ser alcançado da seguinte forma:

docker images srijan/apache2

srijan@vboxtest:~$ docker images srijan/apache2
REPOSITORY          TAG                 IMAGE ID            CREATED             VIRTUAL SIZE
srijan/apache2      8ce0ea7a1528        741155868ac8        6 minutes ago       207.2 MB
srijan@vboxtest:~$

Nota: Aqui 8ce0ea7a1528 foi o nome da tag que usei no momento de salvar o contêiner,   
Nota: 741155868ac8 é o ID da IMAGEM desse contêiner  
Nota: Todos esses valores diferirão no seu caso, pois no momento de salvar o contêiner, o docker gera nomes aleatórios para eles

Agora vou salvar a imagem personalizada da seguinte forma:

docker commit -m="Uma nova imagem personalizada" --author="Srijan Kishore" 73527b8b4261 srijan/apache2:webserver

Isso resultará em:

srijan@vboxtest:~$ docker commit -m="Uma nova imagem personalizada" --author="Srijan Kishore" 73527b8b4261 srijan/apache2:webserver
f0367362eb405c513ac002b5cf172a2c0bc6c8212eab91c613f9ee611cf92fec

Para executar um contêiner a partir de nossa nova imagem, podemos fazer isso usando o comando docker run.

docker run -t -i srijan/apache2:webserver /bin/bash

Podemos verificar nossa imagem comprometida da seguinte forma:

docker inspect srijan/apache2:webserver

srijan@vboxtest:~$ docker inspect srijan/apache2:webserver
[{
    "Architecture": "amd64",
    "Author": "Srijan Kishore",
    "Comment": "Uma nova imagem personalizada",
    "Config": {
        "AttachStderr": false,
        "AttachStdin": false,
        "AttachStdout": false,
        "Cmd": [
            "/bin/bash"
        ],
        "CpuShares": 0,
        "Cpuset": "",
        "Domainname": "",
        "Entrypoint": null,
        "Env": [
            "HOME=/",
            "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
        ],
        "ExposedPorts": null,
        "Hostname": "",
        "Image": "",
        "Memory": 0,
        "MemorySwap": 0,
        "NetworkDisabled": false,
        "OnBuild": null,
        "OpenStdin": false,
        "PortSpecs": null,
        "StdinOnce": false,
        "Tty": false,
        "User": "",
        "Volumes": null,
        "WorkingDir": ""
    },
    "Container": "73527b8b42614f6ecd83fb5f9822d6086988d3b68fd5e32b4afbc7cd415402fd",
    "ContainerConfig": {
        "AttachStderr": true,
        "AttachStdin": true,
        "AttachStdout": true,
        "Cmd": [
            "/bin/bash"
        ],
        "CpuShares": 0,
        "Cpuset": "",
        "Domainname": "",
        "Entrypoint": null,
        "Env": [
            "HOME=/",
            "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
        ],
        "ExposedPorts": null,
        "Hostname": "73527b8b4261",
        "Image": "ubuntu",
        "Memory": 0,
        "MemorySwap": 0,
        "NetworkDisabled": false,
        "OnBuild": null,
        "OpenStdin": true,
        "PortSpecs": null,
        "StdinOnce": true,
        "Tty": true,
        "User": "",
        "Volumes": null,
        "WorkingDir": ""
    },
    "Created": "2014-06-30T12:58:04.973349049Z",
    "DockerVersion": "1.0.1",
    "Id": "f0367362eb405c513ac002b5cf172a2c0bc6c8212eab91c613f9ee611cf92fec",
    "Os": "linux",
    "Parent": "ef83896b7fb99b00b9e0e6ac943826386e7edcef11a3a2f58b42011ab4a4e683",
    "Size": 14463026
}
srijan@vboxtest:~$

Para executar um contêiner a partir de nossa nova imagem, podemos fazer isso usando o comando docker run.

docker run -t -i srijan/apache2:webserver /bin/bash