Entenda o Representational State Transfer (REST) no Ruby

Desenvolva um cliente RESTful simples com Ruby

REST, ou Representational State Transfer, é uma arquitetura de comunicação distribuída que está rapidamente se tornando a linguagem comum para nuvens. Ela é simples, embora expressiva o suficiente para representar uma variedade de recursos de nuvem e configuração e gerenciamento gerais. Saiba como desenvolver um agente REST simples a partir do zero em Ruby para aprender sua implementação e uso.

M. Tim Jones, Independent author, Consultor

M. Tim JonesM. Tim Jones é arquiteto de firmware embarcado e autor de Artificial Intelligence: A Systems Approach, GNU/Linux Application Programming (agora em sua segunda edição), AI Application Programming (em sua segunda edição) e BSD Sockets Programming from a Multilanguage Perspective. Seu conhecimento em engenharia varia do desenvolvimento de kernels para naves espaciais geossíncronas até a arquitetura de sistemas embarcados e o desenvolvimento de protocolos de rede. Tim é arquiteto de plataforma da Intel e autor em Longmont, Colorado.



31/Ago/2012

A Representational State Transfer (REST) é um estilo de arquitetura para comunicação baseada na web que permite aos clientes conversar com os servidores de maneira única. Em particular, a REST representa recursos dentro de um dado servidor, como Identificador Uniforme de Recursos (URIs), simplificando a implementação de arquiteturas REST no Hypertext Transport Protocol (HTTP). Começaremos com uma introdução às ideias por trás de REST e HTTP. Então, exploraremos a representação de dados e implementaremos um cliente REST simples na linguagem Ruby.

Rápida introdução a HTTP

Começaremos com uma rápida introdução a HTTP, uma vez que é importante entendê-lo para as transações REST individuais. Embora HTTP seja o protocolo de comunicação de base que conecta navegadores da web a servidores, ele é um protocolo útil para transferir muitos tipos de dados além de HTML.

HTTP é um protocolo de solicitação e resposta—ou seja, os clientes fazem solicitações e os servidores atendem essas solicitações com uma resposta. O protocolo real para HTTP é bastante legível para humanos, e para demonstrar o HTTP, uso telnet para fazer uma solicitação a um servidor da web.

Solicitação de um navegador

Observe que a solicitação que eu fiz manualmente na Listagem 1 teria sido especificada como o URI http://www.mtjones.com/index.html. Um navegador da web divide esse URI para a solicitação em particular (como demonstrado na Listagem 1).

A Listagem 1 fornece uma solicitação HTTP e uma resposta parcial de um servidor da web. Eu inicio a solicitação I com o telnet especificando o nome de domínio do servidor da web e a porta (80 é uma porta HTTP típica). O Telnet responde primeiro com uma resolução de Sistema de Nomes de Domínio do nome de domínio para um endereço IP, e então, indica que estou conectado ao servidor da web. Então, especifico uma linha de solicitação (que contém meu método HTTP GET , um caminho para o recurso no servidor da web e o protocolo que estou usando— nesse caso, HTTP versão 1.1). A seguir, forneço um conjunto de cabeçalhos de solicitação (que podem ser bastante grandes, mas como eu estou digitando, simplesmente especifico o cabeçalho da solicitação de Host , que indica o host e a porta opcional da qual estou fazendo a solicitação). Minha solicitação é seguida por uma linha em branco, que indica ao servidor da web que minha solicitação está concluída. O servidor da web então fornece uma resposta, indicando o protocolo usado e fornecendo um código de status (nesse caso, 200 OK, indicando uma solicitação válida) e cabeçalhos de resposta adicionais. Uma linha em branco então aparece, seguida por 1.944 caracteres de resposta. Essa é uma representação do recurso— nesse caso, um documento HTML.

Listagem 1. Realizando uma transação HTTP com telnet
$ telnet mtjones.com 80
Trying 198.145.43.103...
Connected to mtjones.com.
Escape character is '^]'.
GET /index.html HTTP/1.1Host: example.org

HTTP/1.1 200 OK
Date: Sun, 25 Mar 2012 05:33:07 GMT
Server: Apache
Last-Modified: Sat, 26 Sep 2009 20:22:36 GMT
ETag: "2c984bf-798-d3451b00"
Accept-Ranges: bytes
Content-Length: 1944
Vary: Accept-Encoding
Content-Type: text/html

<DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" ...

Esse exemplo ilustra uma transação simples, mas vários métodos na verdade são implementados em HTTP. O método GET é usado para recuperar um recurso do servidor da web, enquanto HEAD é usado para obter somente metainformações sobre o recurso (não o conteúdo real). Um método POST é usado para fornecer novo conteúdo ao servidor da web, e o método PUT é usado para colocar dados para um recurso existente no servidor da web. A Tabela 1 fornece uma lista completa dos métodos HTTP

Tabela 1. Métodos de solicitação HTTP 1.1 comuns
MétodoIdempotenteDescrição
OPTIONSSimSolicitação de informações sobre as opções de comunicação
GETSimRecupera a representação para um URI
HEADSimRecupera metainformações para um URI
PUTSimCria ou substitui um recurso com uma representação
POSTNãoAumenta um recurso existente com uma representação
DELETESimExclui um recurso que o URI especifica

O que é importante observar com essa breve exploração de HTTP é que esse é um protocolo com suporte para operações básicas em recursos. Embora HTTP seja comumente usado atualmente para transferir conteúdo da web entre servidores e clientes, ele também é um protocolo cada vez mais usado para interações de sistema distribuído e para o desenvolvimento de interfaces de programação de aplicativos (APIs) que permitem a sistemas heterogêneos comunicar e compartilhar dados.

Agora observaremos a pilha de protocolo para explorar a camada REST.


O que é REST?

A força da REST

REST é um estilo de arquitetura, não um protocolo ou implementação. REST tem alguns princípios centrais, mas, no final, é uma abstração, não uma implementação específica.

REST é mais um estilo de arquitetura, e menos uma implementação ou design específico. Uma arquitetura RESTful é definida por um conjunto simples de restrições, ilustradas na Figura 1. . No centro de uma arquitetura RESTful está o conjunto de recursos. Esses recursos são identificados por URIs (como um Localizador Uniforme de Recursos [URL]) e uma representação interna (comumente uma forma de dados autodescritivos, que você explorará em breve). Por fim, há um conjunto de operações através das quais é possível manipular os recursos.

Figura 1. Visualização de alto nível de uma arquitetura RESTful
Visualização de alto nível de uma arquitetura RESTful

Em termos mais concretos, esses recursos podem representar objetos de dados usando uma variedade de tipos (como JavaScript Object Notation [JSON]). É possível abordar os recursos por meio de URLs (como http://www.mtjones.com) usando um conjunto de operações padrão (HTTP GET, POST, DELETE e afins). Usar HTTP como transporte simplifica muito o desenvolvimento das arquiteturas RESTful, porque elas usam um protocolo de base bem conhecido e estável. O HTTP também está amplamente disponível e não requer nova configuração para usar, incluindo serviços da Internet como gateways, proxies, entidades de aplicação de segurança e serviços de armazenamento em cache HTTP. Para deixar os servidores REST altamente escaláveis, é possível explorar outros recursos úteis, como balanceamento de carga.


Características de uma arquitetura RESTful

Embora as arquiteturas RESTful tenham liberdade considerável na sua implementação, um conjunto de características é importante.

A REST define uma arquitetura de cliente-servidor em que os clientes têm acesso a recursos do servidor através de uma representação que o servidor exporta. Os clientes não acessam os recursos diretamente, mas, em vez disso, uma representação do recurso através de uma interface uniforme. Como com muitas arquiteturas de cliente-servidor, a REST é implementada como uma arquitetura em camadas, permitindo a exploração das várias capacidades que as camadas inferiores (balanceamento de carga HTTP, etc.) fornecem.

Mas um aspecto essencial das arquiteturas RESTful é que elas são stateless. O servidor não pode manter nenhum contexto de cliente entre transações, e toda transação deve conter todas as informações necessárias para satisfazer a solicitação em particular. Essa característica tende a tornar as arquiteturas RESTful mais confiáveis e também ajuda a expandir sua escalabilidade.


Interface REST de amostra

Observe uma implementação REST de amostra para ilustrar algumas das características da arquitetura RESTful. Lembre-se de que a REST conta com interações de cliente-servidor (consulte a Figura 2). . Um aplicativo cliente faz uma solicitação que é convertida para uma solicitação HTTP RESTful. Essa solicitação é iniciada como qualquer outra transação HTTP de um cliente para um servidor. O servidor processa a solicitação e responde adequadamente.

Figura 2. Arquitetura em camadas de interações RESTful
Arquitetura em camadas de interações RESTful

Um exemplo interessante de uma API REST que é possível usar para desenvolver um cliente simples é o CrunchBase. O CrunchBase é um banco de dados gratuito de empresas, pessoas e investidores relacionados a tecnologia. Além de fornecer um front-end da web tradicional, o CrunchBase oferece uma interface baseada em REST/JSON sobre HTTP.

O CrunchBase implementa três ações através da sua API:

  • mostrar (para recuperar informações sobre uma entidade específica)
  • procurar (para recuperar uma lista de entidades que corresponde a um dado critério de pesquisa)
  • listar (para recuperar todas as entidades dentro de um dado namespace)

O CrunchBase também exporta cinco namespaces para seus dados —consulte a Figura 3—junto com o formulário da URL usado para interações REST do CrunchBase. (Os namespaces são empresa, pessoa, produto, organização financeira e provedor de serviços.) Observe que /v/1 indica a versão da API, que no momento é 1. Observe também o campo permalink , que indica o nome exclusivo das entidades dentro do banco de dados.

Figura 3. Namespaces na API do CrunchBase
Namespaces na API do CrunchBase

Se você desejasse obter informações atualizadas sobre a IBM, poderia desenvolver uma URL usando o namespace de empresa (experimente isto no seu navegador):

http://api.crunchbase.com/v/1/ibm.js

É possível digitar esta URL no navegador, e o navegador renderizará a resposta textual (baseada em JSON) para você (enquanto consome os cabeçalhos HTTP). Observe isso em mais detalhes enquanto explora a representação de dados do CrunchBase no formato JSON.


Introdução a dados autodescritivos

Comunicar-se entre sistemas heterogêneos apresenta alguns problemas interessantes, um dos quais é a serialização dos dados para transferência. As máquinas representam dados de diferentes maneiras (de diferentes representações de vírgula flutuante ao conflito de ordenação de byte padrão). Implementações anteriores incluíam o formato Abstract Syntax Notation (ASN.1) e o protocolo Representação Externa de Dados (XDR) (usado dentro do Sistema de Arquivos de Rede). Outras abordagens incluem XML, que codifica dados dentro de documentos formatados em ASCII.

Nos últimos seis anos, o formato JSON aumentou em popularidade. Como o nome implica, JSON foi derivado da linguagem JavaScript e é usado para representar estruturas de dados autodescritivas como matrizes associativas. Apesar do nome, JSON é um formato de intercâmbio de dados comum e tem suporte em uma variedade de linguagens. Também é fácil de ler.

Agora veja um exemplo de JSON, em particular— um através da interface REST do CrunchBase. Esse exemplo usa o shell Ruby interativo (irb), que permite experimentar com Ruby em tempo real.

Como mostra a Listagem 2, você começa executando o shell Ruby interativo. Você prepara o ambiente carregando alguns módulos (em particular, os componentes JSON e HTTP) e define o seu URI. Observe, aqui, que o URI é uma solicitação CrunchBase completa (no namespace de empresa, com um permalink de ibm). . Isso é fornecido ao método get_response de Net::HTTP, que é um atalho para realizar uma solicitação GET no URI especificado (analisado nos seus componentes individuais através do método URI.parse ). Se você emitir resp.body, poderá ver os dados JSON que foram retornados. Isso inclui um conjunto de pares de nome-valor (como "nome" e "IBM"). Use o método JSON.parse para analisar a resposta em uma estrutura de objeto Ruby. Por fim, extraia um valor em particular especificando seu nome.

Listagem 2. Interagindo com o CrunchBase usando Ruby
$ irb
irb(main):001:0> require 'rubygems'
=> true
irb(main):002:0> require 'json'
=> true
irb(main):003:0> require 'net/http'
=> true
irb(main):004:0> uri = "http://api.crunchbase.com/v/1/company/ibm.js"
=> "http://api.crunchbase.com/v/1/company/ibm.js"
irb(main):005:0> resp = Net::HTTP.get_response(URI.parse(uri))
=> #<Net::HTTPOK 200 OK readbody=true>
irb(main):006:0> puts resp.body
{"name": "IBM",
 "permalink": "ibm",
 "crunchbase_url": "http://www.crunchbase.com/company/ibm",
 "homepage_url": "http://www.ibm.com",
 "blog_url": "",
 "blog_feed_url": "",
 "twitter_username": "",
 "category_code": "software",
 "number_of_employees": 388000,
...
=> nil
irb(main):007:0> parsedresp = JSON.parse(resp.body)
=> {"updated_at"=>"Wed Feb 01 03:10:14 UTC 2012", "alias_list"=>nil, 
...
irb(main):008:0> 
irb(main):009:0* puts parsedresp['founded_year']
1896
=> nil
irb(main):010:0>

Na Listagem 2, é possível ver como foi fácil fazer o protótipo de uma extração rápida de dados de uma resposta JSON (sete linhas). Leve isso além agora e desenvolva uma API simples e reutilizável para interagir com o CrunchBase.


Desenvolvendo um cliente REST simples

Antes de desenvolver seu cliente REST, você deve instalar algumas coisas. Se não tiver Ruby instalada, instale-a. Como eu uso o Ubuntu, emprego a Ferramenta do Pacote Avançado para a maioria desses requisitos de instalação (e o gerenciador de pacotes de gem Ruby para outros).

Pegue o pacote Ruby com:

$ sudo apt-get install ruby

Opcionalmente, peque o Shell Ruby Interativo irb), que é uma maneira útil de experimentar com a linguagem Ruby:

$ sudo apt-get install irb

Por fim, a gem JSON é necessária para Ruby. O código a seguir mostra como obter tanto o front-end da gem e a gem JSON.

$ sudo apt-get install rubygems1.8
$ sudo apt-get install ruby-dev
$ sudo gem install json

Com seu ambiente pronto, comece a desenvolver a API do cliente REST com Ruby. Você viu na Listagem 1 como comunicar-se com um servidor HTTP em Ruby e como analisar um nome simples de um objeto JSON. Desenvolva com base nesse conhecimento um conjunto de classes Ruby que implementam uma API simples.

Primeiro, vejas as duas classes de amostra que interagem com o servidor REST do CrunchBase. A primeira foca em um namespace de empresa e a segunda foca no namespace de pessoa. Observe que ambas estendem um conjunto mínimo de métodos, mas são facilmente extensíveis para os outros elementos de dados.

A Listagem 3 fornece a API para interagir com o namespace de empresa. Essa classe estende um método construtor (initialize) e quatro métodos usados para extrair dados de um registro de empresa baseado em JSON. A teoria da operação para a classe é que o usuário cria uma instância do objeto, fornecendo um nome de empresa (permalink). Como parte do construtor, o CrunchBase é solicitado para o registro da empresa. Você desenvolve dinamicamente a URL, adicionando o nome da empresa enviado como parte do método new . O método get_response é usado para recuperar a resposta, e o resultado analisado (um objeto hash) é carregado para uma variável da instância (@record).

Com o registro analisado disponível, cada método, quando chamado, simplesmente extrai os dados desejados e retorna-os para o usuário. Os métodos founded_year, num_employees e company_type são diretos, dada a discussão da Listagem 1. O método people requer um pouco mais de interpretação.

A resposta JSON do CrunchBase é representada por um hash contendo alguns números de chaves. Observe que nos três primeiros métodos, você especifica a chave para retornar o valor. O método people itera por um hash identificado pela chave relationships. . Cada registro contém uma chave is_past (que é usada para identificar se a pessoa não está mais em uma determinada empresa), uma chave title e uma chave person, que contém first_name , last_name e permalink. . O iterador simplesmente passa por cada uma, e quando a chave is_past é falsa, extrai a pessoa e o cargo e cria um novo hash a partir dessas informações. Esse hash é retornado quando mais nenhuma chave é encontrada. Observe que é possível visualizar todo esse hash dentro do IRB simplesmente emitindo a resposta com o item JSON.parse.

Listagem 3. API CrunchBase de Ruby para o namespace da empresa (company.rb)
require 'rubygems'
require 'json'
require 'net/http'

class Crunchbase_Company

  @record = nil

  def initialize( company )

    base_url = "http://api.crunchbase.com"
    url = "#{base_url}/v/1/company/#{company}.js"

    resp = Net::HTTP.get_response(URI.parse(url))

    @record = JSON.parse(resp.body)

      enddef founded_year
    return @record['founded_year']
  end

  def num_employees
    return @record['number_of_employees']
  end

  def company_type
    return @record['category_code']
  end

  def people

    employees = Hash.new

    relationships = @record['relationships']

    if !relationships.nil?

        relationships.each do | person |
            if person['is_past'] == false then
                permalink = person['person']['permalink']
                title = person['title']
                employees[permalink] = title
            end
        end

    end    return employees

  endend

A Listagem 4 fornece uma função similar à classe Company discutida na Listagem 3. O construtor initialize opera da mesma maneira, e você tem dois métodos simples para extrair o nome da pessoa determinada (do permalink dessa pessoa). O método companies itera o hash para a chave relationships e retorna as firmas (empresas) a que essa pessoa em particular estava associada no passado. As empresas associadas são retornadas nesse caso como um array Ruby simples (de permalinks).

Listagem 4. API CrunchBase de Ruby para o namespace da pessoa (person.rb)
require 'rubygems'
require 'json'
require 'net/http'

class Crunchbase_Person

  @record = nil

  def initialize( person )

    base_url = "http://api.crunchbase.com"
    url = "#{base_url}/v/1/person/#{person}.js"

    resp = Net::HTTP.get_response(URI.parse(url))

    @record = JSON.parse(resp.body)

  enddef fname
    return @record['first_name']
  end

  def lname
    return @record['last_name']
  end

  def companies

    firms = Array.new

    @record['relationships'].each do | firm |

        firms << firm['firm']['permalink']

end    return firms

  endend

Observe que nessas duas classes simples, a Ruby oculta a complexidade de lidar com o servidor HTTP em Net::HTTP . A complexidade de analisar a resposta JSON é totalmente simplificada por meio da gem JSON. Agora analisaremos alguns aplicativos dessas APIs para ilustrar seu uso.


Desenvolvendo alguns aplicativos simples

Inicie com uma demonstração das classes. No primeiro exemplo (consulte a Listagem 5), você deseja identificar as pessoas associadas a uma dada empresa (com base no permalink da empresa). O registro recuperado no namespace da empresa contém uma lista de permalinks para pessoas associadas à empresa. Você itera esse hash de pessoas e recupera um registro do indivíduo baseado no permalink. Esse registro fornece o primeiro e o último nome do indivíduo, e seu cargo é parte do registro da empresa (retornado como parte do hash nome-cargo).

Listagem 5. Identificando pessoas associadas a uma empresa (people.rb)
#!/usr/bin/ruby

load "company.rb"
load "person.rb"

# Get argument (company permalink)
input = ARGV[0]

company = Crunchbase_Company.new(input)

people = company.people

# Iterate the people hash
people.each do |name, title|

    # Get the person record
    person = Crunchbase_Person.new( name )

    # Emit the name and title
    print "#{person.fname} #{person.lname} | #{title}\n"

endpeople = nil
company = nil

O script é executado na Listagem 5 , como mostra a a Listagem 6. . Com o script, você fornece um permalink da empresa, e o resultado é o nome e sobrenome do indivíduo mais o cargo.

Listagem 6. Testando o script people.rb
$ ./people.rb emulex
Jim McCluney | President and CEO
Michael J. Rockenbach | Executive Vice President and CFO
Jeff Benck | Executive Vice President & COO
$

Agora analisaremos um exemplo mais complexo. Esse exemplo pega uma determinada empresa e identifica a equipe executiva. Então, identifica as empresas em que esses executivos trabalharam no passado. A Listagem 7 fornece o script, chamado influence.rb. . Como mostrado, você aceita um nome da empresa como o argumento, recupera o registro da empresa e depois recupera um hash das pessoas atualmente nessa empresa (por meio do método pessoas). Então, itera essas pessoas e identifica os chefes pelo cargo (não de forma totalmente precisa, dada a variabilidade de cargos no CrunchBase). Para quaisquer chefes identificados, você emite as empresas para as quais esses indivíduos trabalharam (recuperando um array de empresas do registro da pessoa).

Listagem 7. Relacionamento e influência executiva (influence.rb)
#!/usr/bin/ruby

load "crunchbase.rb"

input = ARGV[0]

puts "Executive Relationships to " + input

company = Crunchbase_Company.new(input)

people = company.people

# Iterate through everyone associated with this company
people.each do |name, title|

    # Search for only certain titles
    if title.upcase.include?("CEO") or
       title.upcase.include?("COO") or
       title.upcase.include?("CFO") or
       title.upcase.include?("CHIEF") or
       title.upcase.include?("CTO") then

        person = Crunchbase_Person.new( name )

        companies = person.companies

        companies.each do | firm |
            if input != firm
                puts "  " + firm
            end
        end

endend

A Listagem 8 ilustra esse script para a empresa de big data, Cloudera. Como é possível ver na A Listagem 7, Ruby e suas gems ocultam muitos detalhes de você, permitindo-lhe focar na tarefa em questão.

Listagem 8. Testando o script Ruby de influência
$ ./influence.rb cloudera
Executive Relationships to cloudera
  accel-partners
  bittorrent
  mochimedia
  yume
  lookout
  scalextreme
  vivasmart
  yahoo
  facebook
  rock-health
$

Usando outros métodos HTTP REST

Nos exemplos simples mostrados aqui, você usou somente o método GET para extrair dados do banco de dados CrunchBase. Outros sites podem estender uma interface para recuperar e enviar dados para o servidor REST em particular. A Listagem 9 fornece uma introdução a outros métodos Net::HTTP .

Listagem 9. Métodos HTTP para outras interações RESTful
http = Net::HTTP.new("site url")

# Delete a resource
transaction = Net::HTTP::Delete.new("resource")
response = http.request(transaction)

# Post a resource
resp, data = Net::HTTP.post_form( url, post_arguments )

# Put a resource
transaction = Net::HTTP::Put.new("resource")
transaction.set_form_data( "form data..." )
response = http.request(transaction)

Para simplificar o desenvolvimento de clientes REST ainda mais, é possível usar gems adicionais do Ruby, como rest-client (consulte Recursos). Essa gem fornece uma camada REST sobre HTTP, oferecendo métodos como get, postedelete.


Avançando

Espero que essa rápida introdução aos princípios de REST com Ruby ilustre a potência da arquitetura baseada na web, bem como por que Ruby é uma das minhas linguagens favoritas. A REST é uma das arquiteturas de API mais populares para as nuvens de computação e armazenamento e, portanto, vale a pena dedicar tempo para entendê-la e explorá-la. Na seção Recursos, você encontrará links para mais informações sobre as tecnologias usadas neste artigo, bem como para outros artigos sobre REST no developerWorks.

Recursos

Aprender

  • REST é uma arquitetura de software para comunicação entre sistemas distribuídos. A REST foi apresentada pela primeira vez por Roy Fielding em sua dissertação de doutorado, chamada Architectural Styles and the Design of Network-based Software Architectures, na Universidade da California, Irvine.
  • REST é desenvolvida sobre HTTP. Saiba mais detalhes sobre HTTP na Internet Engineering Task Force Solicitação de Comentários-2616 (para a versão 1.1).
  • Obtenha uma introdução interessante a REST no vídeo Intro to REST, fornecido por Joe Gregorio, da Google.
  • Saiba mais sobre várias ideias e tecnologias úteis exploradas neste artigo: URI, URL e JSON.
  • Ruby é de longe minha linguagem de script favorita e uma das linguagens mais intuitivas que já usei. A Ruby é ótima não apenas para a criação de protótipos rápida e desenvolvimento experimental, mas também para desenvolvimento de software de produção. Se for iniciante em Ruby, você irá se agradecer mais tarde por realizar essa ótima introdução à Ruby, Ruby in Twenty Minutes.
  • Leia mais sobre REST nestes artigos do developerWorks:
  • Para uma implementação ainda mais simples de REST em Ruby, experimente a gem rest-client em Github. . Esse cliente REST simplifica a maioria das grandes operações e permite que você foque no seu aplicativo.
  • A zona de software livre do developerWorks fornece uma ampla gama de informações sobre ferramentas de software livre e sobre o uso de tecnologias de software livre.
  • Fique por dentro dos eventos técnicos e webcasts do developerWorks com ênfase em uma variedade de produtos IBM e assuntos do segmento de mercado de TI.
  • Participe de um briefing gratuito do developerWorks Live! para inteirar-se sobre os produtos e ferramentas IBM, além das tendências do mercado de TI.
  • Acompanhe as Demos on demand do developerWorks , que abrangem desde demos de instalação e configuração de produtos para iniciantes até funcionalidades avançadas para desenvolvedores experientes.
  • Siga o developerWorks no Twitter.

Obter produtos e tecnologias

  • Avalie os produtos IBM da maneira que for melhor para você: faça download da versão de teste de um produto, avalie um produto online, use-o em um ambiente de nuvem ou passe algumas horas na SOA Sandbox para saber mais sobre como implementar arquitetura orientada a serviço (SOA) de maneira eficiente.

Discutir

Comentários

developerWorks: Conecte-se

Los campos obligatorios están marcados con un asterisco (*).


Precisa de um ID IBM?
Esqueceu seu ID IBM?


Esqueceu sua senha?
Alterar sua senha

Ao clicar em Enviar, você concorda com os termos e condições do developerWorks.

 


A primeira vez que acessar o developerWorks, um perfil será criado para você. Informações do seu perfil (tais como: nome, país / região, e empresa) estarão disponíveis ao público, que poderá acompanhar qualquer conteúdo que você publicar. Seu perfil no developerWorks pode ser atualizado a qualquer momento.

Todas as informações enviadas são seguras.

Elija su nombre para mostrar



Ao se conectar ao developerWorks pela primeira vez, é criado um perfil para você e é necessário selecionar um nome de exibição. O nome de exibição acompanhará o conteúdo que você postar no developerWorks.

Escolha um nome de exibição de 3 - 31 caracteres. Seu nome de exibição deve ser exclusivo na comunidade do developerWorks e não deve ser o seu endereço de email por motivo de privacidade.

Los campos obligatorios están marcados con un asterisco (*).

(Escolha um nome de exibição de 3 - 31 caracteres.)

Ao clicar em Enviar, você concorda com os termos e condições do developerWorks.

 


Todas as informações enviadas são seguras.


static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=80
Zone=Software livre, Linux
ArticleID=831984
ArticleTitle=Entenda o Representational State Transfer (REST) no Ruby
publish-date=08312012