festON - Sua festa começa online : www.feston.com.br
Vitor Yudi Hansen
domingo, 8 de setembro de 2019
quarta-feira, 7 de outubro de 2015
Nginx servindo Node.js
Nesse post falarei um pouco mais sobre a união entre Node.js e Nginx, mostrando as vantagens desse casamento e como implementar essa dupla corretamente.
O objetivo dessa integração visa aumentar performance de uma aplicação pelo qual criaremos um proxy server do Nginx com Node.js e também um static server pelo qual é delegado todo processamento de arquivos estático para o Nginx, deixando apenas que o Node.js cuide do processamento de suas rotas, diminuindo o número de requisições diretas na aplicação.
Atenção: Não entrarei em detalhes sobre como instalar o Nginx em sua máquina, para instalá-lo recomendo que acesse seu site oficial: http://nginx.org. Também recomendo que leia sua Wiki que contém diversas dicas de como configurá-lo. A versão utilizada neste post é a versão 1.5.2, recomendo que não utilize versões anteriores a esta, pois provavelmente não irá funcionar a dica de configuração que explicarei a seguir.
Agora que temos o Nginx instalado e funcionando corretamente em sua máquina, vamos configurá-lo para que ele comece a servir arquivos estáticos de nossa aplicação, tudo isso será feito dentro de seu arquivo principal chamado
nginx.conf
. A localização deste arquivo varia de acordo com o sistema operacional, então recomendo que leia sua documentação oficial para descobrir onde ele se encontra.
Abaixo apresento uma versão simplificada de configuração do Nginx. Esta configuração fará o Nginx servir os arquivos estáticos ao invés do Node.js, e para finalizar aplicamos um proxy no Nginx para que ele redirecione para Node.js quando um usuário acessar uma rota da nossa aplicação.
worker_processes 1;
events {
worker_connections 1024;
}
http {
include mime.types;
default_type application/octet-stream;
sendfile on;
keepalive_timeout 65;
gzip on;
server {
listen 80;
server_name localhost;
access_log logs/access.log;
location /static {
root /meuapp/public;
expires max;
}
location / {
proxy_pass http://localhost:3000;
}
}
}
Praticamente adicionamos algumas melhorias em cima das configurações padrões do
nginx.conf
. Com o objetivo de otimizar o servidor estático, habilitamos compactação gzip, através do trecho: gzip on
e criamos dois location
dentro de server
. O primeiro location
é responsável por servir conteúdo estático.location /static {
root /meuapp/public;
expires max;
}
É dentro dele definimos a localização da pasta
public
da nossa aplicação através do trecho: root /meuapp/public
. Esta localização definida no item root
se baseia no endereço onde fica a pasta public
do seu sistema operacional, ou seja, emroot /meuapp/public
estou assumindo que a pasta meuapp
esta localizada na raíz do sistema operacional (geralmente sistemasLinux, Unix e MacOSX utilizam este padrão de endereço). Se o seu sistema é Windows altere o endereço para o padrão de diretórios dele, que é algo semelhante a root C:/meuapp/public
. Também aplicamos dentro desse location
um cache simples dos arquivos através do item: expires max
.
No último
location
, aplicamos o proxy server, o item proxy_pass
praticamente faz um redirecionamento para as demais rotas da aplicação e esse redirecionamento vai para o endereço: http://localhost:3000
.location / {
proxy_pass http://localhost:3000;
}
Agora que já configuramos o Nginx, vamos criar uma simples aplicação em Node.js. Crie o arquivo dentro da pasta
/meuapp
e também crie a pasta /meuapp/public
. Abaixo segue o código-fonte da aplicação Node utilizando Express:// Arquivo: app.js
var express = require('express')
, app = express();
app.use(express.favicon());
app.use(express.logger('dev'));
app.use(express.static(__dirname + '/public'));
app.get('/node', function(req, res){
var html = "<h1>Aqui é Node.js!</h1>"
+ "<h1><a href='/static/nginx.html'>Ir para Nginx</a></h1>";
res.send(html);
});
app.listen(3000);
Vamos criar o arquivo
nginx.html
dentro da pasta /meuapp/public/static
, para que este arquivo seja servido via Nginx.<h1>Aqui é Nginx</h1>
<h1><a href="/node">Ir para Node.js</a></h1>
Pronto! Criamos uma aplicação em Node.js que utiliza o Express, para rodá-lo, instale primeiro:
Agora execute:
Acesse no seu browser:
npm install express --save
Agora execute:
node app.js
.Acesse no seu browser:
http://localhost:3000
e clique em ambos os links. Veja dessa vez os logs registraram acessos nas rotas:/node
e /nginx.html
.
Isto é normal, visto que até agora o Node.js esta servindo arquivo estático e o Nginx não esta rodando seu proxy server por um motivo: você está acessando diretamente o servidor Node.js através da porta 3000.
Agora que temos o Nginx configurado, que tal testar essa integração? Reinicie o Nginx através do comando:
nginx -s reload
. E acesse sua aplicação através do novo endereço: http://localhost
.
Dessa vez o seu log da aplicação Node.js vai apenas registrar acessos na rota
/node
, deixando que a rota /nginx.html
seja acessada pelo Nginx.
fonte: http://udgwebdev.com/nginx-servindo-nodejs/
Vitor Yudi Hansen
Node.js e MongoDB na prática!
Na wiki oficial sobre módulos do Node.js https://github.com/joyent/node/wiki/modules existem cerca de 1100 módulos para Node.js e existem 15 módulos para MongoDB com Node.js.
Desses 15 módulos apenas testei 4 pelo qual 3 deles fiquei meio perdido por falta de uma clara documentação e o módulo que tive mais afinidade e facilidade em usar foi o mongoq, inclusive até conheci o autor desse módulo, um chinês muito gente boa que me ajudou, ensinando as boas práticas do seu módulo.
Abaixo irei explicar um pouco de código para criar um mini-aplicativo de cadastro de usuários. Lembrando que utilizarei também o Express que permitie criar as rotas da aplicação, pois o código abaixo apenas apresentarei como fazer um simplescontroller criando as rotas e explorando as funcionalidades do MongoQ, mas não entrarei em detalhes sobre o Express, pois não é o objetivo desse post.
Primeiro, para começarmos a brincadeira, instale os seguintes módulos:
npm install express mongoq
Agora crie o arquivo app.js e mãos a obra!
// Instanciando os módulos Express e Mongoq
var express = require('express');
var mongoq = require('mongoq');
// Configurando a execução do banco MongoDB
var COLLECTION = 'collection_teste';
var DB = 'banco_teste';
var db = mongoq(DB);
var collection = db.collection(COLLECTION);
// Iniciando o servidor Express
var app = module.exports = express.createServer();
// Configuração básica do servidor Express
app.configure(function(){
app.use(express.bodyParser());
app.use(express.methodOverride());
app.use(app.router);
});
// Rota GET para listar os usuários
app.get('/usuarios', function(req, res){
// Fazendo uma consulta no banco de dados
collection.find().toArray(function(err, result){
res.render('index', { usuarios : result });
});
});
// Rota GET para consultar um usuário
app.get('/usuario/:id', function(req, res){
// Recebendo os parâmetros de um query string
var id = req.params.id;
// Fazendo uma consulta no banco de dados
var params = {usuario : {id: id}};
collection.find(params).toArray(function(err, result){
res.render('ver', { usuario : result.usuario });
});
});
// Rota POST para cadastrar um usuário
app.post('/usuario', function(req, res){
// Recebendo os parâmetros da requisição
var usuario = req.body.usuario;
// Persistindo o novo usuário
collection.insert({usuario : usuario});
res.redirect('/usuarios');
});
// Rota PUT para atualizar um usuário
app.put('/usuario/:id', function(req, res){
// Recebendo os parâmetros de um query string
var id = req.params.id;
// Recebendo os parâmetros da requisição
var usuario = req.body.usuario;
// Atualizando dados do usuário que possuir este id
collection.update({usuario: {id: id }}, {usuario : usuario});
res.redirect('/usuarios');
});
// Rota DELETE para excluir um usuário
app.del('/usuario/:id', function(req, res){
// Recebendo os parâmetros de um query string
var id = req.params.id;
// Excluindo o usuário do banco de dados
collection.remove({usuario : {id: id }});
res.redirect('/usuarios');
});
Na prática este simples código já exemplifica o poder que Node.js + MongoDB + Express pode fazer.
Para conhecer em mais detalhes essas tecnologias visite:
- Site Oficial do MongoDB: http://www.mongodb.org/
- Site Oficial do Node.js: http://nodejs.org/
- Site Oficial do Express: http://expressjs.com/
- Github do MongoQ: https://github.com/zzdhidden/mongoq
fonte: http://udgwebdev.com/um-pouco-de-node-js-e-mongodb-na-pratica/
Vitor Yudi Hansen
terça-feira, 6 de outubro de 2015
Guia Para Iniciantes em Node.js
Guia Para Absolutos Iniciantes em Node.js
- Artigo Original: AN ABSOLUTE BEGINNER'S GUIDE TO NODE.JS
- Tradução: Eric Douglas
Veja uma versão atualizada desse artigo aqui
Não existe uma escassez de tutoriais para Node.js, mas a maioria deles cobrem usos e casos específicos, ou tópicos que somente aplicáveis se você já tiver um conhecimento prático do Node. Eu vejo vários comentários que se parecem com coisas do tipo: "Eu fiz o download do node, agora o que fazer?" Este tutorial responde esta questão e explica como iniciar bem do princípio.
O que é Node.js?
Muitos iniciantes em Node tem a dúvida de o quê exatamente ele é, e a descrição em nodejs.org definitivamente não ajuda.
Uma coisa importante de se perceber é que o Node não é um servidor web. Por ele próprio, não se tem nada. Ele não funciona como o Apache. Não existe um arquivo de configuração onde você o aponta para seus arquivos html. Se você quer que o Node seja um servidor HTTP, você tem que escrever um servidor HTTP (com a ajuda das bibliotecas incluídas). O Node.js é somente outra forma de executar código em seu computador. Ele é simplesmente umJavaScript runtime (ambiente de execução de código JavaScript).
Instalando o Node.js
Node.js é muito simples de ser instalado. Se você estiver usando Windows ou Mac, os instaladores estão disponíveis na página de download.
Já tenho o Node instalado, e agora o que fazer?
Uma vez instalado, agora você tem acesso a um novo comando chamado
node
. Você pode usar o comando node
de duas formas diferentes. A primeira é sem argumentos. Isto irá abrir um shell interativo (REPL: read-eval-print-loop), onde você pode executar código JavaScript puro.$ node
> console.log('Hello World');
Hello World
undefined
No exemplo acima eu digitei
console.log('Hello World')
dentro do shell e apertei enter. O Node vai então executar o código e nós podemos ver nossa mensagem registrada. Ele também imprimi undefined
pelo fato de sempre mostrar o valor de retorno de cada comando, e console.log
não retorna nada.
A outra forma de rodar o Node é fornecendo a ele um arquivo JavaScript para execução. Isto será na maioria das vezes a maneira como você irá utilizá-lo.
hello.js
console.log('Hello World');
$ node hello.js
Hello World
Neste exemplo, eu movi o comando
console.log()
para dentro de um arquivo e então passei este arquivo para o comando node como um argumento. O Node então roda o JavaScript contido neste arquivo e imprimi "Hello World".Fazendo Algo Útil
Rodar código JavaScript é divertido e tal, mas não é muito útil. Ai é onde o Node.js também inclui um poderoso conjunto de bibliotecas (módulos) para se fazer coisas reais. No primeiro exemplo eu vou abrir um arquivo de registros e analisá-lo.
example-log.txt
2013-08-09T13:50:33.166Z A 2
2013-08-09T13:51:33.166Z B 1
2013-08-09T13:52:33.166Z C 6
2013-08-09T13:53:33.166Z B 8
2013-08-09T13:54:33.166Z B 5
O que esses dados registrados significam não importa, mas basicamente cada mensagem contém uma data, uma letra e um valor. Eu quero somar os valores para cada letra.
A primeira coisa que nós precisamos fazer é ler o conteúdo do arquivo.
my-parser.js
// Carregando o módulo fs (filesystem)
var fs = require('fs');
// Leia o conteúdo do arquivo para a memória
fs.readFile('example-log.txt', function ( err, loData ) {
// Se um erro ocorrer, será lançada uma
// exceção, e a aplicação irá ser encerrada
if ( err ) throw err;
// logData é um Buffer, converta-o para string
var text = loData.toString();
});
Felizmente o Node.js faz a entrada e saída (I/O) do arquivo facilmente com o módulo embutido filesystem (
fs
). O módulo fs
tem uma função chamada readFIle que pega o caminho de um arquivo e um callback. O callback vai ser invocado quando o arquivo for lido por completo. O dado do arquivo vem na forma de um Buffer, que é basicamente um array de bytes. Nós podemos convertê-lo para uma string usando a função toString()
.
Agora vamos adicionar o parsing (analisador).
my-parser.js
// Carregando o módulo fs (filesystem)
var fs = require('fs');
// Leia o conteúdo do arquivo para a memória
fs.readFile('example-log.txt', function ( err, logData ) {
// Se um erro ocorrer, será lançada uma
// exceção, e a aplicação irá ser encerrada
if ( err ) throw err;
// logData é um Buffer, converta para string
var text = logData.toString();
var results = {};
// Quebrando o arquivo em linhas
var lines = text.split( '\n' );
lines.forEach(function ( line ) {
var parts = line.split( ' ' );
var letter = parts[ 1 ];
var count = parseInt( parts[ 2 ] );
if ( !results[ letter ] ) {
results[ letter ] = 0;
}
results[ letter ] += parseInt( count );
});
console.log( results );
// { A: 2, B: 14, C: 6 }
});
Agora vamos passar este arquivo como um argumento para o comando
node
e ele vai imprimir o resultado e sair.$ node my-parser.js
{ A: 2, B: 14, C: 6 }
Eu uso muito o Node.js para scripts como este. É uma alternativa muito mais simples e poderosa que os scripts bash.
Callbacks Assíncronos
Como você viu no exemplo anterior, o padrão típico do Node.js é o uso de callbacks assíncronos. Basicamente você está dizendo a ele para fazer algo e quando isso estiver terminado ele irá chamar sua função (callback). Isto porque o Node é de thread única. Enquanto você está esperando pelo disparo do callback, o Node pode fazer outras coisas ao invés de bloquear até que a requisição esteja terminada.
Isso é especialmente importante para servidores web. Isto é muito comum em aplicações web modernas para acessar banco de dados. Enquanto você espera pelo retorno do banco de dados, o Node pode processar mais requisições. Isso permite que você manipule milhares de conexões conjuntas com pequenos acréscimos, comparado a criar uma thread separada para cada conexão.
Fazendo Algo Útil - Servidor HTTP
Como disse anteriormente, o Node não faz nada por si só. Um dos módulos embutidos tornam a criação de servidores HTTP simples muito fácil, que é o exemplo na página inicial do Node.js.
my-web-server.js
var http = require('http');
http.createServer(function ( req, res ) { // req = requisição, res = resposta
res.writeHead( 200, { 'Content-Type': 'text/plain' } );
res.end( 'Hello World\n' );
}).listen( 8080 );
console.log( 'Servidor rodando na porta 8080' );
Quando eu digo básico, quero dizer básico mesmo. Este não é um servidor HTTP completo. Ele não pode servir qualquer arquivo HTML ou de imagem. De fato, não importa sua requisição, ela vai retornar 'Hello World'. No entanto, você pode rodar isto e verá em seu navegador no endereço
http://localhost:8080
o texto "Hello World".$ node my-web-server.js
Você pode ter percebido uma coisa diferente agora. Sua aplicação node.js não fechou. Isto acontece pois você criou um servidor e sua aplicação node vai continuar rodando e respondendo as requisições até que você mesmo mate o processo.
Se você quiser ter um servidor web completo, você terá que fazer este trabalho. Você deve checar o que foi requisitado, ler os arquivos apropriados e enviar o conteúdo de volta. Pessoas já fizeram estr trabalho duro para você.
Fazendo Algo Útil - Express
Express é um framework que torna a criação de sites normais muito simples. A primeira coisa que você tem que fazer é instalá-lo. Juntamente com o comando
node
, você também tem acesso a um comando chamado npm
. Esta ferramenta permite que você acesse uma enorme coleção de módulos criados pela comunidade, e um deles é o Express.$ cd /my/app/location
$ npm install express
Quando você instala um módulo, ele vai ser colado em uma pasta chamada node_modules dentro do diretório da sua aplicação. Você pode agora "require" (requisitar) este módulo como um módulo embutido. Vamos criar um arquivo estático básico usando o Express.
my-static-file-server.js
var express = require('express');
app = express();
app.use(express.static(__dirname + '/public'));
app.listen(8080);
$ node my-static-file-server.js
Agora você tem um servidor de arquivos estáticos bastante eficiente. Tudo que você colocar dentro da pasta
/public
vai ser requisitado pode agora ser requisitado pelo seu navegador e será mostrado. HTML, imagens, enfim, tudo. Por exemplo, se você colocar uma imagem chamada my-image.png
dentro da pasta public
, você pode acessá-la usando seu navegador no endereço http://localhost:8080/my-image.png
. Claro que o Express tem muito muito outros recursos, mas você pode olhá-los a medida que continua desenvolvendo.NPM
Nós usamos um pouco o NPM nas seções anteriores, mas eu quero enfatizar o quão importante esta ferramenta se faz no desenvolvimento para Node.js. Existem milhares de módulos disponíveis que resolvem quase todos os problemas típicos que você encontra. Lembre-se de checar o NPM antes de re-inventar a roda. Não é inédito para uma aplicação Node ter dezenas de dependências.
No exemplo anterior nós instalamos o Express manualmente. Se você tiver muitas dependências, essa não será uma forma muito interessante de instalá-las. É por isso que o NPM faz uso do arquivo
package.json
.package.json
.{
"name" : "MyStaticServer",
"version" : "0.0.1",
"dependencies" : {
"express" : "3.3.x"
}
}
Um arquivo
package.json
contém um resumo da sua aplicação. Existem vários campos disponíveis, sendo este apenas o mínimo. A seção dependencies (dependências) descreve o nome e a versão dos módulos que você gostaria de instalar. Neste caso eu vou aceitar qualquer versão do Express 3.3. Você pode listar quantas dependências quiser nesta seção.
Agora, ao invés de instalar cada dependência em separado, nós podemos rodar um simples comando e instalar todas elas.
$ npm install
Quando você roda este comando, o npm vai verificar na pasta atual pelo arquivo
package.json
. Se ele encontrar um, então irá instalar cada dependência listada.Organização do Código
Até agora só usamos um único arquivo, que não é muito sustentável. Na maioria das aplicações, seu código vai ser dividido em vários arquivos. Não nenhuma norma ou organização imposta dizendo para onde os arquivos vão. Isto não é Rails. Não há conceitos de views e controllers acontecendo aqui. Você pode fazer o que quiser.
Vamos refatorar o script de análise de registros (log parsing). Ele será muito mais testável e manutenível se nós separarmos a lógica de análise (parsing) dentro de um arquivo próprio.
parser.js
// Construtor Parser
var Parser = function () {
};
// Analisa o texto especificado
Parser.prototype.parse = function ( text ) {
var results = {};
// Quebra o arquivo em linhas
var lines = text.split('\n');
lines.forEach(function ( line ) {
var parts = line.split( ' ' );
var letter = parts[ 1 ];
var count = parseInt( parts[2] );
if ( !results[ letter ] ) {
results[ letter ] = 0;
}
results[ letter ] += parseInt( count );
});
return results;
};
// Exportando o construtor Parser neste módulo
module.exports = Parser;
O que eu fiz foi criar um novo arquivo para conter a lógica da análise dos registros. Isto é apenas JavaScript puro e existe várias formas de se encapsular este código. Eu escolhi por definir um novo objeto JavaScript pois assim é mais fácil de se fazer testes unitários.
A parte importante para isso é a linha
module.exports
. Isso diz ao Node que você está exportando deste arquivo. Neste caso exportei um construtor, então os usuários podem criar instâncias do meu objeto Parser
. Você pode exportar qualquer coisa que quiser.
Agora vamos olhar como é importante este arquivo e fazer uso do novo objeto
Parser
.my-parser.js
// Requisitando o arquivo parser.js
var Parser = require('./parser');
// Carregandoo módulo fs (filesystem)
var fs = require('fs');
// Lendo o conteúdo do arquivo para a memória
fs.readFile('example-log.txt', function ( err, logData ) {
// Se um erro ocorrer, irá ser lançada
// a exceção e a app será encerrada
if ( err ) throw err;
// logData é um Buffer, converta-o para string
var text = logData.toString();
// Criando uma instância do objeto Parser
var parser = new Parser();
// Chame a função parse
console.log( parser.parse( text ) );
// { A: 2, B: 14, C: 6 }
});
Arquivos foram incluídos exatamente como módulos, exceto que você inclui um caminho ao invés de um nome. A extensão
.js
é implícita, então você pode omití-la se quiser.
Tendo sido exportado um construtor, é isso que vai ser retornado da declaração
require
. Eu posso agora criar instâncias do meu objeto Parser
e usá-las.Resumo
Esperamos que este tutorial tenha feito a ponte entre a parte de fazer o download do Node.js e construir sua primeira ferramenta. O Node.js é uma tecnologia extremamenta poderosa e flexível que pode resolver uma vastidão de tipos de problemas.
Eu quero que cada um de vocês se lembre que o Node.js é somente limitado pela sua imaginação. As bibliotecas de seu núcleo foram cuidadosamente projetadas para fornecer as peças do quebra-cabeça necessárias para se construir qualquer fotografia. Combine-as com módulos disponíveis no NPM e será incrível o quão rápido você poderá começar a construir aplicações muito complexas e atraentes.
fonte: https://github.com/ericdouglas/traduz-ai/blob/master/nodejs/001-guia-para-iniciantes-absolutos-em-nodejs.md
Vitor Yudi Hansen
Assinar:
Postagens (Atom)