OSS 前端自动化部署:

使用 node.js 或 python。

阿里云官方文档(使用 nodejs)

快速入门

OSS(options)中的各个配置项说明如下:

  • [accessKeyId] {String}:通过阿里云控制台创建的AccessKey。
  • [accessKeySecret] {String}:通过阿里云控制台创建的AccessSecret。
  • [stsToken] {String}:使用临时授权方式,详情请参见使用 STS 进行临时授权。
  • [bucket] {String}:通过控制台或PutBucket创建的bucket。
  • [endpoint] {String}:OSS域名。
  • [region] {String}:bucket所在的区域, 默认oss-cn-hangzhou。
  • [internal] {Boolean}:是否使用阿里云内网访问,默认false。比如通过ECS访问OSS,则设置为true,采用internal的endpoint可节约费用。
  • [cname] {Boolean}:是否支持上传自定义域名,默认false。如果cname为true,endpoint传入自定义域名时,自定义域名需要先同bucket进行绑定。
  • [isRequestPay] {Boolean}:bucket是否开启请求者付费模式,默认false。具体可查看请求者付费模式。
  • [secure] {Boolean}:(secure: true)则使用HTTPS,(secure: false)则使用HTTP,详情请查看常见问题。
  • [timeout] {String|Number}:超时时间,默认60s。

安装 ali-oss

1
npm install ali-oss

OSS NodeJS SDK同时支持同步和异步的使用方式

region是指您申请 OSS 服务时的区域,例如oss-cn-hangzhou。完整的区域列表请参考访问域名和数据中心

同步方式:基于async和await方式,异步编程同步化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
let OSS = require('ali-oss');

let client = new OSS({
region: '<oss region>',
//云账号AccessKey有所有API访问权限,建议遵循阿里云安全最佳实践,部署在服务端使用RAM子账号或STS,部署在客户端使用STS。
accessKeyId: '<Your accessKeyId>',
accessKeySecret: '<Your accessKeySecret>',
bucket: '<Your bucket name>'
});

async function put () {
try {
// object表示上传到OSS的Object名称,localfile表示本地文件或者文件路径
let r1 = await client.put('object','localfile');
console.log('put success: %j', r1);
let r2 = await client.get('object');
console.log('get success: %j', r2);
} catch(e) {
console.error('error: %j', err);
}
}
put();

异步方式:类似callback的方式,API接口返回Promise,使用.then()处理返回结果,使用.catch()处理错误

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
let OSS = require('ali-oss');

let client = new OSS({
region: '<oss region>',
//云账号AccessKey有所有API访问权限,建议遵循阿里云安全最佳实践,部署在服务端使用RAM子账号或STS,部署在客户端使用STS。
accessKeyId: '<Your accessKeyId>',
accessKeySecret: '<Your accessKeySecret>',
bucket: '<Your bucket name>'
});

// object表示上传到OSS的Object名称,localfile表示本地文件或者文件路径
client.put('object', 'localfile').then(function (r1) {
console.log('put success: %j', r1);
return client.get('object');
}).then(function (r2) {
console.log('get success: %j', r2);
}).catch(function (err) {
console.error('error: %j', err);
});

子账号访问

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
let OSS = require('ali-oss');
let STS = OSS.STS;
let sts = new STS({
accessKeyId: '<子账号的AccessKeyId>',
accessKeySecret: '<子账号的AccessKeySecret>'
});
async function assumeRole () {
try {
let token = await sts.assumeRole(
'<role-arn>', '<policy>', '<expiration>', '<session-name>');
let client = new OSS({
region: '<region>',
accessKeyId: token.credentials.AccessKeyId,
accessKeySecret: token.credentials.AccessKeySecret,
stsToken: token.credentials.SecurityToken,
bucket: '<bucket-name>'
});
} catch (e) {
console.log(e);
}
}
assumeRole();

STS 临时授权访问 OSS 步骤

查看存储空间(Bucket)列表(node app.js 运行)

1
2
3
4
5
6
7
8
9
async function listBuckets () {
try {
let result = await client.listBuckets();
} catch(err) {
console.log(err)
}
}

listBuckets();

查看文件列表

1
2
3
4
5
6
7
8
9
10
11
12
client.useBucket('Your bucket name');
async function list () {
try {
let result = await client.list({
'max-keys': 5
})
console.log(result)
} catch (err) {
console.log (err)
}
}
list();

上传文件

1
2
3
4
5
6
7
8
9
10
11
12
client.useBucket('Your bucket name');

async function put () {
try {
let result = await client.put('object-name', 'local file');
console.log(result);
} catch (err) {
console.log (err);
}
}

put();

下载文件

1
2
3
4
5
6
7
8
9
10
async function get () {
try {
let result = await client.get('object-name');
console.log(result);
} catch (err) {
console.log (err);
}
}

get();

删除文件

1
2
3
4
5
6
7
8
9
10
async function delete () {
try {
let result = await client.delete('object-name');
console.log(result);
} catch (err) {
console.log (err);
}
}

delete();

完整流程

存储空间

创建 Bucket

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
let OSS = require('ali-oss');

let client = new OSS({
region: '<Your region>',
accessKeyId: '<Your AccessKeyId>',
accessKeySecret: '<Your AccessKeySecret>'
});

// putBucket
async function putBucket() {
try {
const result = await client.putBucket('your bucket name');
console.log(result);
} catch (err) {
console.log(err);
}
}

putBucket();

删除 Bucket

  • 如果该 Bucket 下还有文件,则需要先删除所有文件才能删除 Bucket。
  • 如果该 Bucket 下还有未完成的上传请求,则需要通过listUploads和abortMultipartUpload取消请求后才能删除 Bucket。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
let OSS = require('ali-oss');

let client = new OSS({
region: '<Your region>',
accessKeyId: '<Your AccessKeyId>',
accessKeySecret: '<Your AccessKeySecret>'
});

async function deleteBucket() {
try {
const result = await client.deleteBucket('your bucket name');
console.log(result);
} catch (err) {
console.log(err);
}
}

deleteBucket();

设置访问权限

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
let OSS = require('ali-oss');

let client = new OSS({
region: '<Your region>',
accessKeyId: '<Your AccessKeyId>',
accessKeySecret: '<Your AccessKeySecret>'
});

async function putBucketACL() {
try {
const result = await client.putBucketACL('bucket name', 'public-read');
console.log(result);
} catch (err) {
console.log(err);
}
}

putBucketACL();

上传文件

上传本地文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
let OSS = require('ali-oss')

let client = new OSS({
region: '<Your region>',
accessKeyId: '<Your AccessKeyId>',
accessKeySecret: '<Your AccessKeySecret>',
bucket: '<Your bucket name>',
});

async function put () {
try {
let result = await client.put('object-name', 'local-file');
console.log(result);
} catch (e) {
console.log(e);
}
}

put();

流式上传

当使用 putStream 接口时,SDK 默认会发起一个 chunked encoding 的 HTTP PUT 请求。如果在 options 指定了 contentLength 参数,则不会使用 chunked encoding。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
let OSS = require('ali-oss');
let fs = require('fs');

let client = new OSS({
region: '<Your region>',
accessKeyId: '<Your AccessKeyId>',
accessKeySecret: '<Your AccessKeySecret>',
bucket: '<Your bucket name>'
});

async function putStream () {
try {
// use 'chunked encoding'
let stream = fs.createReadStream('local-file');
let result = await client.putStream('object-name', stream);
console.log(result);

// don't use 'chunked encoding'
let stream = fs.createReadStream('local-file');
let size = fs.statSync('local-file').size;
let result = await client.putStream(
'object-name', stream, {contentLength: size});
console.log(result);
} catch (e) {
console.log(e)
}
}

putStream();

管理文件

判断文件是否存在

1
2
3
4
5
6
7
8
9
client.get(object).then((result) => {
if (result.res.status == 200) {
return true
}
}).catch((e)=> {
if (e.code == 'NoSuchKey') {
return false
}
})

列举指定Bucket下的所有文件

  • prefix:只列出符合特定前缀的文件。
  • marker:只列出文件名大于 marker 之后的文件。
  • delimiter:用于获取文件的公共前缀。
  • max-keys:用于指定最多返回的文件个数。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
let OSS = require('ali-oss');
let client = new OSS({
region: '<Your region>',
accessKeyId: '<Your AccessKeyId>',
accessKeySecret: '<Your AccessKeySecret>',
bucket: '<Your bucket name>'
});
async function list () {
{
// 不带任何参数,默认最多返回1000个文件。
let result = await client.list();
console.log(result);
// 根据nextMarker继续列出文件。
if (result.isTruncated) {
let result = await client.list({
marker: result.nextMarker
});
}
// 列举前缀为'my-'的文件。
let result = await client.list({
prefix: 'my-'
});
console.log(result);
// 列举前缀为'my-'且在'my-object'之后的文件。
let result = await client.list({
prefix: 'my-',
marker: 'my-object'
});
console.log(result);
} catch (e) {
console.log(e);
}
}
list();

删除文件

删除单个文件
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
let OSS = require('ali-oss')

let client = new OSS({
region: '<Your region>',
accessKeyId: '<Your AccessKeyId>',
accessKeySecret: '<Your AccessKeySecret>',
bucket: '<Your bucket name>',
});

async function delete () {
try {
let result = await client.delete('object-name');
console.log(result);
} catch (e) {
console.log(e);
}
}

delete();
删除多个文件
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
let OSS = require('ali-oss')

let client = new OSS({
region: '<Your region>',
accessKeyId: '<Your AccessKeyId>',
accessKeySecret: '<Your AccessKeySecret>',
bucket: '<Your bucket name>',
});

async function deleteMulti () {
try {
let result = await client.deleteMulti(['obj-1', 'obj-2', 'obj-3']);
console.log(result);
let result = await client.deleteMulti(['obj-1', 'obj-2', 'obj-3'], {
quiet: true
});
console.log(result);
} catch (e) {
console.log(e);
}
}

deleteMulti();

访问日志

开启访问日志记录

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
let OSS = require('ali-oss')
let client = new OSS({
region: '<Your region>'
accessKeyId: '<Your AccessKeyId>',
accessKeySecret: '<Your AccessKeySecret>',
bucket: '<Your bucket name>'
});
async function putBucketLogging () {
try {
let result = await client.putBucketLogging('bucket-name', 'logs/');
console.log(result)
} catch (e) {
console.log(e)
}
}
putBucketLogging();

查看访问日志设置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
let OSS = require('ali-oss')

let client = new OSS({
region: '<Your region>'
accessKeyId: '<Your AccessKeyId>',
accessKeySecret: '<Your AccessKeySecret>',
bucket: '<Your bucket name>'
});

async function getBucketLogging() {
try {
let result = await client.getBucketLogging('bucket-name');
console.log(result);
} catch (e) {
console.log(e);
}
})

getBucketLogging();

关闭访问日志记录

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
let OSS = require('ali-oss')

let client = new OSS({
region: '<Your region>'
accessKeyId: '<Your AccessKeyId>',
accessKeySecret: '<Your AccessKeySecret>',
bucket: '<Your bucket name>'
});

async function deleteBucketLogging () {
try {
let result = await client.deleteBucketLogging('bucket-name');
console.log(result);
} catch (e) {
console.log(e);
}

deleteBucketLogging();

静态网站托管

设置静态网站托管

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
let OSS = require('ali-oss')

let client = new OSS({
region: '<Your region>'
accessKeyId: '<Your AccessKeyId>',
accessKeySecret: '<Your AccessKeySecret>',
bucket: '<Your bucket name>'
});

async function putBucketWebsite () {
try {
let result = await client.putBucketWebsite('bucket-name', {
index: 'index.html',
error: 'error.html'
});
console.log(result);
} catch (e) {
console.log(e);
}
}

putBucketWebsite();

查看静态网站托管配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
let OSS = require('ali-oss')

let client = new OSS({
region: '<Your region>'
accessKeyId: '<Your AccessKeyId>',
accessKeySecret: '<Your AccessKeySecret>',
bucket: '<Your bucket name>'
});

async function getBucketWebsite () {
try {
let result = await client.getBucketWebsite('bucket-name');
console.log(result);
} catch (e) {
console.log(e);
}
}

getBucketWebsite();

删除静态网站托管配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
let OSS = require('ali-oss')

let client = new OSS({
region: '<Your region>'
accessKeyId: '<Your AccessKeyId>',
accessKeySecret: '<Your AccessKeySecret>',
bucket: '<Your bucket name>'
});

async function deleteBucketWebsite() {
try {
let result = await client.deleteBucketWebsite('bucket-name');
console.log(result);
} catch (e) {
console.log(e);
}
}

deleteBucketWebsite();

最终代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
const fs = require('fs');
const join = require('path').join;

let OSS = require('ali-oss');
let STS = OSS.STS;
let sts = new STS({
accessKeyId: 'LTA&*******5p',
accessKeySecret: 'VNbvLHs**********j2vPsK'
});

const BucketName = 'demo-demo-demo';
const Region = 'oss-cn-shanghai***';
const Ram = 'acs:ram::185190330623****:role/aliyunoss***';
const BaseDir = 'dist';

sts.assumeRole(Ram).then((token) => {
return new OSS({
region: Region,
accessKeyId: token.credentials.AccessKeyId,
accessKeySecret: token.credentials.AccessKeySecret,
stsToken: token.credentials.SecurityToken
});
}).then((client) => {
client.listBuckets().then((buckets) => {
let flag = false;
if (buckets.buckets) {
for (let i = 0, j = buckets.buckets.length; i < j; i++) {
if (buckets.buckets[i].name === BucketName) {
flag = true;
}
}
}
if (flag) {
client.putBucketACL(BucketName, 'public-read').then(() => {
client.putBucketWebsite(BucketName, {index: 'index.html'});
client.useBucket(BucketName);
client.list().then((res) => {
if (res.objects && res.objects.length > 0) {
for (let i = 0, j = res.objects.length; i < j; i++) {
client.delete(res.objects[i].name)
}
}
}).then(() => {
function getJsonFiles(jsonPath) {
let jsonFiles = [];

function findJsonFile(path) {
let files = fs.readdirSync(path);
files.forEach(function (item, index) {
let fPath = join(path, item);
let stat = fs.statSync(fPath);
if (stat.isDirectory() === true) {
findJsonFile(fPath);
}
if (stat.isFile() === true) {
jsonFiles.push(fPath);
}
});
}

findJsonFile(jsonPath);
return jsonFiles;
}

let filesArr = getJsonFiles("./" + BaseDir);
for (let i = 0, j = filesArr.length; i < j; i++) {
client.put(filesArr[i].replace('dist/', ''), filesArr[i]).catch((err) => {
console.log('errors:-------\n' + err);
});
}
});
});
} else {
client.putBucket(BucketName).then(() => {
client.putBucketACL(BucketName, 'public-read').then(() => {
client.putBucketWebsite(BucketName, {index: 'index.html'});
client.useBucket(BucketName);

function getJsonFiles(jsonPath) {
let jsonFiles = [];

function findJsonFile(path) {
let files = fs.readdirSync(path);
files.forEach(function (item, index) {
let fPath = join(path, item);
let stat = fs.statSync(fPath);
if (stat.isDirectory() === true) {
findJsonFile(fPath);
}
if (stat.isFile() === true) {
jsonFiles.push(fPath);
}
});
}

findJsonFile(jsonPath);
return jsonFiles;
}

let filesArr = getJsonFiles("./" + BaseDir);
for (let i = 0, j = filesArr.length; i < j; i++) {
client.put(filesArr[i].replace('dist/', ''), filesArr[i]).catch((err) => {
console.log('errors:-------\n' + err);
});
}
});
})
}
});
}).catch((res) => {
console.log(res);
});

注意事项

  • 子账号通过 sdk 访问阿里云 OSS 需要相关的权限配置,具体流程可见官网文档描述
  • 域名绑定,需要 CDN 权限
  • 结合 vue 脚手架工具打包工程+上传到 OSS,先按照 ali-oss,然后如上在根目录创建 app.js 后,在 packsge.json 中加入脚本:

    1
    "oss": "vue-cli-service build && echo \"uploading...\nPlease wait for a while...\" && node app.js && echo \"success\""
  • 参数说明

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    // STS 访问需要的子用户 accessKeyId 和 accessKeySecret
    let sts = new STS({
    accessKeyId: 'LTAI****do5p',
    accessKeySecret: 'VNbv****vPsK'
    });
    // 本地要上传的文件夹名称(默认 dist)
    const BaseDir = 'dist';
    // OSS 存储的名称
    const BucketName = 'demo-demo-demo';
    // OSS 存储的区域
    const Region = 'oss-cn-shanghai';
    // 通过 STS 临时访问需要的 ram
    const Ram = 'acs:ram::1851****3203:role/aliyunoss****';