Neo4j - Enterprise Edition Caractéristiques

J'utilisais l'édition communautaire de Neo4j avec Scala avec le wrapper Scala-Neo4j et je viens de télécharger l'édition Enterprise de Neo4j. J'ai vu quelques-unes des fonctionnalités supplémentaires dans l'édition Enterprise, comme le cache haute performance, le clustering et les instances de production 3 *. Comment puis-je utiliser ces fonctionnalités? Ai-je besoin d'apporter des modifications au code que j'ai écrit en utilisant l'édition de la communauté pour utiliser ces fonctionnalités?

0

2 Réponses

Cela dépend de votre modèle de déploiement.

Si vous utilisez Neo4j en mode incorporé, vous initialisez généralement la base de données en utilisant GraphDatabaseFactory.newEmbeddedDatabase (path) . Lorsque vous utilisez Neo4j Enterprise embedded, vous devez le remplacer par HighlyAvailableGraphDatabaseFactory.newHighlyAvailableDatabaseBuilder (chemin) .setConfig (map) .newGraphDatabase()map contient les paramètres de configuration de votre déploiement , en particulier les paramètres ha documentés à http://docs.neo4j.org/chunked/ stable/ha-configuration.html .

Dans le cas d'un déploiement où votre application accède à Neo4j via REST (déploiement de serveur), vous ne devez pas modifier l'URL d'accès à l'URL de l'équilibreur de charge.

S'il vous plaît noter que Neo4j entreprise est à double licence: licence AGPL (affero-GPL) ou commerciale, voir http://www .neo4j.org/learn/licensing pour plus d'informations.

1
ajouté
J'utilise Neo4j en mode embarqué. Puis-je avoir des explications sur les fonctionnalités que j'ai mentionnées dans ma question (cache haute performance, mise en cluster et instances de production 3 *).
ajouté l'auteur yAsH, source
Tout est dans le manuel de référence, voir docs.neo4j.org/chunked/stable/ha. html pour Clustering et docs.neo4j.org/chunked/stable/ operations-backup.html pour la sauvegarde en ligne et docs.neo4j .org/chunked/stable/& hellip; pour le cache résistant au GC (aka high perf cache).
ajouté l'auteur Stefan Armbruster, source

Je sais que c'est une vieille question, mais d'autres peuvent trouver cela utile. Il est possible d'utiliser le Scala Neo4j Wrapper avec une instance HA.

Vous pouvez étendre GraphDatabaseServiceProvider . Pour obtenir les fonctionnalités d'entreprise telles que le clustering, vous devez exécuter une instance de votre application sur chaque nœud de cluster.

package graphdatabase

import scala.collection.JavaConversions._

import eu.fakod.neo4jscala.{
  Neo4jWrapper, DatabaseService,
  DatabaseServiceImpl, GraphDatabaseServiceProvider
}

import org.neo4j.cluster.ClusterSettings
import org.neo4j.kernel.ha.HaSettings
import org.neo4j.graphdb.factory.HighlyAvailableGraphDatabaseFactory

object HighAvailabilityGraphDatabase extends Neo4jWrapper with GraphDatabaseServiceProvider {

  def neo4jStoreDir = "/path/to/db"

 //The config params will vary for each cluster node.
 //You could use environment variables for example to configure.
  def configParams = Map(
    ClusterSettings.server_id.name -> sys.env.get("SERVER_ID").get,//e.g. 1
    HaSettings.ha_server.name -> sys.env.get("HA_SERVER").get,//e.g. server1:6001
    ClusterSettings.cluster_server.name -> sys.env.get("CLUSTER_SERVER").get,//e.g.server1:5001
    ClusterSettings.initial_hosts.name -> sys.env.get("INITIAL_HOSTS").get//e.g. server1:5001,server2:5001
  )

  val ds: DatabaseService = {
    val gdb = DatabaseServiceImpl(new HighlyAvailableGraphDatabaseFactory()
      .newHighlyAvailableDatabaseBuilder(neo4jStoreDir)
      .setConfig(mapAsJavaMap(configParams))
      .newGraphDatabase
    )
    sys.addShutdownHook({
      shutdown(gdb)
    })
    gdb
  }
}

Vous devriez également être capable de configurer la mise en cache haute performance dans la configuration bien que je vérifie les docs pour ça

Vous pouvez ensuite utiliser l'encapsuleur Neo4j Scala comme vous le feriez n'importe où en important depuis HighAvailabilityGraphDatabase . Mais vous pouvez désormais tirer parti d'autres fonctionnalités d'entreprise telles que les sauvegardes en direct. Il est également facile d'accéder au service de base de données Java sous-jacent à partir du wrapper Scala.

import graphdatabase.HighAvailabilityGraphDatabase._

object Foo {
  withTx { implicit db =>
   //use db.gds to access the underlying GraphDatabaseService object.
   //otherwise create nodes etc as per usual.
    val node = createNode
    node("foo") = "bar"
  }
}

Note: You'll also need to ensure that you include Neo4j HA in your build.sbt (or similar) since it isn't included in the Scala wrapper.

libraryDependencies ++= Seq(
  "org.neo4j" % "neo4j-ha" % "2.1.3"//Replace 2.1.3 with your version
)
0
ajouté