O Docker tem revolucionado o mercado de TI nos últimos tempos. E se você foi a algum evento de tecnologia ou desenvolvimento recentemente, sabe que anda difícil ignorar o tema.

Trata-se de uma tecnologia bastante interessante, capaz de despertar a atenção tanto de administradores de sistemas quanto de desenvolvedores e, justamente por esse fato, cai “como uma luva” dentro do processo que atualmente chamamos de “devops”. Ou seja, esse universo cinzento que resulta da interseção entre “programadores” e “operações”, onde ambos os times trabalham em prol de colocar em produção aplicações funcionais na nuvem, com a menor quantidade de erros possível e sem downtime algum.

Em um mundo onde é preciso entregar software em intervalos cada vez menores e colher feedback constante, é necessário um fluxo de trabalho mais estreito entre essas duas áreas: com desenvolvedores envolvendo-se cada vez mais com servidores web e infraestrutura, e administradores escrevendo código para automatizar tarefas, por exemplo.

Docker e a computação em nuvem

Dentro do ambiente de cloud, há algumas mudanças significativas. Há dois modelos de cloud bastante representativos: IaaS e PaaS.

O IaaS (Infraestrutura como Serviço) sempre foi mais flexível, mas assim como em uma estrutura física, a administração e a escalabilidade tornam-se um problema cada vez mais complexo na medida em que a infraestrutura cresce.

Já a Plataforma como Serviço (PaaS) surgiu logo depois, como uma solução para solucionar essa complexidade crescente, mas às custas de um pequeno sacrifício na flexibilidade e compatibilidade das aplicações.

Contudo, a introdução do suporte ao Docker em plataformas de cloud como o Jelastic abrem a possibilidade da execução de qualquer aplicação Linux dentro de um contêiner desse tipo, sem que seja necessário sacrificar a flexibilidade e a facilidade de uso presentes em recursos como escalabilidade e balanceamento de carga automáticos, aproximando-se daquilo que pode vir a ser “o melhor dos dois mundos”.

Criação de um contêiner com a sua aplicação

Vamos exemplificar como isso funciona colocando uma aplicação que escreveremos em um contêiner Docker, utilizando-o para mover nossa aplicação para o Jelastic, onde colocaremos em produção. A primeira coisa a se fazer é instalar o Docker. Há várias formas de fazer isso, e a documentação oficial do projeto relaciona várias delas.

Vamos começar a partir de uma imagem de contêiner que já possua Nodejs instalado. Para isso, vamos baixar o contêiner oficial do projeto Nodejs digitando:

# docker pull node

Isso iniciará o processo de download do contêiner. Uma vez baixado, podemos criar nossa aplicação. Note que criaremos nossa aplicação dentro do contêiner apenas para fins de teste. Um cenário mais natural seria criar a aplicação e apenas fazer o deploy dela no contêiner, utilizando para isso um repositório Git, por exemplo.

Para acessar o bash do contêiner node, utilizaremos o seguinte comando:

# docker run -t -i -p 8080:80 node /bin/bash

Em instantes, estaremos acessando o terminal do contêiner que acabamos de baixar.

 root@3c4529a869c4:/#

Agora vamos criar uma pasta para a aplicação Nodejs que escreveremos. Como já baixamos uma imagem com Nodejs, não precisamos nos preocupar com o provisionamento dele. Essa é uma das vantagens de se construir uma imagem Docker a partir de outra já existente. Contudo, teremos que baixar o Vim para utilizarmos a seguir. Fique à vontade para fazer uso de outro editor de texto com o qual você se sinta mais confortável.

# mkdir /home/demo
# cd /home/demo
# apt-get update
# apt-get install vim-nox

Primeiro, vamos criar um package.json com os metadados da nossa aplicação ao digitar npm init e preencher os campos solicitados. Em seguida, vamos instalar o Express: npm install express –save.

Agora, é só criar o arquivo app.js na pasta demo e escrever nosso hello-world abaixo.

var express = require('express');
var app = express();

app.get('/', function (req, res) {
res.send('Hello World!');
});

var server = app.listen(80, function () {
var host = server.address().address;
var port = server.address().port;

console.log('Example app listening at http://%s:%s', host, port);
});

Perfeito! Se executarmos um node /home/demo/app.js e digitarmos localhost:8080 em um navegador, conseguiremos ver o nosso Hello Word! rodando na nossa máquina:

Hora de commitar nossa aplicação e criar nosso próprio contêiner com a aplicação instalada. Para isso, vamos precisar do CONTAINER ID que aparece na linha de comando do Bash e que surge também quando digitamos docker ps:

 # docker ps
CONTAINER ID    IMAGE   COMMAND     CREATED         STATUS      PORTS   NAMES
3c4529a869c4    node    "/bin/bash"  19 minutes ago Up 19 minutes   0.0.0.0:8080->80/tcp    lonely_goodall

Como podemos ver nesse caso, o contêiner id é 3c4529a869c4. Agora, é só criar o nosso próprio utilizando este e o comando abaixo:

docker commit -m "Hello Word inicial" -a "Kemel Zaidan" 3c4529a869c4 kemelzaidan/jelastic_demo:v1

A opção -m refere-se à mensagem do commit; com -a, é possível indicar o autor e o último argumento passado, quer dizer, usuário_no_hub/nome_da_imagem:versão. Se digitarmos docker images, veremos nossa imagem recém-criada:

REPOSITORY                  TAG     IMAGE ID        CREATED         VIRTUAL SIZE
kemelzaidan/jelastic_demo   v1      3c3dddc5dcb4    23 hours ago    706.5 MB
node                        latest  9e20baae42c8    13 days ago     641.6 MB

Se você “commitou” a imagem da maneira correta, o Docker vai exibir um longo hash relativo à nova imagem criada; algo como 0226dba34984fb57e7f582efdc0f03506d232a5a0dfd8adfde1ab939829dbaec.

Agora vamos enviar a nova imagem para o repositório do Docker Hub, de forma a efetuarmos o deploy dela em nossa conta no Jelastic Locaweb. Para isso, utilizaremos o nome que acabamos de passar como argumento para o commit anterior.

 docker push kemelzaidan/jelastic_demo

Configuração do contêiner Docker no Jelastic

Agora é hora de fazermos o deploy da imagem no Jelastic. Apesar de o processo ser muito intuitivo, escrevi um artigo no blog da Locaweb, mostrando como fazer isso.

Basta procurar pela imagem que acabamos de enviar ao repositório do Docker: kemelzaidan/jelasticdemo_. A diferença é que temos que efetuar algumas configurações para fazer com que nossa aplicação dentro do contêiner seja iniciada. Para isso, vamos clicar no botão Editar depois de termos escolhido o contêiner:

Temos que efetuar duas configurações. A primeira delas é dizer a porta na qual nossa aplicação está rodando. Para isso, criamos uma variável de ambiente de nome DOCKER_EXPOSED_PORT, dizendo a porta na qual nossa aplicação será executada:

O segundo passo é dizer como damos início à nossa aplicação. Por padrão, o Jelastic busca por scripts como start.sh ou run.sh. Contudo, como não criamos nenhum script com esse nome, iremos passar o mesmo comando que utilizamos para executar a aplicação no teste em nossa máquina local, conforme ilustra a imagem abaixo:

Pronto! Agora basta clicar no botão Aplicar e ver nosso fantástico “Hello World” sendo executado no Jelastic! Obviamente há a possibilidade de criar arquiteturas bem mais complexas e de maneira modular, com contêiners específicos para aplicação, banco de dados, cache e servidore web, por exemplo; cada um responsável por executar uma determinada tarefa de forma isolada, como se estivessem em diferentes nós.

Esta é uma aplicação simples apenas para exemplificar o processo, mas poderia muito bem ser uma aplicação Haskell, e eu aposto que você jamais pensou que seria possível rodar uma aplicação Haskell na nuvem de forma tão simples, pensou?

Se você gostou da ideia, há no repositório do Docker até mesmo uma imagem oficial com o Haskell instalado para você não perder tempo e ir direto ao ponto: https://hub.docker.com/_/haskell. Que tal?

O IaaS (Infraestrutura como Serviço) é fortemente baseado em tecnologias de hypervisors (Xen e KVM, por exemplo). Historicamente, foi o primeiro modelo a surgir, sendo a principal referência que a maioria das pessoas faz quando pensam em cloud. Sua principal característica é a possibilidade de escolher a imagem do sistema operacional que será utilizada, possibilitando total flexibilidade na criação do ambiente; algo comparável apenas a um servidor físico.

A diferença do modelo on-premise para o IaaS é justamente a cobrança como serviço e a possibilidade de escalar os recursos computacionais na mesma medida da demanda. Quanto mais você consome, maior é o valor da conta, de forma análoga ao uso de recursos como energia elétrica, água e gás.

Contudo, é necessário manter e administrar toda a camada de sistema operacional e do stack da aplicação, o que se torna particularmente complexo na medida que a infraestrutura começa a escalar. Quando um bug como o heartbleed, por exemplo, precisar ser corrigido em 100 servidores, você certamente vai entender o que eu quero dizer com isso.

Já o modelo de PaaS surge como uma evolução ou alternativa a esse modelo: automatiza boa parte desses processos, aliviando o trabalho de administração ao custo de uma diminuição da autonomia. É uma troca possível para a maior parte dos casos.

Nesse sentido, o suporte a Docker em nuvens públicas representa uma mudança considerável. No ambiente de IaaS, o uso da ferramenta dispensa o provisionamento do stack necessário para a execução e da própria aplicação, uma vez que tudo estará “contido” dentro do container Docker.

Já no PaaS, o container Docker elimina praticamente todas as limitações da plataforma, uma vez que passa a ser possível executar qualquer aplicação dentro do container.

Agora, basta efetuar o deploy uma única vez dentro do container Docker e apontar todos os servidores de produção para essa mesma imagem em um registry. Dessa forma, todos os servidores permanecerão atualizados segundo a imagem do container que eles estão rodando.

Se já temos um certo consenso em relação ao formato do container a ser utilizado, ainda faltam opções para o gerenciamento e a orquestração de containers de forma a permitir essa e outras tarefas através da utilização de containers.

É justamente nesse sentido que o Jelastic se propõem a auxiliar: sendo uma plataforma que integra de forma nativa containers Docker, tornando o gerenciamento e a orquestração de containers uma tarefa trivial.