Docker: containers, isolamento e replicabilidade de ambientes de produção

Se com o Vagrant você consegue ter o ambiente de dev como parte do código fonte do projeto, como ter o mesmo para o ambiente de produção? Conheça agora o Docker!

Docker é uma abstração, que adiciona recursos e simplifica o uso, dos linux containers (LXC), que são, basicamente, uma forma de isolamento de processo e sistemas, quase como virtualização, porém mais leve e integrada ao host. Linux-only, nesse caso.

O Docker então te permite criar aplicações e “containers”, que isolam o SO base e todo a pilha de dependências de seu app (libs, servidores, etc, etc) de forma leve em espaço e performance. É o vagrant para produção, basicamente. Pense em VMs muito leves, que podem rodar em cima de outras VMs, na verdade.

Assim, você pode usar o Docker para ter diversas aplicações com ambientes diversos (apache vs unicorn vs tomcat vs whatevernot) em uma mesma maquina ou vm porém sem perder muito em recursos.

O Docker trabalha ainda com um sistema de arquivos “empilhaveis”, o aufs, que permite que os passos para configuração do seu container funcionem de forma incremental e “cacheable”, mais ou menos como “commits” do GIT. Pense em GIT para seu ambiente de produção ;-).

Atualizou libs: commit. Instalou o server: commit. Terminou uma nova versão: Tag. Da mesma forma você pode mandar o ambiente em partes para a nuvem (push) você também pode trazer apenas as atualizações (pull). Viu, git.

E como fazer, afinal:

Primeiro, o Docker é para o linux, assim em outros sistemas você vai precisar de uma maquina virtual com linux (usando, por exemplo, o vagrant :-). Instale o docker para sua distro e comece seu primeiro projeto.

Você deve escolher uma maquina base, como uma das muitas disponíveis no Docker index. Pode ser que já tenha uma 100% como você precisa, ou até os 80% chatos prontos. Em seguida o principal comando do docker:

docker run -i -t ubuntu /bin/bash

Esse comando diz: docker, rode (run), de forma interativa (-i, para terminais), em cima da imagem do ubuntu (-t ubuntu, de tag) o comando bash (/bin/bash). Outro exemplo:

docker run -t ubuntu echo hello from docker

Repare que após rodar um comando esse vai retornar um identificador, esse é o id da imagem gerada pelo comando. Você pode ver todos os containers, ativos ou não:

docker ps # containers em execução
docker ps -a # todos

Como configurar uma maquina então?

CONTAINER=$(docker run -t ubuntu apt-get update) # atualiza e salva o id do container
CONTAINER=$(docker run $CONTAINER apt-get install apache2 -y) # instala o apache e salva o id do container
docker tag $CONTAINER diogok/apache2 # identifica o ultimo comando
$RUNNING_CONT=$(docker run -d -t diogko/apache2 apache -D FOREGROUND)
docker ps
docker logs  $RUNNING_CONT

Temos vários parâmetros importantes, alguns são:

Redirecionando portas: -p host:guest direciona a porta host para o porta do guest, pode usar várias vezes. Ou -P para expor várias portas aleatoriamente (apenas portas descritas como passiveis de expor, mais disso mais tarde).

docker run -p 8080:80 -t diogok/apache2 #direciona a porta 8080 da maquina host para a 80 do apache

 Variáveis de ambiente: usando -e FOO=BAR o container vai ter essa variável disponível.

Rordar em background: -d , pois por padrão ele vai ficar no seu terminal.

Compartilhar volumes(pastas): -v /pasta1:/pasta2 compartilha a pasta  /pasta1 do host como a /pasta2 do guest (ele monta como um volume). Pode usar para vários containers ao mesmo tempo.

Isso tudo é legal, mas o grande ganho eu acho que vem com  a configuração sendo parte do projeto, usando o Dockerfile.  O formato do Dockerfile é bem simples, eis um exemplo:

FROM ubuntu:14.04 # baseado no ubuntu 14.04
RUN apt-get update # rode esse comando
RUN apt-get install apache2 -y # lembre de confirmar automáticamente, pois você não vai ter um tty
ADD index.html /var/www/index.html # copia um arquivo do projeto
EXPOSE 80 # expõe a porta 80
CMD [“apache”,”-D”,”FOREGROUND”] # esse é o comando padrão

Para construir esse Dockerfile em um container basta executar, na pasta do projeto:

docker build -t diogok/apache2 .

Então para rodar o container:

docker run -d -P -t diogok/apache2

Para ver em execução:

docker ps

Ler os logs:

docker log $container_id

E enviar pro registro online:

docker push diogok/apache2

Cada passo é atômico e fica em cache, assim se você muda um passo ele só vai refazer este e os seguintes.

Isso tudo vai ter dar um ambiente replicação para dev,homolog e prod, seja lá onde cada um for (aws, digitalocean, linode, sua máquina…).

Experimente com diferentes construções do docker e divirta-se.

Servidor Git pessoal com gitolite

Usem o Git, vale a pena. Usem o Github quando puderem, também vale muito a pena. Mas as vezes precisamos de um repositório mais privado, e não estamos afim de pagar para o github (embora vale a pena!) já que temos servidores sobrando.

Entra o gitolite, que permite fácil configuração multiusuário para um repositório Git.

Eis como proceder: Primeiro copie sua chave pública para o servidor (a mesma do github, por exemplo):

$ scp ~/.ssh/id_rsa.pub user@servidor:~/

E então faça ssh para o servidor e se torne root, para seguir os seguintes passos:

# cd
# aptitude install git
# git clone git://github.com/sitaramc/gitolite gitolite-source
# cd gitolite-source
# mkdir -p /usr/local/share/gitolite/conf /usr/local/share/gitolite/hooks
# src/gl-system-install /usr/local/bin /usr/local/share/gitolite/conf /usr/local/share/gitolite/hooks
# useradd git -d /home/git -g users -m -s /bin/bash
# su - git
$ gl-setup /home/user/id_rsa.pub

Atenção: assumi que seu usuário padrão no servidor é user, se não for troque as ocorrências. Pronto assim temos o básico pronto, agora sobre operação geral.

Você pode configurar uma interface de consulta básica na web usando o próprio git, ainda no user git faça:

$ cd repositories/testing.git
$ git instaweb -d webrick -p 8081

Agora pode acessar seu servidor na porta 8081 para navegar nos projetos. Não precisamos mais estar no servidor para os próximos passos.

Então vamos criar um novo repo e adcionar usuários, da sua maquina:

$ git clone git@servidor:gitolite-admin.git
$ cd gitolite-admin

Nessa pasta edite o arquivo conf/gitollite.conf, nessa sintaxe:

repo nome-do-repositorio
  RW+ = user1 user2 user3

Sendo user1 user2 e user3 os usuários com acesso para escrita. O repositório será criado vazio e e para liberar os usuários basta copiar as chaves publicas para a pasta “keydir”, no formato “user1.pub” e etc. Agora envie as alterações.

$ git commit -a -m 'adionado repositorio nome-do-repositorio'
$ git push

Congratz, you got git!

Terminais múltiplos com screen

Quem usa Linux no desktop pode livremente abrir mais de um terminal ou mais de uma aba no terminal, quem está acostumado com o Vim e o Emacs também pode ter múltiplas janelas dentro do editor. Mas as vezes é útil em um mesmo terminal, como numa sessão ssh, você ter mais de uma janela, ai entra o screen!

O uso do screen é bem simples, ele cria uma sessão de shell (bash, zsh, etc…) da qual você pode se “desplugar” e voltar depois, aonde você inclusive manter múltiplas sessões e janelas.

Para iniciar uma sessão usando um apelido, basta usar o comando “screen -S nome” e para reconectar a uma sessão interrompida “screen -r -S nome”.

Os comandos para manipular o screen começam com CTRL+A, você pode se desconectar de uma sessão sem encerrá-la com “CTRL+A CTRL+D”, pode salvar o histórico usando “CTRL+A SHIFT+H”, e ao encerrar a sessão tudo vai para um log.

Dentro de uma sessão você pode iniciar outro shell usando “CTRL+A CTRL+C”, ver a lista de shells usando “CTRL+A CTRL+W”, ir para o próximo shell usando “CTRL+A CTRL+A”.

Você pode ter janelas em uma sessão como no vim/emacs. Divide a janela horizontalmente usando “CTRL+A SHIFT+S”, divida a janela verticalmente usando “CTRL+A | “ (é o caractere de “pipe”, sabe?). Você alternar entre janelas usando “CTRL+A CTRL+I”, para fechar a janela usa-se “CTRL+A SHIFT+X”. Veja que uma janela começa sem shell nenhum.

O screen permite ainda que mais de um usuário se conecte a uma sessão, para permitir que sua sessão tenha mais de um usuário você pode usar “CTRL+A :multiuser on”, e adicione um usuário usando “CTRL+A :acladd user”, agora o outro usuário pode por exemplo fazer ssh para sua maquina e entrar na sua sessão usando “screen -x user/nome_da_sessao”. Para usar o multiusuário o screen deve rodar com “setuid”.

Lembre de não sair usando “ctrl+d” ou o screen vai encerrar, de agora em diante use o “ctrl+a ctrl+d” para manter a sessão rodando.

Instalando e configurando NGINX e PHP5 no Debian Lenny

História

Vou migrar de servidores para um VPS na Linode, o 360, então primeiro preciso ter certeza que tudo vai funcionar lá, para tanto preparei um máquina virtual com a mesma configuração de software que vou preparar por lá, o objetivo é rodar uma cópia de algumas instalações do Joomla, WordPress e agora um Drupal.

Como o VPS vai ser bem, digamos, compacto, fiz uma instalação básica do Debian Lenny (netinst) sem nada e parti daí. Segue agora como configurar o stack moderninho 2.0. (Uma solução até de preguiçoso, por usar o Fastcgi ao invés do FPM, mas não quero compilar o PHP agora, deixa para o próximo release).

NGINX

Comçando pelo NGINX, o ideal é pegar o código-fonte e compilar, seguem comandos:

# aptitude install build-essential libssl-dev libpcre3-dev -y
# wget http://nginx.org/download/nginx-0.8.33.tar.gz
# tar -zxvf nginx-0.8.33.tar.gz
# cd nginx-0.8.33
# ./configure --sbin-path=/usr/local/sbin --with-http_ssl_module \
--without-mail_pop3_module --without-mail_imap_module \
--without-mail_smtp_module --with-http_stub_status_module
# make
# make install
# ln -s /usr/local/nginx/conf /etc/nginx
# cd ..
# wget htt://www.manifesto.blog.br/extras/nginx
# mv nginx /etc/init.d/nginx
# chmod +x /etc/init.d/nginx
# update-rc.d nginx defaults

Vamos acertar ainda os logs do nginx, editando o arquivo /etc/logrotate.d/nginx:

/var/log/nginx/*.log {
daily
missingok
rotate 7
compress
delaycompress
notifempty
create 640 root adm
sharedscripts
postrotate
[ ! -f /var/run/nginx.pid ] || kill -USR1 `cat /var/run/nginx.pid`
endscript
}

E ainda a configuração do Nginx:

# mkdir /var/log/nginx
# mkdir /var/www

E o conteúdo do arquivo /etc/nginx/nginx.conf :

user  www-data;
worker_processes 4;
error_log /var/log/nginx/error.log;
events {
worker_connections 1024;
}
http {
include mime.types;
default_type application/octet-stream;
access_log /var/log/nginx/access.log;
sendfile on;
keepalive_timeout 60;
tcp_nodelay on;
gzip on;
gzip_http_version 1.0;
gzip_comp_level 2;
gzip_proxied any;
gzip_min_length 1100;
gzip_buffers 16 8k;
gzip_types text/plain text/css application/x-javascript text/xml \
application/xml application/xml+rss text/javascript \
image/gif image/jpeg image/png;
gzip_disable "MSIE [1-6].(?!.*SV1)";
gzip_vary on;
server {
root /var/www/;
server_name localhost;
listen 80;
location / {
index index.php index.html index.htm;
}
location ~ \.php$ {
fastcgi_pass 127.0.0.1:9000;
fastcgi_index index.php;
include fastcgi_params;
fastcgi_param SCRIPT_FILENAME /var/www/$fastcgi_script_name;
fastcgi_param SERVER_NAME $http_host;
fastcgi_ignore_client_abort on;
}
}
}

Pronto, agora o nginx está pronto, basta criar o arquivo /etc/init.d/nginx para controlar o serviço, com o seguinte conteúdo:

! /bin/sh
PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin:/usr/local
DAEMON=/usr/local/sbin/nginx
NAME=nginx
DESC=nginx
test -x $DAEMON || exit 0
if [ -f /etc/default/nginx ] ; then
. /etc/default/nginx
fi
set -e
case "$1" in
start)
echo -n "Starting $DESC: "
start-stop-daemon --start --quiet --pidfile /var/run/$NAME.pid \
--exec $DAEMON -- $DAEMON_OPTS || true
echo "$NAME."
;;
stop)
echo -n "Stopping $DESC: "
start-stop-daemon --stop --quiet --pidfile /var/run/$NAME.pid \
--exec $DAEMON || true
echo "$NAME."
;;
restart|force-reload)
echo -n "Restarting $DESC: "
start-stop-daemon --stop --quiet --pidfile \
/var/run/$NAME.pid --exec $DAEMON || true
sleep 1
start-stop-daemon --start --quiet --pidfile \
/var/run/$NAME.pid --exec $DAEMON -- $DAEMON_OPTS || true
echo "$NAME."
;;
reload)
echo -n "Reloading $DESC configuration: "
start-stop-daemon --stop --signal HUP --quiet --pidfile /var/run/$NAME.pid \
--exec $DAEMON || true
echo "$NAME."
;;
configtest)
echo -n "Testing $DESC configuration: "
if nginx -t > /dev/null 2>&1
then
echo "$NAME."
else
exit $?
fi
;;
*)
echo "Usage: $NAME {start|stop|restart|reload|force-reload|configtest}" >&2
exit 1
;;
esac
exit 0

E então o ativamos para iniciar automáticamente:

# chmod +x /etc/init.d/nginx
# update-rc.d nginx defaults
# /etc/init.d/nginx start

PHP

Seguimos com a instalação do PHP5, APC e seus principais pacotes, usando os do dotdeb.org para termos versões mais recente, então primeiro adcione o dotdeb aos seus repositórios, adcionando as seguintes linhas ao /etc/apt/sources.list:

deb http://dotdeb.mirror.somersettechsolutions.co.uk/ stable all
deb-src http://dotdeb.mirror.somersettechsolutions.co.uk/ stable all

E agora instalamos o php5 sem o apache, e com os principais modulos:

# aptitude update 
# aptitude install php5 php5-cli php5-cgi php5-curl php5-gd php5-common \
php5-memcache php5-mysql php5-pgsql php5-sqlite php5-apc

Configuramos e agora criamos o script para controlar o serviço do fastcgi do php, em /etc/init.d/php-fastcgi :

#!/bin/bash
BIND=127.0.0.1:9000
USER=www-data
PHP_FCGI_CHILDREN=15
PHP_FCGI_MAX_REQUESTS=1000
PHP_CGI=/usr/bin/php-cgi
PHP_CGI_NAME=`basename $PHP_CGI`
PHP_CGI_ARGS="- USER=$USER PATH=/usr/bin \
PHP_FCGI_CHILDREN=$PHP_FCGI_CHILDREN \
PHP_FCGI_MAX_REQUESTS=$PHP_FCGI_MAX_REQUESTS \
$PHP_CGI -b $BIND"
RETVAL=0
start() {
echo -n "Starting PHP FastCGI: "
start-stop-daemon --quiet --start --background --chuid "$USER" \
--exec /usr/bin/env -- $PHP_CGI_ARGS
RETVAL=$?
echo "$PHP_CGI_NAME."
}
stop() {
echo -n "Stopping PHP FastCGI: "
killall -q -w -u $USER $PHP_CGI
RETVAL=$?
echo "$PHP_CGI_NAME."
}

case "$1" in
start)
start
;;
stop)
stop
;;
restart)
stop
start
;;
*)
echo "Usage: php-fastcgi {start|stop|restart}"
exit 1
;;
esac
exit $RETVAL

E então o ativamos para iniciar automáticamente:

# chmod +x /etc/init.d/php-fastcgi
# update-rc.d php-fastcgi defaults

Agora com o PHP configurado, terminamos criando uma página e acessando o nosso servidor local, crie em /var/www/index.php como “< ? phpinfo() ? >” e acesse o ip do servidor para ver se funcionou… ou não.

Rede de máquinas virtuais com KVM e VDE

História

Como parte da migração de servidores que estou fazendo, montei uma pequena estrutura virtual para testes… na verdade levantei uma maquina virtual com o KVM com configuração semelhante a que vou usar no VPS.

O objetivo inicial é levantar a máquina com acesso SSH, para poder configurar o servidor (nginx, php e mysql), então segue o passo-a-passo para rede no KVM. O básico do KVM/QEmu pode-se conferir nesse mini tutorial do qemu e nesse micro guia do KVM.

Preparando a VM

Então comece criando o HD, baixando a ISO de sua distro favorita, que é claro que é o Debian, e siga a instalação padrão. Para manter mais parecido com o VPS mantive tudo em uma partição só e deixei um espacinho para o swap.

# qemu-img -f qcow2 debian.qcow 10G
# kvm -monitor stdio -smp 2 -m 360 -localtime -hda debian5.qcow -cdrom debian-lenny.iso
-boot d -net nic,vlan=0 -net user,vlan=0 -name "debian-lenny"

Esses comandos só criam um HD de 10GB e iniciam o KVM com dois processadores virtuais, 360MB de ram, usando as imagens devidas e rede local padrão. Basta seguir a instalação padrão, depois para carregar a VM use o mesmo comando mas sem a imagem do cd e com boot do hda:

# kvm -monitor stdio -smp 2 -m 360 -localtime -hda debian5.qcow -boot c -net nic,vlan=0
-net user,vlan=0 -name "debian-lenny"

Rede do KVM com VDE

Agora parte importante para ter uma rede lega é usar o VDE (virtual distributed ethernet) para configurar a rede do KVM, assim podendo acessar ele como um servidor normal, e ao contrário, assim como em outras VMS.

Primeiro instale o instale o VDE, para a rede distribuída, e o dnsmasq, para servir o DHCP para os guests, no host:

# aptitude install vde2 dnsmasq 
# modprobe tun
# adduser seu_usuario vde2-net
$ newgrp vde2-net

E configure suas interfaces de rede para o vde2, em /etc/network/interfaces adicione:

auto tap0
iface tap0 inet static
address 10.0.2.1
netmask 255.255.255.0
network 10.0.2.0
broadcast 10.0.2.255
pre-up tunctl -u diogo -t tap0
pre-up /etc/init.d/dnsmasq restart
up iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
up echo 1 > /proc/sys/net/ipv4/ip_forward
vde2-switch -

Troque “diogo” pelo seu usuário que vai iniciar a VM, e as faixas de ip se precisar.

Configure por final o DNSMASQ, ao final do /etc/dnsmasq.conf adcione:

user=nobody 
domain=qemu.lan
interface=tap0
dhcp-range=10.0.2.1,10.0.2.253,255.255.255.0,10.0.2.255,8h

Ainda para cada guest que planeje ter pode definir um ip estatico pelo seu mac address, adcionando um linha para cada conforme o exemplo:

dhcp-host=11:22:33:44:55:66,10.0.2.5  

E recarregue sua rede

# /etc/init.d/networking restart  

Agora com o host configurado é a hora do guest, lance sua maquina virtual com o comando final:

kvm -monitor stdio -smp 2 -m 360 -localtime -hda debian5.qcow -boot c
-net nic,macaddr=1a:2b:3c:4d:5e:6f,model=rtl8139,vlan=0
-net vde,vlan=0,sock=/var/run/vde2/tap0.ctl
-name "debian-lenny"

Agora na VM configure a rede:

# ifconfig eth0 up 
# dhclient eth0
# ping 10.0.2.1
# ifconfig eth0 gateway 10.0.2.1
# ifconfig eth0

Presto! O ultimo comando vai mostrar o ip que o guest recebeu (se reservou o ip estático deve ser o 10.0.2.5), o ip do host é 10.0.2.1.

Agora para deixar melhor instale o servidor SSH para acessar a maquina da forma como é devido:

# aptitude install openssh-server  

Agora você pode entrar na maquina usando o ssh como root na primeira vez para criar seu usuário, e depois iniciar a vm com a opção “–nographic” e passar a entrar apenas com o SSH.

Divirta-se!

Linux em um pendrive: Debian e Enlightenment (E17) persistente.

História

 

Enlightenment E17

 

 

Além de já ter usado o Linux em um pendrive com o DSL, que é uma das distros que melhor se adaptam ao estilo, é fácil hoje instalar outras distros semelhantes, como o Slax, o SliTaz (muito bom) e o TinyCore(abandonei o DSL por este), com seus 10MBs.

A boa noticia é que hoje é bem mais fácil rodar um linux a partir de um pendrive, temos o projeto pendrive linux, com vários distros preparadas para tal, e o unetbootin para configurar e “bootar” qualquer ISO a partir de um pendrive.

Parti então para as distros completas: Ubuntu e Debian. O Ubuntu eu não gosto, acho um desktop muito fraco. O Debian iniciei com o projeto do Debian Live, oficial, mas este se baseia na versão estável, então está muito antigo nos pacotes. Mas como o debian é o debian era possível reconstruir o Debian live em qualquer versão, com o Debian Live Helper, mas também dava muito trabalho e demorava muito.

Foi ai que pensei em ficar com as minimalistas, entre o TinyCore e o SliTaz. Não fiquei com o SliTaz por que me parecia pacotes muito antigos, em especial o kernel, já o TinyCore eu fiquei com preguiça mesmo, afinal ainda seria muito parecido com o DSL.

Ai eu esbarrei no Elive. Na verdade já paquerava o Enlightenment tem um bom tempo, mas E16 não é tão interessante, e o E17 envolvia muitas gambiarras, e as versão “fáceis” de instalar não estavam muito legais.

Uma boa opção me pareceu usar o Elive, baseado no debian, que já vem configurado com tudo de bom e melhor do Enlightenment de desenvolvimento, por isso resolvi testa-lo.

Como fazer

 

Unetbootin com E17 ELIve

 

 

Primeiro instale o Unetbootin, que está presente na maioria das distribuições modernas:

# aptitude install unetbootin

Executando-o como root, o unetbootin já existem diversas distros prontas, ele mesmo se encarrega de baixar a ISO configurar o pendrive e torná-lo bootável com o syslinux.

Você pode também fazer o Download da ISO do ELive você mesmo(eu fiz assim), e seleciona-la no unetbootin, e então é só seguir e iniciar o processo, não tem mistério nenhum.

O passo seguinte, após o unetbootin dizer que terminou, é configurar um arquivo para que o Elive salve as alterações. Você precisa primeiro criar um arquivo para ser a “partição” da persistencia:

# dd if=/dev/zero of=elive-rw bs=1M count=1024

O valor do count diz o tamanho do arquivo em megabytes, veja quanto resta no pendrive e quanto você quer usar, no exemplo vai ter 1GB (mais ou menos).

Em seguida formate-o como ext3, apenas confirme:

# mkfs.ext3 elive-rw

Agora pode copiar o arquivo elive-rw para a raiz do pendrive, e editar o arquivo de boot “syslinux.cfg” nessa mesma raiz. No linha append da entrada padrão adcione “persistent=elive-rw” e salve.

Basta desmontar o pendrive e rebootar o computador com a BIOS configurada para carregar apartir do pendrive e curtir no ambiente. Trate-o como um netbook, pois o espaço é pouco.

Um detalhe importante, que me atrapalhou a testar o elive antes, é que ele não roda no Qemu(e KVM) por algum motivo, mas funciona no VirtualBox e VMWare, eu acredito.

Agora posso carregar meu lindo ambiente de programação para todo canto, combinado com controle de versão, e impressionar todo mundo com como o linux pode ser bonito :D

Compartilhando internet pela rede sem fio no linux

Tutorial de como configurar sua placa de rede sem fio para compartilhar a internet, no linux.

Aqui vou explicar como configurar seu computador/notebook como hotspot wifi, para compartilhar a internet na rede sem fio, com o mínimo de “segurança” WEP apenas.

O Primeiro passo é saber qual a interface que chega a conexão com a internet, no geral se é internet discada, 3G ou se usa o pppoe a interface é ppp0, se a internet chega roteada pela rede é a mesma da interface de rede, eth0 ou outro. Aqui uso internet móvel 3G, então conecta em ppp0.

Temos então que mascarar o encaminhamento de pacotes dessa interface por um nat, usando as regras do iptables. Carregue o módulo de nat, definir a regra e ativar o encaminhamento no sistema, com os seguintes comandos:

# modprobe iptable_nat
# iptables -t nat -A POSTROUTING -o ppp0 -j MASQUERADE
# echo 1 > /proc/sys/net/ipv4/ip_forward

O próximo passo é configurar a rede wifi, com os seguintes comandos:

# ifconfig wlan0 down
# ifconfig wlan0 192.168.0.1 netmask 255.255.255.0 broadcast 192.168.0.255
# ifconfig wlan0 up

Em seguida definimos as caracteristicas da rede sem fio, definindo o nome, o modo ad-hoc, a chave de encriptação e para apenas aceitar com encriptação, os comandos:
# iwconfig wlan0 essid “acer”
# iwconfig wlan0 mode ad-hoc
# iwconfig wlan0 key ‘s:diogo’
# iwconfig wlan0 key restricted

Para os clientes receberem as configurações devidas você precisará agir como cliente dhcp (ou configurar manualmente a rede nos clientes), você pode instalar o servidor com o seguinte comando:

# aptitude install dhcp3-server

Para configurar o servidor, edite o arquivo /etc/dhcp3/dhcpd.conf, conforme:

ddns-update-style ad-hoc;
option domain-name “home.org”;
option domain-name-servers 208.67.222.222, 208.67.220.220;
default-lease-time 600;
max-lease-time 7200;
authoritative;
log-facility local7;
subnet 192.168.0.0 netmask 255.255.255.0 {
range 192.168.0.10 192.168.0.254;
option routers 192.168.0.1;
option broadcast-address 192.168.0.255;
}

Com o dhcp configurado, basta ativa-lo na interface da rede sem fio.

# dhcp3d wlan0

Agora os clientes podem se conctar a sua rede e navegar na sua internet. Você pode tentar configurar outro meio mais seguro que WEP, mas eu não sei ainda :P e definir regras no dhcp e iptables limitando os MACs e IPs, mas isso fica para próxima.

Downgrade de versão no Debian

Sabe, sou um feliz usuário de Linux. Mesmo tendo um hardware complico, isso melhorou com o tempo.

A história deste post está no primeiro link.

Vou explicar aqui o simples passo-a-passo para fazer o downgrade de versão do debian, sem reinstalar o sistema ou fazer algo mais complicado que o apt-get costumeiro. Se você usa o debian, sabe que pode fazer isso com a consciencia limpa.

O debian tem um sistema de “pinning” para o apt, que permite, entre outras coisas, definir preferencias de versões de pacotes, e vamos usar isso para fazer o downgrade, já que por padrão o apt escolhe os pacotes mais novos.

Primeiro devemos acertar os repositórios desejados, eu estou voltando do unstable(Sid) para o testing(Squeeze), então meu /etc/apt/sources.list ficou assim:

# deb ftp://ftp.br.debian.org/debian/ unstable main contrib non-free 
# deb ftp://ftp.br.debian.org/debian-multimedia/ unstable main

#deb ftp://security.debian.org/ testing/updates main contrib non-free
deb ftp://ftp.br.debian.org/debian/ testing main contrib non-free
deb ftp://ftp.br.debian.org/debian-multimedia/ testing main

#deb http://apt.wicd.net/ sid extras

Eu apenas comentei os “unstable” e adcionei as linhas do “testing”.

Agora vamos configurar o tal “pin”, para editar suas preferências do apt e dpkg você pode editar o arquivo /etc/apt/preferences, ou criar um arquivo em /etc/apt/preferences.d/ para cada configuração, no caso para o downgrade para o testing, fiz um assim:

X-comment: Force downgrade to testing.
Package: *
Pin: release a=testing
Pin-Priority: 1100

Veja que facilmente podemos criar outros, para escolher versões especificas de cada pacote, bastando acerta o “pin-priority” para isso.

Após configurado, basta atualizas a lista de pacotes e instala-los:

# dselect update
# aptitude dist-upgrade

E Pronto, seu sistema está “atualizado”, é só reiniciar o X, se não mudou o Kernel nem precisa reiniciar. Se você acha que mudou muitos módulos do kernel em uso pode fazer um “depmod” e depois um “modprobe” nos módulos desejados.

Seja feliz com seu sistema “novo” :)

Game Over: Linux ganhou no Acer 5050!

Eu tenho um hardware complicado. Meu notebook é um acer 5050 e sempre deu trabalho Linux, mas firme e forte segui com minha saga de suporta-lo 100% no pinguim.

E a pouco tempo essa saga chegou no fim, e é Game Over, com vitória para o usuário, vitória do pinguim!

Basta um kernel recente e o Linux funciona no Acer 5050. Sem truques, sem mágica, sem compilações complicadas com parametros sinistros, agora quando eu quiser atualizar o  kernel, o farei sem medo.

Muito obrigado ao desenvolvedores do Kernel Linux. Tux #win. 

Do VirtualBox ao KVM, e como usar o KVM

Esse é um artigo que achava que tinha escrito uns anos atrás, mas parece que não. Enfim, história primeiro:

Quando comecei nesse “negócio” de usar Linux e SL, uma das primeiras maravilhas que me deparei foi o Qemu, e assim conheci o maravilhoso mundo da virtualização. Fato que o Qemu não é um virtualizador, mas sim um emulador. E era lento, por ser emulador, mesmo com a evolução do kqemu. Mas era poderoso. Inclusive o Android usa o Qemu para seu emulador do SDK. Mas com a necessidade, depois de um tempo migrei para um virtualizador, e o escolhido foi o ótimo VirtualBox. Por que sim. 

Estava muito feliz com o VBox, mas sempre fiquei de olho o KVM. O Kvm é parte do kernel do linux(logo opensource), que permite virtualizar sistemas através de instrução especificas existentes nos processadores modernos(ou nem tão modernos). Enfim, é, assim como o qemu, uma forma extremamente simples de ter um SO rodando como se fosse “mais um” processo do sistema. Muito simples mesmo. E, como bônus, o kvm se baseia no qemu modificado e pode usar as ótimas ferramentas do mesmo.

Eu ia mudar antes, mas como o VBox estava indo tão bem acabei enrolando, mas desde o aniversário do meu notebook, onde ganhou mais ram e um kernel recompilado o VBox perdeu desempenho. Devo ter sido eu a fazer algo errado, mas já queria migrar mesmo o passei ao KVM.

 

Desktops Virtuais

 

 

A performance esta ótima, basicamente tenho VMs do Win XP,  OpenSolaris (para aprender) e um Debian de standby. Estou feliz com isso, qualquer dia entra o Win 7 aí na história… ou não.

Acabou a  história, vamos ao que interessa. Para migrar as imagens do VBox para o formato compacto qcow do qemu, usa primeiro as ferramentas do próprio VBox, na pasta do Harddrive, geralmente ~/.VirtualBox/HardDrivers:

$  VBoxManager clonehd -format RAW old.vdi nova.img 

Depois convertemos a imagem bruta para o formato qcow2:

$ qmeu-img convert -f raw nova.img -O qcow nova.qcow

“Tcharã!” está pronta a nova imagem. Lendo assim parace fácil, mas imagens grandes demoram vários minutos para cada passo.

Uma pegadinha é que instalações do Windows podem precisar serem reparadas. Vejam bem, não precisa reinstalar. Coloque o CD, boot pelo cd, comece como se fosse instalar. Ao chegar na escolha de partições, pressione “R” sobre a partição do windows e continue. 

Usa o kvm é ridiculamente fácil, primeiro certifique-se de ter te-lo instalado e levante o modulo para sua plataforma:

# aptitude install kvm

# modprobe kvm-amd

Ou “kvm-intel”. Garanta ainda que seu usuário possui permissões no dispositivo /dev/kvm adicionando-o ao groupo kvm:

# useradd username kvm

# chown kvm.kvm /dev/kvm 

A Sintaxe básica é a mesma do qemu, veja um exemplo:

$ kvm -hda nova.qcow -cdrom /dev/cdrom -usb -m 1024 -smp 2  -sd card.img -boot c

Isso diz que o kvm vai ter , na ordem, a imagem nova.qcow como hda (primeiro disco), cdrom no disposivo de sistema, usb ativado, 1G de ram, 2 núcleos, card.img com sdcard e vai bootar no hda (c). Muitas outras opções estão disponiveis no “kvm -help” ou “man kvm”.

Você pode ainda ser mais fresco e usar o virt-manager, e ter uma interface gráfica para administrar suas VMs. Esta disponível no seu repositório linux favorito, e não esqueça o python-libvirt (ou python2.5-libvirt). Ou o Qemulator, Ou o AQemu.

Enfim, o KVM suporta live migrations, vários SOs e esta ai evoluindo bem. Confira um ótimo conteúdo em http://www.linux-kvm.org/

Seja mais feliz virtualizando.