Usar os blocos de anotações de grafos Neptune para começar rapidamente

Não é necessário usar os blocos de anotações de grafos Neptune para trabalhar com um grafo do Neptune, então, se quiser, crie um banco de dados do Neptune imediatamente usando um modelo do AWS CloudFormation.

Ao mesmo tempo, se você não tem conhecimento sobre grafos e quer aprender e experimentar, ou se tem experiência e quer refinar suas consultas, a bancada de trabalho do Neptune oferece um ambiente de desenvolvimento interativo (IDE) que pode aumentar sua produtividade ao criar aplicações de grafos.

O Neptune oferece cadernos Jupyter e JupyterLab no projeto de bloco de anotações de grafos Neptune no GitHub e na bancada de trabalho do Neptune. Esses blocos de anotações oferecem exemplos de tutoriais de aplicações e trechos de código em um ambiente de codificação interativo onde você pode saber mais sobre a tecnologia de grafos e o Neptune. É possível usá-los para percorrer a instalação, a configuração, o preenchimento e a consulta de grafos usando diferentes linguagens de consulta, conjuntos de dados distintos e até mesmo bancos de dados diferentes no back-end.

É possível hospedar esses blocos de anotações de várias maneiras diferentes:

• A bancada de trabalho do Neptune permite executar cadernos Jupyter em um ambiente totalmente gerenciado, hospedado no Amazon SageMaker, e carregar automaticamente a versão mais recente do projeto de blocos de anotações de grafos Neptune para você. É fácil configurar a bancada de trabalho no console do Neptune ao criar um banco de dados do Neptune.

• Você também pode instalar o Jupyter localmente. Isso permite que você execute os blocos de anotações no laptop, conectado ao Neptune ou em uma instância local de um dos bancos de dados de grafos de código aberto. No último caso, é possível experimentar a tecnologia de grafos o quanto quiser sem gastar. Então, quando estiver com tudo pronto, você poderá migrar sem problemas para o ambiente de produção gerenciado oferecido pelo Neptune.

Usar a bancada de trabalho do Neptune para hospedar blocos de anotações Neptune

O Neptune oferece os tipos de instância T3 e T4g com os quais é possível começar por menos de USD 0,10 por hora. Você será cobrado pelos recursos da bancada de trabalho por meio do Amazon SageMaker, separadamente da cobrança do Neptune. Consulte a página Preços do Neptune. Todos os cadernos Jupyter e JupyterLab criados na bancada de trabalho do Neptune usam um ambiente Amazon Linux 2 e JupyterLab 3. Para obter mais informações sobre o suporte ao caderno JupyterLab, consulte a documentação do Amazon SageMaker.

É possível criar um caderno Jupyter ou JupyterLab usando a bancada de trabalho do Neptune no AWS Management Console de uma das duas maneiras:

• Use o menu Configuração de cadernos ao criar um cluster de banco de dados do Neptune. Para isso, siga as etapas descritas em Iniciar um cluster de banco de dados do Neptune usando o AWS Management Console.

• Use o menu Blocos de anotações no painel de navegação esquerdo depois que o cluster de banco de dados já tiver sido criado. Para isso, siga as etapas abaixo.

Como criar um caderno Jupyter ou JupyterLab usando o menu Cadernos

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. No painel de navegação à esquerda, escolha Notebooks (Blocos de anotações).

3. Selecione Create Notebook (Criar bloco de anotações).

4. Na lista Cluster, escolha o cluster de banco de dados do Neptune. Se você ainda não tiver um cluster de banco de dados, escolha Create cluster (Criar cluster) para criar um.

5. Selecione um Tipo de instância de caderno.

6. Insira um nome para o seu bloco de anotações e, opcionalmente, uma descrição.

7. A menos que já tenha criado um perfil do AWS Identity and Access Management (IAM) para os blocos de anotações, escolha Criar um perfil do IAM e insira um nome para o perfil do IAM.

   nota

   Se você optar por reutilizar um perfil do IAM criado para um bloco de anotações anterior, a política do perfil deverá conter as permissões corretas para acessar o cluster de banco de dados do Neptune que você está usando. É possível verificar isso conferindo se os componentes do ARN do recurso sob a ação neptune-db:* correspondem a esse cluster. Permissões configuradas incorretamente geram erros de conexão quando você tenta executar comandos mágicos do caderno.

8. Selecione Create Notebook (Criar bloco de anotações). O processo de criação pode levar de cinco a dez minutos até que tudo esteja pronto.

9. Depois que o bloco de anotações for criado, selecione-o e escolha Abrir Jupyter ou Abrir JupyterLab.

O console pode criar um perfil do AWS Identity and Access Management (IAM) para os blocos de anotações ou você mesmo pode criar um. A política para essa função deve incluir o seguinte:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "s3:GetObject",
        "s3:ListBucket"
      ],
      "Resource": [
        "arn:aws:s3:::aws-neptune-notebook-(AWS region)",
        "arn:aws:s3:::aws-neptune-notebook-(AWS region)/*"
      ]
    },
    {
      "Effect": "Allow",
      "Action": "neptune-db:*",
      "Resource": [
        "arn:aws:neptune-db:(AWS region):(AWS account ID):(Neptune resource ID)/*"
      ]
    }
  ]
}

Observe que a segunda declaração na política acima lista um ou mais IDs de recursos do cluster do Neptune.

Além disso, a função deve estabelecer a seguinte relação de confiança:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "Service": "sagemaker.amazonaws.com"
      },
      "Action": "sts:AssumeRole"
    }
  ]
}

Novamente, preparar tudo pode levar de cinco a dez minutos.

Você pode configurar o novo bloco de anotações para funcionar com o Neptune ML, conforme explicado em Configurar manualmente um bloco de anotações Neptune para o Neptune ML.

Usar o Python para conectar um bloco de anotações genérico do SageMaker ao Neptune

Conectar um bloco de anotações ao Neptune será fácil se você tiver instalado a magia do Neptune, mas também é possível conectar um bloco de anotações SageMaker ao Neptune usando Python, mesmo que você não esteja usando um bloco de anotações Neptune.

Etapas a serem seguidas para se conectar ao Neptune em uma célula de bloco de anotações SageMaker

1. Instale o cliente do Python em Gremlin:

   !pip install gremlinpython

   Os blocos de anotações Neptune instalam o cliente do Python em Gremlin para você, então essa etapa só será necessária se você estiver usando um bloco de anotações SageMaker simples.

2. Escreva um código como o seguinte para se conectar e emitir uma consulta do Gremlin:

   from gremlin_python import statics
   from gremlin_python.structure.graph import Graph
   from gremlin_python.process.graph_traversal import __
   from gremlin_python.process.strategies import *
   from gremlin_python.driver.driver_remote_connection import DriverRemoteConnection
   from gremlin_python.driver.aiohttp.transport import AiohttpTransport
   from gremlin_python.process.traversal import *
   import os
   
   port = 8182
   server = '(your server endpoint)'
   
   endpoint = f'wss://{server}:{port}/gremlin'
   
   graph=Graph()
   
   connection = DriverRemoteConnection(endpoint,'g',
                    transport_factory=lambda:AiohttpTransport(call_from_event_loop=True))
   
   g = graph.traversal().withRemote(connection)
   
   results = (g.V().hasLabel('airport')
                   .sample(10)
                   .order()
                   .by('code')
                   .local(__.values('code','city').fold())
                   .toList())
   
   # Print the results in a tabular form with a row index
   for i,c in enumerate(results,1):
       print("%3d %4s %s" % (i,c[0],c[1]))
   
   connection.close()

nota

Se você estiver usando uma versão do cliente do Python em Gremlin anterior à 3.5.0, esta linha:

connection = DriverRemoteConnection(endpoint,'g',
                 transport_factory=lambda:AiohttpTransport(call_from_event_loop=True))

Será apenas:

connection = DriverRemoteConnection(endpoint,'g')

Habilitar os logs do CloudWatch em blocos de anotações Neptune

Os logs do CloudWatch agora estão desabilitados por padrão para blocos de anotações Neptune. Se você tiver um bloco de anotações mais antigo que não esteja produzindo logs do CloudWatch, siga estas etapas para habilitá-los manualmente:

1. Faça login no AWS Management Console e abra o console do SageMaker.

2. No painel de navegação à esquerda, selecione Bloco de anotações e depois Instâncias do bloco de anotações. Procure o nome do bloco de anotações Neptune para o qual você gostaria de habilitar os logs.

3. Acesse a página de detalhes selecionando o nome dessa instância do bloco de anotações.

4. Se a instância do bloco de anotações estiver em execução, selecione o botão Interromper, no canto superior direito da página de detalhes do bloco de anotações.

5. Em Permissões e criptografia, há um campo para o ARN do perfil do IAM. Selecione o link nesse campo para acessar o perfil do IAM com o qual essa instância de bloco de anotações é executada.

6. Crie a seguinte política:

   {
     "Version": "2012-10-17",
     "Statement": [
       {
         "Effect": "Allow",
         "Action": [
           "logs:CreateLogDelivery",
           "logs:CreateLogGroup",
           "logs:CreateLogStream",
           "logs:DeleteLogDelivery",
           "logs:Describe*",
           "logs:GetLogDelivery",
           "logs:GetLogEvents",
           "logs:ListLogDeliveries",
           "logs:PutLogEvents",
           "logs:PutResourcePolicy",
           "logs:UpdateLogDelivery"
         ],
         "Resource": "*"
       }
     ]
   }

7. Salve essa nova política e anexe-a ao perfil do IAM encontrado na etapa 4.

8. Selecione Iniciar no canto superior direito da página de detalhes da instância do bloco de anotações SageMaker.

9. Quando os logs começarem a fluir, você verá um link Visualizar logs abaixo do campo Configuração do ciclo de vida, na parte inferior esquerda da seção Configurações da instância do bloco de anotações na página de detalhes.

Se o bloco de anotações não for iniciado, haverá uma mensagem na página de detalhes do bloco de anotações no console do SageMaker informando que a instância do bloco de anotações demorou mais de cinco minutos para ser iniciada. Os logs do CloudWatch relevantes para esse problema podem ser encontrados com este nome:

(your-notebook-name)/LifecycleConfigOnStart

Configurar blocos de anotações de grafos na máquina local

O projeto de bloco de anotações de grafos tem instruções para configurar os blocos de anotações Neptune na máquina local:

• Pré-requisitos

• Instalação do Jupyter e do JupyterLab

• Conectar-se a um banco de dados de grafos

É possível conectar os blocos de anotações locais a um cluster de banco de dados do Neptune ou a uma instância local ou remota de um banco de dados de grafos de código aberto.

Usar blocos de anotações Neptune com clusters do Neptune

Se você estiver se conectando a um cluster do Neptune no back-end, talvez queira executar os blocos de anotações no Amazon SageMaker. Conectar-se ao Neptune por meio do SageMaker pode ser mais conveniente do que por uma instalação local dos blocos de anotações, além de permitir que você trabalhe com maior facilidade com o Neptune ML.

Para obter instruções sobre como configurar blocos de anotações no SageMaker, consulte Launching graph-notebook using Amazon SageMaker.

Para obter instruções sobre como instalar e configurar o Neptune em si, consulte Configurar o Neptune.

Você também pode conectar uma instalação local dos blocos de anotações Neptune a um cluster de banco de dados do Neptune. Isso pode ser um pouco mais complicado porque os clusters de banco de dados do Amazon Neptune só podem ser criados em uma Amazon Virtual Private Cloud (VPC), que é, por design, isolada do mundo externo. Há várias maneiras de se conectar a uma VPC de fora dela. Uma delas é usar um balanceador de carga. Outra é usar o emparelhamento de VPCs (consulte o Guia de emparelhamento da Amazon Virtual Private Cloud).

No entanto, a maneira mais conveniente para a maioria das pessoas é se conectar para configurar um servidor proxy do Amazon EC2 na VPC e, depois, usar o tunelamento SSH (também chamado de encaminhamento de porta) para se conectar a ele. É possível encontrar instruções sobre como configurar em Connecting graph notebook locally to Amazon Neptune na pasta additional-databases/neptune do projeto graph-notebook do GitHub.

Usar blocos de anotações Neptune com bancos de dados de grafos de código aberto

Para começar a usar a tecnologia de grafos sem nenhum custo, você também pode usar os blocos de anotações Neptune com vários bancos de dados de código aberto no back-end. São exemplos: o servidor Gremlin em TinkerPop e o banco de dados Blazegraph.

Para usar o servidor do Gremlin como o banco de dados de back-end, siga as instruções em:

• A pasta Connecting graph-notebook to a Gremlin Server no GitHub.

• A pasta graph-notebook Gremlin configuration no GitHub.

Para usar uma instância local do Blazegraph como o banco de dados de back-end, siga estas instruções:

• Instruções de início rápido do Blazegraph

• A pasta graph-notebook Blazegraph configuration no GitHub.

Migrar os blocos de anotações Neptune do Jupyter para o JupyterLab 3

Os blocos de anotações Neptune criados antes de 21 de dezembro de 2022 usam o ambiente Amazon Linux 1. É possível migrar cadernos Jupyter antigos criados antes dessa data para o novo ambiente Amazon Linux 2 com o JupyterLab 3 seguindo as etapas descritas nesta postagem no blog da AWS: Migrate your work to an Amazon SageMaker notebook instance with Amazon Linux 2.

Além disso, também há mais algumas etapas que se aplicam especificamente à migração dos blocos de anotações Neptune para o novo ambiente:

Pré-requisitos específicos do Neptune

No perfil do IAM do bloco de anotações Neptune de origem, adicione todas as seguintes permissões:

{
  "Effect": "Allow",
  "Action": [
    "s3:GetObject",
    "s3:ListBucket",
    "s3:CreateBucket",
    "s3:PutObject"
  ],
  "Resource": [
    "arn:aws:s3:::(your ebs backup bucket name)",
    "arn:aws:s3:::(your ebs backup bucket name)/*"
  ]
},
{
  "Effect": "Allow",
  "Action": [
    "sagemaker:ListTags"
  ],
  "Resource": [
    "*"
  ]
}

Especifique o ARN correto para o bucket do S3 que você usará para fazer backup.

Configuração de ciclo de vida específica do Neptune

Ao criar o segundo script de configuração do ciclo de vida para restaurar o backup (de on-create.sh) conforme descrito na postagem no blog, o nome do ciclo de vida deve seguir o formato aws-neptune-*, como aws-neptune-sync-from-s3. Isso garante que a LCC possa ser selecionada durante a criação do bloco de anotações no console do Neptune.

Sincronização específica do Neptune de um snapshot para uma nova instância

Nas etapas descritas na postagem no blog para sincronização de um snapshot para uma nova instância, veja as alterações específicas do Neptune:

• Na etapa 4, escolha notebook-al2-v2.

• Na etapa 5, reutilize o perfil do IAM do bloco de anotações Neptune de origem.

• Entre as etapas 7 e 8:

  • Em Configurações da instância do bloco de anotações, defina um nome que use o formato aws-neptune-*.

  • Abra o menu sanfonado de configurações de Rede e selecione a mesma VPC, sub-rede e grupo de segurança do bloco de anotações de origem.

Etapas específicas do Neptune após a criação do bloco de anotações

1. Selecione o botão Abrir Jupyter para o bloco de anotações. Quando o arquivo SYNC_COMPLETE aparecer no diretório principal, vá para a próxima etapa.

2. Vá para a página de instância do bloco de anotações no console do SageMaker.

3. Interrompa o bloco de anotações.

4. Selecione Edit (Editar).

5. Nas configurações da instância do bloco de anotações, edite o campo Configuração do ciclo de vida selecionando o ciclo de vida original do bloco de anotações Neptune de origem. Observe que esse não é o ciclo de vida de backup do EBS.

6. Selecione Atualizar configurações do bloco de anotações.

7. Inicie o bloco de anotações novamente.

Com as modificações descritas aqui nas etapas contidas na postagem no blog, os blocos de anotações de grafos agora devem ser migrados para uma nova instância do bloco de anotações Neptune que use o ambiente Amazon Linux 2 e JupyterLab 3. Eles aparecerão para acesso e gerenciamento na página do Neptune no AWS Management Console, e agora você pode continuar seu trabalho de onde parou selecionando Open Jupyter ou Abrir JupyterLab.