Ansible

Olá pessoal,

Hoje vamos falar sobre uma ferramenta que cada vez mais quem trabalha com Docker acaba utilizando que é o Ansible. A primeira vista muitas pessoas acham que ambas ferramentas fazem a mesma coisa, apresentando uma solução para gerenciamento de configurações através de meios diferentes. Na realidade a união das duas ferramentas torna o ambiente de implantações de softwares limpo, confiável e rápido.

Ansible

É uma ferramenta de automatização de tarefas semelhante a Puppet e Chef, porém muito mais poderosa e a queridinha do pessoal DevOps hoje. Com ela é possível fazer o deploy de aplicações, provisionando de servidores, automatizar tarefas, e outras funções.

O Ansible trabalha com arquivos YAML,  o principal arquivo de configuração é chamado de PLAYBOOK onde você coloca todas as tarefas que serão executadas “yum”,”mkdir”,”useradd” e no arquivo .ini você adiciona os servidores onde o Ansible irá executar esse PLAYBOOK. Cada Playbook possui roles que são as informações de provisionamento, após definir as roles você definirá em quais hosts essas roles serão executadas.

Dentro das roles existem as tasks, handlers, variaveis e templates:

       – Tasks: Tarefas de provisionamento que serão executadas

       – Handlers: Tarefas para manipular serviços e arquivos.

       – Templates: Arquivos para serem transformados em configurações dentro das máquinas.

       – Variaveis: Valores que são definidos para serem usados dentro das tasks, handlers e templates

O Ansible é uma ferramenta muito mais simples que seus concorrentes citados anteriormente, já que ele não precisa que seja instalado agents nos servidores na qual ele irá executar.

É possível utilizar Docker e Ansible em conjuntos para resolver duas situações: Implantação de Containers e Criação de Imagens.

Implantação de containers: É possível fazer toda a parte de orquestração, configuração e provisionamento com containers, sem precisar fazer a instalação de agents dentro dos containers

Criação de Imagens:

Exemplo de Playbook:

# Mysql service name for drupal application
mysqlservice: mysqld

# Mysql port for drupal application
mysql_port: 3306

# Database name for the drupal application
dbname: databasename

# Mysql Username for drupal application
dbuser: root  

Exemplo de Configuração do arquivo do Ansible:

[defaults]
inventory = /etc/ansible/inventory
host_key_checking = False
priva_key_file = ~/.sh/id_rsa
callback_plugins   = /opt/ansible-plugins/callbacks
connection_plugins = /opt/ansible-plugins/connections

Então tá pessoal, hoje fizemos apenas uma pequena introdução ao Ansible, em nossos próximos posts estaremos trazendo algo como Jenkins, Travis e também faremos um grande post mostrando como podemos criar um ambiente com Docker, Jenkins e Ansible. Obrigado

Referência: http://docs.ansible.com/ansible/playbooks_intro.html e http://ibm.com/developerworks/br/cloud/library/cl-provision-docker-containers-ansible/

Rancher – Painel para Docker

Olá,
O MundoDocker mostra hoje para vocês como funciona o Rancher, uma plataforma para deploy de sua infraestrutura Docker de forma fácil e controlada. O Rancher pode ser dividido em duas camadas: RancherOS, que é um sistema operacional minimalista (assim como o CoreOS) e a plataforma Rancher, vamos conhece-las mais:

RancheOS

O RancherOS, trás apenas as funções essenciais para o funcionamento do ambiente Docker, veja na imagem abaixo como é a arquitetura do RancherOS:

rancheroshowitworksFonte: http://docs.rancher.com/

O tamanho de uma imagem do RancherOS é de de 20MB, e possui tudo que é necessário para montar seu servidor para deploy de containers Docker. Como pode ser visto na imagem acima, o RancherOS é uma kernel base bem limitado, e toda a plataforma do Rancher é montada em cima de containers, sendo o init do sistema, chamado PID 1, é feito dentro de um container Docker, e os demais serviços (udev, dhcp, etc) são inicializados dentro de outros containers. Como você deve ter notado, no RancherOS o Docker faz o trabalho do sistema de inicialização (sysvinit ou systemd), comum em outros distribuições Linux.

Outro ponto interessante é que, como o RancherOS inicializa dentro de um container, o próprio serviço Docker a nível de usuário executa dentro um container Docker, ou seja, os containers de aplicação (que o usuário cria) são inicializados dentro do container de sistema, isso garante ainda mais isolamento e claro segurança, pois inclusive o sistema está encapsulado dentro de um container.

Rancher

Rancher é um software opensource que possibilita a criação de uma plataforma privada para criação de containers. Através dele é possível administrar todos os pontos de seu ambiente Docker, incluindo: orquestração, loadbalance, volumes e rede. E ainda é possível fazer a diferenciação entre usuários, ou seja, você pode criar um pool de recursos para seu desenvolvedor e ele mesmo poderá criar quantos containers quiser e puder, isso é muito útil para da liberdade e ainda assim garantir controle.

Um grande ponto positivo do Rancher, é você não ser obrigado a usar o RancherOS (claro que isso é muito recomendado), basta você subir seu servidor com Docker instalado e instalar tanto a plataforma quanto os agentes do Rancher dentro de containers.

Vamos a prática? Partimos do principio que você já tenha o Docker instalado, agora execute:

docker run -d --restart=always -p 8080:8080 rancher/server

Esse comando criará um containers com o servidor Rancher já pronto, feito isso basta acessar via web o ipdoservidor:8080, veja na imagem:

Rancher01

Veja que ele deixa em destaque a informação de que não foi configurado uma forma de acesso, para fazer isso vá até: Admin – Access Control, e habilite a forma que desejar, em nosso exemplo escolhemos Local, ou seja, utilizarei usuário criados dentro do Rancher mesmo, após isso crie seu primeiro usuário administrativo e salve, em seguida faça logout da plataforma e acesse: ipdoservidor:8080/login e acesse com os dados que você acabou de criar:

Rancher02

Depois de logado, clique em Add Host, para adicionar um host a ser manipulado pelo Rancher, lembre-se, você pode ou não adicionar o host onde está executando o servidor Rancher, se escolher adicionar ele deixe marcado a opção que vem e clique em Save, na próxima tela você pode escolher um dos provedores (Amazon, Digital Ocean, RackSpace, etc) para fazer deploy de seus hosts, como vamos adicionar o host local, clique me Custom, o Rancher lhe informará alguns dados que você deverá seguir, como por exemplo liberar porta no firewall e executar um comando para adicionar o Rancher Agent, veja:

Rancher03

Feito isso você verá que foi adicionado um host em seu dashboard. A partir de agora basta você criar os containers que desejar e claro fazer toda a definição de usuários, pool de recursos e o que mais for interessante para você.

Isso é o básico sobre o Rancher, mas o suficiente para você entender a ferramenta e dar o uso adequado a ela dentro do seu ambiente, em posts futuros falaremos mais sobre ela e traremos alguns exemplos práticos de uso do Rancher para deploy de container e automação de infraestrutura.

Esperamos ter ajudado, e nos ajude divulgando o MundoDocker. Abraço!

Persistindo dados -BTSync

Olá,

Hoje o mundodocker.com.br dará inicio a uma série de posts que tem por objetivo trazer soluções práticas para a persistência de dados no ambiente Docker.

Uma das premissas de se utilizar Docker é de que seu container é descartável, sim, isso pode parecer um tanto quanto radical, mas container em si foi desenvolvido para atender um processo durante um tempo determinado, e não para servir como um servidor virtual, nesse sentido, um cuidado que se deve ter é persistir os dados importantes de sua aplicação em um volume, ou até mesmo em um sistema de arquivo distribuído, dessa forma um container pode morrer, sem que sua aplicação morra junto.

Vamos ver nessa série, algumas alternativas para isso, e começamos com a mais simples delas: BTSync. Para quem não conhece o BTSync é uma ferramenta que utiliza o protocolo do Bittorrent para sincronismo de dados, através dele é possível sincronizar pastas e arquivos entre diferentes plataformas (desde que tenha o Sync instalado), de forma segura e rápida. No nosso exemplo vamos simular a sincronização de dados entre containers, dessa forma você pode fazer com que diversos containers tenha os dados de sua aplicação, garantindo assim maior disponibilidade. Mãos a obra então:

Como vocês já sabem, vamos criar um Dockerfile para gerarmos uma imagem e carrega-la para onde quisermos, esse é um bom exemplo:

FROM ubuntu:14.04

RUN apt-get update && apt-get install -y curl
RUN curl -o /usr/bin/btsync.tar.gz http://download-lb.utorrent.com/endpoint/btsync/os/linux-x64/track/stable; cd /usr/bin && tar -xzvf btsync.tar.gz && rm btsync.tar.gz
RUN mkdir -p /btsync/.sync; mkdir -p /var/run/btsync; mkdir -p /data

EXPOSE 8888
EXPOSE 55555

ADD start.sh /usr/bin/start.sh

RUN chmod +x /usr/bin/start.sh

VOLUME ["/data"]

ENTRYPOINT ["start.sh"]

 

Na mesma pasta onde está esse Dockerfile, crie um arquivo chamado: start.sh com o seguinte código:

#!/bin/bash
SECRET="${@}"
: ${SECRET:=`btsync --generate-secret`}

echo "Starting btsync with secret: $SECRET"

echo "{
 "device_name": "Sync Server",
 "listening_port": 55555,
 "storage_path": "/btsync/.sync",
 "pid_file": "/var/run/btsync/btsync.pid",
 "check_for_updates": false,
 "use_upnp": false,
 "download_limit": 0,
 "upload_limit": 0,
 "shared_folders": [
 {
 "secret": "$SECRET",
 "dir": "/data",
 "use_relay_server": true,
 "use_tracker": true,
 "use_dht": false,
 "search_lan": true,
 "use_sync_trash": false
 }
 ]
}" > /btsync/btsync.conf

btsync --config /btsync/btsync.conf --nodaemon

Explicando: Você pode definir, via arquivo de configuração, algumas variáveis para o btsync trabalhar, como por exemplo chave para estabelecer comunicação, diretório que será sincronizado e limites de transferência, é claro que em nosso teste não vamos definir algumas delas, apenas alterei o “dir” para que seja sincronizado o diretório /data, você pode definir qualquer um. Por padrão, a porta de comunicação é a 55555, você pode modificá-la sem problema, e não é necessário você mapear portas do host para o container ;).

Então, criado o Dockerfile e o start.sh, vamos gerar a imagem:

docker build -t bt_mundodocker .

Agora é simples, basta você iniciar o primeiro container:

docker run -d --name repl1 bt_mundodocker

Você deve capturar a chave gerada na inicialização desse container, ela será útil para quando você iniciar o segundo container, pois será a chave que permitirá estabilizar a conexão entre os peers do btsync:

docker logs repl1

A saída desse comando, será algo parecido com isso:

Starting btsync with secret: ANDHOU5F7NHNR3EBPFYBPFJJMKATGLBEK
[20160329 21:23:04.194] total physical memory 536870912 max disk cache 2097152
[20160329 21:23:04.195] My PeerID: 102D9BFD720DF686F77DD0BC7FE5FDC98C767930
[20160329 21:23:04.683] LC: license expired
[20160329 21:23:05.291] LC: license renewal

Basta você inicializar o segundo container, passando essa chave como parâmetro:

docker run -d --name repl2 bt_mundodocker ANDHOU5F7NHNR3EBPFYBPFJJMKATGLBEK

Veja agora o retorno do comando docker logs desse container:

Starting btsync with secret: ANDHOU5F7NHNR3EBPFYBPFJJMKATGLBEK
[20160329 21:27:07.480] total physical memory 536870912 max disk cache 2097152
[20160329 21:27:07.482] My PeerID: 1015FC44C961E6AB9B77AD3951437CC69C6D357A
[20160329 21:27:07.756] LC: license expired
[20160329 21:27:08.084] LC: license renewal
[20160329 21:27:08.090] PeerConnection[0x00007fe9bc001170] incoming connection from 172.17.0.42:57871
[20160329 21:27:08.143] PeerConnection[0x00007fe9bc001170] incoming connection from 172.17.0.42:57871
[20160329 21:27:09.260] PeerConnection[0x00007fe9bc20a1c0] incoming connection from 172.17.0.42:55555

Para testar, acesse os containers (docker exec -it repl1/repl2 /bin/bash), crie arquivos dentro da pasta /data e veja que eles serão sincronizados entre os containers, mesmo se você tiver mais de dois containers. Legal né? Todo o trafego entre os containers (mesmo os que não sejam locais) é criptografado, e apenas peers (containers) que iniciaram com a chave mencionada é que entram na replicação. Claro, nem tudo são flores, quanto maior a latência entre os containers, mais lento será essa replicação, então pense bem antes de sair utilizando ele para qualquer coisa

Fácil, simples e muito eficiente, essa foi a apresentação da primeira solução para persistência de dados entre os containers, fique atento aos próximos. Se gostou, ajude divulgando o Blog.

Grande Abraço!

Docker Compose

Oi pessoal,

Seguindo nossa série de posts sobre as ferramentas do ecossistema Docker, hoje veremos um pouco mais sobre o Docker Compose, uma ferramenta que agilizar no deploy de seu ambiente, utilizando uma forma simples, claro e padronizada.

O Docker Compose é uma ferramenta para a criação e execução de múltiplos containers de aplicação. Com o Compose, você usar um arquivo do tipo yaml para definir como será o ambiente de sua aplicação e usando um único comando você criará e iniciará todos os serviços definidos.

Compose é ótimo para desenvolvimento, testes e homologação, bem como para melhorar seu fluxo de integração continua. Por exemplo:

  • Em ambiente de desenvolvimento: Você pode utilizar ele para simular todo o ambiente de produção, ou seja, precisando de serviço redis, php, mysql? Basta definir isso em um arquivo .yml e quando você executar o docker-compose up, todo esse ambiente está disponível para você, todas as dependências que sua stack precisa estará configurada e disponível para uso. Isso sem contar que este ambiente poderá ser isolado, sem depender ou prejudicar o trabalho dos demais da equipe.
  • Automação de testes: Uma das premissas básicas para desenvolvimento e integração continua é ter uma base de testes automatizada, isso para garantir qualidade e agilidade na entrega de novas releases de sua aplicação. Pensando nisso, você pode utilizar o docker compose para criar sua própria suite de testes, e precisando apenas executar um docker-compose up para testar os 50, 100, 200 requisitos que você definiu.

Para utilizar o docker-compose você precisa ter em mente que será necessário seguir essas três etapas:

  1. Definir o ambiente necessário para sua aplicação utilizando um Dockerfile (que pode ser reproduzido em qualquer lugar que tenha Docker instalado);
  2. Definir no arquivo .yml  quais serviços são essenciais para sua aplicação e a relação entre elas.
  3. Executar o comando docker-compose up para que seu ambiente seja criado e configurado.

Fácil certo? Vamos praticar?

Instalação

Bem simples, basta executar o seguinte comando (caso Linux), se você estiver utilizando em Windows via Docker ToolBox você já terá disponível o docker-compose. Vamos lá:

curl -L https://github.com/docker/compose/releases/download/1.5.2/docker-compose-`uname -s`-`uname -m`
 > /usr/local/bin/docker-compose

Depois:

chmod +x /usr/local/bin/docker-compose

Compose eu escolho você

Vamos testar com um WordPress, é fácil:

  1. Criar um diretório de trabalho (mkdir /my-app);
  2. Faça download do WordPress: cd /my-app; curl https://wordpress.org/latest.tar.gz | tar -xvzf –
  3. Criar um arquivo Dockerfile com o seguinte código:
    FROM orchardup/php5
    ADD . /app
    
  4. Criar um arquivo my-app.yml com o código:
    web:
      build: .
      command: php -S 0.0.0.0:8000 -t /my-app
      ports:
        - "80:8000"
      links:
        - db
      volumes:
        - .:/my-app
    db:
      image: orchardup/mysql
      environment:
        MYSQL_DATABASE: wordpress
    
  5. Certifique-se de que seu wp-config esteja parecido com este:
    <?php
    define('DB_NAME', 'wordpress');
    define('DB_USER', 'root');
    define('DB_PASSWORD', '');
    define('DB_HOST', "db:3306");
    define('DB_CHARSET', 'utf8');
    define('DB_COLLATE', '');
    
    define('AUTH_KEY',         'put your unique phrase here');
    define('SECURE_AUTH_KEY',  'put your unique phrase here');
    define('LOGGED_IN_KEY',    'put your unique phrase here');
    define('NONCE_KEY',        'put your unique phrase here');
    define('AUTH_SALT',        'put your unique phrase here');
    define('SECURE_AUTH_SALT', 'put your unique phrase here');
    define('LOGGED_IN_SALT',   'put your unique phrase here');
    define('NONCE_SALT',       'put your unique phrase here');
    
    $table_prefix  = 'wp_';
    define('WPLANG', '');
    define('WP_DEBUG', false);
    
    if ( !defined('ABSPATH') )
        define('ABSPATH', dirname(__FILE__) . '/');
    
    require_once(ABSPATH . 'wp-settings.php');
    
  6. O que falta? docker-compose up no diretório onde você criou o Dockerfile e o  my-app.yml.

Agora é só acessar: http://ipdamaquina e prosseguir com a instalação do Woprdress normalmente, o que o Compose fez então? No passo 3 nós criamos um arquivo Dockerfile contendo a descrição da imagem que queremos criar e que será utilizada como base para o nosso ambiente, no passo 4 nós definimos qual era esse ambiente, veja que definimos 1 container para atender requisições web e 1 banco de dados, quando executamos o docker-compose up ele criará a imagem baseado no Dockerfile e criar os containers de serviços que definimos no my-app.yml. O mais legal, você pode quer escalar seu ambiente, ter mais containers web? docker-compose scale web=5 e o Compose criará e iniciará 5 containers do serviço web que definimos no my-app.yml.

Alguns dados importantes sobre o Docker Compose:

  • O Compose preserva todos os volumes atribuídos aos seus serviços, por exemplo, quando você executa o docker-compose up, se você já tiver algum outro container utilizando o volume informado, o Compose copiará o volume do container antigo para o novo container, sem perder nenhuma informação.
  • O Compose recriará apenas containers cujas configurações foras modificadas, caso contrário ele se baseará nas configurações que ele já tem armazenada em cache, isso é muito útil principalmente para provisionar e escalar seu ambiente de forma muito mais rápida.

Você ainda pode utilizar o Docker Compose juntamente com o Docker Machine e provisionar seu ambiente em qualquer lugar que precisar, isso é ainda mais útil para quem tem seu serviço de infraestrutura terceirizado com outros provedores (AWS, Digital Ocean, etc).

Gostou? Ótimo! nos ajude divulgando o MundoDocker, não gostou? Não tem problema, deixa seu feedback para que possamos melhorar cada vez mais

 

Abraço!

Troubleshooting e dicas de Docker

Olá pessoal,

Já faz mais de 1 ano que criamos esse blog e hoje resolvemos fazer um post referente a como solucionar algumas dificuldades e problemas que tivemos no começo, visto que trabalhamos a mais de 2 anos já com Docker, tivemos muitos problemas que queremos demonstrar para vocês.

Instalando a versão mais recente

A maioria das pessoas que acabam por usar Ubuntu, Centos, RedHat ou qualquer outra distribuição utiliza seus próprios comandos para realizar a instalação do Docker, com yum ou apt-get. Mas a forma de utilizar as versões mais recentes são essas:

Versão oficial para se utilizar em produção:

curl -sSL https://get.docker.com/ | sh

Versão que se encontra ainda em fase de testes:

curl -fsSL https://test.docker.com/ | sh

Versão alpha que está em constante desenvolvimento:

curl -fsSL https://experimental.docker.com/ | sh

 Como remover todos os containers parados:

docker rm $(docker ps -a -q)

 Sincronizar o relógio do host com o container:

Isso é um dos principais problemas que as pessoas acabam encontrando as vezes.

Para Centos (Na hora de criar o container mapeia o diretório do host com o do container)

docker run -v /etc/localtime:/etc/localtime:ro centos date

Para Ubuntu (Na hora da criar o container passa como variável o timezone(tz)

docker run -e "TZ=America/Salvador" ubuntu date

 Comunicação entre containers:

Por padrão no Docker a comunicação entre os containers na mesma rede é liberado através de IP interno. Mas caso você queira que os containers não se comuniquem diretamente basta mudar na hora da criação da rede colocar icc=false.

docker network create -o com.docker.network.bridge.enable_icc=false rede_isolada

Montando volumes com services:

Quando criamos um container simples com docker run, existe a opção do -v onde podemos passar como parâmetro o nosso volume, porém com a implementação do services no Docker 1.12 ficou um pouco mais complicado na hora de passar um volume para o serviço:

Como você pode ver na opção “type” temos o “bind” que seria um diretório em nosso host:

docker service create --mount type=bind,source=/diretoriohost,target=/diretoriocontainer imagem

E também temos a opção volume que é passado o volume que é criado com “docker volume create…..

docker service create --mount type=volume,source=meuvolume,target=/diretoriocontainer imagem

 Docker commit e volume:

O comando “docker commit” gera uma imagem do nosso container, porém ele NÃO vai armazenar os dados do volume que estão atrelados a aquele container. Então o docker commit não irá servir de backup para os seus dados que estão no volume.

Não rode containers com –privileged

Com a opção de –privileged o container consegue facilmente acessar diversas áreas do seu host na qual podem ser cruciais caso alguém ache alguma brecha de segurança em sua aplicação.

Um processo para cada container.

Não instale pacotes desnecessários em seus containers, se você quer ter um container para apache, só instale o apache nele. Quer ter o PHP também? então suba outro container.

Cuidado com as regras de IPTABLES

Como o Docker trabalha com toda a sua parte de redes através de iptables, é bem provável que se você fizer alguma manutenção em seu firewall e editar alguma regra errada, toda a sua estrutura de Docker pode parar de funcionar por algum problema.

Coloque o diretório do docker em outro disco:

O docker utiliza o caminho “/var/lib/docker” para colocar todos os seus arquivos de instalação e também toda a sua estrutura de containers, volumes e mais outros recursos que ele utiliza. Então não deixe esse diretório no mesmo disco do seu SO.

Gostaram do post? Deixe seu feedback e novamente, nos ajudem divulgando o blog.

Grande abraço!

E os Logs?

Oi Pessoal, tranquilo?

Uma das coisas que atormentam tanto a vida do pessoal de Dev quanto de Ops é saber o que está acontecendo com o seu ambiente. Como se resolve isso? Existem duas formas, que devem sempre trabalhar juntas, são elas: Monitoramento, para saber que vai dar problema antes do problema ocorrer :), e Gerencia de logs, para saber, depois de ocorrer algum problema, o que aconteceu com sua aplicação ou ambiente que ocasionou o comportamento inesperado.

Essa mesma abordagem deve ser utilizada quando se trabalha com containers também, para monitoria você já viu aqui e aqui algumas formas de como pode ser feito esse monitoramento. Para a gerencia de logs você deve pensar antes qual será a criticidade dessas informações para o debug de sua aplicação e resolução de algum imprevisto, outro ponto é: como preciso ou como gostaria de visualizar essas informações. Tendo resolvido essas duas questões você pode então optar:

  • Utilizar o comando docker logs: Com isso você terá as informações do que está sendo enviando para a console do container, ou seja,somente irá visualizar aquilo que estiver passando na console, você deve fazer com que sua aplicação envie as informações necessárias para a console do container. Caso sua aplicação salve o debug em arquivo de log você não conseguirá visualizar de forma fácil essa informação.
  • Utilizar plugins de log: Utilizando plugins você pode fazer com que qualquer log do container seja enviado para um serviço externo, isso garante que você poderá ter acesso a qualquer informação (seja do container ou app) de um único lugar.

O que vamos ver hoje é como você pode utilizar alguns dos plugins de logs mais conhecidos, isso é claro na prática

Fluentd

Um dos drivers de log mais fácil de se utilizar, com ele você pode enviar tanto o stderr quanto o stout para o serviço de logs externo, para isso basta você rodar:

docker run --log-driver=fluentd

É claro que você precisa passar alguns parâmetros, como por exemplo: “–log-opt fluentd-address=” onde você define qual será o destino de seus logs, geralmente será um host onde estará rodando o servidor Fluentd ou o endereço que esse serviço lhe fornecer. Por padrão a tag de busca será o id do container, com isso, quando você precisar consultar algum log deverá faze-lo pelo id do container que desejar.

Splunk

O Splunk é talvez uma das ferramentas para gerenciamento de log mais completo que se pode ter, e da mesma forma que o Fluentd, você precisa apenas definir esse driver como sendo de log:

docker run --log-driver=splunk

Você precisa definir algumas coisas antes, veja a lista:

  • splunk-token: Token utilizado para autenticação do container na API http;
  • splunk-url: Endereço do servidor de Splunk disponível, seja ele local ou na solução de cloud da Splunk;
  • splunk-source: Origem do log (se não definido ele coletará tudo);
  • splunk-sourcetype: Tipo do log (app, debug, etc);
  • splunk-index: Índice para os logs;
  • splunk-capath: Caminho do certificado;
  • splunk-caname: Nome para validação do certificado, por padrão ele pega pelo nome do splunk-url;
  • splunk-insecureskipverify: Desativa a verificação ssl para o seu host Splunk;
  • tag: Identificação do log na base, no caso do Docker você pode definir qualquer informação do container como tag, por exemplo: ID, Nome, Região, etc;
  • labels: Facilita a consulta do log posteriormente, você pode por exemplo consultar logs do container x que pertence a região Sul;
  • env: Pode classificar por Dev, Test, Prod etc.

Veja um exemplo prático:

docker run --log-driver=splunk --log-opt splunk-token=SEUTOKENAQUI --log-opt splunk-url=https://servidor-splunk:8088 --log-opt splunk-capath=/etc/cert/cacert.pem --log-opt splunk-caname=SplunkDefaultCert --log-opt tag="{{.Name}}/{{.FullID}}" --log-opt labels=location --log-opt env=TESTE --env "TESTE=false" --label location=sul nginx

AWS Logs

Claro que não poderia faltar a opção de enviar seus logs para o CloudWatch da AWS, e é o mais simples de se utilizar, por um motivo: Basta você ter conta na AWS e ativar o CloudWatch, não é necessário contratar um serviço cloud de terceiro ou subir um servidor de log local. Veja como você pode utiliza-lo:

docker run --log-driver=awslogs --log-opt awslogs-region=sa-east-1

Você deve definir para qual grupo de log deseja enviar os logs do container, e tenha cuidado pois dependendo do tipo de logs e quantidade, pode prejudicar a visualização do mesmo, então preste atenção no formato de log que estará enviando:

docker run --log-driver=awslogs --log-opt awslogs-region=sa-east-1 --log-opt awslogs-group=MeuGrupodeLog nginx

A autenticação é bem simples, você montar o seguinte volume: aws:~/.aws, dentro dessa pasta deve ter um arquivo chamado credentials com o seu AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, e AWS_SESSION_TOKEN Lembre-se que o usuário utilizado para isso deve ter no mínimo as seguintes permissões: logs:CreateLogStream e logs:PutLogEvents.

Espero ter ajudado, tenho alguma dúvida pode nos enviar por e-mail ou deixe nos comentários. E nos ajude divulgando o blog

Abraço!

Docker – Device mapper

Olá pessoal,

No primeiro post da série falamos sobre AUFS e hoje vamos falar um pouco sobre Device Mapper.

Origem

No começo o Docker era suportado apenas em distribuições Ubuntu, Debian e usavam AUFS para o seu armazenamento. Depois de algum tempo o Docker começou a se popularizar e as pessoas começaram a querer utilizar Docker com RedHat, porêm o AUFS era suportado apenas em sistemas (Debian,Ubuntu).

Então os engenheiros da Redhat baseados no código do AUFS decidiram desenvolver uma tecnologia própria de armazenamento baseado no já existente “Device mapper”. Então os engenheiros da RedHat colaboraram com o “Docker inc” para contribuir com um novo driver de armazenamento para containers. Então o Docker foi reprojetado para fazer a conexão automática com o dispositivo de armazenamento baseado em Device Mapper.

Layers

O Device Mapper armazena cada imagem e container em seu disco virtual, esses discos virtuais são dispositivos do tipo Copy-on-Write no nível de bloco e não a nível de arquivo. Isso significa que ao invés do Device Mapper copiar todo um arquivo para o seu dispositivo, ele vai copiando por blocos o que o torna muito rápido comparado ao AUFS. No processo de criação de uma imagem com o Device Mapper é criado um pool e em cima desse pool é criado um dispositivo base que é a partir dele que as imagens são construídas, a partir dai temos as imagens base do Docker que a cada modificação vão criando camadas de snapshots a cima da camada anterior. Conforme a imagem abaixo:

https://docs.docker.com/engine/userguide/storagedriver/images/two_dm_container.jpg

Read

Quando um container deseja ler algum arquivo que está nas camadas anteriores o Device Mapper cria um ponteiro na camada do container referenciando a camada da imagem onde possui esses dados colocando transferindo esse bloco para a memória do container.

Write

Quando o Docker faz uma alteração no arquivo utilizando Device Mapper esse arquivo é copiado apenas o que sera modificado cada bloco de modificação copiado é de no máximo 64KB. Por exemplo na escrita de um arquivo de 40KB de novos dados para o container o Device Mapper aloca um único bloco de 64KB para o container, caso a escrita seja de um arquivo maior que 64KB então o Device Mapper aloca mais blocos para realizar essa gravação.

O Device Mapper já é padrão nas em algumas distribuições do linux como:

  • RedHat/Centos/Fedora
  • Ubuntu 12.04 e 14.04
  • Debian

Docker e Device Mapper

O Device Mapper atribui novos blocos para um container por meio de uma operação chamada “Allocate-on-Demand”, isso significa que cada vez que uma aplicação for gravar em algum lugar novo dentro do container, um ou mais blocos vazios dependendo do tamanho de gravação terão que ser localizados a partir do pool mapeado para esse container. Como os blocos são de 64KB então muitas gravações pequenas podem sofrer com problemas de performance, pois acaba causando lentidões nas operações. Com isso aplicações que gravam arquivos pequenos sequencialmente podem ter performance piores com Device Mapper do que com AUFS.

Legal né? Se gostou nos ajude divulgando o blog.

Grande abraço!

 

Sysdig para Ops

Oi Pessoal,

Queremos mostrar para vocês hoje como é possível analisar seu ambiente Docker e ver a saúde de seus containers de forma fácil e bem prática, conheça nesse post o Sysdig. O Sysdig é uma ferramenta escrita em Lua que vem como uma opção, principalmente para quem é de operações, para realizar algum troubleshooting em seu sistema. Ele trás de forma rápida e fácil todas as informações que você precisa saber, não havendo mais a necessidade de executar dois, três comandos para ter uma noção do que está acontecendo, com o Sysdig em um único comando você já terá visibilidade do que é importante você saber e do que pode estar ocorrendo em seu sistema. O Sysdig também é multiplataforma, então é possível instalar ele tanto em Windows, quanto Linux e Mac, e claro, ele suporta containers, ótimo! Veja abaixo um mini tutorial que montamos para você:

1 – Instalação:

Simples, se for em um host Linux você pode utilizar o comando abaixo:

curl -s https://s3.amazonaws.com/download.draios.com/stable/install-sysdig | sudo bash

Você ainda pode baixar os repositório e utilizar sua ferramenta para instalação (yum, apt-get e afins), que saber como? Da uma olhada aqui e veja também como instalar o Sysdi em Windows e Mac.

2 – Utilização:

Mas claro o que nos interessa é saber como mais como está o uso de recursos do meu host, e descobrir qual container está utilizando mais em relação aos outros, ou ainda ver como está a saúde do meu ambiente Docker, mas como o Sysdig faz isso? Ele fica ‘ouvindo’ as chamadas de sistema e com base nessas informações monta os reports para você, veja na imagem abaixo como ele trabalha tanto com Docker quanto com LXC puro:

Perceba que o Kernel envia para o Sysdig todas as informações que foram processadas por ele, seja de acesso a memória, disco, rede, processador, etc. e com base nisso o Sysdig consegue mapear qual processo está vinculado a qual arquivo, ou quanto de trafego está sendo gerado por um container.

Veja abaixo o exemplo de alguns comandos que pode lhe ser muito uteis (existe um lista bem grande disponível, vamos colocar aqui apenas os essenciais e extremamente úteis para fazer um troubleshooting em seu ambiente Docker):

  • Listagem dos containters existentes:
    sysdig -c lscontainers
  • Top por containers que mais utilizam CPU:
    sysdig -c topcontainers_cpu
  • Você ainda por visualizar quais processos estão consumindo mais recursos dentro de cada container, para isso:
    sysdig -pc -c topprocs_cpu

O retorno desse comando será algo parecido com este gif:

 

topproc_cpu

  • Você pode ainda filtrar a saída do comando pelo nome de seu container:
    sysdig -pc -c topprocs_cpu container.name contains wordpress
  • Quer ver quanto de rede um container está utilizando?
    sysdig -pc -c topcontainers_net
  • E qual processo dentro de cada container está utilizando mais rede?
    sysdig -pc -c topprocs_net
  • Quais portas estão trafegando mais?
    sysdig -pc -c topconns
  • Consigo filtrar por nome de container também?
    sysdig -pc -c topconns container name=wordpress
  • Eu consigo saber quais containers estão utilizando mais I/O em meu host?
    sysdig -c topcontainers_file
  • Consigo saber qual processo dentro do container está fazendo isso?
    sysdig -pc -c topprocs_file
  • E quais arquivos realmente estão sendo mais lidos ou escritos?
    sysdig -pc -c topfiles_bytes

 

Ufa, já é um começo certo? Existem muitas outras opções disponíveis, como por exemplo agregar logs de todos os containers em uma única visualização, com o Sysdig isso é simples de se fazer, quer ver mais? Acessa a Wiki dele, ela é rica em informações: http://sysdig.org/wiki

Por hoje era isso, fique por dentro das novidades aqui do Blog e se você ainda não viu, montamos um fórum aqui no blog, acessa o link ai em cima e poste a sua dúvida ou dificuldade, assim tanto nós quantos outras pessoas da comunidade Docker podem te ajudar e claro nos ajude divulgando o MundoDocker, Abraço!

Persistindo dados – Flocker

Olá,

Hoje, no terceiro post da série: Persistindo dados, vamos abordar mais uma forma de como você pode persistir os dados de sua aplicação, garantindo maior disponibilidade para seu ambiente, hoje o assunto é sobre o Flocker.

 A proposta do Flocker é muito parecida com demais soluções para sistema de arquivos distribuídos, a grande diferença esta no foco que a ClusterHQ (desenvolvedora da solução) está dando para o projeto, pois o objetivo tem sido tornar o Flocker cada vez mais especializado em Docker, ou seja, o objetivo do Flocker não é atender a qualquer tipo de problema, mas sim, atender muito bem uma das deficiências que há no Docker , que é a persistência de dados, tanto que o Flocker em si já é um plugin de volumes oficial do Docker. Veja abaixo uma imagem que ilustra muito bem o que o Flocker se propõem a atender:

Fonte: https://clusterhq.com/flocker/introduction/

Atualmente, quando você instância um container em outro host, você precisa cuidar se o volume de onde está sua aplicação também tem mapeamento nesse novo host, o objetivo do Flocker abstrair esse tipo de preocupação, e garantir que, quando um container for movido de um lado para o outro, os dados que estavam mapeados nele também acompanhem esse movimento.

Veja abaixo como é a arquitetura dessa plugin:

Fonte: https://clusterhq.com/flocker/introduction/

Note que, diferentemente do GlusterFS, você precisa ter um ambiente mais complexo, envolvendo basicamente 3 camadas: Flocker Plugin, que é responsável pela comunicação entre o Docker e o Flocker; Flocker Conrol, responsável pelo monitoramento dos volumes, e controle sob o funcionamento do ambiente; Flocker Agent, responsável por executar as ações de criação, remoção e demais ações do Flocker no host que faz parte do ambiente.

Novamente, e o Docker?

Como já falamos em posts anteriores, a intenção não é mostrar a vocês como realizar a instalação e configuração do cluster de Flocker, e sim, seu uso final, juntamente com o Docker, talvez daqui a pouco possamos montar um material com isso ;).

Mãos a massa:

Primeiro vamos criar o volume Docker utilizando o plugin do Flocker, para isso:

$ docker volume create --name volume-1 -d flocker

Agora basta mapear esse volume criado aos containers que desejar:

$ docker run -v volume-1:/data -it centos /bin/bash

Basta criar algum arquivo ou pasta no diretório /data do container e essa informação será salva no volume Flocker que você criou, para ter certeza de que o dado estará nesse volume, crie outro container mapeando esse volume, e você verá que no /data desse novo container estará o arquivo/pasta que você criou no primeiro.

Fácil né? O mais interessante no Flocker é que você não perde os dados caso dê algum problema no host, o volume será criado no cluster Flocker que você montou, e isso é o que garante a disponibilidade da informação.

Por hoje era isso, espero que tenham gostado e tendo dúvidas nos avisem, e claro ajudem divulgando o Blog

Abraço!

Docker AUFS

Olá pessoal,

AUFS foi o primeiro controlador de armazenamento em uso com Docker, como beneficio tem uma história longa com Docker. É muito estável, tem grandes implementações no mundo real e possui forte apoio da comunidade, o AUFS possui diversas características que acabam o tornando uma boa escolha para uso com Docker. Entre elas estão:

  • Tempo de inicialização do container rápido
  • Uso eficiente de armazenamento
  • Uso eficiente de memória

Apesar de ter uma ampla capacidade de caracteristicas com Docker, algumas distribuições não possuem suporte ao AUFS, pois ele não está incluído na linha principal do Kernel Linux, no caso do RHEL não é suporte AUFS.

Os tópicos seguintes demonstram algumas características do AUFS e como ele se relaciona com o Docker:

 

Layers de Imagens:

AUFS é um sistema de unificação de arquivos, isso quer dizer que ele leva vários diretórios em um único host linux, colocando um sobre o outro e fornece uma visão unificada desses arquivos para conseguir isso o AUFS usa uma união de montagem.

O AUFS driver de storage do Docker implementa Layers de imagens utilizando usando a união do sistema montado. Abaixo podemos ver um exemplo de Layers, onde para o cliente é apresentado a união de todas elas:

 

layer1

 

Utilizando arquivos:

O Docker utiliza a tecnologia de “AUFS CoW”  para conseguir compartilhar a imagem e minimizar o uso de disco. Como o AUFS trabalha em nível de arquivos então todos os dados são copiados por inteiros para a camada superior mesmo que modificando uma pequena parte do arquivo, isso faz com que dependendo do tamanho de arquivo que será copiado acabe penalizando um pouco o desempenho do container, pois um arquivo muito grande demorará algum tempo para que seja copiado. Ou também a imagem possui uma grande quantidade de camadas e o arquivo que você deseja utilizar está na primeira camada da imagem.

A ordem de procura é de cima para baixo, então caso seja a primeira vez que o usuário irá utilizar aquele arquivo, então o Docker vai procurar esse arquivo nas suas camadas abaixo e copiar todo o seu conteúdo para a camada gravável do container. Porém o arquivo só é copiado na primeira vez, após isso o esse arquivo já está na ultima camada então todas as demais operações são rápidas.

Deletando arquivos:

O driver do AUFS exclui um arquivo de dentro do container colocando um arquivo whiteout na camada gravável do container. O arquivo whiteout obscurece a existência do arquivo nas camadas inferiores de imagem:

 

 

layers2

 

 

Você pode adicionar o driver AUFS no seu daemon docker editando o arquivo de conf do docker e adicionando:

DOCKER_OPTS="--storage-driver=aufs"
systemctl restart docker

 

Então ta pessoal esse é nosso primeiro post dessa série que vai mostrar para vocês os drivers de armazenamento nativos do Docker.

 

Persistindo dados – GlusterFS

Oi Pessoal,

Seguindo na sequência de posts sobre persistência de dados no Docker, hoje vamos ver como podemos utilizar um sistema de arquivos distribuídos para garantir a disponibilidade de sua aplicação dentro de containers.

Para quem não conhece, o GlusterFS é um sistema de arquivos distribuídos desenvolvido pela RedHat e mantido pela comunidade GlusterFS. Como ele funciona? O Gluster permite que você defina volumes compartilhados entre os hosts, isso faz com que os dados sejam distribuídos entre os nós que fazem parte desse volume, existem basicamente duas formas de distribuir os dados com o GlusterFS:

Distributed Glusterfs Volume

Nesse Formato, o GlusterFS distribuí os dados do volume entre todos os nós, isso quer dizer que cada nó terá apenas uma parte da informação, essa arquitetura é muito útil quando você deseja que a leitura seja muito rápida, pois o acesso é feito simultaneamente em todos os nós, mas não garante disponibilidade dos dados, pois caso um dos nós falhe, as informações que ele continha ficarão inacessíveis. Veja abaixo o desenho ilustrativo:

distributed_volume

Fonte: http://gluster.readthedocs.org/en/latest/Quick-Start-Guide/Architecture

Neste exemplo, quando for solicitado os arquivos File 1 e File 3, o Gluster consultará todos os nós e retornará a informação solicitada, como esse acesso é simultâneo, o tempo de resposta é reduzido.

Replicated Glusterfs Volume

No caso de se utilizar o método de replicação, os dados serão armazenados em todos os nóss, isso é claro aumenta o tempo de gravação do arquivo, pois o tempo de resposta será baseado no nó mais lento, mas garante disponibilidade da informação em caso de falha de algum outro nó. Veja abaixo como é esse tipo de arquitetura:

replicated_volume

Fonte: http://gluster.readthedocs.org/en/latest/Quick-Start-Guide/Architecture

Como ser visto, os arquivos são salvos sempre em todos os demais nós, a consulta é feita sempre no nó com menos latência, ou seja, o mais próximo do ponto de origem da requisição.

Há ainda uma forma mista de trabalho, onde é possível garantir que o dados seja replicado e que seja escrito em diversos nós, chama-se:

Distributed Replicated Glusterfs Volume

Dessa forma os dados são escritos em um volume distribuído, que possui ainda sub-volumes replicados, ou seja, você tem maior velocidade de leitura, e ainda garante que os dados estejam em vários nós ao mesmo tempo. Veja como isso funciona:

distributed_replicated_volume

Fonte: http://gluster.readthedocs.org/en/latest/Quick-Start-Guide/Architecture

Note que quando for salvo algum arquivo no ponto de montagem, ele salvará o arquivo no volume distribuído, e esse volume contém os sub-volumes replicados. Para todos os efeitos, o retorno da operação de gravação é realizado pelo volume distribuído, mas o dado será replicado entre os demais nós que fazem parte do volume replicado.

Ok, mas e o Docker?

O objetivo desse post não é ensiná-los a como instalar ou configurar o Gluster, mas sim, como utilizá-lo para garantir disponibilidade de seus dados. Pensando nisso, queremos mostrar para vocês como pode ser utilizado um plugins do Docker que provê suporte a GlusterFS, tenha em mente, antes de tudo, que você já deve ter seu cluster de GlusterFS montando e funcionando, independente da arquitetura escolhida ou ponto de montagem.

Passo 1:

Instale o plugin para administração dos volumes GlusterFS:

$ go get github.com/calavera/docker-volume-glusterfs
Passo 2:

Monte seu ambiente, informando quais servidores fazem parte do cluster que atenderá a demanda de volume, informe também em qual porta o serviço executará, caso esteja utilizando uma porta alternativa:

$ docker-volume-glusterfs -servers server1:server2:server3

É importante enfatizar que você precisará realizar esse procedimento em todos os hosts com Docker aos quais deseja utilizar esse plugin.

Passo 3:

Agora use!

$ docker run --volume-driver glusterfs --volume datastore:/teste centos touch /teste/ola

Inicie outro container, informando esses dados de volume e veja que foi criado um arquivo ola dentro da pasta teste:

$ docker run --volume-driver glusterfs --volume datastore:/teste centos /bin/bash
$ ls -la /teste/
$ -rw-r-xr-- 1 root root 1115 Apr 11 ola

O mais interessante é que nesse caso, você não precisa fazer com que os containers se falem diretamente, basta que nos hosts de Docker você inicie o plugin informando quais os hosts de GlusterFS que serão utilizados, feito isso é só mapear para o container e pronto, seus dados estarão sendo vistos por qualquer container que utilizar esse mesmo volume.

Gostou? Ajude divulgando o Blog

Grande Abraço!

Oito dicas sobre Docker

Oi Gente!

Sendo este o primeiro post com conteúdo sobre Docker para o ano de 2017, tivemos a ideia de trazer a vocês algumas dicas e informações que consideramos de muita importância. Para isso fizemos um com uma apresentação sobre essas dicas, explicando cada uma dela e contando um pouco sobre como elas resolvem ou ajudam em determinadas situações. Vamos ao vídeo?

 
Para você que não conseguiu ver o vídeo, disponibilizamos também a apresentação em nosso canal no slideshare, acompanhe:

 

Viu, não deixamos passar nada

Aguarde pois este ano teremos diversas novidades aqui no blog, garanto que vocês vão gostar.

 

Grande abraço!

Alpine – Faça você mesmo

Oi Pessoal,

O MundoDocker trás hoje para você um pequeno tutorial de como é possível criar uma imagem enxuta, somente com o que você precisa e utilizando menos espaço possível. Para isso será necessário utilizar uma das duas imagens mais limpas do Docker, são elas: Alpine ou BusyBox, nesse tutorial vamos focar na Alpine, uma das mais buscadas atualmente.

Para que não conhece, a Alpine é uma distribuição construída com musl libc e BusyBox, que é conhecida como canivete suíço, pois combina versões minúsculas de muitos utilitários comuns no UNIX em um único pequeno executável. Algumas características de Alpine:

Pequena

Enquanto a menor imagem para Docker precisa de cerca de 130MB de espaço em disco, a Alpine precisa de no máximo 8MB, isso faz com que, mesmo você montando todo o seu ambiente, ele nunca terá o mesmo tamanho do que se montando em um imagem tradicional, isso é ótimo, pois deixa o ambiente ainda mais enxuto e simples de migrar.

Simples

Você tem apenas aquilo que é necessário para o funcionamento de sua aplicação, se precisar de mais alguma biblioteca, é só instalar, você não precisa se preocupar em desativar ou remover lixos, eles simplesmente não existem.

Segura

Alpine foi desenvolvida pensando em segurança, e para garantir isso os desenvolvedores se preocuparam aprimorar os recursos de segurança do kernel como grsecurity/PaX, além disso, todos os binários foram compilados em executáveis independente de posição, isso previne alguns uso problemas relacionados a buffer overflow e outros tipos de ataques envolvendo estouro de pilha.

Mãos a obra?

Nosso exemplo consistirá em montarmos uma imagem de com Alpine e Nodejs, e vamos comparar o tamanho da nova imagem que montamos com Alpine e outras distros disponíveis.

A Aplicação:

Será algo bem simples, apenas uma aplicação olá mundo:

var http = require('http');
http.createServer(function(req,res) {
 res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' });
 res.end('Exemplo Node.js Mundo Docker!');
}).listen(8080);

Colocamos o nome de app.js, não esqueça de criar o package.json com as dependências da aplicação:

{
"name": "docker_web_app",
"version": "1.0.0",
"description": "Node.js on Docker",
"author": "First Last <[email protected]>",
"main": "app.js"
}

Agora criamos nosso Dockerfile:

FROM alpine:3.1
# Update
RUN apk add --update nodejs
# Cria a pasta da app
RUN mkdir -p /usr/src/app
WORKDIR /usr/src/app
# Instala as dependencias da app
COPY package.json /usr/src/app/
RUN npm install
# copia a app
COPY . /usr/src/app
EXPOSE 8080
CMD ["node", "/usr/src/app/app.js"]

 

Não é nada muito complexo, basta você informar qual imagem base utilizará, e a diferença está no instalador de dependências, que para o Alpine é o apk. Agora vamos gerar a imagem:

docker build -t alpineteste .

Será gerado uma nova imagem com o nome de alpineteste, agora vamos comparar o tamanho dessa imagem com outras:

Alpine

Lembrando, que utilizamos a imagem base de cada distribuição e em cima dela instalamos o node e subimos essa aplicação, note que a diferença é exorbitante, isso por que a Alpine tem apenas o que é necessário para essa aplicação rodar, nada além disso.

Como podem ver, utilizando essa abordagem seu ambiente fica ainda mais escalável, e claro ainda mais portável, pois quanto menos a sua imagem, melhor é para transitar ela entre os hosts (não é necessário baixar megas e megas da imagem no primeiro deploy por exemplo) .

Gostou? nos ajude divulgando o Blog

Grande abraço!

Docker e DevOps

Olá pessoal!

Hoje vamos ao post um pouco mais voltado ao conceito e ideias que fazem do Docker uma tecnologia/solução tão inovadora, eficiente e claro popular.

Precisamos entender, antes de tudo, como a vida de um profissional pode ser, primeiro temos o mundo das empresas que adotam o método tradicional de trabalho, nessa empresa o horário é fixo, as decisões demoradas, e geralmente as ideias que você pode ter estão descritas em um manual interno.

Geralmente essas empresas demoram a reagir ao mercado, ou seja, algo novo demora a ser posto em prática, e as mudanças são vistas como um problema.

Temos outro mundo, a de empresas que vêem em mudanças um forma de ganhar espaço no mercado, onde ideias novas e desafios são um requisito para se trabalhar, você é instigado a ver as coisas de uma outra perspectiva, pois deve se manter sempre a frente do que vem em seguida.

Um os grandes entraves em ambas as empresas é a diferenciação que há entre as equipes de desenvolvimento e infra-estrutura, elas não se conversam, e o que uma propõe é um problema para a outra. Isso leva apenas a um lugar: Estagnação, pois não colaboração entre elas para criar ou resolver algo que seja vital para a empresa.

blue devops_4

Felizmente essa percepção está sendo mudada, em seu lugar surgiu um novo conceito de trabalho, que serve para ambas as empresas que mencionei acima, o conceito de DevOps. Mas o que ser isso cacique?

DevOps é uma metodologia, que incentiva uma maior integração entre as diferentes áreas da empresa, ou seja, em vez de cada um fazer uma coisa, as equipes tendem a se integrar em prol de uma objetivo comum, seja um projeto ou a resolução de um problema.

Para que isso seja possível, existem diversas ferramentas que auxiliam o desenvolvimento conjunto de projetos, desde base de conhecimento até orquestração de serviços. É nesse sentido em que o Docker auxilia, tanto o pessoal de Dev, quanto o pessoal de Ops. O Docker permite que o desenvolvedor tenha todo o seu ambiente de desenvolvimento e teste totalmente agnóstico da infraestrutura.  Da mesma forma que permite ao analista de infraestrutura realizar ou configurar o ambiente de produção de uma maneira muito mais segura e eficiente, pois basta replicar o ambiente de homologação (que já foi testado pelo desenvolvedor) no ambiente de produção, e isso sem se preocupar nas diferenças nos ambiente, pois é o mesmo ambiente.

Outro beneficio que o Docker proporciona é a agilidade no deploy das aplicações, pois não é necessário subir uma instância ou instalar um servidor todo apenas para testar algo, basta criar um container e subir sua aplicação.

Nos próximos posts nós iniciaremos alguns tutoriais que explicarão melhor como podemos integrar de forma mais eficiente o Docker a outras ferramentas, permitindo criar um ecossistema completo de desenvolvimento e integra continua, tendo em vista os benefícios tanta para Dev quanto Ops.

Montando Volumes no Docker

Olá!

Hoje, nós do mundodocker.com.br, vamos ver como podemos utilizar a funcionalidade de volumes no Docker. Um volume pode ser apenas o mapeamento de pasta entre o host e container, bem como o mapeamento de uma pasta entre containers.

Gerenciando volumes

Host – Container

Na imagem abaixo podemos visualizar como fica o mapeamento entre host e container:

host_containerPodemos analisar os pontos positivos e negativos dessa abordagem em:

Prós:

– Menor overhead para acesso disco, pois não há analise pela libcontainer das chamadas para esse volume mapeado;

– É possível mapear o mesmo volume para múltiplos containers, forma primitiva de replicação de dados entre containers (lembrando que neste caso não há controle de arquivos lidos e escritos ao mesmo tempo, quem deve ser responsável por isso é o filesystem do volume, não o volume em si);

– Persistência de dados, não há risco do container cair ou ser removido e os dados desaparecerem;

Contras:

– Sucessível possíveis brechas de segurança a nível de filesystem, escalonamento de privilégios, pois neste ambiente não há controle pela libcontainer.

– Não escalável, pois  atrela-se o container ao host ou pelo menos ao mapeamento.

– Dificulta administração, pois há mais uma camada de gerenciamento que deve ser muito bem estruturada.

Container – Container

Na imagem abaixo podemos visualizar como fica o mapeamento entre containers:

container_containerPodemos analisar os pontos positivos e negativos dessa abordagem em:

Prós:

– Portável, pois o volume não está mais atrelado ao host;

– É possível mapear o mesmo volume para múltiplos containers, forma primitiva de replicação de dados entre containers (lembrando que neste caso não há controle de arquivos lidos e escritos ao mesmo tempo, quem deve ser responsável por isso é o filesystem do volume, não o volume em si);

– Persistência de dados, não há risco do container cair ou ser removido e os dados desaparecerem;

Contras:

– Maior overhead para acesso disco, pois há analise pela libcontainer das chamadas para esse volume mapeado;

– Maior complexidade, pois há mais passos a serem seguidos para criação e remoção de containers;

Criando e montando volumes

Adicionando um volume de dados

Para mapear o volume do container a uma pasta no host basta executar o comando:

docker run -d --name meucontainer -v /var/app imagem

Será criado um novo diretório dentro do container chamado /var/app, caso o mesmo já exista, será sobrescrito por este novo.

Verificando volume

Você pode verificar quais volumes um container possui executando o comando:

docker inspect meucontainer

O resultado do comando será parecido com isso:

...
Mounts": [
    {
        "Name": "fac362...80535",
        "Source": "/var/lib/docker/volumes/fac362...80535/_data",
        "Destination": "/var/app",
        "Driver": "local",
        "Mode": "",
        "RW": true
    }
]
...

Por padrão todos os volumes são montandos como leitura e escrita, você pode montar o volume como apenas leitura, basta executar:

docker run -d --name meucontainer -v /var/app:ro imagem

Note o :ro no final do /var/app, isso quer dizer que este volume é apenas leitura.

Montando um diretório do host como um volume de dados

Para mapear o volume do container a uma pasta no host basta executar o comando:

docker run -d --name meucontainer -v /var/app:/var/www/html imagem

Será criado um novo diretório dentro do container chamado /var/app, caso o mesmo já exista, será sobrescrito por este novo.

Criando e montando um container como um volume de dados

É possível você criar um container com um volume que pode ser compartilhado com demais containers, isso é uma prática comum quando deseja-se ter alguma persistência de dados e que não esteja atrelado ao host onde o container está. Para isso, crie o container conforme abaixo:

docker create -v /dados --name meucontainer imagem /bin/true

Agora, no próximo container basta você utilizar o parametro –volumes-from para que o volume criado no container acima seja mapeado para o novo container, algo como isso:

docker run -d --volumes-from dados--name meucontainer1 imagem

Você pode criar quantos containers desejar mapeando este volume, inclusive pode mapear o volume de um container, por exemplo:

docker run -d --volumes-from container1 --name meucontainer2 imagem

Com isso não é necessário mapear obrigatoriamente o container de volume, e sim algum container que já utiliza ele. Outro ponto importante a se observar nessa caso é que:

  • Quando removido o container de volume os demais containers não perdem os dados, pois continuará existindo neste container a pasta montada;
  • Para remover o volume nesse caso é necessário remover todos os containers que foram criando mapeando este container e em seguida executar o comando: docker em -v

 

Bom pessoal, espero que tenham gostado, esse assunto é muito importante dentro do Docker, espero fazer um vídeo e disponibilizar para vocês um prática usando volumes.

Não fique com dúvida, mande e-mail para: [email protected] e vamos conversando, ajude a divulgar o blog e disseminar conhecimento, abraço!

Segurança do Docker Swarm

Olá gente!

Com a grande ajuda do wsilva, estamos trazendo um post que levanta um ponto bem interessante do ambiente de Docker Swarm : Como deixar meu cluster mais seguro?

Existem diferentes forma de se fazer isso, algumas nativas, e outras envolvendo ferramentas de terceiros, nesse post replicaremos o post do Dumps Cerebrais, que aborda uma das formas nativas de se garantir maior segurança no cluster de Swarm. Vamos lá!

O Auto Locking

é uma das grandes funcionalidades adicionadas na versão 1.13.0 do Docker e presente nas novas versões 1.13.1, 17.03.0-ce, 17.03.1-ce e 17.04.0-ce (versões disponíveis até a data de publicação desse artigo).

Você deve estar se perguntando: “Versões 1.12, 1.13 e agora 17.03.x-ce? Que zona é essa?” Na verdade não é zona, é reorganização, na versão 1.13 uma das novidades foi a reorganização dos comandos no CLI, agora a Docker está reorganizando os release e versões. Ela lançou um novo ciclo de releases, renomeou as versões baseando-se em datas (ano e mês) e separou a parte open source, Docker CE (community edition) da parte proprietária com licensa e com planos de suporte da própria Docker, o EE (enterprise edition). Resumindo reorganização. Mas essa é uma história que podemos detalhar em outro artigo, nosso foco aqui será mostrar o que é e como funciona o Auto Locking

A motivação por trás do Auto Locking

Tanto a comunicação entre os nós do Swarm quanto os logs do Raft consensus são por padrão encriptados por chaves TLS que ficam nos discos das máquinas managers. Tá, mas o que isso quer dizer?

Vamos imaginar que uma máquina manager reinicia, tanto a chave TLS usada para a encriptação da comunicação entre os nós, quanto a chave TLS usada para encriptar os logs do Raft são carregados na sua memória. Isso por um lado é bom pois permite que um nó seja reiniciado sem intervenção humana e sistema continua funcionando normalmente. Por outro lado se alguém conseguir essas chaves seja por um backup que vaze ou disco corrompido essa pessoa vai conseguir acesso aos logs do Raft e também às informações sensíveis como onde estão rodando os serviços, às configurações de acesso dos serviços e inclusive aos secrets dessas aplicações rodando nesse cluster.

Como funciona o Auto Locking.

O auto locking é uma camada de proteção a mais e é super simples. Quando você iniciar ou atualizar um cluster Swarm passando a flag --autolock uma chave é gerada para encriptar as demais chaves, porém essa nova chave é responsabilidade nossa e deve ser mantida por nós, devs e operadores. Seja via password manager, seja guardando de cabeça (o que duvido), seja anotando em papel de pão.

Com o auto lock ativo se por um acaso a máquina reiniciar ninguém conseguirá rodar comandos nela sem antes desbloqueá-la e para desbloquear aquela chave de nossa responsabilidade será solicitada.

Podemos iniciar um cluster já utilizando a funcionalidade de auto lock:

$ docker swarm init --autolock
Swarm initialized: current node (drr4hrzngqoh90cpp0t5lnuv1) is now a manager.

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

    docker swarm join 
    --token SWMTKN-1-1infi7fei781xasqoh1q1k5i7p47ocvyptaoq1r6dmmp1bwz0p-e37ividr81a45qzhq9ptkb836 
    192.168.65.2:2377

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

To unlock a swarm manager after it restarts, run the `docker swarm unlock`
command and provide the following key:

    SWMKEY-1-nly8Gmulj+xuPwFF4ks4evN6OxdUtVFdD1QlIhdVvto

Please remember to store this key in a password manager, since without it you
will not be able to restart the manager.

Ou adicionar a um cluster já em produção:

$ docker swarm update --autolock
Swarm updated.
To unlock a swarm manager after it restarts, run the `docker swarm unlock`
command and provide the following key:

    SWMKEY-1-av+McYBAyjy6o1RMYsDqUsS8lkjH05t5HMnP7USjk+4

Please remember to store this key in a password manager, since without it you
will not be able to restart the manager.

Podemos perceber o token gerado nos dois casos, ambos começam com SWMKEY, essa é a chave que devemos guardar, ela não é persistida no cluster.

Se a máquina manager não estiver travada você consegue recuperar essa chave com seguinte comando:

$ docker swarm unlock-key
To unlock a swarm manager after it restarts, run the `docker swarm unlock`
command and provide the following key:

    SWMKEY-1-av+McYBAyjy6o1RMYsDqUsS8lkjH05t5HMnP7USjk+4

Please remember to store this key in a password manager, since without it you
will not be able to restart the manager.

Se a máquina estiver travada qualquer comando administrativo não será executado e vai retornar a seguinte mensagem:

$ docker node ls
Error response from daemon: Swarm is encrypted and needs to be unlocked before it can be used. Please use "docker swarm unlock" to unlock it.

Para mudarmos a key que destrava o Swarm usamos o seguinte comando:

$ docker swarm unlock-key --rotate
Successfully rotated manager unlock key.

To unlock a swarm manager after it restarts, run the `docker swarm unlock`
command and provide the following key:

    SWMKEY-1-ECkuyhW8Zgc9nZthmkMpZd5f+mxPuOEC5K6CyA89xNk

Please remember to store this key in a password manager, since without it you
will not be able to restart the manager.

Para ficar mais claro, o wsilva ainda gravou um vídeo, esse mesmo foi utilizado no meetup de docker em SP (grupo do qual ele ajuda a organizar), confere:

Bem bacana né? Então não deixe de utilizar, como visto é bem simples a sua configuração, se quiser ter certeza antes de sair colocando em produção, usa o Play-With-Docker para montar seu lab e testar, é uma ferramenta free e bem simples de se usar, através dela você pode subir todo seu ambiente, validar e depois disso colocar a mão na massa em seu ambiente, há obviamente uma limitação, que é o tempo de uso, mas garanto que facilita horrores .

Então era isso, nos ajude divulgando o blog, e deixe suas dúvidas, elogios ou críticas nos comentários .

Grande abraço!

Migrando do Docker Swarm para o Kubernetes

Post incialmente públicado em: https://dumpscerebrais.com/2019/01/migrando-do-docker-swarm-para-o-kubernetes

Começamos 2019 e ficou bem claro que o Docker Swarm perdeu para o Kubernetes na guerra de orquestradores de contêineres.

Não vamos discutir aqui motivos, menos ainda se um é melhor que outro. Cada um tem um cenário ótimo para ser empregado como já disse em algumas das minhas palestras sobre o assunto. Mas de uma maneira geral se considerarmos o requisito evolução e compararmos as duas plataformas então digo que se for construir e manter um cluster de contêineres é melhor já começarmos esse cluster usando Kubernetes.

O real objetivo desse artigo é mostrar uma das possíveis abordagens para que nossas aplicações hoje rodando num cluster Docker Swarm, definidas e configuradas usando o arquivo docker-compose.yml possam ser entregues também em um cluster Kubernetes.

Intro

Já é meio comum a comparação entre ambos e posso até vir a escrever algo por aqui mas no momento vamos nos ater a um detalhe simples: cada orquestrador de contêineres cria recursos próprios para garantir uma aplicação rodando. E apesar de em alguns orquestradores recursos terem o mesmo nome, como o Services do Docker Swarm e o Services do Kubernetes eles geralmente fazem coisas diferente, vem de conceitos diferentes, são responsáveis por entidades diferentes e tem objetivos diferentes.

O Kompose, uma alternativa

O kompose é uma ferramenta que ajuda muito a converter arquivos que descrevem recursos do Docker em arquivos que descrevem recursos do Kubernetes e até dá para utilizar diretamente os arquivos do Docker Compose para gerir recursos no Kubernetes. Também tenho vontade de escrever sobre ele, talvez em breve, já que neste artigo vou focar em como ter recursos do Docker Swarm e do Kubernetes juntos.

Um pouco de história

Sempre gosto de passar o contexto para as pessoas entenderem como, quando e onde foram feitas as coisas, assim podemos compreender as decisões antes de pré-julgarmos.

Na Dockercon européia de 2017, a primeira sem o fundador Solomon Hykes, foi anunciado e demostrado como usar um arquivo docker-compose.yml para rodar aplicações tanto num cluster Docker Swarm quanto num cluster Kubernetes usando a diretiva Stacks.

A demostração tanto na Dockercon quanto no vídeo acima foram sensacionais. Ver que com o mesmo comando poderíamos criar recursos tanto no Docker Swarm quanto no Kubernetes foi um marco na época. O comando na época:

docker stack deploy --compose-file=docker-compose.yml stackname

Só tinha um problema, isso funcionava apenas em instalações do Docker Enterprise Edition ($$$) ou nas novas versões do Docker for Desktop que eram disponíveis apenas para OSX e Windows.

Aí você pergunta: Como ficaram os usuário de Linux nessa história, Wsilva?

Putos, eu diria.

Protecionismo?

Assim como outros também tentei fazer uma engenharia reversa e vi que o bootstrap desse Kubernetes rodando dentro do Docker for Mac e Windows era configurado usando o Kubeadm. Fucei, criei os arquivos para subir os recursos Kubernetes necessários e quase consegui fazer rodar mas ainda me faltava descobrir como executar o binário responsável por extender a api do Kubernetes com os parâmetros certos durante a configuração de um novo cluster, todas as vezes que rodei tive problemas diferentes.

Até postei um tweet a respeito marcando a Docker Inc mas a resposta que tive foi a que esperava: a Docker não tem planos para colocar suporte ao Compose no Linux, somente Docker for Desktop e Enterprise Edition.

Ainda bem antes de tentar fazer isso na mão, lá na Dockercon de 2018 (provavelmente também escreverei sobre ela) tive a oportunidade de ver algumas palestras sobre extender a API do Kubernetes, sobre como usaram Custom Resource Definition na época para fazer a mágica de interfacear o comando docker stack antes de mandar a carga para a API do Kubernetes ou para a API do Docker Swarm e também conversei com algumas pessoas no conference a respeito.

A desculpa na época para não termos isso no Docker CE no Linux era uma questão técnica, a implementação dependeria muito de como o Kubernetes foi instalado por isso que no Docker para Desktop e no Docker Enterprise, ambientes controlados, essa bruxaria era possível, mas nas diversas distribuíções combinadas com as diversas maneiras de criar um cluster Kubernetes seria impossível prever e fazer um bootstrap comum a todos.

Docker ainda pensando no Open Source?

Na Dockercon européia de 2018, praticamente um ano depois do lançamento do Kubernetes junto com o Swarm finalmente foi liberado como fazer a API do Compose funcionar em qualquer instalação de Kubernetes. Mesmo sem as instruções de uso ainda mas já com os fontes do instalador disponíveis (https://github.com/docker/compose-on-kubernetes) era possível ver que a estrutura tinha mudado de Custom Resource Definition para uma API agregada e relativamente fácil de rodar em qualquer cluster Kubernetes como veremos a seguir.

Mão na massa.

Para rodarmos essa API do Compose no Mac e no Windows, assim como no final de 2017, basta habilitar a opção Kubernetes na configuração conforme a figura e toda a mágica vai acontecer.

No Linux podemos trabalhar com o Docker Enterprise Edition ou com o Docker Community Edition.

Para funcinar com o Docker Community Edition primeiramente precisamos de um cluster pronto rodando kubernetes e podemos fazer teoricamente em qualquer tipo de cluster. Desde clusters criados para produção com Kops – (esse testei na AWS e funcionou), ou Kubespray, ou em clusteres locais como esse que criei para fins educativos: https://github.com/wsilva/kubernetes-vagrant/ (também funcionou), ou Minikube (também funcionou, está no final do post), ou até no saudoso play with kubernetes (também funcionou) criado pelo nosso amigo argentino Marcos Nils.

Para verificar se nosso cluster já não está rodando podemos checar os endpoints disponíveis filtrando pela palavra compose:

$ kubectl api-versions | grep compose

Pré requisitos

Para instalar a api do Compose em um cluster Kubernetes precisamos do etcd operator rodando e existem maneiras de instalar com e sem suporte a SSL. Mais informações podem ser obtidas nesse repositório.

Neste exemplo vamos utilizar o gerenciador de pacotes Helm para instalar o etcd operator.

Instalação

Primeiro criamos o namespace compose em nosso Kubernetes:

$ kubectl create namespace compose

Em seguida instalmos ou atualizamos o Helm.

Se estivermos utilizando OSX, podemos instalar de maneira simples com homebrew.

$ brew install kubernetes-helm
Updating Homebrew...
Error: kubernetes-helm 2.11.0 is already installed
To upgrade to 2.12.3, run `brew upgrade kubernetes-helm`
$ brew upgrade kubernetes-helm
Updating Homebrew...
==&gt; Upgrading 1 outdated package:
kubernetes-helm 2.11.0 -&gt; 2.12.3
==&gt; Upgrading kubernetes-helm
==&gt; Downloading https://homebrew.bintray.com/bottles/kubernetes-helm-2.12.3.moja
######################################################################## 100.0%
==&gt; Pouring kubernetes-helm-2.12.3.mojave.bottle.tar.gz
==&gt; Caveats
Bash completion has been installed to:
/usr/local/etc/bash_completion.d

zsh completions have been installed to:
/usr/local/share/zsh/site-functions
==&gt; Summary
?  /usr/local/Cellar/kubernetes-helm/2.12.3: 51 files, 79.5MB

No Linux podemos optar por gerenciadores de pacotes ou instalar manualmente baixando o pacote e colocando em algum diretório do PATH:

$ curl -sSL https://storage.googleapis.com/kubernetes-helm/helm-v2.12.1-linux-amd64.tar.gz -o helm-v2.12.1-linux-amd64.tar.gz

$ tar -zxvf helm-v2.12.1-linux-amd64.tar.gz
x linux-amd64/
x linux-amd64/tiller
x linux-amd64/helm
x linux-amd64/LICENSE
x linux-amd64/README.md

$ cp linux-amd64/tiller /usr/local/bin/tiller
$ cp linux-amd64/helm /usr/local/bin/helm

Estamos em 2019 então todos os clusters Kubernetes já deveriam estar rodando com RBAC (Role Base Access Control) por questões de segurança. Para isso devemos criar uma Service Account em nosso cluster para o tiller.

$ kubectl --namespace=kube-system create serviceaccount tiller
serviceaccount/tiller created

$ kubectl --namespace=kube-system 
    create clusterrolebinding tiller 
    --clusterrole=cluster-admin 
    --serviceaccount=kube-system:tiller 
clusterrolebinding.rbac.authorization.k8s.io/tiller created

Neste exemplo fizemos o bind para o role cluster admin, mas seria interessante criar uma role com permissões mais restritas definindo melhor o que o helm pode ou não fazer em nosso cluster Kubernetes.

Instalamos o etcd operator:

$ helm init --service-account tiller --upgrade
$ helm install --name etcd-operator 
    stable/etcd-operator 
    --namespace compose

Monitoramos até os pods responsáveis pelo etcd operator estarem de pé:

$ watch kubectl get pod --namespace compose

Com etcd operator de pé podemos matar o watch loop com ctrl+c.

Próximo passo vai ser subir um cluster etcd usando o operator:

$ cat &gt; compose-etcd.yaml &lt;&lt;EOF
apiVersion: &quot;etcd.database.coreos.com/v1beta2&quot;
kind: &quot;EtcdCluster&quot;
metadata:
name: &quot;compose-etcd&quot;
namespace: &quot;compose&quot;
spec:
size: 3
version: &quot;3.2.13&quot;
EOF

$ kubectl apply -f compose-etcd.yaml

Monitoramos novamente até os pods responsáveis pelo nosso etcd cluster estarem de pé:

$ watch kubectl get pod --namespace compose

Com etcd cluster rodando podemos matar o watch loop com ctrl+c.

Em seguida baixamos diretamente do GitHub e executamos o instalador da API do Compose.

Se estivermos utilizando OSX:

$ curl -sSLO https://github.com/docker/compose-on-kubernetes/releases/download/v0.4.18/installer-darwin
chmod +x installer-darwin
./installer-darwin 
    -namespace=compose 
    -etcd-servers=http://compose-etcd-client:2379 
    -tag=v0.4.18

No Linux:

$ curl -sSLO https://github.com/docker/compose-on-kubernetes/releases/download/v0.4.18/installer-linux
chmod +x installer-linux
./installer-linux 
    -namespace=compose 
    -etcd-servers=http://compose-etcd-client:2379 
    -tag=v0.4.18

Vamos checar se os pods estão rodando novamente com watch loop:

watch kubectl get pod --namespace compose 

Após todos os pods rodando usamos o ctrl+c para parar o watch loop e em seguida podemos verificar se agora temos os endpoints do compose:

$ kubectl api-versions | grep compose
compose.docker.com/v1beta1
compose.docker.com/v1beta2

Sucesso. Agora vamos baixar um arquivo docker compose de exemplo do repositório da própria Docker:

curl -sSLO https://github.com/docker/compose-on-kubernetes/blob/master/samples/docker-compose.yml

Para ver o conteudo do arquivo podemos usar um editor de texto ou o simples cat docker-compose.yml no terminal mesmo.

Agora vamos usar o docker para criar os recursos no kubernetes, como se estivessemos fazendo um deployment em um cluster de Docker Swarm mesmo:

$ docker stack deploy 
    --orchestrator=kubernetes 
    --compose-file docker-compose.yml 
    minha-stack

Podemos usar tando o kubectl como o docker cli para checar os status:

$ kubectl get stacks  
NAME        SERVICES  PORTS    STATUS                        CREATED AT
demo-stack  3         web: 80  Available (Stack is started)  2019-01-28T20:47:38Z

$ docker stack ls 
    --orchestrator=kubernetes
NAME           SERVICES      ORCHESTRATOR      NAMESPACE
demo-stack     3             Kubernetes        default

Podemos pegar o ip da máquina virtual rodando minikube com o comando minikube ip e a porta do serviço web-published e acessar no nosso navegador.

No próprio repositório temos uma matriz de compatibilidade entre as funcionalidades no Docker Swarm e funcionalidades no Kubernetes: https://github.com/docker/compose-on-kubernetes/blob/master/docs/compatibility.md

Conclusão

Se você está pensando em migrar seus workloads de clusters de Docker Swarm para clusters de Kubernetes você pode optar tanto pelo Kompose quanto pelo Docker Compose no Kubernetes.

Optando pelo Compose no Kubernetes podemos usar o Docker for Mac ou Docker for Windows, basta habilitar nas configurações a opção de cluster Kubernetes.

Se estiver no Linux pode optar por seguir os passos acima ou pagar pelo Docker Enterprise Edition.

Veja como cada uma dessas opções se adequa melhor aos seus processos e divirta-se.

Até a próxima.

Kubernetes e Docker

Olá pessoal,

Hoje vamos iniciar uma série de posts demonstrado como podemos utilizar o Kubernetes como ferramenta de automatização, distribuição de carga, monitoramento e orquestração entre containers.

Kubernetes é um sistema de código aberto que foi desenvolvido pelo Google para gerenciamento de aplicativos em containers através de múltiplos hosts de um cluster. Tem como principal objetivo facilitar a implantação de aplicativos baseados em microservices. Ele foi baseado na experiência do Google de muitos anos trabalho com containers, adaptando o  para se trabalhar com Docker.

O Kubernetes foi muito útil para ser utilizado até o Docker Swarm 1.0, pois disponibilizava muitos recursos que o Docker não disponibilizava até aquele momento, entre eles: Balanceamento de carga e movimento de containers sem perda de dados.

A principal vantagem que se tem ao utilizar o Kubernetes é que você não está preso as limitações da API do Docker (O Problema do Swarm) você tem total liberdade já que o Kubernetes não foi desenvolvido especialmente para o Docker, você pode trocar a sua estrutura de Docker para Rockets (Containers no CoreOS). Você pode escolher a simplicidade do Swarm ou o poder do Kubernetes.

Dentro do Kubernetes possuímos alguns termos para determinadas funções:

Minions: É o nome dado para cada host do cluster.

Kubelet: Agente que roda nos hosts do cluster.

Pods: É a menor unidade dentro de um cluster, nada mais é do que containers rodando dentro de seu cluster de Kubernetes. Pode ser um container rodando nginx, php, apache, etc…

Replication Controller: É o responsável por manter um número determinado de pods em execução. No RC é onde você diz quantos containers de nginx, php, apache você desejá que fiquem rodando, caso um caia, o RC cria outra instância automaticamente.

Services: É o responsável por atrelar uma faixa de IP para um determinado RC. Para que cada vez que o RC crie uma nova instância de pod o mesmo inicie com um IP determinado pelo service.

Namespace: Com o namespace você pode dividir seu Cluster de Kubernetes em dois ambientes, Produção e Teste, podendo limitar os recursos computacionais para ambos.

No proximo post vamos mostrar como podemos instalar e configurar o kubernetes para que você use em seu ambiente da melhor maneira possível.

Docker Swarm

Oi Pessoal,

Hoje queremos trazer para vocês mais uma das ferramentas que o Docker disponibiliza em seu ecossistema, chegou a hora de conhecermos o Docker Swarm. O Docker Swarm é uma ferramenta nativa do Docker que permite a criação de clusters de Docker, ou seja, podemos fazer com que diversos hosts de Docker estejam dentro do mesmo pool de recursos, facilitando assim o deploy de containers. É possível por exemplo criar um container sem necessariamente saber em qual host ele está, pois o Swarm disponibilidade uma API de integração, onde é possível realizar grande parte das atividades administrativas de um container. Quer ver na prática?

Requisitos:

  • Estar com a versão 1.6+ do Docker
  • Abrir a API do Docker para o Swarm Manager

 

Mãos a obra:

1 – Baixando a imagem oficial:

$ docker pull swarm

2 – Criando o cluster:

$ docker run --rm swarm create 
4765653423fdecsdfe875954a6e2h78ed # 

 

O retorno desse comando será o ID do Cluster, armazena essa informação pois será importante nas próximas etapas.

3 – Adicionando nós ao cluster:

$ docker run -d swarm join --addr=<node_ip:2375> token://4765653423fdecsdfe875954a6e2h78ed

4 – Configurando o Manager:

$ docker run -d -p <porta_manager>:2375 swarm manage token://4765653423fdecsdfe875954a6e2h78ed

Lembrando que <porta_manager> será a porta que você utilizará para se comunicar com o Swarm Manager, responsável pela administração do cluster, a arquitetura ficará da forma como a imagem abaixo:

5 – Verificando o Cluster:

$ docker -H tcp://ip:porta_manager> info

O retorno será algo parecido com isso:

Containers: 0 
Nodes: 3 
agent-2: 172.31.0.1:2375 
  └ Containers: 0 
  └ Reserved CPUs: 0 / 1 
  └ Reserved Memory: 0 B / 514.5 MiB 
agent-1: 172.31.0.2:2375 
  └ Containers: 0 
  └ Reserved CPUs: 0 / 1
  └ Reserved Memory: 0 B / 514.5 MiB 
agent-0: 172.31.0.3:2375 
  └ Containers: 0 
  └ Reserved CPUs: 0 / 1 
  └ Reserved Memory: 0 B / 514.5 MiB

Você pode enfrentar alguma dificuldade relacionada a TLS, principalmente se estiver apenas testando, para resolver isso basta executar: unset DOCKER_TLS_VERIFY, com isso não será verificado se os hosts possuem acesso via TLS ativado.

Para administrar seu cluster (criar containers, etc) basta utilizar o IP e Porta do Swarm Manage, dessa forma:

$ docker -H tcp://<manager_ip:manager_port> info 
$ docker -H tcp://<manager_ip:manager_port> run ... 
$ docker -H tcp://<manager_ip:manager_port> ps 

Para listar os nós que fazem parte do cluster, bata utilizar o comando abaixo:

$ docker run --rm swarm list token://4765653423fdecsdfe875954a6e2h78ed
172.31.0.1:2375 
172.31.0.2:2375 
172.31.0.3:2375

 

É claro que isso é apenas o início, tendo o cluster montado é possível criar filtros de identificação por tipo de serviço, isso é muito útil para criar containers com o mesmo tipo de serviço em um mesmo local sem a necessidade de saber onde. Mas isso é história para um próximo post

Fique atento as novidades do Blog, e ajude divulgando o mundodocker.com.br.

Abraço!