Este artigo foi traduzido por máquina.

Azure Insider

Microsoft Azure e Open Source Power Grid Computing

Bruno Terkaly
Ricardo Villalobos

Imagine a construção de sua própria plataforma de computação de grade que utiliza Microsoft Azure e um grande número de dispositivos conectados. O objetivo é alavancar o poder de computação excesso encontrado em navegadores modernos, envio uma pequena quantidade de código JavaScript e dados para realizar um trabalho de computação de cada cliente. Após a conclusão, cada dispositivo conectado a esta rede envia os resultados para um servidor central que residem no Azure.

Há algo assim realmente no lugar — a busca de um projeto de Inteligência Extra terrestre (SETI). A busca por vida extraterrestre usa uma grade em grande escala ou computação distribuída pela Internet. Ele monitora espaço para sinais de transmissões de civilizações alienígenas através da análise de radiação eletromagnética no espectro de microondas. É um bom exemplo do poder da computação em grade.

Grade de uso geral

Na coluna deste mês, vamos criar uma grade mais polivalente, sistema de computação. Isto deixa-nos enviará o código específico e dados que queremos executados em cada nó de grade. Para este projeto, cada navegador cliente receberá um pedaço de JavaScript juntamente com as informações a serem processadas. Isto permite-nos mais precisamente controlar a tarefa executada no navegador. O exemplo que apresentaremos resolve muitos problemas de computação de propósito geral que podem surgir no contexto da computação em grade.

A génese deste trabalho surgiu a participação da Microsoft em um dos hackathons maior do mundo, a Tech Crunch Disrupt 2013. Microsoft ficou em terceiro lugar de 280 equipes. Você pode ver toda a solução em tcrn.ch/OkIchx.

O desafio em uma competição como esta é que você só tem dois dias para completar um projeto antes dos juízes entram e te abater. Além de lidar com a privação de sono, você tem que aproveitar como muitos componentes pré-construídos possível para concluir o projeto a tempo. Mais, se não todos, da tecnologia utilizada na competição foi baseada em software de código aberto rodando no Azure. As tecnologias de código aberto usadas incluíam Jade, Express, Socket.io, Bootstrap, jQuery e node. js.

Web Sockets

Nós dependia fortemente o agora ubiquitous Web Sockets padrão. Soquetes Web fazem parte da iniciativa de HTML5. Eles fornecem uma conexão bidirecional full-duplex sobre os quais você pode transmitir mensagens entre cliente e servidor. Web Sockets permitem uma abordagem padronizada para o servidor enviar conteúdo para o navegador sem ser explicitamente solicitado pelo cliente.

Este deixe nos trocar mensagens e para trás, mantendo a conexão aberta — criação de comunicação completa e orquestração, que é uma capacidade necessária para uma sistema de computação em grade. Navegadores modernos de hoje, como o Firefox 6, 6 Safari, Google Chrome 14, 12.10 Opera e Internet Explorer 10 (e posterior) universalmente suportam Web Sockets.

Papel da Web Sockets

Web Sockets começam a trabalhar quando o cliente envia uma solicitação de aperto de mão de tomada de Web para o servidor na forma de uma solicitação HTTP GET. Com soquetes de Web, o que se segue o aperto de mão não se conforma ao protocolo HTTP padrão. Quadros de texto de dados em full duplex são enviados para a frente e para trás, com cada quadro de texto que representa uma carga acompanhada de um pequeno cabeçalho. Você pode dividir mensagens maiores em vários quadros de dados.

O encanamento do soquete da Web tenta detectar se há um agente de usuário configurado, que iria deixá-lo a estabelecer um túnel de comunicação persistente. Na nossa implementação, o agente de usuário é simplesmente um campo no cabeçalho HTTP usado para enviar uma solicitação HTTP especial que basicamente diz: "Mudar para Web Sockets." Neste artigo, usaremos Web Sockets para enviar executável JavaScript e dados para cada cliente da Web. Concluído o trabalho, usaremos o Web Sockets para enviar resultados computacionais para o servidor de Node. js. Esta é a parte fundamental da nossa arquitetura que nós explicaremos mais tarde.

Executar o projeto inteiro se é muito fácil. Você pode ver um breve vídeo que mostra o projeto em ação no 1drv.ms/1d79pjo. Antes de assistir o vídeo, você pode pegar todo o código do GitHub em bit.ly/1mgWWwc. Como configurar o projeto para executar é simples com node. js:

1. Iniciar instalando node. js do nodejs.org
2. Instalar o Git (git-scm.com) ou GitHub (github.com)
3. Clonar seu garfo com um clone Git (bit.ly/1cZ1nZh)
4. Instalar o Gerenciador de pacotes (NPM) do node. js no diretório clonado
5. Iniciar NPM para executar

Você precisará instalar os vários pacotes de Node. js, destacados nesta coluna. Você pode baixar os pacotes usando o NPM em npmjs.org. Você também pode aprender como instalá-los com um clique-direito no Visual Studio no bit.ly/OBbtEF. Para saber mais sobre como usar o Visual Studio com node. js, confira o post no blog de Bruno, "Getting Started com node. js e Visual Studio(bit.ly/1gzKkbj).

Concentre-se em App.js

A solução final que criamos na verdade tem dois processos do lado do servidor. O primeiro e mais óbvio do lado do servidor processo é aquele que está quebrando o grande trabalho de computação em pedaços menores e distribuir o trabalho e os dados para o navegador cliente conectado. Você encontrará esse código em App.js.

Há um segundo processo de lado do servidor que fornece um portal para gerenciamento de experiência e visualização da computação grandes trabalhos em execução na rede. Você encontrará esse código em Server.js. Ele fornece uma experiência de painel de controle em tempo real, completo com live atualização de gráficos e números através de um navegador (ver Figura 1). Nossa coluna irá focar o código App.js.

Figura 1 arquitetura de rede de alto nível

Detalhes de orquestração

Node. js fornece alguns surpreendentemente poder­ful abstrações que ajudá-lo a montam uma implementação elegante. Primeiro, você precisa resolver o problema do envio de um pedaço de código JavaScript que você deseja executar como parte do trabalho grande grade. Você também precisa enviar alguns dados código usará o Javascript.

Você pode usar o pacote de Node. js Express e Socket.io para realizar essa tarefa. Não é o suficiente para enviar apenas um pedaço de código JavaScript e dados para o navegador. Você ainda precisa de uma maneira de executar o código contra os dados e enviar o resultado para o servidor. Você pode resolver isso com o módulo Index.jade. Isto significa que há uma segunda parte do código JavaScript para gerenciar a execução do código da grade em si.

Três pacotes de nó (juntamente com alguns pacotes de apoio) simplificam a implementação desta arquitetura. Por exemplo, o pacote é um pacote popular que ajuda com rotas de URL, manipulação de solicitações e vistas. Ele também simplifica as coisas tais como a análise de cargas, cookies e armazenar as sessões.

Outro poderoso pacote é Socket.io, que abstrai a distância Web Sockets e inclui características convenientes, tais como transmissões e difusões seletivas. Socket.Io permite-lhe configurar a comunicação bidirecional usando código JavaScript sintaticamente idêntico sobre o navegador e o servidor. Socket.Io gerencia o JavaScript que é executado no navegador e o servidor. Isto é precisamente o que acreditamos que faz node. js grande. Não há nenhum contexto mental de comutação com escrita JavaScript que é executado no servidor contra o cliente.

Node. js é integrado firmemente com Jade, que agiliza o processo de criação de uma interface Web. Jade fornece uma abordagem baseada em modelo para criar o HTML, além de conter a orquestração de código JavaScript que gerencia a comunicação entre o servidor e o navegador (cliente).

Tomados em conjunto, todos os pacotes referenciados no Figura 2 reduzirá drasticamente a quantidade de código que você tem que escrever. Um bom desenvolvedor de Node. js entende a linguagem e os recursos internos. Um grande desenvolvedor de Node. js está familiarizado com os vários pacotes e é hábil em usá-los de forma eficiente. Faz um favor e familiarize-se com a biblioteca de módulos empacotados de Node. js em npmjs.org.

Figura 2 a comunicação bidirecional de arquitetura em grade

Lógica bidirecional

Em última análise, a orquestração entre cliente e servidor é nada mais do que a lógica de bidirecional de máquina de estado. Por exemplo, o cliente pode estar em um estado de espera para o código JavaScript ou pode ser em um estado de espera para os dados a serem recebidos.

O lado servidor terá Estados correspondentes, tais como o estado remetente de JavaScript ou estado envio de dados. Você observará instruções no código node. js, tais como "Socket.on ("algum estado")," indicando que o servidor está esperando para receber uma seqüência de caracteres mágica para provocar uma mudança de estado (ver Figura 3). Então pode responder adequadamente a esse evento.

Figura 3 listagem parcial em App.js para criação de pacotes de Node. js

// Setup libraries.
var express = require('express');
var routes = require('./routes');
var user = require('./routes/user');
var http = require('http');
var path = require('path');
var socketio = require('socket.io');
var app = express();
var azure = require('azure');
var fs = require('fs')
// Code omitted for brevity.
// Let Jade handle the client-side JavaScript and HTML
app.set('views', __dirname + '/views');
app.set('view engine', 'jade');

Vamos começar examinando o código de configuração para o servidor de Node. js -­processo de lado. O fluxo de trabalho começa quando o servidor abre uma porta e espera por conexões. Ambos Express e Socket.io deixem o servidor escutar conexões de entrada de navegadores em Porto 3.000:

// Create a Web server, allowing the Express package to
// handle the requests.
var server = http.createServer(app);
// Socket.io injects itself into HTTP server, handling Socket.io
// requests, not handled by Express itself.
var io = socketio.listen(server);

Enviar JavaScript para o navegador

Uma vez que a conexão é estabelecida, o servidor aguarda por uma mensagem do cliente que indica que o cliente está pronto para receber um código JavaScript através da conexão de soquete de Web. O código na linha nove em Figura 4 representa o servidor esperando a conexão tomar o lugar e para o cliente enviar a seqüência de caracteres "pronto para o trabalho", indicando que o servidor o JavaScript deve ser enviada para o cliente.

A Figura 4 lista parcial de codificar Server-Side que distribui dados para navegadores da grelha e JavaScript

(001) // Code Part 1
(003) // Wait for the browser to say it’s ready for the job.
(005) // If it is, send the JavaScript to the grid node for execution.
(007) // Do the same thing for the data being sent to the browser.
(009) io.on('connection', function(socket) {
(011)   socket.on('ready for job', function() {
(013)     clients++;
(015)     socket.emit('job', 'function process(message){function isInRange(origin,target,range){function toRad(deg){return deg*Math.PI/180}function getDistance(origin,target){var R=6371;var delta={lat:toRad(target.lat-origin.lat),lon:toRad(target.lon-origin.lon)};var start=toRad(origin.lat);var end=toRad(target.lat);var a=Math.sin(delta.lat/2)*Math.sin(delta.lat/2)+Math.sin(delta.lon/2)*Math.sin(delta.lon/2)*Math.cos(start)*Math.cos(end);var c=2*Math.atan2(Math.sqrt(a),Math.sqrt(1-a));return R*c}return getDistance(origin,target)<range}function parseData(data){var parts=data.split(",");return{lat:parts[parts.length-1],lon:parts[parts.length-2]}}var target=parseData(message.body);var origin={lat:37.769578,lon:-122.403663};var range=5;return isInRange(origin,target,range)?1:0}');
(017)   });
(018)
(021) // Code Part 2  Sending data to the browser for processing
(023) // when 'ready for data event' fires off.
(025)   socket.on('ready for data', function() {
(027)     socket.isClient = true;
(029)     sendDataToSocket(socket);
(031)   });
(032)
(035) // Code Part 3 - retrieving the results of the computation.
(037) // A more thorough implementation will aggregate all the
      // results from all the browsers to solve the large computational
(039) // problem that has been broken into small chunks for each browser.
(041)   socket.on('results', function(message, results) {
(043)     messageCount++;
(045)     crimesInRange += results;
(047)   });
(048)
(051) // Code Part 4 - A basic method to send data to a connected
      // client with a timeout of 77 ms.
(053) function sendDataToSocket(socket) {
(055)   var data = lines.shift();
(057)   lines.push(data);
(059)   setTimeout(function() {
(061)     // To one client, singular
(063)     socket.emit('process', {
(065)                                        body: data
(067)     });
(069)   }, 77);
(071) }

Neste ponto, estamos quase lá. O cliente ainda precisa solicitar os dados para processar. O código é algum código trigonométrico básico para calcular a distância entre dois pontos usando coordenadas GPS. Você pode substituir qualquer código JavaScript que você quer aqui.

O código na parte dois representa o estado em que o servidor aguarda a "pronto para dados" de seqüência de caracteres na linha 25 em Figura 4. Isso sinaliza a solicitação do navegador de dados. O JavaScript enviado anteriormente na primeira parte irá processar esses dados. O código na parte três representa o estado em que o navegador do cliente terminou de cálculos sobre os dados enviados. Quando o servidor recebe os resultados de seqüência de caracteres na linha 41, está pronto para incorporar o resultado final do que o navegador para o trabalho de computação. Neste momento, o navegador pode ser enviado outro trabalho para fazer mais processamento, repetindo o ciclo.

O mecanismo de Jade

Jade é um produtivo motor de visualização e modelagem HTML integrado em node. js. Jade simplifica bastante a marcação e JavaScript que você escreve para o navegador. Figura 5 mostra a linguagem de marcação de Jade que define a interface do usuário.

Figura 5 Jade define a interface do usuário

// Part 1
// This UI markup gets translated into real HTML
// before running on the client.
block content
  h1= title
  p This is an example client Web site.
Imagine a beautiful Web site without any advertisements!
p This page is processing
    span#items
    |  jobs per second.
// Part 2
// This is the client-side JavaScript code.
script.
var socket = io.connect();
    var job = function(id, data) {  };
    var createFunction = function(string) {
      return (new Function( 'return (' + string + ')' )());
    }
    var items = 0;
    function calculateWork() {
      $('#items').text(items);
      items = 0;
    }
    setInterval(calculateWork, 1000);
    socket.on('connect', function() {
      socket.emit('ready for job');
    });
    socket.on('job', function(fn) {
      job = createFunction(fn);
      console.log(fn);
      console.log(job);
      socket.emit('ready for data');
    });
    socket.on('process', function(message) {
      var results = job(message);
      items++;
      socket.emit('results', message, results);
      socket.emit('ready for data');
    });

Primeiro, ele simplesmente mostra o progresso do trabalho para o navegador. Em segundo lugar, é preciso que o JavaScript e os dados enviados pelo servidor. Isto representa o trabalho computacional necessária ao executar. Ele executa o trabalho, retornando os resultados para o servidor.

Se você já se perguntou como enviar JavaScript para um navegador para execução, Figura 5 representa o código que você precisará fazer isso. Se você quer saber mais sobre obras como Jade, recomendamos esta explicação brilhantemente simples no jade-lang.com. A linha inferior é que você pode codificar uma interface visual sem todo as complicado tags HTML, colchetes angulares e assim por diante.

Há outros aspectos deste projeto, que não temos a chance de cobrir. Uma das maiores peças é em Server.js, onde a experiência do portal vive e permite que você controle o progresso de todos os trabalhos de grade no processo. Inclui uma interface de usuário bonita é 100% baseada na Web. É um painel ao vivo, constantemente atualizando, completo com gráficos e tabelas. Também não abordamos os aspectos práticos da segurança e da ameaça de alguém seqüestro e modificando o JavaScript enviados para o cliente e fazendo mal.

Conclusão

Você pode adaptar tudo isso para outros problemas de computação de grade de uso geral. Pensamos que o mais importante tirar este artigo é o poder e a flexibilidade de Node. js. O repos no GitHub para node. js exceder a do jQuery, um poderoso testemunho de como o Node. js ressoa com desenvolvedor moderno de hoje.

Gostaríamos de agradecer a inicialização e parceiro evangelistas, cujo trabalho é para ajudar as empresas e os empresários compreender e utilizar a pilha de Microsoft e tecnologias relacionadas, muitas das quais estão abertas de origem. Warren Wilbee, Gerenciador de inicialização da região oeste, semeado a equipe Tech Crunch Disrupt com alguns dos seus melhores jogadores, incluindo Felix Rieseberg, Helen Zeng, Steve Siqueira, Timothy Strimple e Will Tschumy.

Bruno Terkaly is a developer evangelist for Microsoft. Seu profundo conhecimento é fruto de anos de experiência no campo, escrevendo código para uma grande quantidade de plataformas, linguagens, estruturas, SDKs, bibliotecas e APIs. Ele passa o tempo escrevendo código, blogar e fazer apresentações ao vivo na construção de aplicativos baseados em nuvem, especificamente, utilizando a plataforma Azure. Você pode ler seu blog em blogs.msdn.com/b/brunoterkaly.

Ricardo Villalobos é arquiteto de software experiente com mais de 15 anos de experiência projetando e criando aplicativos para empresas em várias indústrias. Segurando diferentes certificações técnicas, bem como um mestrado em Administração pela Universidade de Dallas, ele trabalha como arquiteto de nuvem na equipe DPE globalmente parceiros engajados para a Microsoft, ajudando as empresas em todo o mundo a implementar soluções em Azure. Você pode ler seu blog em blog.ricardovillalobos.com.

Terkaly e Villalobos conjuntamente apresentar conferências da indústria em geral. Eles encorajam os leitores do Azure Insider contatá-los para disponibilidade. Terkaly pode ser contatado em bterkaly@microsoft.com e Villalobos pode ser contatado em Ricardo.Villalobos@microsoft.com.

Agradecemos aos seguintes especialistas técnicos da Microsoft pela revisão deste artigo: Gert Drapers, Cort Fritz e Tim Park