OpenLDAP é um software open source que implementa o protocolo LDAP (Lightweight Directory Access Protocol) e está disponível nos repositórios das principais distribuições Linux e BSD.
Seu uso mais comum é para autenticação de usuários em casos onde a informação precisa estar disponível em várias plataformas, aplicações de diferentes fornecedores necessitam de tais informações e os registros armazenados sofrem poucas alterações.

Vários softwares suportam o protocolo LDAP, tais como Apache, Subversion, Squid e é claro sistemas operacionais como Linux e Windows (Active Directory).
O objetivo aqui é mostrar o básico para configurar um servidor LDAP de forma rápida e simples no CentOS mas a idéia pode ser aproveitada em outras distros como Ubuntu ou Fedora.

Instalação e Configuração

Instale os pacotes necessários:

# yum install openldap-servers openldap-clients

Copie o modelo slapd.conf para /etc/openldap e altere:

# cp /usr/share/openldap-servers/slapd.conf.obsolete /etc/openldap/slapd.conf
# vim /etc/openldap/slapd.conf
 
include          /etc/openldap/schema/core.schema
include          /etc/openldap/schema/inetorgperson.schema
include          /etc/openldap/schema/openldap.schema
 
allow bind_v2
 
pidfile           /var/run/openldap/slapd.pid
argsfile           /var/run/openldap/slapd.args
 
database config
access to *
               by dn.exact="gidNumber=0+uidNumber=0,cn=peercred,cn=external,cn=auth" manage
               by * none
 
database monitor
access to *
               by dn.exact="gidNumber=0+uidNumber=0,cn=peercred,cn=external,cn=auth" read
               by dn.exact="cn=admin,dc=dominio,dc=com,dc=br" read
               by * none
 
database      bdb
suffix             "dc=dominio,dc=com,dc=br"
checkpoint   1024 15
rootdn          "cn=admin,dc=dominio,dc=com,dc=br"
rootpw          senha
 
directory        /var/lib/ldap
 
index objectClass                                    eq,pres
index ou,cn,mail,surname,givenname   eq,sub

rootdn tem permissão para adicionar ou remover qualquer informação na árvore de diretórios. rootpw pode conter a senha em plain text ou criptografada. Por medidas de segurança é aconselhável adicionar o hash gerado pelo comando slappasswd:

# slappasswd -s senha
{SSHA}m/SnFEf/S+S5jGjCof1Ltesi9noPBiXf

Apague a configuração padrão removendo tudo que está dentro do diretório /etc/openldap/slapd.d:

# rm -rf /etc/openldap/slapd.d/*

Copie o arquivo /usr/share/openldap-servers/DB_CONFIG.example para /var/lib/ldap/DB_CONFIG:

# cp /usr/share/openldap-servers/DB_CONFIG.example /var/lib/ldap/DB_CONFIG

Execute o slapdtest para converter as configurações do arquivo slapd.conf (formato antigo) no formato mais recente onde as configurações ficam armazenadas no diretório slapd.d:

# slaptest -f /etc/openldap/slapd.conf -F /etc/openldap/slapd.d

Atribua as permissões dos arquivos de configuração ao usuário e grupo ldap:

# chown ldap.ldap -Rf /etc/openldap/slapd.d/*
# chown ldap.ldap -Rf /var/lib/ldap/*

Para finalizar, inicie o servidor OpenLDAP:

# service slapd start
Starting slapd:                                                        [  OK  ]

Agora o servidor OpenLDAP está configurado e funcionando escutando na porta padrão 389. Com isso é possível usar o rootdn e rootpw para criar e gerenciar a árvore de diretórios LDAP.

Criando diretórios

LDAP utiliza o padrão LDIF para gerenciamento de registros. LDIF é um formato de troca de dados em plain text para representar o conteúdo de diretório e requisições de atualização, transportando conteúdo de diretório como um conjunto de registros.
Crie um arquivo chamado primeiroregistro.ldif como abaixo:

# vim /etc/openldap/primeiroregistro.ldif
dn: dc=dominio,dc=com,dc=br
dc: dominio
objectClass: top
objectClass: domain
 
dn: cn=desenvolvedores,dc=dominio,dc=com,dc=br
objectClass: top
objectclass: groupOfNames
cn: desenvolvedores
member: cn=gustavo,cn=desenvolvedores,dc=dominio,dc=com,dc=br
 
dn: cn=gustavo,cn=desenvolvedores,dc=dominio,dc=com,dc=br
objectclass: top
objectclass: inetOrgPerson
cn: gustavo
sn: Gustavo
uid: 10
userpassword: senha

Agora execute o ldapadd para adicionar as entradas do arquivo primeiroregistro.ldif na base LDAP. Quando for solicitada a senha, informe o rootpw que está no arquivo slapd.conf:

# ldapadd -h localhost -a -W -x -D "cn=admin,dc=dominio,dc=com,dc=br" -f /etc/openldap/primeiroregistro.ldif

Nesse exemplo foi criada uma estrutura onde dominio.com.br é o topo da hierarquia, desenvolvedores é um grupo que está um nível abaixo e gustavo é uma pessoa pertencente ao grupo desenvolvedores. Também é possível criar outros diretórios no mesmo nível ou abaixo de desenvolvedores.
Lembrando que é sempre recomendado inserir no atributo userpassword o hash gerado pelo comando slappasswd ao invés de plain text.

Como podem ver, as três entradas no arquivo primeiroregistro.ldif possuem linhas em comum como dn e objectclass. O dn é a chave para identificar um diretório e objectclass especifica o schema utilizado. O LDAP possui vários schemas com um conjunto de atributos e alguns com dependências para outros schemas. No início do arquivo slapd.conf foram incluídos os schemas utilizados nesse exemplo. Um diretório pode ter mais de um schema e alguns atributos são de preenchimento obrigatório. Por exemplo, usando o inetOrgPerson os atributos cn e sn obrigatoriamente precisam conter algum valor, já uid e userpassword são opcionais, sequer precisam ser adicionados. É possível criar um schema com outros atributos mas isso já é um tópico mais avançado.

O arquivo primeiroregistro.ldif pode ser deletado pois não será mais utilizado.

Há ainda os comandos ldapdelete e ldapmodify com funcionamento semelhante. Mais detalhes em man ldapdelete e man ldapmodify.

Buscas com filtros

Operador =

# ldapsearch -x -b "dc=dominio,dc=com,dc=br" "(objectclass=inetOrgPerson)"

Operador or

# ldapsearch -x -b "dc=dominio,dc=com,dc=br" "(uid=10)" or "(cn=gustavo)"

Operador &

# ldapsearch -x -b "dc=dominio,dc=com,dc=br" "(&(uid=10)(cn=gustavo))"

Ferramentas para administração

Ao lidar com uma base de centenas de diretórios fica complicado, entediante e perigoso administrar uma árvore utilizando as ferramentas de linha de comando. Pensando nisso foram desenvolvidas ferramentas gráficas para esse tipo de trabalho. Das opções open source, duas me chamaram a atenção, o Apache Directory Studio e o phpLdapAdmin. A primeira é baseada na popular IDE Eclipse e me pareceu mais fácil e amigável e por isso vou mostrar como instalar no Fedora 16:

Faça o download em http://directory.apache.org/studio/download/download-linux.html. Descompacte em /opt/ApacheDirectoryStudio e crie um arquivo em /opt/ApacheDirectoryStudio/startup.sh com permissão de execução com o conteúdo abaixo:

# vim /opt/ApacheDirectoryStudio/startup.sh
export GDK_NATIVE_WINDOWS=1
/opt/ApacheDirectoryStudio/ApacheDirectoryStudio

Pronto!!! Execute /opt/ApacheDirectoryStudio/startup.sh para abrir o Apache Directory Studio.

Links

http://www.openldap.org/
http://www.tldp.org/HOWTO/LDAP-HOWTO/
http://migre.me/7Zeup
http://directory.apache.org/studio/download/download-linux.html

KVM (Kernel-based Virtual Machine) é uma solução de virtualização open source para Linux incluído por padrão no kernel a partir da versão 2.6.20.
A maioria das distros possuem as ferramentas necessárias para virtualização com KVM nos CDs de instalação ou repositórios de pacotes. Nesse artigo vou usar o Fedora 16 como host e instalar o CentOS como guest.

Instalação no Fedora 16

# yum install qemu-kvm python-virtinst libvirt virt-manager

Verificando suporte virtualização de hardware:

grep -E "(vmx|svm)" --color=always /proc/cpuinfo

Caso a saída do comando acima não retorne nenhuma informação na tela é porque o processador não suporta virtualização de hardware. Sendo asssim há apenas a opção de usar emulação com o QEMU.

Iniciando o serviço:

# service libvirtd start

Antes de instalar o sistema operacional no guest é necessário criar o virtual disk usado pela máquina virtual. KVM suporta o formato raw, qcow2 (nativo do QEMU), VMWare, dentre outros. Vou criar usando qcow2 e alocando 10GB de espaço:

$ qemu-img create -f qcow2 -o preallocation=metadata /home/gustavo/vm/hd-centos.qcow2 10G

As opções de rede disponíveis são bridge, virtual network e user.
bridge permite que à máquina virtual obter endereço IP como se fosse outra máquina na rede onde está o host;
virtual network cria uma rede virtual no qual apenas outros guests na mesma virtual network e o host consegueguem se comunicar;
user provê uma forma de NAT muito limitada, indicado apenas se for executar o kvm com usuário diferente de root.

Para usar o modo bridge primeiramente é preciso criar a interface br0. Os passos estão descritos nas instruções da documentação da libvirt em http://wiki.libvirt.org/page/Networking.

Criando uma Virtual Machine com KVM

Modo simples, especificando o path da iso de instalação e do virtual disk:

# virt-install --name=minha-vm-centos --arch=x86_64 --vcpus=1 --ram=512 --os-type=linux --os-variant=rhel5 --hvm --connect=qemu:///system --network bridge=br0 --cdrom=/home/gustavo/Downloads/softwares/iso/CentOS-6.2-x86_64-LiveDVD.iso --disk path=/home/gustavo/vm/hd-centos.qcow2,size=10 --graphics vnc,keymap=pt-br,  --noautoconsole

Modo muito simples, onde serão feitas perguntas ao usuário:

# /usr/sbin/virt-install --prompt

Rodando no modo gráfico é possível utilizar virt-manager – interface gráfica para gerenciar máquinas virtuais.

Gerenciando máquinas virtuais com o Virsh

Virsh é utilitário em modo texto que utiliza a API da libvirt para gerenciamento de máquinas virtuais. Abaixo os comandos mais utilizados.

Exibir todas as máquinas virtuais:

virsh list --all

Iniciar uma máquina virtual:

virsh start <nome da vm>

Desligar uma máquina virtual:

virsh shutdown <nome da vm>

Editar configuração:

virsh edit <nome da vm>

Forçar o desligamento:

virsh destroy <nome da vm>

Salvar um snapshot:

virsh save <nome da vm> <nome do arquivo>

Restaurar um snapshot:

virsh restore <nome do arquivo>

Acessar remotamente via ssh:

virsh -c qemu+ssh://<usuario>@<ip>/system <nome da vm>

Outras dicas

Para renomar uma máquina virtual no Virsh é necessário copiar o arquivo xml contendo as configurações, editar manualmente esse arquivo, criar uma máquina virtual com o novo nome e remover a antiga.

virsh dumpxml <nome da vm> > arquivo.xml
vim arquivo.xml #alterar o novo nome dentro do arquivo xml
virsh undefine <nome da vm>
virsh define <nome da nova vm>

Após aumentar o espaço de um virtual disk usando o qemu-img é necessário dar boot no guest com alguma distro livecd e usar o software gparted para redimensionar a partição sem perda de dados.

qemu-img resize /home/gustavo/vm/hd-centos.qcow2 +25GB

O processo de clonar uma máquina virtual consiste em criar uma cópia idêntica com outro nome que pode usar o mesmo virtual disk ou um clone.

virt-clone --connect=qemu:///system -o <nome da vm> -n <nome da vm clonada> -f <path do virtual disk>

Links

http://wiki.libvirt.org/page/Networking
http://www.techotopia.com/index.php/Installing_a_KVM_Guest_OS_from_the_Command-line_(virt-install)
http://www.linux-kvm.org/

Introdução

Nginx foi desenvolvido inicialmente em 2002 por Igor Sysoev para servir um site russo chamado Rambler que tinha milhares de requisições por dia. Entre suas características estão o baixo consumo de cpu e memória (pois usa um processo por core para gerenciar varias conexões) e o formato dos arquivos de configuração que são mais simples de entender e modificar do que os do apache.
Entre os grandes sites que o utilizam, podemos destacar o wordpress e sourceforge.

VirtualEnv é um software que permite criar um ambiente python único e exclusivo para cada projeto. Não entrarei em detalhes sobre seu funcionamento então recomendo uma lida no artigo Gerenciando Ambientes Virtuais que explica melhor sobre o assunto.

Instalação

$ sudo apt-get install nginx
$ sudo pip install virtualenv, virtualenvwrapper

Configuração

Por padrão o arquivo de configuração é o /etc/nginx/nginx.conf. Vamos modifica-lo e deixar como abaixo:

user www-data;
worker_processes 2;
 
error_log  /var/log/nginx/error.log;
pid        /var/run/nginx.pid;
 
http {
    include     /etc/nginx/mime.types;
    access_log  /var/log/nginx/access.log;
    sendfile        on;
    keepalive_timeout  65;
    tcp_nodelay        on;
    gzip  on;
    gzip_disable "MSIE [1-6]\.(?!.*SV1)";
 
    server {
        server_name project-1-0;
        listen 80;
 
        location /media {
            autoindex on;
            alias /var/www/project_1_0/media;
            expires 31d;
        }
 
        location /admin_media {
            autoindex on;
            alias /var/www/project_1_0/media/admin;
            expires 31d;
        }
 
        location / { 
            root /var/www/project_1_0;
            fastcgi_pass 127.0.0.2:8000;
            fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
            fastcgi_param PATH_INFO $fastcgi_script_name;
            fastcgi_param REQUEST_METHOD $request_method;
            fastcgi_param QUERY_STRING $query_string;
            fastcgi_param CONTENT_TYPE $content_type;
            fastcgi_param CONTENT_LENGTH $content_length;
            fastcgi_param SERVER_PORT $server_port;
            fastcgi_param SERVER_NAME $server_name;
            fastcgi_param SERVER_PROTOCOL $server_protocol;
        }   
    }
 
    server {
        server_name project-1-3;
        listen 80; 
 
        location /media {
            autoindex on; 
            alias /var/www/project_1_3/media;
            expires 31d;
        }
 
        location /admin_media {
            autoindex on; 
            alias /var/www/project_1_3/media/admin;
            expires 31d;
        }
 
        location / { 
            root /var/www/project_1_3;
            fastcgi_pass 127.0.0.3:9000;
            fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
            fastcgi_param PATH_INFO $fastcgi_script_name;
            fastcgi_param REQUEST_METHOD $request_method;
            fastcgi_param QUERY_STRING $query_string;
            fastcgi_param CONTENT_TYPE $content_type;
            fastcgi_param CONTENT_LENGTH $content_length;
            fastcgi_param SERVER_PORT $server_port;
            fastcgi_param SERVER_NAME $server_name;
            fastcgi_param SERVER_PROTOCOL $server_protocol;
       }
    }
}

Pode-se dizer que o arquivo de configuração do nginx é uma lista de diretivas organizadas em uma estrutura lógica. Nginx é modular e cada módulo possui um conjunto específico de diretivas. Na configuração acima, todas as diretivas fazem parte do core do nginx, exceto as diretivas fastcgi que fazem parte do módulo FastCGI. Esse módulo é incluído por padrão na compilação do nginx, sendo assim não é preciso ativa-lo.
Nginx trabalha com um sistema de blocos. Um configuração mínima requer os principais blocos: http, server e location.

O bloco http é responsável por tratar requisições desse tipo. Ele pode conter um ou mais blocos server que contém configurações para um virtual host. Cada server pode ter um ou mais blocos location. Esse por sua vez possui configurações para um determinado url pattern.
Na configuração acima foram criados dois blocos server (um para cada projeto) e cada um possui três blocos location contendo configurações para arquivos estáticos e para os projetos em django.

Algumas diretivas podem ser colocadas na raiz do arquivo, fora dos blocos. Diretivas assim são chamadas de diretivas globais e afetam as demais configurações.
Sobre algumas diretivas:

user www-data
Define o usuário do nginx. Coloquei o mesmo usado pelo apache mas nada impede de usar outro. Apenas lembre-se de atribuir as devidas permissões nos diretórios dos projetos para esse user.

worker_processes 2
Define o número de processos executados por core da CPU. No meu caso, uso uma CPU Core 2 Duo.

error_log /var/log/nginx/error.log
Caminho para o arquivo de log de erros.

pid /var/run/nginx.pid
Caminho para o arquivo contendo o PID do nginx.

include /etc/nginx/mime.types
Similar à função include usada em algumas linguagens. Insere o conteúdo do arquivo externo no trecho indicado.

access_log /var/log/nginx/access.log
Caminho para o arquivo de log de acessos.

sendfile on
Se habilitado, nginx usa sendfile kernel call para gerenciar transmissão de arquivos. Se desabilitado, ele próprio gerencia a transmissão. Dependendo da localização física do arquivo, isso pode afetar a performance.

keepalive_timeout 65
Tempo de espera do servidor para fechar conexões keep-alive.

tcp_nodelay on
Habilita ou não a opção TCP_NODELAY para conexões keep-alive. TCP_NODELAY é usado para um único propósito; desabilitar o algoritmo de buffer Nagle. Deve ser habilitado apenas para aplicações que enviam frequentemente requests sem necessidade de obter um response imediato.

gzip on
Habilita compressão gzip.

gzip_disable "MSIE [1-6]\.(?!.*SV1)"
Desabilita a compressão gzip para requests cujo o User-Agent no cabeçalho http combine com a expressão regular. Nesse caso, desabilita para o internet explorer.

server_name project-1-0
Associa um ou mais hostnames ao bloco server. O nginx verifica o Host no cabeçalho do request e seleciona o primeiro bloco que combina.

listen 80
Escuta na porta 80 (padrão http).

autoindex on
Exibe os arquivos do diretório.

alias /var/www/project_1_0/media
Define a location /media como um atalho para o diretório media do projeto.

expires 31d
Define o tempo de expiração do conteúdo. Nesse caso, 31 dias.

root /var/www/project_1_0
Caminho do projeto.

fastcgi_pass 127.0.0.2:8000
Endereço e porta do servidor web usado pelo django. Ex.: python manage.py runfcgi host=127.0.0.2 port=8000 pidfile=/var/run/project_1_0.pid

fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name
fastcgi_param PATH_INFO $fastcgi_script_name
fastcgi_param REQUEST_METHOD $request_method
fastcgi_param QUERY_STRING $query_string
fastcgi_param CONTENT_TYPE $content_type
fastcgi_param CONTENT_LENGTH $content_length
fastcgi_param SERVER_PORT $server_port
fastcgi_param SERVER_NAME $server_name
fastcgi_param SERVER_PROTOCOL $server_protocol
Repassa os parâmetros do request recebido pelo nginx para o servidor fastcgi.

Para finalizar a configuração, vamos editar o /etc/hosts e adicionar dois virtual hosts referentes aos projetos.

$ sudo /etc/hosts
 
127.0.0.2   project-1-0.localdomain project-1-0
127.0.0.3   project-1-3.localdomain project-1-3

Notem que estou utilizando dois IPs de loopback, ou seja, visível somente na máquina local.

Criando os Projetos

Agora vem a parte mais fácil. Vamos criar dois ambientes virtuais (env-1.0 e env-1.3) e instalar o django-1.0 em um e o django-1.3 no outro.
Dentro de cada ambiente vou criar um projeto que vai exibir a versão do django em uso.
O único pacote python obrigatório a ser instalado é o flup, que é uma coleção de módulos WSGI.
Vou usar o virtualenv + virtualenv wrapper e como já havia dito não entrarei em detalhes sobre essas ferramentas.

Ambiente 1.0

Criando o ambiente env-1.0 e o projeto dentro do diretório /var/www:

gustavo@notebook www$ mkvirtualenv --no-site-packages env-1.0
(env-1.0)gustavo@notebook www$ pip install django==1.0, flup
(env-1.0)gustavo@notebook www$ django-admin startproject project_1_0

Modificando o arquivo project_1_0/urls.py para exibir a versão do django na tela:

from django.conf.urls.defaults import *
from django.http import HttpResponse
import django
 
urlpatterns = patterns('',
    (r'^version/$', lambda request:HttpResponse(django.VERSION)),
)

Executando o servidor fastcgi:

(env-1.0)gustavo@notebook project_1_0$ python manage.py runfcgi host=127.0.0.2 port=8000 pidfile=/tmp/project_1_0.pid

Agora basta testar. Abra o navegador e digite http://project-1-0/. Se tudo deu certo então será exibido na tela a versão do Django, no caso “10final”.

Ambiente 1.3

Criando o ambiente env-1.3 e o projeto:

gustavo@notebook www$ mkvirtualenv --no-site-packages env-1.3
(env-1.3)gustavo@notebook www$ pip install django==1.3, flup
(env-1.3)gustavo@notebook www$ django-admin startproject project_1_3

Modificando o arquivo project_1_3/urls.py para exibir a versão do django na tela:

from django.conf.urls.defaults import patterns, include, url 
from django.http import HttpResponse
import django
 
urlpatterns = patterns('',
    (r'^version/$', lambda request:HttpResponse(django.VERSION)),
)

Executando o servidor fastcgi:

(env-1.3)gustavo@notebook project_1_3$ python manage.py runfcgi host=127.0.0.3 port=9000 pidfile=/tmp/project_1_3.pid

Abra o navegador e digite http://project-1-3/. Deve ser exibido na tela a versão do Django, “130final0″.

Conclusão

Esse artigo mostrou uma forma simplista de servir dois projetos usando versões diferentes do django no nginx. Na configuração foram criados blocos location para servir arquivos estáticos como /media e /admin_media porém nos projetos não me aprofundei em alterar o settings.py para isso.

O Nginx possui a diretiva include que permite inserir trechos de configuração localizados em outros arquivos no arquivo de configuração principal. Sendo assim, como boa prática, é indicado colocar a configuração de cada projeto em arquivos separados. No ubuntu 10.10 o diretório /etc/nginx possui dois sub-diretórios, sites-available e sites-enabled, similar ao apache2. A idéia é colocar os arquivos de configuração referentes a cada projeto dentro de sites-available e criar um link simbólico em sites-enabled para habilitar seu uso.
Quem quiser conhecer melhor esse fantástico servidor web, recomendo a leitura do livro Nginx HTTP Server, que inclusive serviu como base para esse artigo.

Links

Nginx Project Page
Planet Nginx
Nginx HTTP Server Book

Primeiros Passos

Configurando informações sobre o autor dos commits:

git config --global user.name "Gustavo"
git config --global user.email "gustavo@gustavohenrique.net"

É possível alterar essas informações no arquivo ~/.gitconfig

Criando um repositório local:

cd meuprojeto
git init

Para ter certeza que o repositório foi criado:

git status

Áreas de Trabalho

O git possui 4 áreas de trabalho:
1. O diretório .git que é o repositório contendo todos os arquivos versionados;
2. Working Area que é um snapshot do .git dentro de um determinado momento no tempo;
3. Stage que é um local temporário que armazena a referência para arquivos a serem versionados antes de serem commitados;
4. Stash que também é um local temporário que pode armazenar e esconder arquivos que estão no Stage.

Adicionando arquivos novos ou modificados no Stage:

git add arquivo.txt
git add *.py
git add . (para add todos os arquivos)
git add -i (para modo interativo. 1-5 ou 1,2,3,4 e -3 para retirar)

Removendo arquivos não versionados do Stage:

git rm --cached arquivo.txt
git clean -fd (remove todos arquivos e diretórios)

Removendo arquivos versionados e modificados do Stage:

git reset HEAD arquivo.txt
git reset HEAD (todos os arquivos)

Desfazendo modificações de arquivos versionados no Stage:

git checkout -- arquivo.txt

Trabalhando com o Stash:

git stash (Move todos os arquivos do Stage para o Stash)
git stash save "Mensagem" (Move todos os arquivos do Stage para o Stash e os identifica com uma mensagem)
git stash list
git stash apply (Recupera os arquivos do último Stash de volta para o Stage mantendo cópia no Stash)
git stash apply <ID> (Recupera os arquivos do Stash identificado pelo ID obtido pelo git stash list. Ex.: stash@{0})
git stash pop (Faz o mesmo que apply porém apaga os arquivos do Stash)
git stash drop <ID> (Apaga completamente o Stash)
git fsck --unreachable | grep commit (Recupera arquivos apagados do Stash)

Commits

Apenas arquivos no Stage podem ser commitados.

git commit -m "Mensagem"
git commit -a -m "Mensagem" (commita também os arquivos versionados mesmo nao estando no Stage)

Refazendo commit quando esquecer de adicionar um arquivo no Stage:

git add arquivo.txt
git commit -m "Mensagem" --amend

O amend é destrutivo e só deve ser utilizado antes do commit ter sido enviado ao servidor remoto.

Voltando commits anteriores:

git reset --hard HEAD~1 (volta ao último commit)
git reset --soft HEAD~1 (volta ao último commit e mantém os últimos arquivos no Stage)
git reset --hard XXXXXXXXXXX (Volta para o commit com a hash XXXXXXXXXXX)

Recuperando commit apagado pelo git reset:

git reflog (Para visualizar os hashs)
git merge <hash>

Logs

Visualizando logs:

git log
git log --stat (Mostra o que foi modificado em cada commit)
git log --graph (Mostra gráfico do log)
git log --pretty=oneline (Mostra os commits linha por linha)
git log --pretty=format:"%an %ad %h %s" (Exibe o autor, data, sha1 abreviado e texto do commit)
git log --since=30.minutes ou 1.hour ou 2.hours (Exibe commits dos últimos 30 minutos, 1h ou 2h)
git log --since=10.hours --until=2.hours (Exibe commits entre as últimas 10h e últimas 2h)
git log --before="2010-12-25" (Exibe commits antes do dia 25/12/2010)
git reflog (Mostra commits apagados pelo git reset)

Branches

Cada branch deve ter uma única funcionalidade. É recomendado criar um novo branch a partir do master e aplicar os merges nele para efeito de simulação.

git branch (Lista os branches)
git branch -a (Mostra também os branches do repositório remoto)
git branch -d novobranch (Apaga o branch)
git branch -D novobranch (Força a remoção do branch)
git checkout -b novobranch (Cria um branch contendo os mesmos commits do branch de origem)
git checkout -b novobranch origin/outrobranch (Cria novobranch a partir do outrobranch no repositório remoto)
git checkout -b [branch, tag, sha1]
git checkout -b <branch> v1.0 (Cria um branch a partir da tag v1.0)
git checkout master (Retorna ao branch master)
git rebase master (Atualiza um branch com o que há de novo no master)
git merge novobranch (Faz um merge do que foi feito em novobranch)
git merge novobranch --squash (Permite definir uma nova mensagem em vez das mensagens de todos os commits do novobranch)

Conflitos

Quanto mais tempo demorar para atualizar um branch a partir do master (git rebase), maior será a chance de haver conflitos depois.
O rebase é destrutivo, se estiver trabalhando em um servidor remoto deve usar o merge.

git rebase --skip (Perde o arquivo novo)
git rebase --abort (Cancela o rebase)
git rebase --continue (Para continuar após lidar com o conflito manualmente)

Repositórios

Clonando repositórios:

git clone repo1 repo2 (Clona um repositório e add o repo1 como orign no repo2)
git remote show origin (Origin é uma convenção para o primeiro remote)
git push origin (Envia o commit local para o repositório remoto)
git push origin outrobranch (O mesmo acima mas para um determinado branch)
git remote add origin repo (Adiciona um repositório como remoto)
git pull (Atualiza a partir do repositório remoto)
git pull origin outrobranch (O mesmo acima mas a partir de um determinado branch)
git remote rm origin (Remove o repositório remoto)

Trabalhando como repositórios remotos:
Antes de dar um git push, dar um git fecth e um git rebase para não criar conflitos para outros usuários.

git init --bare (Cria um repositório sem área de trabalho)
git fetch origin (Puxa novos commits do repositório remoto)
git fetch remote <branch> (Puxa novos commits do repositório remoto para o branch)
git push origin <branch> (Envia o que está no branch atual para o branch no repositório remoto)
git push origin v1.0 (Envia a tag v1.0)
git pull (Atualiza o repositório local a partir do remoto. Similar a usar "fecth" + "merge")
git pull origin <branch> (Atualiza o branch local a partir do branch remoto)

Github

Criando seu próprio projeto:
Crie um projeto pelo site do github. Em seguida, na máquina local, crie um par de chaves pública e privada, copie e cole no campo apropriado no github.

ssh-keygen -t rsa

Depois copiar o conteudo de ~/.ssh/id_rsa.pub e colar na página do github.

Fazendo um fork de um projeto:
Faça um fork de um repositório, um clone para sua máquina, altere o código, commit e no site clique no link “pull request”. O dono do repositório original deve adicionar a URL do repositório fork com git remote add usuario urlfork. Depois executar um git fecth para trazer os branches do fork. Usar git diff usuario/ para ver as alterações. Para aceitar, git merge (resolver conflitos caso apareça), criar um novo commit e enviar com o git push. O usuário que fez o fork deve executar o mesmo procedimentos para manter o fork sincronizado com o repositório original.

Patches

Trabalhando com patches:

git format-patch <branch> --stdout > patch.diff (Cria um patch)
git am patch.diff (Aplica o patch)

Tags

Uma tag é utilizada para criar uma versão de lançamento.

git tag v1.0 (Cria a tag v1.0)
git push origin v1.0 (Envia a tag v1.0)
git push --tags (Envia todas as tags)
git checkout -b <branch> v1.0 (Cria um branch a partir da tag v1.0)

git-svn

Lidando com svn:

git svn clone svn://repo (Clona um repositorio svn)
git svn dcommit (Envia commit para o repositório svn)
git svn fecth (Atualiza a partir do repositório svn)

Links

http://git-scm.com/
http://www.kernel.org/pub/software/scm/git/docs/

Instalação

Há diversas maneiras de se instalar um sistema feito em django. Vou mostrar como fazer o deploy usando Apache2 com o módulo mod_wsgi.
O ambiente completo usa Apache2, sqlite3, python-2.6 e Django-1.1.

root@localhost# apt-get install apache2 libapache2-mod-wsgi sqlite3 python-pysqlite2 python-django

O diretório web padrão do Apache no Ubuntu é o /var/www. Vamos manter assim. Faça o download do Bandcontrol pelo site github.com (no site, clique no botão Download Source), descompacte no /var/www, renomeie o diretório para bandcontrol e altere o dono/grupo de acordo com o usuário do apache.

root@localhost: /var/www# tar zxvf gustavohenrique-bandcontrol-XXXXXX.tar.gz
root@localhost: /var/www# mv gustavohenrique-bandcontrol-XXXXXX bandcontrol
root@localhost: /var/www# chown www-data.www-data -Rf bandcontrol

Os shell scripts usam o Iptables para firewall e TC para controle de banda. É necessário permissão de super usuário para executar esses comandos. Vamos configurar o sudo para que o usuário do Apache possa executar tais comandos como root.

root@localhost: /var/www# visudo

Adicione essas linhas no arquivo /etc/sudoers:

# No Ubuntu o iptables e o tc estao dentro do /sbin
Cmd_Alias BANDCONTROL = /sbin/iptables, /sbin/tc
www-data  ALL = (ALL) NOPASSWD: BANDCONTROL

Configuracao do Apache

Configure um virtualhost no apache criando o arquivo /etc/apache2/sites-enabled/bandcontrol contendo:

WSGIRestrictStdout Off
NameVirtualHost bandcontrol
 
        ServerAdmin webmaster@localhost
        LimitInternalRecursion 1000
        ServerName bandcontrol
 
 
                Options ExecCGI FollowSymLinks MultiViews
                AllowOverride FileInfo
                MultiviewsMatch Handlers
                Order deny,allow
                Allow from all
 
 
        ErrorLog /var/log/apache2/bandcontrol_error.log
        CustomLog /var/log/apache2/bandcontrol_access.log combined
 
        WSGIScriptAlias /     "/var/www/bandcontrol/config.wsgi"
 
        Alias /admin_media/ "/usr/lib/pymodules/python2.6/django/contrib/admin/media/"
        Alias /media/           "/var/www/bandcontrol/media/"

Edite o /etc/hosts e adicione:

127.0.0.2     bandcontrol

Configuracao do Bandcontrol

Altere o arquivo /var/www/bandcontrol/config.wsgi ajustando o diretório de instalação do Django. O padrão do Ubuntu é /usr/lib/pymodules/python2.6/django. Nesse arquivo também é configurado o diretório do bandcontrol:

import os, sys
PROJECT_ROOT_PATH = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, PROJECT_ROOT_PATH)
sys.path.append('/usr/lib/pymodules/python2.6/django/')
sys.path.append('/var/www')
os.environ['DJANGO_SETTINGS_MODULE']='settings'
import django.core.handlers.wsgi
application = django.core.handlers.wsgi.WSGIHandler()
 
import bandcontrol.monitor
bandcontrol.monitor.start(interval=1.0)

No arquivo /var/www/bandcontrol/settings.py é possível fazer mais alterações.
Para definir as interfaces de rede e classe IP utilizada na rede, edite os arquivos /var/www/bandcontrol/scripts/CONFIG e /var/www/bandcontrol/scripts/firewall.

Por padrão é utilizado o banco de dados sqlite3. Você pode escolher usar o MySQL ou PostgreSQL editando o arquivo /var/www/bandcontrol/settings.py.
Para criar o BD, entre no diretório do bandcontrol e execute o comando manage.py syncdb. Digite yes para confirmar a criação do super usuário. Forneça um login, e-mail e senha:

root@localhost: /var/www/bandcontrol# python manage.py syncdb
Creating table auth_permission
Creating table auth_group
Creating table auth_user
Creating table auth_message
Creating table django_content_type
Creating table django_session
Creating table django_site
Creating table django_admin_log
Creating table rede_plano
Creating table rede_pontorede
 
You just installed Django's auth system, which means you don't have any superusers defined.
Would you like to create one now? (yes/no): yes
Username (Leave blank to use 'root'): gustavo
E-mail address: eu@gustavohenrique.net
Password:
Password (again):
Superuser created successfully.
Installing index for auth.Permission model
Installing index for auth.Message model
Installing index for admin.LogEntry model
Installing index for rede.PontoRede model

Reinicie o Apache para que as alterações tenham efeito.

Utilização

Abra o browser e acesse http://bandcontrol/.
Reparem que no campo de endereço da URL e os nomes de usuário utilizados não condizem com o que foi exemplificado nesse artigo. Bom... estou com preguiça para alterar as imagens, então vamos desconsiderar esse "bug".

Entre com o login e senha criados no passo anterior.

Tela inicial do sistema.

Clique em Planos e vamos criar alguns.

Volte à tela inicial, clique em Pontos de Rede. No menu superior há opção para executar o firewall, parar o controle de banda e exibir os IPs conectados ao servidor. Sempre que fizer alguma alteração no sistema deve executar o firewall para ativar as mudanças.

Em exibir IPs conectados, para adicionar um IP no sistema forneça uma descrição única, escolha o plano e clique em [+].

O bandcontrol permite criar outros usuários com acesso ao sistema. Trabalha com permissões e grupos. Cortesia do Django \o/

Conclusão

Bandcontrol foi uma daquelas coisas "pra ontem". Foi feito em uma tarde de terça-feira. Tal velocidade se deve ao framework Django.
Esse artigo foi escrito um pouco de cada vez, por isso há grandes chances de algo sair errado. Há muito material disponível na web sobre deploy de projetos em Django. Em caso de dúvidas estarei disposto a ajudar.

Introdução

Nessa segunda parte do artigo vou mostrar como criar um shell script usando o iptables para filtragem de pacotes e CBQ para controle de banda.
O script está fácil de entender e sua utilização é bem simples. É necessário criar um arquivo texto contento informações sobre cada máquina cliente que possui acesso à internet. Informações como IP, MAC, Download, Upload, se vai passar pelo Squid e se está bloqueado o acesso. Com base nestas informações, o script cria as regras no firewall bloqueando ou liberando acessos, amarrando IP ao endereço MAC, faz proxy transparente e determina qual a velocidade de download e upload para cada um. Fora isso, é criado o arquivo /etc/dhcpd.con usado pelo servidor DHCP associando o IP ao seu MAC, fazendo com que um cliente obtenha sempre o mesmo IP.

Firewall e Controle de Banda

É recomendado um conhecimento básico sobre Linux e Shell Script para bom entendimento do código.

#!/bin/bash
 
ARQUIVO="/var/www/bandcontrol/scripts/pontosderede.txt"     # Contem os pontos de rede cadastrados
 
MOD=$(which modprobe)                        # Comando para carregar modulos do kernel
IPT=$(which iptables)                        # Caminho do iptables
TC=$(which tc)                               # tc (pacote iproute2)
 
I_WAN="eth0"                                 # Interface internet
I_LAN1="eth1"                                # Interface Rede local
 
GATEWAY_IP="192.168.254.254"
NETMASK="255.255.255.0"
CLASSE_LAN1="192.168.254"                    # Classe de IP utilizada na rede local. Ex.: 10.0
PROXY_SERVER="$GATEWAY_IP:3128"              # O proprio gateway tambem roda o Squid na porta 3128
 
DHCPD_DAEMON="/etc/init.d/dhcp3-server"      # Executavel do dhcpd server
DHCPDCONF="/etc/dhcp3/dhcpd.conf"            # Arquivo de configuracao do dhcpd
DOMINIO="gustavohenrique.net"                # Dominio ao qual a rede faz parte
DNS_SERVERS="$GATEWAY_IP, 8.8.8.8, 4.2.2.2"  # Servidores DNS. O primeiro é o próprio gateway
 
# Remove o controle de banda
function parar_controle_de_banda {
    $TC qdisc del dev $I_LAN1 root
    $TC qdisc del dev $I_WAN root
}
 
# Cria as regras iniciais para controle de banda
function iniciar_controle_de_banda {
    # Remove as regras do controle de banda
    parar_controle_de_banda
 
    # Download
    $TC qdisc add dev $I_LAN1 root handle 1 cbq bandwidth 100Mbit avpkt 1000 cell 8
    $TC class change dev $I_LAN1 root cbq weight 10Mbit allot 1514
 
    # Upload
    $TC qdisc add dev $I_WAN root handle 1 cbq bandwidth 100Mbit avpkt 1000 cell 8
    $TC class change dev $I_WAN root cbq weight 10Mbit allot 1514
 
    # Cache Full. Pacotes marcados com TOS 60 vao para a classe 1:9999 cuja banda é 100 Mbit (rede ethernet)
    $TC class add dev $I_LAN1 parent 1: classid 1:9999 cbq bandwidth 100Mbit rate 100Mbit weight 10Mbit prio 4 allot 1514 cell 8 maxburst 20 avpkt 1000 bounded
    $TC filter add dev $I_LAN1 parent 1:0 protocol ip prio 3 u32 match ip protocol 0x6 0xff match ip tos 60 0xff classid 1:9999
}
 
 
# Limpa o firewall
function parar_firewall() {
    # Configura a politca padrao para aceitar tudo
    $IPT -P INPUT ACCEPT
    $IPT -P OUTPUT ACCEPT
    $IPT -P FORWARD ACCEPT
    $IPT -t nat -P PREROUTING ACCEPT
 
    # Limpa a tabela netfilter
    $IPT -F
    $IPT -X
    $IPT -t nat -F
    $IPT -t nat -X
    $IPT -t mangle -F
    $IPT -t mangle -X
}
 
 
# Cria as regras de firewall
function iniciar_firewall() {
 
    # Finaliza o script se nao existir o arquivo contendo os pontos de rede
    if [ ! -f $ARQUIVO ]; then
        echo "Arquivo contendo os pontos de rede ($ARQUIVO) nao existe.";
        exit 0
    fi
 
    # Carrega modulos do iptables
    $MOD ip_tables
    $MOD iptable_nat
    $MOD ipt_MASQUERADE
    $MOD ipt_LOG
    $MOD ipt_REJECT
    $MOD ip_conntrack_ftp
    $MOD ip_nat_ftp
 
    # Limpa todas as regras do firewall
    parar_firewall
 
    # Recria as regras para controle de banda
    iniciar_controle_de_banda
 
    # Por padrao bloqueia tudo que for entrar no firewall
    $IPT -P INPUT DROP
    $IPT -t nat -P PREROUTING DROP
 
    # Habilita redirecionamento de pacotes para compartilhar internet
    echo 1 > /proc/sys/net/ipv4/ip_forward
 
    # Aumenta o limite do nf_conntrack_max
    echo 99999 > /proc/sys/net/netfilter/nf_conntrack_max
 
    # Libera acesso para pacotes vindos da internet (CUIDADO)
    $IPT -t nat -A PREROUTING -s 0/0 -i $I_WAN -p all -j ACCEPT
    $IPT -A INPUT -i $I_WAN -j ACCEPT
 
    # Cria uma nova chain para tratar do proxy transparente
    $IPT -t nat -N proxy
        # O software conectividade social da Caixa Economica nao funciona se
        # estiver passando pelo proxy. Tudo que for destinado ao IP da Caixa
        # nao vai passar pelo proxy
        $IPT -t nat -A proxy -p tcp -d 200.201.174.0/16 --dport 80 -j ACCEPT
        $IPT -t nat -A proxy -p tcp -d 200.201.173.0/16 --dport 80 -j ACCEPT
        $IPT -t nat -A proxy -p tcp -d 200.201.0.0/16 --dport 80 -j ACCEPT
        $IPT -t nat -A proxy -p tcp -d 200.201.174.207 --dport 80 -j ACCEPT
 
        # Internet Caixa nao passa pelo proxy
        $IPT -t nat -A proxy -p tcp -d 200.201.169.0/8 --dport 80 -j ACCEPT
        $IPT -t nat -A proxy -p tcp -d 200.201.169.69 --dport 80 -j ACCEPT
 
        # Esse servidor tambem roda o Apache na port 80. Nao quero que as
        # paginas locais passem pelo proxy, pois assim posso controlar a banda
        # de pacotes vindos do apache definindo a velocidade máxima da rede
        $IPT -t nat -A proxy -p tcp -d $GATEWAY_IP --dport 80 -j ACCEPT
 
        # Proxy transparente redirecionando os pacotes para a porta do Squid
        $IPT -t nat -A proxy -s 0/0 -p tcp --dport 80 -j DNAT --to-dest $PROXY_SERVER
 
        # Se o pacote nao for pra porta 80 (não é navegação), deixa passar
        $IPT -t nat -A proxy -i $I_LAN1 -j ACCEPT
 
 
    # Libera o IP abaixo sem amarrar com MAC e sem passar pelo proxy
    #$IPT -t nat -A PREROUTING -i $I_LAN1 -s 192.168.254.2 -j ACCEPT
 
    # Configuracao inicial do dhcpd.conf. Distribuicao de IPs na faixa 192.168.254.80 a 192.168.254.90
    echo "# Arquivo dhcpd.conf criado pelo BandControl" > $DHCPDCONF
    echo "ddns-update-style none;" >> $DHCPDCONF
    echo "option domain-name \"$DOMINIO\";" >> $DHCPDCONF
    echo "option domain-name-servers $DNS_SERVERS;" >> $DHCPDCONF
    echo "default-lease-time 600;" >> $DHCPDCONF
    echo "max-lease-time 7200;" >> $DHCPDCONF
    echo "authoritative;" >> $DHCPDCONF
    echo "shared-network 0-2 {" >> $DHCPDCONF
    echo "  subnet $CLASSE_LAN1"."0 netmask $NETMASK { range $CLASSE_LAN1.80 $CLASSE_LAN1.90; }" >> $DHCPDCONF
    echo "}" >> $DHCPDCONF
 
    # Inicio do loop para liberacao e bloqueio de clientes.
    # O formato do arquivo é: codigo_identificador-descricao-ip-mac-download-upload-liberado-proxy
    # Ex.: 1-gustavo_henrique_notebook-192.168.254.10-512-256-S-S
    # Acesso liberado e uso do proxy sao valores que devem ser True ou False
    for i in `cat $ARQUIVO`; do
        CODIGO=$(echo $i | awk -F "-" {'print $1'})                  # Numero usado como identificador no controle de banda
        IP=$(echo $i | awk -F "-" {'print $3'})                      # IP
        MAC=$(echo $i | awk -F "-" {'print $4'})                     # MAC em letras minusculas e separado por dois pontos (:)
        DOWNLOAD=$(echo $i | awk -F "-" {'print $5'})                # Numero correspondente a velocidade de download em Kbit
        UPLOAD=$(echo $i | awk -F "-" {'print $6'})                  # Numero correspondente a velocidade de upload em Kbit
        POSSUI_ACESSO_LIBERADO=$(echo $i | awk -F "-" {'print $7'})  # True para sim, False para bloquear o acesso
        VAI_USAR_PROXY=$(echo $i | awk -F "-" {'print $8'})          # True para usar o proxy, False para não usar
 
        # Configurar dhcpd para associar IP ao MAC
        if [ "$MAC" != "" ]; then
          LINHA="host $CODIGO { hardware ethernet $MAC; fixed-address $IP; option subnet-mask $NETMASK; option routers $GATEWAY_IP; option domain-name-servers $DNS_SERVERS; }"
          echo $LINHA >> $DHCPDCONF
        fi
 
        # Se o IP nao esta liberado, bloqueia no firewall
        if [ "$POSSUI_ACESSO_LIBERADO" == "False" ]; then
            EXECUTAR_REGRA="$IPT -t nat -A PREROUTING -p tcp -i $I_LAN1 -s $IP -j DROP"
        else
            if [ "$VAI_USAR_PROXY" == "True" ]; then
                EXECUTAR_REGRA="$IPT -t nat -A PREROUTING -i $I_LAN1 -s $IP -m mac --mac-source $MAC -j proxy"
            else
                EXECUTAR_REGRA="$IPT -t nat -A PREROUTING -i $I_LAN1 -s $IP -j ACCEPT"
            fi
        fi
 
        # Executa a regra referente ao IP dentro do loop
        $EXECUTAR_REGRA
 
 
        # Aplica o controle de banda ao IP. Para cada IP é criada uma classe de download e upload.
        WEIGHT_DOWN=$(expr $DOWNLOAD / 10)
        ID_DOWN=1"$CODIGO"
        $TC class add dev $I_LAN1 parent 1: classid 1:$ID_DOWN cbq bandwidth 10Mbit rate "$DOWNLOAD"Kbit weight "$WEIGHT_DOWN"Kbit prio 5 allot 1514 cell 8 maxburst 20 avpkt 1000 bounded
        $TC filter add dev $I_LAN1 parent 1:0 protocol ip prio 100 u32 match ip dst $IP classid 1:$ID_DOWN
 
        WEIGHT_UP=$(expr $UPLOAD / 10)
        ID_UP=2"$CODIGO"
        $TC class add dev $I_WAN parent 1: classid 1:$ID_UP cbq bandwidth 10Mbit rate "$UPLOAD"Kbit weight "$WEIGHT_UP"Kbit prio 5 allot 1514 cell 8 maxburst 20 avpkt 1000 bounded
        $TC qdisc add dev $I_WAN parent 1:$ID_UP handle $ID_UP tbf rate "$UPLOAD"Kbit buffer 10Kb/8 limit 15Kb mtu 1500
        $TC filter add dev $I_WAN parent 1:0 protocol ip prio 100 u32 match ip src $IP classid 1:$ID_UP
 
    done
 
    # Aplica o TOS 60 nas portas utilizadas por outros serviços. Assim é usado a velocidade total da rede
    # para acesso ao SSH, Apache e Samba
    $IPT -t mangle -A OUTPUT -p tcp --sport 22 -j TOS --set-tos 60
    $IPT -t mangle -A OUTPUT -p tcp --sport 80 -j TOS --set-tos 60
 
    $IPT -t mangle -A OUTPUT -p tcp --sport 137:139 -j TOS --set-tos 60
    $IPT -t mangle -A OUTPUT -p udp --sport 137:139 -j TOS --set-tos 60
    $IPT -t mangle -A INPUT -p tcp --dport 137:139 -j TOS --set-tos 60
    $IPT -t mangle -A INPUT -p udp --dport 137:139 -j TOS --set-tos 60
 
    # Compartilha a internet
    $IPT -t nat -A POSTROUTING -o $I_WAN -j MASQUERADE
 
    # Bloqueio contra Scanners Ocultos (Shealt Scan)
    $IPT -A INPUT -p tcp --tcp-flags SYN,ACK,FIN,RST RST -m limit --limit 1/s -j DROP
 
    # Libera ping (CUIDADO com ataques ddos)
    $IPT -A INPUT -i $I_LAN1 -p icmp -j ACCEPT
    $IPT -A INPUT -i $I_WAN -p icmp -j ACCEPT
 
    # Libera acesso para o proprio gateway
    $IPT -A INPUT -i lo -j ACCEPT
    $IPT -A FORWARD -i lo -j ACCEPT
 
    # Libera acesso ao Apache
    $IPT -A INPUT -p tcp --dport 80 -j ACCEPT
    $IPT -A INPUT -p tcp --dport 443 -j ACCEPT
 
    # Libera acesso ao Squid
    $IPT -A INPUT -p tcp --dport 3128 -j ACCEPT
 
    # Libera acesso ao SSH
    $IPT -A INPUT -p tcp --dport 22 -j ACCEPT
 
    # Libera acesso ao DNS
    $IPT -A INPUT -p udp --dport 53 -j ACCEPT
 
    # Libera acesso aos compartilhamentos do Samba
    $IPT -A INPUT -p tcp --dport 137:139 -j ACCEPT
    $IPT -A INPUT -p udp --dport 137:139 -j ACCEPT
 
    # Libera acesso ao SNMP
    #$IPT -A INPUT -p udp --dport 160:162 -j ACCEPT
 
    # Tratamento de conexoes TCP
    $IPT -A INPUT -p tcp --syn -j DROP
    $IPT -A INPUT -p tcp -m state --state ESTABLISHED,RELATED,NEW -j ACCEPT
    $IPT -A INPUT -m limit --limit 3/minute --limit-burst 3 -j DROP
 
    # Bloqueando pacotes estranhos
    $IPT -A INPUT -p tcp --tcp-flags ALL FIN,URG,PSH -j DROP
    $IPT -A INPUT -p tcp --tcp-flags ALL SYN,RST,ACK,FIN,URG -j DROP
    $IPT -A INPUT -p tcp --tcp-flags ALL ALL -j DROP
    $IPT -A INPUT -p tcp --tcp-flags ALL FIN -j DROP
    $IPT -A INPUT -p tcp --tcp-flags SYN,RST SYN,RST -j DROP
    $IPT -A INPUT -p tcp --tcp-flags SYN,FIN SYN,FIN -j DROP
    $IPT -A INPUT -p tcp --tcp-flags ALL NONE -j DROP
 
    echo "Firewall iniciado"
}
 
 
case $1 in
    # Inicia o firewall e o dhcpd
    start) iniciar_firewall; $DHCPD_DAEMON stop; $DHCPD_DAEMON start; exit ;;
 
    # Finaliza o firewall sem parar o dhcp
    stop) parar_firewall; exit ;;
 
    # Inicia o firewall sem reiniciar o dhcpd
    only) iniciar_firewall; exit ;;
 
    # Finaliza o controle de banda
    fast) parar_controle_de_banda; exit ;;
 
    # Se nenhum parametro for passado, mostra a ajuda abaixo
    *) echo "Use assim: $0 start|stop|only|fast"; exit 1;;
esac

Conclusão

Com o término da segunda parte do artigo é possível colocar um servidor Linux funcionando com eficiência, segurança e estabilidade para compartilhar uma conexão de internet. É uma ótima solução custo/benefício para micro e pequenas empresas.
Na próxima parte vou mostrar como desenvolver uma interface web para gerenciar melhor os pontos de rede. Isso dá mais agilidade ao trabalhar com muitas máquinas na rede.

Algumas considerações:

• Tomem cuidado na configuração do firewall. Esse é um script simples que serve não deve ser tomado como solução definitiva.
• Há outra alternativa para controle de banda chamada HTB. Pessoalmente prefiro o CBQ, o mesmo utilizado nesse script, mas vale a pena dar uma estudada.
• Usar um arquivo texto contendo os dados dos pontos de rede para ser lido pelo shell script foi a idéia mais simples e não a de melhor desempenho. Também fiz o script fazer consultas ao MySQL mas não senti diferença na velocidade comparado com a leitura de um arquivo de texto.

Bom, a parte 3 do artigo só em 2010. Nesse momento já estou em algum lugar sem internet e talvez sem celular.
Feliz ano novo à todos!

1. Instalação do Squid com o patch ZPH (para fazer cache full)
2. Configuração do script de firewall e controle de banda
3. Interface web (desenvolvida em Django) para gerenciar o firewall

Introdução

O uso do GNU/Linux em servidores vem crescendo a cada ano. Não só pelo custo zero com licenças mas também por sua superior vantagem em desempenho, segurança e estabilidade em relação à outros sistemas operacionais.
Graças ao Linux e aos softwares open source descritos nesse artigo é possível criar uma solução economicamente viável para empresas que ainda não dispõem de uma estrutura adequada para compartilhar a internet.
Nesse exemplo vamos instalar o proxy Squid na mesma máquina que funciona como gateway. Com o crescimento da rede, é aconselhável separar um ou mais servidores apenas para proxy e definindo as rotas manualmente no gateway.
A distribuição utilizada foi Ubuntu Server 9.04 mas nada impede que seja aplicada à outras distros.

Compilando o Squid com suporte a Cache Full

Cache full é a ação de fazer com que os arquivos em cache utilizem uma velocidade maior independente do controle de banda definido para as máquinas clientes. Com o proxy Squid, alguns arquivos ficam em cache, ou seja, ficam no HD do seu servidor. Então quando um cliente acessa um site que contém algumas imagens em cache, o Squid não baixa novamente essas imagens, ele envia o que está armazenado no HD. Se arquivos em cache estão vindo do HD do servidor de proxy, então por que não usar a velocidade da rede (10/100 Ethernet por exemplo) para enviar esses arquivos aos clientes já que não consome o link de internet? É até melhor pois o carregamento do site fica mais rápido.
Existe um patch para o squid, chamado de ZPH, que faz uma marcação nos pacotes que estão em cache, e sabendo dessa marcação podemos definir uma velocidade no controle de banda para esses pacotes.
O patch ZPH NÃO funciona com qualquer versão do Squid. Até o momento em que estou escrevendo a última versão do Squid compatível é a 3.0STABLE8.
Vou baixar o código fonte do squid, o patch ZPH, aplicar o patch, compilar e instalar o Squid. Chega de teorias:

root@localhost:~# wget http://zph.bratcheda.org/squid-3.0.STABLE8-zph.patch
root@localhost:~# apt-get source squid3
root@localhost:~# apt-get build-dep squid3
root@localhost:~# cd squid3-3.0.STABLE8
root@localhost:~/squid3-3.0.STABLE8# patch -p1 ../squid-3.0.STABLE8-zph.patch
root@localhost:~/squid3-3.0.STABLE8# dpkg-buildpackage -rfakeroot -uc -b

Primeiro foi feito o download do patch ZPH usando o software wget. Depois foi baixado o source do squid3 diretamente dos repositórios do Ubuntu e então, usando o apt-get build-dep squid3, foi criado o diretório squid3-3.0.STABLE8 e instaladas as dependências necessárias para compilar o squid. Após isso, entrei no diretório contendo o source do Squid, apliquei o patch ZPH (comando patch -p1) e com isso foram criados os pacotes no formato deb para instalação. Para instalar basta usar o dpkg -i em cada pacote no formato deb.

root@localhost:~/squid3-3.0.STABLE8# cd ..
root@localhost:~# dpkg -i squid3_3.0.STABLE8-3+lenny2build0.9.04.1_i386.deb
root@localhost:~# dpkg -i squid3-common_3.0.STABLE8-3+lenny2build0.9.04.1_all.deb
root@localhost:~# dpkg -i squid3-cgi_3.0.STABLE8-3+lenny2build0.9.04.1_i386.deb
root@localhost:~# dpkg -i squidclient_3.0.STABLE8-3+lenny2build0.9.04.1_i386.deb

Configurando o squid.conf

A localização do arquivo deve ser /etc/squid3/squid.conf.

acl manager proto cache_object
acl localhost src 127.0.0.1/32
acl to_localhost dst 127.0.0.0/8
acl localnet src 192.168.254.0/24
acl SSL_ports port 443
acl Safe_ports port 80		# http
acl Safe_ports port 21		# ftp
acl Safe_ports port 443		# https
acl Safe_ports port 70		# gopher
acl Safe_ports port 210		# wais
acl Safe_ports port 1025-65535	# unregistered ports
acl Safe_ports port 280		# http-mgmt
acl Safe_ports port 488		# gss-http
acl Safe_ports port 591		# filemaker
acl Safe_ports port 777		# multiling http
acl CONNECT method CONNECT
 
http_access allow manager localhost
http_access deny manager
http_access deny !Safe_ports
http_access deny CONNECT !SSL_ports
http_access allow localnet
http_access deny all
 
icp_access allow localnet
icp_access deny all
htcp_access allow localnet
htcp_access deny all
 
# Porta
http_port 3128 transparent
 
hierarchy_stoplist cgi-bin ?
maximum_object_size_in_memory 64 KB
cache_dir aufs /var/cache/squid 40000 16 256
max_open_disk_fds 0
 
# Marcacao TOS do ZPH
zph_tos_local 16
zph_tos_parent on
 
# Arquivos de LOG
access_log /var/log/squid3/access.log squid
cache_log /var/log/squid3/cache.log
cache_store_log /var/log/squid3/store.log
 
# PID
pid_filename /var/run/squid.pid
 
refresh_pattern ^ftp:		1440	20%	10080
refresh_pattern ^gopher:	1440	0%	1440
refresh_pattern (cgi-bin|\?)	0	0%	0
refresh_pattern .		0	20%	4320
visible_hostname mainserver
icp_port 3130
coredump_dir /var/cache

Consulte a documentação do squid para mais informações.

Inciando o Squid

Criando a estrutura de diretórios e iniciando o serviço:

root@localhost:~# squid -z
root@localhost:~# /etc/init.d/squid3 start

Para testar o funcionamento basta configurar o browser para acessar via proxy usando o IP 127.0.0.1 e porta 3128. Se navegar na internet significa que funcionou, se não, leia os arquivos de log para tentar identificar o problema.

Conclusão

É possível que ocorra algum problema seguindo os passos descritos nesse artigo. O motivo se deve ao fato de que tive que simplificar bastante os passos para servir como um exemplo genérico.
Problemas ou dúvidas ficarei feliz em poder ajudar.
Feliz natal à todos!

Como primeiro artigo do ano, vou mostrar de forma bem rápida como configurar o Apache no Linux para trabalhar com Django e com PHP ao mesmo tempo. Para tal, foi usada a instalação padrão do Apache2 com PHP5 do Ubuntu no servidor de desenvolvimento.
O mod_wsgi é um módulo para o Apache que permite executar aplicações web escritas em Python. Trata-se de uma alternativa ao mod_python e ao FastCGI.

Instalação

O primeiro passo é instalar o mod_wsgi. No meu caso instalei a partir do repositório do Ubuntu, via apt-get:
root@notebook:~# apt-get install libapache2-mod-wsgi
Nesse exemplo vamos utilizar o diretório padrão do Apache (/var/www) para hospedar os projetos feitos em Django e PHP. Abaixo a estrutura de diretório utilizada:

+ /var/www/
+--+ meusite/
+-- apps_wsgi/
| +-- djangosite/
+-- www/


var/www – Diretório padrão do Apache
meusite – Diretório do projeto
apps_wsgi – Diretório de projetos feitos em Django
djangosite – Projeto em Django, criado com o django-admin
www – Diretório de arquivos PHP

Antes de criarmos o VirtualHost, é preciso configurar o /etc/hosts. Vamos atribuir um IP de loopback uma vez que o Apache está sendo executado na máquina local que é um ambiente de desenvolvimento.
Segue abaixo o conteúdo do /etc/hosts já alterado. A primeira coluna é o IP do servidor virtual, a segunda é o hostname e a terceira é um alias para o hostname.

gustavo@notebook:~# cat /etc/hosts
127.0.0.1 localhost notebook
127.0.0.2 www2.meusite.com.br meusite

Reparem que não configurei o hostname como www.meusite.com.br, pois senão o Apache responderia à toda requisição feita para essa URL, logo não conseguiríamos acessar o site na web. Se testarmos dar um ping para meusite vamos obter uma resposta sem perda de pacotes.

O próximo passo é criar um VirtualHost para nosso projeto. Com VirtualHost é possível hospedar vários sites no Apache, cada um sendo representado por um nome. Vamos criar nosso VirtualHost após a última linha do arquivo de configuração /etc/apache2/sites-enabled/000-default do Apache:

WSGIRestrictStdout Off
<virtualHost www2.meusite.com.br>
  LimitInternalRecursion 1000
  ServerName meusite
  DocumentRoot /var/www/meusite/www/
 
  ErrorLog /var/www/meusite/error.log
  LogLevel warn
 
  <directory "/var/www/meusite/www/">
    Order allow,deny
    Allow from all
  </directory>
 
  AddHandler wsgi-script .wsgi
  #WSGIScriptAlias /meusite/ "/var/www/meusite/www/meusite.wsgi"
  <directory "/var/www/meusite/apps_wsgi/">
    AllowOverride FileInfo
    Options ExecCGI MultiViews FollowSymLinks
    MultiviewsMatch Handlers
    Order deny,allow
    Allow from all
  </directory>
</virtualHost>

Então agora criamos o arquivo /var/www/meusite/www/meusite.wsgi com o seguinte conteúdo:

import os, sys
sys.path.append('/var/www/meusite/apps_wsgi')
os.environ['DJANGO_SETTINGS_MODULE']='meusite.settings'
import django.core.handlers.wsgi
application = django.core.handlers.wsgi.WSGIHandler()

E para finalizar, vamos criar um arquivo .htaccess dentro do DocumentRoot. Esse arquivo utiliza o mod_rewrite do Apache para sobrescrever URLs. Nesse exemplo o .htaccess verifica todas as requisições feitas ao servidor, e caso não exista o arquivo dentro do diretório www, quem assume o controle é o Django.

$ cat /var/www/meusite/www/.htaccess
RewriteEngine On
RewriteCond %{REQUEST_FILENAME} !-f
RewriteRule ^(.*)$ /var/www/meusite/www/meusite.wsgi/$1 [QSA,PT,L]


Conclusão

Para testar, crie o arquivo /var/www/meusite/www/info.php contendo a seguinte linha:

<? phpinfo(); ?>

Agora tente acessa a URL http://www2.meusite.com.br/info.php e será exibida na tela informações sobre o ambiente web instalado na máquina. Agora se tentar acessar um arquivo que não existe, tipo http://www2.meusite.com.br/qualquercoisa, o .htaccess redirecionará a requisição para o arquivo urls.py do projeto feito em Django.

Como primeiro artigo sobre Linux, vou abordar um pouco sobre roteamento de pacotes usando iproute e iptables.
Imagine um cenário onde há um servidor que compartilha a internet para a rede interna, atuando como gateway, e por algum motivo foi contratado mais um link de internet. Ou então há 2 ou mais servidores proxy e se deseja definir para qual deles cada IP da rede interna deve seguir caminho. Outro cenário seria separar a parte de navegação dos demais serviços (msn, emule, e-mail…), cada uma usando um link diferente. Nesse artigo vou demonstrar que o Linux proporciona maneiras simples e eficientes de implementar esse tipo de roteamento. As distribuições utilizadas foram ubuntu server 5.04 e 5.10 e debian lenny.

Funcionamento

No exemplo em questão, o servidor que vou configurar é um gateway compartilhando a internet para vários clientes. O iptables realiza uma marcação para todos os pacotes oriundos de cada IP cliente e o iproute determina para qual link os pacotes deverão ser encaminhados de acordo com a marcação feita. Vou usar a marcação 1 para pacotes via link1, marcação 2 para pacotes à serem encaminhados para o link2 e a rota principal do próprio gateway será pelo link1.

Instalação

O iptables e iproute são pacotes presentes em quase todas as distribuições. Na maioria o iptables é instalado por padrão. Nesse caso, vou instalar apenas o iproute, via apt-get, que é o gerenciador de pacotes padrão das distribuições debian e ubuntu.
sudo apt-get install iproute2

Criando a tabela de roteamento

Vou criar 2 tabelas chamadas link1 e link2, adicionando duas linhas no final do arquivo /etc/iproute2/rt_tables, ficando assim:

root@gateway# cat /etc/iproute2/rt_tables
255 local
254 main
253 default
0 unspec
250 link1
251 link2


Agora vou criar o script rotas, dentro do diretório /etc/init.d/, que utiliza o iproute para definir as rotas.

root@gateway# vim /etc/init.d/rotas


conteúdo do script:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

#!/bin/bash
 
# DEFINICAO DOS GATEWAYS (IPs FICTICIOS)
GW_LINK1=189.12.34.1
GW_LINK2=200.56.78.1
 
# PLACAS DE REDE
ETH_LINK1=eth1
ETH_LINK2=eth2
 
function start() {
  # Limpa o cache de rotas
  ip route flush cache
  # Pacotes com marcacao 1 vao para o link1
  ip rule add fwmark 1 prio 20 table link1
  # Pacotes com marcacao 2 vao para o link2
  ip rule add fwmark 2 prio 20 table link2
  # Associa a rota do link1 a interface de rede e tabela correspondentes
  ip route add default via $GW_LINK1 dev $ETH_LINK1 table link1
  # Associa a rota do link1 a interface de rede e tabela correspondentes
  ip route add default via $GW_LINK2 dev $ETH_LINK2 table link2
  # Adiciona a rota padrao ao link1
  route add default gw $GW_LINK1
  echo "Tabela de roteamento criada."
}
 
function stop() {
  # Limpa o cache
  ip route flush cache
  # Deleta as regras de acordo com as marcacoes
  ip rule del fwmark 2
  ip rule del fwmark 3
  # Deleta a rota padrao
  route del default
  echo "Limpeza da tabela de roteamento concluida."
}
 
case $1 in
  'start') start; exit ;;
  'stop') stop; exit ;;
  'restart') stop; start; exit ;;
  *) start; exit ;;
esac

Reparem que o que o script rotas faz é dizer que pacotes marcados como 1 (fwmark 1) fazem parte da tabela link1 e marcados como 2 (fwmark 2) da tabela link2. Em seguida cria uma regra dizendo que os pacotes da tabela link1 seguem pelo gateway e interface de rede correspondentes. O mesmo para a tabela link2.
O próximo passo é fazer a marcação dos pacotes.

Marcando os pacotes com iptables

Esse script de firewall é apenas para demonstrar como fazer a marcação de pacotes. As regras devem ser incorporadas à um firewall melhor configurado e mais seguro.
O iptables na verdade é um software que age como frontend para manipulação do firewall do Linux, chamado de netfilter. Esse por sua vez possui uma tabela chamada mangle que é onde ficam armazenadas as regras de marcação de pacotes e outra chamada nat, que contém as regras de NAT.
Assim como antes, vou colocar o script dentro do diretório /etc/init.d

root@gateway# vim /etc/init.d/firewall


E dentro do script:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

#!/bin/bash
 
# modprobe eh usado para carregar modulos do kernel
MOD=$(which modprobe)
 
# iptables
IPT=$(which iptables)
 
# Interfaces de rede
I_LINK1="eth1"
I_LINK2="eth2"
I_LAN="eth0"
 
function stop() {
  # Limpa a tabela mangle
  $IPT -t mangle -F
  $IPT -t mangle -X
 
  echo "Firewall parado."
}
 
function start() {
  # Carrega o modulo do kernel
  $MOD ip_tables
 
  # Limpa as regras anteriores
  stop;
 
  # Habilita redirecionamento de IP
  echo 1 > /proc/sys/net/ipv4/ip_forward
 
  # Clientes para o link1
  $IPT -t mangle -A PREROUTING -s 192.168.0.2 -i $I_LAN -j MARK --set-mark 1
  $IPT -t mangle -A PREROUTING -s 192.168.0.4 -i $I_LAN -j MARK --set-mark 1
 
  # Clientes para o link2
  $IPT -t mangle -A PREROUTING -s 192.168.0.3 -i $I_LAN -j MARK --set-mark 2
  $IPT -t mangle -A PREROUTING -s 192.168.0.5 -i $I_LAN -j MARK --set-mark 2
  $IPT -t mangle -A PREROUTING -s 192.168.0.6 -i $I_LAN -j MARK --set-mark 2
 
  # Apenas a navegacao vai para o link2. E-mail, msn e outros vao para o link1 que é a rota padrao.
  $IPT -t mangle -A PREROUTING -s 192.168.0.7 -i $I_LAN -p tcp --dport 80 -j MARK --set-mark 2
  $IPT -t mangle -A PREROUTING -s 192.168.0.7 -i $I_LAN -p tcp --dport ! 80 -j MARK --set-mark 1
 
  echo "Firewall iniciado."
}
 
case $1 in
  'start') start; exit ;;
  'stop') stop; exit ;;
  *) start; exit ;;
esac

Por fim, vou colocar os dois scripts para carregarem durante a inicialização do sistema. Há muitas maneiras de fazer isso, então vou fazer da mais preguiçosa possível porque isso varia de acordo com o administrador e distribuição utilizada:

root@gateway#: chmod +x /etc/init.d/rotas
root@gateway#: chmod +x /etc/init.d/firewall
root@gateway#: ln -s /etc/init.d/rotas /etc/rcS.d/S79rotas
root@gateway#: ln -s /etc/init.d/firewall /etc/rcS.d/S80firewall


Conclusão

Apenas com esses 2 scripts não será possível compartilhar a internet. Porém o objetivo aqui é mostrar uma breve abordagem de como fazer roteamento no Linux. Artigos, dicas e scripts para compartilhar internet existem aos milhares na internet. Com uma rápida pesquisa no google e implementando o que foi descrito aqui, é possível criar um servidor de internet em Linux muito mais estável e eficiente do que um rodando Windows.