Neo4j中的软件工程实践 - 使用Golang和Kubernetes开发

// Neo4j Go客户端示例 - 展示与Kubernetes环境的集成
package main

import (
    "context"
    "fmt"
    "log"
    "time"

    "github.com/neo4j/neo4j-go-driver/v5/neo4j"
    corev1 "k8s.io/api/core/v1"
    metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    "k8s.io/client-go/kubernetes"
    "k8s.io/client-go/rest"
)

// Neo4jService 封装Neo4j数据库操作
type Neo4jService struct {
    driver neo4j.Driver
}

// NewNeo4jService 创建Neo4j服务实例
func NewNeo4jService(uri, username, password string) (*Neo4jService, error) {
    driver, err := neo4j.NewDriver(uri, neo4j.BasicAuth(username, password, ""))
    if err != nil {
        return nil, fmt.Errorf("failed to create driver: %w", err)
    }
    
    // 测试连接
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()
    
    if err = driver.VerifyConnectivity(ctx); err != nil {
        driver.Close()
        return nil, fmt.Errorf("connectivity verification failed: %w", err)
    }
    
    return &Neo4jService{driver: driver}, nil
}

// CreateGraphNode 创建图节点
func (s *Neo4jService) CreateGraphNode(ctx context.Context, label string, properties map[string]interface{}) (string, error) {
    session := s.driver.NewSession(neo4j.SessionConfig{AccessMode: neo4j.AccessModeWrite})
    defer session.Close()
    
    result, err := session.WriteTransaction(func(tx neo4j.Transaction) (interface{}, error) {
        query := fmt.Sprintf("CREATE (n:%s $props) RETURN elementId(n)", label)
        params := map[string]interface{}{"props": properties}
        
        record, err := tx.Run(query, params)
        if err != nil {
            return nil, err
        }
        
        if record.Next() {
            return record.Record().Values[0], nil
        }
        return nil, record.Err()
    }, neo4j.WithTxTimeout(5*time.Second))
    
    if err != nil {
        return "", fmt.Errorf("failed to create node: %w", err)
    }
    
    return result.(string), nil
}

// KubernetesManager 管理Kubernetes资源
type KubernetesManager struct {
    clientset *kubernetes.Clientset
}

// NewKubernetesManager 创建Kubernetes管理器
func NewKubernetesManager() (*KubernetesManager, error) {
    config, err := rest.InClusterConfig()
    if err != nil {
        return nil, fmt.Errorf("failed to get in-cluster config: %w", err)
    }
    
    clientset, err := kubernetes.NewForConfig(config)
    if err != nil {
        return nil, fmt.Errorf("failed to create clientset: %w", err)
    }
    
    return &KubernetesManager{clientset: clientset}, nil
}

// CreateNeo4jSecret 创建Neo4j数据库密钥
func (k *KubernetesManager) CreateNeo4jSecret(namespace, name, username, password string) error {
    secret := &corev1.Secret{
        ObjectMeta: metav1.ObjectMeta{
            Name:      name,
            Namespace: namespace,
        },
        StringData: map[string]string{
            "username": username,
            "password": password,
        },
        Type: corev1.SecretTypeOpaque,
    }
    
    _, err := k.clientset.CoreV1().Secrets(namespace).Create(
        context.Background(),
        secret,
        metav1.CreateOptions{},
    )
    
    return err
}

// GraphQueryService 图查询服务
type GraphQueryService struct {
    neo4j *Neo4jService
}

// FindRelationships 查找节点间的关系
func (g *GraphQueryService) FindRelationships(ctx context.Context, startLabel, endLabel, relationshipType string) ([]map[string]interface{}, error) {
    session := g.neo4j.driver.NewSession(neo4j.SessionConfig{AccessMode: neo4j.AccessModeRead})
    defer session.Close()
    
    query := `
        MATCH (start:$startLabel)-[r:$relationshipType]->(end:$endLabel)
        RETURN start, r, end
        LIMIT 100
    `
    
    params := map[string]interface{}{
        "startLabel":       startLabel,
        "endLabel":         endLabel,
        "relationshipType": relationshipType,
    }
    
    result, err := session.Run(query, params)
    if err != nil {
        return nil, fmt.Errorf("query failed: %w", err)
    }
    
    var relationships []map[string]interface{}
    for result.Next() {
        record := result.Record()
        relationships = append(relationships, record.AsMap())
    }
    
    return relationships, result.Err()
}

// HealthCheck 健康检查端点
func (s *Neo4jService) HealthCheck(ctx context.Context) error {
    session := s.driver.NewSession(neo4j.SessionConfig{AccessMode: neo4j.AccessModeRead})
    defer session.Close()
    
    _, err := session.Run("RETURN 1", nil)
    return err
}

func main() {
    // 初始化Kubernetes管理器
    k8sManager, err := NewKubernetesManager()
    if err != nil {
        log.Fatalf("Failed to create k8s manager: %v", err)
    }
    
    // 创建Neo4j密钥
    err = k8sManager.CreateNeo4jSecret("default", "neo4j-credentials", "neo4j", "secure-password")
    if err != nil {
        log.Printf("Warning: Failed to create secret: %v", err)
    }
    
    // 初始化Neo4j服务
    neo4jService, err := NewNeo4jService(
        "bolt://neo4j-service:7687",
        "neo4j",
        "secure-password",
    )
    if err != nil {
        log.Fatalf("Failed to create Neo4j service: %v", err)
    }
    defer neo4jService.driver.Close()
    
    // 创建示例节点
    ctx := context.Background()
    nodeID, err := neo4jService.CreateGraphNode(ctx, "Person", map[string]interface{}{
        "name":     "John Doe",
        "age":      30,
        "location": "London",
    })
    if err != nil {
        log.Fatalf("Failed to create node: %v", err)
    }
    
    fmt.Printf("Created node with ID: %s\n", nodeID)
    
    // 执行健康检查
    if err := neo4jService.HealthCheck(ctx); err != nil {
        log.Printf("Health check failed: %v", err)
    } else {
        fmt.Println("Neo4j connection is healthy")
    }
}

这个示例展示了在Kubernetes环境中使用Go语言与Neo4j图数据库集成的实践。代码包含Neo4j客户端初始化、图数据操作、Kubernetes资源管理以及健康检查功能，体现了云原生环境下Go语言开发的最佳实践。