Como criar um cluster de Raspberry Pi 4 com Docker Swarm

O Raspberry Pi 4 é um microcontrolador com uma boa capacidade de processamento. Possui uma CPU ARM v8 64 bits (Quad core Cortex-A72), uma interface Gigabit Ethernet, uma porta USB 3.0 e duas portas HDMI. Ele pode ser configurado com até 8 GB de memória. Com armazenamento microSD é possível instalar sistemas operacionais Linux, tal como Ubuntu 18 Core ou Ubuntu 20 e softwares de servidores.

Podemos instalar o Docker neste hardware e criar um cluster com 2 ou mais Raspberry Pi para executar cargas de trabalho de análise de dados em larga escala. A vantagem desta configuração é o baixo custo do hardware. Um cartão microSD pode fornecer desempenho de leitura de 80 MB/s e com a interface gigabit ligada num switch adequado podemos obter 100 MB/s de taxa de transferência. Considerando um custo de 100 dólares por kit Raspberry Pi 4 de 8GB e 30 dólares pelo arranjo mostrado na figura abaixo, temos um custo aproximado de 780 dólares por um cluster de 6 computadores totalizando uma memória de 48 GB e 192 GB de armazenamento de dados. 

Isto é suficiente para várias aplicações e provas de conceito de  IoT, AI, WEB, micro-serviços rodando de forma distribuída sobre Docker numa solução escalável horizontalmente.

Vale ressaltar que o próprio Raspberry Pi possui interface GPIO e portas para câmera, audio stéreo e vídeo composto, permitindo aquisição e processamentos diversos, incluindo processamento de imagens usando aprendizado de máquina. 

Instalação do Sistema Operacional

Na página de Download https://www.raspberrypi.org/downloads/ você pode baixar o Raspberry Pi Imager que está disponível para Ubuntu, MacOS e Windows. Este programa, após instalado no seu computador, oferecerá um diálogo onde você pode escolher [1] a versão do Sistema Operacional que quer copiar para o cartão microSD. Escolha [2] o microSD onde será gravada a imagem do Sistema Operacional. Com estas duas informações preenchidas o botão [3] ficará habilitado para iniciar a gravação. 

É importante escolher uma versão de 64 bits tal como Ubuntu Core 18

As instruções para instalar o Ubuntu Core 18 podem ser vistas neste link:

https://ubuntu.com/download/raspberry-pi-core. Veja abaixo um resumo 

Antes de fazer o boot no seu Raspberry Pi com o microSD gerado faça o seguinte no seu computador usado para gerar a imagem:

1. Crie um par de chaves RSA usando o comando ssh-keygen. No meu caso usei opção -C para adicionar um comentário para facilitar o gerenciamento de chaves SSH na minha conta do ubuntu.com. Veja abaixo o comando executado:

ssh-keygen -t rsa -b 4096 -C "id_rsa_r-pi-01 AT admin@automacao.info"

Quando solicitado informe o nome do arquivo, como por exemplo: ~/.ssh/id_rsa_r-pi-01. É importante escolher um nome adequado para não sobrescrever chaves já existentes em ~/.ssh.

2. Copie a chave pública gerada para a área de transferência do computador. No caso do MacOS você pode usar pbcopy como mostrado abaixo: 

pbcopy < ~/.ssh/id_rsa_r-pi-01.pub

3. Crie uma conta em https://ubuntu.com e depois adicione a chave pública gerada na etapa 1 acima, na sua lista de chaves. Use a URL abaixo e faça a cópia à partir da área de transferência (Copy/Paste) :  

https://login.ubuntu.com/ssh-keys

OBS: Esta chave pública será copiada para o seu Raspberry Pi para a área de usuário no arquivo ~/.ssh/authorized_keys  onde  ~/ no meu caso é /home/r-pi-01/, ou seja, o mecanismo que o programa de setup do Ubuntu Core 18 64 bits para permitir o acesso remoto ao Raspberry Pi é criar o arquivo ~/.ssh/authorized_keys  com a chave pública associada a uma chave privada que você tem acesso pois criou o par anteriormente.

Agora já é possível fazer o boot do Raspberry Pi à partir do microSD gerado. Vamos então ao passo a passo.

1. Conecte os cabos: i) teclado na USB; ii) rede ethernet no RJ45; iii)  monitor na micro HDMI; iv) alimentação na fonte adequada.

2. Quando for solicitado use as credenciais de sua conta citada na etapa 3, anteriormente, e informe usuário e senha.

3. O Raspberry responde que copiou a chave SSH da sua conta Ubuntu (Public SSH keys were added to the device for remote access) e abre uma tela informando:

  1. O endereço IP associado a sua interface ethernet 
  2. As impressões digitais (fingerprints) de sua chave RSA
  3. Instruções de login remoto usando o comando ssh com IPV4

Veja exemplo de saída (no meu caso) abaixo:

Ubuntu Core 18 on 192.168.1.120 (tty1)
The host key fingerprints are:
    RSA     SHA256:PaSE+kKJLKSDREKJeiKLKJeJ3JKLKJEEKJ    ECDSA   SHA256:wIKSDFLKsdlkfsjDFSdfujsdf83kljSDdD    ED25519 SHA256:7JSDFSDkdsS3KJKSDsdflkfSDFLJKDSs39
To login:
    ssh r-pi-01@192.168.1.120
Personalize your account at https://login.ubuntu.com.

Volte ao seu computador e execute os 3 comandos abaixo:

eval `ssh-agent -s` && ssh-add -D && ssh-add ~/.ssh/id_rsa_r-pi-01

Estes comandos registram sua chave privada criada para efeitos de autenticação automática (sem pedido de senha) no seu Raspberry Pi.

Use as instruções de login remoto fornecidas pelo se Raspberry Pi para logar-se remotamente. No meu caso use o comando abaixo:

ssh r-pi-01@192.168.1.120

Em seguida você pode definir uma senha para seu usuário no Raspberry Pi para usar também sem configuração de chaves SSH.   

sudo passwd $USER

Informe a nova senha e anote para uso posterior.

Para ver detalhes da versão instalada execute:

cat /etc/os-release ; uname -a  

Esta versão do Ubuntu não vem com apt instalado e devemos usar o snap.  Podemos instalar o  htop assim:

sudo snap install htop 

E depois usá-lo.  Num Raspberry Pi com 4GB vemos algo assim:

Veja agora onde o snap instala os aplicativos:

which htop

/snap/bin/htop

Ou seja, todos os aplicativos instalados via snap ficam em área protegida /snap.

Podemos instalar o Firewall do Ubuntu Core 18.04 com o snap:

snap install ufw ; sudo ufw allow 22 # Muito importante liberar a porta 22 do SSH !

Instalação do Docker

Podemos pesquisar a documentação oficial em https://docs.ubuntu.com/core/en/platforms.  No caso de instalar o Docker podemos pesquisar o repositório de aplicativos assim:

snap find docker | grep canonical 

que exibirá:

 docker      19.03.11       canonical*    -   Docker container runtime
 etcd        3.4.5          canonical*    -   Resilient key-value store by CoreOS

Assim podemos instalar o Docker executando:

sudo snap install docker  &amp;&amp; sudo usermod -aG docker $USER &amp;&amp; groups $USER

Com o Docker instalado podemos obter, por exemplo, o OpenJDK 11 64 bits para processadores ARM executando o comando:

docker pull adoptopenjdk/openjdk11:jdk-11.0.8_10-slim

A tag jdk-11.0.8_10-slim ocupa apenas 150 MB (comprimida) e é adequada ao RaspberryPi. Para testar a imagem podemos usar:

docker run -it --rm --name java11 adoptopenjdk/openjdk11:jdk-11.0.8_10-slim bash

Dentro do contêiner é possível executar o jshell que é um REPL Java e testar o ambiente.

System.out.println("Olá mundo. Timestamp:" 
    + new java.sql.Timestamp(System.currentTimeMillis()))

Criando o Cluster com Swarm

Podemos em seguida criar um cluster de hosts gerenciado pelo Swarm que é nativo no Docker. Para tal precisamos saber o endereço externo da interface de rede usada pelo Docker. Já sabemos o endereço mas podemos executar um script awk para filtrar a lista de interfaces de rede  executando:

EXTERNAL_IP=`ip addr show | grep 'inet ' | grep -v ' lo$\| docker0$' \
            | awk '{ split($2,t,"/"); print t[1] }'`
echo ${EXTERNAL_IP}

que exibe no meu caso:

192.168.1.120

Este é o endereço já conhecido e o script awk foi colocado aí para efeitos de automação, caso seja necessário. Para criar um cluster executamos o comando abaixo no primeiro node (Raspberry Pi corrente):

sudo docker swarm init --advertise-addr ${EXTERNAL_IP}

que exibirá algo assim:

Swarm initialized: current node (e02ra6e1n0coj5rt6j3tqwnad) is now a manager. 

To add a worker to this swarm, run the following command: 

docker swarm join --token \
SWMTKN-1-5e3lcfszfbvwxpzqbdf6l1yged6pzovctmlze0070bsfv41r98-f59jvnvcesyb5rxd4dm7irlov \
192.168.1.120:2377

To add a manager to this swarm, run 'docker swarm join-token manager' and
follow the instructions.

Observe que o Swarm é inicializado e configura o Raspberry Pi atual como master e fornece o comando para agregar novos hosts ao Cluster.

O próximo passo agora é repetir a instalação e configuração do segundo Raspberry Pi que envolve todas as etapas descritas acima nesta seção. Quando estivermos com o sistema rodando no Ubuntu Core 18 com o Docker instalado podemos executar neste novo host, o comando sugerido pelo swarm (em azul, acima).

docker swarm join --token \
  SWMTKN-1-5e3lcfszfbvwxpzqbdf6l1yged6pzovctmlze0070bsfv41r98-f59jvnvcesyb5rxd4dm7irlov \
  192.168.1.120:237

O  docker responde com o seguinte:

This node joined a swarm as a worker.

Pronto, temos agora um Cluster com 2 Nodes. Este processo pode ser repetido para quantos Raspberry Pi forem necessários no Cluster.

O comando docker info pode ser executado em todos os hosts onde instalamos o Docker e fizemos Join ao Cluster. Todos eles mostrarão uma seção Swarm com status active. e também mostrará o número de nodes existentes no Cluster, no momento aparece a linha Nodes: 2 sob a seção Swarm.

É importante mencionar que o comando mostrado acima poderá ser executado também em outras máquinas da rede que tenham o Docker instalado. Basta que seja uma versão atual com o Swarm integrado. É bastante saudável, entretanto, que as versões do Docker sejam as mesmas, mesmo que em sistemas operacionais distintos (Ubuntu, CentOS, MacOS, etc.).

Para ter uma visão geral das informações com destaque para o número de nodes podemos executar:

INFO=`sudo docker info 2> /dev/null` ; echo $INFO | grep "Nodes: \|: "

que retorna algo parecido com isto abaixo:

Client: Debug Mode: false Server: Containers: 0 Running: 0 Paused: 0 Stopped: 0 Images: 0 Server Version: 19.03.11 Storage Driver: overlay2 Backing Filesystem: extfs Supports d_type: true Native Overlay Diff: true Logging Driver: json-file Cgroup Driver: cgroupfs Plugins: Volume: local Network: bridge host ipvlan macvlan null overlay Log: awslogs fluentd gcplogs gelf journald json-file local logentries splunk syslog Swarm: active NodeID: e02ra6e1n0coj5rt6j3tqwnad Is Manager: true ClusterID: l7341897urhhwv1d0hyuq2rjh Managers: 1 Nodes: 2 Default Address Pool: 10.0.0.0/8 SubnetSize: 24 Data Path Port: 4789 Orchestratio: Task History Retention Limit: 5 Raft: Snapshot Interval: 10000 Number of Old Snapshots to Retain: 0 Heartbeat Tick: 1 Election Tick: 10 Dispatcher: Heartbeat Period: 5 seconds CA Configuration: Expiry Duration: 3 months Force Rotate: 0 Autolock Managers: false Root Rotation In Progress: false Node Address: 192.168.1.120 Manager Addresses: 192.168.1.120:2377 Runtimes: runc Default Runtime: runc Init Binary: docker-init containerd version: 7ad184331fa3e55e52b890ea95e65ba581ae3429 runc version: init version: fec3683 Security Options: apparmor seccomp Profile: default Kernel Version: 5.3.0-1028-raspi2 Operating System:Ubuntu Core 16 OSType: linux Architecture: aarch64 CPUs: 4 Total Memory: 3.703GiB Name: localhost ID: A5IA:FQN7:N675:6F5V:E34I:UIHO:K4YY:UJIZ:35CU:XZBE:U4GR:I7SU Docker Root Dir: /var/snap/docker/common/var-lib-docker Debug Mode: false Registry: https://index.docker.io/v1/ Labels: Experimental: false Insecure Registries: 127.0.0.0/8 Live Restore Enabled: false

O comando  sudo docker node ls mostra os Nodes existentes no Cluster, seus Hostnames, seus estados e versões do Docker instaladas.  Já o comando docker node inspec mostra mais detalhes.

Exemplo: sudo docker node inspect --pretty localhost

O comando docker service create pode ser usado no Cluster para iniciar contêineres Docker que irão se replicar pelos nodes existentes. Considere um exemplo com o HTTP Server do Python3 do Ubuntu rodando como serviço em um Cluster de 4 Raspberry Pi. Um deles funcionará como master e os outros 3 como workers.

Cluster de Raspberry Pi numa arquitetura orientada a serviços rodando sobre Docker Swarm

Antes liberamos a porta 80 no Raspberry Pi usando os comandos:

sudo ufw allow 80 ; sudo ufw enable ; sudo ufw status 

É preciso também atualizar a disponibilidade do Node master. No primeiro Raspberry Pi criado, que funcionará como node master, execute o seguinte:

NODE_ID=`docker info | grep "NodeID: " | awk '{ print $2 }'`
echo  $NODE_ID # Para verificar a execução correta do AWK
sudo docker node update --availability drain $NODE_ID

Agora criamos o serviço HTTP Server do Python3 disponível, por exemplo no Ubuntu 18.

sudo docker service create --name http-server -d -p 80:8000 \
     ubuntu:18.04 python3 -m http.server 8000

Agora podemos listar os serviços.

sudo docker service ls

E verificar o estado deles.

sudo docker service ps http-server

Ao finalizar a utilização dos serviços no Cluster podemos removê-los

sudo docker service rm http-server

O docker swarm é apenas um dentre os diversos orquestradores multi-host para contêineres Docker.  O padrão de fato para computação em nuvem é o Kubernetes. Então podemos verificar o suporte no Ubuntu Core 18 64 bits para este componente.  Executando o comando snap find kubernetes  verificamos que não existe um snap pronto com Kubernetes no Ubuntu Core 18. Na verdade esta versão do sistema é focada em IoT e sistemas embarcados e por isso deve ser muito enxuta. Para a maioria das aplicações, mesmo em Cluster, o Docker Swarm atende as necessidades de infraestrutura neste tipo de hardware. Sendo assim Kubernetes no Raspberry Pi fica pra próxima.

Conclusão

Esta foi uma breve introdução ao orquestrador multi host nativo do Docker que portanto pode rodar normalmente mesmo em sistemas Linux embarcados como é o caso do Ubuntu Core 18. Não foi a intenção esgotar as funcionalidades do Docker Swarm neste documento mas ele poderá servir de ponto de partida para desenvolvimento de soluções criativas, escaláveis e com bom desempenho. Também foi abordado o processo de instalação do Ubuntu Core 18.04 64 bits no Raspberry Pi 4 de forma que fica muito fácil criar um cluster on-premise com este tipo de hardware de baixo custo. Tal solução permite desenvolver soluções de IoT com computação distribuída usando micro serviços. Uma dessas soluções é o SOMA – Sistema Orientado à Gestão de Ativos de engenharia. Este sistema foi instalado pelo CEPEL (http://cepel.br) na Usina de Itaipú, usando servidores Windows Server, para monitorar toda a planta de geração de energia, mas poderá ser instalado em pequenas plantas industriais, em um cluster como este descrito, pois é uma solução Java EE e portanto compatível com a arquitetura ARM 64.

O Docker e a Virtualização Enxuta

Atualmente os sistemas de software afetam praticamente todos os aspectos de nossas vidas. No entanto  erros em sistemas de computação podem produzir prejuízos assustadores, tal como explodir uma nave espacial, levar uma empresa multimilionária a falência ou expor a imagem de uma gigante e líder na área de video-games. Todos estes exemplos são reais e a todo momento vemos noticias de outras catástrofes ocorridas por erros de software.

Qual o motivo para ocorreram estas coisas ? No raiz do problema está a negligência com a complexidade envolvida nos processos de desenvolvimento e implantação de sistemas. Um sistema de software bem escrito deve ser robusto, eficiente, confiável e flexível. Para conseguir isso devemos ter o controle de todo o Ciclo de Vida da Aplicação, desde a concepção, baseada nos requisitos do negócio, passando pelo desenvolvimento, testes, homologação, produção e gerenciamento de mudanças.

Ok, mas este é um artigo sobre Docker então por que falar disso tudo ? Ora, por que o Docker vai facilitar nossa vida em várias etapas desse ciclo de vida da aplicação. Neste artigo vou descrever o que é o Docker, pois este é o primeiro passo para poder usa-lo de forma eficiente para Gerenciar todos os Ciclos de Vida de nossas Aplicações. Acompanhe!

Gerenciamento do Ciclo de Vida da Aplicação

A manutenção de ambientes de Desenvolvimento, Homologação e Produção tem grande impacto no Gerenciamento do Ciclo de Vida da Aplicação (ALM – Application Lifecycle Management), devido a grande complexidade das aplicações atuais nas sua maioria rodando em ambiente distribuído. Para mitigar os riscos neste gerenciamento e manter os altos níveis de qualidade desejados pelos usuários dos sistemas é necessário que usemos algumas das ferramentas disponíveis para os setores de Tecnologia da Informação que permitam alto nível de produtividade.

Considere como exemplo um sistema com com apenas 5 clientes (Window, MacOS, Ubuntu, iOS e Android). Como temos três ambientes diferentes para cada cliente (teste, homologação e produção) devemos gerenciar 15 ambientes, cada um com seus ativos de software, banco de dados, scripts de teste, etc. Torna-se impossível usar maquinas reais nesta tarefa pois teríamos uma pilha de 15 máquinas que consumiria muitos recursos e muito espaço físico. Para resolver este problema é necessário compartilhar os recursos de hardware usando algum tipo de virtualização.

Virtualização

Podemos optar por usar Maquinas Virtuais para facilitar o gerenciamento e provisionamento de serviços. Neste caso entra em cena a ferramenta Vagrant que facilita a criação dessas máquinas virtuais e o provisionamento de recursos de forma programática. Isto é possível usando ferramentas como Puppet, Salt, Chief ou Ansible.

A criação e manutenção de uma máquina virtual (Virtual Box, Hyper-V ou VMWare) demanda grande quantidade de tempo e, muitas vezes revela-se uma tarefa complexa. Além do fato dessas máquinas virtuais consumirem uma quantidade imensa de espaço em disco.

Melhorando o modelo

Devido ao crescimento da demanda por Maquinas Virtuais e grande dificuldade na operação desse ambiente surgiu a necessidade de melhorar esse modelo. Os pesquisadores desta área perceberam que não havia a necessidade de recriar um SO completo e que bastava reusar os recursos de um mesmo SO num espaço de run-time independente chamado Virtual Environment. Lançando mão de uma funcionalidade nativa do Kernel Linux, para facilitar a criação e gestão destes ambientes virtuais leves, eles conseguiram ótimos resultados. Assim surgiu o LxC e mais recentemente o Software Docker que em pouco tempo roubou a cena quando se fala em automatizar a infraestrutura de software e hardware.

O Vagrant e o Docker se complementam num ambiente de Gerenciamento de infraestrutura de TI mais sofisticado onde podemos usar Ansible para automatizar, de forma global, toda a infraestrutura de virtualização.

Detalhando

A seguir vamos detalhar um pouco mais o Docker que é uma ferramenta extremamente útil na gestão de múltiplos ambientes para Gerenciamento do Ciclo de Vida do Software.

Docker é uma plataforma aberta usada por desenvolvedores e administradores de sistemas para construir, entregar e rodar aplicações distribuídas. É composto pelo Docker Engine, que é uma ferramenta leve de execução e empacotamento, e pelo Docker Hub, um serviço em nuvem responsável pelo compartilhamento de aplicações e automação de fluxos de trabalho. Ele permite que aplicações sejam rapidamente montadas e elimina as diferenças entre os ambientes de desenvolvimento, testes e produção.

O Docker não é uma ferramenta de virtualização de máquinas, ele é um ambiente de virtualização de Linux, construído sobre os LinuX Contêineres (LxC), que utiliza as funcionalidades cgroups e namespacing do Kernel do Linux (e é escrito na linguagem Go) para criar e rodar ambientes Linux Virtuais isolados em um único host. Em 2015 a equipe do Docker em parceria com 34 outras empresas fundaram a Open Container Initiative para padronizar contêineres e a forma de executá-los independente de sistema operacional. Com isso foi possível que a Microsoft criasse também o seu Kernel de Windows como base para contêineres.

O Virtual Environment – VE roda diretamente sobre o kernel já existente (do host) e apenas cria um contêiner onde serão executados seus aplicativos, onde até é possível recriar outra configuração de SO, já que este será apenas outro aplicativo rodando sobre o kernel. Vale observar que o Docker compartilha o kernel do Linux entre os ambientes e portanto seus contêineres não terão completo isolamento como acontece numa maquina real ou numa maquina virtual completa rodando sob Virtual Box, Hyper-V ou VMWare.

Acontece porém que o isolamento que ele proporciona atende plenamente as necessidades dos Sistemas de Informação em ambientes controlados, com a vantagem de executar extremamente rápido. Por exemplo, podemos iniciar um aplicativo num contêiner à partir do Host em apenas alguns milisegundos de latência. Esta mesma aplicação iniciando numa maquina virtual pode demorar vários minutos.

O Docker usa o AuFS (advanced multi layered unification filesystem) como sistema de arquivos, assim ele reutiliza a imagem do SO e as imagens relativas a cada um dos serviços instalados entre vários de seus contêineres em execução economizando recursos valiosos do computador host. O Docker pode usar opcionalmente o OverlayFS que oferece as mesmas vantagens e tem melhor desempenho.

O Docker permite Implantação portátil através de máquinas, pois podemos usar o Docker para criar um objeto único que contém todas as suas aplicações empacotadas o qual chamamos Imagem Docker. Este objeto pode ser transferido e rapidamente instalado em qualquer outro host Linux com Docker habilitado, incluindo maquinas reais ou virtuais rodando Linux, Windows ou MAC OSX.

O Docker permite Reutilização de componentes pois podemos “empilhar” pacotes já criados cada um com sua funcionalidade específica. Por exemplo, se você precisa criar várias máquinas que todos necessitam de banco de dados Oracle e WebServer Apache, podemos criar uma imagem base contendo o Oracle e outra contendo o Apache, e na sequência, construir e criar novos contêineres que utilizam estas imagens base já criadas.

O Docker pode usar imagens disponíveis em bibliotecas compartilhadas. Existe um registro público, já mencionado, onde podemos encontrar milhares de imagens já prontas (https://hub.docker.com/explore/).

Principais Funcionalidades do Docker

Contêineres facilmente portáveis: você pode criar uma imagem de toda a configuração e aplicativos instalados em seu contêiner, transferir e instalar em um outro host desde que tenha um Docker previamente instalado.

Versionamento: Docker permite que você versione as alterações de um contêiner de uma forma muito semelhante ao feito pelo GIT ou SVN. Isto permite portanto verificar as diferenças entre versões, fazer commit de novas versões e fazer rollback de uma dada versão.

Reutilização de componentes: as imagens criadas podem ser reutilizadas, como por exemplo, se diversas de suas aplicações utilizam uma stack com Java 11, Tomcat 9 e Oracle 18 você poderá criar uma uma imagem base contendo estes itens com sua instalação e configuração. Desta maneira esta imagem poderá ser reutilizada em diversos contêineres diferentes. Podemos construir imagens Docker usando um arquivo texto chamado Dockerfile e o comando de montagem docker build. O Dockerfile usa uma DSL – Domain Specific Language – simples com poucas instruções, porém suficientes para construir imagens Docker. A abordagem de criação via Dockerfile pode ser repetida quantas vezes for necessário, em quantos ambientes seja desejado além de permitir gerenciamento de versão no GIT/SVN das definições da infraestrutura. Com esta DSL o Docker consegue levar a Metodologia de Orientação a Objetos para o provisionamento da Infraestrutura e passamos a ter funcionalidades de Programação de Infraestrutura que é o sonho de qualquer profissional de operações de TI.

Compartilhamento: o Docker Hub já possui milhares de imagens de contêineres com as mais diversas aplicações instaladas e configuradas e desta maneira você pode rapidamente criar sua aplicação com uma base desenvolvida por outra pessoa, ou ainda criar sua base e compartilhá-la.

CLI – Command Line Interface e API – Application Program Interface: Permite criação de Programas e Scripts que interagem com o Docker para provisionar serviços nos Contêineres.

Automatização de Implantação dentro dos Contêineres: Usando os provisionadores que por sua vez usam a API do Docker, podemos automatizar a implantação dos ambientes de software.

Licença Open Source: Licenciado como Apache License, Version 2.0 mantém os códigos fonte disponíveis para facilitar o desenvolvimento colaborativo.

Evita Dependency Hell: Um dos maiores problemas em múltiplos ambientes com os quais os desenvolvedores de software convivem diariamente é o gerenciamento de dependências. O Docker evita problemas neste gerenciamento por permitir versionamento de cada componente adicionado na imagem.

Demanda Poucos Recursos de Hardware: Exige poucos recursos de processos, memória e espaço em disco. Você pode rodar facilmente o Docker e os seus contêineres em computadores tão pequenos quanto um Raspberry Pi.

Performance inigualável: é possível baixar, por exemplo, uma imagem Fedora do repositório público na Internet em menos de um minuto e executar um comando simples num contêiner criado com esta imagem, à partir do computador Host, em menos de um segundo. Imagens baseadas em Alpine Linux são ainda menores e mais rápidas.

Ligação entre Contêineres: Conectar contêineres via mapeamentos de porta TCP/IP não é a única forma de disponibilizar recursos entre eles. Um contêiner Docker pode se conectar a um outro via um sistema de ligação e enviar informações de um para o outro de forma eficiente e segura. Quando os contêineres estão ligados, a informação sobre o contêiner origem pode ser enviada para um contêiner destino. Isso permite que o contêiner destino possa acessar dados selecionados do contêiner origem. Como exemplo, podemos então criar um contêiner chamado web (destino) e ligá-lo a um contêiner chamado db (origem) usando um alias para o link chamado dblink, por exemplo. Para permitir a ligação o Docker cria um túnel seguro entre o contêiner origem e o contêiner destino, eliminando a necessidade de expor qualquer porta TCP/IP externamente a estes dois contêineres. Isto é feito com Redes Docker que são redes programadas por software compatíveis com Ethernet/TCP-IP.

Orquestração com Docker Compose ou Kubernetes

Docker Compose é uma ferramenta para definir e rodar aplicações complexas via Docker. Com o Docker Compose, podemos definir uma aplicação multi-contêiner num único arquivo de script, e em seguida iniciar a aplicação e tudo da qual ela depende para sua execução. O Docker Compose é ótimo para usar em ambientes de desenvolvimento, homologação e Integração Contínua e permite implementar Arquitetura de Micro Serviço de forma simples.

Quando precisamos escalar nossa infraestrutura horizontalmente em um Cluster podemos usar o Docker Swarm que é um orquestrado multi-host fornecido nativamente pelo Docker e funciona até em hardwares minúsculos como o Raspberry Pi. A vantagem do Docker Swarm é a simplicidade.

Quando pensamos em Computação em nuvem em larga escala precisamos de soluções mais escaláveis para orquestração e neste caso é necessário usar Kubernetes que é o padrão da indústria de TI atualmente. Por ser projeto de código aberto o Kubernetes é suportado em todos os provedores de CaaS (Containers as a Service), tais como Azure, Google Cloud Plataform e AWS. Veja este post para detalhes das ofertas de serviços atuais de nuvem

Virtualização Enxuta

Por tudo isso que foi exposto aqui podemos dizer que o Docker permite levar para a Infraestrutura de TI esta Técnica de Virtualização Enxuta que nos proporciona o benefício da eliminação de desperdício da mesma forma que é preconizada pelas Metodologias Ágeis para Desenvolvimento de Software (SCRUM/XP) e de Produtos e Negócios (Lean Startup). Assim Docker, Kubernetes e Cloud Computing são os parceiros ideais das metodologias ágeis de gestão e desenvolvimento de produtos e de negócios. Ferramentas essenciais para as Start-ups de qualquer natureza.