创建桶

功能说明

用户通过创建桶操作创建桶（bucket）后才能访问存储资源，每个用户可以拥有多个桶。桶的名称在媒体存储范围内必须是全局唯一的，一旦创建之后无法修改名称。桶的创建者默认是桶的拥有者，对桶拥有FULL_CONTROL权限，可以通过设置参数的方式为其他用户配置创建桶的权限。桶的命名规范如下：

使用字母、数字和短横线（-）；
以小写字母或者数字开头和结尾；
长度在3-63字节之间。

代码示例

func CreateBucket(svc *s3.S3) {
    bucketName := "<your-bucket-name>"
    // 创建桶
    createBucketInput := &s3.CreateBucketInput{
        Bucket:           aws.String(bucketName),
        GrantFullControl: aws.String("emailAddress=<user@example.com>"),
    }
    createBucketOutput, err := svc.CreateBucket(createBucketInput)
    if err != nil {
        fmt.Printf("Unable to create bucket %s, %v\n", bucketName, err)
    }
    // 等待桶创建
    fmt.Printf("Waiting for bucket %s to be created...\n", bucketName)
    err = svc.WaitUntilBucketExists(&s3.HeadBucketInput{
        Bucket: aws.String(bucketName),
    })
    if err != nil {
        fmt.Printf("Error occurred while waiting for bucket to be created, %v", createBucketOutput)
    }

    fmt.Printf("Bucket %s successfully created\n", bucketName)
}

通过CreateBucketRequest操作：

CreateBucketRequest操作首先生成一个"request.Request"对象，该对象是一个执行CreateBucket操作的请求。通过调用Request对象的Send方法完成创建bucket的操作。该方法可以生成定制化的请求，例如自定义请求头部请求超时重试设置。

func CreateBucketRequest(svc *s3.S3) {
    createBucketInput := &s3.CreateBucketInput{
        Bucket: aws.String("<your-bucket-name>"),
    }
    req, createBucketOutput := svc.CreateBucketRequest(createBucketInput)

    err := req.Send()
    if err != nil {
        fmt.Printf("fail to create bucket. %v\n", err)
    } else {
        fmt.Println(createBucketOutput)
    }
}

请求参数

CreateBucketInput可设置的参数如下：

参数	类型	说明	是否必要
ACL	*string	配置创建bucket预定义的标准ACL信息，例如private，public-read等	否
Bucket	*string	创建bucket的名称	是
GrantFullControl	*string	用于自定义用户对此bucket的READ、WRITE、READ_ACP、WRITE_ACP权限信息	否
GrantRead	*string	用于自定义用户对此bucket的READ权限信息	否
GrantReadACP	*string	用于自定义用户对此bucket的READ_ACP权限信息	否
GrantWrite	*string	用于自定义用户对此bucket的WRITE权限信息	否
GrantWriteACP	*string	用于自定义用户对此bucket的WRITE_ACP权限信息	否

获取桶列表

功能说明

获取桶列表可以显示用户全部可用的桶。

代码示例

func ListBuckets(svc *s3.S3) {
    listBucketsInput := &s3.ListBucketsInput{}
    listBucketsOutput, err := svc.ListBuckets(listBucketsInput)
    if err != nil {
        fmt.Println("Failed to list buckets", err)
    }
    for _, b := range listBucketsOutput.Buckets {
        fmt.Printf("* %s created on %s\n", aws.StringValue(b.Name), aws.TimeValue(b.CreationDate))
    }
}

通过ListBucketsRequest操作：

ListBucketsRequest操作首先生成一个"request.Request"对象，该对象是一个执行ListBucket操作的请求。通过调用Request对象的Send方法完成列出可用桶的操作。该方法可以生成定制化的请求，例如自定义请求头部请求超时重试设置。

func ListBucketRequest(svc *s3.S3) {
    listBucketsInput := &s3.ListBucketsInput{}
    req, listBucketsOutput := svc.ListBucketsRequest(listBucketsInput)

    err := req.Send()
    if err != nil {
        fmt.Printf("fail to list bucket. %v\n", err)
    } else {
        fmt.Println(listBucketsOutput)
    }
}

返回结果

ListBucketsOutput返回的属性如下：

属性名	类型	说明
Buckets	[]*Bucket	bucket信息的数组，包含了每个bucket的名字和创建时间
Owner	*Owner	bucket的拥有者信息

判断桶是否存在

功能说明

通过请求返回结果中的HTTP状态码快速判断桶是否存在，返回状态码为200表示桶存在，返回状态码为404表示桶不存在。

代码示例

func HeadBucket(svc *s3.S3) {
    headBucketInput := &s3.HeadBucketInput{
        Bucket: aws.String("<your-bucket-name>"),
    }
    _, err := svc.HeadBucket(headBucketInput)

    if err != nil {
        fmt.Printf("fail to head bucket, %v\n", err)
        return
    }
}

通过HeadBucketRequest操作：

HeadBucketRequest操作首先生成一个"request.Request"对象，该对象是一个执行HeadBucket操作的请求。通过调用Request对象的Send方法完成判断桶是否存在的操作。该方法可以生成定制化的请求，例如自定义请求头部请求超时重试设置。

func HeadBucketRequest(svc *s3.S3) {
    headBucketInput := &s3.HeadBucketInput{
        Bucket: aws.String("<your-bucket-name>"),
    }
    req, _ := svc.HeadBucketRequest(headBucketInput)

    err := req.Send()
    if err != nil {
        fmt.Printf("fail to head bucket. %v\n", err)
    }
}

请求参数

HeadBucketInput可设置的参数如下：

参数	类型	说明	是否必要
Bucket	*string	bucket的名称	是

删除桶

功能说明

用于删除桶（bucket），删除一个桶前，需要先删除该桶中的全部对象（包括object versions和delete markers）。

代码示例

func DeleteBucket(svc *s3.S3) {
    deleteBucketInput := &s3.DeleteBucketInput{
        Bucket: aws.String("<your-bucket-name>"),
    }

    _, err := svc.DeleteBucket(deleteBucketInput)
    if err != nil {
        fmt.Printf("fail to delete bucket. %v\n", err)
    }
}

通过DeleteBucketRequest操作：

DeleteBucketRequest操作首先生成一个"request.Request"对象，该对象是一个执行DeleteBucket操作的请求。通过调用Request对象的Send方法完成删除bucket的操作。该方法可以生成定制化的请求，例如自定义请求头部请求超时重试设置。

func DeleteBucketRequest(svc *s3.S3) {
    deleteBucketInput := &s3.DeleteBucketInput{
        Bucket: aws.String("<your-bucket-name>"),
    }

    req, _ := svc.DeleteBucketRequest(deleteBucketInput)

    err := req.Send()
    if err != nil {
        fmt.Printf("fail to delete bucket. %v\n", err)
    }
}

请求参数

DeleteBucketInput可设置的参数如下：

参数	类型	说明	是否必要
Bucket	*string	bucket的名称	是

列举桶内对象

功能说明

列举桶内对象操作用于列出桶中的全部对象，该操作返回最多1000个对象信息，可以通过设置过滤条件来列出桶中符合特定条件的对象信息。

代码示例

func ListObjects(svc *s3.S3) {
    listObjectsInput := &s3.ListObjectsInput{
        Bucket: aws.String("<your-bucket-name>"),
    }

    ListObjectsOutput, err := svc.ListObjects(listObjectsInput)
    if err != nil {
        fmt.Printf("fail to list objects of bucket. %v\n", err)
    }
    for _, object := range ListObjectsOutput.Contents {
        fmt.Println(*object.Key)
    }
}

通过ListObjectsRequest操作：

ListObjectsRequest操作首先生成一个"request.Request"对象，该对象是一个执行ListObjects操作的请求。通过调用Request对象的Send方法完成列出bucket中对象的操作。该方法可以生成定制化的请求，例如自定义请求头部请求超时重试设置。

func ListObjectRequest(svc *s3.S3) {
    listObjectsInput := &s3.ListObjectsInput{
        Bucket: aws.String("<your-bucket-name>"),
    }
    req, listObjectsOutput := svc.ListObjectsRequest(listObjectsInput)

    err := req.Send()
    if err != nil {
        fmt.Printf("fail to list objects. %v\n", err)
    } else {
        fmt.Println(listObjectsOutput)
    }
}

如果 list 大于1000，则返回的结果中 isTruncated 为true，通过返回的 nextMarker 标记可以作为下次读取的起点。列举所有对象示例代码如下：

func ListAllObjects(svc *s3.S3) {
    var nextMarker *string

    for {
        listObjectsInput := &s3.ListObjectsInput{
            Bucket: aws.String("<your-bucket-name>"),
            Marker: nextMarker,
        }

        req, listObjectsOutput := svc.ListObjectsRequest(listObjectsInput)
        err := req.Send()
        if err != nil {
            fmt.Printf("Failed to list objects: %v\n", err)
            return
        }

        if listObjectsOutput.Contents != nil {
            for _, obj := range listObjectsOutput.Contents {
                fmt.Println("Object Key:", *obj.Key)
            }
        }

        if listObjectsOutput.IsTruncated != nil && *listObjectsOutput.IsTruncated {
            nextMarker = listObjectsOutput.NextMarker
        } else {
            break
        }
    }
}

请求参数

ListObjectsInput可设置的参数如下：

参数	类型	说明	是否必要
Bucket	*string	bucket的名称	是
Delimiter	*string	与Prefix参数一起用于对对象key进行分组的字符。所有key包含指定的Prefix且第一次出现Delimiter字符的对象作为一组。如果没有指定Prefix参数，按Delimiter对所有对象key进行分割，多个对象分割后从对象key开始到第一个Delimiter之间相同的部分形成一组	否
Marker	*string	指定一个标识符，返回的对象的key将是按照字典顺序排序后位于该标识符之后的所有对象	否
MaxKeys	*int64	设置response中返回object key的数量，默认值和最大值均为1000	否
Prefix	*string	限定返回对象的key必须以Prefix作为前缀	否

返回结果

ListObjectsOutput返回的属性如下：

属性名	类型	说明
CommonPrefixes	[]*CommonPrefix	当请求中设置了Delimiter和Prefix属性时，所有包含指定的Prefix且第一次出现Delimiter字符的对象key作为一组
Contents	[]*Object	对象数据，每个对象包含了Entity Tag、Key、LastModifiedTime、Owner和Size等信息
Delimiter	*string	与请求中设置的Delimiter一致
IsTruncated	*bool	当为false时表示返回结果中包含了全部符合本次请求查询条件的对象信息，否则只返回了数量为MaxKeys个的对象信息
Marker	*string	与请求中设置的Marker一致
MaxKeys	*int64	本次返回结果中包含的对象数量的最大值
Name	*string	执行本操作的桶名称
NextMarker	*string	当返回结果中的IsTruncated为true时，可以使用NextMarker作为下次查询的Marker，继续查询出下一部分的对象信息
Prefix	*string	与请求中设置的Prefix一致

列举桶内多版本对象

功能说明

列举桶内多版本对象操作可以获取关于对象版本信息的元数据，执行该操作需要对桶有READ权限。

代码示例

// 列出对象的版本信息
func ListObjectVersion(svc *s3.S3) {
    listObjectVersionsInput := &s3.ListObjectVersionsInput{
        Bucket: aws.String("<your-bucket-name>"),
        Prefix: aws.String("<your-object-key>"),
    }

    listObjectVersionsOutput, err := svc.ListObjectVersions(listObjectVersionsInput)
    if err != nil {
        fmt.Printf("fail to list object versions. %v\n", err)
        return
    }
    fmt.Println(listObjectVersionsOutput)
}

通过ListObjectVersionsRequest操作

ListObjectVersionsRequest操作首先生成一个"request.Request"对象，该对象是一个执行ListObjectVersions操作的请求。通过调用Request对象的Send方法来获取对象版本信息 。该方法可以生成定制化的请求，例如自定义请求头部请求超时重试设置。
func ListObjectVersionsRequest(svc *s3.S3) {
    listObjectVersionsInput := &s3.ListObjectVersionsInput{
        Bucket:    aws.String("<your-bucket-name>"),
        KeyMarker: aws.String("<your-object-key>"),
    }
    req, listObjectVersionsOutput := svc.ListObjectVersionsRequest(listObjectVersionsInput)

    err := req.Send()
    if err != nil {
        fmt.Printf("fail to list object versions. %v\n", err)
    } else {
        fmt.Println(listObjectVersionsOutput)
    }
}

请求参数

ListObjectVersionsInput可设置的参数如下：

参数	类型	说明	是否必要
Bucket	*string	查询版本信息的对象所在的桶的名称	是
Delimiter	*string	与Prefix参数一起用于对对象key进行分组的字符。所有key包含指定的Prefix且第一次出现Delimiter字符之间的对象作为一组。如果没有指定Prefix参数，按Delimiter对所有对象key进行分割，多个对象分割后从对象key开始到第一个Delimiter之间相同的部分形成一组	否
KeyMarker	*string	指定一个标识符，返回的对象的key将是按照字典顺序排序后位于该标识符之后的所有对象	否
MaxKeys	*int64	设置查询结果中返回对象key的数量，默认值和最大值均为1000	否
Prefix	*string	限定返回对象的key必须以Prefix作为前缀	否
VersionIdMarker	*string	列举多版本时指定对象的起始版本Id	否

返回结果

ListObjectVersionsOutput返回的属性如下：

属性名	类型	说明
CommonPrefixes	[]*CommonPrefix	当请求中设置了Delimiter和Prefix属性时，所有包含指定的Prefix且第一次出现Delimiter字符的对象key作为一组
DeleteMarkers	[]*DeleteMarkerEntry	对象删除标记信息数组，数组中每一项包含了是否为最新版本、对象key、最新修改时间、拥有者和版本Id等信息
Delimiter	*string	与请求中设置的Delimiter一致
IsTruncated	*bool	当为false时表示返回结果中包含了全部符合本次请求查询条件的对象版本信息，否则只返回了MaxKeys个对象版本信息
KeyMarker	*string	与请求中设置的KeyMarker一致
MaxKeys	*int64	本次返回结果中包含的对象版本信息数量的最大值
Name	*string	执行本操作的桶名称
NextKeyMarker	*string	当返回结果中的IsTruncated为true时，可以使用NextKeyMarker作为下次查询请求中的KeyMarker，继续查询出下一部分的对象版本信息
NextVersionIdMarker	*string	当返回结果中的IsTruncated为true时，可以使用NextVersionIdMarker作为下次查询请求中的VersionIdMarker，继续查询出下一部分的对象版本信息
Prefix	*string	与请求中设置的Prefix一致
VersionIdMarker	*string	表示列举多版本对象的起始版本Id，与请求中的该参数对应
Versions	[]*ObjectVersion	对象版本信息的数组，数组中每一项包含了对象的Entity Tag、是否为最新版本、对象key、最新修改时间、拥有者、大小、存储类型和版本Id的信息

设置桶ACL

功能说明

设置桶ACL操作可以通过access control list（ACL）设置一个桶的访问权限。用户在设置桶的ACL之前需要具备WRITE_ACP 权限。

Bucket的权限说明：

权限类型	说明
READ	可以对bucket进行list操作
READ_ACP	可以读取bucket的ACL信息。bucket的拥有者默认具有bucket的READ_ACP权限
WRITE	可以在bucket中创建对象，修改原有对象数据和删除对象
WRITE_ACP	可以修改bucket的ACL信息，授予该权限相当于授予FULL_CONTROL权限，因为具有WRITE_ACP权限的用户可以配置bucket的任意权限。bucket的拥有者默认具有bucket的WRITE_ACP权限
FULL_CONTROL	同时授予READ、READ_ACP、WRITE和WRITE_ACP权限

代码示例

func PutBucketAcl(svc *s3.S3) {
    bucket := "<your-bucket-name>"
    permission := "READ_ACP" // FULL_CONTROL、WRITE、WRITE_ACP、READ、READ_ACP
    granteeDisplayName := "<your-display-name>"
    granteeId := "<your-user-id>"
    userType := "CanonicalUser"
    // 获取当前ACL
    currentACL, err := svc.GetBucketAcl(&s3.GetBucketAclInput{Bucket: aws.String(bucket)})
    if err != nil {
        fmt.Printf("fail to get acl of bucket, %v\n", err)
        os.Exit(1)
    }
    // 创建一个新的授权信息
    var newGrantee = s3.Grantee{
        Type:        aws.String(userType),
        DisplayName: aws.String(granteeDisplayName),
        ID:          aws.String(granteeId),
    }
    var newGrant = s3.Grant{Grantee: &newGrantee, Permission: &permission}

    grants := currentACL.Grants
    owner := *currentACL.Owner.DisplayName
    ownerId := *currentACL.Owner.ID
    grants = append(grants, &newGrant)
    // 添加一个授权信息
    putBucketAclInput := &s3.PutBucketAclInput{
        Bucket: &bucket,
        AccessControlPolicy: &s3.AccessControlPolicy{
            Grants: grants,
            Owner: &s3.Owner{
                DisplayName: &owner,
                ID:          &ownerId,
            },
        },
    }

    _, err = svc.PutBucketAcl(putBucketAclInput)
    if err != nil {
        fmt.Printf("fail to put acl to bucket. %v\n", err)
        os.Exit(1)
    }
    fmt.Println("You gave user with ", permission, "permission to bucket ", bucket)
}

通过PutBucketAclRequest操作：

PutBucketAclRequest操作首先生成一个"request.Request"对象，该对象是一个执行PutBucketAcl操作的请求。通过调用Request对象的Send方法完成设置bucket ACL信息的操作。该方法可以生成定制化的请求，例如自定义请求头部请求超时重试设置。

func PutBucketAclRequest(svc *s3.S3) {
    bucket := "<your-bucket-name>"
    permission := "READ_ACP" // FULL_CONTROL、WRITE、WRITE_ACP、READ、READ_ACP
    granteeDisplayName := "<your-display-name>"
    granteeId := "<your-user-id>"
    userType := "CanonicalUser"
    // 获取当前ACL
    currentACL, err := svc.GetBucketAcl(&s3.GetBucketAclInput{Bucket: aws.String(bucket)})
    if err != nil {
        fmt.Printf("fail to get acl of bucket, %v\n", err)
        os.Exit(1)
    }
    // 创建一个新的授权信息
    var newGrantee = s3.Grantee{
        Type:        aws.String(userType),
        DisplayName: aws.String(granteeDisplayName),
        ID:          aws.String(granteeId),
    }
    var newGrant = s3.Grant{Grantee: &newGrantee, Permission: &permission}

    grants := currentACL.Grants
    owner := *currentACL.Owner.DisplayName
    ownerId := *currentACL.Owner.ID
    grants = append(grants, &newGrant)
    // 添加一个授权信息
    putBucketAclInput := &s3.PutBucketAclInput{
        Bucket: &bucket,
        AccessControlPolicy: &s3.AccessControlPolicy{
            Grants: grants,
            Owner: &s3.Owner{
                DisplayName: &owner,
                ID:          &ownerId,
            },
        },
    }

    req, _ := svc.PutBucketAclRequest(putBucketAclInput)

    err = req.Send()
    if err != nil {
        fmt.Printf("fail to put bucket acl. %v\n", err)
    }
}

请求参数

PutBucketAclInput可设置的参数如下：

参数	类型	说明	是否必要
ACL	*string	配置此bucket预定义的标准ACL信息，例如private，public-read等	否
AccessControlPolicy	*AccessControlPolicy	配置该bucket对于每个用户的ACL授权信息	否
Bucket	*string	bucket的名称	是
GrantFullControl	*string	用于自定义用户对此bucket的FULL_CONTROL权限信息	否
GrantRead	*string	用于自定义用户对此bucket的READ权限信息	否
GrantReadACP	*string	用于自定义用户对此bucket ACL的READ权限信息	否
GrantWrite	*string	用于自定义用户对此bucket的WRITE权限信息	否
GrantWriteACP	*string	用于自定义用户对此bucket ACL的WRITE权限信息	否

用户可以通过ACL参数设置bucket的访问权限，也可以通过GrantFullControl、GrantRead、GrantReadACP、GrantWrite、GrantWriteACP等参数设置bucket的访问权限，但二者只能同时使用一种方式。

获取桶ACL

功能说明

获取桶ACL操作用户获取bucket的access control list（ACL）信息。桶的ACL可以在创建的时候设置并且通过API查看，用户需要具有READ_ACP（读取桶ACL信息）权限才可以查询桶的ACL信息。

代码示例

// 获取桶的ACL信息
func GetBucketAcl(svc *s3.S3) {
    getBucketAclInput := &s3.GetBucketAclInput{
        Bucket: aws.String("<your-bucket-name>"),
    }

    getBucketAclOutput, err := svc.GetBucketAcl(getBucketAclInput)
    if err != nil {
        fmt.Printf("fail to get bucekt acl. %v\n", err)
        return
    }
    owner := getBucketAclOutput.Owner
    fmt.Printf("owner is %v with ID %v\n", *owner.DisplayName, *owner.ID)
    for _, grant := range getBucketAclOutput.Grants {
        fmt.Println(grant.String())
    }
}

通过GetBucketAclRequest操作：

GetBucketAclRequest操作首先生成一个"request.Request"对象，该对象是一个执行GetBucketAcl操作的请求。通过调用Request对象的Send方法完成获取bucket ACL信息的操作。该方法可以生成定制化的请求，例如自定义请求头部请求超时重试设置。
func GetBucketAclRequest(svc *s3.S3) {
    getBucketAclInput := &s3.GetBucketAclInput{
        Bucket: aws.String("<your-bucket-name>"),
    }
    req, getBucketAclOutput := svc.GetBucketAclRequest(getBucketAclInput)

    err := req.Send()
    if err != nil {
        fmt.Printf("fail to get bucket acl. %v\n", err)
    } else {
        fmt.Println(getBucketAclOutput)
    }
}

请求参数

GetBucketAclInput可设置的参数如下：

参数	类型	说明	是否必要
Bucket	*string	bucket的名称	是

返回结果

GetBucketAclOutput返回的属性如下：

属性名	类型	说明
Grants	[]*Grant	Grant信息的数组，包含了每项授权和被授予人的信息
Owner	*Owner	bucket的拥有者信息

设置桶策略

功能说明

桶策略（bukcet policy）可以灵活地配置用户各种操作和访问资源的权限。访问控制列表（access control lists，ACL）只能对单一对象设置权限，而桶策略可以基于各种条件对一个桶内的全部或者一组对象配置权限。桶的拥有者拥有PutBucketPolicy操作的权限，如果桶已经被设置了policy，则新的policy会覆盖原有的policy。

设置桶策略操作可以设置桶策略，描述桶策略的信息以JSON格式的字符串形式通过Policy参数传入。一个policy的示例如下：

{
    "Id":"PolicyId",
    "Version":"2012-10-17",
    "Statement":[
        {
            "Sid":"ExampleStatementID1",
            "Principal":{
                "AWS":[
                    "arn:aws:iam:::user/userId",
                    "arn:aws:iam:::user/userName"
                ]
            },
            "Effect":"Allow",
            "Action":[
                "s3:ListBucket",
                "s3:CreateBucket"
            ],
            "Resource":[
                "arn:aws:iam:::exampleBucket"
            ],
            "Condition":"some conditions"
        },
        ......
    ]
}

Statement的内容说明如下：

元素	描述	是否必要
Sid	statement Id，可选关键字，描述statement的字符串	否
Principal	可选关键字，被授权人，指定本条statement权限针对的Domain以及User，支持通配符“”，表示所有用户（匿名用户）。当对Domain下所有用户授权时，Principal格式为arn:aws:iam:::user/。当对某个User进行授权时，Principal格式为arn:aws:iam:::user/userId或者arn:aws:iam:::user/userName。	可选，Principal与NotPrincipal选其一
NotPrincipal	可选关键字，不被授权人，statement匹配除此之外的其他人。取值同Principal	可选，NotPrincipal与Principal选其一
Action	可选关键字，指定本条statement作用的操作，Action字段为对象存储支持的所有操作集合，以字符串形式表示，不区分大小写。支持通配符“”，表示该资源能进行的所有操作。例如："Action":["List", "Get*"]	可选，Action与NotAction选其一
NotAction	可选关键字，指定一组操作，statement匹配除该组操作之外的其他操作。取值同Action	可选，NotAction与Action选其一
Effect	必选关键字，效果，指定本条statement的权限是允许还是拒绝，Effect的值必须为Allow或者Deny	必选
Resource	可选关键字，指定statement起作用的一组资源，支持通配符“*”，表示所有资源	可选，Resource与NotResource选其一
NotResource	可选关键字，指定一组资源，statement匹配除该组资源之外的其他资源。取值同Resource	可选，NotResource与Resource选其一
Condition	可选关键字，本条statement生效的条件	可选

代码示例

// 设置桶策略
func PutBucketPolicy(svc *s3.S3) {
    putBucketPolicyInput := &s3.PutBucketPolicyInput{
        Bucket: aws.String("<your-bucket-name>"),
        Policy: aws.String("<example-policy>"),
    }
    _, err := svc.PutBucketPolicy(putBucketPolicyInput)
    if err != nil {
        fmt.Printf("fail to put bucket policy. %v\n", err)
    }
}

通过PutBucketPolicyRequest操作：

PutBucketPolicyRequest操作首先生成一个"request.Request"对象，该对象是一个执行PutBucketPolicy操作的请求。通过调用Request对象的Send方法完成设置桶策略的操作。该方法可以生成定制化的请求，例如自定义请求头部请求超时重试设置。

func PutBucketPolicyRequest(svc *s3.S3) {
    putBucketPolicyInput := &s3.PutBucketPolicyInput{
        Bucket: aws.String("<your-bucket-name>"),
        Policy: aws.String("<example-policy>"),
    }
    req, _ := svc.PutBucketPolicyRequest(putBucketPolicyInput)

    err := req.Send()
    if err != nil {
        fmt.Printf("fail to put bucket policy. %v\n", err)
    }
}

请求参数

PutBucketPolicyInput可以设置的参数如下：

参数	类型	说明	是否必要
Bucket	*string	桶的名称	是
Policy	*string	JSON格式的桶策略信息	是

获取桶策略

功能说明

获取桶策略操作用于获取桶的policy，policy配置功能可以使用户根据需求更精确地定义桶的访问策略。桶的拥有者可以查看桶的policy信息。

代码示例

// 获取桶的策略信息
func GetBucketPolicy(svc *s3.S3) {
    getBucketPolicyInput := &s3.GetBucketPolicyInput{
        Bucket: aws.String("<your-bucket-name>"),
    }

    getBucketPolicyOutput, err := svc.GetBucketPolicy(getBucketPolicyInput)
    if err != nil {
        fmt.Printf("fail to get policy of bucket. %v\n", err)
        return
    }
    fmt.Printf("policy of bucket: %v\n", *getBucketPolicyOutput.Policy)
}

通过GetBucketPolicyRequest操作：

GetBucketPolicyRequest操作首先生成一个"request.Request"对象，该对象是一个执行GetBucketPolicy操作的请求。通过调用Request对象的Send方法完成获取bucket policy信息的操作。该方法可以生成定制化的请求，例如自定义请求头部请求超时重试设置。

func GetBucketPolicyRequest(svc *s3.S3) {
    getBucketPolicyInput := &s3.GetBucketPolicyInput{
        Bucket: aws.String("<your-bucket-name>"),
    }
    req, getBucketPolicyOutput := svc.GetBucketPolicyRequest(getBucketPolicyInput)

    err := req.Send()
    if err != nil {
        fmt.Printf("fail to get bucket policy. %v\n", err)
    } else {
        fmt.Println(getBucketPolicyOutput)
    }
}

请求参数

GetBucketPolicyInput可设置的参数如下：

参数	类型	说明	是否必要
Bucket	*string	桶的名称	是

返回结果

GetBucketPolicyOutput返回的属性如下：

属性名	类型	说明
Policy	*string	JSON格式的桶策略信息

删除桶策略

功能说明

删除桶策略操作可以删除桶已经配置的策略，桶的创建者默认拥有删除桶策略的权限。

代码示例

func DeleteBucketPolicy(svc *s3.S3) {
    deleteBucketPolicyInput := &s3.DeleteBucketPolicyInput{
        Bucket: aws.String("<your-bucket-name>"),
    }

    _, err := svc.DeleteBucketPolicy(deleteBucketPolicyInput)
    if err != nil {
        fmt.Printf("fail to delete bucket policy. %v\n", err)
        return
    }
}

通过DeleteBucketPolicyRequest操作：

DeleteBucketPolicyRequest操作首先生成一个"request.Request"对象，该对象是一个执行DeleteBucketPolicy操作的请求。通过调用Request对象的Send方法完成删除桶策略的操作。该方法可以生成定制化的请求，例如自定义请求头部请求超时重试设置。

func DeleteBucketPolicyRequest(svc *s3.S3) {
    deleteBucketPolicyInput := &s3.DeleteBucketPolicyInput{
        Bucket: aws.String("<your-bucket-name>"),
    }
    req, _ := svc.DeleteBucketPolicyRequest(deleteBucketPolicyInput)

    err := req.Send()
    if err != nil {
        fmt.Printf("fail to delete bucket policy. %v\n", err)
    }
}

请求参数

DeleteBucketPolicyInput可以设置的参数如下：

参数	类型	说明	是否必要
Bucket	*string	桶的名称	是

设置桶生命周期规则

功能说明

设置桶生命周期规则操作可以设置桶的生命周期规则，规则可以通过匹配对象key前缀、标签的方法设置当前版本或者历史版本对象的过期时间，对象过期后会被自动删除。桶的版本控制状态必须处于Enabled或者Suspended，历史版本对象过期时间配置才能生效。每次执行操作会覆盖桶中已存在的生命周期规则。

代码示例

// 设置桶生命周期规则
func PutBucketLifecycleConfiguration(svc *s3.S3) {
    // rule1:设置匹配指定前缀的对象一天后过期
    rule1 := &s3.LifecycleRule{
        ID:     aws.String("expireAfterOneDay"),
        Status: aws.String("Enabled"),
        Filter: &s3.LifecycleRuleFilter{
            Prefix: aws.String("expireAfterOneDay/"),
        },
        Expiration: &s3.LifecycleExpiration{
            Days: aws.Int64(1),
        },
    }
    // rule2: 设置匹配指定前缀的对象的历史版本一天后过期
    rule2 := &s3.LifecycleRule{
        ID:     aws.String("noncurrentVersionExpireAfterOneDay"),
        Status: aws.String("Enabled"),
        Filter: &s3.LifecycleRuleFilter{
            Prefix: aws.String("noncurrentVersionExpireAfterOneDay/"),
        },
        NoncurrentVersionExpiration: &s3.NoncurrentVersionExpiration{
            NoncurrentDays: aws.Int64(1),
        },
    }
    // rule3: 设置匹配指定标签信息的对象一天后过期
    rule3 := &s3.LifecycleRule{
        ID:     aws.String("withTagsExpireAfterOneDay"),
        Status: aws.String("Enabled"),
        Expiration: &s3.LifecycleExpiration{
            Days: aws.Int64(1),
        },
        Filter: &s3.LifecycleRuleFilter{
            Tag: &s3.Tag{
                Key:   aws.String("<key1>"),
                Value: aws.String("<value1>"),
            },
        },
    }
    putBucketLifecycleConfigurationInput := &s3.PutBucketLifecycleConfigurationInput{
        Bucket: aws.String("<your-bucket-name>"),
        LifecycleConfiguration: &s3.BucketLifecycleConfiguration{
            Rules: []*s3.LifecycleRule{rule1, rule2, rule3},
        },
    }
    _, err := svc.PutBucketLifecycleConfiguration(putBucketLifecycleConfigurationInput)
    if err != nil {
        fmt.Printf("fail to put bucket lifecycle configuration. %v\n", err)
    }
}

通过PutBucketLifecycleConfigurationRequest操作：

PutBucketLifecycleConfigurationRequest操作首先生成一个"request.Request"对象，该对象是一个执行PutBucketLifecycleConfiguration操作的请求。通过调用Request对象的Send方法完成获设置桶生命周期规则的操作。该方法可以生成定制化的请求，例如自定义请求头部请求超时重试设置。

func PutBucketLifecycleConfigurationRequest(svc *s3.S3) {
    // rule1:设置匹配指定前缀的对象一天后过期
    rule1 := &s3.LifecycleRule{
        ID:     aws.String("expireAfterOneDay"),
        Status: aws.String("Enabled"),
        Filter: &s3.LifecycleRuleFilter{
            Prefix: aws.String("expireAfterOneDay/"),
        },
        Expiration: &s3.LifecycleExpiration{
            Days: aws.Int64(1),
        },
    }
    // rule2: 设置匹配指定前缀的对象的历史版本一天后过期
    rule2 := &s3.LifecycleRule{
        ID:     aws.String("noncurrentVersionExpireAfterOneDay"),
        Status: aws.String("Enabled"),
        Filter: &s3.LifecycleRuleFilter{
            Prefix: aws.String("noncurrentVersionExpireAfterOneDay/"),
        },
        NoncurrentVersionExpiration: &s3.NoncurrentVersionExpiration{
            NoncurrentDays: aws.Int64(1),
        },
    }
    // rule3: 设置匹配指定标签信息的对象一天后过期
    rule3 := &s3.LifecycleRule{
        ID:     aws.String("withTagsExpireAfterOneDay"),
        Status: aws.String("Enabled"),
        Expiration: &s3.LifecycleExpiration{
            Days: aws.Int64(1),
        },
        Filter: &s3.LifecycleRuleFilter{
            Tag: &s3.Tag{
                Key:   aws.String("<key1>"),
                Value: aws.String("<value1>"),
            },
        },
    }
    putBucketLifecycleConfigurationInput := &s3.PutBucketLifecycleConfigurationInput{
        Bucket: aws.String("<your-bucket-name>"),
        LifecycleConfiguration: &s3.BucketLifecycleConfiguration{
            Rules: []*s3.LifecycleRule{rule1, rule2, rule3},
        },
    }

    req, _ := svc.PutBucketLifecycleConfigurationRequest(putBucketLifecycleConfigurationInput)

    err := req.Send()
    if err != nil {
        fmt.Printf("fail to put bucket policy. %v\n", err)
    }
}

请求参数

PutBucketLifecycleConfigurationInput可设置的参数如下：

参数	类型	说明	是否必要
Bucket	*string	bucket的名称	是
LifecycleConfiguration	*BucketLifecycleConfiguration	封装了生命周期规则的数组	是

查看桶生命周期规则

功能说明

查看桶生命周期规则操作可以查看桶当前的生命周期规则。生命周期管理可以通过设置规则实现自动清理过期的对象，优化存储空间。

代码示例

func GetBucketLifecycleConfiguration(svc *s3.S3) {
    getBucketLifecycleConfigurationInput := &s3.GetBucketLifecycleConfigurationInput{
        Bucket: aws.String("<your-bucket-name>"),
    }
    getBucketLifecycleConfigurationOutput, err := svc.GetBucketLifecycleConfiguration(getBucketLifecycleConfigurationInput)
    if err != nil {
        fmt.Printf("fail to get bucket lifecycle. %v\n", err)

        return
    }
    fmt.Println(getBucketLifecycleConfigurationOutput)
}

通过GetBucketLifecycleConfigurationRequest操作：

GetBucketLifecycleConfigurationRequest操作首先生成一个"request.Request"对象，该对象是一个执行GetBucketLifecycleConfiguration操作的请求。通过调用Request对象的Send方法完成获取桶当前生命周期规则的操作。该方法可以生成定制化的请求，例如自定义请求头部请求超时重试设置。

func GetBucketLifecycleConfigurationRequest(svc *s3.S3) {
    getBucketLifecycleConfigurationInput := &s3.GetBucketLifecycleConfigurationInput{
        Bucket: aws.String("<your-bucket-name>"),
    }
    req, getBucketLifecycleConfigurationOutput := svc.GetBucketLifecycleConfigurationRequest(getBucketLifecycleConfigurationInput)

    err := req.Send()
    if err != nil {
        fmt.Printf("fail to put bucket policy. %v\n", err)
    } else {
        fmt.Println(getBucketLifecycleConfigurationOutput)
    }
}

请求参数

GetBucketLifecycleConfigurationInput可设置的参数如下：

参数	类型	说明	是否必要
Bucket	*string	bucket的名称	是

返回结果

GetBucketLifecycleConfigurationOutput返回的属性如下：

属性名	类型	说明
Rules	[]*LifecycleRule	一个描述生命周期管理的规则数组，一条规则包含了规则ID、匹配的对象key前缀、匹配的对象标签信息、当前版本对象过期时间、历史版本对象过期时间和是否生效标识等信息

删除桶生命周期规则

功能说明

删除桶生命周期操作可以删除桶中的全部生命周期规则。

代码示例

func DeleteBucketLifeCycle(svc *s3.S3) {
    deleteBucketLifecycleInput := &s3.DeleteBucketLifecycleInput{
        Bucket: aws.String("<your-bucket-name>"),
    }

    _, err := svc.DeleteBucketLifecycle(deleteBucketLifecycleInput)
    if err != nil {
        fmt.Printf("fail to delete bucket lifecycle. %v\n", err)
    }
}

通过DeleteBucketLifecycleRequest操作：

DeleteBucketLifecycleRequest操作首先生成一个"request.Request"对象，该对象是一个执行DeleteBucketLifecycle操作的请求。通过调用Request对象的Send方法完成删除桶生命周期规则的操作。该方法可以生成定制化的请求，例如自定义请求头部请求超时重试设置。

func DeleteBucketLifeCycleRequest(svc *s3.S3) {
    deleteBucketLifecycleInput := &s3.DeleteBucketLifecycleInput{
        Bucket: aws.String("<your-bucket-name>"),
    }

    req, _ := svc.DeleteBucketLifecycleRequest(deleteBucketLifecycleInput)

    err := req.Send()
    if err != nil {
        fmt.Printf("fail to put bucket policy. %v\n", err)
    }
}

请求参数

DeleteBucketLifecycleInput可设置的参数如下：

参数	类型	说明	是否必要
Bucket	*string	bucket的名称	是

配置桶的website配置

功能说明

设置桶的静态网站配置。

代码示例

func PutBucketWebsite(svc *s3.S3) {
    putBucketWebsiteInput := &s3.PutBucketWebsiteInput{
        Bucket: aws.String("<your-bucket-name>"),
        WebsiteConfiguration: &s3.WebsiteConfiguration{
            ErrorDocument: &s3.ErrorDocument{
                Key: aws.String("error.html"),
            },
            IndexDocument: &s3.IndexDocument{
                Suffix: aws.String("index.html"),
            },
        },
    }

    _, err := svc.PutBucketWebsite(putBucketWebsiteInput)
    if err != nil {
        fmt.Printf("fail to put bucket website. %v\n", err)
    }
}

通过PutBucketWebsiteRequest操作设置桶网站配置：

PutBucketWebsiteRequest操作首先生成一个"request.Request"对象，该对象是一个执行PutBucketWebsite操作的请求。通过调用Request对象的Send方法完成设置桶静态网站配置的操作。该方法可以生成定制化的请求，例如自定义请求头部请求超时重试设置。

func PutBucketWebsiteRequest(svc *s3.S3) {
    putBucketWebsiteInput := &s3.PutBucketWebsiteInput{
        Bucket: aws.String("<your-bucket-name>"),
        WebsiteConfiguration: &s3.WebsiteConfiguration{
            ErrorDocument: &s3.ErrorDocument{
                Key: aws.String("error.html"),
            },
            IndexDocument: &s3.IndexDocument{
                Suffix: aws.String("index.html"),
            },
        },
    }

    req, _ := svc.PutBucketWebsiteRequest(putBucketWebsiteInput)
    err := req.Send()
    if err != nil {
        fmt.Printf("fail to put bucket website. %v\n", err)
    }
}

请求参数

PutBucketWebsiteInput可设置的参数如下：

参数	类型	说明	是否必要
Bucket	*string	bucket的名称	是
WebsiteConfiguration	*WebsiteConfiguration	描述桶网站配置的配置项	是

获取桶的website配置

功能说明

获取桶的静态网站配置。

代码示例

func GetBucketWebsite(svc *s3.S3) {
    getBucketWebsiteInput := &s3.GetBucketWebsiteInput{
        Bucket: aws.String("<your-bucket-name>"),
    }

    getBucketWebsiteOutput, err := svc.GetBucketWebsite(getBucketWebsiteInput)
    if err != nil {
        fmt.Printf("fail to get bucket website. %v\n", err)
    } else {
        fmt.Println(getBucketWebsiteOutput)
    }
}

通过GetBucketWebsiteRequest操作获取桶网站配置：

GetBucketWebsiteRequest操作首先生成一个"request.Request"对象，该对象是一个执行GetBucketWebsite操作的请求。通过调用Request对象的Send方法完成获取桶静态网站配置的操作。该方法可以生成定制化的请求，例如自定义请求头部请求超时重试设置。
func GetBucketWebsiteRequest(svc *s3.S3) {
    getBucketWebsiteInput := &s3.GetBucketWebsiteInput{
        Bucket: aws.String("<your-bucket-name>"),
    }

    req, getBucketWebsiteOutput := svc.GetBucketWebsiteRequest(getBucketWebsiteInput)
    err := req.Send()
    if err != nil {
        fmt.Printf("fail to get bucket website. %v\n", err)
    } else {
        fmt.Println(getBucketWebsiteOutput)
    }
}

请求参数

GetBucketWebsiteInput可设置的参数如下：

参数	类型	说明	是否必要
Bucket	*string	bucket的名称	是

返回结果

GetBucketWebsiteOutput返回的属性如下：

属性名	类型	说明
ErrorDocument	*ErrorDocument	错误页面信息
IndexDocument	*IndexDocument	默认主页页面信息
RedirectAllRequestsTo	*RedirectAllRequestsTo	重定向全部请求配置
RoutingRules	[]*RoutingRule	重定向规则配置

删除桶的website配置

功能说明

删除桶的静态网站配置。

代码示例

func DeleteBucketWebsite(svc *s3.S3) {
    deleteBucketWebsiteInput := &s3.DeleteBucketWebsiteInput{
        Bucket: aws.String("<your-bucket-name>"),
    }

    _, err := svc.DeleteBucketWebsite(deleteBucketWebsiteInput)
    if err != nil {
        fmt.Printf("fail to delete bucket website. %v\n", err)
    }
}

通过DeleteBucketWebsiteRequest操作：

DeleteBucketWebsiteRequest操作首先生成一个"request.Request"对象，该对象是一个执行DeleteBucketWebsite操作的请求。通过调用Request对象的Send方法完成删除桶静态网站配置的操作。该方法可以生成定制化的请求，例如自定义请求头部请求超时重试设置。

func DeleteBucketWebsiteRequest(svc *s3.S3) {
    deleteBucketWebsiteInput := &s3.DeleteBucketWebsiteInput{
        Bucket: aws.String("<your-bucket-name>"),
    }

    req, _ := svc.DeleteBucketWebsiteRequest(deleteBucketWebsiteInput)
    err := req.Send()
    if err != nil {
        fmt.Printf("fail to delete bucket website. %v\n", err)
    }
}

请求参数

DeleteBucketWebsiteInput可设置的参数如下：

参数	类型	说明	是否必要
Bucket	*string	bucket的名称	是

设置桶的多版本状态

功能说明

设置桶多版本状态操作可以设置版本控制状态。桶的版本控制状态可以设置为以下的值：

Enabled：对bucket中的所有对象启用版本控制，之后每个添加到bucket中的对象都会被设置一个唯一的version id。
Suspended：关闭bucket的版本控制，之后每个添加到bucket中的对象的version ID会被设置为null。

代码示例

func PutBucketVersioning(svc *s3.S3) {
    putBucketVersioningInput := &s3.PutBucketVersioningInput{
        Bucket: aws.String("<your-bucket-name>"),
        VersioningConfiguration: &s3.VersioningConfiguration{
            Status:    aws.String("Enabled"), //启用版本控制：Enabled，暂停版本控制：Suspended
        },
    }

    _, err := svc.PutBucketVersioning(putBucketVersioningInput)
    if err != nil {
        fmt.Printf("fail to put bucket versioning. %v\n", err)
        return
    }
}

通过PutBucketVersioningRequest操作：

PutBucketVersioningRequest操作首先生成一个"request.Request"对象，该对象是一个执行PutBucketVersioning操作的请求。通过调用Request对象的Send方法完成配置bucket版本控制信息的操作。该方法可以生成定制化的请求，例如自定义请求头部请求超时重试设置。

func PutBucketVersioningRequest(svc *s3.S3) {
    putBucketVersioningInput := &s3.PutBucketVersioningInput{
        Bucket: aws.String("<your-bucket-name>"),
        VersioningConfiguration: &s3.VersioningConfiguration{
            Status: aws.String("Enabled"), //启用版本控制
        },
    }
    req, _ := svc.PutBucketVersioningRequest(putBucketVersioningInput)

    err := req.Send()
    if err != nil {
        fmt.Printf("fail to put bucket versioning request. %v\n", err)
    }
}

请求参数

PutBucketVersioningInput可设置的参数如下：

参数	类型	说明	是否必要
Bucket	*string	bucket的名称	是
VersioningConfiguration	*VersioningConfiguration	封装了设置版本控制状态的参数	是

获取桶的多版本状态

功能说明

获取桶的多版本状态操作可以获取桶的版本控制状态信息。只有bucket的拥有者才能获取到桶的版本控制信息。

每个桶的版本控制有三个状态：未开启、开启（Enabled）和暂停（Suspended）版本控制，如果桶从来没有被设置过版本控制状态，那么该桶默认为未开启版本控制状态，执行GetBucketVersioning操作不能获取任何版本控制信息。

代码示例

func GetBucketVersioning(svc *s3.S3){
    getBucketVersioningInput := &s3.GetBucketVersioningInput{
        Bucket: aws.String("<your-bucket-name>"),
    }

    getBucketVersioningOutput, err := svc.GetBucketVersioning(getBucketVersioningInput)
    if err != nil {
        fmt.Printf("fail to get bucket versioning. %v\n", err)
        return
    }
    fmt.Println(getBucketVersioningOutput)
}

通过GetBucketVersioningRequest操作：

GetBucketVersioningRequest操作首先生成一个"request.Request"对象，该对象是一个执行GetBucketVersioning操作的请求。通过调用Request对象的Send方法完成获取bucket版本控制配置信息的操作。该方法可以生成定制化的请求，例如自定义请求头部请求超时重试设置。

func GetBucketVersioningRequest(svc *s3.S3) {
    getBucketVersioningInput := &s3.GetBucketVersioningInput{
        Bucket: aws.String("<your-bucket-name>"),
    }
    req, getBucketVersioningOutput := svc.GetBucketVersioningRequest(getBucketVersioningInput)

    err := req.Send()
    if err != nil {
        fmt.Printf("fail to get bucket versioning. %v\n", err)
    } else {
        fmt.Println(getBucketVersioningOutput)
    }
}

请求参数

GetBucketVersioningInput可设置的参数如下：

参数	类型	说明	是否必要
Bucket	*string	bucket的名称	是

返回结果

GetBucketVersioningOutput返回的属性如下：

属性名	类型	说明
Status	*string	桶的版本控制设置状态

设置桶的CORS配置

功能说明

设置桶的跨域资源共享CORS（Cross-Origin Resource Sharing）规则。桶默认不开启跨域资源共享规则，设置桶的跨域资源共享规则时，新配置的规则会覆盖已有的规则。

代码示例

func PutBucketCors(svc *s3.S3) {
    putBucketCorsInput := &s3.PutBucketCorsInput{
        Bucket: aws.String("<your-bucket-name>"),
        CORSConfiguration: &s3.CORSConfiguration{
            CORSRules: []*s3.CORSRule{
                {
                    AllowedHeaders: []*string{
                        aws.String("*"),
                    },
                    AllowedMethods: []*string{
                        aws.String("PUT"),
                        aws.String("POST"),
                        aws.String("DELETE"),
                    },
                    AllowedOrigins: []*string{
                        aws.String("http://www.example.com"),
                    },
                    ExposeHeaders: []*string{
                        aws.String("x-amz-server-side-encryption"),
                    },
                    MaxAgeSeconds: aws.Int64(3000),
                },
                {
                    AllowedHeaders: []*string{
                        aws.String("Authorization"),
                    },
                    AllowedMethods: []*string{
                        aws.String("GET"),
                    },
                    AllowedOrigins: []*string{
                        aws.String("*"),
                    },
                    MaxAgeSeconds: aws.Int64(3000),
                },
            },
        },
    }

    _, err := svc.PutBucketCors(putBucketCorsInput)
    if err != nil {
        fmt.Printf("fail to put bucket cors. %v\n", err)
    }
}

通过PutBucketCorsRequest操作：

PutBucketCorsRequest操作首先生成一个"request.Request"对象，该对象是一个执行PutBucketCors操作的请求。通过调用Request对象的Send方法完成设置桶CORS配置的操作。该方法可以生成定制化的请求，例如自定义请求头部请求超时重试设置。

func PutBucketCorsRequest(svc *s3.S3) {
    putBucketCorsInput := &s3.PutBucketCorsInput{
        Bucket: aws.String("<your-bucket-name>"),
        CORSConfiguration: &s3.CORSConfiguration{
            CORSRules: []*s3.CORSRule{
                {
                    AllowedHeaders: []*string{
                        aws.String("*"),
                    },
                    AllowedMethods: []*string{
                        aws.String("PUT"),
                        aws.String("POST"),
                        aws.String("DELETE"),
                    },
                    AllowedOrigins: []*string{
                        aws.String("http://www.example.com"),
                    },
                    ExposeHeaders: []*string{
                        aws.String("x-amz-server-side-encryption"),
                    },
                    MaxAgeSeconds: aws.Int64(3000),
                },
                {
                    AllowedHeaders: []*string{
                        aws.String("Authorization"),
                    },
                    AllowedMethods: []*string{
                        aws.String("GET"),
                    },
                    AllowedOrigins: []*string{
                        aws.String("*"),
                    },
                    MaxAgeSeconds: aws.Int64(3000),
                },
            },
        },
    }

    req, _ := svc.PutBucketCorsRequest(putBucketCorsInput)
    err := req.Send()
    if err != nil {
        fmt.Printf("fail to put bucket cors. %v\n", err)
    }
}

请求参数

PutBucketCorsInput可设置的参数如下：

参数	类型	说明	是否必要
Bucket	*string	bucket的名称	是
CORSConfiguration	*CORSConfiguration	描述桶跨域配置的配置信息	是

获取桶的CORS配置

功能说明

获取指定桶当前生效的跨域资源共享CORS（Cross-Origin Resource Sharing）规则。

代码示例

func GetBucketCors(svc *s3.S3) {
    getBucketCorsInput := &s3.GetBucketCorsInput{
        Bucket: aws.String("<your-bucket-name>"),
    }

    getBucketCorsOutput, err := svc.GetBucketCors(getBucketCorsInput)
    if err != nil {
        fmt.Printf("fail to get bucket cors. %v\n", err)
    } else {
        fmt.Println(getBucketCorsOutput)
    }
}

通过GetBucketCorsRequest操作：

GetBucketCorsRequest操作首先生成一个"request.Request"对象，该对象是一个执行GetBucketCors操作的请求。通过调用Request对象的Send方法完成获取桶CORS配置的操作。该方法可以生成定制化的请求，例如自定义请求头部请求超时重试设置。
func GetBucketCorsRequest(svc *s3.S3) {
    getBucketCorsInput := &s3.GetBucketCorsInput{
        Bucket: aws.String("<your-bucket-name>"),
    }

    req, getBucketCorsOutput := svc.GetBucketCorsRequest(getBucketCorsInput)
    err := req.Send()
    if err != nil {
        fmt.Printf("fail to get bucket cors. %v\n", err)
    } else {
        fmt.Println(getBucketCorsOutput)
    }
}

请求参数

GetBucketCorsInput可设置的参数如下：

参数	类型	说明	是否必要
Bucket	*string	bucket的名称	是

返回结果

GetBucketCorsOutput返回的属性如下：

属性名	类型	说明
CORSRules	[]*CORSRule	桶设置的跨域资源共享规则的集合

删除桶的CORS配置

功能说明

删除指定桶的跨域资源共享CORS（Cross-Origin Resource Sharing）所有规则并关闭跨域资源共享功能。

代码示例

func DeleteBucketCors(svc *s3.S3) {
    deleteBucketCorsInput := &s3.DeleteBucketCorsInput{
        Bucket: aws.String("<your-bucket-name>"),
    }

    _, err := svc.DeleteBucketCors(deleteBucketCorsInput)
    if err != nil {
        fmt.Printf("fail to delete bucket website. %v\n", err)
    }
}

通过DeleteBucketCorsRequest操作：

DeleteBucketCorsRequest操作首先生成一个"request.Request"对象，该对象是一个执行DeleteBucketCors操作的请求。通过调用Request对象的Send方法完成删除桶CORS配置的操作。该方法可以生成定制化的请求，例如自定义请求头部请求超时重试设置。

func DeleteBucketCorsRequest(svc *s3.S3) {
    deleteBucketCorsInput := &s3.DeleteBucketCorsInput{
        Bucket: aws.String("<your-bucket-name>"),
    }

    req, _ := svc.DeleteBucketCorsRequest(deleteBucketCorsInput)
    err := req.Send()
    if err != nil {
        fmt.Printf("fail to delete bucket website. %v\n", err)
    }
}

请求参数

DeleteBucketCorsInput可设置的参数如下：

参数	类型	说明	是否必要
Bucket	*string	bucket的名称	是

设置桶标签

功能说明

以key-value的形式为桶设置标签，通过设置通标签可以标记桶的用途，方便对其进行分类和管理。

代码示例

func PutBucketTagging(svc *s3.S3) {
    putBucketTaggingInput := &s3.PutBucketTaggingInput{
        Bucket: aws.String("<your-bucket-name>"),
        Tagging: &s3.Tagging{
            TagSet: []*s3.Tag{
                {
                    Key:   aws.String("<key1>"),
                    Value: aws.String("<value1>"),
                },
                {
                    Key:   aws.String("<key2>"),
                    Value: aws.String("<value2>"),
                },
            },
        },
    }

    _, err := svc.PutBucketTagging(putBucketTaggingInput)
    if err != nil {
        fmt.Printf("fail to put bucket tagging. %v\n", err)
    }
}

通过PutBucketTaggingRequest操作：

PutBucketTaggingRequest操作首先生成一个"request.Request"对象，该对象是一个执行PutBucketTagging操作的请求。通过调用Request对象的Send方法完成设置桶标签的操作。该方法可以生成定制化的请求，例如自定义请求头部请求超时重试设置。

func PutBucketTaggingRequest(svc *s3.S3) {
    putBucketTaggingInput := &s3.PutBucketTaggingInput{
        Bucket: aws.String("<your-bucket-name>"),
        Tagging: &s3.Tagging{
            TagSet: []*s3.Tag{
                {
                    Key:   aws.String("<key1>"),
                    Value: aws.String("<value1>"),
                },
                {
                    Key:   aws.String("<key2>"),
                    Value: aws.String("<value2>"),
                },
            },
        },
    }

    req, _ := svc.PutBucketTaggingRequest(putBucketTaggingInput)
    err := req.Send()
    if err != nil {
        fmt.Printf("fail to put bucket tagging. %v\n", err)
    }
}

请求参数

PutBucketTaggingInput可设置的参数如下：

参数	类型	说明	是否必要
Bucket	*string	bucket的名称	是
Tagging	*Tagging	描述桶标签的信息	是

获取桶标签

功能说明

获取指定桶的标签信息。

代码示例

func GetBucketTagging(svc *s3.S3) {
    getBucketTaggingInput := &s3.GetBucketTaggingInput{
        Bucket: aws.String("<your-bucket-name>"),
    }

    getBucketTaggingOutput, err := svc.GetBucketTagging(getBucketTaggingInput)
    if err != nil {
        fmt.Printf("fail to get bucket tagging. %v\n", err)
        return
    }
    fmt.Println(getBucketTaggingOutput)
}

通过GetBucketTaggingRequest操作：

GetBucketTaggingRequest操作首先生成一个"request.Request"对象，该对象是一个执行GetBucketTagging操作的请求。通过调用Request对象的Send方法完成获取桶标签的操作。该方法可以生成定制化的请求，例如自定义请求头部请求超时重试设置。

func GetBucketTaggingRequest(svc *s3.S3) {
    getBucketTaggingInput := &s3.GetBucketTaggingInput{
        Bucket: aws.String("<your-bucket-name>"),
    }
    req, getBucketTaggingOutput := svc.GetBucketTaggingRequest(getBucketTaggingInput)

    err := req.Send()
    if err != nil {
        fmt.Printf("fail to get bucket tagging. %v\n", err)
    } else {
        fmt.Println(getBucketTaggingOutput)
    }
}

请求参数

GetBucketTaggingInput可设置的参数如下：

参数	类型	说明	是否必要
Bucket	*string	bucket的名称	是

返回结果

GetBucketTaggingOutput返回的属性如下：

属性名	类型	说明
TagSet	[]*Tag	桶的标签集合，以key-value的形式描述桶标签信息

删除桶标签

功能说明

删除指定桶的全部标签。

代码示例

func DeleteBucketTagging(svc *s3.S3) {
    deleteBucketTaggingInput := &s3.DeleteBucketTaggingInput{
        Bucket: aws.String("<your-bucket-name>"),
    }

    _, err := svc.DeleteBucketTagging(deleteBucketTaggingInput)
    if err != nil {
        fmt.Printf("fail to delete bucket tagging. %v\n", err)
        return
    }
}

通过DeleteBucketTaggingRequest操作：

DeleteBucketTaggingRequest操作首先生成一个"request.Request"对象，该对象是一个执行DeleteBucketTagging操作的请求。通过调用Request对象的Send方法完成删除桶标签的操作。该方法可以生成定制化的请求，例如自定义请求头部请求超时重试设置。

func DeleteBucketTaggingRequest(svc *s3.S3) {
    deleteBucketTaggingInput := &s3.DeleteBucketTaggingInput{
        Bucket: aws.String("<your-bucket-name>"),
    }
    req, _ := svc.DeleteBucketTaggingRequest(deleteBucketTaggingInput)

    err := req.Send()
    if err != nil {
        fmt.Printf("fail to delete bucket tagging. %v\n", err)
    }
}

请求参数

DeleteBucketTaggingInput可设置的参数如下：

参数	类型	说明	是否必要
Bucket	*string	bucket的名称	是

设置桶加密配置

功能说明

获取指定桶的加密配置信息。

代码示例

func GetBucketEncryption(svc *s3.S3) {
    getBucketEncryptionInput := &s3.GetBucketEncryptionInput{
        Bucket: aws.String("<your-bucket-name>"),
    }

    GetBucketEncryptionOutput, err := svc.GetBucketEncryption(getBucketEncryptionInput)
    if err != nil {
        fmt.Printf("fail to get bucket encryption. %v\n", err)
    } else {
        fmt.Println(GetBucketEncryptionOutput)
    }
}

通过GetBucketEncryptionRequest操作：

GetBucketEncryptionRequest操作首先生成一个"request.Request"对象，该对象是一个执行GetBucketEncryption操作的请求。通过调用Request对象的Send方法完成获取桶加密配置的操作。该方法可以生成定制化的请求，例如自定义请求头部请求超时重试设置。
func GetBucketEncryptionRequest(svc *s3.S3) {
    GetBucketEncryptionInput := &s3.GetBucketEncryptionInput{
        Bucket: aws.String("<your-bucket-name>"),
    }

    req, GetBucketEncryptionOutput := svc.GetBucketEncryptionRequest(GetBucketEncryptionInput)
    err := req.Send()
    if err != nil {
        fmt.Printf("fail to get bucket encryption. %v\n", err)
    } else {
        fmt.Println(GetBucketEncryptionOutput)
    }
}

请求参数

GetBucketEncryptionInput可设置的参数如下：

参数	类型	说明	是否必要
Bucket	*string	bucket的名称	是

返回结果

GetBucketEncryptionOutput返回的属性如下：

属性名	类型	说明
ServerSideEncryptionConfiguration	*ServerSideEncryptionConfiguration	桶设置的加密配置信息

获取桶加密配置

功能说明

获取指定桶的加密配置信息。

代码示例

func GetBucketEncryption(svc *s3.S3) {
    getBucketEncryptionInput := &s3.GetBucketEncryptionInput{
        Bucket: aws.String("<your-bucket-name>"),
    }

    GetBucketEncryptionOutput, err := svc.GetBucketEncryption(getBucketEncryptionInput)
    if err != nil {
        fmt.Printf("fail to get bucket encryption. %v\n", err)
    } else {
        fmt.Println(GetBucketEncryptionOutput)
    }
}

通过GetBucketEncryptionRequest操作：

GetBucketEncryptionRequest操作首先生成一个"request.Request"对象，该对象是一个执行GetBucketEncryption操作的请求。通过调用Request对象的Send方法完成获取桶加密配置的操作。该方法可以生成定制化的请求，例如自定义请求头部请求超时重试设置。

func GetBucketEncryptionRequest(svc *s3.S3) {
    GetBucketEncryptionInput := &s3.GetBucketEncryptionInput{
        Bucket: aws.String("<your-bucket-name>"),
    }

    req, GetBucketEncryptionOutput := svc.GetBucketEncryptionRequest(GetBucketEncryptionInput)
    err := req.Send()
    if err != nil {
        fmt.Printf("fail to get bucket encryption. %v\n", err)
    } else {
        fmt.Println(GetBucketEncryptionOutput)
    }
}

请求参数

GetBucketEncryptionInput可设置的参数如下：

参数	类型	说明	是否必要
Bucket	*string	bucket的名称	是

返回结果

GetBucketEncryptionOutput返回的属性如下：

属性名	类型	说明
ServerSideEncryptionConfiguration	*ServerSideEncryptionConfiguration	桶设置的加密配置信息

删除桶加密配置

功能说明

删除指定桶的全部加密配置，停用上传对象时自动加密功能。

代码示例

func DeleteBucketEncryption(svc *s3.S3) {
    deleteBucketEncryptionInput := &s3.DeleteBucketEncryptionInput{
        Bucket: aws.String("<your-bucket-name>"),
    }

    _, err := svc.DeleteBucketEncryption(deleteBucketEncryptionInput)
    if err != nil {
        fmt.Printf("fail to delete bucket encryption. %v\n", err)
    }
}

通过DeleteBucketEncryptionRequest操作：

DeleteBucketEncryptionRequest操作首先生成一个"request.Request"对象，该对象是一个执行DeleteBucketEncryption操作的请求。通过调用Request对象的Send方法完成删除桶加密配置的操作。该方法可以生成定制化的请求，例如自定义请求头部请求超时重试设置。
func DeleteBucketEncryptionRequest(svc *s3.S3) {
    deleteBucketEncryptionInput := &s3.DeleteBucketEncryptionInput{
        Bucket: aws.String("<your-bucket-name>"),
    }

    req, _ := svc.DeleteBucketEncryptionRequest(deleteBucketEncryptionInput)
    err := req.Send()
    if err != nil {
        fmt.Printf("fail to delete bucket encryption. %v\n", err)
    }
}

请求参数

DeleteBucketEncryptionInput可设置的参数如下：

参数	类型	说明	是否必要
Bucket	*string	bucket的名称	是

活动

智算服务

应用商城

定价

合作伙伴

开发者

支持与服务

了解天翼云

媒体存储

媒体存储

创建桶

功能说明

代码示例

请求参数

获取桶列表

功能说明

代码示例

返回结果

判断桶是否存在

功能说明

代码示例

请求参数

删除桶

功能说明

代码示例

请求参数

列举桶内对象

功能说明

代码示例

请求参数

返回结果

列举桶内多版本对象

功能说明

代码示例

请求参数

返回结果

设置桶ACL

功能说明

代码示例

​请求参数

获取桶ACL

功能说明

代码示例

请求参数

返回结果

设置桶策略

功能说明

代码示例

请求参数

获取桶策略

功能说明

代码示例

请求参数

返回结果

删除桶策略

功能说明

代码示例

请求参数

设置桶生命周期规则

功能说明

代码示例

请求参数

查看桶生命周期规则

功能说明

代码示例

请求参数

返回结果

删除桶生命周期规则

功能说明

代码示例

请求参数

配置桶的website配置

功能说明

代码示例

请求参数

获取桶的website配置

功能说明

代码示例

请求参数

返回结果

请求参数

请求参数