1. Lancer gDown

Docker est le chemin le plus court : l'image est signée, tourne sans root et n'a aucun mot de passe par défaut (la commande en crée un dans secrets/admin_password). Installation sur un serveur, cluster et OpenShift : page d'installation.

mkdir gdown && cd gdown
curl -fsSLO https://gdown.gluonify.io/docker/docker-compose.yml
mkdir -p secrets && openssl rand -base64 24 | tr -d '\n' > secrets/admin_password && chmod 644 secrets/admin_password
docker compose up -d && docker compose ps      # wait for "healthy"

2. Une première requête en HTTP

POST /db/{base}/query reçoit un corps JSON : statement et parameters (écrits $name en Cypher). La réponse donne columns, un tableau par ligne, et stats. La base par défaut est neo4j ; l'authentification Basic avec le compte administrateur suffit pour ce premier essai, et le contrat OpenAPI est sur /q/openapi (Swagger UI sur /rest).

PASSWORD="$(cat secrets/admin_password)"
curl -s -u "neo4j:$PASSWORD" -H 'Content-Type: application/json' localhost:8080/db/neo4j/query \
  -d '{"statement":"CREATE (a:Person {name: $name})-[:KNOWS]->(:Person {name: \"Bob\"}) RETURN a.name","parameters":{"name":"Ann"}}'
curl -s -u "neo4j:$PASSWORD" -H 'Content-Type: application/json' localhost:8080/db/neo4j/query \
  -d '{"statement":"MATCH (p:Person)-[:KNOWS]->(f) RETURN p.name, f.name"}'
# {"columns":["p.name","f.name"],"rows":[["Ann","Bob"]],"stats":{...}}

3. Un compte et un jeton pour votre application

Ne livrez pas le mot de passe administrateur. Créez un utilisateur local avec le rôle writer (ou reader), puis un jeton d'API révocable : affiché une seule fois, accepté comme jeton bearer en HTTP, MCP et Bolt, et comme mot de passe de ce même utilisateur dans les pilotes. Exécutez ces instructions dans la console web (http://localhost:8080) ou avec cypher-shell.

CREATE USER app SET PASSWORD 'change-me' CHANGE NOT REQUIRED;
GRANT ROLE writer TO app;
CREATE API TOKEN app_token FOR USER app EXPIRES IN '90d';   -- shown once: gdt_… ; later: SHOW API TOKENS, DROP API TOKEN app_token

4. Java avec le pilote Neo4j officiel

gDown parle Bolt 5.0 à 5.4 : les pilotes officiels fonctionnent tels quels (Java, Python, JavaScript, Go, .NET), comme Neo4j-OGM et Spring Data Neo4j. neo4j:// envoie les écritures au leader et les lectures aux suiveurs ; bolt:// parle à un membre. Les transactions gérées sont réessayées pendant un changement de leader.

Maven

<dependency>
  <groupId>org.neo4j.driver</groupId>
  <artifactId>neo4j-java-driver</artifactId>
  <version>5.28.15</version>
</dependency>

Gradle (DSL Kotlin)

implementation("org.neo4j.driver:neo4j-java-driver:5.28.15")

Java : GDOWN_TOKEN porte le jeton de l'étape 3, jamais écrit dans le code

import org.neo4j.driver.*;
import java.util.Map;

try (Driver driver = GraphDatabase.driver("neo4j://localhost:7687", AuthTokens.basic("app", System.getenv("GDOWN_TOKEN")))) {
    driver.verifyConnectivity();
    try (Session session = driver.session(SessionConfig.forDatabase("neo4j"))) {
        session.executeWrite(tx -> tx.run("CREATE (:Person {name: $n})", Map.of("n", "Ada")).consume());
        var names = session.executeRead(tx -> tx.run("MATCH (p:Person) RETURN p.name AS name ORDER BY name").list(r -> r.get("name").asString()));
        System.out.println(names);
    }
}

5. Python

La même API de pilote depuis Python : le paquet neo4j suffit, avec l'utilisateur et le jeton de l'étape 3.

pip install neo4j
python3 - <<'PY'
import os
from neo4j import GraphDatabase
with GraphDatabase.driver("neo4j://localhost:7687", auth=("app", os.environ["GDOWN_TOKEN"])) as driver:
    driver.verify_connectivity()
    with driver.session(database="neo4j") as s:
        s.execute_write(lambda tx: tx.run("CREATE (:Person {name: $n})", n="Ada").consume())
        print(s.execute_read(lambda tx: [r["name"] for r in tx.run("MATCH (p:Person) RETURN p.name AS name ORDER BY name")]))
PY

Sur la plateforme Gluonify

Une application déployée sur Gluonify ne configure pas gDown. Déclarez gdown dans uses (ou laissez le build le déduire du pilote Neo4j présent sur le chemin de classes d'exécution) : la plateforme injecte GLUONIFY_GDOWN_BOLT_URL et GLUONIFY_GDOWN_CA_FILE avant le démarrage, Bolt sous TLS sur le réseau interne, et le compte vient des secrets de l'application.

gluonify.json (seulement si le pilote n'est pas sur le chemin de classes d'exécution)

{ "uses": ["gdown"] }

Lire les variables injectées (pilote Java)

// On Gluonify, the platform sets GLUONIFY_GDOWN_BOLT_URL (bolt+s://…:7687) and GLUONIFY_GDOWN_CA_FILE (the internal CA, PEM) before start.
Config config = Config.builder().withTrustStrategy(Config.TrustStrategy.trustCustomCertificateSignedBy(new java.io.File(System.getenv("GLUONIFY_GDOWN_CA_FILE")))).build();
Driver driver = GraphDatabase.driver(System.getenv("GLUONIFY_GDOWN_BOLT_URL"), AuthTokens.basic(user, password), config);

Depuis votre poste, la CLI Gluonify vous connecte à votre zone dans le navigateur ; le SDK résout ensuite les services de la plateforme pour une exécution locale.

java -jar gluonify-plasma-cli-0.7.0.jar login <your-zone>   # once, in the browser (PKCE); then: mvn quarkus:dev

Pour continuer

Console web : requêtes, vue du graphe, modèle de données et état du cluster, sur http://localhost:8080.
Assistants IA : le serveur MCP sur /mcp, les index vectoriels et plein texte, et la mémoire de vos dépôts.
Un cluster de trois membres, TLS mutuel, OpenShift et Microsoft Entra ID : la page d'installation.
Ce qui est pris en charge : couverture openCypher, fonctions Bolt et HTTP, limites, sur la page du comparatif.
Documentation de l'image sur Docker Hub : variables, volumes, montées de version, limites.

Ports : 8080 pour HTTP (API, console, Swagger UI) et 7687 pour Bolt. Un jeton ne va jamais dans une URL, un journal ni un dépôt.