Começando com Docker

Quando falamos em desenvolvimento de softwre é comum ter diversos ambientes, por exemplo:

  • Desenvolvimento
  • Teste
  • Homologação
  • Produção

E outra coisa comum no mundo de desenvolvimento é ter divergências entre estes ambientes.

Quem nunca ouviu a frase:

“Na minha máquina funciona!”?

Nesse post vamos abordar o Docker como uma alternativa para minimizar essa divergência.

Mas o que é o Docker?

O Docker é um sistema de virtualização não convencional. Mas o que isso quer dizer?
Em virtualizações convencionais temos um software instalado na máquina Host que irá gerenciar as máquinas virtuais (ex.: VirtualBox, VMWare, Parallels e etc…).

Para cada máquina virtual temos uma instalação completa do S.O. que queremos virtualizar, além de ter o próprio hardware virtualizado.

Se por exemplo eu precisar de uma biblioteca comum para todas as máquinas virtuais, preciso instalar em cada uma delas.

O Docker usa uma abordagem diferente, ele utiliza o conceito de container. Como assim container?

Compreendendo o conceito de containers

Se pensarmos em transporte de cargas, container foi uma revolução nessa àrea. Pois antes deles o tempo de carregar e descarregar um navio era gigantesco e o trabalho era feito manualmente. Sem contar perdas (devido a quebras ou deterioração), desvio e outros problemas.

Com a chegada dos containers foi possível transportar mercadorias de uma forma segura, de fácil manipulação e com pouco, ou nenhum, trabalho braçal no carregamento ou descarregamento. E é justamente isso que o Docker tenta fazer com nossos softwares.

Ganhos ao usar containers do Docker

Imagine nosso software como uma mercadoria a ser transportar como por exemplo, do ambiente de Desenvolvimento para Produção.

Para fazer isso precisamos garantir que nosso ambiente de Produção tenha todos os pré-requisitos instalados, de preferência uma versão do S.O. parecida com a do ambiente de Desenvolvimento entre outros cuidados que devem ser tomados (relacionados a permissionamento, serviços dependentes e etc…).

Com o Docker temos um container com nosso software. Esse container é levado inteiro para o outro ambiente.

Com isso não precisamos nos preocupar com pré-requisitos instalados no outro ambiente, versão do S.O., permissionamento e se quisermos podemos ter containers para os serviços dependentes também. Dessa forma minimizamos muito a divergência entre os ambientes.

Mas como o Docker faz isso?

Essa ideia de container já é bem antiga e a princípio o Docker usava internamente um projeto chamado LXC (Linux Container).

O projeto LXC usa por baixo dos panos diversas funcionalidades presentes no Kernel do Linux. Abaixo vou listar algumas dessas funcionalidades:

  • chroot – Reponsavel por mapear os diretórios do S.O. e criar o ponto de montagem (/, /etc, /dev, /proc entre outros).
  • cgroup – Reponsável por controlar os recursos por processo. Com ele podemos por exemplo limitar o uso de memória e/ou processador para um processo específico.
  • kernel namespace – Com ele podemos isolar processos, ponto de montagem entre outras coisas. Com esse isolamento, conseguimos a sensação de estar usando uma máquina diferente da máquina host. Pois enxergamos somente o ponto de montagem especifico e processos especificos, inclusive nossos processos começam com PID baixo.
  • kernel capabilities – Entre outras coisas, conseguimos rodar alguns comandos de forma privilegiada.

Mão na massa

Agora que temos uma noção do que é e para que serve o Docker, vamos fazer o download da ferramenta e começar nesse mundo de containers.

Instalando o Docker

Atualmente Docker está disponível em duas versões Docker Community Edition(CE) e Docker Enterprise Edition(EE).

Em ambas as versões temos acesso a toda a API, basicamente a diferença entre as duas versões é o perfil desejado de aplicações. No EE temos um ambiente homologado pela Docker com toda infraestrutura certificada, segura pensada para o mundo enterprise. Já na versão CE podemos chegar ao mesmo nível que EE porém de uma forma manual.

Nesse link você pode encontrar as distribuições para downloads em cada sistema operacional disponível e os passos para instalação.

Feito a instalação, execute esse comando no terminal docker --version. Se a instalação ocorreu com sucesso deve ser impresso algo semelhante a isso Docker version 17.03.1-ce, build c6d412e.

Imagens

O Docker trabalha com o conceito de images, ou seja, para colocar um container em funcionamento o Docker precisa ter a imagem no host.

Essas imagens podem ser baixadas de um repositório (a nomenclatura para esse repositório é registry) ou criadas localmentes e compiladas. Esse é o link para o registry do Docker.

Nesse registry podemos ter imagens oficiais e não oficiais. Além de podermos criar nossas próprias imagens, também é possível fazer upload dela em um registry.

Baixando Imagens

Para baixar uma imagem podemos usar o comando docker pull e o nome da imagem que queremos baixar. Vamos baixar a imagem do Ubuntu, para isso execute o seguinte comando no terminal: docker pull ubuntu.

Resultado docker pull ubuntu

Aqui o Docker baixou nossa imagem. Percebam que uma imagem é composta de várias camadas, por esse motivo teve que fazer vários Downloads/Pulls.

Listando imagens baixadas

Para listar todas as imagens podemos usar o comando docker images. O retorno desse comando é algo semelhante a isso:

O nome da imagem é exibido na coluna REPOSITORY, cada imagem tem um identificador único que é exibido na coluna IMAGE ID. A coluna TAG indica a “versão” da imagem do ubuntu. O latest quer dizer que é a última “versão” da imagem (a mais recente).

Executando Containers

A partir da imagem podemos iniciar quantos containers quisermos através do comando docker run.

Para acessarmos um terminal do Ubuntu podemos usar o comando docker run -i -t ubuntu ou docker run -it ubuntu. O parâmetro -i indica que queremos um container interativo, o -t indica que queremos anexar o terminal virtual tty do container ao nosso host.

Listando containers em execução

Para ver os containers em execução podemos usar o comando docker ps (em outro terminal ou aba), e ele exibirá um retorno parecido com esse:

Aqui temos informações sobre os containers em execução, como id, imagem base, comando inicial, há quanto tempo foi criado, status, quais portas estão disponíveis e/ou mapeadas para acesso e o nome do mesmo. Quando não especificamos um nome ao iniciá-lo, será gerado um nome aleatóriamente.

Quando encerramos um container ele não será mais exibido na saida do comando docker ps, porém isso não significa que o container não existe mais. Para verificar os containers existentes que foram encerrados podemos usar o comando docker ps -a e teremos uma saída parecida com essa:

Como o próprio status do container informa, o mesmo já saiu de execução e no nosso caso saiu com status 0 (ou seja saiu normalmente).

Removendo containers

Para remover o container podemos usar o comando docker rm e informar o id do container ou o nome dele. Para nosso caso poderíamos executar o comando docker rm 43aac92b4c99 ou docker rm dreamy_bassi para remover o container por completo.

Caso tenhamos a necessidade de remover todos os container (em execução ou encerrados) podemos usar o comando docker rm $(docker ps -qa). A opção -q do comando docker ps tem como saída somente os ids dos containers, essa lista de ids é passado para o docker rm e com isso será removido todos os containers.

Só será possível remover um container caso o mesmo não esteja em execução, do contrário temos que encerrar o container para removê-lo.

Como são feitas as imagens?

Nesse momento podemos pensar que o Docker é meio mágico (e é…kkk). Dado uma imagem ele pode rodar um ou mais containers com pouco esforço, mas como são feitas as images?

Uma imagem pode ser criada a partir de um arquivo de definição chamado de Dockerfile, nesse arquivo usamos algumas diretivas para declarar o que teremos na nossa imagem. Por exemplo se olharmos a definição da imagem do Ubuntu podemos ver algo semelhante a isso:

FROM scratch
ADD ubuntu-xenial-core-cloudimg-amd64-root.tar.gz /
.
.
.
RUN mkdir -p /run/systemd && echo 'docker' > /run/systemd/container

CMD ["/bin/bash"]

Para ver o Dockerfile completo consulte aqui.

Com um arquivo Dockerfile podemos compilá-lo com o comando docker build. Ao compilar um arquivo Dockerfile temos uma imagem. Mas isso é um assunto para um próximo post.

E você já usa o Docker? Conte-nos sobre suas aventuras com essa técnologia. Se não conhece não deixe de conferir nosso curso de docker na Alura.

Fique por dentro

(Última atualização em: 22 de junho de 2017)

  • Tailo Mateus

    Basicamente, o docker tem praticamente a mesma função que o vagrant?

    • Fernando Willian de Souza Furt

      Fala aí Tailo blz?

      Então o Vagrant (pelo pouco que eu conheço) auxilia no provisionamento de maquina virtual. Já o Docker auxilia na criação do container.

      A diferença entre um e outro é que o container não precisa de um S.O. ele roda sobre o mesmo S.O. do host compartilhando os recursos do kernel.

      []s

  • Leonardo

    Pequena correção: “enxergar” com x no lugar de ch.

    • Fernando Willian de Souza Furt

      Opa, corrigido.

      Valeu Leandro.

      []s

  • Flávio Henrique Almeida

    Post muito bem escrito e analogias bem escolhidas e ainda forneceu algo prático. Muito bom, parabéns!

    • Fernando Willian de Souza Furt

      Valeu Flávio!

      []s

  • Patrick Reis

    Ótimo artigo. Parabéns

    • Fernando Willian de Souza Furt

      Valeu Patrick!

  • Vinicius Romero

    Nao testei ainda, mas acredito que o mesmo possui um ip, certo? Entao seria inicializar-lo e fazer um push do seu codigo para o container?

    • Fernando Willian de Souza Furt

      Olá Vinicius tudo bem?

      Não entendi direito sua dúvida. Pode me esclarecer melhor ela?

      • Vinicius Romero

        Tudo sim Fernando e com você? A pergunta seria sobre o container. Quando iniciar com o run, será designado um endereço IP?

        • Fernando Willian de Souza Furt

          Fala aí Vinicius, não é designado um IP para o container. Pois a ideia é isolar o container do seu host.

          Porém você consegue fazer o mapeamento de portas para o container.

          Então você pode subir uma aplicação rodando na porta 8080 do seu container.

          E mapear a porta 8080 do container para a porta 80 do seu host.

          Dessa forma você acessa http://nome-do-seu-host e o docker redireciona para a porta 8080 do seu container.

          Espero ter ajudado.

          []s

          • Vinicius Romero

            Com certeza ajudou, valeu Fernando. Muito obrigado pelo post.

  • Douglas Correa

    Otimo artigo.

    Alerto apenas para uma pequena correção;

    “chroot – Reponsavel”
    “cgroup – Reponsável”

    Abraços

Próximo ArtigoDiagrame como um profissional: veja 7 hacks para o Indesign