Utilizando Docker em ambiente de

desenvolvimento
Criao de containers e como conect-los.
Publicado por Lohan Bodevan 3 de Outubro de 2016 s 19:28

Introduo
Docker uma ferramenta que permite criar containers isolados porm que compartilham o mesmo
Kernel. Imagine uma unidade isolada do sistema operacional, totalmente independente, onde voc
pode instalar pacotes e rodar servios. Uma das vantagens do Docker sobre softwares de
virtualizao como Vagrant que os containers ocupam muito menos disco do S.O hospedeiro.
Neste rpido tutorial, vou mostrar como rodar um cdigo Python simples, usando Memcached e
MySQL.

O que voc precisa saber antes de comear?

Considero que voc tenha conhecimentos bsicos sobre utilizao de um banco de dados relacional
como o MySQL e banco de dados em memria como o Memcached. Alm, claro, do uso do
terminal do seu sistema operacional.

Preparando o ambiente
Para quem usa o Ubuntu, ou alguma outra distribuio Linux, bem fcil instalar o Docker e eu
recomendo seguir o passo a passo da documentao oficial, ele bem claro e prtico.
Uma dica importante: Aps a instalao, voc precisar usar sudo antes de cada comando Docker.
Para evitar isso, voc precisa seguir os passos abaixo:
1. Criar um grupo chamado docker
sudo groupadd docker

2. Adicione seu usurio ao grupo docker

sudo usermod -aG docker $USER

3. Faa Logout e Logon no sistema

Pronto! Para testar, execute o seguinte comando:
docker run hello-world

Se tudo ocorrer bem voc deve ver uma tela de sucesso parecida com essa abaixo:
Para quem usa OSX, macOS ou Windows existe um pacote de softwares chamado Docker Tool
Box.
A instalao bem simples, vou deixar aqui o link para configurao em cada plataforma:
Instalao do Docker Tool Box no Mac
Instalao do Docker Tool Box no Windows
O comando para verificar se a instalao est correta o mesmo:
docker run hello-world

Ao
Vamos criar um container MySQL chamado mysql-db, um Memcached chamado memcached-db e
um container para a aplicao chamado python-flask

Criando container MySQL

Agora que temos o Docker instalado vamos criar um container para o nosso banco de dados, para
isso usaremos o comando run
docker run -d -p 3306:3306 --name mysql-db -e MYSQL_ROOT_PASSWORD=root mysql:5.6

-d
O argumento `-d` ou `--detach` significa que queremos que o container continue rodando ao invs
de executar um nico comando e sair, como fizemos com o hello-world.
-p
O argumento `-p` informa a porta que desejamos exportar do nosso container.
(hostPort:containerPort). Isso significa que, a porta 3306 da mquina hospedeira ir redirecionar
para a porta 3306 do container.
Importante, se voc possui o MySQL server instalado e rodando no seu computador, o comando
docker vai falhar pois a porta 3306 j estar em uso. Para usar o MySQL apenas via Docker voc
precisa parar o MySQL local. No Ubuntu pode ser feito da seguinte forma:
sudo service mysql stop

-e
O argumento `-e` tem a funo de setar variveis de ambiente no container, nesse caso iremos setar
a varivel `MYSQL_ROOT_PASSWORD` com o valor `root`. Ou seja, quando container for criado
ser setada a senha "root" para o usurio "root" do MySQL.
Teste a conexo do servidor de banco de dados no container com o software client de MySQL de
sua preferncia.
Para quem usa Ubuntu poder usar o host localhost com usurio root e senha root.
Para quem usa Mac ou Windows muda apenas o host, ao invs de localhost dever usar o ip da
Docker Machine que pode ser consultado da seguinte forma:
docker-machine ip default

--name
`--name` utilizado para nomear o container. Apesar de no ser um argumento obrigatrio, muito
importante pois, caso no seja definido, o Docker ir setar um nome aleatrio para o container.
Imagem
O ltimo argumento `mysql:5.6` informa o nome e a verso da imagem que o Docker usar para
construir o container. comum usar a verso da imagem para informar a verso do software, no
nosso caso a imagem base que ser usada para o container ser a do MySQL Server 5.6.

Verificando os containers ativos

docker ps

Este comando lista todos os containers que esto "UP", com seus respectivos IDs e informaes de
forward de porta. Para listar todos os containers, independente do estado, use o argumento `-a`:
docker ps -a

Criando container Memcached

docker run -d -p 11211:11211 --name memcached-db memcached
Para a criao do container memcached nenhuma diferena do exemplo acima, exceto que no
utilizamos uma verso especfica para imagem, ento o Docker se prontificar a achar a ltima
verso de imagem Memcached disponvel.

Criando container da aplicao

Para este tutorial iremos utilizar uma aplicao de cdigo Python com o micro framework Flask. O
foco aqui no o cdigo e sim a utilizao do Docker, por isso ele ser o mais simples possvel.
Vamos criar o container:
docker run -d -it -p 5000:5000 --name python-flask -v
`pwd`:/home/application/python-flask -w /home/application/python-flask --link
memcached-db --link mysql-db python:3.5

Aqui utilizamos alguns argumentos diferentes. Mas calma, vamos v-los um a um.
-it
Na verdade uma juno dos argumentos `-i` e `-t`.
O argumento `-t` aloca um pseudo-terminal (pseudo-tty), isso nos ir permitir conectar via ssh no
container, porm nesse caso especfico s ser possvel se utilizarmos em conjunto o argumento `-i`
que mantm vivo um STDIN.
Diferente dos containers MySQL e Memcached, o container da nossa aplicao no possui nenhum
processo padro rodando, ele apenas um container Python aguardando que faamos algo com ele.
Se no utilizarmos esses dois argumentos em conjunto, o container iria levantar e cair logo em
seguida pois no passamos nenhum comando para ele executar.
-v
Este argumento tem como funo montar volumes, ou seja, compartilhar uma determinada pasta da
mquina hospedeira com o container. No nosso exemplo utilizamos o seguinte:
`pwd`:/home/application/python-flask
Onde `pwd`, conhecido comando de sistemas unix-like, representa a pasta atual. E separamos ento
com ":" onde a queremos montar dentro do container.
-w
O argumento `-w` no obrigatrio neste contexto porm ele facilita muito nossa vida, ele
significa workdir. O propsito definir uma pasta que ser usada como diretrio padro ao conectar
via ssh no container.
--link
Aqui acontece a mgica! O argumento `--link`, como o nome sugere, ir criar um link entre o
container que est sendo criado com o container citado logo em seguida. No nosso exemplo estamos
criando dois links, um para o container que nomeamos de memcached-db e outro de mysql-db.
Isso significa que dentro do container python-flask o servidor Memcached chama-se memcached-db
e o servidor MySQL chama-se mysql-db. E como fizemos o forward de portas, podemos acessar
ambos servidores por suas portas padro, 11211 e 3306 sucessivamente.
Portanto ao criar uma conexo com o MySQL via aplicao o host mysql-db dever ser usado. O
mesmo vale para o Memcached (memcached-db). Fcil no ?
O ltimo argumento como j falamos a imagem Python na verso 3.5, que possui o Python 3.5
como verso padro. Vale lembrar que em sua grande maioria as imagens bases so verses enxutas
de distribuies Linux, otimizadas para o seu propsito. Voc encontra diversas imagens no Docker
Hub, o repositrio oficial de imagens Docker.

Cdigo da aplicao
Os arquivos abaixo devero ser criados na raiz do projeto.
app.py
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask_cache import Cache

app = Flask(__name__)

# Database config
app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql://root:root@mysql-db/mysql'
db = SQLAlchemy(app)

# Cache config
cache = Cache(app,
config={'CACHE_TYPE': 'memcached',
'CACHE_MEMCACHED_SERVERS': ['memcached-db']
}
)
@app.route("/")
def main():
db_test = db.engine.execute("SELECT 1;").fetchone()

cache.set('test_key', 1, 1000)
cache_test = cache.get('test_key')

return "DB: OK {} - CACHE: OK {}".format(db_test, cache_test)

if __name__ == "__main__":
app.run(debug=True, host='0.0.0.0')

requirements.txt
Flask==0.11.1
mysqlclient==1.3.7
Flask-SQLAlchemy==2.1
Flask-Cache==0.13.1
python-memcached==1.58

Com estes dois arquivos conseguimos testar se nosso container python-flask est conseguindo
conectar-se aos outros dois containers de servio.
Antes vamos executar um comando para instalar as dependncias da nossa aplicao. Em todo caso,
nossa aplicao ir rodar dentro do container, por isso o comando deve ser executado l e existem
duas formas de fazer isso.
Executando comandos dentro do container via `docker exec`
docker exec -it python-flask pip install -r requirements.txt

O comando auto-explicativo, o argumento `-it` j conhecemos, aps ele vem o nome do container
e em seguida o comando a ser executado dentro dele: pip install -r requirements.txt
Executando comandos dentro do container via ssh
docker exec -it python-flask bash

pip install -r requirements.txt

Esta forma possui dois passos, o primeiro fazer logon via ssh no container e o segundo executar
de fato o comando para instalar as dependncias de nossa APP. Para sair da conexo com o
container executar `exit`.

Run
Com isso feito, agora s dar o start da aplicao:
docker exec -it python-flask python app.py

Resultado
Se tudo ocorrer bem voc ver as seguintes mensagens ao acessar a URL http://localhost:5000/
(Lembrando que se voc est no Windows ou Mac, dever trocar "localhost" pelo ip de sua Docker
Machine).
Concluso
Vimos aqui alguns conceitos bsicos sobre o Docker, como criar containers, como conect-los e
como executar comandos dentro deles via ssh, bem legal no ? Mais da pra ficar ainda melhor,
podemos usar o Docker Compose, ele facilita esse trabalho de conectar containers. Podemos
tambm criar um Dockerfile para automatizar alguns comandos como o de instalar dependncias e
dar o start na nossa aplicao.
Mas eu preferi comear os posts sobre Docker dessa forma para que fica claro o que feito por
baixo dos panos. Acredito muito nas ferramentas que facilitam nossa vida, porm importante saber
o que ela est fazendo.
Espero que tenham sido teis essas dicas, em breve postarei mais sobre o assunto.
Grande Abrao!