@cloudbase/manager-node 4.2.0 → 4.2.2

package/src/function/index.ts

@@ -0,0 +1,1378 @@
+import fs from 'fs'
+import path from 'path'
+import { FunctionPacker, CodeType } from './packer'
+import { Environment } from '../environment'
+import {
+    IResponseInfo,
+    ICloudFunction,
+    IFunctionLogOptions,
+    ICloudFunctionTrigger,
+    IFunctionInvokeRes,
+    IFunctionLogRes,
+    IFunctionDownloadUrlRes
+} from '../interfaces'
+import { CloudBaseError } from '../error'
+import {
+    sleep,
+    preLazy,
+    delSync,
+    isDirectory,
+    CloudService,
+    compressToZip,
+    checkFullAccess
+} from '../utils'
+import { SCF_STATUS } from '../constant'
+import { IFunctionInfo, IFunctionUpdateAttribute } from './types'
+
+export interface IFunctionCode {
+    func: ICloudFunction // 云函数信息
+    functionRootPath?: string // 云函数根目录
+    base64Code?: string
+    functionPath?: string
+}
+
+export interface ICreateFunctionParam {
+    // 云函数信息
+    func: ICloudFunction & {
+        // 云接入路径
+        path?: string
+    }
+    functionRootPath?: string // 云函数根目录
+    force?: boolean // 是否覆盖同名云函数
+    base64Code?: string
+    functionPath?: string
+    codeSecret?: string // 代码保护密钥
+}
+
+export interface IUpdateFunctionCodeParam {
+    func: ICloudFunction // 云函数信息
+    functionPath?: string
+    functionRootPath?: string // 云函数的目录路径（可选） functionRootPath 与 base64Code 可任选其中一个
+    base64Code?: string // 云函数 ZIP 文件的 base64 编码（可选）
+    codeSecret?: string // 代码保护密钥
+}
+
+export interface IUpdateFunctionIncrementalCodeParam {
+    func: ICloudFunction
+    functionRootPath: string // 必选
+    deleteFiles?: Array<string> // 要删除的文件和目录列表
+    addFiles?: string // 新增或修改的文件路径 （指定单个文件或单个文件夹）
+}
+
+export interface ICreateFunctionRes {
+    triggerRes: IResponseInfo
+    configRes: IResponseInfo
+    codeRes: IResponseInfo
+}
+
+export interface IFunctionLayerOptions {
+    contentPath?: string
+    base64Content?: string
+    name: string
+    runtimes: string[] // 支持的运行时
+    description?: string // 层版本描述
+    licenseInfo?: string // 层的软件许可证
+}
+
+export interface ICreateLayerResponse extends IResponseInfo {
+    LayerVersion: number
+}
+
+export interface ILayerOptions {
+    name: string
+    version: number
+}
+
+export interface IVersionListOptions {
+    name: string
+    runtimes?: string[]
+}
+
+export interface ILayerListOptions {
+    offset?: number
+    limit?: number
+    runtime?: string
+    searchKey?: string
+}
+
+export interface ILayerVersionInfo {
+    CompatibleRuntimes: string[] // 版本适用的运行时
+    AddTime: string // 创建时间
+    Description: string // 版本描述
+    LicenseInfo: string // 许可证信息
+    LayerVersion: number // 版本号
+    LayerName: string // 层名称
+    Status: string // 层的具体版本当前状态
+}
+
+export interface IListLayerVersionsRes extends IResponseInfo {
+    LayerVersions: Array<ILayerVersionInfo>
+}
+
+export interface IListLayerRes extends IResponseInfo {
+    Layers: Array<ILayerVersionInfo>
+    TotalCount: number
+}
+
+export interface IGetLayerVersionRes extends IResponseInfo {
+    CompatibleRuntimes: string[] // 适配的运行时
+    CodeSha256: string // 层中版本文件的SHA256编码
+    Location: string // 层中版本文件的下载地址
+    AddTime: string // 版本的创建时间
+    Description: string // 版本的描述
+    LicenseInfo: string // 许可证信息
+    LayerVersion: number // 版本号
+    LayerName: string // 层名称
+    Status: string // 	层的具体版本当前状态
+}
+
+export interface ISetProvisionedConcurrencyConfig {
+    functionName: string
+    qualifier: string
+    versionProvisionedConcurrencyNum: number
+}
+
+export interface IGetProvisionedConcurrencyConfig {
+    functionName: string
+    qualifier?: string
+}
+
+export interface IVersionProvisionedConcurrencyInfo {
+    AllocatedProvisionedConcurrencyNum: number // 设置的预置并发数。
+    AvailableProvisionedConcurrencyNum: number // 当前已完成预置的并发数。
+    Status: string // 预置任务状态，Done表示已完成，InProgress表示进行中，Failed表示部分或全部失败。
+    StatusReason: string // 对预置任务状态Status的说明。
+    Qualifier: string // 版本号
+}
+export interface IGetProvisionedConcurrencyRes extends IResponseInfo {
+    UnallocatedConcurrencyNum: number
+    Allocated: IVersionProvisionedConcurrencyInfo[]
+}
+
+export interface IPublishVersionParams {
+    functionName: string
+    description?: string
+}
+
+export interface IPublishVersionRes extends IResponseInfo {
+    FunctionVersion: string
+    CodeSize: number
+    MemorySize: number
+    Description: string
+    Handler: string
+    Timeout: number
+    Runtime: string
+    Namespace: string
+}
+
+export interface IListFunctionVersionParams {
+    functionName: string
+    offset?: number
+    limit?: number
+    order?: string
+    orderBy?: string
+}
+
+export interface IFunctionVersion {
+    Version: string
+    Description: string
+    AddTime: string
+    ModTime: string
+    Status: string //
+}
+
+export interface IFunctionVersionsRes extends IResponseInfo {
+    FunctionVersion: string[]
+    Versions: IFunctionVersion[]
+    TotalCount: number
+}
+
+export interface IVersionMatch {
+    Version: string // 函数版本名称
+    Key: string // 匹配规则的key，调用时通过传key来匹配规则路由到指定版本 header方式：key填写"invoke.headers.User"，并在 invoke 调用函数时传参 RoutingKey：{"User":"value"}规则匹配调用
+    Method: string // 匹配方式。取值范围：range：范围匹配 exact：字符串精确匹配
+    Expression: string //
+}
+
+export interface IVersionWeight {
+    Version: string
+    Weight: number
+}
+
+export interface IRoutingConfig {
+    AdditionalVersionWeights?: IVersionWeight[]
+    AddtionVersionMatchs?: IVersionMatch[]
+}
+
+export interface IUpdateFunctionAliasConfig {
+    functionName: string // 函数名
+    name: string // 函数别名 如$DEFAULT
+    functionVersion: string // 函数版本
+    description?: string // 别名描述
+    routingConfig?: IRoutingConfig
+}
+
+export interface IGetFunctionAlias {
+    functionName: string // 函数名称
+    name: string // 别名
+}
+
+export interface IGetFunctionAliasRes extends IResponseInfo {
+    FunctionVersion: string
+    Name: string
+    RoutingConfig: IRoutingConfig
+    Description: string
+    AddTime: string
+    ModTime: string
+}
+
+// 是否为 Node 函数
+function isNodeFunction(runtime: string) {
+    // 不严格限制
+    return runtime === 'Nodejs10.15' || runtime === 'Nodejs8.9' || runtime?.includes('Nodejs')
+}
+
+// 解析函数配置，换成请求参数
+function configToParams(options: { func: ICloudFunction; codeSecret: string; baseParams: any }) {
+    const { func, codeSecret, baseParams } = options
+    let installDependency
+    // Node 函数默认安装依赖
+    installDependency = isNodeFunction(func.runtime) ? 'TRUE' : 'FALSE'
+    // 是否安装依赖，选项可以覆盖
+    if (typeof func.installDependency !== 'undefined') {
+        installDependency = func.installDependency ? 'TRUE' : 'FALSE'
+    }
+
+    // 转换环境变量
+    const envVariables = Object.keys(func.envVariables || {}).map(key => ({
+        Key: key,
+        Value: func.envVariables[key]
+    }))
+
+    // 当不存在 L5 配置时，不修改 L5 状态，否则根据 true/false 进行修改
+    const l5Enable = typeof func?.l5 === 'undefined' ? null : func?.l5 ? 'TRUE' : 'FALSE'
+
+    const params: any = {
+        ...baseParams,
+        FunctionName: func.name,
+        // 不可选择
+        L5Enable: l5Enable
+    }
+
+    // 函数绑定的角色
+    params.Role = func.role || params.Role
+    // 修复参数存在 undefined 字段时，会出现鉴权失败的情况
+    // Environment 为覆盖式修改，不保留已有字段
+    envVariables.length && (params.Environment = { Variables: envVariables })
+    // 处理入口
+    params.Handler = func.handler || 'index.main'
+    // 默认超时时间为 10S
+    params.Timeout = Number(func.timeout) || 10
+    // 默认运行环境 Nodejs8.9
+    params.Runtime = func.runtime || 'Nodejs8.9'
+
+    if (func?.vpc?.subnetId !== undefined && func?.vpc?.vpcId !== undefined) {
+        // VPC 网络
+        params.VpcConfig = {
+            SubnetId: func?.vpc?.subnetId,
+            VpcId: func?.vpc?.vpcId
+        }
+    }
+    // 运行内存
+    params.MemorySize = func.memorySize || 256
+    // 自动安装依赖
+    params.InstallDependency = installDependency
+
+    // 代码保护
+    if (codeSecret || func.codeSecret) {
+        params.CodeSecret = codeSecret || func.codeSecret
+    }
+
+    // 函数层
+    if (func?.layers?.length) {
+        const transformLayers = func.layers.map(item => ({
+            LayerName: item.name,
+            LayerVersion: item.version
+        }))
+        params.Layers = transformLayers
+    }
+
+    return params
+}
+
+export class FunctionService {
+    private environment: Environment
+    private vpcService: CloudService
+    private scfService: CloudService
+
+    constructor(environment: Environment) {
+        this.environment = environment
+        this.scfService = new CloudService(environment.cloudBaseContext, 'scf', '2018-04-16')
+        this.vpcService = new CloudService(environment.cloudBaseContext, 'vpc', '2017-03-12')
+    }
+
+    /**
+     * 增量更新函数代码
+     * @param {IUpdateFunctionIncrementalCodeParam} funcParam
+     * @returns {Promise<void>}
+     * @memberof FunctionService
+     */
+    @preLazy()
+    public async updateFunctionIncrementalCode(
+        funcParam: IUpdateFunctionIncrementalCodeParam
+    ): Promise<IResponseInfo> {
+        const { namespace } = this.getFunctionConfig()
+        const { functionRootPath, func, deleteFiles, addFiles } = funcParam
+        const { name, runtime } = func
+        const params: any = {
+            FunctionName: name,
+            Namespace: namespace
+        }
+
+        let packer: FunctionPacker
+        let base64
+
+        if (deleteFiles) {
+            params.DeleteFiles = deleteFiles
+        }
+
+        if (addFiles) {
+            // 将选中的增量文件或增量文件夹  转base64
+            const codeType: CodeType = runtime === 'Java8' ? CodeType.JavaFile : CodeType.File
+            packer = new FunctionPacker({
+                codeType,
+                name,
+                root: functionRootPath,
+                ignore: [],
+                incrementalPath: addFiles
+            })
+            await packer.build()
+            base64 = await packer.getBase64Code()
+            if (!base64) {
+                throw new CloudBaseError('函数不存在！')
+            }
+            params.AddFiles = base64
+        }
+
+        return this.scfService.request<IResponseInfo>('UpdateFunctionIncrementalCode', params)
+    }
+
+    /**
+     * 创建云函数
+     * @param {ICreateFunctionParam} funcParam
+     * @returns {(Promise<IResponseInfo | ICreateFunctionRes>)}
+     */
+    @preLazy()
+    public async createFunction(
+        funcParam: ICreateFunctionParam
+    ): Promise<IResponseInfo | ICreateFunctionRes> {
+        const { namespace } = this.getFunctionConfig()
+        const {
+            func,
+            functionRootPath,
+            force = false,
+            base64Code,
+            codeSecret,
+            functionPath
+        } = funcParam
+        const funcName = func.name
+
+        const params: IFunctionUpdateAttribute = configToParams({
+            func,
+            codeSecret,
+            baseParams: {
+                Namespace: namespace,
+                Role: 'TCB_QcsRole',
+                Stamp: 'MINI_QCBASE'
+            }
+        })
+
+        params.Code = await this.getCodeParams(
+            {
+                func,
+                base64Code,
+                functionPath,
+                functionRootPath
+            },
+            params.InstallDependency
+        )
+
+        const { TopicId, LogsetId } = this.getClsServiceConfig()
+        params.ClsTopicId = TopicId
+        params.ClsLogsetId = LogsetId
+
+        try {
+            // 创建云函数
+            const res = await this.scfService.request<IResponseInfo | ICreateFunctionRes>(
+                'CreateFunction',
+                params
+            )
+            // 等待函数状态正常
+            await this.waitFunctionActive(funcName, codeSecret)
+            // 创建函数触发器、失败自动重试
+            await this.retryCreateTrigger(funcName, func.triggers)
+
+            // 设置路径，创建云接入路径
+            if (func.path) {
+                await this.createAccessPath(funcName, func.path)
+            }
+
+            // 检查函数状态
+            await this.waitFunctionActive(funcName, codeSecret)
+
+            return res
+        } catch (e) {
+            // 函数存在
+            const functionExist =
+                e.code === 'ResourceInUse.FunctionName' || e.code === 'ResourceInUse.Function'
+            // 已存在同名函数，强制更新
+            if (functionExist && force) {
+                // 1. 更新函数配置和代码，同名函数可能存在 codeSecret，先修改代码，清除 codeSecret
+                const codeRes = await this.updateFunctionCode({
+                    func,
+                    base64Code,
+                    functionPath,
+                    functionRootPath,
+                    codeSecret: codeSecret
+                })
+                // 等待函数状态正常
+                await this.waitFunctionActive(funcName, codeSecret)
+                // 2. 更新函数配置
+                const configRes = await this.updateFunctionConfig(func)
+                // 等待函数状态正常
+                await this.waitFunctionActive(funcName, codeSecret)
+                // 3. 创建函数触发器
+                const triggerRes = await this.retryCreateTrigger(funcName, func.triggers)
+
+                // 设置路径，创建云接入路径
+                if (func.path) {
+                    await this.createAccessPath(funcName, func.path)
+                }
+
+                // 检查函数状态
+                await this.waitFunctionActive(funcName, codeSecret)
+                // 返回全部操作的响应值
+                return {
+                    triggerRes,
+                    configRes,
+                    codeRes
+                }
+            }
+
+            // 不强制覆盖，抛出错误
+            if (e.message && !force) {
+                throw new CloudBaseError(`[${funcName}] 部署失败：\n${e.message}`, {
+                    code: e.code,
+                    requestId: e.requestId
+                })
+            }
+
+            throw e
+        }
+    }
+
+    /**
+     * @param {number} [limit=20]
+     * @param {number} [offset=0]
+     * @returns {Promise<{
+     *         Functions: Record<string, string>[]
+     *         RequestId: string
+     *         TotalCount: number
+     *     }>}
+     * @memberof FunctionService
+     */
+    @preLazy()
+    async getFunctionList(
+        limit = 20,
+        offset = 0
+    ): Promise<{
+        Functions: Record<string, string>[]
+        RequestId: string
+        TotalCount: number
+    }> {
+        // 获取Function 环境配置
+        const { namespace } = this.getFunctionConfig()
+
+        const res: any = await this.scfService.request('ListFunctions', {
+            Namespace: namespace,
+            Limit: limit,
+            Offset: offset
+        })
+        return res
+    }
+
+    /**
+     * 列出函数
+     * @param {number} [limit=20]
+     * @param {number} [offset=0]
+     * @returns {Promise<Record<string, string>[]>}
+     */
+    @preLazy()
+    async listFunctions(limit = 20, offset = 0): Promise<Record<string, string>[]> {
+        // 获取Function 环境配置
+        const { namespace } = this.getFunctionConfig()
+
+        const res: any = await this.scfService.request('ListFunctions', {
+            Namespace: namespace,
+            Limit: limit,
+            Offset: offset
+        })
+        const { Functions = [] } = res
+        const data: Record<string, string>[] = []
+        Functions.forEach(func => {
+            const { FunctionId, FunctionName, Runtime, AddTime, ModTime, Status } = func
+            data.push({
+                FunctionId,
+                FunctionName,
+                Runtime,
+                AddTime,
+                ModTime,
+                Status
+            })
+        })
+
+        return data
+    }
+
+    /**
+     * 删除云函数
+     * @param {string} name 云函数名称
+     * @param {string} qualifier 需要删除的版本号，不填默认删除函数下全部版本。
+     * @returns {Promise<IResponseInfo>}
+     */
+    @preLazy()
+    async deleteFunction(name: string, qualifier?: string): Promise<IResponseInfo> {
+        const { namespace } = this.getFunctionConfig()
+        return this.scfService.request('DeleteFunction', {
+            FunctionName: name,
+            Namespace: namespace,
+            Qualifier: qualifier
+        })
+    }
+
+    /**
+     * 获取云函数详细信息
+     * @param {string} name 云函数名称
+     * @returns {Promise<Record<string, string>>}
+     */
+    @preLazy()
+    async getFunctionDetail(name: string, codeSecret?: string): Promise<IFunctionInfo> {
+        const { namespace } = this.getFunctionConfig()
+
+        const params: any = {
+            FunctionName: name,
+            Namespace: namespace,
+            ShowCode: 'TRUE'
+        }
+
+        if (codeSecret) {
+            params.CodeSecret = codeSecret
+        }
+
+        const data = await this.scfService.request<IFunctionInfo>('GetFunction', params)
+
+        // 解析 VPC 配置
+        const { VpcId = '', SubnetId = '' } = data.VpcConfig || {}
+        if (VpcId && SubnetId) {
+            try {
+                const vpcs = await this.getVpcs()
+                const subnets = await this.getSubnets(VpcId)
+                const vpc = vpcs.find(item => item.VpcId === VpcId)
+                const subnet = subnets.find(item => item.SubnetId === SubnetId)
+                data.VpcConfig = {
+                    vpc,
+                    subnet
+                }
+            } catch (e) {
+                data.VpcConfig = {
+                    vpc: '',
+                    subnet: ''
+                }
+            }
+        }
+
+        return data
+    }
+
+    /**
+     * 获取函数日志
+     * @param {{
+     *         name: string
+     *         offset: number
+     *         limit: number
+     *         order: string
+     *         orderBy: string
+     *         startTime: string
+     *         endTime: string
+     *         requestId: string
+     *     }} options
+     * @returns {Promise<IFunctionLogRes>}
+     */
+    @preLazy()
+    async getFunctionLogs(options: IFunctionLogOptions): Promise<IFunctionLogRes> {
+        const {
+            name,
+            offset = 0,
+            limit = 10,
+            order,
+            orderBy,
+            startTime,
+            endTime,
+            requestId
+        } = options
+        const { namespace } = this.getFunctionConfig()
+
+        const params = {
+            Namespace: namespace,
+            FunctionName: name,
+            Offset: offset,
+            Limit: limit,
+            Order: order,
+            OrderBy: orderBy,
+            StartTime: startTime,
+            EndTime: endTime,
+            FunctionRequestId: requestId
+        }
+
+        const res: IFunctionLogRes = await this.scfService.request('GetFunctionLogs', params)
+        return res
+    }
+
+    /**
+     * 更新云函数配置
+     * @param {ICloudFunction} func 云函数配置
+     * @returns {Promise<IResponseInfo>}
+     */
+    @preLazy()
+    async updateFunctionConfig(func: ICloudFunction): Promise<IResponseInfo> {
+        const { namespace } = this.getFunctionConfig()
+
+        const envVariables = Object.keys(func.envVariables || {}).map(key => ({
+            Key: key,
+            Value: func.envVariables[key]
+        }))
+
+        // 当不存在 L5 配置时，不修改 L5 状态，否则根据 true/false 进行修改
+        const l5Enable = typeof func.l5 === 'undefined' ? null : func.l5 ? 'TRUE' : 'FALSE'
+
+        const params: any = {
+            FunctionName: func.name,
+            Namespace: namespace,
+            L5Enable: l5Enable
+        }
+
+        // 修复参数存在 undefined 字段时，会出现鉴权失败的情况
+        // Environment 为覆盖式修改，不保留已有字段
+        envVariables.length && (params.Environment = { Variables: envVariables })
+        // 不设默认超时时间，防止覆盖已有配置
+        func.timeout && (params.Timeout = func.timeout)
+        // 运行时
+        func.runtime && (params.Runtime = func.runtime)
+
+        if (func?.vpc?.subnetId !== undefined && func?.vpc?.vpcId !== undefined) {
+            // VPC 网络
+            params.VpcConfig = {
+                SubnetId: func?.vpc?.subnetId,
+                VpcId: func?.vpc?.vpcId
+            }
+        }
+
+        // 内存
+        func.memorySize && (params.MemorySize = func.memorySize)
+
+        // Node 函数默认安装依赖
+        isNodeFunction(func.runtime) && (params.InstallDependency = 'TRUE')
+        // 是否安装依赖，选项可以覆盖
+        if (typeof func.installDependency !== 'undefined') {
+            params.InstallDependency = func.installDependency ? 'TRUE' : 'FALSE'
+        }
+
+        // 函数层
+        if (func?.layers?.length) {
+            const transformLayers = func.layers.map(item => ({
+                LayerName: item.name,
+                LayerVersion: item.version
+            }))
+            params.Layers = transformLayers
+        }
+
+        return this.scfService.request('UpdateFunctionConfiguration', params)
+    }
+
+    /**
+     *
+     * @param {IUpdateFunctionCodeParam} funcParam
+     * @returns {Promise<IResponseInfo>}
+     * @memberof FunctionService
+     */
+    @preLazy()
+    async updateFunctionCode(funcParam: IUpdateFunctionCodeParam): Promise<IResponseInfo> {
+        const { func, functionRootPath, base64Code, codeSecret, functionPath } = funcParam
+        const funcName = func.name
+
+        const { namespace } = this.getFunctionConfig()
+
+        let installDependency
+        // Node 函数默认安装依赖
+        installDependency = isNodeFunction(func.runtime) ? 'TRUE' : 'FALSE'
+        // 是否安装依赖，选项可以覆盖
+        if (typeof func.installDependency !== 'undefined') {
+            installDependency = func.installDependency ? 'TRUE' : 'FALSE'
+        }
+
+        const codeParams = await this.getCodeParams(
+            {
+                func,
+                functionPath,
+                functionRootPath,
+                base64Code
+            },
+            installDependency
+        )
+
+        const params: any = {
+            FunctionName: funcName,
+            Namespace: namespace,
+            Handler: func.handler || 'index.main',
+            InstallDependency: installDependency,
+            ...codeParams
+        }
+
+        if (codeSecret) {
+            params.CodeSecret = codeSecret
+        }
+
+        try {
+            // 等待函数状态正常
+            await this.waitFunctionActive(funcName, codeSecret)
+            // 更新云函数代码
+            const res = await this.scfService.request<IResponseInfo>('UpdateFunctionCode', params)
+            if (installDependency && func.isWaitInstall === true) {
+                await this.waitFunctionActive(funcName, codeSecret)
+            }
+            return res
+        } catch (e) {
+            throw new CloudBaseError(`[${funcName}] 函数代码更新失败： ${e.message}`, {
+                code: e.code
+            })
+        }
+    }
+
+    /**
+     * 调用云函数
+     * @param {string} name 云函数名称
+     * @param {Record<string, any>} params 调用函数传入参数
+     * @returns {Promise<IFunctionInvokeRes>}
+     */
+    @preLazy()
+    async invokeFunction(name: string, params?: Record<string, any>): Promise<IFunctionInvokeRes> {
+        const { namespace } = this.getFunctionConfig()
+
+        const _params: any = {
+            FunctionName: name,
+            Namespace: namespace,
+            LogType: 'Tail'
+        }
+
+        if (params) {
+            _params.ClientContext = JSON.stringify(params)
+        }
+
+        try {
+            const { RequestId, Result } = await this.scfService.request('Invoke', _params)
+            return {
+                RequestId,
+                ...Result
+            }
+        } catch (e) {
+            throw new CloudBaseError(`[${name}] 调用失败：\n${e.message}`)
+        }
+    }
+
+    /**
+     * 复制云函数
+     * @param {string} name 云函数名称
+     * @param {string} newFunctionName 新的云函数名称
+     * @param {string} targetEnvId 目标环境 Id
+     * @param {boolean} [force=false] 是否覆盖同名云函数
+     * @returns {Promise<IResponseInfo>}
+     */
+    /* eslint-disable-next-line */
+    @preLazy()
+    async copyFunction(
+        name: string,
+        newFunctionName: string,
+        targetEnvId?: string,
+        force = false
+    ): Promise<IResponseInfo> {
+        const { namespace } = this.getFunctionConfig()
+
+        if (!namespace || !name || !newFunctionName) {
+            throw new CloudBaseError('参数缺失')
+        }
+
+        return this.scfService.request('CopyFunction', {
+            FunctionName: name,
+            NewFunctionName: newFunctionName,
+            Namespace: namespace,
+            TargetNamespace: targetEnvId || namespace,
+            Override: force ? true : false
+        })
+    }
+
+    /**
+     * 创建云函数触发器
+     * @param {string} name 云函数名称
+     * @param {ICloudFunctionTrigger[]} triggers 云函数触发器配置
+     * @returns {Promise<IResponseInfo>}
+     */
+    @preLazy()
+    async createFunctionTriggers(
+        name: string,
+        triggers: ICloudFunctionTrigger[] = []
+    ): Promise<IResponseInfo> {
+        if (!triggers || !triggers.length) return null
+        const { namespace } = this.getFunctionConfig()
+
+        const parsedTriggers = triggers.map(item => {
+            if (item.type !== 'timer') {
+                throw new CloudBaseError(
+                    `不支持的触发器类型 [${item.type}]，目前仅支持定时触发器（timer）！`
+                )
+            }
+            return {
+                TriggerName: item.name,
+                Type: item.type,
+                TriggerDesc: item.config
+            }
+        })
+
+        return this.scfService.request('BatchCreateTrigger', {
+            FunctionName: name,
+            Namespace: namespace,
+            Triggers: JSON.stringify(parsedTriggers),
+            Count: parsedTriggers.length
+        })
+    }
+
+    /**
+     * 删除云函数触发器
+     * @param {string} name 云函数名称
+     * @param {string} triggerName 云函数触发器名称
+     * @returns {Promise<IResponseInfo>}
+     */
+    @preLazy()
+    async deleteFunctionTrigger(name: string, triggerName: string): Promise<IResponseInfo> {
+        const { namespace } = this.getFunctionConfig()
+
+        return this.scfService.request('DeleteTrigger', {
+            FunctionName: name,
+            Namespace: namespace,
+            TriggerName: triggerName,
+            Type: 'timer'
+        })
+    }
+
+    /**
+     * 获取云函数代码下载 链接
+     * @param {string} functionName
+     * @param {string} [codeSecret]
+     * @returns {Promise<IFunctionDownloadUrlRes>}
+     * @memberof FunctionService
+     */
+    @preLazy()
+    public async getFunctionDownloadUrl(
+        functionName: string,
+        codeSecret?: string
+    ): Promise<IFunctionDownloadUrlRes> {
+        const { namespace } = this.getFunctionConfig()
+
+        const params: any = {
+            FunctionName: functionName,
+            Namespace: namespace
+        }
+
+        if (codeSecret) {
+            params.CodeSecret = codeSecret
+        }
+
+        try {
+            const { Url, CodeSha256, RequestId } = await this.scfService.request(
+                'GetFunctionAddress',
+                params
+            )
+            return { Url, RequestId, CodeSha256 }
+        } catch (e) {
+            throw new CloudBaseError(`[${functionName}] 获取函数代码下载链接失败：\n${e.message}`)
+        }
+    }
+
+    // 创建文件层版本
+    @preLazy()
+    public async createLayer(options: IFunctionLayerOptions): Promise<ICreateLayerResponse> {
+        const { env } = this.getFunctionConfig()
+        const {
+            contentPath = '',
+            name,
+            base64Content = '',
+            runtimes = [],
+            description = '',
+            licenseInfo = ''
+        } = options
+
+        let base64
+
+        if (base64Content) {
+            base64 = base64Content
+        } else if (isDirectory(contentPath)) {
+            // 压缩文件夹
+            const dirName = path.parse(contentPath).name
+            const dest = path.join(process.cwd(), `temp-${dirName}.zip`)
+            // ZIP 文件存在，删除 ZIP 文件
+            if (checkFullAccess(dest)) {
+                delSync(dest)
+            }
+            await compressToZip({
+                dirPath: contentPath,
+                outputPath: dest
+            })
+            // 转换成 base64
+            const fileBuffer = await fs.promises.readFile(dest)
+            base64 = fileBuffer.toString('base64')
+            delSync(dest)
+        } else {
+            const fileType = path.extname(contentPath)
+            if (fileType !== '.zip') {
+                throw new CloudBaseError('文件类型不正确，目前只支持 ZIP 文件！')
+            }
+            const fileBuffer = await fs.promises.readFile(contentPath)
+            base64 = fileBuffer.toString('base64')
+        }
+
+        return this.scfService.request('PublishLayerVersion', {
+            LayerName: name,
+            CompatibleRuntimes: runtimes,
+            Content: {
+                // 最大支持 20M
+                ZipFile: base64
+            },
+            Description: description,
+            LicenseInfo: licenseInfo,
+            Src: `TCB_${env}`
+        })
+    }
+
+    // 删除文件层版本
+    @preLazy()
+    public async deleteLayerVersion(options: ILayerOptions): Promise<IResponseInfo> {
+        const { name, version } = options
+
+        return this.scfService.request('DeleteLayerVersion', {
+            LayerName: name,
+            LayerVersion: version
+        })
+    }
+
+    // 获取层版本列表
+    @preLazy()
+    public async listLayerVersions(options: IVersionListOptions): Promise<IListLayerVersionsRes> {
+        const { name, runtimes } = options
+        let param: any = {
+            LayerName: name
+        }
+        if (runtimes?.length) {
+            param.CompatibleRuntime = runtimes
+        }
+        return this.scfService.request('ListLayerVersions', param)
+    }
+
+    // 获取文件层列表
+    @preLazy()
+    public async listLayers(options: ILayerListOptions): Promise<IListLayerRes> {
+        const { env } = this.getFunctionConfig()
+        const { limit = 20, offset = 0, runtime, searchKey } = options
+        let param: any = {
+            Limit: limit,
+            Offset: offset,
+            SearchKey: searchKey,
+            SearchSrc: `TCB_${env}`
+        }
+        if (runtime) {
+            param.CompatibleRuntime = runtime
+        }
+
+        return this.scfService.request('ListLayers', param)
+    }
+
+    // 获取层版本详细信息
+    @preLazy()
+    public async getLayerVersion(options: ILayerOptions): Promise<IGetLayerVersionRes> {
+        const { name, version } = options
+
+        return this.scfService.request('GetLayerVersion', {
+            LayerName: name,
+            LayerVersion: version
+        })
+    }
+
+    /**
+     * 设置预置并发
+     * @private
+     * @param {IProvisionedConcurrencyConfig} concurrencyConfig
+     * @returns
+     * @memberof FunctionService
+     */
+    @preLazy()
+    public async setProvisionedConcurrencyConfig(
+        concurrencyConfig: ISetProvisionedConcurrencyConfig
+    ): Promise<IResponseInfo> {
+        const { namespace } = this.getFunctionConfig()
+        const {
+            functionName: FunctionName,
+            qualifier: Qualifier,
+            versionProvisionedConcurrencyNum: VersionProvisionedConcurrencyNum
+        } = concurrencyConfig
+
+        return this.scfService.request('PutProvisionedConcurrencyConfig', {
+            FunctionName,
+            Qualifier,
+            VersionProvisionedConcurrencyNum,
+            Namespace: namespace
+        })
+    }
+
+    /**
+     * 获取函数预置并发详情
+     * @private
+     * @param {IGetProvisionedConcurrencyConfig} concurrencyConfig
+     * @returns {Promise<IGetProvisionedConcurrencyRes>}
+     * @memberof FunctionService
+     */
+    @preLazy()
+    public async getProvisionedConcurrencyConfig(
+        concurrencyConfig: IGetProvisionedConcurrencyConfig
+    ): Promise<IGetProvisionedConcurrencyRes> {
+        const { namespace } = this.getFunctionConfig()
+        const { functionName: FunctionName, qualifier: Qualifier } = concurrencyConfig
+
+        return this.scfService.request('GetProvisionedConcurrencyConfig', {
+            FunctionName,
+            Qualifier,
+            Namespace: namespace
+        })
+    }
+
+    /**
+     * 删除预置并发
+     * @private
+     * @param {IGetProvisionedConcurrencyConfig} concurrencyConfig
+     * @returns {Promise<IResponseInfo>}
+     * @memberof FunctionService
+     */
+    @preLazy()
+    public async deleteProvisionedConcurrencyConfig(
+        concurrencyConfig: IGetProvisionedConcurrencyConfig
+    ): Promise<IResponseInfo> {
+        const { namespace } = this.getFunctionConfig()
+        const { functionName: FunctionName, qualifier: Qualifier } = concurrencyConfig
+
+        return this.scfService.request('DeleteProvisionedConcurrencyConfig', {
+            FunctionName,
+            Qualifier,
+            Namespace: namespace
+        })
+    }
+
+    /**
+     * 发布新版本
+     * @param {IPublishVersionParams} publishParams
+     * @returns {Promise<IPublishVersionRes>}
+     * @memberof FunctionService
+     */
+    @preLazy()
+    public async publishVersion(publishParams: IPublishVersionParams): Promise<IPublishVersionRes> {
+        const { namespace } = this.getFunctionConfig()
+        const { functionName: FunctionName, description: Description } = publishParams
+
+        return this.scfService.request('PublishVersion', {
+            FunctionName,
+            Description,
+            Namespace: namespace
+        })
+    }
+
+    /**
+     * 查询函数版本详情
+     * @param {IListFunctionVersionParams} listVersionParams
+     * @returns {Promise<IFunctionVersionsRes>}
+     * @memberof FunctionService
+     */
+    @preLazy()
+    public async listVersionByFunction(
+        listVersionParams: IListFunctionVersionParams
+    ): Promise<IFunctionVersionsRes> {
+        const { namespace } = this.getFunctionConfig()
+        const {
+            functionName: FunctionName,
+            offset: Offset,
+            limit: Limit,
+            order: Order,
+            orderBy: OrderBy
+        } = listVersionParams
+
+        return this.scfService.request('ListVersionByFunction', {
+            FunctionName,
+            Namespace: namespace,
+            Offset,
+            Limit,
+            Order,
+            OrderBy
+        })
+    }
+
+    /**
+     *
+     * @param {IUpdateFunctionAliasConfig} updateVersionConfigParams
+     * @returns {Promise<IResponseInfo>}
+     * @memberof FunctionService
+     */
+    @preLazy()
+    public async updateFunctionAliasConfig(
+        updateVersionConfigParams: IUpdateFunctionAliasConfig
+    ): Promise<IResponseInfo> {
+        const { namespace } = this.getFunctionConfig()
+        const {
+            functionName: FunctionName,
+            name: Name,
+            functionVersion: FunctionVersion,
+            routingConfig: RoutingConfig,
+            description: Description
+        } = updateVersionConfigParams
+
+        return this.scfService.request('UpdateAlias', {
+            FunctionName,
+            Name,
+            Namespace: namespace,
+            FunctionVersion,
+            RoutingConfig,
+            Description
+        })
+    }
+
+    /**
+     * 查询函数别名详情
+     * @param {IGetFunctionAlias} params
+     * @returns {Promise<IGetFunctionAliasRes>}
+     * @memberof FunctionService
+     */
+    @preLazy()
+    public async getFunctionAlias(params: IGetFunctionAlias): Promise<IGetFunctionAliasRes> {
+        const { namespace } = this.getFunctionConfig()
+        const { functionName: FunctionName, name: Name } = params
+
+        return this.scfService.request('GetAlias', {
+            FunctionName,
+            Name,
+            Namespace: namespace
+        })
+    }
+
+    @preLazy()
+    private async createAccessPath(name: string, path: string) {
+        const access = this.environment.getAccessService()
+        try {
+            await access.createAccess({
+                name,
+                path
+            })
+        } catch (e) {
+            // 当 Path 存在时，校验 Path 绑定的函数是不是当前函数
+            if (e.code === 'InvalidParameter.APICreated') {
+                const { APISet } = await access.getAccessList({
+                    name
+                })
+                if (APISet?.[0].Name !== name || APISet?.[0].Type !== 1) {
+                    throw e
+                }
+            } else {
+                throw e
+            }
+        }
+    }
+
+    @preLazy()
+    private async getCodeParams(options: IFunctionCode, installDependency: 'TRUE' | 'FALSE') {
+        const { func, functionPath, functionRootPath, base64Code } = options
+        // 20MB
+        const BIG_LENGTH = 167772160
+        if (base64Code?.length > BIG_LENGTH) {
+            throw new CloudBaseError('base64 不能大于 20 MB')
+        }
+
+        if (base64Code?.length) {
+            return {
+                ZipFile: base64Code
+            }
+        }
+
+        const codeType: CodeType = func.runtime === 'Java8' ? CodeType.JavaFile : CodeType.File
+        // 云端安装依赖，自动忽略 node_modules 目录
+        const ignore =
+            installDependency === 'TRUE'
+                ? ['node_modules/**/*', 'node_modules', ...(func.ignore || [])]
+                : [...(func.ignore || [])]
+
+        const packer = new FunctionPacker({
+            ignore,
+            codeType,
+            functionPath,
+            name: func.name,
+            root: functionRootPath
+        })
+
+        await packer.build()
+
+        // 通过云 API 传输的代码大小不能超过 50MB
+        const reachMax = await packer.isReachMaxSize()
+
+        if (reachMax) {
+            throw new CloudBaseError('函数代码不能大于 50MB')
+        }
+
+        const base64 = await packer.getBase64Code()
+        if (!base64?.length) {
+            throw new CloudBaseError('文件不能为空')
+        }
+        return {
+            ZipFile: base64
+        }
+    }
+
+    // 获取 COS 临时信息
+    @preLazy()
+    private async getTempCosInfo(name: string) {
+        const { env, appId } = await this.getFunctionConfig()
+
+        /**
+         * Response:
+         * Date: "2020-03-18"
+         * RequestId: "91876f56-7cd3-42bb-bc32-b74df5d0516e"
+         * Sign: "Gc8QvXD50dx7yBfsl2yEYFwIL45hPTEyNTM2NjU4MTkm
+         */
+        return this.scfService.request('GetTempCosInfo', {
+            ObjectPath: `${appId}/${env}/${name}.zip"`
+        })
+    }
+
+    private async retryCreateTrigger(name, triggers, count = 0) {
+        try {
+            const res = await this.createFunctionTriggers(name, triggers)
+            return res
+        } catch (e) {
+            if (count < 3) {
+                await sleep(500)
+                const res = await this.retryCreateTrigger(name, triggers, count + 1)
+                return res
+            } else {
+                throw e
+            }
+        }
+    }
+
+    /**
+     * 获取函数配置信息
+     * @private
+     * @returns
+     * @memberof FunctionService
+     */
+    private getFunctionConfig() {
+        const envConfig = this.environment.lazyEnvironmentConfig
+        const namespace = envConfig.Functions[0].Namespace
+        const appId = envConfig.Storages[0]?.AppId
+        const { proxy } = this.environment.cloudBaseContext
+
+        return {
+            proxy,
+            appId,
+            namespace,
+            env: envConfig.EnvId
+        }
+    }
+
+    /**
+     * 获取日志cls配置信息
+     */
+    private getClsServiceConfig() {
+        const currentEnv = this.environment.lazyEnvironmentConfig
+        const customLogServices = currentEnv?.CustomLogServices?.[0]
+        const logServices = currentEnv?.LogServices?.[0]
+        return {
+            TopicId: customLogServices?.ClsTopicId || logServices?.TopicId,
+            LogsetId: customLogServices?.ClsLogsetId || logServices?.LogsetId
+        }
+    }
+
+    /**
+     * 获取 vpc 信息
+     * @returns
+     */
+    private async getVpcs() {
+        const { VpcSet } = await this.vpcService.request('DescribeVpcs')
+        return VpcSet
+    }
+
+    /**
+     * 获取子网
+     * @param {string} vpcId
+     * @returns
+     */
+    private async getSubnets(vpcId: string) {
+        const { SubnetSet } = await this.vpcService.request('DescribeSubnets', {
+            Filters: [
+                {
+                    Name: 'vpc-id',
+                    Values: [vpcId]
+                }
+            ]
+        })
+        return SubnetSet
+    }
+
+    // 检查函数状态，部分操作在函数更新中时不可进行
+    private async waitFunctionActive(funcName: string, codeSecret?: string) {
+        let ticker
+        let timer
+        let resolved
+
+        return new Promise<void>((resolve, reject) => {
+            // 超时时间 5 分钟
+            timer = setTimeout(() => {
+                clearInterval(ticker)
+                if (!resolved) {
+                    reject(new CloudBaseError('函数状态异常，检查超时'))
+                }
+            }, 300000)
+
+            ticker = setInterval(async () => {
+                try {
+                    const { Status } = await this.getFunctionDetail(funcName, codeSecret)
+                    // 更新中
+                    if (Status === SCF_STATUS.CREATING || Status === SCF_STATUS.UPDATING) return
+                    // 创建失败
+                    if (Status === SCF_STATUS.CREATE_FAILED) {
+                        throw new CloudBaseError('云函数创建失败')
+                    }
+                    // 函数状态正常
+                    clearInterval(ticker)
+                    clearTimeout(timer)
+                    resolve()
+                } catch (e) {
+                    clearInterval(ticker)
+                    clearTimeout(timer)
+                    reject(e)
+                }
+                resolved = true
+            }, 1000)
+        })
+    }
+}