Compatibilidade do Neptune com o Neo4j

LOAD CSV: o Neptune tem uma abordagem arquitetônica diferente do Neo4j para carregar dados. Para permitir uma melhor escalabilidade e otimização de custos, o Neptune implementa uma separação de preocupações em relação aos recursos e recomenda o uso de uma das integrações de serviços da AWS, como AWS Glue para executar os processos de ETL necessários para preparar dados em um formato compatível com o carregador em massa do Neptune.

Outra opção é fazer a mesma coisa usando o código da aplicação executado em recursos computacionais da AWS, como instâncias do Amazon EC2, funções do Lambda, Amazon Elastic Container Service, trabalhos AWS Batch, etc. O código pode usar o endpoint HTTPS do Neptune ou o endpoint do Bolt.

Controle de acesso refinado: o Neptune é compatível com o controle de acesso granular sobre ações de acesso a dados usando chaves de condição do IAM. Controle de acesso refinado adicional pode ser implementado na camada de aplicação.

Neo4j Fabric: o Neptune é compatível com a federação de consultas em bancos de dados para workloads do RDF usando a palavra-chave SERVICE do SPARQL. Como no momento não há um padrão aberto nem uma especificação para federação de consultas para workloads de grafos de propriedades, essa funcionalidade precisaria ser implementada na camada da aplicação.

Controle de acesso baseado em perfil (RBAC): o Neptune gerencia a autenticação por meio da atribuição de políticas e perfis do IAM. As políticas e os perfis do IAM oferecem um nível extremamente flexível de gerenciamento de usuários em um aplicação, por isso é útil ler e entender as informações na Visão geral do IAM antes de configurar o cluster.

Marcação: os clusters do Neptune consistem em uma única instância de gravador e até 15 instâncias de réplica de leitura. Os dados gravados na instância de gravador são compatíveis com ACID e fornecem uma forte garantia de consistência nas leituras subsequentes. As réplicas de leitura usam o mesmo volume de armazenamento da instância de gravador e acabam sendo consistentes, em geral, em menos de 100 ms a partir do momento em que os dados são gravados. Se o caso de uso tiver uma necessidade imediata de garantir a consistência de leitura de novas gravações, essas leituras deverão ser direcionadas para o endpoint de cluster em vez do endpoint de leitor.

Procedimentos APOC: como os procedimentos APOC não estão incluídos na especificação do openCypher, o Neptune não oferece suporte direto para procedimentos externos. Em vez disso, o Neptune depende de integrações com outros serviços da AWS para obter uma funcionalidade semelhante ao usuário final de maneira escalável, segura e sólida. Às vezes, os procedimentos APOC podem ser regravados em openCypher ou em Gremlin, e alguns não são relevantes para as aplicações do Neptune.

Em geral, os procedimentos APOC se enquadram nas categorias abaixo:

Procedimentos personalizados: o Neptune não é compatível com procedimentos personalizados criados por usuários. Essa funcionalidade teria que ser implementada na camada da aplicação.

Geoespacial: embora o Neptune não ofereça suporte nativo para atributos geoespaciais, uma funcionalidade semelhante pode ser obtida por meio da integração com outros serviços da AWS, conforme mostrado nesta postagem no blog: Combine Amazon Neptune and Amazon OpenSearch Service for geospatial queries de Ross Gabay e Abhilash Vinod (1.º de fevereiro de 2022).

Ciência de dados de grafos: o Neptune oferece suporte à análise de grafos por meio do Neptune Analytics, um mecanismo otimizado para memória compatível com uma biblioteca de algoritmos analíticos de grafos.

O Neptune também oferece integração com o SDK do AWS Pandas e vários exemplos de bloco de anotações que mostram como aproveitar essa integração em ambientes Python para realizar análises em dados de grafos.

Restrições do esquema: no Neptune, a única restrição do esquema disponível é a exclusividade do ID de um nó ou uma borda. Não há nenhum atributo para especificar restrições adicionais do esquema nem qualquer restrição adicional de exclusividade ou valor em um elemento no grafo. Os valores de ID no Neptune são strings e podem ser definidos usando Gremlin, da seguinte forma:

g.addV('person').property(id, '1') )

As aplicações que precisam utilizar o ID como restrição de exclusividade são incentivadas a tentar essa abordagem para obter uma restrição de exclusividade. Se a aplicação usou várias colunas como restrição de exclusividade, o ID pode ser definido como uma combinação desses valores. Por exemplo, id=123, code='SEA' pode ser representado como ID='123_SEA' para obter uma restrição de exclusividade complexa.

Multilocação: o Neptune é compatível apenas com um único grafo por cluster. Para criar um sistema multilocatário usando o Neptune, use vários clusters ou particione logicamente os locatários em um único grafo e use a lógica do lado da aplicação para impor a separação. Por exemplo, adicione uma propriedade tenantId e inclua-a em cada consulta, da seguinte forma:

MATCH p=(n {tenantId:1})-[]->({tenantId:1}) RETURN p LIMIT 5)

O Neptune Serverless torna relativamente fácil implementar a multilocação usando vários clusters de banco de dados, sendo cada um escalado de forma independente e automática conforme necessário.

Neo4j Browser: o Neptune fornece blocos de anotações de grafos de código aberto que fornecem um IDE enfocado no desenvolvedor para executar consultas e visualizar os resultados.

Neo4j Bloom: o Neptune é compatível com visualizações de grafos avançadas usando soluções de visualização de terceiros, como Graph-explorer, Tom Sawyer, Cambridge Intelligence, Graphistry, metaphacts e G.V().

GraphQL: no momento, o Neptune é compatível com o GraphQL por meio de integrações AWS AppSync personalizadas. Consulte a postagem no blog Build a graph application with Amazon Neptune and AWS Amplify e o exemplo de projeto, Building Serverless Calorie tracker application with AWS AppSync and Amazon Neptune.

NeoSemantics: o Neptune oferece suporte nativo ao modelo de dados do RDF, portanto, os clientes que desejam executar workloads do RDF são aconselhados a usar o suporte ao modelo do RDF do Neptune.

Arrows.app: o Cypher criado ao exportar o modelo usando o comando export é compatível com o Neptune.

Linkurious Ogma: um exemplo de integração com o Linkurious Ogma está disponível aqui.

Spring Data Neo4j: no momento, não é compatível com o Neptune.

Conector Spark do Neo4j: o conector Spark do Neo4j pode ser usado em um trabalho do Spark para se conectar ao Neptune usando o openCypher. Veja alguns exemplos de código e configuração da aplicação:

Código de exemplo:

SparkSession spark = SparkSession
            .builder()
            .config("encryption.enabled", "true")
            .appName("Simple Application").config("spark.master", "local").getOrCreate();

Dataset<Row> df = spark.read().format("org.neo4j.spark.DataSource")
            .option("url", "bolt://(your cluster endpoint):8182")
            .option("encryption.enabled", "true")
            .option("query", "MATCH (n:airport) RETURN n")
            .load();
            
System.out.println("TOTAL RECORD COUNT: " + df.count());
spark.stop();

Configuração da aplicação:

<dependency>
    <groupId>org.neo4j</groupId>
    <artifactId>neo4j-connector-apache-spark_2.12-4.1.0</artifactId>
    <version>4.0.1_for_spark_3</version>
</dependency>