管理对象访问权限

更新时间： 2019-03-14 10:05

对象访问权限与桶访问权限类似，也可支持预定义访问策略（参见桶访问权限）或直接设置。

对象访问权限（ACL）可以通过三种方式设置：

  • 上传对象时指定预定义访问策略。
  • 调用ObsClient.SetObjectAcl指定预定义访问策略。
  • 调用ObsClient.SetObjectAcl直接设置。

上传对象时指定预定义访问策略

以下代码展示如何在上传对象时指定预定义访问策略：

  1. // 引入依赖包
  2. import (
  3.        "fmt"
  4.        "obs"
  5.        "strings"
  6. )
  7.  
  8. var ak = "*** Provide your Access Key ***"
  9. var sk = "*** Provide your Secret Key ***"
  10. var endpoint = "https://your-endpoint"
  11.  
  12. // 创建ObsClient结构体
  13. var obsClient, _ = obs.New(ak, sk, endpoint)
  14.  
  15. func main() {
  16.        input := &obs.PutObjectInput{}
  17.        input.Bucket = "bucketname"
  18.        input.Key = "objectkey"
  19.        input.Body = strings.NewReader("Hello OBS")
  20.        // 设置对象访问权限为公共读
  21.        input.ACL = obs.AclPublicRead
  22.  
  23.        output, err := obsClient.PutObject(input)
  24.        if err == nil {
  25.               fmt.Printf("RequestId:%s\n", output.RequestId)
  26.        } else if obsError, ok := err.(obs.ObsError); ok {
  27.               fmt.Printf("Code:%s\n", obsError.Code)
  28.               fmt.Printf("Message:%s\n", obsError.Message)
  29.        }
  30. }

为对象设置预定义访问策略

以下代码展示如何为对象设置预定义访问策略：

  1. // 引入依赖包
  2. import (
  3.        "fmt"
  4.        "obs"
  5. )
  6.  
  7. var ak = "*** Provide your Access Key ***"
  8. var sk = "*** Provide your Secret Key ***"
  9. var endpoint = "https://your-endpoint"
  10.  
  11. // 创建ObsClient结构体
  12. var obsClient, _ = obs.New(ak, sk, endpoint)
  13.  
  14. func main() {
  15.        input := &obs.SetObjectAclInput{}
  16.        input.Bucket = "bucketname"
  17.        input.Key = "objectkey"
  18.        // 设置对象访问权限为私有读写
  19.        input.ACL = obs.AclPrivate
  20.        output, err := obsClient.SetObjectAcl(input)
  21.        if err == nil {
  22.               fmt.Printf("RequestId:%s\n", output.RequestId)
  23.        } else if obsError, ok := err.(obs.ObsError); ok {
  24.               fmt.Printf("Code:%s\n", obsError.Code)
  25.               fmt.Printf("Message:%s\n", obsError.Message)
  26.        }
  27. }

直接设置对象访问权限

以下代码展示如何直接设置对象访问权限：

  1. // 引入依赖包
  2. import (
  3.        "fmt"
  4.        "obs"
  5. )
  6.  
  7. var ak = "*** Provide your Access Key ***"
  8. var sk = "*** Provide your Secret Key ***"
  9. var endpoint = "https://your-endpoint"
  10.  
  11. // 创建ObsClient结构体
  12. var obsClient, _ = obs.New(ak, sk, endpoint)
  13.  
  14. func main() {
  15.        input := &obs.SetObjectAclInput{}
  16.        input.Bucket = "bucketname"
  17.        input.Key = "objectkey"
  18.  
  19.        input.Owner.ID = "ownerid"
  20.  
  21.        var grants [3]obs.Grant
  22.        // 为授权用户设置写权限
  23.        grants[0].Grantee.Type = obs.GranteeGroup
  24.        grants[0].Grantee.URI = obs.GroupAuthenticatedUsers
  25.        grants[0].Permission = obs.PermissionWrite
  26.  
  27.        // 为指定用户设置完全控制权限
  28.        grants[1].Grantee.Type = obs.GranteeUser
  29.        grants[1].Grantee.ID = "granteeid"
  30.        grants[1].Permission = obs.PermissionFullControl
  31.  
  32.        // 为所有用户设置读权限
  33.        grants[2].Grantee.Type = obs.GranteeGroup
  34.        grants[2].Grantee.URI = obs.GroupAllUsers
  35.        grants[2].Permission = obs.PermissionRead
  36.        input.Grants = grants[0:3]
  37.  
  38.        output, err := obsClient.SetObjectAcl(input)
  39.        if err == nil {
  40.               fmt.Printf("RequestId:%s\n", output.RequestId)
  41.        } else if obsError, ok := err.(obs.ObsError); ok {
  42.               fmt.Printf("Code:%s\n", obsError.Code)
  43.               fmt.Printf("Message:%s\n", obsError.Message)
  44.        }
  45. }

管理对象访问权限 - 图1 说明：

所有者ID或者被授权用户ID，是指用户的账户ID，可通过OBS控制台“我的凭证”页面查看。

获取对象访问权限

您可以通过ObsClient.GetObjectAcl获取对象的访问权限。以下代码展示如何获取对象访问权限：

  1. // 引入依赖包
  2. import (
  3.        "fmt"
  4.        "obs"
  5. )
  6.  
  7. var ak = "*** Provide your Access Key ***"
  8. var sk = "*** Provide your Secret Key ***"
  9. var endpoint = "https://your-endpoint"
  10.  
  11. // 创建ObsClient结构体
  12. var obsClient, _ = obs.New(ak, sk, endpoint)
  13.  
  14. func main() {
  15.        input := &obs.GetObjectAclInput{}
  16.        input.Bucket = "bucketname"
  17.        input.Key = "objectkey"
  18.        output, err := obsClient.GetObjectAcl(input)
  19.        if err == nil {
  20.               fmt.Printf(Owner.ID:%s\n", output.Owner.ID)
  21.               for index, grant := range output.Grants {
  22.                      fmt.Printf("Grant[%d]-Type:%s, ID:%s, URI:%s, Permission:%s\n", index, grant.Grantee.Type, grant.Grantee.ID, grant.Grantee.URI, grant.Permission)
  23.               }
  24.        } else if obsError, ok := err.(obs.ObsError); ok {
  25.               fmt.Printf("Code:%s\n", obsError.Code)
  26.               fmt.Printf("Message:%s\n", obsError.Message)
  27.        }
  28. }

父主题：管理对象