What is AWS Neptune?

Note: Check out the Property graphs vs. RDF Answer to learn more about graphs and RDFs.

Here are some key features of AWS Neptune:

High availability

AWS Neptune has automatic failover and backup features, so you can be sure that your data will always be dependable and accessible. For applications that require continuous service, this is crucial.

Security

AWS places a high premium on security, and Neptune is no different. It can be integrated with AWS Identity and Access Management (IAM) to provide more precise access control, and it offers encryption both in transit and at rest. This guarantees the security of your data.

Scalability

Through Neptune, scaling your graph database up or down to meet your application’s demands is simple. Neptune can adjust to accommodate both little datasets and large graphs.

Compatibility

Popular graph query languages, such as SPARQL[object Object] for RDF and Apache TinkerPop Gremlin[object Object] for Property Graph, are compatible with Neptune. Developers who are familiar with these query languages can now access it.

Use cases for AWS Neptune

AWS Neptune is appropriate for several application cases, including:

Social networking: Creating social networking sites emphasizing user relationships, content, and interactions.
Recommendation engines: Provide individualized suggestions based on user behavior and preferences using recommendation systems.
Fraud detection: Fraud detection looks for patterns and relationships in big datasets to identify fraudulent activity.
Knowledge graphs: Building knowledge graphs in various fields, including education or healthcare, to arrange and find information.

import boto3
# Create a session with configured credentials
session = boto3.Session(
    aws_access_key_id=aws_access_key,
    aws_secret_access_key=aws_secret_key,
    region_name='us-east-1'
)
# Initialize the Neptune and EC2 client using the configured session
neptune = session.client('neptune')
ec2 = session.client('ec2')
# Get the default VPC
response = ec2.describe_vpcs(
    Filters=[
        {
            'Name': 'isDefault',
            'Values': ['true']
        }
    ]
)
default_vpc_id = response['Vpcs'][0]['VpcId']
# Get subnets in the default VPC
response = ec2.describe_subnets(
    Filters=[
        {
            'Name': 'vpc-id',
            'Values': [default_vpc_id]
        }
    ]
)
subnet_ids = [subnet['SubnetId'] for subnet in response['Subnets']]
# Create a DB subnet group
db_subnet_group_name = 'default-vpc-subnet-group'
try:
    response = neptune.create_db_subnet_group(
        DBSubnetGroupName=db_subnet_group_name,
        DBSubnetGroupDescription='Subnet group for Neptune DB in the default VPC',
        SubnetIds=subnet_ids
    )
    print('DB Subnet Group Created:')
except neptune.exceptions.DBSubnetGroupAlreadyExistsFault:
    print(f'DB Subnet Group {db_subnet_group_name} already exists.')
except Exception as e:
    print(f'Error: {e}')
# Define cluster parameters
cluster_identifier = 'educative-neptune-cluster'
instance_class = 'db.r5.large'
# Create the Neptune cluster
response = neptune.create_db_cluster(
    DBClusterIdentifier=cluster_identifier,
    Engine='neptune',
    DBSubnetGroupName=db_subnet_group_name ,
    AvailabilityZones=['us-east-1a'],
    BackupRetentionPeriod=7,
    Port=8182,  # Default port for Neptune
)
print("Neptune cluster created with ID:", response['DBCluster']['DBClusterIdentifier'])

After successfully running the code, you can verify the creation of the cluster by following the steps below:

Log in to your AWS account to open the AWS Management Console.
On the AWS Management Console, search for “Neptune” and select “Neptune” from the search results.
On the Neptune dashboard, click “Clusters” from the sidebar menu.
On the clusters dashboard, notice the educative-neptune-cluster and its status.

Code explanation:

Line 1: We import the boto3 library to connect with AWS services using Python.
Lines 4–8: We initiate a boto3 session, which will be used to call AWS resources.
Lines 11–12: We initialize the Neptune and EC2 client using the configured session.
Lines 27–34: We fetch the list of the subnets in the default-vpc.
Line 37: We define the name for the default subnet group.
Lines 39–49: We create a database subnet group for Neptune in default-vpc.
Lines 52–53: We define parameters for creating the Neptune cluster, including the cluster identifier and instance class.
Lines 56–63: We create the Neptune cluster using neptune.create_db_cluster(). We set various parameters, such as the cluster identifier, engine type, master user password, username, subnet group, availability zones, backup retention period, and port.
Line 65: We print a message indicating the successful creation of the Neptune cluster, along with its identifier.

Conclusion

AWS Neptune is a great complement to the AWS ecosystem for apps that handle highly linked data. For graph database needs, its scalability, security capabilities, and completely managed nature make it an appealing option. AWS Neptune makes storing and querying data easier, freeing you up to concentrate on the essential features of your application, whether you’re developing a social network, recommendation system, or any other application that depends on intricate relationships.

Free Resources

Learn in-demand tech skills in half the time

PRODUCTS

Mock Interview

New

Courses

Skill Paths

Projects

Assessments