sábado, 17 de julho de 2010

Testes de requisito

Para começar a explicar em detalhes os principais tipos de testes existentes vou atacar a base: testes de requisitos.

Por que testes de requisitos?

Em uma frase: porque é onde os projetos nascem.

Qualquer software, desde uma simples calculadora até uma aplicação de grande porte passa de alguma forma por esta fase, mesmo que informalmente.

Definir requisitos é descrever um pedido, uma idéia, aquilo que nós (ou geralmente o nosso cliente) quer que o programa faça.

Fica aqui a primeira nota importante para qualquer projeto, de qualquer tamanho, e que tem valor não apenas do ponto de vista técnico, quanto do ponto de vista administrativo e financeiro: escreva os requisitos.

Essa parte, assim como quase sempre a documentação é inexistente em projetos pequenos. E não é por menos que é a maior fonte de dor de cabeça para pequenos empresários, programadores, testers e pro próprio cliente.

Creio que todo leitor aqui já deve ter passado pela situação onde o cliente pede algo, você cria, e depois de terminado, o cliente diz que queria que algumas funcionalidades fossem diferentes, e quase sempre são funcionalidades que mexem com a base do programa, do modelo adotado para a solução. Coisa boba que se explicada de início, pouparia muito tempo, retrabalho e desgaste por todas as partes mais tarde.

OK, requisitos são importantes. Mas como testá-los?
Em pequenos e médios projetos, geralmente a documentação sobre especificações técnicas é inexistente, ou feita apenas através de emails. O primeiro passo é escrever os requisitos. Não é necessário muito, mas tem que ser algo que dê bases aos outros times (design, implementação e teste).

Exemplo. Um cliente pede uma loja virtual, onde ele vai vender vários produtos e, na interface, os consumidores poderão procurar/navegar pelas diversas categorias. Ele quer poder incluir e excluir produtos na lista, tem um sistema de venda, com acompanhamento de pedidos, e um sistema de relatórios sobre as vendas e sobre o estoque.

Bastante trabalho pela frente, mas poucas linhas para descrever. Faltou alguma coisa? Muitas. Mas para este exemplo, vou pegar um ponto que certamente poderia ser um foco de divergência: as categorias.

Perguntas básicas a se fazer sobre o "simples" sistema de categorias.
  1. O cliente irá usar apenas categorias pré-definidas, ou quer poder gerenciar as categorias (criar novas, remover existentes...)?
  2. Essas categorias poderão ter subcategorias?
  3. Um produto pode pertencer a mais de uma categoria ou subcategoria?

Aí estão perguntas cujas respostas podem significar desde uma nova tabela e formulários no banco de dados, até uma reestruturação de boa parte do banco de dados e da aplicação.

Outro exemplo. O cliente pede um sistema onde um usuário poderá se cadastrar.
Simples, não? Não. Você não pode supor que se trata de uma newsletter, nem supor que se trata de um formulário altamente complexo. O certo é esclarecer.

  1. Cadastrar o que? email apenas? ou endereço, telefone...?
  2. Quais são os campos obrigatórios e quais são opcionais?
  3. Clientes de onde? de um estado específico? de uma cidade específica? um continente? do mundo?

Faça uma lista de perguntas. Se possível, ajude seu cliente sugerindo prováveis campos e indicando quais você acha que seriam os obrigatórios, mas deixe que o cliente decida e diga o que é que ele realmente quer, afinal o negócio é dele.

Resumindo

Sempre que você chegar numa situação onde para testar ou criar você tenha que supor ou adivinhar o que o cliente quer, pergunte, esclareça. Vale a pena o investimento, porque é necessário pouco tempo para obter respostas que podem significar uma diferença enorme em termos de prazo e preço a todos os lados envolvidos.

Abraços e até a próxima.
----------- keepReading

segunda-feira, 12 de julho de 2010

Testes de Software - Tipos de teste

Falar em testes de software pode ser um tanto subjetivo. Para evitar essa abertura de interpretação, até mesmo porque é um serviço que exige rigor, vamos ver os tipos de teste. Quais são, quais as finalidades e como avaliá-los no processo.

Existem vários tipos de teste, cada um para avaliar uma determinada característica da aplicação.

Testes funcionais - estes são os testes que servem para determinar se a aplicação faz o que se propõe a fazer. Comecei falando deste tipo, porque certamente é o primeiro teste que se passa na cabeça dos programadores.

Como exemplo simples para teste de um sistema de login:
UserPassResultado esperado
válidoválidoLogin bem sucedido
inválidoválidoMensagem de erro
válidoinválidoMensagem de erro

Este é o exemplo mais básico, só para ilustrar. Como veremos adiante, existem outros cenários e casos de uso que aumentam a complexidade da bateria de testes.

Testes de performance - nem sempre este tipo de teste se faz necessário. Eles avaliam o tempo de resposta, ou quantidade de memória usada, ou algum outro parâmetro crítico em função da variação da quantidade de inputs ou requisições. São os famosos benchmarkings e variantes. Veremos mais detalhes num post futuro.

Testes de segurança - Há muito o que se discutir aqui. O que é hacking, o que não é, quais as técnicas, quais as medidas de proteção, como considerar algo como seguro... Responder essas questões básicas que servem de base para os testes é que são o maior desafio, e motivo de discussão.

Teste unitário - quando se procura alguma ferramenta ou alguma informação sobre testes em alguma linguagem específica, isto é geralmente o que se encontra. Testes unitários são testes realizados para cobrir um módulo isolado, uma função, ou um conjunto de funções intimamente relacionadas. São similares aos testes funcionais, só que aqueles podem ser extensos, enquanto estes são direcionados e geralmente curtos. Por serem testes simples, rápidos, e com foco na parte e não no todo, eles são muito importantes, e boa parte dos erros são encontrados através deles.

Teste de requisito - pode soar estranho para quem nunca trabalhou com QA antes, mas aqui está o teste mais fundamental de todos, seja qual for o modelo de desenvolvimento ou aplicação desenvolvida. Testar os requisitos é EXTREMAMENTE IMPORTANTE porque:
1. Evita interpretações dúbias tanto da parte dos desenvolvedores, quanto de quem testa;
2. Decorrente da afirmação acima, facilita o trabalho (e diminui o retrabalho) dos arquitetos, designers e implementadores;
3. Apesar de aumentar o tempo necessário inicial dos trabalhos, o ciclo completo de desenvolvimento é reduzido, reduzindo custos do projeto;
4. Evita a criação de testes desnecessários, ou com expectativa falsa, não só reduzindo o trabalho de testes como também aumentando a produtividade (erros encontrados x numero de testes) em quality assurance.

Revisão de código - tipo de teste feito pelos desenvolvedores. É precedente ao Unit Test, e se faz com a inspeção criteriosa do código. Vale a ressalva que nas metodologias ágeis, onde se programa em dupla, esse tipo de teste é mais comumente feita. Um faz um trecho do código, e o outro revisa.

Teste de cobertura de código - Primo do Unit Test, este tipo de teste visa garantir que todos os possíveis caminhos dentro do código sejam acessados. A principal diferença entre este e o Unit Test, é que este é mais abrangente.

Teste de atomicidade - pouco conhecido, este tipo de teste visa garantir a tipagem de dados. Uma variante deste tipo de teste mais difundida é a Fault Injection Test, onde se introduzem inputs não esperados, geralmente usando caracteres de controle mesclados os inputs normais, e observando o comportamento do sistema.

Teste de integração - testa a integração entre módulos e componentes para checar sua compatibilidade e eventual quebra no fluxo do processo.

Teste de recuperação de falha - tipo de teste feito geralmente em aplicações que funcionam como servidores (servidores HTTP, servidores de bancos de dados), sistemas operacionais e sistemas de arquivos. Neste tipo de teste, o sistema é forçado a falhar de alguma forma, e depois se verifica como ele se recupera de um erro grave, se há perdas de ddos e afins.

Testes de regressão - em softwares que são desenvolvidos em ciclos, esta é uma bateria que é feita ao finaldo ciclo funcional, e onde as funcionalidades anteriores que não foram modificadas são postas à prova, afim de garantir que nenhuma funcionalidade antiga foi alterada.

Teste de instalação - para software que serão distribuídos, este é o teste onde se verifica se a instalação será bem sucedida nas plataformas-alvo.

Testes estáticos - são os testes onde se observam o estado do sistema. Inspeções de códigos, e estabilidade inicial pertencem à esta classe de testes.

Testes dinâmicos - são feitos colocando o sistema para executar, com entradas, e então parando a execução e observando o estado das variáveis. Quem usa o Firebug para depurar javascript, ou o gdb para depurar um código em C++ sabe do que se trata.

Testes manuais - são feitos um a um, com um usuário criando dados e fazendo sua inserção no sistema.

Testes automatizados - é quando se usa algum tipo de ferramenta para auxiliar na execução de testes, agilizando o processo. Testes de performance, segurança, carga, estabilidade e regressão são alguns tipos de teste onde vale a pena usar tecnologias que automatizem o processo de teste. Vale notar que o que garante a qualidade deste tipo de teste (onde milhares, às vezes milhões de testes são rodados de uma única vez) é a massa de dados utilizada no input. Se ela for inválida ou inconsistente, a bateria de nada vale.

Fora do cunho técnico e relacionado com a criação de códigos propriamente ditos, ainda temos outros tipos de teste que podem ser feitos.

Testes de acessibilidade - verifica se o programa é acessível sem o uso de mouse, de tecnologias opcionais (addons), avalia a disposição dos elementos, contraste de cores, tamanho e legibilidade de fontes...

Testes de usabilidade - Verifica se o software é de fácil utilização. É um tipo de teste que quando bem feito e bem trabalhado, pode significar a diferença entre o sucesso e o fracasso de uma aplicação. Card sorting, eye tracking, mouse tracking e simple task são alguns dos tipos de teste de usabilidade.

Testes de internacionalização - verifica se a aplicação se comporta de forma adequada em termos de linguagens e seus padrões (padrão para o formato da data, da hora, da moeda, separador decimal, direção do texto).

Teste de documentação - no caso de produtos voltados à indústria, geralmente se faz o teste da documentação afim de avaliar a qualidade em termos de utilidade da mesma (o usuário consegue as instruções necessárias para efetuar alguma tarefa na documentação?). Alguns sites fazem o teste de suas FAQs.

Se você nunca leu nada antes a respeito sobre Quality Assurance deve ter se assustado com a quantidade de tópicos que temos dentro da área. Nos posts seguintes, vou procurar explicar o que é e como se faz cada tipo de teste, mas lembre-se que assim como segurança, qualidade é algo subjetivo, e devem ser considerados quais são os aspectos mais importantes para dimensionar corretamente o tempo e a verba empregadas nisso.

Se você vai fazer um site com estimativa de visitação máxima de 15 usuários logados simultaneamente, provavelmente não precisa de um ciclo de performance, ao passo que se você está desenvolvendo um software de CAD/CAE/CAM ou modelagem 3D com ray tracer, análises de performance serão tão importantes quanto testes funcionais.

Bom pessoal, é isso. Até a próxima.
----------- keepReading

Qualidade de Software

Na China antiga havia uma família de curandeiros, um dos quais era conhecido em toda a terra e trabalhava como médico de um grande senhor. O médico foi perguntado sobre quem de sua família era o curandeiro mais habilidoso. Ele respondeu:
"Eu atendo os doentes terminais com tratamentos dramáticos, e de vez em quando alguém é curado e meu nome sai entre os senhores."
"Meu irmão mais velho que eu cura a doença quando ela começa a criar raízes, e suas habilidades são conhecidos entre os camponeses locais e vizinhos."
"Meu irmão mais velho é capaz de sentir o espírito de doença e erradicá-la antes que ele tome forma. Seu nome é desconhecido fora de nossa casa."

Com esta parábola chinesa, abro este artigo para falar sobre qualidade de software e sua importância.

No últimos 2 anos e 3 meses, minha principal função foi trabalhar com Software Quality Assurance (Controle de Qualidade Software). Uma área vasta e que eu praticamente desconhecia antes. Obviamente aprendi muita coisa, e talvez a principal delas tenha sido ser um desenvolvedor melhor, mais criterioso.

Antes de trabalhar nessa área, eu era basicamente um desenvolvedor web, com o básico das apostilas da que se encontram facilmente na internet, e uma ou outra experiência agregada através dos projetos no tocante javascript (fiz algumas coisas interessantes e aprendi na marra a lidar com o DOM).

Sou inegavelmente um perfeccionista e autodidata. Sempre fui ligado nos aspectos de segurança, performance, standards compliance, acessibilidade, SEO, entre tantos outros, ainda que de forma amadora, sendo procurando artigos, benchmarkings, novas técnicas e tentando aprender a forma certa - ou a melhor forma entre as certas - de se fazer as coisas.

Admito que eu tinha uma visão muito estreita do que é Quality Assurance, afinal eu já programava, raramente alguma coisa que era feita por mim apresentava algum bug depois de entregue (claro que rolava aquele teste básico pra ver se tudo estava em ordem antes), e as coisas que eu fazia funcionavam. Não entendia a necessidade de testar algo que já era funcional.

Eu achava que ser um tester era algo como um passo para trás na carreira. Ledo engano. Ser um bom tester, exige que você seja antes de tudo, um bom programador (ou tenha uma idéia realmente boa de como as coisas funcionam por baixo dos panos), afinal, você vai submeter o trabalho de um programador à uma bateria de testes diversos, afim de encontrar falhas.

Para ilustrar, não raro uma coisa me acontecia - e creio que todo programador passou ou passa por isso vez ou outra: você cria o programa, faz alguns testes básicos, vê que funciona, olha novamente e código e se sente orgulhoso do trabalho que fez e entrega. Dias depois - ou horas depois - é comunicado de que encontraram uma falha, geralmente é o cliente que encontra, e é algo simples, mas que não foi testado. Você abre o código, e depois de alguns minutos - às vezes horas - procurando, acaba encontrando um erro bobo num if da vida. Você havia lido e relido várias vezes o if, e nem imaginava que o erro estaria ali, porque numa leitura à primeira vista, tudo parecia em perfeita ordem.

Bom, pretendo dar início neste post a uma série de tutoriais sobre metodologias e técnicas sobre QA. Mas nada técnico por enquanto. Este post é apenas uma introdução.

Mas a primeira e mais importante dica é formalizar. Escrever e tomar notas sobre o que foi feito e o que não foi feito, sobre o que funciona, e o que não funciona.

Seja num arquivo txt, ou numa planilha, anotar o que foi testado evita que o programador pense que funciona para todos os casos e seja depois surpreendido por um erro que ele achava que funcionava.
----------- keepReading

domingo, 11 de julho de 2010

O grande desafio da web

É inegável que a internet revolucionou a que nós vivemos. Compartilhar fotos, vídeos, músicas, conversar com amigos e parentes distantes em tempo real, fazer novas amizades - e, por que não, amores (sou um exemplo vivo disso) - dividir conhecimento, agilizar processos, integrar negócios... Tudo isto é possível por causa da internet.

Ainda que haja muito lixo virtual, o potencial criativo e benéfico da internet como plataforma e meio de comunicação é expressivo, comparável talvez somente aos adventos da prensa de Johannes Gutenberg e à radiodifusão.

Mas ao contrário de suas revoluções predecessoras, a internet é muito mais complexa. Tanto por ser mais flexível e apresentar uma grande diversidade de tecnologias, quanto por exigir que estas tencologias respeitem padrões que interessam a diversos ambitos. Em outras palavras, criar algo realmente com qualidade, aceitável em todos os aspectos é uma tarefa para titã.

Digo isso porque até hoje não vi nenhum, absolutamente NENHUM framework que respeite isso. Se é fácil de mapear banco de dados para a aplicação, pode ser que seja falho na segurança. Se implementa recursos modernos, como tecnologias assíncronas (Ajax, E4X) ou RIA [Rich Internet Application, onde tem no flash dinâmico seu ilustre exemplo], é quase certo que vai pecar na acessibilidade. Se é bonito ou rápido de desenvolver, provavelmente vai mandar por água abaixo padrões para findability, essenciais ao SEO (Otimização para buscadores).

Talvez por isso até hoje eu não tenha terminado meu próprio framework. Devido ao meu lado perfeccionista. Não me arrependo, mas estou muito motivado a criar algo de qualidade.

Só para ilustrar, eu gostaria que meu framework pudesse:
1. Se conectar ao BD, mapear os metadados e relações, e com base nisso criar os objetos e formulários.
2. Ao efetuar operações, manter a segurança, tanto evitando os tipos básicos de ataque, quanto verificando se os dados respeitam o modelo definido no banco.
3. Permitir que regras de negócio fiquem numa camada separada, facilmente editável.
4. A mesma flexibilidade para as views
5. Que trabalhe nessa construção de operações e estruturas da forma Progressive Enhancement, ou seja, funcional mesmo se não houver javascript ou flash disponíveis.
6. Que tenha em vista o SEO como uma medida - quiçá como uma característica - promovendo URL realmente amigáveis, e não os padrões talhados e engessados, muitas vezes que só disfarçam o verdadeiro sentido da composição das URLs para programadores que gostam de padrões convenientes.
7. Que seja aberto a novas tecnologias (HTML 5, CSS 3), e use as existentes de forma eficiente e inteligente (recursos dentro dos bancos de dados, XSLT...)

Agora, se você é um empresário, ou tenha interesse em manter um site, fica aqui a justificativa de porque alguns profissionais cobrarem muito mais do que outros. A explicação é essa: a importância que verdadeiros profissionais dão aos produtos e serviços que vendem e prestam.

Fazer algo com qualidade passa longe de ser simples. O resultado é bem diferente, e faz diferença se seu negócio vai pra frente ou não no mundo virtual. E é claro, qualidade tem preço.

Imagine um profissional que dê conta de fazer um site com todas as características acima, e ainda por cima um designer que empregue identidade visual, acessibilidade através de contraste adequado, composição, semantica no código (que ajuda no SEO), tipografia e convenções que façam a diferença para quem lê e usa o site...

Não, não é fácil mesmo fazer um simples site. Há muito mais trabalho e técnica do que o sobrinho que aceita fazer por $300 sonha em existir.

Bom, é isso, fica aqui o registro, meio desabafo, meio mirando no futuro.

Keep reading, fellas.
---------- keepReading

segunda-feira, 7 de junho de 2010

Tipo ENUM no MySQL e no PostgreSQL

Tempos atrás eu publiquei aqui, sobre os tipos ENUM e SET no MySQL, porém as respostas dos leitores deixaram claro que eu não havia explicado o assunto direito. E relendo o texto, realmente assumo que ficou péssimo. Não consegui passar o conceito, quanto menos a aplicabilidade desses recursos.

Então aqui cabe a redenção. Vamos ao tipo ENUM. Ele não é um tipo definido no padrão SQL, e sim implementações proprietárias, encontrado nos bancos de dados mais comuns. Assim seu comportamento, espaço em disco e queries que podem ser usadas diferem ligeiramente entre suas implementações, mas a idéia por trás do tipo ENUM é comum a todos.

As vantagens do uso do tipo ENUM são:
  • ganho de performance
  • segurança dos dados

As desvantagens são:
  • limites de uso (a alteração requer a reestruturação da tabela)
  • a não portabilidade devido as diferenças de implementação

A principal característica do tipo ENUM é permitir a criação de uma lista enumerada, sendo cada registro um par index-value. A idéia é bem simples mesmo, mas extremamente eficaz e poderosa. O uso do tipo ENUM deve ser feito em parâmetros onde há pouca ou nenhuma alteração durante a existência da aplicação - por exemplo, sexo, ou um sistema de rating com valores fixos de entrada.

CREATE TABLE 'myPics' (
'id' INT NOT NULL AUTO_INCREMENT ,
'url' VARCHAR( 255 ) NOT NULL ,
'rate' ENUM('bad', 'good', 'excellent') NULL DEFAULT 'good',
PRIMARY KEY ('id') ,
INDEX ('url')
) ENGINE = InnoDB CHARACTER SET utf8 COLLATE utf8_bin;

Na tabela de exemplo acima, criamos o campo rate, que deve armazenar a classificação da foto. Os possíveis valores são: NULL, 'bad', 'good' e 'excellent'. Ou seja você tem valores pré-definidos para o input de dados, e a cada um é atribuído um índice na ordem em que foram declarados. Os possíveis valores para o nosso campo são:
valor índice
NULL NULL
'' 0
bad 1
good 2
excellent 3

Na hora da query uma possível construção seria:

SELECT name, rate FROM myPics WHERE rate >= 'good';

Isso demonstra a utilidade do tipo ENUM. Ao invés de criar uma tabela auxiliar e atribuir valores a ela, podemos reduzir essa complexidade fazendo uso do tipo ENUM em nossa arquitetura. Ah sim, qualquer função que demande tipos numéricos (SUM(), AVG(), MIN(), MAX(), COUNT()....) podem ser usadas em cima dos campos ENUM. Nesse caso, os valores são primeiro transformados no seu índice numérico.

E vale mencionar mais uma vez que o índice atribuído depende da ordem da declaração dos possíveis valores. Se você declarar ENUM ('bom', 'ruim'), 'bom' terá um valor menor do que 'ruim', e se declarar ENUM ('ruim', 'bom'), 'ruim' terá um valor menor do que 'bom'.

No Postgresql o uso do tipo enum é ligeiramente diferente. O trecho a seguir ilustra o mesmo exemplo anterior, só no que postgre.

CREATE TYPE rating AS ENUM ('bad', 'good', 'excellent');
CREATE TABLE myPics (
id serial,
url varchar(255),
rate rating
);

É necessário criar um tipo de dado com nome próprio do tipo ENUM, e depois atribuí-lo à coluna. Na hora de utilizar, nos beneficiamos dos mesmos recursos de construção.

Agora sobre o tipo SET. O tipo SET só existe no MySQL. E uma possível aplicação para ilustrar sua utilidade seria um sistema de tags, implementado de forma nativa na tabela.

Considere a seguinte tabela:

CREATE TABLE 'myPics' (
'id' INT NOT NULL AUTO_INCREMENT ,
'url' VARCHAR( 255 ) NOT NULL ,
'rate' ENUM('bad', 'good', 'excellent') NULL,
'tags' SET('outdoor', 'studio', 'stock', 'fruits', 'nature', 'close-up', 'people') NULL
PRIMARY KEY ('id') ,
INDEX ('url')
) ENGINE = InnoDB CHARACTER SET utf8 COLLATE utf8_bin

Nela, podemos atribuir valores como:

INSERT INTO myPics (id, url, rate, tags) VALUES (NULL, 'xxx', 'good', 'people, close-up'), (NULL, 'yyy', 'excellent', 'fruits, nature, close-up');

Ou seja declarando as tags direto no insert. Na hora de fazer o SELECT, contamos com mais uma função nativa do MySQL bem útil, a FIND_IN_SET:

SELECT * from myPics WHERE FIND_IN_SET('nature', tags) > 0 AND FIND_IN_SET('close-up', tags) > 0;

Isso vai trazer todos os registros cujo campo tags contenha os valores 'nature' e 'close-up'.

Bom, acho que agora o conceito e a aplicação dos tipos ENUM e SET está agora mais clara e mais útil.

-----------
keepReading

quarta-feira, 2 de junho de 2010

Open Source e o bug tracking

Fala pessoal,

nem preciso dizer que sou um entusiasta do movimento do software livre. Embora existam algumas divergências e tecnicismos sobre as definições e terminologias sobre o que é open source, o que é livre e etc... uma coisa é certa: o espírito de ajuda mútua em criar algo que beneficie quem usa os softwares.

E isso é feito de várias formas. Uma das bases desse mundo é a relatação de defeitos encontrados. É algo simples, eficaz e que muitas empresas privadas de desenvolvimento de software adotaram. Você está usando o programa e de repente ele trava, ou dá uma mensagem de erro. Bem, você então relata este erro aos desenvolvedores, assim eles podem investigar o que aconteceu, e trabalhar para a melhoria do produto. Desta forma todo mundo ganha.

Mas se tem algo que me deixa puto da vida é quando eu tenho um bug para reportar, depois de muita googlada, pesquisa, etc, e o serviço de bug tracking não responde de acordo, ou torna a tarefa de reportar um bug mis complicada do que deveria. É o que está acontecendo comigo neste exato momento.

Eu concordo que se deva oferecer ferramentas que automatizem a tarefa de juntar informações necessárias, ainda mais com usuários menos experientes, assim eles podem dar uma contribuição de qualidade, mesmo sem enteder muito do sistema.

Mas no caso eu poderia reportar um bug, com muita informação, e simplesmente não consigo. Processo complicado demais, lento demais, e instável demais (timeouts, internal errors..).

Fico chateado de ver isso, sinceramente. Pois é um gargalo a mais na hora de melhorar a qualidade do produto. E assim a comunidade se enfraquece.

----------- keepReading

A Verdade sobre Sessões

Estou iniciando uma série aqui no blog. Vou traduzir artigos e posts renomados sobre programação e desenvolvimento.

Para a estréia, escolhi um artigo altamente esclarecedor do Chris Shiflett, The Truth About Sessions, que explica em detalhes como as seções do PHP funcionam. Este artigo está originalmente sob licensa Creative Commons, bem como esta tradução. Vamos lá.

Introdução

Praticamente toda aplicação em PHP usa sessões. Este artigo dá uma olhada detalhada na implementação de um mecanismo seguro de gerência de sessões em PHP. Seguindo uma introdução básica de HTTP, o desafio de manter estado, e a operação básica de Cookies, eu vou explicar através de métodos simples e efetivos que podem ser usados para aumentar a segurança e a confiabilidade de suas aplicações PHP com estado.

A falta de estado

HTTP é um protocolo sem estado. Isso porque não há nada dentro do protocolo que requisite que o browser identifique a si mesmo em cada requisição, e também não há nenhuma conexão estabelecida entre o browser e o servidor que persista entre uma página e a próxima. Quando um usuário visita um site, o browser do usuário envia uma requisição HTTP ao servidor, que por sua vez envia uma resposta HTTP de volta. Essa é a extensão da comunicação, e representa uma transação HTTP completa.

Como a web se baseia em comunicações HTTP, manter o estado em aplicações web pode ser particularmente desafiador para desenvolvedores. Cookies são uma extensão do HTTP que foram introduzidos para ajudar a providenciar transações HTTP com estado, mas preocupações com privacidade levaram muitos usuários a desabilitar o suporte a cookies. Informações sobre estado podem ser passadas na URL, mas a divulgação acidental dessa informação mostra sérios riscos de segurança. De fato, a própria natureza de manter estado requer que o cliente identifique a si mesmo, assim a nossa consciência sobre segurança nos diz que nós nunca devemos confiar nas informações enviadas pelos clientes.

Apesar de tudo isso, existem soluções elegantes para o problema de manter o estado. Não existe solução perfeita, é claro, nem existe uma única solução que satisfaça as necessidades de todos. Este artigo introduz algumas técnicas que podem confiavelmente prover o manutenção do estado, bem como se proteger contra técnicas de invasão através de ataques de sessão, como o roubo de sessão. Mais abaixo, você vai aprender como os cookies realmente funcionam, o que as seções PHP fazem, e o que é preciso para roubar uma sessão.

Visão geral sobre HTTP

Para apreciar o desafio de manter o estado bem como escolher a melhor solução às suas necessidades, é importante entender um pouco sobre a arquitetura de web por trás disso tudo, o HyperText Transfer Protocol (HTTP).

Uma visita a http://exemplo.org/ requer que o navegador envie uma requisição HTTP para exemplo.org na porta 80. A sintaze dessa requisição é algo mais ou menos assim:
GET / HTTP/1.1
Host: exemplo.org

A primeira linha é chamada linha de requisição, e o segundo parâmetro (uma barra neste exemplo) é o caminho do recurso solicitado. Uma barra representa a raíz do documento; o servidor web transforma a raíz do documento para um caminmho específico no sistema de arquivos. Usuários do Apache podem estar acostumados a configurar este caminho com a diretiva DocumentRoot. Se http://www.exemplo.org/caminho/para/script.php é solicitado, o caminho para o recurso solicitado na requisição é /caminho/para/script.php. Se a raíz do documento está definida para ser /usr/local/apache/htdocs, o caminho completo para o recurso que o servidor irá usar é /usr/local/apache/htdocs/caminho/para/script.php

Existem muitas tecnologias como mod_rewrite que oferecem mais flexibilidade quando estão mapeando uma URL para um recurso específico

A segunda linha ilustra a sintaxe de de um cabeçalho HTTP. O cabeçalho neste exemplo é Host, e identifica o nome do domínio do servidor onde o browser pretende requisitar um recurso. Este cabeçalho é requerido pelo HTTP/1.1 e ajuda a prover suporte a mecanismos de virtual hosting, múltiplos domínios sendo servidor por um único endereço IP público. Existem muitos outros cabeçalhos opcionais que podem ser incluídos numa requisição, e você pode estar familiarizado em fazer referência a alguns deles no seu código PHP; exemplos incluem $_SERVER['HTTP_REFERER'] que se refere ao cabeçalho Referer e $_SERVER['HTTP_USER_AGENT'] que se refere ao cabeçalho User-Agent.

Uma nota particular desta requisição é que não há nada dentro dela que possa ser usado para identificar unicamente para identificar o cliente. Alguns desenvolvedores recorrem a informações obtidas do do TCP/IP (como o endereço IP) para identificação única, mas essa abordagem tem muitos problemas. Mais notavelmente, um único usuário pode potencialmente usar diferentes endereços IP para cada requisição (como no caso de grandes provedores de internet como AOL), e vários usuários podem usar o mesmo endereço IP (como no caso de laboratórios de computador usando um proxy HTTP). Estas situações podem fazer com que um único usuário aparente ser vários, ou muitos usuários aparentar ser apenas um. Para qualquer método de prover estado seguro e confiável, apenas informações obtidas do HTTP podem ser usadas.

O primeiro passo em manter o estado da aplicação é de alguma forma identificar unicamente cada cliente. Visto que a única fonte confiável de informações que podem ser usadas para a identificação deve vir da requisição HTTP, é necessário algo esteja dentro da requisição que possa ser usado para identificação única. Existem algumas poucas formas de se fazer isso, mas a solução desenvolvida para resolver este problema em particular é o cookie.

Cookies

A constatação de que deve haver um método único de identificação dos clientes resultou nos cookies, uma solução bastante criativa. Cookies são mais fáceis de entender se você considerá-los uma extensão do protocolo HTTP, o que é precisamente o que eles são. Os cookies estão definidos pelo RFC 2965, embora a especificação original escrita pela Netscape se aproxime mais do suporte à indústria.

Existem dois cabeçalhos HTTP que são necessários para se implementar os cookies, Set-Cookie e Cookie. O servidor web inclui o cabeçalho Set-Cookie em resposta a uma requisição para que o browser inclua este cookie em futuras requisições. Um navegador compatível que está com os cookies ativados inclui o cabeçalho Cookie em todas as requisições subsequentes (que satisfaçam as condições definidas pelo cabeçalho Set-Cookie) até que o cookie expire. Um scenario típico consiste de duas transações (quatro mensagens HTTP):

  1. O cliente envia uma requisição HTTP
  2. O servidor envia uma resposta HTTP que inclui o cabeçalho Set-Cookie
  3. O cliente envia uma requisição com o cabeçalho Cookie
  4. O servidoe envia uma resposta HTTP

Esta troca está ilustrada na figura 1:

Figura 1

A adição do cabeçalho Cookie na segunda requisição do cliente providencia a informação que o servidor pode usar para identificar unicamente o cliente. Também é neste ponto que o servidor (ou um script PHP no lado do servidor) pode determinar se o usuário tem cookies habilitados. Embora o usuário possa escolher desabilitar os cookies, é razoavelmente seguro assumir que as preferências do usuário não vão mudar enquanto ele interage com sua aplicação. Este fato pode provar ser muito útil, como em breve será demonstrado.

Dados GET e POST

Existem dois métodos adicionais que um cliente pode usar para enviar dados ao servidor, e estes métodos são anteriores aos cookies. Um cliente pode incluir informação na URL requisitada, tanto na query string ou como parte do caminho. Como um exemplo de query string, considere a seguinte requisição:
GET /index.php?foo=bar HTTP/1.1
Host: example.org
O script receptor, index.php, pode referenciar $_GET['foo'] para fazer referência ao valor bar. Por isso, muitos desenvolvedores PHP se referenciam a estes dados como dados GET (outros algumas vezes chamam de dados query string, ou variáveis de URL). Um ponto de confusão comum, é que os dados GET podem existir mesmo numa requisição POST, porque eles são simplesmente parte da URL e não dependem do método de requisição.

Uma outra forma que os os clientes pode usar para enviar dados é utilizando a porção conteúdo da requisição HTTP. Esta técnica requer que o método de requisição seja o POST, e um exemplo de tal requisição é como o seguinte:
POST /index.php HTTP/1.1
Host: example.org
Content-Type: application/x-www-form-urlencoded
Content-Length: 7

foo=bar

Neste caso, o script receptor, index.php, pode se referenciar a $_POST['foo'] para fazer referência ao valor bar. Os desenvolvedores PHP se referem tipicamente a estes dados como dados POST, e é assim que um browser passa os dados submetidos através de um formulário cuja propriedade method é o POST.

Um request pode potencialmente ter os dois tipos de dado, desta forma:
POST /index.php?myget=foo HTTP/1.1
Host: example.org
Content-Type: application/x-www-form-urlencoded
Content-Length: 11

mypost=bar

Estes dois métodos adicionais de enviar dados podem prover substitutos aos cookies. Diferente dos cookies, GET e POST não são opcionais, então estes métodos são mais confiáveis. Considere um identificador único chamado PHPSESSID incluído na URL requerida como segue:
GET /index.php?PHPSESSID=12345 HTTP/1.1
Host: example.org

Isto cumpre com o mesmo objetivo do cabeçalho Cookies, porque o cliente identifica a si mesmo, mas é muito menos automático para o desenvolvedor. Uma vez que o cookie está definido, é responsabilidade do browser enviá-lo nas requisições subsequentes. Para propagar o identificador único através das URLs, o desenvolvedor precisa garantir que todos os links, formulários, e similares a ter a query string apropriada (o PHP pode ajudar nisso se você habilitar a opção session.enable_trans_sid). Em adição, dados GET são mostrados na URL e são muitos mais expostos do que cookies. De fato, usuários desavisados podem salvar tais URLs nos favoritos, enviar para um amigo, ou um número qualquer de outras coisas que podem acidentalmente revelar sua identificação única.

Embora os dados POST sejam menos suscetíveis a serem expostos, propagar o identificador único como uma variável POST requer que todas as requisições ao servidor sejam também POST. Esta não é uma opção conveniente, ainda que o design da sua aplicação possa fazer isso viável.

Gerenciamento de sessões

Até agora, eu discuti sobre estado. Este é um detalhe de nível baixo o bastante que envolve o a associação de uma transação HTTP com outra. O recurso mais útil com o qual provavelmente você esteja familiarizado seja o gerenciamento de sessões. Gerenciamento de sessões não se baseia apenas na habilidade de manter o estado, mas também requer que você mantenha dados unicamente associados com cada usuário. Este dados costumam ser chamados de dados de seção, porque são associados com uma seção específica do usuário. Se você usa o mecanismo nativo do PHP para gerenciamento de sessões, os dados de sessão são mantidos para você (em /tmp por padrão) e disponíveis através do vetor superglobal $_SESSION. Um exemplo simples do uso de sessões envolve a persistência dos dados de sessão entre uma página e a próxima. A lista 1, start.php, demonstra como isso pode ser feito:

Lista 1:
<?php

session_start();
$_SESSION['foo'] = 'bar';

?>

<a href="continue.php">continue.php</a>

Assumindo que o usuário clica no link dentro de tart.php, o script receptor (continue.php) poderá acessar a mesma variável de sessão, $_SESSION['foo']. Isto é mostrado na lista 2.

Lista 2:
<?php
session_start();
echo $_SESSION['foo']; /* bar */
?>

Sérios riscos existem quando você escreve o código desta forma sem entender o que o PHP faz por você. Sem este conhecimento, você poderá achar difícil depurar erros de sessões, ou prover um nível razoável de segurança.

Personificação

É um equívoco comum acreditar que o mecanismo de gerenciamento de sessões nativo do PHP provê defesas contra os ataques baseados em sessões. Ao contrário, o PHP simplesmente provê um mecanismo conveniente. É responsabilidade do desenvolvedor prover as defesas de segurança apropriadas. Como mencionado antes, não existe solução perfeita, nem uma melhor solução apropriada que se aplique a todos.

Para explicar o risco da personificação, considere a seguinte série de eventos:

  1. Pessoa inocente visita http://www.exemplo.org/ e faz login
  2. exemplo.org define um cookie, PHPSESSID=12345
  3. Pessoa maliciosa visita http://www.exemplo.org/ e apresenta um cookie, PHPSESSID=12345
  4. exemplo.org confunde pessoa maliciosa com pessoa inocente

Estes eventos estão ilustrados na figura 2.

Figura 2


É claro, este cenário assume que a pessoa maliciosa de alguma forma descobre ou adivinha a PHPSESSID válida que pertence a pessoa inocente. Enquanto isto pode parecer improvável, é um exemplo de segurança sobre obscuridade e não é algo sobre o qual devemos nos basear. Obscuridade não é uma coisa ruim, é claro, e pode ajudar, mas precisa ser algo mais substancial no lugar que ofereça proteção confiável contra tais ataques.

Prevenindo a personificação

Existem muitas técnicas que podem ser usadas para complicar a personificação ou outros ataques baseados em sessões. A aproximação geral, é fazer as coisas tão convenientes quanto for possível para legitimar seus usuários e tão complicadas quanto possível para os atacantes. Este é um balanço desafiante a ser atingido, e o balanço perfeito depende muito do design da aplicação. Assim, você é o melhor juiz no fim das contas.

A requisição HTTP/1.1 válida mais simples consiste de uma linha de requisição e o cabeçalho Host.

GET / HTTP/1.1
Host: example.org

Se o cliente estiver passando o identificador único de sessão PHPSESSID, este pode ser passado no cabeçalho Cookie como a seguir:

GET / HTTP/1.1
Host: example.org
Cookie: PHPSESSID=12345

Alternativamente, o cliente pode passar o identificador único de sessão na URL requisitada

GET /?PHPSESSID=12345 HTTP/1.1
Host: example.org

O identificador de sessão também pode ser incluído como dados POST, mas isto tipicamente envolve uma experiência de usuário menos amigável e é a abordagem menos popular.

Porque a informação obtida do TCP/IP não pode ser confiavelmente usada para ajudar a fortalecer a segurança do mecanismo, parece que há pouco o que um desenvolvedor pode fazer para complicar a personificação. Apesar de tudo, a única coisa que um atacante precisa fazer é enviar o mesmo identificador único que um usuário legítimo enviaria para personificar aquele usuário e roubar a sessão. Assim, parece que a única proteção é manter o identificador de sessão oculto ou fazer com que ele seja mais difícil de adivinhar (preferencialmente ambos).

O PHP gera um identificador de sessão randômico, que é praticamente impossível de adivinhar, então esta preocupação já está mitigada. Prevenir um atacante de descobrir um identificador válido de sessão é muito mais difícil, porque muito dessa responsabilidade está fora do domínio onde o desenvolvedor tem controle.

Existem muitas situações que podem resultar na exposição do identificador de sessão do usuário. Dados GET podem ser erroneamente guardados em cache, observados por um estranho, guardado nos favoritos, ou enviados por email. Cookies provêm um mecanismo mais safo, mas usuários podem desabilitar o suporte a cookies, descartando a possibilidade de usá-los, e vulnerabilidades passadas no Internet Explorer foram conhecidas por revelar cookies a sites não autorizados.

Assim, um desenvolvedor pode estar bem certo de que o identificador de sessão não possa ser adivinhado, mas a possibilidade de que ele seja revelado a um atacante é mais provável, independente do método utilizado para propagá-lo. Algo adicional é necessário para ajudar a prevenir a personificação.

Na prática, uma típica requisição HTTP inclui muitos cabeçalhos opcionais além do Host. Por exemplo, considere a seguinte requisição:

GET / HTTP/1.1
Host: example.org
Cookie: PHPSESSID=12345
User-Agent: Mozilla/5.0 (Macintosh; U; Intel Mac OS X; en-US; rv:1.8.1.1) Gecko/20061204 Firefox/2.0.0.1
Accept: text/html;q=0.9, */*;q=0.1
Accept-Charset: ISO-8859-1, utf-8;q=0.66, *;q=0.66
Accept-Language: en

Este exemplo inclui quatro cabeçalhos opcionais, User-Agent, Accept, Accept-Charset, e Accept-Language. Como estes cabeçalhos são opcionais, não é muito inteligente contar com sua presença. Contudo, se o browser de um usuário envia estes cabeçalhos, é seguro assumir que eles estarão presentes nas requisições subsequentes? A resposta é sim, com poucas exceções. Assumindo o exemplo anterior como sendo uma requisição enviada de um usuário atual com uma sessão ativa, considere a seguinte requisição subsequente enviada pouco depois:

GET / HTTP/1.1
Host: example.org
Cookie: PHPSESSID=12345
User-Agent: Mozilla/5.0 (compatible; IE 6.0 Microsoft Windows XP)

Como o mesmo identificador único está sendo apresentado, a mesma sessão PHP será acessada. Se o browser está identificando a si mesmo de forma diferente do que na interações anteriores, nós devemos assumir que é o mesmo usuário?

Está claro que isto não é desejável, mas é exatamente isto o que acontece se você não escreveum código que especificamente não checa situações assim. Mesmo nos casos onde você não consegue ter certeza que a requisição é um ataque de personificação, simplesmente pedir que a senha ao usuário pode ajudar a prevenir a personificação sem afetar demais os uauários adversamente. Isto é um ponto importante.

Você pode adicionar a validação do User-Agent ao seu modelo de segurança de forma similar à lista 3.

Lista 3:

<?php
session_start();

if (md5($_SERVER['HTTP_USER_AGENT']) != $_SESSION['HTTP_USER_AGENT']) {
/* Prompt for Password */
exit;
}

/* Rest of Code */
?>

É claro, primeiro você precisará armazenar o digest MD5 do user agent que iniciou a sessão, como mostrado na lista 4.

Lista 4:

<?php
session_start();

$_SESSION['HTTP_USER_AGENT'] = md5($_SERVER['HTTP_USER_AGENT']);
?>

Enquanto não é necessário que você o MD5 do User-Agent, isso ajuda a providenciar consistência e elimina a necessidade de filtrar $_SERVER['HTTP_USAR_AGENT'] antes de usá-la. Como essa informação é originada de uma fonte remota, não podemos confiar de forma cega nela, mas o formato de um digest MD5 é consistente.

Agora que você exige a consistência de User-Agent, um atacante deve cumprir dois passos para roubar a sessão:

  1. Capturar um identificador de sessão válido.
  2. Apresentar o User-Agent da vítima na tentativa de personificação.

Enquanto isto é claramento possível, é ligeiramente mais complicado, e desta forma o mecanismo de sessão já está mais seguro.

Outros cabeçalhos podem ser adicionados desta forma, e você pode até mesmo usar uma combinação de cabeçalhos como uma impressão digital. Se você também incluir algum tipo de revestimento de algum tipo, esta impressão digital se torna praticamente impossível de adivinhar. Considere o exemplo da lista 5.

Lista 5:

<?php

session_start();

$fingerprint = 'SHIFLETT' . $_SERVER['HTTP_USER_AGENT'];
$_SESSION['fingerprint'] = md5($fingerprint . session_id());

?>

O cabeçalho Accept não deve ser usado nesta impressão, porque alguns browsers podem variar o valor deste cabeçalho quando o usuário atualiza a página.

Com uma impressão digital que é difícil de adivinhar, pouco é ganho não usando-a. Considere um mecanismo de sessão onde a impressão digital é propagada como o identificador de sessão. Nesta caso, um atacante deve completar os três passos seguintes para roubar uma sessão com sucesso:

  1. Capturar um identificador de sessão válido.
  2. Apresentar os mesmo cabeçalhos HTTP usados para gerar a impressão.
  3. Apresentar a impressão digital da vítima.

Se ambos o identificador de sessão e a impressão digital são propagadas como dados GET, ainda é possível que um atacante que obtenha um também consiga ter acesso ao outro. Uma abordagem mais segura é utilizar dois métodos diferentes de propagação, dados GET e cookies. É claro, isto depende das preferências do usuário, mas um nível extra de proteção pode ser oferecido para aqueles que habilitam os cookies. Assim, se um atacante obtém um identificador único por uma vulnerabilidade do browser, a impressão digital ainda continua desconhecida.

Existem muitos outros mecanismos que podem ser usados para ajudar a fortalecer a segurança do seu mecanismo de sessões. Esperamos que você esteja no caminho de criar as suas próprias técnicas. Afinal, você é o expert das suas próprias aplicações, então munido com um bom entendimento de sessões, você é a melhor pessoa para implementar alguma segurança adicional.

Obscuridade


Eu gostaria de desfazer um mito sobre a obscuridade. O mito é de que "não existe segurança através da obscuridade". Como mencionei antes, obscuridade não é algo que oferece a proteção adequada, nem deve ser tomada por base. Contudo, isso não significa que não há absolutamente nada a ser ganhar. Resguardado por um mecanismo seguro de sessões, obscuridade pode oferecer um pouco de segurança adicional.

O simples uso de nomes de variáveis que induzam ao erro para o identificador de sessão e para a impressão digital já ajudam. Você também pode propagar dados de engodo para confundir um potencial atacante. Estas técnicas certamente não devem ser usadas como a base para proteção, é claro, mas você não irá perder seu tempo implementando um pouquinho de obscuridade no seu próprio mecanismo.

Sumário


Eu espero que você tenha ganho diversas coisas deste artigo. Notavelmente, agora você deve ter um entendimento básico de como a web funciona, de como o estado completo é alcançado, o que é realmente um cookie, como as sessões do PHP funcionam, e algumas técnicas que você pode usar para aumentar a segurança das suas sessões.

Se você gostou deste artigo, você pode estar interessado em outros:


Se você desenvolver um mecanismo de sessões seguro por conta própria, por favor, sinta-se à vontade para compartilhar com a comunidade. Eu adoraria ouvir sobre suas próprias soluções, e eu espero que este artigo tenha fornecido as informações de base necessárias para dar suporte à sua própria criatividade.

----------- keepReading

terça-feira, 25 de maio de 2010

Robots.txt - Ajudando os buscadores

Voltamos a mais um artigo sobre boas práticas de web.

O assunto de hoje não tem a ver diretamente com usuários, e sim com os buscadores: robots.txt

O que é?

O arquivo robots.txt é algo extremamente simples. De verdade. É um arquivo, com o nome "robots.txt", que deve ficar na raíz do site, e com um conteúdo similar a:

User-agent: *
Disallow: /img/
Disallow: /styles/
Disallow: /scripts/
Disallow: /busca.php

Explicação

Na primeira linha definimos o user-agent, que nada mais é que o nome do crawler. No caso especificamos *, curinga para todos os crawlers. Para saber melhor quais os nomes válidos, veja a lista completa.

Nas outras linhas temos Disallow, que é a dica de quais diretórios e arquivos não indexar. No caso acima, dizemos que todo o conteúdo dos diretórios img, scripts e styles não devem ser indexados, e que o arquivo /busca.php também não.

Outras opções

Existem várias outras opções que não fazem parte do padrão como
  • Allow - funciona como o disallow, mas ao invés de proibir, permite
  • Delay - diz qual o intervalo em segundos entre uma requisição e outra
  • Request-rate - que diz qual a taxa de requisições.
  • Visit-time - diz qual o melhor intervalo para visitação do crawler
  • Sitemap - diz onde está o sitemap xml do site.

O que usar?

É muito incomum ver nos robots.txt existentes, alguma diretiva que fuja do padrão (user-agent e disallow), com exceção da diretiva sitemap. Para os crawlers dos maiores buscadores (google, yahoo, bing, ask), o uso dessa diretiva é bastante útil, então o uso da diretiva sitemap é recomendado.

Considerações

Assim como o sitemap, a função do robots.txt é meramente informativa. O trabalho de indexação acontece de forma independente. Um badbot pode - e provavelmente irá - ignorar uma cláusula de disallow. Para evitar a indexação de informações privilegiadas, use o .htaccess.

Mas sem neuroses, a existência do robots.txt no seu site indica a preocupação em ajudar os crawlers na tarefa de indexação, e isso com certeza conta alguns pontos para uma melhor colocação do site. É mais poderoso ainda se você indicar um sitemap.

Exemplo final

User-agent: *
Disallow: /scripts/
Disallow: /styles/
Disallow: /private/
Disallow: /busca.php
Sitemap: http://www.seusite.com/sitemaps/sitemap.xml

Até a próxima.
----------- keepReading

segunda-feira, 24 de maio de 2010

Sitemaps -- Como fazer e o que fazer com eles

Fala pessoal, vamos continuar o assunto de boas práticas e de design voltado ao usuário que abordei nos dois últimos posts desse blog.

Os sitemaps são uma poderosa ferramenta de organização e SEO. Alguns buscadores aceitam que você envie o sitemap o seu site. Assim eles sabem exatamente o que indexar, ao invés de apenas ir navegando e filtrando. Outro lugar onde você pode fazer referência ao seu sitemap é no arquivo robots.txt (falaremos brevemente sobre esse arquivo num post futuro).

Isso sem contar que um sitemap em XML pode servir de base para que você crie seu sitemap HTML (seja server-side, ou com transformação XSLT).

Chega de papo. Vamos ao que interessa. Um arquivo sitemap é nada mais que um arquivo XML, com o seguinte formato:

O arquivo de sitemap

<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
 <url>
  <loc>http://www.example.com/</loc>
  <lastmod>2005-01-01</lastmod>
  <changefreq>monthly</changefreq>
  <priority>0.8</priority>
 </url>
</urlset>

Explicando cada tag.
urlset - é a raíz do arquivo. Só pode existir uma.
url - é usada para englobar as propriedade de cada página. Cada página do site precisa de um conjunto desses.
loc - é o endereço da página. Importante: esse endereço deve ser escapado. Mais detalhes abaixo.
lastmod - é a data da última modificação da página, no formato AAAA-MM-DD
changefreq - é a frequencia com que a página tem seu conteúdo atualizado (aceita os valores always, hourly, daily, weekly, monthly, yearly, never - sempre, horário, diário, semanal, mensal, anual, nunca respectivamente).
priority - define a prioridade da página em relação ao site. Os valores vão de 0.01 a 1.00

Explicações

As tags lastmod, changefreq e priority são opcionais. Note que o changefreq dá apenas uma indicação aos buscadores. Uma página marcada com always ou hourly pode ser indexada com uma frequencia menor do que isso. Uma página marcada com yearly, pode ser indexada mais de uma vez por ano. Ou seja, ela é apenas uma dica. A indexação de fato é feita pelos buscadores, e não há como garantir isso com precisão absoluta.

Para sites dinâmicos, criar o sitemap na mão pode ser bastante complicado. Então podemos criar um script que gere o sitemap. Eu criei um script rápido em PHP que faz isso.

Outra observação a ser feita é em relação ao uso da tag priority. Setar todas as páginas com prioridade 1.00 (mais importante) é uma tentação como todas as outras práticas de black hat SEO. Não faça isso!

Na dúvida deixe o valor 1.00 para a home, e outros valores mais baixos para outras páginas. Uma boa abordagem seria contar quantos níveis existem no path para cada página, e daí sim basear o valor de cada página. Por exemplo, para o endereço http://www.seusite.com.br/artigos /subcategoria/nome-do-artigo.html, vemos a seguinte estrutura:
0 - http://www.seusite.com.br/
1 - http://www.seusite.com.br/artigos/
2 - http://www.seusite.com.br/artigos/subcategoria/
3 - http://www.seusite.com.br/artigos/subcategoria/nome-do-artigo.html

Daí podemos fazer a seguinte associação de valores:
0 - 1.00
1 - 0.85
2 - 0.80
3 - 0.75

Ou mesmo inverter os dois últimos números, 0.80 e 0.75 (isso porque o conteúdo de um artigo geralment é mais importante do que o índice, mas uma seção de artigos é mais importante que um artigo sozinho).

Uma outra abordagem para calcular o valor da prioridade seria ver qual o real valor do conteúdo de cada página para o site. Vamos supor que você escreveu um artigo muito bom, ou tem uma página de produtos que atrai mais visitas que sua própria página inicial - em outros termos, você tem uma outra fonte de entrada muito boa no seu site.

É normal e aceitável que esta página tenha um valor de prioridade maior na indexação, podendo ser mesmo 1.00 (> 80% das visitas vindo por mecanismos de busca achem seu site por esta página).

Em suma: o bom senso deve imperar.

E o escaping das URLs?

Pra fechar, deixe-me falar sobre o valor da tag mais importante de cada URL, a tag loc.
O valor para esta tag que contém a URL deve ser uma URL escapada - com os carateres especiais codificados.

Por exemplo, a URL http://www.seusite.com.br/usuários/josé123 deverá ser escrita no sitemap como
http://www.seusite.com.br/usu%C3%A1rios/jos%C3%A9.

Esse resultado pode ser obtido pelo javascript, usando a função encodeURI(), ou no PHP, com a função encodeurl. Note que o PHP também faz o encoding dos caracteres especiais como ":" e "/".

No meu script há uma ligeira adaptação da função encodeURL. Eu uso a função encodeURL, e depois a str_replace para voltar os caracteres de controle ao normal.

Bom, isso é tudo. No próximo artigo, um tapa no robots.txt. Até lá.
----------- keepReading

sexta-feira, 21 de maio de 2010

Páginas de erro 404 úteis - Nos bastidores

No artigo passado sobre páginas de erro 404 úteis, vimos que existem possibilidades de sugestões e alternativas para ajudar pessoas e navegadores a encontrar o conteúdo que procuram.

Agora é hora de uma pitada técnica sobre os cabeçalhos HTTP envolvidos nesse processo, e como eles afetam sua página nos buscadores.

É de uso comum e corrente, que quando uma página não é encontrada, se faça um redirecionamento para uma página padrão, como a página de entrada. Como seguinte trecho de PHP:
<?php
header("Location http://www.seusite.com.br/");
?>

O problema dessa implementação é bem simples. Você envia junto com esse header Location, um cabeçalho HTTP 302 (Found).

Vamos supor que um indexador (googlebot, ou qqr outro) veja um link num outro site, apontando para o seu, mas com o endereço para uma página que não existe, e deveria lançar um erro 404 - porque ela não existe!

Sua manipulação com o simples header location, ou mesmo com um redirect 301 no .htaccess vai enviar o código errado, e o indexador vai entender essa página inexistente como uma existente. Pior, pode ser que ela indexe conteúdo duplicado (muitos links diferentes que apontam para uma mesma página). O que é uma má prática bad SEO.

Quando criar a sua página de erro para páginas não encontradas, SEMPRE se assegure que vai enviar o cabeçalho HTTP 404.

Em PHP o código é bem simples.
<?php
header($_SERVER["SERVER_PROTOCOL"]." 404 Not Found");
?>
//código da página de erro amigável

Assim, você garante a correta indexação e a consistencia entre o seu sitemap XML, e as páginas válidas no seu site.

No próximo post: sitemaps.
----------- keepReading