使用腾讯云go sdk 查询对象存储中最新文件

saynaihe2024-03-03 23:54

背景：

腾讯云账号下，有很多对象存储COS桶：

我现在想确认某一个对象存储桶的活跃程度，简单的来说。我想知道这个桶里面最后上传的一个文件是什么，以及它的上传时间戳。

本文将介绍如何使用腾讯云对象存储（COS）的 Go 语言 SDK 查询指定存储桶中的最新文件信息，包括文件路径和上传时间。本教程假设读者已经具备基本的 Go 语言编程知识，并且对腾讯云 COS 有一定的了解。

使用腾讯云go sdk 查询对象存储中最新文件

前置条件

  • 您需要拥有一个腾讯云账号，并创建了至少一个COS存储桶。
  • 了解Go语言和基本的并发编程知识。
  • 确保您已安装Go运行时环境。

安装腾讯云COS Go SDK

在开始之前，先确保您的开发环境已安装了腾讯云COS的Go SDK。如果尚未安装，可以使用以下Go命令安装：

shell 复制代码 
mkdir xxxx
go mod int xxxx
go get github.com/tencentyun/cos-go-sdk-v5

我们这里的操作是属于List Object 参照：GetBucket

第一版代码：

使用chatgpt 生成第一版代码：
main.go

bash 复制代码 
package main

import (
	"context"
	"fmt"
	"net/http"
	"net/url"
	"sort"
	"time"

	"github.com/tencentyun/cos-go-sdk-v5"
)

// 请替换下面的假设值为实际的 SecretId、SecretKey、BucketName 和 Region。
const (
	SecretId     = "xxxxxx"
	SecretKey    = "xxxx"
	BucketName   = "xxxxxx" // 例如 "example-1250000000"
	BucketRegion = "ap-shanghai"      // 例如 "ap-guangzhou"
)

func main() {
	u, _ := url.Parse(fmt.Sprintf("https://%s.cos.%s.myqcloud.com", BucketName, BucketRegion))
	b := &cos.BaseURL{BucketURL: u}
	client := cos.NewClient(b, &http.Client{
		Transport: &cos.AuthorizationTransport{
			SecretID:  SecretId,
			SecretKey: SecretKey,
		},
	})

	c := context.Background()
	opt := &cos.BucketGetOptions{
		MaxKeys: 1000, // 修改这个值以获取更多或更少的对象
	}

	v, _, err := client.Bucket.Get(c, opt)
	if err != nil {
		panic(err)
	}

	// 对结果进行排序，找到最后更新的对象
	if len(v.Contents) > 0 {
		sort.Slice(v.Contents, func(i, j int) bool {
			ti, _ := time.Parse(time.RFC3339, v.Contents[i].LastModified)
			tj, _ := time.Parse(time.RFC3339, v.Contents[j].LastModified)
			return ti.After(tj)
		})
		lastUpdatedObj := v.Contents[0]
		fmt.Printf("最新上传文件路径: %s\n", lastUpdatedObj.Key)
		fmt.Printf("最新上传时间: %s\n", lastUpdatedObj.LastModified)
	} else {
		fmt.Println("桶中没有文件。")
	}
}

运行main.go

bash 复制代码 
go run main.go

运行后也许感觉是正确的，毕竟没有报错。但是这里是有问题的，为什么呢？因为我本身不知道最后一个文件是什么，我手动上传了一个文件，最后一个文件应该是输出：go1.22.0.linux-amd64.tar.gz！

什么原因呢？问题应该是在这里：

shell 复制代码 
	c := context.Background()
	opt := &cos.BucketGetOptions{
		MaxKeys: 1000, // 修改这个值以获取更多或更少的对象
	}

marker标记参数没有设置

继续修改完善main.go代码：

shell 复制代码 
package main

import (
	"context"
	"fmt"
	"net/http"
	"net/url"
	"sort"
	"time"

	"github.com/tencentyun/cos-go-sdk-v5"
)

// 请替换以下的假设值为实际的 SecretId、SecretKey、BucketName 和 Region。
const (
	SecretId     = "xxxxxx"
	SecretKey    = "xxxx"
	BucketName   = "xxxxxx" // 例如 "example-1250000000"
	BucketRegion = "ap-shanghai"      // 例如 "ap-guangzhou"
)

func main() {
	u, _ := url.Parse(fmt.Sprintf("https://%s.cos.%s.myqcloud.com", BucketName, BucketRegion))
	b := &cos.BaseURL{BucketURL: u}
	client := cos.NewClient(b, &http.Client{
		Transport: &cos.AuthorizationTransport{
			SecretID:  SecretId,
			SecretKey: SecretKey,
		},
	})

	c := context.Background()

	var lastUpdatedObj *cos.Object
	isTruncated := true
	nextMarker := ""

	for isTruncated {
		opt := &cos.BucketGetOptions{
			Marker:   nextMarker,
			MaxKeys:  1000, // 单次请求返回的最大对象数
		}

		v, _, err := client.Bucket.Get(c, opt)
		if err != nil {
			panic(err)
		}

		for _, object := range v.Contents {
			if lastUpdatedObj == nil || object.LastModified > lastUpdatedObj.LastModified {
				lastUpdatedObj = &object
			}
		}

		// 更新下一个标记和是否截断的标志
		isTruncated = v.IsTruncated
		nextMarker = v.NextMarker
	}

	// 检查是否有对象被找到
	if lastUpdatedObj != nil {
		fmt.Printf("最新上传文件路径: %s\n", lastUpdatedObj.Key)
		fmt.Printf("最新上传时间: %s\n", lastUpdatedObj.LastModified)
	} else {
		fmt.Println("桶中没有文件。")
	}
}

运行修改后的main.go文件：

shell 复制代码 
go run main.go

输出go1.22.0.linux-amd64.tar.gz这个起码是正确的！

拆分代码

想继续拆分一下，将客户端的创建和查找逻辑拆分到两个独立的函数createCOSClient getLastUpdatedFileInfo，然后main函数中调用：

bash 复制代码 
package main

import (
	"context"
	"fmt"
	"github.com/tencentyun/cos-go-sdk-v5"
	"net/http"
	"net/url"
	"sort"
	"time"
)

// 请替换下面的假设值为实际的 SecretId、SecretKey、BucketName 和 Region。
const (
	SecretId     = "xxxxxx"
	SecretKey    = "xxx"
	BucketName   = "xxxxx" // 例如 "example-1250000000"
	BucketRegion = "ap-shanghai"      // 例如 "ap-guangzhou"
)

// 创建 COS 客户端
func createCOSClient(secretId, secretKey, bucketName, bucketRegion string) *cos.Client {
	u, _ := url.Parse(fmt.Sprintf("https://%s.cos.%s.myqcloud.com", bucketName, bucketRegion))
	b := &cos.BaseURL{BucketURL: u}
	client := cos.NewClient(b, &http.Client{
		Transport: &cos.AuthorizationTransport{
			SecretID:  secretId,
			SecretKey: secretKey,
		},
	})
	return client
}
func getLastUpdatedFileInfo(client *cos.Client) (key, lastModifiedTime string, err error) {
	c := context.Background()

	// 初始化一个空字符串，表示从桶的开头获取文件列表
	nextMarker := ""
	var allContents []cos.Object

	for {
		opt := &cos.BucketGetOptions{
			MaxKeys: 1000,
			Marker:  nextMarker,
		}

		v, _, err := client.Bucket.Get(c, opt)
		if err != nil {
			return "", "", err
		}

		allContents = append(allContents, v.Contents...)

		// 如果没有更多的文件，则停止循环
		if !v.IsTruncated {
			break
		}

		// 更新 nextMarker 为下一页的开始位置
		nextMarker = v.NextMarker
	}

	// 对所有结果进行排序以找到最新更新的对象
	if len(allContents) > 0 {
		sort.Slice(allContents, func(i, j int) bool {
			ti, errTi := time.Parse(time.RFC3339, allContents[i].LastModified)
			tj, errTj := time.Parse(time.RFC3339, allContents[j].LastModified)
			if errTi != nil || errTj != nil {
				fmt.Printf("Error parsing time: %v, %v", errTi, errTj)
				return false
			}
			return ti.After(tj)
		})
		lastUpdatedObj := allContents[0]
		return lastUpdatedObj.Key, lastUpdatedObj.LastModified, nil
	} else {
		return "", "", fmt.Errorf("桶中没有文件")
	}
}

func main() {
	client := createCOSClient(SecretId, SecretKey, BucketName, BucketRegion)
	key, lastModifiedTime, err := getLastUpdatedFileInfo(client)
	if err != nil {
		fmt.Printf("\n查询失败: %v\n", err)
		return
	}

	fmt.Printf("\n最后更新的文件:\n")
	fmt.Printf("文件路径: %s\n", key)
	fmt.Printf("最后修改时间: %s\n", lastModifiedTime)
}

运行main.go

bash 复制代码 
go run main.go

注：为了验证代码有效性，我这里后面又加了一个新的文件：zaZTYa1i2x.txt

加个进度条

上面的代码已经可以正常满足需求了，但是我新加一个进度条，显示查询了多少文件了。也能大概知道一个进度的状况，继续修改一下main.go

bash 复制代码 
package main

import (
	"context"
	"fmt"
	"github.com/tencentyun/cos-go-sdk-v5"
	"net/http"
	"net/url"
	"sort"
	"time"
)

// 请替换下面的假设值为实际的 SecretId、SecretKey、BucketName 和 Region。
const (
	SecretId     = "xxxx"
	SecretKey    = "xxxxx"
	BucketName   = "xxxxx" // 例如 "example-1250000000"
	BucketRegion = "ap-shanghai"      // 例如 "ap-guangzhou"
)

// 创建 COS 客户端
func createCOSClient(secretId, secretKey, bucketName, bucketRegion string) *cos.Client {
	u, _ := url.Parse(fmt.Sprintf("https://%s.cos.%s.myqcloud.com", bucketName, bucketRegion))
	b := &cos.BaseURL{BucketURL: u}
	client := cos.NewClient(b, &http.Client{
		Transport: &cos.AuthorizationTransport{
			SecretID:  secretId,
			SecretKey: secretKey,
		},
	})
	return client
}
func getLastUpdatedFileInfo(client *cos.Client) (key, lastModifiedTime string, err error) {
	c := context.Background()

	nextMarker := ""
	var allContents []cos.Object
	var retrievedCount int

	fmt.Println("开始检索文件列表...")

	for {
		opt := &cos.BucketGetOptions{
			MaxKeys: 10000,
			Marker:  nextMarker,
		}

		v, _, err := client.Bucket.Get(c, opt)
		if err != nil {
			return "", "", err
		}

		retrievedCount += len(v.Contents)
		fmt.Printf("已检索 %d 个文件...\r", retrievedCount) // 输出进度信息 '\r' 会覆盖当前行，这样我们就可以在同一行更新进度

		allContents = append(allContents, v.Contents...)

		if !v.IsTruncated {
			break
		}

		nextMarker = v.NextMarker
	}

	fmt.Println("\n文件列表检索完成。")

	if len(allContents) > 0 {
		sort.Slice(allContents, func(i, j int) bool {
			ti, errTi := time.Parse(time.RFC3339, allContents[i].LastModified)
			tj, errTj := time.Parse(time.RFC3339, allContents[j].LastModified)
			if errTi != nil || errTj != nil {
				fmt.Printf("Error parsing time: %v, %v", errTi, errTj)
				return false
			}
			return ti.After(tj)
		})
		lastUpdatedObj := allContents[0]
		return lastUpdatedObj.Key, lastUpdatedObj.LastModified, nil
	} else {
		return "", "", fmt.Errorf("桶中没有文件")
	}
}

func main() {
	client := createCOSClient(SecretId, SecretKey, BucketName, BucketRegion)
	key, lastModifiedTime, err := getLastUpdatedFileInfo(client)
	if err != nil {
		fmt.Printf("\n查询失败: %v\n", err)
		return
	}

	fmt.Printf("\n最后更新的文件:\n")
	fmt.Printf("文件路径: %s\n", key)
	fmt.Printf("最后修改时间: %s\n", lastModifiedTime)
}

运行main.go

bash 复制代码 
go run main.go

继续完善

继续完善一下代码：我需要把MaxKeys 提取出来，增加一下输出程序的运行时间，并把输出文件的时间戳调整为东八区时间：

bash 复制代码 
package main

import (
	"context"
	"fmt"
	"github.com/tencentyun/cos-go-sdk-v5"
	"net/http"
	"net/url"
	"sort"
	"time"
)

const (
	SecretId     = "xxxx"
	SecretKey    = "xxxxx"
	BucketName   = "xxxxx"
	BucketRegion = "ap-shanghai"
	MaxKeys      = 1000 // 设置最大检索数量的常量
)

var cstZone = time.FixedZone("CST", 8*3600) // 东八区时区

func createCOSClient(secretId, secretKey, bucketName, bucketRegion string) *cos.Client {
	u, _ := url.Parse(fmt.Sprintf("https://%s.cos.%s.myqcloud.com", bucketName, bucketRegion))
	b := &cos.BaseURL{BucketURL: u}
	client := cos.NewClient(b, &http.Client{
		Transport: &cos.AuthorizationTransport{
			SecretID:  secretId,
			SecretKey: secretKey,
		},
	})
	return client
}

func getLastUpdatedFileInfo(client *cos.Client) (key, lastModifiedTime string, err error) {
	c := context.Background()

	nextMarker := ""
	var allContents []cos.Object
	var retrievedCount int

	fmt.Println("开始检索文件列表...")

	for {
		opt := &cos.BucketGetOptions{
			MaxKeys: MaxKeys, // 使用常量 MaxKeys
			Marker:  nextMarker,
		}

		v, _, err := client.Bucket.Get(c, opt)
		if err != nil {
			return "", "", err
		}

		retrievedCount += len(v.Contents)
		fmt.Printf("已检索 %d 个文件...\r", retrievedCount)

		allContents = append(allContents, v.Contents...)

		if !v.IsTruncated {
			break
		}

		nextMarker = v.NextMarker
	}

	fmt.Println("\n文件列表检索完成。")

	if len(allContents) > 0 {
		sort.Slice(allContents, func(i, j int) bool {
			ti, errTi := time.Parse(time.RFC3339, allContents[i].LastModified)
			tj, errTj := time.Parse(time.RFC3339, allContents[j].LastModified)
			if errTi != nil || errTj != nil {
				fmt.Printf("Error parsing time: %v, %v", errTi, errTj)
				return false
			}
			return ti.After(tj)
		})

		lastUpdatedObj := allContents[0]
		// 将文件的 LastModified 时间字符串转换为 time.Time
		t, err := time.Parse(time.RFC3339, lastUpdatedObj.LastModified)
		if err != nil {
			return "", "", fmt.Errorf("无法解析最后修改时间: %v", err)
		}
		// 转换为东八区时间
		cstTime := t.In(cstZone).Format(time.RFC3339)
		return lastUpdatedObj.Key, cstTime, nil
	} else {
		return "", "", fmt.Errorf("桶中没有文件")
	}
}

func main() {
	start := time.Now() // 程序开始时间

	client := createCOSClient(SecretId, SecretKey, BucketName, BucketRegion)
	key, lastModifiedTime, err := getLastUpdatedFileInfo(client)
	if err != nil {
		fmt.Printf("\n查询失败: %v\n", err)
		return
	}

	fmt.Printf("\n最后更新的文件:\n")
	fmt.Printf("文件路径: %s\n", key)
	fmt.Printf("最后修改时间: %s\n", lastModifiedTime)

	elapsed := time.Since(start) // 程序执行时间
	fmt.Printf("\n程序运行时间: %s\n", elapsed)
}

运行修改后的main.go文件：

bash 复制代码 
go run main.go

继续发散

继续发散一下，我需要输出最后上传的10个文件

bash 复制代码 
package main

import (
	"context"
	"fmt"
	"github.com/tencentyun/cos-go-sdk-v5"
	"net/http"
	"net/url"
	"sort"
	"time"
)

// 请替换下面的假设值为实际的 SecretId、SecretKey、BucketName 和 Region。
const (
	SecretId      = "AKID7Mhwz45A9zqcCf4s07A7FIKKTlAiEf7M"
	SecretKey     = "KXbXL0unr2EaBsicYejj1GkEjO2jWOAg"
	BucketName    = "layabox-10028350" // 例如 "example-1250000000"
	BucketRegion  = "ap-shanghai"      // 例如 "ap-guangzhou"
	MaxKeys       = 1000               // 设置最大检索数量的常量
	NumberOfFiles = 10                 // 需要获取的最后更新的文件数量
)

var cstZone = time.FixedZone("CST", 8*3600) // 东八区时区

func createCOSClient(secretId, secretKey, bucketName, bucketRegion string) *cos.Client {
	u, _ := url.Parse(fmt.Sprintf("https://%s.cos.%s.myqcloud.com", bucketName, bucketRegion))
	b := &cos.BaseURL{BucketURL: u}
	client := cos.NewClient(b, &http.Client{
		Transport: &cos.AuthorizationTransport{
			SecretID:  secretId,
			SecretKey: secretKey,
		},
	})
	return client
}

func getLastUpdatedFileInfo(client *cos.Client, numberOfFiles int) ([]cos.Object, error) {
	c := context.Background()

	nextMarker := ""
	var allContents []cos.Object
	var retrievedCount int

	fmt.Println("开始检索文件列表...")

	for {
		opt := &cos.BucketGetOptions{
			MaxKeys: MaxKeys, // 使用常量 MaxKeys
			Marker:  nextMarker,
		}

		v, _, err := client.Bucket.Get(c, opt)
		if err != nil {
			return nil, err
		}

		retrievedCount += len(v.Contents)
		fmt.Printf("已检索 %d 个文件...\r", retrievedCount)

		allContents = append(allContents, v.Contents...)

		if !v.IsTruncated {
			break
		}

		nextMarker = v.NextMarker
	}

	fmt.Println("\n文件列表检索完成。")
	fmt.Printf("\n桶中总文件数: %d\n", len(allContents))

	if len(allContents) > 0 {
		sort.Slice(allContents, func(i, j int) bool {
			ti, errTi := time.Parse(time.RFC3339, allContents[i].LastModified)
			tj, errTj := time.Parse(time.RFC3339, allContents[j].LastModified)
			if errTi != nil || errTj != nil {
				fmt.Printf("Error parsing time: %v, %v", errTi, errTj)
				return false
			}
			return ti.After(tj)
		})

		// 截取切片以获取最后更新的numberOfFiles个文件
		if len(allContents) > numberOfFiles {
			allContents = allContents[:numberOfFiles]
		}

		// 返回最后更新的numberOfFiles个文件
		return allContents, nil
	} else {
		return nil, fmt.Errorf("桶中没有文件")
	}
}

func main() {
	start := time.Now() // 程序开始时间

	client := createCOSClient(SecretId, SecretKey, BucketName, BucketRegion)
	files, err := getLastUpdatedFileInfo(client, NumberOfFiles)
	if err != nil {
		fmt.Printf("\n查询失败: %v\n", err)
		return
	}

	fmt.Printf("\n最后更新的%d个文件:\n", NumberOfFiles)
	for _, file := range files {
		t, err := time.Parse(time.RFC3339, file.LastModified)
		if err != nil {
			fmt.Printf("无法解析文件 %s 的最后修改时间: %v\n", file.Key, err)
			continue
		}
		cstTime := t.In(cstZone).Format(time.RFC3339)
		fmt.Printf("文件路径: %s\n", file.Key)
		fmt.Printf("最后修改时间: %s\n", cstTime)
	}

	elapsed := time.Since(start) // 程序执行时间
	fmt.Printf("\n程序运行时间: %s\n", elapsed)
}

其实也想过协程或者其他方式？但是奈何max-keys 最大是1000测试了一下没有太大的提升放弃了...

总结

在这篇博客中，我们学习了如何使用腾讯云 COS Go SDK 查询存储桶中最新的文件信息。这包括如何创建COS客户端，如何逐页检索对象列表，并如何对结果排序以找到最后更新的对象。我们还展示了如何优化用户体验，通过实时进度更新和检索多个文件来改进程序。

希望本文能帮助你在使用腾讯云 COS 时实现更高效的数据管理。

相关推荐
sszdzq11 分钟前
Docker
运维·docker·容器
book012115 分钟前
MySql数据库运维学习笔记
运维·数据库·mysql
bugtraq20211 小时前
XiaoMi Mi5(gemini) 刷入Ubuntu Touch 16.04——安卓手机刷入Linux
linux·运维·ubuntu
xmweisi1 小时前
【华为】报文统计的技术NetStream
运维·服务器·网络·华为认证
VVVVWeiYee1 小时前
BGP配置华为——路径优选验证
运维·网络·华为·信息与通信
陆鳐LuLu2 小时前
日志管理利器：基于 ELK 的日志收集、存储与可视化实战
运维·elk·jenkins
DC_BLOG2 小时前
Linux-GlusterFS进阶分布式卷
linux·运维·服务器·分布式
cookies_s_s3 小时前
Linux--进程（进程虚拟地址空间、页表、进程控制、实现简易shell）
linux·运维·服务器·数据结构·c++·算法·哈希算法
zhouwu_linux3 小时前
MT7628基于原厂的SDK包， 修改ra1网卡的MAC方法。
linux·运维·macos
维维180-3121-14553 小时前
AI赋能生态学暨“ChatGPT+”多技术融合在生态系统服务中的实践技术应用与论文撰写
人工智能·chatgpt
热门推荐
01DeepSeek各版本说明与优缺点分析02如何在WPS和Word/Excel中直接使用DeepSeek功能03DeepSeek本地部署详细指南04太炸裂了！清华大学deepseek从入门到精通使用手册又出第三版了，《普通人如何抓住DeepSeek红利》（无套路，直接下载）05本地部署DeepSeek教程（Mac版本）06DeepSeek r1本地安装全指南07DeepSeek R1本地化部署 Ollama + Chatbox 打造最强 AI 工具08本地化部署AI知识库：基于Ollama+DeepSeek+AnythingLLM保姆级教程09在Windows下安装Ollama并体验DeepSeek r1大模型10DeepSeek RAGFlow构建本地知识库系统