DEV Community: Bruno Mestres

[Boost]

Bruno Mestres — Thu, 27 Feb 2025 02:53:18 +0000

🚀 Como Rodar uma API Node.js + PostgreSQL com Docker

Bruno Mestres ・ Feb 26

🚀 Como Rodar uma API Node.js + PostgreSQL com Docker

Bruno Mestres — Wed, 26 Feb 2025 20:53:18 +0000

Hoje, vou compartilhar um exemplo prático e direto para quem quer aprender Docker: subir uma API Node.js conectada ao PostgreSQL sem precisar instalar o banco localmente.

Se você já perdeu tempo configurando dependências no seu ambiente ou precisa garantir que tudo funcione igual em qualquer máquina, Docker é a solução!

📌 Estruturando o Projeto
Criamos dois containers:
🔹 App Node.js para servir uma API
🔹 Banco PostgreSQL para armazenar os dados

📦 meu-projeto-docker ┣ 📂 src ┃ ┣ 📜 main.ts ┣ 📜 Dockerfile ┣ 📜 docker-compose.yml ┣ 📜 package.json
1️⃣ Criando a API Node.js
Dentro do projeto, inicialize o package.json:

npm init -y

Instale as dependências:

npm install express pg

Agora, crie src/main.ts:

import express from "express";
import pg from 'pg'
const { Pool } = pg
const app = express();

const pool = new Pool({
  user: "postgres",
  host: "db",
  database: "meubanco",
  password: "postgres",
  port: 5432,
});

app.get("/", async (req, res) => {
  const response = await pool.query("SELECT NOW()");

  res.send(`Banco conectado! Hora atual: ${response.rows[0].now}`);
});



app.listen(3000, () => console.log("API running on port 3000"));

2️⃣ Criando o Dockerfile

Esse arquivo define a imagem da nossa API:

Dockerfile

FROM node:23
WORKDIR /app
COPY package.json package-lock.json ./
RUN npm install
COPY . .
EXPOSE 3000
CMD ["node", "src/main.ts"]

3️⃣ Configurando o Docker Compose

Aqui criamos os serviços da API e do PostgreSQL.

docker-compose.yml

version: "3.8"

services:
  db:
    image: postgres:15
    restart: always
    environment:
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: postgres
      POSTGRES_DB: meubanco
    ports:
      - "5432:5432"
    volumes:
      - pgdata:/var/lib/postgresql/data

  app:
    build: .
    restart: always
    depends_on:
      - db
    ports:
      - "3000:3000"
    volumes:
      - .:/app

volumes:
  pgdata:

4️⃣ Rodando o Projeto 🚀

Agora é só rodar:

docker compose up -d

E acessar a API em:
http://localhost:3000

Enfim, com Docker, garantimos que nosso ambiente seja consistente, evitando aqueles famosos "na minha máquina funciona".

Esse foi só o começo! Podemos evoluir esse setup com migrations, CI/CD e Kubernetes. Se quiser mais conteúdos como esse, comenta aí! 👇🔥

Construindo uma API segura e eficiente com @fastify/jwt e @fastify/mongodb

Bruno Mestres — Mon, 13 Jan 2025 22:14:10 +0000

Ultimamente tenho utilizado bastante o Fastify em meus projetos pessoais, recentemente descobri diversas funcionalidades através de plugins oficiais.

Eles são leves, eficientes e, o melhor de tudo, encaixam perfeitamente no ecossistema do Fastify.

Então resolvi criar um projeto prático com autenticação e persistência, utilizando o JWT e o MongoDB.

Plugins usados no projeto:

⚒️ O @fastify/jwt é um plugin oficial que simplifica a autenticação com JSON Web Tokens. Com ele, dá pra:

Gerar tokens JWT de forma rápida.
Verificar tokens automaticamente nas rotas protegidas.

⚒️ @fastify/mongodb: Plugin oficial do Fastify para integração com o banco de dados MongoDB.

Ele se encarrega de gerenciar a conexão com o MongoDB de forma eficiente, sem que eu precise ficar configurando drivers manualmente.

Os plugins seguem uma interface padrão. Basta registrá-los com fastify.register(), definir algumas configurações e pronto.

Depois disso posso, acessar o banco diretamente com fastify.mongo e o módulo do jwt com o fastify.jwt.

Também criei um decorator para anexar apenas as rotas que seriam protegidas, onde ele verificará o token passado no cabeçalho.

import Fastify from "fastify";
import mongodb from "@fastify/mongodb";
import jwt from "@fastify/jwt";
import { config } from "./constants.ts";
import * as bcrypt from "bcrypt";

const fastify = Fastify();

type RequestUser = {
  username: string;
  email: string;
  password: string;
};

fastify.register(mongodb, {
  forceClose: true,
  url: config.MONGO_URL,
});

fastify.register(jwt, {
  secret: "supersecret",
});

fastify.post("/signup", async (req, reply) => {
  const salt = 10;
  const { email, password, username } = req.body as RequestUser;

  const data = {
    username,
    email,
    password: await bcrypt.hash(password, salt),
  };

  const user = await fastify.mongo.client.db("plugins").collection("users").insertOne(data);

  reply.send({ user })
});

fastify.decorate("auth", async (request, reply) => {
  try {
    await request.jwtVerify();
  } catch (err) {
    reply.send(err);
  }
});

fastify.post("/signin", (req, reply) => {
  // some code
  const body = req.body;
  const token = fastify.jwt.sign({ body });
  console.log(token);
  reply.send({ token });
});

fastify.get("/", { onRequest: [fastify.auth] }, async (req, reply) => {
  const users = fastify.mongo?.client.db("plugins").collection("users").find();

  const data: any = [];

  for await (const doc of users) {
    data.push(doc);
  }
  return data;
});

fastify.listen({ port: 3333 }, (err) => {
  if (err) process.exit(1);

  console.log("Running server");
});

Design Pattern - Strategy

Bruno Mestres — Mon, 18 Mar 2024 13:52:30 +0000

Ultimamente tenho estudado bastante padrões de projetos, então resolvi escrever um pouco sobre alguns, e decidi começar pelo Strategy.

O Strategy é um padrão de projeto da categoria comportamental, que permite que você crie uma hierarquia de algoritmos, separando os objetos intercambiáveis em classes separadas.
Esse padrão é muito útil quando temos um código carregado de condições, ele permite que nosso código se adapte a diversas situações que venha acontecer posteriormente.

Digamos que tenham algumas regras de negocio para dar desconto em um Ecommerce, e ela varia dependendo de diversos fatores, como quantidade de produtos no carrinho, ou um determinado valor a ser batido, promoções e etc. Nesse caso a classe que representa o carrinho de compra teria que verificar cada uma dessas variantes com diversos IFS e aplicar o valor correto, e a medida que mais opções de desconto fosse adicionado na regra de negocio, teríamos que mexer na classe do carrinho, tornando o código cada vez mais difícil de se manter e aumentando a chance de criar bugs em códigos que já estavam funcionando.

O Strategy sugere que nesse caso, pegue a classe que tem diversos IFS e separe os códigos em outras classes separadas, chamadas de estratégias.

Na estrutura desse Padrão temos:
O contexto e a classe que contem o algoritmo com a lógica comum, ela vem carregada de condições.
A interface da Strategy, que define a função que as estratégias deverão executar.
E as estratégias que são os algoritmos específicos para cada situação que o código cliente chamar.