1. gDown starten

Docker ist der kürzeste Weg: das Image ist signiert, läuft ohne root und hat kein Standardpasswort (der Befehl erzeugt eines in secrets/admin_password). Installation auf einem Server, Cluster und OpenShift: Installationsseite.

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. Eine erste Abfrage über HTTP

POST /db/{datenbank}/query nimmt einen JSON-Body: statement und parameters (in Cypher als $name geschrieben). Die Antwort liefert columns, ein Array pro Zeile, und stats. Die Standarddatenbank ist neo4j; Basic-Authentifizierung mit dem Administratorkonto reicht für diesen ersten Versuch, und der OpenAPI-Vertrag liegt unter /q/openapi (Swagger UI unter /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. Ein Konto und ein Token für Ihre Anwendung

Liefern Sie das Administratorpasswort nicht aus. Legen Sie einen lokalen Benutzer mit der Rolle writer (oder reader) an, dann ein widerrufbares API-Token: es wird einmal angezeigt, gilt als Bearer-Token über HTTP, MCP und Bolt und als Passwort desselben Benutzers in den Treibern. Führen Sie diese Anweisungen in der Web-Konsole (http://localhost:8080) oder mit cypher-shell aus.

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 mit dem offiziellen Neo4j-Treiber

gDown spricht Bolt 5.0 bis 5.4: die offiziellen Treiber funktionieren unverändert (Java, Python, JavaScript, Go, .NET), ebenso Neo4j-OGM und Spring Data Neo4j. neo4j:// leitet Schreibzugriffe zum Leader und Lesezugriffe zu den Followern; bolt:// spricht mit einem Mitglied. Verwaltete Transaktionen werden bei einem Leaderwechsel wiederholt.

Maven

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

Gradle (Kotlin-DSL)

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

Java: GDOWN_TOKEN enthält das Token aus Schritt 3, nie im Code geschrieben

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

Dieselbe Treiber-API aus Python: das Paket neo4j genügt, mit Benutzer und Token aus Schritt 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

Auf der Gluonify-Plattform

Eine auf Gluonify bereitgestellte Anwendung konfiguriert gDown nicht. Deklarieren Sie gdown in uses (oder lassen Sie den Build es aus dem Neo4j-Treiber im Laufzeit-Classpath ableiten): die Plattform setzt GLUONIFY_GDOWN_BOLT_URL und GLUONIFY_GDOWN_CA_FILE vor dem Start, Bolt über TLS im internen Netz, und das Konto kommt aus den Geheimnissen der Anwendung.

gluonify.json (nur wenn der Treiber nicht im Laufzeit-Classpath ist)

{ "uses": ["gdown"] }

Die gesetzten Variablen lesen (Java-Treiber)

// 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);

Von Ihrem Arbeitsplatz aus meldet Sie die Gluonify-CLI im Browser an Ihrer Zone an; das SDK löst dann die Plattformdienste für einen lokalen Lauf auf.

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

Weiter geht es

Web-Konsole: Abfragen, Graphansicht, Datenmodell und Clusterzustand, unter http://localhost:8080.
KI-Assistenten: der MCP-Server unter /mcp, Vektor- und Volltextindizes und das Gedächtnis Ihrer Repositories.
Ein Cluster aus drei Mitgliedern, gegenseitiges TLS, OpenShift und Microsoft Entra ID: die Installationsseite.
Was unterstützt wird: openCypher-Abdeckung, Bolt- und HTTP-Funktionen, Grenzen, auf der Vergleichsseite.
Image-Dokumentation auf Docker Hub: Variablen, Volumes, Upgrades, Grenzen.

Ports: 8080 für HTTP (API, Konsole, Swagger UI) und 7687 für Bolt. Ein Token gehört nie in eine URL, ein Protokoll oder ein Repository.