Migrar do Blazegraph para o Amazon Neptune

Se você tiver um grafo no armazenamento triplo do RDF Blazegraph de código aberto, poderá migrar os dados de grafos para o Amazon Neptune usando as seguintes etapas:

• Provisione a infraestrutura da AWS. Comece provisionando a infraestrutura Neptune necessária usando um modelo do AWS CloudFormation (consulte Criar um cluster de banco de dados).

• Exporte dados do Blazegraph. Existem dois métodos principais para exportar dados do Blazegraph, ou seja, usar consultas SPARQL CONSTRUCT ou o utilitário Export do Blazegraph.

• Importe os dados para o Neptune. Depois, é possível carregar os arquivos de dados exportados no Neptune usando a bancada de trabalho do Neptune e Carregador em massa do Neptune.

Em geral, essa abordagem também é aplicável à migração de outros bancos de dados triplestore do RDF.

Compatibilidade do Blazegraph com o Neptune

Antes de migrar os dados de grafos para o Neptune, há várias diferenças significativas entre o Blazegraph e o Neptune que você deve conhecer. Essas diferenças podem exigir alterações nas consultas, na arquitetura da aplicação ou em ambas, ou até mesmo tornar a migração impraticável:

• Full-text search: no Blazegraph, é possível usar os recursos de pesquisa interna ou externa de texto completo por meio de uma integração com o Apache Solr. Se você usar qualquer um desses atributos, informe-se sobre as atualizações mais recentes dos atributos de pesquisa de texto completo compatíveis com o Neptune. Consulte Pesquisa de texto completo do Neptune.

• Query hints: tanto o Blazegraph quanto o Neptune estendem o SPARQL usando o conceito de dicas de consulta. Durante uma migração, é necessário migrar todas as dicas de consulta usadas. Para obter informações sobre as dicas de consulta mais recentes que o Neptune aceita, consulte SPARQLdicas de consulta.

• Inferência: o Blazegraph é compatível com inferência como uma opção configurável no modo de triplos, mas não no modo de quádruplos. O Neptune ainda não é compatível com inferência.

• Pesquisa geoespacial: o Blazegraph é compatível com a configuração de namespaces que permitem suporte geoespacial. Esse atributo ainda não está disponível no Neptune.

• Multilocação: o Blazegraph é compatível com multilocação em um único banco de dados. No Neptune, a multilocação é compatível armazenando dados em grafos nomeados e usando as cláusulas USING NAMED para consultas do SPARQL ou criando um cluster de banco de dados separado para cada locatário.

• Federação: no momento, o Neptune é compatível com a federação SPARQL 1.1 em locais acessíveis à instância do Neptune, como na VPC privada, entre VPCs ou em endpoints externos da Internet. Dependendo da configuração específica e dos endpoints de federação necessários, talvez seja necessária alguma configuração de rede adicional.

• Extensões de padrões do Blazegraph: o Blazegraph inclui várias extensões para os padrões do SPARQL e da API REST, enquanto o Neptune é compatível apenas com as próprias especificações dos padrões. Isso pode exigir alterações na aplicação ou dificultar a migração.

Provisionar a infraestrutura da AWS para o Neptune

Embora seja possível construir a infraestrutura da AWS necessária manualmente por meio do AWS Management Console ou da AWS CLI, geralmente é mais conveniente usar um modelo do CloudFormation, conforme descrito abaixo:

Provisionando o Neptune com um modelo do CloudFormation:

1. Acesse Usando um AWS CloudFormation Pilha para criar um cluster de banco de dados Neptune.

2. Selecione Iniciar pilha na região de preferência.

3. Defina os parâmetros necessários (nome da pilha e EC2SSHKeyPairName). Defina também os seguintes parâmetros opcionais para facilitar o processo de migração:

   • Defina AttachBulkloadIAMRoleToNeptuneCluster como verdadeiro. Esse parâmetro permite criar e anexar o perfil apropriado do IAM ao cluster para permitir o carregamento em massa de dados.

   • Defina NotebookInstanceType como o tipo de instância de sua preferência. Esse parâmetro cria uma pasta de trabalho do Neptune que você usa para executar o carregamento em massa no Neptune e validar a migração.

4. Escolha Next (Próximo).

5. Defina as outras opções de pilha desejadas.

6. Escolha Next (Próximo).

7. Analise as opções e marque as duas caixas de seleção para confirmar que o AWS CloudFormation pode exigir recursos adicionais.

8. Selecione Criar pilha.

O processo de criação da pilha pode levar alguns minutos.

Exportar dados do Blazegraph

A próxima etapa é exportar dados do Blazegraph em um formato compatível com o carregador em massa do Neptune.

Dependendo de como os dados são armazenados no Blazegraph (triplos ou quádruplos) e de quantos grafos nomeados estão em uso, o Blazegraph pode exigir que você execute o processo de exportação várias vezes e gere vários arquivos de dados:

• Se os dados forem armazenados em triplos, você precisará executar uma exportação para cada grafo nomeado.

• Se os dados forem armazenados como quads, você poderá optar por exportar dados no formato N-Quads ou exportar cada grafo nomeado em um formato de triplos.

Abaixo, supomos que você exporte um único namespace como N-Quads, mas você pode repetir o processo para namespaces adicionais ou formatos de exportação desejados.

Se você precisar que o Blazegraph esteja on-line e disponível durante a migração, use as consultas SPARQL CONSTRUCT. Isso requer que você instale, configure e execute uma instância do Blazegraph com um endpoint do SPARQL acessível.

Se for necessário que o Blazegraph esteja on-line, use o utilitário BlazeGraph Export. Para fazer isso, é necessário baixar o Blazegraph, e o arquivo de dados e de configuração precisam estar acessíveis, mas o servidor não precisa estar em execução.

Exportar dados do Blazegraph usando SPARQL CONSTRUCT

SPARQL CONSTRUCT é um atributo do SPARQL que gera um grafo do RDF correspondente ao modelo de consulta especificado. Para esse caso de uso, você o usa para exportar os dados um namespace por vez, usando uma consulta como a seguinte:

CONSTRUCT WHERE { hint:Query hint:analytic "true" . hint:Query hint:constructDistinctSPO "false" . ?s ?p ?o }

Embora existam outras ferramentas do RDF para exportar esses dados, a maneira mais fácil de executar essa consulta é usando o endpoint da API REST fornecido pelo Blazegraph. O seguinte script demonstra como usar um script Python (3.6+) para exportar dados como N-Quads:

import requests

# Configure the URL here: e.g. http://localhost:9999/sparql
url = "http://localhost:9999/sparql"
payload = {'query': 'CONSTRUCT WHERE { hint:Query hint:analytic "true" . hint:Query hint:constructDistinctSPO "false" . ?s ?p ?o }'}
# Set the export format to be n-quads
headers = {
'Accept': 'text/x-nquads'
}
# Run the http request
response = requests.request("POST", url, headers=headers, data = payload, files = [])
#open the file in write mode, write the results, and close the file handler
f = open("export.nq", "w")
f.write(response.text)
f.close()

Se os dados forem armazenados como triplos, você precisará alterar o parâmetro de cabeçalho Accept para exportar dados em um formato apropriado (N-Triples, RDF/XML ou Turtle) usando os valores especificados no repositório do Blazegraph no GitHub.

Usar o utilitário de exportação Blazegraph para exportar dados

O Blazegraph contém um método utilitário para exportar dados, ou seja, a classe ExportKB. O ExportKB facilita a exportação de dados do Blazegraph, mas, ao contrário do método anterior, exige que o servidor esteja off-line enquanto a exportação está sendo executada. Isso o torna o método ideal para ser usado quando você pode colocar o Blazegraph off-line durante a migração, ou a migração pode ocorrer a partir de um backup dos dados.

Você executa o utilitário a partir de uma linha de comando Java em uma máquina que tem o Blazegraph instalado, mas não está em execução. A maneira mais fácil de executar esse comando é baixar a versão mais recente do blazegraph.jar localizada no GitHub. A execução desse comando requer vários parâmetros:

• log4j.primary.configuration: a localização do arquivo de propriedades log4j.

• log4j.configuration: a localização do arquivo de propriedades log4j.

• output: o diretório de saída dos dados exportados. Os arquivos estão localizados como tar.gz em um subdiretório chamado conforme documentado na base de conhecimento.

• format: o formato de saída desejado seguido pela localização do arquivo RWStore.properties. Se você estiver trabalhando com triplos, precisará alterar o parâmetro -format para N-Triples, Turtle ou RDF/XML.

Por exemplo, se você tiver o arquivo de diário e os arquivos de propriedades do Blazegraph, exporte os dados como N-Quads usando o seguinte código:

java -cp blazegraph.jar \
    com.bigdata.rdf.sail.ExportKB \
    -outdir ~/temp/ \
    -format N-Quads \
    ./RWStore.properties

Se a exportação for bem-sucedida, a saída será semelhante à seguinte:

Exporting kb as N-Quads on /home/ec2-user/temp/kb
Effective output directory: /home/ec2-user/temp/kb
Writing /home/ec2-user/temp/kb/kb.properties
Writing /home/ec2-user/temp/kb/data.nq.gz
Done

Criar um bucket do Amazon Simple Storage Service (Amazon S3) e copiar os dados exportados nele

Depois de exportar os dados do Blazegraph, crie um bucket do Amazon Simple Storage Service (Amazon S3) na mesma região do cluster de banco de dados do Neptune de destino para o carregador em massa do Neptune usar para importar os dados.

Para obter instruções sobre como criar um bucket do Amazon S3, consulte How do I create an S3 Bucket? no Guia do usuário do Amazon Simple Storage Service e Examples of creating a bucket no Guia do usuário do Amazon Simple Storage Service.

Para obter instruções sobre como copiar os arquivos de dados exportados para o novo bucket do Amazon S3, consulte Uploading an object to a bucket no Guia do usuário do Amazon Simple Storage Service ou Using high-level (s3) commands with the AWS CLI. Você também pode usar o código Python como o seguinte para copiar os arquivos um por um:

import boto3

region = 'region name'
bucket_name = 'bucket name'
s3 = boto3.resource('s3')
s3.meta.client.upload_file('export.nq', bucket_name, 'export.nq')

Usar o carregador em massa do Neptune para importar os dados para o Neptune

Depois de exportar os dados do Blazegraph e copiá-los em um bucket do Amazon S3, estará tudo pronto para a importação dos dados para o Neptune. O Neptune tem um carregador em massa que carrega dados com maior rapidez e menor sobrecarga do que realizar operações de carregamento usando SPARQL. O processo do carregador em massa é iniciado por uma chamada à API do endpoint do carregador para carregar os dados armazenados no bucket do S3 identificado no Neptune.

Embora seja possível fazer isso com uma chamada direta para o endpoint REST do carregador, você deve ter acesso à VPC privada na qual a instância de destino do Neptune é executada. Você pode configurar um bastion host, SSH nessa máquina e executar o comando cURL, mas usar a bancada de trabalho do Neptune é mais fácil.

A bancada de trabalho do Neptune é um caderno Jupyter pré-configurado executado como um bloco de anotações Amazon SageMaker, com várias magias de bloco de anotações específicas do Neptune instaladas. Essas magias simplificam as operações comuns do Neptune, como conferir o status do cluster, executar percursos do SPARQL e do Gremlin e executar uma operação de carregamento em massa.

Para iniciar o processo de carregamento em massa, use a magia %load, que fornece uma interface para executar o Comando do carregador do Neptune:

1. Faça login no Console de Gerenciamento da AWS e abra o console do Amazon Neptune em https://console.aws.amazon.com/neptune/home.

2. Selecione aws-neptune-blazegraph-to-neptune.

3. Escolha Abrir bloco de anotações.

4. Na instância em execução do Jupyter, selecione um caderno existente ou crie um usando o kernel do Python 3.

5. No bloco de anotações, abra uma célula, insira %load e execute a célula.

6. Defina os parâmetros para o carregador em massa:

   1. Em Fonte, insira a localização de um arquivo de origem a ser importado: s3://{bucket_name}/{file_name}.

   2. Em Formato, escolha o formato apropriado, que neste exemplo é nquads.

   3. Em Carregar ARN, insira o ARN do perfil IAMBulkLoad (essas informações estão localizadas no console do IAM em Perfis).

7. Selecione Submit (Enviar).

O resultado contém o status da solicitação. As cargas em massa geralmente são processos de longa duração, então a resposta não significa que a carga foi concluída, apenas que ela começou. Essas informações de status são atualizadas periodicamente até relatar que o trabalho foi concluído.

nota

Essas informações também estão disponíveis na postagem no blog, Moving to the cloud: Migrating Blazegraph to Amazon Neptune.