How to use the gulp-awspublish.create function in gulp-awspublish

gulp.task('upload-vendor-file', function publishAWS() {
  if (existsSync(manifestPath)) {
    // eslint-disable-next-line global-require, import/no-dynamic-require
    manifestJSON = require(manifestPath);
  } else {
    log(`Manifest file not found: ${manifestPath}`);
    throw new Error(`Manifest file not found: ${manifestPath}`);
  }

  const publisher = awspublish.create({
    region: 'us-east-1',
    params: {
      Bucket: process.env.s3bucket
    }
  });

  const headers = {
    'Cache-Control': 'max-age=315360000, no-transform, public'
  };

  return gulp
    .src([
      `./dist/static/js/${manifestJSON['vendor.js']}`,
      `./dist/static/js/${manifestJSON['vendor.js.map']}`
    ])
    .pipe(

gulp.task("cdn", function(){

    var aws = JSON.parse(fs.readFileSync("./_s3.json"));

    // create a new publisher
    var publisher = awspublish.create(aws);
    gulp
        .src("./build/alpaca/**/*")
        .pipe(rename(function(x) {
            x.dirname = path.join("alpaca", pkg.version, x.dirname);
        }))
        .pipe(publisher.publish())
        //.pipe(publisher.sync())
        .pipe(awspublish.reporter());
});

gulp.task('deploy', function() {
  var cacheLife, publisher, headers;
  if (!process.env.AWS_KEY || !process.env.AWS_SECRET) {
    throw 'AWS credentials are required!';
  }
  cacheLife = (1000 * 60 * 60); // 1 hour (* 24 * 365)
  headers = {
    'Cache-Control': 'max-age=' + cacheLife + ', public'
  };
  publisher = aws.create({
    'accessKeyId': process.env.AWS_KEY,
    'secretAccessKey': process.env.AWS_SECRET,
    'params': {
      'Bucket': 'keen-js',
      'Expires': new Date(Date.now() + cacheLife)
    }
  });

  return gulp.src([
      './dist/' + pkg.name + '.js',
      './dist/' + pkg.name + '.min.js'
    ])
    .pipe(rename(function(path) {
      path.dirname += '/';
      var name = pkg.name + '-' + pkg.version;
      path.basename = (path.basename.indexOf('min') > -1) ? name + '.min' : name;

function deployS3(config) {
  if (!config.credentials.accessKeyId || !config.credentials.secretAccessKey) {
    gutil.log(
      gutil.colors.red('AWS S3 credentials missing, skipping upload...'),
    );
    return;
  }

  // create a new publisher
  const publisher = aws.create(config.credentials);

  // define custom headers
  const headers = {
    'Cache-Control': 'max-age=315360000, no-transform, public',
  };
  return (
    gulp
      .src(config.assetsPath)
      .pipe(
        rename(function(filepath) {
          filepath.dirname = path.join(config.dirname, filepath.dirname);
        }),
      )
      // gzip, Set Content-Encoding headers and add .gz extension
      .pipe(gulpIf(file => !file.path.match(/\.(mp4|ogg|webm|avi|mov|mkv)$/), aws.gzip()))
      // publisher will add Content-Length, Content-Type and headers specified above

gulp.task('deploy', ['minify'], function() {
  var publisher = awspublish.create({
    region: config.cdn.region,
    params: {
      Bucket: config.cdn.bucket
    }
  });

  var packageConfigs = config.getPackageConfigs();
  var streams = packageConfigs.map(function(packageConfigs) {
    return gulp.src(config.minifiedDest + '*')
      .pipe(rename(function(filePath) {
        var version = packagejson.version;
        if (gutil.env.latest) {
          version = 'latest';
        }

        filePath.dirname = path.join(config.cdnPath, version);

gulp.task('publish', function() {
  var publisher = awspublish.create(awsconfig);
  var headers = {
    'Cache-Control': 'max-age=315360000, no-transform, public'
  };
  return gulp.src('public/**')
    .pipe(awspublish.gzip())
    .pipe(publisher.publish(headers))
    .pipe(publisher.cache())
    .pipe(awspublish.reporter());
});

gulp.task('deploy', ['build'], function() {
    var awsConf = localConfig.getAwsConf('production');
    var publisher = awspublish.create(awsConf.keys);
    return gulp.src(localConfig.buildSrc)
      .pipe(awspublish.gzip({ ext: '' }))
      .pipe(publisher.publish(awsConf.headers))
      .pipe(publisher.cache())
      .pipe(publisher.sync())
      .pipe(awspublish.reporter());
});

function CDNPublisher () {
  var s3Config = {
    accessKeyId:process.env.AWS_ACCESS_KEY_ID,
    secretAccessKey:process.env.AWS_SECRET_ACCESS_KEY,
    params:{
      Bucket:conf.cdn.bucketName
    }
  };
  return awspublish.create(s3Config);
}

gulp.task("publish", function() {
  var publisher = awspublish.create({
    "params": {
      "Bucket": "accesslint-js"
    },
  });

  return gulp.src('./dist/accesslint-*.js')
  .pipe(publisher.publish())
  .pipe(publisher.cache())
  .pipe(awspublish.reporter());
});

gulp.task('publish-aws', function () {
	var publisher = awspublish.create({
		region: awsRegion,
		accessKeyId: awsAccessKey,
		secretAccessKey: process.env.awssecretkey,
		params: { Bucket: 'sdk.altvr.com' }
	});
	return gulp.src('../dist/**')
		.pipe(rename(function (distPath) {
			if (distPath.dirname === '.') { distPath.dirname = ''; }
			distPath.dirname = s3Path + '/' + version + '/' + distPath.dirname;
		}))
		.pipe(publisher.publish())
		.pipe(awspublish.reporter());
});