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 vo [...]]]>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.

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 i [...]]]>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!

Parte da documentação incluí a API de classes, com os pacotes, cla [...]]]>Outra parte importante em um projeto, principalmente se está tratando de pacotes públicos e frameworks, é uma documentação completa. Mas documentar é um saco.

Parte da documentação incluí a API de classes, com os pacotes, classes, métodos e suas descrições. O padrão para documentação destes são o docblocks, ou phpdoc, que são comentários no código, sobre a classe, propriedade ou método, e possuem descrição e tags padrões para completar a documentação.

< ?php
  
  /**
   * Class Foo
   *
   * This class implements a hello speaker
   * @package hello
   */
  class Foo {
      /**
       * this is some useless var
       */
      private $bar ;
      
      /**
        * Says hello to provided name
        * @param string $name this is the name to be said
        * @return Foo
        */
      public function hello($name="world") {
          echo "Hello, ".ucfirst($name)."!";
          return $this 
      }
  }
  

Esses comentários comuns são mais fáceis de escrever durante o desenvolvimento, e acrescentam muito a documentação. O padrão permite descriçoes muito mais complexas que isso, mas na maior parte das vezes não é necessário.

Agora que esses comentários estão em seu lugar basta usar uma ferramenta para transformar o código em documentação de verdade, pronto para ir online e estar disponível para consulta.

O PhpDocumentor é extremamente fácil de usar e instalar, e gera documentações razoáveis. Ele possui bastante opções de formato de saída (html, pdf, xml...) e templates, mas vou fazer só o básico aqui.

Para instalar o PhpDocumentor você pode usar o PEAR ( se você não conhece, está perdendo muito), basta rodar o comando a seguir:

# pear install PhpDocumentor

Se tudo correr bem você pode agora transformar seu código em documentação com a linha a seguir:

$ phpdoc -t docs -o HTML:default:eathli -d src

Nesse caso a documentação será salva na pasta docs, no formato HTML usando o template earthli, através dos arquivos da pasta src.

Basta apontar seu navegador para a pasta docs e navegar na documentação agora.

Confira mais opções comentários, anotações e tudo mais no Manual do PhpDocumentor.

• Mais alguns links da série de programação funcional, e também adcionar o NoSQL a lista, banco da dados não relacionais para resolver o problema da escalabilidade.
  •  Concur.next - Uma ótima série sobre programação concorrente, com foco em Clojure. Em especial:
    • Messaging
    • Paralelism I/O
  •  Web Application with Erlang
  • Bancos de dados não relacionais e o movimento NoSQL , no blog da Caelum.
  • Mapeando o padrão relacional para o Data Store do Google, da uma ótima noção das diferenças.
  • Riak Web-shaped datastorage, um video apresentando o a tecnologia Basho, com exemplos de código, que demonstra as principais diferenças entre NoSQL e os banco de dados relacionais.

   Divarta-se. 

  ]]>http://feeds.yoomp.com/36/376046/linuxemumpendrivedebianeenlightenmente17persistenteThu, 01 Jan 1970 00:33:29 +0000http://feeds.yoomp.com/36/376046/linuxemumpendrivedebianeenlightenmente17persistenteHistória

   

  
   

   

  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
  

   

  
   

   

  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

  ]]>http://feeds.yoomp.com/36/371737/compartilhandointernetpelaredesemfionolinuxThu, 01 Jan 1970 00:33:29 +0000http://feeds.yoomp.com/36/371737/compartilhandointernetpelaredesemfionolinux
  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" [...]]]>
  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.]]>http://feeds.yoomp.com/36/369748/downgradedeversonodebianThu, 01 Jan 1970 00:33:29 +0000http://feeds.yoomp.com/36/369748/downgradedeversonodebianSabe, sou um feliz usuário de Linux. Mesmo tendo um hardware complico, isso melhorou com o tempo.

  A história deste post está [...]]]>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" :)

  ]]>