Como criar um servidor HTTP com o Restify

Imagem do logo do Restify pra deixar o post bonito :-)

Você pode ver o conteúdo em vídeo também :-)

Estou escrevendo um livro sobre como construir uma API REST com Restify pela Casa do Código e minha ideia é escrever posts sobre o assunto enquanto escrevo o livro. Pra começar, antes mesmo de falar sobre como implementar uma API RESTful precisamos aprender a criar um simples servidor web com o framework Restify.

Pera lá, se você não sabe o que é Restify vou explicar, se já sabe pode pular a seção abaixo, ou você pode ler e me dar um feedback do que achou da explicação :-)

O que é Restify?

Restify é um framework criado pra quem quer desenvolver uma API REST em cima da plataforma do NodeJS. Ele já tem uma estrutura que se preocupa com a semântica de uma API REST, além de já estar preparado pra ser colocado em produção em alta escala.

Tem empresas bem famosas por terem uma equipe técnica muito forte que utilizam o Restify, como: Netflix, Napster, Pinterest e outras.

Ah! Não se preocupe se você não sabe o que é uma API REST, nos próximos posts e no livro desenvolverei uma junto com você, aí você conseguirá aprender o que é essa tal de API REST enquanto desenvolvemos uma.

Voltando a criar um servidor web com Restify?

Agora que já vimos o que é o Restify, vamos entender o que queremos desenvolver nesse post.

Quero conseguir criar um servidor web que consiga responder um JSON (JavaScript Object Notation - Anotação de Objeto JavaScript) quando for digitado no navegador a seguinte URL (Uniform Resource Locator - Localizador Padrão de Recurso): http://localhost:8080/

Para criar um projeto utilizando o NodeJS como plataforma utilizamos o npm (Node Package Manager). Ele é responsável por instalar as dependências do nosso projeto e com ele você também pode começar o nosso projeto.

Com o NodeJS instalado (você pode ir até o site nodejs.org e realizar a instalação sem complicação), quero que você vá até o terminal do seu sistema operacional e crie uma pasta chamada servidor-restify (mkdir servidor-restify). Entre na pasta que acabamos de criar (cd servidor-restify) e em seguida rode o seguinte comando:

npm init

Assim que você der o ENTER o npm começará a te fazer perguntas sobre o seu projeto, na seguinte ordem:

1. package name (nome do seu projeto);
2. version (versão que você está no projeto);
3. description (pequena descrição do seu projeto);
4. entry point (arquivo onde seu projeto começará);
5. test command (script para executar os teste da sua aplicação);
6. git repository (caminho do repositório do seu projeto);
7. keywords (palavras-chave pra quem buscar o seu projeto caso ele for open source conseguir achá-lo com mais facilidade);
8. author (nome de quem desenvolveu o projeto, nesse caso o seu nome);
9. license (se for um projeto open source você define a licença dele aqui);

Por último, ele mostrará um resumo de como você definiu o seu projeto, se tudo estiver correto basta dar ENTER, conforme a imagem abaixo:

Imagem de exemplo do comando npm init

Assim que você confirmar o último ENTER o npm criará um arquivo chamado package.json na raiz do seu projeto. Nele ficarão todas as informações que você acabou de preencher mais as dependências do projeto, além de outras coisas que veremos em posts futuros.

Agora precisamos instalar o Restify e para fazermos essa instalação também utilizamos o npm. Por favor, volte no terminal e execute a linha abaixo que realizará a instalação do Restify (lembre-se de verificar se você está dentro da pasta do servidor-restify):

npm install restify --save

Utilizamos o parâmetro --save para informar ao npm que o Restify que estamos instalando precisa ser definido como uma dependência do projeto. Sendo assim, o npm criará uma nova chave no package.json com o nome de dependencies. Dentro dessa chave ficarão todas as dependências do nosso projeto, mas como nesse momento só temos o Restify, o seu package.json ficará assim:

{
  "name": "servidor-rest",
  "version": "1.0.0",
  "description": "Projeto que estou criando pra deixar de exemplo para um post no medium",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [
    "restify"
  ],
  "author": "Marco Bruno",
  "license": "MPL-2.0",
  "dependencies": {
    "restify": "^6.3.4"
  }
}

O trecho que está em negrito no arquivo acima é a parte que o npm adicionou após a instalação e definição do Restify como uma dependência do projeto. Este é um padrão que vou adotar no restante do post, toda linha que eu adicionar deixarei ela em negrito.

Bom agora que já temos o Restify instalado e já sabemos um pouco mais de como funciona o npm e o package.json, podemos começar o código responsável por criar um servidor web com Restify.

Primeiro criaremos um arquivo na raiz do nosso projeto com o nome de index.js. Na primeira linha desse arquivo vamos chamar o nosso framework Restify e guardar o valor dele em uma variável com o nome de restify.

index.js

const restify = require('restify')

Agora que o nosso código já tem como acessar os recursos do Restify, o próximo passo que temos que executar é a criação de um servidor, para isso utilizaremos um método chamado createServer que retornará a referência de um servidor que guardaremos dentro de uma variável chamada servidor:

const restify = require('restify')
const servidor = restify.createServer()

Show! Já temos um servidor criado com o Restify, só está faltando colocar ele de pé. Para isso utilizaremos um método chamado listen, esse método espera receber dois argumentos, o primeiro é a porta que o servidor estará disponível (vamos criar um variável com o nome de porta pra guardar o valor 8080) e o segundo argumento é uma função que será executada no momento em que o servidor ficar de pé:

const restify = require('restify')
const porta = 8080
const servidor= restify.createServer()
servidor.listen(porta, () => {
  console.log(`Servidor de pé em http://localhost:${porta}`)
  console.log('Pra derrubar o servidor: ctrl + c')
})

Só para termos certeza que já conseguimos colocar o servidor de pé, vamos até o terminal para rodar o comando que executará o código do arquivo index.js (você tem que estar dentro da pasta servidor-restify):

node index.js

Após dar o ENTER você verá a seguinte saída no terminal:

Servidor de pé em http://localhost:8080
Pra derrubar o servidor: ctrl + c

Por favor, abre seu navegador e acesse http://localhost:8080. Se tudo deu certo até o momento você receberá como resposta no seu navegador:

{"code":"ResourceNotFound","message":"/ does not exist"}

Isso quer dizer que o nosso servidor está criado e de pé mas infelizmente não temos um recurso criado no caminho / (barra é a raiz do projeto). Para finalizarmos o nosso objetivo de como criar um servidor web com o Restify, vamos criar um recurso pro caminho / que responderá: Ae! Servidor criado veio com resposta para o path /.

Volte até o arquivo index.js, nele precisamos utilizar o método get que está disponível na variável sevidor, este método recebe dois parâmetros, no primeiro informamos qual é o path (caminho) que queremos criar e no segundo passamos uma função como argumento que será executada no momento que um usuário acessar o path que informamos no primeiro parâmetro:

const restify = require('restify')
const porta = 8080
const servidor = restify.createServer()
servidor.get('/', () => {
})
servidor.listen(porta, () => {
  console.log(`Servidor de pé em http://localhost:${porta}`)
  console.log('Pra derrubar o servidor: ctrl + c')
})

Dentro da função que passamos como segundo argumento, ela recebe no primeiro parâmetro as informações da request (requisição) e no segundo parâmetro as informações da response (resposta), portando dentro da função vamos utilizar o segundo parâmetro pra enviarmos uma resposta pro usuário que será o texto: Ae! Servidor criado veio com resposta para o path /.

const restify = require('restify')
const porta = 8080
const servidor = restify.createServer()
servidor.get('/', (req, res) => {
  res.send('Ae! Servidor criado veio com resposta para o path /.')
})
servidor.listen(porta, () => {
  console.log(`Servidor de pé em http://localhost:${porta}`)
  console.log('Pra derrubar o servidor: ctrl + c')
})

Olhando o código acima você perceberá que demos nomes carinhosos para os parâmetros de request e response, eles ficaram com os nomes de req e res.

No próximo post vamos começar a desenvolver uma API RESTful para uma aplicação que manterá dados do cotidiano de um bebê, como:

• Hora que ele dormiu e acordou;
• Quantos minutos ele mamou, que horas foi isso e qual foi a mama (direita ou esquerda);
• Na troca de fralda tinha xixi e/ou cocô e que horas foi trocada;
• E outras que não me lembro agora.

Ah! Como vamos montar esse esquema todo de como é o cotidiano de um bebê, precisamos também ter a funcionalidade de cadastrar um bebê na plataforma.

Até o próximo post e se quiser tirar dúvidas só me pentelhar nós comentários ou se preferir pode me adicionar nas redes socias da vida: Twitter, Telegram (bucar por MarcoBrunoBR), Linkedin e Facebook.