脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 脚本专栏 → Golang → 腾讯云go sdk 查询对象存储

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

 更新时间：2024年03月04日 11:24:35   作者：对你无可奈何2008  
这篇文章主要介绍了使用腾讯云go sdk 查询对象存储中最新文件,这包括如何创建COS客户端,如何逐页检索对象列表,并如何对结果排序以找到最后更新的对象,我们还展示了如何优化用户体验,通过实时进度更新和检索多个文件来改进程序,需要的朋友可以参考下

背景：

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

我现在想确认某一个对象存储桶的活跃程度，简单的来说。我想知道这个桶里面最后上传的一个文件是什么，以及它的上传时间戳。
本文将介绍如何使用腾讯云对象存储（COS）的 Go 语言 SDK 查询指定存储桶中的最新文件信息，包括文件路径和上传时间。本教程假设读者已经具备基本的 Go 语言编程知识，并且对腾讯云 COS 有一定的了解。

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

前置条件

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

安装腾讯云COS Go SDK

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

mkdir xxxx
go mod int xxxx
go get github.com/tencentyun/cos-go-sdk-v5

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

第一版代码：

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

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

go run main.go

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

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

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

marker标记参数没有设置
继续修改完善main.go代码：

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文件：

go run main.go

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

拆分代码

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

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

go run main.go

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

加个进度条

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

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

go run main.go

继续完善

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

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文件：

go run main.go

继续发散

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

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 时实现更高效的数据管理。

到此这篇关于使用腾讯云go sdk 查询对象存储中最新文件的文章就介绍到这了,更多相关腾讯云go sdk 查询对象存储内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

相关文章

  • Go语言带缓冲的通道实现

    Go语言带缓冲的通道实现

    这篇文章主要介绍了Go语言带缓冲的通道实现，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
    2021-04-04
  • Go语言中日志的规范使用建议分享

    Go语言中日志的规范使用建议分享

    在任何服务端的语言项目中,日志是至关重要的组成部分,本文为大家整理了一些如何规范使用GO语言日志的建议,以及相应的实际示例,希望对大家有事帮助
    2024-01-01
  • Go语言中序列化与反序列化示例详解

    Go语言中序列化与反序列化示例详解

    我们的数据对象要在网络中传输或保存到文件,就需要对其编码和解码动作,Go语言当然也支持所有这些编码格式,下面这篇文章主要给大家介绍了关于Go语言中序列化与反序列化的相关资料,需要的朋友可以参考下
    2022-07-07
  • golang如何优雅的编写事务代码示例

    golang如何优雅的编写事务代码示例

    这篇文章主要介绍了golang如何优雅的编写事务代码示例，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
    2020-05-05
  • Go 的入口函数和包初始化的使用

    Go 的入口函数和包初始化的使用

    本文主要介绍了Go 的入口函数和包初始化的使用，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
    2022-05-05
  • wind10 idea中 go 开发环境搭建教程图解

    wind10 idea中 go 开发环境搭建教程图解

    这篇文章主要介绍了wind10 idea中 go 开发环境搭建过程，本文通过图文并茂的形式给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
    2020-06-06
  • Go泛型之泛型约束示例详解

    Go泛型之泛型约束示例详解

    这篇文章主要给大家介绍了关于Go泛型之泛型约束的相关资料,泛型是静态语言中的一种编程方式,这种编程方式可以让算法不再依赖于某个具体的数据类型,而是通过将数据类型进行参数化,以达到算法可复用的目的,需要的朋友可以参考下
    2023-12-12
  • 一文搞懂Golang中iota的用法和原理

    一文搞懂Golang中iota的用法和原理

    我们知道iota是go语言的常量计数器，本文尝试全面总结其使用用法以及其实现原理，需要的朋友可以参考以下内容，希望对大家有所帮助
    2022-08-08
  • Golang文件读写操作详情

    Golang文件读写操作详情

    这篇文章主要介绍了Golang文件读写操作详情，文件是数据源(保存数据的地方)的一种,文件最主要的作用就是保存数据，文件在程序中是以流的形式来操作的，更多详细内容需要的朋友可以参考一下
    2022-07-07
  • Go结合Redis用最简单的方式实现分布式锁

    Go结合Redis用最简单的方式实现分布式锁

    本文主要介绍了Go结合Redis用最简单的方式实现分布式锁示例，文中通过示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
    2022-01-01

最新评论