Amazon Neptune: Een blik op AWS’ volledig beheerde graafdatabase

Amazon Neptune is, als je er nog niet bekend mee bent, een volledig beheerde graafdatabaseservice van AWS, ontworpen voor het opslaan en bevragen van sterk verbonden data zoals sociale netwerken. Het is geoptimaliseerd voor scenario’s waarin relaties tussen datapunten net zo belangrijk zijn als de data zelf.

Zoals je later zult zien, ondersteunt Amazon Neptune twee grote graafmodellen: property graphs, met knooppunten en randen met key-value-eigenschappen, en RDF (Resource Description Framework), dat bestaat uit triples van subject-predicaat-object. Amazon Neptune is compatibel met drie belangrijke querytalen, zoals Gremlin, openCypher en SPARQL. Klinkt allemaal veelbelovend, dus laten we beginnen.

Wat is Amazon Neptune?

Zoals ik al aangaf, is Amazon Neptune een doelgerichte graafdatabase voor razendsnel bevragen van relaties, die miljarden knooppunten en randen met lage latentie aankan. Het ondersteunt property graphs die, dankzij hun flexibiliteit, worden gebruikt voor sociale netwerken, aanbevelingen en netwerkanalyse, en RDF, de standaard voor het semantische web, knowledge graphs en gelinkte data in het algemeen.

Amazon Neptune wordt ingezet in meerdere AWS-regio’s voor wereldwijde dekking en disaster recovery. En voor het geval je je dat afvraagt: het is veilig in gebruik, omdat het voldoet aan belangrijke regelgeving zoals HIPAA voor de gezondheidszorg, PCI DSS voor betalingen en ISO voor algemene beveiliging. Dit maakt het geschikt voor gevoelige en gereguleerde workloads. Wil je meer leren over graafdatabases, lees dan onze blogpost What is A Graph Database? A Beginner's Guide.

Hoe werkt Amazon Neptune?

De database-engine van Amazon Neptune is oorspronkelijk gebaseerd op Blazegraph en is inmiddels door AWS doorontwikkeld voor hoge prestaties en betrouwbaarheid. Het ondersteunt meerdere querytalen, zoals Gremlin voor het traverseren van property graphs (bijv. friends-of-friends vinden in een communitygrafiek), openCypher met declaratieve SQL-achtige syntaxis voor property graph-queries, en SPRQL voor het bevragen van RDF-data en het ondersteunen van semantische relaties en ontologieën.

Neptune slaat data op SSD-ondersteunde clustervolumes op, gerepliceerd over meerdere availability zones voor duurzaamheid, wat de opslag bijzonder snel en responsief maakt voor productbehoeften. Daarnaast ondersteunt het tot 15 read-replica’s om leesverkeer te verdelen en de beschikbaarheid te verhogen, en het gaat soepel om met instance-failures. Dit betekent dat Neptune automatisch overfailt naar een read-replica.

Bovendien beheert AWS efficiënt de hardware, software-updates en back-ups. Neptune is dus een zeer goede keuze voor fouttolerante, self-healing opslag. Volg onze cursus AWS Concepts voor meer diepgaande uitleg en een beter begrip van AWS.

Belangrijkste functies van Amazon Neptune

Amazon Neptune zit vol met functies en voordelen, waardoor het een uitstekende keuze is voor de industrie. In deze sectie neem ik je mee langs de belangrijkste features van Neptune om in gedachten te houden.

Schaalbaarheid en prestaties

Amazon Neptune schaalt erg goed, afhankelijk van je gebruik, met een veelbelovende performance trade-off. Zo vergroot het automatisch de opslag naarmate je data groeit tot 64 TB of zelfs meer, ondersteunt het tienduizenden queries per seconde met hoge throughput, en levert het realtimeresponsen met millisecondenlatentie voor interactieve applicaties, zelfs bij grote, complexe grafen, doordat het efficiënt met miljarden relaties omgaat.

Beveiliging en compliance

De prestaties van Neptune gaan niet ten koste van de beveiliging: alle data is versleuteld in rust met AWS KMS en tijdens transport met TLS, het wordt ingezet binnen een VPC voor private en veilige netwerken, en de toegangsrechten zijn fijnmazig via AWS IAM-rollen en -policies. Dit blijkt ook uit de naleving van regelgeving, want het is gecertificeerd voor HIPAA, PCI DSS en ISO, waardoor het geschikt is voor gereguleerde sectoren.

AWS-integratie

Het zal je niet verbazen dat Amazon Neptune goed integreert met diverse AWS-services en het bredere ecosysteem. Zo kun je bijvoorbeeld eenvoudig grote datasets importeren en exporteren met Amazon S3, prestaties monitoren, alarmen instellen en logs analyseren in Amazon CloudWatch, serverless-functies triggeren op basis van database-events in AWS Lambda, en toepassingen draaien op EC2-instances die met Neptune verbinden.

Daarnaast is Neptune een geweldig hulpmiddel voor ML-taken, omdat het goed aansluit op Amazon SageMaker om machine learning te integreren voor geavanceerde analyses. Er is zelfs een specifieke toepassing, Neptune ML, met ingebouwde machine learning voor taken zoals link prediction en node classification.

Toepassingen van Amazon Neptune

Amazon Neptune zit vol functionaliteit die breed inzetbaar is voor uiteenlopende taken. In deze sectie bespreek ik de real-world-toepassingen van Neptune.

Identiteitsgrafen en klantdata

Neptune’s vermogen om graafdata op te slaan en te bevragen maakt het geschikt om klantdata uit meerdere bronnen te aggregeren tot één profiel. Relatiegegevens worden gebruikt om aanbevelingen en communicatie te personaliseren. Het is ook zeer bruikbaar voor fraudedetectie, zoals het identificeren van creditcardfraude. Dat gebeurt door verdachte patronen te vinden via het analyseren van verbindingen tussen gebruikers, accounts en transacties. Daarnaast leent het zich goed voor doelgroepadvertenties om relevante advertenties te tonen op basis van gebruikersprofielen, dankzij de graafstructuur van de data.

Aanbevelingssystemen

Aanbevelingssystemen leunen doorgaans sterk op graafdata, waardoor de keuze van een geschikte engine cruciaal is in productie. Neptune biedt hiervoor de perfecte gereedschapskist. Een toepassing is e-commerce, waar de oplossing producten moet suggereren op basis van gebruikersgedrag en itemrelaties. Het wordt ook gebruikt op mediaplatformen om films, muziek of artikelen aan te bevelen op basis van voorkeuren en sociale connecties, of om vrienden, groepen of content te suggereren door gebruikersinteracties in sociale netwerken te analyseren, zoals op socialmediaplatformen.

Knowledge graphs en fraudedetectie

Bedrijven integreren tegenwoordig volop AI in hun oplossingen. Een voorbeeld is het gebruik van agentic workflows of AI-gedreven inzichten. Dit gebeurt vaak met knowledge graphs voor robuuste oplossingen. Het werkt door informatie te organiseren en te koppelen voor semantisch zoeken en AI-gedreven inzichten, zoals GraphRAG, of andere veelgebruikte technieken om AI-oplossingen te versterken. Neptune is ook krachtig voor semantische zoektoepassingen om de zoekrelevantie te verbeteren via begrip van relaties tussen entiteiten, en voor financiële diensten om bijvoorbeeld witwassen en fraude te detecteren door complexe transactienetwerken en relaties te traceren. En er zijn nog tal van andere use-cases voor Neptune, zoals drug discovery, netwerkbeveiliging en supply chain management.

Aan de slag met Amazon Neptune

Amazon Neptune is goed geïntegreerd in het AWS-ecosysteem. Daarom neem ik je mee door de belangrijkste setups en technieken om met Neptune te werken.

Neptune instellen

Volg deze stappen om met Neptune te starten:

1. Open de Neptune-sectie van het platform

Klik vervolgens op Launch Amazon Neptune om naar de aanmaakpagina te gaan.

Deze afbeelding toont de voorpagina van Amazon Neptune.

2. Configureer de database-engineopties

Selecteer het type provisioned engine als je vaste capaciteit met handmatige schaalvergroting wilt, of kies serverless als je automatische schaalvergroting op basis van de werklast verkiest. Je kunt de versie kiezen op basis van je specifieke use-case.

Deze afbeelding toont de parameters die je kunt kiezen binnen het paneel Engine options bij het aanmaken van een database.

3. Geef een naam op voor je clusteridentifier

Je kunt een naam kiezen zoals “mydbcluster”. Volg de conventies die in het paneel zijn vermeld.

4. Stel de capaciteitsparameters in

Stel de grenzen in van de Neptune-capaciteitseenheden die tijdens verwerking beschikbaar zijn. Meer capaciteitseenheden kosten meer geld. Het is dus belangrijk rekening te houden met de omvang van je applicatie.

5. Kies een template

Je kunt productietemplates kiezen als je vooraf geconfigureerde instances wilt voor hoge beschikbaarheid, duurzaamheid en prestaties. Maar als je in de ontwikkelfase werkt, raad ik aan om development-templates te gebruiken voor optimale kostenefficiëntie en snel testen met minimale resources, omdat je hoge beschikbaarheid en duurzaamheid op dit moment minder nodig hebt.

Deze afbeelding toont de templates-instellingen binnen het aanmaken van een Neptune-database. 

Zodra je een van de templates kiest, worden de instellingen voor beschikbaarheid en duurzaamheid automatisch gekozen. Een production-template schakelt dus automatisch het aanmaken van replica’s in verschillende zones in, terwijl de development-template dat niet doet.

6. Connectiviteitsinstellingen

Selecteer de Virtual Private Cloud (VPC) waarin het overkoepelende netwerk zit waar je Neptune-cluster in wordt uitgerold. Je kunt ook op aanvullende connectiviteitsconfiguraties klikken om de subnets en security groups te configureren.

Dit onderdeel is cruciaal om alle beveiligingsprotocollen van je cluster te beheren.

Je kunt een snelle verbinding maken via de Notebooks-sectie door links op je scherm op “Notebooks” te klikken:

Er staat standaard een demonotebook, met basisqueries om je databaseverbinding en andere taken te testen. Je kunt ook overschakelen naar de Graph Explorer door rechts op je scherm op actions te klikken. Je kunt ook de meegeleverde endpoint gebruiken om verbinding te maken vanuit applicaties of ontwikkeltools.

Queries schrijven in Amazon Neptune

In deze sectie introduceer ik de “hello world”-queries in elk van de drie talen voor AWS Neptune:

Gremlin

Een Gremlin-query is een keten van bewerkingen/functies die van links naar rechts worden geëvalueerd. Hier is een voorbeeld van het toevoegen van twee vertices en een edge:

g.addV('Person').property('id','1').property('name','Alice')
.as('a').
addV('Person').property('id','2').property('name','Bob')
.as('b').
addE('knows').from('a').to('b');

Waar .addV('Person')…property(…) de engine vertelt een vertex met label "Person" te maken en er eigenschappen zoals "id" en "name" aan toe te voegen. .as('a') / .as('b') geeft elke nieuwe vertex een referentie (“a” en “b”) zodat je ze kunt koppelen. .addE('knows').from('a’).to('b') maakt een edge met het label knows van Alice naar Bob.

Hier is een voorbeeld van ophalen:

g.V().hasLabel('Person').valueMap('id','name');

Waar g.V().hasLabel('Person').valueMap('id','name') alle vertices met het label Person vindt en hun eigenschappen id en name retourneert.

openCypher

Een Cypher-query gebruikt ASCII-art-achtige patronen om graafelementen te maken en te matchen. Zo maak je twee nodes en een relatie aan:

CREATE (a:Person {id: '1', name: 'Alice'}),
(b:Person {id: '2', name: 'Bob'})
CREATE (a)-[:KNOWS]->(b);

Waar (a:Person {…}) een node met het label Person definieert met de eigenschappen id en name. De tweede CREATE gebruikt (a)-[:KNOWS]->(b) om een gerichte KNOWS-relatie van a naar b toe te voegen.

Zo haal je ze op:

MATCH (p:Person)
RETURN p.id, p.name;

Waar MATCH (p:Person) alle nodes met het label Person vindt, en RETURN p.id, p.name de id- en name-eigenschappen van elke node teruggeeft.

SPARQL

Een SPARQL-query werkt met RDF-triples en gebruikt PREFIX-declaraties plus graafpatronen. Zo voeg je twee resources en hun relatie toe:

PREFIX ex: <http://example.com/>
INSERT DATA {
ex:Alice a ex:Person ;
ex:name "Alice" .
ex:Bob a ex:Person ;
ex:name "Bob" .
ex:Alice ex:knows ex:Bob .
}

Waar PREFIX ex:… een verkorte naamruimte definieert. Binnen INSERT DATA eindigt elk blok triples met .: ex:Alice a ex:Person wijst het RDF-type toe, ex:name "Alice" voegt de naamliteral toe en ex:Alice ex:knows ex:Bob creëert de koppeling.

Zo selecteer je ze:

SELECT ?person ?name WHERE {
?person a ex:Person ;
ex:name ?name .
}

Waar ?person a ex:Person alle subjecten van het type ex:Person matcht en ?person ex:name ?name hun ex:name ophaalt in de variabele ?name. 

Monitoring en optimalisatie

CloudWatch correct gebruiken stelt je in staat om de prestaties van Neptune efficiënt te volgen door enhanced monitoring in te schakelen voor gedetailleerde inzichten (tot intervallen van 1 seconde) op CPU-, geheugen-, schijf- en netwerkmetrics. Je kunt ook metrics bekijken zoals Engine CPU Utilization en Freeable Memory om CPU/geheugendruk te herkennen, Buffer Cache Hit Ratio om cache-efficiëntie te begrijpen (hoger is beter), en Query Latency en Query Throughput om te monitoren hoe lang queries duren en hoeveel er per seconde worden verwerkt. Je kunt bovendien dashboards en alarmen instellen met CloudWatch, waarmee je respectievelijk in één oogopslag trends ziet en notificaties of geautomatiseerde schaalvergroting triggert. Daarnaast kun je logs integreren om slow-query logging in Neptune in te schakelen en logs naar CloudWatch Logs te sturen. 

Er zijn natuurlijk veel best practices om je workflows met Neptune verder te optimaliseren, die ik in twee klassen indeel. Als je het verschil tussen AWS CloudTrail en AWS CloudWatch niet scherp hebt, raad ik onze blogpost AWS CloudTrail vs AWS CloudWatch: A Beginner's Guide aan.

Query-optimalisatie

Een goede workflow optimaliseer je door je queries te verbeteren. Hier zijn enkele belangrijke tips om in gedachten te houden bij het bevragen:

• Gebruik indexen en labels: Indexeer in Gremlin/openCypher eigenschappen die vaak bevraagd worden. Bijvoorbeeld g.createIndex('name','vertex') in Gremlin en CREATE INDEX FOR (n:Person) ON (n.name) in openCypher. Gebruik goed gedefinieerde RDF-classes en -predicaten om patroonmatching in SPARQL te versnellen.

• Profile en tune queries: Gebruik EXPLAIN in openCypher of PROFILE in Gremlin om traversals en filterplaatsing te bekijken. Duw filters zo vroeg mogelijk naar voren om minder data te scannen, zoals g.V().has('Person','age',gt(30)).out('knows')…

• Vermijd cartesiaanse producten: Verbind in Cypher altijd patronen met elkaar in plaats van niet-gerelateerde subgrafen te matchen, anders groeit de verwerkingstijd explosief. Voor SPARQL: scope je graafpatronen strak om het kruisen van grote sets te vermijden.

• Gebruik batchwrites en bulkladingen: Bundel het aanmaken van vertices/edges in minder requests of gebruik Neptune’s bulk loader, zoals CSV/JSON op S3, om grote volumes efficiënt in te laden.

Grote datasets beheren

Het beheren van grote datasets is anders dan het werken met kleine, beperkte data, omdat sommige queries microcontroles vereisen die exponentieel in aantal toenemen naarmate de data groeit. Daarom noem ik enkele hulpmiddelen in Amazon Neptune:

• Read-replica’s: Leid leesintensieve workloads om naar maximaal 15 read-replica’s en routeer analytische queries daarheen om de primaire schrijfknoop responsief te houden.
• Archiveer oude data: Pas TTL’s toe of exporteer en verwijder regelmatig verouderde knooppunten/randen om de werkende graaf klein te houden.
• Partitioneer per domein: Splits zeer grote grafen in meerdere clusters, bijvoorbeeld ‘social’ versus ‘transactional’, en routeer queries in je app.
• Monitor opslaggroei: Houd auto-scaling storage in de gaten en stel alerts in, zodat je nooit voor capaciteitsverrassingen komt te staan.
• Beoordeel regelmatig trage queries: Check wekelijks je slow-query-logs en tune of pak problematische patronen aan.

Voor- en nadelen van Amazon Neptune

Neptune biedt veel voordelen en handige tips en tricks. Toch zijn er ook enkele beperkingen waar je rekening mee moet houden bij je keuze.

Amazon Neptune vs. Neo4j en anderen

Graafdatabases strijden tegenwoordig in een razendsnelle competitie, zeker met de opkomst van LLM’s, RAG’s en agentic workflows. Hoewel Neptune veel sterke punten heeft, zijn er talloze potentiële ontwikkelingen gaande, zoals diepere AI/ML-integratie, verbeterde analytics en visualisatie, en meer querytalen of interoperabiliteit.

Er zijn echter veel concurrenten in het speelveld, zoals het bekende Neo4j, dat property graphs biedt en een sterke community heeft, maar minder integratie met AWS. TigerGraph legt daarentegen de nadruk op hoge prestaties, maar is complexer te beheren. ArangoDB is ook een sterke concurrent en biedt multimodeldata zoals grafen, documenten en key-value, maar is niet zo strak geïntegreerd met AWS.

Ik raad Neptune aan als je een beheerde service, AWS-integratie en sterke compliance nodig hebt. Overweeg echter alternatieven als je meer flexibiliteit of multi-cloud-ondersteuning zoekt. Amazon Neptune versus Neo4j kan een lastige vergelijking zijn, dus ik beveel aan om je goed in te lezen voordat je een keuze maakt.

Conclusie

Neptune is ideaal voor toepassingen die sterk verbonden data moeten beheren en analyseren. Het is volledig beheerd, schaalbaar, veilig en diep geïntegreerd met AWS-services en binnen het AWS-ecosysteem.

Blijf leren met ons. Volg onze cursus AWS Concepts als je iets uit dit artikel niet kent, en veel succes met Amazon Neptune!