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.

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.