Deploy com render

#Java
#Spring
#Docker
#PostgreSQL
#Cloud

Você está dando os primeiros passos no mundo do desenvolvimento backend com Java e Spring? Já criou algo incrível localmente e quer mostrar seu potencial? Deployar sua aplicação pode parecer um bicho de sete cabeças, mas com o Render e este guia simplificado, você verá como é mais fácil do que imagina! Vamos juntos colocar sua aplicação Java Spring Boot, com banco de dados PostgreSQL (tudo gratuito!), rodando na nuvem para que qualquer pessoa possa acessar. Prepare-se para ver seu backend ganhar vida!

Pré-requisitos:

Conhecimentos básicos de Java e Spring Boot: Uma compreensão fundamental de como criar e executar uma aplicação Spring Boot.
Familiaridade com PostgreSQL (conceitos básicos): Entendimento de como bancos de dados relacionais funcionam, mesmo que a experiência prática seja limitada.
Conta gratuita no Render: Uma conta ativa na plataforma Render (https://render.com/). é grátis criar e super rápido.
Projeto Java Spring Boot com dependência do PostgreSQL: Sua aplicação já deve estar configurada para interagir com um banco de dados PostgreSQL (mesmo que atualmente esteja configurada para rodar localmente)
Código da aplicação em um repositório Git: Seu projeto deve estar hospedado em um serviço como GitHub, GitLab ou Bitbucket. O Render se conecta ao seu repositório para fazer o deploy.

Configurando o PostgreSQL no Render:

Uma das grandes vantagens do Render é a facilidade com que você pode provisionar um banco de dados PostgreSQL totalmente gerenciado, sem se preocupar com configurações complexas. Veja como criar seu banco de dados gratuito (na camada gratuita do Render) e obter as informações de conexão, lembrando por se tratar de um sistema gratuito ele da um limite de memoria diária, então cuidado quando for aplicar algo mais complexo:

Acesse o Painel do Render:

Faça login na sua conta Render através do site https://render.com/.
Você será direcionado ao seu dashboard, onde poderá visualizar seus serviços existentes.

Crie um Novo Banco de Dados:

No canto superior direito do dashboard, clique no botão "New +".
No menu dropdown, selecione a opção "PostgreSQL".

Escolha as Configurações:

Nome: Dê um nome amigável ao seu banco de dados (por exemplo, meu-projeto-db). Este nome é para sua organização interna no Render.
Região: Selecione a região que melhor atende aos seus usuários. Geralmente, escolher uma região mais próxima deles pode reduzir a latência. Recomendo: US East.
Plano: Para este guia focado na camada gratuita, o plano "Free" será selecionado por padrão (ou escolha-o se houver outras opções). Fique atento às limitações do plano gratuito, como tamanho do banco de dados e recursos.

Aguarde a Criação:

Após configurar as opções, clique em "Create Database".
O Render provisionará automaticamente sua instância do PostgreSQL. Este processo pode levar alguns minutos. Você poderá acompanhar o status na tela.

Obtenha as Credenciais de Conexão:

Assim que o banco de dados for criado com sucesso, clique no nome do seu banco de dados na lista de serviços.
Na página de detalhes do seu banco de dados PostgreSQL, você encontrará a seção "Connection Details".
Aqui, o Render fornecerá as seguintes informações importantes: Host: O endereço do servidor PostgreSQL. Port: A porta de comunicação do PostgreSQL (geralmente 5432).
Database: O nome do banco de dados padrão (geralmente o mesmo nome que você escolheu).
User: O nome do usuário padrão para acesso ao banco de dados (geralmente render).
Password: A senha para o usuário padrão.
Database URL: Uma string de conexão completa que combina todas as informações acima. Essa é a forma mais comum de configurar a conexão no Spring Boot.

DICA: A conexão com banco de dados é gerado com variáveis de ambiente, então sempre Procure usa-las na sua aplicação.

Importante: Guarde essas informações de conexão em um local seguro. Você precisará delas para configurar sua aplicação Spring Boot para se conectar ao banco de dados no Render.

Com esses passos, você terá um banco de dados PostgreSQL rodando no Render, pronto para ser utilizado pela sua aplicação Spring Boot. No próximo passo, vamos configurar o deploy da sua aplicação web.

Configurando o Deploy da Aplicação Spring Boot no Render:

Crie um Novo Serviço Web:

No canto superior direito, clique em "New +".
Desta vez, selecione a opção "Web Service".

Conecte ao seu Repositório:

O Render perguntará onde está hospedado o código da sua aplicação. Selecione o serviço onde seu repositório Git está localizado (GitHub, GitLab ou Bitbucket).
Você pode ser solicitado a autorizar o Render a acessar sua conta nesse serviço. Siga as instruções para conceder as permissões necessárias.

Selecione o Repositório e Branch:

Após a conexão, você verá uma lista dos seus repositórios. Encontre e selecione o repositório do seu projeto Spring Boot.
Escolha o branch que você deseja fazer o deploy (geralmente a main ou master).

Configure os Detalhes do Serviço Web:

Nome: Escolha um nome para sua aplicação web no Render (por exemplo, meu-projeto-web). Este será o nome visível no seu dashboard do Render e fará parte da URL padrão da sua aplicação (se você não configurar um domínio personalizado).
Região: Selecione a mesma região que você escolheu para o seu banco de dados PostgreSQL para minimizar a latência entre a aplicação e o banco.
Environment: No dropdown de "Environment", selecione "Java". Isso informará ao Render que se trata de uma aplicação Java.

Crie um Dockerfile:

é importante configurar p Dockerfile na sua aplicação Spring, para o sistema do render poder reconhecer a aplicação sem erros futuros.

Na raiz do seu projeto Spring Boot, crie um arquivo chamado Dockerfile (sem extensão).
Adicione as seguintes instruções básicas (você pode precisar adaptá-las dependendo da sua configuração):

# Use uma imagem base com Java (escolha a versão adequada)

FROM openjdk:17-jdk-slim

# Defina o diretório de trabalho dentro do container

WORKDIR /app

# Copie o arquivo JAR construído (certifique-se de ajustar o nome)

COPY target/*.jar app.jar

# Exponha a porta que sua aplicação Spring Boot utiliza (geralmente 8080)

EXPOSE 8080

# Comando para executar a aplicação

ENTRYPOINT ["java", "-jar", "app.jar"]

Exemplo de uma aplicação:

Defina os Comandos de Build e Start: Esta é uma parte crucial para que o Render saiba como construir e executar sua aplicação. Os comandos variam dependendo do seu sistema de build (Maven ou Gradle) execute isso no terminal da sua aplicação Local:

Build Command: Para projetos Maven: Digite mvn clean package -DskipTests. Este comando limpa o projeto, compila o código, executa os testes (o -DskipTests opcionalmente pula os testes para um deploy mais rápido, mas em produção é recomendado removê-lo) e cria o arquivo JAR na pasta target. Para projetos Gradle: Digite ./gradlew clean build -x test. Similar ao Maven, este comando limpa, compila e builda o projeto, colocando o JAR na pasta build/libs.
Start Command: Este comando instrui o Render a executar o arquivo JAR gerado pelo build. Geralmente, você pode usar algo como: java -jar target/*.jar (para Maven) - O *.jar garante que ele execute o arquivo JAR gerado. java -jar build/libs/*.jar (para Gradle) - Similarmente, executa o JAR gerado pelo Gradle.

Configure as Variáveis de Ambiente: Aqui é onde você conecta sua aplicação ao banco de dados PostgreSQL no Render. A boa notícia é que o Render geralmente configura a variável de ambiente DATABASE_URL automaticamente para o seu serviço web, se ele estiver na mesma conta e região do seu banco de dados PostgreSQL. O Spring Boot pode muitas vezes ler essa variável diretamente.

Verifique as Variáveis: Após criar o serviço web (ou mesmo durante a configuração), procure pela seção "Environment Variables". Você deverá ver a variável DATABASE_URL listada.
Outras Variáveis: Se sua aplicação precisar de outras variáveis de ambiente (como chaves de API, configurações específicas de produção), você pode adicioná-las aqui usando o formato KEY=VALUE.

Como configurar:

Vá até a parte escrita "Environment" : Coloque as variáveis que estão na sua aplicação na pasta "appliaction. properties" que esta em conexão com o postgresql

application.properties

variáveis de ambiente no Render. lembrando que TODOS os valores estão disponíveis no seu Banco Postgresql criado no Render

DICA Configuração da DATABASE_URL: use o seguinte Value no URL, substituindo pelos dados do seu banco Postegresql do Render.

jdbc:postgresql://(Hostname):(Port)/(Database)

Só substituir os valores pelos valores do seu Banco no Render

Clique em "Create Web Service": Após preencher todas as configurações, clique neste botão para iniciar o processo de deploy, e pronto sua aplicação estará rodando no Render, Parabéns.

O Render agora irá buscar seu código do repositório, executar o comando de build e, se tudo correr bem, iniciar sua aplicação Spring Boot. Você poderá acompanhar o progresso na página do seu serviço web no painel do Render.

Conclusão:

"Deployar sua aplicação Java Spring Boot com PostgreSQL no Render é um processo acessível e, com a camada gratuita, uma ótima maneira de começar. Esperamos que este guia tenha desmistificado o processo e o encoraje a colocar seus projetos online. Compartilhe suas experiências e dúvidas nos comentários! E não se esqueça de conectar para mais dicas e tutoriais sobre desenvolvimento Java e Spring."

Gostaria de agradecer a @danieleleaoevangelista pela aula inspiradora sobre deploy no Render, que foi fundamental para a criação deste guia. Se você quiser se aprofundar no assunto, confira a aula aqui: https://www.youtube.com/watch?v=fwWvgk_SW2g.

Qualquer duvida só chamar, minha redes:

Github : https://github.com/JonasSMendes

Linkedin: https://www.linkedin.com/in/jonassmendes/