Deploy Gratuito de um Projeto Full Stack em 10 Passos

Baixe aqui o arquivo e aprenda passo a passo como fazer o deploy gratuito com Render de um projeto MERN (MongoDB, Express, React, Node.js).

Neste artigo você vai aprender em 10 passos simples como realizar o deploy de um projeto completo usando a plataforma Render, mas que podem ser adaptados para outras plataformas como Heroku ou Vercel. Vamos direto ao ponto, com uma linguagem acessível e exemplos práticos!

Por que fazer o deploy de um projeto MERN?

Fazer o deploy de um projeto MERN permite que sua aplicação saia do ambiente local (localhost) e fique disponível online para qualquer pessoa acessar. Isso é essencial para demonstrar seu trabalho, testar em produção ou até compartilhar com clientes e recrutadores.

Para fazer o download do(s) arquivo(s) utilizados na aula, preencha com o seu e-mail:

Não vamos te encaminhar nenhum tipo de SPAM! A Hashtag Treinamentos é uma empresa preocupada com a proteção de seus dados e realiza o tratamento de acordo com a Lei Geral de Proteção de Dados (Lei n. 13.709/18). Qualquer dúvida, nos contate.

Passo 1: Criar o Build do Frontend em React

O que é build e por que ele é necessário?

Chamamos de build o processo de transformar seu projeto React em arquivos estáticos (HTML, CSS e JavaScript) que podem ser servidos por um servidor. Sem isso, seu frontend não poderá ser acessado online.

No terminal, na pasta do frontend, execute:

Codigo
npm run build

Isso vai criar uma pasta dist com os arquivos index.html, index.js e index.css. Esses arquivos são os que o servidor vai entregar aos usuários.

Criar a build, pasta dist com os arquivos index.html, index.js e index.css

Dica: Certifique-se de que todas as dependências do frontend estão instaladas com npm install antes do build.

Passo 2: Servir o Frontend de Forma Estática

Como configurar o backend para servir o frontend?

No backend (Node.js com Express), você precisa configurar o servidor para entregar os arquivos estáticos gerados no build do React. Use o middleware express.static para isso.

Exemplo de código no arquivo principal do backend (server.js):

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

app.use(express.static(path.join(__dirname, '../frontend/dist')));

Isso vai fazer com que a pasta dist do frontend seja servida como a rota padrão.

Dica: Use o módulo path do Node.js para criar caminhos corretos entre o backend e a pasta dist.

Passo 3: Criar uma Rota de Redirecionamento

Por que redirecionar rotas não mapeadas?

Em aplicações React, quando o usuário acessa uma rota não mapeada diretamente, o servidor deve redirecionar para o index.html para que o React Router gerencie a navegação.

Adicione esta rota no backend, após todas as outras rotas:

JavaScript
app.get('*', (req, res) => {
  res.sendFile(path.join(__dirname, '../frontend/dist/index.html'));
});

Isso garante que qualquer rota não reconhecida seja redirecionada para o frontend.

Passo 4: Organizar as Rotas da API no Backend

Como evitar conflitos entre rotas do frontend e backend?

Para evitar confusão entre as rotas do frontend e do backend, adicione um prefixo /api a todas as rotas do backend.

Por exemplo:

JavaScript
app.use('/api/users', userRoutes);
app.use('/api/places', placeRoutes);
app.use('/api/bookings', bookingRoutes);

No frontend, atualize as chamadas à API para incluir o prefixo /api. Exemplo:

JavaScript
const baseURL = '/api';
fetch(`${baseURL}/users`);

Dica: Consolidar o baseURL em uma variável facilita futuras alterações.

Passo 5: Diferenciar Ambientes (Development vs. Production)

Como configurar o frontend para diferentes ambientes?

Use variáveis de ambiente para definir a URL da API dependendo do ambiente (desenvolvimento ou produção). No arquivo principal do frontend (App.jsx), configure o baseURL com um operador ternário:

Codigo
const baseURL = import.meta.env.MODE === 'development' 
  ? 'http://localhost:4000/api' 
  : 'https://seu-dominio.com/api';

Isso garante que o frontend se conecte à API correta em cada ambiente.

Ícone Full StackFull Stack Impressionador

Essa é uma trilha de especialização que vai te tornar um verdadeiro Desenvolvedor Web Full Stack, dominando todas as principais tecnologias usadas tanto para o Front End quanto para o Backend e ainda para Mobile, construindo projetos práticos e exercícios aplicados à realidade das empresas. Tudo o que você precisa para se tornar um Desenvolvedor Full Stack em um único lugar.

Começar agoraSeta para a direita
Fundo Full StackTelas Full Stack
Luz Full Stack

Passo 6: Automatizar Build e Start com Scripts

Como preparar o projeto para o deploy?

Crie um arquivo package.json na raiz do projeto para gerenciar os scripts de build e start. Exemplo:

JSON
{
  "scripts": {
    "install-all": "npm install --prefix backend && npm install --prefix frontend",
    "build": "npm run build --prefix frontend",
    "start": "npm run start --prefix backend"
  }
}

Execute os comandos:

  • npm run install-all: Instala dependências do backend e frontend.
  • npm run build: Gera a pasta dist do frontend.
  • npm run start: Inicia o servidor backend.

Passo 7: Criar e Subir o Repositório no GitHub

Como preparar o projeto para o GitHub?

  1. Inicialize um repositório Git na pasta raiz:git init
  2. Adicione todos os arquivos:git add .
  3. Faça o commit inicial:git commit -m "Configurações iniciais para deploy"
  4. Renomeie a branch para main (se necessário):git branch -M main
  5. Vincule ao repositório remoto no GitHub:git remote add origin <URL_DO_REPOSITORIO>
  6. Envie o projeto:git push -u origin main

Dica:

  • Certifique-se de que o repositório é público (ou privado com acesso ao Render).

Passo 8: Configurar o Render para o Deploy

Como configurar o deploy no Render?

  1. Crie uma conta no Render (gratuita).
  2. Crie um novo "Web Service" e conecte ao repositório GitHub.
  3. Configure:
    • Language: Node
    • Branch: main
    • Root Directory: (deixe em branco, pois o package.json está na raiz)
    • Build Command: npm run build
    • Start Command: npm run start
  4. Adicione variáveis de ambiente (ex.: chaves do MongoDB, AWS S3, etc.) no painel do Render.
Configurando o deploy gratuito com render

Passo 9: Atualizar o Frontend com a Nova URL

Como ajustar a URL da API após o deploy?

Após o deploy, o Render fornece uma URL (ex.: https://seu-projeto.onrender.com). Atualize o baseURL no frontend:

JavaScript
const baseURL = import.meta.env.MODE === 'development' 
  ? 'http://localhost:4000/api' 
  : 'https://seu-projeto.onrender.com/api';

Faça um novo commit e push:

JavaScript
git add .
git commit -m "Atualização da base URL"
git push

Passo 10: Deploy Final e Testes

Como garantir que tudo funciona?

  1. No Render, clique em "Deploy latest commit" para atualizar o projeto.
  2. Acesse a URL fornecida pelo Render e teste:
    • Verifique se o frontend carrega corretamente.
    • Teste as chamadas à API (ex.: login, listagem de dados).
    • Confirme a conexão com o banco de dados (MongoDB).

Tabela de Verificação:

FuncionalidadeTesteStatus (verifique e marque
✅ ou ❌)
FrontendPágina inicial carrega corretamente✅/❌
APIChamadas (ex.: /api/users) funcionam✅/❌
Banco de DadosConexão e leitura de dados✅/❌
AutenticaçãoLogin e persistência de sessão✅/❌

Conclusão

Com esses 10 passos, você consegue fazer o deploy de um projeto MERN de forma gratuita e eficiente.

O segredo é organizar bem o frontend e o backend, configurar as rotas corretamente e usar uma plataforma como o Render para simplificar o processo. Agora que seu projeto está online, teste todas as funcionalidades e compartilhe com o mundo!

Próximos passos:

  • Adicione monitoramento de erros no Render.
  • Considere otimizar o desempenho com lazy loading no React.
  • Explore opções de escalabilidade (ex.: planos pagos ou outras plataformas).

Caso prefira esse conteúdo no formato de vídeo-aula, assista ao vídeo abaixo ou acesse o nosso canal do YouTube!

FAQ - Como fazer deploy gratuito

1. O que é necessário para fazer o deploy de um projeto MERN?

Para fazer o deploy de um projeto MERN, você precisa de um projeto com frontend (React) e backend (Node.js/Express) configurados, um banco de dados MongoDB (pode ser gratuito, como o MongoDB Atlas), uma conta no GitHub para hospedar o repositório e uma plataforma de deploy, como o Render. Além disso, certifique-se de ter o Node.js e o npm instalados localmente para rodar os comandos de build e instalação.

2. Posso usar outra plataforma além do Render para o deploy?

Sim! A lógica dos 10 passos pode ser adaptada para outras plataformas, como Heroku, Vercel ou Railway. As principais diferenças estarão nos comandos de build e start, além das configurações de variáveis de ambiente, que variam de acordo com a plataforma escolhida.

3. Por que preciso criar uma pasta dist no frontend?

A pasta dist é gerada pelo comando npm run build no React e contém os arquivos estáticos (HTML, CSS e JavaScript) otimizados para produção. Esses arquivos são necessários para que o servidor consiga servir o frontend de forma eficiente ao usuário final.

4. Como evitar conflitos entre rotas do frontend e do backend?

Para evitar conflitos, adicione um prefixo, como /api, a todas as rotas do backend (ex.: /api/users). Isso separa as rotas do backend das rotas do frontend gerenciadas pelo React Router. No frontend, atualize as chamadas à API para usar esse prefixo.

5. O que fazer se o deploy no Render falhar?

Se o deploy falhar, verifique os logs no painel do Render para identificar o erro. Problemas comuns incluem: variáveis de ambiente ausentes (ex.: conexão com o MongoDB), dependências não instaladas corretamente ou erros nos scripts de build/start no package.json. Certifique-se de que o repositório GitHub está acessível e que os comandos no Render estão corretos.

Hashtag Treinamentos

Para acessar publicações de Full Stack, clique aqui!


Quer aprender mais sobre JavaScript com um minicurso básico gratuito?








Posts mais recentes de Full Stack

Posts mais recentes da Hashtag Treinamentos