Neo4j Cheatsheet

> > > > > > "Clase de inscripción" Neo4j es una base de datos gráfica nativa altamente escalable que aprovecha las relaciones de datos como entidades de primera clase, ayudando a las empresas a crear aplicaciones inteligentes para hacer frente a los desafíos de datos en evolución de hoy. ▪/p] ■/div titulada

########################################################################################################################################################################################################################################################## Copiar todos los comandos

########################################################################################################################################################################################################################################################## Generar PDF seleccionado/button

■/div titulada ■/div titulada

Cuadro de contenidos

• Instalación
• Basic Operations
• Cypher Query Language
• Nodos y relaciones
• Data Import/Export
• Indexes and Constraints
• Perfeccionamiento Optimización
• Administración
• Seguridad
• Clustering
• Monitoreo
• Las mejores prácticas

Instalación

Instalación Ubuntu/Debian

# Add Neo4j repository
wget -O - https://debian.neo4j.com/neotechnology.gpg.key | sudo apt-key add -
echo 'deb https://debian.neo4j.com stable latest' | sudo tee /etc/apt/sources.list.d/neo4j.list

# Update package index
sudo apt update

# Install Neo4j Community Edition
sudo apt install neo4j

# Install Neo4j Enterprise Edition (requires license)
sudo apt install neo4j-enterprise

# Start Neo4j service
sudo systemctl start neo4j
sudo systemctl enable neo4j

# Check status
sudo systemctl status neo4j

# Access Neo4j Browser
# http://localhost:7474
# Default credentials: neo4j/neo4j (change on first login)

CentOS/RHEL Instalación

# Add Neo4j repository
sudo rpm --import https://debian.neo4j.com/neotechnology.gpg.key

sudo tee /etc/yum.repos.d/neo4j.repo << EOF
[neo4j]
name=Neo4j RPM Repository
baseurl=https://yum.neo4j.com/stable
enabled=1
gpgcheck=1
EOF

# Install Neo4j
sudo yum install neo4j

# Start Neo4j service
sudo systemctl start neo4j
sudo systemctl enable neo4j

# Check status
sudo systemctl status neo4j

Docker Instalación

# Pull Neo4j image
docker pull neo4j:latest

# Run Neo4j container
docker run \
    --name neo4j \
    -p 7474:7474 -p 7687:7687 \
    -d \
    -v neo4j-data:/data \
    -v neo4j-logs:/logs \
    -v neo4j-import:/var/lib/neo4j/import \
    -v neo4j-plugins:/plugins \
    --env NEO4J_AUTH=neo4j/password \
    neo4j:latest

# Run with custom configuration
docker run \
    --name neo4j \
    -p 7474:7474 -p 7687:7687 \
    -d \
    -v neo4j-data:/data \
    -v neo4j-logs:/logs \
    --env NEO4J_AUTH=neo4j/password \
    --env NEO4J_dbms_memory_heap_initial__size=1G \
    --env NEO4J_dbms_memory_heap_max__size=1G \
    --env NEO4J_dbms_memory_pagecache_size=1G \
    neo4j:latest

# Docker Compose setup
cat > docker-compose.yml << EOF
version: '3.8'
services:
  neo4j:
    image: neo4j:latest
    container_name: neo4j
    ports:
      - "7474:7474"
      - "7687:7687"
    environment:
      - NEO4J_AUTH=neo4j/password
      - NEO4J_dbms_memory_heap_initial__size=1G
      - NEO4J_dbms_memory_heap_max__size=1G
      - NEO4J_dbms_memory_pagecache_size=1G
    volumes:
      - neo4j-data:/data
      - neo4j-logs:/logs
      - neo4j-import:/var/lib/neo4j/import
      - neo4j-plugins:/plugins
    restart: unless-stopped

volumes:
  neo4j-data:
  neo4j-logs:
  neo4j-import:
  neo4j-plugins:
EOF

docker-compose up -d

Instalación manual

# Download Neo4j
wget https://neo4j.com/artifact.php?name=neo4j-community-5.13.0-unix.tar.gz -O neo4j-community-5.13.0-unix.tar.gz

# Extract
tar -xzf neo4j-community-5.13.0-unix.tar.gz
sudo mv neo4j-community-5.13.0 /opt/neo4j

# Set environment variables
echo 'export NEO4J_HOME=/opt/neo4j' >> ~/.bashrc
echo 'export PATH=$PATH:$NEO4J_HOME/bin' >> ~/.bashrc
source ~/.bashrc

# Set initial password
neo4j-admin dbms set-initial-password password

# Start Neo4j
neo4j start

# Check status
neo4j status

# Stop Neo4j
neo4j stop

# Access Neo4j Browser
# http://localhost:7474

Operaciones básicas

Navegador Neo4j

# Access Neo4j Browser
http://localhost:7474

# Connect with credentials
# Username: neo4j
# Password: (set during installation)

# Basic browser commands
:help          // Show help
:clear         // Clear the result frame
:history       // Show command history
:config        // Show configuration
:schema        // Show database schema
:sysinfo       // Show system information
:queries       // Show running queries
:server status // Show server status

Cypher Shell

# Connect to Neo4j using Cypher Shell
cypher-shell

# Connect with specific credentials
cypher-shell -u neo4j -p password

# Connect to specific database
cypher-shell -d mydb

# Execute Cypher from file
cypher-shell -f script.cypher

# Execute single command
cypher-shell "MATCH (n) RETURN count(n);"

# Connect to remote Neo4j
cypher-shell -a bolt://remote-host:7687 -u neo4j -p password

Configuración

# Main configuration file
/etc/neo4j/neo4j.conf

# Common configuration settings
# Memory settings
dbms.memory.heap.initial_size=1G
dbms.memory.heap.max_size=1G
dbms.memory.pagecache.size=1G

# Network settings
dbms.default_listen_address=0.0.0.0
dbms.connector.bolt.listen_address=:7687
dbms.connector.http.listen_address=:7474
dbms.connector.https.listen_address=:7473

# Security settings
dbms.security.auth_enabled=true
dbms.security.allow_csv_import_from_file_urls=true

# Logging
dbms.logs.query.enabled=true
dbms.logs.query.threshold=0

# Transaction settings
dbms.transaction.timeout=60s
dbms.transaction.concurrent.maximum=1000

# Apply configuration changes
sudo systemctl restart neo4j

Cipher Query Language

Sintaxis básica

-- Comments in Cypher
// Single line comment
/* Multi-line
   comment */

-- Case sensitivity
// Keywords are case-insensitive: MATCH, match, Match
// Labels, property names, and variables are case-sensitive

-- Basic query structure
MATCH (pattern)
WHERE condition
RETURN result
ORDER BY property
LIMIT number;

-- Variables and patterns
MATCH (n)           // Variable 'n' represents any node
MATCH (p:Person)    // Variable 'p' represents nodes with label 'Person'
MATCH ()-[r]->()    // Variable 'r' represents any relationship
MATCH (a)-[:KNOWS]->(b)  // Specific relationship type

Tipos de datos

-- Primitive types
RETURN 42 AS integer;
RETURN 3.14 AS float;
RETURN "Hello" AS string;
RETURN true AS boolean;
RETURN null AS nullValue;

-- Temporal types
RETURN date('2023-12-01') AS dateValue;
RETURN time('14:30:00') AS timeValue;
RETURN datetime('2023-12-01T14:30:00') AS datetimeValue;
RETURN duration('P1Y2M3DT4H5M6S') AS durationValue;

-- Composite types
RETURN [1, 2, 3] AS list;
RETURN {name: 'John', age: 30} AS map;

-- Spatial types
RETURN point({x: 3, y: 4}) AS cartesianPoint;
RETURN point({latitude: 40.7128, longitude: -74.0060}) AS geographicPoint;

Pattern Matching

-- Node patterns
MATCH (n)                    // Any node
MATCH (p:Person)             // Node with label Person
MATCH (p:Person:Employee)    // Node with multiple labels
MATCH (p {name: 'John'})     // Node with property
MATCH (p:Person {name: 'John', age: 30})  // Node with label and properties

-- Relationship patterns
MATCH (a)-[r]->(b)           // Any relationship from a to b
MATCH (a)-[:KNOWS]->(b)      // Specific relationship type
MATCH (a)-[r:KNOWS]->(b)     // Relationship with variable
MATCH (a)-[:KNOWS|LIKES]->(b) // Multiple relationship types
MATCH (a)-[*1..3]->(b)       // Variable length path (1 to 3 hops)
MATCH (a)-[*]->(b)           // Variable length path (any length)

-- Bidirectional relationships
MATCH (a)-[:KNOWS]-(b)       // Relationship in either direction
MATCH (a)<-[:KNOWS]-(b)      // Relationship from b to a

-- Complex patterns
MATCH (a:Person)-[:KNOWS]->(b:Person)-[:WORKS_FOR]->(c:Company)
WHERE a.age > 25 AND c.name = 'TechCorp'
RETURN a.name, b.name, c.name;

Nodos y relaciones

Crear nodos

-- Create single node
CREATE (n);

-- Create node with label
CREATE (p:Person);

-- Create node with properties
CREATE (p:Person {name: 'John Doe', age: 30, email: 'john@example.com'});

-- Create multiple nodes
CREATE (p1:Person {name: 'Alice'}), (p2:Person {name: 'Bob'});

-- Create node with multiple labels
CREATE (p:Person:Employee {name: 'John', department: 'IT'});

-- Create and return node
CREATE (p:Person {name: 'Jane'})
RETURN p;

-- Create node with computed properties
CREATE (p:Person {
  name: 'John',
  created: datetime(),
  id: randomUUID()
});

Crear relaciones

-- Create relationship between existing nodes
MATCH (a:Person {name: 'Alice'}), (b:Person {name: 'Bob'})
CREATE (a)-[:KNOWS]->(b);

-- Create relationship with properties
MATCH (a:Person {name: 'Alice'}), (b:Person {name: 'Bob'})
CREATE (a)-[:KNOWS {since: date('2020-01-01'), strength: 0.8}]->(b);

-- Create nodes and relationship in one statement
CREATE (a:Person {name: 'Alice'})-[:KNOWS]->(b:Person {name: 'Bob'});

-- Create bidirectional relationship
MATCH (a:Person {name: 'Alice'}), (b:Person {name: 'Bob'})
CREATE (a)-[:KNOWS]->(b), (b)-[:KNOWS]->(a);

-- Create multiple relationships
MATCH (p:Person {name: 'John'}), (c1:Company {name: 'TechCorp'}), (c2:Company {name: 'DataInc'})
CREATE (p)-[:WORKS_FOR {start: date('2020-01-01')}]->(c1),
       (p)-[:PREVIOUSLY_WORKED_FOR {start: date('2018-01-01'), end: date('2019-12-31')}]->(c2);

Datos de lectura

-- Return all nodes
MATCH (n) RETURN n;

-- Return nodes with specific label
MATCH (p:Person) RETURN p;

-- Return specific properties
MATCH (p:Person) RETURN p.name, p.age;

-- Return with aliases
MATCH (p:Person) RETURN p.name AS name, p.age AS age;

-- Return relationships
MATCH (a:Person)-[r:KNOWS]->(b:Person)
RETURN a.name, type(r), b.name;

-- Return paths
MATCH path = (a:Person)-[:KNOWS]->(b:Person)
RETURN path;

-- Count nodes
MATCH (p:Person) RETURN count(p);

-- Distinct values
MATCH (p:Person) RETURN DISTINCT p.department;

-- Limit results
MATCH (p:Person) RETURN p LIMIT 10;

-- Order results
MATCH (p:Person) RETURN p ORDER BY p.age DESC;

-- Skip results (pagination)
MATCH (p:Person) RETURN p ORDER BY p.name SKIP 10 LIMIT 10;

Actualización de datos

-- Update node properties
MATCH (p:Person {name: 'John'})
SET p.age = 31, p.updated = datetime();

-- Add new property
MATCH (p:Person {name: 'John'})
SET p.email = 'john.doe@example.com';

-- Update using map
MATCH (p:Person {name: 'John'})
SET p += {age: 31, city: 'New York'};

-- Replace all properties
MATCH (p:Person {name: 'John'})
SET p = {name: 'John Doe', age: 31, email: 'john@example.com'};

-- Add label
MATCH (p:Person {name: 'John'})
SET p:Employee;

-- Remove property
MATCH (p:Person {name: 'John'})
REMOVE p.email;

-- Remove label
MATCH (p:Person {name: 'John'})
REMOVE p:Employee;

-- Update relationship properties
MATCH (a:Person)-[r:KNOWS]->(b:Person)
WHERE a.name = 'Alice' AND b.name = 'Bob'
SET r.strength = 0.9, r.updated = datetime();

Eliminación de datos

-- Delete node (must delete relationships first)
MATCH (p:Person {name: 'John'})
DELETE p;

-- Delete node and all its relationships
MATCH (p:Person {name: 'John'})
DETACH DELETE p;

-- Delete relationship
MATCH (a:Person)-[r:KNOWS]->(b:Person)
WHERE a.name = 'Alice' AND b.name = 'Bob'
DELETE r;

-- Delete multiple nodes
MATCH (p:Person)
WHERE p.age < 18
DETACH DELETE p;

-- Delete all data (use with caution!)
MATCH (n)
DETACH DELETE n;

-- Conditional delete
MATCH (p:Person)
WHERE p.lastLogin < date('2022-01-01')
DETACH DELETE p;

Importación de datos/Exportación

CSV Importación

-- Load CSV with headers
LOAD CSV WITH HEADERS FROM 'file:///people.csv' AS row
CREATE (p:Person {
  name: row.name,
  age: toInteger(row.age),
  email: row.email
});

-- Load CSV without headers
LOAD CSV FROM 'file:///people.csv' AS row
CREATE (p:Person {
  name: row[0],
  age: toInteger(row[1]),
  email: row[2]
});

-- Load CSV from URL
LOAD CSV WITH HEADERS FROM 'https://example.com/data.csv' AS row
CREATE (p:Person {name: row.name, age: toInteger(row.age)});

-- Load CSV with field terminator
LOAD CSV WITH HEADERS FROM 'file:///data.tsv' AS row
FIELDTERMINATOR '\t'
CREATE (p:Person {name: row.name});

-- Batch processing for large files
:auto USING PERIODIC COMMIT 1000
LOAD CSV WITH HEADERS FROM 'file:///large_file.csv' AS row
CREATE (p:Person {name: row.name, age: toInteger(row.age)});

-- Load relationships from CSV
LOAD CSV WITH HEADERS FROM 'file:///relationships.csv' AS row
MATCH (a:Person {id: row.from_id}), (b:Person {id: row.to_id})
CREATE (a)-[:KNOWS {since: date(row.since)}]->(b);

-- Error handling during import
LOAD CSV WITH HEADERS FROM 'file:///people.csv' AS row
WITH row WHERE row.name IS NOT NULL
CREATE (p:Person {
  name: row.name,
  age: CASE WHEN row.age IS NOT NULL THEN toInteger(row.age) ELSE null END
});

APOC Import/Export

-- Install APOC plugin first
-- Download from: https://github.com/neo4j-contrib/neo4j-apoc-procedures

-- Export to CSV
CALL apoc.export.csv.all("all-data.csv", {});

-- Export specific nodes to CSV
CALL apoc.export.csv.query(
  "MATCH (p:Person) RETURN p.name, p.age, p.email",
  "people.csv",
  {}
);

-- Export to JSON
CALL apoc.export.json.all("all-data.json", {});

-- Import from JSON
CALL apoc.load.json("file:///data.json") YIELD value
CREATE (p:Person {
  name: value.name,
  age: value.age
});

-- Import from XML
CALL apoc.load.xml("file:///data.xml") YIELD value
UNWIND value._children AS person
CREATE (p:Person {
  name: person.name._text,
  age: toInteger(person.age._text)
});

-- Import from database
CALL apoc.load.jdbc(
  "jdbc:mysql://localhost:3306/mydb",
  "SELECT name, age FROM people"
) YIELD row
CREATE (p:Person {name: row.name, age: row.age});

Herramienta de importación a granel

# Neo4j Admin Import Tool (for initial data load)
# Prepare CSV files: nodes.csv, relationships.csv

# Import nodes and relationships
neo4j-admin database import full \
  --nodes=Person=people.csv \
  --nodes=Company=companies.csv \
  --relationships=WORKS_FOR=works_for.csv \
  --relationships=KNOWS=knows.csv \
  neo4j

# Import with custom delimiters
neo4j-admin database import full \
  --delimiter="|" \
  --array-delimiter=";" \
  --nodes=Person=people.csv \
  --relationships=KNOWS=relationships.csv \
  neo4j

# Example CSV format for nodes (people.csv)
# personId:ID,name,age:int,:LABEL
# 1,Alice,30,Person
# 2,Bob,25,Person

# Example CSV format for relationships (knows.csv)
# :START_ID,:END_ID,:TYPE,since
# 1,2,KNOWS,2020-01-01

Índices y Limitaciones

Índices

-- Create index on single property
CREATE INDEX person_name_index FOR (p:Person) ON (p.name);

-- Create index on multiple properties (composite index)
CREATE INDEX person_name_age_index FOR (p:Person) ON (p.name, p.age);

-- Create text index for full-text search
CREATE FULLTEXT INDEX person_fulltext_index FOR (p:Person) ON EACH [p.name, p.description];

-- Create index on relationship property
CREATE INDEX knows_since_index FOR ()-[r:KNOWS]-() ON (r.since);

-- Show all indexes
SHOW INDEXES;

-- Show specific index
SHOW INDEX YIELD name, labelsOrTypes, properties WHERE name = 'person_name_index';

-- Drop index
DROP INDEX person_name_index;

-- Create index if not exists
CREATE INDEX person_email_index IF NOT EXISTS FOR (p:Person) ON (p.email);

Constraints

-- Unique constraint
CREATE CONSTRAINT person_email_unique FOR (p:Person) REQUIRE p.email IS UNIQUE;

-- Node key constraint (multiple properties must be unique together)
CREATE CONSTRAINT person_name_age_key FOR (p:Person) REQUIRE (p.name, p.age) IS NODE KEY;

-- Property existence constraint (Enterprise Edition)
CREATE CONSTRAINT person_name_exists FOR (p:Person) REQUIRE p.name IS NOT NULL;

-- Relationship property existence constraint
CREATE CONSTRAINT knows_since_exists FOR ()-[r:KNOWS]-() REQUIRE r.since IS NOT NULL;

-- Show all constraints
SHOW CONSTRAINTS;

-- Drop constraint
DROP CONSTRAINT person_email_unique;

-- Create constraint if not exists
CREATE CONSTRAINT person_id_unique IF NOT EXISTS FOR (p:Person) REQUIRE p.id IS UNIQUE;

Búsqueda de texto completo

-- Create full-text index
CREATE FULLTEXT INDEX person_search FOR (p:Person) ON EACH [p.name, p.description, p.bio];

-- Search using full-text index
CALL db.index.fulltext.queryNodes("person_search", "john AND developer") YIELD node, score
RETURN node.name, node.description, score;

-- Search with fuzzy matching
CALL db.index.fulltext.queryNodes("person_search", "john~") YIELD node, score
RETURN node.name, score;

-- Search with wildcards
CALL db.index.fulltext.queryNodes("person_search", "john*") YIELD node, score
RETURN node.name, score;

-- Search with phrase
CALL db.index.fulltext.queryNodes("person_search", '"software developer"') YIELD node, score
RETURN node.name, score;

-- Search relationships
CREATE FULLTEXT INDEX review_search FOR ()-[r:REVIEWED]-() ON EACH [r.title, r.content];

CALL db.index.fulltext.queryRelationships("review_search", "excellent") YIELD relationship, score
RETURN relationship, score;

Optimización del rendimiento

Optimización de consultas

-- Use EXPLAIN to see query plan
EXPLAIN
MATCH (p:Person {name: 'John'})
RETURN p;

-- Use PROFILE to see actual execution statistics
PROFILE
MATCH (p:Person)-[:KNOWS]->(friend:Person)
WHERE p.age > 30
RETURN p.name, collect(friend.name);

-- Use indexes for WHERE clauses
// Good: Uses index
MATCH (p:Person)
WHERE p.email = 'john@example.com'
RETURN p;

// Bad: Full scan
MATCH (p:Person)
WHERE p.email CONTAINS '@example.com'
RETURN p;

-- Use LIMIT to reduce result set
MATCH (p:Person)
RETURN p
ORDER BY p.created DESC
LIMIT 10;

-- Use WITH for intermediate processing
MATCH (p:Person)-[:KNOWS]->(friend:Person)
WITH p, count(friend) AS friendCount
WHERE friendCount > 5
RETURN p.name, friendCount;

-- Avoid Cartesian products
// Bad: Cartesian product
MATCH (p:Person), (c:Company)
WHERE p.company = c.name
RETURN p, c;

// Good: Use relationships
MATCH (p:Person)-[:WORKS_FOR]->(c:Company)
RETURN p, c;

Gestión de memoria

-- Use PERIODIC COMMIT for large operations (Legacy)
:auto USING PERIODIC COMMIT 1000
LOAD CSV WITH HEADERS FROM 'file:///large_file.csv' AS row
CREATE (p:Person {name: row.name});

-- Use CALL IN TRANSACTIONS for batching (Neo4j 4.4+)
:auto
LOAD CSV WITH HEADERS FROM 'file:///large_file.csv' AS row
CALL {
  WITH row
  CREATE (p:Person {name: row.name, age: toInteger(row.age)})
} IN TRANSACTIONS OF 1000 ROWS;

-- Limit memory usage with LIMIT
MATCH (p:Person)
WITH p
ORDER BY p.created
LIMIT 1000
MATCH (p)-[:KNOWS]->(friend)
RETURN p.name, collect(friend.name);

Query Hints

-- Force index usage
MATCH (p:Person)
USING INDEX p:Person(name)
WHERE p.name = 'John'
RETURN p;

-- Force scan
MATCH (p:Person)
USING SCAN p:Person
WHERE p.age > 30
RETURN p;

-- Join hint
MATCH (p:Person), (c:Company)
USING JOIN ON p
WHERE p.company_id = c.id
RETURN p, c;

Administración

Gestión de bases de datos

-- Show databases
SHOW DATABASES;

-- Create database
CREATE DATABASE mydb;

-- Use database
:use mydb;

-- Drop database
DROP DATABASE mydb;

-- Start database
START DATABASE mydb;

-- Stop database
STOP DATABASE mydb;

-- Show default database
SHOW DEFAULT DATABASE;

-- Set default database
ALTER DATABASE mydb SET ACCESS READ WRITE;

Gestión de usuarios

-- Show users
SHOW USERS;

-- Create user
CREATE USER alice SET PASSWORD 'password123' CHANGE NOT REQUIRED;

-- Create user with password change required
CREATE USER bob SET PASSWORD 'temp123' CHANGE REQUIRED;

-- Change user password
ALTER USER alice SET PASSWORD 'newpassword123';

-- Drop user
DROP USER alice;

-- Show current user
SHOW CURRENT USER;

-- Show user privileges
SHOW USER alice PRIVILEGES;

Función de gestión

-- Show roles
SHOW ROLES;

-- Create role
CREATE ROLE developer;

-- Grant role to user
GRANT ROLE developer TO alice;

-- Revoke role from user
REVOKE ROLE developer FROM alice;

-- Drop role
DROP ROLE developer;

-- Show role privileges
SHOW ROLE developer PRIVILEGES;

Privilege Management

-- Grant database privileges
GRANT ACCESS ON DATABASE mydb TO alice;
GRANT START ON DATABASE mydb TO developer;
GRANT STOP ON DATABASE mydb TO admin;

-- Grant graph privileges
GRANT MATCH {*} ON GRAPH mydb TO alice;
GRANT CREATE ON GRAPH mydb TO developer;
GRANT DELETE ON GRAPH mydb TO admin;

-- Grant specific node privileges
GRANT MATCH {Person} ON GRAPH mydb TO alice;
GRANT CREATE ON GRAPH mydb NODES Person TO developer;

-- Grant relationship privileges
GRANT MATCH {KNOWS} ON GRAPH mydb TO alice;
GRANT CREATE ON GRAPH mydb RELATIONSHIPS KNOWS TO developer;

-- Revoke privileges
REVOKE ACCESS ON DATABASE mydb FROM alice;
REVOKE MATCH {*} ON GRAPH mydb FROM alice;

-- Show privileges
SHOW PRIVILEGES;
SHOW USER alice PRIVILEGES;
SHOW ROLE developer PRIVILEGES;

Respaldo y restauración

# Online backup (Enterprise Edition)
neo4j-admin database backup --to-path=/backup/location mydb

# Full backup
neo4j-admin database backup --to-path=/backup/location --include-metadata=all mydb

# Incremental backup
neo4j-admin database backup --to-path=/backup/location --incremental mydb

# Restore from backup
neo4j-admin database restore --from-path=/backup/location mydb

# Dump database
neo4j-admin database dump --to-path=/dump/location mydb

# Load database from dump
neo4j-admin database load --from-path=/dump/location mydb

# Copy database
neo4j-admin database copy --to-path=/copy/location mydb

Seguridad

Autenticación

# Configuration in neo4j.conf
dbms.security.auth_enabled=true
dbms.security.auth_provider=native

# LDAP authentication (Enterprise Edition)
dbms.security.auth_provider=ldap
dbms.security.ldap.host=ldap.example.com
dbms.security.ldap.port=389
dbms.security.ldap.user_dn_template=cn={0},ou=users,dc=example,dc=com

# Active Directory authentication
dbms.security.auth_provider=ldap
dbms.security.ldap.host=ad.example.com
dbms.security.ldap.port=389
dbms.security.ldap.user_dn_template={0}@example.com

SSL/TLS Configuración

# Enable HTTPS
dbms.connector.https.enabled=true
dbms.connector.https.listen_address=:7473

# SSL certificates
dbms.ssl.policy.https.enabled=true
dbms.ssl.policy.https.base_directory=certificates/https
dbms.ssl.policy.https.private_key=private.key
dbms.ssl.policy.https.public_certificate=public.crt

# Bolt SSL
dbms.connector.bolt.tls_level=REQUIRED
dbms.ssl.policy.bolt.enabled=true
dbms.ssl.policy.bolt.base_directory=certificates/bolt

Network Security

# Bind to specific interfaces
dbms.default_listen_address=10.0.0.1
dbms.connector.bolt.listen_address=10.0.0.1:7687
dbms.connector.http.listen_address=10.0.0.1:7474

# Disable HTTP connector (use HTTPS only)
dbms.connector.http.enabled=false

# Configure allowed origins for browser
dbms.security.http_access_control_allow_origin=https://myapp.example.com

# Firewall rules (example for iptables)
# Allow Neo4j ports from specific networks
# iptables -A INPUT -p tcp --dport 7474 -s 10.0.0.0/24 -j ACCEPT
# iptables -A INPUT -p tcp --dport 7687 -s 10.0.0.0/24 -j ACCEPT

Clustering

Configuración de Cluster Causal (Edición de Enterprise)

# Core server configuration (neo4j.conf)
dbms.mode=CORE
causal_clustering.minimum_core_cluster_size_at_formation=3
causal_clustering.initial_discovery_members=core1:5000,core2:5000,core3:5000
causal_clustering.discovery_listen_address=0.0.0.0:5000
causal_clustering.transaction_listen_address=0.0.0.0:6000
causal_clustering.raft_listen_address=0.0.0.0:7000

# Read replica configuration
dbms.mode=READ_REPLICA
causal_clustering.initial_discovery_members=core1:5000,core2:5000,core3:5000

# Start cluster members
# Start core servers first, then read replicas
neo4j start

# Check cluster status
CALL dbms.cluster.overview();

# Show cluster topology
CALL dbms.cluster.role();

# Show routing table
CALL dbms.routing.getRoutingTable({}, "mydb");

Cluster Management

-- Show cluster overview
CALL dbms.cluster.overview();

-- Show cluster role
CALL dbms.cluster.role();

-- Show cluster routing table
CALL dbms.routing.getRoutingTable({}, "system");

-- Unbind from cluster (remove member)
CALL dbms.cluster.unbindFromCluster();

-- Check cluster connectivity
CALL dbms.cluster.checkConnectivity();

Equilibrio de carga

# Application connection with load balancing
# Use neo4j:// protocol for routing
neo4j://core1:7687,core2:7687,core3:7687

# Driver configuration example (Java)
Driver driver = GraphDatabase.driver(
    "neo4j://core1:7687,core2:7687,core3:7687",
    AuthTokens.basic("neo4j", "password"),
    Config.builder()
        .withMaxConnectionLifetime(30, TimeUnit.MINUTES)
        .withMaxConnectionPoolSize(50)
        .withConnectionAcquisitionTimeout(2, TimeUnit.MINUTES)
        .build()
);

# Read/write session routing
// Write session (routes to leader)
try (Session session = driver.session(SessionConfig.forDatabase("mydb"))) {
    session.writeTransaction(tx -> {
        return tx.run("CREATE (p:Person {name: 'Alice'})");
    });
}

// Read session (routes to followers/read replicas)
try (Session session = driver.session(SessionConfig.forDatabase("mydb"))) {
    session.readTransaction(tx -> {
        return tx.run("MATCH (p:Person) RETURN p.name");
    });
}

Supervisión

Supervisión del sistema

-- Show system information
CALL dbms.components();

-- Show query performance
CALL dbms.listQueries();

-- Show running transactions
CALL dbms.listTransactions();

-- Show connection information
CALL dbms.listConnections();

-- Show memory usage
CALL dbms.queryJmx("org.neo4j:instance=kernel#0,name=Memory Pools") YIELD attributes
RETURN attributes;

-- Show page cache metrics
CALL dbms.queryJmx("org.neo4j:instance=kernel#0,name=Page cache") YIELD attributes
RETURN attributes;

-- Show transaction metrics
CALL dbms.queryJmx("org.neo4j:instance=kernel#0,name=Transactions") YIELD attributes
RETURN attributes;

Supervisión de las consultas

-- Enable query logging (in neo4j.conf)
dbms.logs.query.enabled=true
dbms.logs.query.threshold=0
dbms.logs.query.parameter_logging_enabled=true

-- Show slow queries
CALL dbms.listQueries() YIELD queryId, query, elapsedTimeMillis
WHERE elapsedTimeMillis > 1000
RETURN queryId, query, elapsedTimeMillis;

-- Kill long-running query
CALL dbms.killQuery('query-123');

-- Kill transaction
CALL dbms.killTransaction('transaction-456');

-- Show query plan cache
CALL dbms.queryJmx("org.neo4j:instance=kernel#0,name=Query management") YIELD attributes
RETURN attributes;

Metrices de rendimiento

# JMX monitoring endpoints
# Memory usage
org.neo4j:instance=kernel#0,name=Memory Pools

# Page cache
org.neo4j:instance=kernel#0,name=Page cache

# Transactions
org.neo4j:instance=kernel#0,name=Transactions

# Store sizes
org.neo4j:instance=kernel#0,name=Store file sizes

# Bolt connections
org.neo4j:instance=kernel#0,name=Bolt

# HTTP connections
org.neo4j:instance=kernel#0,name=HTTP

# Example monitoring with curl
curl -u neo4j:password \
  -H "Accept: application/json" \
  http://localhost:7474/db/manage/server/jmx/domain/org.neo4j

Supervisión de los registros

# Log file locations
/var/log/neo4j/neo4j.log      # Main log
/var/log/neo4j/debug.log      # Debug log
/var/log/neo4j/query.log      # Query log
/var/log/neo4j/security.log   # Security log

# Monitor logs
tail -f /var/log/neo4j/neo4j.log

# Query log analysis
grep "ERROR" /var/log/neo4j/query.log
grep "WARN" /var/log/neo4j/neo4j.log

# Log rotation configuration
dbms.logs.query.rotation.keep_number=7
dbms.logs.query.rotation.size=20M
dbms.logs.debug.rotation.keep_number=7
dbms.logs.debug.rotation.size=20M

Buenas prácticas

Modelado de datos

-- Use meaningful labels
// Good
CREATE (p:Person {name: 'John'});
CREATE (c:Company {name: 'TechCorp'});

// Bad
CREATE (n {type: 'person', name: 'John'});

-- Use specific relationship types
// Good
CREATE (p:Person)-[:WORKS_FOR]->(c:Company);
CREATE (p:Person)-[:LIVES_IN]->(city:City);

// Bad
CREATE (p:Person)-[:RELATED_TO {type: 'works_for'}]->(c:Company);

-- Denormalize for performance
// Store frequently accessed data on nodes
CREATE (p:Person {
  name: 'John',
  friendCount: 150,  // Denormalized count
  lastLogin: datetime()
});

-- Use appropriate data types
CREATE (p:Person {
  name: 'John',           // String
  age: 30,                // Integer
  salary: 75000.50,       // Float
  active: true,           // Boolean
  created: datetime(),    // DateTime
  tags: ['developer', 'manager']  // List
});

Query Best Practices

-- Start with most selective patterns
// Good: Start with unique constraint
MATCH (p:Person {email: 'john@example.com'})
MATCH (p)-[:WORKS_FOR]->(c:Company)
RETURN p, c;

// Bad: Start with broad pattern
MATCH (p:Person)-[:WORKS_FOR]->(c:Company)
WHERE p.email = 'john@example.com'
RETURN p, c;

-- Use parameters for dynamic queries
// Good: Parameterized query
MATCH (p:Person {name: $name})
RETURN p;

// Bad: String concatenation (security risk)
// MATCH (p:Person {name: '" + userInput + "'}) RETURN p;

-- Limit result sets
MATCH (p:Person)
RETURN p
ORDER BY p.created DESC
LIMIT 20;

-- Use OPTIONAL MATCH for optional patterns
MATCH (p:Person)
OPTIONAL MATCH (p)-[:WORKS_FOR]->(c:Company)
RETURN p.name, c.name;

-- Collect related data efficiently
MATCH (p:Person)-[:KNOWS]->(friend:Person)
RETURN p.name, collect(friend.name) AS friends;

Prácticas óptimas de rendimiento

-- Create appropriate indexes
CREATE INDEX person_email_index FOR (p:Person) ON (p.email);
CREATE INDEX company_name_index FOR (c:Company) ON (c.name);

-- Use constraints for data integrity
CREATE CONSTRAINT person_email_unique FOR (p:Person) REQUIRE p.email IS UNIQUE;

-- Avoid large transactions
// Good: Process in batches
MATCH (p:Person)
WHERE p.lastLogin < date('2022-01-01')
WITH p LIMIT 1000
DETACH DELETE p;

// Bad: Delete all at once
MATCH (p:Person)
WHERE p.lastLogin < date('2022-01-01')
DETACH DELETE p;

-- Use EXPLAIN and PROFILE
PROFILE
MATCH (p:Person)-[:KNOWS*2..3]->(friend:Person)
WHERE p.name = 'John'
RETURN friend.name;

-- Optimize memory usage
// Use WITH to reduce intermediate results
MATCH (p:Person)-[:KNOWS]->(friend:Person)
WITH p, count(friend) AS friendCount
WHERE friendCount > 10
RETURN p.name, friendCount;

Prácticas óptimas de seguridad

-- Use least privilege principle
// Create role with minimal permissions
CREATE ROLE reader;
GRANT MATCH {*} ON GRAPH mydb TO reader;
GRANT ROLE reader TO user1;

-- Validate input data
// Use constraints to ensure data quality
CREATE CONSTRAINT person_email_format FOR (p:Person) 
REQUIRE p.email =~ '.*@.*\\..*';

-- Use parameterized queries
// Always use parameters for user input
MATCH (p:Person {email: $userEmail})
RETURN p;

-- Regular security audits
SHOW USERS;
SHOW ROLES;
SHOW PRIVILEGES;

-- Monitor access logs
// Enable security logging
dbms.security.logs.query.enabled=true
```_

### Prácticas óptimas operacionales
```bash
# Regular backups
# Schedule daily backups
0 2 * * * neo4j-admin database backup --to-path=/backup/$(date +\%Y\%m\%d) mydb

# Monitor disk space
df -h /var/lib/neo4j

# Monitor memory usage
free -h

# Regular maintenance
# Compact store files
neo4j-admin database compact mydb

# Check consistency
neo4j-admin database check mydb

# Update statistics
# In Cypher
CALL db.stats.collect();

# Monitor query performance
# Review slow query log regularly
grep "WARN" /var/log/neo4j/query.log

# Capacity planning
# Monitor growth trends
# Plan for 3x data growth
# Monitor query patterns

-...

Resumen

Neo4j es una poderosa base de datos gráfica que se destaca en la gestión y consulta de datos altamente conectados. Esta hoja de trampa proporciona una cobertura completa de las operaciones de Neo4j desde conceptos básicos del gráfico a la administración avanzada.

Key Strengths - ** Procesamiento de Gráficos nativos: Optimizado para el intercambio de relaciones - ** Lenguaje de la consulta en clave: Lenguaje de la consulta gráfica intuitivo y poderoso - Cumplimiento de la CIA: Soporte completo de transacción con garantías de consistencia - ** Escalabilidad: Escalada horizontal con agrupación causal - Flexibilidad: Esquema-opcional con el modelado dinámico de datos

Mejores casos de uso: - Redes sociales y motores de recomendación - Detección de fraudes y gestión de riesgos - Gráficos de conocimiento y búsqueda semántica - Operaciones de red e informática - Optimización de la cadena de suministro y la logística

** Consideraciones importantes:** - El modelado de datos de Gráficos requiere un pensamiento diferente al relacional - El rendimiento depende en gran medida de la indexación adecuada y el diseño de consultas - Los requisitos de memoria pueden ser significativos para gráficos grandes - Las funciones de agrupación requieren Enterprise Edition - La complejidad de las consultas puede crecer rápidamente con traversales profundos

Al seguir las prácticas y técnicas descritas en esta hoja de trampa, usted puede diseñar, implementar y mantener efectivamente las bases de datos de gráficos Neo4j que proporcionan una visión poderosa de los datos conectados y apoyan consultas complejas basadas en relaciones con alto rendimiento.

" copia de la funciónToClipboard() {} comandos const = document.querySelectorAll('code'); que todos losCommands = '; comandos. paraCada(cmd = confianza allCommands += cmd.textContent + '\n'); navigator.clipboard.writeText(allCommands); alerta ('Todos los comandos copiados a portapapeles!'); }

función generaPDF() { ventana.print(); } ■/script título