Usar a bancada de trabalho do Neptune Habilitando CloudWatch registros Hospedagem local Migrando para 3 JupyterLab

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 fornece Jupyter e JupyterLabnotebooks no projeto de caderno gráfico Neptune de código aberto e na bancada de trabalho Neptune. GitHub 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 Neptune permite que você execute notebooks Jupyter em um ambiente totalmente gerenciado, hospedado na SageMaker Amazon, e carregue automaticamente a versão mais recente do projeto de caderno gráfico Neptune para você. É fácil configurar a bancada de trabalho no console do Neptune ao criar um banco de dados do Neptune.

nota
Ao criar uma instância do notebook Neptune, você tem duas opções de acesso à rede: acesso direto pela SageMaker Amazon (o padrão) e acesso por meio de uma VPC. Em qualquer uma das opções, o notebook requer acesso à Internet para buscar dependências de pacotes para instalar o Neptune Workbench. A falta de acesso à Internet fará com que a criação de uma instância do notebook Neptune falhe.
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ê é cobrado pelos recursos do Workbench por meio da Amazon SageMaker, separadamente do faturamento do Neptune. Consulte a página Preços do Neptune. O Jupyter e JupyterLab os notebooks criados na bancada de trabalho Neptune usam um ambiente Amazon Linux 2 e 3. JupyterLab Para obter mais informações sobre o suporte a JupyterLab notebooks, consulte a SageMakerdocumentação da Amazon.

Você pode criar um Jupyter ou um JupyterLab notebook usando a bancada de trabalho Neptune de duas maneiras: AWS Management Console

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.

Para criar um Jupyter ou JupyterLab notebook usando o menu Notebooks

Faça login no AWS Management Console e abra o console do Amazon Neptune em https://console.aws.amazon.com/neptune/home.
No painel de navegação à esquerda, escolha Notebooks (Blocos de anotações).
Escolha Criar caderno.
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.
Selecione um Tipo de instância de caderno.
Insira um nome para o seu bloco de anotações e, opcionalmente, uma descrição.
A menos que você já tenha criado uma função AWS Identity and Access Management (IAM) para seus notebooks, escolha Criar uma função do IAM e insira um nome de função 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.
Escolha Criar caderno. O processo de criação pode levar de cinco a dez minutos até que tudo esteja pronto.
Depois que seu notebook 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.

Usando Python para conectar um SageMaker notebook genérico ao Neptune

Conectar um notebook ao Netuno é fácil se você tiver instalado o Neptune Magics, mas também é possível conectar um notebook SageMaker ao Netuno usando Python, mesmo se você não estiver usando um notebook Neptune.

Etapas a serem seguidas para se conectar ao Neptune em uma célula de notebook SageMaker

Instale o cliente do Python em Gremlin:
```
!pip install gremlinpython
```
Os notebooks Neptune instalam o cliente Gremlin Python para você, então essa etapa só é necessária se você estiver usando um notebook simples. SageMaker

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')

Ativando CloudWatch registros nos notebooks Neptune

CloudWatch os registros agora estão habilitados por padrão para o Neptune Notebooks. Se você tiver um notebook antigo que não esteja produzindo CloudWatch registros, siga estas etapas para habilitá-los manualmente:

Faça login no AWS Management Console e abra o SageMaker console.
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.
Acesse a página de detalhes selecionando o nome dessa instância do bloco de anotações.
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.
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.

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": "*"
    }
  ]
}

Salve essa nova política e anexe-a ao perfil do IAM encontrado na etapa 4.
Clique em Iniciar no canto superior direito da página de detalhes da instância do SageMaker notebook.
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 um notebook falhar ao iniciar, haverá uma mensagem na página de detalhes do notebook no SageMaker console, informando que a instância do notebook demorou mais de 5 minutos para iniciar. CloudWatch registros 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:

É 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 Neptune no back-end, talvez queira executar os notebooks na Amazon. SageMaker Conectar-se ao Neptune a SageMaker partir de pode ser mais conveniente do que a partir de uma instalação local dos notebooks e permitirá que você trabalhe mais facilmente com o Neptune ML.

Para obter instruções sobre como configurar cadernos em SageMaker, consulte Lançamento de cadernos gráficos usando a 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. Você pode encontrar instruções sobre como configurar em Conectando o caderno gráfico localmente ao Amazon Neptune na pasta additional-databases/neptune do projeto do notebook gráfico. 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. Exemplos são o servidor TinkerPop Gremlin 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:

O caderno gráfico Conectando a uma pasta do Gremlin Server. GitHub
A pasta de configuração do Gremlin do notebook gráfico. 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 de configuração Blazegraph do notebook gráfico. GitHub

Migrando seus cadernos Neptune do Jupyter para o 3 JupyterLab

Os blocos de anotações Neptune criados antes de 21 de dezembro de 2022 usam o ambiente Amazon Linux 1. Você pode migrar notebooks Jupyter antigos criados antes dessa data para o novo ambiente Amazon Linux 2 com JupyterLab 3 seguindo as etapas descritas nesta postagem do AWS blog: Migre seu trabalho para uma SageMaker instância de notebook Amazon com o 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

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.
Acesse a página da instância do notebook no SageMaker console.
Interrompa o bloco de anotações.
Selecione Edit (Editar).
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.
Selecione Atualizar configurações do bloco de anotações.
Inicie o bloco de anotações novamente.

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

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Conceitos básicos

Magias da bancada de trabalho