Os discos de estado sólido ainda estão absurdamente caros (beirando os 4 dólares), mas investir em colocar sua base de dados em um disco desses pode valer a pena desde já.

Em base de dados a largura de banda, apesar de ser importante não chega ao nível de importância que o tempo de busca tem. E dispositivos de armazenamento de estado sólido possuem praticamente zero de tempo de busca.

Outro dia essa idéia me veio a cabeça e eu achei essa comparação: More Details on MySQL & SSD drive performance, agora fiquei animado ao ver um case no HighScalability onde a empresa de games online “EVE Online” utiliza SSD em seus servidores SQL Server. Abaixo um paragrafo do case:

Cluster de base de dados – Essa é a camada persistente da EVE Online. Os nós do cluster usam bastante a base de dados, então claro que quase tudo que se fazer com o game está aqui. Graças aos discos de estado sólido a base de dados consegue lidar com uma quantidade enorme de I/O tranqüilamente.

Como é possível ver nos gráficos desse artigo a diferença é realmente absurda.

Para reforçar que para aumentar performance na base de dados pode valer a pena o investimento em um SDD, leia o artigo do Marcos Tapajós sobre CouchDB – Databases don’t scale. YET! – ele deixa bem claro que o maior problema de escalabilidade é base de dados e mostra o CouchDB, promissor projeto da incubadora da Apache.

A API do Twitter é um grande exemplo do por que é bom ter uma API que entrega bastante dados a cada requisição.

Se você possui dados valiosos na aplicação, acredite, as pessoas vão querer ler e mesclar esses dados dentro de novos aplicativos. Não adianta fazer nada, por que a questão é justamente “o que você deixou de fazer”. Eles fizeram.

O lado bom é que as vezes (muitas vezes) eles podem pagar por isso. Eles podem comprar a sua empresa só para agregar o valor do produto (dados). Podem te pagar pagar mensalmente pelos dados. E ainda existe o caso no qual a empresa pode recompensar quem usar sua API (se isso agregar valor de alguma forma ao produto, ou o tornar real).

Mas aqui tem um problema. Um problema que fica imperceptível aos olhos de pequenas aplicações mas que fica claro em robustas (pense no Twitter): são muitos dados para buscar e muitas requisições para responder.

No caso do Twitter, mesmo quando eles haviam entendido a aplicação como um sistema de entrega de mensagens assíncronas e então resolvido os problemas com leitura/escrita e locks na base de dados, faltava-lhes algo. Eles sabiam que estavam somente começando a enfrentar o problema de escrita/leitura de uma grande quantidade de dados ao mesmo tempo. Tanto que compram logo o Summize que tinha um estrutura e melhor experiência para lidar com esse tipo de problema.

Particularmente eu acho muito mais importante entender ferramentas como o Hadoop e/ou CouchDB do que depender da quantidade de memoria da maquina de MySQL, de sharding ou de cluster. E provavelmente foi isso que o pessoal do Twitter fez, provavelmente era isso que o Summize tinha e vendeu: conhecimento em sistemas distribuídos para web.

Mas voltando ao assunto principal: API.
Se sua aplicação vai ser digamos que o novo Submarino. Digamos que no meio da crise você consiga até comprar a B2W (empresa responsável pelo Submarino). Por que você deveria se preocupar em fazer uma boa API?

Ah… é um e-commerce. Não é nenhuma dessas aplicações novas da Web. Pra que RSS? Pra que API?

Eu digo por que: se você não fizer um RSS ou uma API, as pessoas irão partir para ignorância.
Repito: se você está expondo dados de alguma forma na web, não tem como impedir que eles não sejam extraídos para uma outra aplicação. Screen Scraping é uma arte antiga e fácil.

E aqui você tem um grande problema: como você não planejou esse tipo de acesso (bots acessando muito frequentemente o seu servidor), você vai ter problemas decorrentes da falta de planejamento.

Que eu saiba somente um grande (e antigo) player da Web brasileira está desenvolvendo uma API para um grande estoque de produtos. Essa é a chance da sua solução de e-commerce ter algo competitivo com esses caras: faça uma API rapidamente. Procure por algum protocolo aberto para o seu modelo de API (API de fotos, API de produtos, etc) e desenvolva essa área. Se você fizer algo, por favor deixe-me ficar sabendo. Eu quero o maior número de API de produtos que vocês conseguirem me dar e prometo que retribuo

Só para reforçar a importância que uma API tem, dê uma olhada na qualidade da documentação que o Twitter disponibiliza para sua interface de aplicação. Reparem na quantidade de dados que é possível retirar com uma só requisição… totalmente excelente!

Desculpas para quem leu a versão zuada que foi no RSS antes. Publiquei antes de assar

Eu resolvi fazer alguns testes com Threads e Timeouts no Ruby hoje e para tal resolvi lidar com algo real: chamadas a APIs.

Problema

O problema todo da escalabilidade acontece por um simples motivo: uma chamada que demora para responder gera uma bola de neve no sistema. E esse problema da bola de neve se repete em várias partes do sistema todo. É isso que ocorre com as querys longas no MySQL ou upload de arquivo que trava uma instância do servidor e deixa todas próximas requisições lentas.

Por isso que é muito mais importante diminuir o tempo das querys longas no MySQL do que qualquer outra coisa. Você provavelmente consegue tirar mais tempo das querys mais longas, certo? Pense no lance de proporção, certo?

Problemas em escalar leitura em MySQL são comuns e por isso as soluções são amplamente conhecidas. Apesar de existir lock para leitura e outras características que machucam muito o trabalho de quem tem que escalar base de dados relacionais, caras como o Flickr fazem um bom uso do MySQL até hoje (sempre com ajuda de cache, lembre-se disso).

Mas e se a fonte de dados da aplicação é algo muito mais lento que um MySQL? E se a fonte de dados é digamos um WebService? Ou no pior dos casos: Web Scraping?

Um WebService ou uma API RESTfull não tem latência controlada como uma query rodando no MySQL local (ou em um cluster de) pode ter. Para começar a falar sobre WebServices eu penso logo em 200ms de latência só para atingir o servidor. E acredite, na maioria das vezes isso é pouco e de qualquer forma é o tempo de resposta que uma query comum no MySQL deve levar.

Além da lentidão você tem que pensar que a coisa toda pode não funcionar. Você pode fazer a requisição HTTP e ela não voltar. É da natureza do HTTP não retornar algumas requisições.

Agora você pensa em centenas de requisições entrando na fila a cada segundo em um sistema que busca os dados em uma API de tempo de resposta médio de 2 segundos. Esqueça a moleza do MySQL. 2 segundos aqui (no meu exemplo de API) é o tempo de resposta mínimo! Ferrou.

Eu já passei por isso. A maneira básica de lidar é cache. Você sabe. Todo mundo sabe…

Mas ainda acontece que as requisições são muito lentas! Muito! O cache não pode ser para sempre e as vezes acontecem coisas que lhe obrigam a limpar todo o cache.

Não importa quantos processos Ruby você abrir (ou quantas requisições/segundo seu Apache sirva em uma maquina de 16 bits), sua aplicação não escala e a culpa é da sua fonte de dados que para piorar é externa e você não pode fazer nada.

Solução

Eu estou planejando cortar muito processos Ruby de uma aplicação em Merb que bate 2MM req/dia com uma solução parecida com a experiência de hoje (que alias se encontra no final do post).

Por enquanto, para manter o serviço no ar a solução foi usar o que havia de melhor na infra: Nginx, Memcached e Thin. Ainda assim eu preciso de 75 instancias do Thin para que tudo funcione (lembre-se: cache não é eterno e requisições sem cache são extremamente lentas).

Como irei mudar o cenário? Quase da mesma forma como espanquei um WebServer a poucas horas com somente um processo Ruby aberto e muito menos banda do que um VPS costuma ter… “Threads”.

Usei Threads de Ruby aqui para a experiência que vou passar, mas para produção recomendo o uso de bibliotecas que irão gerenciar o trabalho. Nanite leva a carga de conhecimento em engenharia que a EngineYard possui, e apesar de não ter uma solução baseada especificamente na questão de threads pode servir para distribuir instâncias do servidor entre várias maquinas numa rede local (lógico que não é – e nem pretende ser – uma implementação do MapReduce). Ainda preciso fazer um bom teste com Nanite e conhecer soluções como NeverBlock. De qualquer forma, essas são boas soluções para o problema de escalabilidade. Pode confiar

Abaixo o código (experimental) que derrubou um IIS (inclusive expondo pedaços da aplicação). Ele mostra como eu usei o máximo da banda disponível para fazer tantas requisições em um servidor remoto até ele cair. Isso com somente um processo Ruby.

Em casos comuns o gargalo seria do script Ruby que faz as requisições no outro servidor, no caso desse script eu tranformei o gargalo em banda e na capacidade do outro servidor de me responder. Situação bem melhor do que gargalo na requisição em si.

Ouvi dizer que essa não é a maneira mais fácil de lidar com o problema, certamente no Ruby NeverBlock é uma solução legal. Como eu disse, preciso olhar com atenção.

Boa parte do código serve para estimar o tempo necessário para conclusão da tarefa e para exibir quanto tempo cada Thread está levando.
O ideal é achar um bom número para colocar no método join da Thread. Tente deixar esse número um pouco acima do tempo médio que o servidor remoto (ou serviço externo) responda tranquilo suas requisições sem cair no mesmo problema de bola de neve. O grande segredo do código está nesse valor e você precisa ajustar ele para sua realidade.

Notas da brincadeira:

• Prefira utilizar Ruby 1.8.6. A documentação do 1.8.7 não está muito real. Principalmente com bibliotecas, onde enfrentei um probleminha com as classes Date e Time no 1.8.7.
• Cuidado com comparação de Floats (principalmente se tratando de datas), Floats são números muito mais complexos do que parecem.
• Hadoop

A época de ouro do Apache parece ter acabado há algum tempo. Após muitos anos sendo o servidor de aplicações para Web mais usado (na realidade ainda sendo o mais usado), o market-share do Apache está em queda há algum tempo segundo o Netcraft.

Mas eu não vim aqui para enterrar o coitado do Apache, provavelmente já fizeram muito disso por aí… sem necessidade na minha opinião. Muitos problemas ainda podem ser resolvidos com ele, sem contar que é muita falta de consideração jogar pedra em quem te alimentou por todo esse tempo (mais de 10 anos) não é?

Estou aqui para falar das entrelinhas no levantamento de Junho da Netcraft. Mais precisamente quando eles expõem o seguinte: “nginx mais que dobrou em números; com um ganho de mais de 1 milhão de sites”.

Nginx

Nginx para quem não sabe é um servidor web escrito pelo russo Igor Sysoev que também pode ser usado como proxy reverso ou e-mail proxy (fique ligado no RSS para receber atualizações sobre proxy reverso).

Dentre as vantagens do engine X (pronúncia de nginx) estão:

• estável
• configuração simplificada
• baixo consumo de recursos

Baixo consumo de memoria pode à primeira vista significar performance, mas nginx vai além, sendo desenvolvido para solucionar um grande problema de escalabilidade. Para isso possui um modelo de IO assíncrono e o já citado baixo consumo de memória que retornam além de performance, escalabilidade.

Trust Me / Thin

Há algum tempo atrás quando os widgets da boo-box foram para o ar eu não fazia idéia do poder do nginx. Sendo mais sincero do que deveria: ele só estava sendo usado pois era a opção que eu e o Maurício conhecíamos para colocar o nosso Merb no ar.

Logo no começo ele era um load balancer para um par de Mongrel em esquema Round-Robin, mas tão logo as requisições começaram a aumentar algo precisou ser feito.

Ezra Zygmuntowicz da EngineYard já havia enfrentado um problema com o modelo Round-Robin usado pela versão estável do nginx, então criou um patch para resolver isso com Fair queuing (ou quase isso).

A solução de Ezra foi de grande ajuda, pois o ponto mais díficil de escalar na aplicação que usei de exemplo é a ocorrencia de muitas requisições longas que ficam aguardando retorno de outras APIs, tornando Round-Robin impossível uma vez que algumas requisições poderiam cair em uma instância ocupada. Round-Robin não se importa se a instância está ocupada ou não e manda a requisição para fila da mesma forma e Fair resolve isso enviando requisições somente para instâncias desocupadas. Ponto para o nginx e sua crescente comunidade.

Mas outro problema é que uma vez que mais e mais requisições lentas vão entrando no sistema as instâncias ativas de Mongrel tendem a acabar. A solução poderia ser adicionar mais e mais instâncias até acabar com a memória ou com sobrecarregar a interface TCP/IP, uma vez que Mongrel não consegue trabalhar com Unix Sockets.

A solução então está sendo trabalhar com Thin, um ótimo webserver Ruby. Thin é uma solução alternativa ao Mongrel que merece um artigo dedicado, então o que posso dizer dele por enquanto é que suporta Unix Sockets (isso é bom) e tem um custo baixo de memória, possibilitando rodar várias instâncias diminuindo o desperdício de recursos.

Não estou muito certo quanto a possibilidade de se rodar qualquer aplicação Rails nele, mas de uma coisa eu sei: Merb + Thin + Nginx estão me deixando dormir tranquilamente. Se você ainda não conhece essas excelentes ferramentas do mundo Ruby acredite em mim, conheça.

Ps: nginx não é exclusivo do ambiente Ruby, ele é um proxy reverso que pode trabalhar com outras linguagens como PHP.

Ps 2: Phusion Passenger parece ser uma ótima opção para rodar Rails, mas mesmo suportando Rack não estou certo (fico devendo o benchmark) se haveria ganho para rodar Merb.