Implementando o Gearman em múltiplos ambientes

O serviço Gearman de software livre permite distribuir facilmente o
trabalho para outras
máquinas na sua rede, se desejar espalhar o trabalho por um corpo
grande
de máquinas ou se desejar compartilhar a funcionalidade de
diferentes linguagens e ambientes com outras máquinas. Neste artigo,
serão apresentados usos típicos do Gearman e as maneiras de resolver uma
variedade de problemas e complicações em aplicativos modernos. Será
mostrado também como Gearman pode ser combinado com outras ferramentas,
como o memcached, para ajudar a acelerar o aplicativo e os requisitos de
processamento.

Introdução

Um dos grandes desafios do ambiente moderno de computação é a
distribuição e o uso efetivo dos recursos de computação. A tendência
geral da computação, no momento, é tão extensa que se pode instalar uma
máquina potente, facilmente e com baixo custo, para executar uma tarefa
relativamente clara e simples, mas que não é possível obter o melhor uso
ou desempenho geral da máquina.

Da mesma forma, muitos aplicativos
possuem, atualmente, a necessidade de executar operações relativamente
pequenas, mas possivelmente centenas ou milhares de vezes, sem a
necessidade (ou a capacidade de uso) da potência de uma única máquina.

Conforme o tamanho das farms de computação aumenta, às vezes, há uma
necessidade de executar uma ação ou operação em todas essas máquinas
simultaneamente ou seletivamente para executar tarefas de instalação ou
administração.

Existem muitas soluções que podem ser usadas. Por exemplo,
a virtualização é uma maneira pela qual os computadores podem ser particionados para a obtenção do melhor
desempenho, mesmo que eles tenham seus próprios problemas e limitações. A ferramenta memcached,
que faz uso da memória sobressalente, e as soluções tipo
grade da nuvem IBM também suportam a provisão flexível de potência de
computação, de forma que ela possa ser usada em qualquer lugar.

O Gearman tem uma abordagem diferente porque fornece um mecanismo flexível para a distribuição de
tarefas discretas ao redor de um grupo de máquinas. Esse método permite escalar e
tornar mais eficiente o uso dos sistemas, ao mesmo tempo em que remove muita da complexidade de
produzir e suportar um sistema desse tipo.

Isso estende e expande muitas das
soluções, inclusive os ambientes de grade e mesmo os básicos dos serviços da Web, mas com uma
abordagem de distribuição prática. O que torna o Gearman útil em ambientes ou
ambientes da Web em que você deseja compartilhar e distribuir trabalho e pedidos. Ele também pode ser
usado para transferir e processar as informações em ambientes da Web, banco de dados e Amazon,
o que o torna ideal para suportar ferramentas como o IBM WebSphere ou as implementações do Amazon.

Fundamentos do Gearman

Existem muitos elementos no serviço Gearman que fazem dele mais do que apenas uma maneira de
enviar e compartilhar trabalho, contudo, o sistema principal é composto de três componentes: o
gearmand daemon (ou servidor de tarefa); clientes para submeter solicitações ao serviço Gearman
e trabalhadores, que executam o trabalho atual (A figura 1 demonstra).

Figura 1. Resumo do serviço Gearman

As plataformas do servidor gearmand executam uma função simples de
coleta de pedidos para trabalhar a partir dos
clientes e agir como um registro em que os trabalhadores possam
enviar as informações sobre os tipos de trabalho e a operação que eles
suportam. Diferente de um serviço de grade tradicional, em que os nós da
grade são designados para uma tarefa em particular e recebem trabalho
de um servidor de gerenciamento, no Gearman os trabalhadores pedem
trabalho para executar.

Essa distinção é importante porque as decisões sobre o que cada
trabalhador faz
não são necessárias. Não existe configuração, priorização ou outra
organização
necessária durante a distribuição de trabalho. Em vez disso, o
natural do sistema é que ele esteja
se autoexecutando e autogerenciando e, para muitas instalações, ele
requer bem pouca complexidade da estrutura básica que será inicialmente
descrita aqui.

Amostra de Gearman

A maneira mais fácil de ver o Gearman trabalhar é testar um aplicativo simples que faça uso
do serviço Gearman. Usaremos o Perl – confira a seção Recursos ao final do artigo
para fazer download – para os elementos trabalhador e cliente neste
exemplo, mesmo assim, vale a pena apontar que é possível combinar e
corresponder as linguagens para obter o máximo de um ambiente
específico.

Para iniciar, é necessário ter o servidor gearmand em execução. Para isso, é possível fazer o download da
origem, executar o script de configuração e preparar o servidor; a biblioteca libevent
é necessária para isso. Muitas distribuições Linux também têm componentes Gearman
disponíveis para a instalação sem o processo manual (consulte em Recursos mais informações sobre libevent e Gearman).

Depois de instalado, leia o serviço com as opções -vv da linha de comando para que seja possível ver o que servidor está fazendo, depois que você começou a usá-lo.

Para os componentes cliente e trabalhador, é necessário instalar o módulo Gearman CPAN, que inclui os módulos Gearman::Client e Gearman::Worker necessários para criar clientes e trabalhadores.

Para um trabalhador simples, vamos fornecer uma contagem básica de palavras.

Listagem 1. Trabalhador Simples do Gearman

use Gearman::Worker;<br />my $worker = Gearman::Worker->new;<br />$worker->job_servers('192.168.0.2:4730');<br />$worker->register_function('wordcount' => \&wordcount);<br />$worker->work while 1;<br /><br />sub wordcount<br />{<br />    my ($input) = @_;<br /><br />    my @words = split /\s+/,$input->arg;<br /><br />    return (scalar @words);<br />}

A primeira linha carrega o módulo, em seguida, você cria um novo objeto Trabalhador. O método job_servers,
então, registra um ou mais servidores de tarefa que serão contatados
para solicitar trabalho disponível. O endereço IP (é possível usar um
nome do host) e o número da porta foram especificados. Isso é
particularmente importante já que o número da porta padrão usada para o
Gearman mudou, e isso pode causar problemas com o sistema fora de
funcionamento.

Especificar a porta explicitamente contorna esse
problema. É possível especificar vários servidores de tarefa para
fornecer resiliência (mais de um servidor de tarefa significa que existe
um sobressalente para o caso de o inicial falhar) ou para distribuir
trabalhos diferentes com a mesma tarefa por diferentes grupos de
servidores.

O método register_function() associa uma função local
no script com o nome de uma tarefa. O nome da tarefa será usado
pelos clientes para solicitar
uma operação em particular. Um trabalhador pode executar inúmeras
tarefas e
talvez o mais importante, qualquer trabalhador pode executar um
grande número de tarefas diferentes.

Isso permite suportar uma tarefa
computacionalmente cara somente em máquinas que tiveram seus recursos
registrados para executar tal tarefa. Já que é o trabalhador que
solicita o trabalho para as tarefas que ele é capaz de executar, não
devem existir problemas relacionados à falta de capacidade de um
trabalhador de executar uma tarefa delegada.

A peça final, o método work() , alterna o trabalhador para que ele possa iniciar os pedidos de processo. No exemplo, a condição loop significa que o trabalhador continuará processando pedidos até que o programa seja finalizado.

O resto do script é a própria função. Nesse caso, você toma a entrada
fornecida pelo cliente como primeiro argumento (usando o método arg()
para obter o seu valor), divide esse valor com um espaço em branco, e
então, retorna a conta de números inteiros dos itens no array. Está um
pouco mais detalhado do que o necessário para que as etapas sejam
demonstradas com mais facilidade.

No lado do cliente, algumas das mesmas etapas básicas ocorrem. Você cria um objeto Cliente do Gearman, especifica os servidores e chama a tarefa que deseja executar. É possível ver mais claramente na Listagem 2.

Listagem 2. Criando um objeto Cliente do Gearman

use Gearman::Client;<br />my $client = Gearman::Client->new;<br />$client->job_servers('192.168.0.2:4730');<br /><br />my $result = $client->do_task('wordcount','the quick brown fox jumps over the lazy dog');<br /><br />print "Words $result\n";

O do_task() é o método principal.
Ele executa a tarefa especificada (wordcount) e o dado
de argumento. O valor de resultado é retornado como uma referência,
assim é necessário desfazer a referência para obter a contagem de
palavras solicitada.

Agora, é possível fazer o teste iniciando o gearmand. Se forem usadas três opções -v
, são obtidas informações sobre o registro e as conexões, conforme a
Listagem 3, o que mostra que o gearmand foi iniciado e o script do
trabalhador foi registrado.

Listagem 3. Iniciando o gearmand

$ gearmand -vvv<br /> INFO Starting up<br /> INFO Listening on 0.0.0.0:4730 (6)<br /> INFO Creating wakeup pipe<br /> INFO Creating IO thread wakeup pipe<br /> INFO Adding event for listening socket (6)<br /> INFO Adding event for wakeup pipe<br /> INFO Entering main event loop<br /> INFO Accepted connection from 192.168.0.2:47158<br /> INFO [   0]     192.168.0.2:47158 Connected<br /> INFO [   0]     192.168.0.2:47158 Disconnected<br /> INFO Accepted connection from 192.168.0.2:47159<br /> INFO [   0]     192.168.0.2:47159 Connected<br /> INFO [   0]     192.168.0.2:47159 Disconnected<br /> INFO Accepted connection from 192.168.0.2:47160<br /> INFO [   0]     192.168.0.2:47160 Connected

O trabalhador foi iniciado pela execução do script com o Perl, mas o trabalhador não produz
nenhuma saída. O cliente, por sua vez, retorna o número de palavras na
sentença, conforme a Listagem 4.

Listagem 4. Executando o script Perl para retornar o número de palavras em uma sentença

$ perl client.pl<br />Words 9

Tudo isso parece muito trabalhoso para a obtenção de uma simples
contagem de palavras. No entanto, tenha em mente que a máquina que faz a
manipulação do trabalhador e o cliente que envia o pedido poderiam
estar em diferentes lados do mundo ou, simplesmente, em diferentes
partes da mesma nuvem.

A Listagem 5 mostra a mesma saída, desta vez usando uma máquina diferente como cliente. Para
executar outro script, tudo o que é necessário são as bibliotecas do Gearman, os módulos de script e o próprio script.

Listagem 5. Mesma saída usando uma máquina diferente como um cliente

$ gearmand -vvv<br /> INFO Starting up<br /> INFO Listening on 0.0.0.0:4730 (6)<br /> INFO Creating wakeup pipe<br /> INFO Creating IO thread wakeup pipe<br /> INFO Adding event for listening socket (6)<br /> INFO Adding event for wakeup pipe<br /> INFO Entering main event loop<br /> INFO Accepted connection from 192.168.0.2:47158<br /> INFO [   0]     192.168.0.2:47158 Connected<br /> INFO [   0]     192.168.0.2:47158 Disconnected<br /> INFO Accepted connection from 192.168.0.2:47159<br /> INFO [   0]     192.168.0.2:47159 Connected<br /> INFO [   0]     192.168.0.2:47159 Disconnected<br /> INFO Accepted connection from 192.168.0.2:47160<br /> INFO [   0]     192.168.0.2:47160 Connected<br /> INFO Accepted connection from 192.168.0.2:56545<br /> INFO [   0]     192.168.0.2:56545 Connected<br /> INFO [   0]     192.168.0.2:56545 Disconnected<br /> INFO Accepted connection from 192.168.0.111:54307<br /> INFO [   0]   192.168.0.111:54307 Connected<br /> INFO [   0]   192.168.0.111:54307 Disconnected

Para entender como isso é útil, considere a flexibilidade atrás do
processo. Pode
parecer outra solução para funcionalidade do tipo serviços da Web.
Contudo, seria possível
ter 20 trabalhadores registrados e um cliente que pedisse apenas a
um deles que completasse o
trabalho. Não há necessidade de executar um deles ou usar um sistema
complicado de balanceamento de carga para decidir por você.

Usando o Gearman pelos ambientes

O servidor gearmand é escrito em C, o que o torna completamente móvel
em vários ambientes
UNIX e Linux. Ele é baseado em ferramentas de software livre comuns
(como o sistema de autoconstrução e configuração GNU), isso faz com que
ele seja implementável e utilizável em muitos ambientes.

As interfaces do cliente e do trabalhador estão disponíveis em um
host de linguagens, que inclui as linguagens de programação Perl
PHP, Python e Java e até mesmo através do shell
UNIX/Linux. Além disso, existem também UDFs para Drizzle, MySQL e
PostgreSQL para permitir a interação direta dentro desses bancos de
dados com o Gearman.

Contudo, você não está limitado à comunicação entre o mesmo
trabalhador e as interfaces de
cliente. É possível, por exemplo, chamar uma tarefa suportada por um
trabalhador Python e solicitar aquelas informações do script Perl
anterior. É possível ver o mesmo script de contagem de palavras em
Python na Listagem 6.

Listagem 6. Script da contagem de palavras em Python

from gearman import GearmanWorker<br /><br />def wordcount(input):<br />    words = input.arg.split(None)<br />    print words<br />    return len(words)<br /><br />worker = GearmanWorker(["127.0.0.1:4730"])<br />worker.register_function('wordcount', wordcount)<br />worker.work()

Executar o trabalhador e o cliente tem como resultado a mesma contagem de palavras.

Listagem 7. Executando o trabalhador e o cliente novamente

$ perl client.pl<br />Words 9

A vantagem disso é que é possível usar o Gearman a partir de uma variedade de ferramentas e integrá-lo
no aplicativo existente independente dos ambientes que são usados. Se
o aplicativo da Web é baseado em PHP, mas você deseja fazer uso da funcionalidade do
aplicativo no ambiente existente do WebSphere, é possível fazer isso através do Gearman pela
extensão da tecnologia Java com um trabalhador e pela chamada da tarefa correta do frontend da PHP.

Uma coisa com que se deve ter cuidado é o compartilhamento de dado. O Gearman não executa nenhuma forma de
tradução ou manipulação de dados trocados. Para cadeia de caracteres simples e de números inteiros
usada aqui, isso não é um problema, contudo, não se deve compartilhar um array de valores em
PHP e esperar que ela seja compreendida em linguagem Java.

Para esse tipo de
interação, é possível usar um dos muitos padrões de dados estruturados, como JavaScript
Object Notation (JSON) ou XML. Como alternativa, se estiver trabalhando com informações de
um banco de dados, basta compartilhar as informações necessárias de ID para localizar o dado que precisa
ser processado ou usar um método temporário como o memcached (embora ainda seja necessário o
JSON ou um equivalente).

Vamos dar uma olhada em mais alguns exemplos de implementações Gearman.

Implementando Gearman em ambientes dinâmicos

É óbvio que quando se tem um ambiente flexível assim, um ambiente
ideal para usá-lo
é aquele com uma nuvem flexível de servidores EC2 da Amazon, por
exemplo, ou uma
infraestrutura de grande escala existente, como uma farm de
servidores da Web em que você tem máquinas que podem ser subutilizadas
ou capazes de tratar de tarefas discretas pequenas.

Quando for usado um ambiente em nuvem, use a natureza flexível do
Gearman para aumentar os trabalhadores disponíveis quando precisar
deles. Para incluir trabalhadores no sistema Gearman é necessário,
apenas, executar o script do trabalhador durante o tempo de boot.

Assim, considere o layout na Figura 2. Temos um ambiente Gearman padrão
que usa o grupo padrão de trabalhadores que atendem as necessidades de seus
clientes.

Quando o carregamento no ambiente aumenta de repente, é possível
fazer o boot das instâncias do EC2, executar o script do trabalhador e registrar a
disponibilidade deles para fazer o trabalho e selecionar e processar as informações. As instâncias do
EC2 são, portanto, temporárias é possível registrar e
remover registro das instâncias conforme precisar delas.

Figura 2. Ambiente Gearman padrão usando um grupo de trabalhadores padrão

Isso pode ser realmente útil se houver processamento e preparação
envolvidos na
formulação das informações. Nesse caso, é possível criar as
instâncias do EC2, executar o trabalho pelo Gearman, coletar as
respostas e fechar as instâncias do EC2. Isso economiza crédito para
quando forem necessárias toneladas ou centenas de máquinas para que o
processo seja executado.

Usando o Gearman em extremidades de dados

Muitas vezes, existem casos em que é desejada a execução de alguma
operação em algumas informações, mas
o processamento não é de tempo crítico ou existe alguns termos de
distância (na rede, não física) entre a origem do dado e o destino.

Até então, foram mostradas maneiras de usar o Gearman onde era desejada e necessária uma resposta
imediata. O Gearman também inclui o recurso para iniciar um processo de segundo plano.
Isso ocorre quando o cliente em primeiro plano pede para que o trabalho
seja executado e não se preocupa com quando (ou mesmo se) a resposta
será retornada.

Considere um aplicativo da Web que tem um e-mail de registro enviado
durante o processo de registro.
Existem muitos problemas em potencial no envio de tal e-mail on-line
no momento em que o usuário
clica no botão Submeter no formulário da Web. Os problemas em
alcançar o servidor de e-mail ou apenas
no envio do e-mail em horários não disponíveis podem atrasar o
aplicativo da Web.

Com o Gearman, é possível
submeter a tarefa para a fila e deixar um dos trabalhadores tratar
do processamento real,
da formatação do e-mail e do envio, o que permite que a interface da
Web responda
instantaneamente. Esse é um bom exemplo de despacho de um processo
de segundo plano em que o frontend não precisa esperar por uma resposta.

O mesmo princípio pode também ser usado para outros elementos não
sensíveis ao tempo. Por exemplo,
se estiver fornecendo ou usando a integração com o Twitter, é
possível usar o Gearman para tratar da
postagem na conta do Twitter. Nesta instância, não é necessário que o
conteúdo seja instantâneo e, não necessariamente, os problemas na
execução da postagem atrasam o resto do aplicativo. Os serviços Gearman
permitem retornar a um estado de falha que garante que a tarefa será
recolocada na fila e tentada novamente.

É possível também usar o Gearman para tratar de banco de dados ou outras atualizações em que a natureza
instantânea da atualização não é vital, assim as informações não precisam ser gravadas no
banco de dados on-line.Nessa situação, é possível aproveitar os outros componentes no
arsenal moderno de aplicativos da Web, como o memcached.

Um bom exemplo é um aplicativo que processa conteúdo, como um
arquivador de documento no qual você desejar construir índices e outras
informações a partir do conteúdo. Mesmo que as filas tradicionais para
esse tipo de operação estejam disponíveis, o Gearman facilita a
disseminação e a distribuição dessas informações ao redor de um grupo de
máquinas e aumenta o desempenho do processo de indexação.

Um elemento que ajuda nessas situações é a combinação do
processamento Gearman com o memcached para permitir submeter o dado,
analisar e processá-lo, e em seguida, atualizar a versão em cache das
informações automaticamente.

Em um blog ou outro sistema de gerenciamento de conteúdo, é possível
usar esse elemento para permitir a
atualização e a publicação das informações instantaneamente pela
atualização da versão do memcached do conteúdo e pela atualização do
banco de dados em segundo plano ou pela atualização do banco de dados e
atualização da versão do lado do cliente do memcached para exibição logo
após a conclusão da gravação.

Ambas as soluções ajudam a reduzir o
conteúdo da gravação no banco de dados porque reduzem a gravação
simultânea, ao mesmo tempo em que melhoram a responsividade do
aplicativo de frontend.

Um exemplo de uso do memcached pode ser visto nas versões modificadas do cliente e
script do trabalhador nas Listagem 8 e Listagem 9.
O
cliente grava a cadeia de caractere a ser contada no memcached e o
trabalhador usa o ID fornecido pelo cliente para ler a cadeia, contar as
palavras e, em seguida, grava as informações de volta no memcached. Foi
usado um ID codificado permanentemente nesse caso, mas é possível usar
um ID originado do banco de dados ou UUID.

Listagem 8. Cliente baseado em memcached

use Gearman::Client;<br />use Cache::Memcached;<br /><br /># Set up memcached<br /><br />my $cache = new Cache::Memcached {<br />    'servers' => [<br />                   '192.168.0.2:11211',<br />                   ],<br />};<br /><br /># Set up Gearman<br /><br />my $client = Gearman::Client->new;<br />$client->job_servers('192.168.0.2:4730');<br /><br />#<br /># Obtain the information you want to process<br /># and generate a unique key<br /><br />my $id = 9334;<br /><br /># Write some metadata<br /><br />$cache->set(sprintf('doc-%d-srctxt',$id),<br />            'The quick brown fox jumps over the lazy dog');<br /><br />my $result = $client->dispatch_background('wordcount',$id);

A Listagem 9 mostra o script modificado do trabalhador.

Listagem 9. Trabalhador baseado em memcached

use Cache::Memcached;<br />use Gearman::Worker;<br /><br />my $cache = new Cache::Memcached {<br />    'servers' => [<br />                   '192.168.0.2:11211',<br />                   ],<br />    };<br /><br />my $worker = Gearman::Worker->new;<br />$worker->job_servers('192.168.0.2:4730');<br />$worker->register_function('wordcount' => \&wordcount);<br />$worker->work while 1;<br /><br />sub wordcount<br />{<br />    my ($arg) = @_;<br /><br />    my $id = $arg->arg;<br /><br />    print STDERR "Providing word count for ",$id,"\n";<br /><br />    my $string = $cache->get(sprintf('doc-%d-srctxt',$id));<br /><br />    if (!defined($string))<br />    {<br />        $cache->set(sprintf('doc-%d-status',$id),<br />                    'Error: Source text not found');<br />        return;<br />    }<br /><br />    my @words = split /\s+/,$string;<br />    $cache->set(sprintf('doc-%d-status',$id),<br />                'Complete');<br />    $cache->set(sprintf('doc-%d-result',$id),<br />                scalar @words);<br />}

Observe que no trabalhador, o script usa as entradas do memcached com
tag e de status para manter as informações, as falhas podem ser
gravadas no status. Isso permite que um cliente submeta novamente o
pedido de trabalho no caso de uma falha temporária.

Tendo em vista que o cliente não espera obter a resposta de volta, um
script separado é necessário para a obtenção das informações quando
estiverem prontas. A Listagem 10 mostra um script simples de cliente
para isso, identificando a presença de erros (e relatando-os) ou
relatando o resultado.

Listagem 10. Obtendo um resultado do memcached

use Cache::Memcached;<br /><br />my $cache = new Cache::Memcached {<br />    'servers' => [<br />                   '192.168.0.2:11211',<br />                   ],<br />};<br /><br />my $id = 9334;<br /><br />if ((my $result = $cache->get(sprintf('doc-%d-status',$id))) =~ m/Complete/)<br />{<br />    print "Count is ",$cache->get(sprintf('doc-%d-result',$id),),"\n";<br />}<br />else<br />{<br />    print "Result not ready: $result\n";<br />}

Para usá-lo, execute o script de trabalhador: $ perl workermemc.pl.
Em seguida, execute o script de cliente para submeter o pedido para a fila: $ perl clientmemc.pl.

É possível ver se o pedido foi concluído usando o script de recuperação.

Listagem 11. Script de recuperação

$ perl getresult.pl<br />Result not ready:

E é possível ver uma vez que o resultado estiver finalmente disponível.

Listagem 12. Um resultado final

$ perl client.pl<br />Words 9

É possível repetir isso com todos os tipos de dado e eventos e incluir gravação e recuperação de banco de dados no processo.

Conclusão

O Gearman é uma ideia simples que é fácil de usar e, ainda assim,
fornece uma grandeza de
funcionalidades, que vão desde simplesmente distribuir e
compartilhar a carga de trabalho até permitir
a interoperabilidade entre diferentes linguagens e ambientes de
implementação.O sistema de
fila permite utilizar essas funcionalidades e usá-las para melhorar o
desempenho do aplicativo e reduzir a carga no banco de dados e outros
componentes do servidor ao colocar em fila ou reduzir a simultaneidade
que normalmente causa problemas de desempenho no frontend.

Recursos

Aprender

• Visite Gearman.org para fazer download de informações e detalhes sobre as bibliotecas e interfaces disponíveis.
• JSON fornece uma maneira simples de trocar informações complexas.
• Leia “Distribua
  a carga de trabalho do seu aplicativo PHP com Gearman“, conheça o
  sistema de distribuição de trabalho Gearman e distribua a carga de
  trabalho dos aplicativos escritos em PHP, C, Ruby ou outras linguagens
  suportadas.
• Start your learning with Open Source:
  Leia essa entrada do blog do Chris Walden sobre a grandeza dos pacotes
  de software livre disponíveis para praticamente qualquer trabalho.
• “Making
  UNIX and Linux work together” é um guia que ensina como fazer com que distribuições tradicionais do Unix e Linux trabalhem juntas.
• Diferentes sistemas usam diferentes ferramentas e o IBM Redbooks intitulado “Solaris to Linux Migration: A Guide for System Administrators” ajudará você a identificar algumas ferramentas principais.
• Visite a zona de software livre
  do developersWorks para obter informações instrutivas abrangentes e
  atualizações de projetos para ajudar você a desenvolver usando
  tecnologias de software livre e usá-las com os produtos IBM, assim como
  os nossos tutoriais e artigos mais populares.

Obter produtos e tecnologias

• Faça o download do Servidor e bibliotecas do Gearman (0.13).
• Faça o download do Perl.
• memcached.org fornece informações sobre o memcached e como fazer o download e instalá-lo
• A interface Cache::Memcached para Perl fornece uma interface extensiva.
• Consulte a página da libevent para obter informações e instruções sobre o download dessa biblioteca.
• Inove seu próximo projeto de desenvolvimento de software livre com a versão de avaliação de software IBM, disponível para download ou em DVD.
• Faça o download do versões de avaliação de produto IBM
  ou explore
  as avaliações on-line no IBM SOA Sandbox e obtenha ferramentas de desenvolvimento de aplicativo e produtos de middleware do
  DB2, Lotus, Rational, Tivoli e WebSphere.

artigo publicado originalmente no developerWorks Brasil, por Martin Brown

Martin Brown é escritor profissional por mais de oito anos. Ele é o
autor de inúmeros livros e artigos sobre diversos tópicos. Seu
conhecimento vai desde as linguagens e plataformas de desenvolvimento

Perl, Python, Java, JavaScript, Basic, Pascal, Modula-2, C, C++,
Rebol, Gawk, Shellscript, Windows, Solaris, Linux, BeOS, Mac OS/X e mais

à programação da Web, gerenciamento de sistemas e integração. Martin é
colaborador assíduo do ServerWatch.com, do LinuxToday.com e do IBM
developerWorks; blogueiro regular no Computerworld, no The Apple Blog e
em outros sites; e ainda Subject Matter Expert (SME) da Microsoft. É
possível entrar em contato com ele pelo seu Web site
http://www.mcslp.com
.