Aplicações tolerantes a falhas em Node.js

Como parte da minha busca contínua para desenvolver a Skynet, tenho mergulhado na computação distribuída.

No Nodejitsu, nossas plataformas de hospedagens Node.js lidam com milhares de servidores ativos distribuídos através de múltiplos data-centers. Com o aumento da escala, pequenas probabilidades estatísticas tornam-se problemas muito reais. A rede não é confiável, os discos se tornam não-graváveis, conexões se rompem, a entrada inesperada é inesperada, e data-centers inteiros podem ir abaixo.

Pense assim:

Se você tem mil servidores e cada um for individualmente avaliado, em média, em 99,9% no tempo de atividade, uma dessas máquinas está sempre falhando.

Por isso, pesquisamos …

• Sistema tolerante a falhas
• Falácias da Computação Distribuída
• Propriedades de sistemas distribuídos
• Cálculo de disponibilidade de alta porcentagem

e pesquisamos mais …

• Arquitetura não compartilhada
• Tolerância a falhas bizantinas
• Paxos

Eventualmente, esbarramos com o problema de desligamento:

Dada a descrição de um programa de computador, decida se ele terminará de ser executado ou continuará a rodar para sempre. Em 1936, Alan Turing provou que não é possível existir um algoritmo geral para resolver o problema da parada para todos os possíveis programas de entrada pares.

Para resumir todos esses links no contexto deste artigo: é matematicamente impossível que a sua aplicação distribuída não vá estragar. Aprenda a lidar com isso.

Estratégias básicas em aplicações de construção tolerantes a falhas no node

1. A RAM, os processos e os descritores de arquivo do sistema operacional são relativamente baratos. Use-os quando necessário.
2. Use JSON para passar dados entre os nodes. (veja: nssocket ou dnode).
3. Adote o design crash-only. Nodes devem ser capazes de desligar, reiniciar e reconectar o mais rápido possível com um impacto mínimo.
4. Nunca assuma que qualquer processo de um node nunca vai deixar de funcionar. Assuma que qualquer processo pode ir abaixo, por qualquer motivo, a qualquer momento.

O último ponto é particularmente importante. Se o seu aplicativo não é capaz de se recuperar de uma queda de um node “central” então ele não deve ser considerado tolerante a falhas.

hook.io

O hook.io é um framework distribuído de entrada/saída para o Node.js. Ele permite que você interligue facilmente vários processos e inicie o envio de mensagens entre eles. O hook.io também fornece uma rica rede de ganchos de bibliotecas autônomas para adição de fontes adicionais i/o. Em certo sentido, o hook.io pode ser descrito como uma próxima geração de empresas de serviços de barramento.

• Lista de e-mail: http://groups.google.com/group/hookio
• Vídeoaulas: http://www.youtube.com/maraksquires (espelho)
• Páginas wiki: https://github.com/hookio/hook.io/wiki/_pages
• hook.io para leigos
• # nodejitsu em irc.freenode.net

Paxos básicos

Paxos são uma família de protocolos para solucionar o consenso em uma rede de processadores não-confiáveis. Consenso é o processo de chegar a um acordo sobre um resultado entre um grupo de participantes. Esse problema torna-se difícil quando os participantes ou seu meio de comunicação enfrentam falhas.

A partir da v0.8.6, o hook.io tem a capacidade de fazer um consenso básico entre todos os ganchos para garantir a recuperação, caso algum deles venha a falhar.

Nas versões anteriores do hook.io, se o “mestre” ou gancho servidor “central” falhassem, todos os outros ganchos deixariam de se comunicar.

Agora, o hook.io é capaz de recuperar o gancho servidor “central” que estiver falhando.

Anteriormente, quando o cubo desaparecia, nenhum dos raios sabia onde se conectar mais.

Construindo uma aplicação Node.js tolerante a falhas com hook.io

O hook.io pode ser usado como um programa ou como binário independente. Para simplificar, vamos supor neste exemplo que você esteja usando hookio como uma aplicação binária, e com ele todas as suas configurações padrão.

Para mais exemplos de utilização hook.io programaticamente, verificar os exemplos ou pastas de teste.

Para instalar hook.io com npm

Agora, vamos iniciar três instâncias de hookio em nosso terminal.

Terminal 1

npm install hook.io -g

Terminal 2

hookio

Terminal 3

hookio

Usando a funcionalidade padrão de autodescoberta do hook.io, o primeiro terminal assumirá o papel de servidor, e os segundo e terceiro terminais se conectarão como clientes para o primeiro terminal.

Agora, termine primeiro gancho terminal com CTRL-C. O segundo assumirá a função do servidor. O terceiro gancho saberá agora como conectar ao segundo em vez do primeiro.

Pode não parecer muito impressionante, mas demonstra um exemplo básico de como construir aplicações tolerantes a falhas de multi-processamento distribuídos em Node.js.

Os aplicativos criados com hook.io agora não têm ponto central de falha. Mas espere, há mais!

mdns

Multicast DNS (MDC) é uma maneira de usar interfaces de programação de DNS, formatos de pacotes e semântica de operação em uma rede pequena, onde nenhum servidor DNS está em execução. O protocolo mDNS é usado pelos sistemas de descoberta de serviços Bonjour da Apple e Linux Avahi. mdns é uma maneira fácil de ajudar dispositivos de rede a encontrar uns aos outros sem qualquer configuração prévia.

A partir da v0.8.6, hook.io tem suporte alfa para nenhuma configuração de rede via mdns. Isso significa que se você usar hookio-m em duas máquinas na mesma rede local… elas se encontrarão e, imediatamente, começarão a se comunicar sem qualquer configuração!

Computador A

hookio -m

Computador B

hookio -m

Agora, esses dois computadores (conectados por meio de uma LAN, sem nenhum servidor DNS central) irão se descobrir automaticamente e começarão a transmitir mensagens.

Pense nas possibilidades!

Conclusão

Com os novos recursos de mdns e Paxos, o hook.io está ficando melhor a cada dia. A meta atual é estabilizar essa nova funcionalidade no ramo 0.8.x em todas as plataformas.

Os próximos passos serão ganchos rastreadores p2p e serviços de hospedagem para ganchos…

?

Texto original disponível em http://blog.nodejitsu.com/fault-tolerant-applications-in-nodejs