删除 S3 存储桶中所有版本的对象并删除存储桶的方法

大家好，今天本人给大家带来文章《删除 S3 存储桶中所有版本的对象并删除存储桶的方法》，文中内容主要涉及到，如果你对Golang方面的知识点感兴趣，那就请各位朋友继续看下去吧~希望能真正帮到你们，谢谢！

我有一个启用了版本控制的 S3 存储桶。该存储桶中几乎没有具有版本的文件。我编写了一个示例 golang 程序，它可以执行以下操作：

• GetBucketVersioning - 能够获取存储桶版本控制状态，即已启用
• ListObjects - 能够列出存储桶对象
• DeleteObjects - 能够删除存储桶对象（但它只是将“删除标记”仅添加到每个对象的最新版本。对象的版本历史记录仍然保持未删除）李>
• DeleteBucket：此操作失败并显示错误消息：

“BucketNotEmpty：您尝试删除的存储桶不为空。 您必须删除存储桶中的所有版本。”

您能否建议如何强制删除 S3 存储桶中的所有对象的所有版本，以便我最终可以使用 aws-sdk-go 删除整个存储桶？

解决方案

根据文档，DeleteBucket 指出，

现在，要从启用版本控制的存储桶中删除版本，我们可以

1. 使用 DeleteObject，其中指出，

1. 使用 DeleteObjects，其中同样指出，

在使用以下命令（先决条件 - docker、docker compose、aws cli）创建存储桶并使用文件填充其中以包含版本后，我整理了一个示例程序，并针对 LocalStack 进行了测试。

curl -o https://raw.githubusercontent.com/localstack/localstack/master/docker-compose.yml
export services="s3"
docker-compose up

export aws_access_key_id="test"
export aws_secret_access_key="test"
export aws_default_region="us-east-1"
aws --endpoint-url=http://localhost:4566 s3 mb s3://testbucket
aws --endpoint-url=http://localhost:4566 s3api put-bucket-versioning --bucket testbucket --versioning-configuration status=enabled
for i in 1 2 3; do
    aws --endpoint-url=http://localhost:4566 s3 cp main.go s3://testbucket/main.go
    aws --endpoint-url=http://localhost:4566 s3 cp go.mod s3://testbucket/go.mod
done

aws --endpoint-url=http://localhost:4566 s3api list-object-versions --bucket testbucket

运行前设置以下环境变量

export aws_endpoint="http://localhost:4566"
export s3_bucket="testbucket"

package main

import (
    "context"
    "fmt"
    "log"
    "os"

    "github.com/aws/aws-sdk-go-v2/aws"
    "github.com/aws/aws-sdk-go-v2/config"
    "github.com/aws/aws-sdk-go-v2/service/s3"
    "github.com/aws/aws-sdk-go-v2/service/s3/types"
)

type s3client struct {
    *s3.client
}

func main() {
    awsendpoint := os.getenv("aws_endpoint")
    bucketname := os.getenv("s3_bucket")

    cfg, err := config.loaddefaultconfig(context.todo(),
        config.withendpointresolverwithoptions(aws.endpointresolverwithoptionsfunc(
            func(service, region string, options ...interface{}) (aws.endpoint, error) {
                return aws.endpoint{
                    url:               awsendpoint,
                    hostnameimmutable: true,
                }, nil
            })),
    )
    if err != nil {
        log.fatalf("cannot load the aws configs: %s", err)
    }

    serviceclient := s3.newfromconfig(cfg)

    client := &s3client{
        client: serviceclient,
    }

    fmt.printf(">>> bucket: %s\n", bucketname)

    objects, err := client.listobjects(bucketname)
    if err != nil {
        log.fatal(err)
    }
    if len(objects) > 0 {
        fmt.printf(">>> list objects in the bucket: \n")
        for _, object := range objects {
            fmt.printf("%s\n", object)
        }
    } else {
        fmt.printf(">>> no objects in the bucket.\n")
    }

    if client.versioningenabled(bucketname) {
        fmt.printf(">>> versioning is enabled.\n")
        objectversions, err := client.listobjectversions(bucketname)
        if err != nil {
            log.fatal(err)
        }
        if len(objectversions) > 0 {
            fmt.printf(">>> list objects with versions: \n")
            for key, versions := range objectversions {
                fmt.printf("%s: ", key)
                for _, version := range versions {
                    fmt.printf("\n\t%s ", version)
                }
                fmt.println()
            }
        }

        if len(objectversions) > 0 {
            fmt.printf(">>> delete objects with versions.\n")
            if err := client.deleteobjects(bucketname, objectversions); err != nil {
                log.fatal(err)
            }

            objectversions, err = client.listobjectversions(bucketname)
            if err != nil {
                log.fatal(err)
            }
            if len(objectversions) > 0 {
                fmt.printf(">>> list objects with versions after deletion: \n")
                for key, version := range objectversions {
                    fmt.printf("%s: %s\n", key, version)
                }
            } else {
                fmt.printf(">>> no objects in the bucket after deletion.\n")
            }
        }
    }

    fmt.printf(">>> delete the bucket.\n")
    if err := client.deletebucket(bucketname); err != nil {
        log.fatal(err)
    }

}

func (c *s3client) versioningenabled(bucket string) bool {
    output, err := c.getbucketversioning(context.todo(), &s3.getbucketversioninginput{
        bucket: aws.string(bucket),
    })
    if err != nil {
        return false
    }
    return output.status == "enabled"
}

func (c *s3client) listobjects(bucket string) ([]string, error) {
    var objects []string
    output, err := c.listobjectsv2(context.todo(), &s3.listobjectsv2input{
        bucket: aws.string(bucket),
    })
    if err != nil {
        return nil, err
    }

    for _, object := range output.contents {
        objects = append(objects, aws.tostring(object.key))
    }

    return objects, nil
}

func (c *s3client) listobjectversions(bucket string) (map[string][]string, error) {
    var objectversions = make(map[string][]string)
    output, err := c.listobjectversions(context.todo(), &s3.listobjectversionsinput{
        bucket: aws.string(bucket),
    })
    if err != nil {
        return nil, err
    }

    for _, object := range output.versions {
        if _, ok := objectversions[aws.tostring(object.key)]; ok {
            objectversions[aws.tostring(object.key)] = append(objectversions[aws.tostring(object.key)], aws.tostring(object.versionid))
        } else {
            objectversions[aws.tostring(object.key)] = []string{aws.tostring(object.versionid)}
        }
    }

    return objectversions, err
}

func (c *s3client) deleteobjects(bucket string, objectversions map[string][]string) error {
    var identifiers []types.objectidentifier
    for key, versions := range objectversions {
        for _, version := range versions {
            identifiers = append(identifiers, types.objectidentifier{
                key:       aws.string(key),
                versionid: aws.string(version),
            })
        }
    }

    _, err := c.deleteobjects(context.todo(), &s3.deleteobjectsinput{
        bucket: aws.string(bucket),
        delete: &types.delete{
            objects: identifiers,
        },
    })
    if err != nil {
        return err
    }
    return nil
}

func (c *s3client) deletebucket(bucket string) error {
    _, err := c.deletebucket(context.todo(), &s3.deletebucketinput{
        bucket: aws.string(bucket),
    })
    if err != nil {
        return err
    }

    return nil
}

请注意，在 listobjectversions 方法中，我将 versionids 与 keys 进行映射。

    for _, object := range output.versions {
        if _, ok := objectversions[aws.tostring(object.key)]; ok {
            objectversions[aws.tostring(object.key)] = append(objectversions[aws.tostring(object.key)], aws.tostring(object.versionid))
        } else {
            objectversions[aws.tostring(object.key)] = []string{aws.tostring(object.versionid)}
        }
    }

然后在 deleteobjects 方法中，当传递 objectidentifiers 时，我传递了对象的所有版本的 key 和 objectids 。

    for key, versions := range objectVersions {
        for _, version := range versions {
            identifiers = append(identifiers, types.ObjectIdentifier{
                Key:       aws.String(key),
                VersionId: aws.String(version),
            })
        }
    }

理论要掌握，实操不能落！以上关于《删除 S3 存储桶中所有版本的对象并删除存储桶的方法》的详细介绍，大家都掌握了吧！如果想要继续提升自己的能力，那么就来关注golang学习网公众号吧！