关于阿里云oss:golang使用阿里云OSS对象存储

概念

• Bucket：存储空间
• Object：文件
• ObjectKey：文件名，文件的惟一标识，与Key、ObjectName为同一概念
• Region：地区，OSS数据中心的地理位置
• Endpoint：域名
• AccessKey：密钥，由AccessKey ID和AccessKey Secret组成

计费

总费用 = 存储费 + 长期存储费 + 数据取回费 + 流量费 + 申请费 + 其他费用

一、存储费

存储费 = 文件大小(GB) x 单价 ÷ 30 ÷ 24 x 存储时长(hour)

最贵的规范存储的单价是最便宜的冷归档存储的8倍。
存储一个大小为1G的文件每月须要领取0.12元的存储费。

二、长期存储费

长期存储费 = 文件大小(GB) x 单价 ÷ 30 ÷ 24 x 冻结时长(hour)

冷归档文件在冻结期间，须额定领取一笔依照规范存储单价计算的长期存储费用。

三、数据取回费

数据取回费 = 文件大小(GB) x 单价

四、流量费

流量费 = 流量(GB) x 单价

上传收费，下载免费。
一个大小为1G的文件，每下次1次，须要领取0.25元的流量费。

五、申请费

申请费 = math.Ceil(申请次数/10000) x 单价

冷归档文件的取回申请每一万次需领取30元的申请费。

六、其他费用

跨区域文件复制流量费、图片处理费、图片压缩费、视频截帧费、标签费、传输减速费、DDoS防护费、元数据管理费、敏感数据保护费等等。

存储类型

规范 + 低频 + 归档 + 冷归档。

URL

公共：<Schema>://<Bucket>.<Endpoint>/<Object>
公有：<Schema>://<Bucket>.<Endpoint>/<Object>?签名信息

Bucket

CRUD

Bucket创立后不反对批改，所以只有CRD，没有U。

package mainimport (    "fmt"    "os"    "github.com/aliyun/aliyun-oss-go-sdk/oss")func main() {    // 创立OSSClient实例。    // yourEndpoint填写Bucket对应的Endpoint。    // 以华东1（杭州）为例，填写为https://oss-cn-hangzhou.aliyuncs.com。    client, err := oss.New(        "yourEndpoint", "yourAccessKeyId", "yourAccessKeySecret",    )    if err != nil {        fmt.Println("Error:", err)        os.Exit(-1)    }    // 新增    err = client.CreateBucket(        "examplebucket",         oss.StorageClass(oss.StorageIA),         oss.ACL(oss.ACLPublicRead),        oss.RedundancyType(oss.RedundancyZRS)    )    if err != nil {        fmt.Println("Error:", err)        os.Exit(-1)    }    /*     StorageClass：存储类型。        StorageStandard=规范存储        StorageIA=低频拜访        StorageArchive=归档存储        StorageColdArchive=冷归档存储    ACL：拜访权限。        ACLPrivate=公有        ACLPublicRead=公共读        ACLPublicReadWrite=公共读写    RedundancyType：冗余类型。        RedundancyLRS=本地冗余        RedundancyZRS=同城冗余    */    // 查问    marker := ""    for {        lsRes, err := client.ListBuckets(oss.Marker(marker))        if err != nil {            fmt.Println("Error:", err)            os.Exit(-1)        }        // 默认状况下一次返回100条记录。        for _, bucket := range lsRes.Buckets {            fmt.Println("Bucket: ", bucket.Name)        }        if lsRes.IsTruncated {            marker = lsRes.NextMarker        } else {            break        }    }    // 查问Region ID    regionID, err := client.GetBucketLocation("examplebucket")    if err != nil {        fmt.Println("Error:", err)        os.Exit(-1)    }    fmt.Println("Bucket Location:", regionID) // oss-cn-shanghai    /*        Region ID能够了解为Endpoint的前缀：        外网Endpoint：oss-cn-shanghai.aliyuncs.com        内网Endpoint：oss-cn-shanghai-internal.aliyuncs.com    */    // 删除    err = client.DeleteBucket("examplebucket")    if err != nil {        fmt.Println("Error:", err)        os.Exit(-1)    }}

生命周期

通过设置生命周期，能够实现定期将Bucket内的Object转换存储类型，或者将过期的Object和碎片文件删除，进而升高存储费用。

能够基于最初一次批改工夫（Last Modified Time）或最初一次拜访工夫（Last Access Time）创立生命周期规定。

基于最初一次批改工夫

最初一次批改工夫，其实根本能够了解为创立工夫。

这样就能够实现相似「上传N天后删除」或者「上传N天后将存储类型由规范切换为低频拜访」的需要。

一些限度

1. 仅反对依据前缀和标签进行匹配，不反对通配符匹配、后缀匹配以及正则匹配。
2. 能够叠加，但下限为1000条。
3. 溯及既往
4. 失效：规定创立胜利后的24小时内实现加载，加载胜利后将于每天的08:00执行。
5. 最初批改工夫与规定执行工夫的距离必须大于24小时。

package mainimport (    "fmt"    "os"    "github.com/aliyun/aliyun-oss-go-sdk/oss")func Main() {    client, err := oss.New(        "yourEndpoint", "yourAccessKeyId", "yourAccessKeySecret",    )    if err != nil {        fmt.Println("Error:", err)        os.Exit(-1)    }    // 定义规定    // 前缀为10086的Object将于最初一次批改工夫后的第14天删除    ruleA := oss.BuildLifecycleRuleByDays("ruleA", "10086", true, 14)    // 前缀为10010的Object将于2025年10月10日的08:00删除    ruleB := oss.BuildLifecycleRuleByDate("ruleB", "10010", true, 2025, 10, 10)    // 前缀为10000的Object的存储类型将于最初一次批改工夫的30天后变更为低频拜访    ruleC := oss.LifecycleRule{        ID:     "ruleC",        Prefix: "10000",        Status: "Enabled",        Transitions: []oss.LifecycleTransition{            {                Days:         30,                StorageClass: oss.StorageIA,            },        },    }    // 设置规定    err = client.SetBucketLifecycle(        "examplebucket", []oss.LifecycleRule{ruleA, ruleB, ruleC},    )    if err != nil {        fmt.Println("Error:", err)        os.Exit(-1)    }}

基于最初一次拜访工夫

基于最初一次拜访工夫的生命周期规定仿佛不反对SDK。

Object

类型

Object依据上传形式能够分为以下三类：

命名

• UTF-8编码
• 1 ~ 1024个字符
• 不能以/和\结尾

上传和删除

package mainimport (    "fmt"    "os"    "github.com/aliyun/aliyun-oss-go-sdk/oss")func Main() {    client, err := oss.New(        "yourEndpoint", "yourAccessKeyId", "yourAccessKeySecret",    )    if err != nil {        fmt.Println("Error:", err)        os.Exit(-1)    }    // 生成Bucket实例    bucket, e := client.Bucket("examplebucket")    if err != nil {        fmt.Println("Error:", e)        os.Exit(-1)    }    // 上传    if err = bucket.PutObject("objectKey", file); err != nil {        fmt.Println("Error:", err)        os.Exit(-1)    }    // 删除    if err = bucket.DeleteObject("objectKey"); err != nil {        fmt.Println("Error:", err)        os.Exit(-1)    }}

访问控制

阿里云提供四种类型的拜访权限控制策略：

RAM Policy

RAM Policy为JSON格局，其构造为：

{  "Version": "1",  "Statement": [    {      "Effect": "Deny",      "Action": [        "oss:PutObject"      ],      "Resource": [        "acs:oss:*:*:examplebucket"      ],      "Condition": {}    }  ]}

Version：版本
Statement：受权语句
Effect：效劳（Allow / Deny）
Action：操作
Resource：资源
Condition：条件

能够应用官网的RAM策略编辑器疾速生成RAM策略。

【示例】禁止指定RAM上传Object到Bucket。

step1：生成RAM Policy：

{  "Version": "1",  "Statement": [    {      "Effect": "Deny",      "Action": [        "oss:PutObject"      ],      "Resource": [        "acs:oss:*:*:avatar"      ],      "Condition": {}    }  ]}

step2：增加权限策略：

控制台 - RAM访问控制 - 权限治理 - 创立权限策略 - 脚本编辑

step3：为RAM增加权限策略：

控制台 - RAM访问控制 - 身份治理 - 用户 - 增加权限

Bucket Policy

package mainimport (    "fmt"    "os"    "github.com/aliyun/aliyun-oss-go-sdk/oss")func Main() {    client, err := oss.New(        "yourEndpoint", "yourAccessKeyId", "yourAccessKeySecret",    )    if err != nil {        fmt.Println("Error:", err)        os.Exit(-1)    }    // 配置policy（禁止192.168.1.1之外的所有人对examplebucket的所有申请）    policy := `{        "Version": "1",        "Statement": [            {                "Principal": ["*"],                "Effect": "Deny",                "Action": ["oss:*"],                "Resource": ["acs:oss:*:*:examplebucket"],                "Condition": {                    "NotIpAddress": {                    "acs:SourceIp": ["192.168.1.1"]                    }                }            }        ]    }`    // 设置    err = client.SetBucketPolicy("examplebucket", policy)    if err != nil {        fmt.Println("Error:", err)        os.Exit(-1)    }    // 查问    policy, e := client.GetBucketPolicy("examplebucket")    if e != nil {        fmt.Println("Error:", e)        os.Exit(-1)    }    // 删除    err = client.DeleteBucketPolicy("examplebucket")    if err != nil {        fmt.Println("Error:", err)        os.Exit(-1)    }}

Bucket ACL

package mainimport (    "fmt"    "os"    "github.com/aliyun/aliyun-oss-go-sdk/oss")func Main() {    client, err := oss.New(        "yourEndpoint", "yourAccessKeyId", "yourAccessKeySecret",    )    if err != nil {        fmt.Println("Error:", err)        os.Exit(-1)    }    // 设置examplebucket的权限为公共读    err = client.SetBucketACL("examplebucket", oss.ACLPublicRead)    if err != nil {        fmt.Println("Error:", err)        os.Exit(-1)    }    // 设置examplebucket的权限为公共读写    err = client.SetBucketACL("examplebucket", oss.ACLPublicReadWrite)    if err != nil {        fmt.Println("Error:", err)        os.Exit(-1)    }    // 设置examplebucket的权限为公有    err = client.SetBucketACL("examplebucket", oss.ACLPrivate)    if err != nil {        fmt.Println("Error:", err)        os.Exit(-1)    }    // 查问Bucket ACL    res, e := client.GetBucketACL("examplebucket")    if e != nil {        fmt.Println("Error:", e)        os.Exit(-1)    }}

Object ACL

package mainimport (    "fmt"    "os"    "github.com/aliyun/aliyun-oss-go-sdk/oss")func Main() {    client, err := oss.New(        "yourEndpoint", "yourAccessKeyId", "yourAccessKeySecret",    )    if err != nil {        fmt.Println("Error:", err)        os.Exit(-1)    }    // 生成Bucket实例    bucket, e := client.Bucket("examplebucket")    if e != nil {        fmt.Println("Error:", e)        os.Exit(-1)    }    // 设置exampleobject的权限为公共读    err = bucket.SetObjectACL("exampleobject", oss.ACLPublicRead)    if err != nil {        fmt.Println("Error:", err)        os.Exit(-1)    }    // 设置exampleobject的权限为公共读写    err = bucket.SetObjectACL("exampleobject", oss.ACLPublicReadWrite)    if err != nil {        fmt.Println("Error:", err)        os.Exit(-1)    }    // 设置exampleobject的权限为公有    err = bucket.SetObjectACL("exampleobject", oss.ACLPrivate)    if err != nil {        fmt.Println("Error:", err)        os.Exit(-1)    }    // 设置exampleobject的权限为继承Bucket    err = bucket.SetObjectACL("exampleobject", oss.ACLDefault)    if err != nil {        fmt.Println("Error:", err)        os.Exit(-1)    }    // 查问Object ACL    res, er := bucket.GetObjectACL("exampleobject")    if er != nil {        fmt.Println("Error:", er)        os.Exit(-1)    }}

数据容灾

同城冗余

如果把默认的本地冗余比喻为一份数据存在同一机房内的三个不同硬盘中的话，那么同城冗余就是将数据存在同一数据中心的三个不同机房。

从本地冗余到同城冗余，隔离等级由硬盘级回升到机房级。

err = client.CreateBucket(    "examplebucket",     oss.StorageClass(oss.StorageIA),     oss.ACL(oss.ACLPublicRead),    oss.RedundancyType(oss.RedundancyZRS))/*     RedundancyType：冗余类型。    RedundancyLRS=本地冗余    RedundancyZRS=同城冗余*/

冗余类型仅反对创立Bucket时指定，一旦创立不反对批改。

跨城冗余

跨城冗余就是将数据寄存在不同城市的机房。

从同城冗余到跨城冗余，隔离等级由机房级回升到城市级。

package mainimport (    "fmt"    "github.com/aliyun/aliyun-oss-go-sdk/oss"    "os")func main()  {    client, err := oss.New(        "yourEndpoint", "yourAccessKeyId", "yourAccessKeySecret",    )    if err != nil {        fmt.Println("Error:", err)        os.Exit(-1)    }    /*     指定仅同步复制规定创立后新写入的数据    不同步源Bucket的历史数据    且尔后将源Bucket执行的所有操作都将实时同步到指标Bucket    */    putXml := `<?xml version="1.0" encoding="UTF-8"?>    <ReplicationConfiguration>      <Rule>        <PrefixSet>            <! --指定待复制Object的前缀prefix_1和prefix_2。指定Prefix后，只有匹配该Prefix的Object才会复制到指标Bucket。-->            <! --如果您须要将源Bucket中的所有Object复制到指标Bucket，则无需设置Prefix。            <Prefix>prefix_1</Prefix>            <Prefix>prefix_2</Prefix>        </PrefixSet>        <! --指定能够被复制到指标Bucket的操作。默认值为ALL，示意源Bucket的所有操作都会复制到指标Bucket。-->        <Action>ALL</Action>        <Destination>            <! --指定数据要复制到的指标Bucket。-->            <Bucket>destexamplebucket</Bucket>            <! --指定指标Bucket所在的Region。-->            <Location>oss-cn-beijing</Location>            <! --指定数据复制时应用的数据传输链路。此处设置为oss_acc，示意应用了传输减速链路。-->            <TransferType>oss_acc</TransferType>        </Destination>        <! --默认同步历史数据。此处设置为disabled，示意禁止同步历史数据。-->        <HistoricalObjectReplication>disabled</HistoricalObjectReplication>        <! --指定受权OSS进行数据复制的角色名称。如果指定应用SSE-KMS加密指标对象，则必须指定该元素。-->        <SyncRole>aliyunramrole</SyncRole>        <SourceSelectionCriteria>          <SseKmsEncryptedObjects>            <! --指定OSS是否复制通过SSE-KMS加密创立的对象。-->            <Status>Enabled</Status>          </SseKmsEncryptedObjects>        </SourceSelectionCriteria>        <EncryptionConfiguration>            <! --指定SSE-KMS密钥ID。如果指定Status为Enabled，则必须指定该元素。-->           <ReplicaKmsKeyID>c4d49f85-ee30-426b-a5ed-95e9139d****</ReplicaKmsKeyID>       </EncryptionConfiguration>     </Rule>   </ReplicationConfiguration>`    // 开启跨区域复制    err = client.PutBucketReplication("srcexamplebucket",putXml)    if err != nil {        fmt.Println("Error:", err)        os.Exit(-1)    }}            

数据加密

OSS服务侧加密

上传Object时，OSS对收到的文件进行加密，再将加密文件长久化保留。

下载Object时，OSS主动将加密文件解密后返回，并在响应头中返回x-oss-server-side-encryption，用于申明该文件进行了OSS服务侧加密。

package mainimport (    "fmt"    "os"    "github.com/aliyun/aliyun-oss-go-sdk/oss")func main() {    // 创立OSSClient实例    client, err := oss.New(        "yourEndpoint", "yourAccessKeyId", "yourAccessKeySecret",    )    if err != nil {        fmt.Println("Error:", err)        os.Exit(-1)    }    // 初始化加密规定，应用AES256算法    config := oss.ServerEncryptionRule{        SSEDefault: oss.SSEDefaultRule{SSEAlgorithm: "AES256"},    }    // 设置OSS服务侧加密    err = client.SetBucketEncryption("examplebucket", config)    if err != nil {        fmt.Println("Error:", err)        os.Exit(-1)    }}

应用服务侧加密

应用服务侧加密是指将Object发送到OSS之前进行加密，而后将加密后的Object传输至OSS长久化保留。

package mainimport (    "bytes"    "fmt"    "io"    "io/ioutil"    "log"    "os"    "github.com/aliyun/aliyun-oss-go-sdk/oss"    "github.com/aliyun/aliyun-oss-go-sdk/oss/crypto")func main() {    // 创立OSSClient实例。    client, err := oss.New(        "<yourEndpoint>", "<yourAccessKeyId>", "<yourAccessKeySecret>",    )    if err != nil {        fmt.Println("Error:", err)        os.Exit(-1)    }    // 创立一个主密钥的形容信息，创立后不容许批改。主密钥形容信息和主密钥一一对应。    // 如果所有的Object都应用雷同的主密钥，主密钥形容信息能够为空，但后续不反对更换主密钥。    // 如果主密钥形容信息为空，解密时无奈判断应用的是哪个主密钥。    // 强烈建议为每个主密钥都配置主密钥形容信息(json字符串), 由客户端保留主密钥和形容信息之间的对应关系（服务端不保留两者之间的对应关系）。    // 由主密钥形容信息(json字符串)转换的map。    materialDesc := make(map[string]string)    materialDesc["desc"] = "<your master encrypt key material describe information>"    // 依据主密钥形容信息创立一个主密钥对象。    masterRsaCipher, err := osscrypto.CreateMasterRsa(        materialDesc, "<your rsa public key>", "<your rsa private key>",    )    if err != nil {        fmt.Println("Error:", err)        os.Exit(-1)    }    // 依据主密钥对象创立一个用于加密的接口, 应用aes ctr模式加密。    contentProvider := osscrypto.CreateAesCtrCipher(masterRsaCipher)    // 获取bucket。    cryptoBucket, err := osscrypto.GetCryptoBucket(client, "<yourBucketName>", contentProvider)    if err != nil {        fmt.Println("Error:", err)        os.Exit(-1)    }    // 上传时时主动加密。    err = cryptoBucket.PutObject(        "<yourObjectName>", bytes.NewReader([]byte("yourObjectValueByteArray")),    )    if err != nil {        fmt.Println("Error:", err)        os.Exit(-1)    }    // 下载时主动解密。    body, err := cryptoBucket.GetObject("<yourObjectName>")    if err != nil {        fmt.Println("Error:", err)        os.Exit(-1)    }    defer func(b *io.ReadCloser) {        err = (*b).Close()        if err != nil {            log.Println("Error:", err)        }    }(&body)    data, err := ioutil.ReadAll(body)    if err != nil {        fmt.Println("Error:", err)        os.Exit(-1)    }    fmt.Println("data:", string(data))}

版本控制

版本控制以回滚至任一历史版本的形式，为谬误笼罩和谬误删除提供容错空间。

版本控制的一些限度：

1. 与合规保留策略无奈同时配置
2. 开启版本控制的Bucket，x-oss-forbid-overwrite申请头将不再失效
3. 不倡议同时开明OSS-HDFS服务并设置保留策略

版本控制有三个状态：未开启、开启、暂停。

package mainimport (    "fmt"    "os"    "github.com/aliyun/aliyun-oss-go-sdk/oss")func main() {    // 创立Client实例。    client, err := oss.New(        "<yourEndpoint>", "<yourAccessKeyId>", "<yourAccessKeySecret>",    )    if err != nil {        fmt.Println("Error:", err)        os.Exit(-1)    }    // 创立Bucket实例。    err = client.CreateBucket("<yourBucketName>")    if err != nil {        fmt.Println("Error:", err)        os.Exit(-1)    }    // 开启版本控制。    config := oss.VersioningConfig{Status: "Enabled"}    err = client.SetBucketVersioning("<yourBucketName>", config)    if err != nil {        fmt.Println("Error:", err)        os.Exit(-1)    }    // 暂停版本控制。    config.Status = "Suspended"    err = client.SetBucketVersioning("<yourBucketName>", config)    if err != nil {        fmt.Println("Error:", err)        os.Exit(-1)    }}

防盗链

OSS通过比照request header的Referer与配置规定是否统一来判断容许或回绝该申请。

package mainimport (    "fmt"    "os"    "github.com/aliyun/aliyun-oss-go-sdk/oss")func main() {    // 创立Client实例。    client, err := oss.New("yourEndpoint", "yourAccessKeyId", "yourAccessKeySecret")    if err != nil {        fmt.Println("Error:", err)        os.Exit(-1)    }    // 初始化Referer白名单。反对通配符星号（*）和问号（？）。    referers := []string{        "http://www.aliyun.com",        "http://www.???.aliyuncs.com",        "http://www.*.com",    }    // 设置Referer白名单，并禁止空Referer    // 留神：如果你配置了白名单但容许空Referer，终局会很生硬...    err = client.SetBucketReferer("yourBucketName", referers, false)    if err != nil {        fmt.Println("Error:", err)        os.Exit(-1)    }    // 查问Bucket Referer    res, e := client.GetBucketReferer("yourBucketName")    if e != nil {        fmt.Println("Error:", e)        os.Exit(-1)    }    fmt.Println(res.RefererList, res.AllowEmptyReferer)}

合规保留策略

合规保留策略容许用户以“不可删除、不可篡改”形式保留和应用数据，合乎美国证券交易委员会（SEC）和金融业监管局（FINRA）的合规要求。

package mainimport (    "fmt"    "os"    "github.com/aliyun/aliyun-oss-go-sdk/oss")func main() {    // 创立OSSClient实例。    client, err := oss.New(        "yourEndpoint", "yourAccessKeyId", "yourAccessKeySecret",    )    if err != nil {        handleError(err)    }    // 初始化WORM规定（锁定60天）。    // 最短锁定1天，最长锁定70年。    wormID, e := client.InitiateBucketWorm("examplebucket", 60)    if e != nil {        handleError(e)    }    /*        初始化后的24小时内，WORM处于InProgress状态。        在此期间，能够提交锁定，或者删除。        若在此期间即未提交锁定也未删除，则WORM主动生效。    */    // 提交锁定    err = client.CompleteBucketWorm("examplebucket", wormID)    if err != nil {        handleError(err)    }    // 或者删除    /*        err = client.AbortBucketWorm("examplebucket")        if err != nil {            handleError(err)        }    */    // 通过Bucket查问WORM    wormConfiguration, er := client.GetBucketWorm("examplebucket")    if er != nil {        handleError(er)    }    // WORM一旦提交锁定，在解锁日期前，WORM和Bucket内的所有Object均不反对删除。    // 但能够缩短锁定期：    err = client.ExtendBucketWorm(        "examplebucket", 180, wormConfiguration.WormId,    )    if err != nil {        handleError(err)    }}func handleError(err error) {    fmt.Println("Error:", err)    os.Exit(-1)}

日志

package mainimport (    "fmt"    "os"    "github.com/aliyun/aliyun-oss-go-sdk/oss")func main() {    // 创立OSSClient实例。    client, err := oss.New(        "yourEndpoint", "yourAccessKeyId", "yourAccessKeySecret",    )    if err != nil {        handleError(err)    }    // 开启    // 将examplebucket的日志存入destbucket。    err = client.SetBucketLogging("examplebucket", "destbucket", "log/", true)    if err != nil {        handleError(err)    }    // 查问    res, e := client.GetBucketLogging("examplebucket")    if e != nil {        handleError(e)    }    fmt.Println(        res.LoggingEnabled.TargetBucket, res.LoggingEnabled.TargetPrefix,    )    // 敞开    err = client.DeleteBucketLogging("examplebucket")    if err != nil {        handleError(err)    }}func handleError(err error) {    fmt.Println("Error:", err)    os.Exit(-1)}

细节

避免意外笼罩

默认状况下，如果上传的文件与已有文件同名，则笼罩已有文件。
为避免文件被意外笼罩，能够在上传申请的Header中携带参数x-oss-forbid-overwrite，并指定其值为true。

防止批改门路

OSS能够通过一些操作来模仿相似文件夹的性能，然而代价十分低廉。

比方重命名目录，心愿将test1目录重命名成test2，那么OSS的实际操作是将所有以test1/结尾的Object都从新复制成以test2/结尾的Object。

这是一个十分耗费资源的操作。因而在应用OSS的时候要尽量避免相似的操作。

性能与扩展性最佳实际

Object Key不要应用程序前缀！！！
Object Key不要应用程序前缀！！！
Object Key不要应用程序前缀！！！

阿里云 对象存储 OSS