Compatibilidade do Neptune com o Neo4j

O Neo4j tem uma abordagem completa em que o carregamento e o ETL de dados, as consultas de aplicações, o armazenamento de dados e as operações de gerenciamento acontecem no mesmo conjunto de recursos computacionais, como instâncias do EC2. O Amazon Neptune é um banco de dados de grafos de especificações abertas concentrado em OLTP em que a arquitetura separa as operações e desconecta os recursos para que eles possam ser escalados dinamicamente.

Há uma série de atributos e ferramentas no Neo4j, incluindo ferramentas de terceiros, que não fazem parte da especificação do openCypher, são incompatíveis com o openCypher ou com a implementação do openCypher pelo Neptune. Veja alguns dos mais comuns listados.

Atributos específicos do Neo4j não presentes no Neptune

• 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:

  • Importar: o Neptune é compatível com a importação de dados com uma variedade de formatos usando linguagens de consulta, o carregador em massa do Neptune ou como destino do AWS Database Migration Service. As operações de ETL nos dados podem ser realizadas com AWS Glue e o pacote de código aberto neptune-python-utils.

  • Exportar: o Neptune é compatível com a exportação de dados usando o utilitário neptune-export, que é compatível com uma variedade de formatos e métodos de exportação comuns.

  • Integração de banco de dados: o Neptune é compatível com a integração com outros bancos de dados usando ferramentas ETL, como AWS Glue ou ferramentas de migração, como o AWS Database Migration Service.

  • Atualizações de grafos: o Neptune é compatível com um rico conjunto de atributos para atualizar dados de grafos de propriedades por meio do suporte para as linguagens de consulta openCypher e Gremlin. Consulte Reformulações do Cypher para obter exemplos de regravações de procedimentos usados com frequência.

  • Estruturas de dados: o Neptune é compatível com um rico conjunto de atributos para atualizar dados de grafos de propriedades por meio do suporte para as linguagens de consulta openCypher e Gremlin. Consulte Reformulações do Cypher para obter exemplos de regravações de procedimentos usados com frequência.

  • Temporal (data e hora): o Neptune é compatível com um rico conjunto de atributos para atualizar dados de grafos de propriedades por meio do suporte para as linguagens de consulta openCypher e Gremlin. Consulte Reformulações do Cypher para obter exemplos de regravações de procedimentos usados com frequência.

  • Matemático: o Neptune é compatível com um rico conjunto de atributos para atualizar dados de grafos de propriedades por meio do suporte para as linguagens de consulta openCypher e Gremlin. Consulte Reformulações do Cypher para obter exemplos de regravações de procedimentos usados com frequência.

  • Consultas de grafos avançadas: o Neptune é compatível com um rico conjunto de atributos para atualizar dados de grafos de propriedades por meio do suporte para as linguagens de consulta openCypher e Gremlin. Consulte Reformulações do Cypher para obter exemplos de regravações de procedimentos usados com frequência.

  • Comparação de grafos: o Neptune é compatível com um rico conjunto de atributos para atualizar dados de grafos de propriedades por meio do suporte para as linguagens de consulta openCypher e Gremlin. Consulte Reformulações do Cypher para obter exemplos de regravações de procedimentos usados com frequência.

  • Execução do Cypher: o Neptune é compatível com um rico conjunto de atributos para atualizar dados de grafos de propriedades por meio do suporte para as linguagens de consulta openCypher e Gremlin. Consulte Reformulações do Cypher para obter exemplos de regravações de procedimentos usados com frequência.

• 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.

Suporte do Neptune para ferramentas do Neo4j

O Neptune oferece as seguintes alternativas às ferramentas do Neo4j:

• 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>

Atributos e ferramentas do Neo4j não listados aqui

Se você estiver usando uma ferramenta ou um atributo não listado aqui, não temos certeza da compatibilidade com o Neptune ou com outros serviços da AWS contidos nele. Em caso de mais dúvidas, entre em contato com o AWS Support ou entre em contato com a equipe de sua conta.