NoSQL: Hospedando bancos de dados MongoDB

Nos últimos anos, o MongoDB vem se popularizando tanto no meio acadêmico quando profissional. A utilização deste sistema de banco de dados possibilita armazenamento de dados não estruturados de forma bastante simples.

Geralmente este tipo de banco de dados deve ser localizado em um ambiente de fácil acesso, pois geralmente as aplicações que usam este banco precisam fazê-lo em locais fisicamente distantes. Diante desta necessidade, este artigo apresenta uma forma de armazenar e realizar operações básicas no MongoDB utilizando um serviço de hospedagem web. A discussão desse tem é útil para quem deseja conhecer a forma de criar e administrar bancos de dados MongoDB na nuvem. Com objetivo de oferecer soluções para gerenciamento deste tipo de banco de dados, o artigo também indica ferramentas gráficas para sua administração. Ao longo do artigo será dada ênfase a tecnologias para desenvolvimento de aplicações web utilizando a linguagem de programação Java.

Para acesso ao banco de dados será desenvolvido um web service, que será hospedado em um host grátis. Para testar o serviço será desenvolvida uma aplicação console na linguagem Java. Por fim, o artigo mostra como testar e monitorar o web service e o banco de dados MongoDB.

O termo NoSQL significa Not Only SQL, ou seja, não somente SQL. Outros significados foram propostos inicialmente, porém o mais adotado pela comunidade foi este. Os bancos de dados NoSQL surgiram para facilitar o armazenamento e tratamento de dados em grande volume, oferecendo estrutura que possibilita alta escalabilidade.

Atualmente existem em torno de 150 diferentes bancos de dados NoSQL. O MongoDB vem ganhando novos adeptos devido a sua vasta documentação e comunidade envolvida.

O movimento MongoDB começou no início de 2009 e de lá para cá mais características e recursos se somam ao MongoDB, tais como: suporte sem esquema, fácil replicação, API simples, drivers para diversas linguagens, ferramentas de manipulação, atualizações de funções e muito mais.

O grupo dos bancos de dados NoSQL é constituído de bancos voltados para aplicações que gerenciam grande volumes de dados, adotam recursos de escalabilidade, protocolo REST, MapReduce (ler BOX 1) e outros recursos de alto desempenho.

A sigla REST significa Representational state transfer, ou seja Transferência de Estado Representativo. É uma técnica largamente utilizada em sistemas distribuídos para manipulação (CRUD) de dados utilizando apenas chamadas HTTP. Este tipo de chamada simplifica a programação, abstraindo para o programador as tarefas de baixo nível, possibilitando a implementação de rotinas diversas em serviços web. As chamadas realizadas são basicamente para: inserção de dados (POST), consulta de dados (GET), atualização de dados (PUT) e exclusão de dados (DELETE).

Saiba mais: Confira também uma boa opção de hospedagem VPS no Brasil

Neste artigo será apresentada uma pequena introdução ao funcionamento e sintaxe do banco de dados MongoDB. Para isso, serão apresentados comandos básicos e ferramentas para acessar o banco. Na sequência discutiremos sobre o OpenShift e como criar uma conta no mesmo. Depois são descritos os detalhes sobre a IDE adotada e os passos necessários para desenvolver as aplicações envolvidas.

Logo em seguida é apresentado como realizar o upload da aplicação para o serviço de hospedagem. Por fim, serão realizados testes e destacadas as conclusões deste artigo.

MongoDB

A primeira coisa que se pensa quando se inicia no assunto NoSQL é comparativo. Como não podíamos deixar de falar, vamos ao comparativo dos principais termos em relação aos bancos relacionais. Observe a Tabela 1.

No MongoDB, cada documento pode ser completamente distinto de outro documento na mesma coleção, o que não é verdade no modelo relacional. Geralmente os dados são gravados no formato BSON (Binary JSON).

Para seguir os passos apresentados na seção seguinte, não é necessário ter o MongoDB instalado no computador local.

A instalação no computador local é apenas para fins de testes mais rápidos e simples. Caso o leitor deseje instalar o MongoDB em seu computador e manipulá-lo, seguem alguns comandos iniciais que podem ser úteis. Para executar o serviço (daemon), você deve considerar o seguinte comando: /mongod. Com o serviço em execução, podemos iniciar o interpretador de comandos:/mongo, os comandos básicos para listar bases de dados são:show dbs ou show databases, Para escolher uma base de dados utilize (caso não exista, será criada a base de dados sqlMagazine): use sqlMagazine é importante estar atento ao fato de que letras maiúsculas e minúsculas são diferentes, tome cuidado com este detalhe.

Para listar as collections (tabelas) de um banco, utilize o seguinte comando show collections. Para adicionar dados no banco de dados, a seguinte instrução deve ser considerada:

db.sqlMagazine.insert({OqueFaremos:"Aprender sobre MongoDB", 
DataDeCriação: new Date(), tags:["MongoDB", "openshift",
"cloud", "paas"]})

Para consultar utilizamos o find no contexto da collection considerada:

db.sqlMagazine.insert({OqueFaremos:"Aprender
<p>db.sqlMagazine.find()

Se quisermos atualizar as informações de uma collection, basta proceder conforme os exemplos a seguir:

db.sqlMagazine.insert({OqueFaremos:"Aprender
 db.sqlMagazine.update({"OqueFaremos":"Aprender
sobre MongoDB"},

db.sqlMagazine.insert({OqueFaremos:"Aprender
 {$push : {tags : "Web Service"}},true)

db.sqlMagazine.insert({OqueFaremos:"Aprender
 db.sqlMagazine.update({"OqueFaremos":"Aprender
sobre MongoDB"}

db.sqlMagazine.insert({OqueFaremos:"Aprender
 {$push : {tags : "Java EE"}},true)

db.sqlMagazine.insert({OqueFaremos:"Aprender
db.sqlMagazine.update({"OqueFaremos":"Aprender
sobre MongoDB"},

db.sqlMagazine.insert({OqueFaremos:"Aprender
 {$push
: {tags : "C#"}},true)

Observe que é tudo muito simples. Após a execução destes comandos, o banco de dados terá as informações apresentadas na Figura 1.

Observe agora a atualização realizada com o comando:

db.sqlMagazine.update({"OqueFaremos":"Aprender
sobre MongoDB"}

{$pop
: {tags : 1}})

Neste caso, estamos removendo a última tag. Para remover a primeira tag poderíamos usar o mesmo comando, no entanto trocaríamos o 1 por -1. O resultado desta atualização pode ser observado na Figura 2.

Por fim, para remover a coleção utilizamos o seguinte comando:

db.sqlMagazine.remove(
{"OqueFaremos" : "Aprender sobre MongoDB"})

Ferramentas para MongoDB

Depois de tantos comandos, já temos uma base para seguir adiante. Conhecer os comandos é fundamental para desenvolver aplicações, no entanto, para administração existem outras ferramentas gráficas que são boas aliadas. Por exemplo, as Figuras 1 e 2 foram capturadas do software MongoHub.

Existem outras ferramentas para acessar o MongoDB, tais como RockMongo e MongoVUE. A ferramenta RockMongo precisa de outros serviços (PHP e Apache), além de ativar o módulo MongoDB na configuração do PHP. Esta ferramenta é adotada como padrão no OpenShift, portanto é bom ter um conhecimento sobre ela.

A ferramenta MongoVUE é apenas para computadores com sistema operacional Microsoft Windows. Ela oferece boas funcionalidades. Um outro artigo publicado na SQL Magazine, indicado na seção Links, fala bastante sobre esta ferramenta.

Para usuários de sistema operacional da Apple (Mac OS 10.6.x ou superior), existe a ferramenta MongoHub. Apesar de existir um site específico desta ferramenta, no momento de edição deste artigo o mesmo estava fora de operação. Desta forma, o link indicado para download é o site da equipe de desenvolvimento.

Criando uma conta para hospedar a aplicação

Neste artigo, o objetivo é disponibilizar o banco de dados na web e possibilitar o acesso a ele por uma aplicação que esteja também na web ou por uma aplicação que esteja instalada em outro computador. O serviço escolhido para hospedagem do banco de dados foi o OpenShift. Neste, o usuário pode criar até três aplicações e em cada uma delas é possível criar vários serviços, tais como aplicações Java, PHP, Phyton, Ruby entre outras.

Saiba mais: Tutorial Python

Caso deseje criar mais aplicações na mesma conta ou mesmo contratar outros serviços e recursos de escalabilidade, deve-se criar uma conta paga. O OpenShift oferece plataforma como serviço, identificado pela sigla PaaS. Vamos aos passos necessários para criar uma conta.

Saiba mais: Como aprender PHP

Inicialmente o usuário deve ir até o porta do OpenShift (ver seção Links) endereço: e escolher a opção SIGN UP FOR FREE. Será apresentada a tela de cadastro, conforme a Figura 3.

Basta informar os dados e clicar em “Sign Up”. Será enviado um e-mail para confirmação do cadastro, é necessário clicar no link deste e-mail para ativar o cadastro e poder criar as aplicações.

Ao acessar sua conta no OpenShift, é possível criar os serviços desejados, também são oferecidas instruções para acessar as aplicações por linha de comando, utilizar a IDE JBoss Developer Studio e uma infinidade de outros recursos. Com o objetivo de facilitar este passo a passo, vamos criar a aplicação automaticamente depois de ter desenvolvido a mesma localmente.

Algumas configurações devem ser feitas em nossa conta do OpenShift. Depois de acessar a conta, devemos ir na seção “Settings”, conforme mostra a Figura 4.

Na caixa de texto “Domain name” devemos digitar o nome do domínio desejado, neste teste digitamos “sqlmagazine”. Este nome (máximo de caracteres é 16) é de livre escolha, porém, ele é importante pois será utilizado em nosso projeto Java. Em seguida clique na opção “Save”.

Realizado este passo, podemos retornar para a guia “Applications” e clicar na opção “Create your first application now” . Será exibida uma lista com vários serviços que podemos criar. Vamos escolher “JBoss Apllication Server 7”. Em seguida é exibida a janela para escolher o nome da aplicação, conforme mostra a Figura 5.

Este nome também é de livre escolha, no entanto deve ser um nome fácil de lembrar, pois precisaremos dele logo em seguida. Para este teste digitamos “mongodb”.

O próximo passo é clicar em “Create Application”. Este processo pode levar alguns segundos ou até mesmo minutos, aguarde até que o processo seja concluído. Agora podemos retornar para guia “Applications” e clicar na aplicação criada.

Neste momento vamos adicionar o MongoDB à nossa aplicação. Para isso, basta clicar na aplicação, neste exemplo “mongodb” e em seguida clicar em “Add MongoDB 2.4”, conforme mostra a Figura 6. Caso abra uma janela com informações e instruções, vai ser apresentado o link “Continue to the application overview page”, que deve ser clicado, em seguida vai ser possível clicar em “Add MongoDB 2.4”.

Em seguida, clique em “Add Cartridge”. Este processo também pode levar alguns segundos. Será apresentada então uma tela com informações importantes de acesso ao banco de dados, é importante registar estas informações pois serão utilizadas nos próximos passos. As informações são usuário, senha e nome do banco de dados.

Neste momento já temos um servidor (JBoss Application Server) à nossa disposição e um banco de dados NoSQL (MongoDB). Basta agora criar um web service para acessar este banco e um projeto para acessar este web service.

Desenvolvimento das aplicações

Basicamente teremos duas aplicações e um banco de dados. A primeira aplicação será a responsável por realizar requisições para o banco de dados. Esta aplicação servirá como um exemplo bem simples, apenas para testar o funcionamento do web service. A segunda aplicação (web service) será responsável por receber as requisições da primeira e acessar o banco de dados.

Vamos à primeira aplicação. Seus pré-requisitos são: Eclipse Kepler e duas bibliotecas da API (Application Program Interface) Jersey (jersey-client e jersey-core). A fim de facilitar e simplificar o passo a passo descrito aqui, faremos um aplicativo Java no Eclipse Kepler.

As imagens para ilustrar o passo a passo foram obtidas usando sistema operacional Mac OS 10.9.3, no entanto o leitor pode utilizar Microsoft Windows, ou mesmo uma distribuição Linux.

Dentro do Eclipse acesse: Arquivo, Novo, Projeto. Na janela seguinte escolha “Projeto Java” e clique em “Próximo”. Em seguida, digite um nome para o projeto, conforme mostra na Figura 7 e escolha a opção “Finalizar”.

Agora precisamos criar uma classe no projeto. Para isso, basta clicar com o botão direito do mouse em “src”, “Novo”, ”Classe”.

Na tela seguinte, devemos digitar um nome para classe e marcar a opção “Criar método principal” “public static void main (String[] args)”, e clicar em “Finalizar”, conforme mostra a Figura 8.

Este projeto Java tem por objetivo gravar informações um banco de dados MongoDB que estará hospedado na web. O tipo de hospedagem utilizado permite o acesso externo ao banco de dados, ou seja, aplicações de qualquer lugar conseguem acessar o servidor de banco de dados, no entanto é necessário redirecionamento de portas na máquina local.

Como isso pode se tornar algo bem complexo de fazer quando se trata de computadores fora de nosso controle ou mesmo computadores que precisam continuar a acessar as portas locais, ou ainda quando se trata de dispositivos móveis, o redirecionamento de portas não é o melhor caminho. Desta forma, o nosso projeto Java irá acessar o banco de dados por meio de um web service.

Antes de digitar os códigos, vamos adicionar duas bibliotecas para trabalhar com web services. As duas bibliotecas que utilizaremos são provenientes da API Jersey 1.18. Para adicioná-las ao projeto, após fazer o download (indicado na seção Links), basta copiá-las para a pasta do mesmo e clicar com o botão direito do mouse em cima do nome do projeto e escolher propriedades.

Dentro da janela “Propriedades”, selecione a opção “Java Build Path” e depois “Bibliotecas”. Em seguida, clique em “Adicionar Jar Externos”. Observe na Figura 9 as duas bibliotecas estão informadas no “build path”.

Agora que temos a API Jersey adicionada ao nosso projeto, podemos codificar um pouco. A Listagem 1 apresenta o código inicial do projeto Java.

1    package mongoDBSQLMagazine;
2    
3    import com.sun.jersey.api.client.Client;
4    import com.sun.jersey.api.client.WebResource;
5    
6    public class TesteParaMongoDB {
7    
8        public static void main(String[] args) {
9           Client client = Client.create();
10          WebResource webResource = 
            client.resource("http://mongodb-sqlmagazine.
            rhcloud.com/rest/post");
11                 
12       }
13   
14   }
  

Neste trecho inicial de código estamos apenas criando um cliente de uma url. Nas primeiras linhas (3 e 4) temos o import para utilização dos métodos da biblioteca “Jersey”. Nas linhas 9 e 10 estamos criando um objeto para conectar a url do web service. Perceba que a url do web service é composta pelo nome completo de nossa conta no OpenShift juntamente com a palavra rest e post, indicando que o web service tem um local para os métodos, chamado rest e um método chamado post. Em seguida, vamos criar alguma informação para enviar ao banco de dados (ver Listagem 2).

  1    String[][] sensores;
  2    sensores = new String[3][2];
  3    sensores[0][0]="Sensor 1";
  4    sensores[0][1]="MPU-6K Accelerometer";
  5    sensores[1][0]="Sensor 2";
  6    sensores[1][1]="MPU-6K Gyroscope";
  7    sensores[2][0]="Sensor 3";
  8    sensores[2][1]="YAS532 Magnetic Sensor";
  9    
  10   StringBuilder conteudo = new StringBuilder();
  11   
  12   conteudo.append("{");
  13   conteudo.append(" \"Usuário\" : \" Usuário de testes\",");
  14   conteudo.append(" \n \"sensores\" : { \n");
  15   
  16   for (int i = 0; i < sensores.length; i++) {
  17     conteudo.append("\""+sensores[i][0]);
  18     conteudo.append("\" : \""+sensores[i][1]);
  19     conteudo.append("\", \n");
  20   }
  <p align="left">21   conteudo.append("}}");

O objetivo do trecho de código apresentado nessa listagem é montar uma sequência de caracteres obedecendo ao padrão JSON para ser enviado ao banco de dados MongoDB. Por fim, o arquivo a ser enviado para o servidor terá a seguinte estrutura:

{ "Usuário" : " Usuário
de testes", 
"sensores" : { 
"Sensor 1" : "MPU-6K Accelerometer", 
"Sensor 2" : "MPU-6K Gyroscope", 
"Sensor 3" : "YAS532 Magnetic Sensor", 
 }
}

Vamos agora ao último trecho de código do projeto Java. Observe a Listagem 3.

1    try {
2       ClientResponse response = webResource.type("application/json")
3         .post(ClientResponse.class, conteudo.toString());
4       if (response.getStatus() != 201) {
5         System.out.println("Falhou: Código de erro: "+ response.getStatus());
6        throw new RuntimeException("Falhou: Código de erro: "+ response.getStatus());
7       }
8       System.out.println("Resposta do Servidor : \n");
9       String output = response.getEntity(String.class);
10      System.out.println(output);
11   } catch (Exception e) {
12      e.printStackTrace();
<p align="left">13   }

Este trecho de código vai necessitar de mais um import para nosso projeto: import com.sun.jersey.api.client.ClientResponse;

O trecho de código apresentado realiza a conexão com o web service, enviando o arquivo JSON com os dados desejados. Por fim, o código recebe a resposta do servidor. Para isso, na linha 1 temos a instrução try sendo inicializada, o Java exige que algumas tarefas, tais como acesso a arquivos, conexão com banco de dados e conexão com web services sejam realizadas em blocos de testes, os quais realizam a operação em memória a fim de verificar possíveis problemas. Este bloco de tentativa (try) deve ser finalizado, conforme indica as linhas 11 a 13.

O comando que inicia na linha 2 e se estende até a linha 3 realiza o envio do arquivo JSON para a url especificada no objeto webResource e armazena no objeto response a resposta do servidor. Esta é a principal parte do código.

A instrução da linha 4 é apenas para testar a resposta do servidor e exibir a mensagem de erro, caso este ocorra. Entre as linhas 8 e 10 são exibidas na tela um texto fixo “Resposta do Servidor :” seguido do retorno do web service. A Listagem 4 apresenta o código completo da nossa primeira aplicação.

1    package mongoDBSQLMagazine;
2    
3    import com.sun.jersey.api.client.Client;
4    import com.sun.jersey.api.client.WebResource;
5    import com.sun.jersey.api.client.ClientResponse;
6    
7    
8    public class TesteParaMongoDB {
9    
10       public static void main(String[] args) {
11                  Client client = Client.create();
12            WebResource webResource = 
			  client.resource("http://mongodb-sqlmagazine.rhcloud.com/rest/post");
13            
14            String[][] sensores;
15            sensores = new String[3][2];
16            sensores[0][0]="Sensor 1";
17            sensores[0][1]="MPU-6K Accelerometer";
18            sensores[1][0]="Sensor 2";
19            sensores[1][1]="MPU-6K Gyroscope";
20            sensores[2][0]="Sensor 3";
21            sensores[2][1]="YAS532 Magnetic Sensor";
22            
23            StringBuilder conteudo = new StringBuilder();
24            
25            conteudo.append("{");
26            conteudo.append(" \"Usuario\" : \" Usuário de testes\",");
27            conteudo.append(" \n \"sensores\" : { \n");
28   
29            for (int i = 0; i < sensores.length; i++) {
30                     conteudo.append("\""+sensores[i][0]);
31                     conteudo.append("\" : \""+sensores[i][1]);
32               conteudo.append("\", \n");
33            }
34            conteudo.append("}}");
35          
36            try {
37                ClientResponse response = webResource.type("application/json")
38                        .post(ClientResponse.class, conteudo.toString());
39                if (response.getStatus() != 201) {
40                    System.out.println("Falhou: Código de erro: "+ response.getStatus());
41                    throw new RuntimeException("Falhou: Código de erro: "+ 
					  response.getStatus());
42                }
43                System.out.println("Resposta do Servidor : \n");
44                String output = response.getEntity(String.class);
45                System.out.println(output);
46            } catch (Exception e) {
47                e.printStackTrace();
48            }
49       }
<p align="left">50   }

Vamos agora iniciar o desenvolvimento da segunda aplicação. Desta vez os pré-requisitos serão: Eclipse Kepler com JBoss Developer Studio ou a IDE JBoss Developer Studio. Podemos instalar o JBoss Developer Studio dentro do Eclipse ou podemos utilizar a IDE indicada pelo OpenShift, JBoss Developer Studio. É recomendado utilizar esta IDE, pois ela facilita bastante a tarefa. Além disso, ela conta com vários aplicativos de exemplos, conhecidos como “quick starts”.

Para instalar o JBoss Developer Studio no Eclipse, basta ir na janela principal do Eclipse, clicar em “Ajuda” e, em seguida, clicar em “Eclipse Marketplace”. Na caixa de texto “Procurar”, digite JBoss Developer Studio e escolha a segunda opção. Para instalar a ferramenta, basta seguir as instruções apresentadas e concordar com os termos do contrato.

Agora com a ferramenta instalada, podemos desenvolver nossa segunda aplicação. Dentro do Eclipse, escolha “Janela”, “Abrir perspectiva”, “outro”. Na janela que irá abrir, escolha JBoss, conforme mostra a Figura 10.

Na janela de boas vindas do JBoss, vamos escolher, na guia “Start from a sample”, “Back-end Applications”, “helloworld-rs”, conforme mostra a Figura 11.

Feita a escolha, basta clicar em próximo e finalizar. Este processo pode demorar um pouco pois será feito o download de algumas bibliotecas. Caso ocorra erro nesta etapa, pode ser necessário instalar o “Maven” que é um gerenciador de dependências.

Concluída esta etapa, o projeto de exemplo já esta pronto. Vamos explorar ele um pouco. Para isso, expanda o diretório principal conforme mostra a Figura 12.

Antes de codificar vamos adicionar uma dependência ao projeto. As dependências são as bibliotecas utilizadas pelo web service. Para adicionar é bem simples, basta abrir o arquivo pom.xml que se encontra na pasta principal do projeto. Na Figura 12 é possível verificar o arquivo pom.xml.

Quem utilizar a IDE JBoss Developer Studio irá encontrar uma ferramenta gráfica para manipulação deste arquivo. Encontre neste arquivo uma tag , dentro dela adicione o código apresentado na Listagem 5.

<dependency>
	<groupId>org.mongodb</groupId>
	<artifactId>mongo-java-driver</artifactId>
	<version>2.4</version>
</dependency>

Feito isso, basta adicionar a dependência Maven. Para isso, dentro do Eclipse, clique com o botão direito em cima do nome do projeto e escolha a opção “Maven”, “Add Dependency”. Será exibida uma janela com alguns campos que devem ser preenchidos conforme a Figura 13.

Se tudo ocorreu bem, o driver Mongo será exibido juntamente às outras dependências Maven, conforme mostra a Figura 14.

Com a biblioteca do MongoDB adicionada ao nosso projeto, podemos codificar um pouco. Vamos ao código necessário para o web service. Abra a classe HelloWorld.java que se encontra no pacote org.jboss.as.quickstarts.rshelloworld.

Perceba que esta classe já tem dois métodos GET que servem para obter dados, um em JSON e outro em XML. Como nosso objetivo é enviar dados para serem gravados no servidor, vamos desenvolver nosso método (POST) para isso.

Na classe HelloWorld.java, inicialmente vamos ajustar os imports, conforme apresentado na Listagem 6.

//imports originais
import javax.inject.Inject;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
//imports para métodos POST
import javax.ws.rs.Consumes;
import javax.ws.rs.POST;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
//imports para operações no MongoDB
import com.mongodb.BasicDBObject;
import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.Mongo;
import java.util.Date;

Os primeiros quatro imports já estão no projeto, basta adicionar os demais, que servem para utilização de métodos de POST e acesso ao MongoDB. O último é para utilização de datas.

Adicionados os imports, vamos ao método POST. Logo abaixo do fechamento das chaves do último método GET, adicione o trecho de código da Listagem 7.

1     @POST
2     @Path("/post")
3     @Consumes(MediaType.APPLICATION_JSON)
4     public Response createDataInJSON(String DadosRecebidos) { 
5     String sistemaUser, sistemaSenha, sistemaBase, sistemaCollection, sistemaIp, sistemaPorta;
6             sistemaIp = System.getenv("OPENSHIFT_MONGODB_DB_HOST");
7             sistemaUser = "admin";
8             sistemaSenha = "sua senha";
9             sistemaPorta = System.getenv("OPENSHIFT_MONGODB_DB_PORT");
10            sistemaBase = "sqlteste";
11            sistemaCollection = "sensores"; 
12            try{
13    Mongo mongo= new Mongo(sistemaIp, Integer.parseInt(sistemaPorta));
14    DB db = mongo.getDB(sistemaBase);
15    boolean auth = db.authenticate(sistemaUser, sistemaSenha.toCharArray());
16    DBCollection coll = db.getCollection(sistemaCollection);
17    BasicDBObject doc = new BasicDBObject(
18                          "Data Recebida", new Date())
19                      .append("Dados", DadosRecebidos);
20    coll.insert(doc);
21    }catch (Exception e){
22    System.out.println("Erro na comunicação "+sistemaIp +" "+sistemaUser+" "+ e.getMessage());
23    e.printStackTrace();
24    }
25            String result = "Data post: "+DadosRecebidos;
26            return Response.status(201).entity(result).build(); 
27 }

Na linha 1 temos a definição do tipo de método, POST. Na linha 2 temos a informação de url a ser acessada. Perceba que o /post foi utilizado no nosso aplicativo 1, conforme indica as Listagens 1 e 4. Na linha 3 é indicado o tipo de resposta que será gerada, um arquivo json. Na linha 4 temos a criação da variável que receberá os dados que serão enviados para o método.

Nesta variável teremos os dados que a primeira aplicação vai enviar. Nas linhas 5 a 11 temos algumas variáveis recebendo valores de conexão com o banco de dados. Note que estamos utilizando variáveis de ambiente. Conforme indicado pelo OpenShift, também é possível utilizar diretamente o IP do servidor, algo parecido com 127.11.172. 2. Para descobrir este valor basta explorar o Rock Mongo na guia servidor. Para localizar a porta, procedemos da mesma maneira.

Para porta, seria melhor utilizar o número diretamente, pois logo em seguida precisamos converter a variável para inteiro (linha 13). Na linha 8 troque por sua senha. Na linha 11 temos o nome de uma coleção, não se preocupe em criar ela antes, pois ela será criada automaticamente caso não exista.

Entre as linhas 12 e 21 temos a parte mais importante do código, onde nos conectamos com o banco de dados (linhas 13 a 15) e montamos um arquivo json com a data atual juntamente com os dados recebidos na variável DadosRecebidos. A linha 20 insere os dados no banco de dados.

As linhas 22 e 23 são apenas úteis se ativarmos o “Tail files”. Desta forma, conseguimos mostrar no console de nosso computador local os eventuais erros da aplicação rodando no OpenShift. Mais detalhes sobre o “Tail files” serão informados mais adiante neste artigo. Na linha 26 é montado o retorno do método POST.

Mesmo sendo um método que tem por finalidade apenas receber dados e gravar no banco, é uma boa prática desenvolver um retorno para estes métodos, este resultado é utilizado no aplicativo 1.

Para este tutorial foi utilizado o driver mongo-java-driver-2.4.jar. Existem versões mais recentes deste drive de comunicação, no entanto algumas funcionalidade não estão estáveis para tratamento de dados originados de dispositivos móveis. Note que o arquivo não foi adicionado ao projeto, apenas foi informado para o Maven realizar isso.

Enviando para a nuvem

Agora podemos enviar nosso web service para o OpenShift. Dentro do Eclipse escolha a perspectiva do JBoss e clique em OpenShift Application.

Serão solicitadas as credenciais da conta (e-mail e senha) definidos no cadastro. Basta informar os dados da conta e clicar em “Próximo”. Na primeira vez que se conecta é solicitada a criação de SSH Keys.

Basta clicar em “Novo”, escolher um nome para chave e digitar um nome para o arquivo, conforme mostra a Figura 15.

Em seguida, clique em “Finalizar”, “Finalizar”. Será exibida a tela conforme mostra a Figura 16.

Nesta tela devemos marcar a opção “Use existing application”. Ao marcar esta opção será exibida a tela para escolher a aplicação criada anteriormente. Escolha a aplicação e clique em “Próximo”. Neste tutorial havíamos criado a aplicação “mongodb”.

Na tela seguinte será perguntado se desejamos criar um projeto para enviar ao nosso servidor ou utilizar um projeto existente. Vamos utilizar um projeto existente, no caso, nosso web service recentemente desenvolvido. Para isso desmarque a opção “Criar novo projeto”, clique em “Explorar” e escolha o projeto jboss-as-helloworld-rs, conforme mostra a Figura 17.

Finalize o processo. Será solicitada a confirmação para usar a chave de SSH, clique “Sim”. Mais uma vez “Sim” para confirmar o envio do web service. Após este passo podemos publicar o nosso web service. Para isso, vamos ao Eclipse e abrimos a guia “Servidores”, clique para expandir a guia do servidor, neste caso “mongodb at OpenShift”. Irá aparecer o nome do nosso web service jboss-as-helloworld-rs, clique com o botão direito do mouse nele e escolha a opção “Publicação Completa” ou “Full Publish”.

Verifique se a aplicação já foi construída no servidor OpenShift. Para isso, vá até o navegador e acesse sua conta no OpenShift na guia “Applications” e clique no aplicativo. No exemplo deste tutorial, “mongodb”, e confirme se já foi construído. Observe na Figura 18 que durante o teste, logo depois de enviar o Web Service, aparece “Building”.

Caso demore muito (mais de três minutos), pode ser necessário reinicializar a aplicação. Para isso, utilize o ícone correspondente bem à direita da tela.

Testes finais

Agora que temos um servidor com o MongoDB à nossa disposição, um projeto para enviar dados para o servidor, e um web service para juntar os dois, podemos partir para os testes.

Um aliado importante para verificar o funcionamento é o Rock Mongo. Ele pode ser ativado no OpenShift de forma muito simples, basta clicar em “Add Rock Mongo 1.1” na guia “Applications”. As credenciais de acesso são as mesmas informadas anteriormente.

Outro recurso importante é o “Tail files”, que pode ser ativado no console, conforme mostra a Figura 19. Navegue até o console do Eclipse e clique em OpenShift Explorer, expanda todas as opções até chegar na aplicação, no nosso caso “mongodb”. Clique com o botão direito do mouse e escolha a opção “Tail files”.

A opção “Tail files” faz com que todas as mensagens de console sejam exibidas no Eclipse do computador local quando a aplicação estiver recebendo as requisições dentro do OpenShift. Desta forma, conseguimos ler tudo que está acontecendo no servidor.

O teste que vamos realizar é no aplicativo 1. Para verificar o funcionamento também vamos consultar o Rock Mongo. Basta executar o aplicativo 1 e verificar o resultado. Se tudo ocorreu bem, o resultado será apresentado no console do Eclipse conforme mostra a Figura 20.

No Rock Mongo,o resultado pode ser conferido, conforme mostra a Figura 21.

Como vimos neste artigo, é possível desenvolver soluções na nuvem utilizando a IDE adequada e os serviços PaaS disponíveis de forma livre pela internet.