NOVO 📢 Black Friday: a oferta de lançamento termina em 30/11. Até 70% de desconto no seu primeiro mês!Ver planos
Black FridayAté 70% de desconto no seu primeiro mês, termina em 30/11Termina em 9 d 02 h 49 minBlack FridayAté 70% de desconto no seu primeiro mês, termina em 30/11Termina em 9 d 02 h 49 minBlack FridayAté 70% de desconto no seu primeiro mês, termina em 30/11Termina em 9 d 02 h 49 min

Como hospedar um bot Discord4J 24/7

Hospedagem de bot do DiscordAtualizado 6/11/202613 min de leitura

Para hospedar um bot Discord4J 24/7, você o executa em uma máquina que fica sempre ligada: uma VPS Linux com um serviço systemd que o inicia de novo quando ele para, ou um plano de bots na hospedagem de bots Discord da PlayNHost (a partir de US$1,99 por mês), onde você envia um jar executável, cola o token e clica em Iniciar. No nosso teste, um bot Discord4J 3.3.3 usou cerca de 126 MB de memória no Java 21 e recebeu a resposta do Discord 2,6 segundos depois de ser iniciado. O Discord4J é uma biblioteca, não um programa, então você primeiro compila seu bot em um jar no seu próprio computador. Os passos na PlayNHost:

  1. Na página Hospedagem de bots Discord, clique em Criar servidor em um plano. Na janela do pedido, responda Para qual plataforma é o seu bot? com Discord e escolha Java.
  2. No seu computador, compile o bot com o pom.xml abaixo: mvn package grava target/bot.jar, com o Discord4J dentro.
  3. Abra seu servidor no painel. O cartão Configurar seu bot na Visão geral abre em Conectar ao Discord. O primeiro passo, O que roda, deve dizer Este bot roda Java Bot.; clique nesse passo para conferir e depois em Continuar.
  4. Em Conectar ao Discord, cole seu token em Cole o token do seu bot, clique em Conectar e depois em Sim, continuar.
  5. Em Permissões, marque Meu código usa isto só para os intents privilegiados que seu código pede (o bot abaixo não precisa de nenhum), clique em Adicionar a um servidor do Discord e depois em Continuar.
  6. Em Seu código, clique em Enviar arquivos e envie bot.jar para a pasta principal.
  7. Na página Bot, painel Código, confira se o Arquivo de entrada é bot.jar e se o Runtime é Java 21 (recommended), ou Java 17 ou 25. Se você mudar o Arquivo de entrada, clique em Salvar ao lado dele; um novo Runtime é salvo assim que você o escolhe.
  8. Clique em Iniciar bot e acompanhe o Console. Quando seu bot imprimir Logged in as ..., o cartão mostra Seu bot está online no Discord.

Como criar o bot e o token dele está em Como criar um bot do Discord e obter o token, e o tipo de bot Java em geral em Como hospedar um bot do Discord em Java. Esta página trata do próprio Discord4J: o que ele usa em um servidor e o que saber antes de hospedá-lo.

O que medimos

BibliotecaVersãoMemória após iniciarDo início à resposta do DiscordTamanho do jar
Discord4J3.3.3126 MB2,6 s37 MB
JDA6.7.091 MB1,5 s19 MB
Só o Java 21, sem biblioteca21.0.12.138 MBnenhuma0,0 MB

Como: no nosso próprio nó, em um contêiner descartável configurado como um plano de bots de 1 GB (a imagem do Java 21 e o comando java exato do nosso tipo de bot Java), cada bot fez login com um token falso, que o Discord recusou; a memória é a memória residente 15 segundos depois dessa resposta, o tempo de início vai do lançamento até a resposta e cada valor é a mediana das execuções 2 a 4.

Esses são valores mínimos: sem servidores, sem membros em cache, ainda sem sessão de gateway aberta. Seu próprio código e o número de servidores em que seu bot está se somam a eles, e o script de início deixa o heap do Java crescer até 80 por cento do plano (veja abaixo). Compare os números com os planos da hospedagem de bots Discord e escolha pelo que seu bot faz.

Um bot Discord4J mínimo

Ele registra um comando slash /ping, responde com Pong!, lê o token de DISCORD_TOKEN (o nome que o painel dá a ele) e imprime uma linha de pronto. Não precisa de nenhum intent privilegiado. Dois arquivos:

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.example</groupId>
  <artifactId>bot</artifactId>
  <version>1.0</version>
  <properties>
    <maven.compiler.release>17</maven.compiler.release>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>
  <dependencies>
    <dependency>
      <groupId>com.discord4j</groupId>
      <artifactId>discord4j-core</artifactId>
      <version>3.3.3</version>
    </dependency>
  </dependencies>
  <build>
    <finalName>bot</finalName>
    <plugins>
      <plugin>
        <artifactId>maven-assembly-plugin</artifactId>
        <version>3.7.1</version>
        <configuration>
          <descriptorRefs>
            <descriptorRef>jar-with-dependencies</descriptorRef>
          </descriptorRefs>
          <appendAssemblyId>false</appendAssemblyId>
          <archive>
            <manifest>
              <mainClass>Bot</mainClass>
            </manifest>
          </archive>
        </configuration>
        <executions>
          <execution>
            <phase>package</phase>
            <goals>
              <goal>single</goal>
            </goals>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>
</project>

src/main/java/Bot.java

import discord4j.core.DiscordClient;
import discord4j.core.event.domain.interaction.ChatInputInteractionEvent;
import discord4j.core.event.domain.lifecycle.ReadyEvent;
import discord4j.discordjson.json.ApplicationCommandRequest;
import discord4j.rest.http.client.ClientException;
import reactor.core.publisher.Mono;

public class Bot {
    public static void main(String[] args) {
        String token = System.getenv("DISCORD_TOKEN");
        if (token == null || token.isBlank()) {
            System.out.println("No DISCORD_TOKEN found. Paste your bot token on the Bot page, then restart.");
            System.exit(1);
        }

        ApplicationCommandRequest ping = ApplicationCommandRequest.builder()
                .name("ping")
                .description("Replies with Pong!")
                .build();

        try {
            DiscordClient.create(token).withGateway(gateway -> {
                // Creating a command that already exists updates it, so this is safe on every start.
                Mono<Void> register = gateway.getRestClient().getApplicationId()
                        .flatMap(appId -> gateway.getRestClient().getApplicationService()
                                .createGlobalApplicationCommand(appId, ping))
                        .then();

                Mono<Void> ready = gateway.on(ReadyEvent.class, event -> Mono.fromRunnable(() ->
                        System.out.println("Logged in as " + event.getSelf().getUsername())))
                        .then();

                Mono<Void> commands = gateway.on(ChatInputInteractionEvent.class, event -> {
                    if (event.getCommandName().equals("ping")) {
                        return event.reply("Pong!");
                    }
                    return Mono.empty();
                }).then();

                return register.and(ready).and(commands);
            }).block();
        } catch (RuntimeException e) {
            if (ClientException.isStatusCode(401).test(e)) {
                System.out.println("Discord did not accept the bot token. Copy it again (Developer Portal, Bot, Reset Token), paste it on the Bot page, then restart.");
            } else {
                e.printStackTrace();
            }
            System.exit(1);
        }
    }
}

Compile com o Maven 3.9 e um JDK 17 ou mais novo:

mvn package
java -jar target/bot.jar

A segunda linha é um teste no seu computador: sem token, ela imprime No DISCORD_TOKEN found. e para, o que prova que o jar inicia e encontra a classe principal. Envie target/bot.jar. O jar-with-dependencies do maven-assembly-plugin coloca o Discord4J e tudo de que ele precisa nesse único jar; no Gradle, o plugin Shadow faz o mesmo. maven.compiler.release 17 gera um jar que roda nas três versões do Java que o painel oferece.

A linha Logged in as ... é a que muda o indicador em Visão geral para Online no Discord. Convide o bot com Adicionar a um servidor do Discord antes de testar /ping: Como convidar seu bot do Discord para um servidor.

Se o token estiver errado

No nosso teste, com um token falso, o login do Discord4J falhou com este erro:

ClientException: GET /gateway/bot returned 401 Unauthorized with response {code=0, message=401: Unauthorized}

O bot acima captura um token recusado (HTTP 401) e imprime Discord did not accept the bot token. Copy it again (Developer Portal, Bot, Reset Token), paste it on the Bot page, then restart. em vez de um stack trace, e então para com o código de saída 1. Quando o executamos com um token falso, três linhas de aviso SLF4J: vieram primeiro, a primeira começando com SLF4J: Failed to load class "org.slf4j.impl.StaticLoggerBinder".; elas são sobre logging, não sobre o token (veja Logs abaixo). Para corrigir, abra o Discord Developer Portal, sua aplicação, Bot, e clique em Reset Token; o Discord mostra o novo token uma única vez. Na nossa página Bot, painel Discord, clique em Substituir token, cole-o, clique em Salvar token e depois em Reiniciar agora. Quando o Discord recusa a verificação do token salvo, o painel mostra O Discord não aceitou.

O que saber sobre o Discord4J em um servidor

  • Versões: o Discord4J 3.3.3 saiu em 19 de agosto de 2026. A linha 3.3 é a atual e a 3.2 recebe só manutenção. O Discord4J 3.3.3 é compilado para o Java 8, então qualquer Runtime que o painel oferece (Java 17, 21 ou 25) o executa; compile com um release não mais novo que o runtime escolhido.
  • Um jar, nada instalado no servidor. O tipo de bot Java não tem origem Git nem campo Pacotes: ele inicia java -jar no seu Arquivo de entrada, então tudo que seu bot usa precisa estar dentro do jar. Para atualizar o bot, envie um jar novo.
  • Limite de memória: o script de início executa o Java com -XX:MaxRAMPercentage=80.0 e o coletor de lixo G1, então o heap pode usar até 80 por cento da memória do seu plano e o resto do processo tem espaço. Se o heap encher, o Java imprime java.lang.OutOfMemoryError e o painel mostra Seu bot ficou sem memória.
  • Intents: o Discord4J conecta com todos os intents não privilegiados, a menos que você escolha outros. O exemplo !ping do README do Discord4J lê o texto das mensagens, o que exige o intent privilegiado Message Content: ative-o no Developer Portal, peça-o no código com DiscordClient.create(token).gateway().setEnabledIntents(IntentSet.nonPrivileged().or(IntentSet.of(Intent.MESSAGE_CONTENT))) e marque Meu código usa isto para ele na nossa etapa Permissões. Sem ele, o Discord envia ao bot o texto da mensagem vazio, exceto em mensagens diretas e em mensagens que mencionam o bot. Um comando slash, como acima, não precisa de nada disso. Veja Corrigir "Used disallowed intents" no seu bot do Discord.
  • Logs: o Discord4J registra logs pelo Reactor, que usa o SLF4J quando o SLF4J está no jar, e o Discord4J traz o SLF4J junto. Sem uma biblioteca de logging por trás, como no pom.xml acima, o SLF4J imprime três linhas de aviso ao iniciar, a última SLF4J: See http://www.slf4j.org/codes.html#StaticLoggerBinder for further details., e depois descarta as linhas de log do próprio Discord4J, erros incluídos. Suas linhas System.out continuam aparecendo no Console. Para ver as linhas do Discord4J, adicione uma biblioteca de logging; a documentação do Discord4J recomenda o Logback.
  • Faça o main() esperar. O Discord4J é reativo: o login dele é um Mono que só conecta quando algo se inscreve nele. Os exemplos do README terminam o main() com gateway.onDisconnect().block() ou com block() em withGateway(...), que esperam enquanto o bot está conectado. O bot acima usa withGateway(...).block().
  • Registrar comandos a cada início não tem problema. O Discord trata a criação de um comando com um nome que sua aplicação já usa como uma atualização desse comando, então o bot acima não acumula cópias de /ping.
  • Falhas: quando o bot encerra, como o bot acima faz com um token recusado, o painel o inicia de novo na hora. Se ele parar outra vez dentro de um minuto, fica parado e o Console diz o motivo.

Hospede você mesmo em uma VPS Linux

Uma VPS precisa só de um runtime Java, porque você compila o jar no seu próprio computador. No Debian 13 ou Ubuntu 24.04, instale o Java 21; o Debian 12 traz o Java 17, que também executa o jar acima:

sudo apt update
sudo apt install openjdk-21-jre-headless
java -version

Crie um usuário para o bot e copie o jar para o servidor (por exemplo com scp), depois para a pasta dele:

sudo useradd --system --create-home --home-dir /opt/mybot mybot
sudo cp bot.jar /opt/mybot/
sudo chown -R mybot: /opt/mybot

Mantenha o token fora do seu código, em um arquivo que só o root consegue ler:

sudo sh -c 'echo "DISCORD_TOKEN=your-token" > /etc/mybot.env'
sudo chmod 600 /etc/mybot.env

Crie /etc/systemd/system/mybot.service:

[Unit]
Description=Discord4J bot
Wants=network-online.target
After=network-online.target

[Service]
User=mybot
WorkingDirectory=/opt/mybot
EnvironmentFile=/etc/mybot.env
ExecStart=/usr/bin/java -XX:MaxRAMPercentage=80.0 -jar /opt/mybot/bot.jar
Restart=always
RestartSec=5

[Install]
WantedBy=multi-user.target

Inicie-o agora e a cada boot, depois acompanhe a saída:

sudo systemctl daemon-reload
sudo systemctl enable --now mybot
sudo journalctl -u mybot -f

Restart=always inicia o bot de novo 5 segundos depois que ele encerra ou cai, mas não depois que você o para com systemctl stop. Em uma VPS, -XX:MaxRAMPercentage é uma fração da memória da máquina inteira, então reduza-o se outros programas rodarem lá. Para atualizar, copie o jar novo sobre o antigo e execute sudo systemctl restart mybot.

Hospedar por conta própria ou usar um plano de bots

Em uma VPS que você mesmo gerencia, cabe a você cuidar de:

  • Atualizações e segurança do sistema operacional, e atualizações do Java.
  • Copiar cada jar novo, o arquivo de serviço, o arquivo do token e as permissões dele.
  • Ler o journalctl para descobrir por que o bot parou.
  • Backups de tudo que seu bot guarda.

Em troca, uma VPS executa qualquer coisa que você instalar nela.

Em um plano de bots da PlayNHost, o painel faz isso por você:

  • Java 17, 21 ou 25 em um seletor, com o limite do heap e o coletor de lixo já definidos.
  • O token, verificado no Discord antes de ser salvo, guardado criptografado e entregue ao seu código como DISCORD_TOKEN.
  • Um link de convite com as permissões que você escolher e um cartão Intents privilegiados que confere quais estão ativados no seu Developer Portal.
  • Iniciar o bot de novo após uma falha e um aviso acima do Console quando a memória acaba.
  • Envio pelo navegador e backups pelo painel.

Perguntas frequentes

Meu bot Discord4J está online, mas !ping não faz nada. Por quê?

Porque o texto da mensagem está vazio. O Discord4J pede só intents não privilegiados por padrão, e ler o texto das mensagens em servidores exige Message Content, um intent privilegiado. Ative-o no Developer Portal e peça-o com setEnabledIntents como mostrado acima, ou use um comando slash como /ping no bot desta página, que não precisa de intent privilegiado.

Discord4J ou JDA na PlayNHost?

Os dois rodam no mesmo tipo de bot Java, a partir do mesmo tipo de jar. A tabela acima traz a memória que medimos para cada um. A diferença real é o estilo: o Discord4J é baseado no Reactor, então você encadeia Mono e Flux, enquanto o JDA usa listeners e callbacks. Escolha aquele cujo código você acha mais fácil de ler. Passos para o JDA: Como hospedar um bot do Discord em Java.

Qual versão do Java devo escolher para o Discord4J?

Java 21, a recomendada, a menos que seu próprio código precise do 25. O Discord4J em si funciona a partir do Java 8, então o limite é o release com que você compila: um jar compilado para um Java mais novo que o do servidor para com UnsupportedClassVersionError. Escolha um Runtime mais novo ou compile com um release menor.

Por que meu jar do Discord4J é tão grande?

Porque ele contém tudo: o Discord4J traz o Reactor, o Netty, o Jackson e os próprios módulos de voz, e a compilação com jar-with-dependencies empacota todos. O jar do nosso teste tinha 37 MB. Isso é espaço em disco do seu plano; a memória que o bot em execução usou está na tabela acima.

Pronto para manter seu bot Discord4J no ar o tempo todo? Veja os planos da hospedagem de bots Discord.

Seu bot já está em outro lugar? Traga-o para nós

NOSSOS ÚLTIMOS ARTIGOS