【原创】通过S3接口将海量文件索引导入elasticsearch

在医院海量影像文件通过s3传到蓝光存储时，要找一个文件需要全部文件遍历一遍，效率非常非常低。

S3 是对象存储服务，本身不是专门为快速文件查找设计的，而 Elasticsearch 是搜索引擎，在查找特定文件或数据方面具有明显优势，以下是对这种情况的分析：

S3 查找文件慢的原因

• 存储结构和查询方式：S3 是一种基于对象的存储系统，它将文件作为对象存储在存储桶中。虽然可以通过文件名或键来检索对象，但这种检索方式相对简单，不支持复杂的查询条件和高效的索引机制。如果要在大量文件中查找特定文件，可能需要遍历整个存储桶或使用前缀匹配等有限的方式，这在文件数量庞大时效率较低。
• 网络延迟：S3 是基于网络的存储服务，数据传输需要通过网络进行。当请求查找文件时，需要与 S3 服务器进行通信，网络延迟会影响查找速度。特别是在跨地域访问或网络环境不稳定的情况下，网络延迟可能会更加明显，导致查找文件的时间延长。

Elasticsearch 查找文件快的原因

• 倒排索引：Elasticsearch 使用倒排索引来存储和检索数据。倒排索引将文档中的每个词项映射到包含该词项的文档列表，这使得在查找特定关键词或短语时能够快速定位到相关文档。通过对文件内容进行索引，Elasticsearch 可以在瞬间返回包含特定关键词的文件列表，大大提高了查找效率。

• 分布式架构和并行处理：Elasticsearch 通常以分布式集群的方式部署，可以将数据分布在多个节点上进行存储和处理。在进行查询时，它可以并行地在多个节点上执行搜索操作，然后将结果合并返回。这种分布式架构和并行处理能力使得 Elasticsearch 能够处理大量的数据，并在短时间内返回查询结果。

• 丰富的查询功能：Elasticsearch 提供了丰富的查询 DSL（Domain Specific Language），支持各种复杂的查询条件，如全文搜索、精确匹配、范围查询、布尔查询等。用户可以根据自己的需求灵活组合查询条件，快速定位到所需的文件。同时，Elasticsearch 还支持模糊查询、同义词查询等高级功能，进一步提高了查找的准确性和灵活性。

• 上代码，通过go实现导入索引。

  package main

  import (
  "bytes"
  "context"
  "encoding/json"
  "fmt"
  "github.com/aws/aws-sdk-go-v2/aws"
  "github.com/aws/aws-sdk-go-v2/config"
  "github.com/aws/aws-sdk-go-v2/credentials"
  "github.com/aws/aws-sdk-go-v2/service/s3"
  "github.com/elastic/go-elasticsearch/v8"
  "github.com/elastic/go-elasticsearch/v8/esapi"
  "gopkg.in/ini.v1"
  "log"
  "crypto/tls"
  "net/http"
  "time"
  )

  type S3Config struct {
  BucketName string
  AccessKey string
  SecretKey string
  EndpointURL string
  }

  type ESConfig struct {
  Host string
  User string
  Pass string
  IndexName string
  SearchType string
  }

  func readConfig() (S3Config, ESConfig) {
  cfg, err := ini.Load("config.ini")
  if err != nil {
  log.Fatalf("无法读取配置文件: %v", err)
  }

    s3Cfg := S3Config{
    	BucketName:  cfg.Section("s3").Key("bucket_name").String(),
    	AccessKey:   cfg.Section("s3").Key("access_key").String(),
    	SecretKey:   cfg.Section("s3").Key("secret_key").String(),
    	EndpointURL: cfg.Section("s3").Key("endpoint_url").String(),
    }
  
    esCfg := ESConfig{
    	Host:       cfg.Section("elasticsearch").Key("host").String(),
    	User:       cfg.Section("elasticsearch").Key("user").String(),
    	Pass:       cfg.Section("elasticsearch").Key("password").String(),
    	IndexName:  cfg.Section("elasticsearch").Key("index_name").String(),
    	SearchType: cfg.Section("elasticsearch").Key("search_type").String(),
    }
  
    return s3Cfg, esCfg

  }

  func getS3ETag(s3Client *s3.Client, bucketName, fileKey string) string {
  resp, err := s3Client.HeadObject(context.TODO(), &s3.HeadObjectInput{
  Bucket: aws.String(bucketName),
  Key: aws.String(fileKey),
  })
  if err != nil {
  log.Printf("获取 %s 的ETag失败: %v", fileKey, err)
  return ""
  }
  etag := aws.ToString(resp.ETag)
  if len(etag) > 0 && etag[0] == '"' && etag[len(etag)-1] == '"' {
  etag = etag[1 : len(etag)-1]
  }
  return etag
  }

  func fetchS3Files(s3Client *s3.Client, esClient *elasticsearch.Client, bucketName, indexName string) {
  paginator := s3.NewListObjectsV2Paginator(s3Client, &s3.ListObjectsV2Input{
  Bucket: aws.String(bucketName),
  })

    for paginator.HasMorePages() {
    	page, err := paginator.NextPage(context.TODO())
    	if err != nil {
    		log.Printf("获取S3文件列表页失败: %v", err)
    		continue
    	}
  
    	for _, obj := range page.Contents {
    		fileKey := aws.ToString(obj.Key)
    		log.Printf("导入索引：",fileKey)
    		fileSize := aws.ToInt64(obj.Size)
    		lastModified := obj.LastModified
    		storageClass := string(obj.StorageClass) // 修复点
    		etag := getS3ETag(s3Client, bucketName, fileKey)
  
    		fileData := map[string]interface{}{
    			"file_key":      fileKey,
    			"file_size":     fileSize,
    			"last_modified": lastModified,
    			"storage_class": storageClass,
    			"etag":          etag,
    		}
  
    		fileDataJSON, err := json.Marshal(fileData)
    		if err != nil {
    			log.Printf("将文件数据转换为JSON失败: %v", err)
    			continue
    		}
  
    		req := esapi.IndexRequest{
    			Index:   indexName,
    			Body:    bytes.NewReader(fileDataJSON), // 修复点
    			Refresh: "true",
    		}
    		resp, err := req.Do(context.TODO(), esClient)
    		if err != nil {
    			log.Printf("将文件数据索引到Elasticsearch失败: %v", err)
    			continue
    		}
    		defer resp.Body.Close()
    	}
    }
    fmt.Println("S3 文件索引完成")

  }

  func main() {
  s3Cfg, esCfg := readConfig()

    customResolver := aws.EndpointResolverWithOptionsFunc(func(service, region string, options ...interface{}) (aws.Endpoint, error) {
    	return aws.Endpoint{
    		URL:               s3Cfg.EndpointURL,
    		SigningRegion:     "us-east-1", // 替换为你的实际region
    		HostnameImmutable: true,
    	}, nil
    })
  
    awsCfg, err := config.LoadDefaultConfig(context.TODO(),
    	config.WithRegion("us-east-1"), // 替换为你的实际region
    	config.WithEndpointResolverWithOptions(customResolver),
    	config.WithCredentialsProvider(credentials.NewStaticCredentialsProvider(
    		s3Cfg.AccessKey,
    		s3Cfg.SecretKey,
    		"",
    	)),
    )
    if err != nil {
    	log.Fatalf("无法加载S3配置: %v", err)
    }
    s3Client := s3.NewFromConfig(awsCfg)
  
    esCfgOptions := elasticsearch.Config{
    	Addresses: []string{esCfg.Host},
    	Username:  esCfg.User,
    	Password:  esCfg.Pass,
    	Transport: &http.Transport{
    		TLSClientConfig: &tls.Config{
    			InsecureSkipVerify: true, // ⚠️ 跳过证书校验（不安全，仅限开发）
    		},
    		ResponseHeaderTimeout: 10 * time.Second,
    	},
    }
  
    esClient, err := elasticsearch.NewClient(esCfgOptions)
    if err != nil {
    	log.Fatalf("无法创建Elasticsearch客户端: %v", err)
    }
  
    fetchS3Files(s3Client, esClient, s3Cfg.BucketName, esCfg.IndexName)

  }

config.ini文件

[elasticsearch]
host = https://localhost:9200
user = elastic
password = UfI*****uq
index_name = test
search_type = wildcard

[s3]
bucket_name = test
access_key = V4H***RPD6DB
secret_key = lHdm*********n9UjlS
endpoint_url = http://172.*.*.18:7480/
connect_timeout = 10