DEV Community: Ruan Vitor

Como rodar o n8n em Docker de forma simples e eficiente 🐋

Ruan Vitor — Mon, 02 Feb 2026 15:00:47 +0000

O que é Docker, para que serve e quando utilizar ?

O Docker é uma plataforma que permite criar, empacotar e executar aplicações dentro de containers. Um container inclui tudo o que a aplicação precisa para funcionar — código, dependências, bibliotecas e configurações — garantindo que ela rode da mesma forma em qualquer ambiente, seja no computador do desenvolvedor, em um servidor ou na nuvem.

Na prática, o Docker resolve um problema muito comum no desenvolvimento: “na minha máquina funciona”. Ao isolar a aplicação do sistema operacional, ele garante consistência, portabilidade e rapidez no setup de ambientes. Isso torna o processo de desenvolvimento, testes e deploy muito mais previsível e eficiente.

O Docker é ideal quando você precisa padronizar ambientes, facilitar a colaboração entre equipes, reduzir o tempo de configuração ou escalar aplicações com mais controle. Ele é amplamente utilizado em microsserviços, pipelines de CI/CD, ambientes de desenvolvimento local e também em produção, principalmente quando combinado com ferramentas como Docker Compose ou Kubernetes.

Exemplos práticos de uso

Um dos usos mais comuns do Docker é com bancos de dados. Por exemplo, ao usar Docker + PostgreSQL, você pode subir rapidamente um banco para desenvolvimento ou testes sem instalar nada na sua máquina, apenas executando um container já pronto. O mesmo vale para Docker + MySQL, muito utilizado em aplicações web, ou Docker + MongoDB, bastante comum em sistemas que trabalham com dados não relacionais.

Esses containers podem ser criados, destruídos e recriados facilmente, mantendo os dados persistidos por meio de volumes. Isso facilita testes, simulações de ambiente e até a troca de versões do banco de dados sem dores de cabeça.

Em resumo, o Docker permite que você foque no que realmente importa: desenvolver e entregar valor, sem perder tempo com configurações complexas ou inconsistentes.

Exemplo prático: rodando o n8n com Docker Compose

services:
  n8n-blog:
    image: n8nio/n8n
    ports:
      - "1978:5678"
    volumes:
      - n8n-blog:/var/lib/n8n-blog
    environment:
      GENERIC_TIMEZONE: America/Sao_Paulo
    restart: unless-stopped
    networks:
      - n8n-blog
volumes:
  n8n-blog:
networks:
  n8n-blog:
    driver: bridge

O que esse arquivo faz ?

services: define os serviços que serão executados. Aqui, criamos um serviço chamado n8n-rocketseat.
image: utiliza a imagem oficial do n8n (n8nio/n8n) disponível no Docker Hub.
ports: faz o mapeamento da porta 5678 do container para a porta 1978 da máquina host, permitindo acessar o n8n pelo navegador em http://localhost:1978.
volumes: cria um volume nomeado para persistir os dados do n8n, garantindo que fluxos e configurações não sejam perdidos ao reiniciar o container.
environment: define variáveis de ambiente, como o fuso horário (America/Sao_Paulo), essencial para o correto funcionamento de automações baseadas em tempo.
restart: com a opção unless-stopped, o container reinicia automaticamente em caso de falha ou reboot do servidor.
networks: cria uma rede bridge dedicada, permitindo comunicação segura e organizada entre serviços (útil caso você adicione um banco de dados no futuro).

Como iniciar o ambiente

Com o Docker e o Docker Compose instalados, basta executar:

docker compose up -d

Após isso, o n8n estará disponível no navegador e pronto para criar automações, sem necessidade de instalações manuais ou configurações complexas.

Esse tipo de setup é ideal tanto para testes, desenvolvimento quanto para ambientes mais controlados em produção.

Como Validar Dados de Forma Segura com Zod ☀️

Ruan Vitor — Mon, 24 Nov 2025 15:04:50 +0000

1. Entendo a funcionalidade do ZOD

Zod é uma biblioteca de validação de dados para TypeScript que permite definir schemas de forma simples e tipada. Com ele, é possível validar desde valores primitivos, como strings e números, até estruturas complexas, como objetos e arrays, garantindo segurança e consistência nos dados da aplicação.

const formSchema = z
  .object({
     username: z.string().min(5).max(12).trim(),
     email: z.email().min(5).trim().trim(),
     password: z.string().min(7),
     confirmPassword: z.string().min(7),
   })
  .refine(
     (data) => data.confirmPassword === data.password,
     "As senhas não se coencidem"
   );

2. Instalando o ZOD no projeto

Antes de começarmos, precisamos instalar o Zod em nosso projeto. Para isso, basta executar o seguinte comando: yarn add zod. Com a instalação concluída, o Zod já estará disponível em nosso ambiente, permitindo que criemos nosso primeiro schema de validação🔥

import { z } from "zod"

3. Definindo um Schema

Para valdiarmos os dados, primeiro devemos definir um Schema. Um Schema representa tipos, desde de uma String até um Array ou Objetos.

Primeiro caso de uso: vamos considerar uma situação em que precisamos validar o nome de usuário (username) em nossa aplicação. Ou seja, o usuário poderá inserir seu nome de usuário ao se cadastrar, e queremos garantir que esse valor atenda a certos critérios, por exemplo, possuir um tamanho mínimo, máximo e estar no formato esperado.

import { z } from "zod"

const usernameSchema = z.string()
.min(5, "O username deve conter no mínimo 5 caracteres")
.max(12, "O username deve conter no máximo 5 caracteres")

Como podemos ver, para criar nosso primeiro schema de validação, utilizamos o método .string() do objeto z, responsável por indicar que o valor esperado deve ser uma string.

Para definir um valor mínimo de caracteres, utilizamos o método .min(), que recebe dois parâmetros:

O número mínimo de caracteres permitidos;
A mensagem de erro exibida caso a validação falhe;

Segundo caso de uso: vamos considerar uma situação em que estamos recebendo um payload contendo os dados necessários para o cadastro de um novo usuário em nossa plataforma.

const formSchema = z
  .object({
     username: z.string().min(5).max(12).trim(),
     email: z.email().min(5).trim().trim(),
     password: z.string().min(7),
     confirmPassword: z.string().min(7),
   })
  .refine(
     (data) => data.confirmPassword === data.password,
     "As senhas não se coencidem"
   );

Neste caso de uso específico, precisamos comparar as duas senhas (password e confirmPassword). Caso elas não coincidam, deve ser retornada uma mensagem de erro informando:
"As senhas não coincidem"

Ou seja, será necessário criar uma validação personalizada, que não está disponível por padrão no Zod. Para isso iremos utilizar o método .refine()

.REFINE()

O método .refine() nos permite criar validações personalizadas em um schema.
Ele recebe dois parâmetros principais:

Uma função de callback responsável pela validação. Deve retornar um valor booleano, indicando se a condição é válida (true) ou não (false);
Mensagem de erro se a validação for falsa

4. Validando os dados

Para validar os dados, podemos utilizar o método .parse, passando como argumento o objeto (ou qualquer outro tipo de dado) que desejamos validar.

Com o .parse, se o objeto for válido, o método retorna exatamente o que foi passado como argumento. Se for inválido, ele lança um erro do tipo ZodError.

const form = {
    username: "RuanDevJs",
    email: "ruandevjs@hotmail.com",
    password: "Password@0777",
    confirmPassword: "Password@0777",
};

const data = formSchema.parse(form);
console.log(`Bem vindo ${data.username}`)

.safeParse()

Para evitar a necessidade de tratar erros manualmente, podemos utilizar o método .safeParse(), que já faz esse tratamento internamente e nos retorna um objeto com três propriedades:

success: um booleano que indica se o objeto é válido ou não
error: uma instância de ZodError (presente apenas quando a validação falha)
data: os dados validados (presente apenas quando a validação é bem-sucedida)

const data = formSchema.safeParse(form);

console.log("Resultado da validação: ", data.success);
console.log("Retorno da validação: ", data.data);
console.error("Erro da validação: ", data.error);

Secure Authentication with ReactJS and TS 🔒👻

Ruan Vitor — Thu, 07 Sep 2023 23:52:11 +0000

Recently, have you ever found yourself in an intriguing situation while working with the new version of react-router-dom ? I just encountered this situation, and I found myself thinking:

How the hell do I create private routes now? 🧐

So I decided to investigate and try the traditional authentication method, but to my surprise, this wasn't working as expected 😔.

function PrivateRoute ({ isPrivate, ...props }: Props) {
const { authenticated, loading } = useContext(AuthContext);

if(loading) {
return <Loading />;
}

if (isPrivate && !authenticated) {
return <Navigate to="/" />;
}

return <Route {...props} />;
}

However, to my surprise, I’ve found a way to create private routes in react-router-dom and I came today to share it with you. So, prepare yourself, because what comes next is pure React magic! ✨

First Step

As is customary, we will create our pagination structure using react-router-dom inside the ./src/routes/index.routes.tsx folder of our project. Following that, we’ll export it to App.tsx as usual.

/* File: index.routes.tsx */

import { Navigate, Route, Routes } from "react-router-dom";

import { Home } from "../pages/Home";
import { SignIn } from "../pages/SignIn";
import { SignUp } from "../pages/SignUp";

export function Router() {
  return (
    <Routes>
      <Route element={<Home />} path="/" />
      <Route element={<SignIn />} path="/sign-in" />
      <Route element={<SignUp />} path="/sign-up" />
      <Route element={<Navigate to="/" />} path="*" />
    </Routes>
  );
}

/* File: App.tsx */

import { BrowserRouter } from "react-router-dom";
import { Router } from "./routes/index.routes";

export default function App() {
  return (
    <BrowserRouter>
      <Router />
    </BrowserRouter>
  );
}

Second Step

Within the routes file, we will create a function called PrivateRoutes(). This function will be responsible for rendering specific components based on user authentication.

If the user is authenticated, our website will display the initial page (Home) within the component <Outlet />. On the other hand, if the user isn't authenticated, the <Navigate /> component with its to=”/sign-in” property will automatically redirect the user to the sign-in page.

/* File: index.routes.tsx */

import { Navigate, Route, Routes, Outlet } from "react-router-dom";

import { Home } from "../pages/Home";
import { SignIn } from "../pages/SignIn";
import { SignUp } from "../pages/SignUp";

function PrivateRoutes(){
  const isUserAuth = true;
  return isUserAuth ? <Outlet /> : <Navigate to="/sign-in"/>
}

export function Router() {
  return (
    <Routes>
      <Route element={<SignIn />} path="/sign-in" />
      <Route element={<SignUp />} path="/sign-up" />
      <Route element={<PrivateRoutes />}>
        <Route element={<Home />} path="/" />
      <Route />
      <Route element={<Navigate to="/sign-in" />} path="*" />
    </Routes>
  );
}

Done! From this point on, you can already have private pages in your project! I hope you enjoyed it.

Follow me for more tips 🔥