Histórico de Revisão
Data | Versão | Descrição | Revisor |
---|---|---|---|
26/05/2017 | 1.0 | Estrutura de tópicos | Vitor Borges |
29/05/2017 | 1.1 | Escrita dos tópicos | Vitor Borges e Thiago Moreira |
30/05/2017 | 1.2 | Revisão dos tópicos | Danilo Barros e Lucas Rufino |
30/05/2017 | 1.3 | Validação dos tópicos e refatoração final | Danilo Barros, Lucas Rufino, Thiago Moreira e Vitor Borges |
30/05/2017 | 1.4 | Configuração final do RethinkDB | Danilo Barros, Lucas Rufino, Thiago Moreira e Vitor Borges |
1. Introdução
2. Tecnologias
2.1. Node JS
Contruído com base em Javascript, o Node.js tem a capacidade de executar código Javascript fora dos navegadores. Além disso, ele pode ser usado também como complemento de outras aplicações ou até mesmo em uma aplicação nativa, permitindo que scripts em JS sejam executados das mais variadas formas, proporcionando um melhor aproveitamento do mesmo. Ele é muito utilizado ao lado do servidor, atendendo demandas de aplicações web e APIs. Apesar disto, ele tem a capacidade de ser executado sem um servidor, sendo uma vantagem relevante.
O Node.js utiliza o conceito de assincronidade no seu funcionamento, onde realiza varias atividades ao mesmo tendo, facilitando na realização de tarefas e otimizando o seu tempo. Quando o Node foi criado, em 2009, os desenvolvedores queriam deixar esse processo de assincronidade mais fácil e conveniente.
A arquitetura do Node.js é baseada no paradigma de Programação Orientada a Evento, onde, basicamente, utiliza métodos para monitorar os eventos que avisa o código especializado em responder a um determinado evento, que aquele evento que ele espera ocorreu. Com isso, o código que foi avisado responde ao evento. Esse métodos citados são chamados de callback, e são utilizados constantemente na execução do Node. A assincronidade só é possível devido a presença desses métodos, para ter controle das ações dos diversos scripts rodando ao mesmo tempo na aplicação.
2.2. RethinkDB
Construído em C++ mas que utiliza a sintaxe em Javascript (quando configurado com o Node), o banco de dados RethinkDB é não-relacional que possui uma vasta lista de queries flexíveis, operações intuitivas de monitoramento de API e é facil de configurar e aprender a utilizar.
A principal ideia do RethinkDB é que ele seja uma base de dados realtime, onde o desenvolvedor pode dizer ao RethinDB para continuamente atualizar resultados de query em tempo real, para o consumo de dados em diversos tipos de plataformas.
O RethinkDB deve estar dentro das alternativas a serem escolhidas quando:
- Aplicações mobile e web colaborativas;
- Jogos multiplayer;
- Mercados em tempo real;
- Dispositivos conectados.
3. Instalação
Explicaremos agora como instalar essas tecnologias na plataforma Linux.
3.1. Instalando o Node JS
Para a instalação da mais nova versão do Node utilize os seguintes comandos:
$ curl -sL https://deb.nodesource.com/setup_7.x | sudo -E bash -
$ sudo apt-get install -y nodejs
Opcionalmente, installe o build-essencial
para utilizar addons nativos do npm:
$ sudo apt-get install -y build-essential
Com a instalação concluída, cheque se o npm e o Node foram instalados corretamente.
$ node --version
v7.10.0
$ npm --version
4.5.0
3.2. Instalando o RethinkDB
Para a instalação do RethinkDB em distribuições Linux Ubuntu 16.04 utilize os comandos:
$ source /etc/lsb-release && echo "deb http://download.rethinkdb.com/apt $DISTRIB_CODENAME main" | sudo tee /etc/apt/sources.list.d/rethinkdb.list
$ wget -qO- https://download.rethinkdb.com/apt/pubkey.gpg | sudo apt-key add -
$ sudo apt-get update
$ sudo apt-get install rethinkdb
Para verificar a correnta instalação do RethinkDB execute:
$ rethinkdb -v
rethinkdb 2.3.5~0trusty (GCC 4.8.2)
Para executar o Rethindb basta abrir o terminal e executar o comando `rethinkdb` e o mesmo será carregado na página do Browser default do seu sistema operacional utilizando a url https://localhost:8080 (porta padrão da tecnologia, mas que pode ser alterada).
4. Configuração
Será falado agora uma breve configuração de uma API RESTFull utilizando o RethinkDB e o Node.js.
O primeiro passo é criar um projeto em Node. Para isso, crie uma pasta com o nome do projeto que deseja criar.
$ mkdir myAPI
$ cd myAPI
Na pasta da aplicação, inicie um projeto Node.js com o comando npm e as configurações desejadas.
myApp-$ npm init
Após isso, deve-se inserir as informações referentes ao seu servidor. Ele pede o nome, versão, descrição, entry point, test command, git repository, palavras-chaves, autor e licença. No fim, ele pergunta se está tudo ok para criar o projeto. Se sim, digite yes
no terminal.
Com isso, será criado um arquivo chamado package.json
que é o coração da aplicação Node.js, pois nele definimos todas as dependências da API.
4.1. Configurando o Node JS
Após a criação do projeto, é recomendado instalar algumas depêndencias que melhoram a experiência da utilização do Node, facilitando em diversos aspectos, como por exemplo, simplificar a utilização de querys para requisições no banco.
As dependências recomendadas são:
Express: Poderoso gerenciador de rotas focado em alta performance, que simplifica requisições HTTP.
$ npm install express --save
Body-parser: Facilita a captura dos objetos que são passados ou recebidos na sua requisição HTTP.
$ npm install body-parser --save
Morgan: Gera logs de requisição para melhor acompanhamento das rotas.
$ npm install morgan --save
Nodemon: Recarrega automaticamente o seu servidor, poupando o trabalho de reiniciá-lo sempre que houver alguma modificação.
$ npm install nodemon --save
O comando --save
presente nestes comandos citados acima salva todas as dependências instaladas no package.json
, facilitando o compartilhamento do código posteriormente. Para um terceiro instalar essas dependências do projeto, basta digitar o comando:
$ npm install
4.1.1 Criando um servidor
Após os passos acima, você já é capaz de criar sua API. Mas para isso, é necessário criar o servidor para iniciar os procedimentos.
Devemos criar um arquivo na pasta raiz para rodar nossa aplicação. Neste exemplo usaremos o nome app.js
.
Inicialmente, é preciso importar as depêndencias que serão necessárias para rodar o servidor. A importação é feita com o método require
do Node.
var express = require('express')
var bodyParser = require('body-parser')
var morgan = require('morgan')
Após isso, devemos evocar a função para utilizar os objetos do express em si.
var app = express()
No fim, devemos subir o servidor utilizando nossa variável app
. Para isso, passamos a porta que o servidor vai escutar e uma função que vai ser chamada assim que o servidor estiver no ar, como é mostrada no código abaixo.
app.listen(3000, function() {
console.log('Servidor executando no endereço http://localhost:' + 3000)
})
Após isso, seu servidor estará pronto para ser utilizado.
Utilize o comando abaixo para rodar o seu servidor.
$ node app
4.2. Configurando o RethinkDB
Uma tecnologia auxiliar ao RethinkDB que nos permite criar models e facilita nas queries é o Thinky, o qual utilizamos para configurar a base de dados. Para instalar o Thinky, faça:
myAPI-$ npm install --save thinky
Com isso, crie uma pasta com o nome database
e configure o arquivo de banco de dados chamado index.js
.
//Path: myAPI/database/
var thinky = require('thinky')()
var { type, r } = thinky // importa 'type' para tipos de variáveis e 'r' como o próprio módulo do RethinkDB
async function init () {
try {
await thinky.dbReady()
return thinky
} catch (error) {
throw error
}
}
export { init, thinky, type, r }
Com a base de dados configurada, volte ao arquivo app.js
e adicione as linhas de configuração do banco de dados:
var express = require('express')
var bodyParser = require('body-parser')
var db = require('./database')
var morgan = require('morgan')
var app = express()
app.use(bodyParser.json({
limit: '5mb'
}))
db.init()
.then(db => {
app.listen(3000, () => {
console.log('Server listening on http://localhost:3000')
})
})
O próximo passo é criar uma model
para poder salvar no banco de dados. Para isso, crie uma pasta models
.
myAPI-$ mkdir models
Agora, crie uma model qualquer de teste, no caso, criaremos uma model User.js
.
var { thinky, type } = require('../database')
var User = thinky.createModel('Users', {
name: type.string(),
email: type.string()
})
export default User
Agora, basta criar uma api
e configura-la para disponibilizar os métodos de requisição e consumir a API REST. Para isso, crie a pasta api
e o arquivo index.js
.
myAPI-$ mkdir api
myAPI-$ touch api/index.js
myAPI-$ touch api/users.js
// index.js
var { Router } = require('express')
var userRouter = require('./users')
export default ({ db }) => {
let api = Router()
var users = userRouter({ db })
api.use('/users', users)
return api
}
Crie também o arquivo users.js
na pasta api
.
// users.js
var { Router } = require('express')
var User = require('../models/User')
export default ({ db }) => {
let router = Router()
/*
configuração para rotas do tipo users/:id para
utilizarem o id do User como parâmetro
*/
router.param('user', (req, resp, next, id) => {
req.userDocument = User.get(id)
next()
})
router.get('/', async (request, response) => {
try {
var result = await User.run() // executa a query de get all no bando de dados
response.json(result)
} catch (error) {
response.status(500).send(error)
}
})
return router
}
Agora, volte no arquivo app.js
e configure a rota para /api
.
var api = require('./api') // importe a pasta 'api'
[...]
db.init()
.then(db => {
app.use('/api', api({ db })) // configure as rotas para começarem com '/api'
app.listen(3000, () => {
console.log('Server listening on http://localhost:3000')
})
})
Agora, para executar a api
basta executar os comandos rethinkdb
e nodemon app.js
na pasta myAPI
e acessar a rota http://localhost:3000/api/users
para acessar a rota e verificar a resposta do servidor.
Repare que não existe nenhum usuário cadastrado. Para inserir um usuário de teste, acesse o http://localhost:8080
para acessar o RethinkDB, como a imagem a seguir:
Agora, acesse o Data Explorer
e crie um usuário default:
Agora, ao acessar novamente a rota de /api/users
na API
você verá a resposta do servidor com o usuário cadastrado.
Pronto. Você já pode criar sua própria RESTfull API com Node.js e RethinkDB!
5. Bibliografia
- http://nodebr.com/o-que-e-node-js/
- https://pt.stackoverflow.com/questions/80601/o-que-é-a-programação-orientada-a-eventos
- https://www.rethinkdb.com/faq/
- https://nodejs.org/en/download/package-manager/#debian-and-ubuntu-based-linux-distributions