Datasets:

dongshuaijun

/

qiniu_developer_data

like 0

空间访问日志

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [开发指南](https://developer.qiniu.com/kodo/development_guidelines/8596/development- guidelines) > [管理存储空间](https://developer.qiniu.com/kodo/development_guidelines/8599/management- of-storage-space) > 空间访问日志 # 空间访问日志 最近更新时间: 2023-12-25 11:32:59 对象存储 Kodo 提供自动保存访问空间日志的功能。 # **具体说明** * 当天的日志 2 天后可下载 * 支持存储空间开启和关闭日志记录 * 支持在已开启日志记录的同一存储空间中存储日志，也可以另外创建新存储空间来存储日志。 * 当空间开启访问日志记录功能后，Kodo 自动将访问这个空间的请求日志，按照固定的命名规则，每 10 分钟生成一个文件写入您指定的目标空间。 # **日志的命名规则** 存储访问空间日志的文件命名规则示例如下： _log/bucketname/YYYY-MM-DD-HH-mm/partN.gz 字段名称 | 说明 ---|--- _log | 固定字段 bucketname | 用户指定的存储访问空间日志的空间名 YYYY-MM-DD-HH-mm | YYYY、MM、DD、HH 和 mm 分别是该日志文件被创建时的阿拉伯数字的年、月、日、小时、分钟 partN.gz | 当日志文件很大时，会拆分成多个，第一个是 part0，第二个是 part1，以此类推 # **日志文件格式** 日志文件的组成字段举例说明，帮助您更好的分析日志。以下名称从左至右，以空格分隔。 字段名称 | 举例说明 ---|--- Remote IP | 远端 IP 地址，比如 120.194.101.86。 Remote Logname | 远程登录名，目前统一显示为 -。 Remote User | 远程用户名，目前统一显示为 -。 Time | 七牛云对象存储收到请求的时间，比如 [16/May/2013:00:00:00 +0800]。 RequestTime | 七牛对象存储 Kodo 处理本次请求的时间（ms）。 Request-URI | 用户请求的 URI，比如 “GET /group1/M00/28/9D/CvFRWFGSBvsEAAAAAAAAAD0JyMI178.jpg?imageView/2/w/480 HTTP/1.1”。 HTTP Status | 七牛对象存储 Kodo 返回的 HTTP 状态码，比如 200。 SentBytes | 用户下载的流量，比如 37431。当没有字节传送时显示 -，而不是 0。 Referer | 请求的 HTTP Referer，比如 “http://iovip.qiniuio.com”。没有时，显示 “-”。 User-Agent | HTTP 的 User-Agent 头，比如 “Dalvik/0.0.0 (Linux; U; Android 1.6.1.16-RT-20120926.152630; W806 Build/AliyunOs-2012)”。 Request Host | HTTP 请求的 Host，比如 “http://image.qiniu.com”。 UID | 空间拥有者的 uid。 Bucket | 空间拥有者的空间名。 StorageClass | 对象存储类型，0 表示标准存储，1 表示低频存储，2 表示归档存储，3 表示深度归档存储，4 表示归档直读存储。 Sync Request | 是否是 CDN 回源请求，若来自 CDN，则为 qiniucdn；若不是则为-。 Version | 目前固定值为 V2。 日志格式为：Remote IP - - [Time] RequestTime “Request-URI” HttpStatus SentBytes “Referer” User-Agent “Request Host” UID Bucket StorageClass V2 一条完整的日志记录例子如下： 120.194.101.86 - - [16/May/2013:00:00:00 +0800] 20 "GET /group1/M00/28/9D/CvFRWFGSBvsEAAAAAAAAAD0JyMI178. jpg?imageView/2/w/480 HTTP/1.1" 200 37431 "-" "Dalvik/0.0.0 (Linux; U; Android 1.6.1.16-RT-20120926. 152630; W806 Build/AliyunOs-2012)" "http://image.yourdream.cc" 10101010 Tbl 0 - V2 # **补充说明** * 日志中的任何一个字段，都可能出现-，用于表示未知数据或对于当前请求该字段无效。 * 根据需求，日志格式将来会在尾部（Version 字段除外），添加一些字段，请开发者开发日志处理工具时需考虑兼容性的问题。 # **操作方式** Kodo 支持通过控制台方式设置空间访问日志。 支持的操作方式 | 参考文档 ---|--- 控制台 | [设置空间日志](https://developer.qiniu.com/kodo/development_guidelines/8546/set-the-space-log) 以上内容是否对您有帮助？

删除空间

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [开发指南](https://developer.qiniu.com/kodo/development_guidelines/8596/development- guidelines) > [管理存储空间](https://developer.qiniu.com/kodo/development_guidelines/8599/management- of-storage-space) > 删除空间 # 删除空间 最近更新时间: 2021-08-31 14:23:01 当您不再需要使用指定存储空间（Bucket）时，对象存储 Kodo 支持您删除该空间。 您可以在对象存储 Kodo 控制台或通过 API 方式进行删除操作。 # **具体说明** * 非空空间不可删除，您需要先删除该空间中所有的文件（Object），详情请见[删除文件](https://developer.qiniu.com/kodo/development_guidelines/8571/delete-the-file)。 * 直播空间不可删除，详情请参考七牛直播云[直播落存储服务 __](https://developer.qiniu.com/pili/1209/live-the-core-function#4)。 * 若空间仍绑定有自定义 CDN 域名时，不允许删除。您可参考[设置自定义 CDN 加速域名](https://developer.qiniu.com/kodo/development_guidelines/8555/set-the-custom-cdn-to-accelerate-the-domain-name)先解绑 CDN 域名，后删除空间。 * 空间删除后，空间名称可以被重新使用。 ### **空间删除后不可恢复，请谨慎操作！** # **操作方式** Kodo 支持通过控制台、API 方式设置删除存储空间。 支持的操作方式 | 参考文档 ---|--- 控制台 | [删除存储空间](https://developer.qiniu.com/kodo/development_guidelines/8548/remove-the-storage-space) API | [drop 删除空间](https://developer.qiniu.com/kodo/api/1601/drop-bucket) 以上内容是否对您有帮助？

数据安全

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [开发指南](https://developer.qiniu.com/kodo/development_guidelines/8596/development- guidelines) > 数据安全 # 数据安全 最近更新时间: 2022-06-24 11:05:52 为保障您的数据安全，对象存储 Kodo 支持多方面的安全设置: 快速链接 | 摘要 ---|--- [Referer 防盗链](https://developer.qiniu.com/kodo/development_guidelines/8618/dev-preventing-hotlinking) | 依据用户设置访问域名参数来允许或限制访问，防止数据被盗链。 [对象锁定](https://developer.qiniu.com/kodo/development_guidelines/8621/dev-object-locking) | 支持使用一次写入、多次读取模式存储对象，实现在固定的时间段内或无限期地阻止删除或覆盖对象。 以上内容是否对您有帮助？

Referer 防盗链

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [开发指南](https://developer.qiniu.com/kodo/development_guidelines/8596/development- guidelines) > [数据安全](https://developer.qiniu.com/kodo/development_guidelines/8625/dev-data- security) > Referer 防盗链 # Referer 防盗链 最近更新时间: 2022-07-05 14:21:18 为了防止数据被其他人盗链，用户可以设置防盗链功能，包括以下参数： * Referer 白名单，仅允许指定的域名访问资源；或黑名单，指定域名禁止访问资源 * 是否允许空 Referer。如果不允许空 Referer，则只有 HTTP 或 HTTPS header 中包含 Referer 字段的请求才能访问资源。 例如，对于一个名为 test-example 的 Bucket，设置其 Referer 白名单为 http://www.mytest.com/。则所有 Referer 为 http://www.mytest.com/ 的请求才能访问 test-example 这个 Bucket 中的 Object。 # **具体说明** * Referer 验证 * 一旦开启 Referer 防盗链，所有请求都会做防盗链验证。 * Referer 配置 * 一个 Bucket 可以支持多个 Referer 参数。通过控制台设置时使用回车作为换行符分隔. * 无需填写 http:// ，https:// . * 支持域名前使用通配符「 * 」：*.example.com 可用于指代所有 example.com 下的多级子域名，比如 a.example.com 等，但是不包括 example.com，如需要请额外填写一条 example.com. * 支持完全通配符，即规则是一个「 * 」 * Referer 效果 * Referer 白名单为空时，不会检查 Referer 字段是否为空（否则所有的请求都会被拒绝）。黑名单为空时，会检查 Referer 字段是否允许为空。 * 如果 Referer 白名单不为空，且不允许 Referer 字段为空，则只有 Referer 属于白名单的请求被允许，其他请求（包括 Referer 为空的请求）会被拒绝。 * 如果白名单不为空，但允许 Referer 字段为空，则 Referer 为空的请求和符合白名单的请求会被允许，其他请求都会被拒绝。 # **操作方式** Kodo 支持通过控制台方式设置防盗链。 支持的操作方式 | 参考文档 ---|--- 控制台 | [设置 Referer 防盗链](https://developer.qiniu.com/kodo/development_guidelines/8538/set-the-referer-hotlinking-prevention) 以上内容是否对您有帮助？

对象锁定

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [开发指南](https://developer.qiniu.com/kodo/development_guidelines/8596/development- guidelines) > [数据安全](https://developer.qiniu.com/kodo/development_guidelines/8625/dev-data- security) > 对象锁定 # 对象锁定 最近更新时间: 2023-12-25 11:40:29 对象存储 Kodo 支持设置空间（Bucket）级别的对象锁定功能。开启对象锁定后，您可以使用一次写入，多次读取 (write once read many, WORM) 模式存储对象（Object）。您可以使用它在固定的时间段内或无限期地阻止删除或覆盖对象，符合合规监管需求。 针对需要长期存储且不允许修改或删除的重要数据，如医疗档案、合同等，您可以将它们存放在开启对象锁定、设置了保留策略的存储空间内，以便于保护。 # **具体说明** 空间的对象锁定状态有：「关闭」、「开启」 **注：一旦将空间的对象锁定状态设置为「开启」，它将无法返回到「关闭」状态。** ### **开启对象锁定** * Kodo 支持在空间级别设置开启对象锁定功能，用户可针对存储空间设置基于时间的合规保留规则。 * 当规则设定后，用户可以在空间中上传和读取文件 Object。 * 在开启对象锁定时，受保护文件不可被任何用户删除或覆盖，包括修改文件类型信息、修改自定义元数据、修改文件名。Object 的保留时间到期后，才可以进行相关操作。 ### **对象锁定** * 我们提供在空间上设置默认保留模式，当前仅支持合规保留模式，会在设置保护时间段内保护数据。 * 开启对象锁定，启动合规保留模式，不可关闭，将永久允许锁定此存储空间中的对象。 * 保留周期设置后，只可延长、不可缩短。 * 允许针对指定空间添加一条基于时间的合规保留策略，保护周期为 1天 到 70年。 * 当前设置的保留周期仅作用在设置完成后空间内新上传的文件上。 ### **对象锁定与其他空间设置功能** * 与[生命周期管理](https://developer.qiniu.com/kodo/development_guidelines/8609/dev-life-cycle-management) * 不可在生命周期保护周期内删除，超过保护期再删除。 * 同时设置生命周期删除策略和对象锁定保护时，将自动判断取锁定保护时间及删除策略定义时间的最大值作为删除时间。 * 其他生命周期管理配置（转低频、转归档直读、转归档、转深度归档）将继续正常应用于受对象锁定保护的对象。 * 与[删除空间](https://developer.qiniu.com/kodo/development_guidelines/8601/dev-delete-the-space) * 若带有对象锁定策略的空间内未存储文件，可以直接删除该空间。 * 若带有对象锁定策略的空间内已存储文件，且所有文件均已过了保护期，支持先删除该空间内所有文件，再删除空间。 * 若带有对象锁定策略的空间内已存储文件，且还有文件处于保护期内，无法删除该空间。 # **操作方式** Kodo 支持通过控制台方式设置对象锁定。 支持的操作方式 | 参考文档 ---|--- 控制台 | [设置对象锁定](https://developer.qiniu.com/kodo/development_guidelines/8545/set-the-object-lock) 以上内容是否对您有帮助？

数据处理

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [开发指南](https://developer.qiniu.com/kodo/development_guidelines/8596/development- guidelines) > 数据处理 # 数据处理 最近更新时间: 2024-03-27 11:51:14 对象存储 Kodo 支持您的多样化数据处理需求： 快速链接 | 摘要 ---|--- [视频处理](https://developer.qiniu.com/kodo/development_guidelines/12654/video-process) | 针对视频类文件提供的实时转码处理服务 [图片处理](https://developer.qiniu.com/kodo/development_guidelines/8623/dev-the-picture-style) | 针对图片类文件提供图片处理服务 [转码样式](https://developer.qiniu.com/kodo/development_guidelines/8624/dev-transcoding-style) | 针对控制台上传文件提供的一键式转码模板 [原始资源保护](https://developer.qiniu.com/kodo/development_guidelines/8616/dev-the-original-image-to-protect) | 针对媒体类源文件的保护措施，使空间内的文件无法直接通过url进行访问 以上内容是否对您有帮助？

实时转码（边转边播）

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [开发指南](https://developer.qiniu.com/kodo/development_guidelines/8596/development- guidelines) > [数据处理](https://developer.qiniu.com/kodo/development_guidelines/8615/dev-the- data-processing) > 实时转码（边转边播） # 实时转码（边转边播） 最近更新时间: 2024-08-21 14:01:21 对象存储 Kodo 提供多种方式对空间中的视频文件做处理： * 可以在空间上配置 [任务触发器](https://developer.qiniu.com/dora/6489/task-workflow)，上传的文件满足规则策略时会自动触发已经编排好的异步视频处理。 * 可以在单次上传文件的时候，指定 [异步处理动作](https://developer.qiniu.com/kodo/1661/persistent-op)。支持配置成模板，用于在 [控制台上传文件时触发转码处理](https://developer.qiniu.com/kodo/8624/dev-transcoding-style)。 * 支持 实时转码和视频样式，可以在访问时触发视频处理、秒级开播、实时查看转码后的视频 * 支持开启 [CDN 热点视频瘦身](https://developer.qiniu.com/kodo/12748/hot-video-slim)，可以依据文件在 **七牛 CDN** 上的访问统计次数自动识别热点视频、触发视频瘦身处理，节省视频分发成本。 本文主要介绍实时转码（边转边播）功能。 # **实时转码** 传统离线转码需要对整个视频进行解码和编码后才能访问处理后的视频，这是一种异步处理模式，需要用户的等待时间较长。然而，实时转码技术可以即播即转、秒级开播，为用户提供全新的转码体验。  ## **功能优势** * 耗时极短：无需等待异步转码完成，即播即转、可以在极短时间内播放实时转码后的视频 * 使用/对接简单：无需接收离线转码任务完成回调、开发复杂业务逻辑，接入简单 * 节约转码成本：只在视频访问时才触发转码处理、非必要不转码，减少转码量 实时转码按输出时长计量计费，实时转码定价参考 [智能多媒体服务定价 __](https://www.qiniu.com/prices/dora)。 # **视频样式** 实时转码的使用方式和图片处理类似。您可以将视频实时转码的参数保存成视频样式，作为视频文件访问时触发实时处理的模板。 * 不支持 av1 和 H.265 HDR 编码的视频输入 * 输入封装格式暂时仅支持 mp4、mov，输出封装格式暂时仅支持 m3u8 * 输出分辨率不超过2K（2560×1440） * 不支持管道命令 * 实时转码目前仅限国内华东-浙江、华南-广东、华北-河北区域使用。 视频样式访问链接格式：`视频访问链接 + 分隔符 + 样式名称` * 视频样式，是视频实时处理参数组合的模板。 * 样式分隔符，是用于连接资源链接和视频样式的特殊符号。 * 服务处理访问请求时，会优先定位到链接中的分隔符、并尝试以分隔符之后的内容去匹配视频样式、触发视频处理。 ## **使用案例** 1. 转码为标清 720P 的 m3u8 文件，视频样式命名为 `sd.m3u8`，并指定样式分隔符为 `-`。 2. 原始视频链接 `http://aaa.com/sample.mp4`。 3. 将原始视频链接使用样式分隔符 `-` 拼接视频样式名 `sd.m3u8`，即访问 `http://aaa.com/sample.mp4-sd.m3u8` 便可直接获得 720P 的 m3u8 视频文件。 # **处理参数** 注意：接口规格不含任何空格与换行符，下列内容经过格式化以便阅读。 avcvt/3/<Format> /segtime/<SegSeconds> /t/<Duration> /vcodec/<VideoCodec> /vb/<VideoBitRate> /r/<FrameRate> /s/<Resolution> /acodec/<AudioCodec> /ab/<AudioBitRate> /ar/<SamlingRate> /output/<Output> 分类 | 参数名 | 类别 | 必填 | 说明 ---|---|---|---|--- 封装格式 | `<Format>` | A/V | Y | 封装格式，只支持输出 m3u8 流（HLS协议） 切片时长 | `segtime/<SegSeconds>` | A/V | Y | 音视频切片时长，单位为秒（s），精确到毫秒（ms），取值范围为 2-120 秒，默认为10秒。 截取长度 | `/t/<Duration>` | A/V | Y | 指定音视频截取的长度，单位：秒，支持精确到毫秒，例如1.500s。用于截取（0,Duration] 的音视频流进行切片。 视频编码格式 | `/vcodec/<VideoCodec>` | V | N | 视频编码格式，支持libx264，libx265等，默认采用libx264 视频码率 | `/vb/<VideoBitRate>` | V | N | 1、视频码率，单位：比特每秒（bit/s），常用视频码率：128k，1.25m，5m等。 2、默认等于源视频码率，在不改变视频编码格式时，若指定码率大于原视频码率，则使用原视频码率进行转码。 3、参数末尾使用 ! ，如 128k!，可以强制使用指定码率转码, 使平均码率不高于指定值，会牺牲一些视频播放质量；不使用!强制，会在码率与视频质量之间自动平衡。 视频帧率 | `/r/<FrameRate>` | V | N | 1、视频帧率，每秒显示的帧数，单位：赫兹（Hz），常用帧率：24，25，30 等。 2、默认等于源视频帧率，取值范围[1,30]。 分辨率 | `/s/<Resolution>` | V | N | 1、指定目标视频分辨率，格式为宽 x 高，长边范围[20,2560]，短边取值范围[20,1440]。 2、w、h 都为空时，则和原视频保持一致。 3、w为空，h不为空，则按h的值对原视频等比例缩放。 4、w不为空，h为空时，则按w的值对原视频等比例缩放。 5、w、h都不为空时，则根据w、h来缩放。 音频编码格式 | `/acodec/<AudioCodec>` | A | N | 音频编码格式，支持：libmp3lame，libfdk_aac等，默认采用libfdk_aac。 音频码率 | `/ab/<AudioBitRate>` | A | N | 1、音频码率，单位：比特每秒（bit/s），常用码率：64k，128k，192k，256k，320k等。 2、默认等于源音频码率，在不改变音频编码格式时，若指定码率大于原音频码率，则使用原音频码率进行转码。 3、参数末尾使用 !, 可以以强制使用指定码率转码, 如 64k! 音频采样频率 | `/ar/<AudioSamplingRate>` | V | N | 音频采样频率，单位：赫兹（Hz），常用音频采样频率有 8000, 11025、12000、16000、22050、24000、32000、44056、44100、47250、48000、50000、64000、88200、96000 等。默认等于源音频采样频率。 m3u8 文件名 | `/output/<Output>` | A/V | N | 指定 m3u8 文件存储时的文件名（url 安全的 base64 编码）。ts 文件名为 <m3u8_name>~/$(count).ts，其中 $(count) 是六位的占位符数字串。比如 m3u8 是 aaa.m3u8，则 ts 文件名为 aaa.m3u8~/000000.ts、aaa.m3u8~/000001.ts 。 # **操作方式** Kodo 支持通过控制台设置视频样式。 支持的操作方式 | 参考文档 ---|--- 控制台 | [设置视频样式](https://developer.qiniu.com/kodo/development_guidelines/12738/set-the-video-style) 以上内容是否对您有帮助？

CDN 热点视频瘦身

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [开发指南](https://developer.qiniu.com/kodo/development_guidelines/8596/development- guidelines) > [数据处理](https://developer.qiniu.com/kodo/development_guidelines/8615/dev-the- data-processing) > CDN 热点视频瘦身 # CDN 热点视频瘦身 最近更新时间: 2024-08-21 16:33:58 七牛云支持 CDN 热点视频瘦身功能，节省视频分发成本的同时、保证视频播放体验。 开启 CDN 热点视频瘦身后，系统会依据文件在 **七牛 CDN** 上的访问统计次数自动识别热点视频、触发视频瘦身处理、并在瘦身成功后刷新对应的 CDN 缓存，将瘦身后的文件快速应用于分发访问。 经瘦身处理的视频文件，肉眼画质基本不变（局部增强）、文件体积一般减小 30%～40%。 瘦身支持两种触发类型 * 访问次数阈值：统计周期内访问次数>阈值的视频触发处理 * 访问次数TopN：统计周期内访问次数排名前 N 的视频触发处理  ## 功能优势 1. 降低视频的 CDN 分发成本 * 瘦身后的视频文件，肉眼画质基本不变（局部增强）、文件体积一般减小 30%～40% 2. 按需处理、优化转码成本 * 仅热点视频触发瘦身、有效减少转码量 3. 自动触发、效率优化 * 自动触发、自动分发、用户业务 0 管理代码，无需用户统计热点视频、规划管理瘦身任务 ## 应用案例 1. app 使用 CDN 域名 app.example.com 分发 mp4 和 m3u8 的视频文件，`https://app.example.com/test.mp4` 视频每次完整播放需要流量 1.2 GB 2. 为域名 app.example.com 开启热点视频瘦身功能，配置 * 仅对 .mp4、.m3u8 后缀的文件识别热点 * 当文件在 60 分钟内的访问次数超过 100 次时触发瘦身处理 3. 之后系统每间隔约 5 分钟，就统计出过去 60 分钟内访问次数超过 100 次的文件、后台执行视频瘦身处理，其中 `https://app.example.com/test.mp4` 被访问了 200 次 4. 当 `test.mp4` 瘦身处理完成后，文件大小变成了 0.7GB，系统会刷新掉 `https://app.example.com/test.mp4` 的 CDN 缓存 5. 之后终端再次访问 `https://app.example.com/test.mp4` 时会获取到瘦身后的视频文件，每次完整播放 `test.mp4` 视频只需要 0.7GB 流量 ## 功能开启 CDN 热点视频瘦身功能，暂时不支持自助开启、需后台配置，如有需求请您联系您的商务，或是[提交工单 __](https://support.qiniu.com/tickets/new)申请。 以上内容是否对您有帮助？

图片处理

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [开发指南](https://developer.qiniu.com/kodo/development_guidelines/8596/development- guidelines) > [数据处理](https://developer.qiniu.com/kodo/development_guidelines/8615/dev-the- data-processing) > 图片处理 # 图片处理 最近更新时间: 2024-03-27 11:39:37 对象存储 Kodo 对空间中的图片提供多种处理功能： * 对图片进行缩略操作 * 图片缩放、裁剪、旋转 * 获取图片格式、大小、色彩模型信息 * 提供数码相机照片的可交换图像文件格式 * 图片添加图片、文字、图文混合水印等 您可以通过两种方式使用图片处理功能 * 通过给图片 URL 添加参数：您可以通过在图片的访问链接（URL）后添加相应参数来对图片进行相应的处理。 * **使用图片样式** ：推荐您通过创建样式的方式将不同的处理效果保存下来，然后使用样式对图片进行统一的处理。图片样式是图片下载时实时处理参数组合的一个模板。 # **图片样式** 图片样式访问链接格式：`图片访问链接 + 分隔符 + 样式名称` * 图片样式，是图片实时处理参数组合的模板。 * 样式分隔符，是用于连接资源链接和图片样式的特殊符号 * 存储服务处理访问请求时，会优先定位到链接中的分隔符、并尝试以分隔符之后的内容去匹配图片样式、触发图片处理 ### **样式分隔符** * 为防止访问出错，样式名称中不可出现已设置启用的分隔符。 * 修改分隔符会导致样式访问链接生效，并且须 24 小时后才会在 cdn 上生效，需谨慎操作。 ### **使用案例** 1. 若期望对图片进行[缩略处理 __](https://developer.qiniu.com/dora/1279/basic-processing-images-imageview2)，如指定长短边缩略剪裁方式为：缩至指定长短边区域内（长边最多为 48px，短边最多为 48px），将生成如下指令代码作为图片样式的具体样式内容：`imageView2/0/w/48/h/48`。 2. 将该图片样式命名为 `imageFop`，并指定样式分隔符为 `-`。 图片样式预览效果如下：  3. 原始图片链接 `http://dn-odum9helk.qbox.me/qiniu-picture1.jpg`。 4. 将原图链接使用样式分隔符 `-` 拼接图片样式名 `imageFop`，即访问 `http://dn-odum9helk.qbox.me/qiniu-picture1.jpg-imageFop` 便可直接获得缩放效果图。 # **处理功能** 图片处理 | 参数 | 简介 ---|---|--- [图片瘦身](https://developer.qiniu.com/dora/api/1271/image-thin-body-imageslim) | imageslim | 将存储在七牛的JPEG、PNG格式的图片实时压缩而尽可能不影响画质。 [图片基本处理](https://developer.qiniu.com/dora/api/1279/basic-processing-images-imageview2) | imageView2 | 可对图片进行缩略操作，生成各种缩略图。imageView2 接口可支持处理的原图片格式有 psd、jpeg、png、gif、webp、tiff、bmp。 [图片高级处理- 缩放](https://developer.qiniu.com/dora/api/8255/the-zoom) | thumbnail | 将图片缩放至指定大小。 [图片高级处理- 裁剪](https://developer.qiniu.com/dora/api/8256/tailoring) | crop | 普通裁剪、缩放裁剪 [图片高级处理- 旋转](https://developer.qiniu.com/dora/api/8257/rotating) | auto-orient rotate | 自适应旋转、普通旋转。 [图片高级处理- 格式转换](https://developer.qiniu.com/dora/api/8258/format-conversion) | format colors | 格式转换、GIF 颜色控制。 [图片高级处理- 渐进显示](https://developer.qiniu.com/dora/api/8260/progressive-shows) | interlace | 将图片调整为渐进显示。 [图片高级处理- 背景色填充](https://developer.qiniu.com/dora/api/8351/the-background-color-fill) | background | 对图片填充背景颜色 [图片高级处理- 质量变换](https://developer.qiniu.com/dora/api/8259/the-quality-of-transformation) | q | 对图片质量进行调节 [图片高级处理- 高斯模糊](https://developer.qiniu.com/dora/api/8261/gaussian-blur) | blur | 对图片进行模糊处理 [图片基本信息](https://developer.qiniu.com/dora/api/pictures-basic-information-imageinfo) | imageInfo | 可以获取图片格式、大小、色彩模型信息。 [图片水印处理](https://developer.qiniu.com/dora/api/image-watermarking-processing-watermark) | watermark | 提供四种水印接口：图片水印、文字水印，文字平铺水印、混合水印。 更多图片处理功能，请参考七牛云智能多媒体服务的[图片处理 __](https://developer.qiniu.com/dora/3683/img- directions-for-use)。 # **操作方式** Kodo 支持使用命令行辅助工具或通过控制台设置。 支持的操作方式 | 参考文档 ---|--- 控制台 | [设置图片样式](https://developer.qiniu.com/kodo/development_guidelines/8558/set-the-picture-style) 命令行辅助工具 | [qrsctl 数据处理](https://developer.qiniu.com/kodo/tools/1300/qrsctl#8) 以上内容是否对您有帮助？

转码样式

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [开发指南](https://developer.qiniu.com/kodo/development_guidelines/8596/development- guidelines) > [数据处理](https://developer.qiniu.com/kodo/development_guidelines/8615/dev-the- data-processing) > 转码样式 # 转码样式 最近更新时间: 2022-09-22 22:09:32 视频转码样式，用于在控制台上传文件时触发转码处理。 # **转码命令参数详解** 转码命令 | 完整命令 | 命令参数 ---|---|--- audio-AAC-64K | avthumb/mp4/ab/64k/ar/44100/acodec/libfaac | 封装：MP4，音频码率：64Kbps，音频采样率：44100Hz，音频编码格式：libfaac audio-AAC-128K | avthumb/mp4/ab/128k/ar/44100/acodec/libfaac | 封装：MP4，音频码率：128Kbps，音频采样率：44100Hz，音频编码格式：libfaac audio-AAC-256K | avthumb/mp4/ab/256k/ar/44100/acodec/libfaac | 封装：MP4，音频码率：256Kbps，音频采样率：44100Hz，音频编码格式：libfaac audio-HLS-32k | avthumb/m3u8/segtime/10/ab/32k/ar/44100/acodec/libfaac | 封装：m3u8，切片时长：10s，音频码率：32Kbps，音频采样率：44100Hz，音频编码格式：libfaac audio-HLS-48k | avthumb/m3u8/segtime/10/ab/48k/ar/44100/acodec/libfaac | 封装：m3u8，切片时长：10s，音频码率：48Kbps，音频采样率：44100Hz，音频编码格式：libfaac audio-HLS-64k | avthumb/m3u8/segtime/10/ab/64k/ar/44100/acodec/libfaac | 封装：m3u8，切片时长：10s，音频码率：64Kbps，音频采样率：44100Hz，音频编码格式：libfaac audio-MP3-128K | avthumb/mp3/ab/128k/ar/44100/acodec/libmp3lame | 封装：MP3，音频码率：128Kbps，音频采样率：44100Hz，音频编码格式：MP3 (MPEG audio layer 3) audio-MP3-160K | avthumb/mp3/ab/160k/ar/44100/acodec/libmp3lame | 封装：MP3，音频码率：160Kbps，音频采样率：44100Hz，音频编码格式：MP3 (MPEG audio layer 3) audio-MP3-192K | avthumb/mp3/ab/192k/ar/44100/acodec/libmp3lame | 封装：MP3，音频码率：192Kbps，音频采样率：44100Hz，音频编码格式：MP3 (MPEG audio layer 3) audio-MP3-320K | avthumb/mp3/ab/320k/ar/44100/acodec/libmp3lame | 封装：MP3，音频码率：320Kbps，音频采样率：44100Hz，音频编码格式：MP3 (MPEG audio layer 3) video-Generic-320x240 | avthumb/mp4/ab/128k/ar/22050/acodec/libfaac/r/30/vb/300k/vcodec/libx264/s/320x240/autoscale/1/stripmeta/0 | 封装：MP4，音频码率：128Kbps，音频采样率：22050Hz，音频编码格式：libfaac，视频帧率：30Hz，视频码率：300Kbps，视频编码：H.264，视频分辨率：320x240，视频按原比例缩放至分辨率，清除文件metadata video-Generic-360p-16:9 | avthumb/mp4/ab/128k/ar/44100/acodec/libfaac/r/30/vb/720k/vcodec/libx264/s/640x360/autoscale/1/stripmeta/0 | 封装：MP4，音频码率：128Kbps，音频采样率：44100Hz，音频编码格式：libfaac，视频帧率：30Hz，视频码率：720Kbps，视频编码：H.264，视频分辨率：640x360，视频按原比例缩放至分辨率，清除文件metadata video-Generic-360p-4:3 | avthumb/mp4/ab/128k/ar/44100/acodec/libfaac/r/30/vb/600k/vcodec/libx264/s/480x360/autoscale/1/stripmeta/0 | 封装：MP4，音频码率：128Kbps，音频采样率：44100Hz，音频编码格式：libfaac，视频帧率：30Hz，视频码率：600Kbps，视频编码：H.264，视频分辨率：480x360，视频按原比例缩放至分辨率，清除文件metadata video-Generic-480p-16:9 | avthumb/mp4/ab/128k/ar/44100/acodec/libfaac/r/30/vb/1200k/vcodec/libx264/s/854x480/autoscale/1/stripmeta/0 | 封装：MP4，音频码率：128Kbps，音频采样率：44100Hz，音频编码格式：libfaac，视频帧率：30Hz，视频码率：1200Kbps，视频编码：H.264，视频分辨率：854x480，视频按原比例缩放至分辨率，清除文件metadata video-Generic-480p-4:3 | avthumb/mp4/ab/128k/ar/44100/acodec/libfaac/r/30/vb/900k/vcodec/libx264/s/640x480/autoscale/1/stripmeta/0 | 封装：MP4，音频码率：128Kbps，音频采样率：44100Hz，音频编码格式：libfaac，视频帧率：30Hz，视频码率：900Kbps，视频编码：H.264，视频分辨率：640x480，视频按原比例缩放至分辨率，清除文件metadata video-Generic-720P | avthumb/mp4/ab/160k/ar/44100/acodec/libfaac/r/30/vb/2400k/vcodec/libx264/s/1280x720/autoscale/1/stripmeta/0 | 封装：MP4，音频码率：160Kbps，音频采样率：44100Hz，音频编码格式：libfaac，视频帧率：30Hz，视频码率：2400Kbps，视频编码：H.264，视频分辨率：1280x720，视频按原比例缩放至分辨率，清除文件metadata video-Generic-1080P | avthumb/mp4/ab/160k/ar/44100/acodec/libfaac/r/30/vb/5400k/vcodec/libx264/s/1920x1080/autoscale/1/strpmeta/0 | 封装：MP4，音频码率：160Kbps，音频采样率：44100Hz，音频编码格式：libfaac，视频帧率：30Hz，视频码率：5400Kbps，视频编码：H.264，视频分辨率：1920x1080，视频按原比例缩放至分辨率，清除文件metadata video-HLS-150k | avthumb/m3u8/segtime/10/ab/128k/ar/44100/acodec/libfaac/r/30/vb/150k/vcodec/libx264/stripmeta/0 | 封装：m3u8，切片时长：10s，音频码率：128Kbps，音频采样率：44100Hz，音频编码格式：libfaac，视频帧率：30Hz，视频码率：150Kbps，视频编码：H.264，清除文件metadata video-HLS-240k | avthumb/m3u8/segtime/10/ab/128k/ar/44100/acodec/libfaac/r/30/vb/240k/vcodec/libx264/stripmeta/0 | 封装：m3u8，切片时长：10s，音频码率：128Kbps，音频采样率：44100Hz，音频编码格式：libfaac，视频帧率：30Hz，视频码率：240Kbps，视频编码：H.264，清除文件metadata video-HLS-640k | avthumb/m3u8/segtime/10/ab/128k/ar/44100/acodec/libfaac/r/30/vb/640k/vcodec/libx264/stripmeta/0 | 封装：m3u8，切片时长：10s，音频码率：128Kbps，音频采样率：44100Hz，音频编码格式：libfaac，视频帧率：30Hz，视频码率：640Kbps，视频编码：H.264，清除文件metadata video-HLS-1000k | avthumb/m3u8/segtime/10/ab/128k/ar/44100/acodec/libfaac/r/30/vb/1000k/vcodec/libx264/stripmeta/0 | 封装：m3u8，切片时长：10s，音频码率：128Kbps，音频采样率：44100Hz，音频编码格式：libfaac，视频帧率：30Hz，视频码率：1000Kbps，视频编码：H.264，清除文件metadata video-Web | avthumb/mp4/ab/160k/ar/44100/acodec/libfaac/r/30/vb/2200k/vcodec/libx264/s/1280x720/autoscale/1/stripmeta/0 | 封装：MP4，音频码率：160Kbps，音频采样率：44100Hz，音频编码格式：libfaac，视频帧率：30Hz，视频码率：2200Kbps，视频分辨率：1280x720，视频按原比例缩放至分辨率，视频编码：H.264，清除文件metadata video-iPhone4 | avthumb/mp4/ab/160k/ar/48000/acodec/libfaac/r/30/vb/2200k/vcodec/libx264/s/1280x720/autoscale/1/stripmeta/0 | 封装：MP4，音频码率：160Kbps，音频采样率：48000Hz，音频编码格式：libfaac，视频帧率：30Hz，视频码率：2200Kbps，视频分辨率：1280x720，视频按原比例缩放至分辨率，视频编码：H.264，清除文件metadata video-iPhone4s | avthumb/mp4/ab/160k/ar/48000/acodec/libfaac/r/30/vb/5000k/vcodec/libx264/s/1920x1080/autoscale/1/stripmeta/0 | 封装：MP4，音频码率：160Kbps，音频采样率：48000Hz，音频编码格式：libfaac，视频帧率：30Hz，视频码率：5000Kbps，视频分辨率：1920x1080，视频按原比例缩放至分辨率，视频编码：H.264，清除文件metadata # **目标文件名设置** 目标文件名指转码后的文件名，设置时支持使用[魔法变量](https://developer.qiniu.com/kodo/manual/1235/vars#magicvar)，魔法变量引用格式为 ${var}，$(var)。 特别的，魔法变量仅支持：bucket、key、etag、fsize、mimeType、endUser、fname、ext、fprefix、keybase 举例： 1.目标文件名设置为 $(fprefix)-transcode.$(ext) 2.上传文件名为 butterfly.mp4，则转码后文件名为 butterfly-transcode.mp4；上传文件名 newcity.flv，则转码后文件名为 newcity-transcode.flv # **操作方式** Kodo 支持通过控制台设置转码样式。 支持的操作方式 | 参考文档 ---|--- 控制台 | [设置转码样式](https://developer.qiniu.com/kodo/development_guidelines/8559/set-the-transcoding-style) 以上内容是否对您有帮助？

原始资源保护

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [开发指南](https://developer.qiniu.com/kodo/development_guidelines/8596/development- guidelines) > [数据处理](https://developer.qiniu.com/kodo/development_guidelines/8615/dev-the- data-processing) > 原始资源保护 # 原始资源保护 最近更新时间: 2024-03-27 11:35:38 原始资源保护是七牛存储针对媒体类原始文件的保护措施。 对整个存储空间内所有的资源生效，开启后，空间内的文件无法直接通过 URL 进行访问，需要配合样式分隔符和样式才能访问。 * [图片样式](https://developer.qiniu.com/kodo/development_guidelines/8623/dev-the-picture-style) * [视频样式](https://developer.qiniu.com/kodo/development_guidelines/12654/video-process) # **应用场景** 用于控制客户只能访问处理后的资源，如： * 对于存储在七牛上的图片和视频资源，只希望客户访问携带水印的图片和视频 * 对于存储在七牛上的图片资源，进行统一的规格化处理 **特别需要注意的是，原始资源保护是一种空间属性，对整个空间的资源都会生效，因此强烈建议对于开启原始资源保护的空间只存储需要保护的原始图片和视频文件，其他文件使用其他空间存放。** # **访问方式** 开启原始资源保护后，不能通过如下方式访问: * `http://绑定域名/文件key或相对路径` * `http://绑定域名/文件key或相对路径?操作符/操作符参数` 可以通过如下方式进行公开访问（其中加号“+”忽略）： * `http://绑定域名/文件key或相对路径 + 已设定的样式分隔符 + 已设定的图片样式` 如配置分隔符为 “-”,图片样式名称为 “watermarked.jpg”，则以下形式的链接可以访问 * `http://(Domain)/(Key)-watermarked.jpg` 如果希望对原始文件进行访问，可以通过[私有链接签名](https://developer.qiniu.com/kodo/development_guidelines/1656/download- private)的方式，携带鉴权参数访问，但不建议这样使用。 # **操作方式** Kodo 支持通过控制台或使用命令行辅助工具设置原始资源保护。 支持的操作方式 | 参考文档 ---|--- 控制台 | [设置原始资源保护](https://developer.qiniu.com/kodo/development_guidelines/8560/set-the-original-protection) 命令行辅助工具 | [qrsctl](https://developer.qiniu.com/kodo/tools/1300/qrsctl) protected 命令 以上内容是否对您有帮助？

传输加速

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [开发指南](https://developer.qiniu.com/kodo/development_guidelines/8596/development- guidelines) > 传输加速 # 传输加速 最近更新时间: 2024-06-25 10:25:47 如果您希望实现远距离数据传输加速，例如从非中国内地向中国内地的空间请求上传或下载文件，您可以开启传输加速。传输加速利用全球分布的云机房，将全球各地用户对您存储空间的访问，经过智能路由解析至就近的接入点，使用优化后的网络及协议，为云存储互联网的上传、下载提供端到端的加速方案。 # **具体说明** * 当前七牛云存储传输加速，仅支持上传链路加速。您可以开启传输加速，使用七牛云提供的传输加速域名做上传，可以为互联网的上传提供端到端的加速效果。通过传输加速域名上传数据时，会产生加速上传流量。更多信息，请参见 [计量项与计费项](https://developer.qiniu.com/kodo/buying_guide/6379/metering-and-billing)。 * 访问域名。开启传输加速后，您可以通过两种域名访问您空间的文件： * **默认源站上传域名** ，格式如 `up-*.qiniup.com` ，详情见 [存储区域](https://developer.qiniu.com/kodo/product_introduction/1671/region-endpoint-fq)，可以指定 HTTP / HTTPS 传输协议。通过该域名上传对象时，您的请求会被直接转发至七牛云对应区域存储机房，如果外网链路长，可能存在传输不稳定的情况；通过该域名上传对象时，不需要收取上传流量费用。 * **空间级别传输加速域名** ，格式如 `*.kodo-accelerate.*.qiniucs.com`，可以指定 HTTP / HTTPS 传输协议。通过该域名上传对象时，会根据网络状况为您智能解析并就近接入，使用优化后的网络及协议，实现加速的效果。通过该域名上传对象时，会产生加速上传流量。 # **使用案例** * 跨境数据传输需求 您的业务场景要求是将文件上传至国内华东-浙江区域，终端对传输成功率要求极高，海量全球分布终端用户每天需要从世界各地，比如新加坡和美国，上传数据到华东-浙江； * 大文件传输加速需求 您的业务场景要求是将音视频文件、高清图片、压缩包等快速高效的上传，需要从办公室每天上传 GB 级别大小的文件上至国内华东-浙江区域 # **操作方式** Kodo 支持使用通过控制台开启 / 关闭传输加速。 支持的操作方式 | 参考文档 ---|--- 控制台 | [设置传输加速](https://developer.qiniu.com/kodo/development_guidelines/12659/set-transfer-acceleration) # **使用方式** Kodo 支持通过 SDK 、命令行工具、图形化管理工具等使用加速域名。 支持的使用入口 | 具体使用方式 | 详细参考文档 ---|---|--- 控制台 | 上传时指定使用传输加速域名 | 开启传输加速后，即可通过控制台在上传文件时按需选择加速域名上传，参考[上传文件](https://developer.qiniu.com/kodo/development_guidelines/8562/upload-a-file) SDK | 指定传输加速域名 | 各 SDK 使用文档，[比如 GO SDK ](https://developer.qiniu.com/kodo/sdk/1238/go) 可以在上传可选配置 `putExtra.UpHost` ，指定上传域名为传输加速域名 命令行工具 | 配置文件指定传输加速域名或者上传命令指定传输加速域名 | [Qshell 使用文档](https://developer.qiniu.com/kodo/tools/1302/qshell)，比如`fput`的上传命令指定参数 `--up-host`，指定上传域名为传输加速域名 图形化管理工具 | 配置文件指定传输加速域名 | 能力迭代中 # **测试传输加速效果** * 您可以通过 [上传测速工具](https://developer.qiniu.com/kodo/tools/2528/upload-webtest) 测试对比您本地访问七牛存储全球各地数据中心时，开启传输加速与未开启传输加速的访问速度； * 通过在 Qshell 命令对比测试使用默认源站上传域名和传输加速域名上传文件所需时间以及访问速度；  以上内容是否对您有帮助？

AWS S3 兼容

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [开发指南](https://developer.qiniu.com/kodo/development_guidelines/8596/development- guidelines) > AWS S3 兼容 # AWS S3 兼容 最近更新时间: 2020-12-28 20:15:29 为了使众多基于AWS S3接口协议开发的各类应用及服务能够轻便的接入七牛对象存储，七牛对象存储兼容了AWS S3常用接口。接口的具体兼容情况，在下文中做了详细叙述。 七牛云存储兼容S3协议接口，是为了尽可能的方便基于 AWS S3 而开发的应用接入到七牛对象存储。如果您刚刚开始着手开发新的应用，为了更好的使用七牛对象存储丰富的产品功能，更推荐使用原生接口进行开发。 * [存储类型](https://developer.qiniu.com/kodo/manual/5906/storage-type) * [服务域名](https://developer.qiniu.com/kodo/manual/4088/s3-access-domainname) * [签名认证](https://developer.qiniu.com/kodo/manual/4093/s3-authentication) * [临时安全凭证](https://developer.qiniu.com/kodo/manual/5914/s3-compatible-sts) * [兼容公共头](https://developer.qiniu.com/kodo/manual/4091/s3-compatible-header) * [兼容API](https://developer.qiniu.com/kodo/manual/4087/compatible-s3-api) * [兼容工具示例](https://developer.qiniu.com/kodo/manual/4096/s3-compatible-sdk) 以上内容是否对您有帮助？

存储类型

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [开发指南](https://developer.qiniu.com/kodo/development_guidelines/8596/development- guidelines) > [AWS S3 兼容](https://developer.qiniu.com/kodo/development_guidelines/4086/aws-s3-compatible) > 存储类型 # 存储类型 最近更新时间: 2023-12-25 11:31:31 七牛对象存储支持标准（STANDARD）、低频访问（LINE）、归档直读（GLACIER_IR）、归档（GLACIER）、深度归档（DEEP_ARCHIVE）五种存储类型。 以上内容是否对您有帮助？

服务域名

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [开发指南](https://developer.qiniu.com/kodo/development_guidelines/8596/development- guidelines) > [AWS S3 兼容](https://developer.qiniu.com/kodo/development_guidelines/4086/aws-s3-compatible) > 服务域名 # 服务域名 最近更新时间: 2024-08-20 14:49:38 # 服务域名 您可使用如下服务域名通过 AWS S3 协议访问七牛云对象存储： 存储区域 | 区域简称 Region ID | 访问 Endpoint | 协议 ---|---|---|--- 华东-浙江 | cn-east-1 | s3.cn-east-1.qiniucs.com | HTTP，HTTPS 华东-浙江2 | cn-east-2 | s3.cn-east-2.qiniucs.com | HTTP，HTTPS 华北-河北 | cn-north-1 | s3.cn-north-1.qiniucs.com | HTTP，HTTPS 华南-广东 | cn-south-1 | s3.cn-south-1.qiniucs.com | HTTP，HTTPS 北美-洛杉矶 | us-north-1 | s3.us-north-1.qiniucs.com | HTTP，HTTPS 亚太-新加坡（原东南亚） | ap-southeast-1 | s3.ap-southeast-1.qiniucs.com | HTTP，HTTPS 亚太-河内 | ap-southeast-2 | s3.ap-southeast-2.qiniucs.com | HTTP，HTTPS 亚太-胡志明 | ap-southeast-3 | s3.ap-southeast-3.qiniucs.com | HTTP，HTTPS _注意：暂不支持通过以上服务域名匿名访问七牛云存储，必须携带**[AWS Signature](https://developer.qiniu.com/kodo/manual/4093/s3-authentication.md)** 。_ # 访问方式 七牛对象存储兼容 AWS S3 的 path-style 和 bucket virtual hosting 两种访问方式，以 GetObject 为例 风格 | 示例 ---|--- Path Style | `http://s3.cn-east-1.qiniucs.com/<S3 空间名>/objectname` Virtual-host Style | `http://<S3 空间名>.s3.cn-east-1.qiniucs.com/objectname` 其中 S3 空间名的获取，需参考下述说明。 # 获取七牛 S3 空间名 S3 空间名：全局唯一（遵循 S3 协议的要求） * 空间名称全局唯一时，S3 空间名=空间名称；空间名称全局不唯一时，系统会为空间自动生成一个 S3 空间名 * 七牛对象存储空间的 S3 空间名，可以通过 [Get Service](https://developer.qiniu.com/kodo/manual/4087/compatible-s3-api#service-operation) 接口获取，也可在 [产品服务-对象存储-空间管理-空间概览 __](https://portal.qiniu.com/kodo/bucket)中查看 以上内容是否对您有帮助？

签名认证

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [开发指南](https://developer.qiniu.com/kodo/development_guidelines/8596/development- guidelines) > [AWS S3 兼容](https://developer.qiniu.com/kodo/development_guidelines/4086/aws-s3-compatible) > 签名认证 # 签名认证 最近更新时间: 2020-12-28 20:14:51 同时兼容AWS Signature Version 2 和 AWS Signature Version 4，均实现了请求头签名和参数签名方式。AWS Signature V2 签名方法请查阅 [Signing and Authenticating REST Requests __](https://docs.aws.amazon.com/AmazonS3/latest/dev/RESTAuthentication.html)， AWS Signature V4 签名方法请查阅[Authenticating Requests (AWS Signature Version 4)__](https://docs.aws.amazon.com/AmazonS3/latest/API/sig-v4-authenticating- requests.html)。 以上内容是否对您有帮助？

临时安全凭证

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [开发指南](https://developer.qiniu.com/kodo/development_guidelines/8596/development- guidelines) > [AWS S3 兼容](https://developer.qiniu.com/kodo/development_guidelines/4086/aws-s3-compatible) > 临时安全凭证 # 临时安全凭证 最近更新时间: 2020-12-28 20:14:39 兼容 AWS Security Token Service (STS) 的联合身份临时安全凭证 (federation token) ，更多详细信息请查阅 [AWS 临时安全凭证 __](https://docs.aws.amazon.com/zh_cn/IAM/latest/UserGuide/id_credentials_temp_request.html#api_getfederationtoken)。 # **兼容API** STS API | 请求兼容描述 | 响应兼容描述 ---|---|--- GetFederationToken | 未支持请求参数 PolicyArns.member.N | 未支持响应参数 PackedPolicySize 请求参数中的 Policy 结构与 S3 一致，对于策略中的 Action 元素，目前已经兼容的包括： * s3:CreateBucket * s3:ListBucket * s3:DeleteBucket * s3:GetBucketLocation * s3:ListAllMyBuckets * s3:DeleteObject * s3:PutObject * s3:GetObject * s3:AbortMultipartUpload * s3:ListMulitpartUploadParts 您也可以使用通配符 “*” 或 “S3:*” 表示任意操作。关于 Policy 更多内容请查阅[会话策略 __](https://docs.aws.amazon.com/zh_cn/IAM/latest/UserGuide/access_policies.html#policies_session)。 以上内容是否对您有帮助？

兼容公共头

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [开发指南](https://developer.qiniu.com/kodo/development_guidelines/8596/development- guidelines) > [AWS S3 兼容](https://developer.qiniu.com/kodo/development_guidelines/4086/aws-s3-compatible) > 兼容公共头 # 兼容公共头 最近更新时间: 2020-12-28 20:14:30 # **公共请求头** AWS S3 请求头 | 说明 ---|--- Authorization | 兼容 Content-Length | 兼容 Content-Type | 兼容 Content-MD5 | 兼容 Date | 兼容 Expect | 兼容 Host | 兼容 x-amz-content-sha256 | 兼容 x-amz-date | 兼容 x-amz-security-token | 不兼容 # **公共响应头** AWS S3 请求头 | 说明 ---|--- Content-Length | 兼容 Content-Type | 兼容 Connection | 兼容 Date | 兼容 ETag | 兼容 Server | 兼容 x-amz-delete-marker | 暂不支持 x-amz-request-id | 兼容 x-amz-id-2 | 不兼容 x-amz-version-id | 暂不支持 以上内容是否对您有帮助？

兼容 API

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [开发指南](https://developer.qiniu.com/kodo/development_guidelines/8596/development- guidelines) > [AWS S3 兼容](https://developer.qiniu.com/kodo/development_guidelines/4086/aws-s3-compatible) > 兼容 API # 兼容 API 最近更新时间: 2024-07-02 14:52:13 下方列出了已经实现兼容的接口，并在表格中详细列出了未兼容的字段。 # **Service API** AWS S3 接口 | 请求兼容描述 | 响应兼容描述 ---|---|--- GET Service | 兼容 | 兼容 # **Bucket API** AWS S3 接口 | 请求兼容描述 | 响应兼容描述 ---|---|--- DELETE Bucket | 兼容 | 兼容 DELETE Bucket tagging | 兼容 | 兼容 GET Bucket | 未支持请求参数encoding-type | 未支持响应参数Encoding-Type GET Bucket Version 2 | 未支持请求参数encoding-type | 未支持响应参数Encoding-Type GET Bucket tagging | 兼容 | 兼容 HEAD Bucket | 兼容 | 兼容 PUT Bucket | 兼容 | 兼容 PUT Bucket tagging | 兼容 | 兼容 GET Bucket location | 兼容 | 兼容 PUT Bucket acl | 兼容 | 兼容 GET Bucket acl | 兼容 | 兼容 PUT Bucket cors | 兼容 | 兼容 GET Bucket cors | 兼容 | 兼容 DELETE Bucket cors | 兼容 | 兼容 特别的，为了便于排障，跨域请求的响应 Access-Control-Expose-Headers 中，必定会包含 `x-amz-request- id`（即使用户没有配置）。 Bucket Policy相关参见 [使用 Bucket Policy 授权](https://developer.qiniu.com/kodo/manual/6317/BucketPolicy) # **Object API** AWS S3 接口 | 请求兼容描述 | 响应兼容描述 ---|---|--- DELETE Multiple Object | 未支持请求头x-amz-mfa | 兼容 DELETE Object | 未支持请求头x-amz-mfa | 兼容 GET Object | 未支持请求头x-amz-server-side-encryption-* | 未支持响应头 x-amz-replication-status, x-amz-server-side-encryption-*, x-amz-tagging-count, x-amz-object-lock-* HEAD Object | 未支持请求头x-amz-server-side-encryption-* | 未支持响应头x-amz-missing-meta, x-amz-replication-status, x-amz-server-side-encryption-*, x-amz-object-lock-* POST Object | 未支持表单字段AWSAccessKeyId, policy, tagging, x-amz-security-token, x-amz-server-side-encryption-* x-amz-storage-class取值 STANDARD、LINE、GLACIER、DEEP_ARCHIVE，默认STANDARD | 未支持响应头x-amz-expiration, x-amz-server-side-encryption-* PUT Object | 未支持请求头x-amz-tagging, x-amz-object-lock-*, x-amz-server-side-encryption-* x-amz-storage-class取值 STANDARD、LINE、GLACIER、DEEP_ARCHIVE，默认STANDARD | 未支持响应头x-amz-expiration, x-amz-server-side-encryption-* PUT Object - Copy | 未支持请求头 x-amz-tagging-directive, x-amz-server-side-encryption-*, x-amz-copy-source-server-side-encryption-* x-amz-storage-class取值 STANDARD、LINE、GLACIER、DEEP_ARCHIVE，默认STANDARD | 未支持响应头x-amz-expiration, x-amz-server-side-encryption-* Abort Multipart Upload | 兼容 | 兼容 Complete Multipart Upload | 兼容 | 未支持响应头x-amz-expiration, x-amz-server-side-encryption-*, x-amz-version-id Initiate Multipart Upload | 未支持请求头 x-amz-tagging, x-amz-server-side-encryption-* x-amz-storage-class取值 STANDARD、LINE、GLACIER、DEEP_ARCHIVE，默认STANDARD | 未支持响应头x-amz-abort-date, x-amz-abort-rule-id, x-amz-server-side-encryption-* List Parts | 未支持请求参数encoding-type | 未支持响应参数x-amz-abort-date, x-amz-abort-rule-id,Encoding-Type, LastModified Upload Part | 未支持请求头x-amz-server-side-encryption-* | 未支持响应头x-amz-server-side-encryption-* Upload Part - copy | 未支持请求头x-amz-server-side-encryption-* | 未支持响应头x-amz-copy-source-version-id,x-amz-server-side-encryption-* Restore Object | 未支持请求参数 versionId, Description, OutputLocation, SelectParameters, Tier, Type Days 解冻天数限 1～7 深度归档存储类型支持 GlacierJobParameters.Tier=Standard | 未支持响应头 x-amz-restore-output-path PUT Object acl | 兼容 | 兼容 GET Object acl | 兼容 | 兼容 以上内容是否对您有帮助？

使用 Bucket Policy 授权

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [开发指南](https://developer.qiniu.com/kodo/development_guidelines/8596/development- guidelines) > [AWS S3 兼容](https://developer.qiniu.com/kodo/development_guidelines/4086/aws-s3-compatible) > [兼容 API](https://developer.qiniu.com/kodo/development_guidelines/4087/compatible-s3-api) > 使用 Bucket Policy 授权 # 使用 Bucket Policy 授权 最近更新时间: 2024-05-22 14:43:36 Bucket Policy 是基于资源的授权策略，常见的应用场景如下： * 向其他账号授权访问。 您可以授予其他账号访问您对象存储资源的权限。 * 授予带特定 IP 条件限制的访问权限。 某些场景下，您需要授予带 IP 限制的访问策略。例如，企业内部的机密文档，只允许在企业内部访问，不允许在其他区域访问。由于企业内部人员较多，如果针对每个人配置子账号，工作量非常大。此时，您可以基于 Bucket Policy 设置带 IP 限制的访问策略，从而高效方便地进行授权。 Bucket Policy 使用限制 * 只有 Bucket 拥有者可以设置 Bucket Policy * 每个 Bucket 默认最多设置 20条 Bucket Policy，超出限制服务端返回 400：too many statement in policy * 每个 Bucket 的 Policy 总内容大小限制为 20KB，超出限制服务端返回 400：EntityTooLarge # **策略模型** Bucket Policy 是一组规定谁能以什么样的权限访问 Bucket/Object 的策略。 Policy 可定义的内容包括： * 版本（Version）：请指定为 2024-05-20 * 资源（Resource） * Bucket * 资源/Object：单个 Object key 或 Prefix 指定 * 权限（Action）：每个 Action 对应一组 API * 分别定义有 Bucket 级别和 Object 级别的 Action * 详见 支持的权限列表 * 用户（Principal）：被授权者 * 全部用户（不含匿名账户） * 指定用户 * 效果（Effect） * Deny，禁止权限，优先级高于 Allow * Allow，允许权限 * 条件（Condition） * 支持的运算符 * IpAddress：IP 列表，支持指定地址或地址段 * NotIpAddress：排除的 IP 列表，支持指定地址或地址段 * StringLike：字符串匹配（区分大小写），值可以包含 ? 和 * 通配符。如需匹配字符本身需添加 `${}` 进行转义，即定义为 `${*}` 和 `${?}`；如需匹配 `$` 转义符本身，需定义为 `${$}` * StringNotLike：字符串否定匹配（区分大小写），值可以包含 ? 和 * 通配符。如需匹配字符本身需添加 `${}` 进行转义，即定义为 `${*}` 和 `${?}`；如需匹配 `$` 转义符本身，需定义为 `${$}` * StringEquals：字符串精确匹配（区分大小写），值不支持通配符 * StringNotEquals：字符串精确否定匹配（区分大小写），值不支持通配符 * 条件按键 * aws:SourceIp：可使用运算符 IpAddress、NotIpAddress * aws:Referer、aws:Host、aws:AccessKey、s3:Prefix：可使用运算符 StringLike、StringNotLike、StringEquals、StringNotEquals；其中 s3:Prefix 仅限用于 ListBucket action 的授权。 # **策略声明格式** Bucket Policy声明样例如下： { "Version":"2024-05-20", "Id": "samplepolicy", "Statement" : [ { "Sid":"AddPerm", "Effect":"Allow", "Principal" : { "AWS":["111122223333","444455556666","iam::111122223333:3984935484"] }, "Action":["s3:*"], "Resource":"arn:aws:s3:::bucket/*", "Condition": { "IpAddress": {"aws:SourceIp": ["54.240.143.0/24","2001:DB8:1234:5678::/64","1.1.1.1"]}, "NotIpAddress": {"aws:SourceIp": "54.240.143.188/32"}, "StringLike": { "aws:Referer": ["*.uuci.net",""], "aws:Host": ["fly.uuci.net",""] } }, {},... ] } 字段说明： 字段 | 必填 | 说明 | 样例 ---|---|---|--- Version | 是 | 请指定为 2024-05-20 | `"Version":"2024-05-20"` Resource | 是 | 授权资源，可以是 Bucket 或 Object，以字符串或字符串列表表示，大小写敏感：`"arn:aws:s3:::<bucket>"`，`"arn:aws:s3:::<bucket>/<key_regex>"`。 * Object 支持正则表达式。Object 名支持通配符 * 和 ?，如需匹配字符本身需添加 `${}` 进行转义，即定义为 `${*}` 和 `${?}`；如需匹配 `$` 转义符本身，需定义为 `${$}`。 * 如果不带/ 认为是 bucket 形式, 否则认为是 object 形式。 * 指定为 Bucket 时, 要求包含至少一个 Bucket 级别的 Action；指定为 Object 时，则要求包含至少一个 Object 级别的 Action。 | `"Resource":["arn:aws:s3:::examplebucket"]` `"Resource":["arn:aws:s3:::examplebucket/abc/*"]` `"Resource":"arn:aws:s3:::examplebucket/* "` `"Resource":"arn:aws:s3:::examplebucket/ab?df* "` Action | 是 | 权限，仅限使用系统定义的 Action 名来设置，支持指定多个 Action，格式为字符串 | `"Action":["s3:PutObject","s3:GetObject","s3:DeleteObject"]` `"Action":"s3:*"` Principal | 是 | 被授权者，以七牛云账号的用户 id 表示，支持指定多个用户：`"AWS":<id>`，`"AWS":<id list>`。AWS必须大写。 * IAM 用户 id 的格式为 `iam::<root_id>:<iamid>`。 * 当 Bucket 拥有者被 Principal 指定时，Bucket 拥有者也会被策略限制；但是 Bucket 拥有者可以修改 Policy 来解除限制。 | `"Principal":{"AWS":["11","22"]}` `"Principal":{"AWS":["iam::111111:123123"]}` `"Principal":{"AWS":"*"}` Effect | 是 | 效果，可以设置为允许（Allow）或拒绝（Deny），大小写敏感。 * 拒绝优先级高于允许；其他字段都匹配成功后，Effect字段才生效。 | `"Effect":"Allow"` Condition | 否 | 策略生效条件。目前支持 IpAddress、NotIpAddress、StringLike、StringNotLike、StringEquals、StringNotEquals 六种运算符，aws:SourceIp、aws:Referer、aws:Host、aws:AccessKey、s3:Prefix 五种条件键；均大小写敏感。 * IpAddress 和 NotIpAddress 支持指定多个IP地址或地址段：`"IpAddress":{"aws:SourceIp":<IP>}`,`"IpAddress":{"aws:SourceIp":<IP segment>}`。 * StringLike、StringNotLike、StringEquals、StringNotEquals 支持设定 aws:Referer、aws:Host 和 aws:AccessKey，来实现对请求 Referer、Host 和 AccessKey 的校验；StringLike、StringNotLike 的设置支持空、每个值最多包含1个多字符匹配的通配符 * 或 ?。如需匹配字符本身需添加 `${}` 进行转义，即定义为 `${*}` 和 `${?}`；如需匹配 `$` 转义符本身，需定义为 `${$}`。 * StringLike、StringNotLike、StringEquals、StringNotEquals 支持设定 s3:prefix，且必须配合 Action s3:ListBucket 授权。 | `"Condition": {` `"IpAddress": {"aws:SourceIp":["54.240.143.0/24", "1.1.1.1"] },` `"NotIpAddress": {"aws:SourceIp": "54.240.143.188/32"},` `"StringLike": {` `"aws:Referer": ["*.uuci.net",""],` `"aws:Host": ["fly.uuci.net",""]` `}` `}` # **支持的权限列表** Bucket Policy 的权限分为 Bucket 和 Object 两类，对应的 API相互独立，目前支持的权限列表如下： Action | API | Level ---|---|--- s3:DeleteBucket | DELETE Bucket | Bucket s3:ListBucket | GET Bucket(List Objects)，HEAD Bucket | Bucket s3:GetBucketLocation | Get bucket location | Bucket s3:ListBucketMultipartUploads | List Multipart Uploads | Bucket s3:DeleteObject | DELETE Object, DELETE Multiple Object | Object s3:GetObject | GET Object, HEAD Object | Object s3:PutObject | PUT Object, POST Object, Initiate Multipart Upload, Upload Part, Complete Multipart Upload, PUT Object-Copy | Object s3:AbortMultipartUpload | Abort Multipart Upload | Object s3:ListMultipartUploadParts | List Parts | Object s3:* | All API above | Bucket、Object 说明： * 不支持 Upload Part-copy 授权；PUT Object-Copy 需要对 src object 有读权限，对 dst object 有写权限 * Action 和 Resource 需要匹配，否则无法设置，服务端返回错误：Action does not apply to any resource(s) in statement * Level 为 Bucket 时，Resource 必须指定 Bucket * Level 为 Object 时，Resource 必须指定具体的 Object 或是 Prefix * 想要授予空间及其对象的完全控制权限时， * 针对 Bucket 设置 Action 为`s3:* ` * 同时针对 Bucket 下所有的 Object 设置 Action 为`s3:* ` # **Bucket Policy API** ## **设置 Bucket Policy** 本接口支持 Bucket Policy 的新增和修改操作。 ### **请求** **语法** PUT /?policy HTTP/1.1 Host: <s3空间名>.s3.cn-east-1.qiniucs.com Date: Tue, 04 Apr 2019 20:34:56 GMT Authorization: authorization string { Policy in JSON format } **请求元素** Policy 声明。 ### **响应** **响应码** 与 AWS 一致。 **响应元素** 该请求操作的响应体为空。 ## **查询 Bucket Policy** 本接口支持查询指定空间已设置的 Policy 信息。 ### **请求** **语法** GET /?policy HTTP/1.1 Host: <s3空间名>.s3.cn-east-1.qiniucs.com Date: Tue, 04 Apr 2019 20:34:56 GMT Authorization: authorization string **请求元素** 该请求操作的请求体为空。 ### **响应** **响应码** 与AWS一致。 **响应元素** Policy in JSON format。可参见 Bucket Policy声明样例 ## **删除 Bucket Policy** 本接口支持一键删除指定空间的所有 Policy 信息。 ### **请求** **语法** DELETE /?policy HTTP/1.1 Host: <s3空间名>.s3.cn-east-1.qiniucs.com Date: Tue, 04 Apr 2019 20:34:56 GMT Authorization: authorization string **请求元素** 该请求操作的请求体为空 ### **响应** **响应码** 与 AWS 一致。 **响应元素** 该请求操作的响应体为空。 以上内容是否对您有帮助？

兼容 SDK 示例

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [开发指南](https://developer.qiniu.com/kodo/development_guidelines/8596/development- guidelines) > [AWS S3 兼容](https://developer.qiniu.com/kodo/development_guidelines/4086/aws-s3-compatible) > 兼容 SDK 示例 # 兼容 SDK 示例 最近更新时间: 2023-12-28 18:27:25 对大多数基于 AWS S3 的 SDK 开发工具包，进行如下改动即可访问七牛云对象存储 Kodo： * 获取七牛云账号的 AccessKey 和 SecretKey，在您使用的 SDK 中配置七牛云的 AccessKey 和 SecretKey * 设置 SDK 连接的 Region 及 Endpoint 分别为七牛云对象存储的 S3 Region ID 和 访问 Endpoint，可以参考[服务域名 __](https://developer.qiniu.com/kodo/4088/s3-access-domainname) 只要涉及的接口实现了兼容，即可在 SDK 中使用对应的功能、对接七牛云对象存储。 AWS S3 各语言 SDK 对接七牛云对象存储的方式，参考： 使用说明 --- [AWS SDK for C++](https://developer.qiniu.com/kodo/development_guidelines/12554/aws-sdk- cpp-examples) [AWS SDK for .NET (C#)](https://developer.qiniu.com/kodo/development_guidelines/12555/aws-sdk- csharp-examples) [AWS SDK for Go](https://developer.qiniu.com/kodo/development_guidelines/12556/aws-sdk-go- examples) [AWS SDK for Java](https://developer.qiniu.com/kodo/development_guidelines/12557/aws-sdk- java-examples) [AWS SDK for JavaScript](https://developer.qiniu.com/kodo/development_guidelines/12558/aws- sdk-javascript-examples) [AWS SDK for Kotlin](https://developer.qiniu.com/kodo/development_guidelines/12559/aws-sdk- kotlin-examples) [AWS SDK for PHP](https://developer.qiniu.com/kodo/development_guidelines/12562/aws-sdk- php-examples) [AWS SDK for Python](https://developer.qiniu.com/kodo/development_guidelines/12563/aws-sdk- python-examples) [AWS SDK for Ruby](https://developer.qiniu.com/kodo/development_guidelines/12571/aws-sdk- ruby-examples) [AWS SDK for Rust](https://developer.qiniu.com/kodo/development_guidelines/12572/aws-sdk- rust-examples) [AWS SDK for Swift](https://developer.qiniu.com/kodo/development_guidelines/12573/aws-sdk- swift-examples) 以上内容是否对您有帮助？

AWS SDK for C++

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [开发指南](https://developer.qiniu.com/kodo/development_guidelines/8596/development- guidelines) > [AWS S3 兼容](https://developer.qiniu.com/kodo/development_guidelines/4086/aws-s3-compatible) > [兼容 SDK 示例](https://developer.qiniu.com/kodo/development_guidelines/12553/S3 SDK sample) > AWS SDK for C++ # AWS SDK for C++ 最近更新时间: 2024-02-19 17:06:08 # 初始化 CMakeList 导入 AWS SDK for C++ 确保 `CMake v3.14+`，`libcurl`，`OpenSSL v1.x` 已经安装。 创建 `CMakeLists.txt` cmake_minimum_required(VERSION 3.14 FATAL_ERROR) project(aws-sdk-cpp-qiniu-example VERSION 1.0.0 LANGUAGES CXX) set(CMAKE_CXX_STANDARD 11) set(CMAKE_CXX_STANDARD_REQUIRED True) include(FetchContent) fetchcontent_declare( awscppsdk GIT_REPOSITORY https://github.com/aws/aws-sdk-cpp.git GIT_PROGRESS TRUE GIT_SUBMODULES crt/aws-crt-cpp GIT_TAG 1.11.166 ) if(NOT awscppsdk_POPULATED) fetchcontent_populate(awscppsdk) set(BUILD_ONLY "s3;transfer;sts") set(ENABLE_TESTING OFF) fetchcontent_makeavailable(awscppsdk) add_subdirectory(${awscppsdk_SOURCE_DIR} ${awscppsdk_BUILD_DIR}) endif() aux_source_directory(src SRCS) add_executable(${PROJECT_NAME} ${SRCS}) if(MSVC AND BUILD_SHARED_LIBS) target_compile_definitions(${PROJECT_NAME} PUBLIC "USE_IMPORT_EXPORT") add_definitions(-DUSE_IMPORT_EXPORT) list(APPEND SERVICE_LIST s3) AWSSDK_CPY_DYN_LIBS(SERVICE_LIST "" ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_BUILD_TYPE}) endif() set_compiler_flags(${PROJECT_NAME}) set_compiler_warnings(${PROJECT_NAME}) target_link_libraries(${PROJECT_NAME} aws-cpp-sdk-core aws-cpp-sdk-s3 aws-cpp-sdk-transfer aws-cpp-sdk-sts) 对于之后的每个代码示例，将代码创建在 `src/main.cpp` 后，执行 cmake -S . -B build cmake --build build --config Debug 即可编译出可执行文件。 # 对象上传 ## 获取客户端上传 URL 创建 `src/main.cpp` #include <aws/core/Aws.h> #include <aws/core/auth/AWSCredentials.h> #include <aws/s3/S3Client.h> int main() { Aws::SDKOptions options; Aws::InitAPI(options); { const Aws::Auth::AWSCredentials credential("<QINIU_ACCESS_KEY>", "<QINIU_SECRET_KEY>"); Aws::Client::ClientConfiguration clientConfig; clientConfig.endpointOverride = "https://s3.cn-east-1.qiniucs.com"; // 华东-浙江区 endpoint clientConfig.region = "cn-east-1"; // 华东-浙江区 region id Aws::S3::S3Client s3Client(credential, Aws::MakeShared<Aws::S3::S3EndpointProvider>(Aws::S3::S3Client::ALLOCATION_TAG), clientConfig); Aws::String url = s3Client.GeneratePresignedUrl("<Bucket>", "<ObjectName>", Aws::Http::HttpMethod::HTTP_PUT); std::cout << url << std::endl; } Aws::ShutdownAPI(options); return 0; } 这段代码将生成一个经过预先签名的客户端上传 URL，有效期为 7 天，客户端可以在有效时间内对该 URL 发送 HTTP PUT 请求将文件上传。 以下是用 curl 上传文件的案例： curl -X PUT --upload-file "<path/to/file>" "<presigned url>" 您也可以自行指定上传凭证的有效期，例如： #include <aws/core/Aws.h> #include <aws/core/auth/AWSCredentials.h> #include <aws/s3/S3Client.h> int main() { Aws::SDKOptions options; Aws::InitAPI(options); { const Aws::Auth::AWSCredentials credential("<QINIU_ACCESS_KEY>", "<QINIU_SECRET_KEY>"); Aws::Client::ClientConfiguration clientConfig; clientConfig.endpointOverride = "https://s3.cn-east-1.qiniucs.com"; // 华东-浙江区 endpoint clientConfig.region = "cn-east-1"; // 华东-浙江区 region id Aws::S3::S3Client s3Client(credential, Aws::MakeShared<Aws::S3::S3EndpointProvider>(Aws::S3::S3Client::ALLOCATION_TAG), clientConfig); Aws::String url = s3Client.GeneratePresignedUrl("<Bucket>", "<ObjectName>", Aws::Http::HttpMethod::HTTP_PUT, 3600); // 有效期为一小时 std::cout << url << std::endl; } Aws::ShutdownAPI(options); return 0; } ## 服务器端直传 ### 单请求上传（文件） 创建 `src/main.cpp` #include <aws/core/Aws.h> #include <aws/core/auth/AWSCredentials.h> #include <aws/s3/S3Client.h> #include <aws/s3/model/PutObjectRequest.h> #include <iostream> #include <fstream> int main() { Aws::SDKOptions options; Aws::InitAPI(options); { const Aws::Auth::AWSCredentials credential("<AccessKey>", "<SecretKey>"); Aws::Client::ClientConfiguration clientConfig; clientConfig.endpointOverride = "https://s3.cn-east-1.qiniucs.com"; // 华东-浙江区 endpoint clientConfig.region = "cn-east-1"; // 华东-浙江区 region id Aws::S3::S3Client s3Client(credential, Aws::MakeShared<Aws::S3::S3EndpointProvider>(Aws::S3::S3Client::ALLOCATION_TAG), clientConfig); Aws::S3::Model::PutObjectRequest putObjectRequest; putObjectRequest.SetBucket("<Bucket>"); putObjectRequest.SetKey("<Key>"); std::shared_ptr<Aws::IOStream> requestBody = Aws::MakeShared<Aws::FStream>("PutObjectAllocationTag", "<path/to/upload>", std::ios_base::in | std::ios_base::binary); if (!*requestBody) { std::cerr << "Error: open file: " << strerror(errno) << std::endl; goto fail; } putObjectRequest.SetBody(requestBody); Aws::S3::Model::PutObjectOutcome putObjectOutcome = s3Client.PutObject(putObjectRequest); if (!putObjectOutcome.IsSuccess()) { std::cerr << "Error: PutObject: " << putObjectOutcome.GetError().GetMessage() << std::endl; // 上传错误，输出错误信息 } else { std::cout << "ETag: " << putObjectOutcome.GetResult().GetETag() << std::endl; // 上传成功，打印 ETag } } fail: Aws::ShutdownAPI(options); return 0; } ### 单请求上传（数据流） 创建 `src/main.cpp` #include <aws/core/Aws.h> #include <aws/core/auth/AWSCredentials.h> #include <aws/s3/S3Client.h> #include <aws/s3/model/PutObjectRequest.h> #include <iostream> #include <fstream> int main() { Aws::SDKOptions options; Aws::InitAPI(options); { const Aws::Auth::AWSCredentials credential("<AccessKey>", "<SecretKey>"); Aws::Client::ClientConfiguration clientConfig; clientConfig.endpointOverride = "https://s3.cn-east-1.qiniucs.com"; // 华东-浙江区 endpoint clientConfig.region = "cn-east-1"; // 华东-浙江区 region id Aws::S3::S3Client s3Client(credential, Aws::MakeShared<Aws::S3::S3EndpointProvider>(Aws::S3::S3Client::ALLOCATION_TAG), clientConfig); Aws::S3::Model::PutObjectRequest putObjectRequest; putObjectRequest.SetBucket("<Bucket>"); putObjectRequest.SetKey("<Key>"); std::shared_ptr<Aws::IOStream> requestBody = Aws::MakeShared<Aws::StringStream>(""); // 这里用 Aws::StringStream 来模拟 Aws::IOStream 实例 *requestBody << "Hello Qiniu S3!"; putObjectRequest.SetBody(requestBody); Aws::S3::Model::PutObjectOutcome putObjectOutcome = s3Client.PutObject(putObjectRequest); if (!putObjectOutcome.IsSuccess()) { std::cerr << "Error: PutObject: " << putObjectOutcome.GetError().GetMessage() << std::endl; // 上传错误，输出错误信息 } else { std::cout << "ETag: " << putObjectOutcome.GetResult().GetETag() << std::endl; // 上传成功，打印 ETag } } Aws::ShutdownAPI(options); return 0; } ### 分片上传（文件） 创建 `src/main.cpp` #include <aws/core/Aws.h> #include <aws/core/auth/AWSCredentials.h> #include <aws/s3/S3Client.h> #include <aws/s3/model/CompletedPart.h> #include <aws/s3/model/CompleteMultipartUploadRequest.h> #include <aws/s3/model/CreateMultipartUploadRequest.h> #include <aws/s3/model/UploadPartRequest.h> #include <fstream> #include <sstream> #include <string> static std::size_t read_bytes(std::istream &in, char *buf, std::size_t len) { std::size_t n = 0; while (len > 0 && in.good()) { in.read(&buf[n], len); int i = in.gcount(); n += i; len -= i; } return n; } int main() { Aws::SDKOptions options; Aws::InitAPI(options); { const Aws::Auth::AWSCredentials credential("<AccessKey>", "<SecretKey>"); Aws::Client::ClientConfiguration clientConfig; clientConfig.endpointOverride = "https://s3.cn-east-1.qiniucs.com"; // 华东-浙江区 endpoint clientConfig.region = "cn-east-1"; // 华东-浙江区 region id Aws::S3::S3Client s3Client(credential, Aws::MakeShared<Aws::S3::S3EndpointProvider>(Aws::S3::S3Client::ALLOCATION_TAG), clientConfig); std::shared_ptr<Aws::IOStream> file = Aws::MakeShared<Aws::FStream>("PutObjectAllocationTag", "<path/to/upload>", std::ios_base::in | std::ios_base::binary); if (!*file) { std::cerr << "Error: open file: " << strerror(errno) << std::endl; goto fail; } Aws::S3::Model::CreateMultipartUploadRequest createMultipartUploadRequest; createMultipartUploadRequest.SetBucket("<Bucket>"); createMultipartUploadRequest.SetKey("<Key>"); Aws::S3::Model::CreateMultipartUploadOutcome createMultipartUploadOutcome = s3Client.CreateMultipartUpload(createMultipartUploadRequest); if (!createMultipartUploadOutcome.IsSuccess()) { std::cerr << "CreateMultipartUpload Error:" << createMultipartUploadOutcome.GetError().GetMessage() << std::endl; goto fail; } const long long PART_SIZE = 5 * 1024 * 1024; // 分片大小为 5 MB long long partSize = PART_SIZE; Aws::Vector<Aws::S3::Model::CompletedPart> parts; // 这里给出的案例是串行分片上传。可以自行改造成并行分片上传以进一步提升上传速度 for (long long uploaded = 0, partNumber = 1;; uploaded += partSize, partNumber++) { std::vector<char> bytes(partSize); std::size_t haveRead = read_bytes(*file, bytes.data(), partSize); if (haveRead == 0) { break; } Aws::S3::Model::UploadPartRequest uploadPartRequest; uploadPartRequest.SetUploadId(createMultipartUploadOutcome.GetResult().GetUploadId()); uploadPartRequest.SetPartNumber(partNumber); uploadPartRequest.SetBucket(createMultipartUploadRequest.GetBucket()); uploadPartRequest.SetKey(createMultipartUploadRequest.GetKey()); uploadPartRequest.SetBody(Aws::MakeShared<Aws::StringStream>("UploadPartAllocationTag", std::string(bytes.data(), haveRead))); Aws::S3::Model::UploadPartOutcome uploadPartOutcome = s3Client.UploadPart(uploadPartRequest); if (!uploadPartOutcome.IsSuccess()) { std::cerr << "UploadPart Error:" << uploadPartOutcome.GetError().GetMessage() << std::endl; goto fail; } Aws::S3::Model::CompletedPart completedPart; completedPart.SetETag(uploadPartOutcome.GetResult().GetETag()); completedPart.SetPartNumber(partNumber); parts.push_back(completedPart); } Aws::S3::Model::CompletedMultipartUpload completedMultipartUpload; completedMultipartUpload.SetParts(parts); Aws::S3::Model::CompleteMultipartUploadRequest completeMultipartUploadRequest; completeMultipartUploadRequest.SetBucket(createMultipartUploadRequest.GetBucket()); completeMultipartUploadRequest.SetKey(createMultipartUploadRequest.GetKey()); completeMultipartUploadRequest.SetUploadId(createMultipartUploadOutcome.GetResult().GetUploadId()); completeMultipartUploadRequest.SetMultipartUpload(completedMultipartUpload); Aws::S3::Model::CompleteMultipartUploadOutcome completeMultipartUploadOutcome = s3Client.CompleteMultipartUpload(completeMultipartUploadRequest); if (!completeMultipartUploadOutcome.IsSuccess()) { std::cerr << "CompleteMultipartUpload Error:" << completeMultipartUploadOutcome.GetError().GetMessage() << std::endl; goto fail; } std::cout << "Etag: " << completeMultipartUploadOutcome.GetResult().GetETag() << std::endl; // 复制成功 } fail: Aws::ShutdownAPI(options); return 0; } ### 上传文件 创建 `src/main.cpp` #include <aws/core/Aws.h> #include <aws/core/auth/AWSCredentials.h> #include <aws/s3/S3Client.h> #include <aws/transfer/TransferManager.h> #include <iostream> #include <fstream> int main() { Aws::SDKOptions options; Aws::InitAPI(options); { const Aws::Auth::AWSCredentials credential("<AccessKey>", "<SecretKey>"); Aws::Client::ClientConfiguration clientConfig; clientConfig.endpointOverride = "https://s3.cn-east-1.qiniucs.com"; // 华东-浙江区 endpoint clientConfig.region = "cn-east-1"; // 华东-浙江区 region id std::shared_ptr<Aws::S3::S3Client> s3Client = Aws::MakeShared<Aws::S3::S3Client>("S3Client", credential, Aws::MakeShared<Aws::S3::S3EndpointProvider>(Aws::S3::S3Client::ALLOCATION_TAG), clientConfig); std::shared_ptr<Aws::Utils::Threading::Executor> executor = Aws::MakeShared<Aws::Utils::Threading::PooledThreadExecutor>("executor", 5); Aws::Transfer::TransferManagerConfiguration transferConfig(executor.get()); transferConfig.s3Client = s3Client; std::shared_ptr<Aws::Transfer::TransferManager> transferManager = Aws::Transfer::TransferManager::Create(transferConfig); std::shared_ptr<Aws::IOStream> requestBody = Aws::MakeShared<Aws::FStream>("PutObjectAllocationTag", "<path/to/upload>", std::ios_base::in | std::ios_base::binary); if (!*requestBody) { std::cerr << "Error: open file: " << strerror(errno) << std::endl; goto fail; } std::shared_ptr<Aws::Transfer::TransferHandle> uploadHandle = transferManager->UploadFile(requestBody, "<Bucket>", "<Key>", "<ContentType>", Aws::Map<Aws::String, Aws::String>()); uploadHandle->WaitUntilFinished(); if (uploadHandle->GetStatus() != Aws::Transfer::TransferStatus::COMPLETED) { std::cerr << "Error: TransferManager: " << uploadHandle->GetLastError().GetMessage() << std::endl; } else { std::cout << "Size: " << uploadHandle->GetBytesTotalSize() << std::endl; } } Aws::ShutdownAPI(options); return 0; } ### 上传目录 创建 `src/main.cpp` #include <aws/core/Aws.h> #include <aws/core/auth/AWSCredentials.h> #include <aws/s3/S3Client.h> #include <aws/transfer/TransferManager.h> #include <iostream> #include <fstream> int main() { Aws::SDKOptions options; options.loggingOptions.logLevel = Aws::Utils::Logging::LogLevel::Info; Aws::InitAPI(options); { const Aws::Auth::AWSCredentials credential("<AccessKey>", "<SecretKey>"); Aws::Client::ClientConfiguration clientConfig; clientConfig.endpointOverride = "https://s3.cn-east-1.qiniucs.com"; // 华东-浙江区 endpoint clientConfig.region = "cn-east-1"; // 华东-浙江区 region id std::shared_ptr<Aws::S3::S3Client> s3Client = Aws::MakeShared<Aws::S3::S3Client>("S3Client", credential, Aws::MakeShared<Aws::S3::S3EndpointProvider>(Aws::S3::S3Client::ALLOCATION_TAG), clientConfig); std::shared_ptr<Aws::Utils::Threading::Executor> executor = Aws::MakeShared<Aws::Utils::Threading::PooledThreadExecutor>("executor", 5); Aws::Transfer::TransferManagerConfiguration transferConfig(executor.get()); transferConfig.s3Client = s3Client; transferConfig.transferInitiatedCallback = [](const Aws::Transfer::TransferManager *, const std::shared_ptr<const Aws::Transfer::TransferHandle> &) {}; transferConfig.errorCallback = [](const Aws::Transfer::TransferManager *, const std::shared_ptr<const Aws::Transfer::TransferHandle> &handle, const Aws::Client::AWSError<Aws::S3::S3Errors> &error) { std::cout << "Error: " << handle->GetBucketName() << "/" << handle->GetKey() << ": " << error.GetMessage() << std::endl; }; std::shared_ptr<Aws::Transfer::TransferManager> transferManager = Aws::Transfer::TransferManager::Create(transferConfig); transferManager->UploadDirectory("<path/to/upload>", "<Bucket>", "<KeyPrefix>", Aws::Http::HeaderValueCollection()); Aws::Transfer::TransferStatus status = transferManager->WaitUntilAllFinished(); if (status == Aws::Transfer::TransferStatus::COMPLETED) { std::cout << "Done" << std::endl; } else { std::cerr << "Error: " << status << std::endl; } } Aws::ShutdownAPI(options); return 0; } # 对象下载 ## 获取客户端下载 URL 创建 `src/main.cpp` #include <aws/core/Aws.h> #include <aws/core/auth/AWSCredentials.h> #include <aws/s3/S3Client.h> int main() { Aws::SDKOptions options; Aws::InitAPI(options); { const Aws::Auth::AWSCredentials credential("<QINIU_ACCESS_KEY>", "<QINIU_SECRET_KEY>"); Aws::Client::ClientConfiguration clientConfig; clientConfig.endpointOverride = "https://s3.cn-east-1.qiniucs.com"; // 华东-浙江区 endpoint clientConfig.region = "cn-east-1"; // 华东-浙江区 region id Aws::S3::S3Client s3Client(credential, Aws::MakeShared<Aws::S3::S3EndpointProvider>(Aws::S3::S3Client::ALLOCATION_TAG), clientConfig); Aws::String url = s3Client.GeneratePresignedUrl("<Bucket>", "<ObjectName>", Aws::Http::HttpMethod::HTTP_GET); std::cout << url << std::endl; } Aws::ShutdownAPI(options); return 0; } 这段代码将生成一个经过预先签名的客户端下载 URL，有效期为 7 天，客户端可以在有效时间内对该 URL 发送 HTTP GET 请求将文件下载。 以下是用 curl 下载文件的案例： curl -o "<path/to/download>" "<presigned url>" 您也可以自行指定下载凭证的有效期，例如： #include <aws/core/Aws.h> #include <aws/core/auth/AWSCredentials.h> #include <aws/s3/S3Client.h> int main() { Aws::SDKOptions options; Aws::InitAPI(options); { const Aws::Auth::AWSCredentials credential("<QINIU_ACCESS_KEY>", "<QINIU_SECRET_KEY>"); Aws::Client::ClientConfiguration clientConfig; clientConfig.endpointOverride = "https://s3.cn-east-1.qiniucs.com"; // 华东-浙江区 endpoint clientConfig.region = "cn-east-1"; // 华东-浙江区 region id Aws::S3::S3Client s3Client(credential, Aws::MakeShared<Aws::S3::S3EndpointProvider>(Aws::S3::S3Client::ALLOCATION_TAG), clientConfig); Aws::String url = s3Client.GeneratePresignedUrl("<Bucket>", "<Key>", Aws::Http::HttpMethod::HTTP_GET, 3600); // 有效期为一小时 std::cout << url << std::endl; } Aws::ShutdownAPI(options); return 0; } ## 服务器端直接下载 创建 `src/main.cpp` #include <aws/core/Aws.h> #include <aws/core/auth/AWSCredentials.h> #include <aws/s3/S3Client.h> #include <aws/s3/model/GetObjectRequest.h> #include <fstream> static std::streamsize copy(std::istream &in, std::ostream &out) { std::vector<char> bytes(32 * 1024); std::streamsize have_copied = 0; while (in.good() && out.good()) { in.read(bytes.data(), bytes.size()); std::streamsize have_read = in.gcount(); have_copied += have_read; out.write(bytes.data(), have_read); } return have_copied; } int main() { Aws::SDKOptions options; Aws::InitAPI(options); { const Aws::Auth::AWSCredentials credential("<QINIU_ACCESS_KEY>", "<QINIU_SECRET_KEY>"); Aws::Client::ClientConfiguration clientConfig; clientConfig.endpointOverride = "https://s3.cn-east-1.qiniucs.com"; // 华东-浙江区 endpoint clientConfig.region = "cn-east-1"; // 华东-浙江区 region id std::shared_ptr<Aws::IOStream> file = Aws::MakeShared<Aws::FStream>("GetObjectAllocationTag", "<path/to/download>", std::ios_base::out | std::ios_base::binary); if (!*file) { std::cerr << "Error: open file: " << strerror(errno) << std::endl; goto fail; } Aws::S3::S3Client s3Client(credential, Aws::MakeShared<Aws::S3::S3EndpointProvider>(Aws::S3::S3Client::ALLOCATION_TAG), clientConfig); Aws::S3::Model::GetObjectRequest getObjectRequest; getObjectRequest.SetBucket("<Bucket>"); getObjectRequest.SetKey("<Key>"); Aws::S3::Model::GetObjectOutcome getObjectOutcome = s3Client.GetObject(getObjectRequest); if (!getObjectOutcome.IsSuccess()) { std::cerr << "Error: GetObject: " << getObjectOutcome.GetError().GetMessage() << std::endl; // 下载错误，输出错误信息 } else { copy(getObjectOutcome.GetResult().GetBody(), *file); std::cout << "ETag: " << getObjectOutcome.GetResult().GetETag() << std::endl; // 下载成功，打印 ETag } } fail: Aws::ShutdownAPI(options); return 0; } ## 下载文件 创建 `src/main.cpp` #include <aws/core/Aws.h> #include <aws/core/auth/AWSCredentials.h> #include <aws/s3/S3Client.h> #include <aws/transfer/TransferManager.h> #include <iostream> #include <fstream> int main() { Aws::SDKOptions options; Aws::InitAPI(options); { const Aws::Auth::AWSCredentials credential("<AccessKey>", "<SecretKey>"); Aws::Client::ClientConfiguration clientConfig; clientConfig.endpointOverride = "https://s3.cn-east-1.qiniucs.com"; // 华东-浙江区 endpoint clientConfig.region = "cn-east-1"; // 华东-浙江区 region id std::shared_ptr<Aws::S3::S3Client> s3Client = Aws::MakeShared<Aws::S3::S3Client>("S3Client", credential, Aws::MakeShared<Aws::S3::S3EndpointProvider>(Aws::S3::S3Client::ALLOCATION_TAG), clientConfig); std::shared_ptr<Aws::Utils::Threading::Executor> executor = Aws::MakeShared<Aws::Utils::Threading::PooledThreadExecutor>("executor", 5); Aws::Transfer::TransferManagerConfiguration transferConfig(executor.get()); transferConfig.s3Client = s3Client; std::shared_ptr<Aws::Transfer::TransferManager> transferManager = Aws::Transfer::TransferManager::Create(transferConfig); std::shared_ptr<Aws::Transfer::TransferHandle> downloadHandle = transferManager->DownloadFile("<Bucket>", "<Key>", "<path/to/download>"); downloadHandle->WaitUntilFinished(); if (downloadHandle->GetStatus() != Aws::Transfer::TransferStatus::COMPLETED) { std::cerr << "Error: TransferManager: " << downloadHandle->GetLastError().GetMessage() << std::endl; } else { std::cout << "Size: " << downloadHandle->GetBytesTotalSize() << std::endl; } } Aws::ShutdownAPI(options); return 0; } ## 下载目录 创建 `src/main.cpp` #include <aws/core/Aws.h> #include <aws/core/auth/AWSCredentials.h> #include <aws/s3/S3Client.h> #include <aws/transfer/TransferManager.h> int main() { Aws::SDKOptions options; Aws::InitAPI(options); { const Aws::Auth::AWSCredentials credential("<QINIU_ACCESS_KEY>", "<QINIU_SECRET_KEY>"); Aws::Client::ClientConfiguration clientConfig; clientConfig.endpointOverride = "https://s3.cn-east-1.qiniucs.com"; // 华东-浙江区 endpoint clientConfig.region = "cn-east-1"; // 华东-浙江区 region id std::shared_ptr<Aws::S3::S3Client> s3Client = Aws::MakeShared<Aws::S3::S3Client>("S3Client", credential, Aws::MakeShared<Aws::S3::S3EndpointProvider>(Aws::S3::S3Client::ALLOCATION_TAG), clientConfig); std::shared_ptr<Aws::Utils::Threading::Executor> executor = Aws::MakeShared<Aws::Utils::Threading::PooledThreadExecutor>("executor", 5); Aws::Transfer::TransferManagerConfiguration transferConfig(executor.get()); transferConfig.s3Client = s3Client; transferConfig.transferInitiatedCallback = [](const Aws::Transfer::TransferManager *, const std::shared_ptr<const Aws::Transfer::TransferHandle> &) {}; transferConfig.errorCallback = [](const Aws::Transfer::TransferManager *, const std::shared_ptr<const Aws::Transfer::TransferHandle> &handle, const Aws::Client::AWSError<Aws::S3::S3Errors> &error) { std::cout << "Error: " << handle->GetBucketName() << "/" << handle->GetKey() << ": " << error.GetMessage() << std::endl; }; std::shared_ptr<Aws::Transfer::TransferManager> transferManager = Aws::Transfer::TransferManager::Create(transferConfig); transferManager->DownloadToDirectory("<path/to/download>", "<Bucket>", "<KeyPrefix>"); Aws::Transfer::TransferStatus status = transferManager->WaitUntilAllFinished(); if (status == Aws::Transfer::TransferStatus::COMPLETED) { std::cout << "Done" << std::endl; } else { std::cerr << "Error" << std::endl; } } Aws::ShutdownAPI(options); return 0; } # 对象管理 ## 获取对象信息 创建 `src/main.cpp` #include <aws/core/Aws.h> #include <aws/core/auth/AWSCredentials.h> #include <aws/s3/S3Client.h> #include <aws/s3/model/HeadObjectRequest.h> int main() { Aws::SDKOptions options; Aws::InitAPI(options); { const Aws::Auth::AWSCredentials credential("<QINIU_ACCESS_KEY>", "<QINIU_SECRET_KEY>"); Aws::Client::ClientConfiguration clientConfig; clientConfig.endpointOverride = "https://s3.cn-east-1.qiniucs.com"; // 华东-浙江区 endpoint clientConfig.region = "cn-east-1"; // 华东-浙江区 region id Aws::S3::S3Client s3Client(credential, Aws::MakeShared<Aws::S3::S3EndpointProvider>(Aws::S3::S3Client::ALLOCATION_TAG), clientConfig); Aws::S3::Model::HeadObjectRequest headObjectRequest; headObjectRequest.SetBucket("<Bucket>"); headObjectRequest.SetKey("<Key>"); Aws::S3::Model::HeadObjectOutcome headObjectOutcome = s3Client.HeadObject(headObjectRequest); if (!headObjectOutcome.IsSuccess()) { std::cerr << "Error: HeadObject: " << headObjectOutcome.GetError().GetMessage() << std::endl; // 下载错误，输出错误信息 } else { std::cout << "ETag: " << headObjectOutcome.GetResult().GetETag() << std::endl; // 获取成功，打印 ETag } } Aws::ShutdownAPI(options); return 0; } ## 修改对象 MimeType 创建 `src/main.cpp` #include <aws/core/Aws.h> #include <aws/core/auth/AWSCredentials.h> #include <aws/s3/S3Client.h> #include <aws/s3/model/CopyObjectRequest.h> int main() { Aws::SDKOptions options; Aws::InitAPI(options); { const Aws::Auth::AWSCredentials credential("<QINIU_ACCESS_KEY>", "<QINIU_SECRET_KEY>"); Aws::Client::ClientConfiguration clientConfig; clientConfig.endpointOverride = "https://s3.cn-east-1.qiniucs.com"; // 华东-浙江区 endpoint clientConfig.region = "cn-east-1"; // 华东-浙江区 region id Aws::S3::S3Client s3Client(credential, Aws::MakeShared<Aws::S3::S3EndpointProvider>(Aws::S3::S3Client::ALLOCATION_TAG), clientConfig); Aws::S3::Model::CopyObjectRequest copyObjectRequest; copyObjectRequest.SetBucket("<Bucket>"); copyObjectRequest.SetKey("<Key>"); copyObjectRequest.SetCopySource("/<Bucket>/<Key>"); copyObjectRequest.SetMetadataDirective(Aws::S3::Model::MetadataDirective::REPLACE); copyObjectRequest.SetContentType("<NewContentType>"); Aws::S3::Model::CopyObjectOutcome copyObjectOutcome = s3Client.CopyObject(copyObjectRequest); if (!copyObjectOutcome.IsSuccess()) { std::cerr << "Error: CopyObject: " << copyObjectOutcome.GetError().GetMessage() << std::endl; // 修改错误，输出错误信息 } else { std::cout << "Done" << std::endl; // 修改成功 } } Aws::ShutdownAPI(options); return 0; } ## 修改对象存储类型 创建 `src/main.cpp` #include <aws/core/Aws.h> #include <aws/core/auth/AWSCredentials.h> #include <aws/s3/S3Client.h> #include <aws/s3/model/CopyObjectRequest.h> int main() { Aws::SDKOptions options; Aws::InitAPI(options); { const Aws::Auth::AWSCredentials credential("<QINIU_ACCESS_KEY>", "<QINIU_SECRET_KEY>"); Aws::Client::ClientConfiguration clientConfig; clientConfig.endpointOverride = "https://s3.cn-east-1.qiniucs.com"; // 华东-浙江区 endpoint clientConfig.region = "cn-east-1"; // 华东-浙江区 region id Aws::S3::S3Client s3Client(credential, Aws::MakeShared<Aws::S3::S3EndpointProvider>(Aws::S3::S3Client::ALLOCATION_TAG), clientConfig); Aws::S3::Model::CopyObjectRequest copyObjectRequest; copyObjectRequest.SetBucket("<Bucket>"); copyObjectRequest.SetKey("<Key>"); copyObjectRequest.SetCopySource("/<Bucket>/<Key>"); copyObjectRequest.SetMetadataDirective(Aws::S3::Model::MetadataDirective::COPY); copyObjectRequest.SetStorageClass(Aws::S3::Model::StorageClass::GLACIER); Aws::S3::Model::CopyObjectOutcome copyObjectOutcome = s3Client.CopyObject(copyObjectRequest); if (!copyObjectOutcome.IsSuccess()) { std::cerr << "Error: CopyObject: " << copyObjectOutcome.GetError().GetMessage() << std::endl; // 修改错误，输出错误信息 } else { std::cout << "Done" << std::endl; // 修改成功 } } Aws::ShutdownAPI(options); return 0; } ## 复制对象副本 创建 `src/main.cpp` #include <aws/core/Aws.h> #include <aws/core/auth/AWSCredentials.h> #include <aws/s3/S3Client.h> #include <aws/s3/model/CopyObjectRequest.h> int main() { Aws::SDKOptions options; Aws::InitAPI(options); { const Aws::Auth::AWSCredentials credential("<QINIU_ACCESS_KEY>", "<QINIU_SECRET_KEY>"); Aws::Client::ClientConfiguration clientConfig; clientConfig.endpointOverride = "https://s3.cn-east-1.qiniucs.com"; // 华东-浙江区 endpoint clientConfig.region = "cn-east-1"; // 华东-浙江区 region id Aws::S3::S3Client s3Client(credential, Aws::MakeShared<Aws::S3::S3EndpointProvider>(Aws::S3::S3Client::ALLOCATION_TAG), clientConfig); Aws::S3::Model::CopyObjectRequest copyObjectRequest; copyObjectRequest.SetBucket("<ToBucket>"); copyObjectRequest.SetKey("<ToKey>"); copyObjectRequest.SetCopySource("/<FromBucket>/<FromKey>"); copyObjectRequest.SetMetadataDirective(Aws::S3::Model::MetadataDirective::COPY); Aws::S3::Model::CopyObjectOutcome copyObjectOutcome = s3Client.CopyObject(copyObjectRequest); if (!copyObjectOutcome.IsSuccess()) { std::cerr << "Error: CopyObject: " << copyObjectOutcome.GetError().GetMessage() << std::endl; // 修改错误，输出错误信息 } else { std::cout << "Done" << std::endl; // 修改成功 } } Aws::ShutdownAPI(options); return 0; } ## 复制对象副本（大于 5GB） 创建 `src/main.cpp` #include <aws/core/Aws.h> #include <aws/core/auth/AWSCredentials.h> #include <aws/s3/S3Client.h> #include <aws/s3/model/CompletedPart.h> #include <aws/s3/model/CompleteMultipartUploadRequest.h> #include <aws/s3/model/CreateMultipartUploadRequest.h> #include <aws/s3/model/HeadObjectRequest.h> #include <aws/s3/model/UploadPartCopyRequest.h> #include <algorithm> int main() { Aws::SDKOptions options; Aws::InitAPI(options); { const Aws::Auth::AWSCredentials credential("<QINIU_ACCESS_KEY>", "<QINIU_SECRET_KEY>"); Aws::Client::ClientConfiguration clientConfig; clientConfig.endpointOverride = "https://s3.cn-east-1.qiniucs.com"; // 华东-浙江区 endpoint clientConfig.region = "cn-east-1"; // 华东-浙江区 region id Aws::S3::S3Client s3Client(credential, Aws::MakeShared<Aws::S3::S3EndpointProvider>(Aws::S3::S3Client::ALLOCATION_TAG), clientConfig); Aws::S3::Model::HeadObjectRequest headObjectRequest; headObjectRequest.SetBucket("<FromBucket>"); headObjectRequest.SetKey("<FromKey>"); Aws::S3::Model::HeadObjectOutcome headObjectOutcome = s3Client.HeadObject(headObjectRequest); if (!headObjectOutcome.IsSuccess()) { std::cerr << "HeadObject Error:" << headObjectOutcome.GetError().GetMessage() << std::endl; goto fail; } Aws::S3::Model::CreateMultipartUploadRequest createMultipartUploadRequest; createMultipartUploadRequest.SetBucket("<ToBucket>"); createMultipartUploadRequest.SetKey("<ToKey>"); Aws::S3::Model::CreateMultipartUploadOutcome createMultipartUploadOutcome = s3Client.CreateMultipartUpload(createMultipartUploadRequest); if (!createMultipartUploadOutcome.IsSuccess()) { std::cerr << "CreateMultipartUpload Error:" << createMultipartUploadOutcome.GetError().GetMessage() << std::endl; goto fail; } const long long PART_SIZE = 5 * 1024 * 1024; // 分片大小，调整过小会影响复制速度，调整过大可能导致服务器超时 long long partSize = PART_SIZE; Aws::Vector<Aws::S3::Model::CompletedPart> parts; // 这里给出的案例是串行分片复制。可以自行改造成并行分片复制以进一步提升复制速度 for (long long copied = 0, partNumber = 1; copied < headObjectOutcome.GetResult().GetContentLength(); copied += partSize, partNumber++) { partSize = std::min(headObjectOutcome.GetResult().GetContentLength() - copied, PART_SIZE); Aws::S3::Model::UploadPartCopyRequest uploadPartCopyRequest; uploadPartCopyRequest.SetUploadId(createMultipartUploadOutcome.GetResult().GetUploadId()); uploadPartCopyRequest.SetPartNumber(partNumber); uploadPartCopyRequest.SetBucket(createMultipartUploadRequest.GetBucket()); uploadPartCopyRequest.SetKey(createMultipartUploadRequest.GetKey()); Aws::String copySource = "/"; copySource.append(headObjectRequest.GetBucket()).append("/").append(headObjectRequest.GetKey()); uploadPartCopyRequest.SetCopySource(copySource); Aws::String copySourceRange = "bytes="; copySourceRange.append(std::to_string(copied)); copySourceRange.append("-"); copySourceRange.append(std::to_string(copied + partSize - 1)); uploadPartCopyRequest.SetCopySourceRange(copySourceRange); Aws::S3::Model::UploadPartCopyOutcome uploadPartCopyOutcome = s3Client.UploadPartCopy(uploadPartCopyRequest); if (!uploadPartCopyOutcome.IsSuccess()) { std::cerr << "UploadPartCopy Error:" << uploadPartCopyOutcome.GetError().GetMessage() << std::endl; goto fail; } Aws::S3::Model::CompletedPart completedPart; completedPart.SetETag(uploadPartCopyOutcome.GetResult().GetCopyPartResult().GetETag()); completedPart.SetPartNumber(partNumber); parts.push_back(completedPart); } Aws::S3::Model::CompletedMultipartUpload completedMultipartUpload; completedMultipartUpload.SetParts(parts); Aws::S3::Model::CompleteMultipartUploadRequest completeMultipartUploadRequest; completeMultipartUploadRequest.SetBucket(createMultipartUploadRequest.GetBucket()); completeMultipartUploadRequest.SetKey(createMultipartUploadRequest.GetKey()); completeMultipartUploadRequest.SetUploadId(createMultipartUploadOutcome.GetResult().GetUploadId()); completeMultipartUploadRequest.SetMultipartUpload(completedMultipartUpload); Aws::S3::Model::CompleteMultipartUploadOutcome completeMultipartUploadOutcome = s3Client.CompleteMultipartUpload(completeMultipartUploadRequest); if (!completeMultipartUploadOutcome.IsSuccess()) { std::cerr << "CompleteMultipartUpload Error:" << completeMultipartUploadOutcome.GetError().GetMessage() << std::endl; goto fail; } std::cout << "Done" << std::endl; // 复制成功 } fail: Aws::ShutdownAPI(options); return 0; } ## 删除空间中的文件 创建 `src/main.cpp` #include <aws/core/Aws.h> #include <aws/core/auth/AWSCredentials.h> #include <aws/s3/S3Client.h> #include <aws/s3/model/DeleteObjectRequest.h> int main() { Aws::SDKOptions options; Aws::InitAPI(options); { const Aws::Auth::AWSCredentials credential("<QINIU_ACCESS_KEY>", "<QINIU_SECRET_KEY>"); Aws::Client::ClientConfiguration clientConfig; clientConfig.endpointOverride = "https://s3.cn-east-1.qiniucs.com"; // 华东-浙江区 endpoint clientConfig.region = "cn-east-1"; // 华东-浙江区 region id Aws::S3::S3Client s3Client(credential, Aws::MakeShared<Aws::S3::S3EndpointProvider>(Aws::S3::S3Client::ALLOCATION_TAG), clientConfig); Aws::S3::Model::DeleteObjectRequest deleteObjectRequest; deleteObjectRequest.SetBucket("<Bucket>"); deleteObjectRequest.SetKey("<Key>"); Aws::S3::Model::DeleteObjectOutcome deleteObjectOutcome = s3Client.DeleteObject(deleteObjectRequest); if (!deleteObjectOutcome.IsSuccess()) { std::cerr << "Error: DeleteObject: " << deleteObjectOutcome.GetError().GetMessage() << std::endl; // 删除错误，输出错误信息 } else { std::cout << "Done" << std::endl; // 删除成功 } } Aws::ShutdownAPI(options); return 0; } ## 获取指定前缀的文件列表 创建 `src/main.cpp` #include <aws/core/Aws.h> #include <aws/core/auth/AWSCredentials.h> #include <aws/s3/S3Client.h> #include <aws/s3/model/ListObjectsV2Request.h> int main() { Aws::SDKOptions options; Aws::InitAPI(options); { const Aws::Auth::AWSCredentials credential("<QINIU_ACCESS_KEY>", "<QINIU_SECRET_KEY>"); Aws::Client::ClientConfiguration clientConfig; clientConfig.endpointOverride = "https://s3.cn-east-1.qiniucs.com"; // 华东-浙江区 endpoint clientConfig.region = "cn-east-1"; // 华东-浙江区 region id Aws::S3::S3Client s3Client(credential, Aws::MakeShared<Aws::S3::S3EndpointProvider>(Aws::S3::S3Client::ALLOCATION_TAG), clientConfig); Aws::S3::Model::ListObjectsV2Request listObjectsV2Request; listObjectsV2Request.SetBucket("<Bucket>"); listObjectsV2Request.SetPrefix("<KeyPrefix>"); Aws::S3::Model::ListObjectsV2Outcome listObjectsV2Outcome = s3Client.ListObjectsV2(listObjectsV2Request); if (!listObjectsV2Outcome.IsSuccess()) { std::cerr << "Error: ListObjects: " << listObjectsV2Outcome.GetError().GetMessage() << std::endl; // 列举错误，输出错误信息 } else { for (const Aws::S3::Model::Object &object : listObjectsV2Outcome.GetResult().GetContents()) { std::cout << "Key: " << object.GetKey() << std::endl; std::cout << "ETag: " << object.GetETag() << std::endl; } } } Aws::ShutdownAPI(options); return 0; } ## 批量删除空间中的文件 创建 `src/main.cpp` #include <aws/core/Aws.h> #include <aws/core/auth/AWSCredentials.h> #include <aws/s3/S3Client.h> #include <aws/s3/model/DeleteObjectsRequest.h> int main() { Aws::SDKOptions options; Aws::InitAPI(options); { const Aws::Auth::AWSCredentials credential("<QINIU_ACCESS_KEY>", "<QINIU_SECRET_KEY>"); Aws::Client::ClientConfiguration clientConfig; clientConfig.endpointOverride = "https://s3.cn-east-1.qiniucs.com"; // 华东-浙江区 endpoint clientConfig.region = "cn-east-1"; // 华东-浙江区 region id Aws::S3::S3Client s3Client(credential, Aws::MakeShared<Aws::S3::S3EndpointProvider>(Aws::S3::S3Client::ALLOCATION_TAG), clientConfig); Aws::S3::Model::Delete deleteRequest; deleteRequest.AddObjects(Aws::S3::Model::ObjectIdentifier().WithKey("<Key1>")); deleteRequest.AddObjects(Aws::S3::Model::ObjectIdentifier().WithKey("<Key2>")); deleteRequest.AddObjects(Aws::S3::Model::ObjectIdentifier().WithKey("<Key3>")); deleteRequest.AddObjects(Aws::S3::Model::ObjectIdentifier().WithKey("<Key4>")); deleteRequest.AddObjects(Aws::S3::Model::ObjectIdentifier().WithKey("<Key5>")); Aws::S3::Model::DeleteObjectsRequest deleteObjectsRequest; deleteObjectsRequest.SetBucket("<Bucket>"); deleteObjectsRequest.SetDelete(deleteRequest); Aws::S3::Model::DeleteObjectsOutcome deleteObjectsOutcome = s3Client.DeleteObjects(deleteObjectsRequest); if (!deleteObjectsOutcome.IsSuccess()) { std::cerr << "Error: DeleteObjects: " << deleteObjectsOutcome.GetError().GetMessage() << std::endl; // 删除错误，输出错误信息 } else { for (const Aws::S3::Model::DeletedObject &object : deleteObjectsOutcome.GetResult().GetDeleted()) { std::cout << "Deleted: " << object.GetKey() << std::endl; } for (const Aws::S3::Model::Error &error : deleteObjectsOutcome.GetResult().GetErrors()) { std::cout << "Error: " << error.GetMessage() << std::endl; } } } Aws::ShutdownAPI(options); return 0; } # 临时安全凭证 创建 `src/main.cpp` #include <aws/core/Aws.h> #include <aws/core/auth/AWSCredentials.h> #include <aws/core/auth/AWSCredentialsProvider.h> #include <aws/s3/S3Client.h> #include <aws/sts/STSClient.h> #include <aws/sts/model/GetFederationTokenRequest.h> #include <aws/crt/Optional.h> class STSCredentialsProvider : public Aws::Auth::AWSCredentialsProvider { public: STSCredentialsProvider(const Aws::Auth::AWSCredentials &credentials, const Aws::STS::STSClientConfiguration &clientConfiguration = Aws::STS::STSClientConfiguration()) : Aws::Auth::AWSCredentialsProvider(), stsClient(credentials, Aws::MakeShared<Aws::STS::STSEndpointProvider>(Aws::STS::STSClient::ALLOCATION_TAG), clientConfiguration) { } virtual ~STSCredentialsProvider() = default; virtual Aws::Auth::AWSCredentials GetAWSCredentials() override { if (!credentials.has_value() || credentials->IsExpired()) { Reload(); return *credentials; } else { return *credentials; } } protected: virtual void Reload() override { Aws::STS::Model::GetFederationTokenRequest getFederationTokenRequest; getFederationTokenRequest.SetName("Bob"); getFederationTokenRequest.SetDurationSeconds(3600); getFederationTokenRequest.SetPolicy("{\"Version\":\"2012-10-17\",\"Statement\":[{\"Sid\":\"Stmt1\",\"Effect\":\"Allow\",\"Action\":[\"*\"],\"Resource\":[\"*\"]}]}"); Aws::STS::Model::GetFederationTokenOutcome getFederationTokenOutcome = stsClient.GetFederationToken(getFederationTokenRequest); if (getFederationTokenOutcome.IsSuccess()) { const Aws::STS::Model::Credentials stsCredentials = std::move(getFederationTokenOutcome.GetResult().GetCredentials()); credentials = Aws::Auth::AWSCredentials(stsCredentials.GetAccessKeyId(), stsCredentials.GetSecretAccessKey(), stsCredentials.GetSessionToken(), stsCredentials.GetExpiration()); Aws::Auth::AWSCredentialsProvider::Reload(); } else { std::cerr << "Error: GetFederationToken: " << getFederationTokenOutcome.GetError().GetMessage() << std::endl; } } private: Aws::STS::STSClient stsClient; Aws::Crt::Optional<Aws::Auth::AWSCredentials> credentials; }; int main() { Aws::SDKOptions options; Aws::InitAPI(options); { const Aws::Auth::AWSCredentials credential("<QINIU_ACCESS_KEY>", "<QINIU_SECRET_KEY>"); Aws::Client::ClientConfiguration clientConfig; clientConfig.endpointOverride = "https://s3.cn-east-1.qiniucs.com"; // 华东-浙江区 endpoint clientConfig.region = "cn-east-1"; // 华东-浙江区 region id const std::shared_ptr<Aws::Auth::AWSCredentialsProvider> stsCredentialsProvider = Aws::MakeShared<STSCredentialsProvider>("STSCredentialsProviderTag", credential, clientConfig); const Aws::S3::S3Client s3Client(stsCredentialsProvider, Aws::MakeShared<Aws::S3::S3EndpointProvider>(Aws::S3::S3Client::ALLOCATION_TAG), clientConfig); // 可以使用这些临时凭证调用 S3 服务 const Aws::S3::Model::ListBucketsOutcome listBucketsOutcome = s3Client.ListBuckets(); if (listBucketsOutcome.IsSuccess()) { for (const Aws::S3::Model::Bucket bucket : listBucketsOutcome.GetResult().GetBuckets()) { std::cout << bucket.GetName() << std::endl; } } else { std::cerr << "ListBuckets Error:" << listBucketsOutcome.GetError().GetMessage() << std::endl; goto fail; } } fail: Aws::ShutdownAPI(options); return 0; } 以上内容是否对您有帮助？

AWS SDK for .NET

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [开发指南](https://developer.qiniu.com/kodo/development_guidelines/8596/development- guidelines) > [AWS S3 兼容](https://developer.qiniu.com/kodo/development_guidelines/4086/aws-s3-compatible) > [兼容 SDK 示例](https://developer.qiniu.com/kodo/development_guidelines/12553/S3 SDK sample) > AWS SDK for .NET # AWS SDK for .NET 最近更新时间: 2024-02-19 17:11:27 # 导入 AWS SDK for .NET 确保 Microsoft .NET Core SDK, version 2.1, 3.1 或更新版本已经安装，包含 .NET 命令行工具以及 .NET Core 运行时。 执行以下命令创建 .NET 项目 dotnet new console --name S3QiniuExamples 然后添加 AWS SDK for .NET 包 dotnet add S3QiniuExamples package AWSSDK.S3 --version 3.7.305.22 dotnet add S3QiniuExamples package AWSSDK.SecurityToken --version 3.7.300.47 对于之后的每个代码示例，将代码创建在 `Program.cs` 后，执行 dotnet run --project S3QiniuExamples 即可执行代码。 # 对象上传 ## 获取客户端上传 URL 创建 `Program.cs` using Amazon.Runtime; using Amazon.S3; using Amazon.S3.Model; namespace S3QiniuExamples { class Program { static async Task Main(string[] args) { var credentials = new BasicAWSCredentials("<AccessKey>", "<SecretKey>"); var s3Config = new AmazonS3Config { ServiceURL = "https://s3.cn-east-1.qiniucs.com" // 华东-浙江区 endpoint }; var s3Client = new AmazonS3Client(credentials, s3Config); var request = new GetPreSignedUrlRequest { BucketName = "<Bucket>", Key = "<Key>", Verb = HttpVerb.PUT, Expires = DateTime.Now.AddSeconds(3600) // 有效期为一小时 }; var url = s3Client.GetPreSignedURL(request); Console.WriteLine("{0}", url); } } } 这段代码将生成一个经过预先签名的客户端上传 URL，有效期为一小时，客户端可以在过期时间内对该 URL 发送 HTTP PUT 请求将文件上传。 以下是用 curl 上传文件的案例： curl -X PUT --upload-file "<path/to/file>" "<presigned url>" ## 服务器端直传 ### 单请求上传（文件） 创建 `Program.cs` using System.Net; using Amazon.Runtime; using Amazon.S3; using Amazon.S3.Model; namespace S3QiniuExamples { class Program { static async Task Main(string[] args) { var credentials = new BasicAWSCredentials("<AccessKey>", "<SecretKey>"); var s3Config = new AmazonS3Config { ServiceURL = "https://s3.cn-east-1.qiniucs.com" // 华东-浙江区 endpoint }; var s3Client = new AmazonS3Client(credentials, s3Config); var putRequest = new PutObjectRequest { BucketName = "<Bucket>", Key = "<Key>", FilePath = "<path/to/upload>" }; try { var result = await s3Client.PutObjectAsync(putRequest); if (result.HttpStatusCode == HttpStatusCode.OK) { Console.WriteLine("ETag: {0}", result.ETag); } else { Console.WriteLine("Unexpected Status Code: {0}", result.HttpStatusCode); } } catch (AmazonS3Exception ex) { Console.WriteLine(ex); throw; } catch (Exception ex) { Console.WriteLine(ex); throw; } } } } ### 单请求上传（数据流） 创建 `Program.cs` using System.Net; using Amazon.Runtime; using Amazon.S3; using Amazon.S3.Model; namespace S3QiniuExamples { class Program { static async Task Main(string[] args) { var credentials = new BasicAWSCredentials("<AccessKey>", "<SecretKey>"); var s3Config = new AmazonS3Config { ServiceURL = "https://s3.cn-east-1.qiniucs.com" // 华东-浙江区 endpoint }; var s3Client = new AmazonS3Client(credentials, s3Config); using (var fileStream = new FileStream("<path/to/upload>", FileMode.Open)) { var putRequest = new PutObjectRequest { BucketName = "<Bucket>", Key = "<Key>", InputStream = fileStream, }; try { var result = await s3Client.PutObjectAsync(putRequest); if (result.HttpStatusCode == HttpStatusCode.OK) { Console.WriteLine("ETag: {0}", result.ETag); } else { Console.WriteLine("Unexpected Status Code: {0}", result.HttpStatusCode); } } catch (AmazonS3Exception ex) { Console.WriteLine(ex); throw; } catch (Exception ex) { Console.WriteLine(ex); throw; } } } } } ### 分片上传（文件） 创建 `Program.cs` using System.Net; using Amazon.Runtime; using Amazon.S3; using Amazon.S3.Model; namespace S3QiniuExamples { class Program { static async Task Main(string[] args) { var credentials = new BasicAWSCredentials("<AccessKey>", "<SecretKey>"); var s3Config = new AmazonS3Config { ServiceURL = "https://s3.cn-east-1.qiniucs.com" // 华东-浙江区 endpoint }; var s3Client = new AmazonS3Client(credentials, s3Config); const string LOCAL_FILE_PATH = "<path/to/upload>"; try { long totalFileSize = new FileInfo(LOCAL_FILE_PATH).Length; long uploadedSize = 0; var initiateMultipartUploadRequest = new InitiateMultipartUploadRequest { BucketName = "<Bucket>", Key = "<Key>", }; var initiateMultipartUploadResponse = await s3Client.InitiateMultipartUploadAsync(initiateMultipartUploadRequest); const long PART_SIZE = 5 * 1024 * 1024; // 分片大小为 5 MB var partCount = (int)Math.Ceiling((double)totalFileSize / PART_SIZE); var completeMultipartUploadRequest = new CompleteMultipartUploadRequest { BucketName = initiateMultipartUploadRequest.BucketName, Key = initiateMultipartUploadRequest.Key, UploadId = initiateMultipartUploadResponse.UploadId }; // 这里给出的案例是串行分片上传。可以自行改造成并行分片上传以进一步提升上传速度 for (var i = 0; i < partCount; i++) { var uploadPartRequest = new UploadPartRequest { BucketName = initiateMultipartUploadRequest.BucketName, Key = initiateMultipartUploadRequest.Key, UploadId = initiateMultipartUploadResponse.UploadId, PartNumber = i + 1, PartSize = Math.Min(PART_SIZE, totalFileSize - uploadedSize), FilePath = LOCAL_FILE_PATH, FilePosition = uploadedSize }; var uploadPartResponse = await s3Client.UploadPartAsync(uploadPartRequest); completeMultipartUploadRequest.AddPartETags(uploadPartResponse); uploadedSize += uploadPartRequest.PartSize; } var completeMultipartUploadResponse = await s3Client.CompleteMultipartUploadAsync(completeMultipartUploadRequest); if (completeMultipartUploadResponse.HttpStatusCode == HttpStatusCode.OK) { Console.WriteLine("ETag: {0}", completeMultipartUploadResponse.ETag); } else { Console.WriteLine("Unexpected Status Code: {0}", completeMultipartUploadResponse.HttpStatusCode); } } catch (AmazonS3Exception ex) { Console.WriteLine(ex); throw; } catch (Exception ex) { Console.WriteLine(ex); throw; } } } } ### 上传文件 创建 `Program.cs` using Amazon.Runtime; using Amazon.S3; using Amazon.S3.Transfer; namespace S3QiniuExamples { class Program { static async Task Main(string[] args) { var credentials = new BasicAWSCredentials("<AccessKey>", "<SecretKey>"); var s3Config = new AmazonS3Config { ServiceURL = "https://s3.cn-east-1.qiniucs.com" // 华东-浙江区 endpoint }; var s3Client = new AmazonS3Client(credentials, s3Config); try { var transferUtility = new TransferUtility(s3Client); await transferUtility.UploadAsync("<path/to/upload>", "<Bucket>", "<Key>"); Console.WriteLine("Done"); } catch (AmazonS3Exception ex) { Console.WriteLine(ex); throw; } catch (Exception ex) { Console.WriteLine(ex); throw; } } } } ### 上传目录 创建 `Program.cs` using Amazon.Runtime; using Amazon.S3; using Amazon.S3.Transfer; namespace S3QiniuExamples { class Program { static async Task Main(string[] args) { var credentials = new BasicAWSCredentials("<AccessKey>", "<SecretKey>"); var s3Config = new AmazonS3Config { ServiceURL = "https://s3.cn-east-1.qiniucs.com" // 华东-浙江区 endpoint }; var s3Client = new AmazonS3Client(credentials, s3Config); try { var transferUtility = new TransferUtility(s3Client); await transferUtility.UploadDirectoryAsync("<path/to/upload>", "<Bucket>"); Console.WriteLine("Done"); } catch (AmazonS3Exception ex) { Console.WriteLine(ex); throw; } catch (Exception ex) { Console.WriteLine(ex); throw; } } } } # 对象下载 ## 获取客户端下载 URL 创建 `Program.cs` using Amazon.Runtime; using Amazon.S3; using Amazon.S3.Model; namespace S3QiniuExamples { class Program { static async Task Main(string[] args) { var credentials = new BasicAWSCredentials("<AccessKey>", "<SecretKey>"); var s3Config = new AmazonS3Config { ServiceURL = "https://s3.cn-east-1.qiniucs.com" // 华东-浙江区 endpoint }; var s3Client = new AmazonS3Client(credentials, s3Config); var request = new GetPreSignedUrlRequest { BucketName = "<Bucket>", Key = "<Key>", Verb = HttpVerb.GET, Expires = DateTime.Now.AddSeconds(3600) // 有效期为一小时 }; var url = s3Client.GetPreSignedURL(request); Console.WriteLine("{0}", url); } } } 这段代码将生成一个经过预先签名的客户端下载 URL，有效期为一小时，客户端可以在过期时间内对该 URL 发送 HTTP GET 请求将文件下载。 以下是用 curl 下载文件的案例： curl -o "<path/to/download>" "<presigned url>" ## 服务器端直接下载 创建 `Program.cs` using System.Net; using Amazon.Runtime; using Amazon.S3; using Amazon.S3.Model; namespace S3QiniuExamples { class Program { static async Task Main(string[] args) { var credentials = new BasicAWSCredentials("<AccessKey>", "<SecretKey>"); var s3Config = new AmazonS3Config { ServiceURL = "https://s3.cn-east-1.qiniucs.com" // 华东-浙江区 endpoint }; var s3Client = new AmazonS3Client(credentials, s3Config); var request = new GetObjectRequest { BucketName = "<Bucket>", Key = "<Key>" }; try { using (var response = await s3Client.GetObjectAsync(request)) { if (response.HttpStatusCode == HttpStatusCode.OK) { using (var responseStream = response.ResponseStream) using (var fileStream = new FileStream("<path/to/download>", FileMode.OpenOrCreate)) { await responseStream.CopyToAsync(fileStream); } Console.WriteLine("Done"); } else { Console.WriteLine("Unexpected Status Code: {0}", response.HttpStatusCode); } } } catch (AmazonS3Exception ex) { Console.WriteLine(ex); throw; } catch (Exception ex) { Console.WriteLine(ex); throw; } } } } ## 下载文件 创建 `Program.cs` using Amazon.Runtime; using Amazon.S3; using Amazon.S3.Transfer; namespace S3QiniuExamples { class Program { static async Task Main(string[] args) { var credentials = new BasicAWSCredentials("<AccessKey>", "<SecretKey>"); var s3Config = new AmazonS3Config { ServiceURL = "https://s3.cn-east-1.qiniucs.com" // 华东-浙江区 endpoint }; var s3Client = new AmazonS3Client(credentials, s3Config); try { var transferUtility = new TransferUtility(s3Client); await transferUtility.DownloadAsync("<path/to/download>", "<Bucket>", "<Key>"); Console.WriteLine("Done"); } catch (AmazonS3Exception ex) { Console.WriteLine(ex); throw; } catch (Exception ex) { Console.WriteLine(ex); throw; } } } } ## 下载目录 创建 `Program.cs` using Amazon.Runtime; using Amazon.S3; using Amazon.S3.Transfer; namespace S3QiniuExamples { class Program { static async Task Main(string[] args) { var credentials = new BasicAWSCredentials("<AccessKey>", "<SecretKey>"); var s3Config = new AmazonS3Config { ServiceURL = "https://s3.cn-east-1.qiniucs.com" // 华东-浙江区 endpoint }; var s3Client = new AmazonS3Client(credentials, s3Config); try { var transferUtility = new TransferUtility(s3Client); await transferUtility.DownloadDirectoryAsync("<Bucket>", "<RemoteDirectoryPath>", "<LocalDirectoryPath>"); Console.WriteLine("Done"); } catch (AmazonS3Exception ex) { Console.WriteLine(ex); throw; } catch (Exception ex) { Console.WriteLine(ex); throw; } } } } # 对象管理 ## 获取对象信息 创建 `Program.cs` using System.Net; using Amazon.Runtime; using Amazon.S3; namespace S3QiniuExamples { class Program { static async Task Main(string[] args) { var credentials = new BasicAWSCredentials("<AccessKey>", "<SecretKey>"); var s3Config = new AmazonS3Config { ServiceURL = "https://s3.cn-east-1.qiniucs.com" // 华东-浙江区 endpoint }; var s3Client = new AmazonS3Client(credentials, s3Config); try { var result = await s3Client.GetObjectMetadataAsync(bucketName: "<Bucket>", key: "<Key>"); if (result.HttpStatusCode == HttpStatusCode.OK) { Console.WriteLine("ETag: {0}", result.ETag); } else { Console.WriteLine("Unexpected Status Code: {0}", result.HttpStatusCode); } } catch (AmazonS3Exception ex) { Console.WriteLine(ex); throw; } catch (Exception ex) { Console.WriteLine(ex); throw; } } } } ## 修改对象 MimeType 创建 `Program.cs` using System.Net; using Amazon.Runtime; using Amazon.S3; using Amazon.S3.Model; namespace S3QiniuExamples { class Program { static async Task Main(string[] args) { var credentials = new BasicAWSCredentials("<AccessKey>", "<SecretKey>"); var s3Config = new AmazonS3Config { ServiceURL = "https://s3.cn-east-1.qiniucs.com" // 华东-浙江区 endpoint }; var s3Client = new AmazonS3Client(credentials, s3Config); var request = new CopyObjectRequest { SourceBucket = "<Bucket>", SourceKey = "<Key>", DestinationBucket = "<Bucket>", DestinationKey = "<Key>", ContentType = "<NewContentType>", MetadataDirective = S3MetadataDirective.REPLACE }; try { var result = await s3Client.CopyObjectAsync(request); if (result.HttpStatusCode == HttpStatusCode.OK) { Console.WriteLine("Done"); } else { Console.WriteLine("Unexpected Status Code: {0}", result.HttpStatusCode); } } catch (AmazonS3Exception ex) { Console.WriteLine(ex); throw; } catch (Exception ex) { Console.WriteLine(ex); throw; } } } } ## 修改对象存储类型 创建 `Program.cs` using System.Net; using Amazon.Runtime; using Amazon.S3; using Amazon.S3.Model; namespace S3QiniuExamples { class Program { static async Task Main(string[] args) { var credentials = new BasicAWSCredentials("<AccessKey>", "<SecretKey>"); var s3Config = new AmazonS3Config { ServiceURL = "https://s3.cn-east-1.qiniucs.com" // 华东-浙江区 endpoint }; var s3Client = new AmazonS3Client(credentials, s3Config); var request = new CopyObjectRequest { SourceBucket = "<Bucket>", SourceKey = "<Key>", DestinationBucket = "<Bucket>", DestinationKey = "<Key>", StorageClass = S3StorageClass.Glacier, MetadataDirective = S3MetadataDirective.REPLACE }; try { var result = await s3Client.CopyObjectAsync(request); if (result.HttpStatusCode == HttpStatusCode.OK) { Console.WriteLine("Done"); } else { Console.WriteLine("Unexpected Status Code: {0}", result.HttpStatusCode); } } catch (AmazonS3Exception ex) { Console.WriteLine(ex); throw; } catch (Exception ex) { Console.WriteLine(ex); throw; } } } } ## 复制对象副本 创建 `Program.cs` using System.Net; using Amazon.Runtime; using Amazon.S3; using Amazon.S3.Model; namespace S3QiniuExamples { class Program { static async Task Main(string[] args) { var credentials = new BasicAWSCredentials("<AccessKey>", "<SecretKey>"); var s3Config = new AmazonS3Config { ServiceURL = "https://s3.cn-east-1.qiniucs.com" // 华东-浙江区 endpoint }; var s3Client = new AmazonS3Client(credentials, s3Config); var request = new CopyObjectRequest { SourceBucket = "<Bucket>", SourceKey = "<Key>", DestinationBucket = "<Bucket>", DestinationKey = "<Key>", MetadataDirective = S3MetadataDirective.COPY }; try { var result = await s3Client.CopyObjectAsync(request); if (result.HttpStatusCode == HttpStatusCode.OK) { Console.WriteLine("Done"); } else { Console.WriteLine("Unexpected Status Code: {0}", result.HttpStatusCode); } } catch (AmazonS3Exception ex) { Console.WriteLine(ex); throw; } catch (Exception ex) { Console.WriteLine(ex); throw; } } } } ## 复制对象副本（大于 5GB） 创建 `Program.cs` using System.Net; using Amazon.Runtime; using Amazon.S3; using Amazon.S3.Model; namespace S3QiniuExamples { class Program { static async Task Main(string[] args) { var credentials = new BasicAWSCredentials("<AccessKey>", "<SecretKey>"); var s3Config = new AmazonS3Config { ServiceURL = "https://s3.cn-east-1.qiniucs.com" // 华东-浙江区 endpoint }; var s3Client = new AmazonS3Client(credentials, s3Config); try { var headObjectRequest = new GetObjectMetadataRequest { BucketName = "<FromBucket>", Key = "<FromKey>" }; var headObjectResponse = await s3Client.GetObjectMetadataAsync(headObjectRequest); if (headObjectResponse.HttpStatusCode != HttpStatusCode.OK) { Console.WriteLine("Unexpected Status Code: {0}", headObjectResponse.HttpStatusCode); return; } var createMultipartUploadRequest = await s3Client.InitiateMultipartUploadAsync(bucketName: "<ToBucket>", key: "<ToKey>"); if (createMultipartUploadRequest.HttpStatusCode != HttpStatusCode.OK) { Console.WriteLine("Unexpected Status Code: {0}", createMultipartUploadRequest.HttpStatusCode); return; } const long PART_SIZE = 5 * 1024 * 1024; // 分片大小，调整过小会影响复制速度，调整过大可能导致服务器超时 long partSize = PART_SIZE; List<PartETag> partETags = new List<PartETag>(); // 这里给出的案例是串行分片复制。可以自行改造成并行分片复制以进一步提升复制速度 for (long copied = 0, partNumber = 1; copied < headObjectResponse.ContentLength; copied += partSize, partNumber++) { partSize = Math.Min(headObjectResponse.ContentLength - copied, PART_SIZE); var uploadPartCopyRequest = new CopyPartRequest { DestinationBucket = createMultipartUploadRequest.BucketName, DestinationKey = createMultipartUploadRequest.Key, SourceBucket = headObjectRequest.BucketName, SourceKey = headObjectRequest.Key, UploadId = createMultipartUploadRequest.UploadId, PartNumber = (int)partNumber, FirstByte = copied, LastByte = copied + partSize, }; var uploadPartCopyResponse = await s3Client.CopyPartAsync(uploadPartCopyRequest); if (uploadPartCopyResponse.HttpStatusCode != HttpStatusCode.OK) { Console.WriteLine("Unexpected Status Code: {0}", uploadPartCopyResponse.HttpStatusCode); return; } partETags.Add(new PartETag { PartNumber = uploadPartCopyRequest.PartNumber, ETag = uploadPartCopyResponse.ETag, }); Console.WriteLine("PartNumber: {0}", uploadPartCopyRequest.PartNumber); } var completeMultipartUploadRequest = new CompleteMultipartUploadRequest { BucketName = createMultipartUploadRequest.BucketName, Key = createMultipartUploadRequest.Key, UploadId = createMultipartUploadRequest.UploadId, PartETags = partETags, }; var completeMultipartUploadAsync = await s3Client.CompleteMultipartUploadAsync(completeMultipartUploadRequest); if (completeMultipartUploadAsync.HttpStatusCode == HttpStatusCode.OK) { Console.WriteLine("ETag: {0}", completeMultipartUploadAsync.ETag); } else { Console.WriteLine("Unexpected Status Code: {0}", completeMultipartUploadAsync.HttpStatusCode); } } catch (AmazonS3Exception ex) { Console.WriteLine(ex); throw; } catch (Exception ex) { Console.WriteLine(ex); throw; } } } } ## 删除空间中的文件 创建 `Program.cs` using System.Net; using Amazon.Runtime; using Amazon.S3; using Amazon.S3.Model; namespace S3QiniuExamples { class Program { static async Task Main(string[] args) { var credentials = new BasicAWSCredentials("<AccessKey>", "<SecretKey>"); var s3Config = new AmazonS3Config { ServiceURL = "https://s3.cn-east-1.qiniucs.com" // 华东-浙江区 endpoint }; var s3Client = new AmazonS3Client(credentials, s3Config); try { var deleteObjectRequest = new DeleteObjectRequest { BucketName = "<BucketName>", Key = "<Key>" }; var deleteObjectResponse = await s3Client.DeleteObjectAsync(deleteObjectRequest); if (deleteObjectResponse.HttpStatusCode == HttpStatusCode.NoContent) { Console.WriteLine("Done"); } else { Console.WriteLine("Unexpected Status Code: {0}", deleteObjectResponse.HttpStatusCode); } } catch (AmazonS3Exception ex) { Console.WriteLine(ex); throw; } catch (Exception ex) { Console.WriteLine(ex); throw; } } } } ## 获取指定前缀的文件列表 创建 `Program.cs` using System.Net; using Amazon.Runtime; using Amazon.S3; using Amazon.S3.Model; namespace S3QiniuExamples { class Program { static async Task Main(string[] args) { var credentials = new BasicAWSCredentials("<AccessKey>", "<SecretKey>"); var s3Config = new AmazonS3Config { ServiceURL = "https://s3.cn-east-1.qiniucs.com" // 华东-浙江区 endpoint }; var s3Client = new AmazonS3Client(credentials, s3Config); try { var request = new ListObjectsV2Request { BucketName = "<Bucket>", Prefix = "<KeyPrefix>", }; var result = await s3Client.ListObjectsV2Async(request); if (result.HttpStatusCode == HttpStatusCode.OK) { foreach (var obj in result.S3Objects) { Console.WriteLine("Key: {0}", obj.Key); Console.WriteLine("ETag: {0}", obj.ETag); } } else { Console.WriteLine("Unexpected Status Code: {0}", result.HttpStatusCode); } } catch (AmazonS3Exception ex) { Console.WriteLine(ex); throw; } catch (Exception ex) { Console.WriteLine(ex); throw; } } } } ## 批量删除空间中的文件 创建 `Program.cs` using System.Net; using Amazon.Runtime; using Amazon.S3; using Amazon.S3.Model; namespace S3QiniuExamples { class Program { static async Task Main(string[] args) { var credentials = new BasicAWSCredentials("<AccessKey>", "<SecretKey>"); var s3Config = new AmazonS3Config { ServiceURL = "https://s3.cn-east-1.qiniucs.com" // 华东-浙江区 endpoint }; var s3Client = new AmazonS3Client(credentials, s3Config); try { var objectsToDelete = new List<KeyVersion> { new() { Key = "<Key1>" }, new() { Key = "<Key2>" } }; var request = new DeleteObjectsRequest { BucketName = "<Bucket>", Objects = objectsToDelete }; var result = await s3Client.DeleteObjectsAsync(request); if (result.HttpStatusCode == HttpStatusCode.OK) { Console.WriteLine("Done"); } else { Console.WriteLine("Unexpected Status Code: {0}", result.HttpStatusCode); } } catch (AmazonS3Exception ex) { Console.WriteLine(ex); throw; } catch (Exception ex) { Console.WriteLine(ex); throw; } } } } # 临时安全凭证 创建 `Program.cs` using System.Net; using Amazon.Runtime; using Amazon.S3; using Amazon.SecurityToken; using Amazon.SecurityToken.Model; namespace S3QiniuExamples { class Program { class STSCredentials : RefreshingAWSCredentials { private AmazonSecurityTokenServiceClient stsClient; public STSCredentials(AWSCredentials credentials, AmazonSecurityTokenServiceConfig stsConfig) { stsClient = new AmazonSecurityTokenServiceClient(credentials, stsConfig); } protected override CredentialsRefreshState GenerateNewCredentials() { var getFederationTokenRequest = new GetFederationTokenRequest(); getFederationTokenRequest.Name = "Bob"; getFederationTokenRequest.DurationSeconds = 3600; getFederationTokenRequest.Policy = "{\"Version\":\"2012-10-17\",\"Statement\":[{\"Sid\":\"Stmt1\",\"Effect\":\"Allow\",\"Action\":[\"*\"],\"Resource\":[\"*\"]}]}"; var getFederationTokenTask = Task.Run(async () => await stsClient.GetFederationTokenAsync(getFederationTokenRequest)); getFederationTokenTask.Wait(); var getFederationTokenResponse = getFederationTokenTask.Result; if (getFederationTokenResponse.HttpStatusCode == HttpStatusCode.OK) { var credentials = new ImmutableCredentials(getFederationTokenResponse.Credentials.AccessKeyId, getFederationTokenResponse.Credentials.SecretAccessKey, getFederationTokenResponse.Credentials.SessionToken); var expiration = getFederationTokenResponse.Credentials.Expiration; return new CredentialsRefreshState(credentials, expiration); } else { throw new AmazonS3Exception(getFederationTokenResponse.ToString()); } } } static async Task Main(string[] args) { var credentials = new BasicAWSCredentials("<AccessKey>", "<SecretKey>"); var stsConfig = new AmazonSecurityTokenServiceConfig { ServiceURL = "https://s3.cn-east-1.qiniucs.com" // 华东-浙江区 endpoint }; var stsCredentials = new STSCredentials(credentials, stsConfig); var s3Config = new AmazonS3Config { ServiceURL = "https://s3.cn-east-1.qiniucs.com" // 华东-浙江区 endpoint }; var s3Client = new AmazonS3Client(stsCredentials, s3Config); // 可以使用这些临时凭证调用 S3 服务 var listBucketsResponse = await s3Client.ListBucketsAsync(); if (listBucketsResponse.HttpStatusCode == HttpStatusCode.OK) { foreach (var bucket in listBucketsResponse.Buckets) { Console.WriteLine(bucket.BucketName); } } else { Console.WriteLine("Unexpected Status Code: {0}", listBucketsResponse.HttpStatusCode); } } } } 以上内容是否对您有帮助？

AWS SDK for Go

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [开发指南](https://developer.qiniu.com/kodo/development_guidelines/8596/development- guidelines) > [AWS S3 兼容](https://developer.qiniu.com/kodo/development_guidelines/4086/aws-s3-compatible) > [兼容 SDK 示例](https://developer.qiniu.com/kodo/development_guidelines/12553/S3 SDK sample) > AWS SDK for Go # AWS SDK for Go 最近更新时间: 2024-02-19 17:02:38 # 导入 AWS SDK for Go 确保 Go v1.15 或更新版本已经安装。 执行以下命令初始化 Go mod 项目 go mod init example 然后添加 AWS SDK for Go 包 go get github.com/aws/[email protected] go get github.com/aws/aws-sdk-go-v2/[email protected] go get github.com/aws/aws-sdk-go-v2/[email protected] go get github.com/aws/aws-sdk-go-v2/feature/s3/[email protected] go get github.com/aws/aws-sdk-go-v2/service/[email protected] go get github.com/aws/aws-sdk-go-v2/service/[email protected] 对于之后的每个代码示例，将代码创建在 `main.go` 后，执行 go run main.go 即可执行代码。 # 对象上传 ## 获取客户端上传 URL 创建 `main.go` package main import ( "context" "fmt" "log" "github.com/aws/aws-sdk-go-v2/aws" "github.com/aws/aws-sdk-go-v2/config" "github.com/aws/aws-sdk-go-v2/credentials" "github.com/aws/aws-sdk-go-v2/service/s3" ) func main() { cfg, err := config.LoadDefaultConfig( context.Background(), config.WithCredentialsProvider(credentials.StaticCredentialsProvider{ Value: aws.Credentials{ AccessKeyID: "<QiniuAccessKey>", SecretAccessKey: "<QiniuSecretKey>", }, }), config.WithRegion("cn-east-1"), // 华东-浙江区 region id config.WithEndpointResolverWithOptions(aws.EndpointResolverWithOptionsFunc(func(service, region string, options ...interface{}) (aws.Endpoint, error) { return aws.Endpoint{ URL: "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint }, nil }))) if err != nil { log.Fatalln(err) } s3Client := s3.NewFromConfig(cfg) s3PresignClient := s3.NewPresignClient(s3Client) req, err := s3PresignClient.PresignPutObject(context.Background(), &s3.PutObjectInput{ Bucket: aws.String("<Bucket>"), Key: aws.String("<Key>"), }) if err != nil { log.Fatalln(err) } fmt.Println(req.URL) } 这段代码将生成一个经过预先签名的客户端上传 URL，有效期为 15 分钟，客户端可以在有效时间内对该 URL 发送 HTTP PUT 请求将文件上传。 以下是用 curl 上传文件的案例： curl -X PUT --upload-file "<path/to/file>" "<presigned url>" 您也可以自行指定上传凭证的有效期，例如： package main import ( "context" "fmt" "log" "time" "github.com/aws/aws-sdk-go-v2/aws" "github.com/aws/aws-sdk-go-v2/config" "github.com/aws/aws-sdk-go-v2/credentials" "github.com/aws/aws-sdk-go-v2/service/s3" ) func main() { cfg, err := config.LoadDefaultConfig( context.Background(), config.WithCredentialsProvider(credentials.StaticCredentialsProvider{ Value: aws.Credentials{ AccessKeyID: "<QiniuAccessKey>", SecretAccessKey: "<QiniuSecretKey>", }, }), config.WithRegion("cn-east-1"), // 华东-浙江区 region id config.WithEndpointResolverWithOptions(aws.EndpointResolverWithOptionsFunc(func(service, region string, options ...interface{}) (aws.Endpoint, error) { return aws.Endpoint{ URL: "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint }, nil }))) if err != nil { log.Fatalln(err) } s3Client := s3.NewFromConfig(cfg) s3PresignClient := s3.NewPresignClient(s3Client) req, err := s3PresignClient.PresignPutObject(context.Background(), &s3.PutObjectInput{ Bucket: aws.String("<Bucket>"), Key: aws.String("<Key>"), }, s3.WithPresignExpires(1*time.Hour)) // 有效期为一小时 if err != nil { log.Fatalln(err) } fmt.Println(req.URL) } ## 服务器端直传 ### 单请求上传（文件） 创建 `main.go` 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/credentials" "github.com/aws/aws-sdk-go-v2/service/s3" ) func main() { cfg, err := config.LoadDefaultConfig( context.Background(), config.WithCredentialsProvider(credentials.StaticCredentialsProvider{ Value: aws.Credentials{ AccessKeyID: "<QiniuAccessKey>", SecretAccessKey: "<QiniuSecretKey>", }, }), config.WithRegion("cn-east-1"), // 华东-浙江区 region id config.WithEndpointResolverWithOptions(aws.EndpointResolverWithOptionsFunc(func(service, region string, options ...interface{}) (aws.Endpoint, error) { return aws.Endpoint{ URL: "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint }, nil }))) if err != nil { log.Fatalln(err) } s3Client := s3.NewFromConfig(cfg) file, err := os.Open("<path/to/upload>") if err != nil { log.Fatalln(err) } defer file.Close() output, err := s3Client.PutObject(context.Background(), &s3.PutObjectInput{ Bucket: aws.String("<Bucket>"), Key: aws.String("<Key>"), Body: file, // 这里也可以使用其他 io.Reader 实例实现对数据流的上传 }) if err != nil { log.Fatalln(err) } fmt.Printf("ETag: %s\n", aws.ToString(output.ETag)) } ### 单请求上传（数据流） 创建 `main.go` package main import ( "context" "fmt" "log" "strings" "github.com/aws/aws-sdk-go-v2/aws" "github.com/aws/aws-sdk-go-v2/config" "github.com/aws/aws-sdk-go-v2/credentials" "github.com/aws/aws-sdk-go-v2/service/s3" ) func main() { cfg, err := config.LoadDefaultConfig( context.Background(), config.WithCredentialsProvider(credentials.StaticCredentialsProvider{ Value: aws.Credentials{ AccessKeyID: "<QiniuAccessKey>", SecretAccessKey: "<QiniuSecretKey>", }, }), config.WithRegion("cn-east-1"), // 华东-浙江区 region id config.WithEndpointResolverWithOptions(aws.EndpointResolverWithOptionsFunc(func(service, region string, options ...interface{}) (aws.Endpoint, error) { return aws.Endpoint{ URL: "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint }, nil }))) if err != nil { log.Fatalln(err) } s3Client := s3.NewFromConfig(cfg) output, err := s3Client.PutObject(context.Background(), &s3.PutObjectInput{ Bucket: aws.String("<Bucket>"), Key: aws.String("<Key>"), Body: strings.NewReader("Hello Qiniu S3!"), }) if err != nil { log.Fatalln(err) } fmt.Printf("ETag: %s\n", aws.ToString(output.ETag)) } ### 分片上传（文件） 创建 `main.go` package main import ( "context" "fmt" "io" "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/credentials" "github.com/aws/aws-sdk-go-v2/service/s3" "github.com/aws/aws-sdk-go-v2/service/s3/types" ) func main() { cfg, err := config.LoadDefaultConfig( context.Background(), config.WithCredentialsProvider(credentials.StaticCredentialsProvider{ Value: aws.Credentials{ AccessKeyID: "<QiniuAccessKey>", SecretAccessKey: "<QiniuSecretKey>", }, }), config.WithRegion("cn-east-1"), // 华东-浙江区 region id config.WithEndpointResolverWithOptions(aws.EndpointResolverWithOptionsFunc(func(service, region string, options ...interface{}) (aws.Endpoint, error) { return aws.Endpoint{ URL: "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint }, nil }))) if err != nil { log.Fatalln(err) } s3Client := s3.NewFromConfig(cfg) file, err := os.Open("<path/to/upload>") if err != nil { log.Fatalln(err) } defer file.Close() fileInfo, err := file.Stat() if err != nil { log.Fatalln(err) } createMultipartUploadInput := s3.CreateMultipartUploadInput{ Bucket: aws.String("<Bucket>"), Key: aws.String("<Key>"), } createMultipartUploadOutput, err := s3Client.CreateMultipartUpload(context.Background(), &createMultipartUploadInput) if err != nil { log.Fatalln(err) } multipartUpload := types.CompletedMultipartUpload{} const PART_SIZE int64 = 5 * 1024 * 1024 // 分片大小为 5 MB // 这里给出的案例是串行分片上传。可以自行改造成并行分片上传以进一步提升上传速度 for uploaded, partNumber := int64(0), int32(1); uploaded < fileInfo.Size(); partNumber += 1 { partSize := PART_SIZE if partSize > fileInfo.Size()-uploaded { partSize = fileInfo.Size() - uploaded } uploadPartOutput, err := s3Client.UploadPart(context.Background(), &s3.UploadPartInput{ Bucket: createMultipartUploadInput.Bucket, Key: createMultipartUploadInput.Key, UploadId: createMultipartUploadOutput.UploadId, PartNumber: partNumber, Body: &io.LimitedReader{R: file, N: partSize}, }) if err != nil { log.Fatalln(err) } multipartUpload.Parts = append(multipartUpload.Parts, types.CompletedPart{PartNumber: partNumber, ETag: uploadPartOutput.ETag}) uploaded += partSize } completeMultipartUploadOutput, err := s3Client.CompleteMultipartUpload(context.Background(), &s3.CompleteMultipartUploadInput{ Bucket: createMultipartUploadInput.Bucket, Key: createMultipartUploadInput.Key, UploadId: createMultipartUploadOutput.UploadId, MultipartUpload: &multipartUpload, }) if err != nil { log.Fatalln(err) } fmt.Printf("ETag: %s\n", aws.ToString(completeMultipartUploadOutput.ETag)) } ### 上传文件 创建 `main.go` 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/credentials" "github.com/aws/aws-sdk-go-v2/feature/s3/manager" "github.com/aws/aws-sdk-go-v2/service/s3" ) func main() { cfg, err := config.LoadDefaultConfig( context.Background(), config.WithCredentialsProvider(credentials.StaticCredentialsProvider{ Value: aws.Credentials{ AccessKeyID: "<QiniuAccessKey>", SecretAccessKey: "<QiniuSecretKey>", }, }), config.WithRegion("cn-east-1"), // 华东-浙江区 region id config.WithEndpointResolverWithOptions(aws.EndpointResolverWithOptionsFunc(func(service, region string, options ...interface{}) (aws.Endpoint, error) { return aws.Endpoint{ URL: "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint }, nil }))) if err != nil { log.Fatalln(err) } s3Client := s3.NewFromConfig(cfg) s3Manager := manager.NewUploader(s3Client) file, err := os.Open("<path/to/upload>") if err != nil { log.Fatalln(err) } defer file.Close() output, err := s3Manager.Upload(context.Background(), &s3.PutObjectInput{ Bucket: aws.String("<Bucket>"), Key: aws.String("<Key>"), Body: file, }) if err != nil { log.Fatalln(err) } fmt.Printf("ETag: %s\n", aws.ToString(output.ETag)) } # 对象下载 ## 获取客户端下载 URL 创建 `main.go` package main import ( "context" "fmt" "log" "github.com/aws/aws-sdk-go-v2/aws" "github.com/aws/aws-sdk-go-v2/config" "github.com/aws/aws-sdk-go-v2/credentials" "github.com/aws/aws-sdk-go-v2/service/s3" ) func main() { cfg, err := config.LoadDefaultConfig( context.Background(), config.WithCredentialsProvider(credentials.StaticCredentialsProvider{ Value: aws.Credentials{ AccessKeyID: "<QiniuAccessKey>", SecretAccessKey: "<QiniuSecretKey>", }, }), config.WithRegion("cn-east-1"), // 华东-浙江区 region id config.WithEndpointResolverWithOptions(aws.EndpointResolverWithOptionsFunc(func(service, region string, options ...interface{}) (aws.Endpoint, error) { return aws.Endpoint{ URL: "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint }, nil }))) if err != nil { log.Fatalln(err) } s3Client := s3.NewFromConfig(cfg) s3PresignClient := s3.NewPresignClient(s3Client) req, err := s3PresignClient.PresignGetObject(context.Background(), &s3.GetObjectInput{ Bucket: aws.String("<Bucket>"), Key: aws.String("<Key>"), }) if err != nil { log.Fatalln(err) } fmt.Println(req.URL) } 这段代码将生成一个经过预先签名的客户端下载 URL，有效期为 15 分钟，客户端可以在有效时间内对该 URL 发送 HTTP GET 请求将文件下载。 以下是用 curl 下载文件的案例： curl -o "<path/to/download>" "<presigned url>" 您也可以自行指定上传凭证的有效期，例如： package main import ( "context" "fmt" "log" "github.com/aws/aws-sdk-go-v2/aws" "github.com/aws/aws-sdk-go-v2/config" "github.com/aws/aws-sdk-go-v2/credentials" "github.com/aws/aws-sdk-go-v2/service/s3" ) func main() { cfg, err := config.LoadDefaultConfig( context.Background(), config.WithCredentialsProvider(credentials.StaticCredentialsProvider{ Value: aws.Credentials{ AccessKeyID: "<QiniuAccessKey>", SecretAccessKey: "<QiniuSecretKey>", }, }), config.WithRegion("cn-east-1"), // 华东-浙江区 region id config.WithEndpointResolverWithOptions(aws.EndpointResolverWithOptionsFunc(func(service, region string, options ...interface{}) (aws.Endpoint, error) { return aws.Endpoint{ URL: "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint }, nil }))) if err != nil { log.Fatalln(err) } s3Client := s3.NewFromConfig(cfg) s3PresignClient := s3.NewPresignClient(s3Client) req, err := s3PresignClient.PresignGetObject(context.Background(), &s3.GetObjectInput{ Bucket: aws.String("<Bucket>"), Key: aws.String("<Key>"), }, s3.WithPresignExpires(1*time.Hour)) if err != nil { log.Fatalln(err) } fmt.Println(req.URL) } ## 服务器端直接下载 创建 `main.go` package main import ( "context" "fmt" "io" "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/credentials" "github.com/aws/aws-sdk-go-v2/service/s3" ) func main() { cfg, err := config.LoadDefaultConfig( context.Background(), config.WithCredentialsProvider(credentials.StaticCredentialsProvider{ Value: aws.Credentials{ AccessKeyID: "<QiniuAccessKey>", SecretAccessKey: "<QiniuSecretKey>", }, }), config.WithRegion("cn-east-1"), // 华东-浙江区 region id config.WithEndpointResolverWithOptions(aws.EndpointResolverWithOptionsFunc(func(service, region string, options ...interface{}) (aws.Endpoint, error) { return aws.Endpoint{ URL: "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint }, nil }))) if err != nil { log.Fatalln(err) } s3Client := s3.NewFromConfig(cfg) file, err := os.OpenFile("<path/to/download>", os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600) if err != nil { log.Fatalln(err) } defer file.Close() output, err := s3Client.GetObject(context.Background(), &s3.GetObjectInput{ Bucket: aws.String("<Bucket>"), Key: aws.String("<Key>"), }) if err != nil { log.Fatalln(err) } defer output.Body.Close() _, err = io.Copy(file, output.Body) if err != nil { log.Fatalln(err) } fmt.Printf("ETag: %s\n", aws.ToString(output.ETag)) } ## 下载文件 创建 `main.go` 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/credentials" "github.com/aws/aws-sdk-go-v2/feature/s3/manager" "github.com/aws/aws-sdk-go-v2/service/s3" ) func main() { cfg, err := config.LoadDefaultConfig( context.Background(), config.WithCredentialsProvider(credentials.StaticCredentialsProvider{ Value: aws.Credentials{ AccessKeyID: "<QiniuAccessKey>", SecretAccessKey: "<QiniuSecretKey>", }, }), config.WithRegion("cn-east-1"), // 华东-浙江区 region id config.WithEndpointResolverWithOptions(aws.EndpointResolverWithOptionsFunc(func(service, region string, options ...interface{}) (aws.Endpoint, error) { return aws.Endpoint{ URL: "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint }, nil }))) if err != nil { log.Fatalln(err) } s3Client := s3.NewFromConfig(cfg) s3Manager := manager.NewDownloader(s3Client) file, err := os.OpenFile("<path/to/download>", os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600) if err != nil { log.Fatalln(err) } defer file.Close() _, err = s3Manager.Download(context.Background(), file, &s3.GetObjectInput{ Bucket: aws.String("<Bucket>"), Key: aws.String("<Key>"), }) if err != nil { log.Fatalln(err) } fmt.Println("Done") } # 对象管理 ## 获取对象信息 创建 `main.go` package main import ( "context" "fmt" "log" "github.com/aws/aws-sdk-go-v2/aws" "github.com/aws/aws-sdk-go-v2/config" "github.com/aws/aws-sdk-go-v2/credentials" "github.com/aws/aws-sdk-go-v2/service/s3" ) func main() { cfg, err := config.LoadDefaultConfig( context.Background(), config.WithCredentialsProvider(credentials.StaticCredentialsProvider{ Value: aws.Credentials{ AccessKeyID: "<QiniuAccessKey>", SecretAccessKey: "<QiniuSecretKey>", }, }), config.WithRegion("cn-east-1"), // 华东-浙江区 region id config.WithEndpointResolverWithOptions(aws.EndpointResolverWithOptionsFunc(func(service, region string, options ...interface{}) (aws.Endpoint, error) { return aws.Endpoint{ URL: "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint }, nil }))) if err != nil { log.Fatalln(err) } s3Client := s3.NewFromConfig(cfg) output, err := s3Client.HeadObject(context.Background(), &s3.HeadObjectInput{ Bucket: aws.String("<Bucket>"), Key: aws.String("<Key>"), }) if err != nil { log.Fatalln(err) } fmt.Printf("ETag: %s\n", aws.ToString(output.ETag)) } ## 修改对象 MimeType 创建 `main.go` package main import ( "context" "fmt" "log" "github.com/aws/aws-sdk-go-v2/aws" "github.com/aws/aws-sdk-go-v2/config" "github.com/aws/aws-sdk-go-v2/credentials" "github.com/aws/aws-sdk-go-v2/service/s3" "github.com/aws/aws-sdk-go-v2/service/s3/types" ) func main() { cfg, err := config.LoadDefaultConfig( context.Background(), config.WithCredentialsProvider(credentials.StaticCredentialsProvider{ Value: aws.Credentials{ AccessKeyID: "<QiniuAccessKey>", SecretAccessKey: "<QiniuSecretKey>", }, }), config.WithRegion("cn-east-1"), // 华东-浙江区 region id config.WithEndpointResolverWithOptions(aws.EndpointResolverWithOptionsFunc(func(service, region string, options ...interface{}) (aws.Endpoint, error) { return aws.Endpoint{ URL: "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint }, nil }))) if err != nil { log.Fatalln(err) } s3Client := s3.NewFromConfig(cfg) _, err = s3Client.CopyObject(context.Background(), &s3.CopyObjectInput{ Bucket: aws.String("<Bucket>"), Key: aws.String("<Key>"), CopySource: aws.String("/<Bucket>/<Key>"), ContentType: aws.String("<NewContentType>"), MetadataDirective: types.MetadataDirectiveReplace, }) if err != nil { log.Fatalln(err) } fmt.Println("Done") } ## 修改对象存储类型 创建 `main.go` package main import ( "context" "fmt" "log" "github.com/aws/aws-sdk-go-v2/aws" "github.com/aws/aws-sdk-go-v2/config" "github.com/aws/aws-sdk-go-v2/credentials" "github.com/aws/aws-sdk-go-v2/service/s3" "github.com/aws/aws-sdk-go-v2/service/s3/types" ) func main() { cfg, err := config.LoadDefaultConfig( context.Background(), config.WithCredentialsProvider(credentials.StaticCredentialsProvider{ Value: aws.Credentials{ AccessKeyID: "<QiniuAccessKey>", SecretAccessKey: "<QiniuSecretKey>", }, }), config.WithRegion("cn-east-1"), // 华东-浙江区 region id config.WithEndpointResolverWithOptions(aws.EndpointResolverWithOptionsFunc(func(service, region string, options ...interface{}) (aws.Endpoint, error) { return aws.Endpoint{ URL: "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint }, nil }))) if err != nil { log.Fatalln(err) } s3Client := s3.NewFromConfig(cfg) _, err = s3Client.CopyObject(context.Background(), &s3.CopyObjectInput{ Bucket: aws.String("<Bucket>"), Key: aws.String("<Key>"), CopySource: aws.String("/<Bucket>/<Key>"), StorageClass: types.StorageClassGlacier, MetadataDirective: types.MetadataDirectiveReplace, }) if err != nil { log.Fatalln(err) } fmt.Println("Done") } ## 复制对象副本 创建 `main.go` package main import ( "context" "fmt" "log" "github.com/aws/aws-sdk-go-v2/aws" "github.com/aws/aws-sdk-go-v2/config" "github.com/aws/aws-sdk-go-v2/credentials" "github.com/aws/aws-sdk-go-v2/service/s3" "github.com/aws/aws-sdk-go-v2/service/s3/types" ) func main() { cfg, err := config.LoadDefaultConfig( context.Background(), config.WithCredentialsProvider(credentials.StaticCredentialsProvider{ Value: aws.Credentials{ AccessKeyID: "<QiniuAccessKey>", SecretAccessKey: "<QiniuSecretKey>", }, }), config.WithRegion("cn-east-1"), // 华东-浙江区 region id config.WithEndpointResolverWithOptions(aws.EndpointResolverWithOptionsFunc(func(service, region string, options ...interface{}) (aws.Endpoint, error) { return aws.Endpoint{ URL: "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint }, nil }))) if err != nil { log.Fatalln(err) } s3Client := s3.NewFromConfig(cfg) _, err = s3Client.CopyObject(context.Background(), &s3.CopyObjectInput{ Bucket: aws.String("<ToBucket>"), Key: aws.String("<ToKey>"), CopySource: aws.String("/<FromBucket>/<FromKey>"), MetadataDirective: types.MetadataDirectiveCopy, }) if err != nil { log.Fatalln(err) } fmt.Println("Done") } ## 复制对象副本（大于 5GB） 创建 `main.go` package main import ( "context" "fmt" "log" "github.com/aws/aws-sdk-go-v2/aws" "github.com/aws/aws-sdk-go-v2/config" "github.com/aws/aws-sdk-go-v2/credentials" "github.com/aws/aws-sdk-go-v2/service/s3" "github.com/aws/aws-sdk-go-v2/service/s3/types" ) func main() { cfg, err := config.LoadDefaultConfig( context.Background(), config.WithCredentialsProvider(credentials.StaticCredentialsProvider{ Value: aws.Credentials{ AccessKeyID: "<QiniuAccessKey>", SecretAccessKey: "<QiniuSecretKey>", }, }), config.WithRegion("cn-east-1"), // 华东-浙江区 region id config.WithEndpointResolverWithOptions(aws.EndpointResolverWithOptionsFunc(func(service, region string, options ...interface{}) (aws.Endpoint, error) { return aws.Endpoint{ URL: "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint }, nil }))) if err != nil { log.Fatalln(err) } s3Client := s3.NewFromConfig(cfg) headObjectInput := s3.HeadObjectInput{ Bucket: aws.String("<ToBucket>"), Key: aws.String("<ToKey>"), } headObjectOutput, err := s3Client.HeadObject(context.Background(), &headObjectInput) if err != nil { log.Fatalln(err) } createMultipartUploadInput := s3.CreateMultipartUploadInput{ Bucket: aws.String("<FromBucket>"), Key: aws.String("<FromKey>"), } createMultipartUploadOutput, err := s3Client.CreateMultipartUpload(context.Background(), &createMultipartUploadInput) if err != nil { log.Fatalln(err) } multipartUpload := types.CompletedMultipartUpload{} const PART_SIZE int64 = 5 * 1024 * 1024 // 分片大小为 5 MB // 这里给出的案例是串行分片复制。可以自行改造成并行分片复制以进一步提升复制速度 for copied, partNumber := int64(0), int32(1); copied < headObjectOutput.ContentLength; partNumber += 1 { partSize := PART_SIZE if partSize > headObjectOutput.ContentLength-copied { partSize = headObjectOutput.ContentLength - copied } uploadPartCopyOutput, err := s3Client.UploadPartCopy(context.Background(), &s3.UploadPartCopyInput{ Bucket: createMultipartUploadInput.Bucket, Key: createMultipartUploadInput.Key, UploadId: createMultipartUploadOutput.UploadId, PartNumber: partNumber, CopySource: aws.String(fmt.Sprintf("/%s/%s", aws.ToString(headObjectInput.Bucket), aws.ToString(headObjectInput.Key))), CopySourceRange: aws.String(fmt.Sprintf("bytes=%d-%d", copied, copied+partSize-1)), }) if err != nil { log.Fatalln(err) } multipartUpload.Parts = append(multipartUpload.Parts, types.CompletedPart{PartNumber: partNumber, ETag: uploadPartCopyOutput.CopyPartResult.ETag}) copied += partSize } completeMultipartUploadOutput, err := s3Client.CompleteMultipartUpload(context.Background(), &s3.CompleteMultipartUploadInput{ Bucket: createMultipartUploadInput.Bucket, Key: createMultipartUploadInput.Key, UploadId: createMultipartUploadOutput.UploadId, MultipartUpload: &multipartUpload, }) if err != nil { log.Fatalln(err) } fmt.Printf("ETag: %s\n", aws.ToString(completeMultipartUploadOutput.ETag)) } ## 删除空间中的文件 创建 `main.go` package main import ( "context" "fmt" "log" "github.com/aws/aws-sdk-go-v2/aws" "github.com/aws/aws-sdk-go-v2/config" "github.com/aws/aws-sdk-go-v2/credentials" "github.com/aws/aws-sdk-go-v2/service/s3" ) func main() { cfg, err := config.LoadDefaultConfig( context.Background(), config.WithCredentialsProvider(credentials.StaticCredentialsProvider{ Value: aws.Credentials{ AccessKeyID: "<QiniuAccessKey>", SecretAccessKey: "<QiniuSecretKey>", }, }), config.WithRegion("cn-east-1"), // 华东-浙江区 region id config.WithEndpointResolverWithOptions(aws.EndpointResolverWithOptionsFunc(func(service, region string, options ...interface{}) (aws.Endpoint, error) { return aws.Endpoint{ URL: "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint }, nil }))) if err != nil { log.Fatalln(err) } s3Client := s3.NewFromConfig(cfg) _, err = s3Client.DeleteObject(context.Background(), &s3.DeleteObjectInput{ Bucket: aws.String("<Bucket>"), Key: aws.String("<Key>"), }) if err != nil { log.Fatalln(err) } fmt.Println("Done") } ## 获取指定前缀的文件列表 创建 `main.go` package main import ( "context" "fmt" "log" "github.com/aws/aws-sdk-go-v2/aws" "github.com/aws/aws-sdk-go-v2/config" "github.com/aws/aws-sdk-go-v2/credentials" "github.com/aws/aws-sdk-go-v2/service/s3" ) func main() { cfg, err := config.LoadDefaultConfig( context.Background(), config.WithCredentialsProvider(credentials.StaticCredentialsProvider{ Value: aws.Credentials{ AccessKeyID: "<QiniuAccessKey>", SecretAccessKey: "<QiniuSecretKey>", }, }), config.WithRegion("cn-east-1"), // 华东-浙江区 region id config.WithEndpointResolverWithOptions(aws.EndpointResolverWithOptionsFunc(func(service, region string, options ...interface{}) (aws.Endpoint, error) { return aws.Endpoint{ URL: "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint }, nil }))) if err != nil { log.Fatalln(err) } s3Client := s3.NewFromConfig(cfg) output, err := s3Client.ListObjectsV2(context.Background(), &s3.ListObjectsV2Input{ Bucket: aws.String("<Bucket>"), Prefix: aws.String("<KeyPrefix>"), }) if err != nil { log.Fatalln(err) } for _, object := range output.Contents { fmt.Printf("Key: %s\n", aws.ToString(object.Key)) fmt.Printf("ETag: %s\n", aws.ToString(object.ETag)) } } ## 批量删除空间中的文件 创建 `main.go` package main import ( "context" "fmt" "log" "github.com/aws/aws-sdk-go-v2/aws" "github.com/aws/aws-sdk-go-v2/config" "github.com/aws/aws-sdk-go-v2/credentials" "github.com/aws/aws-sdk-go-v2/service/s3" "github.com/aws/aws-sdk-go-v2/service/s3/types" ) func main() { cfg, err := config.LoadDefaultConfig( context.Background(), config.WithCredentialsProvider(credentials.StaticCredentialsProvider{ Value: aws.Credentials{ AccessKeyID: "<QiniuAccessKey>", SecretAccessKey: "<QiniuSecretKey>", }, }), config.WithRegion("cn-east-1"), // 华东-浙江区 region id config.WithEndpointResolverWithOptions(aws.EndpointResolverWithOptionsFunc(func(service, region string, options ...interface{}) (aws.Endpoint, error) { return aws.Endpoint{ URL: "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint }, nil }))) if err != nil { log.Fatalln(err) } s3Client := s3.NewFromConfig(cfg) _, err = s3Client.DeleteObjects(context.Background(), &s3.DeleteObjectsInput{ Bucket: aws.String("<Bucket>"), Delete: &types.Delete{ Objects: []types.ObjectIdentifier{ {Key: aws.String("<Key1>")}, {Key: aws.String("<Key2>")}, {Key: aws.String("<Key3>")}, {Key: aws.String("<Key4>")}, }, }, }) if err != nil { log.Fatalln(err) } fmt.Println("Done") } # 临时安全凭证 创建 `main.go` package main import ( "context" "fmt" "log" "github.com/aws/aws-sdk-go-v2/aws" "github.com/aws/aws-sdk-go-v2/config" "github.com/aws/aws-sdk-go-v2/credentials" "github.com/aws/aws-sdk-go-v2/service/s3" "github.com/aws/aws-sdk-go-v2/service/sts" ) func main() { cfg, err := config.LoadDefaultConfig( context.Background(), config.WithCredentialsProvider(aws.NewCredentialsCache(aws.CredentialsProviderFunc(func(ctx context.Context) (aws.Credentials, error) { cfg, err := config.LoadDefaultConfig( ctx, config.WithCredentialsProvider(credentials.StaticCredentialsProvider{ AccessKeyID: "<QiniuAccessKey>", SecretAccessKey: "<QiniuSecretKey>", }), config.WithRegion("cn-east-1"), // 华东-浙江区 region id config.WithEndpointResolverWithOptions(aws.EndpointResolverWithOptionsFunc(func(service, region string, options ...interface{}) (aws.Endpoint, error) { return aws.Endpoint{ URL: "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint }, nil })), ) if err != nil { return aws.Credentials{}, nil } federationToken, err := sts.NewFromConfig(cfg).GetFederationToken(ctx, &sts.GetFederationTokenInput{ Name: aws.String("Bob"), DurationSeconds: aws.Int32(3600), Policy: aws.String("{\"Version\":\"2012-10-17\",\"Statement\":[{\"Sid\":\"Stmt1\",\"Effect\":\"Allow\",\"Action\":[\"*\"],\"Resource\":[\"*\"]}]}"), }) if err != nil { return aws.Credentials{}, nil } return aws.Credentials{ AccessKeyID: aws.ToString(federationToken.Credentials.AccessKeyId), SecretAccessKey: aws.ToString(federationToken.Credentials.SecretAccessKey), SessionToken: aws.ToString(federationToken.Credentials.SessionToken), Expires: aws.ToTime(federationToken.Credentials.Expiration), CanExpire: true, }, nil }))), config.WithRegion("cn-east-1"), // 华东-浙江区 region id config.WithEndpointResolverWithOptions(aws.EndpointResolverWithOptionsFunc(func(service, region string, options ...interface{}) (aws.Endpoint, error) { return aws.Endpoint{ URL: "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint }, nil })), ) if err != nil { log.Fatalln(err) } // 取得了 sts.GetFederationTokenOutput.Credentials 后，可以使用这些临时凭证调用 S3 服务 listBucketsOutput, err := s3.NewFromConfig(cfg).ListBuckets(context.Background(), &s3.ListBucketsInput{}) if err != nil { log.Fatalln(err) } for _, bucket := range listBucketsOutput.Buckets { fmt.Printf("%s\n", aws.ToString(bucket.Name)) } } 以上内容是否对您有帮助？

AWS SDK for Java

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [开发指南](https://developer.qiniu.com/kodo/development_guidelines/8596/development- guidelines) > [AWS S3 兼容](https://developer.qiniu.com/kodo/development_guidelines/4086/aws-s3-compatible) > [兼容 SDK 示例](https://developer.qiniu.com/kodo/development_guidelines/12553/S3 SDK sample) > AWS SDK for Java # AWS SDK for Java 最近更新时间: 2024-02-19 17:12:51 # 导入 AWS SDK for Java 确保 Java v1.8 或更新版本和 Gradle 已经安装。 在 `build.gradle` 的 `dependencies` 代码块中增加如下代码 dependencies { implementation platform('software.amazon.awssdk:bom:2.20.151') implementation 'software.amazon.awssdk:s3' implementation 'software.amazon.awssdk:s3-transfer-manager' implementation 'software.amazon.awssdk:sts' } 以 `com.qiniu.s3.examples.App` 包为例，这里提供 `build.gradle` 的完整案例（Groovy DSL 版本） plugins { id 'application' } repositories { mavenCentral() } dependencies { implementation platform('software.amazon.awssdk:bom:2.20.151') implementation 'software.amazon.awssdk:s3' implementation 'software.amazon.awssdk:s3-transfer-manager' implementation 'software.amazon.awssdk:sts' testImplementation 'org.junit.jupiter:junit-jupiter:5.9.3' testRuntimeOnly 'org.junit.platform:junit-platform-launcher' implementation 'com.google.guava:guava:32.1.1-jre' } java { toolchain { languageVersion = JavaLanguageVersion.of(8) } } application { mainClass = 'com.qiniu.s3.examples.App' } tasks.named('test') { useJUnitPlatform() } 对于之后的每个代码示例，将代码创建在 `app/src/main/java/com/qiniu/s3/examples/App.java` 后，执行 gradle run 即可执行代码。 # 对象上传 ## 获取客户端上传 URL 创建 `app/src/main/java/com/qiniu/s3/examples/App.java` package com.qiniu.s3.examples; import java.net.URI; import java.time.Duration; import software.amazon.awssdk.auth.credentials.AwsBasicCredentials; import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider; import software.amazon.awssdk.regions.Region; import software.amazon.awssdk.services.s3.presigner.S3Presigner; import software.amazon.awssdk.services.s3.presigner.model.PresignedPutObjectRequest; public class App { public static void main(String[] args) { final S3Presigner presigner = S3Presigner.builder().region(Region.of("cn-east-1")) // 华东-浙江区 region id .endpointOverride(URI.create("https://s3.cn-east-1.qiniucs.com")) // 华东-浙江区 endpoint .credentialsProvider( StaticCredentialsProvider.create( AwsBasicCredentials.create("<QiniuAccessKey>", "<QiniuSecretKey>"))) .build(); final PresignedPutObjectRequest presignedPutObjectRequest = presigner .presignPutObject(b -> b.putObjectRequest(builder -> builder.bucket("<Bucket>").key("<Key>")) .signatureDuration(Duration.ofHours(1))); System.out.println(presignedPutObjectRequest.url()); } } 这段代码将生成一个经过预先签名的客户端上传 URL，有效期为一小时，客户端可以在有效时间内对该 URL 发送 HTTP PUT 请求将文件上传。 以下是用 curl 上传文件的案例： curl -X PUT --upload-file "<path/to/file>" "<presigned url>" ## 服务器端直传 ### 单请求上传（文件） 创建 `app/src/main/java/com/qiniu/s3/examples/App.java` package com.qiniu.s3.examples; import java.io.File; import java.net.URI; import software.amazon.awssdk.auth.credentials.AwsBasicCredentials; import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider; import software.amazon.awssdk.core.sync.RequestBody; import software.amazon.awssdk.regions.Region; import software.amazon.awssdk.services.s3.S3Client; import software.amazon.awssdk.services.s3.model.PutObjectResponse; public class App { public static void main(String[] args) { final S3Client s3 = S3Client.builder().region(Region.of("cn-east-1")) // 华东-浙江区 region id .endpointOverride(URI.create("https://s3.cn-east-1.qiniucs.com")) // 华东-浙江区 endpoint .credentialsProvider( StaticCredentialsProvider.create( AwsBasicCredentials.create("<QiniuAccessKey>", "<QiniuSecretKey>"))) .build(); final PutObjectResponse putObjectResponse = s3.putObject(b -> b.bucket("<Bucket>").key("<Key>"), RequestBody.fromFile(new File("<path/to/upload>"))); System.out.printf("ETag: %s\n", putObjectResponse.eTag()); } } ### 单请求上传（数据流） 创建 `app/src/main/java/com/qiniu/s3/examples/App.java` package com.qiniu.s3.examples; import java.io.FileInputStream; import java.io.IOException; import java.io.RandomAccessFile; import java.net.URI; import software.amazon.awssdk.auth.credentials.AwsBasicCredentials; import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider; import software.amazon.awssdk.core.sync.RequestBody; import software.amazon.awssdk.regions.Region; import software.amazon.awssdk.services.s3.S3Client; import software.amazon.awssdk.services.s3.model.PutObjectResponse; public class App { public static void main(String[] args) throws IOException { final S3Client s3 = S3Client.builder().region(Region.of("cn-east-1")) // 华东-浙江区 region id .endpointOverride(URI.create("https://s3.cn-east-1.qiniucs.com")) // 华东-浙江区 endpoint .credentialsProvider( StaticCredentialsProvider.create( AwsBasicCredentials.create("<QiniuAccessKey>", "<QiniuSecretKey>"))) .build(); try (final RandomAccessFile file = new RandomAccessFile("<path/to/upload>", "r")) { // 这里还是以文件作为数据流案例 final PutObjectResponse putObjectResponse = s3.putObject(b -> b.bucket("<Bucket>").key("<Key>"), RequestBody.fromInputStream(new FileInputStream(file.getFD()), file.length())); // AWS Java SDK 规定数据流必须给出大小，或是实现 ContentStreamProvider 接口实现数据流的重置 System.out.printf("ETag: %s\n", putObjectResponse.eTag()); } } } ### 分片上传（文件） 创建 `app/src/main/java/com/qiniu/s3/examples/App.java` package com.qiniu.s3.examples; import java.io.FileInputStream; import java.io.IOException; import java.io.InputStream; import java.net.URI; import java.util.Arrays; import java.util.List; import java.util.Vector; import software.amazon.awssdk.auth.credentials.AwsBasicCredentials; import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider; import software.amazon.awssdk.core.sync.RequestBody; import software.amazon.awssdk.regions.Region; import software.amazon.awssdk.services.s3.S3Client; import software.amazon.awssdk.services.s3.model.CompleteMultipartUploadResponse; import software.amazon.awssdk.services.s3.model.CompletedPart; import software.amazon.awssdk.services.s3.model.CreateMultipartUploadResponse; import software.amazon.awssdk.services.s3.model.UploadPartResponse; public class App { public static void main(String[] args) throws IOException { final S3Client s3 = S3Client.builder().region(Region.of("cn-east-1")) // 华东-浙江区 region id .endpointOverride(URI.create("https://s3.cn-east-1.qiniucs.com")) // 华东-浙江区 endpoint .credentialsProvider( StaticCredentialsProvider.create( AwsBasicCredentials.create("<QiniuAccessKey>", "<QiniuSecretKey>"))) .build(); final int PART_SIZE = 5 * 1024 * 1024; // 分片大小为 5 MB try (final InputStream inputStream = new FileInputStream("<path/to/upload>")) { final CreateMultipartUploadResponse createMultipartUploadResponse = s3 .createMultipartUpload(builder -> builder.bucket("<Bucket>").key("<Key>")); // 这里给出的案例是串行分片上传。可以自行改造成并行分片上传以进一步提升上传速度 final byte[] bytes = new byte[PART_SIZE]; final List<CompletedPart> parts = new Vector<>(); for (int partNumber = 1;; partNumber++) { final int haveRead = inputStream.read(bytes); if (haveRead <= 0) { break; } final int pn = partNumber; final UploadPartResponse uploadPartResponse = s3 .uploadPart(builder -> builder.bucket(createMultipartUploadResponse.bucket()) .key(createMultipartUploadResponse.key()) .uploadId(createMultipartUploadResponse.uploadId()).partNumber(pn), RequestBody.fromBytes(Arrays.copyOf(bytes, haveRead))); parts.add(CompletedPart.builder().eTag(uploadPartResponse.eTag()).partNumber(pn).build()); } final CompleteMultipartUploadResponse completeMultipartUploadResponse = s3 .completeMultipartUpload(builder -> builder.bucket(createMultipartUploadResponse.bucket()) .key(createMultipartUploadResponse.key()).uploadId(createMultipartUploadResponse.uploadId()) .multipartUpload(b -> b.parts(parts))); System.out.printf("ETag: %s\n", completeMultipartUploadResponse.eTag()); } } } ### 上传文件 创建 `app/src/main/java/com/qiniu/s3/examples/App.java` package com.qiniu.s3.examples; import java.io.File; import java.io.IOException; import java.net.URI; import software.amazon.awssdk.auth.credentials.AwsBasicCredentials; import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider; import software.amazon.awssdk.core.async.AsyncRequestBody; import software.amazon.awssdk.regions.Region; import software.amazon.awssdk.services.s3.S3AsyncClient; import software.amazon.awssdk.transfer.s3.S3TransferManager; import software.amazon.awssdk.transfer.s3.model.CompletedUpload; public class App { public static void main(String[] args) throws IOException { final S3AsyncClient s3 = S3AsyncClient.builder().region(Region.of("cn-east-1")) // 华东-浙江区 region id .endpointOverride(URI.create("https://s3.cn-east-1.qiniucs.com")) // 华东-浙江区 endpoint .credentialsProvider( StaticCredentialsProvider.create( AwsBasicCredentials.create("<QiniuAccessKey>", "<QiniuSecretKey>"))) .build(); final S3TransferManager transferManager = S3TransferManager.builder().s3Client(s3).build(); final CompletedUpload fileUpload = transferManager .upload(b -> b.putObjectRequest(builder -> builder.bucket("<Bucket>").key("<Key>")) .requestBody(AsyncRequestBody.fromFile(new File("<path/to/upload>")))) .completionFuture().join(); System.out.printf("ETag: %s\n", fileUpload.response().eTag()); } } ### 上传目录 创建 `app/src/main/java/com/qiniu/s3/examples/App.java` package com.qiniu.s3.examples; import java.io.IOException; import java.net.URI; import java.nio.file.Paths; import software.amazon.awssdk.auth.credentials.AwsBasicCredentials; import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider; import software.amazon.awssdk.regions.Region; import software.amazon.awssdk.services.s3.S3AsyncClient; import software.amazon.awssdk.transfer.s3.S3TransferManager; import software.amazon.awssdk.transfer.s3.model.CompletedDirectoryUpload; import software.amazon.awssdk.transfer.s3.model.DirectoryUpload; public class App { public static void main(String[] args) throws IOException { final S3AsyncClient s3 = S3AsyncClient.builder().region(Region.of("cn-east-1")) // 华东-浙江区 region id .endpointOverride(URI.create("https://s3.cn-east-1.qiniucs.com")) // 华东-浙江区 endpoint .credentialsProvider( StaticCredentialsProvider.create( AwsBasicCredentials.create("<QiniuAccessKey>", "<QiniuSecretKey>"))) .build(); final S3TransferManager transferManager = S3TransferManager.builder().s3Client(s3).build(); final DirectoryUpload directoryUpload = transferManager .uploadDirectory(b -> b.bucket("<Bucket>").source(Paths.get("<path/to/upload>")).s3Prefix("<KeyPrefix>")); final CompletedDirectoryUpload completedDirectoryUpload = directoryUpload.completionFuture().join(); completedDirectoryUpload.failedTransfers().forEach(System.out::println); } } # 对象下载 ## 获取客户端下载 URL 创建 `app/src/main/java/com/qiniu/s3/examples/App.java` package com.qiniu.s3.examples; import java.net.URI; import java.time.Duration; import software.amazon.awssdk.auth.credentials.AwsBasicCredentials; import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider; import software.amazon.awssdk.regions.Region; import software.amazon.awssdk.services.s3.presigner.S3Presigner; import software.amazon.awssdk.services.s3.presigner.model.PresignedGetObjectRequest; public class App { public static void main(String[] args) { final S3Presigner presigner = S3Presigner.builder().region(Region.of("cn-east-1")) // 华东-浙江区 region id .endpointOverride(URI.create("https://s3.cn-east-1.qiniucs.com")) // 华东-浙江区 endpoint .credentialsProvider( StaticCredentialsProvider.create( AwsBasicCredentials.create("<QiniuAccessKey>", "<QiniuSecretKey>"))) .build(); final PresignedGetObjectRequest presignedGetObjectRequest = presigner .presignGetObject(b -> b.getObjectRequest(builder -> builder.bucket("<Bucket>").key("<Key>")) .signatureDuration(Duration.ofHours(1))); System.out.println(presignedGetObjectRequest.url()); } } 这段代码将生成一个经过预先签名的客户端下载 URL，有效期为一小时，客户端可以在有效时间内对该 URL 发送 HTTP GET 请求将文件下载。 以下是用 curl 下载文件的案例： curl -o "<path/to/download>" "<presigned url>" ## 服务器端直接下载 创建 `app/src/main/java/com/qiniu/s3/examples/App.java` package com.qiniu.s3.examples; import java.io.File; import java.net.URI; import software.amazon.awssdk.auth.credentials.AwsBasicCredentials; import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider; import software.amazon.awssdk.regions.Region; import software.amazon.awssdk.services.s3.S3Client; import software.amazon.awssdk.services.s3.model.GetObjectResponse; public class App { public static void main(String[] args) { final S3Client s3 = S3Client.builder().region(Region.of("cn-east-1")) // 华东-浙江区 region id .endpointOverride(URI.create("https://s3.cn-east-1.qiniucs.com")) // 华东-浙江区 endpoint .credentialsProvider( StaticCredentialsProvider.create( AwsBasicCredentials.create("<QiniuAccessKey>", "<QiniuSecretKey>"))) .build(); final GetObjectResponse getObjectResponse = s3.getObject(b -> b.bucket("<Bucket>").key("<Key>"), new File("<path/to/upload>").toPath()); System.out.printf("ETag: %s\n", getObjectResponse.eTag()); } } ## 下载目录 创建 `app/src/main/java/com/qiniu/s3/examples/App.java` package com.qiniu.s3.examples; import java.io.IOException; import java.net.URI; import java.nio.file.Paths; import software.amazon.awssdk.auth.credentials.AwsBasicCredentials; import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider; import software.amazon.awssdk.regions.Region; import software.amazon.awssdk.services.s3.S3AsyncClient; import software.amazon.awssdk.transfer.s3.S3TransferManager; import software.amazon.awssdk.transfer.s3.model.CompletedDirectoryDownload; import software.amazon.awssdk.transfer.s3.model.DirectoryDownload; public class App { public static void main(String[] args) throws IOException { final S3AsyncClient s3 = S3AsyncClient.builder().region(Region.of("cn-east-1")) // 华东-浙江区 region id .endpointOverride(URI.create("https://s3.cn-east-1.qiniucs.com")) // 华东-浙江区 endpoint .credentialsProvider( StaticCredentialsProvider.create( AwsBasicCredentials.create("<QiniuAccessKey>", "<QiniuSecretKey>"))) .build(); final S3TransferManager transferManager = S3TransferManager.builder().s3Client(s3).build(); final DirectoryDownload directoryDownload = transferManager.downloadDirectory(b -> b.bucket("<Bucket>") .destination(Paths.get("<path/to/download>")).listObjectsV2RequestTransformer(l -> l.prefix("<KeyPrefix>"))); final CompletedDirectoryDownload completedDirectoryDownload = directoryDownload.completionFuture().join(); completedDirectoryDownload.failedTransfers().forEach(System.out::println); } } # 对象管理 ## 获取对象信息 创建 `app/src/main/java/com/qiniu/s3/examples/App.java` package com.qiniu.s3.examples; import java.net.URI; import software.amazon.awssdk.auth.credentials.AwsBasicCredentials; import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider; import software.amazon.awssdk.regions.Region; import software.amazon.awssdk.services.s3.S3Client; import software.amazon.awssdk.services.s3.model.HeadObjectResponse; public class App { public static void main(String[] args) { final S3Client s3 = S3Client.builder().region(Region.of("cn-east-1")) // 华东-浙江区 region id .endpointOverride(URI.create("https://s3.cn-east-1.qiniucs.com")) // 华东-浙江区 endpoint .credentialsProvider( StaticCredentialsProvider.create( AwsBasicCredentials.create("<QiniuAccessKey>", "<QiniuSecretKey>"))) .build(); final HeadObjectResponse headObjectResponse = s3.headObject(b -> b.bucket("<Bucket>").key("<Key>")); System.out.printf("ETag: %s\n", headObjectResponse.eTag()); } } ## 修改对象 MimeType 创建 `app/src/main/java/com/qiniu/s3/examples/App.java` package com.qiniu.s3.examples; import java.net.URI; import software.amazon.awssdk.auth.credentials.AwsBasicCredentials; import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider; import software.amazon.awssdk.regions.Region; import software.amazon.awssdk.services.s3.S3Client; import software.amazon.awssdk.services.s3.model.MetadataDirective; public class App { public static void main(String[] args) { final S3Client s3 = S3Client.builder().region(Region.of("cn-east-1")) // 华东-浙江区 region id .endpointOverride(URI.create("https://s3.cn-east-1.qiniucs.com")) // 华东-浙江区 endpoint .credentialsProvider( StaticCredentialsProvider.create( AwsBasicCredentials.create("<QiniuAccessKey>", "<QiniuSecretKey>"))) .build(); s3.copyObject(b -> b.sourceBucket("<Bucket>").sourceKey("<Key>").destinationBucket("<Bucket>").destinationKey("<Key>") .metadataDirective(MetadataDirective.REPLACE).contentType("<NewContentType>")); System.out.println("Done"); } } ## 修改对象存储类型 创建 `app/src/main/java/com/qiniu/s3/examples/App.java` package com.qiniu.s3.examples; import java.net.URI; import software.amazon.awssdk.auth.credentials.AwsBasicCredentials; import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider; import software.amazon.awssdk.regions.Region; import software.amazon.awssdk.services.s3.S3Client; import software.amazon.awssdk.services.s3.model.MetadataDirective; import software.amazon.awssdk.services.s3.model.StorageClass; public class App { public static void main(String[] args) { final S3Client s3 = S3Client.builder().region(Region.of("cn-east-1")) // 华东-浙江区 region id .endpointOverride(URI.create("https://s3.cn-east-1.qiniucs.com")) // 华东-浙江区 endpoint .credentialsProvider( StaticCredentialsProvider.create( AwsBasicCredentials.create("<QiniuAccessKey>", "<QiniuSecretKey>"))) .build(); s3.copyObject(b -> b.sourceBucket("<Bucket>").sourceKey("<Key>").destinationBucket("<Bucket>").destinationKey("<Key>") .metadataDirective(MetadataDirective.REPLACE).storageClass(StorageClass.GLACIER)); System.out.println("Done"); } } ## 复制对象副本 创建 `app/src/main/java/com/qiniu/s3/examples/App.java` package com.qiniu.s3.examples; import java.net.URI; import software.amazon.awssdk.auth.credentials.AwsBasicCredentials; import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider; import software.amazon.awssdk.regions.Region; import software.amazon.awssdk.services.s3.S3Client; import software.amazon.awssdk.services.s3.model.MetadataDirective; public class App { public static void main(String[] args) { final S3Client s3 = S3Client.builder().region(Region.of("cn-east-1")) // 华东-浙江区 region id .endpointOverride(URI.create("https://s3.cn-east-1.qiniucs.com")) // 华东-浙江区 endpoint .credentialsProvider( StaticCredentialsProvider.create( AwsBasicCredentials.create("<QiniuAccessKey>", "<QiniuSecretKey>"))) .build(); s3.copyObject(b -> b.sourceBucket("<FromBucket>").sourceKey("<FromKey>").destinationBucket("<ToBucket>").destinationKey("<ToKey>") .metadataDirective(MetadataDirective.COPY)); System.out.println("Done"); } } ## 复制对象副本（大于 5GB） 创建 `app/src/main/java/com/qiniu/s3/examples/App.java` package com.qiniu.s3.examples; import java.io.IOException; import java.net.URI; import java.util.List; import java.util.Vector; import software.amazon.awssdk.auth.credentials.AwsBasicCredentials; import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider; import software.amazon.awssdk.regions.Region; import software.amazon.awssdk.services.s3.S3Client; import software.amazon.awssdk.services.s3.model.CompleteMultipartUploadResponse; import software.amazon.awssdk.services.s3.model.CompletedPart; import software.amazon.awssdk.services.s3.model.CreateMultipartUploadResponse; import software.amazon.awssdk.services.s3.model.HeadObjectRequest; import software.amazon.awssdk.services.s3.model.HeadObjectResponse; import software.amazon.awssdk.services.s3.model.UploadPartCopyResponse; public class App { public static void main(String[] args) throws IOException { final S3Client s3 = S3Client.builder().region(Region.of("cn-east-1")) // 华东-浙江区 region id .endpointOverride(URI.create("https://s3.cn-east-1.qiniucs.com")) // 华东-浙江区 endpoint .credentialsProvider( StaticCredentialsProvider.create( AwsBasicCredentials.create("<QiniuAccessKey>", "<QiniuSecretKey>"))) .build(); final HeadObjectRequest headObjectRequest = HeadObjectRequest.builder().bucket("<FromBucket>").key("<FromKey>") .build(); final HeadObjectResponse headObjectResponse = s3.headObject(headObjectRequest); final CreateMultipartUploadResponse createMultipartUploadResponse = s3 .createMultipartUpload(b -> b.bucket("<ToBucket>").key("<ToKey>")); final List<CompletedPart> parts = new Vector<>(); final long PART_SIZE = 5 * 1024 * 1024; // 分片大小为 5 MB long copied = 0; // 这里给出的案例是串行分片复制。可以自行改造成并行分片复制以进一步提升复制速度 for (int partNumber = 1; copied < headObjectResponse.contentLength(); partNumber++) { final long partSize = Math.min(PART_SIZE, headObjectResponse.contentLength() - copied); final int pn = partNumber; final String copySourceRange = String.format("bytes=%d-%d", copied, copied + partSize - 1); final UploadPartCopyResponse uploadPartCopyResponse = s3 .uploadPartCopy(b -> b.sourceBucket(headObjectRequest.bucket()).sourceKey(headObjectRequest.key()) .destinationBucket(createMultipartUploadResponse.bucket()) .destinationKey(createMultipartUploadResponse.key()) .uploadId(createMultipartUploadResponse.uploadId()).partNumber(pn) .copySourceRange(copySourceRange)); parts.add(CompletedPart.builder().eTag(uploadPartCopyResponse.copyPartResult().eTag()).partNumber(pn) .build()); copied += partSize; } final CompleteMultipartUploadResponse completeMultipartUploadResponse = s3.completeMultipartUpload( b -> b.bucket(createMultipartUploadResponse.bucket()).key(createMultipartUploadResponse.key()) .uploadId(createMultipartUploadResponse.uploadId()) .multipartUpload(builder -> builder.parts(parts))); System.out.printf("ETag: %s\n", completeMultipartUploadResponse.eTag()); } } ## 删除空间中的文件 创建 `app/src/main/java/com/qiniu/s3/examples/App.java` package com.qiniu.s3.examples; import java.io.IOException; import java.net.URI; import software.amazon.awssdk.auth.credentials.AwsBasicCredentials; import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider; import software.amazon.awssdk.regions.Region; import software.amazon.awssdk.services.s3.S3Client; public class App { public static void main(String[] args) throws IOException { final S3Client s3 = S3Client.builder().region(Region.of("cn-east-1")) // 华东-浙江区 region id .endpointOverride(URI.create("https://s3.cn-east-1.qiniucs.com")) // 华东-浙江区 endpoint .credentialsProvider( StaticCredentialsProvider.create( AwsBasicCredentials.create("<QiniuAccessKey>", "<QiniuSecretKey>"))) .build(); s3.deleteObject(b -> b.bucket("<Bucket>").key("<Key>")); System.out.println("Done"); } } ## 获取指定前缀的文件列表 创建 `app/src/main/java/com/qiniu/s3/examples/App.java` package com.qiniu.s3.examples; import java.io.IOException; import java.net.URI; import software.amazon.awssdk.auth.credentials.AwsBasicCredentials; import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider; import software.amazon.awssdk.regions.Region; import software.amazon.awssdk.services.s3.S3Client; import software.amazon.awssdk.services.s3.model.ListObjectsV2Response; import software.amazon.awssdk.services.s3.model.S3Object; public class App { public static void main(String[] args) throws IOException { final S3Client s3 = S3Client.builder().region(Region.of("cn-east-1")) // 华东-浙江区 region id .endpointOverride(URI.create("https://s3.cn-east-1.qiniucs.com")) // 华东-浙江区 endpoint .credentialsProvider( StaticCredentialsProvider.create( AwsBasicCredentials.create("<QiniuAccessKey>", "<QiniuSecretKey>"))) .build(); final ListObjectsV2Response listObjectsV2Response = s3.listObjectsV2(b -> b.bucket("<Bucket>").prefix("<KeyPrefix>")); for (final S3Object s3Object : listObjectsV2Response.contents()) { System.out.printf("Key: %s\n", s3Object.key()); System.out.printf("ETag: %s\n", s3Object.eTag()); } } } ## 批量删除空间中的文件 创建 `app/src/main/java/com/qiniu/s3/examples/App.java` package com.qiniu.s3.examples; import java.io.IOException; import java.net.URI; import java.util.List; import java.util.Vector; import software.amazon.awssdk.auth.credentials.AwsBasicCredentials; import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider; import software.amazon.awssdk.regions.Region; import software.amazon.awssdk.services.s3.S3Client; import software.amazon.awssdk.services.s3.model.ObjectIdentifier; public class App { public static void main(String[] args) throws IOException { final S3Client s3 = S3Client.builder().region(Region.of("cn-east-1")) // 华东-浙江区 region id .endpointOverride(URI.create("https://s3.cn-east-1.qiniucs.com")) // 华东-浙江区 endpoint .credentialsProvider( StaticCredentialsProvider.create( AwsBasicCredentials.create("<QiniuAccessKey>", "<QiniuSecretKey>"))) .build(); final List<ObjectIdentifier> objectIdentifiers = new Vector<>(); objectIdentifiers.add(ObjectIdentifier.builder().key("<Key1>").build()); objectIdentifiers.add(ObjectIdentifier.builder().key("<Key2>").build()); objectIdentifiers.add(ObjectIdentifier.builder().key("<Key3>").build()); s3.deleteObjects(b -> b.bucket("<Bucket>").delete(builder -> builder.objects(objectIdentifiers))); System.out.println("Done"); } } # 临时安全凭证 创建 `app/src/main/java/com/qiniu/s3/examples/App.java` package com.qiniu.s3.examples; import java.io.IOException; import java.net.URI; import software.amazon.awssdk.auth.credentials.AwsBasicCredentials; import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider; import software.amazon.awssdk.regions.Region; import software.amazon.awssdk.services.s3.S3Client; import software.amazon.awssdk.services.s3.model.Bucket; import software.amazon.awssdk.services.s3.model.ListBucketsResponse; import software.amazon.awssdk.services.sts.StsClient; import software.amazon.awssdk.services.sts.auth.StsGetFederationTokenCredentialsProvider; public class App { public static void main(String[] args) throws IOException { final StsGetFederationTokenCredentialsProvider stsGetFederationTokenCredentialsProvider = StsGetFederationTokenCredentialsProvider .builder() .stsClient(StsClient.builder().region(Region.of("cn-east-1")) // 华东-浙江区 region id .endpointOverride(URI.create("https://s3.cn-east-1.qiniucs.com")) // 华东-浙江区 endpoint .credentialsProvider(StaticCredentialsProvider .create(AwsBasicCredentials.create("<QiniuAccessKey>", "<QiniuSecretKey>"))) .build()) .refreshRequest(builder -> builder.name("Bob") .durationSeconds(3600) .policy("{\"Version\":\"2012-10-17\",\"Statement\":[{\"Sid\":\"Stmt1\",\"Effect\":\"Allow\",\"Action\":[\"*\"],\"Resource\":[\"*\"]}]}")) .build(); final S3Client s3 = S3Client.builder().region(Region.of("cn-east-1")) // 华东-浙江区 region id .endpointOverride(URI.create("https://s3.cn-east-1.qiniucs.com")) // 华东-浙江区 endpoint .credentialsProvider(stsGetFederationTokenCredentialsProvider) .build(); // 可以使用这些临时凭证调用 S3 服务 final ListBucketsResponse listBucketsResponse = s3.listBuckets(); for (final Bucket bucket : listBucketsResponse.buckets()) { System.out.println(bucket.name()); } } } 以上内容是否对您有帮助？

AWS SDK for JavaScript

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [开发指南](https://developer.qiniu.com/kodo/development_guidelines/8596/development- guidelines) > [AWS S3 兼容](https://developer.qiniu.com/kodo/development_guidelines/4086/aws-s3-compatible) > [兼容 SDK 示例](https://developer.qiniu.com/kodo/development_guidelines/12553/S3 SDK sample) > AWS SDK for JavaScript # AWS SDK for JavaScript 最近更新时间: 2024-02-19 17:02:54 AWS SDK for JavaScript 可以同时支持 NodeJS 和浏览器。 # 从 NodeJS 导入 AWS SDK for JavaScript 确保 Node.js v13 或更高版本，并确保 npm，npx 已经安装。 初始化 TypeScript 项目 npm i [email protected] [email protected] @types/[email protected] --save-dev npx tsc --init 导入 AWS SDK for JavaScript npm i @aws-sdk/[email protected] @aws-sdk/[email protected] @aws-sdk/[email protected] @aws-sdk/[email protected] 对于之后的每个代码示例，将代码创建在 `index.ts` 后，执行 npx ts-node index.ts 即可执行代码。 # 从浏览器导入 AWS SDK for JavaScript AWS SDK for JavaScript 支持的浏览器列表可以参见[官方文档 __](https://docs.aws.amazon.com/sdk- for-javascript/v3/developer-guide/browsers-supported.html) 初始化 TypeScript 项目 npm i [email protected] [email protected] @webpack-cli/[email protected] [email protected] --save-dev npx webpack init 设置 `tsconfig.json`，确保以下选项被设置 { "compilerOptions": { "module": "NodeNext", "moduleResolution": "NodeNext" } } 导入 AWS SDK for JavaScript npm i @aws-sdk/[email protected] @aws-sdk/[email protected] @aws-sdk/[email protected] @aws-sdk/[email protected] 执行 Webpack npm run build 启动 Webpack dev server npx webpack serve 该命令会自动启动浏览器，导入 `src/index.ts`，执行代码。 需要注意：从浏览器访问 S3 接口可能需要修改跨域配置。另外以下部分代码实例因为使用了 NodeJS 库因此不适用于浏览器场景。 # 对象上传 ## 获取客户端上传 URL 创建 `index.ts` import { getSignedUrl } from "@aws-sdk/s3-request-presigner"; import { S3Client, PutObjectCommand } from "@aws-sdk/client-s3"; const s3 = new S3Client({ region: "cn-east-1", // 华东-浙江区 region id endpoint: "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint credentials: { accessKeyId: "<AccessKey>", secretAccessKey: "<SecretKey>", }, }); getSignedUrl(s3, new PutObjectCommand({ Bucket: "<Bucket>", Key: "<Key>" })) .then((data) => { console.log(data); }) .catch((err) => { console.error(err); }); 这段代码将生成一个经过预先签名的客户端上传 URL，有效期为 900 秒，客户端可以在过期时间内对该 URL 发送 HTTP PUT 请求将文件上传。 以下是用 curl 上传文件的案例： curl -X PUT --upload-file "<path/to/file>" "<presigned url>" 您也可以自行指定上传凭证的有效期，例如： import { getSignedUrl } from "@aws-sdk/s3-request-presigner"; import { S3Client, PutObjectCommand } from "@aws-sdk/client-s3"; const s3 = new S3Client({ region: "cn-east-1", // 华东-浙江区 region id endpoint: "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint credentials: { accessKeyId: "<AccessKey>", secretAccessKey: "<SecretKey>", }, }); getSignedUrl(s3, new PutObjectCommand({ Bucket: "<Bucket>", Key: "<Key>" }), { expiresIn: 3600, }) .then((data) => { console.log(data); }) .catch((err) => { console.error(err); }); ## 服务器端直传 ### 单请求上传（文件） 创建 `index.ts` import * as fs from "fs"; import { S3Client, PutObjectCommand } from "@aws-sdk/client-s3"; const s3 = new S3Client({ region: "cn-east-1", // 华东-浙江区 region id endpoint: "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint credentials: { accessKeyId: "<AccessKey>", secretAccessKey: "<SecretKey>", }, }); const fileStream = fs.createReadStream("<path/to/upload>"); fileStream.on("error", (err) => console.error(err)); s3.send( new PutObjectCommand({ Bucket: "<Bucket>", Key: "<Key>", Body: fileStream }) ) .then((data) => console.log(data)) .catch((err) => console.error(err)); ### 单请求上传（数据流） 创建 `index.ts` import { Readable } from "stream"; import { S3Client, PutObjectCommand } from "@aws-sdk/client-s3"; const s3 = new S3Client({ region: "cn-east-1", // 华东-浙江区 region id endpoint: "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint credentials: { accessKeyId: "<AccessKey>", secretAccessKey: "<SecretKey>", }, }); s3.send( new PutObjectCommand({ Bucket: "<Bucket>", Key: "<Key>", Body: Readable.from("Hello, Qiniu S3!"), }) ) .then((data) => console.log(data)) .catch((err) => console.error(err)); ### 分片上传（文件） 创建 `index.ts` import * as fs from "fs"; import { StreamingBlobPayloadInputTypes } from "@smithy/types"; import { S3Client, CreateMultipartUploadCommand, CreateMultipartUploadCommandOutput, UploadPartCommand, UploadPartCommandOutput, CompletedPart, CompleteMultipartUploadCommand, CompleteMultipartUploadCommandOutput, } from "@aws-sdk/client-s3"; async function createMultipartUpload( s3: S3Client, bucket: string, key: string ): Promise<CreateMultipartUploadCommandOutput> { return s3.send( new CreateMultipartUploadCommand({ Bucket: bucket, Key: key, }) ); } async function uploadPart( s3: S3Client, bucket: string, key: string, uploadId: string, partNumber: number, body: StreamingBlobPayloadInputTypes, contentLength: number ): Promise<UploadPartCommandOutput> { return s3.send( new UploadPartCommand({ Bucket: bucket, Key: key, UploadId: uploadId, PartNumber: partNumber, Body: body, ContentLength: contentLength, }) ); } async function completeMultipartUpload( s3: S3Client, bucket: string, key: string, uploadId: string, parts: CompletedPart[] ): Promise<CompleteMultipartUploadCommandOutput> { const cmd = new CompleteMultipartUploadCommand({ Bucket: bucket, Key: key, UploadId: uploadId, MultipartUpload: { Parts: parts, }, }); return s3.send(cmd); } async function uploadParts( s3: S3Client, bucket: string, key: string, uploadId: string, filePath: string | Buffer | URL ): Promise<CompletedPart[]> { const PART_SIZE = 5 * 1024 * 1024; // 分片大小为 5 MB const { size: fileSize } = await fs.promises.stat(filePath); const parts: CompletedPart[] = []; // 这里给出的案例是串行分片上传。可以自行改造成并行分片上传以进一步提升上传速度 for ( let offset = 0, partNum = 1; offset < fileSize; offset += PART_SIZE, partNum++ ) { const options = { start: offset, end: Math.min(offset + PART_SIZE, fileSize) - 1, }; const uploadPartCommandOutput = await uploadPart( s3, bucket, key, uploadId, partNum, fs.createReadStream(filePath, options), options.end + 1 - options.start ); parts.push({ PartNumber: partNum, ETag: uploadPartCommandOutput.ETag }); } return parts; } async function uploadFile( s3: S3Client, bucket: string, key: string, filePath: string | Buffer | URL ): Promise<CompleteMultipartUploadCommandOutput> { const createMultipartUploadCommandOutput = await createMultipartUpload( s3, bucket, key ); const completedParts = await uploadParts( s3, bucket, key, createMultipartUploadCommandOutput.UploadId!, filePath ); return await completeMultipartUpload( s3, bucket, key, createMultipartUploadCommandOutput.UploadId!, completedParts ); } const s3 = new S3Client({ region: "cn-east-1", // 华东-浙江区 region id endpoint: "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint credentials: { accessKeyId: "<AccessKey>", secretAccessKey: "<SecretKey>", }, }); uploadFile(s3, "<Bucket>", "<Key>", "<path/to/upload>") .then((data) => console.log(data)) .catch((err) => console.error(err)); ### 上传文件 创建 `index.ts` import { Upload } from "@aws-sdk/lib-storage"; import { S3Client } from "@aws-sdk/client-s3"; import * as fs from "fs"; const s3 = new S3Client({ region: "cn-east-1", // 华东-浙江区 region id endpoint: "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint credentials: { accessKeyId: "<AccessKey>", secretAccessKey: "<SecretKey>", }, }); const upload = new Upload({ client: s3, params: { Bucket: "<Bucket>", Key: "<Key>", Body: fs.createReadStream("<path/to/upload>"), }, }); upload .done() .then((resp) => { if ((resp as CompleteMultipartUploadCommandOutput).ETag) { console.log("ETag:", (resp as CompleteMultipartUploadCommandOutput).ETag); } else { console.log("Aborted"); } }) .catch((err) => { console.error("Error:", err); }); # 对象下载 ## 获取客户端下载 URL 创建 `index.ts` import { getSignedUrl } from "@aws-sdk/s3-request-presigner"; import { S3Client, GetObjectCommand } from "@aws-sdk/client-s3"; const s3 = new S3Client({ region: "cn-east-1", // 华东-浙江区 region id endpoint: "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint credentials: { accessKeyId: "<AccessKey>", secretAccessKey: "<SecretKey>", }, }); getSignedUrl(s3, new GetObjectCommand({ Bucket: "<Bucket>", Key: "<Key>" })) .then((data) => { console.log(data); }) .catch((err) => { console.error(err); }); 这段代码将生成一个经过预先签名的客户端下载 URL，有效期为 900 秒，客户端可以在过期时间内对该 URL 发送 HTTP GET 请求将文件下载。 以下是用 curl 下载文件的案例： curl -o "<path/to/download>" "<presigned url>" 您也可以自行指定下载凭证的有效期，例如： import { getSignedUrl } from "@aws-sdk/s3-request-presigner"; import { S3Client, GetObjectCommand } from "@aws-sdk/client-s3"; const s3 = new S3Client({ region: "cn-east-1", // 华东-浙江区 region id endpoint: "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint credentials: { accessKeyId: "<AccessKey>", secretAccessKey: "<SecretKey>", }, }); getSignedUrl(s3, new GetObjectCommand({ Bucket: "<Bucket>", Key: "<Key>" }), { expiresIn: 3600, }) .then((data) => { console.log(data); }) .catch((err) => { console.error(err); }); ## 服务器端直接下载 创建 `index.ts` import * as fs from "fs"; import { S3Client, GetObjectCommand, GetObjectCommandOutput, } from "@aws-sdk/client-s3"; import { Writable } from "stream"; import Readable from "stream"; async function getObject( s3: S3Client, bucket: string, key: string, writable: Writable ): Promise<GetObjectCommandOutput> { const getObjectCommandOutput = await s3.send( new GetObjectCommand({ Bucket: bucket, Key: key, }) ); if (getObjectCommandOutput.Body) { (getObjectCommandOutput.Body as Readable).pipe(writable); } return getObjectCommandOutput; } const s3 = new S3Client({ region: "cn-east-1", // 华东-浙江区 region id endpoint: "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint credentials: { accessKeyId: "<AccessKey>", secretAccessKey: "<SecretKey>", }, }); getObject(s3, "<Bucket>", "<Key>", fs.createWriteStream("<path/to/download>")) .then((data) => console.log(data)) .catch((err) => console.error(err)); # 对象管理 ## 获取对象信息 创建 `index.ts` import { S3Client, HeadObjectCommand } from "@aws-sdk/client-s3"; const s3 = new S3Client({ region: "cn-east-1", // 华东-浙江区 region id endpoint: "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint credentials: { accessKeyId: "<AccessKey>", secretAccessKey: "<SecretKey>", }, }); s3.send( new HeadObjectCommand({ Bucket: "<Bucket>", Key: "<Key>", }) ) .then((data) => console.log(data)) .catch((err) => console.error(err)); ## 修改对象 MimeType 创建 `index.ts` import { S3Client, CopyObjectCommand } from "@aws-sdk/client-s3"; const s3 = new S3Client({ region: "cn-east-1", // 华东-浙江区 region id endpoint: "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint credentials: { accessKeyId: "<AccessKey>", secretAccessKey: "<SecretKey>", }, }); s3.send( new CopyObjectCommand({ Bucket: "<Bucket>", Key: "<Key>", CopySource: "/<Bucket>/<Key>", ContentType: "<NewContentType>", MetadataDirective: "REPLACE", }) ) .then((data) => console.log(data)) .catch((err) => console.error(err)); ## 修改对象存储类型 创建 `index.ts` import { S3Client, CopyObjectCommand } from "@aws-sdk/client-s3"; const s3 = new S3Client({ region: "cn-east-1", // 华东-浙江区 region id endpoint: "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint credentials: { accessKeyId: "<AccessKey>", secretAccessKey: "<SecretKey>", }, }); s3.send( new CopyObjectCommand({ Bucket: "<Bucket>", Key: "<Key>", CopySource: "/<Bucket>/<Key>", StorageClass: "GLACIER", MetadataDirective: "REPLACE", }) ) .then((data) => console.log(data)) .catch((err) => console.error(err)); ## 复制对象副本 创建 `index.ts` import { S3Client, CopyObjectCommand } from "@aws-sdk/client-s3"; const s3 = new S3Client({ region: "cn-east-1", // 华东-浙江区 region id endpoint: "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint credentials: { accessKeyId: "<AccessKey>", secretAccessKey: "<SecretKey>", }, }); s3.send( new CopyObjectCommand({ Bucket: "<ToBucket>", Key: "<ToKey>", CopySource: "/<FromBucket>/<ToBucket>", MetadataDirective: "COPY", }) ) .then((data) => console.log(data)) .catch((err) => console.error(err)); ## 复制对象副本（大于 5GB） 创建 `index.ts` import * as fs from "fs"; import { S3Client, CreateMultipartUploadCommand, CreateMultipartUploadCommandOutput, UploadPartCopyCommand, UploadPartCopyCommandOutput, CompletedPart, CompleteMultipartUploadCommand, CompleteMultipartUploadCommandOutput, HeadObjectCommand, HeadObjectCommandOutput, } from "@aws-sdk/client-s3"; async function createMultipartUpload( s3: S3Client, bucket: string, key: string ): Promise<CreateMultipartUploadCommandOutput> { return s3.send( new CreateMultipartUploadCommand({ Bucket: bucket, Key: key, }) ); } async function uploadPartCopy( s3: S3Client, fromBucket: string, fromKey: string, toBucket: string, toKey: string, uploadId: string, partNumber: number, from: number, end: number ): Promise<UploadPartCopyCommandOutput> { return s3.send( new UploadPartCopyCommand({ Bucket: toBucket, Key: toKey, UploadId: uploadId, PartNumber: partNumber, CopySource: "/" + fromBucket + "/" + fromKey, CopySourceRange: "bytes=" + from + "-" + (end - 1), }) ); } async function completeMultipartUpload( s3: S3Client, bucket: string, key: string, uploadId: string, parts: CompletedPart[] ): Promise<CompleteMultipartUploadCommandOutput> { const cmd = new CompleteMultipartUploadCommand({ Bucket: bucket, Key: key, UploadId: uploadId, MultipartUpload: { Parts: parts, }, }); return s3.send(cmd); } async function uploadPartsCopy( s3: S3Client, fromBucket: string, fromKey: string, toBucket: string, toKey: string, uploadId: string ): Promise<CompletedPart[]> { const PART_SIZE = 5 * 1024 * 1024; // 分片大小为 5 MB const headObjectCommand = await s3.send( new HeadObjectCommand({ Bucket: fromBucket, Key: fromKey, }) ); const contentLength: number = headObjectCommand.ContentLength!; const parts: CompletedPart[] = []; // 这里给出的案例是串行分片复制。可以自行改造成并行分片复制以进一步提升复制速度 for ( let offset = 0, partNum = 1; offset < contentLength; offset += PART_SIZE, partNum++ ) { const uploadPartCommandOutput = await uploadPartCopy( s3, fromBucket, fromKey, toBucket, toKey, uploadId, partNum, offset, Math.min(offset + PART_SIZE, contentLength) ); parts.push({ PartNumber: partNum, ETag: uploadPartCommandOutput.CopyPartResult!.ETag, }); } return parts; } async function copyFile( s3: S3Client, fromBucket: string, fromKey: string, toBucket: string, toKey: string ): Promise<CompleteMultipartUploadCommandOutput> { const createMultipartUploadCommandOutput = await createMultipartUpload( s3, toBucket, toKey ); const completedParts = await uploadPartsCopy( s3, fromBucket, fromKey, toBucket, toKey, createMultipartUploadCommandOutput.UploadId! ); return await completeMultipartUpload( s3, toBucket, toKey, createMultipartUploadCommandOutput.UploadId!, completedParts ); } const s3 = new S3Client({ region: "cn-east-1", // 华东-浙江区 region id endpoint: "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint credentials: { accessKeyId: "<AccessKey>", secretAccessKey: "<SecretKey>", }, }); copyFile(s3, "<FromBucket>", "<FromKey>", "<ToBucket>", "<ToKey>") .then((data) => console.log(data)) .catch((err) => console.error(err)); ## 删除空间中的文件 创建 `index.ts` import { S3Client, DeleteObjectCommand } from "@aws-sdk/client-s3"; const s3 = new S3Client({ region: "cn-east-1", // 华东-浙江区 region id endpoint: "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint credentials: { accessKeyId: "<AccessKey>", secretAccessKey: "<SecretKey>", }, }); s3.send( new DeleteObjectCommand({ Bucket: "<"Bucket>", Key: "<Key>", }) ) .then((data) => console.log(data)) .catch((err) => console.error(err)); ## 获取指定前缀的文件列表 创建 `index.ts` import { S3Client, ListObjectsCommand } from "@aws-sdk/client-s3"; const s3 = new S3Client({ region: "cn-east-1", // 华东-浙江区 region id endpoint: "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint credentials: { accessKeyId: "<AccessKey>", secretAccessKey: "<SecretKey>", }, }); s3.send( new ListObjectsCommand({ Bucket: "<Bucket>", Prefix: "<KeyPrefix>", }) ) .then(({ Contents: contents }) => console.log(contents)) .catch((err) => console.error(err)); ## 批量删除空间中的文件 创建 `index.ts` import { S3Client, DeleteObjectsCommand } from "@aws-sdk/client-s3"; const s3 = new S3Client({ region: "cn-east-1", // 华东-浙江区 region id endpoint: "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint credentials: { accessKeyId: "<AccessKey>", secretAccessKey: "<SecretKey>", }, }); s3.send( new DeleteObjectsCommand({ Bucket: "<Bucket>", Delete: { Objects: [ { Key: "<Key1>", }, { Key: "<Key2>", }, { Key: "<Key3>", }, ], }, }) ) .then((data) => console.log(data)) .catch((err) => console.error(err)); # 临时安全凭证 创建 `index.ts` import { ListBucketsCommand, S3Client } from "@aws-sdk/client-s3"; import { STSClient, GetFederationTokenCommand } from "@aws-sdk/client-sts"; const sts = new STSClient({ region: 'cn-east-1', // 华东-浙江区 region id endpoint: 'https://s3.cn-east-1.qiniucs.com', // 华东-浙江区 endpoint credentials: { accessKeyId: '<AccessKey>', secretAccessKey: '<SecretKey>', }, }); sts.send(new GetFederationTokenCommand({ Name: 'Bob', DurationSeconds: 3600, Policy: '{"Version":"2012-10-17","Statement":[{"Sid":"Stmt1","Effect":"Allow","Action":["*"],"Resource":["*"]}]}', })) .then((getFederationTokenOutput) => { const s3 = new S3Client({ region: 'cn-east-1', // 华东-浙江区 region id endpoint: 'https://s3.cn-east-1.qiniucs.com', // 华东-浙江区 endpoint credentials: { accessKeyId: getFederationTokenOutput.Credentials!!.AccessKeyId!, secretAccessKey: getFederationTokenOutput.Credentials!!.SecretAccessKey!, sessionToken: getFederationTokenOutput.Credentials!!.SessionToken!, expiration: getFederationTokenOutput.Credentials!!.Expiration!, }, }); // 可以使用这些临时凭证调用 S3 服务 s3.send(new ListBucketsCommand({})) .then((listBucketsOutput) => { for (const bucket of listBucketsOutput.Buckets!) { console.log(bucket.Name); } }) .catch((err) => console.error(err)); }) .catch((err) => console.error(err)); 以上内容是否对您有帮助？

AWS SDK for Kotlin

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [开发指南](https://developer.qiniu.com/kodo/development_guidelines/8596/development- guidelines) > [AWS S3 兼容](https://developer.qiniu.com/kodo/development_guidelines/4086/aws-s3-compatible) > [兼容 SDK 示例](https://developer.qiniu.com/kodo/development_guidelines/12553/S3 SDK sample) > AWS SDK for Kotlin # AWS SDK for Kotlin 最近更新时间: 2024-02-19 17:03:02 # 导入 AWS SDK for Kotlin 确保 Java 11 或更新版本和 Gradle 已经安装。 在 `build.gradle.kts` 的 `dependencies` 代码块中增加如下代码 dependencies { implementation("aws.sdk.kotlin:s3:1.0.50") implementation("aws.sdk.kotlin:sts:1.0.50") } 以 `com.qiniu.s3.examples.App` 包为例，这里提供 `build.gradle.kts` 的完整案例（Kotlin DSL 版本） plugins { id("org.jetbrains.kotlin.jvm") version "1.9.0" application } repositories { mavenCentral() } dependencies { implementation("aws.sdk.kotlin:s3:1.0.50") implementation("aws.sdk.kotlin:sts:1.0.50") testImplementation("org.jetbrains.kotlin:kotlin-test-junit5") testImplementation("org.junit.jupiter:junit-jupiter-engine:5.9.3") testRuntimeOnly("org.junit.platform:junit-platform-launcher") implementation("com.google.guava:guava:32.1.1-jre") } java { toolchain { languageVersion.set(JavaLanguageVersion.of(11)) } } application { mainClass.set("com.qiniu.s3.examples.AppKt") } tasks.named<Test>("test") { useJUnitPlatform() } 对于之后的每个代码示例，将代码创建在 `app/src/main/kotlin/com/qiniu/s3/examples/App.kt` 后，执行 gradle run 即可执行代码。 # 对象上传 ## 获取客户端上传 URL 创建 `app/src/main/kotlin/com/qiniu/s3/examples/App.kt` package com.qiniu.s3.examples import aws.sdk.kotlin.runtime.auth.credentials.StaticCredentialsProvider import aws.sdk.kotlin.services.s3.S3Client import aws.sdk.kotlin.services.s3.model.PutObjectRequest import aws.sdk.kotlin.services.s3.presigners.presignPutObject import aws.smithy.kotlin.runtime.net.url.Url import kotlin.time.Duration.Companion.days import kotlinx.coroutines.runBlocking fun main(): Unit = runBlocking { val s3Client = S3Client { credentialsProvider = StaticCredentialsProvider { accessKeyId = "<QiniuAccessKey>" secretAccessKey = "<QiniuSecretKey>" } region = "cn-east-1" // 华东-浙江区 region id endpointUrl = Url.parse("https://s3.cn-east-1.qiniucs.com") // 华东-浙江区 endpoint } val putObjectRequest = PutObjectRequest { bucket = "<Bucket>" key = "<Key>" } val presignedRequest = s3Client.presignPutObject(putObjectRequest, 1.days) println(presignedRequest.url) } 这段代码将生成一个经过预先签名的客户端上传 URL，有效期为 24 小时，客户端可以在过期时间内对该 URL 发送 HTTP PUT 请求将文件上传。 以下是用 curl 上传文件的案例： curl -X PUT --upload-file "<path/to/file>" "<presigned url>" ## 服务器端直传 ### 单请求上传（文件） 创建 `app/src/main/kotlin/com/qiniu/s3/examples/App.kt` package com.qiniu.s3.examples import aws.sdk.kotlin.runtime.auth.credentials.StaticCredentialsProvider import aws.sdk.kotlin.services.s3.S3Client import aws.sdk.kotlin.services.s3.model.PutObjectRequest import aws.smithy.kotlin.runtime.content.ByteStream import aws.smithy.kotlin.runtime.content.fromFile import aws.smithy.kotlin.runtime.net.url.Url import java.io.File import kotlinx.coroutines.runBlocking fun main(): Unit = runBlocking { val s3Client = S3Client { credentialsProvider = StaticCredentialsProvider { accessKeyId = "<QiniuAccessKey>" secretAccessKey = "<QiniuSecretKey>" } region = "cn-east-1" // 华东-浙江区 region id endpointUrl = Url.parse("https://s3.cn-east-1.qiniucs.com") // 华东-浙江区 endpoint } val putObjectRequest = PutObjectRequest { bucket = "<Bucket>" key = "<Key>" body = ByteStream.fromFile(File("<path/to/upload>")) } val presignedResponse = s3Client.putObject(putObjectRequest) println("ETag: ${presignedResponse.eTag}") } ### 单请求上传（数据流） 创建 `app/src/main/kotlin/com/qiniu/s3/examples/App.kt` package com.qiniu.s3.examples import aws.sdk.kotlin.runtime.auth.credentials.StaticCredentialsProvider import aws.sdk.kotlin.services.s3.S3Client import aws.sdk.kotlin.services.s3.model.PutObjectRequest import aws.smithy.kotlin.runtime.content.ByteStream import aws.smithy.kotlin.runtime.net.url.Url import kotlinx.coroutines.runBlocking fun main(): Unit = runBlocking { val s3Client = S3Client { credentialsProvider = StaticCredentialsProvider { accessKeyId = "<QiniuAccessKey>" secretAccessKey = "<QiniuSecretKey>" } region = "cn-east-1" // 华东-浙江区 region id endpointUrl = Url.parse("https://s3.cn-east-1.qiniucs.com") // 华东-浙江区 endpoint } val putObjectRequest = PutObjectRequest { bucket = "<Bucket>" key = "<Key>" body = ByteStream.fromString("Hello from Qiniu S3!") } val presignedResponse = s3Client.putObject(putObjectRequest) println("ETag: ${presignedResponse.eTag}") } ### 分片上传（文件） 创建 `app/src/main/kotlin/com/qiniu/s3/examples/App.kt` package com.qiniu.s3.examples import aws.sdk.kotlin.runtime.auth.credentials.StaticCredentialsProvider import aws.sdk.kotlin.services.s3.S3Client import aws.sdk.kotlin.services.s3.model.CompleteMultipartUploadRequest import aws.sdk.kotlin.services.s3.model.CompletedPart import aws.sdk.kotlin.services.s3.model.CreateMultipartUploadRequest import aws.sdk.kotlin.services.s3.model.UploadPartRequest import aws.smithy.kotlin.runtime.content.ByteStream import aws.smithy.kotlin.runtime.net.url.Url import java.io.File import java.util.Vector import kotlinx.coroutines.runBlocking fun main(): Unit = runBlocking { val s3Client = S3Client { credentialsProvider = StaticCredentialsProvider { accessKeyId = "<QiniuAccessKey>" secretAccessKey = "<QiniuSecretKey>" } region = "cn-east-1" // 华东-浙江区 region id endpointUrl = Url.parse("https://s3.cn-east-1.qiniucs.com") // 华东-浙江区 endpoint } val createMultipartUploadRequest = CreateMultipartUploadRequest { bucket = "<Bucket>" key = "<Key>" } val createMultipartUploadResponse = s3Client.createMultipartUpload(createMultipartUploadRequest) val PART_SIZE = 5 * 1024 * 1024 // 分片大小为 5 MB val partBuf = ByteArray(PART_SIZE) val completedParts: Vector<CompletedPart> = Vector() // 这里给出的案例是串行分片上传。可以自行改造成并行分片上传以进一步提升上传速度 File("<path/to/upload>").inputStream().buffered().use { file -> var pn = 1 while (true) { val haveRead = file.read(partBuf) if (haveRead <= 0) { break } val uploadPartRequest = UploadPartRequest { bucket = createMultipartUploadRequest.bucket key = createMultipartUploadRequest.key uploadId = createMultipartUploadResponse.uploadId partNumber = pn body = ByteStream.fromBytes(partBuf.copyOf(haveRead)) } val uploadPartResponse = s3Client.uploadPart(uploadPartRequest) completedParts.add( CompletedPart { eTag = uploadPartResponse.eTag partNumber = pn } ) pn++ } } val completeMultipartUploadRequest = CompleteMultipartUploadRequest { bucket = createMultipartUploadRequest.bucket key = createMultipartUploadRequest.key uploadId = createMultipartUploadResponse.uploadId multipartUpload { parts = completedParts } } val completeMultipartUploadResponse = s3Client.completeMultipartUpload(completeMultipartUploadRequest) println("ETag: ${completeMultipartUploadResponse.eTag}") } # 对象下载 ## 获取客户端下载 URL 创建 `app/src/main/kotlin/com/qiniu/s3/examples/App.kt` package com.qiniu.s3.examples import aws.sdk.kotlin.runtime.auth.credentials.StaticCredentialsProvider import aws.sdk.kotlin.services.s3.S3Client import aws.sdk.kotlin.services.s3.model.GetObjectRequest import aws.sdk.kotlin.services.s3.presigners.presignGetObject import aws.smithy.kotlin.runtime.net.url.Url import kotlin.time.Duration.Companion.days import kotlinx.coroutines.runBlocking fun main(): Unit = runBlocking { val s3Client = S3Client { credentialsProvider = StaticCredentialsProvider { accessKeyId = "<QiniuAccessKey>" secretAccessKey = "<QiniuSecretKey>" } region = "cn-east-1" // 华东-浙江区 region id endpointUrl = Url.parse("https://s3.cn-east-1.qiniucs.com") // 华东-浙江区 endpoint } val getObjectRequest = GetObjectRequest { bucket = "<Bucket>" key = "<Key>" } val presignedRequest = s3Client.presignGetObject(getObjectRequest, 1.days) println(presignedRequest.url) } 这段代码将生成一个经过预先签名的客户端下载 URL，有效期为 24 小时，客户端可以在过期时间内对该 URL 发送 HTTP GET 请求将文件下载。 以下是用 curl 下载文件的案例： curl -o "<path/to/download>" "<presigned url>" ## 服务器端直接下载 创建 `app/src/main/kotlin/com/qiniu/s3/examples/App.kt` package com.qiniu.s3.examples import aws.sdk.kotlin.runtime.auth.credentials.StaticCredentialsProvider import aws.sdk.kotlin.services.s3.S3Client import aws.sdk.kotlin.services.s3.model.GetObjectRequest import aws.smithy.kotlin.runtime.content.writeToFile import aws.smithy.kotlin.runtime.net.url.Url import java.io.File import kotlinx.coroutines.runBlocking fun main(): Unit = runBlocking { val s3Client = S3Client { credentialsProvider = StaticCredentialsProvider { accessKeyId = "<QiniuAccessKey>" secretAccessKey = "<QiniuSecretKey>" } region = "cn-east-1" // 华东-浙江区 region id endpointUrl = Url.parse("https://s3.cn-east-1.qiniucs.com") // 华东-浙江区 endpoint } val getObjectRequest = GetObjectRequest { bucket = "<Bucket>" key = "<Key>" } s3Client.getObject(getObjectRequest) { resp -> resp.body?.writeToFile(File("<path/to/download>")) println("ETag: ${resp.eTag}") } } # 对象管理 ## 获取对象信息 创建 `app/src/main/kotlin/com/qiniu/s3/examples/App.kt` package com.qiniu.s3.examples import aws.sdk.kotlin.runtime.auth.credentials.StaticCredentialsProvider import aws.sdk.kotlin.services.s3.S3Client import aws.sdk.kotlin.services.s3.model.HeadObjectRequest import aws.smithy.kotlin.runtime.net.url.Url import kotlinx.coroutines.runBlocking fun main(): Unit = runBlocking { val s3Client = S3Client { credentialsProvider = StaticCredentialsProvider { accessKeyId = "<QiniuAccessKey>" secretAccessKey = "<QiniuSecretKey>" } region = "cn-east-1" // 华东-浙江区 region id endpointUrl = Url.parse("https://s3.cn-east-1.qiniucs.com") // 华东-浙江区 endpoint } val headObjectRequest = HeadObjectRequest { bucket = "<Bucket>" key = "<Key>" } val headObjectResponse = s3Client.headObject(headObjectRequest) println("ETag: ${headObjectResponse.eTag}") } ## 修改对象 MimeType 创建 `app/src/main/kotlin/com/qiniu/s3/examples/App.kt` package com.qiniu.s3.examples import aws.sdk.kotlin.runtime.auth.credentials.StaticCredentialsProvider import aws.sdk.kotlin.services.s3.S3Client import aws.sdk.kotlin.services.s3.model.CopyObjectRequest import aws.sdk.kotlin.services.s3.model.MetadataDirective import aws.smithy.kotlin.runtime.net.url.Url import kotlinx.coroutines.runBlocking fun main(): Unit = runBlocking { val s3Client = S3Client { credentialsProvider = StaticCredentialsProvider { accessKeyId = "<QiniuAccessKey>" secretAccessKey = "<QiniuSecretKey>" } region = "cn-east-1" // 华东-浙江区 region id endpointUrl = Url.parse("https://s3.cn-east-1.qiniucs.com") // 华东-浙江区 endpoint } val copyObjectRequest = CopyObjectRequest { bucket = "<Bucket>" key = "<Key>" copySource = "/<Bucket>/<Key>" contentType = "<NewContentType>" metadataDirective = MetadataDirective.Replace } s3Client.copyObject(copyObjectRequest) println("Done") } ## 修改对象存储类型 创建 `app/src/main/kotlin/com/qiniu/s3/examples/App.kt` package com.qiniu.s3.examples import aws.sdk.kotlin.runtime.auth.credentials.StaticCredentialsProvider import aws.sdk.kotlin.services.s3.S3Client import aws.sdk.kotlin.services.s3.model.CopyObjectRequest import aws.sdk.kotlin.services.s3.model.MetadataDirective import aws.sdk.kotlin.services.s3.model.StorageClass import aws.smithy.kotlin.runtime.net.url.Url import kotlinx.coroutines.runBlocking fun main(): Unit = runBlocking { val s3Client = S3Client { credentialsProvider = StaticCredentialsProvider { accessKeyId = "<QiniuAccessKey>" secretAccessKey = "<QiniuSecretKey>" } region = "cn-east-1" // 华东-浙江区 region id endpointUrl = Url.parse("https://s3.cn-east-1.qiniucs.com") // 华东-浙江区 endpoint } val copyObjectRequest = CopyObjectRequest { bucket = "<Bucket>" key = "<Key>" copySource = "/<Bucket>/<Key>" storageClass = StorageClass.Glacier metadataDirective = MetadataDirective.Replace } s3Client.copyObject(copyObjectRequest) println("Done") } ## 复制对象副本 创建 `app/src/main/kotlin/com/qiniu/s3/examples/App.kt` package com.qiniu.s3.examples import aws.sdk.kotlin.runtime.auth.credentials.StaticCredentialsProvider import aws.sdk.kotlin.services.s3.S3Client import aws.sdk.kotlin.services.s3.model.CopyObjectRequest import aws.sdk.kotlin.services.s3.model.MetadataDirective import aws.smithy.kotlin.runtime.net.url.Url import kotlinx.coroutines.runBlocking fun main(): Unit = runBlocking { val s3Client = S3Client { credentialsProvider = StaticCredentialsProvider { accessKeyId = "<QiniuAccessKey>" secretAccessKey = "<QiniuSecretKey>" } region = "cn-east-1" // 华东-浙江区 region id endpointUrl = Url.parse("https://s3.cn-east-1.qiniucs.com") // 华东-浙江区 endpoint } val copyObjectRequest = CopyObjectRequest { bucket = "<ToBucket>" key = "<ToKey>" copySource = "/<FromBucket>/<FromKey>" metadataDirective = MetadataDirective.Copy } s3Client.copyObject(copyObjectRequest) println("Done") } ## 复制对象副本（大于 5GB） 创建 `app/src/main/kotlin/com/qiniu/s3/examples/App.kt` package com.qiniu.s3.examples import aws.sdk.kotlin.runtime.auth.credentials.StaticCredentialsProvider import aws.sdk.kotlin.services.s3.S3Client import aws.sdk.kotlin.services.s3.model.CompleteMultipartUploadRequest import aws.sdk.kotlin.services.s3.model.CompletedPart import aws.sdk.kotlin.services.s3.model.CreateMultipartUploadRequest import aws.sdk.kotlin.services.s3.model.HeadObjectRequest import aws.sdk.kotlin.services.s3.model.UploadPartCopyRequest import aws.smithy.kotlin.runtime.net.url.Url import java.util.Vector import kotlin.math.min import kotlinx.coroutines.runBlocking fun main(): Unit = runBlocking { val s3Client = S3Client { credentialsProvider = StaticCredentialsProvider { accessKeyId = "<QiniuAccessKey>" secretAccessKey = "<QiniuSecretKey>" } region = "cn-east-1" // 华东-浙江区 region id endpointUrl = Url.parse("https://s3.cn-east-1.qiniucs.com") // 华东-浙江区 endpoint } val headObjectRequest = HeadObjectRequest { bucket = "<FromBucket>" key = "<FromKey>" } val headObjectResponse = s3Client.headObject(headObjectRequest) val createMultipartUploadRequest = CreateMultipartUploadRequest { bucket = "<ToBucket>" key = "<ToKey>" } val createMultipartUploadResponse = s3Client.createMultipartUpload(createMultipartUploadRequest) val PART_SIZE = 5 * 1024 * 1024 // 分片大小为 5 MB val completedParts: Vector<CompletedPart> = Vector() // 这里给出的案例是串行分片复制。可以自行改造成并行分片复制以进一步提升复制速度 var pn = 1 var copied: Long = 0 while (copied < headObjectResponse.contentLength) { val partSize = min(headObjectResponse.contentLength - copied, PART_SIZE.toLong()) val uploadPartCopyRequest = UploadPartCopyRequest { bucket = createMultipartUploadRequest.bucket key = createMultipartUploadRequest.key uploadId = createMultipartUploadResponse.uploadId partNumber = pn copySource = "/${headObjectRequest.bucket}/${headObjectRequest.key}" copySourceRange = "bytes=${copied}-${copied+partSize}" } val uploadPartCopyResponse = s3Client.uploadPartCopy(uploadPartCopyRequest) completedParts.add( CompletedPart { eTag = uploadPartCopyResponse.copyPartResult!!.eTag partNumber = pn } ) pn++ copied += partSize } val completeMultipartUploadRequest = CompleteMultipartUploadRequest { bucket = createMultipartUploadRequest.bucket key = createMultipartUploadRequest.key uploadId = createMultipartUploadResponse.uploadId multipartUpload { parts = completedParts } } val completeMultipartUploadResponse = s3Client.completeMultipartUpload(completeMultipartUploadRequest) println("ETag: ${completeMultipartUploadResponse.eTag}") } ## 删除空间中的文件 创建 `app/src/main/kotlin/com/qiniu/s3/examples/App.kt` package com.qiniu.s3.examples import aws.sdk.kotlin.runtime.auth.credentials.StaticCredentialsProvider import aws.sdk.kotlin.services.s3.S3Client import aws.sdk.kotlin.services.s3.model.DeleteObjectRequest import aws.smithy.kotlin.runtime.net.url.Url import kotlinx.coroutines.runBlocking fun main(): Unit = runBlocking { val s3Client = S3Client { credentialsProvider = StaticCredentialsProvider { accessKeyId = "<QiniuAccessKey>" secretAccessKey = "<QiniuSecretKey>" } region = "cn-east-1" // 华东-浙江区 region id endpointUrl = Url.parse("https://s3.cn-east-1.qiniucs.com") // 华东-浙江区 endpoint } val deleteObjectRequest = DeleteObjectRequest { bucket = "<Bucket>" key = "<Key>" } s3Client.deleteObject(deleteObjectRequest) println("Done") } ## 获取指定前缀的文件列表 创建 `app/src/main/kotlin/com/qiniu/s3/examples/App.kt` package com.qiniu.s3.examples import aws.sdk.kotlin.runtime.auth.credentials.StaticCredentialsProvider import aws.sdk.kotlin.services.s3.S3Client import aws.sdk.kotlin.services.s3.model.ListObjectsV2Request import aws.smithy.kotlin.runtime.net.url.Url import kotlinx.coroutines.runBlocking fun main(): Unit = runBlocking { val s3Client = S3Client { credentialsProvider = StaticCredentialsProvider { accessKeyId = "<QiniuAccessKey>" secretAccessKey = "<QiniuSecretKey>" } region = "cn-east-1" // 华东-浙江区 region id endpointUrl = Url.parse("https://s3.cn-east-1.qiniucs.com") // 华东-浙江区 endpoint } val listObjectsV2Request = ListObjectsV2Request { bucket = "<Bucket>" prefix = "<KeyPrefix>" } val listObjectsV2Response = s3Client.listObjectsV2(listObjectsV2Request) for (content in listObjectsV2Response.contents!!) { println("Key: ${content.key}") println("ETag: ${content.eTag}") } } ## 批量删除空间中的文件 创建 `app/src/main/kotlin/com/qiniu/s3/examples/App.kt` package com.qiniu.s3.examples import aws.sdk.kotlin.runtime.auth.credentials.StaticCredentialsProvider import aws.sdk.kotlin.services.s3.S3Client import aws.sdk.kotlin.services.s3.model.DeleteObjectsRequest import aws.sdk.kotlin.services.s3.model.ObjectIdentifier import aws.smithy.kotlin.runtime.net.url.Url import kotlinx.coroutines.runBlocking fun main(): Unit = runBlocking { val s3Client = S3Client { credentialsProvider = StaticCredentialsProvider { accessKeyId = "<QiniuAccessKey>" secretAccessKey = "<QiniuSecretKey>" } region = "cn-east-1" // 华东-浙江区 region id endpointUrl = Url.parse("https://s3.cn-east-1.qiniucs.com") // 华东-浙江区 endpoint } val deleteObjectsRequest = DeleteObjectsRequest { bucket = "<Bucket>" delete { objects = listOf( ObjectIdentifier { key = "<Key1>" }, ObjectIdentifier { key = "<Key2>" }, ObjectIdentifier { key = "<Key3>" } ) } } s3Client.deleteObjects(deleteObjectsRequest) println("Done") } # 临时安全凭证 创建 `app/src/main/kotlin/com/qiniu/s3/examples/App.kt` package com.qiniu.s3.examples import aws.sdk.kotlin.runtime.auth.credentials.StaticCredentialsProvider import aws.sdk.kotlin.services.s3.S3Client import aws.sdk.kotlin.services.s3.listBuckets import aws.sdk.kotlin.services.sts.StsClient import aws.sdk.kotlin.services.sts.model.GetFederationTokenRequest import aws.smithy.kotlin.runtime.auth.awscredentials.CachedCredentialsProvider import aws.smithy.kotlin.runtime.auth.awscredentials.Credentials import aws.smithy.kotlin.runtime.auth.awscredentials.CredentialsProvider import aws.smithy.kotlin.runtime.collections.Attributes import aws.smithy.kotlin.runtime.net.url.Url import kotlinx.coroutines.runBlocking class StsCredentialsProvider(val stsClient: StsClient, val request: GetFederationTokenRequest) : CredentialsProvider { override suspend fun resolve(attributes: Attributes): Credentials { val response = stsClient.getFederationToken(request) return Credentials( response.credentials!!.accessKeyId, response.credentials!!.secretAccessKey, response.credentials!!.sessionToken, response.credentials!!.expiration ) } } fun main(): Unit = runBlocking { val stsClient = StsClient { credentialsProvider = StaticCredentialsProvider { accessKeyId = "<QiniuAccessKey>" secretAccessKey = "<QiniuSecretKey>" } region = "cn-east-1" // 华东-浙江区 region id endpointUrl = Url.parse("https://s3.cn-east-1.qiniucs.com") // 华东-浙江区 endpoint } val s3Client = S3Client { credentialsProvider = CachedCredentialsProvider( StsCredentialsProvider( stsClient, GetFederationTokenRequest { name = "Bob" durationSeconds = 3600 policy = "{\"Version\":\"2012-10-17\",\"Statement\":[{\"Sid\":\"Stmt1\",\"Effect\":\"Allow\",\"Action\":[\"*\"],\"Resource\":[\"*\"]}]}" } ) ) region = "cn-east-1" // 华东-浙江区 region id endpointUrl = Url.parse("https://s3.cn-east-1.qiniucs.com") // 华东-浙江区 endpoint } // 可以使用这些临时凭证调用 S3 服务 val listBucketsResponse = s3Client.listBuckets() for (bucket in listBucketsResponse.buckets!!) { println("${bucket.name}") } } 以上内容是否对您有帮助？

AWS SDK for PHP

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [开发指南](https://developer.qiniu.com/kodo/development_guidelines/8596/development- guidelines) > [AWS S3 兼容](https://developer.qiniu.com/kodo/development_guidelines/4086/aws-s3-compatible) > [兼容 SDK 示例](https://developer.qiniu.com/kodo/development_guidelines/12553/S3 SDK sample) > AWS SDK for PHP # AWS SDK for PHP 最近更新时间: 2024-02-19 17:03:17 # 导入 AWS SDK for PHP 确保 PHP v5.5 或更新版本已经安装。 其他推荐配置 * 使用 cURL 7.16.2 或更新版本 * 使用 OPCache * 不使用 Xdebug * 使用 Composer 自动加载依赖 * 详见：https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/getting-started_requirements.html 添加 AWS SDK for PHP 包 composer require aws/aws-sdk-php=3.281.15 对于之后的每个代码示例，将代码创建在 `main.php` 后，执行 php main.php 即可执行代码。 # 对象上传 ## 获取客户端上传 URL 创建 `main.php` <?php require 'vendor/autoload.php'; use Aws\S3\S3Client; use Aws\Credentials\Credentials; $s3Client = new S3Client([ "region" => "cn-east-1", // 华东-浙江区 region id "endpoint" => "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint "credentials" => new Credentials("<QiniuAccessKey>", "<QiniuSecretKey>"), ]); $request = $s3Client->createPresignedRequest($s3Client->getCommand("GetObject", ["Bucket" => "<Bucket>", "Key" => "<Key>"]), "+1 hours"); echo $request->getUri() . "\n"; 这段代码将生成一个经过预先签名的客户端上传 URL，有效期为 1 小时，客户端可以在过期时间内对该 URL 发送 HTTP PUT 请求将文件上传。 以下是用 curl 上传文件的案例： curl -X PUT --upload-file "<path/to/file>" "<presigned url>" ## 服务器端直传 ### 单请求上传（文件） 创建 `main.php` <?php require 'vendor/autoload.php'; use Aws\S3\S3Client; use Aws\Credentials\Credentials; $s3Client = new S3Client([ "region" => "cn-east-1", // 华东-浙江区 region id "endpoint" => "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint "credentials" => new Credentials("<QiniuAccessKey>", "<QiniuSecretKey>"), ]); try { $putObjectResponse = $s3Client->putObject(["Bucket" => "<Bucket>", "Key" => "<Key>", "SourceFile" => "<path/to/upload>"]); echo "ETag: " . $putObjectResponse["ETag"] . "\n"; } catch (AwsException $e) { echo "Error: " . $e . "\n"; } ### 单请求上传（数据流） 创建 `main.php` <?php require 'vendor/autoload.php'; use Aws\S3\S3Client; use Aws\Credentials\Credentials; $s3Client = new S3Client([ "region" => "cn-east-1", // 华东-浙江区 region id "endpoint" => "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint "credentials" => new Credentials("<QiniuAccessKey>", "<QiniuSecretKey>"), ]); try { $putObjectResponse = $s3Client->putObject(["Bucket" => "<Bucket>", "Key" => "<Key>", "Body" => "Hello, Qiniu S3!"]); echo "ETag: " . $putObjectResponse["ETag"] . "\n"; } catch (AwsException $e) { echo "Error: " . $e . "\n"; } ### 分片上传（文件） 创建 `main.php` <?php require 'vendor/autoload.php'; use Aws\S3\S3Client; use Aws\Credentials\Credentials; use Aws\Exception\AwsException; $s3Client = new S3Client([ "region" => "cn-east-1", // 华东-浙江区 region id "endpoint" => "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint "credentials" => new Credentials("<QiniuAccessKey>", "<QiniuSecretKey>"), ]); const PART_SIZE = 5 * 1024 * 1024; // 分片大小为 5 MB try { $createMultipartUploadResponse = $s3Client->createMultipartUpload(["Bucket" => "<Bucket>", "Key" => "<Key>"]); $file = fopen("<path/to/upload>", "rb"); if (!$file) { return; } $parts = array(); try { // 这里给出的案例是串行分片上传。可以自行改造成并行分片上传以进一步提升上传速度 for ($partNumber = 1;; $partNumber++) { $partBody = fread($file, PART_SIZE); if (!$partBody) { break; } $uploadPartResponse = $s3Client->uploadPart([ "Bucket" => $createMultipartUploadResponse["Bucket"], "Key" => $createMultipartUploadResponse["Key"], "UploadId" => $createMultipartUploadResponse["UploadId"], "PartNumber" => $partNumber, "Body" => $partBody, ]); array_push($parts, ["ETag" => $uploadPartResponse["ETag"], "PartNumber" => $partNumber]); } } finally { if (!$file) { fclose($file); } } $completeMultipartUploadResponse = $s3Client->completeMultipartUpload([ "Bucket" => $createMultipartUploadResponse["Bucket"], "Key" => $createMultipartUploadResponse["Key"], "UploadId" => $createMultipartUploadResponse["UploadId"], "MultipartUpload" => [ "Parts" => $parts, ] ]); echo 'ETag: ' . $completeMultipartUploadResponse["ETag"] . "\n"; } catch (AwsException $e) { echo "Error: " . $e . "\n"; } ### 上传文件 创建 `main.php` <?php require 'vendor/autoload.php'; use Aws\S3\S3Client; use Aws\Credentials\Credentials; use Aws\Exception\AwsException; $s3Client = new S3Client([ "region" => "cn-east-1", // 华东-浙江区 region id "endpoint" => "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint "credentials" => new Credentials("<QiniuAccessKey>", "<QiniuSecretKey>"), ]); $file = fopen("<path/to/upload>", "r") or die("Unable to open file"); try { $resp = $s3Client->upload("<Bucket>", "<Key>", $file); echo 'ETag: ' . $resp["ETag"] . "\n"; } catch (AwsException $e) { echo "Error: " . $e . "\n"; } finally { fclose($file); } ### 上传目录 创建 `main.php` <?php require 'vendor/autoload.php'; use Aws\S3\S3Client; use Aws\Credentials\Credentials; use Aws\Exception\AwsException; $s3Client = new S3Client([ "region" => "cn-east-1", // 华东-浙江区 region id "endpoint" => "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint "credentials" => new Credentials("<QiniuAccessKey>", "<QiniuSecretKey>"), ]); try { $s3Client->uploadDirectory("<path/to/upload>", "<Bucket>", "<KeyPrefix>"); } catch (AwsException $e) { echo "Error: " . $e . "\n"; } # 对象下载 ## 获取客户端下载 URL 创建 `main.php` <?php require 'vendor/autoload.php'; use Aws\S3\S3Client; use Aws\Credentials\Credentials; $s3Client = new S3Client([ "region" => "cn-east-1", // 华东-浙江区 region id "endpoint" => "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint "credentials" => new Credentials("<QiniuAccessKey>", "<QiniuSecretKey>"), ]); $request = $s3Client->createPresignedRequest($s3Client->getCommand("PutObject", ["Bucket" => "<Bucket>", "Key" => "<Key>"]), "+1 hours"); echo $request->getUri() . "\n"; 这段代码将生成一个经过预先签名的客户端下载 URL，有效期为 1 小时，客户端可以在过期时间内对该 URL 发送 HTTP GET 请求将文件下载。 以下是用 curl 下载文件的案例： curl -o "<path/to/download>" "<presigned url>" ## 服务器端直接下载 创建 `main.php` <?php require 'vendor/autoload.php'; use Aws\S3\S3Client; use Aws\Credentials\Credentials; use Aws\Exception\AwsException; $s3Client = new S3Client([ "region" => "cn-east-1", // 华东-浙江区 region id "endpoint" => "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint "credentials" => new Credentials("<QiniuAccessKey>", "<QiniuSecretKey>"), ]); try { $getObjectResponse = $s3Client->getObject(["Bucket" => "<Bucket>", "Key" => "<Key>", "SaveAs" => "<path/to/download>"]); echo "ETag: " . $getObjectResponse["ETag"] . "\n"; } catch (AwsException $e) { echo "Error: " . $e . "\n"; } ## 下载目录 创建 `main.php` <?php require 'vendor/autoload.php'; use Aws\S3\S3Client; use Aws\Credentials\Credentials; use Aws\Exception\AwsException; $s3Client = new S3Client([ "region" => "cn-east-1", // 华东-浙江区 region id "endpoint" => "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint "credentials" => new Credentials("<QiniuAccessKey>", "<QiniuSecretKey>"), ]); try { $s3Client->downloadBucket("<path/to/download>", "<Bucket>", "<KeyPrefix>"); } catch (AwsException $e) { echo "Error: " . $e . "\n"; } # 对象管理 ## 获取对象信息 创建 `main.php` <?php require 'vendor/autoload.php'; use Aws\S3\S3Client; use Aws\Credentials\Credentials; use Aws\Exception\AwsException; $s3Client = new S3Client([ "region" => "cn-east-1", // 华东-浙江区 region id "endpoint" => "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint "credentials" => new Credentials("<QiniuAccessKey>", "<QiniuSecretKey>"), ]); try { $headObjectResponse = $s3Client->headObject(["Bucket" => "<Bucket>", "Key" => "<Key>"]); echo "ETag: " . $headObjectResponse["ETag"] . "\n"; } catch (AwsException $e) { echo "Error: " . $e . "\n"; } ## 修改对象 MimeType 创建 `main.php` <?php require 'vendor/autoload.php'; use Aws\S3\S3Client; use Aws\Credentials\Credentials; use Aws\Exception\AwsException; $s3Client = new S3Client([ "region" => "cn-east-1", // 华东-浙江区 region id "endpoint" => "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint "credentials" => new Credentials("<QiniuAccessKey>", "<QiniuSecretKey>"), ]); try { $s3Client->copyObject([ "Bucket" => "<Bucket>", "Key" => "<Key>", "MetadataDirective" => "REPLACE", "CopySource" => "/<Bucket>/<Key>", "ContentType" => "<NewContentType>", ]); echo "Done\n"; } catch (AwsException $e) { echo "Error: " . $e . "\n"; } ## 修改对象存储类型 创建 `main.php` <?php require 'vendor/autoload.php'; use Aws\S3\S3Client; use Aws\Credentials\Credentials; use Aws\Exception\AwsException; $s3Client = new S3Client([ "region" => "cn-east-1", // 华东-浙江区 region id "endpoint" => "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint "credentials" => new Credentials("<QiniuAccessKey>", "<QiniuSecretKey>"), ]); try { $s3Client->copyObject([ "Bucket" => "<Bucket>", "Key" => "<Key>", "MetadataDirective" => "REPLACE", "CopySource" => "/<Bucket>/<Key>", "StorageClass" => "GLACIER", ]); echo "Done\n"; } catch (AwsException $e) { echo "Error: " . $e . "\n"; } ## 复制对象副本 创建 `main.php` <?php require 'vendor/autoload.php'; use Aws\S3\S3Client; use Aws\Credentials\Credentials; use Aws\Exception\AwsException; $s3Client = new S3Client([ "region" => "cn-east-1", // 华东-浙江区 region id "endpoint" => "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint "credentials" => new Credentials("<QiniuAccessKey>", "<QiniuSecretKey>"), ]); try { $s3Client->copyObject([ "Bucket" => "<ToBucket>", "Key" => "<ToKey>", "MetadataDirective" => "COPY", "CopySource" => "/<FromBucket>/<FromKey>", ]); echo "Done\n"; } catch (AwsException $e) { echo "Error: " . $e . "\n"; } ## 复制对象副本（大于 5GB） 创建 `main.php` <?php require 'vendor/autoload.php'; use Aws\S3\S3Client; use Aws\Credentials\Credentials; use Aws\Exception\AwsException; $s3Client = new S3Client([ "region" => "cn-east-1", // 华东-浙江区 region id "endpoint" => "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint "credentials" => new Credentials("<QiniuAccessKey>", "<QiniuSecretKey>"), ]); const PART_SIZE = 5 * 1024 * 1024; // 分片大小为 5 MB try { $headObjectRequest = ["Bucket" => "<FromBucket>", "Key" => "<FromKey>"]; $headObjectResponse = $s3Client->headObject($headObjectRequest); $createMultipartUploadResponse = $s3Client->createMultipartUpload(["Bucket" => "<ToBucket>", "Key" => "<ToKey>"]); $parts = array(); $copied = 0; // 这里给出的案例是串行分片复制。可以自行改造成并行分片复制以进一步提升复制速度 for ($partNumber = 1; $headObjectResponse["ContentLength"] > $copied; $partNumber++) { $partSize = min(PART_SIZE, $headObjectResponse["ContentLength"] - $copied); $uploadPartCopyResponse = $s3Client->uploadPartCopy([ "Bucket" => $createMultipartUploadResponse["Bucket"], "Key" => $createMultipartUploadResponse["Key"], "UploadId" => $createMultipartUploadResponse["UploadId"], "PartNumber" => $partNumber, "CopySource" => "/" . $headObjectRequest["Bucket"] . "/" . $headObjectRequest["Key"], "CopySourceRange" => "bytes=" . $copied . "-" . ($copied + $partSize), ]); array_push($parts, ["ETag" => $uploadPartCopyResponse["CopyPartResult"]["ETag"], "PartNumber" => $partNumber]); $copied += $partSize; } $completeMultipartUploadResponse = $s3Client->completeMultipartUpload([ "Bucket" => $createMultipartUploadResponse["Bucket"], "Key" => $createMultipartUploadResponse["Key"], "UploadId" => $createMultipartUploadResponse["UploadId"], "MultipartUpload" => [ "Parts" => $parts, ] ]); echo 'ETag: ' . $completeMultipartUploadResponse["ETag"] . "\n"; } catch (AwsException $e) { echo "Error: " . $e . "\n"; } ## 删除空间中的文件 创建 `main.php` <?php require 'vendor/autoload.php'; use Aws\S3\S3Client; use Aws\Credentials\Credentials; use Aws\Exception\AwsException; $s3Client = new S3Client([ "region" => "cn-east-1", // 华东-浙江区 region id "endpoint" => "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint "credentials" => new Credentials("<QiniuAccessKey>", "<QiniuSecretKey>"), ]); try { $s3Client->deleteObject(["Bucket" => "<Bucket>", "Key" => "<Key>"]); echo "Done\n"; } catch (AwsException $e) { echo "Error: " . $e . "\n"; } ## 获取指定前缀的文件列表 创建 `main.php` <?php require 'vendor/autoload.php'; use Aws\S3\S3Client; use Aws\Credentials\Credentials; use Aws\Exception\AwsException; $s3Client = new S3Client([ "region" => "cn-east-1", // 华东-浙江区 region id "endpoint" => "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint "credentials" => new Credentials("<QiniuAccessKey>", "<QiniuSecretKey>"), ]); try { $listObjectsV2Response = $s3Client->listObjectsV2(["Bucket" => "<Bucket>", "Prefix" => "<KeyPrefix>"]); foreach ($listObjectsV2Response["Contents"] as $content) { echo "Key: " . $content["Key"] . "\n"; echo "ETag: " . $content["ETag"] . "\n"; } } catch (AwsException $e) { echo "Error: " . $e . "\n"; } ## 批量删除空间中的文件 创建 `main.php` <?php require 'vendor/autoload.php'; use Aws\S3\S3Client; use Aws\Credentials\Credentials; use Aws\Exception\AwsException; $s3Client = new S3Client([ "region" => "cn-east-1", // 华东-浙江区 region id "endpoint" => "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint "credentials" => new Credentials("<QiniuAccessKey>", "<QiniuSecretKey>"), ]); try { $s3Client->deleteObjects([ "Bucket" => "<Bucket>", "Delete" => [ "Objects" => [ ["Key" => "<Key1>"], ["Key" => "<Key2>"], ["Key" => "<Key3>"], ] ], ]); echo "Done\n"; } catch (AwsException $e) { echo "Error: " . $e . "\n"; } # 临时安全凭证 创建 `main.php` <?php require 'vendor/autoload.php'; use Aws\S3\S3Client; use Aws\Sts\StsClient; use Aws\Credentials\Credentials; use Aws\Exception\AwsException; $stsClient = new StsClient([ "region" => "cn-east-1", // 华东-浙江区 region id "endpoint" => "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint "credentials" => new Credentials("<QiniuAccessKey>", "<QiniuSecretKey>"), ]); try { $getFederationTokenResponse = $stsClient->getFederationToken([ "Name" => "Bob", "Policy" => json_encode([ "Version" => "2012-10-17", "Statement" => [ [ "Sid" => "Stmt1", "Effect" => "Allow", "Action" => ["*"], "Resource" => ["*"], ], ], ]), "DurationSeconds" => 3600, ]); $credentials = $getFederationTokenResponse["Credentials"]; $s3Client = new S3Client([ "region" => "cn-east-1", // 华东-浙江区 region id "endpoint" => "https://s3.cn-east-1.qiniucs.com", // 华东-浙江区 endpoint "credentials" => new Credentials($credentials["AccessKeyId"], $credentials["SecretAccessKey"], $credentials["SessionToken"], $credentials["Expiration"]), ]); // 可以使用这些临时凭证调用 S3 服务 $listBucketsResponse = $s3Client->listBuckets(); foreach ($listBucketsResponse["Buckets"] as $bucket) { echo $bucket["Name"] . "\n"; } } catch (AwsException $e) { echo "Error: " . $e . "\n"; } 以上内容是否对您有帮助？

AWS SDK for Python

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [开发指南](https://developer.qiniu.com/kodo/development_guidelines/8596/development- guidelines) > [AWS S3 兼容](https://developer.qiniu.com/kodo/development_guidelines/4086/aws-s3-compatible) > [兼容 SDK 示例](https://developer.qiniu.com/kodo/development_guidelines/12553/S3 SDK sample) > AWS SDK for Python # AWS SDK for Python 最近更新时间: 2024-02-19 17:03:25 # 导入 AWS SDK for Python 确保 Python v3.7 或更新版本已经安装。 初始化 `venv` 项目 python3 -m venv .venv . .venv/bin/activate 添加 AWS SDK for Python 包 python3 -m pip install boto3==1.28.85 对于之后的每个代码示例，将代码创建在 `main.py` 后，执行 python3 main.py 即可执行代码。 # 对象上传 ## 获取客户端上传 URL 创建 `main.py` import boto3 s3 = boto3.client('s3', region_name='cn-east-1', # 华东-浙江区 region id endpoint_url='https://s3.cn-east-1.qiniucs.com', # 华东-浙江区 endpoint aws_access_key_id='<QiniuAccessKey>', aws_secret_access_key='<QiniuSecretKey>', config=boto3.session.Config(signature_version="s3v4")) presigned_url = s3.generate_presigned_url(ClientMethod='put_object', Params={'Bucket': '<Bucket>', 'Key': '<Key>'}) print(presigned_url) 这段代码将生成一个经过预先签名的客户端上传 URL，有效期为 1 小时，客户端可以在过期时间内对该 URL 发送 HTTP PUT 请求将文件上传。 以下是用 curl 上传文件的案例： curl -X PUT --upload-file "<path/to/file>" "<presigned url>" 您也可以自行指定上传凭证的有效期，例如： import boto3 s3 = boto3.client('s3', region_name='cn-east-1', # 华东-浙江区 region id endpoint_url='https://s3.cn-east-1.qiniucs.com', # 华东-浙江区 endpoint aws_access_key_id='<QiniuAccessKey>', aws_secret_access_key='<QiniuSecretKey>', config=boto3.session.Config(signature_version="s3v4")) presigned_url = s3.generate_presigned_url(ClientMethod='put_object', Params={'Bucket': '<Bucket>', 'Key': '<Key>'}, ExpiresIn=86400) print(presigned_url) ## 服务器端直传 ### 单请求上传（文件） 创建 `main.py` import boto3 s3 = boto3.client('s3', region_name='cn-east-1', # 华东-浙江区 region id endpoint_url='https://s3.cn-east-1.qiniucs.com', # 华东-浙江区 endpoint aws_access_key_id='<QiniuAccessKey>', aws_secret_access_key='<QiniuSecretKey>', config=boto3.session.Config(signature_version="s3v4")) with open('<path/to/upload>', 'rb') as f: s3.put_object(Bucket='<Bucket>', Key='<Key>', Body=f) ### 单请求上传（数据流） 创建 `main.py` import boto3 s3 = boto3.client('s3', region_name='cn-east-1', # 华东-浙江区 region id endpoint_url='https://s3.cn-east-1.qiniucs.com', # 华东-浙江区 endpoint aws_access_key_id='<QiniuAccessKey>', aws_secret_access_key='<QiniuSecretKey>', config=boto3.session.Config(signature_version="s3v4")) s3.put_object(Bucket='<Bucket>', Key='<Key>', Body='Hello, Qiniu S3!') ### 分片上传（文件） 创建 `main.py` import boto3 s3 = boto3.client('s3', region_name='cn-east-1', # 华东-浙江区 region id endpoint_url='https://s3.cn-east-1.qiniucs.com', # 华东-浙江区 endpoint aws_access_key_id='<QiniuAccessKey>', aws_secret_access_key='<QiniuSecretKey>', config=boto3.session.Config(signature_version="s3v4")) create_multipart_upload_response = s3.create_multipart_upload(Bucket='<Bucket>', Key='<Key>') uploaded = 0 PART_SIZE = 5*1024*1024 # 分片大小为 5 MB part_number = 1 parts = [] with open('<path/to/upload>', 'rb') as f: # 这里给出的案例是串行分片上传。可以自行改造成并行分片上传以进一步提升上传速度 while True: part_body = f.read(PART_SIZE) if len(part_body) == 0: break upload_part_response = s3.upload_part(Bucket=create_multipart_upload_response['Bucket'], Key=create_multipart_upload_response['Key'], UploadId=create_multipart_upload_response['UploadId'], PartNumber=part_number, Body=part_body) parts.append({'PartNumber': part_number, 'ETag': upload_part_response['ETag']}) part_number += 1 uploaded += len(part_body) complete_multipart_upload_response = s3.complete_multipart_upload( Bucket=create_multipart_upload_response['Bucket'], Key=create_multipart_upload_response['Key'], UploadId=create_multipart_upload_response['UploadId'], MultipartUpload={'Parts': parts}) print('ETag:', complete_multipart_upload_response['ETag']) ### 上传文件 创建 `main.py` import boto3 s3 = boto3.client('s3', region_name='cn-east-1', # 华东-浙江区 region id endpoint_url='https://s3.cn-east-1.qiniucs.com', # 华东-浙江区 endpoint aws_access_key_id='<QiniuAccessKey>', aws_secret_access_key='<QiniuSecretKey>', config=boto3.session.Config(signature_version="s3v4")) s3.upload_file("<path/to/upload>", "<Bucket>", "<Key>") print('Done') # 对象下载 ## 获取客户端下载 URL 创建 `main.py` import boto3 s3 = boto3.client('s3', region_name='cn-east-1', # 华东-浙江区 region id endpoint_url='https://s3.cn-east-1.qiniucs.com', # 华东-浙江区 endpoint aws_access_key_id='<QiniuAccessKey>', aws_secret_access_key='<QiniuSecretKey>', config=boto3.session.Config(signature_version="s3v4")) presigned_url = s3.generate_presigned_url(ClientMethod='get_object', Params={'Bucket': '<Bucket>', 'Key': '<Key>'}) print(presigned_url) 这段代码将生成一个经过预先签名的客户端下载 URL，有效期为 1 小时，客户端可以在过期时间内对该 URL 发送 HTTP GET 请求将文件下载。 以下是用 curl 下载文件的案例： curl -o "<path/to/download>" "<presigned url>" 您也可以自行指定下载凭证的有效期，例如： import boto3 s3 = boto3.client('s3', region_name='cn-east-1', # 华东-浙江区 region id endpoint_url='https://s3.cn-east-1.qiniucs.com', # 华东-浙江区 endpoint aws_access_key_id='<QiniuAccessKey>', aws_secret_access_key='<QiniuSecretKey>', config=boto3.session.Config(signature_version="s3v4")) presigned_url = s3.generate_presigned_url(ClientMethod='get_object', Params={'Bucket': '<Bucket>', 'Key': '<Key>'}, ExpiresIn=86400) print(presigned_url) ## 服务器端直接下载 创建 `main.py` import boto3 s3 = boto3.client('s3', region_name='cn-east-1', # 华东-浙江区 region id endpoint_url='https://s3.cn-east-1.qiniucs.com', # 华东-浙江区 endpoint aws_access_key_id='<QiniuAccessKey>', aws_secret_access_key='<QiniuSecretKey>', config=boto3.session.Config(signature_version="s3v4")) get_object_response = s3.get_object(Bucket='<Bucket>', Key='<Key>') with open('<path/to/download>', 'wb') as f: shutil.copyfileobj(get_object_response['Body'], f) print('ETag:', get_object_response['ETag']) ## 下载文件 创建 `main.py` import boto3 s3 = boto3.client('s3', region_name='cn-east-1', # 华东-浙江区 region id endpoint_url='https://s3.cn-east-1.qiniucs.com', # 华东-浙江区 endpoint aws_access_key_id='<QiniuAccessKey>', aws_secret_access_key='<QiniuSecretKey>', config=boto3.session.Config(signature_version="s3v4")) s3.download_file('<Bucket>', '<Key>', '<path/to/download>') print('Done') # 对象管理 ## 获取对象信息 创建 `main.py` import boto3 s3 = boto3.client('s3', region_name='cn-east-1', # 华东-浙江区 region id endpoint_url='https://s3.cn-east-1.qiniucs.com', # 华东-浙江区 endpoint aws_access_key_id='<QiniuAccessKey>', aws_secret_access_key='<QiniuSecretKey>', config=boto3.session.Config(signature_version="s3v4")) head_object_response = s3.head_object(Bucket='<Bucket>', Key='<Key>') print('ETag:', head_object_response['ETag']) ## 修改对象 MimeType 创建 `main.py` import boto3 s3 = boto3.client('s3', region_name='cn-east-1', # 华东-浙江区 region id endpoint_url='https://s3.cn-east-1.qiniucs.com', # 华东-浙江区 endpoint aws_access_key_id='<QiniuAccessKey>', aws_secret_access_key='<QiniuSecretKey>', config=boto3.session.Config(signature_version="s3v4")) s3.copy_object(Bucket='<Bucket>', Key='<Key>', CopySource='/<Bucket>/<Key>', MetadataDirective='REPLACE', ContentType='<NewContentType>') print('Done') ## 修改对象存储类型 创建 `main.py` import boto3 s3 = boto3.client('s3', region_name='cn-east-1', # 华东-浙江区 region id endpoint_url='https://s3.cn-east-1.qiniucs.com', # 华东-浙江区 endpoint aws_access_key_id='<QiniuAccessKey>', aws_secret_access_key='<QiniuSecretKey>', config=boto3.session.Config(signature_version="s3v4")) s3.copy_object(Bucket='<Bucket>', Key='<Key>', CopySource='/<Bucket>/<Key>', MetadataDirective='REPLACE', StorageClass='GLACIER') print('Done') ## 复制对象副本 创建 `main.py` import boto3 s3 = boto3.client('s3', region_name='cn-east-1', # 华东-浙江区 region id endpoint_url='https://s3.cn-east-1.qiniucs.com', # 华东-浙江区 endpoint aws_access_key_id='<QiniuAccessKey>', aws_secret_access_key='<QiniuSecretKey>', config=boto3.session.Config(signature_version="s3v4")) s3.copy_object(Bucket='<ToBucket>', Key='<ToKey>', CopySource='/<FromBucket>/<FromKey>', MetadataDirective='COPY') print('Done') ## 复制对象副本（大于 5GB） 创建 `main.py` import boto3 s3 = boto3.client('s3', region_name='cn-east-1', # 华东-浙江区 region id endpoint_url='https://s3.cn-east-1.qiniucs.com', # 华东-浙江区 endpoint aws_access_key_id='<QiniuAccessKey>', aws_secret_access_key='<QiniuSecretKey>', config=boto3.session.Config(signature_version="s3v4")) head_object_response = s3.head_object( Bucket='<FromBucket>', Key='<FromKey>') create_multipart_upload_response = s3.create_multipart_upload( Bucket='<ToBucket>', Key='<ToKey>') uploaded = 0 PART_SIZE = 5*1024*1024 # 分片大小为 5 MB part_number = 1 parts = [] copied = 0 # 这里给出的案例是串行分片上传。可以自行改造成并行分片上传以进一步提升上传速度 while copied < head_object_response['ContentLength']: part_size = min(head_object_response['ContentLength'] - copied, PART_SIZE) upload_part_copy_response = s3.upload_part_copy(Bucket=create_multipart_upload_response['Bucket'], Key=create_multipart_upload_response['Key'], UploadId=create_multipart_upload_response['UploadId'], PartNumber=part_number, CopySource='/<FromBucket>/<FromKey>', CopySourceRange=f'bytes={copied}-{copied+part_size}') parts.append({'PartNumber': part_number, 'ETag': upload_part_copy_response['CopyPartResult']['ETag']}) part_number += 1 copied += part_size complete_multipart_upload_response = s3.complete_multipart_upload( Bucket=create_multipart_upload_response['Bucket'], Key=create_multipart_upload_response['Key'], UploadId=create_multipart_upload_response['UploadId'], MultipartUpload={'Parts': parts}) print('ETag:', complete_multipart_upload_response['ETag']) ## 删除空间中的文件 创建 `main.py` import boto3 s3 = boto3.client('s3', region_name='cn-east-1', # 华东-浙江区 region id endpoint_url='https://s3.cn-east-1.qiniucs.com', # 华东-浙江区 endpoint aws_access_key_id='<QiniuAccessKey>', aws_secret_access_key='<QiniuSecretKey>', config=boto3.session.Config(signature_version="s3v4")) s3.delete_object(Bucket='<Bucket>', Key='<Key>') print('Done') ## 获取指定前缀的文件列表 创建 `main.py` import boto3 s3 = boto3.client('s3', region_name='cn-east-1', # 华东-浙江区 region id endpoint_url='https://s3.cn-east-1.qiniucs.com', # 华东-浙江区 endpoint aws_access_key_id='<QiniuAccessKey>', aws_secret_access_key='<QiniuSecretKey>', config=boto3.session.Config(signature_version="s3v4")) response = s3.list_objects_v2(Bucket='<Bucket>', Prefix='<KeyPrefix>') for object in response['Contents']: print('Key:', object['Key']) print('ETag:', object['ETag']) ## 批量删除空间中的文件 创建 `main.py` import boto3 s3 = boto3.client('s3', region_name='cn-east-1', # 华东-浙江区 region id endpoint_url='https://s3.cn-east-1.qiniucs.com', # 华东-浙江区 endpoint aws_access_key_id='<QiniuAccessKey>', aws_secret_access_key='<QiniuSecretKey>', config=boto3.session.Config(signature_version="s3v4")) s3.delete_objects(Bucket='<Bucket>', Delete={'Objects': [{'Key': '<Key1>'}, {'Key': '<Key2>'}, {'Key': '<Key3>'}]}) print('Done') # 临时安全凭证 创建 `main.py` import boto3 sts = boto3.client('sts', region_name='cn-east-1', # 华东-浙江区 region id endpoint_url='https://s3.cn-east-1.qiniucs.com', # 华东-浙江区 endpoint aws_access_key_id='<QiniuAccessKey>', aws_secret_access_key='<QiniuSecretKey>', config=boto3.session.Config(signature_version="s3v4")) get_federation_token_response = sts.get_federation_token(Name='Bob', DurationSeconds=3600, Policy='{"Version":"2012-10-17","Statement":[{"Sid":"Stmt1","Effect":"Allow","Action":["*"],"Resource":["*"]}]}') s3 = boto3.client('s3', region_name='cn-east-1', # 华东-浙江区 region id endpoint_url='https://s3.cn-east-1.qiniucs.com', # 华东-浙江区 endpoint aws_access_key_id=get_federation_token_response['Credentials']['AccessKeyId'], aws_secret_access_key=get_federation_token_response['Credentials']['SecretAccessKey'], aws_session_token=get_federation_token_response['Credentials']['SessionToken'], config=boto3.session.Config(signature_version="s3v4")) # 可以使用这些临时凭证调用 S3 服务 list_buckets_response = s3.list_buckets() for bucket in list_buckets_response['Buckets']: print(bucket['Name']) 以上内容是否对您有帮助？

AWS SDK for Ruby

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [开发指南](https://developer.qiniu.com/kodo/development_guidelines/8596/development- guidelines) > [AWS S3 兼容](https://developer.qiniu.com/kodo/development_guidelines/4086/aws-s3-compatible) > [兼容 SDK 示例](https://developer.qiniu.com/kodo/development_guidelines/12553/S3 SDK sample) > AWS SDK for Ruby # AWS SDK for Ruby 最近更新时间: 2024-02-19 17:03:42 # 导入 AWS SDK for Ruby 确保 Ruby v2.3 或更新版本已经安装。 初始化 `bundler` 项目 bundle init 添加 AWS SDK for Ruby 包 bundle add aws-sdk-s3 --version "=1.136.0" bundle add aws-sdk-sts --version "=1.11.0" bundle add nokogiri --version "=1.15.4" 对于之后的每个代码示例，将代码创建在 `main.rb` 后，执行 ruby main.rb 即可执行代码。 # 对象上传 ## 获取客户端上传 URL 创建 `main.rb` require 'aws-sdk-s3' s3 = Aws::S3::Resource::new( region: 'cn-east-1', # 华东-浙江区 region id credentials: Aws::Credentials.new('<QiniuAccessKey>', '<QiniuSecretKey>'), endpoint: 'https://s3.cn-east-1.qiniucs.com', # 华东-浙江区 endpoint ) puts s3.bucket('<Bucket>').object('<Key>').presigned_url(:put) 这段代码将生成一个经过预先签名的客户端上传 URL，有效期为 900 秒，客户端可以在过期时间内对该 URL 发送 HTTP PUT 请求将文件上传。 以下是用 curl 上传文件的案例： curl -X PUT --upload-file "<path/to/file>" "<presigned url>" 您也可以自行指定上传凭证的有效期，例如： require 'aws-sdk-s3' s3 = Aws::S3::Resource::new( region: 'cn-east-1', # 华东-浙江区 region id credentials: Aws::Credentials.new('<QiniuAccessKey>', '<QiniuSecretKey>'), endpoint: 'https://s3.cn-east-1.qiniucs.com', # 华东-浙江区 endpoint ) puts s3.bucket('<Bucket>').object('<Key>').presigned_url(:put, expires_in: 3600) ## 服务器端直传 ### 单请求上传（文件） 创建 `main.rb` require 'aws-sdk-s3' s3 = Aws::S3::Resource::new( region: 'cn-east-1', # 华东-浙江区 region id credentials: Aws::Credentials.new('<QiniuAccessKey>', '<QiniuSecretKey>'), endpoint: 'https://s3.cn-east-1.qiniucs.com', # 华东-浙江区 endpoint ) open('<path/to/upload>', 'rb') do |file| resp = s3.put_object(bucket: '<Bucket>', key: '<Key>', body: file) puts resp[:etag] end ### 单请求上传（数据流） 创建 `main.rb` require 'aws-sdk-s3' s3 = Aws::S3::Client::new( region: 'cn-east-1', # 华东-浙江区 region id credentials: Aws::Credentials.new('<QiniuAccessKey>', '<QiniuSecretKey>'), endpoint: 'https://s3.cn-east-1.qiniucs.com', # 华东-浙江区 endpoint ) resp = s3.put_object(bucket: '<Bucket>', key: '<Key>', body: 'Hello from Qiniu S3!') puts resp[:etag] ### 分片上传（文件） 创建 `main.rb` require 'aws-sdk-s3' s3 = Aws::S3::Client::new( region: 'cn-east-1', # 华东-浙江区 region id credentials: Aws::Credentials.new('<QiniuAccessKey>', '<QiniuSecretKey>'), endpoint: 'https://s3.cn-east-1.qiniucs.com', # 华东-浙江区 endpoint ) create_multipart_upload_resp = s3.create_multipart_upload(bucket: '<Bucket>', key: '<Key>') PART_SIZE = 5 * 1024 * 1024 # 分片大小为 5 MB parts = [] open('<path/to/upload>', 'rb') do |file| # 这里给出的案例是串行分片上传。可以自行改造成并行分片上传以进一步提升上传速度 (1..).each do |part_number| part_body = file.read(PART_SIZE) break if part_body.nil? upload_part_response = s3.upload_part( bucket: create_multipart_upload_resp[:bucket], key: create_multipart_upload_resp[:key], upload_id: create_multipart_upload_resp[:upload_id], part_number: part_number, body: part_body, ) parts << {etag: upload_part_response[:etag], part_number: part_number} end end complete_multipart_upload_response = s3.complete_multipart_upload( bucket: create_multipart_upload_resp[:bucket], key: create_multipart_upload_resp[:key], upload_id: create_multipart_upload_resp[:upload_id], multipart_upload: {parts: parts}, ) puts complete_multipart_upload_response[:etag] ### 上传文件 创建 `main.rb` require 'aws-sdk-s3' s3 = Aws::S3::Resource::new( region: 'cn-east-1', # 华东-浙江区 region id credentials: Aws::Credentials.new('<QiniuAccessKey>', '<QiniuSecretKey>'), endpoint: 'https://s3.cn-east-1.qiniucs.com', # 华东-浙江区 endpoint ) s3.bucket('<Bucket>').object('<Key>').upload_file('<path/to/upload>') puts 'Done' # 对象下载 ## 获取客户端下载 URL 创建 `main.rb` require 'aws-sdk-s3' s3 = Aws::S3::Resource::new( region: 'cn-east-1', # 华东-浙江区 region id credentials: Aws::Credentials.new('<QiniuAccessKey>', '<QiniuSecretKey>'), endpoint: 'https://s3.cn-east-1.qiniucs.com', # 华东-浙江区 endpoint ) puts s3.bucket('<Bucket>').object('<Key>').presigned_url(:get) 这段代码将生成一个经过预先签名的客户端下载 URL，有效期为 900 秒，客户端可以在过期时间内对该 URL 发送 HTTP GET 请求将文件下载。 以下是用 curl 下载文件的案例： curl -o "<path/to/download>" "<presigned url>" 您也可以自行指定下载凭证的有效期，例如： require 'aws-sdk-s3' s3 = Aws::S3::Resource::new( region: 'cn-east-1', # 华东-浙江区 region id credentials: Aws::Credentials.new('<QiniuAccessKey>', '<QiniuSecretKey>'), endpoint: 'https://s3.cn-east-1.qiniucs.com', # 华东-浙江区 endpoint ) puts s3.bucket('<Bucket>').object('<Key>').presigned_url(:get, expires_in: 3600) ## 服务器端直接下载 创建 `main.rb` require 'aws-sdk-s3' s3 = Aws::S3::Client::new( region: 'cn-east-1', # 华东-浙江区 region id credentials: Aws::Credentials.new('<QiniuAccessKey>', '<QiniuSecretKey>'), endpoint: 'https://s3.cn-east-1.qiniucs.com', # 华东-浙江区 endpoint ) response = s3.get_object(bucket: '<Bucket>', key: '<Key>') puts response[:etag] ## 下载文件 创建 `main.rb` require 'aws-sdk-s3' s3 = Aws::S3::Resource::new( region: 'cn-east-1', # 华东-浙江区 region id credentials: Aws::Credentials.new('<QiniuAccessKey>', '<QiniuSecretKey>'), endpoint: 'https://s3.cn-east-1.qiniucs.com', # 华东-浙江区 endpoint ) s3.bucket('<Bucket>').object('<Key>').get(response_target: '<path/to/download>') puts 'Done' # 对象管理 ## 获取对象信息 创建 `main.rb` require 'aws-sdk-s3' s3 = Aws::S3::Client::new( region: 'cn-east-1', # 华东-浙江区 region id credentials: Aws::Credentials.new('<QiniuAccessKey>', '<QiniuSecretKey>'), endpoint: 'https://s3.cn-east-1.qiniucs.com', # 华东-浙江区 endpoint ) response = s3.get_object(bucket: '<Bucket>', key: '<Key>') puts response[:etag] ## 修改对象 MimeType 创建 `main.rb` require 'aws-sdk-s3' s3 = Aws::S3::Client::new( region: 'cn-east-1', # 华东-浙江区 region id credentials: Aws::Credentials.new('<QiniuAccessKey>', '<QiniuSecretKey>'), endpoint: 'https://s3.cn-east-1.qiniucs.com', # 华东-浙江区 endpoint ) s3.copy_object(bucket: '<Bucket>', key: '<Key>', copy_source: '/<Bucket>/<Key>', metadata_directive: 'REPLACE', content_type: '<NewContentType>') puts 'Done' ## 修改对象存储类型 创建 `main.rb` require 'aws-sdk-s3' s3 = Aws::S3::Client::new( region: 'cn-east-1', # 华东-浙江区 region id credentials: Aws::Credentials.new('<QiniuAccessKey>', '<QiniuSecretKey>'), endpoint: 'https://s3.cn-east-1.qiniucs.com', # 华东-浙江区 endpoint ) s3.copy_object(bucket: '<Bucket>', key: '<Key>', copy_source: '/<Bucket>/<Key>', metadata_directive: 'REPLACE', storage_class: 'GLACIER') puts 'Done' ## 复制对象副本 创建 `main.rb` require 'aws-sdk-s3' s3 = Aws::S3::Client::new( region: 'cn-east-1', # 华东-浙江区 region id credentials: Aws::Credentials.new('<QiniuAccessKey>', '<QiniuSecretKey>'), endpoint: 'https://s3.cn-east-1.qiniucs.com', # 华东-浙江区 endpoint ) s3.copy_object(bucket: '<ToBucket>', key: '<ToKey>', copy_source: '/<FromBucket>/<FromKey>', metadata_directive: 'COPY') puts 'Done' ## 复制对象副本（大于 5GB） 创建 `main.rb` require 'aws-sdk-s3' s3 = Aws::S3::Client::new( region: 'cn-east-1', # 华东-浙江区 region id credentials: Aws::Credentials.new('<QiniuAccessKey>', '<QiniuSecretKey>'), endpoint: 'https://s3.cn-east-1.qiniucs.com', # 华东-浙江区 endpoint ) head_object_resp = s3.head_object(bucket: '<FromBucket>', key: '<FromKey>') create_multipart_upload_resp = s3.create_multipart_upload(bucket: '<ToBucket>', key: '<ToKey>') PART_SIZE = 5 * 1024 * 1024 # 分片大小为 5 MB copied = 0 parts = [] # 这里给出的案例是串行分片复制。可以自行改造成并行分片复制以进一步提升复制速度 (1..).each do |part_number| break if head_object_resp[:content_length] <= copied part_size = [PART_SIZE, head_object_resp[:content_length] - copied].min upload_part_copy_response = s3.upload_part_copy( bucket: create_multipart_upload_resp[:bucket], key: create_multipart_upload_resp[:key], upload_id: create_multipart_upload_resp[:upload_id], part_number: part_number, copy_source: "/<FromBucket>/<FromKey>", copy_source_range: "bytes=#{copied}-#{copied+part_size-1}", ) parts << {etag: upload_part_copy_response[:copy_part_result][:etag], part_number: part_number} copied += part_size end complete_multipart_upload_response = s3.complete_multipart_upload( bucket: create_multipart_upload_resp[:bucket], key: create_multipart_upload_resp[:key], upload_id: create_multipart_upload_resp[:upload_id], multipart_upload: {parts: parts}, ) puts complete_multipart_upload_response[:etag] ## 删除空间中的文件 创建 `main.rb` require 'aws-sdk-s3' s3 = Aws::S3::Client::new( region: 'cn-east-1', # 华东-浙江区 region id credentials: Aws::Credentials.new('<QiniuAccessKey>', '<QiniuSecretKey>'), endpoint: 'https://s3.cn-east-1.qiniucs.com', # 华东-浙江区 endpoint ) s3.delete_object(bucket: '<Bucket>', key: '<Key>') puts 'Done' ## 获取指定前缀的文件列表 创建 `main.rb` require 'aws-sdk-s3' s3 = Aws::S3::Client::new( region: 'cn-east-1', # 华东-浙江区 region id credentials: Aws::Credentials.new('<QiniuAccessKey>', '<QiniuSecretKey>'), endpoint: 'https://s3.cn-east-1.qiniucs.com', # 华东-浙江区 endpoint ) resp = s3.list_objects_v2(bucket: '<Bucket>', prefix: '<KeyPrefix>') resp[:contents].each do |object| puts "Key: #{object[:key]}" puts "ETag: #{object[:etag]}" end ## 批量删除空间中的文件 创建 `main.rb` require 'aws-sdk-s3' s3 = Aws::S3::Client::new( region: 'cn-east-1', # 华东-浙江区 region id credentials: Aws::Credentials.new('<QiniuAccessKey>', '<QiniuSecretKey>'), endpoint: 'https://s3.cn-east-1.qiniucs.com', # 华东-浙江区 endpoint ) s3.delete_objects(bucket: '<Bucket>', delete: { objects: [{key: '<Key1>'}, {key: '<Key2>'}, {key: '<Key3>'}] }) puts 'Done' # 临时安全凭证 创建 `main.rb` require 'aws-sdk-s3' require 'aws-sdk-sts' sts = Aws::STS::Client::new( region: 'cn-east-1', # 华东-浙江区 region id credentials: Aws::Credentials.new('<QiniuAccessKey>', '<QiniuSecretKey>'), endpoint: 'https://s3.cn-east-1.qiniucs.com', # 华东-浙江区 endpoint ) get_federation_token_response = sts.get_federation_token({ name: 'Bob', duration_seconds: 3600, policy: '{"Version":"2012-10-17","Statement":[{"Sid":"Stmt1","Effect":"Allow","Action":["*"],"Resource":["*"]}]}' }) s3 = Aws::S3::Resource::new( region: 'cn-east-1', # 华东-浙江区 region id credentials: Aws::Credentials.new( get_federation_token_response.credentials.access_key_id, get_federation_token_response.credentials.secret_access_key, get_federation_token_response.credentials.session_token ), endpoint: 'https://s3.cn-east-1.qiniucs.com', # 华东-浙江区 endpoint ) # 可以使用这些临时凭证调用 S3 服务 s3.buckets.each {|bucket| puts bucket.name} 以上内容是否对您有帮助？

AWS SDK for Rust

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [开发指南](https://developer.qiniu.com/kodo/development_guidelines/8596/development- guidelines) > [AWS S3 兼容](https://developer.qiniu.com/kodo/development_guidelines/4086/aws-s3-compatible) > [兼容 SDK 示例](https://developer.qiniu.com/kodo/development_guidelines/12553/S3 SDK sample) > AWS SDK for Rust # AWS SDK for Rust 最近更新时间: 2024-02-19 17:03:51 # 导入 AWS SDK for Rust 确保 Rust v1.70.0 或更新版本已经安装。 初始化 Rust 项目 cargo init 添加 AWS SDK for Rust 包 cargo add [email protected] cargo add aws-config@=1.1.5 cargo add aws-credential-types@=1.1.5 -F hardcoded-credentials cargo add aws-smithy-types@=1.1.6 -F rt-tokio cargo add aws-sdk-s3@=1.15.0 cargo add aws-sdk-sts@=1.13.0 cargo add [email protected] -F full 对于之后的每个代码示例，将代码创建在 `src/main.rs` 后，执行 cargo run 即可执行代码。 # 对象上传 ## 获取客户端上传 URL 创建 `src/main.rs` use aws_config::{BehaviorVersion, SdkConfig}; use aws_credential_types::{provider::SharedCredentialsProvider, Credentials}; use aws_sdk_s3::{config::Region, presigning::PresigningConfig, Client}; use std::time::Duration; #[tokio::main] async fn main() -> anyhow::Result<()> { let client = Client::new( &SdkConfig::builder() .region(Region::new("cn-east-1")) // 华东-浙江区 region id .endpoint_url("https://s3.cn-east-1.qiniucs.com") // 华东-浙江区 endpoint .behavior_version(BehaviorVersion::v2023_11_09()) .credentials_provider(SharedCredentialsProvider::new(Credentials::from_keys( "<QiniuAccessKey>", "<QiniuSecretKey>", None, ))) .build(), ); let request = client .put_object() .bucket("<Bucket>") .key("<Key>") .presigned( PresigningConfig::builder() .expires_in(Duration::from_secs(3600)) .build()?, ) .await?; println!("{}", request.uri()); Ok(()) } 这段代码将生成一个经过预先签名的客户端上传 URL，有效期为 1 小时，客户端可以在过期时间内对该 URL 发送 HTTP PUT 请求将文件上传。 以下是用 curl 上传文件的案例： curl -X PUT --upload-file "<path/to/file>" "<presigned url>" ## 服务器端直传 ### 单请求上传（文件） 创建 `src/main.rs` use aws_config::{BehaviorVersion, SdkConfig}; use aws_credential_types::{provider::SharedCredentialsProvider, Credentials}; use aws_sdk_s3::{config::Region, primitives::ByteStream, Client}; #[tokio::main] async fn main() -> anyhow::Result<()> { let client = Client::new( &SdkConfig::builder() .region(Region::new("cn-east-1")) // 华东-浙江区 region id .endpoint_url("https://s3.cn-east-1.qiniucs.com") // 华东-浙江区 endpoint .behavior_version(BehaviorVersion::v2023_11_09()) .credentials_provider(SharedCredentialsProvider::new(Credentials::from_keys( "<QiniuAccessKey>", "<QiniuSecretKey>", None, ))) .build(), ); let output = client .put_object() .bucket("<Bucket>") .key("<Key>") .body(ByteStream::from_path("<path/to/upload>").await?) .send() .await?; let etag = output.e_tag().expect("etag is expected"); println!("ETag: {}", etag); Ok(()) } ### 单请求上传（数据流） 创建 `src/main.rs` use aws_config::{BehaviorVersion, SdkConfig}; use aws_credential_types::{provider::SharedCredentialsProvider, Credentials}; use aws_sdk_s3::{config::Region, primitives::ByteStream, Client}; #[tokio::main] async fn main() -> anyhow::Result<()> { let client = Client::new( &SdkConfig::builder() .region(Region::new("cn-east-1")) .endpoint_url("https://s3.cn-east-1.qiniucs.com") // 华东-浙江区 endpoint .behavior_version(BehaviorVersion::v2023_11_09()) .credentials_provider(SharedCredentialsProvider::new(Credentials::from_keys( "<QiniuAccessKey>", "<QiniuSecretKey>", None, ))) .build(), ); let output = client .put_object() .bucket("<Bucket>") .key("<Key>") .body(ByteStream::from_static(b"Hello from Qiniu S3!")) .send() .await?; let etag = output.e_tag().expect("etag is expected"); println!("ETag: {}", etag); Ok(()) } ### 分片上传（文件） 创建 `src/main.rs` use aws_config::{BehaviorVersion, SdkConfig}; use aws_credential_types::{provider::SharedCredentialsProvider, Credentials}; use aws_sdk_s3::{ config::Region, primitives::ByteStream, types::{CompletedMultipartUpload, CompletedPart}, Client, }; use aws_smithy_types::byte_stream::Length; use tokio::fs::metadata; #[tokio::main] async fn main() -> anyhow::Result<()> { let client = Client::new( &SdkConfig::builder() .region(Region::new("cn-east-1")) // 华东-浙江区 region id .endpoint_url("https://s3.cn-east-1.qiniucs.com") // 华东-浙江区 endpoint .behavior_version(BehaviorVersion::v2023_11_09()) .credentials_provider(SharedCredentialsProvider::new(Credentials::from_keys( "<QiniuAccessKey>", "<QiniuSecretKey>", None, ))) .build(), ); let create_multipart_upload_resp = client .create_multipart_upload() .bucket("<Bucket>") .key("<Key>") .send() .await?; const PART_SIZE: u64 = 5 * 1024 * 1024; // 分片大小为 5 MB let mut offset: u64 = 0; let file_size = metadata("<path/to/upload>").await?.len(); let mut completed_multipart_upload_builder = CompletedMultipartUpload::builder(); let upload_id = create_multipart_upload_resp .upload_id() .expect("upload_id is expected"); // 这里给出的案例是串行分片上传。可以自行改造成并行分片上传以进一步提升上传速度 for part_number in 1.. { if offset >= file_size { break; } let part_size = PART_SIZE.min(file_size - offset); let upload_part_resp = client .upload_part() .bucket("<Bucket>") .key("<Key>") .upload_id(upload_id) .part_number(part_number) .body( ByteStream::read_from() .path("<path/to/upload>") .offset(offset) .length(Length::UpTo(part_size)) .build() .await?, ) .send() .await?; let etag = upload_part_resp.e_tag().expect("etag is expected"); completed_multipart_upload_builder = completed_multipart_upload_builder.parts( CompletedPart::builder() .part_number(part_number) .e_tag(etag) .build(), ); offset += part_size; } let complete_multipart_upload_resp = client .complete_multipart_upload() .bucket("<Bucket>") .key("<Key>") .upload_id(upload_id) .multipart_upload(completed_multipart_upload_builder.build()) .send() .await?; let etag = complete_multipart_upload_resp .e_tag() .expect("etag is expected"); println!("ETag: {}", etag); Ok(()) } # 对象下载 ## 获取客户端下载 URL 创建 `src/main.rs` use aws_config::{BehaviorVersion, SdkConfig}; use aws_credential_types::{provider::SharedCredentialsProvider, Credentials}; use aws_sdk_s3::{config::Region, presigning::PresigningConfig, Client}; use std::time::Duration; #[tokio::main] async fn main() -> anyhow::Result<()> { let client = Client::new( &SdkConfig::builder() .region(Region::new("cn-east-1")) // 华东-浙江区 region id .endpoint_url("https://s3.cn-east-1.qiniucs.com") // 华东-浙江区 endpoint .behavior_version(BehaviorVersion::v2023_11_09()) .credentials_provider(SharedCredentialsProvider::new(Credentials::from_keys( "<QiniuAccessKey>", "<QiniuSecretKey>", None, ))) .build(), ); let request = client .get_object() .bucket("<Bucket>") .key("<Key>") .presigned( PresigningConfig::builder() .expires_in(Duration::from_secs(3600)) .build()?, ) .await?; println!("{}", request.uri()); Ok(()) } 这段代码将生成一个经过预先签名的客户端下载 URL，有效期为 1 小时，客户端可以在过期时间内对该 URL 发送 HTTP GET 请求将文件下载。 以下是用 curl 下载文件的案例： curl -o "<path/to/download>" "<presigned url>" ## 服务器端直接下载 创建 `src/main.rs` use std::mem::take; use aws_config::{BehaviorVersion, SdkConfig}; use aws_credential_types::{provider::SharedCredentialsProvider, Credentials}; use aws_sdk_s3::{config::Region, Client}; use tokio::{fs::File, io::copy}; #[tokio::main] async fn main() -> anyhow::Result<()> { let client = Client::new( &SdkConfig::builder() .region(Region::new("cn-east-1")) // 华东-浙江区 region id .endpoint_url("https://s3.cn-east-1.qiniucs.com") // 华东-浙江区 endpoint .behavior_version(BehaviorVersion::v2023_11_09()) .credentials_provider(SharedCredentialsProvider::new(Credentials::from_keys( "<QiniuAccessKey>", "<QiniuSecretKey>", None, ))) .build(), ); let mut resp = client .get_object() .bucket("<Bucket>") .key("<Key>") .send() .await?; let mut file = File::create("<path/to/download>").await?; copy(&mut take(&mut resp.body).into_async_read(), &mut file).await?; println!("ETag: {}", resp.e_tag().expect("etag is expected")); Ok(()) } # 对象管理 ## 获取对象信息 创建 `src/main.rs` use aws_config::{BehaviorVersion, SdkConfig}; use aws_credential_types::{provider::SharedCredentialsProvider, Credentials}; use aws_sdk_s3::{config::Region, Client}; #[tokio::main] async fn main() -> anyhow::Result<()> { let client = Client::new( &SdkConfig::builder() .region(Region::new("cn-east-1")) // 华东-浙江区 region id .endpoint_url("https://s3.cn-east-1.qiniucs.com") // 华东-浙江区 endpoint .behavior_version(BehaviorVersion::v2023_11_09()) .credentials_provider(SharedCredentialsProvider::new(Credentials::from_keys( "<QiniuAccessKey>", "<QiniuSecretKey>", None, ))) .build(), ); let resp = client .head_object() .bucket("<Bucket>") .key("<Key>") .send() .await?; println!("ETag: {}", resp.e_tag().expect("etag is expected")); Ok(()) } ## 修改对象 MimeType 创建 `src/main.rs` use aws_config::{BehaviorVersion, SdkConfig}; use aws_credential_types::{provider::SharedCredentialsProvider, Credentials}; use aws_sdk_s3::{config::Region, types::MetadataDirective, Client}; #[tokio::main] async fn main() -> anyhow::Result<()> { let client = Client::new( &SdkConfig::builder() .region(Region::new("cn-east-1")) // 华东-浙江区 region id .endpoint_url("https://s3.cn-east-1.qiniucs.com") // 华东-浙江区 endpoint .behavior_version(BehaviorVersion::v2023_11_09()) .credentials_provider(SharedCredentialsProvider::new(Credentials::from_keys( "<QiniuAccessKey>", "<QiniuSecretKey>", None, ))) .build(), ); client .copy_object() .bucket("<Bucket>") .key("<Key>") .copy_source("/<Bucket>/<Key>") .content_type("<NewContentType>") .metadata_directive(MetadataDirective::Replace) .send() .await?; println!("Done"); Ok(()) } ## 修改对象存储类型 创建 `src/main.rs` use aws_config::{BehaviorVersion, SdkConfig}; use aws_credential_types::{provider::SharedCredentialsProvider, Credentials}; use aws_sdk_s3::{ config::Region, types::{MetadataDirective, StorageClass}, Client, }; #[tokio::main] async fn main() -> anyhow::Result<()> { let client = Client::new( &SdkConfig::builder() .region(Region::new("cn-east-1")) // 华东-浙江区 region id .endpoint_url("https://s3.cn-east-1.qiniucs.com") // 华东-浙江区 endpoint .behavior_version(BehaviorVersion::v2023_11_09()) .credentials_provider(SharedCredentialsProvider::new(Credentials::from_keys( "<QiniuAccessKey>", "<QiniuSecretKey>", None, ))) .build(), ); client .copy_object() .bucket("<Bucket>") .key("<Key>") .copy_source("/<Bucket>/<Key>") .storage_class(StorageClass::Glacier) .metadata_directive(MetadataDirective::Replace) .send() .await?; println!("Done"); Ok(()) } ## 复制对象副本 创建 `src/main.rs` use aws_config::{BehaviorVersion, SdkConfig}; use aws_credential_types::{provider::SharedCredentialsProvider, Credentials}; use aws_sdk_s3::{config::Region, types::MetadataDirective, Client}; #[tokio::main] async fn main() -> anyhow::Result<()> { let client = Client::new( &SdkConfig::builder() .region(Region::new("cn-east-1")) .endpoint_url("https://s3.cn-east-1.qiniucs.com") // 华东-浙江区 endpoint .behavior_version(BehaviorVersion::v2023_11_09()) .credentials_provider(SharedCredentialsProvider::new(Credentials::from_keys( "<QiniuAccessKey>", "<QiniuSecretKey>", None, ))) .build(), ); client .copy_object() .bucket("<ToBucket>") .key("<ToKey>") .copy_source("/<FromBucket>/<FromKey>") .metadata_directive(MetadataDirective::Copy) .send() .await?; println!("Done"); Ok(()) } ## 复制对象副本（大于 5GB） 创建 `src/main.rs` use aws_config::{BehaviorVersion, SdkConfig}; use aws_credential_types::{provider::SharedCredentialsProvider, Credentials}; use aws_sdk_s3::{ config::Region, types::{CompletedMultipartUpload, CompletedPart}, Client, }; #[tokio::main] async fn main() -> anyhow::Result<()> { let client = Client::new( &SdkConfig::builder() .region(Region::new("cn-east-1")) // 华东-浙江区 region id .endpoint_url("https://s3.cn-east-1.qiniucs.com") // 华东-浙江区 endpoint .behavior_version(BehaviorVersion::v2023_11_09()) .credentials_provider(SharedCredentialsProvider::new(Credentials::from_keys( "<QiniuAccessKey>", "<QiniuSecretKey>", None, ))) .build(), ); let head_object_resp = client .head_object() .bucket("<FromBucket>") .key("<FromKey>") .send() .await?; let content_length = u64::try_from(head_object_resp.content_length().unwrap())?; let create_multipart_upload_resp = client .create_multipart_upload() .bucket("<ToBucket>") .key("<ToKey>") .send() .await?; const PART_SIZE: u64 = 5 * 1024 * 1024; let mut offset: u64 = 0; let mut completed_multipart_upload_builder = CompletedMultipartUpload::builder(); let upload_id = create_multipart_upload_resp .upload_id() .expect("upload_id is expected"); for part_number in 1.. { if offset >= content_length { break; } let part_size = PART_SIZE.min(content_length - offset); let upload_part_copy_resp = client .upload_part_copy() .bucket("<ToBucket>") .key("<ToKey>") .upload_id(upload_id) .part_number(part_number) .copy_source("/<FromBucket>/<FromKey>") .copy_source_range(format!("bytes={}-{}", offset, offset + part_size - 1)) .send() .await?; let etag = upload_part_copy_resp .copy_part_result() .expect("copy_part_result is expected") .e_tag() .expect("etag is expected"); completed_multipart_upload_builder = completed_multipart_upload_builder.parts( CompletedPart::builder() .part_number(part_number) .e_tag(etag) .build(), ); offset += part_size; } let complete_multipart_upload_resp = client .complete_multipart_upload() .bucket("<ToBucket>") .key("<ToKey>") .upload_id(upload_id) .multipart_upload(completed_multipart_upload_builder.build()) .send() .await?; let etag = complete_multipart_upload_resp .e_tag() .expect("etag is expected"); println!("ETag: {}", etag); Ok(()) } ## 删除空间中的文件 创建 `src/main.rs` use aws_config::{BehaviorVersion, SdkConfig}; use aws_credential_types::{provider::SharedCredentialsProvider, Credentials}; use aws_sdk_s3::{config::Region, Client}; #[tokio::main] async fn main() -> anyhow::Result<()> { let client = Client::new( &SdkConfig::builder() .region(Region::new("cn-east-1")) // 华东-浙江区 region id .endpoint_url("https://s3.cn-east-1.qiniucs.com") // 华东-浙江区 endpoint .behavior_version(BehaviorVersion::v2023_11_09()) .credentials_provider(SharedCredentialsProvider::new(Credentials::from_keys( "<QiniuAccessKey>", "<QiniuSecretKey>", None, ))) .build(), ); client .delete_object() .bucket("<Bucket>") .key("<Key>") .send() .await?; println!("Done"); Ok(()) } ## 获取指定前缀的文件列表 创建 `src/main.rs` use aws_config::{BehaviorVersion, SdkConfig}; use aws_credential_types::{provider::SharedCredentialsProvider, Credentials}; use aws_sdk_s3::{config::Region, Client}; #[tokio::main] async fn main() -> anyhow::Result<()> { let client = Client::new( &SdkConfig::builder() .region(Region::new("cn-east-1")) // 华东-浙江区 region id .endpoint_url("https://s3.cn-east-1.qiniucs.com") // 华东-浙江区 endpoint .behavior_version(BehaviorVersion::v2023_11_09()) .credentials_provider(SharedCredentialsProvider::new(Credentials::from_keys( "<QiniuAccessKey>", "<QiniuSecretKey>", None, ))) .build(), ); let resp = client .list_objects_v2() .bucket("<Bucket>") .prefix("<KeyPrefix>") .send() .await?; for content in resp.contents() { println!("Key: {}", content.key().expect("key is expected")); println!("ETag: {}", content.e_tag().expect("etag is expected")); } Ok(()) } ## 批量删除空间中的文件 创建 `src/main.rs` use aws_config::{BehaviorVersion, SdkConfig}; use aws_credential_types::{provider::SharedCredentialsProvider, Credentials}; use aws_sdk_s3::{ config::Region, types::{Delete, ObjectIdentifier}, Client, }; #[tokio::main] async fn main() -> anyhow::Result<()> { let client = Client::new( &SdkConfig::builder() .region(Region::new("cn-east-1")) // 华东-浙江区 region id .endpoint_url("https://s3.cn-east-1.qiniucs.com") // 华东-浙江区 endpoint .behavior_version(BehaviorVersion::v2023_11_09()) .credentials_provider(SharedCredentialsProvider::new(Credentials::from_keys( "<QiniuAccessKey>", "<QiniuSecretKey>", None, ))) .build(), ); client .delete_objects() .bucket("<Bucket>") .delete( Delete::builder() .objects(ObjectIdentifier::builder().key("<Key1>").build()?) .objects(ObjectIdentifier::builder().key("<Key2>").build()?) .objects(ObjectIdentifier::builder().key("<Key3>").build()?) .build()?, ) .send() .await?; println!("Done"); Ok(()) } # 临时安全凭证 创建 `src/main.rs` use aws_config::{BehaviorVersion, SdkConfig}; use aws_credential_types::{ provider::{error::CredentialsError, ProvideCredentials, SharedCredentialsProvider}, Credentials, }; use aws_sdk_s3::{config::Region, Client as S3Client}; use aws_sdk_sts::{ operation::get_federation_token::builders::GetFederationTokenFluentBuilder, Client as StsClient, }; #[derive(Debug)] struct StsCredentialsProvider { get_federation_token_builder: GetFederationTokenFluentBuilder, } impl ProvideCredentials for StsCredentialsProvider { fn provide_credentials<'a>( &'a self, ) -> aws_credential_types::provider::future::ProvideCredentials<'a> where Self: 'a, { aws_credential_types::provider::future::ProvideCredentials::new(async { match self.get_federation_token_builder.to_owned().send().await { Ok(get_federation_token_output) => { if let Some(credentials) = get_federation_token_output.credentials() { Ok(Credentials::new( credentials.access_key_id(), credentials.secret_access_key(), Some(credentials.session_token().to_owned()), Some( credentials .expiration() .to_owned() .try_into() .map_err(CredentialsError::unhandled)?, ), "Bob", )) } else { Err(CredentialsError::not_loaded( "No credentials from get_federation_token", )) } } Err(err) => Err(CredentialsError::provider_error(err)), } }) } } #[tokio::main] async fn main() -> anyhow::Result<()> { let sts_client = StsClient::new( &SdkConfig::builder() .region(Region::new("cn-east-1")) // 华东-浙江区 region id .endpoint_url("https://s3.cn-east-1.qiniucs.com") // 华东-浙江区 endpoint .behavior_version(BehaviorVersion::v2023_11_09()) .credentials_provider(SharedCredentialsProvider::new(Credentials::from_keys( "<QiniuAccessKey>", "<QiniuSecretKey>", None, ))) .build(), ); let s3_client = S3Client::new( &SdkConfig::builder() .region(Region::new("cn-east-1")) // 华东-浙江区 region id .endpoint_url("https://s3.cn-east-1.qiniucs.com") // 华东-浙江区 endpoint .behavior_version(BehaviorVersion::v2023_11_09()) .credentials_provider(SharedCredentialsProvider::new(StsCredentialsProvider { get_federation_token_builder: sts_client.get_federation_token(). set_name(Some("Bob".to_owned())). set_duration_seconds(Some(3600)). set_policy(Some("{\"Version\":\"2012-10-17\",\"Statement\":[{\"Sid\":\"Stmt1\",\"Effect\":\"Allow\",\"Action\":[\"*\"],\"Resource\":[\"*\"]}]}".to_owned())), })) .build(), ); // 可以使用这些临时凭证调用 S3 服务 let list_buckets_output = s3_client.list_buckets().send().await?; for bucket in list_buckets_output.buckets() { println!("{}", bucket.name().unwrap()); } Ok(()) } 以上内容是否对您有帮助？

AWS SDK for Swift

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [开发指南](https://developer.qiniu.com/kodo/development_guidelines/8596/development- guidelines) > [AWS S3 兼容](https://developer.qiniu.com/kodo/development_guidelines/4086/aws-s3-compatible) > [兼容 SDK 示例](https://developer.qiniu.com/kodo/development_guidelines/12553/S3 SDK sample) > AWS SDK for Swift # AWS SDK for Swift 最近更新时间: 2024-02-19 17:03:58 # 导入 AWS SDK for Swift 确保 Swift 5.7 或更高版本，以及 OpenSSL v1.x 已经被安装。 AWS SDK for Swift 支持以下平台： * iOS & iPadOS 13.0 或更高版本 * macOS 10.15 或更高版本 * Ubuntu Linux 16.04 LTS 或更高版本 * Amazon Linux 2 或更高版本 初始化 Swift 项目 swift package init --type executable 添加 AWS SDK for Swift 包，这里给出 `Package.swift` 的案例 // swift-tools-version:5.5 // The swift-tools-version declares the minimum version of Swift required to build this package. import PackageDescription let package = Package( name: "aws-swift-sdk-test-examples", dependencies: [ .package( url: "https://github.com/awslabs/aws-sdk-swift", from: "0.36.0" ) ], targets: [ // Targets are the basic building blocks of a package. A target can define a module or a test suite. // Targets can depend on other targets in this package, and on products in packages this package depends on. .executableTarget( name: "aws-swift-sdk-test-examples", dependencies: [ .product(name: "AWSS3", package: "aws-sdk-swift"), .product(name: "AWSSTS", package: "aws-sdk-swift")], path: "Sources") ] ) 对于之后的每个代码示例，将代码创建在 `Sources/entry.swift` 后，执行 swift run 即可执行代码。 # 对象上传 ## 获取客户端上传 URL 创建 `Sources/entry.swift` import AWSClientRuntime import AWSS3 @main struct Main { static func main() async throws { let config = try await S3Client.S3ClientConfiguration() config.credentialsProvider = try StaticCredentialsProvider(Credentials( accessKey: "<QiniuAccessKey>", secret: "<QiniuSecretKey>" )) config.region = "cn-east-1" // 华东-浙江区 region id config.endpoint = "https://s3.cn-east-1.qiniucs.com" // 华东-浙江区 endpoint let uploadRequest = PutObjectInput( bucket: "<Bucket>", key: "<Key>" ) let url = try await uploadRequest.presignURL(config: config, expiration: 3600) print("\(String(describing: url))") } } 这段代码将生成一个经过预先签名的客户端上传 URL，有效期为 1 小时，客户端可以在过期时间内对该 URL 发送 HTTP PUT 请求将文件上传。 以下是用 curl 上传文件的案例： curl -X PUT --upload-file "<path/to/file>" "<presigned url>" ## 服务器端直传 ### 单请求上传（文件） 创建 `Sources/entry.swift` import Foundation import ClientRuntime import AWSClientRuntime import AWSS3 @main struct Main { static func main() async throws { let config = try await S3Client.S3ClientConfiguration() config.credentialsProvider = try StaticCredentialsProvider(Credentials( accessKey: "<QiniuAccessKey>", secret: "<QiniuSecretKey>" )) config.region = "cn-east-1" // 华东-浙江区 region id config.endpoint = "https://s3.cn-east-1.qiniucs.com" // 华东-浙江区 endpoint let client = S3Client(config: config) guard let file = FileHandle(forReadingAtPath: "<path/to/upload>") else { return } let response = try await client.putObject(input: PutObjectInput( body: ByteStream.from(fileHandle: file), bucket: "<Bucket>", key: "<Key>" )) print("ETag: \(String(describing: response.eTag))") } } ### 单请求上传（数据流） 创建 `Sources/entry.swift` import Foundation import ClientRuntime import AWSClientRuntime import AWSS3 @main struct Main { static func main() async throws { let config = try await S3Client.S3ClientConfiguration() config.credentialsProvider = try StaticCredentialsProvider(Credentials( accessKey: "<QiniuAccessKey>", secret: "<QiniuSecretKey>" )) config.region = "cn-east-1" // 华东-浙江区 region id config.endpoint = "https://s3.cn-east-1.qiniucs.com" // 华东-浙江区 endpoint let client = S3Client(config: config) let response = try await client.putObject(input: PutObjectInput( body: ByteStream.data("Hello from Qiniu S3!".data(using: .utf8)), bucket: "<Bucket>", key: "<Key>" )) print("ETag: \(String(describing: response.eTag))") } } ### 分片上传（文件） 创建 `Sources/entry.swift` import Foundation import ClientRuntime import AWSClientRuntime import AWSS3 @main struct Main { static func main() async throws { let config = try await S3Client.S3ClientConfiguration() config.credentialsProvider = try StaticCredentialsProvider(Credentials( accessKey: "<QiniuAccessKey>", secret: "<QiniuSecretKey>" )) config.region = "cn-east-1" // 华东-浙江区 region id config.endpoint = "https://s3.cn-east-1.qiniucs.com" // 华东-浙江区 endpoint let client = S3Client(config: config) guard let file = FileHandle(forReadingAtPath: "<path/to/upload>") else { return } let createMultipartUploadResponse = try await client.createMultipartUpload(input: CreateMultipartUploadInput( bucket: "<Bucket>", key: "<Key>" )) if createMultipartUploadResponse.uploadId == nil { return } let PART_SIZE = 5 * 1024 * 1024 // 分片大小为 5 MB var parts = [S3ClientTypes.CompletedPart]() var partNum = 1 // 这里给出的案例是串行分片上传。可以自行改造成并行分片上传以进一步提升上传速度 while true { let data = file.readData(ofLength: PART_SIZE) if data.count == 0 { break } let uploadPartResponse = try await client.uploadPart(input: UploadPartInput( body: ByteStream.data(data), bucket: createMultipartUploadResponse.bucket, key: createMultipartUploadResponse.key, partNumber: partNum, uploadId: createMultipartUploadResponse.uploadId )) if uploadPartResponse.eTag == nil { return } parts.append(S3ClientTypes.CompletedPart( eTag: uploadPartResponse.eTag, partNumber: partNum )) partNum += 1 } let completeMultipartUploadResponse = try await client.completeMultipartUpload(input: CompleteMultipartUploadInput( bucket: createMultipartUploadResponse.bucket, key: createMultipartUploadResponse.key, multipartUpload: S3ClientTypes.CompletedMultipartUpload(parts: parts), uploadId: createMultipartUploadResponse.uploadId )) print("ETag: \(String(describing: completeMultipartUploadResponse.eTag)))") } } # 对象下载 ## 获取客户端下载 URL 创建 `Sources/entry.swift` import AWSClientRuntime import AWSS3 @main struct Main { static func main() async throws { let config = try await S3Client.S3ClientConfiguration() config.credentialsProvider = try StaticCredentialsProvider(Credentials( accessKey: "<QiniuAccessKey>", secret: "<QiniuSecretKey>" )) config.region = "cn-east-1" // 华东-浙江区 region id config.endpoint = "https://s3.cn-east-1.qiniucs.com" // 华东-浙江区 endpoint let downloadRequest = GetObjectInput( bucket: "<Bucket>", key: "<Key>" ) let url = try await downloadRequest.presignURL(config: config, expiration: 3600) print("\(String(describing: url))") } } 这段代码将生成一个经过预先签名的客户端下载 URL，有效期为 1 小时，客户端可以在过期时间内对该 URL 发送 HTTP GET 请求将文件下载。 以下是用 curl 下载文件的案例： curl -o "<path/to/download>" "<presigned url>" ## 服务器端直接下载 创建 `Sources/entry.swift` import AWSClientRuntime import AWSS3 @main struct Main { static func main() async throws { let config = try await S3Client.S3ClientConfiguration() config.credentialsProvider = try StaticCredentialsProvider(Credentials( accessKey: "<QiniuAccessKey>", secret: "<QiniuSecretKey>" )) config.region = "cn-east-1" // 华东-浙江区 region id config.endpoint = "https://s3.cn-east-1.qiniucs.com" // 华东-浙江区 endpoint let client = S3Client(config: config) let response = try await client.getObject(input: GetObjectInput( bucket: "<Bucket>", key: "<Key>" )) guard let body = response.body, let data = try await body.readData() else { return } try data.write(to: URL(fileURLWithPath: "<path/to/download>")) print("ETag: \(String(describing: response.eTag))") } } # 对象管理 ## 获取对象信息 创建 `Sources/entry.swift` import AWSClientRuntime import AWSS3 @main struct Main { static func main() async throws { let config = try await S3Client.S3ClientConfiguration() config.credentialsProvider = try StaticCredentialsProvider(Credentials( accessKey: "<QiniuAccessKey>", secret: "<QiniuSecretKey>" )) config.region = "cn-east-1" // 华东-浙江区 region id config.endpoint = "https://s3.cn-east-1.qiniucs.com" // 华东-浙江区 endpoint let client = S3Client(config: config) let response = try await client.headObject(input: HeadObjectInput( bucket: "<Bucket>", key: "<Key>" )) print("ETag: \(String(describing: response.eTag))") } } ## 修改对象 MimeType 创建 `Sources/entry.swift` import AWSClientRuntime import AWSS3 @main struct Main { static func main() async throws { let config = try await S3Client.S3ClientConfiguration() config.credentialsProvider = try StaticCredentialsProvider(Credentials( accessKey: "<QiniuAccessKey>", secret: "<QiniuSecretKey>" )) config.region = "cn-east-1" // 华东-浙江区 region id config.endpoint = "https://s3.cn-east-1.qiniucs.com" // 华东-浙江区 endpoint let client = S3Client(config: config) let _ = try await client.copyObject(input: CopyObjectInput( bucket: "<Bucket>", contentType: "text/plain", copySource: "/<Bucket>/<Key>", key: "<Bucket>", metadataDirective: .replace )) print("Done") } } ## 修改对象存储类型 创建 `Sources/entry.swift` import AWSClientRuntime import AWSS3 @main struct Main { static func main() async throws { let config = try await S3Client.S3ClientConfiguration() config.credentialsProvider = try StaticCredentialsProvider(Credentials( accessKey: "<QiniuAccessKey>", secret: "<QiniuSecretKey>" )) config.region = "cn-east-1" // 华东-浙江区 region id config.endpoint = "https://s3.cn-east-1.qiniucs.com" // 华东-浙江区 endpoint let client = S3Client(config: config) let _ = try await client.copyObject(input: CopyObjectInput( bucket: "<Bucket>", copySource: "/<Bucket>/<Key>", key: "<Key>", metadataDirective: .replace, storageClass: .glacier )) print("Done") } } ## 复制对象副本 创建 `Sources/entry.swift` import AWSClientRuntime import AWSS3 @main struct Main { static func main() async throws { let config = try await S3Client.S3ClientConfiguration() config.credentialsProvider = try StaticCredentialsProvider(Credentials( accessKey: "<QiniuAccessKey>", secret: "<QiniuSecretKey>" )) config.region = "cn-east-1" // 华东-浙江区 region id config.endpoint = "https://s3.cn-east-1.qiniucs.com" // 华东-浙江区 endpoint let client = S3Client(config: config) let _ = try await client.copyObject(input: CopyObjectInput( bucket: "<ToBucket>", copySource: "/<FromBucket>/<FromKey>", key: "<ToKey>", metadataDirective: .copy )) print("Done") } } ## 复制对象副本（大于 5GB） 创建 `Sources/entry.swift` import Foundation import ClientRuntime import AWSClientRuntime import AWSS3 @main struct Main { static func main() async throws { let config = try await S3Client.S3ClientConfiguration() config.credentialsProvider = try StaticCredentialsProvider(Credentials( accessKey: "<QiniuAccessKey>", secret: "<QiniuSecretKey>" )) config.region = "cn-east-1" // 华东-浙江区 region id config.endpoint = "https://s3.cn-east-1.qiniucs.com" // 华东-浙江区 endpoint let client = S3Client(config: config) let headObjectResponse = try await client.headObject(input: HeadObjectInput( bucket: "<FromBucket>", key: "<FromKey>" )) let createMultipartUploadResponse = try await client.createMultipartUpload(input: CreateMultipartUploadInput( bucket: "<ToBucket>", key: "<ToKey>" )) if createMultipartUploadResponse.uploadId == nil { return } let PART_SIZE = 5 * 1024 * 1024 // 分片大小为 5 MB var parts = [S3ClientTypes.CompletedPart]() var partNum = 1 var copied = 0 // 这里给出的案例是串行分片复制。可以自行改造成并行分片复制以进一步提升复制速度 while copied < headObjectResponse.contentLength! { let partSize = min(headObjectResponse.contentLength! - copied, PART_SIZE) let uploadPartCopyResponse = try await client.uploadPartCopy(input: UploadPartCopyInput( bucket: createMultipartUploadResponse.bucket, copySource: "/<FromBucket>/<FromKey>", copySourceRange: "bytes=\(copied)-\(copied+partSize-1)", key: createMultipartUploadResponse.key, partNumber: partNum, uploadId: createMultipartUploadResponse.uploadId )) if uploadPartCopyResponse.copyPartResult?.eTag == nil { return } parts.append(S3ClientTypes.CompletedPart( eTag: uploadPartCopyResponse.copyPartResult?.eTag, partNumber: partNum )) partNum += 1 copied += partSize } let completeMultipartUploadResponse = try await client.completeMultipartUpload(input: CompleteMultipartUploadInput( bucket: createMultipartUploadResponse.bucket, key: createMultipartUploadResponse.key, multipartUpload: S3ClientTypes.CompletedMultipartUpload(parts: parts), uploadId: createMultipartUploadResponse.uploadId )) print("ETag: \(String(describing: completeMultipartUploadResponse.eTag)))") } } ## 删除空间中的文件 创建 `Sources/entry.swift` import AWSClientRuntime import AWSS3 @main struct Main { static func main() async throws { let config = try await S3Client.S3ClientConfiguration() config.credentialsProvider = try StaticCredentialsProvider(Credentials( accessKey: "<QiniuAccessKey>", secret: "<QiniuSecretKey>" )) config.region = "cn-east-1" // 华东-浙江区 region id config.endpoint = "https://s3.cn-east-1.qiniucs.com" // 华东-浙江区 endpoint let client = S3Client(config: config) let _ = try await client.deleteObject(input: DeleteObjectInput( bucket: "<Bucket>", key: "<Key>" )) print("Done") } } ## 获取指定前缀的文件列表 创建 `Sources/entry.swift` import AWSClientRuntime import AWSS3 @main struct Main { static func main() async throws { let config = try await S3Client.S3ClientConfiguration() config.credentialsProvider = try StaticCredentialsProvider(Credentials( accessKey: "<QiniuAccessKey>", secret: "<QiniuSecretKey>" )) config.region = "cn-east-1" // 华东-浙江区 region id config.endpoint = "https://s3.cn-east-1.qiniucs.com" // 华东-浙江区 endpoint let client = S3Client(config: config) let response = try await client.listObjectsV2(input: ListObjectsV2Input( bucket: "<Bucket>", prefix: "<KeyPrefix>" )) for content in response.contents ?? [] { print("Key: \(String(describing: content.key))") print("ETag: \(String(describing: content.eTag))") } } } ## 批量删除空间中的文件 创建 `Sources/entry.swift` import AWSClientRuntime import AWSS3 @main struct Main { static func main() async throws { let config = try await S3Client.S3ClientConfiguration() config.credentialsProvider = try StaticCredentialsProvider(Credentials( accessKey: "<QiniuAccessKey>", secret: "<QiniuSecretKey>" )) config.region = "cn-east-1" // 华东-浙江区 region id config.endpoint = "https://s3.cn-east-1.qiniucs.com" // 华东-浙江区 endpoint let client = S3Client(config: config) let _ = try await client.deleteObjects(input: DeleteObjectsInput( bucket: "<Bucket>", delete: S3ClientTypes.Delete(objects: [ S3ClientTypes.ObjectIdentifier(key: "<Key1>"), S3ClientTypes.ObjectIdentifier(key: "<Key2>"), S3ClientTypes.ObjectIdentifier(key: "<Key3>"), ]) )) print("Done") } } # 临时安全凭证 创建 `Sources/entry.swift` import Foundation import ClientRuntime import AwsCommonRuntimeKit import AWSClientRuntime import AWSS3 import AWSSTS struct StsCredentialsProvider: AWSClientRuntime.CredentialsProviding { private let stsClient: STSClient private let getFederationTokenInput: GetFederationTokenInput public init(_ stsClient: STSClient, getFederationTokenInput: GetFederationTokenInput) throws { self.stsClient = stsClient self.getFederationTokenInput = getFederationTokenInput } func getCredentials() async throws -> AWSClientRuntime.Credentials { let getFederationTokenOutput = try await self.stsClient.getFederationToken(input: self.getFederationTokenInput) return AWSClientRuntime.Credentials( accessKey: getFederationTokenOutput.credentials!.accessKeyId!, secret: getFederationTokenOutput.credentials!.secretAccessKey!, expirationTimeout: getFederationTokenOutput.credentials?.expiration, sessionToken: getFederationTokenOutput.credentials?.sessionToken) } } @main struct Main { static func main() async throws { let stsConfig = try await STSClient.STSClientConfiguration() stsConfig.credentialsProvider = try StaticCredentialsProvider(Credentials( accessKey: "<QiniuAccessKey>", secret: "<QiniuSecretKey>" )) stsConfig.region = "cn-east-1" // 华东-浙江区 region id stsConfig.signingRegion = stsConfig.region stsConfig.endpoint = "https://s3.cn-east-1.qiniucs.com" // 华东-浙江区 endpoint let stsCredentialsProvider = try StsCredentialsProvider(STSClient(config: stsConfig), getFederationTokenInput: GetFederationTokenInput( durationSeconds: 3600, name: "Bob", policy: "{\"Version\":\"2012-10-17\",\"Statement\":[{\"Sid\":\"Stmt1\",\"Effect\":\"Allow\",\"Action\":[\"*\"],\"Resource\":[\"*\"]}]}")) let s3Config = try await S3Client.S3ClientConfiguration() s3Config.credentialsProvider = try AWSClientRuntime.CachedCredentialsProvider(source: stsCredentialsProvider, refreshTime: 0) s3Config.region = "cn-east-1" // 华东-浙江区 region id s3Config.signingRegion = s3Config.region s3Config.endpoint = "https://s3.cn-east-1.qiniucs.com" // 华东-浙江区 endpoint let client = S3Client(config: s3Config) // 可以使用这些临时凭证调用 S3 服务 try await client.listBuckets(input: ListBucketsInput()).buckets?.forEach { bucket in print(bucket.name!) } } } 以上内容是否对您有帮助？

兼容工具示例

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [开发指南](https://developer.qiniu.com/kodo/development_guidelines/8596/development- guidelines) > [AWS S3 兼容](https://developer.qiniu.com/kodo/development_guidelines/4086/aws-s3-compatible) > 兼容工具示例 # 兼容工具示例 最近更新时间: 2023-12-28 18:27:49 对大多数基于 AWS S3 的工具，进行如下改动即可访问七牛云对象存储 Kodo： * 获取七牛云账号的 AccessKey 和 SecretKey，在您使用的工具中配置七牛云的 AccessKey 和 SecretKey * 设置工具连接的 Region 及 Endpoint 分别为七牛云对象存储的 S3 Region ID 和 访问 Endpoint，可以参考[服务域名 __](https://developer.qiniu.com/kodo/4088/s3-access-domainname) 只要涉及的接口实现了兼容，即可在工具中使用对应的功能、对接七牛对象存储。 各工具对接七牛云对象存储的方式，参考： 使用说明 --- [AWS CLI](https://developer.qiniu.com/kodo/development_guidelines/12574/aws- cli-examples) [CloudBerry Explorer](https://developer.qiniu.com/kodo/development_guidelines/12576/cloud- berry-explorer-examples) [S3 Browser](https://developer.qiniu.com/kodo/development_guidelines/12577/s3-browser- examples) [S3FS](https://developer.qiniu.com/kodo/development_guidelines/12578/s3fs- examples) 以上内容是否对您有帮助？

AWS CLI

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [开发指南](https://developer.qiniu.com/kodo/development_guidelines/8596/development- guidelines) > [AWS S3 兼容](https://developer.qiniu.com/kodo/development_guidelines/4086/aws-s3-compatible) > [兼容工具示例](https://developer.qiniu.com/kodo/development_guidelines/4096/s3-compatible- sdk) > AWS CLI # AWS CLI 最近更新时间: 2023-12-28 18:02:33 AWS Command Line Interface (AWS CLI) 是一种开源工具，让您能够在命令行 Shell 中使用命令与 AWS 服务进行交互。通过配置，您可以使用 AWS CLI 管理您在七牛云对象存储的资源。 参考官方介绍：[AWS CLI __](https://docs.aws.amazon.com/zh_cn/cli/latest/userguide/cli-chap- welcome.html) # 安装 AWS CLI 确保 Python v3.8 或更新版本已经安装。 安装 AWS CLI，以 Linux amd64 为例 curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip" unzip awscliv2.zip sudo ./aws/install 然后安装插件便于设置 AWS CLI 使用七牛 S3 域名 sudo pip3 install awscli-plugin-endpoint 配置 AWS CLI 编写 `~/.aws/credentials` [default] aws_access_key_id = <QiniuAccessKey> aws_secret_access_key = <QiniuSecretKey> 编写 `~/.aws/config` [default] region = cn-east-1 s3 = endpoint_url = https://s3.cn-east-1.qiniucs.com [plugins] endpoint = awscli_plugin_endpoint 需要注意，这里的 `region` 和 `endpoint_url` 都可以按照实际使用需求来调整区域 ID 和区域终端 URL。 # 使用 AWS CLI 案例 ## 列举 BUCKETS aws s3 ls ## 创建 BUCKET aws s3 mb "s3://<NewBucketName>" ## 列举 OBJECTS aws s3 ls "<Bucket>/" aws s3 ls "<Bucket>/<Prefix>/" ## 签发 URL aws s3 presign "s3://<Bucket>/<Prefix>/<FileName>" ## 上传文件 aws s3 cp "<LocalPath>" "s3://<Bucket>/<DestPrefix>/" aws s3 sync "<LocalPath>" "s3://<Bucket>/<DestPrefix>/" ## 下载文件 aws s3 cp "s3://<Bucket>/<SrcPrefix>/<FileName>" "<LocalDestPath>" aws s3 sync "s3://<Bucket>/<SrcPrefix>/<FileName>" "<LocalDestPath>" ## 复制文件 aws s3 cp "s3://<SrcBucket>/<SrcPrefix>/<SrcFileName>" "s3://<DestBucket>/<DestPrefix>/<DestFileName>" ## 复制目录 aws s3 cp --recursive "s3://<SrcBucket>/<SrcPrefix>/" "s3://<DestBucket>/<DestPrefix>/" aws s3 sync "s3://<SrcBucket>/<SrcPrefix>/" "s3://<DestBucket>/<DestPrefix>/" ## 移动文件 aws s3 mv "s3://<SrcBucket>/<SrcPrefix>/<SrcFileName>" "s3://<DestBucket>/<DestPrefix>/<DestFileName>" ## 移动目录 aws s3 mv --recursive "s3://<SrcBucket>/<SrcPrefix>/" "s3://<DestBucket>/<DestPrefix>/" ## 删除文件 aws s3 rm "s3://<Bucket>/<Prefix>/<FileName>" ## 删除目录 aws s3 rm --recursive "s3://<Bucket>/<Prefix>/" 以上内容是否对您有帮助？

CloudBerry Explorer

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [开发指南](https://developer.qiniu.com/kodo/development_guidelines/8596/development- guidelines) > [AWS S3 兼容](https://developer.qiniu.com/kodo/development_guidelines/4086/aws-s3-compatible) > [兼容工具示例](https://developer.qiniu.com/kodo/development_guidelines/4096/s3-compatible- sdk) > CloudBerry Explorer # CloudBerry Explorer 最近更新时间: 2023-12-28 18:02:46 CloudBerry Explorer 是一个图形化数据管理工具，支持您在跨本地存储和您选择的云存储之间进行访问、移动和管理文件。通过配置，您可以使用 CloudBerry Explorer 管理您在七牛云对象存储的资源。此工具支持在 Windows 和 MacOS 系统使用。 参考官方介绍：[CloudBerry Explorer __](https://www.msp360.com/explorer/) # 安装 CloudBerry Explorer 下载并安装 [CloudBerry Explorer __](https://www.msp360.com/explorer/windows/) # 配置 CloudBerry Explorer 打开 CloudBerry Explorer  选择标题栏中的 File，选择 Add New Account  双击 S3 Compatible  打开 S3 Compatible 账户配置对话框，添加新的 S3 Compatible 的账号。  其中，Display name 可以自定义填写，如 Qiniu。Service point 填写为七牛云对象存储的 S3 服务地址，参考 [服务域名 __](https://developer.qiniu.com/kodo/4088/s3-access-domainname)。Access Key 和 Secret Key 填写七牛云账户的 AK/SK，Signature version 选 4。点击 “Test Connection”，显示 “Connection Success!” 表示连接成功。  关闭账户配置对话框后，可以在 Source 内选择刚刚配置的账户，与本机或其他账户之间传输文件。 支持选择指定文件或文件夹 Copy 或 Move 到目标位置。   注：CloudBerry Explorer for Amazon S3 对 S3 Compatible 和 Amazon S3 两种配置的云存储支持的功能本身就有区别，如生命周期、加密等均不支持。 以上内容是否对您有帮助？

S3 Browser

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [开发指南](https://developer.qiniu.com/kodo/development_guidelines/8596/development- guidelines) > [AWS S3 兼容](https://developer.qiniu.com/kodo/development_guidelines/4086/aws-s3-compatible) > [兼容工具示例](https://developer.qiniu.com/kodo/development_guidelines/4096/s3-compatible- sdk) > S3 Browser # S3 Browser 最近更新时间: 2023-12-28 18:03:01 S3 Browser 是一种易于使用和强大的 Amazon S3 免费客户端，通过图形化界面管理 Amazon S3。通过配置，您可以通过使用 S3 Browser 管理您在七牛云对象存储的资源，如进行文件上传、下载、bucket 管理等操作。 参考官方介绍：[S3 Browser __](https://s3browser.com/) # 安装 S3 Browser 从 <https://s3browser.com/download.aspx>[__](https://s3browser.com/download.aspx)下载 S3 Browser 并安装。 安装步骤可参考：[安装 S3 Browser __](https://s3browser.com/how_to_install.aspx) # 配置 S3 Browser 首次打开 S3 Browser 即进入账户配置界面  选择 Account Type 为 S3 Compatible Storage，填写 REST Endpoint 为七牛云对象存储的 S3 服务地址，参考[服务域名 __](https://developer.qiniu.com/kodo/4088/s3-access- domainname)。同时填写七牛云账户的 AccessKey 和 SecretKey  点击 OK 即可看到 Bucket 列表和指定 Bucket 的文件列表  以上内容是否对您有帮助？

S3FS

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [开发指南](https://developer.qiniu.com/kodo/development_guidelines/8596/development- guidelines) > [AWS S3 兼容](https://developer.qiniu.com/kodo/development_guidelines/4086/aws-s3-compatible) > [兼容工具示例](https://developer.qiniu.com/kodo/development_guidelines/4096/s3-compatible- sdk) > S3FS # S3FS 最近更新时间: 2023-12-28 18:03:17 S3FS 是一个开源工具，可以将 S3 对象存储通过 FUSE 挂载到本地，以用户熟悉的形式如在本地磁盘一样进行读写访问。除了 AWS S3，它还支持所有兼容 S3 API 的对象存储，比如七牛云对象存储 Kodo。通过配置，您可以通过 S3FS 管理您在七牛云对象存储的资源。 参考官方介绍：[S3FS __](https://github.com/s3fs-fuse/s3fs-fuse) # 安装 S3FS 大部分 Linux 操作系统都提供 S3FS 的安装包。 * Amazon Linux EPEL: sudo amazon-linux-extras install epel sudo yum install s3fs-fuse * Arch Linux: sudo pacman -S s3fs-fuse * Debian 9 和 Ubuntu 16.04 或更新版本: sudo apt install s3fs * Fedora 27 或更新版本: sudo dnf install s3fs-fuse * Gentoo: sudo emerge net-fs/s3fs * RHEL 和 CentOS 7 或更新版本 EPEL: sudo yum install epel-release sudo yum install s3fs-fuse * SUSE 12 和 openSUSE 42.1 或更新版本: sudo zypper install s3fs * macOS 10.12 或更新版本，通过 [Homebrew __](https://brew.sh/): brew install --cask macfuse brew install gromgit/fuse/s3fs-mac * FreeBSD: pkg install fusefs-s3fs * UNIX / Linux 支持自行编译 * 准备以下依赖 * `fuse >= 2.8.4` * `automake` * `gcc-c++` * `make` * `libcurl` * `libxml2` * `openssl` * `mime.types` * 使用以下命令编译 S3FS git clone https://github.com/s3fs-fuse/s3fs-fuse.git cd s3fs-fuse ./autogen.sh ./configure make sudo make install # 配置 S3FS ## 配置 AWS Credentials S3FS 默认使用 `${HOME}/.passwd-s3fs` 作为当前用户的 AWS Credentials，如果不存在，则使用 `/etc/passwd-s3fs` 作为系统的 AWS Credentials。 通过以下命令设置 `${HOME}/.passwd-s3fs` echo "${QINIU_ACCESS_KEY_ID}:${QINIU_SECRET_KEY}" > "${HOME}/.passwd-s3fs" chmod 600 "${HOME}/.passwd-s3fs" ## 启动 S3FS s3fs "${BUCKET}" "${MOUNTPOINT}" -o url=https://s3.cn-east-1.qiniucs.com # 这里以华东-浙江区为例，如果 $BUCKET 为其他区域，则填写该区域的 S3 服务域名 其中，`${BUCKET}` 为指定存储空间，`${MOUNTPOINT}` 为指定目录。该命令中 `url` 需要填写为 S3 服务域名，可以参考 [服务域名 __](https://developer.qiniu.io/kodo/4088/s3-access- domainname)查看七牛云对象存储各区域的 S3 服务地址。 命令执行成功后，S3FS 将作为守护进程启动，访问 `$MOUNTPOINT` 即可读写指定 Bucket 中的文件。 ## 自动挂载 S3FS 将 S3FS 配置追加到 `/etc/fstab` 中 ${BUCKET} ${MOUNTPOINT} fuse.s3fs _netdev,allow_other,url=https://s3.cn-east-1.qiniucs.com 0 0 ## 调试 S3FS 采用如下命令，将直接在 Shell 中启动 S3FS，并直接输出 S3FS 日志。 s3fs "${BUCKET}" "${MOUNTPOINT}" -o url=https://s3.cn-east-1.qiniucs.com -f -o dbglevel=info -o curldbg 其他选项可以参考 [Ubuntu Manpage __](https://manpages.ubuntu.com/manpages/jammy/en/man1/s3fs.1.html)中的`s3fs` 页面。 以上内容是否对您有帮助？

附录

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [开发指南](https://developer.qiniu.com/kodo/development_guidelines/8596/development- guidelines) > 附录 # 附录 最近更新时间: 2022-05-19 16:58:21 # 域名绑定 每个空间都可以绑定一个到多个自定义域名，以便于更方便的访问资源。 例如`www.qiniu.com`的所有静态资源均存放于一个叫`qiniu- resources`的公开空间中。并将该空间绑定到一个二级域名`i1.qiniu.com`，那么如果要在一个HTML页面中引用该空间的`logo.png`资源，大概的写法如下： <img source="http://i1.qiniu.com/logo.png"></img> 这样一定程度上隐藏了正在使用七牛云存储的事实，更大的好处是如果需要从一个云存储迁移到另一个云存储，只需要修改域名DNS的CNAME设置，而无需更新网页源代码。 # URL安全的Base64编码 URL安全的Base64编码适用于以URL方式传递Base64编码结果的场景。该编码方式的基本过程是先将内容以Base64格式编码为字符串，然后检查该结果字符串，将字符串中的加号`+`换成中划线`-`，并且将斜杠`/`换成下划线`_`。 详细编码规范请参考[RFC4648 __](http://www.ietf.org/rfc/rfc4648.txt)标准中的相关描述。 以上内容是否对您有帮助？

控制台指南

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > 控制台指南 # 控制台指南 最近更新时间: 2024-05-08 18:08:26 对象存储 Kodo 控制台是界面形式的 Web 应用程序，给您提供直观、简单使用的操作平台。通过 Kodo 控制台您可以对您的存储空间、文件等执行相关操作。 您将在本操作指南中，了解以下内容： 控制台操作 | 子操作 ---|--- [控制台概览](https://developer.qiniu.com/kodo/development_guidelines/8404/an-overview-of-the-console) | [空间管理](https://developer.qiniu.com/kodo/development_guidelines/8456/bucket-management) | * 新建空间 * 空间列表管理 * 空间概览 * 空间设置 * 设置访问控制 * 设置静态页面 * 设置空间备注 * 设置文件客户端缓存 * 设置重定向 * 设置标签管理 * 设置空间授权 * 设置Referer防盗链 * 设置跨域资源共享 * 设置生命周期 * 设置事件通知 * 设置镜像回源 * 设置对象锁定 * 设置空间日志 * 设置空间内容审核 * 删除存储空间 * 域名管理 * 设置自定义 CDN 加速域名 * 设置自定义源站域名 * 数据处理 * 图片样式 * 转码样式 * 设置原图保护 [文件管理](https://developer.qiniu.com/kodo/development_guidelines/8561/file-management) | * 上传文件 * 创建目录 * 搜索文件 * 修改文件名 * 修改文件类型 * 查看文件信息 * 设置文件元信息 * 下载文件 * 分享文件 * 刷新 CDN 缓存 * 移动文件 * 删除文件 * 删除目录 * 修改文件存储类型 * 解冻文件 * 任务中心 [设置跨区域同步](https://developer.qiniu.com/kodo/development_guidelines/8557/set-the-cross-regional-synchronization) | [统计分析](https://developer.qiniu.com/kodo/development_guidelines/8531/statistical-analysis) | [存储安全](https://developer.qiniu.com/kodo/development_guidelines/12546/object-storage-safety) | * 内容审核 * 违规列表 [设置数据迁移](https://developer.qiniu.com/kodo/development_guidelines/12666/set-data-migration) | 另外，您可以按需参考关于对象存储 Kodo 产品的部分文档： 参见文档 | 说明 ---|--- [产品简介 __](https://developer.qiniu.com/kodo)| 功能介绍和应用场景 [购买指南 __](http://developer.qiniu.com/kodo/6379/metering-and-billing)| 详细的计费和购买类信息 [快速入门 __](https://developer.qiniu.com/kodo/1233/console-quickstart)| 简单快速的入门知识 [开发指南](https://developer.qiniu.com/kodo/development_guidelines/8596/development-guidelines) | 更详细的概念、功能、原理介绍和可用工具等信息 以上内容是否对您有帮助？

控制台概览

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [控制台指南](https://developer.qiniu.com/kodo/development_guidelines/8452/kodo- console-guide) > 控制台概览 # 控制台概览 最近更新时间: 2024-08-12 15:30:39 对象存储 Kodo 控制台的概览页面简单直观地展示了用户当前所有存储的概况，内容包含该账号下： * 所有存储空间总数、空间所在的区域分布及对应区域的空间总数； * 各存储类型对应的存储用量、文件数、API 请求数及流量。 # **操作步骤** 1. 登录 Kodo 控制台界面进入[概览 __](http://portal.qiniu.com/kodo/overview)界面 2. 如图1，在概览界面，左侧图表展示了本账号下所有存储空间总量、空间使用的区域及对应区域的空间总数。右侧图表，可在**存储量** 查看了本账号下 Top5 存储量的空间及对应用量，切换至**对象数** 查看本账号下 Top5 对象数的空间及对应数量。 图1：  3. 如图2，在空间概览界面，您可单击**标准存储/低频存储/智能分层存储/归档直读存储/归档存储/深度归档存储** 切换显示不同存储类型，以本账号下所有空间对应选择存储类型的今日和昨日的存储量、文件数，本月和上月的 API 请求次数（GET/PUT）、外网下载流量、CDN 回源流量； 4. 您还可以单击**时间选择键** ，选择 7 天、15 天或自选日期以查看对应存储类型的存储量变化。 图2:  以上内容是否对您有帮助？

空间管理

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [控制台指南](https://developer.qiniu.com/kodo/development_guidelines/8452/kodo- console-guide) > 空间管理 # 空间管理 最近更新时间: 2024-07-15 11:21:02 您可以在对象存储 Kodo 空间管理界面直接查看到当前的空间列表，包括全部空间列表或分别查看各区域空间列表。 # **操作步骤** 1. 登录 Kodo 控制台界面进入[空间管理 __](https://portal.qiniu.com/kodo/bucket)界面 2. 您可以在图1:空间管理-空间列表页面，根据以下操作来进一步管理当前账户下所有空间： 图1:空间管理-空间列表  空间管理操作 --- 账户下所有空间管理 | [新建空间 ](https://developer.qiniu.com/kodo/development_guidelines/8498/the-new-space) [ 空间列表管理 ](https://developer.qiniu.com/kodo/development_guidelines/8499/list- of-space-management) 3. 您还可以在图1中选择指定空间后，在图2:空间管理-指定空间根据以下操作来进一步管理该单个空间： 图2:  空间管理操作 --- 单个空间管理 | [空间概览](https://developer.qiniu.com/kodo/development_guidelines/8500/an-overview-of-the-space) [文件管理](https://developer.qiniu.com/kodo/development_guidelines/8561/file- management) [域名管理](https://developer.qiniu.com/kodo/development_guidelines/8527/kodo- domain-name-management) [数据处理](https://developer.qiniu.com/kodo/development_guidelines/8552/the-data- processing) [空间设置](https://developer.qiniu.com/kodo/development_guidelines/8501/space- settings) 以上内容是否对您有帮助？

新建空间

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [控制台指南](https://developer.qiniu.com/kodo/development_guidelines/8452/kodo- console-guide) > [空间管理](https://developer.qiniu.com/kodo/development_guidelines/8456/bucket- management) > 新建空间 # 新建空间 最近更新时间: 2021-09-02 18:05:39 存储空间（Bucket）是用于存储对象（Object）的容器。您必须先创建存储空间才能上传文件。 # **说明** * 创建 Bucket 本身不收取任何费用，仅收取上传至 Bucket 中 Object 的存储费用或者访问 Object 产生的流量费用等。详情请见[购买指南](https://developer.qiniu.com/kodo/buying_guide/6379/metering-and-billing)。 * Bucket 一旦创建，则无法更改其名称及所在地域。 * Bucket 创建后可修改其访问控制，详情请见[设置访问控制](https://developer.qiniu.com/kodo/development_guidelines/8502/set-access-control)。 # **操作步骤** 1. 登录 Kodo 控制台界面进入[空间管理 __](https://portal.qiniu.com/kodo/bucket)界面 2. 单击 **+新建空间** ，右侧弹出如图1的新建存储空间界面。 图1:  3. 在新建存储空间界面，按如下说明配置各项参数: 操作名称 | 说明 | 规则描述 ---|---|--- 存储空间名称 | 请自定义存储空间名称 | \- 存储空间名称必填且不允许重复，遇到冲突请更换名称 \- 名称格式为 3～63 个字符 \- 可以包含小写字母、数字、短划线 \- 且必须以小写字母或者数字开头和结尾 \- 存储空间名称创建后不可修改 存储区域 | 请选择您将要创建的存储空间所属区域 | \- 选择数据中心区域以新建存储空间 * 华东、华北、华南、北美、东南亚、华东-浙江2 \- 各区域不通用 \- 存储区域创建后不可更改 访问控制 | 请选择您将要创建的存储空间的访问限制 | \- 公开和私有仅对 Bucket 的读文件生效，修改、删除、写入等对 Bucket 的操作均需要拥有者的授权才能进行操作。 \- 创建完成后，可在空间设置中更改限制。 4. 单击**确定** ，空间创建成功并弹出如图2域名绑定提示。 图2:  5. 系统已自动为空间配备测试域名， 有效期 30 天，仅限用于业务对接测试，不可用于正式生产环境。请参考以下测试域名限制与规范: * 测试域名每个自然日访问总流量限额 10GB，自创建起 30 个自然日后自动回收。 * 测试域名不得作为生产域名，使用期间不在 SLA 保障范围内。 * 不得使用测试域名存储、发布、传播违法违规内容，禁止下载应用程序(apk、ipa、exe、dmg等)。 当测试域名下有非法资源时，该域名将被直接冻结并不予解封。 * 更多测试域名使用规范请参考[测试域名使用规范 __](https://developer.qiniu.com/fusion/kb/1319/test-domain-access-restriction-rules)。 6. 单击**好的，我知道了** ，使用当前测试域名完成空间创建。后续您可参考[域名管理](https://developer.qiniu.com/kodo/development_guidelines/8527/kodo-domain-name-management)，为当前空间配置域名。 7. 单击**立即绑定自定义域名** ，将跳转至[域名管理](https://developer.qiniu.com/kodo/development_guidelines/8527/kodo-domain-name-management)界面，请参考域名管理绑定自定义域名为生产域名。 以上内容是否对您有帮助？

空间列表管理

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [控制台指南](https://developer.qiniu.com/kodo/development_guidelines/8452/kodo- console-guide) > [空间管理](https://developer.qiniu.com/kodo/development_guidelines/8456/bucket- management) > 空间列表管理 # 空间列表管理 最近更新时间: 2023-10-10 16:27:11 对象存储 Kodo 支持您在空间列表中，按需进行空间列表筛选和展示，以便您在创建大量存储空间的账号下迅速定位到目标空间。 支持的操作包括： * 排列展示：按空间名称递增/减、按创建时间递增/减 * 筛选展示：空间类型、存储区域、访问控制 * 空间标签 * 搜索展示：通过指定存储空间名称、指定空间标签快速搜索 * 如您的空间设置有空间备注，列表中空间名称栏将展示对应备注 # **操作步骤** 1. 登录Kodo控制台界面进入[空间管理 __](https://portal.qiniu.com/kodo/bucket)界面，如图1 图1:  2. 在如图1界面，您可按需选择展示空间列表的形式： ## **排列展示** * 单击**空间名称排序箭头** ，按空间名称排序递增、递减显示； * 单击**创建时间排序箭头** ，按创建时间排序递增、递减显示 ## **筛选展示** * 单击**空间类型箭头** ，按空间类型筛选；如图2，您可按需单选或多选在列表展示**自由空间、授权只读、授权读写** 类型空间，单击**确定** 。 图2:  * 单击**存储区域箭头** ，按存储区域筛选；如图3，您可按需单选或多选在列表展示指定存储区域的空间，单击**确定** 。 图3:  * 单击**访问控制箭头** ，按访问控制筛选；如图4，您可按需单选或多选在列表展示**公开、私有** 类型空间，单击**确定** 。 图4:  ## **空间标签展示** * 鼠标移至**空间标签图标** ，即可显示指定空间的空间标签； * 您可单击**标签键/值** ，分别复制对应内容 * 如需设置该空间标签，您可单击**设置** ，将跳转至空间管理-空间设置界面，请参考[标签管理](https://developer.qiniu.com/kodo/development_guidelines/8536/set-up-the-label-management)界面进行相应操作。 ## **搜索展示** * 下拉选择**空间名称** ，按名称搜索空间；如图5，输入目标**空间名称** ，下方空间列表即筛选出目标空间。 图5:  * 无序列表下拉选择**标签** ，按空间标签搜索空间；如图6，输入目标空间**标签键** 或**键和值** ，下方空间列表即筛选出目标空间。 图6:  以上内容是否对您有帮助？

空间概览

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [控制台指南](https://developer.qiniu.com/kodo/development_guidelines/8452/kodo- console-guide) > [空间管理](https://developer.qiniu.com/kodo/development_guidelines/8456/bucket- management) > 空间概览 # 空间概览 最近更新时间: 2024-08-12 15:30:04 空间概览展示了您当前所选空间的概览信息，包括该空间的 * 用量信息：各存储类型对应的存储量、文件数、内/外网下载流量、CDN 回源流量及 API 请求数 * 基本信息：存储区域、存储总量、文件总数、访问控制限制以及空间类型； * 空间设置信息统计及快捷入口：生命周期、事件通知、镜像回源、空间授权、Referer 防盗链、跨域设置； * 自定义域名信息统计及快捷入口：CDN 加速域名、源站域名 * 系统域名信息：S3 协议的外网访问、传输加速域名 # **操作步骤** 1. 登录 Kodo 控制台界面进入[空间管理 __](https://portal.qiniu.com/kodo/bucket)界面 2. 在空间列表，进入目标空间的**空间概览** 界面，如图1:空间概览 图1:  ## **空间概览 用量信息：** * 如图1:空间概览-用量信息卡片中，您可单击**总用量/标准存储/低频存储/智能分层存储/归档直读存储/归档存储/深度归档存储** 以查看不同存储类型下，该空间内今日和昨日的存储量、文件数，本月和上月的内/外网下载流量、CDN 回源流量、API 请求次数（GET/PUT） ## **空间概览 基本信息：** * 如图1:空间概览-基本信息卡片中，展示了该空间的基本信息，如空间名称、存储区域、空间类型、访问控制以及空间备注。 * 支持快捷复制空间名称、快捷入口前往设置访问控制和空间备注 ## **空间概览 空间设置：** * 如图1:空间概览-空间设置卡片中，展示了空间常用设置的规则数，如[生命周期](https://developer.qiniu.com/kodo/development_guidelines/8540/set-the-life-cycle)、[事件通知](https://developer.qiniu.com/kodo/development_guidelines/8541/set-the-event-notification)、[镜像回源](https://developer.qiniu.com/kodo/development_guidelines/8542/set-up-the-mirror-back-to-the-source)、[空间授权](https://developer.qiniu.com/kodo/development_guidelines/8537/set-the-space-authorization)、[Referer 防盗链](https://developer.qiniu.com/kodo/development_guidelines/8538/set-the-referer-hotlinking-prevention)、[跨域设置](https://developer.qiniu.com/kodo/development_guidelines/8539/set-the-cross-domain-resource-sharing)、[对象锁定](https://developer.qiniu.com/kodo/development_guidelines/8545/set-the-object-lock)。 * 支持快捷入口前往空间设置界面操作对应功能设置 ## **空间概览 自定义域名：** * 如图1:空间概览-自定义域名卡片中，展示了该空间的自定义域名统计信息，包括 CDN 域名和源站域名 * 支持快捷入口前往设置自定义域名 ## **空间概览 系统域名：** * 如图1:空间概览-系统域名卡片中，展示了该空间的系统域名，包括 [s3 协议的外网访问域名](https://developer.qiniu.com/kodo/4088/s3-access-domainname)和传输加速域名（如空间开启了传输加速） 以上内容是否对您有帮助？

空间设置

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [控制台指南](https://developer.qiniu.com/kodo/development_guidelines/8452/kodo- console-guide) > [空间管理](https://developer.qiniu.com/kodo/development_guidelines/8456/bucket- management) > 空间设置 # 空间设置 最近更新时间: 2024-03-20 17:28:22 空间设置界面展示了您可对当前所选空间进行的设置项。 # **操作步骤** * 您可以在当前页面根据以下操作来进一步空间设置： 空间设置操作 --- [设置访问控制](https://developer.qiniu.com/kodo/development_guidelines/8502/set- access-control) [设置静态页面](https://developer.qiniu.com/kodo/development_guidelines/12269/set-a- static-page) [设置空间备注](https://developer.qiniu.com/kodo/development_guidelines/12157/set- the-space-note) [设置文件客户端缓存](https://developer.qiniu.com/kodo/development_guidelines/8535/settings- file-the-client-cache) [设置重定向](https://developer.qiniu.com/kodo/development_guidelines/12262/set-the- redirect) [设置标签管理](https://developer.qiniu.com/kodo/development_guidelines/8536/set-up- the-label-management) [设置空间授权](https://developer.qiniu.com/kodo/development_guidelines/8537/set-the- space-authorization) [设置 Referer 防盗链](https://developer.qiniu.com/kodo/development_guidelines/8538/set-the- referer-hotlinking-prevention) [设置跨域资源共享](https://developer.qiniu.com/kodo/development_guidelines/8539/set- the-cross-domain-resource-sharing) [设置生命周期](https://developer.qiniu.com/kodo/development_guidelines/8540/set-the- life-cycle) [设置事件通知](https://developer.qiniu.com/kodo/development_guidelines/8541/set-the- event-notification) [设置镜像回源](https://developer.qiniu.com/kodo/development_guidelines/8542/set-up- the-mirror-back-to-the-source) [设置对象锁定](https://developer.qiniu.com/kodo/development_guidelines/8545/set-the- object-lock) [设置空间日志](https://developer.qiniu.com/kodo/development_guidelines/8546/set-the- space-log) [设置空间内容审核](https://developer.qiniu.com/kodo/development_guidelines/8547/set- the-space-content-review) [设置传输加速](https://developer.qiniu.com/kodo/development_guidelines/12656/transfer- acceleration) [删除存储空间](https://developer.qiniu.com/kodo/development_guidelines/8548/remove- the-storage-space) 以上内容是否对您有帮助？

设置访问控制

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [控制台指南](https://developer.qiniu.com/kodo/development_guidelines/8452/kodo- console-guide) > [空间管理](https://developer.qiniu.com/kodo/development_guidelines/8456/bucket- management) > [空间设置](https://developer.qiniu.com/kodo/development_guidelines/8501/space- settings) > 设置访问控制 # 设置访问控制 最近更新时间: 2024-07-12 10:19:04 对象存储 Kodo 的存储空间支持公开访问或私有，您可以在对象存储 Kodo 控制台设置目标空间的访问控制。 创建空间时，可设置为公开空间或私有空间： * 公开空间，可通过文件对象的 URL 直接访问。 * 私有空间，文件对象的访问则必须获得拥有者的授权才能访问。 # **说明** * 您在创建空间时可以直接设置空间的访问控制，详情请见[新建空间](https://developer.qiniu.com/kodo/development_guidelines/8498/the-new-space)。 * 您也可以在空间管理的空间列表或指定空间的空间概览中，查看目标空间的访问控制状态。 * 公开和私有仅对空间的读文件生效，修改、删除、写入等对空间的操作均需要拥有者的授权才能进行操作，详情请见[设置空间授权](https://developer.qiniu.com/kodo/development_guidelines/8537/set-the-space-authorization)。 * 更多相关问题，请参考[访问控制](https://developer.qiniu.com/kodo/development_guidelines/8603/dev-access-control)。 # **操作步骤** 1. 登录 Kodo 控制台界面进入[空间管理 __](https://portal.qiniu.com/kodo/bucket)界面 2. 单击**目标空间名称** ，单击**空间设置** 进入空间设置界面 3. 找到访问控制栏，如图1，选择切换空间访问控制 图1:  ## **若当前为公开空间，** 1. 单击**修改为私有空间** ，将弹出如图2切换访问控制确认界面 图2:  2. 单击**确认** ，后输入**账户密码** 再次单击**确定** ## **若当前为私有空间，** 1. 单击**修改为公开空间** ，将弹出如图3切换访问控制确认界面 图3:  2. 单击**确认** ，后输入**账户密码** 再次单击**确定** _注：_ * _公开空间的文件可通过外链地址直接访问，**存在流量盗刷风险并可能导致不预期的流量费用。**_ * _私有空间需要拥有者的授权链接才可访问。_ * _改变访问控制可能使当前正在运行的程序和该空间的域名无法正常使用。切换空间属性后需 10 分钟生效。_ 以上内容是否对您有帮助？

设置静态页面

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [控制台指南](https://developer.qiniu.com/kodo/development_guidelines/8452/kodo- console-guide) > [空间管理](https://developer.qiniu.com/kodo/development_guidelines/8456/bucket- management) > [空间设置](https://developer.qiniu.com/kodo/development_guidelines/8501/space- settings) > 设置静态页面 # 设置静态页面 最近更新时间: 2024-07-12 10:19:18 对象存储 Kodo 控制台静态页面设置功能，支持您设置默认首页和 404 页面。 * 您可以把指定空间（Bucket）中指定文件（Object）设置为默认首页，并且通过访问空间的访问域名来访问该页。 * 您还可以通过设置 404 页面，自定义您的配置 HTTP 请求时的 404 页面；并可将其托管到 Kodo 的存储空间（Bucket），使用 Bucket 的访问域名访问这个网站。 # **说明** * 默认首页：默认关闭该功能。设置开启后，空间根目录及子目录中的 index.html（或 index.htm）文件将会作为默认首页进行展示。 * 默认 404 错误页面：通过浏览器访问空间内文件出现 404 错误时，Kodo 返回给用户的错误页面。设置的页面须保存在当前空间内，即若您选择上传文件作为自定义页面，该文件将被命名为 errno-404 并上传保存至当前空间内。 * 使用访问静态网站时的默认首页功能和自定义 404 页面功能，需要在当前空间绑定您的自定义域名（即您网站的域名），绑定自定义域名请参考[域名管理](https://developer.qiniu.com/kodo/development_guidelines/8527/kodo-domain-name-management)。 * 更多内容请参考[静态页面管理](https://developer.qiniu.com/kodo/development_guidelines/8604/a-static-page-management)。 # **操作步骤** 1. 登录Kodo控制台界面进入[空间管理 __](https://portal.qiniu.com/kodo/bucket)界面 2. 单击**目标空间名称** ，单击**空间设置** 进入空间设置界面 3. 在静态页面设置栏，如图1，单击**设置** ，进入图2:静态页面设置界面 图1:  4. 如图2 为默认的静态页面设置界面。如图3，单击**开启** 设置默认首页，选择**自定义** 404 页面后上传指定文件 图2: 默认静态页面设置  图3:  5. 单击**确定** 提交并完成静态页面设置 以上内容是否对您有帮助？

设置空间备注

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [控制台指南](https://developer.qiniu.com/kodo/development_guidelines/8452/kodo- console-guide) > [空间管理](https://developer.qiniu.com/kodo/development_guidelines/8456/bucket- management) > [空间设置](https://developer.qiniu.com/kodo/development_guidelines/8501/space- settings) > 设置空间备注 # 设置空间备注 最近更新时间: 2024-07-12 10:19:40 您可以在对象存储 Kodo 控制台，针对目标空间（Bucket）设置空间备注。通过简短的描述说明，记录您指定空间的用途。 # **说明** * 支持您使用中文、大小写英文、数字等设置备注 * 为空则不启用该功能 * 支持最多 100 个字符 * 更多详情请参考[空间备注](https://developer.qiniu.com/kodo/development_guidelines/12137/space-note) # **操作步骤** 1. 登录 Kodo 控制台进入[空间管理 __](https://portal.qiniu.com/kodo/bucket)界面 2. 单击**目标空间名称** ，单击**空间设置** 进入空间设置界面 3. 找到空间备注栏，如图1，单击**空间备注** 。 图1:  4. 自定义内容后，单击**确定** 完成空间备注设置 5. 如您想删除该备注，清空自定义备注内容后，单击**确定** 完成删除备注的操作 以上内容是否对您有帮助？

设置文件客户端缓存

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [控制台指南](https://developer.qiniu.com/kodo/development_guidelines/8452/kodo- console-guide) > [空间管理](https://developer.qiniu.com/kodo/development_guidelines/8456/bucket- management) > [空间设置](https://developer.qiniu.com/kodo/development_guidelines/8501/space- settings) > 设置文件客户端缓存 # 设置文件客户端缓存 最近更新时间: 2024-07-12 10:19:51 对象存储 Kodo 支持您通过配置文件客户端缓存 maxAge 实现在规定的时效内使客户端缓存更新的效果。 # **说明** * 通过配置空间属性中 maxAge 实现对缓存的控制，达到配置 HTTP header 中 Cache-Control:max-age 的目的，更多相关概念请参考[文件客户端缓存](https://developer.qiniu.com/kodo/development_guidelines/8605/dev-file-the-client-cache)。 * 对空间该属性的修改将作用在空间内新上传的文件上。 # **操作步骤** 1. 登录 Kodo 控制台界面进入[空间管理 __](https://portal.qiniu.com/kodo/bucket)界面 2. 单击**目标空间名称** ，单击**空间设置** 进入空间设置界面 3. 找到文件客户端缓存栏，输入**自定义缓存时间** ，如图1 图1:  4. 单击**确定** ，完成设置 以上内容是否对您有帮助？

设置重定向

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [控制台指南](https://developer.qiniu.com/kodo/development_guidelines/8452/kodo- console-guide) > [空间管理](https://developer.qiniu.com/kodo/development_guidelines/8456/bucket- management) > [空间设置](https://developer.qiniu.com/kodo/development_guidelines/8501/space- settings) > 设置重定向 # 设置重定向 最近更新时间: 2024-07-12 10:20:01 对象存储 Kodo 提供重定向功能，支持用户使用跳转的功能对指定地址做重定向进而在此基础之上实现各种业务。当请求者访问 Bucket 触发指定请求条件时，Kodo 重定向功能将此请求跳转至指定的地址。 # **说明** * 重定向规则条目不得超过 20 条。 * 重定向规则列表按规则优先级依次展示。 * 按规则的顺位匹配执行；若匹配成功，则执行此规则，后续的规则不再执行。 * 更多详情请参考[重定向](https://developer.qiniu.com/kodo/development_guidelines/12261/redirection) # **操作步骤** 1. 登录 Kodo 控制台进入[空间管理 __](https://portal.qiniu.com/kodo/bucket)界面 2. 单击**目标空间名称** ，单击**空间设置** 进入空间设置界面 3. 找到重定向，如图1，单击**设置** ，进入图2:重定向设置界面 图1:  4. 如图2:重定向设置界面，单击 **+新建规则** ，右侧弹出创建重定向规则界面 图2:  5. 在创建重定向规则界面，按如下说明配置各项参数 操作名称 | 说明 | 规则描述 ---|---|--- 触发条件 | 自定义触发重定向规则的条件，匹配该条件则执行后续跳转规则 | \- 支持定义三种类型的条件：HTTP 状态码、文件名前缀、文件名后缀 \- 仅支持设置 4xx 的 HTTP 状态码 \- 单条规则必须定义至少一种条件，至多三种；每种条件类型不可重复 跳转规则 | 自定义跳转访问地址 | 指定域名 | 自定义跳转域名 host | \- 必填 \- 用于触发重定向跳转请求时，填充请求头中的 host 字段 指定地址 | 自定义跳转到的路径 | \- 支持选择任一种类型：使用原文件名、添加文件前后缀、替换为固定文件名、替换文件名前后缀 \- 使用原文件名: 跳转地址仅按指定域名变更，其余路径不变 \- 添加文件前后缀： * 在匹配到的原文件名上添加前后缀 * 至少输入一项，不得均为空 \- 替换为固定文件名：支持为空，为空即直接访问指定域名 \- 替换文件名前后缀： * 支持选择**截取删除** 或**替换** ，以直接删除匹配到的前/后缀或替换为指定的内容 * 仅当指定前/后缀匹配条件时才支持选择对应操作项 * 当定义前缀和后缀均为替换时，替换内容不得均为空 * 仅当定义前缀和后缀并选择一项为截取删除时，另一项替换内容支持为空，为空即保留该匹配项 指定协议 | 自定义跳转时使用的协议 | 支持选择任一种类型：跟随原请求协议、强制 HTTP、强制 HTTPS URL 参数保留 | 请按需设置是否保留 URL 参数 | 无 响应状态码 | 自定义访问跳转链接时的响应状态码 | 支持设置为 301、302、307 6. 您可以在设置界面的访问链接示例中查看自定义的跳转地址。 7. 单击**确定** ，完成重定向规则设置。 8. 重定向规则保存成功后，您可以在规则列表中查看已设置的规则。您可以**上移** 、**下移** 规则以改变规则顺位，或对规则进行**编辑** 和**删除** 操作。 以上内容是否对您有帮助？

设置标签管理

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [控制台指南](https://developer.qiniu.com/kodo/development_guidelines/8452/kodo- console-guide) > [空间管理](https://developer.qiniu.com/kodo/development_guidelines/8456/bucket- management) > [空间设置](https://developer.qiniu.com/kodo/development_guidelines/8501/space- settings) > 设置标签管理 # 设置标签管理 最近更新时间: 2024-07-12 10:20:12 对象存储 Kodo 支持使用标签对存储空间（Bucket）进行分类。标签使用一组键值对（Key-Value）标记 Bucket。 # **说明** * 只有空间拥有者能为空间设置标签。每个空间最多可设置 10 对标签（Key-Value 对）。 * 您可在此设置中，添加、编辑、删除空间标签。 * 您可以在空间列表界面直接按标签搜索拥有相同标签的 Bucket，详情请见[空间列表管理](https://developer.qiniu.com/kodo/development_guidelines/8499/list-of-space-management)。 * 更多信息请参考[空间标签](https://developer.qiniu.com/kodo/development_guidelines/8607/dev-space-label)。 # **操作步骤** 1. 登录 Kodo 控制台进入[空间管理 __](https://portal.qiniu.com/kodo/bucket)界面 2. 单击**目标空间名称** ，单击**空间设置** 进入空间设置界面 3. 在空间设置中，下拉查找到标签管理栏，并单击该栏的**设置** ，右侧弹出如图1的标签管理界面。 图1:标签管理  4. 在标签管理界面下，单击**添加** ，出现如图2设置标签界面 图2: 设置标签  5. 然后按如下说明配置各项参数： 操作名称 | 说明 | 规则描述 ---|---|--- 标签键 | 请自定义存储空间的标签名称 | \- 同一个 Bucket 下，Key 必须是唯一的, 且一个 Key 只能有 1 个 Value。 \- 最大 64 Byte，不能为空且大小写敏感，不能以 kodo 为前缀(预留), 不支持中文字符，可使用的字符有：字母，数字，空格，+ - = . _ : / @ 标签值 | 请自定义存储空间的标签值 | \- 最大 128 Byte，不能为空且大小写敏感，不支持中文字符，可使用的字符有：字母，数字，空格，+ - = . _ : / @ 6. 单击**保存** ，即可完成标签设置。 7. 单击**关闭** ，则可取消当前操作。 在完成标签设置后， 8. 可单击**编辑** 以修改当前设置的空间标签 9. 也可单击**删除 >确定删除**，以删除当前设置的空间标签 以上内容是否对您有帮助？

设置空间授权

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [控制台指南](https://developer.qiniu.com/kodo/development_guidelines/8452/kodo- console-guide) > [空间管理](https://developer.qiniu.com/kodo/development_guidelines/8456/bucket- management) > [空间设置](https://developer.qiniu.com/kodo/development_guidelines/8501/space- settings) > 设置空间授权 # 设置空间授权 最近更新时间: 2024-07-12 10:20:24 对象存储 Kodo 支持通过空间授权设置，使存储空间所有者将存储空间（Bucket）授予给其他 Kodo 用户。空间所有者可以根据业务需要，授权其他用户访问或管理自己的存储空间的资源。 # **说明** * 空间授权设置支持新增、编辑及删除授权规则 * 更多信息请参考[空间授权](https://developer.qiniu.com/kodo/development_guidelines/8606/dev-authorization-of-the-space)。 # **操作步骤** 1. 登录 Kodo 控制台进入[空间管理 __](https://portal.qiniu.com/kodo/bucket)界面 2. 单击**目标空间名称** ，单击**空间设置** 进入空间设置界面 3. 找到空间授权栏，如图1，单击**设置** ，进入空间授权界面 图1:  ## **新增授权** 1. 如图2，在空间授权界面展示了当前空间授权用户、授权空间别名及其权限列表； 图2:  2. 单击 **+新增授权** ，弹出如图3：新增授权界面 图3：  3. 在新增授权界面，按如下说明配置各项参数： 操作名称 | 说明 | 规则描述 ---|---|--- 授权用户 | 请输入 Kodo 用户邮箱，作为该空间权限被授予的对象 | \- 区别于拥有全部读写权限的空间所有者，存储空间授权用户被空间所有者授予只读权限或读写权限。 \- 该被授权用户须为 Kodo 用户 \- 不可重复授权同一用户 授予权限 | 请选择将要授予目标用户的权限 | 支持授予只读权限和读写权限: * 只读权限：被授权用户对空间的所有对象拥有访问权限。 * 读写权限：对于空间内所有对象拥有增加、删除、修改和访问的权限。 空间别名 | 请定义空间别名 | 请检查空间名称格式， 3 ~ 63 个字符，可以包含小写字母、数字、短划线，且必须以小写字母或者数字开头和结尾 4. 单击**确定** ，完成授权 ## **修改授权** 1. 在如图2的列表中，单击指定栏授予权限的**修改图标** ，右侧将弹出修改授予权限界面 2. 单击选择修改**授予权限** _注：针对指定授权规则仅支持权限修改，不支持授权用户及空间别名修改_ ## **取消授权** 1. 在如图2的列表中，单击指定栏的**取消授权** ，再单击**确认** ，取消当前指定授权规则。 以上内容是否对您有帮助？

设置Referer防盗链

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [控制台指南](https://developer.qiniu.com/kodo/development_guidelines/8452/kodo- console-guide) > [空间管理](https://developer.qiniu.com/kodo/development_guidelines/8456/bucket- management) > [空间设置](https://developer.qiniu.com/kodo/development_guidelines/8501/space- settings) > 设置Referer防盗链 # 设置Referer防盗链 最近更新时间: 2024-07-12 10:20:33 对象存储 Kodo 提供设置防盗链功能，同时支持允许白名单访问和阻止黑明单访问的配置，防止数据被他人盗链。 # **说明** * 一旦开启 Referer 防盗链，所有请求都会做防盗链验证。更多信息请参考 [Referer 防盗链](https://developer.qiniu.com/kodo/development_guidelines/8618/dev-preventing-hotlinking)。 * 空间 Referer 防盗链设置仅对源站生效，空间 CDN 加速域名的 Referer 设置请至 [CDN 域名管理 __](https://portal.qiniu.com/cdn/domain)配置，详情请参考 CDN[设置 Referer 防盗链 __](https://developer.qiniu.com/fusion/3839/domain-name-hotlinking-prevention)。 # **操作步骤** 1. 登录 Kodo 控制台进入[空间管理 __](https://portal.qiniu.com/kodo/bucket)界面 2. 单击**目标空间名称** ，单击**空间设置** 进入空间设置界面 3. 找到 Referer 防盗链栏，如图1，单击**设置** ，右侧将弹出设置 Referer 防盗链界面 图1:  4. 单击当前状态：**开启** ，即显示图2: Referer 防盗链设置 图2:  5. 在 Referer 防盗链配置界面，按如下说明配置各项参数 操作名称 | 说明 | 规则描述 ---|---|--- 黑白名单配置 | 请按需选择配置白名单或黑名单 | \- 白名单：请求的 Referer 字段匹配白名单设置的内容，则允许访问资源，若不匹配，请求会被拒绝访问资源。 \- 黑名单：请求的 Referer 不匹配黑名单内设置的内容，则允许访问资源，若匹配，请求会被拒绝访问资源。 Referer | 请按需配置 Referer 参数 | \- 一个 Bucket 可以支持多个 Referer 参数。 \- 支持以下三种 Referer 格式 * 支持空主机头域名， 比如 foo.com 或 空主机头多级域名，比如 a.b.com; * 支持域名前使用通配符「 * 」，比如 *.bar.com; * 支持完全通配符, 即一个「 * 」 * 无需输入 http:// 或 https:// 允许空 Referer | 请选择是否允许空 Referer | \- 允许空 Referer 开启时，若请求 Referer 字段为空或无 Referer 字段，允许访问资源。 \- 允许空 Referer 关闭时，若请求 Referer 字段为空或无 Referer 字段，请求会被拒绝访问资源 \- 若不允许空 Referer，则只有 HTTP 或 HTTPS header 中包含 Referer 字段的请求才能访问资源。 _注： Referer 防盗链配置效果_ | 允许空 Referer ---|--- 开启 | 关闭 白名单 Referer 参数 | 不为空 | Referer 为空的请求和符合白名单的请求会被允许，其他请求都会被拒绝 | 只有 Referer 属于白名单的请求被允许，其他请求（包括 Referer 为空的请求）会被拒绝 空 | 空 Referer 的请求被允许，即除黑名单外均允许 黑名单 Referer 参数 | 不为空 | Referer 为空的请求和符合黑名单的请求会被拒绝 | 只有 Referer 属于黑名单的请求被拒绝 空 | 空 Referer 的请求被拒绝 | 无拒绝请求 * 单击**确定** ，即可更新设置信息 * Referer 防盗链设置成功后，您也可以**关闭** 当前设定。 以上内容是否对您有帮助？

设置跨域资源共享

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [控制台指南](https://developer.qiniu.com/kodo/development_guidelines/8452/kodo- console-guide) > [空间管理](https://developer.qiniu.com/kodo/development_guidelines/8456/bucket- management) > [空间设置](https://developer.qiniu.com/kodo/development_guidelines/8501/space- settings) > 设置跨域资源共享 # 设置跨域资源共享 最近更新时间: 2024-07-12 10:20:43 跨域访问即通过 HTTP 请求，从一个域去请求另一个域的资源。只要协议、域名、端口有任何一个不相同，都会被当作是不同的域。跨域资源共享 CORS（Cross-Origin Resource Sharing），是 HTML5 提供的标准跨域解决方案。 七牛云对象存储 Kodo 系统默认支持 CORS 标准来实现跨域访问，并提供了存储空间（Bucket）级别的 CORS 自定义规则配置，添加规则后七牛云存储会根据已设定的规则来允许或者拒绝相应的跨域请求。 您可以通过控制台对空间进行设置并对空间中的对象（Object）进行跨域访问。 # **说明** * 存储空间默认允许跨域访问；当添加了自定义跨域规则时，只有在规则匹配时，跨域请求才会被允许。 * 最多允许设置 10 条跨域规则。 * 系统支持创建多条跨域访问规则，当收到跨域访问请求时，会依次检查每一条规则，使用第一条匹配的规则来允许请求并返回对应的 Header。 * 对于同一个域名如果设置了多条规则，那么按顺序使用第一条匹配的规则去生成返回值。 * 如果所有规则都匹配失败，则不附加任何 CORS 相关的 Header。CORS 规则匹配成功必须满足以下三个条件： * 请求的 Origin 必须匹配一个允许来源项。 * 请求的方法（如 GET、PUT 等）或者 OPTIONS 请求的 Access-Control-Request-Method 头对应的方法必须匹配一个允许 Methods 项。 * OPTIONS 请求的 Access-Control-Request-Headers 头包含的每个 Header 都必须匹配一个允许 Headers 项。 * 关于跨域访问的更多信息，请参见 [跨域资源共享](https://developer.qiniu.com/kodo/development_guidelines/8608/dev-cross-domain-resource-sharing)。 # **操作步骤** 1. 登录 Kodo 控制台进入[空间管理 __](https://portal.qiniu.com/kodo/bucket)界面 2. 单击**目标空间名称** ，单击**空间设置** 进入空间设置界面 3. 找到跨域设置栏，如图1，单击**设置** ，进入图2:跨域设置界面 图1:  4. 在图2:跨域设置界面，单击 **+新建规则** ，右侧弹出创建新规则界面 图2:  5. 在创建跨域规则界面，按如下说明配置各项参数： 操作名称 | 说明 | 规则描述 ---|---|--- 来源 | 请填写来源，即指定允许的跨域请求的来源 | \- 必填 \- 大小写敏感 \- 允许多条来源，每行一个 \- 每条匹配规则允许使用最多一个「 * 」通配符 \- 单独填写「 * 」通配符，表示允许所有来源的跨域请求 \- 对应服务端响应头里的 Access-Control-Allow-Origin 字段 允许 Methods | 请勾选允许的 Methods，即指定允许的跨域请求方法 | \- 必填、可多选 \- 对应服务端响应头里的 Access-Control-Allow-Methods 字段 允许 Headers | 请按需填写允许的 Headers，即指定允许的跨域请求的响应头 | \- 大小写不敏感 \- 允许多条匹配规则，多条规则需换行填写 \- 如果有通配符「 * 」，则单行只能是通配符「 * 」 \- 对应服务端响应头里的 Access-Control-Allow-Headers 字段 暴露 Headers | 请按需填写暴露的Headers，即指定允许用户从应用程序中访问的响应头 | \- 大小写不敏感 \- 允许多条匹配规则，多条规则需换行填写 \- 不允许使用*通配符。 \- 对应服务端响应头里的 Access-Control-Expose-Headers 字段 缓存时间（秒） | 请按需填写缓存时间，即指定浏览器对特定资源的预取请求返回结果的缓存时间。 | \- 单位：秒 \- 对应服务端响应头里 Access-Control-Max-Age 字段 6. 单击**确定** ，完成规则创建。 7. 事件通知规则保存成功后，您可以在规则列表中查看已设置的规则，也可以对规则进行 **编辑** 或 **删除** 。如图3，支持单条编辑与删除及批量**清空全部规则** 。 图3:  以上内容是否对您有帮助？

设置生命周期

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [控制台指南](https://developer.qiniu.com/kodo/development_guidelines/8452/kodo- console-guide) > [空间管理](https://developer.qiniu.com/kodo/development_guidelines/8456/bucket- management) > [空间设置](https://developer.qiniu.com/kodo/development_guidelines/8501/space- settings) > 设置生命周期 # 设置生命周期 最近更新时间: 2024-08-12 15:39:33 您可以通过对象存储 Kodo 控制台实现存储空间内所有对象或特定前缀（可以配置一个或者多个规则）的生命周期管理，设置生命周期规则进行转低频存储、转智能分层存储、转归档直读存储、转归档存储、转深度归档存储或删除文件操作，实现批量管理文件。 # **说明** * 空间所有生命周期规则条目不超过 100 条。 * 生命周期规则设置或修改成功后，仅对新上传的文件生效。原本存储在空间内或已被标记有生命周期规则的文件不会跟随新的生命周期规则执行变更。 * 更多有关生命周期的详细内容，请参见[生命周期管理](https://developer.qiniu.com/kodo/development_guidelines/8609/dev-life-cycle-management)。 * 有关存储类型的更详细内容，请参见[存储类型](https://developer.qiniu.com/kodo/product_introduction/3956/kodo-category)。 * 生命周期规则可能导致的费用，相关计量可参考[统计分析](https://developer.qiniu.com/kodo/development_guidelines/8531/statistical-analysis)，相关费用请见[计量项与计费项](https://developer.qiniu.com/kodo/buying_guide/6379/metering-and-billing)。 * 触发转低频存储、转智能分层存储、转归档直读存储、转归档存储、转深度归档操作会收取存储类型转换请求费用 * 触发删除文件操作会收取 PUT/DELETE 请求费用 * 设置不当导致的问题，如指定存储类型未存满相应的最短存储时间将产生提前删除费用 * 可在文件详情上查看该文件根据生命周期定义的过期时间，详情请见[查看文件信息](https://developer.qiniu.com/kodo/development_guidelines/8566/view-the-file-information)。 ### **文件删除是不可逆的，请根据需求合理配置文件生命周期时间计划。** ### **策略配置完成后即时生效，策略存续期间新建的文件将会执行策略，请慎重选择。** # **操作步骤** 1. 登录 Kodo 控制台进入[空间管理 __](https://portal.qiniu.com/kodo/bucket)界面 2. 单击**目标空间名称** ，单击**空间设置** 进入空间设置界面 3. 找到设置生命周期栏，如图1，单击**设置** ，进入图2:生命周期设置界面 图1:  4. 在图2:生命周期设置界面，单击 **+新建规则** ，右侧弹出创建新规则界面 图2:  5. 在创建新规则界面，按如下说明配置各项参数： 操作名称 | 说明 | 规则描述 ---|---|--- 规则名称 | 自定义当前规则名称 | 在当前空间下不可重复命名生命周期管理规则 规则策略 | 选择当前规则的生效范围 | \- 单击**对整个空间生效** ，新建规则将作用在当前整个空间新上传的文件上 \- 单击**对前缀生效** ，新建规则将作用在当前空间新上传的带有该前缀的文件上 * 对前缀的规则唯一，如果一个 key 匹配多个前缀，则按照最长的前缀进行匹配，前缀规则优先于全局规则，只应用最先匹配的规则。 转为低频存储 | 选择是否针对当前文件开启转为低频存储 | 对当前文件单击**开** ，后输入**天数** ，用户新创建的文件将在该设定时间之后自动转为低频存储 \- 建议设定 ≥60 天后，自动转换成低频存储类型 转为智能分层存储 | 选择是否针对当前文件开启转为智能分层存储 | 对当前文件单击**开** ，后输入**天数** ，用户新创建的文件将在该设定时间之后自动转为智能分层存储 \- 建议设定 ≥60 天后，自动转换成智能分层存储类型 转为归档直读存储 | 选择是否针对当前文件开启转为归档直读存储 | 对当前文件单击**开** ，后输入**天数** ，用户新创建的文件将在该设定时间之后自动转为归档直读存储 \- 建议设定 ≥90 天后，自动转换成归档直读存储类型 转为归档存储 | 选择是否针对当前文件开启转为归档存储 | \- 对当前文件单击**开** ，后输入**天数** ，用户新创建的文件将在该设定时间之后自动转为归档存储 \- 建议设定 ≥180 天后，自动转换成归档存储类型 转为深度归档存储 | 选择是否针对当前文件开启转为深度归档存储 | 对当前文件单击**开** ，后输入**天数** ，用户新创建的文件将在该设定时间之后自动转为深度归档存储 \- 建议设定 ≥240 天后，自动转换成深度归档存储类型 删除策略 | 选择是否针对当前文件开启删除策略 | \- 对当前文件单击**开** ，后输入**天数** ，用户新创建的文件将在该设定时间之后自动被删除 \- 建议设定 ≥450 天后，自动执行删除策略 _注：天数设置必须满足条件：转为低频存储 < 转为归档直读存储 < 转为归档存储 < 转为深度归档存储 < 删除文件_ 6. 单击**确定** ，完成规则创建。 7. 生命周期规则保存成功后，您可以在规则列表中查看已设置的生命周期规则，也可以对规则进行**编辑** 或**删除** 。 以上内容是否对您有帮助？

设置事件通知

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [控制台指南](https://developer.qiniu.com/kodo/development_guidelines/8452/kodo- console-guide) > [空间管理](https://developer.qiniu.com/kodo/development_guidelines/8456/bucket- management) > [空间设置](https://developer.qiniu.com/kodo/development_guidelines/8501/space- settings) > 设置事件通知 # 设置事件通知 最近更新时间: 2024-07-12 10:21:05 对象存储 Kodo 支持事件通知功能，能够对管理员所关心的存储资源操作及时进行消息通知。例如：有新数据从图片内容分享平台、音视频平台上传到七牛云存储，资源发生了更新，重要文件被删除，数据同步已经完成等。 您可通过 Kodo 控制台进行以回调方式将消息推送到指定 URL 的事件通知配置。 # **说明** * 支持配置多条规则，每条匹配的规则都会按照设置发送通知推送。 * 事件通知是异步进行的，不影响正常的操作。 * 更多信息请参考[事件通知](https://developer.qiniu.com/kodo/development_guidelines/8610/dev-event-notification)。 # **操作步骤** 1. 登录 Kodo 控制台进入[空间管理 __](https://portal.qiniu.com/kodo/bucket)界面 2. 单击**目标空间名称** ，单击**空间设置** 进入空间设置界面 3. 找到设置事件通知栏，如图1，单击**设置** ，进入图2:事件通知设置界面 图1:  4. 如图2:事件通知设置界面，单击 **+新建规则** ，右侧弹出创建事件通知规则界面 图2:  5. 在创建事件通知规则界面，按如下说明配置各项参数： 操作名称 | 说明 | 规则描述 ---|---|--- 规则名称 | 自定义规则名称 | \- 由 1 ~ 50 个字符组成，可包含：字母、数字和下划线 \- 在当前空间下不可重复命名事件通知规则 规则策略 | 选择当前规则的生效范围 | \- 单击**对整个空间生效** ，新建规则将作用在当前空间内所有文件上 \- 单击**对前缀生效** ，新建规则将作用在当前空间与该前缀匹配的文件上 \- 单击**对后缀生效** ，新建规则将作用在当前空间与该后缀匹配的文件上 \- 支持配置多条规则，每条匹配的规则都会按照设置发送通知推送。 事件 | 选择本条规则需要进行通知的资源操作类型 | \- 事件类型与含义 * put 创建/覆盖文件：简单上传 * copy 创建/覆盖文件：拷贝文件 * append 创建/覆盖文件：追加上传 * move 移动文件 * delete 删除文件：1个或多个 * mkfile 创建/覆盖文件：分片上传完成 * deleteMarkerCreate：标删历史版本文件 * disable 修改文件状态：禁用 * enable 修改文件状态：启用 \- 事件类型支持多选、不可重复 回调地址 | 输入回调该规则的地址 | 可设置多个回调用于失败后依次尝试。单击 **+** 后输入**地址** ，添加多个回调地址 6. 单击**确定** ，完成规则创建。 7. 事件通知规则保存成功后，您可以在规则列表中查看已设置的规则，也可以对规则进行**编辑** 或**删除** 。 以上内容是否对您有帮助？

设置镜像回源

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [控制台指南](https://developer.qiniu.com/kodo/development_guidelines/8452/kodo- console-guide) > [空间管理](https://developer.qiniu.com/kodo/development_guidelines/8456/bucket- management) > [空间设置](https://developer.qiniu.com/kodo/development_guidelines/8501/space- settings) > 设置镜像回源 # 设置镜像回源 最近更新时间: 2024-07-12 10:21:14 对象存储 Kodo 镜像回源服务主要用于无缝迁移数据到七牛。当业务已经在您自己建立的源站或者在其它云产品上运行，需要迁移数据，但是又不能停止服务时，可利用镜像存储功能实现数据迁移。 设置镜像回源后，可以在源站资源（文件/图片等）初次访问时自动同步到空间，实现数据平滑迁移。 # **说明** * 业务已有的数据可以先使用七牛提供的同步工具 [qshell](https://developer.qiniu.com/kodo/tools/1302/qshell) 迁移到七牛，同时配置镜像存储，将源站的地址配置到存储空间上。 * 七牛云回源源站时，会携带固定的 User-Agent 信息：-qiniu-imgstg-spider-1.0，RegionID为：华东 z0、华南 z1、华北 z2、华东-浙江2 cn-east-2、北美 na0、东南亚 as0。 * 更多详情请参考[镜像回源](https://developer.qiniu.com/kodo/development_guidelines/8611/dev-the-mirror-back-to-the-source)；其他相关问题请参考[镜像存储 __](https://developer.qiniu.com/faq?category=%E9%95%9C%E5%83%8F%E5%AD%98%E5%82%A8&space=kodo)。 # **操作步骤** 1. 登录 Kodo 控制台进入[空间管理 __](https://portal.qiniu.com/kodo/bucket)界面 2. 单击**目标空间名称** ，单击**空间设置** 进入空间设置界面 3. 找到镜像回源栏，如图1，单击**设置** ，右侧将弹出设置镜像回源界面 图1:  4. 单击**开启** ，即显示图2:镜像回源设置 图2:  5. 在镜像回源配置界面，按如下说明配置各项参数 操作名称 | 说明 | 规则描述 ---|---|--- 主/备线路 | 请按需选择线路类型 | \- 支持添加新的线路、修改已有线路、删除已有线路 \- 主线路、备线路，回源时优先选择主线路，尝试均失败后选择备线路 * 按权重选择线路进行尝试，权重相同则随机选择 * 主线路、备线路回源最多分别尝试 3 个 \- 当前最多支持设置 10 个线路 回源地址 | 请输入线路的回源请求地址 | 回源到镜像源的线路，支持 \- 域名 \- 或 IP：适用于需要使用和原有资源域名相同的域名的情况 权重 | 请设置对应线路的权重 | \- 范围限制 1-100, 不填默认为 1 \- 权重越大，线路被选中回源概率越大，用以控制回源请求量在不同线路上的整体分布 \- 主、备线路分开比较权重 镜像空间 | 默认当前空间 | 不可更改 回源 host | 请按需设置回源 host | \- 用于生成镜像回源请求时，填充请求头中的 host 字段 \- 不设置时，默认为回源地址的域名 URL 参数 | 请按需设置是否保留 URL 参数 | 无 回源模式 | 请按需选择回源模式 | \- 普通：回源获取了完整的目标文件以后，再返回给请求端 \- Range 透传：回源单独获取文件指定的一段 Range，然后直接返回给请求端，同时异步回源获取完整目标文件；文件回源获取完成之前，同一段 Range 的请求会再次回源 \- 分片回源：以指定的分片大小（1MB、4MB）为单位对齐，回源单独获取文件的一段 Range（不一定完全等于用户请求的 Range 大小）保存在缓存，同时按请求中指定的 Range 返回数据给请求端，然后异步回源获取完整目标文件；完整文件回源获取完成之前，同一段 Range 的请求会直接从缓存中返回而不会再次回源。 * 请按需**开启/关闭** Etag 校验 * 按需选择分片大小 **1MB/4MB** 重试 Code | 请按需设置源站响应做回源重试的 Code | \- 只允许设置 4xx Code，最多 3 个，按回车输入 \- 不设置时，默认源站响应 5xx 会做回源重试 传递指定的 HTTP header | 请按需开启传递指定的 HTTP header，并输入 header 字段 | \- 设置回源时传递给源站的 HTTP header； \- 支持添加、删除设置，最多可以设置 10 个； \- 禁止设置一些标准 header，比如 Content-Length,User-Agent,Range。 自动生成默认的 robots.txt 配置文件（仅当 robots.txt 不存在） | 请按需开启是否配置 | 生成的默认文件 “robots.txt“ 将保存在当前空间内 6. 单击**确定** ，完成镜像回源设置。 7. 镜像回源设置成功后，您也可以切换**关闭** 当前设定。 # **具体示例** 设置镜像回源主线路 a, b, c 的权重分别为 2，3，5，备线路只有 d。 1. 产生回源请求时，会先尝试使用主线路做回源请求。 2. 主线路 a, b, c 按权重计算，分别有 20%，30% 和 50% 的概率被选中来做此次回源。 3. 回源成功，此次镜像回源处理结束；回源失败的时候会做重试。 4. 如果主线路回源 3 次都失败，会再通过备线路 d 尝试回源 1 次。 5. 主线路回源请求总数如果达到 100，那线路 a, b, c 回源请求次数的分布整体大致是接近 20，30，50。 以上内容是否对您有帮助？

设置对象锁定

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [控制台指南](https://developer.qiniu.com/kodo/development_guidelines/8452/kodo- console-guide) > [空间管理](https://developer.qiniu.com/kodo/development_guidelines/8456/bucket- management) > [空间设置](https://developer.qiniu.com/kodo/development_guidelines/8501/space- settings) > 设置对象锁定 # 设置对象锁定 最近更新时间: 2024-07-12 10:21:53 对象存储 Kodo 支持设置空间（Bucket）级别的对象锁定功能。开启对象锁定后，您可以使用一次写入，多次读取 (write once read many, WORM) 模式存储对象（Object）。您可以使用它在固定的时间段内或无限期地阻止删除或覆盖对象，符合合规监管需求。 # **说明** * 默认开启对象锁定之后不可关闭。 * 支持在空间级别设置开启对象锁定功能，锁定功能作用在设置完成后空间内新上传的文件上。 * 在对象锁定启用后，不可删除或覆盖文件，包括元数据和文件数据内容本身，如修改文件名、修改文件类型、修改文件元信息。 * 更多详情请参考[对象锁定](https://developer.qiniu.com/kodo/development_guidelines/8621/dev-object-locking)。 * 与[生命周期规则](https://developer.qiniu.com/kodo/development_guidelines/8540/set-the-life-cycle) * 不可在生命周期保护周期内删除，超过保护期再删除。 * 同时设置生命周期删除策略和对象锁定保护时，将自动判断取锁定保护时间及删除策略定义时间的最大值作为删除时间。 * 其他生命周期管理配置（转低频、转归档直读、转归档、转深度归档）将继续正常应用于受对象锁定保护的对象。 * 可在文件详情上查看该文件的对象锁定设置信息，详情请见[查看文件信息](https://developer.qiniu.com/kodo/development_guidelines/8566/view-the-file-information)。 # **操作步骤** 1. 登录 Kodo 控制台进入[空间管理 __](https://portal.qiniu.com/kodo/bucket)界面 2. 单击**目标空间名称** ，单击**空间设置** 进入空间设置界面 3. 找到设置对象锁定栏，如图1，单击**设置** ，右侧弹出对象锁定设置界面 图1:  4. 单击**开启** ，如图2： 图2:  5. 在对象锁定界面，按如下说明配置各项参数 操作名称 | 说明 | 规则描述 ---|---|--- 当前状态 | 选择开启对象锁定模式 | 一旦开启，不可关闭，将永久允许锁定此存储空间中的对象 保留模式 | 选择对象锁定的保留模式 | 当前仅支持**合规保留** 保留周期 | 自定义输入文件锁定时间 | \- 保留周期设置后，只可延长、不可缩短 \- 支持设置周期范围为 1 天 ～ 70 年 \- 当前设置的保留周期仅作用在设置完成后空间内新上传的文件上 6. 单击**确定** ，完成设置 以上内容是否对您有帮助？

设置空间日志

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [控制台指南](https://developer.qiniu.com/kodo/development_guidelines/8452/kodo- console-guide) > [空间管理](https://developer.qiniu.com/kodo/development_guidelines/8456/bucket- management) > [空间设置](https://developer.qiniu.com/kodo/development_guidelines/8501/space- settings) > 设置空间日志 # 设置空间日志 最近更新时间: 2024-07-12 10:22:02 对象存储 Kodo 提供自动保存访问空间日志的功能，您可以开启日志存储功能以便于您查询。您可在 Kodo 控制台为存储空间开启和关闭日志记录。 # **说明** * 您可以在已开启日志记录的同一存储空间中存储日志，也可以另外创建新存储空间来存储日志。 * 当空间开启访问日志记录功能后，对象存储 Kodo 自动将访问这个空间的请求日志，按照固定的命名规则，每 10 分钟生成一个文件写入您指定的目标空间。 * 当天的日志 2 天后可下载。 * 更多详情请参考[空间访问日志](https://developer.qiniu.com/kodo/development_guidelines/8614/space-access-log)。 # **操作步骤** 1. 登录 Kodo 控制台进入[空间管理 __](https://portal.qiniu.com/kodo/bucket)界面 2. 单击**目标空间名称** ，单击**空间设置** 进入空间设置界面 3. 找到空间日志栏，如图1，单击**开启/关闭** 当前空间的空间日志功能 图1:  4. 在图1界面，按如下说明配置各项参数： 操作名称 | 说明 | 规则描述 ---|---|--- 启用状态 | 选择是否启用空间日志功能 | 单击**开启/关闭** 保存到空间 | 选择一个空间用于保存日志 | \- 必须指定一个空间 \- 可选择当前空间，也可选择任一已建立空间 \- 选择非当前空间时，日志可能被他人访问 日志的名称 | 默认格式，不可编辑 | 名称解释： \- _log 固定字段 \- bucketname 用户指定的存储访问空间日志的空间名 \- YYYY-MM-DD-HH-mm YYYY、MM、DD、HH 和 mm 分别是该日志文件被创建时的阿拉伯数字的年、月、日、小时、分钟 \- partN.gz 当日志文件很大时，会拆分成多个，第一个是 part0，第二个是 part1，以此类推 日志的格式 | 默认内容，不可编辑 | 无 5. 单击**确定** 保存日志设置信息 以上内容是否对您有帮助？

设置空间内容审核

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [控制台指南](https://developer.qiniu.com/kodo/development_guidelines/8452/kodo- console-guide) > [空间管理](https://developer.qiniu.com/kodo/development_guidelines/8456/bucket- management) > [空间设置](https://developer.qiniu.com/kodo/development_guidelines/8501/space- settings) > 设置空间内容审核 # 设置空间内容审核 最近更新时间: 2024-07-12 10:22:13 对象存储 Kodo 支持针对存储用户，提供一键式的图片、视频内容审核服务。 您可以将保存在七牛云存储中的图片、视频进行鉴黄、鉴暴恐、政治敏感人物识别等内容审核服务，对增量违规数据提供自动封禁功能。提供审核结果的自助复核功能，用户可以对图片、视频进行删除、封禁和通过等操作。 # **说明** * 更多空间内容审核概念介绍，请参考[什么是内容审核 __](https://developer.qiniu.com/censor/4829/censor-introduction)。 * 内容审核可能导致的相关费用，请参考[内容审核产品价格 __](https://developer.qiniu.com/censor/4833/censor-price)。 # **操作步骤** 1. 登录 Kodo 控制台进入[空间管理 __](https://portal.qiniu.com/kodo/bucket)界面 2. 单击**目标空间名称** ，单击**空间设置** 进入空间设置界面 3. 找到内容审核栏，如图1， 图1：  ## **增量审核：** ### **查看增量设置** 1. 在图1，单击**查看增量设置** ，即可跳转至如图2:内容审核-增量审核界面 图2:  2. 如图2，显示了当前空间已设置的增量任务。 3. 在图2界面，您可单击选择**存储空间、前缀、文件类型** ，再单击查询以**查询** 指定空间相关的增量任务。 ### **添加增量设置** 1. 您可在当前图2界面，单击**新建任务** ；或在图1界面中，单击 **+添加增量设置** ，进入新建增量任务界面。 2. 请参考 [增量审核 __](https://developer.qiniu.io/censor/8066/censor-portal-stream)完成新建增量审核任务。 ## **存量审核：** ### **查看存量设置** 1. 在图1，单击**查看存量设置** ，即可跳转至如图3:内容审核-存量审核界面 图3:  2. 如图3，显示了当前空间已设置的存量任务。 3. 在图3界面，您可单击选择**存储空间、前缀、文件类型** ，再单击**查询** 以查询指定空间相关的存量任务。 ### **添加存量设置** 1. 您可在当前图3界面，单击**新建任务** ；或在图1界面中，单击 **+添加存量设置** ，进入新建增量任务界面。 2. 请参考 [存量审核 __](https://developer.qiniu.io/censor/8067/censor-portal-batch)完成新建存量审核任务。 以上内容是否对您有帮助？

设置传输加速

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [控制台指南](https://developer.qiniu.com/kodo/development_guidelines/8452/kodo- console-guide) > [空间管理](https://developer.qiniu.com/kodo/development_guidelines/8456/bucket- management) > [空间设置](https://developer.qiniu.com/kodo/development_guidelines/8501/space- settings) > 设置传输加速 # 设置传输加速 最近更新时间: 2024-07-12 10:22:24 您可以通过控制台为您的存储空间开启传输加速，实现全球各地用户快速访问您的存储空间，提升业务访问成功率和业务稳定性。关于全球加速的更多信息，详情见 [传输加速](https://developer.qiniu.com/kodo/development_guidelines/12656/transfer- acceleration)。 # **操作步骤** 1. 登录 Kodo 控制台进入[空间管理 __](https://portal.qiniu.com/kodo/bucket)界面 2. 单击**目标空间名称** ，单击**域名管理** 3. 如图1：域名管理，在传输加速功能中，单击开关将当前状态修改为开启 图1:  4. 开启了传输加速功能后，您只需要通过传输加速域名上传文件至存储空间，即可实现快速传输的效果，**当前仅支持上传加速** 。 传输加速开启操作会在30分钟内全网生效。关闭传输加速操作也需要在30分钟内全网生效。 **备注** 传输加速，当前在公测阶段，您需要 [提交工单 __](https://support.qiniu.com/tickets/new/?ref=developer.qiniu.com&s_path=%2Fkodo%2F2528%2Fupload- webtest)申请使用。 以上内容是否对您有帮助？

删除存储空间

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [控制台指南](https://developer.qiniu.com/kodo/development_guidelines/8452/kodo- console-guide) > [空间管理](https://developer.qiniu.com/kodo/development_guidelines/8456/bucket- management) > [空间设置](https://developer.qiniu.com/kodo/development_guidelines/8501/space- settings) > 删除存储空间 # 删除存储空间 最近更新时间: 2024-07-12 10:22:42 您可以在对象存储 Kodo 控制台删除您不再需要的存储空间（Bucket）。 # **说明** * 非空空间不可删除，您需要先删除该空间中所有的文件（Object），详情请见[删除文件](https://developer.qiniu.com/kodo/development_guidelines/8571/delete-the-file)。 * 直播空间不可删除，详情请参考七牛直播云[直播落存储服务 __](https://developer.qiniu.com/pili/1209/live-the-core-function#4)。 * 若空间仍绑定有自定义 CDN 域名时，不允许删除。您可参考[设置自定义 CDN 加速域名](https://developer.qiniu.com/kodo/development_guidelines/8555/set-the-custom-cdn-to-accelerate-the-domain-name)先解绑 CDN 域名，后删除空间。 * 空间删除后，空间名称可以被重新使用。 * 更多详情请参考[删除空间](https://developer.qiniu.com/kodo/development_guidelines/8601/dev-delete-the-space)。 ### **空间删除后不可恢复，请谨慎操作！** # **操作步骤** 1. 登录 Kodo 控制台进入[空间管理 __](https://portal.qiniu.com/kodo/bucket)界面 2. 单击**目标空间名称** ，单击**空间设置** 进入空间设置界面 3. 找到删除空间栏，如图1，单击**删除空间** 。 图1:  4. 在弹出的警示窗口，单击**确定** ，后输入**账户密码** 再单击**确定** ，完成删除空间操作。 以上内容是否对您有帮助？

域名管理

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [控制台指南](https://developer.qiniu.com/kodo/development_guidelines/8452/kodo- console-guide) > [空间管理](https://developer.qiniu.com/kodo/development_guidelines/8456/bucket- management) > 域名管理 # 域名管理 最近更新时间: 2024-07-12 10:22:58 当您创建了新的存储空间（Bucket），为了您的业务进展一切顺利，您需要给空间绑定域名以提供正式的生产环境。您可以绑定自定义域名到存储空间，添加 CNAME 记录指向相应域名，然后通过自定义域名来访问存储空间里的文件。 对象存储 Kodo 支持以下两种绑定域名方式： * 自定义 CDN 加速域名：为空间绑定自定义 CDN 加速域名，可以通过 CDN 边缘节点缓存数据，提高存储空间内的文件访问响应速度。 * 自定义源站域名：绑定自定义域名为空间的源站域名，即可通过该域名直接访问存储空间内的文件。 # **说明** * 当新空间创建后，系统将自动为其配备测试域名， 有效期 30 天，仅限用于业务对接测试，不可用于正式生产环境。更多测试域名使用规范请参考[测试域名使用规范 __](https://developer.qiniu.com/fusion/kb/1319/test-domain-access-restriction-rules)。 * 为了您的业务顺利开展，建议您参考以下步骤尽快进行自定义域名配置。 ### **注意：按照中华人民共和国《互联网管理条例》的要求，所有需要绑定自定义域名的用户，必须提前将域名在工信部备案。** # **操作步骤** 1. 登录 Kodo 控制台进入[空间管理 __](https://portal.qiniu.com/kodo/bucket)界面 2. 单击**目标空间名称** ，单击**域名管理** 进入域名管理界面 3. 如图1，域名管理界面展示了您可对当前所选空间域名进行的设置项。 图1  4. 您可以在当前页面根据以下操作来进一步域名管理： 空间设置操作 --- [设置自定义CDN加速域名](https://developer.qiniu.com/kodo/development_guidelines/8555/set- the-custom-cdn-to-accelerate-the-domain-name) [设置自定义源站域名](https://developer.qiniu.com/kodo/development_guidelines/8556/set- the-custom-source-domain-name) 5. 设置域名完成后，您也可单击至**文件管理** ，如图2，单击**外链域名 默认** 获取下拉菜单查看当前空间已绑定的 CDN 及源站域名。 图2:  6. 选择 **目标域名** ，单击**保存为默认域名** ，即可更改当前空间的默认域名。 以上内容是否对您有帮助？

设置自定义CDN加速域名

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [控制台指南](https://developer.qiniu.com/kodo/development_guidelines/8452/kodo- console-guide) > [空间管理](https://developer.qiniu.com/kodo/development_guidelines/8456/bucket- management) > [域名管理](https://developer.qiniu.com/kodo/development_guidelines/8527/kodo- domain-name-management) > 设置自定义CDN加速域名 # 设置自定义CDN加速域名 最近更新时间: 2024-07-12 10:23:11 对象存储 Kodo 与七牛云 CDN 服务结合，支持空间（Bucket） 绑定 CDN 加速域名，利用 CDN 节点缓存数据，来实现存储空间内文件（Object）的加速访问。 # **说明** * 其他 CDN 域名管理的操作，如启用、停用、删除、修改、找回域名，请参考 [域名操作 __](https://developer.qiniu.com/fusion/4940/domain-name-operation)、[域名找回 __](https://developer.qiniu.com/fusion/5857/the-domain-name-back)。 * Kodo 结合七牛云 CDN 加速服务使用时，会产生 CDN 流出流量费用、CDN 回源流出流量费用、请求费用。 计费详情请见[ CDN 产品价格说明 __](https://developer.qiniu.com/fusion/6843/cdn-product-pricing)。 * 若需绑定自定义域名为空间的源站域名，请参考[自定义源站域名](https://developer.qiniu.com/kodo/development_guidelines/8556/set-the-custom-source-domain-name)。 ### **注意：按照中华人民共和国《互联网管理条例》的要求，所有需要绑定自定义域名的用户，必须提前将域名在工信部备案。** # **操作步骤** 1. 登录 Kodo 控制台进入[空间管理 __](https://portal.qiniu.com/kodo/bucket)界面 2. 单击**目标空间名称** ，单击**域名管理** 进入域名管理界面 3. 如图1：域名管理，单击自定义 CDN 加速域名栏的 **绑定域名** ，即可跳转至空间的 CDN 加速域名绑定界面。 图1:  4. 请参考[融合 CDN 域名接入 __](https://developer.qiniu.com/fusion/4939/the-domain-name-to-access)，完成 CDN 加速域名绑定。 * 域名需要能通过 ICP 备案检测，然后按需设置域名的通信协议、使用范围、应用场景和缓存策略即可。 * 域名需要添加 CNAME 记录解析到指定的域名，详情请见[ CNAME 配置 __](https://developer.qiniu.com/fusion/4941/cname-configuration) 5. 如图1，绑定成功的域名，会在空间的自定义 CDN 加速域名列表中展示。列表展示了空间已绑定的 CDN 加速域名，域名的 CNAME 配置信息、域名状态、域名协议、创建时间 6. 单击**指定域名** ，即可跳转查看 CDN 域名详情。 7. 鼠标移至 **CNAME 链接** ，即可查看当前 CNAME 解析记录。 8. 域名状态可能为：成功、失败、处理中、已停用、已冻结 9. 域名协议为 HTTP/HTTPS，支持快速查看 HTTPS 证书状态。 10. 单击**刷新** 可以刷新该条域名信息。 以上内容是否对您有帮助？

设置自定义源站域名

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [控制台指南](https://developer.qiniu.com/kodo/development_guidelines/8452/kodo- console-guide) > [空间管理](https://developer.qiniu.com/kodo/development_guidelines/8456/bucket- management) > [域名管理](https://developer.qiniu.com/kodo/development_guidelines/8527/kodo- domain-name-management) > 设置自定义源站域名 # 设置自定义源站域名 最近更新时间: 2024-07-12 10:23:30 对象存储 Kodo 支持您为空间（Bucket）绑定自定义域名为其源站域名，添加 CNAME 记录指向相应域名，然后通过自定义域名直接访问存储空间里的文件。 # **说明** * 一个域名不能同时与多个空间绑定。 * 支持对已绑定的源站域名开启 HTTPS 访问，须绑定 SSL 证书。证书需要先行托管至七牛云的[ SSL 证书服务 __](https://developer.qiniu.com/ssl)。 * 更多详情请参考[绑定源站域名](https://developer.qiniu.com/kodo/development_guidelines/8622/dev-the-binding-source-domain-name)。 * 若需绑定自定义 CDN 域名为空间的加速域名，请参考[自定义 CDN 加速域名](https://developer.qiniu.com/kodo/development_guidelines/8555/set-the-custom-cdn-to-accelerate-the-domain-name)。 ### **注意：按照中华人民共和国《互联网管理条例》的要求，所有需要绑定自定义域名的用户，必须提前将域名在工信部备案。** # **操作步骤** 1. 登录 Kodo 控制台进入[空间管理 __](https://portal.qiniu.com/kodo/bucket)界面 2. 单击**目标空间名称** ，单击**域名管理** 进入域名管理界面 3. 如图1：域名管理 图1:  ## **绑定自定义源站域名** 1. 单击自定义源站域名栏的**绑定域名** ，弹出图2，**输入域名** 。 图2:  _注：一个域名只能与一个空间绑定_ 2. 单击**绑定域名** ，域名通过 ICP 备案检测后即可绑定成功。后弹出如图3，提示绑定成功并显示当前存储空间所在域名对应的 CNAME 域名 图3:  _注：域名需要添加 CNAME 记录指向存储空间所在区域对应的 CNAME 域名，才能通过自定义域名访问存储空间。各区域 CNAME 域名，请参考[绑定源站域名](https://developer.qiniu.com/kodo/development_guidelines/8622/dev- the-binding-source-domain-name)。_ 3. 如图1，绑定成功的域名，会在空间的自定义源站域名列表中展示。 4. 单击**复制 CNAME** ，即可复制当前区域 CNAME 域名。 5. 请确保输入的域名已备案并已在域名解析商处设置好对应的 CNAME。 ## **开启HTTPS访问** 1. 在如图1的自定义源站域名列表中，选择目标域名栏，单击**配置 HTTPS** ，右侧弹出配置 HTTPS 界面，单击**访问控制 http/https** 切换后如图4 图4:  2. 在更换证书栏，**选择** 自动筛选出当前域名可用的证书列表；若没有可用证书，请至 [SSL 证书服务 __](https://portal.qiniu.com/certificate/ssl#cert)管理证书，详细操作步骤请参考[证书申购流程 __](https://developer.qiniu.com/ssl/3666/ssl-certificate-of-purchase-process)。 ## **验证域名所有权** 当您的域名被其他用户绑定时，可以通过验证域名所有权，强制解绑此域名。 _注：此步骤仅在绑定自定义源站域名提示域名冲突时可查看和操作。_ 1. 域名绑定冲突时，即当前输入的域名已经被其他用户绑定时，界面会提示系统依据域名信息生成的 TXT 记录，如图5。 图5:  2. 在域名解析商处添加对应的 TXT 记录，如图6： 图6：  3. 在图6的添加 TXT 记录界面，按如下说明配置各项参数 操作名称 | 说明 ---|--- 记录类型 | 选择 TXT 主机记录 | 填写图5中显示的主机记录 记录值 | 填写图5中显示的值 其他值保持默认 | 4. 至图5弹窗界面，单击**我已添加TXT验证记录，提交** ，若系统验证检测信息通过，则会执行解绑。 ## **ICP 备案巡检** 自2022年6月8日起，执行 ICP 备案巡检机制。系统会对中国大陆区域空间上的源站域名做 ICP 备案巡检，备案状态异常的域名将会通知客户确认状态、跟进备案更新；而当天下午备案状态依旧异常的域名将会被系统冻结、禁止访问资源。 被冻结的域名在控制台上会出现「冻结」标签，鼠标悬停可以看到冻结原因。  确认 ICP 备案更新正常的话，您可以直接在控制台上操作「解冻」，实时 ICP 检查通过后、系统会执行解冻、域名恢复使用。 ## **解绑自定义源站域名** 1. 在如图1的自定义源站域名列表中，单击**解绑** ，再单击**确定** ，即可完成目标域名栏的解绑操作。 以上内容是否对您有帮助？

数据处理

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [控制台指南](https://developer.qiniu.com/kodo/development_guidelines/8452/kodo- console-guide) > [空间管理](https://developer.qiniu.com/kodo/development_guidelines/8456/bucket- management) > 数据处理 # 数据处理 最近更新时间: 2024-08-01 15:59:52 您可使用对象存储 Kodo，对当前所选空间进行数据处理。 Kodo 支持以下数据处理操作： * 视频处理：针对视频类文件提供的实时转码处理服务，即点即转、边转边播、可以在极短时间内播放转码后的视频 * 图片处理：为七牛云的图片文件提供图片处理服务 * 转码样式：针对控制台上传文件提供的一键式转码模板 * 原始资源保护：针对媒体类源文件的保护措施，使空间内的文件无法直接通过 URL 进行访问 # **操作步骤** * 您可以在当前页面根据以下操作来进一步数据处理： 空间设置操作 --- [设置图片样式](https://developer.qiniu.com/kodo/development_guidelines/8558/set-the- picture-style) [设置视频样式](https://developer.qiniu.com/kodo/development_guidelines/12738/set- the-video-style) [设置转码样式](https://developer.qiniu.com/kodo/development_guidelines/8559/set-the- transcoding-style) [设置原始资源保护](https://developer.qiniu.com/kodo/development_guidelines/8560/set- the-original-protection) 以上内容是否对您有帮助？

设置图片样式

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [控制台指南](https://developer.qiniu.com/kodo/development_guidelines/8452/kodo- console-guide) > [空间管理](https://developer.qiniu.com/kodo/development_guidelines/8456/bucket- management) > [数据处理](https://developer.qiniu.com/kodo/development_guidelines/8552/the-data- processing) > 设置图片样式 # 设置图片样式 最近更新时间: 2024-08-13 19:03:42 对象存储 Kodo 支持通过控制台提供一键式图片编辑功能，方便您对空间（Bucket）内上传文件（Object）做批量图片处理。 您可在本多媒体样式功能中进行： * 图片处理：支持对图片进行如剪裁、添加水印、格式变更等的处理。图片样式将冗长的图片数据处理重新定义的一个友好别名，以简洁的方式描述对图片的处理模式。 * 样式分隔符：样式分隔符是用于连接资源链接和图片样式的特殊符号，为防止访问出错，您可自定义样式名中不可出现的分隔符。 # **说明** * 更多关于图片编辑的操作，请参考七牛云智能多媒体服务的[图片处理 __](https://developer.qiniu.com/dora/3683/img-directions-for-use)。 * 更多详情请参考[图片样式](https://developer.qiniu.com/kodo/development_guidelines/8623/dev-the-picture-style)。 # **操作步骤** 1. 登录 Kodo 控制台进入[空间管理 __](https://portal.qiniu.com/kodo/bucket)界面 2. 单击**目标空间名称** ，单击**多媒体样式** 进入如图1:多媒体样式列表 图1:  3. 单击**新建样式** ，选择**图片处理** 以新建图片处理规则，如图2。 图2:  或在如图3，单击**文件管理** ，选择指定图片文件，在操作栏**更多** 中的**图片样式** 点击**新建样式** ，以进入样式编辑界面 _注：仅支持对标准存储、低频存储和归档直读存储类型及大小不超过 20MB 的图片文件提供**图片样式** 操作_ 图3:  指定规则后，点击**保存样式** 提交新建样式请求，已新建的样式将以列表展示。图片处理参数详情请参考智能多媒体服务[图片样式 __](https://developer.qiniu.com/dora/8264/the-picture-style)。 4. 在图2的样式配置界面中，您可以使用 Kodo 提供的默认图片并点击**预览** 进行样式效果预览。 5. 或点击**选择样例文件** ，在如图4的文件选择界面中点击**空间内选择** 直接选择空间中已有的文件，并点击**预览** 进行样式效果预览。 _注：仅支持选择标准存储、低频存储和归档直读存储的图片类型文件_ 6. 或在如图4的文件选择界面点击**上传文件** ，支持您直接从本地上传指定文件到您空间，并点击**预览** 以使用该文件查看预览效果。 _注：您上传的文件将存储在您空间中，仅支持上传大小不超过 20MB 的图片文件_ 图4:  7. 点击在列表操作栏中**编辑** ，支持对已有样式进行修改。 8. 点击在列表操作栏中**复制** ，支持复制已有样式以在当前空间中进行快速新建。您也可以选择单/多个样式，点击**批量操作** 选择**复制到其他空间** ，快速将当前的样式复制到其他自有空间。如在批量操作中遇到样式名重复，您可以点击**覆盖** 或**取消** 复制当前样式，如图5。 图5:  9. 点击在列表操作栏中**预览** ，可以快速预览样式效果，支持选择指定预览文件查看效果。 10. 点击在列表操作栏中**删除** ，删除已有样式。您也可以选择单/多个样式，点击**批量操作** 选择**批量删除** 完成批量删除样式的操作。 ### **访问设置** 1. 单击**访问设置** ，在如图5右侧弹窗中样式分隔符设置界面，单击**请选择样式分隔符** 栏获取下拉菜单 图5:  2. **单选或多选** 指定分隔符，单击 **+添加** ，单击**保存** ，完成样式分隔符设置。 _注：未设置时默认样式分隔符为 -（中划线）_ # **具体示例** 1. 样式名称为 `imageFop`，样式内容为：`imageView2/0/w/48/h/48`，样式分隔符为 `-` 2. 原始图片链接 `http://dn-odum9helk.qbox.me/qiniu-picture1.jpg` 3. 通过访问 `http://dn-odum9helk.qbox.me/qiniu-picture1.jpg-imageFop` 即可获得效果缩放效果 注意事项： * 创建分隔符时，不建议使用在样式名称中出现的符号作为分隔符。 * 修改分隔符是个危险操作，为保证样式访问链接生效，仅支持新增、不支持删除已设置的样式分隔符。 以上内容是否对您有帮助？

设置转码样式

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [控制台指南](https://developer.qiniu.com/kodo/development_guidelines/8452/kodo- console-guide) > [空间管理](https://developer.qiniu.com/kodo/development_guidelines/8456/bucket- management) > [数据处理](https://developer.qiniu.com/kodo/development_guidelines/8552/the-data- processing) > 设置转码样式 # 设置转码样式 最近更新时间: 2024-07-12 10:24:05 对象存储 Kodo 支持通过控制台提供一键式文件格式转码功能，方便您在空间（Bucket）内上传文件（Object）时做批量转码处理。 # **操作步骤** 1. 登录 Kodo 控制台进入[空间管理 __](https://portal.qiniu.com/kodo/bucket)界面 2. 单击**目标空间名称** ，后单击**转码样式** 进入如图1:转码样式列表 图1:  3. 单击 **+新建转码样式** ，右侧弹出如图2界面 图2:  4. 在新建转码样式界面，按如下说明配置各项参数 操作名称 | 说明 | 规则描述 ---|---|--- 转码配置名称 | 请自定义当前转码样式的名称 | 在当前空间下不可重复命名转码样式规则 转码命令 | 请选择命令或自定义 | \- 转码命令包含参数，详解请参考[存储空间的转码样式使用说明](https://developer.qiniu.com/kodo/development_guidelines/8624/dev-transcoding-style)。 \- 或选择 自定义，输入命令。 目标空间 | 请选择转码后目标放置的空间 | 可选择在同区域建立的任一空间 目标文件名 | 请定义目标文件名称 | 目标文件名支持[魔法变量](https://developer.qiniu.com/kodo/development_guidelines/1235/vars)或自定义字符串。 魔法变量引用格式为 ${var}、$(var)，魔法变量仅支持 bucket、key、etag、fsize、mimeType、ext、endUser、fprefix、 keybase。 回调 URL | 请按需设置回调地址 | 选填 私有队列 | 请按需选择私有队列 | \- 选填，不选择即归为系统默认队列 default.sys \- 选择私有队列，可参考 [队列 __](https://developer.qiniu.com/dora/6497/the-queue)以[创建私有队列 __](https://portal.qiniu.com/dora/mps/new)，更多队列详情请参考[关于七牛云的流媒体队列 __](https://developer.qiniu.com/dora/kb/2500/streaming-media-queue-about- seven-cows?category=kb#2)。 5. 单击**确定** ，完成转码样式规则创建。 6. 转码样式规则保存成功后，您可以在如图1:转码样式列表中查看已设置的规则，也可以对规则进行 **复制、编辑** 或**删除** 。 7. 您还可以在空间上传文件时，**单选或多选** 当前已有的转码样式，直接进行转码。详情请参考[上传文件](https://developer.qiniu.com/kodo/development_guidelines/8562/upload-a-file)。 以上内容是否对您有帮助？

设置原始资源保护

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [控制台指南](https://developer.qiniu.com/kodo/development_guidelines/8452/kodo- console-guide) > [空间管理](https://developer.qiniu.com/kodo/development_guidelines/8456/bucket- management) > [数据处理](https://developer.qiniu.com/kodo/development_guidelines/8552/the-data- processing) > 设置原始资源保护 # 设置原始资源保护 最近更新时间: 2024-07-12 10:24:17 原始资源保护是对象存储 Kodo 针对媒体类源文件的保护措施，不支持直接通过 URL 访问原图，以防止您 Kodo 存储空间内允许匿名访问的图片文件或视频被盗用。 # **说明** * 原始资源保护是一种空间属性，对整个存储空间内所有的资源生效。 * 建议对于开启原始资源保护的空间只存储需要保护的图片文件和视频文件，其他文件使用其他空间存放。 * 开启后，空间内的文件无法直接通过公开 URL 进行访问，需要配合[样式分隔符](https://developer.qiniu.com/kodo/development_guidelines/8558/set-the-picture-style)和[图片样式 __](https://developer.qiniu.com/dora/8264/the-picture-style)才能访问，更多详情请参考[原始资源保护](https://developer.qiniu.com/kodo/development_guidelines/8616/dev-the-original-image-to-protect)。 * 可在文件详情上查看该文件的原始资源保护定义信息，详情请见[查看文件信息](https://developer.qiniu.com/kodo/development_guidelines/8566/view-the-file-information)。 # **操作步骤** 1. 登录 Kodo 控制台进入[空间管理 __](https://portal.qiniu.com/kodo/bucket)界面 2. 单击**目标空间名称** ，单击**多媒体样式** 进入多媒体样式设置界面 3. 点击**访问设置** ，如图1，在原始资源保护栏中单击**开启/关闭** ，完成原始资源保护设置。 图1:  _注：修改设置后，请及时刷新 CDN 缓存，以保证设置生效。请在当前原始资源保护栏单击**[融合 CDN-刷新预取-刷新目录 __](https://portal.qiniu.com/cdn/refresh-prefetch)**刷新 CDN 缓存，详情请见[七牛云 CDN 刷新预取 __](https://developer.qiniu.com/fusion/3845/refresh-the-prefetch- fusion)。_ 以上内容是否对您有帮助？

文件管理

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [控制台指南](https://developer.qiniu.com/kodo/development_guidelines/8452/kodo- console-guide) > 文件管理 # 文件管理 最近更新时间: 2024-04-11 14:46:40 文件管理界面展示了您当前所选空间的概览信息如图1:空间管理-文件管理，包括 * 空间使用信息：各存储类型对应的文件数、存储量 * 域名信息：当前使用的外链域名 * 显示/隐藏目录：支持两种文件列举模式，包括显示目录及隐藏目录平铺列举 * 文件信息：文件列表及文件管理操作 图1:空间管理-文件管理  # **操作步骤** * 您可以在当前页面根据以下操作来进一步文件管理： 文件管理操作 --- [上传文件](https://developer.qiniu.com/kodo/development_guidelines/8562/upload-a- file) [创建目录](https://developer.qiniu.com/kodo/development_guidelines/10576/create-a- directory) [搜索文件](https://developer.qiniu.com/kodo/development_guidelines/8563/search- for-files) [修改文件名](https://developer.qiniu.com/kodo/development_guidelines/8564/modify- the-file-name) [修改文件类型](https://developer.qiniu.com/kodo/development_guidelines/8565/modify- the-file-type) [查看文件详情](https://developer.qiniu.com/kodo/development_guidelines/8566/view- the-file-information) [设置文件元信息](https://developer.qiniu.com/kodo/development_guidelines/8567/settings- file-meta-information) [下载文件](https://developer.qiniu.com/kodo/development_guidelines/8568/the- download-file) [分享文件](https://developer.qiniu.com/kodo/development_guidelines/8569/share- files) [分享目录](https://developer.qiniu.com/kodo/development_guidelines/12667/share- folder) [刷新 CDN 缓存](https://developer.qiniu.com/kodo/development_guidelines/12360/refresh-the- cdn-cache) [移动文件](https://developer.qiniu.com/kodo/development_guidelines/10578/move- files) [删除文件](https://developer.qiniu.com/kodo/development_guidelines/8571/delete- the-file) [删除目录](https://developer.qiniu.com/kodo/development_guidelines/10577/delete- the-directory) [修改文件存储类型](https://developer.qiniu.com/kodo/development_guidelines/8572/modify- the-file-storage-type) [解冻文件](https://developer.qiniu.com/kodo/development_guidelines/8573/thaw-file- storage) [任务中心](https://developer.qiniu.com/kodo/development_guidelines/10580/the-task- center) 以上内容是否对您有帮助？

上传文件

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [控制台指南](https://developer.qiniu.com/kodo/development_guidelines/8452/kodo- console-guide) > [文件管理](https://developer.qiniu.com/kodo/development_guidelines/8561/file- management) > 上传文件 # 上传文件 最近更新时间: 2024-08-12 15:27:38 您可以通过对象存储 Kodo 控制台在已有空间（Bucket）内上传文件（Object）。Kodo 控制台支持您上传单个或多个文件。 # **说明** * 您必须先创建存储空间才能上传文件。详情请见[新建空间](https://developer.qiniu.com/kodo/development_guidelines/8498/the-new-space)。 * 若要上传单个文件大于 4MB，建议通过 SDK 或 API 的[分片上传和断点续传](https://developer.qiniu.com/kodo/development_guidelines/1234/upload-types)、[图形化管理工具 Kodo Browser](https://developer.qiniu.com/kodo/tools/5972/kodo-browser)、[同步上传 Windows 客户端](https://developer.qiniu.com/kodo/tools/1666/qsunsync)或[命令行工具 Qshell](https://developer.qiniu.com/kodo/tools/1302/qshell)。 ### **上传须知：七牛云存储严禁上传包括反动、暴力、色情、违法、及侵权内容的文件。七牛有义务配合有关部门将上传违规文件的用户信息保存，并保留因配合调查而冻结账号的权利。国家秘密受法律保护。一切国家机关、武装力量、政党、社会团体、企事业单位和公民都有保守国家秘密的义务。 任何危害国家秘密安全的行为，都必须受到法律追究。请严格遵守保密法律法规，严禁在互联网上存储、处理、传输、发布涉密信息。** # **操作步骤** 1. 登录 Kodo 控制台进入[空间管理 __](https://portal.qiniu.com/kodo/bucket)界面，在空间列表中 2. 单击**目标空间名称** ，单击**文件管理** 进入文件管理界面 3. 单击**上传文件** ，将显示图1上传文件界面 图1:  4. 在上传文件界面，按如下说明配置各项参数： 操作名称 | 说明 | 规则描述 ---|---|--- 上传位置 | 当前所选文件将被上传到的位置 | \- 单击**编辑** 即可自定义上传位置 * **创建目录必须以`/` 结尾；不以 `/` 结尾将被定义为文件前缀。** * 不得包含连续的 `/` 且每个 `/` 前不得仅为英文句号 `.` 。 选择上传文件存储类型 | 请按需选择将要上传的文件的存储类型 | \- 您可以先选择存储类型，后上传对应文件 * 标准存储：适用于访问量较高的文件。 * 低频存储：适用于长期存储、较少访问的文件，最少需存储 30 天，支持实时访问且访问文件时会产生数据取回费用。 * 智能分层存储：适用于访问模式不固定或者无法预估访问模式的数据，会收取监控和自动化费用。 * 归档直读存储：适用于长期存储、不太访问的文件，最少需存储 60 天，支持实时访问且访问文件时会产生数据取回费用。 * 归档存储：适用于长期存储、基本不访问的文件，最少需存储 60 天。文件需解冻后访问，解冻会产生数据取回费用。 * 深度归档存储：适用于一些需要长期存储的备份文件等，最少需存储 180 天。文件需解冻后访问，解冻会产生数据取回费用。 * 更多详情，请见[存储类型](https://developer.qiniu.com/kodo/product_introduction/3956/kodo-category)。 \- 您也可以后续按需更改您的文件存储类型，详情请见[修改文件存储类型](https://developer.qiniu.com/kodo/development_guidelines/8572/modify- the-file-storage-type)。 上传覆盖 | 请按需选择开启或关闭 | \- 开启上传覆盖后，允许上传同名文件，关闭上传覆盖将无法上传同名文件 \- 开启上传覆盖后上传同名文件，原文件将被覆盖 上传加速 | 请按需选择开启或关闭 | \- 仅在开通[传输加速](https://developer.qiniu.com/kodo/development_guidelines/12656/transfer-acceleration)功能后支持使用，未开通时默认关闭上传加速 \- 开启上传加速后，将使用加速域名上传文件、加快上传速度 转码样式 | 请按需选择转码样式规则 | \- 若无定义，则默认不转码 \- 选择已存在的转码规则，若无则单击 **+** 并参考[设置转码样式](https://developer.qiniu.com/kodo/development_guidelines/8559/set- the-transcoding-style)来新建规则 \- 归档、深度归档存储类型的文件不支持设置转码样式 5. 单击**选择** 文件，选择所需上传的单个或多个文件。如您单击**清空文件** ，列表内当前所选的文件将被清空。 6. 单击**开始上传** ，提交上传任务至任务中心。您可到任务中心，查看该任务状态。 7. 或在当前上传界面自定义策略继续上传单个或多个文件。 8. 或单击 **x** ，完成上传并回到文件列表。单击**刷新** 查看已上传成功的文件。 以上内容是否对您有帮助？

创建目录

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [控制台指南](https://developer.qiniu.com/kodo/development_guidelines/8452/kodo- console-guide) > [文件管理](https://developer.qiniu.com/kodo/development_guidelines/8561/file- management) > 创建目录 # 创建目录 最近更新时间: 2024-07-12 10:25:23 对象存储 Kodo 支持通过目录来管理空间（Bucket）中的文件（Object），以便于您合理归类您的文件。您可以通过 Kodo 控制台创建目录。 # **说明** * Kodo 默认将以 `/` 结尾的对象作为文件目录的形式展现。 * 支持创建单、多层级目录。 * 仅在模式为显示目录时，支持创建目录。 # **操作步骤** 1. 登录 Kodo 控制台进入[空间管理 __](https://portal.qiniu.com/kodo/bucket)界面，在空间列表中 2. 单击**目标空间名称** ，单击**文件管理** 进入文件管理界面 3. 单击**创建目录** ，显示如图1的弹窗 图1:  4. 在图1，按如下说明输入参数 操作名称 | 说明 | 规则描述 ---|---|--- 目录名 | 自定义目录名 | \- 输入目录名，不支持仅由英文句号 `.` 组成的名称 \- 不支持以 `/` 开头， 不能包含连续的 `/` \- 支持以 `/` 分割路径，快速创建子目录 5. 单击**确定** ，完成创建目录 以上内容是否对您有帮助？

搜索文件

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [控制台指南](https://developer.qiniu.com/kodo/development_guidelines/8452/kodo- console-guide) > [文件管理](https://developer.qiniu.com/kodo/development_guidelines/8561/file- management) > 搜索文件 # 搜索文件 最近更新时间: 2024-07-12 10:25:38 对象存储 Kodo 支持通过指定文件（Object）名称快速搜索并筛选出对应文件，以便您在创建大量文件的空间下迅速定位到目标文件。 # **操作步骤** 1. 登录 Kodo 控制台进入[空间管理 __](https://portal.qiniu.com/kodo/bucket)界面，在空间列表中 2. 单击**目标空间名称** ，单击**文件管理** 进入文件管理界面 3. 如图1，输入目标文件名或文件目录名，按**回车** 进行搜索或跳转至指定目录 图1:  4. 如您搜索指定目录，您将进入该目录中、下方文件列表将展示该目录下的内容，如图2 图2:  以上内容是否对您有帮助？

修改文件名

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [控制台指南](https://developer.qiniu.com/kodo/development_guidelines/8452/kodo- console-guide) > [文件管理](https://developer.qiniu.com/kodo/development_guidelines/8561/file- management) > 修改文件名 # 修改文件名 最近更新时间: 2024-07-12 10:25:48 对象存储 Kodo 支持对已上传的文件（Object）名作出修改，以便您在上传文件后仍能快捷编辑文件名称。 # **说明** * 修改的新文件名不可与本空间内其他文件名重复。 * 对于归档、深度归档存储类型的文件，需要确认文件已“解冻”完成才能修改文件名，详情请见[解冻文件](https://developer.qiniu.com/kodo/development_guidelines/8573/thaw-file-storage)。已解冻的文件，在修改文件名后，将再次恢复冷冻。 # **操作步骤** 1. 登录 Kodo 控制台进入[空间管理 __](https://portal.qiniu.com/kodo/bucket)界面，在空间列表中 2. 单击**目标空间名称** ，单击**文件管理** 进入文件管理界面 3. 在如图1的文件列表中，单击目标文件栏文件名称旁的**修改图标** 图1:  4. 将出现如图2的弹窗，按下表参数说明输入新文件名后，单击**确定** 完成修改 图2:  操作名称 | 说明 | 规则描述 ---|---|--- 文件名 | 自定义文件名 | 文件列举模式为显示目录时，文件名不支持仅由英文句号 `.` 组成的名称、不能包含 `/` 。 文件列举模式为隐藏目录时，不支持仅由英文句号 `.` 组成的名称； 不得以 `/` 开头； 不得包含连续的 `/` 且每个 `/` 前不得仅为英文句号 `.` 。 以上内容是否对您有帮助？

修改文件类型

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [控制台指南](https://developer.qiniu.com/kodo/development_guidelines/8452/kodo- console-guide) > [文件管理](https://developer.qiniu.com/kodo/development_guidelines/8561/file- management) > 修改文件类型 # 修改文件类型 最近更新时间: 2024-07-12 10:26:00 对象存储 Kodo 支持对已上传的文件（Object）类型作出修改，方便您在上传文件后仍能快捷编辑文件类型。 # **说明** * 对于归档、深度归档存储类型的文件，需要确认文件已“解冻”完成才能修改文件类型，详情请见[解冻文件](https://developer.qiniu.com/kodo/development_guidelines/8573/thaw-file-storage)。 # **操作步骤** 1. 登录 Kodo 控制台进入[空间管理 __](https://portal.qiniu.com/kodo/bucket)界面，在空间列表中 2. 单击**目标空间名称** ，单击**文件管理** 进入文件管理界面 3. 在如图1的文件列表中，单击目标文件栏文件类型旁的**修改图标** 图1:  4. 在将出现如图2界面，输入新的文件类型后单击**确定** 完成修改 图2:  以上内容是否对您有帮助？

查看文件详情

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [控制台指南](https://developer.qiniu.com/kodo/development_guidelines/8452/kodo- console-guide) > [文件管理](https://developer.qiniu.com/kodo/development_guidelines/8561/file- management) > 查看文件详情 # 查看文件详情 最近更新时间: 2024-07-12 10:26:14 您可以在文件列表里快速查看目标文件信息和当前状态。 根据您当前对空间、文件的设置，您可以在文件详情界面可能看到的信息，如下： * 基础信息：文件预览、文件名、文件类型、Etag、文件大小、存储类型、过期时间（生命周期定义的文件到期删除时间）、文件链接 * 多媒体样式：带样式的文件预览、带样式的文件链接 * 元数据定义：当前元数据信息、快捷添加新元数据信息 # **操作步骤** 1. 登录 Kodo 控制台进入[空间管理 __](https://portal.qiniu.com/kodo/bucket)界面，在空间列表中 2. 单击**目标空间名称** ，单击**文件管理** 进入文件管理界面 3. 在文件列表中，单击目标文件栏中的**详情** ，将弹出文件详情界面，示例如图1 图1:文件详情-基础信息  4. 标准存储、低频存储和归档直读存储类型的文件，您可以在详情中选择指定**样式** ，以预览样式效果并获取带样式链接。图片文件详情中仅支持使用图片样式，视频文件详情中仅支持使用视频样式。选择样式后，单击**样式分隔符** 切换分隔符，获取对应的文件链接。对开启[原始资源保护](https://developer.qiniu.com/kodo/development_guidelines/8616/dev-the-original-image-to-protect)的空间，需通过带样式链接访问文件。 5. 单击图片预览处的**切换键** ，可以快速切换并查看前、后一个文件详情。单击**自动预览** 可以取消勾选默认开启的自动预览文件模式。 6. 如图2，单击**添加** 自定义文件元数据，或单击**编辑** 、**删除** 重定义已添加的元数据 图2:文件详情-元数据定义  以上内容是否对您有帮助？

设置文件元信息

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [控制台指南](https://developer.qiniu.com/kodo/development_guidelines/8452/kodo- console-guide) > [文件管理](https://developer.qiniu.com/kodo/development_guidelines/8561/file- management) > 设置文件元信息 # 设置文件元信息 最近更新时间: 2024-07-12 10:26:23 文件元信息是对文件的属性描述，包括 HTTP 标准属性（HTTP Header）和用户自定义元数据（User Meta）两种。 对象存储 Kodo 支持您通过控制台设置用户自定义元数据，为文件（Object）添加描述信息，以标识其用途或属性等。 # **说明** * 对于归档、深度归档存储类型的文件，需要确认文件已“解冻”完成才能修改其元信息，详情请见[解冻文件](https://developer.qiniu.com/kodo/development_guidelines/8573/thaw-file-storage)。 # **操作步骤** 1. 登录 Kodo 控制台进入[空间管理 __](https://portal.qiniu.com/kodo/bucket)界面，在空间列表中 2. 单击**目标空间名称** ，单击**文件管理** 进入文件管理界面 3. 在文件列表中，单击目标文件栏中的**详情** ，将弹出文件详情界面，示例如图1 4. 在如图1的元数据定义栏，单击**添加** 图1:  5. 在元数据定义界面，按如下说明配置各项参数： 操作名称 | 说明 | 规则描述 ---|---|--- 参数 | 请自定义文件元数据的参数（name）值 | \- 支持如下字符集：a-z、A-Z、 0-9、_、 - \- 最大长度限制 50 个字符 值 | 请自定义文件元数据参数的值（value） | \- 支持如下字符集：a-z、A-Z、 0-9、-、 .、 >、+、 ?、 _、 =、 @、 ^ 、 [、 ]、\、 空格 \- 最大长度限制 200 个字符 _注：_ _\- 自定义元数据，在 Header 中返回时均会冠以 x-qn-meta 的前缀。例如，name: value 的元数据，会以 x-qn-meta- name: value 在 Header 中返回。_ _\- 您可以添加多条自定义元数据，但所有的自定义元数据总大小不能超过 1KB。_ 6. 单击**保存** ，完成元数据定义。 以上内容是否对您有帮助？

下载文件

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [控制台指南](https://developer.qiniu.com/kodo/development_guidelines/8452/kodo- console-guide) > [文件管理](https://developer.qiniu.com/kodo/development_guidelines/8561/file- management) > 下载文件 # 下载文件 最近更新时间: 2024-07-12 10:26:34 您可以在对象存储 Kodo 控制台，对空间（Bucket）中的已有文件（Object）进行下载操作。 Kodo 控制台支持您下载单个或批量文件，下载后文件将保存至浏览器默认路径。 # **说明** * 对于归档、深度归档存储类型的文件，需要确认文件已“解冻”完成才能对其进行下载，详情请见[解冻文件](https://developer.qiniu.com/kodo/development_guidelines/8573/thaw-file-storage)。 * 更多下载详情，请参考[下载资源](https://developer.qiniu.com/kodo/development_guidelines/1232/download-process)。 # **操作步骤** 1. 登录 Kodo 控制台进入[空间管理 __](https://portal.qiniu.com/kodo/bucket)界面，在空间列表中 2. 单击**目标空间名称** ，单击**文件管理** 进入文件管理界面 3. 文件管理界面下方显示了当前空间的文件列表，如图1:文件列表 图1:  ## **单个文件下载** 1. 鼠标移至目标文件栏的**更多** 如图1，以获取下拉菜单 2. 单击**下载** ## **批量文件下载** 1. 单击**文件名前的选择框** ，勾选或全选文件列表中所需的目标文件 2. 鼠标移至**批量操作** 以获取下拉菜单如图1 3. 单击**下载** ，完成批量下载 _注：需要在浏览器设置允许打开新弹出窗口，[了解详情 __](https://developer.qiniu.com/kodo/kb/1336/upload-download- instructions#batchdownload)_ 以上内容是否对您有帮助？

分享文件

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [控制台指南](https://developer.qiniu.com/kodo/development_guidelines/8452/kodo- console-guide) > [文件管理](https://developer.qiniu.com/kodo/development_guidelines/8561/file- management) > 分享文件 # 分享文件 最近更新时间: 2024-07-12 10:26:46 您可以通过文件 URL 将存储在空间（Bucket）中的文件（Object），分享给第三方预览或下载。 Kodo 控制台支持您复制分享单个文件外链或批量导出文件外链。 # **说明** * 公开空间中的文件可以直接分享外链，私有空间中的文件需分享携带有效时长的签名链接。 * 当开启原始资源保护时，不支持直接分享文件公开外链，仅支持分享带签名或样式文件外链。详情请见[设置原始资源保护](https://developer.qiniu.com/kodo/development_guidelines/8560/set-the-original-protection)。 * 对于归档、深度归档存储类型的文件，需要确认文件已“解冻”完成才能成功对其进行分享，具详情请见[解冻文件](https://developer.qiniu.com/kodo/development_guidelines/8573/thaw-file-storage)。 # **操作步骤** 1. 登录 Kodo 控制台进入[空间管理 __](https://portal.qiniu.com/kodo/bucket)界面，在空间列表中 2. 单击**目标空间名称** ，单击**文件管理** 进入文件管理界面 3. 文件管理界面下方显示了当前空间的文件列表，如图1:文件列表 图1:  ## **单个文件分享** 1. 鼠标移至目标文件栏的**更多** 如图1，以获取下拉菜单 2. 单击**复制外链** 3. 将文件 URL 分享给第三方预览或下载 ## **批量文件分享** 1. 单击**文件名前的选择框** ，勾选或全选文件列表中所需的目标文件 2. 鼠标移至**批量操作** 以获取下拉菜单如图1 3. 单击**导出 URL** ，完成外链批量导出至 Excel 文件 _注：该文件包含 Object 及对应的 URL，并将保存至浏览器默认路径_ 4. 将文件 URL 分享给第三方预览或下载。 ## **单个文件带样式分享** 1. 标准存储、低频存储和归档直读存储类型的图片文件，鼠标移至目标文件栏的**更多** 以获取下拉菜单，如图2，单击**图片样式** 的**获取样式链接** 图2:  2. 打开获取样式链接弹窗，如图3。选择指定**样式** 和**样式分隔符** ，即可获取对应外链。单击**复制** 即可复制该外链。 图3:  3. 您也可以从指定文件**更多** 操作中，单击**图片样式** 的**新建样式** ，在新建样式后直接获取带该样式的文件链接，如图4。单击**复制** 即可复制该外链。 图4:  以上内容是否对您有帮助？

分享目录

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [控制台指南](https://developer.qiniu.com/kodo/development_guidelines/8452/kodo- console-guide) > [文件管理](https://developer.qiniu.com/kodo/development_guidelines/8561/file- management) > 分享目录 # 分享目录 最近更新时间: 2024-07-24 14:40:13 您可以通过 Kodo 控制台分享存储在空间（Bucket）中的目录，分享目录即可直接将目录下的所有文件分享给第三方预览或下载。 # **说明** * 仅支持对自有空间中的目录进行分享 * 仅支持在显示目录的模式下才可操作分享 * 对于归档、深度归档存储类型的文件，需要确认文件已“解冻”完成才能成功对其进行分享，具详情请见[解冻文件](https://developer.qiniu.com/kodo/development_guidelines/8573/thaw-file-storage)。 # **操作步骤** 1. 登录 Kodo 控制台进入[空间管理 __](https://portal.qiniu.com/kodo/bucket)界面，在空间列表中 2. 单击**目标空间名称** ，单击**文件管理** 进入文件管理界面 3. 在目录模式下，单击指定目录操作栏的**分享** 4. 将出现如图1的目录分享弹窗，指定分享链接的有效时间、支持设置的范围为1分钟～2小时。您可以选择自动生成提取码或指定自定义提取码，单击**确定** 获取分享链接 图1：  5. 文件夹分享链接如图2，单击**复制链接和提取码** 将 URL 和提取码复制到粘贴板，请注意及时粘贴保存 图2:  6. 在浏览器中，打开此目录分享 URL 链接，即可获得如图3的文件提取页面，输入提取码后单击**提取文件** 图3:  7. 目录分享界面如图4，第三方即可在目录分享链接有效时长内，下载该目录下的所有文件 图4:  以上内容是否对您有帮助？

刷新 CDN 缓存

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [控制台指南](https://developer.qiniu.com/kodo/development_guidelines/8452/kodo- console-guide) > [文件管理](https://developer.qiniu.com/kodo/development_guidelines/8561/file- management) > 刷新 CDN 缓存 # 刷新 CDN 缓存 最近更新时间: 2024-07-12 10:27:12 您可以直接通过对象存储 Kodo 控制台刷新文件外链的 CDN 缓存，将缓存在 CDN 节点上对应的文件进行清除，以确保获取到最新的外链内容。 Kodo 控制台支持您对单个或批量文件刷新 CDN 缓存。 # **说明** * 该功能仅对使用 CDN 域名的文件外链支持。 * 每天缓存刷新额度 500 个，支持在控制台操作刷新时查看剩余额度。 # **操作步骤** 1. 登录 Kodo 控制台进入[空间管理 __](https://portal.qiniu.com/kodo/bucket)界面，在空间列表中 2. 单击**目标空间名称** ，单击**文件管理** 进入文件管理界面 3. 文件管理界面下方显示了当前空间的文件列表，如图1:文件列表 图1:  ## **刷新单个文件的 CDN 缓存** 1. 鼠标移至目标文件栏的**更多** 如图1，以获取下拉菜单 2. 单击**刷新 CDN 缓存** 3. 您也可以进入单个文件的**详情** 中，如图2，单击**刷新 CDN 缓存** 如图2: 详情-刷新 CDN 缓存  4. 单击使用功能后，将出现如图3的确认弹窗 图3：单个文件刷新 CDN 缓存  5. 如展示的刷新链接不预期，您可单击**编辑** 自定义该链接，后单击**确定** 提交刷新请求，或单击**取消** 返回文件列表。 6. 您也可单击**点击查看刷新记录** 跳转至 CDN 刷新界面查看刷新记录。 ## **批量刷新 CDN 缓存** 1. 单击**文件名前的选择框** ，勾选或全选文件列表中所需的目标文件 2. 鼠标移至**批量操作** 以获取下拉菜单如图1 3. 单击**刷新 CDN 缓存** ，完成文件 CDN 缓存的批量刷新 4. 单击使用功能后，将出现如图4的确认弹窗 图4：批量刷新 CDN 缓存  5. 如展示的刷新链接不预期，您可单击**编辑** 自定义该链接，后单击**确定** 提交刷新请求，或单击**取消** 返回文件列表。 6. 确定提交后，如图5，将展示请求结果 图5:  7.您也可单击**点击查看刷新记录** 跳转至 CDN 刷新界面查看刷新记录。 以上内容是否对您有帮助？

移动文件

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [控制台指南](https://developer.qiniu.com/kodo/development_guidelines/8452/kodo- console-guide) > [文件管理](https://developer.qiniu.com/kodo/development_guidelines/8561/file- management) > 移动文件 # 移动文件 最近更新时间: 2024-07-12 10:27:36 对象存储 Kodo 支持您将空间（Bucket）中的文件（Object）移动并粘贴到指定目录下。您可以通过此移动、粘贴功能，实现文件目录的更改。 # **说明** * 支持跨空间、不支持跨区域粘贴。 * 目标位置与源文件所在位置相同时，不支持粘贴。 * 不支持覆盖粘贴。若您所选的目标目录下有同名文件，则会粘贴失败。 * 移动、粘贴前后，文件的存储类型保持不变。归档、深度归档存储类型的文件，需要确认文件已“解冻”完成才能粘贴，详情请见[解冻文件](https://developer.qiniu.com/kodo/development_guidelines/8573/thaw-file-storage)。已解冻的文件，在粘贴后，将再次恢复冷冻。 * 仅在完成粘贴或取消粘贴后，可继续选择文件进行移动。 # **操作步骤** 1. 登录 Kodo 控制台进入[空间管理 __](https://portal.qiniu.com/kodo/bucket)界面，在空间列表中 2. 单击**目标空间名称** ，单击**文件管理** 进入文件管理界面 3. 在文件列表，单击**文件名前的选择框** ，单选或多选所需的目标文件 4. 鼠标移至批量操作以获取下拉菜单如图1 图1:  5. 单击**批量移动** 后，将出现如图2的粘贴选项 图2：  6. 您可进入到指定目录下，单击**粘贴** 完成文件的移动 7. 或单击**x** ，取消本次移动任务 以上内容是否对您有帮助？

删除文件

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [控制台指南](https://developer.qiniu.com/kodo/development_guidelines/8452/kodo- console-guide) > [文件管理](https://developer.qiniu.com/kodo/development_guidelines/8561/file- management) > 删除文件 # 删除文件 最近更新时间: 2024-07-12 10:27:59 您可以在对象存储 Kodo 控制台，删除存储桶中的已有文件。 Kodo 控制台支持您单个或批量删除文件。 # **说明** * 低频、归档和深度归档存储类型的文件最小计量 64KB，若将小于 64KB 的此类型文件删除则按 64KB 计，详情请见[存储类型](https://developer.qiniu.com/kodo/product_introduction/3956/kodo-category)。 * 提前删除低频（最少需存储 30 天）、归档（最少需存储 60 天）和深度归档（最少需存储 180 天）存储类型的文件，将生成提前删除量并产生对应费用，详情请见[统计分析](https://developer.qiniu.com/kodo/development_guidelines/8531/statistical-analysis)和[计量项与计费项](https://developer.qiniu.com/kodo/buying_guide/6379/metering-and-billing)。 # **操作步骤** 1. 登录 Kodo 控制台进入[空间管理 __](https://portal.qiniu.com/kodo/bucket)界面，在空间列表中 2. 单击**目标空间名称** ，单击**文件管理** 进入文件管理界面 3. 文件管理界面下方显示了当前空间的文件列表，如图1:文件列表 图1:  ## **删除单个文件** 1. 鼠标移至目标文件栏的**更多** 如图1，以获取下拉菜单 2. 单击**删除** ## **删除批量文件** 1. 单击**文件名前的选择框** ，勾选或全选文件列表中所需的目标文件 2. 鼠标移至**批量操作** 以获取下拉菜单如图1 3. 单击**删除文件** ，完成批量删除 以上内容是否对您有帮助？

删除目录

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [控制台指南](https://developer.qiniu.com/kodo/development_guidelines/8452/kodo- console-guide) > [文件管理](https://developer.qiniu.com/kodo/development_guidelines/8561/file- management) > 删除目录 # 删除目录 最近更新时间: 2024-07-12 10:28:15 您可以在对象存储 Kodo 控制台，删除空间（Bucket）中的已有非空目录。 # **说明** * 仅支持删除空目录；需清空目录再删除。 # **操作步骤** 1. 登录 Kodo 控制台进入[空间管理 __](https://portal.qiniu.com/kodo/bucket)界面，在空间列表中 2. 单击**目标空间名称** ，单击**文件管理** 进入文件管理界面 3. 在指定目录的操作栏中，单击**删除** 4. 界面出现如图1的确认弹窗 图1:  5. 单击**删除** ，完成删除目录 以上内容是否对您有帮助？

修改文件存储类型

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [控制台指南](https://developer.qiniu.com/kodo/development_guidelines/8452/kodo- console-guide) > [文件管理](https://developer.qiniu.com/kodo/development_guidelines/8561/file- management) > 修改文件存储类型 # 修改文件存储类型 最近更新时间: 2024-08-12 15:28:40 您可以通过对象存储 Kodo 控制台，修改已上传文件的存储类型，以满足不同场景的业务需求。 对象存储 Kodo 提供多种存储类型：标准存储、低频存储、智能分层存储、归档直读存储、归档存储和深度归档存储，详情请见[存储类型](https://developer.qiniu.com/kodo/product_introduction/3956/kodo- category)。 # **说明** * 对于归档、深度归档存储类型的文件，需要确认文件已“解冻”完成才能修改文件存储类型，详情请见[解冻文件](https://developer.qiniu.com/kodo/development_guidelines/8573/thaw-file-storage)。 * 低频、归档和深度归档存储类型的文件最小计量 64KB，若将小于 64KB 的文件转为此类型存储则按 64KB 计，且须满足指定存储天数（低频文件最少需保存 30 天、归档直读存储最少需保存 60 天、归档文件最少需保存 60 天、深度归档文件最少需保存 180 天），详情请见[存储类型](https://developer.qiniu.com/kodo/product_introduction/3956/kodo-category)。 * 若修改低频、归档直读、归档和深度归档存储文件为其他存储类型时，存储时间未满上述指定最少天数的，将生成提前删除量并产生对应费用，详情请见[统计分析](https://developer.qiniu.com/kodo/development_guidelines/8531/statistical-analysis)和[计量项与计费项](https://developer.qiniu.com/kodo/buying_guide/6379/metering-and-billing)。 # **操作步骤** 1. 登录 Kodo 控制台进入[空间管理 __](https://portal.qiniu.com/kodo/bucket)界面，在空间列表中 2. 单击**目标空间名称** ，单击**文件管理** 进入文件管理界面 3. 文件管理界面下方显示了当前空间的文件列表 4. 鼠标移至目标文件栏**更多** ，以获取下拉菜单 5. 单击**修改存储类型** ，出现如图1的弹窗 图1:  6. 选择您希望修改的存储类型后，单击**确定** 以上内容是否对您有帮助？

解冻文件

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [控制台指南](https://developer.qiniu.com/kodo/development_guidelines/8452/kodo- console-guide) > [文件管理](https://developer.qiniu.com/kodo/development_guidelines/8561/file- management) > 解冻文件 # 解冻文件 最近更新时间: 2024-07-12 10:28:38 如果您需要访问归档、深度归档存储类型的文件，必须先对文件进行解冻操作。 # **说明** * 归档存储解冻需要约 5 分钟，深度归档存储解冻需要约 12 小时，解冻成功后，文件变为解冻状态。解冻完成后也可选择修改文档存储类型，详情请见[修改文件存储类型](https://developer.qiniu.com/kodo/development_guidelines/8572/modify-the-file-storage-type)。 * 根据解冻文件的大小，实际解冻时间可能会有变化，请以实际解冻时间为准。 * 关于对象存储 Kodo 所支持的其他存储类型，详情请见[存储类型](https://developer.qiniu.com/kodo/product_introduction/3956/kodo-category)。 * 解冻文件会产生数据取回费用，详情请见[计量项与计费项](https://developer.qiniu.com/kodo/buying_guide/6379/metering-and-billing)。 # **操作步骤** 1. 登录 Kodo 控制台进入[空间管理 __](https://portal.qiniu.com/kodo/bucket)界面，在空间列表中 2. 单击**目标空间名称** ，单击**文件管理** 进入文件管理界面 3. 文件管理界面下方显示了当前空间的文件列表，如图1:文件列表 图1:  4. 找到您希望解冻的文件，鼠标移至该目标文件栏的**更多** ，以获取下拉菜单 5. 单击**解冻** ，右侧将出现如图2的解冻文件界面。 图2-1:解冻归档存储文件  图2-2:解冻深度归档存储文件  6. 设置您预计需要的解冻天数，单击**确定** ，完成解冻。 _注：文件默认解冻 1 天；可以设置解冻有效期最多 7 天，之后文件又回到冷冻状态。_ 以上内容是否对您有帮助？

任务中心

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [控制台指南](https://developer.qiniu.com/kodo/development_guidelines/8452/kodo- console-guide) > [文件管理](https://developer.qiniu.com/kodo/development_guidelines/8561/file- management) > 任务中心 # 任务中心 最近更新时间: 2022-04-26 10:31:22 对象存储 Kodo 支持您在控制台提交上传文件、移动粘贴文件任务后，在任务中心查看当前任务状态，并对任务进行管理。 # **说明** * 当前任务中心支持管理文件上传任务、文件粘贴任务，详情请参考[上传文件](https://developer.qiniu.com/kodo/development_guidelines/8562/upload-a-file)、[移动文件](https://developer.qiniu.com/kodo/development_guidelines/10578/move-files)。 * 首次提交任务后，出现任务中心。刷新页面或离开对象存储 Kodo 会终止所有任务并清空任务记录。 * 任务中心针对不同的任务类型，支持查看待处理、处理中、已停止、成功、失败以及全部状态。 * 支持停止上传中的文件、不支持停止移动粘贴中的文件。 * 任务已停止或已执行失败后，重试策略与提交任务时的策略一致。 # **操作步骤** 1. 在提交任务后，单击**任务中心** 浮标，即可进入任务中心查看当前任务进度，如图1。 图1:  2. 在任务中心，单击**文件上传** 或**文件移动** 切换到目标任务类型后，您可以进行以下操作： * 单击**全部停止** ，您可以暂停正在进行中的任务，包括待处理和处理中的文件。您也可以在目标文件栏单击**停止** ，停止单个任务。 * 单击**全部重试** ，您可以重试已停止或执行失败的任务。您也可以在目标文件栏单击**重试** ，重试单个任务。 * 单击**清空记录** ，您可以移除所有已结束（已停止、成功、失败）的任务记录。您也可以在目标文件栏单击**移除** ，移除单个任务。 3. 在文件上传任务类型中，针对上传成功的文件，单击**复制外链** 即可分享新上传的文件。 * 如需使用其他域名获取外链，请在空间中切换、选择域名。 4. 如在上传文件时，添加使用了转码样式，您可以在上传成功的文件查找并复制到对应的转码 ID。 以上内容是否对您有帮助？

设置跨区域同步

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [控制台指南](https://developer.qiniu.com/kodo/development_guidelines/8452/kodo- console-guide) > 设置跨区域同步 # 设置跨区域同步 最近更新时间: 2023-08-28 19:36:12 对象存储 Kodo 支持跨区域同步功能，将跨不同区域的存储空间（Bucket）之间自动、异步复制文件（Object），并将源存储空间的对象的改动（除删除操作）复制到不同区域的目标存储空间。 您可直接通过控制台设置跨区域同步任务，以保障您的业务需求。 # **说明** * 目前支持华东-浙江、华东-浙江2、华北-河北、华南-广东、北美-洛杉矶、亚太-新加坡存储区域的跨区域同步。 * 目前支持将指定空间的所有数据（暂不支持归档、深度归档存储类型），包括新增、更新操作（暂不支持删除操作）同步到另一个区域的目标空间。 * 在创建跨区域同步任务时，您可以选择是否将源存储空间的历史数据复制至目标存储空间。 * 源空间中的数据可以跨区域同步到多个目标空间。源空间可以在新的任务规则中被指定为目标空间，反之，目标空间也可以在新的任务规则中被指定为源空间。 * 更多关于跨区域同步的详情，请参考[跨区域同步](https://developer.qiniu.com/kodo/development_guidelines/8613/dev-cross-regional-synchronization)。 * 使用限制： * 同步任务的目标存储空间被删除后，源存储空间中新产生的文件改动，将不再被同步。 * 费用说明：计费详情请参考[七牛云官网价格 __](https://www.qiniu.com/prices/kodo) * 跨区域同步功能会产生存储量、流量和请求次数的费用。 * 文件同步后会在源空间和目标空间分别产生一份存储量费用。 * 跨区域同步产生的请求次数合并计入各存储类型的 PUT／DELETE 请求 和 GET 请求次数中，共享用户请求次数的免费额度，超出部分将按照七牛云官网价格中的 PUT／DELETE 请求 和 GET 请求单价进行计费。 # **操作步骤** 1. 登录 Kodo 控制台界面进入[跨区域同步 __](https://portal.qiniu.com/kodo/transfer)界面，展示如图1跨区域同步-同步任务列表， 图1:跨区域同步-同步任务列表 2\. 单击 **+创建任务** ，右侧将弹出如图2:创建任务界面如 图2: 创建任务  2. 在创建任务界面，按如下说明配置各项参数： 操作名称 | 说明 | 规则描述 ---|---|--- 同步任务名称 | 请自定义当前同步任务的名称 | \- 字母开头，4 ~ 63 个字符长 ，可包含 字母、数字、中划线 \- 不可重复命名 源存储区域 | 请按需选择需要同步的源存储空间所在区域 | \- 可选区域：华东-浙江、华东-浙江2、华北-河北、华南-广东、北美-洛杉矶、亚太-新加坡 \- 不支持相同区域的空间内容同步 源存储空间 | 请按需选择需要同步的源存储空间 | \- 选择下拉列表中已存在的空间 目标存储区域 | 请按需选择目标存储空间所在区域 | \- 可选区域：华东-浙江、华东-浙江2、华北-河北、华南-广东、北美-洛杉矶、亚太-新加坡 \- 不支持相同区域的空间内容同步 目标存储空间 | 请按需选择目标存储空间 | \- 如果目标存储空间为非空存储空间，在 Key 相同的情况下，文件会被覆盖。 同步范围 | 请按需选择同步范围 | \- 默认选择同步空间内所有文件 \- 支持同步指定前缀的文件 是否同步历史数据 | 请按需选择开启/关闭是否同步历史数据 | \- 若开启，会将源存储空间的数据同步到目标存储空间。 \- 若关闭，同步任务开启后，仅同步开启该功能时间点后的数据，历史数据不同步。 3. 单击**确定** ，完成创建跨域同步任务。 4. 新建同步任务成功后，您可在如图1：跨区域同步-同步任务列表，单击目标任务栏的**查看** ，即可查看该同步任务的详情信息，如图3。 图3:任务详情  5. 如图1，您可单击目标任务栏的**暂停/开始** ，暂停或重启该任务。 6. 如图1，您可单击目标任务栏的**删除** ，删除该任务。 以上内容是否对您有帮助？

统计分析

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [控制台指南](https://developer.qiniu.com/kodo/development_guidelines/8452/kodo- console-guide) > 统计分析 # 统计分析 最近更新时间: 2024-08-12 15:26:30 您可以在对象存储 Kodo 控制台统计分析界面查看您账户下所有已使用的资源，包括不同存储类型、区域、空间在自定义时间段（支持 2018-01-01 号及之后的时间）内的： * 存储量、提前删除量、智能监控文件数、文件数 * 空间流量：流出、流入、CDN 回源 * 空间带宽：流出、流入、CDN 回源 * API 请求：GET、PUT * 跨区域同步的流量、带宽 # **操作步骤** 1. 登录 Kodo 控制台界面进入[统计分析 __](https://portal.qiniu.com/kodo/dashboard/storage)界面，展示如图1 图1:  2. 如图1，展示了当前标准存储在全部区域全部空间的存储量、文件数，并以图表形式展现了近 7 天中每天的存储量 3. 单击**存储类型** ，获取下拉菜单，选择 **标准存储/低频存储/智能分层存储/归档直读存储/归档存储/深度归档存储** ，以显示不同存储类型的信息 （外网流入及跨区域同步栏无此分类） 4. 单击**区域** ，获取下拉菜单，选择 **全部/华东/华南/华北/北美/东南亚/华东-浙江2** ，以显示不同区域对应存储类型的信息（跨区域同步栏默认全部） 5. 单击**空间** ，获取下拉菜单，选择 **全部/其他自定义空间名** ，以显示对应区域下指定空间内指定存储类型的信息（跨区域同步栏默认全部） 6. 单击 **7天/15天/本月/上月/自选时间区间** ，以显示并在图表中查看指定日期区间内的相关信息 7. 单击**导出 CSV** ，即可导出对应图表中的数值 ## **查看存储量、文件数** 1. 单击 **存储** ，如图1 2. 在指定存储类型/区域/空间/时间范围内，单击选择**存储量** （时间单位为天），即查看当前存储量、文件数，及所选时间段内平均存储量、平均文件数和存储量变化图；仅针对**智能分层存储** ，提供**频繁访问层** 、**不频繁访问层** 、**归档直读层** ，分层查看存储容量。 3. 仅针对**低频存储** 或**归档直读存储** 或**归档存储** 或**深度归档存储** 类型，在指定区域/空间/时间范围内，单击选择**提前删除量** （时间单位为天），即查看所选时间段内累计的提前删除量； 4. 仅针对**智能分层存储** ，在指定区域/空间/时间范围内，单击选择**智能监控文件数（时间单位为天）** ，即可查看所选时间段内智能分层监控文件数量，小于 64KB 的智能分层对象，不会被监控，一直处于智能分层的频繁访问层； 5. 在指定存储类型/区域/空间/时间范围内，单击选择**上传文件数** （时间单位为天），即查看当日上传文件数，及所选时间段内平均上传文件数和上传文件数变化图。 ## **查看空间流量** 1. 单击 **空间流量** ，如图2 图2:  2. 在指定存储类型/区域/空间/时间范围内，单击切换选择**流出/CDN 回源** ，单击切换选择计算的时间粒度 **5分钟/小时/天** ，即可查看对应的当前累计访问总流量、平均流量和流量最大空间，及所选时间段内各空间累计的访问总流量变化图。 3. 在指定区域/空间/时间范围内，单击选择**流入** ，单击切换选择计算的时间粒度 **5分钟/小时/天** ，即可查看对应的当前累计访问总流量、平均流量和流量最大空间，及所选时间段内各空间累计的访问总流量变化图。 4. 如开启[传输加速](https://developer.qiniu.com/kodo/development_guidelines/12656/transfer-acceleration)，可在**流出/流入** 选项之后的**加速用量** 栏，单击切换选择计算的时间粒度 **5分钟/小时/天** ，即可查看对应的当前累计访问总流量、平均流量，及所选时间段内各空间累计的访问总流量变化图。如图3: 图3:  ## **查看空间带宽** 1. 单击 **空间带宽** ，如图4 图4:  2. 在指定存储类型/区域/空间/时间范围内，单击切换选择**流出/CDN 回源** ，单击切换选择计算的时间粒度 **5分钟/天** ，即可查看对应当前所选时间段内带宽峰值、出现时间（精确至所选时间粒度）和所属空间，及各空间带宽峰值的变化图（以 95 峰值为基准）。 3. 在指定区域/空间/时间范围内，单击选择**流入** ，单击切换选择计算的时间粒度 **5分钟/天** ，即可查看对应当前所选时间段内带宽峰值、出现时间（精确至所选时间粒度）和所属空间，及各空间带宽峰值的变化图（以 95 峰值为基准）。 _注：日带宽数据不支持堆叠展示_ ## **查看API请求** 1. 单击 **API 请求** ，如图5 图5:  2. 在指定存储类型/区域/空间/时间范围内，单击切换选择计算的时间粒度 **5分钟/小时/天** ，即可查看对应的当前所选时间段内 GET/PUT 请求总次数和平均次数，及 GET/PUT 请求总次数变化图。 ## **查看跨区域同步** 1. 单击 **跨区域同步** ，如图6 图6:  2. 在指定时间范围内，单击选择**流量** ，单击切换选择计算的时间粒度 **5分钟/天** ，即查看当前所选时间段内全部区域/空间的访问总流量、访问平均流量、和总流量变化图； 3. 在指定时间范围内，单击选择**带宽** ，单击切换选择计算的时间粒度 **5分钟/天** ，即查看当前所选时间段内国内/海外带宽峰值、出现时间和带宽峰值变化图； 以上内容是否对您有帮助？

存储安全

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [控制台指南](https://developer.qiniu.com/kodo/development_guidelines/8452/kodo- console-guide) > 存储安全 # 存储安全 最近更新时间: 2023-09-06 15:12:22 对象存储 Kodo 存储安全支持您对您空间中的数据进行合规监管。 Kodo 支持以下存储安全操作： * 内容审核：使用七牛云内容审核服务，进行空间级别的音图视频内容审核。 * 违规列表：基于法律法规要求的文件安全审核，七牛云合规团队将对违规文件进行处置。您可通过控制台查看和删除违规文件。 # **说明** * 为了更好地提升业务合规性、加强内容安全性，推荐您使用七牛云内容审核服务，主动对 Kodo 数据进行内容审核，对于违规文件及时冻结和管理。 # **操作步骤** * 您可以根据以下操作来进一步存储安全管理： 存储安全操作 --- [内容审核](https://developer.qiniu.com/kodo/development_guidelines/12547/content- detection) [违规列表](https://developer.qiniu.com/kodo/development_guidelines/12548/violation- list) 以上内容是否对您有帮助？

内容审核

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [控制台指南](https://developer.qiniu.com/kodo/development_guidelines/8452/kodo- console-guide) > [存储安全](https://developer.qiniu.com/kodo/development_guidelines/12546/object- storage-safety) > 内容审核 # 内容审核 最近更新时间: 2023-09-06 15:23:25 对象存储 Kodo 支持针对存储用户，提供一键式的图片、音频、视频内容审核服务。 您可以将保存在七牛云存储中的存量、增量数据进行鉴黄、鉴暴恐、政治敏感人物识别等内容审核服务，对违规数据提供自动封禁功能。提供审核结果的自助复核功能，用户可以对图片、视频进行删除、封禁和通过等操作。 # **说明** * 更多空间内容审核概念介绍，请参考[什么是内容审核 __](https://developer.qiniu.com/censor/4829/censor-introduction)。 * 内容审核可能导致的相关费用，请参考[内容审核产品价格 __](https://developer.qiniu.com/censor/4833/censor-price)。 # **操作步骤** 1.登录 Kodo 控制台进入[空间管理 __](https://portal.qiniu.com/kodo/bucket)界面 2\. 单击存储安全栏下的**内容审核** 进入内容审核界面，如图1。您可点击**增量审核** 或**存量审核** ，切换查询的任务类型。 图1：  3\. 如您在增量审核页面，您可在列表中查看到当前所有已设置的空间增量审核任务及其状态。如图2，将鼠标移动至目标任务栏的**查看** 时，将展示该任务详情。 图2:  4\. 在图1中，在目标任务栏单击**管理** ，将跳转至内容审核-增量审核界面，如图3。您可在此页面进一步管理该任务。 图3:  5\. 在图1中，单击**新建任务** ，将快捷跳转至新建增量任务界面，如图4。请参考 [存量审核 __](https://developer.qiniu.io/censor/8067/censor-portal-batch)完成新建存量审核任务。 图4:  6\. 如您切换至存量审核页面，相关操作也可参考上述步骤2-4。 以上内容是否对您有帮助？

违规列表

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [控制台指南](https://developer.qiniu.com/kodo/development_guidelines/8452/kodo- console-guide) > [存储安全](https://developer.qiniu.com/kodo/development_guidelines/12546/object- storage-safety) > 违规列表 # 违规列表 最近更新时间: 2023-09-18 14:25:39 对于存储在七牛云对象存储 Kodo 中的内容，需要符合相关法律法规要求。如您空间中存在违规文件，七牛云合规团队将对其进行处置。 如您有已被处置的违规内容，您将收到七牛云发出的违规邮件通知，您可通过 Kodo 控制台进行查看和删除。在 Kodo 控制台违规列表中，您可查看到违规文件 URL 及该文件所属空间、处置时间等信息。您可以在违规列表直接删除违规文件 URL，删除违规文件 URL 将直接删除违规记录及对应文件。 # **说明** * 此列表仅展示自 2023 年 9 月 18 日功能上线起，您空间中被处置的违规文件 URL。 # **操作步骤** 1.登录 Kodo 控制台进入[空间管理 __](https://portal.qiniu.com/kodo/bucket)界面 2\. 单击存储安全栏下的**违规列表** 进入违规列表界面，如图5。此列表展示了您存储空间中所有违规文件的 URL，支持您按时间范围查询。 图5:  3\. 您可在目标栏单击**删除** 或选择多个目标文件 URL 后单击**批量删除** ，进行违规文件 URL 的清理。 _注：删除违规文件 URL 将直接删除违规记录及对应文件。_ 以上内容是否对您有帮助？

设置数据迁移

[对象存储](https://developer.qiniu.com/kodo) > 使用指南 > [控制台指南](https://developer.qiniu.com/kodo/development_guidelines/8452/kodo- console-guide) > 设置数据迁移 # 设置数据迁移 最近更新时间: 2024-08-12 15:38:03 对象存储 Kodo 提供的数据迁移服务，支持您将第三方数据源轻松迁移至七牛云对象存储 Kodo。当前 Kodo 提供的数据迁移服务是全托管模式的在线迁移服务，用户只需提交迁移任务、服务会自动执行数据迁移，并提供迁移执行状态和进度的信息查询、支持限速控制。 您可通过控制台设置数据迁移任务，或查看[数据迁移最佳实践](https://developer.qiniu.com/kodo/best_practices/12660/data- migration)了解其他数据迁移方案。 # **说明** * 当前已支持的数据源：URL 列表、S3 协议源站 * 当前仅支持的迁移模式：全托管迁移 * 费用： * 全托管迁移模式中，从第三方源对象存储拉取数据会产生公网出流量费用，具体费用需要参考源存储云厂商的定价 * 数据迁移在上传期间会产生 PUT/DELETE 请求次数，成功上传到 Kodo 后会产生存储费用 * 数据校验：校验成功的文件才算迁移成功 * 默认校验源端和目标端的文件数据大小 * 如果源文件头信息携带有 Content-Md5（大小写敏感），则会校验源端和目标端信息是否一致 * 使用限制： * 单个用户只允许同时执行 5 个迁移任务，即状态为迁移中的任务最多 5 个 * 单个任务默认带宽限额 500Mbps，支持用户自定义设置带宽限额、允许设置的范围为 10Mbps~2Gbps # **操作步骤** 1. 登录 Kodo 控制台界面进入[数据迁移 __](https://portal.qiniu.com/kodo/data-migration)界面，如图1 图1:  2. 单击 **+新建任务** ，右侧将弹出如图2: 图2:  3. 在新建任务界面，按如下说明配置各项参数： **任务基础信息** 操作名称 | 必填 | 说明 | 规则描述 ---|---|---|--- 任务名称 | 是 | 请自定义数据迁移任务的名称 | \- 任务名称由 1 ~ 64 个字符组成，可包含：字母、数字和下划线 \- 任务名称不可重复 **迁移源信息** 操作名称 | 必填 | 说明 | 规则描述 ---|---|---|--- 数据源类型 | 是 | 请按需选择迁移数据源的类型 | 可选类型：URL 列表、S3 协议源站 URL 文件列表 | 是 | 指定需要迁移的文件 URL 列表 | \- 仅当数据源类型为 URL 列表时必须定义 \- 提供一个文本文件列表 URL，其中包含需要迁移的文件访问链接（URL），每一行是一个要迁移的文件 URL。例如新建一个文本文件“urls.txt”，文件中包含两个要迁移的 URL 地址： http://xxx.xxx.xxx/xxx/l.jpg http://xxx.xxx.xxx/xxx/xxx/xxxxxx/test.mp4 \- 待迁移文件 http 地址`带有特殊字符`的需要做 `url encode 编码处理` AccessKey | 是 | 请输入 S3 协议源站的 AccessKey | 仅当数据源类型为 S3 协议源站时必须定义 SecretKey | 是 | 请输入 S3 协议源站的 SecretKey | 仅当数据源类型为 S3 协议源站时必须定义 空间名称 | 是 | 请输入的迁移源空间名称 | \- 仅当数据源类型为 S3 协议源站时必须定义 \- 如源端为七牛 S3 协议源站时，存在空间名不唯一、系统自动生成 S3 空间名的情况，可参考[获取七牛 S3 空间名 __](https://developer.qiniu.com/kodo/4088/s3-access-domainname#3)查询 源端区域 | 是 | 请输入的迁移源空间所在区域 | \- 仅当数据源类型为 S3 协议源站时必须定义 \- 仅以下述示例： * 如源端为 AWS S3，区域可为 us-east-2，参考更多 [AWS S3 区域 __](https://docs.aws.amazon.com/general/latest/gr/s3.html) * 如源端为阿里云 OSS，区域可为 oss-cn-beijing，参考更多[阿里云 OSS 区域 __](https://help.aliyun.com/zh/oss/user-guide/regions-and-endpoints?spm=a2c4g.11186623.0.0.59a41668i9yalr) 区域 Endpoint | 是 | 请输入的迁移源空间所在区域的 Endpoint | \- 仅当数据源类型为 S3 协议源站时必须定义 \- 需指定 http(s) 协议，不带协议时默认为 https \- `无需携带空间名称，否则会导致源端连接失败` \- 仅以下述示例： * 如源端为 AWS S3，区域 Endpoint 可为 https://s3.us-east-2.amazonaws.com，更多参考 [S3 Endpoint __](https://docs.aws.amazon.com/general/latest/gr/s3.html) * 如源端为阿里云 OSS，区域 Endpoint 可为 https://oss-cn-beijing.aliyuncs.com，更多参考[阿里云 OSS Endpoint __](https://help.aliyun.com/zh/oss/user-guide/regions-and-endpoints?spm=a2c4g.11186623.0.0.59a41668i9yalr) 文件名过滤 | 否 | 请按需选择数据迁移范围 | \- 仅当数据源类型为 S3 协议源站时可定义 \- 默认不过滤，迁移源空间内的全量文件 \- 支持只迁移前缀匹配的文件 时间范围 | 否 | 请按需选择仅迁移指定时间范围内新增或变更的文件 | \- 仅当数据源类型为 S3 协议源站时可定义 \- 默认不勾选指定时间范围 \- 支持勾选指定时间范围 * 开始时间零点⾄结束时间零点 * 所选时间段时区为东八区 UTC+8 **迁移目标信息** 操作名称 | 必填 | 说明 | 规则描述 ---|---|---|--- 空间名称 | 是 | 请输入的迁移目标空间名称 | \- 为成功迁移需授予服务上传权限，默认勾选“我已知晓、并授予迁移服务在任务执行期间向该空间上传文件的权限。” \- 支持输入完整空间名，或搜索目标空间 \- 只读空间不可写入，不支持选择只读空间 保存路径 | 否 | 请指定所迁移的数据保存到的位置 | \- 默认保存到根路径，将数据以源文件名保存在根目录 \- 保存到指定目录，支持指定文件前缀（例如: aaa）或以 / 结尾指定目录（例如: aaa/bbb/） 同名文件 | 否 | 请指定迁移时对同名文件的处理方式 | \- 默认覆盖，将源空间中的文件替换目标空间中的同名文件 \- 跳过，将保留目标空间中已有的同名文件 \- 新文件覆盖，如源空间中文件的最后修改时间大于目标空间中的同名文件，则执行覆盖 文件存储类型 | 否 | 请按需指定文件迁移到目标空间后的存储类型 | \- 与源文件一致，仅当数据源类型为 S3 协议源站时可定义 * 查看 S3 存储类型与七牛存储类型对应关系 * 源文件没有可识别的存储类型（如：无存储类型信息、无 Kodo 可对应的存储类型）时，将默认迁移至标准存储类型。 \- 默认为全部使用标准存储 \- 支持指定为全部使用标准存储、全部使用低频存储、全部使用智能分层存储、全部使用归档直读存储、全部使用归档存储、全部使用深度归档存储 **迁移执行参数** 操作名称 | 必填 | 说明 | 规则描述 ---|---|---|--- 迁移模式 | 是 | 请选择迁移模式 | \- 当前默认且仅支持新建迁移任务后立即启动全托管迁移 迁移限速 | 否 | 请按需指定迁移限速方式 | \- 默认不设置限速 \- 开启设置限速 * 支持全时段统一限速，默认 500Mbps * 支持分时段限速，当迁移周期时间跨度较大时，使用分时段限速可以利用波谷加速迁移在波峰降低速度或停止、以便保障业务和控制成本。 * 支持在选择指定时间段内限速（限额范围 10Mbps~2000Mbps）或不限速 * 所选时间段时区为东八区 UTC+8 _注：当前默认只迁移源文件的 Content-Type 信息_ 4. 完成上述参数配置后，勾选“我已了解可能的迁移时间以及可能产生的相关成本”，单击**确定** 完成新建数据迁移任务。 5. 如图1已创建的任务将以卡片的形式展示，此界面按任务状态、迁移源或任务名称进行筛选展示，您也可指定按任务的创建时间先后进行排序。仅支持查看距完成时间 180 天内的任务，超时后任务记录将被删除。 6. 在单个任务卡片中，您可查看到下述信息： * 任务 ID * 状态，包括：已创建、迁移中、迁移完成有失败文件、迁移完成无失败文件、已终止、迁移失败 * 迁移目标位置，为数据指定迁移的空间及保存路径 * 迁移源，包括：URL 列表、S3 协议源站 * 迁移统计，展示已迁移文件数/文件大小、失败文件数、进度 * 已迁移文件数 = 迁移成功文件数 + 已跳过文件数 * 进度 = (已迁移文件数 ＋ 失败文件数) / 迁移文件总数 * 迁移文件总数末知（文件列表未列举完毕）时进度不显示 * 创建时间，为任务创建时间 7. 您可在如图1的任务列表中，找到指定任务，单击目标任务栏的**任务名称** ，即可查看该数据迁移任务的规则信息，如图3。 图3:任务规则信息  8. 对不同状态的任务，您可执行下述操作 状态 | 可执行的操作 | 操作说明 ---|---|--- 已创建/迁移中 | 终止、编辑 | \- 终止任务，无法再次重启 \- 编辑任务，仅支持修改任务开启限速或变更限速值 已终止/迁移完成且无失败文件/迁移失败 | 删除 | 删除该条任务记录 迁移完成且有失败文件 | 重试、导出失败列表、删除 | \- 重试，重试迁移失败文件列表 * 限定任务完成 30 天内可操作 \- 导出失败列表，支持获取迁移失败文件列表链接（链接有效时长 60 分钟）或导出迁移失败文件列表 * 限定任务完成 30 天内可操作 * 失败文件列表支持最多含 10 万条数据，如超出需[提交工单 __](https://support.qiniu.com/tickets/category)请求后台导出 \- 删除该条任务记录 当迁移过程中出现失败文件时，您可单击**查看失败列表** 在弹窗中实时查看迁移失败的文件、失败时间及原因 * 支持单击**加载更多** 获取完整失败文件列表 * 支持单击**下载** 导出已加载的失败文件列表 * 限定任务完成 30 天内可操作 9. 对任意状态的任务，均支持您单击**详情** 查看当前任务进展状态，或单击**复制** 进行任务快速创建。其中详情展示下述信息： * 任务执行节点及对应时间 * 如迁移失败，展示失败信息 * 迁移统计信息 * 失败/成功/跳过/待迁移文件数 * 已迁移数据量 * 进度 # S3 存储类型与七牛存储类型对应关系 AWS S3 | 七牛云存储 ---|--- STANDARD REDUCED_REDUNDANCY OUTPOSTS | 标准存储 STANDARD_IA ONEZONE_IA | 低频访问存储 INTELLIGENT_TIERING | 智能分层存储 GLACIER_IA | 归档直读存储 GLACIER | 归档存储 DEEP_ARCHIVE | 深度归档存储 以上内容是否对您有帮助？

API 概览

[对象存储](https://developer.qiniu.com/kodo) > API 文档 > API 概览 # API 概览 最近更新时间: 2023-12-25 12:07:37 # **Service API** 接口 | 说明 ---|--- [buckets](https://developer.qiniu.com/kodo/api/3926/get-service) | 列举请求者拥有的所有 Bucket # **Bucket API** 接口 | 说明 ---|--- [mkbucketv3](https://developer.qiniu.com/kodo/api/1382/mkbucketv3) | 创建新的存储空间 [drop](https://developer.qiniu.com/kodo/api/1601/drop-bucket) | 删除指定存储空间 [domains](https://developer.qiniu.com/kodo/api/3949/get-the-bucket-space-domain) | 获取一个空间绑定的所有域名列表 [image](https://developer.qiniu.com/kodo/api/3966/bucket-image-source) | 为存储空间指定一个镜像回源网址，用于取回资源 [private](https://developer.qiniu.com/kodo/api/3946/set-bucket-private) | 设置空间访问权限 [putBucketTagging](https://developer.qiniu.com/kodo/api/6314/put-bucket-tagging) | 设置空间标签 [getBucketTagging](https://developer.qiniu.com/kodo/api/6315/get-bucket-tagging) | 查询空间标签 [deleteBucketTagging](https://developer.qiniu.com/kodo/api/6316/delete-bucket-tagging) | 删除空间标签 # **Object API** 接口 | 说明 ---|--- [upload](https://developer.qiniu.com/kodo/api/1312/upload) | 用于在一次 HTTP 会话中上传单一的一个对象 [mkblk](https://developer.qiniu.com/kodo/api/1286/mkblk) | 为后续分片上传创建一个新的块，同时上传第一片数据 [bput](https://developer.qiniu.com/kodo/api/1251/bput) | 上传指定块的一片数据，具体数据量可根据现场环境调整，同一块的每片数据必须串行上传 [mkfile](https://developer.qiniu.com/kodo/api/1287/mkfile) | 将上传好的所有数据块按指定顺序合并成一个对象资源 [initiateMultipartUpload](https://developer.qiniu.com/kodo/api/6365/initialize-multipartupload) | 通知服务端开启分块上传任务,得到全局唯一任务UploadId [uploadPart](https://developer.qiniu.com/kodo/api/6366/upload-part) | 分块上传数据，需指定的任务UploadId [completeMultipartUpload](https://developer.qiniu.com/kodo/api/6368/complete-multipart-upload) | 完成整个对象的分块上传，需指定的任务UploadId [abortMultipartUpload](https://developer.qiniu.com/kodo/api/6367/abort-multipart-upload) | 中止分块上传任务，并且删除已经上传的块，需指定的任务UploadId [listParts](https://developer.qiniu.com/kodo/api/6858/listparts) | 列举指定 UploadId 所属的所有已经上传成功Part [list](https://developer.qiniu.com/kodo/api/1284/list) | 用于列举指定空间里的所有对象条目 [stat](https://developer.qiniu.com/kodo/api/1308/stat) | 仅获取对象的 Metadata 信息，不返回对象内容 [chgm](https://developer.qiniu.com/kodo/api/1252/chgm) | 修改对象的 MIME 类型信息 [move](https://developer.qiniu.com/kodo/api/1288/move) | 将源空间的指定对象移动到目标空间，或在同一空间内对对象重命名 [copy](https://developer.qiniu.com/kodo/api/1254/copy) | 将指定对象复制为新命名对象 [delete](https://developer.qiniu.com/kodo/api/1257/delete) | 删除指定对象 [batch](https://developer.qiniu.com/kodo/api/1250/batch) | 指在单一请求中执行多次获取元信息、移动、复制、删除操作，极大提高对象管理效率 [chstatus](https://developer.qiniu.com/kodo/api/4173/modify-the-file-status) | 修改对象的存储状态，即切换启用、禁用状态 [chtype](https://developer.qiniu.com/kodo/api/3710/chtype) | 修改对象的存储类型信息，即标准存储、低频存储、归档直读存储等不同存储类型之间的互相转换 [restoreAr](https://developer.qiniu.com/kodo/api/6380/restore-archive) | 解冻归档存储类型的对象 [deleteAfterDays](https://developer.qiniu.com/kodo/api/1732/update-file-lifecycle) | 设置一个对象多少天后过期删除 [lifecycle](https://developer.qiniu.com/kodo/api/8062/modify-object-life-cycle) | 修改已上传对象的生命周期，即修改对象转低频时间、转归档直读事件、转归档时间、转深度归档时间和过期删除时间 [prefetch](https://developer.qiniu.com/kodo/api/1293/prefetch) | 对于设置了镜像存储的空间，从镜像源站抓取指定名称的对象并存储到该空间中 [sisyphus/fetch](https://developer.qiniu.com/kodo/api/4097/asynch-fetch) | 从指定 URL 抓取对象，并将该对象存储到指定空间中。每次只抓取一个对象，抓取时可以指定保存空间名和最终对象名 以上内容是否对您有帮助？

HTTP Headers

[对象存储](https://developer.qiniu.com/kodo) > API 文档 > HTTP Headers # HTTP Headers 最近更新时间: 2022-11-29 17:52:08 HTTP header | 描述 | 类型 ---|---|--- Authorization | 用于验证请求合法性的认证信息。该头部应严格按照[管理凭证](https://developer.qiniu.com/kodo/manual/1201/access-token)或[上传凭证](https://developer.qiniu.com/kodo/manual/1208/upload-token)格式进行填充，否则会返回 401 错误码。例如`Authorization: Qiniu j853F3bLkWl59I5BOkWm6q1Z1 ...`或`Authorization: UpToken QNJi_bYJlmO5LeY08FfoNj9w_r...`。 | 请求头 Content-Length | 请求或响应内容长度，单位`字节`。例如`Content-Length: 299`。 | 请求头、响应头 Content-Type | 请求或响应内容的 MIME 类型。例如`Content-Type: application/json`。 | 请求头、响应头 Host | 上传服务器域名。例如`Host: rsf-z0.qiniuapi.com`。 | 请求头 Connection | 标明客户端与服务器之间的通信状态。例如`Connection: keep-alive`。 | 请求头、响应头 Date | 服务器端响应时间。例如`Date: Wed, 22 Nov 2017 01:52:39 GMT`。 | 响应头 X-Qiniu-Date | 生成请求的时间，ISO 8601 格式 UTC 时间，形如 `yyyyMMddTHHmmssZ`，例如 `20060102T150405Z`。如果请求中的 X-Qiniu-Date 时间和七牛服务器的当前时间差 15 分钟以上，服务器将拒绝该请求，并返回 HTTP 403 错误。该 header 需要包含在 Authorization 中，详情见 [管理凭证](https://developer.qiniu.com/kodo/manual/1201/access-token) | 请求头 Etag | Etag 是 Object 被创建时用于标识 Object 内容的。ETag 值反映 Object 内容是否发生变化，ETag 返回值根据不同请求的情况选择。例如`ETag: "lrMxbjcfPyC7F1siA6tF78B1IMAq"`。 | 响应头 Server | 生成响应的服务器名称。例如`Server: nginx`。 | 响应头 X-Reqid | 上传请求的唯一 ID。通过该 ID 可快速定位用户请求的相关日志。在联系技术支持时提供该 ID 可快速解决问题。例如`X-Reqid: BlcAAAFP_Hx-RfkU`。 | 响应头 X-Log | 用于快速定位问题的参考信息。例如`X-Log: RSF:102;RSF:103;ZONEPROXY:105`。 | 响应头 以上内容是否对您有帮助？

错误响应

[对象存储](https://developer.qiniu.com/kodo) > API 文档 > 错误响应 # 错误响应 最近更新时间: 2021-05-13 19:02:13 本节为您提供请求出现错误时，返回的错误码和对应的错误信息。 # **错误响应格式** 当您请求出现错误时，响应头部信息包括： * Content-Type: application/json * 一个合适的 3xx，4xx，或者 5xx 的 HTTP 状态码 各个接口在遇到执行错误时，将返回一个 JSON 格式组织的信息对象，描述出错原因。具体格式如下： { "code": <httpCode int>, "error": "<errMsg string>" } 字段名称 | 说明 ---|--- code | 返回的错误码，用来定位错误场景。 error | 包含详细的错误信息 # **错误码列表** 以下表格列出了所有错误码： HTTP状态码 | 说明 ---|--- 298 | 部分操作执行成功 400 | 请求报文格式错误 包括上传时，上传表单格式错误。例如`incorrect region`表示上传域名与上传空间的区域不符，此时需要升级 SDK 版本。 401 | 认证授权失败 错误信息包括密钥信息不正确；数字签名错误；授权已超时，例如`token not specified`表示上传请求中没有带 token ，可以抓包验证后排查代码逻辑; `token out of date`表示 token 过期，推荐 token 过期时间设置为 3600 秒（1 小时），如果是客户端上传，建议每次上传从服务端获取新的 token；`bad token`表示 token 错误，说明生成 token 的算法有问题，建议直接使用七牛服务端 SDK 生成 token。 403 | 权限不足，拒绝访问。 例如`key doesn't match scope`表示上传文件指定的 key 和上传 token 中，putPolicy 的 scope 字段不符。上传指定的 key 必须跟 scope 里的 key 完全匹配或者前缀匹配；`ExpUser can only upload image/audio/video/plaintext`表示账号是体验用户，体验用户只能上传文本、图片、音频、视频类型的文件，完成实名认证即可解决；`not allowed`表示您是体验用户，若想继续操作，请先前往实名认证。 404 | 资源不存在 包括空间资源不存在；镜像源资源不存在。 405 | 请求方式错误 主要指非预期的请求方式。 406 | 上传的数据 CRC32 校验错误 413 | 请求资源大小大于指定的最大值 419 | 用户账号被冻结 478 | 镜像回源失败 主要指镜像源服务器出现异常。 502 | 错误网关 503 | 服务端不可用 504 | 服务端操作超时 573 | 单个资源访问频率过高 579 | 上传成功但是回调失败 包括业务服务器异常；七牛服务器异常；服务器间网络异常。需要确认回调服务器接受 POST 请求，并可以给出 200 的响应。 599 | 服务端操作失败 608 | 资源内容被修改 612 | 指定资源不存在或已被删除 614 | 目标资源已存在 630 | 已创建的空间数量达到上限，无法创建新空间。 631 | 指定空间不存在 640 | 调用[列举资源(list)](https://developer.qiniu.com/kodo/api/1284/list)接口时，指定非法的`marker`参数。 701 | 在断点续上传过程中，后续上传接收地址不正确或`ctx`信息已过期。 如遇 5xx 系列错误，请将完整的错误信息（包括所有的 HTTP 响应头部）[提交工单 __](https://support.qiniu.com/tickets/category)给我们。 以上内容是否对您有帮助？

数据格式

[对象存储](https://developer.qiniu.com/kodo) > API 文档 > 数据格式 # 数据格式 最近更新时间: 2021-07-27 18:42:57 本节描述七牛云存储 API 中使用到的数据格式。 ## EncodedEntryURI 格式 本格式用于在 URI中指定目标资源空间与目标资源名，格式如下： entry = '<Bucket>:<Key>' encodedEntryURI = urlsafe_base64_encode(entry) 假设 **entry** 为 `qiniuphotos:gogopher.jpg` ，则对应的 **encodedEntryURI** 为 `cWluaXVwaG90b3M6Z29nb3BoZXIuanBn` 。 # URL安全的Base64编码 URL安全的Base64编码适用于以URL方式传递Base64编码结果的场景。该编码方式的基本过程是先将内容以Base64格式编码为字符串，然后检查该结果字符串，将字符串中的加号`+`换成中划线`-`，并且将斜杠`/`换成下划线`_`。 详细编码规范请参考[RFC4648 __](https://tools.ietf.org/html/rfc4648#section-4)标准中的相关描述。 以上内容是否对您有帮助？

获取 Bucket 列表

[对象存储](https://developer.qiniu.com/kodo) > API 文档 > Service 接口 >获取 Bucket 列表 # 获取 Bucket 列表 最近更新时间: 2024-05-21 14:10:26 # **描述** 本接口作 GET 请求用来获取请求者拥有的所有存储空间列表。该接口需要您使用带 Authorization 签名认证的请求，如果使用匿名请求无法获取存储空间列表，且只能获取签名中 AccessKey 所属账户的存储空间列表。 # **请求** ### **请求语法** GET /buckets?tagCondition=<Encodedtags> HTTP/1.1 Host: uc.qiniuapi.com Content-Type: application/x-www-form-urlencoded X-Qiniu-Date: 20060102T150405Z Authorization: Qiniu <AccessToken> ### **请求参数** 参数名称 | 必填 | 说明 ---|---|--- Encodedtags | 否 | 过滤空间的标签或标签值条件，指定多个标签或标签值时同时满足条件的空间才会返回。参数值必须做[URL 安全的 Base64 编码](https://developer.qiniu.com/kodo/manual/1231/appendix#urlsafe-base64)。 按标签名过滤空间时，参数值设置为Encoded(key=key1;key=key2)；按标签值过滤空间时，参数值设置为Encoded(key=key1&value=value1;key=key2&value=value2) 别人授权的空间，标签属性不传递，因此依据标签列举空间时只会返回自己创建的空间 ### **请求头** 该请求操作的实现使用了所有操作的公共请求头。有关详细信息，请查阅[公共请求头](https://developer.qiniu.com/kodo/api/3924/common- request-headers)。 ### **请求内容** 该请求操作的请求体为空。 # **响应** ### **响应语法** HTTP/1.1 200 OK Content-Type: application/json [ BucketName ] ### **响应头** 该请求操作的实现使用了所有操作的公共响应头。有关详细信息，请查阅[公共响应头](https://developer.qiniu.com/kodo/api/3924/common- request-headers)。 ### **响应内容** 名称 | 说明 ---|--- BucketName | 空间名称 类型：字符串 ### **响应状态码** 该操作的实现不会返回特殊错误。有关错误和错误代码列表的一般信息，请查阅[错误响应](https://developer.qiniu.com/kodo/api/3928/error- responses)。 # **示例** ### **请求示例** GET /buckets?tagCondition=S09ETy1CVUtDRVQtVEFHUy1rZXktWDdPNjZiNkxLdz1LT0RPLUJVS0NFVC1UQUdTLXZhbHVlLWdFOGhIV2VXUGo= HTTP/1.1 Host: uc.qiniuapi.com User-Agent: Go-http-client/1.1 X-Qiniu-Date: 20060102T150405Z Authorization: Qiniu HwFOxpYCQU6oXoZXFOTh1mq5ZZig6Yyocgk3BTZZ:8tgafMszuwgd99Ix4eQ2HeVT9B0= _注：要在`Authorization` 头部的 `<AccessToken>` 前添加 `Qiniu` 和半角空格。_ ### **响应示例** HTTP/1.1 200 OK Content-Length: 75 Connection: keep-alive Content-Type: application/json Date: Mon, 02 Jan 2006 15:04:05 GMT X-Reqid: rWkAACgHbskB5dYV [ "temp-bucket-xufk1x3r1wa9ayoy7knuz0", "temp-bucket-pighpwdt7lu88ljltffmz0" ] 以上内容是否对您有帮助？

Bucket 接口

[对象存储](https://developer.qiniu.com/kodo) > API 文档 > Bucket 接口 # Bucket 接口 最近更新时间: 2021-12-06 10:03:53 空间管理相关的接口： 接口 | 说明 ---|--- [mkbucketv3](https://developer.qiniu.com/kodo/api/1382/mkbucketv3) | 创建新的存储空间 [drop](https://developer.qiniu.com/kodo/api/1601/drop-bucket) | 删除指定存储空间 [domains](https://developer.qiniu.com/kodo/api/3949/get-the-bucket-space-domain) | 获取一个空间绑定的所有域名列表 [image](https://developer.qiniu.com/kodo/api/3966/bucket-image-source) | 为存储空间指定一个镜像回源网址，用于取回资源 [private](https://developer.qiniu.com/kodo/api/3946/set-bucket-private) | 设置空间访问权限 [putBucketTagging](https://developer.qiniu.com/kodo/api/6314/put-bucket-tagging) | 设置空间标签 [getBucketTagging](https://developer.qiniu.com/kodo/api/6315/get-bucket-tagging) | 查询空间标签 [deleteBucketTagging](https://developer.qiniu.com/kodo/api/6316/delete-bucket-tagging) | 删除空间标签 以上内容是否对您有帮助？

创建 Bucket

[对象存储](https://developer.qiniu.com/kodo) > API 文档 > [Bucket 接口](https://developer.qiniu.com/kodo/api/3941/the-bucket-interface) > 创建 Bucket # 创建 Bucket 最近更新时间: 2023-03-01 17:46:53 # **描述** 本接口用于创建一个新的 Bucket。此接口不支持匿名请求。您可以在请求参数中指定存储区域，例如，您在华东，选择华东存储区域可以减少延迟、降低成本。 # **请求** ### **请求语法** POST /mkbucketv3/<BucketName>/region/<Region> HTTP/1.1 Host: uc.qiniuapi.com Content-Type: application/x-www-form-urlencoded X-Qiniu-Date: 20060102T150405Z Authorization: Qiniu <AccessToken> 使用说明： * 如果请求的 Bucket 已经存在/重名，返回错误码 614，错误信息：目标资源已存在。 * 如果创建的 Bucket 不符合命名规范，返回错误码 400，错误信息：invalid arguments。 * 如果发起创建 Bucket 请求的时候，没有传入认证信息，返回错误码 401，错误信息：bad token。 * 如果创建 Bucket 的时候超过最大创建数（默认 20 个），返回错误码 630，错误信息：too many buckets。 * 目前 Bucket 有两种访问权限：公开和私有。创建的 Bucket，默认为公开权限。 * Bucket 名称和其存储所在区域在创建后无法修改。 ### **请求参数** 参数名称 | 必填 | 说明 ---|---|--- BucketName | 是 | 空间名称，要求**在对象存储系统范围内唯一** ，由3～63个字符组成，支持小写字母、短划线`-`和数字，且必须以小写字母或数字开头和结尾。 Region | 否 | 存储区域 ID，默认 z0。 存储区域 ID 列表见 [存储区域列表](https://developer.qiniu.com/kodo/1671/region-endpoint-fq) ### **请求头** 该请求操作的实现使用了所有操作的公共请求头。有关详细信息，请查阅[公共请求头](https://developer.qiniu.com/kodo/api/3924/common- request-headers)。 ### **请求内容** 该请求操作的请求体为空。 # **响应** ### **响应头** 该请求操作的实现使用了所有操作的公共响应头。有关详细信息，请查阅[公共响应头](https://developer.qiniu.com/kodo/api/3924/common- response-headers)。 ### **响应内容** 该请求操作的响应体为空。 ### **响应状态码** 该操作的实现不会返回特殊错误。有关错误和错误代码列表的一般信息，请查阅[错误响应](https://developer.qiniu.com/kodo/api/3928/error- responses)。 # **示例** ### **请求示例** POST /mkbucketv3/mybucketforvideo HTTP/1.1 Host: uc.qiniuapi.com User-Agent: Go-http-client/1.1 Content-Length: 0 X-Qiniu-Date: 20060102T150405Z Authorization: Qiniu j853F3bLkWl59I5BOkWm6q1Z1mZClpr9Z9CLfDE0:nP7NSSyGo4x3W_nJ8T9X1gJrgpk= _注：要在`Authorization` 头部的 `<AccessToken>` 前添加 `Qiniu` 和半角空格。_ ### **响应示例** HTTP/1.1 200 OK Content-Length: 2 Connection: keep-alive Content-Type: application/json Date: Mon, 02 Jan 2006 15:04:05 GMT Server: nginx X-Reqid: SFkAAAC8BDebTtsU {} 以上内容是否对您有帮助？