Node.js: Instalação e Fundamentos

Domine a tecnologia mais importante do backend moderno desde a instalação até desenvolvimento profissional

Node.jsBackendJavaScriptServer Side

🌟 Por que Node.js é Indispensável?

Node.js revolucionou o desenvolvimento backend permitindo usar JavaScript no servidor. Hoje é a tecnologia com mais oportunidades de trabalho e maior demanda no mercado mundial.

Por que isso é importante: Empresas como Netflix, Uber, LinkedIn e WhatsApp usam Node.js para servir milhões de usuários. Dominar Node.js é garantia de empregabilidade.

🤔 O que é Node.js?

⚡ JavaScript no Servidor

Node.js é um runtime de JavaScript construído sobre o motor V8 do Chrome, permitindo executar JavaScript fora do navegador, especialmente em servidores.

🌐 Antes do Node.js:

JavaScript só no frontend (browsers)

🚀 Depois do Node.js:

JavaScript em qualquer lugar (servers, CLI, desktop)

💡 Principais Características

⚡ Event-Driven: Arquitetura baseada em eventos assíncronos
🔄 Non-blocking I/O: Operações não bloqueiam o thread principal
🏎️ V8 Engine: Mesmo motor ultra-rápido do Chrome
📦 NPM: Maior repositório de pacotes do mundo
🌍 Cross-platform: Roda em Windows, Mac, Linux

exemplo-assincrono.js

// Exemplo: Diferença de Paradigmas

// ❌ Programação Síncrona (Blocking)
console.log("Início");
const data = readFileSync('arquivo-gigante.txt'); // BLOQUEIA aqui
console.log("Arquivo lido!");
console.log("Fim");

// Resultado: Programa para até ler o arquivo

// ✅ Node.js Assíncrono (Non-blocking) 
console.log("Início");
readFile('arquivo-gigante.txt', (err, data) => {
  console.log("Arquivo lido!"); // Executa quando terminar
});
console.log("Fim"); // Executa IMEDIATAMENTE

// Resultado: Programa continua funcionando enquanto lê arquivo

// 🚀 Versão Moderna com Async/Await
async function exemplo() {
  console.log("Início");
  try {
    const data = await readFile('arquivo-gigante.txt');
    console.log("Arquivo lido!");
  } catch (error) {
    console.error("Erro:", error);
  }
  console.log("Fim");
}

🎯 Por que Node.js Domina o Mercado?

📊 Dados do Mercado

Node.js é usado por 85% das empresas Fortune 500 e tem a maior taxa de adoção entre tecnologias backend modernas.

✅ Vantagens

🔥 Performance: Ideal para aplicações I/O intensivas
💰 Custo: Menos recursos de servidor necessários
👥 Time unificado: Mesma linguagem no front e back
🚀 Desenvolvimento rápido: Prototipagem veloz
📦 Ecossistema: NPM tem tudo que precisar
🌐 Real-time: Perfeito para chat, gaming, IoT

⚠️ Limitações

🔢 CPU Intensivo: Não ideal para cálculos pesados
🧵 Single Thread: Não usa múltiplos cores nativamente
📈 Curva de aprendizado: Programação assíncrona
🔄 Callback Hell: Pode ficar complexo (mas solucionável)

casos-de-uso.js

// Casos de Uso Ideais para Node.js

// ✅ PERFEITO PARA:
// 🌐 APIs REST e GraphQL
// 💬 Aplicações real-time (chats, games)  
// 🔄 Microserviços
// 📱 Backends para apps mobile
// 🚀 Serverless functions
// 📊 Streaming de dados
// 🛒 E-commerce platforms
// 📈 Dashboards e analytics

// ❌ NÃO RECOMENDADO PARA:
// 🧮 Machine learning pesado
// 🎮 Game engines complexos  
// 🔬 Simulações científicas
// 📊 Big data processing intensivo
// 🖼️ Processamento de imagem/vídeo pesado

// 🏢 Empresas que usam Node.js:
const empresasNodeJS = [
  "Netflix", "Uber", "LinkedIn", "WhatsApp",
  "Airbnb", "NASA", "Medium", "Trello",
  "PayPal", "Spotify", "Instagram", "Twitter"
];

console.log(`${empresasNodeJS.length} grandes empresas confiam no Node.js!`);

⚡ Instalação Profissional

🎯 Método Recomendado

Evite baixar executáveis! Use gerenciadores de pacote para instalação profissional que permite atualizações fáceis e gerenciamento de versões.

🪟 Windows

windows-install.ps1

# Instalar Chocolatey primeiro
Set-ExecutionPolicy Bypass -Scope Process -Force
iex ((New-Object System.Net.WebClient).DownloadString('https://chocolatey.org/install.ps1'))

# Instalar Node.js LTS
choco install nodejs-lts

# Verificar instalação
node --version
npm --version

# Atualizar Node.js
choco upgrade nodejs-lts

🍎 macOS

macos-install.sh

# Instalar Homebrew primeiro
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# Instalar Node.js LTS  
brew install node@20

# Verificar instalação
node --version
npm --version

# Atualizar Node.js
brew upgrade node

🐧 Linux

linux-install.sh

# Ubuntu/Debian
curl -fsSL https://deb.nodesource.com/setup_lts.x | sudo -E bash -
sudo apt-get install -y nodejs

# CentOS/RHEL/Fedora
curl -fsSL https://rpm.nodesource.com/setup_lts.x | sudo bash -
sudo yum install -y nodejs

# Verificar instalação
node --version
npm --version

# Atualizar
sudo apt update && sudo apt upgrade nodejs npm

⚠️ Dica Importante: LTS vs Current

✅ LTS (Long Term Support):

• Versão estável
• Recomendada para produção
• Suporte garantido por 3 anos
• Use sempre LTS!

⚠️ Current:

• Versão mais recente
• Features experimentais
• Pode ter bugs
• Só para testes

🔄 NVM - Gerenciamento de Versões

🎛️ Por que Usar NVM?

NVM (Node Version Manager) permite instalar e alternar entre diferentes versões do Node.js. Essencial quando você trabalha em projetos que usam versões diferentes.

nvm-commands.sh

# Instalação do NVM

## macOS/Linux
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash
# ou
wget -qO- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash

# Recarregar terminal
source ~/.bashrc

## Windows (nvm-windows)
# Baixe de: https://github.com/coreybutler/nvm-windows/releases
# Execute o instalador nvm-setup.exe

# Comandos Essenciais do NVM

# Listar versões disponíveis
nvm list-remote
nvm list available  # Windows

# Instalar versão LTS mais recente
nvm install node
nvm install --lts

# Instalar versão específica  
nvm install 18.17.0
nvm install 20.5.0

# Listar versões instaladas
nvm list

# Usar versão específica
nvm use 18.17.0
nvm use node  # última instalada
nvm use --lts  # LTS mais recente

# Definir versão padrão
nvm alias default 18.17.0

# Verificar versão atual
nvm current

# Desinstalar versão
nvm uninstall 16.14.0

✅ Workflow com NVM

nvm-workflow.sh

# Exemplo de uso profissional

# Projeto antigo (Node.js 16)
cd projeto-legado
echo "16.14.0" > .nvmrc  # Define versão do projeto
nvm use  # Usa versão do .nvmrc
npm install
npm start

# Projeto novo (Node.js 20)  
cd projeto-novo
echo "20.5.0" > .nvmrc
nvm use
npm install
npm run dev

# NVM troca automaticamente quando você cd em projetos!

# Verificar qual versão está sendo usada
nvm current
# v20.5.0

# Script para automatizar
#!/bin/bash
# auto-nvm.sh - Adicione ao .bashrc/.zshrc

# Auto-switch Node version based on .nvmrc
autoload -U add-zsh-hook
load-nvmrc() {
  local node_version="$(nvm version)"
  local nvmrc_path="$(nvm_find_nvmrc)"
  
  if [ -n "$nvmrc_path" ]; then
    local nvmrc_node_version=$(cat "nvmrc_path")
    
    if [ "$nvmrc_node_version" != "$node_version" ]; then
      nvm use
    fi
  elif [ "$node_version" != "$(nvm version default)" ]; then
    echo "Reverting to nvm default version"
    nvm use default
  fi
}
add-zsh-hook chpwd load-nvmrc
load-nvmrc

🚀 Seu Primeiro Projeto Node.js

📝 Projeto Prático: API de Tarefas

Vamos criar sua primeira API REST com Node.js: um sistema de gerenciamento de tarefas.

projeto-setup.sh

# Estrutura do Projeto
mkdir minha-primeira-api
cd minha-primeira-api

# Inicializar projeto npm
npm init -y

# Instalar dependências
npm install express cors helmet morgan
npm install -D nodemon

# Estrutura de arquivos
touch server.js
mkdir routes controllers models middleware
touch routes/tasks.js
touch controllers/taskController.js
touch models/Task.js

# Estrutura final:
minha-primeira-api/
├── package.json
├── server.js
├── routes/
│   └── tasks.js
├── controllers/
│   └── taskController.js
├── models/
│   └── Task.js
└── middleware/
    └── auth.js

server.js

// server.js - Servidor Principal
const express = require('express');
const cors = require('cors');
const helmet = require('helmet');
const morgan = require('morgan');

// Importar rotas
const taskRoutes = require('./routes/tasks');

// Criar aplicação Express
const app = express();
const PORT = process.env.PORT || 3000;

// Middlewares de segurança e logging
app.use(helmet());  // Segurança HTTP headers
app.use(cors());    // Permitir cross-origin requests  
app.use(morgan('combined')); // Logging de requests
app.use(express.json()); // Parse JSON bodies
app.use(express.urlencoded({ extended: true })); // Parse URL-encoded

// Rotas
app.use('/api/tasks', taskRoutes);

// Rota de saúde da API
app.get('/health', (req, res) => {
  res.json({
    status: 'OK',
    timestamp: new Date().toISOString(),
    uptime: process.uptime()
  });
});

// Middleware de erro global
app.use((err, req, res, next) => {
  console.error('Erro:', err.stack);
  res.status(500).json({
    error: 'Algo deu errado!',
    message: process.env.NODE_ENV === 'development' ? err.message : 'Erro interno do servidor'
  });
});

// 404 handler
app.use('*', (req, res) => {
  res.status(404).json({
    error: 'Rota não encontrada',
    path: req.originalUrl
  });
});

// Iniciar servidor
app.listen(PORT, () => {
  console.log(`🚀 Servidor rodando na porta ${PORT}`);
  console.log(`📱 API Health: http://localhost:${PORT}/health`);
  console.log(`📋 Tasks API: http://localhost:${PORT}/api/tasks`);
});

// Graceful shutdown
process.on('SIGTERM', () => {
  console.log('⛔ Recebido SIGTERM, fechando servidor...');
  process.exit(0);
});

module.exports = app;

models/Task.js

// models/Task.js - Modelo de Dados
class Task {
  constructor(id, title, description, completed = false) {
    this.id = id;
    this.title = title;
    this.description = description;
    this.completed = completed;
    this.createdAt = new Date();
    this.updatedAt = new Date();
  }

  // Validar dados da task
  static validate(taskData) {
    const errors = [];
    
    if (!taskData.title || taskData.title.trim().length === 0) {
      errors.push('Título é obrigatório');
    }
    
    if (taskData.title && taskData.title.length > 200) {
      errors.push('Título deve ter no máximo 200 caracteres');
    }
    
    if (taskData.description && taskData.description.length > 1000) {
      errors.push('Descrição deve ter no máximo 1000 caracteres');
    }
    
    return {
      isValid: errors.length === 0,
      errors
    };
  }

  // Converter para JSON (remove dados sensíveis se houver)
  toJSON() {
    return {
      id: this.id,
      title: this.title,
      description: this.description,
      completed: this.completed,
      createdAt: this.createdAt,
      updatedAt: this.updatedAt
    };
  }
}

module.exports = Task;

controllers/taskController.js

// controllers/taskController.js - Lógica de Negócio
const Task = require('../models/Task');

// Simulando banco de dados em memória (em produção use MongoDB/PostgreSQL)
let tasks = [
  new Task(1, 'Aprender Node.js', 'Estudar os fundamentos do Node.js'),
  new Task(2, 'Criar API REST', 'Implementar CRUD completo')
];
let nextId = 3;

const taskController = {
  // GET /api/tasks - Listar todas as tasks
  getAllTasks: (req, res) => {
    try {
      const { completed, limit = 10, offset = 0 } = req.query;
      
      let filteredTasks = tasks;
      
      // Filtro por status
      if (completed !== undefined) {
        filteredTasks = tasks.filter(task => 
          task.completed === (completed === 'true')
        );
      }
      
      // Paginação
      const paginatedTasks = filteredTasks
        .slice(parseInt(offset), parseInt(offset) + parseInt(limit));
      
      res.json({
        success: true,
        data: paginatedTasks,
        total: filteredTasks.length,
        limit: parseInt(limit),
        offset: parseInt(offset)
      });
    } catch (error) {
      res.status(500).json({
        success: false,
        error: 'Erro ao buscar tasks'
      });
    }
  },

  // GET /api/tasks/:id - Buscar task por ID
  getTaskById: (req, res) => {
    try {
      const { id } = req.params;
      const task = tasks.find(t => t.id === parseInt(id));
      
      if (!task) {
        return res.status(404).json({
          success: false,
          error: 'Task não encontrada'
        });
      }
      
      res.json({
        success: true,
        data: task
      });
    } catch (error) {
      res.status(500).json({
        success: false,
        error: 'Erro ao buscar task'
      });
    }
  },

  // POST /api/tasks - Criar nova task
  createTask: (req, res) => {
    try {
      const { title, description } = req.body;
      
      // Validação
      const validation = Task.validate({ title, description });
      if (!validation.isValid) {
        return res.status(400).json({
          success: false,
          error: 'Dados inválidos',
          details: validation.errors
        });
      }
      
      // Criar nova task
      const newTask = new Task(nextId++, title, description);
      tasks.push(newTask);
      
      res.status(201).json({
        success: true,
        data: newTask,
        message: 'Task criada com sucesso'
      });
    } catch (error) {
      res.status(500).json({
        success: false,
        error: 'Erro ao criar task'
      });
    }
  },

  // PUT /api/tasks/:id - Atualizar task
  updateTask: (req, res) => {
    try {
      const { id } = req.params;
      const { title, description, completed } = req.body;
      
      const taskIndex = tasks.findIndex(t => t.id === parseInt(id));
      
      if (taskIndex === -1) {
        return res.status(404).json({
          success: false,
          error: 'Task não encontrada'
        });
      }
      
      // Validação
      const validation = Task.validate({ title, description });
      if (!validation.isValid) {
        return res.status(400).json({
          success: false,
          error: 'Dados inválidos',
          details: validation.errors
        });
      }
      
      // Atualizar task
      const task = tasks[taskIndex];
      task.title = title || task.title;
      task.description = description || task.description;
      task.completed = completed !== undefined ? completed : task.completed;
      task.updatedAt = new Date();
      
      res.json({
        success: true,
        data: task,
        message: 'Task atualizada com sucesso'
      });
    } catch (error) {
      res.status(500).json({
        success: false,
        error: 'Erro ao atualizar task'
      });
    }
  },

  // DELETE /api/tasks/:id - Deletar task
  deleteTask: (req, res) => {
    try {
      const { id } = req.params;
      const taskIndex = tasks.findIndex(t => t.id === parseInt(id));
      
      if (taskIndex === -1) {
        return res.status(404).json({
          success: false,
          error: 'Task não encontrada'
        });
      }
      
      const deletedTask = tasks.splice(taskIndex, 1)[0];
      
      res.json({
        success: true,
        data: deletedTask,
        message: 'Task deletada com sucesso'
      });
    } catch (error) {
      res.status(500).json({
        success: false,
        error: 'Erro ao deletar task'
      });
    }
  }
};

module.exports = taskController;

routes/tasks.js

// routes/tasks.js - Definição das Rotas
const express = require('express');
const router = express.Router();
const taskController = require('../controllers/taskController');

// GET /api/tasks - Listar tasks
router.get('/', taskController.getAllTasks);

// GET /api/tasks/:id - Buscar task por ID  
router.get('/:id', taskController.getTaskById);

// POST /api/tasks - Criar nova task
router.post('/', taskController.createTask);

// PUT /api/tasks/:id - Atualizar task
router.put('/:id', taskController.updateTask);

// DELETE /api/tasks/:id - Deletar task
router.delete('/:id', taskController.deleteTask);

module.exports = router;

package.json

// package.json - Configuração atualizada
{
  "name": "minha-primeira-api",
  "version": "1.0.0",
  "description": "API REST de gerenciamento de tarefas com Node.js",
  "main": "server.js",
  "scripts": {
    "start": "node server.js",
    "dev": "nodemon server.js",
    "test": "echo \"Tests not implemented\" && exit 0"
  },
  "keywords": ["node.js", "express", "api", "rest"],
  "author": "Seu Nome",
  "license": "MIT",
  "dependencies": {
    "express": "^4.18.2",
    "cors": "^2.8.5", 
    "helmet": "^7.0.0",
    "morgan": "^1.10.0"
  },
  "devDependencies": {
    "nodemon": "^3.0.1"
  },
  "engines": {
    "node": ">=18.0.0",
    "npm": ">=8.0.0"
  }
}

🚀 Testando sua API

api-tests.http

# Executar a API
npm run dev

# Testar no navegador ou Postman:

# 📋 Listar todas as tasks
GET http://localhost:3000/api/tasks

# 👁️ Buscar task específica  
GET http://localhost:3000/api/tasks/1

# ➕ Criar nova task
POST http://localhost:3000/api/tasks
Content-Type: application/json
{
  "title": "Minha nova task",
  "description": "Descrição da task"
}

# ✏️ Atualizar task
PUT http://localhost:3000/api/tasks/1
Content-Type: application/json
{
  "title": "Task atualizada",
  "completed": true
}

# 🗑️ Deletar task
DELETE http://localhost:3000/api/tasks/1

# 🔍 Health check
GET http://localhost:3000/health

🎯 Próximos Passos

🚀 Evolução da sua API

Agora que você tem uma API básica funcionando, estes são os próximos passos para se tornar profissional.

📚 Fundamentos Avançados

🗄️ Banco de Dados: MongoDB, PostgreSQL, Prisma ORM
🔐 Autenticação: JWT, OAuth2, bcrypt
✅ Validação: Joi, Yup, express-validator
🧪 Testes: Jest, Supertest, TDD

🏗️ Arquitetura

📦 Microserviços: Docker, Kubernetes
📡 GraphQL: Apollo Server, type-graphql
⚡ Performance: Redis, clustering, PM2
📊 Monitoring: Logs, métricas, alertas

☁️ Deploy e Produção

🌐 Hosting: AWS, Heroku, DigitalOcean, Vercel
🔄 CI/CD: GitHub Actions, GitLab CI
🛡️ Segurança: HTTPS, CORS, rate limiting
📈 Escalabilidade: Load balancing, auto-scaling

🧰 Ferramentas Profissionais

📝 Documentação: Swagger/OpenAPI
🔧 Debug: Node inspector, profiling
🎯 Lint: ESLint, Prettier, Husky
📊 Analytics: New Relic, DataDog

🎉 Parabéns! Você é um Node.js Developer

Com Node.js instalado corretamente e sua primeira API funcionando, você oficialmente entrou no mundo do desenvolvimento backend profissional. Continue praticando e expandindo seus conhecimentos!

✅ Node.js

Instalado e configurado

🚀 Primeira API

CRUD completo

🏗️ Arquitetura

MVC pattern

🛡️ Boas Práticas

Segurança e validação

Node.js DeveloperBackend ReadyAPI BuilderProduction Ready