Per ospitare un bot Discord4J 24/7 lo fai girare su una macchina sempre accesa: un VPS Linux con un servizio systemd che lo riavvia quando si ferma, oppure un piano bot sull’hosting di bot Discord PlayNHost (da 1,99 US$ al mese), dove carichi un jar eseguibile, incolli il token e premi Avvia. Nel nostro test un bot Discord4J 3.3.3 ha usato circa 126 MB di memoria con Java 21 e ha ricevuto la risposta di Discord 2,6 secondi dopo l’avvio. Discord4J è una libreria, non un programma, quindi prima compili il bot in un jar sul tuo computer. I passaggi su PlayNHost:
- Nella pagina Hosting di bot Discord, clicca su Crea server su un piano. Nella finestra dell’ordine rispondi a Per quale piattaforma è il tuo bot? con Discord e scegli Java.
- Sul tuo computer, compila il bot con il
pom.xmlqui sotto:mvn packagescrivetarget/bot.jar, con Discord4J all’interno. - Apri il tuo server nel pannello. La scheda Configura il tuo bot nella Panoramica si apre su Connetti a Discord. Il primo passaggio, Cosa viene eseguito, dovrebbe indicare Questo bot esegue Java Bot.; clicca su quel passaggio per controllarlo, poi su Continua.
- In Connetti a Discord, incolla il token in Incolla il token del bot, clicca su Connessione e poi su Sì, continua.
- In Permessi, spunta Il mio codice lo usa solo per gli intent privilegiati che richiede il tuo codice (il bot qui sotto non ne richiede nessuno), clicca su Aggiungi a un server Discord e poi su Continua.
- In Il tuo codice, clicca su Carica i file e carica
bot.jarnella cartella principale. - Nella pagina Bot, riquadro Codice, controlla che il File di avvio sia
bot.jare che il Runtime sia Java 21 (recommended), oppure Java 17 o 25. Se cambi il File di avvio, clicca su Salva accanto; un nuovo Runtime viene salvato appena lo scegli. - Clicca su Avvia il bot e guarda la Console. Quando il bot stampa
Logged in as ..., la scheda dice Il tuo bot è online su Discord.
Come creare il bot e il suo token è spiegato in Come creare un bot Discord e ottenere il suo token, e il tipo di bot Java in generale in Come ospitare un bot Discord Java. Questa pagina parla di Discord4J in sé: che cosa usa su un server e che cosa sapere prima di ospitarlo.
Cosa abbiamo misurato
| Libreria | Versione | Memoria dopo l’avvio | Dall’avvio alla risposta di Discord | Dimensione del jar |
|---|---|---|---|---|
| Discord4J | 3.3.3 | 126 MB | 2,6 s | 37 MB |
| JDA | 6.7.0 | 91 MB | 1,5 s | 19 MB |
| Solo Java 21, senza libreria | 21.0.12.1 | 38 MB | nessuna | 0,0 MB |
Come: sul nostro nodo, in un container usa e getta configurato come un piano bot da 1 GB (l’immagine Java 21 e l’esatto comando java del nostro tipo di bot Java), ogni bot ha effettuato l’accesso con un token falso, che Discord ha rifiutato; la memoria è la memoria residente 15 secondi dopo quella risposta, il tempo di avvio va dall’avvio alla risposta e ogni valore è la mediana delle esecuzioni da 2 a 4.
Sono valori minimi: nessun server, nessun membro in cache, ancora nessuna sessione gateway aperta. Il tuo codice e il numero di server in cui si trova il bot si sommano a questi, e lo script di avvio lascia crescere l’heap di Java fino all’80 per cento del piano (vedi sotto). Confronta i numeri con i piani dell’hosting di bot Discord e scegli in base a ciò che fa il tuo bot.
Un bot Discord4J minimo
Registra un comando slash /ping, risponde con Pong!, legge il token da DISCORD_TOKEN (il nome che gli dà il pannello) e stampa una riga di pronto. Non richiede alcun intent privilegiato. Due file:
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);
}
}
}
Compilalo con Maven 3.9 e un JDK 17 o più recente:
mvn package
java -jar target/bot.jar
La seconda riga è un test sul tuo computer: senza token stampa No DISCORD_TOKEN found. e si ferma, il che dimostra che il jar parte e trova la classe principale. Carica target/bot.jar. Il jar-with-dependencies del maven-assembly-plugin mette Discord4J e tutto ciò che gli serve in quell’unico jar; con Gradle si ottiene lo stesso con il plugin Shadow. maven.compiler.release 17 produce un jar che funziona su tutte e tre le versioni di Java offerte dal pannello.
La riga Logged in as ... è quella che porta l’indicatore in Panoramica su Online su Discord. Invita il bot con Aggiungi a un server Discord prima di provare /ping: Come invitare il tuo bot Discord in un server.
Se il token è sbagliato
Nel nostro test, con un token falso, il login di Discord4J è fallito con questo errore:
ClientException: GET /gateway/bot returned 401 Unauthorized with response {code=0, message=401: Unauthorized}
Il bot qui sopra intercetta un token rifiutato (HTTP 401) e stampa Discord did not accept the bot token. Copy it again (Developer Portal, Bot, Reset Token), paste it on the Bot page, then restart. invece di uno stack trace, poi si ferma con codice di uscita 1. Quando lo abbiamo eseguito con un token falso, sono comparse prima tre righe di avviso SLF4J:, la prima inizia con SLF4J: Failed to load class "org.slf4j.impl.StaticLoggerBinder".; riguardano il logging, non il token (vedi Log più avanti). Per risolvere, apri il Discord Developer Portal, la tua applicazione, Bot, e clicca su Reset Token; Discord mostra il nuovo token una sola volta. Nella nostra pagina Bot, riquadro Discord, clicca su Sostituisci il token, incollalo, clicca su Salva il token e poi su Riavvia ora. Quando Discord rifiuta la verifica del token salvato, il riquadro mostra Discord non l’ha accettato.
Cosa sapere su Discord4J su un server
- Versioni: Discord4J 3.3.3 è uscito il 19 agosto 2026. La linea 3.3 è quella attuale e la 3.2 riceve solo manutenzione. Discord4J 3.3.3 è compilato per Java 8, quindi qualsiasi Runtime offerto dal pannello (Java 17, 21 o 25) lo esegue; compila con un
releasenon più recente del runtime scelto. - Un solo jar, niente installato sul server. Il tipo di bot Java non ha una sorgente Git né il campo Pacchetti: avvia
java -jarsul tuo File di avvio, quindi tutto ciò che il bot usa deve stare nel jar. Per aggiornare il bot carica un nuovo jar. - Limite di memoria: lo script di avvio esegue Java con
-XX:MaxRAMPercentage=80.0e il garbage collector G1, quindi l’heap può usare fino all’80 per cento della memoria del piano e al resto del processo resta spazio. Se l’heap si riempie, Java stampajava.lang.OutOfMemoryErrore il pannello mostra Il tuo bot ha esaurito la memoria. - Intent: Discord4J si connette con tutti gli intent non privilegiati, a meno che tu non ne scelga altri. L’esempio
!pingnel README di Discord4J legge il testo dei messaggi, cosa che richiede l’intent privilegiato Message Content: attivalo nel Developer Portal, richiedilo nel codice conDiscordClient.create(token).gateway().setEnabledIntents(IntentSet.nonPrivileged().or(IntentSet.of(Intent.MESSAGE_CONTENT)))e spunta Il mio codice lo usa per lui nel nostro passaggio Permessi. Senza, Discord invia al bot il testo del messaggio vuoto, tranne nei messaggi diretti e nei messaggi che menzionano il bot. Un comando slash, come sopra, non richiede nulla di tutto ciò. Vedi Risolvi "Used disallowed intents" sul tuo bot Discord. - Log: Discord4J registra tramite Reactor, che usa SLF4J quando SLF4J è nel jar, e Discord4J si porta dietro SLF4J. Senza una libreria di logging dietro, come nel
pom.xmlqui sopra, SLF4J stampa tre righe di avviso all’avvio, l’ultimaSLF4J: See http://www.slf4j.org/codes.html#StaticLoggerBinder for further details., e poi scarta le righe di log di Discord4J, errori compresi. Le tue righeSystem.outcompaiono comunque nella Console. Per vedere le righe di Discord4J, aggiungi una libreria di logging; la documentazione di Discord4J consiglia Logback. - Tieni
main()in attesa. Discord4J è reattivo: il suo login è unMonoche si connette quando qualcosa lo sottoscrive. Gli esempi del suo README chiudonomain()congateway.onDisconnect().block()o conblock()suwithGateway(...), che attendono finché il bot è connesso. Il bot qui sopra usawithGateway(...).block(). - Registrare i comandi a ogni avvio va bene. Discord tratta la creazione di un comando con un nome che la tua applicazione usa già come un aggiornamento di quel comando, quindi il bot qui sopra non accumula copie di
/ping. - Arresti anomali: quando il bot termina, come fa quello qui sopra con un token rifiutato, il pannello lo riavvia subito. Se si ferma di nuovo entro un minuto, resta fermo e la Console ne spiega il motivo.
Ospitarlo da solo su un VPS Linux
Un VPS ha bisogno solo di un runtime Java, perché il jar lo compili sul tuo computer. Su Debian 13 o Ubuntu 24.04 installa Java 21; Debian 12 include Java 17, che esegue anche il jar qui sopra:
sudo apt update
sudo apt install openjdk-21-jre-headless
java -version
Crea un utente per il bot e copia il jar sul server (per esempio con scp), poi nella sua cartella:
sudo useradd --system --create-home --home-dir /opt/mybot mybot
sudo cp bot.jar /opt/mybot/
sudo chown -R mybot: /opt/mybot
Tieni il token fuori dal codice, in un file che solo root può leggere:
sudo sh -c 'echo "DISCORD_TOKEN=your-token" > /etc/mybot.env'
sudo chmod 600 /etc/mybot.env
Crea /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
Avvialo subito e a ogni boot, poi segui il suo output:
sudo systemctl daemon-reload
sudo systemctl enable --now mybot
sudo journalctl -u mybot -f
Restart=always riavvia il bot 5 secondi dopo che termina o va in crash, ma non dopo che lo fermi con systemctl stop. Su un VPS, -XX:MaxRAMPercentage è una quota della memoria dell’intera macchina, quindi abbassalo se ci girano altri programmi. Per aggiornare, copia il nuovo jar sopra il vecchio ed esegui sudo systemctl restart mybot.
Self-hosting o piano bot
Su un VPS che gestisci tu ti occupi di:
- Aggiornamenti e sicurezza del sistema operativo e aggiornamenti di Java.
- Copiare ogni nuovo jar, il file del servizio, il file del token e i suoi permessi.
- Leggere
journalctlper capire perché il bot si è fermato. - I backup di tutto ciò che il bot salva.
In cambio, un VPS esegue qualsiasi cosa ci installi.
Su un piano bot PlayNHost ci pensa il pannello:
- Java 17, 21 o 25 da un selettore, con limite dell’heap e garbage collector già impostati.
- Il token, verificato con Discord prima di essere salvato, conservato cifrato e passato al tuo codice come
DISCORD_TOKEN. - Un link di invito con i permessi che scegli e una scheda Intent privilegiati che controlla quali sono attivi nel tuo Developer Portal.
- Il riavvio del bot dopo un crash e un banner sopra la Console quando esaurisce la memoria.
- Caricamento dal browser e backup dal pannello.
Domande frequenti
Il mio bot Discord4J è online ma !ping non fa nulla. Perché?
Perché il testo del messaggio è vuoto. Discord4J richiede per impostazione predefinita solo intent non privilegiati, e leggere il testo dei messaggi nei server richiede Message Content, un intent privilegiato. Attivalo nel Developer Portal e richiedilo con setEnabledIntents come mostrato sopra, oppure usa un comando slash come /ping nel bot di questa pagina, che non richiede alcun intent privilegiato.
Discord4J o JDA su PlayNHost?
Entrambi girano sullo stesso tipo di bot Java, dallo stesso tipo di jar. La tabella qui sopra riporta la memoria che abbiamo misurato per ciascuno. La vera differenza è lo stile: Discord4J è basato su Reactor, quindi concateni Mono e Flux, mentre JDA usa listener e callback. Scegli quello il cui codice ti sembra più leggibile. Passaggi per JDA: Come ospitare un bot Discord Java.
Quale versione di Java scegliere per Discord4J?
Java 21, quella consigliata, a meno che il tuo codice non richieda 25. Discord4J in sé funziona da Java 8 in su, quindi il limite è il release con cui compili: un jar compilato per un Java più recente di quello del server si ferma con UnsupportedClassVersionError. Scegli un Runtime più recente, oppure compila con un release più basso.
Perché il mio jar di Discord4J è così grande?
Perché contiene tutto: Discord4J porta con sé Reactor, Netty, Jackson e i propri moduli vocali, e la build jar-with-dependencies li impacchetta tutti. Il jar nel nostro test era di 37 MB. È spazio su disco del tuo piano; la memoria usata dal bot in esecuzione è nella tabella qui sopra.
Pronto a tenere il tuo bot Discord4J sempre acceso? Guarda i piani dell’hosting di bot Discord.



