Escrito por: Zell Liew

Por muito tempo, não ousei me aventurar no desenvolvimento de back-end. Me sentia intimidado por causa da minha falta de formação acadêmica em programação.

Lembro-me de quando finalmente criei coragem para tentar o desenvolvimento de back-end. Tive tanta dificuldade em entender a documentação do Express, MongoDB e Node.js que desisti.

No fim, voltei e trabalhei para esclarecer minha confusão. Agora, um ano depois, entendi como trabalhar com essas ferramentas. Então, decidi escrever este tutorial abrangente para que você não precise passar pela mesma dor de cabeça que eu passei.

CRUD, Express e MongoDB

CRUD, Express e MongoDB são palavras grandes para uma pessoa que nunca tocou em programação do lado do servidor em sua vida. Vamos apresentar rapidamente o que elas são antes de mergulharmos no tutorial.

Express é um framework para construir aplicações para a web com base no Node.js. Ele simplifica o processo de criação do servidor que já está disponível no Node. Caso você esteja se perguntando: o Node permite que você use JavaScript como sua linguagem do lado do servidor.

MongoDB é um banco de dados. É no banco de dados que você armazena informações para seus sites (ou aplicações) para a web.

CRUD é uma abreviação em inglês para Criar, Ler, Atualizar e Excluir. É um conjunto de operações que fazemos para que os servidores as executem (POST, GET, PUT e DELETE, respectivamente). Isso é o que cada operação faz:

• Criar (POST) — Criar algo
• Ler (GET) — Obter algo
• Atualizar (PUT) — Alterar algo
• Excluir (DELETE)– Remover algo

Se colocarmos CRUD, Express e MongoDB juntos em um único diagrama, seria assim:

CRUD, Express e MongoDB fazem mais sentido para você agora?

Ótimo. Vamos em frente.

O que vamos construir

Vamos construir uma aplicação de lista simples que permite que você acompanhe as coisas dentro de uma lista (como uma Lista de Tarefas, por exemplo).

Bem, uma lista de tarefas é meio chata. Que tal fazermos uma lista de citações de personagens de Star Wars? Incrível, não é? Além disso, aqui é onde você pode encontrar o código finalizado para a aplicação.

A propósito, o que estamos construindo não é uma aplicação de página única atraente. Estamos focando principalmente em como usar o CRUD, o Express e Mongo DB neste tutorial. Serão, portanto, mais orientações de como criar o lado do servidor. Não vou enfatizar o estilo.

Você precisará de duas coisas para começar com este tutorial:

1. Você não deve ter medo de digitar comandos em um shell. Confira este artigo (em inglês) se estiver com medo.
2. Você precisa ter o Node instalado.

Para verificar se você tem o Node instalado, abra sua linha de comando e execute o seguinte código:

$ node -v

Você deve obter um número de versão se tiver o Node instalado. Se não tiver, você pode instalar o Node baixando o instalador do site do Node ou baixando-o por meio de gerenciadores de pacotes como Homebrew (Mac) e Chocolatey (Windows).

Começando

Comece criando uma pasta para este projeto. Sinta-se à vontade para chamá-la do que quiser. Depois de navegar até ela, execute o comando npm init.

Esse comando cria um arquivo package.json, que ajuda você a gerenciar as dependências que instalaremos mais tarde no tutorial.

$ npm init

Basta pressionar Enter em tudo o que aparecer. Falarei sobre o que você precisa saber à medida que avançamos.

Executando o Node pela primeira vez em sua vida

A maneira mais simples de usar o node é executar o comando node e especificar um caminho para um arquivo. Vamos criar um arquivo chamado server.js para executar o node.

$ touch server.js

Quando executarmos o arquivo server.js, queremos ter certeza de que ele está sendo executado corretamente. Para fazer isso, basta escrever uma instrução console.log no server.js:

console.log('Que o Node esteja com você')

Agora, execute node server.js em sua linha de comando e você deverá ver a instrução que você registrou:

Ótimo. Vamos em frente e aprender como usar o Express agora.

Usando o Express

Primeiro, temos que instalar o Express antes de podermos usá-lo em nossa aplicação. Instalar o Express é muito fácil. Tudo o que temos que fazer é executar um comando de instalação com o gerenciador de pacotes do Node (npm), que vem junto com o Node.

Execute o comando npm install express --save em sua linha de comando:

$ npm install express --save

Depois de terminar, você deverá ver que o npm salvou o Express como uma dependência no package.json.

Em seguida, usamos o express em server.js exigindo-o.

const express = require('express');
const app = express();

A primeira coisa que queremos fazer é criar um servidor ao qual os navegadores possam se conectar. Podemos fazer isso com a ajuda de um método listen fornecido pelo Express:

app.listen(3000, function() {
	console.log('Escutando na porta 3000')
})

Agora, execute node server.js e navegue até localhost:3000 em seu navegador. Você deverá ver uma mensagem que diz Cannot get /.

Isso é um bom sinal. Significa que agora podemos nos comunicar com nosso servidor do Express através do navegador. É aqui que começamos as operações CRUD.

CRUD — LER

A operação LER é realizada pelos navegadores sempre que você visita uma página da web. Nos bastidores, os navegadores enviam uma solicitação GET ao servidor para realizar uma operação de LEITURA. O motivo pelo qual vemos o erro "Cannot get /" é porque ainda não enviamos nada de volta ao navegador do nosso servidor.

No Express, lidamos com uma solicitação GET com o método get:

app.get(caminho, callback)

O primeiro argumento, caminho, é o caminho da solicitação GET. É qualquer coisa que vem depois do nome de domínio.

Quando estamos visitando localhost:3000, nossos navegadores estão, na verdade, procurando por localhost:3000/. O argumento caminho, neste caso, é /.

O segundo argumento é uma função de callback que informa ao servidor o que fazer quando o caminho é correspondido. Ele recebe dois argumentos, um objeto de solicitação e um objeto de resposta:

app.get('/', function (request, response) {
  // faça algo aqui
})

Por enquanto, vamos escrever "Olá Mundo" de volta para o navegador. Fazemos isso usando um método send que vem com o objeto de resposta:

app.get('/', function(req, res) {
  res.send('Olá Mundo')
}) // Observação: solicitação e resposta são geralmente escritas como req e res, respectivamente.

Vou começar a escrever em código ES6 e mostrar como converter para ES6 ao longo do caminho também. Primeiro, estou substituindo o function() pela arrow function, da ES6. O código abaixo é o mesmo que o código acima:

app.get('/', (req, res) => {
  res.send('Olá mundo')
})

Agora, reinicie seu servidor fazendo o seguinte:

1. Pare o servidor atual pressionando CTRL + C na linha de comando.
2. Execute node server.js novamente.

Em seguida, navegue até localhost:3000 em seu navegador. Você deverá ver uma string que diz "Hello World" (Olá Mundo).

Ótimo. Vamos mudar nossa aplicação para que sirva uma página index.html de volta para o navegador. Para fazer isso, usamos o método sendFile que é fornecido pelo objeto res.

app.get('/', (req, res) => {
  res.sendFile(__dirname + '/index.html')
}) // Observação: __dirname é o caminho para o seu diretório de trabalho atual. Tente registrá-lo e veja o que você obtém! O meu era '/Users/zellwk/Projects/demo-repos/crud-express-mongo' para esta aplicação.

No método sendFile() acima, dissemos ao Express para servir um arquivo index.html que pode ser encontrado na raiz da pasta do seu projeto. Ainda não temos esse arquivo. Vamos criá-lo agora.

touch index.html

Vamos colocar algum texto em nosso arquivo index.html também:

<!DOCTYPE html>
<html lang="en">
	<head>
	  <meta charset="UTF-8">
	  <title>MEU APP</title></head>
	</head>
	<body>
		Que o Node e o Express estejam com você.
	</body>
</html>

Reinicie seu servidor e atualize seu navegador. Você deverá ver os resultados do seu arquivo HTML agora.

É assim que o Express lida com uma solicitação GET (operação LER) em poucas palavras.

Neste ponto, você provavelmente percebeu que precisa reiniciar seu servidor sempre que fizer uma alteração em server.js. Esse processo é incrivelmente tedioso. Por isso, vamos fazer um pequeno desvio e otimizá-lo usando um pacote chamado nodemon.

Apresentando o Nodemon

O Nodemon reinicia o servidor automaticamente sempre que você salva um arquivo que o servidor usa. Podemos instalar o Nodemon usando o seguinte comando:

$ npm install nodemon --save-dev

Observação: o motivo pelo qual estamos usando uma flag --save-dev aqui é porque estamos usando o Nodemon apenas quando estamos desenvolvendo. Essa flag salvaria o Nodemon como uma devDependency em seu arquivo package.json.

Continuando, o Nodemon se comporta exatamente da mesma maneira que o node, o que significa que podemos executar nosso servidor chamando nodemon server.js. No entanto, não podemos fazer isso na linha de comando agora porque o Nodemon não está instalado com uma flag -g.

Há outra maneira de executar o Nodemon — podemos executá-lo a partir da pasta node_modules. O código se parece com isto:

$ ./node_modules/.bin/nodemon server.js

Isso é muito para digitar. Uma maneira de simplificar é criar uma chave de script em package.json.

{  
	// ...
   "scripts": {
		"dev": "nodemon server.js"
	}
    // ...
}

Agora, você pode executar npm run dev para acionar nodemon server.js.

De volta ao tópico principal. Vamos cobrir a operação CRIAR em seguida.

CRUD — CRIAR

A operação CRIAR é realizada apenas pelo navegador se uma solicitação POST for enviada ao servidor. Essa solicitação POST pode ser acionada com JavaScript ou por meio de um elemento <form>.

Vamos descobrir como usar um elemento <form> para criar entradas para nossa aplicação de citações de Star Wars para esta parte do tutorial.

Para fazer isso, você primeiro precisa criar um elemento <form> e adicioná-lo ao seu arquivo index.html. Você precisa ter três coisas nesse elemento de formulário:

1. Um atributo action
2. Um atributo method
3. Atributos name em todos os elementos <input> dentro do formulário

<form action="/quotes" method="POST">
	<input type="text" placeholder="nome" name="nome">
	<input type="text" placeholder="citação" name="citação">
	<button type="submit">Enviar</button>
</form>

O atributo action informa ao navegador para onde navegar em nossa aplicação Express. Neste caso, estamos navegando para /quotes. O atributo method informa ao navegador qual solicitação enviar. Neste caso, é uma solicitação POST.

Em nosso servidor, podemos lidar com essa solicitação POST com um método post que o Express fornece. Ele recebe os mesmos argumentos que o método GET:

app.post('/quotes', (req, res) => {  console.log('Oláááááááááááááá!')})

Reinicie seu servidor (espero que você tenha configurado o Nodemon para que ele reinicie automaticamente) e atualize seu navegador. Em seguida, insira algo em seu elemento de formulário. Você deverá ver Oláááááááááááááá! em sua linha de comando.

Ótimo, sabemos que o Express está lidando com o formulário para nós agora. A próxima pergunta é: como obtemos os valores de entrada com o Express?

Acontece que o Express não lida com a leitura de dados do elemento <form> por conta própria. Temos que adicionar outro pacote chamado body-parser para obter essa funcionalidade.

$ npm install body-parser --save

O Express nos permite adicionar middlewares como body-parser à nossa aplicação com o método use. Você ouvirá muito o termo middleware ao lidar com o Express. Essas coisas são basicamente plug-ins que alteram o objeto de solicitação ou resposta antes que eles sejam tratados por nossa aplicação. Certifique-se de colocar o body-parser antes de seus manipuladores CRUD!

const express = require('express')
const bodyParser= require('body-parser')
const app = express()
app.use(bodyParser.urlencoded({extended: true}))
// Todos os outros manipuladores aqui...

O método urlencoded dentro do body-parser informa ao body-parser para extrair dados do elemento <form> e adicioná-los à propriedade body no objeto de solicitação.

Nota da tradução: nas versões mais recentes, é possível usar express.json no lugar de body-parser para fazer o parsing do documento, tornando desnecessária a requisição deste último.

Agora, você deverá ver tudo no campo do formulário dentro do objeto req.body. Tente fazer um console.log e veja o que é!

app.post('/quotes', (req, res) => {
  console.log(req.body)
})

Você deverá obter um objeto semelhante ao seguinte em sua linha de comando:

Hmmm. Mestre Yoda falou! Vamos garantir que nos lembremos das palavras de Yoda. É importante. Queremos poder recuperá-las na próxima vez que carregarmos nossa página inicial.

É aqui que entra o banco de dados, o MongoDB.

MongoDB

Primeiro, temos que instalar o MongoDB através do npm se quisermos usá-lo como nosso banco de dados.

npm install mongodb --save

Depois de instalado, podemos nos conectar ao MongoDB através do método connect do Mongo.Client, conforme mostrado no código abaixo:

const MongoClient = require('mongodb').MongoClient

MongoClient.connect('link-para-o-mongodb', (err, database) => {
  // ... inicie o servidor
})

A próxima parte é obter o link correto para nosso banco de dados. A maioria das pessoas armazenam seus bancos de dados em serviços em nuvem como o MongoLab. Faremos o mesmo também.

Então, vá em frente e crie uma conta no MongoLab. (É grátis). Depois de terminar, crie uma nova implantação do MongoDB e defina o plano como sandbox.

Depois de terminar de criar a implantação, vá até ela e crie um usuário de banco de dados e uma senha de banco de dados. Lembre-se do usuário e da senha do banco de dados porque você os usará para conectar o banco de dados que acabou de criar.

Finalmente, pegue o URL do MongoDB e adicione-a ao seu método MongoClient.connect. Certifique-se de usar seu usuário e senha do banco de dados!

MongoClient.connect('seu-url-do-mongodb', (err, database) => {
  // ... faça algo aqui
})

Em seguida, queremos iniciar nossos servidores apenas quando o banco de dados estiver conectado. Portanto, vamos mover app.listen para dentro do método connect(). Também vamos criar uma variável db para nos permitir usar o banco de dados quando lidarmos com solicitações do navegador.

var db

MongoClient.connect('sua-url-do-mongodb', (err, database) => {
  if (err) return console.log(err)
  db = database  
  app.listen(3000, () => {
    console.log('escutando na porta 3000')
  })
})

Terminamos de configurar o MongoDB. Agora, vamos criar uma coleção de citações para armazenar citações para nossa aplicação.

A propósito, uma coleção é um local nomeado para armazenar coisas. Você pode criar quantas coleções quiser. Podem ser coisas como "produtos", "citações", "mantimentos" ou quaisquer outros rótulos que você escolher.

Podemos criar a coleção de citações usando a string quotes ao chamar o método db.collection() do MongoDB. Ao criar a coleção de citações, também podemos salvar nossa primeira entrada no MongoDB com o método save simultaneamente.

Depois de terminarmos de salvar, temos que redirecionar o usuário para algum lugar (ou ele ficará preso esperando para sempre que nosso servidor se mova). Nesse caso, vamos redirecioná-los de volta para /, o que faz com que seus navegadores recarreguem.

app.post('/quotes', (req, res) => {
  db.collection('quotes').save(req.body, (err, result) => {
    if (err) return console.log(err)
    console.log('salvo no banco de dados')
    res.redirect('/')
    })
})

Agora, se você inserir algo no elemento, poderá ver uma entrada em sua coleção do MongoDB.

Uhuuu! Já que já temos algumas citações na coleção, por que não tentar mostrá-las ao nosso usuário quando ele acessar nossa página?

Mostrando citações aos usuários

Temos que fazer duas coisas para mostrar as citações armazenadas no MongoLab aos nossos usuários.

1. Obter citações do MongoLab
2. Usar um mecanismo de template para exibir as citações

Vamos passo a passo.

Podemos obter as citações do MongoLab usando o método find que está disponível no método collection.

app.get('/', (req, res) => {
	var cursor = db.collection('quotes').find()
})

O método find retorna um cursor (um objeto do Mongo) que provavelmente não faz sentido se você fizer console.log dele.

A boa notícia é que esse objeto cursor contém todas as citações do nosso banco de dados. Ele também contém várias outras propriedades e métodos que nos permitem trabalhar com dados facilmente. Um desses métodos é o método toArray().

O método toArray recebe uma função de callback que nos permite fazer coisas com as citações que recuperamos do MongoLab. Vamos tentar fazer um console.log() para os resultados e ver o que obtemos!

db.collection('quotes').find().toArray(function(err, results) {
	console.log(results)  // enviar arquivo HTML preenchido com citações aqui
})

Ótimo! Agora, você vê um array de citações (eu só tenho uma agora). Concluímos a primeira parte — obter dados do MongoLab. A próxima parte é gerar um HTML que contenha todas as nossas citações.

Não podemos servir nosso arquivo index.html e esperar que as citações apareçam magicamente porque não há como adicionar conteúdo dinâmico a um arquivo HTML. O que podemos fazer em vez disso é usar mecanismos de template para nos ajudar. Alguns mecanismos de template populares incluem Jade, Embedded JavaScript e Nunjucks.

Escrevi extensivamente sobre o como e o porquê dos mecanismos de template em uma artigo separado (em inglês). Você pode querer dar uma olhada se não tiver ideia do que são mecanismos de template. Eu pessoalmente uso (e recomendo) Nunjucks como meu mecanismo de template de escolha. Sinta-se à vontade para conferir o artigo para descobrir o porquê.

Para este tutorial, vamos usar Embedded JavaScript - ejs como nosso mecanismo de template porque é o mais fácil para começar. Você o achará familiar desde o início, pois já conhece HTML e JavaScript.

Podemos usar o EJS primeiro instalando-o e, em seguida, definindo o mecanismo de visualização no Express como ejs.

$ npm install ejs --save

app.set('view engine', 'ejs')

Depois que o mecanismo de visualização for definido, podemos começar a gerar o HTML com nossas citações. Esse processo também é chamado de renderização. Podemos usar o objeto render integrado ao objeto de resposta render para fazer isso. Ele tem a seguinte sintaxe:

res.render(view, locals)

O primeiro parâmetro, views, é o nome do arquivo que estamos renderizando. Esse arquivo deve ser colocado dentro de uma pasta views.

O segundo parâmetro, locals, é um objeto que passa dados para a visualização.

Vamos primeiro criar um arquivo index.ejs dentro da pasta views para que possamos começar a preencher os dados.

$ mkdir views$ touch views/index.ejs

Agora, coloque o seguinte código dentro de index.ejs.

<ul class="quotes">
	<% for(var i=0; i<quotes.length; i++) {%>
		<li class="quote">
      		<span><%= quotes[i].name %></span>
      		<span><%= quotes[i].quote %></span>
    	</li>
	<% } %>
</ul>

Viu o que eu quis dizer quando disse que você o acharia familiar? No EJS, você pode escrever JavaScript dentro de tags <% e %>. Você também pode gerar JavaScript como strings se usar as tags <%= e %>.

Aqui, você pode ver que estamos basicamente percorrendo o array quotes e criando strings com quotes[i].name e quotes[i].quote.

Mais uma coisa a fazer antes de prosseguirmos com o arquivo index.ejs. Lembre-se de copiar o elemento <form> do arquivo index.html para esse arquivo também. O arquivo index.ejs completo até agora deve ser:

<!DOCTYPE html>
<html lang="en">
	<head>
    	<meta charset="UTF-8">
        <title>MEU APP</title>
    </head>
    <body>
    	Que o Node e o Express estejam com você.
        <ul class="quotes">
        	<% for(var i=0; i<quotes.length; i++) {%>
            	<li class="quote">
                	<span><%= quotes[i].name %></span>
                    <span><%= quotes[i].quote %></span>
                </li>
            <% } %>
        </ul>
        <form action="/quotes" method="POST">
        	<input type="text" placeholder="nome" name="nome">
            <input type="text" placeholder="citação" name="citação">
            <button type="submit">Enviar</button>
        </form>
     </body>
</html>

Finalmente, temos que renderizar esse arquivo index.ejs ao lidar com a solicitação GET. Aqui, estamos definindo os resultados (um array) como o array quotes que usamos em index.ejs acima.

app.get('/', (req, res) => {
	db.collection('quotes').find().toArray((err, result) => {
    	if (err) return console.log(err)    // renderiza index.ejs
        res.render('index.ejs', {quotes: result})
    })
})

Agora, atualize seu navegador e você deverá ver as citações do Mestre Yoda.

Ah, você pode ter apenas uma citação se seguiu o tutorial passo a passo até esse ponto. O motivo pelo qual tenho várias citações é porque adicionei mais silenciosamente enquanto trabalhava na aplicação.

Conclusão

Cobrimos muito terreno em apenas 3 mil palavras! Aqui estão alguns marcadores para resumir tudo. Você...

• Criou um servidor Express
• Aprendeu a executar operações CRIAR (CREATE) e LER (READ)
• Aprendeu a salvar e ler no MongoDB
• Aprendeu a usar um mecanismo de template como o Embedded JS.

Este artigo apareceu pela primeira vez no blog do autor (em inglês). Confira o blog se quiser ver mais artigos como este.

Escrito por: Pablo Regen

Você, provavelmente, já leu essas frases antes…

O Node.js é um ambiente de tempo de execução de JavaScript criado usando a engine de JavaScript do Chrome, a V8

O Node.js usa um modelo assíncrono e não bloqueador da E/S, orientado a eventos

O Node.js opera em um loop de eventos em thread única

Se já, você pode ter se perguntado o significado de tudo isso. Ao final deste artigo, espero que você tenha uma compreensão melhor dessas frases e saiba o que o Node é, como ele funciona e por que e quando é uma boa ideia usá-lo.

Vamos começar examinando a terminologia.

E/S (entrada e saída – em inglês I/O, ou input/output)

E/S é a abreviação para (dispositivos de) entrada/saída. E/S (ou I/O) tem a ver primordialmente com a interação do programa com o disco e com a rede do sistema. Exemplos de operações de E/S incluem a leitura/gravação de dados de/para uma unidade de disco, a realização de solicitações de HTTP e a comunicação com um banco de dados. São dispositivos muito lentos se comparados com o acesso à memória (RAM) ou com a realização de tarefas pela CPU.

Síncrono x Assíncrono

Execução síncrona (ou "sync") geralmente se refere ao código sendo executado em sequência. Na programação síncrona, o programa é executado linha a linha, uma linha de cada vez. Sempre que uma função é chamada, a execução do programa aguarda até que aquela função retorne um resultado antes de continuar na próxima linha do código.

Execução assíncrona (ou "async") é a execução que não é feita na mesma sequência em que aparece no código. Na programação assíncrona, o programa não aguarda até que a tarefa seja concluída, podendo seguir para a próxima tarefa.

No exemplo a seguir, a operação síncrona faz com que os alertas sejam disparados em sequência. Na operação assíncrona, embora alert(2) pareça ser o segundo a ser executado, não é isso que acontece.

// Operação síncrona: 1,2,3
alert(1);
alert(2);
alert(3);

// Operação assíncrona: 1,3,2
alert(1);
setTimeout(() => alert(2), 0);
alert(3);

Uma operação assíncrona é frequentemente relacionada a E/S, embora setTimeout seja um exemplo de algo que não tenha a ver com E/S, mas ainda seja assíncrono. De um modo geral, qualquer coisa relacionada à computação é sincronizada e qualquer coisa relacionada à entrada/saída/tempo é assíncrona. A razão para as operações de E/S serem feitas de maneira assíncrona é que elas são muito lentas e bloqueariam a execução adicional do código do contrário.

Bloqueador x não bloqueador

O modelo bloqueador se refere a operações que bloqueiam/impedem o resto da execução até que aquela operação esteja concluída. Não bloqueador, por sua vez, se refere ao código que não impede o resto da execução. Conforme vemos na documentação do Node.js, operações bloqueadoras ocorrem quando a execução de JavaScript adicional no processo do Node.js deve aguardar até que uma operação não relacionada ao JavaScript seja concluída.

Métodos bloqueadores executam de modo síncrono, enquanto métodos não bloqueadores executam de modo assíncrono.

// Bloqueador
const fs = require('fs');
const dados = fs.readFileSync('/arquivo.md'); // há um bloqueio aqui até que o arquivo seja lido
console.log(dados);
maisTarefas(); // será executado após o console.log

// Não bloqueador
const fs = require('fs');
fs.readFile('/arquivo.md', (err, dados) => {
  if (err) throw err;
  console.log(dados);
});
maisTarefas(); // será executado antes do console.log

No primeiro exemplo, console.log será chamado antes de maisTarefas(). No segundo exemplo, fs.readFile() é não bloqueador, o que faz com que a execução do JavaScript possa continuar e chamar maisTarefas() primeiro.

No Node, não bloqueador tem primordialmente a ver com operações de E/S e com JavaScript de baixo desempenho em função de demandar demais da CPU, enquanto aguardar por uma operação que não seja do JavaScript, como as operações de E/S, não é tipicamente considerado bloqueador.

Todos os métodos de E/S na biblioteca padrão do Node.js fornecem versões assíncronas – e, portanto, não bloqueadoras – e que aceitam funções de callback. Alguns métodos também têm equivalentes bloqueadores, cujos nomes terminam em "Sync" (veja os exemplos de readFile e readFileSync acima).

Operações de E/S não bloqueadores permitem que um único processo sirva diversas solicitações ao mesmo tempo. Em vez de o processo ser bloqueado e ficar esperando que operações de E/S sejam concluídas, as operações de E/S são delegadas ao sistema. Assim, o processo pode executar a parte seguinte do código. Operações de E/S não bloqueadoras fornecem uma função de callback, que é chamada quando a operação é concluída.

Callbacks

Callbacks são funções passadas como argumento de uma outra função, e que, então, podem ser invocadas (chamadas novamente, ou, em inglês, called back) dentro da função externa para concluir algum tipo de ação na hora em que for conveniente. A chamada pode ser imediata (callback síncrona) ou pode acontecer mais tarde (callback assíncrona).

// Callback síncrona
function saudacao(callback) {
  callback();
}
saudacao(() => { console.log('Olá'); });
maisTarefas(); // será executado após o console.log

// Callback assíncrona
const fs = require('fs');
fs.readFile('/arquivo.md', function callback(err, dados) { // fs.readFile é um método assíncrono fornecido pelo Node
  if (err) throw err;
  console.log(dados);
});
maisTarefas(); // será executado antes do console.log

No primeiro exemplo, a função de callback é chamada imediatamente dentro da função externa saudacao e faz o registro no console antes que maisTarefas() seja executada.

No segundo exemplo, fs.readFile (um método assíncrono fornecido pelo Node) lê o arquivo e, quando termina, chama a função de callback com um erro ou o conteúdo do arquivo. Enquanto isso, o programa pode continuar a execução do código.

Uma função de callback assíncrona pode ser chamada quando um evento acontece ou quando uma tarefa é concluída. Ela evita o bloqueio, permitindo que outro código seja executado enquanto isso.

Em vez de o código ser lido de cima para baixo de modo procedural, os programas assíncronos podem executar funções diferentes em momentos diferentes com base na ordem e velocidade em que funções anteriores, como solicitações de http ou leituras do sistema de arquivos, acontecem. Eles são usados quando você não sabe quando alguma operação assíncrona será concluída.

É preciso, no entanto, evitar o chamado "inferno das callbacks", situação na qual as callbacks são aninhadas dentro de outras callbacks por vários níveis, tornando o código de difícil compreensão, além de difícil de manter e depurar.

Eventos e programação orientada a eventos

Eventos são ações geradas pelo usuário ou pelo sistema, como um clique, um download de arquivo concluído ou um erro de hardware ou software.

A programação orientada a eventos é um paradigma de programação no qual o fluxo do programa é determinado por eventos. Um programa orientado a eventos executa ações em resposta a eventos. Quando ocorre um evento, ele dispara uma função de callback.

Agora, vamos tentar entender o Node e ver como tudo isso se relaciona com ele.

Node.js: o que é, por que foi criado e como funciona?

Colocado de maneira simples, o Node.js é uma plataforma que executa programas em JavaScript do lado do servidor que pode se comunicar com fontes de E/S, como redes e arquivos de sistemas.

Quando Ryan Dahl criou o Node em 2009, ele disse que a E/S vinha sendo manipulada incorretamente, bloqueando todo o processo devido à programação síncrona.

Técnicas de servir conteúdo para a web tradicionais usavam o modelo de threads, ou seja, usavam uma thread para cada solicitação. Como, em uma operação de E/S, a solicitação passa a maior parte do tempo aguardando até ser concluída, cenários com uso intenso de E/S incorporam uma grande quantidade de recursos não utilizados (como a memória) associados a essas threads. Portanto, o modelo de "uma thread por solicitação" para um servidor é um modelo que não dimensiona muito bem.

Dahl argumentou que o software deveria ser capaz de realizar várias tarefas e propôs eliminar o tempo gasto aguardando que os resultados de E/S retornassem. Em vez do modelo de threads, ele disse que a maneira certa de lidar com várias conexões simultâneas era ter uma thread única, um loop de eventos e E/S sem bloqueio. Por exemplo, quando você faz uma consulta a um banco de dados, em vez de aguardar a resposta, você dá a ele uma função de callback para que sua execução possa rodar essa instrução e continuar fazendo outras coisas. Quando os resultados retornam, você pode executar a callback.

O loop de eventos é o que permite que o Node.js execute operações de E/S sem bloqueio, apesar do fato de que o JavaScript é de thread única. O loop, que é executado na mesma thread que o código em JavaScript, pega uma tarefa do código e a executa. Se a tarefa for assíncrona ou uma operação de E/S, o loop a delegará para o kernel do sistema, como no caso de novas conexões com o servidor, ou para um pool de threads, como operações relacionadas ao sistema de arquivos. O loop, então, pega a próxima tarefa e a executa.

Como a maioria dos kernels modernos têm várias threads, eles podem lidar com várias operações em execução em segundo plano. Quando uma dessas operações é concluída (este é um evento), o kernel informa a Node.js para que a callback apropriada (aquela que dependia da conclusão da operação) possa ser adicionada à fila para, por fim, ser executada.

O nó controla as operações assíncronas inacabadas, enquanto o loop de eventos continua em loop para verificar se elas estão concluídas até que todas elas estejam.

Para acomodar o loop de eventos de thread única, o Node.js usa a biblioteca libuv, que, por sua vez, usa um pool de threads de tamanho fixo que lida com a execução de algumas das operações de E/S assíncronas não bloqueadoras em paralelo. As funções de chamada da thread principal lançam tarefas na fila de tarefas compartilhadas, que as threads no pool de threads resgatam e executam.

Funções do sistema inerentemente sem bloqueio, como a rede, são convertidas em soquetes sem bloqueio do lado do kernel, enquanto funções do sistema inerentemente bloqueadas, como E/S de arquivos, são executadas de maneira bloqueada em suas próprias threads. Quando uma thread no pool de threads conclui uma tarefa, ela informa a thread principal sobre isso, que, por sua vez, ativa e executa a callback registrada.

A imagem acima é retirada da apresentação de Philip Roberts na JSConf EU: What the heck is the event loop anyway? ("O que diabos é esse o loop de eventos?", em português). Recomendo assistir o vídeo inteiro (em inglês) para se ter uma ideia geral de como funciona o loop de eventos.

O diagrama explica como o loop de eventos funciona com o navegador, mas sua aparência é basicamente idêntica à do Node. Em vez de APIs da Web, teríamos APIs do Node.

De acordo com a apresentação, a pilha de chamadas (também conhecida como pilha de execução, "call stack" ou, simplesmente, "a stack") é uma estrutura de dados que registra onde no programa estamos. Se entrarmos em uma função, colocamos algo na pilha. Se retornarmos de uma função, nós a tiramos do topo da pilha.

É assim que o código no diagrama é processado quando o executamos:

1. Colocamos main() na pilha (o próprio arquivo)
2. Colocamos console.log('Hi'); na pilha, que é executado imediatamente, registrando "Hi" ("Olá") no console e sendo removido da pilha
3. Colocamos setTimeout(cb, 5000) na pila. setTimeout é uma API fornecida pelo navegador (no back-end, seria uma API do Node). Quando setTimeout é chamada com a função de callback e com os argumentos de atraso, o navegador aciona um temporizador com o tempo de atraso (no caso, 5 mil milissegundos)
4. A chamada de setTimeout é concluída e ela é removida da pilha
5. Colocamos console.log(‘JSConfEU’); na pilha, que executa imediatamente, registrando "JSConfEU" no console e é removida da pilha
6. main() é removida da pilha
7. Após 5 mil milissegundos, o temporizador da API conclui e a função de callback é movida para a fila de tarefas
8. O loop de eventos verifica se a pilha está vazia, já que o JavaScript, por ser de thread única, só consegue fazer uma coisa por vez (setTimeout não é garantido, apenas um tempo mínimo para a execução). Se a pilha estiver vazia, ele pega a primeira coisa que estiver na fila e a envia para a pilha. Assim, o loop coloca a callback na pilha
9. A callback é executada, registra "there" (no final, temos a expressão "Hi there", algo como "Olá, pessoal!", registrado) no console e é removida da pilha. Isso encerra o processo

Se quiser se aprofundar ainda mais nos detalhes de como o Node.js, a libuv, o loop de eventos e o pool de threads funcionam, sugiro conferir os recursos na seção se referências do final – em especial esta, esta e esta referências, juntamente com a documentação do Node (texto e vídeos em inglês).

Node.js: por que e onde usá-lo?

Como quase nenhuma função no Node executa diretamente a E/S, o processo nunca bloqueia (as operações de E/S são descarregadas e executadas de maneira assíncrona no sistema), tornando-se uma boa opção para desenvolver sistemas altamente escaláveis.

Devido ao seu loop de eventos orientado a eventos, thread única e modelo de E/S assíncrono sem bloqueio, o Node.js tem melhor desempenho em aplicações de uso intenso de E/S que exigem velocidade e escalabilidade com muitas conexões simultâneas, como streaming de vídeo e áudio, aplicações em tempo real, bate-papos ao vivo, aplicações de jogos, ferramentas de colaboração ou software de bolsa de valores.

O Node.js pode não ser a escolha certa para operações que exigem muito da CPU. Em vez disso, o modelo de thread tradicional pode ter um desempenho melhor.

npm

O npm é o gerenciador de pacotes padrão do Node.js e é instalado no sistema quando o Node.js é instalado. Ele pode gerenciar pacotes que são dependências locais de um projeto específico, bem como ferramentas do JavaScript instaladas de modo global.

O site www.npmjs.com hospeda milhares de bibliotecas gratuitas para baixar e usar em seu programa para tornar o desenvolvimento mais rápido e eficiente. No entanto, como qualquer pessoa pode criar bibliotecas e não há processo de verificação para o envio, você deve ter cuidado com as de baixa qualidade, inseguras ou maliciosas. O npm depende de relatórios de usuários para remover pacotes se eles violarem as políticas e, para ajudar você a decidir, inclui estatísticas como número de downloads e número de pacotes dependentes.

Como executar código no Node.js

Comece instalando o Node no seu computador, se você ainda não o tiver. A maneira mais fácil é visitar nodejs.org e clicar no botão para fazer o download. A menos que você queira ou precise ter acesso aos recursos mais recentes, baixe a versão LTS (Long Term Support – em português, suporte de longa duração) para seu sistema operacional.

Você executa uma aplicação do Node a partir do terminal do seu computador. Por exemplo, faça um arquivo chamado "app.js" e adicione console.log('Olá'); a ele. No seu terminal, mude o diretório para a pasta onde se encontra o arquivo e execute o comando node app.js. Você verá "Olá" no console. 🙂

Referências

Aqui temos alguns recursos interessantes que eu revisei durante a composição deste artigo.

Apresentações do Node.js feitas pelo criador (em inglês):

• Apresentação original do Node.js, feita por Ryan Dahl na JSConf 2009
• 10 coisas das quais me arrependo com o Node.js, feita por Ryan Dahl na JSConf EU 2018

Apresentações sobre o Node, o loop de eventos e a biblioteca libuv (em inglês):

• What the heck is the event loop anyway?, feita por Philip Roberts na JSConf EU
• Node.js Explained, por Jeff Kunkle
• In The Loop, feita por Jake Archibald na JSConf Asia 2018
• Everything You Need to Know About Node.js Event Loop, por Bert Belder
• A deep dive into libuv, por Saul Ibarra Coretge na NodeConf EU 2016

Documentação do Node (em inglês):

• About Node.js
• The Node.js Event Loop, Timers, and process.nextTick()
• Overview of Blocking vs Non-Blocking

Recursos adicionais (em inglês, exceto os recursos da Wikipédia):

• Art of Node, por Max Ogden
• Callback hell, por Max Ogden
• What is non-blocking or asynchronous I/O in Node.js?, no Stack Overflow
• Programação orientada a eventos na Wikipédia
• Node.js na Wikipédia
• Thread na Wikipédia
• libuv

Obrigado pela leitura.

Escrito por: Antonio Erdeljac

Ajude o autor lendo o texto no original: ORIGINAL (em inglês)

Neste artigo, você aprenderá a lidar com a autenticação para um servidor do Node usando o Passport.js. O artigo não tratará da autenticação no front-end. Use-o para configurar a autenticação no back-end (geração de token para cada usuário e proteção das rotas).

Lembre-se de que, se tiver problemas em alguma das etapas, é possível consultar a qualquer momento o repositório do GitHub.

Neste artigo, ensinarei o seguinte:

• Tratamento de rotas protegidas
• Tratamento de tokens do JWT
• Tratamento de respostas não autorizadas
• Criação de uma API básica
• Criação de modelos e esquemas

Introdução

O que é o Passport.js?

O Passport é um middleware de autenticação para o Node.js. Por ser extremamente flexível e modular, o Passport pode ser colocado sem problemas em qualquer aplicação para a web baseada no Express. Um conjunto extenso de estratégias dá suporte à autenticação usando um nome de usuário e senha, Facebook, Twitter e muito mais. Saiba mais sobre o Passport aqui (documentação em inglês).

Tutorial

Criação do servidor do Node desde o início

Crie um diretório com este arquivo "app.js" dentro dele:

const express = require('express');
const path = require('path');
const bodyParser = require('body-parser');
const session = require('express-session');
const cors = require('cors');
const mongoose = require('mongoose');
const errorHandler = require('errorhandler');

//Configure mongoose's promise to global promise
mongoose.promise = global.Promise;

//Configure isProduction variable
const isProduction = process.env.NODE_ENV === 'production';

//Initiate our app
const app = express();

//Configure our app
app.use(cors());
app.use(require('morgan')('dev'));
app.use(bodyParser.urlencoded({ extended: false }));
app.use(bodyParser.json());
app.use(express.static(path.join(__dirname, 'public')));
app.use(session({ secret: 'passport-tutorial', cookie: { maxAge: 60000 }, resave: false, saveUninitialized: false }));

if(!isProduction) {
  app.use(errorHandler());
}

//Configure Mongoose
mongoose.connect('mongodb://localhost/passport-tutorial');
mongoose.set('debug', true);

//Error handlers & middlewares
if(!isProduction) {
  app.use((err, req, res) => {
    res.status(err.status || 500);

    res.json({
      errors: {
        message: err.message,
        error: err,
      },
    });
  });
}

app.use((err, req, res) => {
  res.status(err.status || 500);

  res.json({
    errors: {
      message: err.message,
      error: {},
    },
  });
});

app.listen(8000, () => console.log('Server running on http://localhost:8000/'));

Instalaremos o nodemon para facilitar o desenvolvimento.

npm install -g nodemon

Em seguida, vamos executar nosso "app.js" com ele.

$ nodemon app.js

Criação do modelo de usuário

Crie uma pasta chamada "models" e um arquivo "Users.js" dentro dessa pasta. É aí que definiremos nosso "UsersSchema", ou esquema de usuário. Usaremos JWT e Crypto para gerar o hash e o salt da string password recebida. Isso será usado mais tarde para a validação do usuário.

const mongoose = require('mongoose');
const crypto = require('crypto');
const jwt = require('jsonwebtoken');

const { Schema } = mongoose;

const UsersSchema = new Schema({
  email: String,
  hash: String,
  salt: String,
});

UsersSchema.methods.setPassword = function(password) {
  this.salt = crypto.randomBytes(16).toString('hex');
  this.hash = crypto.pbkdf2Sync(password, this.salt, 10000, 512, 'sha512').toString('hex');
};

UsersSchema.methods.validatePassword = function(password) {
  const hash = crypto.pbkdf2Sync(password, this.salt, 10000, 512, 'sha512').toString('hex');
  return this.hash === hash;
};

UsersSchema.methods.generateJWT = function() {
  const today = new Date();
  const expirationDate = new Date(today);
  expirationDate.setDate(today.getDate() + 60);

  return jwt.sign({
    email: this.email,
    id: this._id,
    exp: parseInt(expirationDate.getTime() / 1000, 10),
  }, 'secret');
}

UsersSchema.methods.toAuthJSON = function() {
  return {
    _id: this._id,
    email: this.email,
    token: this.generateJWT(),
  };
};

mongoose.model('Users', UsersSchema);

Vamos adicionar nosso modelo recém-criado ao "app.js".

Adicione a linha seguinte ao "app.js" após configurar o Mongoose:

require('./models/Users');

Configuração do Passport

Crie uma pasta "config" com o arquivo "passport.js" dentro dela:

const mongoose = require('mongoose');
const passport = require('passport');
const LocalStrategy = require('passport-local');

const Users = mongoose.model('Users');

passport.use(new LocalStrategy({
  usernameField: 'user[email]',
  passwordField: 'user[password]',
}, (email, password, done) => {
  Users.findOne({ email })
    .then((user) => {
      if(!user || !user.validatePassword(password)) {
        return done(null, false, { errors: { 'email or password': 'is invalid' } });
      }

      return done(null, user);
    }).catch(done);
}));

Nesse arquivo, usamos o método validatePassword que definimos no modelo de usuário. Com base no resultado, retornamos um resultado diferente a partir da LocalStrategy (estratégia local) do Passport.

Vamos conectar o "passport.js" ao arquivo "app.js". Adicione a linha a seguir abaixo de todos os models:

require('./config/passport');

Roas e opções de autenticação

Crie uma pasta chamada "routes" com o arquivo "auth.js" dentro dela.

Nesse arquivo, usaremos a função getTokenFromHeaders para obter um token do JWT que será enviado do lado do client nos cabeçalhos (headers) da solicitação. Também criaremos um objeto auth com as propriedades optional e required. Nós as usaremos mais tarde em nossas rotas.

const jwt = require('express-jwt');

const getTokenFromHeaders = (req) => {
  const { headers: { authorization } } = req;

  if(authorization && authorization.split(' ')[0] === 'Token') {
    return authorization.split(' ')[1];
  }
  return null;
};

const auth = {
  required: jwt({
    secret: 'secret',
    userProperty: 'payload',
    getToken: getTokenFromHeaders,
  }),
  optional: jwt({
    secret: 'secret',
    userProperty: 'payload',
    getToken: getTokenFromHeaders,
    credentialsRequired: false,
  }),
};

module.exports = auth;

Na mesma pasta "routes", criamos um arquivo "index.js":

const express = require('express');
const router = express.Router();

router.use('/api', require('./api'));

module.exports = router;

Agora, precisamos de uma pasta "api" dentro da pasta "routes", com outro arquivo "index.js" dentro dela.

const express = require('express');
const router = express.Router();

router.use('/users', require('./users'));

module.exports = router;

Agora, criaremos o arquivo "users.js" que solicitamos em "api/index.js".

Primeiro, criaremos uma rota de autorização opcional "/", que será usada para a criação de um modelo (registro).

router.post('/', auth.optional, (req, res, next) ...

Depois disso, criaremos outra rota de autorização opcional "/login". Ela será usada para ativar nossa configuração do Passport e validar uma senha recebida com e-mail.

router.post('/login', auth.optional, (req, res, next) ...

Por fim, criaremos uma rota de autorização obrigatória, que será usada para retornar o usuário que está logado atualmente. Somente usuários logados (usuários com o token enviado com sucesso por meio dos cabeçalhos de solicitação) têm acesso a essa rota.

router.get('/current', auth.required, (req, res, next) ...

const mongoose = require('mongoose');
const passport = require('passport');
const router = require('express').Router();
const auth = require('../auth');
const Users = mongoose.model('Users');

//POST new user route (optional, everyone has access)
router.post('/', auth.optional, (req, res, next) => {
  const { body: { user } } = req;

  if(!user.email) {
    return res.status(422).json({
      errors: {
        email: 'is required',
      },
    });
  }

  if(!user.password) {
    return res.status(422).json({
      errors: {
        password: 'is required',
      },
    });
  }

  const finalUser = new Users(user);

  finalUser.setPassword(user.password);

  return finalUser.save()
    .then(() => res.json({ user: finalUser.toAuthJSON() }));
});

//POST login route (optional, everyone has access)
router.post('/login', auth.optional, (req, res, next) => {
  const { body: { user } } = req;

  if(!user.email) {
    return res.status(422).json({
      errors: {
        email: 'is required',
      },
    });
  }

  if(!user.password) {
    return res.status(422).json({
      errors: {
        password: 'is required',
      },
    });
  }

  return passport.authenticate('local', { session: false }, (err, passportUser, info) => {
    if(err) {
      return next(err);
    }

    if(passportUser) {
      const user = passportUser;
      user.token = passportUser.generateJWT();

      return res.json({ user: user.toAuthJSON() });
    }

    return status(400).info;
  })(req, res, next);
});

//GET current route (required, only authenticated users have access)
router.get('/current', auth.required, (req, res, next) => {
  const { payload: { id } } = req;

  return Users.findById(id)
    .then((user) => {
      if(!user) {
        return res.sendStatus(400);
      }

      return res.json({ user: user.toAuthJSON() });
    });
});

module.exports = router;

Vamos adicionar nossa pasta "routes" ao "app.js". Adicione esta linha abaixo do require do Passport:

app.use(require('./routes'));

Teste das rotas

Usaremos o Postman para enviar solicitações ao nosso servidor.

Nosso servidor aceita o body (corpo da solicitação) seguinte:

{
  "user": {
    "email": String,
    "password": String
  }
}

Criação de uma solicitação de POST para a criação de um usuário

body do teste:

Resposta:

{
    "user": {
        "_id": "5b0f38772c46910f16a058c5",
        "email": "erdeljac.antonio@gmail.com",
        "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJlbWFpbCI6ImVyZGVsamFjLmFudG9uaW9AZ21haWwuY29tIiwiaWQiOiI1YjBmMzg3NzJjNDY5MTBmMTZhMDU4YzUiLCJleHAiOjE1MzI5MDgxNTEsImlhdCI6MTUyNzcyNDE1MX0.4TWc1TzY6zToHx_O1Dl2I9Hf9krFTqPkNLHI5U9rn8c"
    }
}

Agora, usaremos este token e o adicionaremos aos nossos "Headers" na configuração do Postman.

Vamos, agora, testar nossa rota acessível somente por autorização.

Criação de uma solicitação de GET para retornar o usuário logado atualmente

URL de solicitação:

GET http://localhost:8000/api/users/current

Resposta:

{
    "user": {
        "_id": "5b0f38772c46910f16a058c5",
        "email": "erdeljac.antonio@gmail.com",
        "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJlbWFpbCI6ImVyZGVsamFjLmFudG9uaW9AZ21haWwuY29tIiwiaWQiOiI1YjBmMzg3NzJjNDY5MTBmMTZhMDU4YzUiLCJleHAiOjE1MzI5MDgzMTgsImlhdCI6MTUyNzcyNDMxOH0.5UnA2mpS-_puPwwxZEb4VxRGFHX6qJ_Fn3pytgGaJT0"
    }
}

Vamos tentar fazer o mesmo sem o token nos "Headers".

Resposta:

Conclusão

Agradeço a leitura deste tutorial. Se perceber erros, informe-os ao autor. Se tiver problemas em qualquer uma das etapas, consulte este repositório do GitHub.

Você também pode entrar em contato com o autor por:

• E-mail
• Linkedin

As variáveis de ambiente são uma parte fundamental do desenvolvimento em Node. Por alguma razão, porém, nunca fui atrás de como usá-las adequadamente.

O motivo é, possivelmente, o fato de elas serem chamadas de "variáveis de ambiente".

A expressão "variáveis de ambiente" por si só é um gatilho para o meu trauma de tentar adicionar o caminho correto para o diretório Home do Java no Windows. Devo usar PATH ou JAVA_HOME? Ou ambos? Preciso colocar ponto e vírgula no final? POR QUE RAIOS ESTOU USANDO JAVA?

No Node, as variáveis de ambiente podem ser globais (como no Windows), mas geralmente são usadas em um processo específico que você deseja executar. Por exemplo, se você tiver uma aplicação para a web, talvez tenha variáveis de ambiente que definem:

• A porta HTTP a ser monitorada
• A string que conecta ao banco de dados
• O JAVA_HOME... espere... isso não — desculpe. Ainda estou me recuperando do trauma.

Em contextos assim, as variáveis de ambiente são realmente mais como "ajustes de configuração". Viu como soa melhor dessa maneira?

Se você tem alguma experiência com .NET, talvez esteja familiarizado com o arquivo web.config. As variáveis de ambiente do Node funcionam de um jeito parecido com os ajustes feitos no web.config — são, basicamente, um modo de passar informações que você não quer deixar no código fonte.

Como usar essas variáveis na sua aplicação do Node? Foi difícil encontrar esse conteúdo com a dose necessária de piadas com Java. Portanto, decidi criar eu mesmo. Aqui estão algumas maneiras de definir e de ler variáveis de ambiente nas suas aplicações do Node.

Passando no terminal

Você pode passar variáveis de ambiente diretamente no terminal como parte do processo da sua aplicação do Node. Por exemplo: se você estiver rodando uma aplicação com o framework Express e se quiser passar um conteúdo para a porta 65534, pode fazer da seguinte maneira...

PORT=65534 node bin/www

Curiosidade: a porta 65535 é o maior valor de rede TCP/IP disponível. Como eu sei disso? StackOverflow, é claro (texto em inglês). De que outra maneira as pessoas sabem das coisas? Só podemos, no entanto, chegar à porta 65534 para uma aplicação da web porque essa é a maior porta a qual o Chrome se conecta. Como eu sei isso? O Liran Tal me disse nos comentários. Recomendo segui-lo. Diferente de mim, ele sabe o que está fazendo.

Para o caso de usar a variável no seu código, você poderia usar o objeto process.env.

var port = process.env.PORT;

Aí, a coisa pode ficar feia. Se você tivesse uma string de conexão, provavelmente não gostaria de passar um monte variáveis no terminal. Isso faria parecer que você está acumulando diversos valores de configuração. Uma pessoa que se importa com você poderia organizar uma intervenção; o que seria constrangedor para todos os envolvidos.

PORT=65534
DB_CONN="mongodb://react-cosmos-db:swQOhAsVjfHx3Q9VXh29T9U8xQNVGQ78lEQaL6yMNq3rOSA1WhUXHTOcmDf38Q8rg14NHtQLcUuMA==@react-cosmos-db.documents.azure.com:10255/?ssl=true&replicaSet=globaldb"
SECRET_KEY="b6264fca-8adf-457f-a94f-5a4b0d1ca2b9"

Isso não escala – e todo mundo quer escalar. De acordo com todos os arquitetos que conheci, a aplicação "escalar" é mais importante do que a aplicação funcionar.

Sendo assim, vamos tentar outra abordagem: os arquivos .env.

Usando um arquivo .env

O que os arquivos .env fazem é nos permitir armazenar nossas variáveis em um arquivo à parte. Você só precisa criar um arquivo .env no seu projeto e colocar as variáveis nele em linhas separadas.

PORT=65534

DB_CONN="mongodb://react-cosmos-db:swQOhAsVjfHx3Q9VXh29T9U8xQNVGQ78lEQaL6yMNq3rOSA1WhUXHTOcmDf38Q8rg14NHtQLcUuMA==@react-cosmos-db.documents.azure.com:10255/?ssl=true&replicaSet=globaldb"

SECRET_KEY="b6264fca-8adf-457f-a94f-5a4b0d1ca2b9"

Existem diferentes maneiras de se ler esses valores, mas a opção mais simples é usar o pacote dotenv via npm.

npm install dotenv --save

Feito isso, você só precisa fazer uma requisição desse pacote no seu projeto sempre que precisar usar suas variáveis de ambiente. O pacote dotenv vai pegar o respectivo arquivo e carregar suas configurações no Node.

// Usando o dotenv para ler variáveis de um arquivo .env no Node:
require('dotenv').config();
var MongoClient = require('mongodb').MongoClient;

// Referenciando variáveis .env fora do objeto process.env:
MongoClient.connect(process.env.DB_CONN, function(err, db) {
  if(!err) {
    console.log("Conectado");
  }
});

Dica importante: Não suba seus arquivos .env para o Github. Os valores armazenados ali devem ser mantidos em sigilo. O próprio Github vai enviar a você um e-mail alertando sobre isso. Não faça a mesma besteira que eu.

Certo — bacana. Isso, porém, é meio chato. Você precisa colocar esse código em cada arquivo em que deseja usar variáveis de ambiente E você deve enviar o dotenv para o ambiente de produção, onde não é exatamente necessário. Não sou muito fã de fazer deploy de código inútil, mas acho que isso descreve a minha carreira como um todo.

Felizmente, você está usando o VS Code (você está usando o VS Code, certo?). Então, você tem algumas outras opções.

Trabalhando com arquivos .env no VS Code

Primeiramente, saiba que você pode instalar a extensão DotENV no seu VS Code. Ela vai fornecer um destaque visual na sintaxe dos seus arquivos .env.

DotENV - Visual Studio Marketplace

O depurador do VS Code também oferece algumas opções mais convenientes para carregar valores de arquivos .env. Isso se você estiver usando o depurador do VS Code.

Configurações de execução do VS Code

O depurador do Node para o VS Code (que já está presente nele – não precisa instalar nada para usá-lo) tem suporte para carregamento em arquivos .env por meio de configurações de execução. Leia mais sobre configurações de execução aqui (texto em inglês).

Quando você cria uma configuração de execução básica do Node (clique na engrenagem e selecione "Node"), você pode fazer uma ou as duas seguintes ações:

A primeira é você simplesmente passar as variáveis para a configuração de execução.

É bacana e tal, mas, aqui, todos os valores precisam ser strings. Isso me incomoda um pouco. É um número, não uma string. O JavaScript só tem 3 tipos. Não quero perder um deles.

Existe um caminho mais fácil. Nós já aprendemos a amar os arquivos .env. Então, ao invés de passar os seus valores, podemos simplesmente informar ao VS Code o nome do arquivo .env em questão.

Desse modo, contanto que iniciemos nosso processo a partir do VS Code, os arquivos de variáveis de ambiente serão carregados. Não precisamos "mutilar" os números transformando-os em strings. Também não estamos enviando código inútil para o ambiente de produção. Ou, pelo menos, você não está.

Começando com o NPM ao invés do Node

Você pode ter chegado aqui pensando: "Burke, eu nunca rodei nada com o comando node. É sempre um script do npm como npm start".

Para casos assim, também é possível usar as configurações de execução do VS Code. Ao invés de usar um processo de execução padrão do Node, você adiciona a configuração "Launch Via NPM" (Executar via NPM).

Agora, você pode adicionar novamente seu arquivo .env na linha envFile e ajustar a linha runtimeArgs para rodar o script correto. Isso normalmente é feito com um comando "start" ou "debug".

Lembre-se de adicionar a flag --inspect ao seu script npm para que o VS Code possa vincular o depurador a ele. Do contrário, a tarefa até vai ser executada, mas o depurador do VS Code vai desistir de continuar – assim como eu, tentando arranjar um encontro no ensino médio.

Variáveis de ambiente em produção

Até agora, vimos como definir variáveis para o ambiente de desenvolvimento. Você provavelmente não vai usar arquivos .env em produção. As configurações de execução do VS Code não vão ser muito úteis em um servidor.

Em produção, as variáveis serão definidas de acordo com a sua plataforma escolhida. Se for a Azure, existem 3 maneiras diferentes de definir e gerenciar suas variáveis de ambiente.

A primeira maneira é usar o Azure CLI.

az webapp config appsettings set -g MyResourceGroup -n MyApp --settings PORT=65534

Até funciona, mas... eca.

Outra maneira é usar o Azure Web Portal. Eu nem sempre uso um portal da web, mas, quando uso, é para definir variáveis de ambiente.

Na nomenclatura da Azure, elas são chamadas de "Application Settings" (Configurações da aplicação).

Porém, como você está usando o VS Code, pode instalar a extensão Azure App Service para gerenciar todas as configurações da aplicação diretamente do seu editor.

Adoro não precisar sair do VS Code. Eu escreveria e-mails no VS Code, se pudesse.

UM MOMENTO!

markdown-mail - Visual Studio Marketplace

Agora você já sabe

Agora você já sabe o que eu sei — o que não é muito, diga-se de passagem — e sinto que cumpri meu objetivo de fornecer uma pitada de piadas com Java ao longo do caminho. Porém, caso eu não tenha conseguido, aqui vai uma:

Java é uma ferramenta muito poderosa para transformar XML em traços de erro.

- Autor desconhecido

Observação: a maior parte das piadas é apenas uma tentativa ruim de fazer humor, parte dessa tentativa feita às custas do Java. Sei que não é legal fazer isso, mas, com o Java, é bem fácil. Afinal, as piadas não se escrevem sozinhas.

Nota da tradução: no momento desta tradução, a versão mais recente do Node é a versão 18.17.1. Se você quiser utilizar a versão mais recente do Node, substitua "12.18.1" sempre que aparecer em alguma instrução do texto por "18.17.1".

A versão mais recente do script "nvm-sh" é a 'v0.39.5'. Caso queira utilizar essa versão, substitua 'v0.35.3' pelo 'v0.39.5' no comando utilizado durante a instalação no Mac OS e Linux.

Antes de começar a criar aplicações incríveis com o NodeJS, você precisa instalá-lo. Felizmente, a instalação do NodeJS é muito simples.

Neste tutorial, abordaremos como instalar o NodeJS/NPM no

• macOS/Linux
• Windows

Depois de instalar o NodeJS/NPM, você pode facilmente fazer o upgrade/downgrade para qualquer versão do Node com um comando. O tutorial em vídeo a seguir mostra como fazer o download do NodeJS em sua máquina.

Guia de instalação para Mac OS e Linux

Abra um novo terminal. Digite o seguinte e pressione Enter:

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.35.3/install.sh | bash

Feche seu terminal, abra um novo e digite o seguinte:

nvm ls

Você verá algo parecido com isto:

system
iojs -> N/A (default)
node -> stable (-> N/A) (default)
unstable -> N/A (default)
nvm_list_aliases:36: no matches found: /Users/adeelimran/.nvm/alias/lts/*

Em seguida, em seu terminal, digite:

nvm install 12.18.1

Depois de instalado, ele estará pronta para ser usado. Para usar essa versão, basta digitar isto em seu terminal:

nvm use 12.18.1

Agora que ele está instalado, vamos verificá-lo fazendo o seguinte:

node --v

É isso! Você terminou. Divirta-se.

Agora, se no futuro, por algum motivo, você quiser desinstalar o NVM (do inglês, Node Version Manager), basta abrir o terminal e digitar o seguinte:

rm -rf $NVM_DIR ~/.npm ~/.bower

Guia de instalação para Windows

Primeiro, acesse a área de versões no repositório do nvm-windows https://github.com/coreybutler/nvm-windows/releases.

Em seguida, escolha o arquivo nvm-setup.zip e faça o download.

Depois que o arquivo for baixado, descompacte-o, clique no instalador e siga as etapas (estou usando o 7zip para extração de arquivos .zip, porque ele é GRATUITO).

Em seguida, para verificar se o nvm está instalado corretamente, abra um novo terminal de prompt de comando e digite nvm. Quando for verificado que ele está instalado, você poderá passar para a próxima etapa.

Instale o NodeJS usando o nvm desta maneira:

nvm install <numero_da_versao> // Vamos supor que seja a versão 12.18.1

A versão pode ser uma versão do NodeJS ou "latest" (para a versão mais recente e estável).

Para usar a versão específica do node que você acabou de instalar, basta digitar o seguinte no terminal:

nvm use 12.18.1;

Verifique a versão do node com node -v. Isso deve mostrar a versão 12.18.1 em seu terminal.

Se você quiser instalar outra versão do Node, repita as etapas com uma versão diferente.

Agora, você deve ter uma versão funcional do NodeJS em execução em sua máquina. Boa programação, pessoal. 🙂

Se você achou este guia útil, envie uma mensagem para o autor no Twitter.

Se você é novo no mundo do desenvolvimento para a web, provavelmente passará bastante tempo aprendendo a construir sites estáticos, com HTML, CSS e JavaScript.

Você pode, então, começar a aprender como usar frameworks populares, como React, VueJS ou Angular.

Porém, depois de experimentar algumas ideias novas e executar alguns sites localmente, você pode se perguntar como realmente implantar ou fazer o deploy de seu site ou aplicação. Ocorre que, às vezes, pode ser difícil saber por onde começar.

Pessoalmente, acho que executar um servidor do Express hospedado no Heroku é uma das maneiras mais simples de começar. Este artigo mostrará como fazer isso.

O Heroku é uma plataforma de nuvem que suporta diversas linguagens de programação e frameworks diferentes.

Este não é um artigo patrocinado – é claro que existem muitas outras soluções disponíveis, como:

• Digital Ocean
• Amazon Web Services
• Azure
• Google Cloud Platform
• Netlify
• ZEIT Now

Confira todos eles e veja qual se adapta melhor às suas necessidades.

Pessoalmente, achei o Heroku o mais rápido e fácil de usar. Ele é "pronto para uso". A versão gratuita é um pouco limitada em termos de recursos. No entanto, posso recomendar com confiança para testes.

Nota da tradução: ao final de 2022, o Heroku encerrou o tier gratuito para implantação. Os planos mensais básicos por lá, no momento desta tradução, custam 5 dólares ao mês.

Este exemplo hospedará um site simples usando um servidor do Express. Aqui estão os passos principais:

1. Configurar o Heroku, o Git e o npm
2. Criar um servidor do Express.js
3. Criar arquivos estáticos
4. Implantar no Heroku

Deve levar cerca de 25 minutos no total (ou mais, se você quiser gastar mais tempo nos arquivos estáticos).

Este artigo pressupõe que você já saiba:

• O básico de HTML, CSS e JavaScript
• Uso básico da linha de comando
• Git de nível iniciante para controle de versão

Você pode encontrar todo o código neste repositório.

Configurando

O primeiro passo em qualquer projeto é configurar todas as ferramentas que você sabe que vai precisar.

Você vai precisar ter:

• Node e npm instalados em sua máquina local (leia como fazer isso aqui – em inglês)
• Git instalado (leia este guia – em inglês)
• O CLI do Heroku instalado (aqui está como fazer isso – em inglês)

1. Crie um diretório e inicialize um repositório Git

A partir da linha de comando, crie um diretório de projeto e entre nesse diretório.

$ mkdir lorem-ipsum-demo
$ cd lorem-ipsum-demo

Agora que você está na pasta do projeto, inicialize um novo repositório do Git.

⚠️Esse passo é importante porque o Heroku depende do Git (texo em inglês) para implantar o código da sua máquina local em seus servidores na nuvem. ⚠️

$ git init

Como etapa final, você pode criar um arquivo README.md para editar posteriormente.

$ echo "Edit me later" > README.md

2. Faça login na CLI do Heroku e crie um projeto

Você pode fazer login no Heroku usando a CLI (interface de linha de comando) do Heroku. Você precisará ter uma conta no Heroku para fazer isso.

Existem duas opções aqui. Por padrão, o Heroku permite que você faça login por meio do navegador da web. Adicionar a flag -i permite que você faça login por meio da linha de comando.

$ heroku login -i

Agora, você pode criar um projeto no Heroku. Eu chamei o meu de lorem-ipsum-demo.

$ heroku create lorem-ipsum-demo

Nomeando seu projeto:

• O Heroku gerará um nome aleatório para o seu projeto se você não especificar um no comando.
• O nome fará parte do URL que você pode usar para acessar seu projeto. Assim, escolha um de que você goste.
• Isso também significa que você precisa escolher um nome de projeto único que ninguém mais tenha usado.
• É possível renomear seu projeto posteriormente (não se preocupe muito em encontrar o nome perfeito agora).

3. Inicialize um novo projeto com o npm e instale o Express.js

Em seguida, você pode inicializar um novo projeto com o npm criando um arquivo package.json. Use o comando abaixo para fazer isso.

⚠️Essa etapa é crucial. O Heroku depende de você fornecer um arquivo package.json para saber que este é um projeto do Node.js ao criar sua aplicação.⚠️

$ npm init -y

Em seguida, instale o Express. O Express é um framework de servidor amplamente utilizado para o NodeJS.

$ npm install express --save

Finalmente, você está pronto para começar a programar!

Criando um servidor do Express simples

O próximo passo é criar um arquivo chamado app.js, que executa um servidor do Express localmente.

$ touch app.js

Esse arquivo será o ponto de entrada para a aplicação quando estiver pronta. Isso significa que o único comando necessário para iniciar a aplicação será:

$ node app.js

Primeiro, no entanto, você precisa escrever algum código no arquivo.

4. Edite o conteúdo do app.js

Abra o app.js no seu editor favorito. Escreva o código mostrado abaixo e clique em salvar.

// Crie uma aplicação do express
const express = require("express")
const app = express()

// Use o middleware express-static
app.use(express.static("public"))

// Defina a primeira rota
app.get("/", function (req, res) {
  res.send("<h1>Hello World!</h1>")
})

// Inicie o servidor escutando por solicitações
app.listen(process.env.PORT || 3000, 
	() => console.log("Server is running..."));

Os comentários devem ajudar a indicar o que está acontecendo. Vamos, porém, dividir rapidamente o código para entendê-lo melhor:

• As primeiras duas linhas simplesmente requerem o módulo do Express e criam uma instância da aplicação.
• A próxima linha requer o uso do middleware express.static. Ele permite que você sirva arquivos estáticos (como HTML, CSS e JavaScript) do diretório que você especificar. Nesse caso, os arquivos serão servidos de uma pasta chamada public.
• A próxima linha usa app.get() para definir uma rota de URL. Quaisquer solicitações de URL para o URL raiz serão respondidas com uma mensagem de HTML simples.
• A parte final inicia o servidor. Ele verifica qual porta o Heroku usará ou, se você estiver executando localmente, a porta padrão será 3000.

⚠️O uso de process.env.PORT || 3000 na última linha é importante para implantar sua aplicação com sucesso. ⚠️

Salve app.js e inicie o servidor com:

$ node app.js

Você, então, pode visitar localhost:3000 em seu navegador e verificar se o servidor está em execução.

Crie seus arquivos estáticos

O próximo passo é criar seus arquivos estáticos. Esses são os arquivos HTML, CSS e JavaScript que você fornecerá sempre que um usuário visitar seu projeto.

Lembre-se de que, no app.js, você informou ao middleware express.static para servir arquivos estáticos a partir do diretório public.

O primeiro passo, é claro, é criar esse diretório e os arquivos que ele conterá.

$ mkdir public
$ cd public
$ touch index.html styles.css script.js

5. Edite o arquivo HTML

Abra o arquivo index.html no seu editor de texto preferido. Essa será a estrutura básica da página que você fornecerá aos seus visitantes.

O exemplo abaixo cria uma página inicial simples para um gerador de Lorem Ipsum, mas você pode ser tão criativo quanto quiser aqui.

<!DOCTYPE html>
<head>
	<script src="https://ajax.googleapis.com/ajax/libs/jquery/3.4.1/jquery.min.js"></script>
	<link href="https://fonts.googleapis.com/css?family=Alegreya|Source+Sans+Pro&display=swap" rel="stylesheet">
	<link rel="stylesheet" type="text/css" href="styles.css">
</head>
<html>
<body>
<h1>Lorem Ipsum generator</h1>
  <p>How many paragraphs do you want to generate?</p>
  <input type="number" id="quantity" min="1" max="20" value="1">
  <button id="generate">Generate</button>
  <button id="copy">Copy!</button>
<div id="lorem">
</div>
<script type="text/javascript" src="script.js"></script>
</body>
</html>

6. Edite o arquivo CSS

A próxima etapa é editar o arquivo styles.css. Certifique-se de que ele esteja vinculado ao seu arquivo HTML.

O CSS abaixo é para o exemplo do Lorem Ipsum. Novamente, sinta-se à vontade para ser tão criativo quanto desejar.

h1 {
	font-family: 'Alegreya' ;
}

body {
	font-family: 'Source Sans Pro' ;
	width: 50%;
	margin-left: 25%;
	text-align: justify;
	line-height: 1.7;
	font-size: 18px;
}

input {
	font-size: 18px;
	text-align: center;
}

button {
	font-size: 18px;
	color: #fff;
}

#generate {
	background-color: #09f;
}

#copy {
	background-color: #0c6;
}

7. Edite o arquivo JavaScript

Por fim, você pode querer editar o arquivo JavaScript script.js. Isso permitirá tornar sua página mais interativa.

O código abaixo define duas funções básicas para o gerador de Lorem Ipsum. Sim, eu usei JQuery - é rápido e fácil de trabalhar.

$("#generate").click(function(){
	var lorem = $("#lorem");
	lorem.html("");
	var quantity = $("#quantity")[0].valueAsNumber;
	var data = ["Lorem ipsum", "quia dolor sit", "amet", "consectetur"];
	for(var i = 0; i < quantity; i++){
		lorem.append("<p>"+data[i]+"</p>");
	}
})

$("#copy").click(function() {
	var range = document.createRange();
	range.selectNode($("#lorem")[0]);
	window.getSelection().removeAllRanges();
	window.getSelection().addRange(range);
	document.execCommand("copy");
	window.getSelection().removeAllRanges();
	}
)

Observe que, aqui, a lista de data foi cortada para facilitar a exibição. Na aplicação real, é uma lista muito mais longa de parágrafos completos. Você pode ver o arquivo completo no repositório ou consultar aqui a fonte original.

Implantando sua aplicação

Após escrever seu código estático e verificar se tudo funciona conforme o esperado, você pode se preparar para implantar no Heroku.

No entanto, há mais algumas coisas a fazer.

8. Crie um Procfile

O Heroku precisará de um Procfile para saber como executar sua aplicação.

Um Procfile é um "arquivo de processo" que informa ao Heroku qual comando executar para gerenciar um determinado processo. Neste caso, o comando dirá ao Heroku como iniciar seu servidor na web.

Use o comando abaixo para criar o arquivo.

⚠️Este é um passo importante, pois sem um Procfile, o Heroku não pode colocar seu servidor on-line. ⚠️

$ echo "web: node app.js" > Procfile

Observe que o Procfile não possui uma extensão de arquivo (e.g., ".txt", ".json").

Além disso, observe como o comando node app.js é o mesmo usado localmente para executar o servidor.

9. Adicione e faça commit dos arquivos no Git

Lembre-se de que você iniciou um repositório Git ao configurar. Talvez você já tenha adicionado e feito commit dos arquivos conforme avançava.

Antes de implantar no Heroku, certifique-se de adicionar todos os arquivos relevantes e fazer commit deles.

$ git add .
$ git commit -m "pronto para o deploy"

O último passo é fazer push para a branch master do Heroku.

$ git push heroku master

Você deve ver a linha de comando imprimir uma série de informações enquanto o Heroku cria e implanta sua aplicação.

A linha a ser procurada é: Verifying deploy... done.

Isso mostra que a criação foi bem-sucedida.

Agora você pode abrir o navegador e visitar nome-do-seu-projeto.herokuapp.com. Sua aplicação será hospedada na web para todos visitarem!

Breve resumo

Abaixo estão os passos a serem seguidos para implantar uma aplicação do Express simples no Heroku:

1. Crie um diretório e inicialize um repositório do Git
2. Faça login na CLI do Heroku e crie um projeto
3. Inicialize um novo projeto com o npm e instale o Express.js
4. Edite o conteúdo de app.js
5. Edite os arquivos estáticos HTML, CSS e JavaScript
6. Crie um Procfile
7. Adicione e faça commit no Git, depois faça push para a branch master do Heroku

O que verificar se a aplicação não estiver funcionando

Às vezes, apesar das melhores intenções, os tutoriais na Internet não funcionam exatamente como você esperava.

Os passos abaixo devem ajudar a depurar alguns erros comuns que você pode encontrar:

• Você inicializou um repositório do Git na pasta do seu projeto? Verifique se você executou git init. O Heroku depende do Git para implantar o código da sua máquina local.
• Você criou um arquivo package.json? Verifique se você executou npm init -y. O Heroku requer um arquivo package.json para reconhecer que é um projeto do Node.js.
• O servidor está sendo executado? Verifique se seu Procfile usa o nome de arquivo correto para iniciar o servidor. Verifique se você tem: web: node app.js em vez de web: node index.js.
• O Heroku sabe em qual porta escutar? Verifique se você usou app.listen(process.env.PORT || 3000) em seu arquivo app.js.
• Seus arquivos estáticos têm erros? Verifique-os executando localmente e veja se há algum bug.

Agradeço por ter chegado até aqui. Boa programação para você!

O MongoDB é, sem dúvida, uma das opções de banco de dados NoSQL mais populares atualmente, tendo uma grande comunidade e um grande ecossistema.

Neste artigo, analisaremos algumas das práticas recomendadas a serem seguidas ao configurar o MongoDB e o Mongoose com o Node.js.

Pré-requisitos para este artigo

Este artigo é um dos caminhos de aprendizado de back-end da codedamn (em inglês), onde começamos com os conceitos básicos de back-end e os abordamos em detalhes. Portanto, presumo que você já tenha alguma experiência com JavaScript (e Node.js).

Atualmente, estamos aqui:

Se você tem pouca experiência com Node.js/JavaScript ou back-end em geral, este é, provavelmente, um bom lugar para começar (em inglês). Você também pode encontrar um curso sobre Mongoose, MongoDB e Node.js aqui (em inglês). Vamos lá!

Por que precisaremos do Mongoose?

Para entender por que precisamos do Mongoose, vamos entender como o MongoDB (e um banco de dados) funciona no nível da arquitetura.

• Você tem um servidor de banco de dados (servidor da comunidade do MongoDB, por exemplo)
• Você tem um script do Node.js em execução (como um processo)

O servidor do MongoDB escuta em um soquete TCP (normalmente) e o processo do Node.js pode se conectar a ele usando uma conexão TCP.

Além do TCP, o MongoDB também tem seu próprio protocolo para entender o que exatamente o client (nosso processo do Node.js) quer que o banco de dados faça.

Para essa comunicação, em vez de aprender as mensagens que temos que enviar na camada TCP, abstraímos isso com a ajuda de um software de "driver", chamado de MongoDB driver, neste caso. O MongoDB driver está disponível como um pacote do npm aqui.

Agora, lembre-se, o MongoDB driver é responsável por conectar e abstrair para você as solicitações/respostas de comunicação de baixo nível – é até aí que você consegue ir sendo um desenvolvedor.

Como o MongoDB é um banco de dados sem esquema, ele oferece muito mais poder do que você precisa como iniciante. Mais potência significa mais área de superfície para erros. Você precisa reduzir sua área de superfície para gerar menos bugs e erros em seu código. Você precisa de algo mais.

Conheça o Mongoose. O Mongoose é uma abstração sobre o driver nativo do MongoDB (o pacote npm que mencionei acima).

A regra geral com abstrações (do jeito que eu entendo) é que, a cada abstração, você perde algum poder de operação de baixo nível. Isso, contudo, não significa necessariamente que seja ruim. Às vezes, isso aumenta a produtividade em mais de mil vezes, pois você nunca precisa realmente ter acesso total à API subjacente, de todo modo.

Uma boa maneira de pensar sobre isso é tecnicamente criar uma aplicação de bate-papo em tempo real, tanto em C, quanto em Python.

O exemplo do Python seria muito mais fácil e rápido para você, como desenvolvedor, implementar com maior produtividade.

O C pode ser mais eficiente, mas terá um custo enorme em produtividade/velocidade de desenvolvimento/bugs/travamentos. Além disso, na maioria das vezes, você não precisa ter o poder que o C oferece para implementar websockets.

Do mesmo modo, com o Mongoose, você pode limitar sua área de superfície de acesso à API de nível inferior, mas desbloquear muitos ganhos potenciais e uma boa DX (Developer Experience, ou, em português, experiência de desenvolvedor – em contraste com a experiência do usuário, ou UX).

Como conectar o Mongoose e o MongoDB

Para começar, mostraremos rapidamente como conectar o banco de dados do MongoDB com o Mongoose:

mongoose.connect(DB_CONNECTION_STRING, {
	useNewUrlParser: true,
	useUnifiedTopology: true,
	useCreateIndex: true,
	useFindAndModify: false
})

Esse formato de conexão garante que você esteja usando o novo parser de URL do Mongoose e que não esteja usando práticas já preteridas (do inglês, deprecated). Você pode ler em profundidade sobre todas essas mensagens de preterimento aqui (em inglês), se quiser.

Como realizar operações com o Mongoose

Agora, discutiremos rapidamente as operações com o Mongoose e como devemos realizá-las.

O Mongoose traz opções para dois modos:

1. Query (em português, consulta) baseada no cursor
2. Query de busca completa (em inglês, full fetching query)

Query baseada no cursor

A query baseada no cursor significa que você trabalha com um único registro de cada vez enquanto busca um único ou um lote de documentos de cada vez no banco de dados. Esta é uma maneira eficiente de se trabalhar com grandes quantidades de dados em um ambiente de memória limitada.

Imagine que você tenha que fazer o parsing documentos de 10 GB em um servidor em nuvem de 1 GB/1 núcleo. Você não pode buscar toda a coleção, pois não caberá no seu sistema. O cursor é uma boa (e, talvez, a única) opção aqui.

Query de busca completa

Esse é o tipo de consulta em que você obtém a resposta completa da consulta de uma só vez. Na maioria das vezes, é isso que você vai usar. Portanto, vamos nos concentrar principalmente nesse método aqui.

Como usar os modelos do Mongoose

Os modelos são o superpoder de Mongoose. Eles ajudam você a impor regras de "esquema" e fornecem uma integração perfeita do código do Node em chamadas de banco de dados.

O primeiro passo é definir um bom modelo:

import mongoose from 'mongoose'

const CompletedSchema = new mongoose.Schema(
	{
		type: { type: String, enum: ['course', 'classroom'], required: true },
		parentslug: { type: String, required: true },
		slug: { type: String, required: true },
		userid: { type: String, required: true }
	},
	{ collection: 'completed' }
)

CompletedSchema.index({ slug: 1, userid: 1 }, { unique: true })

const model = mongoose.model('Completed', CompletedSchema)
export default model

Este é um exemplo cortado diretamente da base de código da codedamn. Algumas coisas interessantes que você deve observar aqui:

1. Tente manter required: true em todos os campos que são obrigatórios. Isso pode poupar muitos problemas para você se você não usar um sistema de verificação de tipo estático como o TypeScript para ajudá-lo com nomes de propriedade corretos ao criar um objeto. Além disso, a validação gratuita também é muito legal.
2. Defina índices e campos exclusivos. A propriedade unique (exclusivo) também pode ser adicionada a um esquema. Os índices são um tema amplo, por isso não vou me aprofundar aqui. Em grande escala, porém, eles podem realmente ajudá-lo a acelerar muito suas consultas.
3. Defina um nome de coleção explicitamente. Embora o Mongoose possa dar, automaticamente, um nome à coleção com base no nome do modelo (aqui, por exemplo, Completed), isso é muita abstração na minha opinião. Você deve pelo menos saber sobre seus nomes de banco de dados e coleções em sua base de código.
4. Restrinja os valores, se puder, usando enums.

Como realizar operações do CRUD

CRUD significa Create, Read, Update e Delete (criar, ler, atualizar e excluir, respectivamente, em português). Essas são as quatro opções fundamentais com as quais você pode executar qualquer tipo de manipulação de dados em um banco de dados. Vamos ver rapidamente alguns exemplos dessas operações.

A operação Create

Isso significa simplesmente criar um registro em um banco de dados. Vamos usar o modelo que definimos acima para criar um registro:

try {
    const res = await CompletedSchema.create(registro)
} catch(erro) {
	console.error(erro)
    // tratamento do erro
}

Mais uma vez, algumas coisas a apontar aqui:

1. Use async-await em vez de callbacks (é mais bonito – e não há muito benefício em termos de desempenho em se usar a outra opção)
2. Use blocos try-catch ao redor das queries, pois a query pode falhar por diversas razões (registro duplicado, valor incorreto e assim por diante)

A operação Read

Isso significa ler os valores existentes do banco de dados. É simples como parece, mas há algumas coisas que você deve saber com relação ao Mongoose:

const res = await CompletedSchema.find(info).lean()

1. Você percebeu a função lean()? Ela é muito útil para o desempenho. Por padrão, o Mongoose processa os documentos retornados do banco de dados e adiciona seus métodos mágicos a eles (por exemplo, .save)
2. Ao usar .lean(), o Mongoose retorna objetos em JSON simples em vez de documentos pesados em termos de memória e recursos. Isso torna as queries mais rápidas e faz com que pesem menos na CPU.
3. Porém, é possível omitir o .lean() se estiver, de fato, pensando em atualizar os dados (o que veremos a seguir)

A operação Update

Se você já tem um documento do Mongoose com você (sem utilizar o .lean()), pode simplesmente modificar a propriedade do objeto e salvá-lo usando object.save():

const doc = await CompletedSchema.findOne(info)
doc.slug = 'outra-coisa'
await doc.save()

Lembre-se de que, aqui, duas chamadas ao banco de dados estão sendo feitas. A primeira é no findOne e a segunda é no doc.save.

Se puder, você deve sempre reduzir o número de solicitações que atingem o banco de dados (porque, se você estiver comparando memória, rede e disco, a rede é quase sempre a mais lenta).

No outro caso, você pode usar uma query como esta:

const res = await CompletedSchema.updateOne(<condição>, <consulta>).lean()

Assim, teríamos apenas uma chamada ao banco de dados.

A operação Delete

Delete também é direto com relação ao Mongoose. Vejamos como podemos excluir um único documento:

const res = await CompletedSchema.deleteOne(<condição>)

Assim como updateOne, deleteOne também aceita o primeiro argumento como condição de correspondência para o documento.

Há também outro método chamado deleteMany, que deve ser usado apenas quando você sabe que deseja excluir vários documentos.

Em qualquer outro caso, use sempre deleteOne para evitar várias exclusões acidentais, especialmente quando você estiver tentando executar queries por conta própria.

Conclusão

Este artigo foi uma introdução simples ao mundo do Mongoose e do MongoDB para desenvolvedores do Node.js.

Se gostou dele, você pode tentar aprimorar ainda mais suas habilidades como desenvolvedor seguindo o caminho de aprendizagem de back-end da codedamn (em inglês). Fique à vontade para entrar em contato com o autor pelo Twitter para fornecer seu feedback!

Escrito por: Rajesh Pillai

Entenda o funcionamento do Node programando pequenos pacotes/módulos

Se você é novo no Node.js, há muitos tutoriais aqui no freeCodeCamp e em outros lugares. Você pode conferir meu artigo All about Core Node.JS (em inglês), por exemplo.

Sem mais delongas, vamos ao assunto em discussão: "Emissores de Eventos". Os emissores de eventos desempenham um papel muito importante no ecossistema do Node.js.

O EventEmitter (Emissor de Eventos) é um módulo que facilita a comunicação/interação entre objetos no Node. O EventEmitter está no centro da arquitetura orientada a eventos assíncrona do Node. Muitos dos módulos internos do Node são herdados do EventEmitter, incluindo frameworks proeminentes, como o Express.js.

O conceito é bastante simples: objetos emissores emitem eventos nomeados, que fazem com que ouvintes (em inglês, listeners) previamente registrados sejam chamados. Assim, um objeto emissor possui basicamente duas funcionalidades principais:

• Emitir eventos nomeados.
• Registrar e cancelar o registro de funções do ouvinte.

É meio como um padrão de desenho pub/sub ou observador (embora não exatamente).

O que criaremos neste tutorial

• classe EventEmitter
• método on/addEventListener
• método off/removeEventListener
• método once
• método emit
• método rawListeners
• método listenerCount

Os recursos básicos acima são suficientes para implementar um sistema completo usando o modelo de eventos.

Antes de entrarmos na programação, vamos dar uma olhada em como usaremos a classe EventEmitter. Observe que nosso código imitará a API exata do módulo "events" do Node.js.

Na verdade, se você substituir nosso EventEmitter pelo módulo "events" integrado do Node.js, você obterá o mesmo resultado.

Exemplo 1 - Crie uma instância de emissor de evento e registre algumas funções de retorno

const myEmitter = new EventEmitter();

function c1() {
   console.log('Ocorreu um evento!');
}

function c2() {
   console.log('E mais outro!');
}

myEmitter.on('eventOne', c1); // Registro para eventOne
myEmitter.on('eventOne', c2); // Registro para eventOne

Quando o evento "eventOne" é emitido, ambas as funções de retorno acima devem ser invocadas.

myEmitter.emit('eventOne');

A saída no console será a seguinte:

Ocorreu um evento!
E mais outro!

Exemplo 2 - Registrando para o evento ser disparado apenas uma vez usando "once"

myEmitter.once('eventOnce', () => console.log('eventOnce disparado apenas uma vez')); 

Emitindo o evento "eventOnce":

myEmitter.emit('eventOne');

A seguinte saída deve aparecer no console:

eventOnce disparado apenas uma vez

Emitir eventos registrados com "once" novamente não terá impacto.

myEmitter.emit('eventOne');

Uma vez que o evento foi emitido apenas uma vez, a instrução acima não terá impacto.

Exemplo 3 - Registrando-se para o evento com parâmetros de função de retorno

myEmitter.on('status', (code, msg)=> console.log(`Obtive ${code} e ${msg}`));

Emitindo o evento com parâmetros:

myEmitter.emit('status', 200, 'ok');

A saída no console será a seguinte:

Obtive 200 e ok

OBSERVAÇÃO: Você pode emitir eventos várias vezes (exceto os registrados com o método "once").

Exemplo 4 - Cancelando o registro de eventos

myEmitter.off('eventOne', c1);

Agora, se você emitir o evento da seguinte forma, nada acontecerá e será um "noop":

myEmitter.emit('eventOne');  // noop

Exemplo 5 - Obtendo contagem de ouvintes

console.log(myEmitter.listenerCount('eventOne'));

OBSERVAÇÃO: Se o registro do evento foi cancelado usando o método "off" ou "removeListener", a contagem será 0.

Exemplo 6 - Obtendo ouvintes brutos

console.log(myEmitter.rawListeners('eventOne'));

Exemplo 7 - Exemplo de demonstração assíncrona

// Exemplo 2->Adaptado de um texto de Sameer Buna. Grato!
class WithTime extends EventEmitter {
  execute(asyncFunc, ...args) {
    this.emit('begin');
    console.time('execute');
    this.on('data', (data)=> console.log('got data ', data));
    asyncFunc(...args, (err, data) => {
      if (err) {
        return this.emit('error', err);
      }
      this.emit('data', data);
      console.timeEnd('execute');
      this.emit('end');
    });
  }
}

Usando o emissor de evento "withTime":

const withTime = new WithTime();

withTime.on('begin', () => console.log('Prestes a executar'));
withTime.on('end', () => console.log('Execução encerrada'));

const readFile = (url, cb) => {
  fetch(url)
    .then((resp) => resp.json()) // Transformar os dados em json
    .then(function(data) {
      cb(null, data);
    });
}

withTime.execute(readFile, 'https://jsonplaceholder.typicode.com/posts/1');

Verifique a saída no console. A lista de postagens será exibida junto com outros logs.

O padrão Observador para nosso emissor de evento

Diagrama visual 1 (métodos em nosso EventEmitter)

Como agora entendemos a utilização da API, vamos programar o módulo.

O código de exemplo completo para a classe EventEmitter

Estaremos preenchendo os detalhes de modo incremental nas próximas seções.

class EventEmitter {
  listeners = {};  // par chave-valor
  
  addListener(eventName, fn) {}
  on(eventName, fn) {}
  
  removeListener(eventName, fn) {}
  off(eventName, fn) {}
  
  once(eventName, fn) {}
  
  emit(eventName, ...args) { }
  
  listenerCount(eventName) {}
  
  rawListeners(eventName) {}
}

Começamos criando o modelo para a classe EventEmitter junto com um objeto para armazenar os ouvintes. Os ouvintes serão armazenados como um par chave-valor. O valor pode ser uma lista (já que para o mesmo evento permitimos que vários ouvintes sejam cadastrados).

1. O método addListener()

Vamos agora implementar o método addListener. Ele recebe um nome de evento e uma função de retorno para ser executada.

addListener(event, fn) {
    this.listeners[event] = this.listeners[event] || [];
    this.listeners[event].push(fn);
    return this;
  }

Uma pequena explicação:

O evento addListener verifica se o evento já está registrado. Se estiver, retorna o array. Caso contrário, o array estará vazio.

this.listeners[event] // retornará o array de eventos ou undefined (registro inicial)

Por exemplo…

Vamos entender isso com um exemplo de uso. Vamos criar um eventEmitter e registrar um "test-event". Esta é a primeira vez que o "test-event" está sendo registrado.

const eventEmitter = new EventEmitter();
eventEmitter.addListener('test-event', 
 ()=> { console.log ("test one") } 
);

Dentro do método addListener():

this.listeners[event] =>  this.listeners['test-event'] 
                  => undefined || []
                  => []

O resultado será:

this.listeners['test-event'] = [];  // empty array

Espero que isso torne o método "addListener" muito claro para decifrar e entender.

Uma observação: várias funções de retornos podem ser registradas para o mesmo evento.

2. O método on()

Este é apenas um apelido para o método "addListener". Usaremos o método "on" mais do que o método "addListener" por uma questão de conveniência.

on(event, fn) {
  return this.addListener(event, fn);
}

3. O método removeListener(event, fn)

O método "removeListener" recebe um nome de evento e a função de retorno como parâmetros. Ele remove o ouvinte mencionado do array de eventos.

OBSERVAÇÃO: Se o evento tiver vários ouvintes, os outros ouvintes não serão afetados.

Primeiro, vamos dar uma olhada no código completo para "removeListener".

removeListener (event, fn) {
    let lis = this.listeners[event];
    if (!lis) return this;
    for(let i = lis.length; i > 0; i--) {
      if (lis[i] === fn) {
        lis.splice(i,1);
        break;
      }
    }
    return this;
}

Aqui está o método "removeListener" explicado passo a passo:

• Obtém o array de ouvintes por evento.
• Se nenhum for encontrado, retornar "this" para encadeamento.
• Se encontrado, percorre todos os ouvintes. Se o ouvinte atual corresponde ao parâmetro "fn", usa o método "splice" do array para removê-lo. Depois, sai do laço.
• Retorna "this" para continuar encadeando.

4. O método off(event, fn)

Este é apenas um apelido para o método "removeListener". Estaremos usando o método "off" mais do que o método "removeListener" por uma questão de conveniência.

off(event, fn) {
    return this.removeListener(event, fn);
  }

5. O método once(eventName, fn)

Adiciona uma função de ouvinte única para o evento chamado "eventName". Na próxima vez que o nome do evento for acionado, esse ouvinte será removido e, em seguida, invocado.

Use para eventos do tipo configuração/inicialização.

Vamos dar uma olhada no código.

once(eventName, fn) {
    this.listeners[event] = this.listeners[eventName] || [];
    const onceWrapper = () => {
      fn();
      this.off(eventName, onceWrapper);
    }
    this.listeners[eventName].push(onceWrapper);
    return this;
}

Aqui está o método "once" explicado passo a passo:

• Obtém o objeto de array de eventos. Se for a primeira vez, o array estará vazio.
• Cria uma função de invólucro chamada "onceWrapper", que invocará a função "fn" quando o evento for emitido e também removerá o ouvinte.
• Adiciona a função de invólucro ao array.
• Retorna "this" para encadeamento.

6. O método emit(eventName, ..args)

Chama de modo síncrono cada um dos ouvintes registrados para o evento com o nome "eventName", na ordem em que foram registrados, passando os argumentos fornecidos para cada um.

Retorna verdadeiro (true) se o evento tiver ouvintes ou falso (false), do contrário.

emit(eventName, ...args) {
    let fns = this.listeners[eventName];
    if (!fns) return false;
    fns.forEach((f) => {
      f(...args);
    });
    return true;
}

Aqui está o método "emit" explicado passo a passo:

• Obtém as funções registradas para o parâmetro nome do evento.
• Se não houver ouvintes, retorna false.
• Para todos os ouvintes de função, invoca a função com os argumentos fornecidos.
• Retorna true quando termina.

7. O método listenerCount(eventName)

Retorna o número de ouvintes escutando o evento com o nome "eventName".

Aqui está o código-fonte:

listenerCount(eventName) {
    let fns = this.listeners[eventName] || [];
    return fns.length;
}

Aqui está o método "listenerCount" explicado passo a passo:

1. Obtém as funções/ouvintes consideradas ou um array vazio se não houver nenhum.
2. Retorna o comprimento (desse array).

8. O método rawListeners(eventName)

Retorna uma cópia do array de ouvintes para o evento com o nome "eventName", incluindo quaisquer invólucros (como os criados por .once()). Os invólucros de .once() nesta implementação não estarão disponíveis se o evento tiver sido emitido uma vez.

rawListeners(event) {
    return this.listeners[event];
}

O código-fonte completo, para referência:

class EventEmitter {
  listeners = {}
  
  addListener(eventName, fn) {
    this.listeners[eventName] = this.listeners[eventName] || [];
    this.listeners[eventName].push(fn);
    return this;
  }

  on(eventName, fn) {
    return this.addListener(eventName, fn);
  }

  once(eventName, fn) {
    this.listeners[eventName] = this.listeners[eventName] || [];
    const onceWrapper = () => {
      fn();
      this.off(eventName, onceWrapper);
    }
    this.listeners[eventName].push(onceWrapper);
    return this;
  }

  off(eventName, fn) {
    return this.removeListener(eventName, fn);
  }

  removeListener (eventName, fn) {
    let lis = this.listeners[eventName];
    if (!lis) return this;
    for(let i = lis.length; i > 0; i--) {
      if (lis[i] === fn) {
        lis.splice(i,1);
        break;
      }
    }
    return this;
  }

  emit(eventName, ...args) {
    let fns = this.listeners[eventName];
    if (!fns) return false;
    fns.forEach((f) => {
      f(...args);
    });
    return true;
  }

  listenerCount(eventName) {
    let fns = this.listeners[eventName] || [];
    return fns.length;
  }

  rawListeners(eventName) {
    return this.listeners[eventName];
  }
}

O código completo está disponível aqui.

Como exercício, sinta-se à vontade para implementar outras APIs de eventos da documentação (em inglês).

Se você gostou deste artigo e deseja ver mais artigos semelhantes, sinta-se à vontade para compartilhá-lo. :)

OBSERVAÇÃO: O código foi otimizado para legibilidade e não para desempenho. Talvez, como exercício, você possa otimizar o código e compartilhá-lo. Não testei completamente para casos extremos e algumas validações podem estar imprecisas, pois foi um rascunho rápido.

Este artigo faz parte de um curso em vídeo que criariei, chamado "Node.JS Master Class — Build Your Own ExpressJS-Like MVC Framework from scratch".

O título do curso, porém, ainda não é definitivo.

Às vezes, fico me perguntando se eu sei muito sobre poucas coisas.

Há algumas semanas, eu conversava com um amigo que mencionou despretensiosamente que "você nunca deveria rodar uma aplicação do Node diretamente em produção".

Eu balancei minha cabeça vigorosamente em sinal de afirmação para demonstrar que eu também nunca rodaria Node em produção porque... hahaha... todo mundo sabe disso. Só que eu não sabia disso!  Eu deveria saber disso? EU AINDA TENHO PERMISSÃO PARA PROGRAMAR?

Se eu fosse desenhar um Diagrama de Venn do que eu sei em comparação com o que eu acho que os outros sabem, seria algo assim...

A propósito, aquele pontinho bem pequeno ali fica cada vez menor conforme eu fico velho.

Existe um diagrama melhor criado por Alicia Liu que, de certo modo, mudou minha vida. Ela diz que, na verdade, seria mais parecido com isso...

Eu amo esse diagrama porque eu quero muito que ele seja verdade. Eu não quero passar o resto da minha vida como um pontinho azul pequeno – e cada vez menor – e insignificante.

MUITO DRAMÁTICO. Ao menos, não estamos partindo da estakazero. Eu não estou controlando qual a próxima música que vai tocar enquanto estou escrevendo, mas escrever artigos com confidências é viciante como uma droga

Bem, assumindo que o diagrama de Alicia seja verdade, eu gostaria de compartilhar com você o que eu sei agora sobre rodar aplicações do Node em produção. Talvez nossos Diagramas de Venn relativos não se sobreponham nesse tema.

Primeiro, vamos analisar a declaração "nunca rodar aplicações do Node diretamente em produção".

Nunca rodar o Node diretamente em produção

Talvez, sim; talvez, não. Vamos falar sobre o raciocínio por trás dessa declaração. Primeiro, vamos dar uma olhada nos motivos contra fazermos isso.

Suponha que temos um simples servidor do Express. O servidor do Express mais simples que eu posso pensar...

const express = require("express");
const app = express();
const port = process.env.PORT || 3000;

// Visível em http://localhost:3000
app.get("/", function(req, res) {
  res.send("Again I Go Unnoticed"); //"De novo, ninguém me nota", em português 
});

app.listen(port, () => console.log(`Example app listening on port ${port}!`)); //"App de exemplo escutando na porta... ", em português 

Rodaríamos isso usando o script start no arquivo package.json.

"scripts": {
  "dev": "npx supervisor index.js",
  "start": "node index.js"
}

Existem dois problemas aqui. O primeiro é um problema de desenvolvimento. O segundo é um problema de produção.

O problema de desenvolvimento: ao mudarmos o código, teremos que parar e começar a aplicação para termos nossas mudanças captadas.

Para solucionar isso, normalmente usamos algo como um gerenciador de processos do Node, como o supervisor ou o nodemon. Esses pacotes observarão nosso projeto e reiniciarão nosso servidor sempre que fizermos mudanças. Eu normalmente faço algo assim:

"scripts": {  "dev": "npx supervisor index.js",  "start": "node index.js"}

Então, eu rodo npm run dev. Note que eu estou rodando npx supervisor aqui, o que me permite usar o pacote supervisor sem ter de instalá-lo. Eu amo a modernidade (na maior parte do tempo).

Nosso outro problema é que ainda estamos rodando diretamente o Node e já dissemos que era algo ruim. Agora, estamos prestes a descobrir o porquê.

Adiciono outro roteador aqui, que tenta ler um arquivo do disco que não existe. Esse é um erro que poderia facilmente aparecer em qualquer aplicação do mundo real.

const express = require("express");
const app = express();
const fs = require("fs");
const port = process.env.PORT || 3000;

// viewed at http://localhost:3000
app.get("/", function(req, res) {
  res.send("Again I Go Unnoticed");
});

app.get("/read", function(req, res) {
  // Isso aqui não existe 
  fs.createReadStream("minha-autoestima.txt");
});

app.listen(port, () => console.log(`Example app listening on port ${port}!`));

Se rodarmos diretamente o Node com o npm start e navegarmos até o endpoint read, vamos obter um erro, pois o arquivo não existe.

Não é um grande problema, certo? É um erro. Acontece.

É um grande problema, sim. Se você voltar ao seu terminal, verá que sua aplicação quebrou completamente.

Isso significa que, se você voltar ao navegador e se tentar acessar o URL raiz do site, terá a mesma mensagem de erro. Um erro em apenas um método quebrou sua aplicação para todos os usuários.

Isso é péssimo – muito ruim, mesmo. Essa é uma das razões principais porque as pessoas dizem "nunca rode o Node diretamente em produção".

OK. Então, se nós não podemos rodar o Node diretamente em produção, qual seria a maneira certa de fazê-lo?

Opções para o Node em produção

Temos algumas opções.

Uma delas seria simplesmente usar algo como o supervisor ou o nodemon em produção da mesma maneira que o usamos em ambiente de desenvolvimento. Isso poderia funcionar, mas essas ferramentas são muito pouco para um controle adequado. Uma opção melhor é chamada de pm2.

Resolva com o pm2

O pm2 é um gerenciador de processos do Node que tem muitos alertas. Assim como todo o resto em "JavaScript", você o instala (globalmente) através do npm — ou pode simplesmente usar o npx outra vez. Faça como você quiser.

Existem muitas maneiras de rodar sua aplicação com o pm2. A maneira mais simples possível seria apenas chamar pm2 start no seu ponto de entrada.

"scripts": {
  "start": "pm2 start index.js",
  "dev": "npx supervisor index.js"
},

Você verá algo mais ou menos assim no seu terminal…,

Esse é o nosso processo rodando, monitorado pelo pm2 em segundo plano. Se você visitar o endpoint read e se a aplicação quebrar, o pm2 vai reinicializá-la automaticamente. Você não verá nada disso no terminal, pois está rodando em segundo plano. Se você quiser observar o pm2 fazendo o trabalho, precisará rodar pm2 log 0, sendo 0 o id do processo cujos relatórios desejamos ver.

Pronto, tudo certo! Você pode ver a reinicialização da aplicação quando ela cair devido ao nosso erro não tratado.

Podemos também colocar nosso comando dev e fazer com que o pm2 observe os arquivos para nós e os reinicialize em quaisquer mudanças.

"scripts": {
  "start": "pm2 start index.js --watch",
  "dev": "npx supervisor index.js"
},

Note que, em função de o pm2 rodar tudo em segundo plano, você não pode simplesmente apertar ctrl+c para terminar o processo do pm2. Você tem que pará-lo usando o ID ou o nome.

pm2 stop 0

pm2 stop index

Observe, também, que o pm2 retém uma referência para o processo para que você possa recomeçá-lo.

Se você quiser excluir a referência do processo, precisa executar pm2 delete. Você pode parar e excluir um processo em um comando com delete.

pm2 delete index

Também podemos usar o pm2 para rodar múltiplos processos da nossa aplicação. O pm2 automaticamente balanceará o carregamento através dessas instâncias.

Múltiplos processos com pm2 no modo fork

O pm2 tem diversas opções de configuração e elas estão contidas em um arquivo de "ecossistema". Para criar um, execute pm2 init. Você vai obter um resultado parecido com esse...

module.exports = {
  apps: [
    {
      name: "Express App",
      script: "index.js",
      instances: 4,
      autorestart: true,
      watch: true,
      max_memory_restart: "1G",
      env: {
        NODE_ENV: "development"
      },
      env_production: {
        NODE_ENV: "production"
      }
    }
  ]
};

Eu vou ignorar a seção "deploy" nesse artigo, pois não tenho a menor ideia do que ela faz.

A seção "apps" é onde você define as aplicações que você deseja que o pm2 rode e monitore. Você pode rodar mais de uma. Muitas dessas configurações do arquivo são, provavelmente, autoexplicativas. Eu quero me concentrar naquela configuração chamada instances (em português, instâncias).

O pm2 pode rodar múltiplas instâncias da sua aplicação. Você pode informar um número de instances que você deseja rodar e o pm2 fará o trabalho. Então, se queremos rodar 4 instances, podemos rodar o seguinte arquivo de configuração:

module.exports = {
  apps: [
    {
      name: "Express App",
      script: "index.js",
      instances: 4,
      autorestart: true,
      watch: true,
      max_memory_restart: "1G",
      env: {
        NODE_ENV: "development"
      },
      env_production: {
        NODE_ENV: "production"
      }
    }
  ]
};

Então, tudo que precisamos é digitar pm2 start.

O pm2 está agora rodando em um modo cluster (em português, "agrupamento"). Cada um desses processos está rodando em uma CPU diferente na minha máquina, dependendo de quantos núcleos de processamento (em inglês, cores) eu tiver. Se rodarmos um processo para cada core, sem saber quantos cores temos, precisamos apenas passar o parâmetro max para o valor instances.

{
   ...
   instances: "max",
   ...
}

Vamos descobrir quantos cores eu tenho nessa máquina.

8 CORES! Nossa!!! Eu vou instalar Subnautica na minha máquina da Microsoft. Não diga a eles que eu disse isso.

A parte coisa sobre rodar processos em CPUs separadas é que, se você tiver um processo que perca o controle e tome 100% da CPU, os outros ainda funcionarão. Se você passar mais instâncias do que cores, o pm2 dobrará o número de processos em uma CPUs conforme for necessário.

Você pode fazer MUITO mais com o pm2, incluindo monitoramento e o tratamento daquelas variáveis de ambiente irritantes.

Um outro item a se observar: se, por alguma razão, você quiser executar seu script npm start, você pode fazer isso através do npm como processo e passar a bandeira -- start. O espaço antes de start (em português, "início") é super importante aqui.

pm2 start npm -- start

No Azure AppService, incluímos o pm2 por padrão em segundo plano. Se você quiser usar o pm2 no Azure, não precisa incluí-lo em seu arquivo package.json. Você somente precisa adicionar um arquivo de ecossistema e está pronto para continuar.

Certo! Agora que aprendemos tudo sobre o pm2, vamos falar um pouco mais sobre o porquê você pode querer não usá-lo. Também veremos que pode, de fato, não haver problema em rodar o Node diretamente.

Rodando o Node diretamente em produção

Eu tinha algumas dúvidas sobre isso. Então, falei com Tierney Cyren, que é uma parte enorme do círculo laranja de conhecimento, especialmente quando o assunto é o Node.

Tierney me apontou algumas desvantagens de se usar o Node baseado em gerenciadores de processos, como o pm2.

A principal delas é que você não deveria usar Node para monitorar a si mesmo. Você não quer usar a coisa que você está monitorando para monitorar a si mesma. Seria como pedir ao meu filho adolescente para tomar conta de si mesmo em uma sexta-feira à noite: isso acabaria mal? Pode ser que sim, pode ser que não, mas você não quer descobrir da pior maneira.

Tierney recomenda que você não tenha um gerenciador de processos do Node rodando em sua aplicação nunca. Ao invés disso, tenha algo em um nível mais alto que observe em conjunto as instâncias separadas de sua aplicação. Por exemplo, uma configuração ideal seria se você tivesse um agrupamento de Kubernetes com sua aplicação rodando em contêineres separados. O Kubernetes podem, então, monitorar aqueles contêineres e, se algum deles cair, pode trazê-lo de volta e registrar sua condição de integridade.

Nesse caso, você pode rodar o Node diretamente porque você o está monitorando um nível acima.

Acontece que o Azure já está fazendo isso. Se não subirmos um arquivo de ecossistema do pm2 para o Azure, a aplicação iniciará com nosso script start do nosso arquivo package.json e podemos, então, rodar diretamente o Node.

"scripts": {
  "start": "node index.js"
}

Nesse caso, estamos rodando diretamente o Node e não há problema. Se a aplicação quebrar, você notará que ela reinicializará. Isso acontece porque, no Azure, sua aplicação roda em um contêiner. O Azure está orquestrando o contêiner que sua aplicação está rodando e saberá quando ela tiver problemas.

Porém, você ainda tem apenas uma instância aqui. É necessário, ao contêiner, algum tempo para voltar a ficar on-line depois de quebrar, o que significa que, nesse tempo, sua aplicação estaria fora do ar para seus usuários.

Idealmente, você vai querer ter mais de um contêiner rodando. A solução para isso seria subir múltiplas instances de sua aplicação para múltiplos sites do Azure AppService e, então, usar o Azure Front Door para balancear a carga das aplicações por detrás de um único endereço de IP. O Front Door saberá quando um contêiner cair e roteará o tráfego para outras instâncias funcionais de sua aplicação.

Saiba mais sobre o serviço Azure Front Door aqui.

systemd

Outra sugestão que o Tierney nos dá é rodar o Node com systemd. Eu não entendo muito (na verdade, não entendo nada) sobre systemd e já estraguei tudo parafraseando ele uma vez. Então, vamos deixar Tierney isso dizer com suas próprias palavras…

Essa opção só é possível se você tiver acesso ao Linux na sua implementação (em inglês, deployment), e se você controlar o modo como o Node é inicializado em nível de serviço. Se você estiver rodando seu processo do Node.js em uma máquina virtual (em inglês, VM), Linux de longa duração, como as VMs do Azure, poderá rodar o Node.js com systemd sem problemas. Se você só estiver fazendo o deploy de seus arquivos para um serviço como o Azure AppService ou o Heroku ou rodando o Node dentro de um ambiente conteinerizado, como o Azure Container Instances, você provavelmente deverá evitar essa opção.

Rodando seu App Node.js com Systemd - Parte 1 (texto em inglês sobre o assunto)

Worker Threads do Node.js

Tierney também gostaria de informar que as Worker Threads estão chegando ao Node. Isso permitirá a você começar sua aplicação em múltiplos "trabalhadores" (em inglês, workers), evitando, desse modo, a necessidade de algo como o pm2. Talvez. Eu não sei. De fato, não li esse artigo.

Documentação d0 Node.js sobre Worker Threads

Seja um adulto

A última sugestão de Tierney era apenas para lidar com o erro e escrever alguns testes (como um adulto faria), mas quem tem tempo para isso, não é mesmo?

O pequeno círculo permanece

Agora você sabe a maior parte do que está no pequeno círculo azul. O restante tem a ver apenas com fatos inúteis sobre bandas e cerveja.

Para mais informações sobre o pm2, Node e Azure, confira os recursos a seguir:

• Site do PM2
• Implantação do Node.js com o VS Code

Neste tutorial, vamos aprender tudo que é preciso para fazer o deploy de uma aplicação em Node para um servidor de produção.

Para começar, vamos alugar um servidor na Digital Ocean. Depois disso, vamos configurar o servidor, fazer a conexão, instalar o Nginx e configurá-lo, extrair ou criar nossa aplicação do Node.js e executá-la como um processo.

Como você pode ver, há muito para ser feito e teremos várias opções. Então, vamos começar.

Você deve ter algum conhecimento básico de como o Terminal funciona e já ter trabalhado com Vi/Vim antes de iniciar o tutorial. Se você não estiver familiarizado com os comandos básicos, eu recomendo ler sobre eles.

Eu vou executar os comandos em um MacOS. Se você quiser seguir esse tutorial em um Windows,  pode usar o Powershell ou algum tipo de emulador para Unix.

Embora eu esteja usando o Node.js como uma plataforma para o nosso exemplo de aplicação, muitas etapas são iguais para qualquer tipo de aplicação para a web.

Por que a Digital Ocean?

Eu escolhi a Digital Ocean pois é barata e a interface é muito fácil de usar, comparada a outras, como a da AWS. Além disso, junto com o pacote para estudantes do GitHub, você recebe US$ 100 de crédito. Desse modo, você não terá que pagar por nada durante alguns meses. É o ideal para um projeto ou um curso.

Ela posssui um conceito chamado Droplets, que é basicamente a sua parte do servidor. Você pode pensar no servidor como um apartamento em que você pode alugar um quarto.

Droplets funcionam com a ajuda de máquinas virtuais que rodam dentro do servidor. Portanto um Droplet é a sua máquina virtual dentro do servidor dividido. Por ser uma máquina virtual, sua CPU e memória são compartilhados e podem ser facilmente aumentados. Isso pode ser feito através de um investimento em dinheiro junto ao provedor.

Como criar um projeto na Digital Ocean

Assumindo que você já se inscreveu e está logado na Digital Ocean, o primeiro passo é criar o projeto que conterá nosso Droplets.  Clique no botão "New Project" no menu do lado esquerdo. Ele vai pedir que você dê um nome para o seu projeto.

Coloque o nome que você quiser. Ele também vai perguntar se você quer mover algum recurso, mas por enquanto apenas clique em Skip (Ignorar). Mais tarde, nós vamos criar o droplet.

Como criar um droplet no Digital Ocean

Vamos criar nosso droplet clicando no botão "Get Started" (Iniciar).

Após clicar no botão, ele vai pedir para escolhermos uma imagem para a máquina virtual.

Nesta parte, eu selecionei Ubuntu 20.04 pois é a versão mais atual e "LTS" no momento em que estava escrevendo. LTS significa "Long Term Support" (suporte de longo prazo), sendo a versão segura mais atual. É melhor usar a versão LTS para os projetos, porque isso garante que o provedor dará suporte e poderá ser mantida por muito tempo. Assim, você não terá problemas a longo prazo.

Eu escolhi o Ubuntu e recomendo a sua utilização, já que é o sistema Linux mais comum. Isso significa que também é o mais fácil para encontrar soluções para suas perguntas no futuro.

Você pode optar por ter uma CPU dedicada, se precisar. Se estiver criando uma startup ou qualquer tipo de negócio, eu recomento da leitura deste artigo (texto em inglês), que contém detalhes sobre como escolher a melhor opção para você.

Nesse caso, eu selecionei a opção mais barata.

Em seguida, você deve selecionar a região do datacenter. Você deve escolher a mais perto de você para diminuir o delay da rede.

Em seguida, selecione "SSH Keys" como forma de autenticação, pois é a opção mais segura.

Para se conectar ao servidor, será preciso gerar uma nova chave SSH no seu próprio dispositivo e adicioná-la a Digital Ocean.

Como gerar uma chave SSH

Eu vou gerar a chave através do meu macOS. Se você estiver usando o Windows, você pode verificar este artigo (texto em inglês). Abra o terminal e crie uma pasta SSH:

cd ~/.ssh

Para criar sua chave SSH:

ssh-keygen

Se o seu computador disser que não reconhece esse comando, você deve instalá-lo através do brew.

Ele vai pedir que você nomeie o arquivo e acrescente uma senha. Não digite o seu nome. Apenas aperter Enter e continue com as definições padrão. Os arquivos devem ser gerados. Eu nomeei o meu como digital-ocean-ssh. Não se confunda com isso.

❯ lsid_dsa      id_rsa      known_hosts

Nossa chave pública é id_dsa e id_rsa é a nossa chave privada. Se você esquecer qual é a privada, você sempre pode fazer um print delas.

Como adicionar sua chave SSH na Digital Ocean

Agora, vamos copiar nossa chave pública e fazer o upload dela na Digital Ocean. Assim, eles saberão qual é a chave usada para nossa autenticação.

Copie toda a chave, incluindo a parte ssh-rsa.

Clique em "New SSH Key":

Cole a chave na caixa de texto que aparece depois que você clica no botão. Desse modo, você verá sua chave SSH.

Como conectar ao servidor

Vamos usar o terminal para conectar ao nosso servidor através do SSH. Você também pode dar uma olhada no Termius para uma interface mais agradável, se você quiser.

Execute este comando no seu terminal após substituir IP_ADDRESS pelo IP do seu servidor (você pode procurar no painel da Digital Ocean).

ssh root@IP_ADDRESS

Se tudo der certo, agora, você deve estar no terminal do servidor. Estamos conectados ao servidor. Se você tiver qualquer tipo de erro, pode fazer o debug executando o comando com "-v" ou "-vv".

Como configurar o seu servidor

Precisamos fazer uma configuração inicial do servidor antes de fazer o deploy da aplicação no Node.

Atualize o software

Precisamos fazer a atualização do software do servidor para ter certeza de que está com a versão mais recente.

Muitos servidores são vulneráveis a ataques, pois estão usando versões antigas do software, com vulnerabilidades já conhecidas. Os invasores buscam por vulnerabilidades no software e tentam explorar isso para ter acesso ao seu servidor.

Você pode atualizar o seu Ubuntu usando o comando "apt update".

apt updateHit:1 https://repos.insights.digitalocean.com/apt/do-agent main InReleaseGet:2 http://mirrors.digitalocean.com/ubuntu focal InRelease [265 kB]      Hit:3 http://mirrors.digitalocean.com/ubuntu focal-updates InRelease                Get:4 http://security.ubuntu.com/ubuntu focal-security InRelease [109 kB]Hit:5 http://mirrors.digitalocean.com/ubuntu focal-backports InReleaseFetched 374 kB in 1s (662 kB/s)                          Reading package lists... DoneBuilding dependency tree       Reading state information... Done96 packages can be upgraded. Run 'apt list --upgradable' to see them.

Se a mensagem estiver dizendo "96 packages can be upgraded", significa que ainda não houve a instalação dos pacotes, apesar de eles terem sido encontrados para atualizar.

Para efetivar a atualização com a instalação dos pacotes encontrados, execute o comando:

apt upgrade

Digite "y" quando solicitado e isso fará a atualização do software.

Criando um usuário

Estamos conectados ao servidor como um usuário root (usuário com mais privilégios). Ser o usuário root pode ser perigoso e pode nos expor a mais vulnerabilidades.

Portanto, devemos criar um usuário para não executar os comandos como root. Substitua $username abaixo com o nome de usuário da sua preferência.

whoamiroot

adduser $username

Você vai criar uma senha para o usuário. Depois disso, ele fará várias perguntas. Para pular isso, digite "y" até que ele termine.

O novo usuário foi criado, mas ainda precisamos adicionar o novo usuário ao grupo "sudo" para que ele possa executar qualquer tipo de ação necessária.

usermod -aG sudo $USERNAME

Adicionamos o usuário ao grupo com o comando -aG (grupo a ser adicionado). Também devemos adicioná-lo ao grupo sudo.

Ainda estamos no usuário root. Então, vamos mudar para nosso novo usuário. Para isso, podemos usar o comando su (usuário a ser usado).

su $USERNAME

Após, se você executar o comando whoami, você deve ver o seu nome de usuário. Você pode verificar a existência do grupo sudo, através do seguinte comando:

sudo cat /var/log/auth.log

Apenas superusuários podem ver esse arquivo. A máquina pedirá a sua senha após executar o comando.

Copie a chave SSH

Após criar o usuário, ainda devemos habilitar seu login através do SSH.

Portanto, devemos copiar a chave pública (criada anteriomente) e colá-la na pasta SSH desse usuário para que o SSH possa saber qual chave ele deve aceitar para autenticar esse usuário.

mkdir -p ~/.ssh

O comando -p cria um diretório, caso ele não exista.

vi ~/.ssh/authorized_keys

Temos que usar o vi ou vim para criar o arquivo chamado authorized_keys.

Copie a chave pública (arquivo id_dsa) e pressione "i" para ir para o modo de edição. Cole a chave no arquivo com CMD + V.

Pressione Esc para sair do modo de edição, digite :wq para salvar e sair.

Se tiver algum problema usando Vim/Vi,  você pode dar uma olhada em algum dos vários tutoriais (texto em inglês) que explicam como eles funcionam.

Conecte ao servidor com o novo usuário

Agora, devemos ser capazes de conectar ao servidor sem nenhum problema. Você pode usar o seguinte comando para conectar (mas lembre-se de alterar o IP_ADDRESS para o seu nome de usuário).

ssh $USERNAME@IP_ADDRESS

Se você tiver algum problema, pode excluir o droplet e iniciar novamente. Isso não deve tomar muito tempo, já que fazer o debug do servidor pode ser muito difícil.

Como desabilitar o login do root

Uma boa prática de segurança é desabilitar o login através do usuário root.

Para não termos problemas de permissão no futuro, é indicado alterar a permissão do arquivo.

chmod 644 ~/.ssh/authorized_keys

Agora abra o arquivo sshd_config:

sudo vi /etc/ssh/sshd_config

Encontre a linha abaixo e modifique no para yes. Isso deve ser feito através do Vim/Vi.

PermitRootLogin no

Salve e saia do Vim/Vi.

Como instalar o Node.js e o Git

Agora, podemos seguir com a instalação do Node.js e do Git:

sudo apt install nodejs npm

sudo apt install git

Estamos prontos para criar nossa aplicação em Node e executá-la. Você pode extrair o seu projeto do Node do GitHub ou criar um projeto em Node aqui apenas para testar se funciona.

Vá para o diretório de sua escolha e crie o arquivo "app.js":

sudo vi app.js

Você pode colar o seguinte texto em seu arquivo app.js:

const express = require('express');const app = express();const port = 3000;app.get('/', (req, res) => {        res.send('Hello World');});app.listen(port, () => console.log(`Example app listening on port ${port}!`));

Agora, execute isso com o comando:

node app.js

Você deve ser a seguinte mensagem no seu terminal: "Example app listening on port 3000!"

Podemos confirmar se está funcionando através de uma requisição:

GET http://IP_ADDRESS:3000/

Envie essa requisição de um client HTTP com o Postman ou de seu navegador. Você deve receber a seguinte mensagem: "Hello World".

Neste ponto, você deve ter percebido que alguma coisa está errada. Usuários comuns não sabem enviar uma requisição através da porta 3000.

Devemos redirecionar as requisições enviadas pelo nosso IP que chegam ao servidor para a Porta 3000. Podemos fazer isso com a ajuda do Nginx.

Como instalar e configurar o Nginx

Vamos usar o Nginx para fazer um proxy reverso para redirecionar as requisições para a nossa aplicação do Node.

Vamos instalar o Nginx:

sudo apt install nginx

Iniciando o serviço Nginx:

sudo service nginx start

Podemos testar enviando uma requisição ao nosso servidor através do navegador. Digite o endereço de IP do servidor em seu navegador e você deverá receber a seguinte mensagem:

É importante saber que o servidor do Nginx é executado do endereço "/var/www/html" por padrão e que você pode encontrar esse arquivo HTML nesse diretório.

Eu também aconselho a você criar uma pasta dentro de "/var/www", chamar a aplicação e mover a sua aplicação em Node para essa pasta, facilitando sua localização.

Como configurar o proxy reverso do Nginx

Vamos editar a configuração do arquivo Nginx para configurar o proxy reverso:

sudo vi /etc/nginx/sites-available/default

Nesse arquivo, você deve encontrar o local/bloco e editá-lo da seguinte maneira:

location / {                # First attempt to serve request as file, then                # as directory, then fall back to displaying a 404.                proxy_pass http://127.0.0.1:3000/;        }

O proxy_pass faz o proxy da solicitação para uma porta específica. Vamos dar à porta o endereço em que nossa aplicação de Node está executando.

Agora, vamos reiniciar o Nginx para que as alterações tenham efeito:

sudo service nginx reload

Após essa etapa, devemos ser capazes de ver a mensagem quando enviamos a requisição ao servidor.

Parabéns, nós completamos o mínimo de passos para fazer o deploy de uma aplicação em Node. Eu aconselho, no entanto, a concluir a parte de bônus, pois acredito que seja muito importante. Se você não conseguir ver a mensagem Hello World!, pode verificar se a sua aplicação e se o Nginx estão sendo executados e reiniciá-los.

Como executar sua aplicação como um processo

Não queremos ter que iniciar nossa aplicação manualmente todas as vezes que algo der errado e ele travar. Nós queremos que ela reinicie sozinha. Além disso, sempre que o servidor iniciar, a aplicação também deve iniciar.

Para fazer isso, podemos usar o PM2. Vamos instalá-lo e configurá-lo.

sudo npm i -g pm2

Estamos instalando o pm2 de modo global, usando a opção "-g". Isso faz com que ele seja acessível a todas as pastas.

pm2 start app.js

Isso garante que a aplicação será reiniciada se ocorrer algum erro.

Salve a lista de processos.

pm2 save

Também precisamos convertê-lo em um daemon que execute sempre que o sistemar iniciar:

pm2 startup systemd

Para lembrar, neste tutorial, estou usando os comandos para Ubuntu. Se você estiver usando outra distribuição do Linux, você deve substituir o comando systemd.

Podemos confirmar que está reiniciando o servidor corretamente enviando uma solicitação sem executar app.js manualmente:

sudo reboot

Depois de enviar a requisição, como fizemos anteriormente, você deve ver a mensagem "Hello World!".

Conclusão

Neste tutorial, começamos do zero, alugamos um servidor, conectamos a ele e o configuramos para a nossa aplicação do Node.js na porta 80.

Se você acompanhou e conseguiu concluir todas as etapas, parabéns! Você pode se orgulhar, pois não foi um tutorial fácil. Espero que você tenha aprendido muito. Agradeço pelo seu tempo.

Estou planejando explorar mais este tópico conectando o servidor ao domínio e, em seguida, conectando-o ao CircleCI para integração contínua. Também vou mostrar quais são as etapas necessárias para preparar sua aplicação em Node.js/React para produção. Este artigo já ficou longo. Então, esses tópicos estão reservados para outro artigo. 🙂

Se você gostou da leitura e quer se manter informado sobre futuros artigos do autor, pode se inscrever no blog pessoal dele. Se estiver interessado, lá você verá as publicações mais antigas do autor, que costuma escrever sobre desenvolvimento para a web.

Uma das coisas mais poderosas a respeito do desenvolvimento de software é a capacidade de reutilizar e criar com base naquilo que outras pessoas deixaram. È esse compartilhamento de código que acabou permitindo que o software avançasse imensamente.

Um mecanismo tão fantástico é fundamental em um nível mais profundo em termos de projetos individuais e de equipes.

Para o Node.js, esse processo de compartilhamento de código – tanto em projetos individuais quanto em dependências externas do npm – é facilitado pelo uso de module.exports ou exports.

Como funcionam os módulos do Node

Como usamos as exportações de módulos para adicionar um módulo externo ou dividir nosso projeto de modo razoável em diversos arquivos (módulos)?

O sistema de módulos do Node.js foi criado porque os criadores não queriam passar pelo mesmo problema do escopo global quebrado, como ocorria com o equivalente no navegador. Eles implementaram a especificação do CommonJS para conseguir isso.

As duas partes importantes do quebra-cabeças são o module.exports e a função require.

Como o module.exports funciona

module.exports é, de fato, uma propriedade do objeto module. É esta a aparência do objeto module quando usamos console.log(module):

Module {
  id: '.',
  path: '/Users/stanleynguyen/Documents/Projects/blog.stanleynguyen.me',
  exports: {},
  parent: null,
  filename: '/Users/stanleynguyen/Documents/Projects/blog.stanleynguyen.me/index.js',
  loaded: false,
  children: [],
  paths: [
    '/Users/stanleynguyen/Documents/Projects/blog.stanleynguyen.me/node_modules',
    '/Users/stanleynguyen/Documents/Projects/node_modules',
    '/Users/stanleynguyen/Documents/node_modules',
    '/Users/stanleynguyen/node_modules',
    '/Users/node_modules',
    '/node_modules'
  ]
}

O objeto acima, basicamente, descreve um módulo encapsulado de um arquivo do JS, com module.exports sendo o componente exportado de todos os tipos – objeto, função, string e outros. A exportação padrão em um módulo do Node.js é simples assim:

module.exports = function umaFuncaoExportada() {
  return "Sim, é simples desse jeito.";
};

Existe uma outra forma de exportar a partir de um módulo do Node.js chamada "exportação nomeada". Em vez de atribuir todo o module.exports a um valor, atribuímos propriedades individuais do objeto module.exports padrão a valores. Algo assim:

module.exports.anExportedFunc = () => {};
module.exports.anExportedString = "Esta string é exportada.";

// ou empacotada juntamente em um objeto
module.exports = {
  anExportedFunc,
  anExportedString,
};

A exportação nomeada também pode ser feita de modo mais conciso com a variável predefinida exports de escopo dos módulos, assim:

exports.anExportedFunc = () => {};
exports.anExportedString = "Esta string é exportada.";

Porém, atribuir toda a variável exports a um novo valor não funcionará (discutiremos o motivo para isso na próxima seção), o que geralmente confunde os desenvolvedores do Node.js.

// Isto não funcionará como poderíamos esperar
exports = {
  anExportedFunc,
  anExportedString,
};

Imagine que as exportações dos módulos do Node.js estão enviando contêineres, com module.exports e exports agindo como a equipe no porto para quem diríamos qual "envio" (ou seja, quais valores) queremos enviar para um "porto estrangeiro" (outro módulo do projeto).

Bem, "a exportação padrão" diria a module.exports qual "envio" deveria ser enviado por navio, enquanto a "exportação nomeada" carregaria contêineres diferentes no navio que module.exports enviará para outro porto.

Agora que enviamos o navio, como esses "portos estrangeiros" receberão os navios?

Como funciona a palavra-chave require no Node.js

No lado do receptor, os módulos do Node.js podem importar usando o valor exportado de require.

Imagine que escrevemos isto em ship.js:

...
module.exports = {
  containerA,
  containerB,
};

Podemos importar esse "envio" em nosso receiving-port.js:

// importando o ship.js inteiro como uma única variável
const ship = require("./ship.js");
console.log(ship.containerA);
console.log(ship.containerB);
// ou importando diretamente os contêineres por meio da desestruturação de objetos
const { containerA, containerB } = require("./ship.js");
console.log(containerA);
console.log(containerB);

Um ponto importante a ser observado sobre esse operador do porto estrangeiro – o require – é que a pessoa não muda de ideia quanto a receber envios que foram feitos pelo module.exports de outro porto qualquer. Isso nos leva à próxima seção, onde trataremos de um ponto que normalmente causa confusão.

module.exports x exports – Qual a diferença e por que usar um ou outro?

Agora que vimos o básico sobre exportação e requisição de módulos, é hora de tratar uma das fontes mais comuns de confusão nos módulos do Node.js.

Este é um erro de exportação de módulos que os iniciantes em Node.js geralmente cometem. Eles atribuem exports a um novo valor, achando que é a mesma coisa que a "exportação padrão" usando module.exports.

Isso, no entanto, não funciona porque:

• require somente usará o valor de module.exports
• exports é uma variável com escopo de módulo que faz referência inicialmente a module.exports

Assim, ao atribuir exports a um novo valor, estamos efetivamente apontando o valor de exports para outra referência que não é  inicial do mesmo objeto module.exports.

Se quiser saber mais a respeito dessa explicação técnica, a documentação oficial do Node.js é um bom ponto de partida.

Voltando à analogia que fizemos anteriormente usando navios e operadores: exports são outra equipe portuária que poderíamos informar sobre o navio que está partindo. No início, tanto module.exports, quanto exports têm a mesma informação sobre o "navio" de partida.

Se dissermos, no entanto, às exportações que o navio de saída será diferente (isto é, se atribuíssemos exports a um valor completamente novo), o que quer que digamos depois (como atribuir propriedades de exports a valores) não estará no navio que module.exports está realmente preparando para ser recebido por require.

Por outro lado, se apenas disséssemos às exportações para "carregar alguns contêineres no navio de saída" (atribuindo propriedades de exports ao valor), na verdade, acabaríamos carregando "contêineres" (isto é, valores de propriedade) no navio que está sendo enviado.

Com base no erro comum explicado acima, poderíamos definitivamente desenvolver algumas boas convenções em torno do uso de módulos CommonJS no Node.js.

Melhores práticas de exportação para o Node.JS – uma alternativa sensata

Logicamente, a convenção oferecida abaixo é inteiramente baseada em minhas próprias análises e raciocínio. Se tiver uma alternativa para a qual você realmente acha que pode melhorar a situação, não hesite em me enviar uma mensagem pelo Twitter a respeito.

O principal que desejo conseguir com essa convenção é:

• eliminar a confusão entre exports e module.exports
• facilitar a leitura e melhorar a observabilidade com relação à exportação de módulos

Minha proposta é, portanto, consolidar os valores exportados na parte de baixo do arquivo, assim:

// exportação padrão
module.exports = function defaultExportedFunction() {};
// exportação nomeada
module.exports = {
  something,
  anotherThing,
};

Ao fazer isso, eliminaríamos as desvantagens em termos de concisão que module.exports têm em comparação com a abreviação exports. Isso removeria todos os incentivos para que usemos os exports, confusos e potencialmente danosos.

Esta prática ainda facilitaria para que os leitores do código o lessem  e aprendessem sobre os valores exportados de um módulo específico.

Indo além do CommonJS

Existe um padrão novo e, obviamente, melhor que foi introduzido há pouco no Node.js, chamamos de módulos do ECMAScript. Os módulos do ECMAScript costumavam estar disponíveis apenas em código que precisaria mais tarde de uma transpilação do Babel, ou como parte de um recurso experimental do Node.js, versões 12 ou posteriores.

É uma maneira bastante simples e elegante de lidar com a exportação de módulos. Uma ideia geral a seu respeito pode ser resumida com a exportação padrão (em inglês, default) a seguir:

export default function exportedFunction() {}

Já as exportações nomeadas teriam esta aparência:

// Exportações nomeadas em linhas separadas
export const constantString = "CONSTANT_STRING";
export const constantNumber = 5;
// Exportações nomeadas consolidadas
export default {
  constantString,
  constantNumber,
};

Esses valores, podem, então, ser facilmente importados pelo receptor, assim:

// valores padrão importados
import exportedFunction from "exporting-module.js";
// importar valores das exportações nomeadas por meio da desestruturação de objetos
import { constantString, constantNumber } from "exporting-module.js";

Isso termina com a confusão entre module.exports e exports com uma sintaxe bonita e que qualquer um pode entender!

Existem, certamente, projetos que ainda serão migrados para a versão 14  ou posterior do Node.js e que ainda não poderão usar essa sintaxe nova.

Porém, se você tiver a oportunidade de fazer isso (por estar começando um novo projeto ou porque seu projeto foi migrado com sucesso para a versão 14 do Node.js ou posteriores), não há motivo para não mudar para este modo futurista e incrível de se olhar para a questão.

Obrigado pela leitura!

Para encerrar, se você gostou do que o autor escreveu, acesse o blog do autor para ver comentários semelhantes e siga-o no Twitter. 🎉

O Node.js é um ambiente de tempo de execução do JavaScript. Certo, mas o que isso quer dizer? Como é que ele funciona?

O ambiente de tempo de execução chamado Node.js inclui tudo de que você precisa para executar um programa escrito em JavaScript.

O Node.js passou a existir quando os desenvolvedores originais do JavaScript decidiram transformá-lo de algo que somente podia ser executado no navegador em algo que podia ser executado em sua máquina e como uma aplicação autônoma.

Agora, é possível fazer muito mais com o JavaScript do que tornar sites da web interativos.

O JavaScript, agora, consegue fazer coisas que outras linguagens de programação como o Python podem fazer.

Tanto o JavaScript do seu navegador quanto o Node.js são executados na engine de tempo de execução V8 do JavaScript. Essa engine recebe o código em JavaScript e o converte em código de máquina mais rápido. O código de máquina é um código de baixo nível que o computador pode executar sem a necessidade de interpretá-lo primeiramente.

Por que usar o Node.js?

Aqui temos uma definição formal dada no site oficial do Node.js:

O Node.js® é um tempo de execução do JavaScript criado com base na engine de JavaScript V8 do Chrome.

O Node.js usa um modelo de entrada e saída orientado por eventos e não bloqueador que o torna leve e eficiente.

O ecossistema de pacotes do Node.js, o npm, é o maior ecossistema de bibliotecas de código aberto do mundo.

Já discutimos a primeira linha dessa definição: "O Node.js® é um tempo de execução do JavaScript criado com base na engine de JavaScript V8 do Chrome." Agora, vamos entender as outras duas linhas para podermos descobrir a razão pela qual o Node.js é tão popular.

Entrada e saída têm a ver com o que chamamos em inglês de input/output (cuja sigla é I/O). Pode ser qualquer coisa – de ler ou gravar arquivos localmente a fazer uma solicitação de HTTP para uma API.

O processo de E/S (entrada e saída) leva tempo e, por isso, bloqueia outras funções.

Considere um cenário onde solicitamos a um banco de dados do back-end que nos retorne os detalhes sobre o usuário1 e o usuário2 (na imagem abaixo, user1 e user2) e que, em seguida, os imprima na tela/console. A resposta para essa solicitação leva tempo, mas as duas solicitações de dados dos usuários podem ser realizadas independentemente e ao mesmo tempo.

E/S com bloqueio

No método com bloqueio, a solicitação de dados do usuário2 não é iniciada até que os dados do usuário1 sejam impressos na tela.

Se estamos falando de um servidor da web, teríamos de iniciar uma nova thread (algo como uma "sequência", em português) para cada novo usuário. O JavaScript, porém, usa uma thread única (isso não é bem verdade, mas ele tem um loop de eventos que são de thread única – falaremos sobre isso mais tarde). Assim, isso faria com que o JavaScript não fosse a melhor opção para tarefas que exigem várias threads.

É aí que entra a parte do "sem bloqueio".

E/S sem bloqueio

Por outro lado, usando uma solicitação sem bloqueio, é possível iniciar uma solicitação de dados do usuário2 sem esperar pela resposta dada sobre o usuário1. Você pode iniciar as duas solicitações em paralelo.

Essa E/S sem bloqueio elimina a necessidade de várias threads, já que o servidor pode lidar com diversas solicitações ao mesmo tempo.

O loop de eventos do JavaScript

Se você tiver 26 minutos à disposição, assista essa explicação em vídeo excelente sobre o loop de eventos do Node (em inglês):

Caso contrário, aqui, temos uma explicação passo a passo de como funciona o loop de eventos em JavaScript.

1. Colocar main() na stack de chamadas.
2. Colocar console.log() na stack de chamadas. Ele é executado imediatamente e retirado da stack.
3. Colocar setTimeout(2000) na stack. setTimeout(2000) é uma API do Node. Quando a chamamos, registramos o par evento-função de callback. O evento aguardará 2.000 milissegundos, depois chamará a função de callback.
4. Depois de ser registrada nas APIs, setTimeout(2000) é retirada da stack de chamadas.
5. O segundo setTimeout(0) é registrado do mesmo modo. Agora, temos duas APIs do Node esperando para serem executadas.
6. Após aguardar 0 segundos, setTimeout(0) é movida para a fila de callback. O mesmo ocorre com setTimeout(2000).
7. Na fila de callback, as funções aguardam que a stack de chamadas esteja vazia, pois apenas uma instrução pode ser executada por vez. Quem cuida disso é o loop de eventos.
8. O último console.log() é executado e main() é retirado da stack de chamadas.
9. O loop de eventos vê que a stack de chamadas está vazia e que a fila de callbacks não está. Ele, então, move as funções de callback (na ordem em que a primeira a entrar é a primeira a sair – FIFO) para a stack de chamadas para execução.

npm

Essas são as bibliotecas criadas pela fantástica comunidade e que resolverão a maior parte dos problemas genéricos. O npm (do inglês, Node package manager) tem pacotes que você pode usar com suas aplicações para tornar o desenvolvimento mais rápido e mais eficiente.

Require

Require faz três coisas:

• Carrega os módulos que vêm com o Node.js, como o sistema de arquivos e o HTTP a partir da API do Node.js.
• Carrega as bibliotecas de terceiros, como o Express e o Mongoose, que você instalará a partir do npm.
• Permite que você solicite seus próprios arquivos e modularize seu projeto.

Require é uma função que aceita o parâmetro "path" (caminho) e retorna module.exports.

Módulos do Node

Um módulo do Node é um bloco de código reutilizável cuja existência não afeta outros códigos acidentalmente.

Você pode escrever seus próprios módulos e usá-los em diversas aplicações. O Node.js tem um conjunto de módulos já incorporados que você pode usar sem precisar instalá-los.

A V8 turbina o JavaScript fazendo uso do C++

A V8 é uma engine de tempo de execução de código aberto escrita em C++.

JavaScript -> V8(C++) -> código de máquina

A V8 implementa uma linguagem de script chamada ECMAScript, conforme especificado na ECMA-262. O ECMAScript foi criado pela Ecma International para padronizar o JavaScript.

A V8 pode ser executada de modo autônomo ou ser incorporada a qualquer aplicação em C++. Ela tem hooks que permitem que você escreva seu próprio código em C++ e que você pode disponibiizar para o JavaScript.

Essencialmente, isso permite que você adicione recursos ao JavaScript incorporando a V8 em seu código em C++ para que o código em C++ entenda mais do que aquilo que, de outro modo, é especificado pelo padrão do ECMAScript.

Comentário: Greg Bulmash chamou minha atenção para o fato de que existem muitas engines de tempo de execução do JavaScript além da V8, usada no Chrome. Também existem a SpiderMonkey, da Mozilla, a Chakra, da Microsoft, entre outras. Detalhes sobre isso podem ser encontrados nesta página.

Eventos

Eventos são situações que ocorrem em nossas aplicações e as quais podemos responder. Existem dois tipos de eventos no Node.

• Eventos de sistema: a base do C++ a partir de uma biblioteca chamada libuv (por exemplo, terminar de ler um arquivo).
• Eventos personalizados: a base do JavaScript.

Como escrever o 'Hello World' no Node.js

Precisamos fazer isso, certo?

Crie um arquivo app.js e adicione a ele o seguinte:

console.log("Hello World!");

Abra seu terminal do Node, altere o diretório para a pasta onde o arquivo está salvo e execute o comando node app.js.

Aí está! Você acaba de escrever o 'Hello World' no Node.js.

Você pode seguir o autor, Priyesh Patel, no Twitter.

Existem diversos recursos que você pode usar para aprender mais sobre o Node.js, incluindo, é claro, o freeCodeCamp.org.

O Nodemailer é um módulo do Node.js que permite enviar e-mails para o seu servidor com facilidade. Quando você quiser se comunicar com seus usuários ou apenas ser notificado quando algo der errado, uma das opções para fazer isso seria usando o e-mail.

Existem muitos artigos explicando como usar o mínimo necessário do Nodemailer, mas esse artigo não é um deles. Aqui, eu vou te mostrar o modo mais comum de praticar o envio de e-mails do seu back-end do Node.js usando o Nodemailer e o Gmail.

Como começar com o Nodemailer

Primeiro, vamos precisar preparar o nosso Node.js usando o Express. Para ter certeza de que você possui o Node e o npm instalado, execute o seguinte comando:

node -v 
npm -v

Se os dois comandos mostrarem suas versões, você pode continuar. Do contrário, instale o que estiver faltando.

Crie um diretório para o seu projeto. Usaremos nodemailerProject.

mkdir nodemailerProject

Vá para o diretório criado e execute o seguinte comando:

npm init

Isso inicializará o nosso projeto com um arquivo pacakge.json.

A seguir, vamos instalar o Express, usando:

npm install express

Dependendo de qual arquivo você apontou como ponto de entrada (o padrão seria index.js), abra e cole o seguinte código:

const express = require('express')
const app = express()
const port = 3000


app.listen(port, () => {
  console.log(`nodemailerProject is listening at http://localhost:${port}`)
})

Acima, você tem o necessário para iniciar um servidor simples usando o Express. Você pode vê-lo funcionando executando o comando abaixo:

node index.js

Como instalar o Nodemailer

Instale o Nodemailer usando o seguinte comando:

npm install nodemailer

A API do Nodemailer é bem simples. Faça o seguinte:

1. Crie um objeto Transporter
2. Crime um objeto MailOptions
3. Use o método Transporter.sendMail

Para criar o objeto Transporter, devemos fazer o seguinte:

let transporter = nodemailer.createTransport({
      service: 'gmail',
      auth: {
        type: 'OAuth2',
        user: process.env.MAIL_USERNAME,
        pass: process.env.MAIL_PASSWORD,
        clientId: process.env.OAUTH_CLIENTID,
        clientSecret: process.env.OAUTH_CLIENT_SECRET,
        refreshToken: process.env.OAUTH_REFRESH_TOKEN
      }
    });

✋ Preste atenção, pois além do usuário e das chaves de acesso, que são suas próprias credenciais da sua conta do gmail, outras três chaves deverão ser recuperadas após configurar o OAuth.

Assim como dissemos no começo do artigo, usaremos o Gmail para enviar e-mails. Como você deve ter imaginado, o Gmail possui um alto nível de segurança quando o assunto é enviar e-mails para/pela conta do usuário.

Existem inúmeras formas para superarmos esses obstáculos (algumas melhores que outras). A solução que escolhemos torna necessário configurar um projeto no Google Cloud Platform. Precisamos fazer isso para poder ter credenciais para segurança do OAuth habilitada pelo Gmail.

Se você quiser ler mais sobre a complexidade de usar o Gmail com o nodemailer, vá aqui (documentação em inglês).

O próximo passo requer algumas configurações em vez de código, portanto preparem-se.

Configurações do Google Cloud Platform

Se você não tem uma conta no Google Cloud Platform, crie uma, pois é um pré-requisito. Possuindo a conta, crie um projeto clicando na seta do menu que fica no canto superior esquerdo.

Selecione a opção New Project:

Na próxima janela, teremos que dar um nome ao nosso projeto. Escolha o que você quiser. Continuaremos usando NodemailerProject. Na propriedade location, você pode manter No organization.

Deve levar alguns segundos para o projeto estar pronto para ser usado. Quando estiver, será possível ver a seguinte janela:

Abra o menu de navegação clicando nos três pontos no canto superior esquerdo e selecione APIs and Services:

Para habilitar a utilização do Nodemailer no Gmail, teremos que usar o OAuth2. Se você não estiver familiarizado com o OAuth, ele é um protocolo de autenticação. Eu não vou ser muito específico aqui, pois não é necessário. Se, no entanto, você quiser entender mais sobre isso, pode acessar aqui (documentação do OAuth em inglês).

Primeiro, vamos configurar a nossa tela de consentimento do OAuth (em inglês, OAuth Consent Screen):

Se você não for um membro do G-Suite, a única opção disponível será External em User Type.

Após clicar em Create, a próxima janela vai exigir o preenchimento das informações da aplicação (ou do servidor):

Preencha com o seu e-mail no campo User support email e no campo de informações de contato do desenvolvedor. Clicando em Save and Continue, será apresentada a fase Scopes dessa configuração. Pule essa fase, já que não é relevante para nós. A seguir, entramos na fase Test Users.

Aqui, se adicione como usuário e clique em Save and continue.

Como configurar o OAuth

Nesta fase, vamos criar as credenciais do OAuth para serem usadas com o Nodemailer. Vá até a aba Credentials, acima de OAuth Consent Screen. Clique no sinal de mais (➕) do texto Create Credentials e escolha OAuth Client ID.

No item Application type, escolha Web Application:

Na seção Authorized Redirect URIs, não se esqueça de adicionar o "OAuth2 Playground" (https://developers.google.com/oauthplayground), já que vamos usá-lo para pegar uma das chaves mencionadas anteriormente neste artigo.

Após clicar em Create, você receberá o seu Client id e o segredo do client. Mantenha-os e nunca os exponha sob qualquer condição ou formato.

Mantenha o seu token do OAuth atualizado

Para manter o seu token atualizado, o qual usaremos para transportar o objeto no Nodemailer, vamos precisar acessar o "OAuth2 Playground". Aprovamos esse "URI" para esse propósito específico em um momento anterior.

1. Clique no ícone de engrenagem à direita (que é a configuração do OAuth2) e marque a caixa para usar sua própria credencial do OAuth2 (em inglês, Use your own oAuth credentials):

2. Do lado esquerdo, você verá uma lista de serviços. Role para baixo até ver Gmail API v1.

3. Clique em Authorize APIs.

Você será apresentado a uma tela para fazer login em qualquer uma de suas contas do Gmail. Escolha aquela que você listou como um usuário de teste (na fase Test Users, anteriormente).

4. A próxima tela informará que o Google ainda não verificou essa aplicação, mas isso está ok, já que nós não a enviamos para verificação. Clique em Continue.

5. Na próxima janela, será perguntado se você quer conceder permissão ao seu projeto para interagir com a sua conta do Gmail. Dê a permissão clicando em Allow.

6. Feito isso, você será redirecionado de volta para o OAuth Playground e poderá ver que há um código de autorização no menu à esquerda. Clique no botão azul  "Exchange authorization code for tokens" (em português, troca de autorização de código para tokens).

Os campos para o token de atualização e para o token de acesso serão preenchidos.

De volta ao servidor

Depois de fazer todas essas configurações, podemos retornar à nossa aplicação e inserir todos os dados na criação do transportador. Para manter todas as suas credenciais privadas, você pode usar o pacote dotenv. Não se esqueça de adicionar o arquivo .env que você criará no .gitignore.

Então, agora, temos o seguinte:

let transporter = nodemailer.createTransport({
      service: 'gmail',
      auth: {
        type: 'OAuth2',
        user: process.env.MAIL_USERNAME,
        pass: process.env.MAIL_PASSWORD,
        clientId: process.env.OAUTH_CLIENTID,
        clientSecret: process.env.OAUTH_CLIENT_SECRET,
        refreshToken: process.env.OAUTH_REFRESH_TOKEN
      }
    });

Em seguida, criamos o objeto mailOptions, que contém os detalhes de para onde enviar o e-mail e com quais dados.

let mailOptions = {
      from: tomerpacific@gmail.com,
      to: tomerpacific@gmail.com,
      subject: 'Nodemailer Project',
      text: 'Hi from your nodemailer project'
    };

Esse objeto pode ter muito mais campos e até mesmo vários destinatários, mas não entraremos nesses detalhes aqui.

Finalmente, usaremos o método sendMail:

transporter.sendMail(mailOptions, function(err, data) {
      if (err) {
        console.log("Error " + err);
      } else {
        console.log("Email sent successfully");
      }
    });

Execute sua aplicação e verá na sua caixa de entrada que recebeu um novo e-mail.

Este artigo foi inspirado em um projeto que criei usando o Nodemailer. Se você quiser conferir, acesse-o aqui.

Escrito por: Sudheesh Shetty

Os aplicações de mensagens estão ficando cada vez mais populares. Os últimos anos trouxeram aplicações como o WhatsApp, o Telegram, o Signal e o Line.

As pessoas parecem preferir aplicações baseadas em bate-papo, pois permitem interação em tempo real. Elas também adicionam um toque pessoal à experiência.

Recentemente, participei de um workshop conduzido pela Free Software Movement Karnataka (em português, Movimento de Software Livre Karnataka), em Bangalore, onde orientei um grupo de estudantes universitários.

Durante as interações, observei algumas coisas:

1. Apesar de incentivar os alunos a interagir com o mentor, a comunicação sempre foi unilateral.
2. Os alunos muitas vezes ficavam tímidos para fazer perguntas durante as sessões.
3. Eles se sentiram mais à vontade para fazer perguntas e obter feedback em conversas individuais.

Então, tivemos que encontrar uma solução para quebrar o gelo entre mentores e alunos. Uma aplicação de bate-papo local foi útil nessa situação. As pessoas adoram ser anônimas, o que dá a elas mais poder para se expressar e perguntar a qualquer hora e em qualquer lugar. Este é o mesmo mantra usado pela maioria dos fóruns populares da internet, como o Reddit e o 4chan. Estes são apenas alguns exemplos gigantes de aplicações semianônimas.

Assim, comecei a pensar nessa ideia e criei alguns dos requisitos e recursos básicos.

1. Os usuários se registram fornecendo um identificador, que é exclusivo para cada usuário (com um nome fictício). Apenas o identificador será revelado a outros usuários. Desse modo, as pessoas são livres para escolher qualquer identificador e, portanto, permanecem anônimas.
2. Um membro pode ver outros membros que estão on-line. Eles têm a opção de ficar visíveis ao público, o que transmite sua mensagem para todos os membros on-line no bate-papo.
3. Para mensagens privadas, o remetente deve primeiro enviar uma solicitação ao outro membro. Outros membros, ao aceitarem o pedido, podem ter um bate-papo privado com eles.

Tecnologias e ferramentas usadas

1. A stack MEAN (Mongo, Express, Angular e Node).
2. Sockets para permitir a comunicação individual em tempo real
3. AJAX para inscrição e autenticação

Como criar uma aplicação de bate-papo simples?

Neste tutorial, vou ajudá-lo a criar sua própria aplicação de bate-papo. Posteriormente, você pode integrá-la como um widget em qualquer projeto! Este tutorial não se concentrará no desenvolvimento completo de uma aplicação de bate-papo. Ajudará, no entanto, a construir um.

Pré-requisito: você precisa ter algum conhecimento básico da stack MEAN, pois estamos fazendo uso dela para o projeto.

Primeiro, crie uma estrutura de diretório mais ou menos assim.

Instale o Node.js e o MongoDB.

Usaremos o AngularJS 1 para este tutorial. Baixe a biblioteca do AngularJS aqui e copie-a para a pasta lib no diretório Client.

Se você gosta de embelezar a aplicação, pode baixar qualquer biblioteca do CSS e copiá-la para lib também.

Construindo o servidor

Passo 1 — Inicie o projeto:

Entre no diretório Server e execute este comando:

npm init

Um novo projeto será iniciado. Forneça todos os detalhes necessários. O package.json será criado e vai ter esta aparência:

{
  "name": "chat",
  "version": "1.0.0",
  "description": "Chat application",
  "main": "server.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "Your name",
  "license": "ISC"
}

Passo 2 — Instale as dependências.

• socket.io — é uma biblioteca do JavaScript para aplicações da web em tempo real. Ele permite a comunicação bidirecional em tempo real entre clients e servidores da web.
• express — é uma estrutura de aplicação da web do Node.js. Ele fornece o conjunto de recursos para desenvolver aplicações da web e para dispositivos móveis. Pode-se responder à solicitação HTTP usando diferentes middlewares e também renderizar páginas em HTML.

npm install --save socket.io
npm install --save express

Isso instalará as dependências necessárias e as adicionará ao package.json. Um campo a mais será adicionado ao package.json, que ficará assim:

"dependencies": {
    "express": "^4.14.0",
    "socket.io": "^1.4.8"
  }

Passo 3 — Criando o servidor

Crie um servidor que atenda na porta 3000 e que envie o documento html quando for chamado.

Inicie uma nova conexão de socket passando o objeto HTTP.

A conexão de evento estará escutando os sockets de entrada.

Cada socket emite um evento de desconexão que será chamado sempre que um client se desconectar.

• socket.on espera pelo evento. Sempre que esse evento é acionado, a função de callback é chamada.
• io.emit é usado para enviar a mensagem para todos os sockets conectados a ele.

A sintaxe é:

socket.on('evento', function(msg){})
io.emit('evento', 'mensagem')

Crie um servidor com o nome server.js. Ele deverá:

• imprimir uma mensagem para o console após a conexão de um usuário
• escutar eventos de mensagem de bate-papo e transmitir a mensagem recebida para todos os sockets conectados.
• imprimir uma mensagem de desconexão no console sempre que um usuário se desconectar.

O servidor vai ter uma aparência semelhante a esta:

var app = require('express')();
var http = require('http').Server(app);
var io = require('socket.io')(http);

app.get('/', function(req, res){
  res.sendfile('index.html');
});

io.on('connection', function(socket){
  console.log('user connected');
  socket.on('chat message', function(msg){
    io.emit('chat message', msg);
  });
  socket.on('disconnect', function(){
    console.log('user disconnected');
  });
});

http.listen(3000, function(){
  console.log('listening on *:3000');
});

Construindo o client

Crie o arquivo index.html no diretório Client, o arquivo style.css no diretório CSS e o arquivo app.js no diretório JS do client.

index.html:

Vamos escrever um HTML simples que possa receber nossa mensagem e também exibi-la.

Inclua socket.io-client e angular.js em elementos script no seu HTML.

<script src="/path/to/angular.js"></script>
<script src="/socket.io/socket.io.js"></script>

socket.io serve o client para nós. O padrão é se conectar ao host, que serve a página. O HTML final terá esta aparência:

<!doctype html>
<html ng-app="myApp">
  <head>
    <title>Socket.IO chat</title>
    <link rel="stylesheet" href="/css/style.css">
    <script src="/lib/angular/angular.js"></script>
    <script src="/socket.io/socket.io.js"></script>
    <script src="http://code.jquery.com/jquery-1.11.1.js">
    </script>
    <script src="/js/app.js"></script>
  </head>
  <body ng-controller="mainController">
    <ul id="messages"></ul>
    <div>
      <input id="m" ng-model="message" autocomplete="off" />
      <button ng-click="send()">Send</button>
    </div>
  </body>
</html>

CSS/style.css:

Dê um estilo para a aplicação fazendo com que se pareça uma caixa de bate-papo. Você pode usar qualquer biblioteca.

* { margin: 0; padding: 0; box-sizing: border-box; }
body { font: 13px Helvetica, Arial; }
div { background: #000; padding: 3px; position: fixed; bottom: 0; width: 100%; }
div input { border: 0; padding: 10px; width: 90%; margin-right: .5%; }
div button { width: 9%; background: rgb(130, 224, 255); border: none; padding: 10px; }
#messages { list-style-type: none; margin: 0; padding: 0; }
#messages li { padding: 5px 10px; }
#messages li:nth-child(odd) { background: #eee; }

JS/app.js:

Crie uma aplicação com o angular.js e inicie uma conexão de socket.

• socket.on escuta um determinado evento. Ele chama uma função de callback sempre que o evento for chamado.
• socket.emit é usado para emitir a mensagem para o evento específico.

A sintaxe básica de ambos é:

socket.on('nome do evento', function(msg){});
socket.emit('nome do evento', mensagem);

Assim, sempre que a mensagem for digitada e o botão for clicado, chame a função para enviar a mensagem.

Sempre que o soquete receber uma mensagem, exiba-a.

O código em JavaScript ficará mais ou menos assim:

var app=angular.module('myApp',[]);

app.controller('mainController',['$scope',function($scope){
 var socket = io.connect();
 $scope.send = function(){
  socket.emit('chat message', $scope.message);
  $scope.message="";
 }
 socket.on('chat message', function(msg){
  var li=document.createElement("li");
  li.appendChild(document.createTextNode(msg));
  document.getElementById("messages").appendChild(li);
 });
}]);

Executando a aplicação

Vá para o diretório Server, onde nosso servidor está presente. Execute o servidor usando o seguinte comando:

node server.js

O servidor começa a rodar na porta 3000. Acesse o navegador e digite o seguinte url:

http://localhost:3000

Como melhorar a aplicação

Você pode criar um banco de dados para salvar detalhes e mensagens do usuário. Seria bom se o design fosse escalável para que você pudesse adicionar mais recursos posteriormente.

Você precisa instalar o Mongoose ou um módulo do MongoDB para usar um banco de dados do Mongo:

npm install --save mongoose

ou:

npm install --save mongodb

Aqui está a documentação para usar o mongoose e o módulo mongodb.
Aqui está a aparência do meu design de esquema:

{
 "_id" : ObjectId("5809171b71e640556be904ef"),
 "name" : "Sudheesh Shetty",
 "handle" : "sudheesh",
 "password" : "556624370",
 "phone" : "8888888888",
 "email" : "sudheeshshetty@gmail.com",
 "friends" : [
    {
      "name" : "abc",
      "status" : "Friend"
    },
    {
      "name" : "xyz",
      "status" : "Friend"
    }
 ],
 "__v" : 0
}

Aqui, o status de cada membro pode ser:

• Friend: afirmando que o membro é um amigo.
• Pending: se o membro ainda não aceitou.
• Blocked: se o membro bloqueou o outro membro.

Suponha que o membro rejeitou uma solicitação de bate-papo. O remetente pode enviar uma solicitação de bate-papo novamente. Um usuário também pode salvar as mensagens criando uma coleção extra. Cada documento terá a mensagem, o remetente, o destinatário e a hora.

Portanto, projete seu banco de dados de acordo com suas necessidades específicas e como deseja tratar as mensagens.

2. Crie APIs REST para servir o client. Por exemplo, um terminal que envia uma página inicial, a partir da qual os usuários podem fazer outras solicitações.

Alguns dos meus endpoints de API são:

app.post('/register',function(req,res){})

app.post('/login',function(req,res){})

app.post('/friend_request',function(req,res){})

app.post('/friend_request/confirmed',function(req,res){})

3. Pense em alguns recursos adicionais interessantes e implemente-os.

O autor criou uma aplicação de bate-papo:

sudheeshshetty/Chat
Contribua com o desenvolvimento do Chat criando uma conta no GitHub

Aqui está uma rápida olhada na minha aplicação de bate-papo:

Dê uma olhada na aplicação e, se gostar, dê a ela uma estrela. Há muitas maneiras de melhorar essa aplicação. Se tiver alguma sugestão, envie-a para o autor pelo e-mail sudheeshshetty@gmail.com.

Você pode seguir o autor no GitHub.

Neste artigo, você aprenderá a trabalhar com o JavaScript no back-end usando o Node no Windows.

Ao começar a trabalhar com o JavaScript e descobrir que você pode não apenas trabalhar com ele no front-end, mas também no back-end, um novo mundo de possibilidades parece se abrir.

Para começar, percebemos que não é necessário utilizar outra linguagem de programação para ter o back-end de suas aplicações funcionando. Em segundo lugar, o Node.js tem uma instalação simples e funciona em todas as plataformas de desenvolvimento com as quais estamos acostumados: Mac, Linux e Windows.

Neste artigo, mostrarei como instalar o Node no Windows com um guia passo a passo para deixá-lo pronto para o uso.

Também é uma ótima notícia o fato de que o gerenciamento de pacotes é facilitado, já que o npm (ou Node Package Manager) vem junto com a instalação do Node.

Com ele, você poderá ter acesso a uma quantidade quase infinita de dependências criadas pela comunidade. Você pode simplesmente instalar essas dependências em sua aplicação e não precisará fazer tudo do zero sempre que precisar.

Vamos, então, instalar o Node no Windows e começar a brincar com ele um pouco.

Como instalar o Node no Windows

A primeira coisa a se fazer é acessar o site oficial do Node.

O site é inteligente o suficiente para detectar o sistema que você está utilizando. Assim, se você estiver no Windows, provavelmente verá uma página como a da imagem acima. Bem no meio dela, dois botões mostram as possibilidades mais comuns – e mais recentes – para download.

Se estiver curioso sobre todos os recursos mais recentes que o Node tem a oferecer, clique no botão da direita. Para a maioria dos usuários, no entanto, o próprio site recomenda usar a versão de suporte estendido (em inglês, Long-Term Support, ou LTS), aquela disponível para download usando o botão da esquerda.

No momento em que este artigo foi criado, a versão LTS é a versão 16.14.0.

Nota de tradução: no momento da tradução do texto, a versão LTS mais recente é a 18.13.0.

Ao clicar em qualquer um dos botões, é feito o download de um arquivo .msi para o seu computador. O próximo passo é clicar nele e a instalação começará. O assistente abre e a janela a seguir é exibida:

Clique em Next (Avançar). Na janela seguinte, você lerá (você lerá, não lerá?) o Acordo de licença do usuário final (ou EULA, com base na sigla em inglês), aceitará os termos do acordo e clicará em Next novamente. A próxima janela é o local onde você selecionar a pasta de destino para o Node.

O Windows normalmente recomenda que os programas sejam instalados na pasta Arquivos de programas (ou, em inglês, Program Files), cada um deles em sua pasta próprio (em nosso caso, como instalaremos o Node.js, a pasta nodejs parece o local ideal).

Para simplificar, vamos seguir as sugestões do assistente e usar C:\Program Files\nodejs\ como a pasta de destino.

A janela a seguir é aquela na qual personalizamos nossa instalação. A menos que você tenha problemas com espaço em disco ou se tiver uma ideia bem clara do que está fazendo, recomendo manter as opções como estão e simplesmente clicar em Next novamente.

Algo que eu gostaria de enfatizar nessa janela é a terceira opção que você verá. Essa é a opção que permite a instalação do npm com o Node em seu computador. Desse modo, se você ainda pretende alterar a configuração dessa página de algum outro modo, mantenha, pelo menos, essa opção como está e o npm será instalado para você ao final do processo.

A próxima janela trata da instalação automática das "Ferramentas para módulos nativos" (em inglês, Tools for Native Modules). Mais uma vez, a menos que você tenha a certeza de que precisa delas, recomendo deixar essa caixa de seleção desmarcada e clicar em Next mais uma vez.

Chegamos à janela final pré-instalação. Conforme ela diz, aqui, basta clicar em Install (Instalar) para começar a instalação. Então, vamos lá.

Consegue observar o escudo azul e amarelo ao lado da palavra Install? Ele significa que o Windows pedirá para você confirmar se realmente deseja realizar o processo de instalação tão logo clique naquele botão. Levando em consideração que esse é o motivo de você estar lendo este artigo, basta clicar em Yes e deixar que o instalador faça seu serviço.

Finalmente chegamos à janela que esperávamos, aquela que nos diz que o Node foi instalado com sucesso em nosso computador com o Windows. Clique em Finish (Finalizar) e vamos conferir se está tudo certo.

Como verificar sua instalação do Node

Para verificar se o Node (e o npm) foram instalados corretamente em seu computador, você pode selecionar abrir o Windows Powershell ou o Prompt de comando.

Usaremos o primeiro neste exemplo. Clique na barra de pesquisa ao lado do botão do seu menu Iniciar e digite powershell. Pressione Enter e o Windows Powershell será aberto em uma janela para você.

Em qualquer pasta (como, por exemplo, em C:\Users), você pode digitar node -v para conferir a versão do Node que está usando. Como mencionei anteriormente, a versão mais recente no momento em que escrevo este artigo é a versão 16.14.0 e é exatamente isso que vemos no Powershell acima.

Nota de tradução: no momento da tradução deste artigo, se fizéssemos os mesmos passos com a versão LTS, a linha que diz v16.14.0 diria v18.13.0.

Vale a pena mencionar que, se você está se perguntando o motivo de podermos fazer essa verificação a partir de qualquer pasta, isso tem a ver com nossa maneira de instalar o Node e o npm. Uma das opções na configuração personalizada que vimos (e que deixamos como estava) foi a de adicionar o Node ao PATH (onde ficam os caminhos que o Windows carrega desde o início). Ao fazer isso, podemos acessá-lo de qualquer lugar ao navegar entre as pastas.

Também é possível conferir a versão do npm. Ao fazer isso, digite npm -v e pressione Enter. Em nosso caso, a versão mais recente é a versão 8.3.1. Então, podemos dizer que estamos atualizados.

Nota de tradução: no momento da tradução deste artigo, se fizéssemos os mesmos passos com a versão LTS do Node, a linha que diz v8.3.1 para a versão mais recente do npm diria v8.19.3.

Como usar o npm

Certo, mas você não chegou até aqui na leitura para concluir após a instalação do Node e do npm, correto? Você quer ver os dois em ação. Vamos lá, então.

Para aprender a iniciar um projeto com o Node e a instalar pacotes com o npm, usaremos o Visual Studio Code.

Criaremos uma pasta chamada Node_Test, onde colocaremos o Node e o npm a trabalhar um pouco.

Vamos começar com o simples. Dentro da pasta Node_Test, clique com o botão direito dentro da pasta e clique em Open with Visual Studio Code (Abrir com o VS Code). Isso abrirá o VS Code nessa pasta vazia automaticamente.

Dentro do VS Code, se você já não fez isso, abra um novo terminal pressionando Ctrl+Shift+' (aspa simples).

Clique no terminal e, na linha de comando, digite npm init -y. Isso iniciará um projeto do Node automaticamente para nós sem a necessidade de nos preocuparmos com toda a configuração inicial (a flag -y fara isso por conta própria). Será criado um arquivo package.json na pasta Node_Test.

Em seguida, vamos instalar o Express como dependência. Você pode encontrá-lo com uma lista de outras dependências possíveis do npm em https://www.npmjs.com/.

Mais um detalhe: sempre que você abrir o site da web do npm, no canto superior esquerdo, você verá o que parece ser uma combinação de três palavras sem muito sentido. Se olhar as iniciais de cada uma, no entanto, verá que é uma sequência cuja sigla é npm.

Certo. Agora, vamos instalar o Express com essa "mantícora ronronadora eficaz" (esse é o significado do Nifty Purring Manticore acima, a propósito). De volta ao VS Code e ao terminal, digite npm i express e pressione Enter. O Express será instalado. Você pode fazer o mesmo com qualquer outra dependência que você imaginar.

Para ter certeza de que o Express foi instalado, abra o arquivo package.json. Role até a lista de dependências (a propriedade dependencies desse grande objeto que compõe o package.json) e você verá o Express lá.

Para concluir

Era isso que tínhamos de momento. Neste artigo, você viu como instalar o Node e o npm no Windows.

Espero que o artigo tenha sido útil para você. Para ver mais tutoriais como esse em português, confira freecodecamp.org/portuguese/news e busque pelo assunto sobre o qual você gostaria de aprender.

Boa programação para você! 😊