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

quarta-feira, 12 de outubro de 2016


O Sendmail é o serviço nativo de envio e recebimento de mensagens de e-mail presente na maioria das distribuições Linux, pelo simples motivo de performance, simplicidade e a capacidade de envio de e-mails internos via Localhost e externos via servidores SMTP locais ou remotos. Nesse exemplo eu estarei utilizando o serviço de SMTP do Gmail para fazer com que o servidor Linux envie e-mails do sistema a partir dele. Muito legal pra quem trabalha com algumas aplicações de notificação como IDS, Firewalls e etc.

Instalando as dependências
 # apt-get install sendmail mailutils sendmail-bin   

Cria a pasta onde vamos deixar nossas configurações de autenticação do Gmail
 # mkdir -m 700 /etc/mail/authinfo/  
 # cd /etc/mail/authinfo/  

Crie o arquivo gmail-auth dentro da pasta e cole o conteúdo com as informações que serão usadas para a conexão com o servidor SMTP do Gmail.
 # vim /etc/mail/authinfo/gmail-auth  
 AuthInfo: "U:root" "I:SEU E-MAIL DO GMAIL" "P:SUA SENHA"  

Após criar o novo arquivo, rode o makemap para gerar o banco de dados do arquivo de autenticação,
 # makemap hash gmail-auth < gmail-auth  

Agora edite o seu sendmail.mc e sobre o primeiro MAILER() cole o conteúdo
 # vim /etc/mail/sendmail.mc  
 define(`SMART_HOST',`[smtp.gmail.com]')dnl  
 define(`RELAY_MAILER_ARGS', `TCP $h 587')dnl  
 define(`ESMTP_MAILER_ARGS', `TCP $h 587')dnl  
 define(`confAUTH_OPTIONS', `A p')dnl  
 TRUST_AUTH_MECH(`EXTERNAL DIGEST-MD5 CRAM-MD5 LOGIN PLAIN')dnl  
 define(`confAUTH_MECHANISMS', `EXTERNAL GSSAPI DIGEST-MD5 CRAM-MD5 LOGIN PLAIN')dnl  
 FEATURE(`authinfo',`hash -o /etc/mail/authinfo/gmail-auth.db')dnl  


Agora de um rebuild nas configurações do Sendmail e recarregue o serviço
 # make -C /etc/mail  
 # /etc/init.d/sendmail reload  
Faça o teste de envio de mensagens via servidor
 # echo "Email de teste" | mail -s 'Testandoa aqui" lala@meudominio.com  

Espero ter ajudado :D

Sendmail :: Vinculando o Serviço de E-mail do Linux ao Gmail

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