quarta-feira, 4 de janeiro de 2017



Depois de algum tempo, cá estou para retomar a cobertura do meu repositório Cinto de Utilidades Docker, que está com o ritmo de crescimento muito maior do que os das postagens (rs). Hoje vamos abordar duas das maiores duvidas de quem começa a utilizar containers em ambiente de Dev e Prod: Primeiro: Como persistir dados dos bancos de dados que rodam em containers e  Segundo: como criar meu banco de dados sempre que eu instalar meu ambiente.

Confira os arquivos do ambiente

Estrutura de diretórios

Neste projeto iremos utilizar dois níveis de diretórios.
No primeiro vamos ter nosso docker-compose e no segundo nível, na pasta /Dumper teremos todas as dependências do nosso restore do MySQL, incluindo nossa Dockerfile e nosso arquivo SQL.

  ~/W/CintoDeUtilidadesDocker   master  MySQL-MySQLRestore  tree .     qua 04 jan 2017 08:13:26 BRST  
 .  
 ├── docker-compose.yml  
 └── Dumper  
   ├── Dockerfile  
   └── dump.sql  
   
 1 directory, 3 files  
   



docker-compose.yml

Nosso arquivo docker-compose.yml vai ter somente dois serviços. 
O primeiro é uma imagem oficial do MySQL na versão 5.7. Vamos expor a porta 3306 e setar a senha do root na variável MYSQL_ROOT_PASSWORD. Para garantir persistência nos dados, vamos fazer com que o Docker crie uma pasta ./data dentro do diretório do projeto e mapeie para dentro da pasta /var/lib/mysql, a pasta onde o MySQL guarda todos os dados e metadados dos bancos e tabelas. Assim sempre que ele realizar alguma modificação, isso será mapeado para fora, e quando ligarmos outra instância, ele vai mapear o mesmo volume para dentro com as mesmas configurações e dados da anterior. Com isso garantimos uma persistência no MySQL. 

Em segundo, vamos ter um container temporário chamado dump. 
Vamos setar a pasta de build para a pasta Dumper/ e mapear a mesma para dentro da pasta /var/db do container. Essa pasta vai servir para armazenar o arquivo SQL que vamos restaurar na base. 

Na opção command, vamos criar um mini bashscript. Vamos dar um tempinho com o sleep para garantir que toda a inicialização do MySQL foi completada e em seguida restaurar o banco na base. 

 version: "2" 
 services:  
  mysql:  
   image: mysql:5.7  
   restart: never  
   ports:  
    - "3306:3306"  
   environment:  
    - MYSQL_ROOT_PASSWORD=root  
    - MYSQL_DATABASE=mydatabase  
   volumes:  
    - ./data/db:/var/lib/mysql  
   
  dump:  
   build: Dumper/  
   volumes:  
    - ./Dumper/:/var/db/  
   command: sh -c "sleep 20 && /usr/bin/mysql -h mysql -uroot -proot < /var/db/dump.sql"  
   depends_on:  
    - mysql  
   


Dumper/Dockerfile

Nosso Dockerfile será ridiculamente simples. Iremos utilizar a versão mais nova do Alpine Linux e em seguida instalar o MySQL-Client. Ele vai realizar uma unica ação e morrer, então não adianta enfeitar muito o ciclo de vida do mesmo. 

 FROM alpine:latest  
 RUN apk add --no-cache mysql-client  

Dumper/dump.sql

O Arquivo dump.sql irá conter todo o conteúdo do seu banco de dados. Aqui fica por sua conta, porém é altamente recomendável você usar as validações IF NOT EXISTS e IF EXISTS em todos os lugares para garantir erros na hora do restore. 
  
 CREATE DATABASE IF NOT EXISTS mydatabase;  
 USE mydatabase;  
   
 CREATE TABLE IF NOT EXISTS mytable (  
  id INT(11) PRIMARY KEY AUTO_INCREMENT,  
  descricao VARCHAR(50)  
 );  
   


Subindo o Container

Vamos inicializar o composer e ver a mágica acontecer. Ele vai iniciar o MySQL, subir nosso dumper que irá restaurar os dados e morrer. Logo após o termino desse processo teremos nosso bando de dados restaurado no MySQL.
 docker-compose up   



:)


Docker :: Restaurando Dumps em Containers MySQL Persistentes.

domingo, 20 de novembro de 2016



Esse post vai ser mais um exemplar explicativo do meu repositório Cinto de Utilidades Docker. Basicamente vamos utilizar o Docker para construir um ambiente de uma API REST utilizando NodeJS e MongoDB, com exemplos práticos de praticamente tudo que você precisa para construir um ambiente completo para seu Backend em Node e Mongo. Basicamente nosso diretório irá conter uma pasta app, onde iremos deixar o código da nossa API, uma Dockerfile para o container do Node e um docker-compose.yml que vai orquestrar nossa aplicação. Basicamente, a estrutura de diretório é esta:



Link dos Exemplos no Github

Node 

Vamos containerizar uma API completa. Nesta caso, no diretório do projeto, vamos criar a pasta app, dentro dela devem existir dois arquivos, um package.json que irá guardar todos os componentes que iremos utilizar na nossa aplicação e o arquivo app.js, que irá conter todo o código da nossa aplicação necessariamente.

./app/app.js

Este é o Código da API que vamos trabalhar com o Docker. Pode parecer grande demais para um exemplo, mas é uma forma de mostrar o funcionamento de ponta a ponta de um código no Docker. 
Basicmente é uma API Rest bem simples com um schema de tasklist já definido que vai gerenciar as informações do MongoDB. Usei essa API na POC do meu TCC na FATEC Itu. Pode ver aqui.

./app/package.json


Aqui iremos satisfazer todas as dependências do nosso projeto. Sem segredo por aqui.


Docker 

Dockerfile 

Veremos a Dockerfile, neste exemplo estaremos baixando uma máquina já preparada com o Node direto do Dockerhub. Pegaremos a versão Latest, que atualmente faz referência a versão 7.1 do Node, copiaremos o arquivo package.json do nosso projeto e irá instalar todas as dependências do mesmo globalmente, e vamos expor a porta 8080 para construção da nossa API e a porta 5858 para debug.
 FROM node:latest  
   
 RUN mkdir -p /usr/src/app  
 RUN npm install nodemon -g  
   
 WORKDIR /usr/src/app  
 COPY app/package.json /usr/src/app/package.json  
 RUN npm install -g  
   
 EXPOSE 8080  
 EXPOSE 5858  
   
 CMD ["npm", "start"]  


Docker Compose

Usaremos o arquivo docker-compose.yml para baixar a versão 3.0 do Mongo, e liberar a porta 27017 do mesmo para a nossa máquina. Em seguida vamos criar/mapear o diretório data, que se não existir será criada no diretório do projeto para pasta /data/db de dentro do container. Essa pasta irá gravar o conteúdo das collections do Mongo, e mapeando para um diretório externo, irá garantir a persistência dos dados do mesmo.
Em seguida iremos buildar nosso Dockerfile, mandando nosso local de build para a pasta local(.), customizando o comando de execução do container para satisfazer as dependências do projeto com o npm install e executar o nodeamon no nosso arquivo servidor do Node.
A pasta que vai ser mapeada para dentro do container é pasta app, que contém todo o nosso projeto do Node. Por ultimo, linkamos o serviço da nossa aplicação para se comunicar com o container do Mongo.
 mongo:  
  image: mongo:3.0.4  
  ports:  
   - "27017:27017"  
  volumes:  
   - './data:/data/db'  
 application:  
  build: .  
  command: bash -c "npm install; nodemon app.js --color=always"  
  ports:  
   - "8080:8080"  
   - "5858:5858"  
  volumes:  
   - ./app:/usr/src/app  
  links:  
   - mongo  

Testando 

Para buildar nosso projeto, iremos utilizar o Docker Compose como de costume. 
 # docker-compose build   
 # docker-compose up  

Agora com ajuda do Postman, ou qualquer cliente REST, podemos fazer requisições para todos os Endpoints da API, pra ver funcionando. Por exemplo, uma requisição POST para o endpoit /api/add com o conteúdo decricacao e concluido por POST, Ou pegar todos registros por GET via /api/all. Exemplificando, o comportamento é esse, mas você pode explorar todos os métodos da API pra ver que funciona. ;)


 Espero ter ajudado ;)


Docker :: Containerizando o NodeJS e o MongoDB de forma rápida

terça-feira, 15 de novembro de 2016


Criando um container para execução de Crontabs 

Neste exemplo vou estar passando um cookbook de como criar um Container Docker responsável por executar crontabs específicas no Linux. Esta é um exemplo bem cru, você deve customizar os arquivos de exemplo e configuração com as dependências e comandos para atender a sua necessidade. Estaremos utilizando um container base rodando Ubuntu 16.04, mas as crontabs são universais pra praticamente todo sistema Linux, então você pode selecionar qual distribuição preferir ajustando os parâmetros para mesma. 

Você deverá criar uma estrutura de diretórios similar a abaixo, onde deve existir uma pasta chamada "crontabs" que vai ser mapeada como um volume para dentro da pasta de configurações do Cron. Nesta pasta iremos guardar os arquivos texto que vão ter as crontabs escritas. Mapeie mais volumes para adicionar seus scripts a vontade, para o exemplo estarei adicionado uma pasta "scripts".

Esse exemplo pode ser adaptado para montar servidores de cron, que requisita URL's, realiza backups, consome ou atualiza API's e etc. Existem N possibilidades. 



Dockerfile 

Para subir o container, irei utilizar o Ubuntu 16.04. Mas como foi dito, customize como preferir :D.

 FROM ubuntu:16.04
 MAINTAINER 

 RUN touch /var/log/cron.log

 RUN apt-get update \
     && apt-get -y install cron

 CMD ["cron && tail -f /var/log/cron.log"]

docker-compose.yml

Agora vamos orquestrar nosso container da melhor forma possível. De forma com que ele sempre inicie junto com o sistema. Vamos buildar nosso projeto utilizando o docker-compose. 
 version: '2'
services:
  crontab:
    build: .
    volumes:
      - ./crontabs:/etc/cron.d
      - ./scripts:/var/scripts

Crie um pasta chamada crontabs dentro da pasta do projeto. E dentro crie um arquivo qualquer. Esse arquivo será utilizado para fazer o apontamento das crontabs.

crontab/crontabs

A crontab de exemplo é essa abaixo. Basicamente roda dois crons a cada minuto. Uma crontab direta e um script de exemplo. 
 * * * * * root echo "Exemplo de Comando" >> /var/log/cron.log 2>&1  
 * * * * * root chmod +x /var/scripts -R ; /var/scripts/exemplo.sh >> /var/log/cron.log 2>&1  

scripts/exemplo.sh 

 #!/bin/bash  
 uptime;  
 echo "Exemplo de Script"  


Rodando o Container 

Dentro da pasta do projeto, vamos iniciar o docker-compose build e em seguida um up para iniciar o processo dos containers.
 # docker-compose build   

Em seguida, vamos subir o projeto com o up. Utilize a opção -d para rodar em segundo plano:
 # docker-compose up 


Liberei todos os arquivos de configuração neste link do Git. Estou fazendo um repositório com os meus ambientes lá.

Vou começar a postar algum material sobre Docker. Assunto bastante presente nos meus dias de DevOps e inclusive do meu TCC. Espero ter ajudado :)

Links de ajuda: 




Docker :: Criando um Container para Execução de Crontabs

terça-feira, 8 de novembro de 2016



A Fish Shell é uma shell para sistemas Unix Like como MacOS e Linux focada em produtividade de navegação. Ela é ideal para quem não se contenta só em customizar o Vim e quer prolongar a experiência de desenvolvimento de administração de servidores para além do bash padrão.  Ela é compatível com o git, e alguns temas podem dar informações a nível visual para o desenvolvedor e administrador sobre o repositório, sucesso de comandos e a fantástica inteligência de autocomplete do sistema e de acordo com o uso do usuário. Eu estou usando nos meus computadores pessoais e no trabalho e estou bem satisfeito com o Fish e o Oh My Fish.

Site do projeto: https://fishshell.com/


Instalando o Fish Shell

O Fish está disponível em praticamente todos os repositórios da maioria das distribuições Linux. Você pode encontrá-lo a partir do Zypper, Yum, Apt e até mesmo do Pacman. 

 DEBIAN LIKE   
 # sudo apt-get update   
 # sudo apt-get install fish   
   
 CENTOS / RHEL   
 # cd /etc/yum.repos.d/  
 # wget http://download.opensuse.org/repositories/shells:fish:release:2/CentOS_7/shells:fish:release:2.repo  
 # yum install fish  

Utilizando o Fish como Shell principal do usuário:
 $ chsh -s /usr/bin/fish  # Define como shell padrão do usuário da sessão 
 $ sudo chsh -s /usr/bin/fish root # Redefine a shell do root   

Atualizando os auto-completes do Fish
 # fish_update_completions  


Oh My Fish 

O Oh My Fish, ou omf, é um gerenciador de pacotes minimalista para ao Fish Shell. Com ele é possível instalar plugins e temas para o fish. Alguns temas são focados em desenvolvimento, onde dão informações visuais do status do git do projeto que você está trabalhando, como branch, se há modificações e etc.

Confira o Git do projeto: https://github.com/oh-my-fish/oh-my-fish

Lista completa de temas para o Oh My Fish: https://github.com/oh-my-fish/oh-my-fish/blob/master/docs/Themes.md

O Oh My Fish necessita de algumas fontes para funcionar 100%, uma vez que ele utiliza icones dentro do terminal (sim). Eles utilizam um projeto de fontes Open Source chamado Power Line. Vamos instalar as fontes diretamente do git do projeto:
 # git clone https://github.com/powerline/fonts.git
 # cd fonts/   
 # ./install.sh  

Para instalar o Oh My Fish é simples também:
 # curl -L http://get.oh-my.fish | fish  

Alguns comandos do Oh My Fish:
 # omf install [<name>|<url>] // Instalando um plugin  
 # omf list // Lista os pacotes instalados   
 # omf theme // Lista os temas intalados   
 # omf theme [<name>] // Muda para o tema informado   
 # omf remove [<name>] // Remove um pacote  


Instalando um tema simples:
 # omf install flash  

Espero ter ajudado :)






Fish Shell & Oh My Fish :: Uma Shell Focada em Produtividade de Desenvolvimento

segunda-feira, 7 de novembro de 2016


Post rapidão. Essa postagem é pra servir como material de apoio pro pessoal que vai na minha apresentação de Docker na Superlogica. Como é continuação, e nem todo mundo foi no primeiro, segue um cookbook pro pessoal que perdeu já ter as ferramentas instaladas lá no dia.

Pra quem quiser se situar, tem uma apresentação que eu fiz no GDG Cabreúva sobre introdução ao Docker. Quem quiser ter uma base, ta aí!

Instalando o Docker 

Instalação Universal - Linux (Ubuntu/Debian/Red Hat/CentOS)
 # sudo curl -sSL https://get.docker.com | sh   

Instalação via APT (Ubuntu/Debian)
 # sudo apt-get install docker docker.io  

Iniciando o Serviço 
 # service docker start   #Ou...
 # /etc/init.d/docker start  

Instalação para MacOS 
Siga os passos descritos na documentação do Docker for Mac. Será baixado um instalador, e depois é só acionar a 'baleinha' que a Engine do Docker já vai iniciar. Depois é só utilizar via terminal normalmente.
Linkhttps://docs.docker.com/docker-for-mac/

Instalação para Windows
Siga os passos descritos na documentação também. Se não funcionar, problema seu. Ninguém mandou você usar Windows mesmo...
Linkhttps://docs.docker.com/docker-for-windows/


Instalando o Docker Compose

Instalação para Linux e MacOS
 # curl -L "https://github.com/docker/compose/releases/download/1.8.1/docker-compose-$(uname -s)-$(uname -m)" > /usr/local/bin/docker-compose  
 # chmod +x /usr/local/bin/docker-compose  


Instalação para Windows:

Mesmo principio do Docker:
Link: https://docs.docker.com/engine/installation/windows/

Fazendo nosso Hello World

Agora com tudo instalado, basta iniciar os serviços e baixar um container para testar.

 # docker run ubuntu /bin/echo 'Hello world manolos!!!'  


Espero ter ajudado! 

Instalação do Docker e suas Ferramentas

quinta-feira, 27 de outubro de 2016


O Mod_Evasive é um módulo do Apache que nos facilita trabalhar com proteções contra DoS e DDoS e ataques de força bruta em requisições HTTP para o Apache.

Ele cria tabelas no firewall com os IP's requisitantes e as URI's que o mesmo estão tentando floodar, e se ele cair em alguma regra, ele ficará banido por x segundos até que possa fazer requisições novamente para o servidor.

Ele é um modulo que pode ser usado com o Modsecurity para melhor a segurança do seu web server. Aqui você pode conhecer um pouco mais sobre o ModSecurity.


Instalando o Mod_Evasive

O modulo é um pacote simples que pode ser instalado via APT
 # sudo apt-get update ; sudo apt-get install libapache2-mod-evasive  

Agora vamos verificar se deu tudo certinho:
 root@servidor:~# sudo apachectl -M | grep evasive  
  evasive20_module (shared)  
 root@servidor:~#   


Agora vamos editar o arquivo de configurações do Mod_Evasive para definir alguns parâmetros de comportamento do módulo
 # vim /etc/apache2/mods-enabled/evasive.conf  
 <IfModule mod_evasive20.c>  
   DOSHashTableSize  3097  
   DOSPageCount    5  
   DOSSiteCount    50  
   DOSPageInterval   1  
   DOSSiteInterval   1  
   DOSBlockingPeriod  30  
   
   DOSEmailNotify   teste@admin.com  
   DOSLogDir      "/var/log/apache2/"  
   #DOSSystemCommand  "su - someuser -c '/sbin/... %s ...'"  
 </IfModule>  
   

  • DOSPageCount : Contador de requisições de uma só página 
  • DOSSiteCount: Contador de requisições feitas para todo o site
  • DOSPageInterval: Intervalo aceitável entre as requisições feitas em páginas específicas 
  • DOSSiteInterval:  Intervalo aceitável entre as requisições feitas em todo o site 
  • DOSBlockingPeriod: Período de bloqueio do IP em segundos
Agora vamos reiniciar o apache com as novas configurações e testar nossa configuração com o arquivo de negação de serviço nativo do próprio Mod_Evasive
 # service apache2 restart  

Esse arquivo escrito em perl, faz requisições HTTP para o localhost. Caso esteja utilizando cache ou load balance, o correto seria apontar para o IP dele, ou qualquer coisa utilize o Hydra.
 sudo perl /usr/share/doc/libapache2-mod-evasive/examples/test.pl  


:)



Apache Mod_Evasive :: Uma camada de proteção contra Ataques DoS e DDoS

 
Nanoshots | Open Source Security, Linux e Tutoriais © 2015 - Designed by Templateism.com