diff --git a/.oebuild/workflows/build_common.groovy b/.oebuild/workflows/build_common.groovy
index 3d56fa153d3bc98afdd53bda16c59a95a89418e5..e2d72a508b9be3a3b1a081c64199f5a64f7211fb 100644
--- a/.oebuild/workflows/build_common.groovy
+++ b/.oebuild/workflows/build_common.groovy
@@ -1,22 +1,34 @@
 STAGES_RES = []
-OEBUILD_DIR = "/home/jenkins/oebuild_workspace"
-AGENT = "/home/jenkins/agent"
-LOG_DIR = "openeuler/logs"
-YOCTO_NAME = "yocto-meta-openeuler"
+class Config{
+    static final String OEBUILD_DIR = "/home/jenkins/oebuild_workspace"
+    static final String AGENT = "/home/jenkins/agent"
+    static final String LOG_DIR = "openeuler/logs"
+    static final String YOCTO_NAME = "yocto-meta-openeuler"
+}
+
+def getConfig(String key){
+    return Config."${key}"
+}
 
 def downloadEmbeddedCI(String remote_url, String branch){
     sh 'rm -rf embedded-ci'
     sh "git clone ${remote_url} -b ${branch} -v embedded-ci --depth=1"
 }
 
-def downloadYoctoWithBranch(String workspace, String repo_remote, String branch, Integer deepth){
+def downloadYoctoWithBranch(String workspace,
+                        String repo_remote,
+                        String branch,
+                        Integer deepth){
     dir(workspace){
         sh 'rm -rf yocto-meta-openeuler'
         sh "git clone ${repo_remote} -b ${branch} --depth=${deepth}"
     }
 }
 
-def downloadYoctoWithPr(String workspace, String repo_remote, Integer prnum, Integer deepth){
+def downloadYoctoWithPr(String workspace,
+                    String repo_remote,
+                    Integer prnum,
+                    Integer deepth){
     dir(workspace){
         sh 'rm -rf yocto-meta-openeuler'
     }
@@ -24,7 +36,7 @@ def downloadYoctoWithPr(String workspace, String repo_remote, Integer prnum, Int
         python3 main.py clone_repo \
         -w ${workspace} \
         -r ${repo_remote} \
-        -p ${YOCTO_NAME} \
+        -p ${Config.YOCTO_NAME} \
         -pr ${prnum} \
         -dp ${deepth}
     """
@@ -59,7 +71,10 @@ def split_build(String build_images, String parallel_str_num){
     return build_list
 }
 
-def formatRes(String name, String action, String check_res, String log_path){
+def formatRes(String name,
+            String action,
+            String check_res,
+            String log_path){
     return sh (script: """
         python3 main.py serial \
             -c name=${name} \
@@ -82,15 +97,15 @@ def getRandomStr(){
 }
 
 def mkdirOpeneulerLog(){
-    dir(AGENT){
-        sh "mkdir -p ${LOG_DIR}"
+    dir(Config.AGENT){
+        sh "mkdir -p ${Config.LOG_DIR}"
     }
 }
 
 def artifactsLogs(){
-    dir(AGENT){
-        sh "ls -al ${LOG_DIR}"
-        archiveArtifacts artifacts: "${LOG_DIR}/*.log", fingerprint: true
+    dir(Config.AGENT){
+        sh "ls -al ${Config.LOG_DIR}"
+        archiveArtifacts artifacts: "${Config.LOG_DIR}/*.log", fingerprint: true
     }
 }
 
@@ -100,24 +115,59 @@ def getNowDatetime(){
     """, returnStdout: true).trim()
 }
 
-def uploadTarImageWithKey(String remote_ip, String remote_dir, String username, String remote_key, String local_dir){
+def uploadTarImageWithKey(String remote_ip,
+                        String remote_port,
+                        String remote_dir,
+                        String username,
+                        String remote_key,
+                        String local_dir){
     sh """
         timestamp=`basename ${local_dir}`
         dir_name=`dirname ${local_dir}`
         cd \${dir_name}
         tar zcf \${timestamp}.tar.gz \${timestamp}
-        ssh -i ${remote_key} -o 'StrictHostKeyChecking no' ${username}@${remote_ip} "mkdir -p ${remote_dir}"
-        scp -i ${remote_key} -o 'StrictHostKeyChecking no' \${timestamp}.tar.gz ${username}@${remote_ip}:${remote_dir}
+        ssh -i ${remote_key} -p ${remote_port} -o 'StrictHostKeyChecking no' ${username}@${remote_ip} "mkdir -p ${remote_dir}"
+        scp -i ${remote_key} -p ${remote_port} -o 'StrictHostKeyChecking no' \${timestamp}.tar.gz ${username}@${remote_ip}:${remote_dir}
+    """
+}
+
+def uploadTarImageWithUserName(String remote_ip,
+                            String remote_port,
+                            String remote_dir,
+                            String username,
+                            String remote_pwd,
+                            String local_dir){
+    sh """
+        timestamp=`basename ${local_dir}`
+        dir_name=`dirname ${local_dir}`
+        pushd \${dir_name}
+        tar zcf \${timestamp}.tar.gz \${timestamp}
+        popd
+
+        python3 main.py put_to_dst \
+            -t 0 \
+            -ld $local_dir/../\${timestamp}.tar.gz \
+            -dd $remote_dir \
+            -i $remote_ip \
+            -p $remote_port \
+            -u $username \
+            -w $remote_pwd
     """
 }
 
-def uploadImageWithKey(String remote_ip, String remote_dir, String username, String remote_key, String local_dir){
+def uploadImageWithKey(String remote_ip,
+                        String remote_port,
+                        String remote_dir,
+                        String username,
+                        String remote_key,
+                        String local_dir){
     sh """
         python3 main.py put_to_dst \
         -t 0 \
+        -i $remote_ip \
+        -p $remote_port \
         -ld $local_dir \
         -dd $remote_dir \
-        -i $remote_ip \
         -u $username \
         -k $remote_key \
         -sign \
@@ -134,24 +184,65 @@ def putSStateCacheToDst(String local_dir, String dst_dir){
     """
 }
 
-def uploadLogWithKey(String remote_ip, String remote_dir, String username, String remote_key, String local_path){
+def uploadLogWithKey(String remote_ip,
+                    String remote_dir,
+                    String username,
+                    String remote_key,
+                    String local_path){
     sh """
         scp -i ${remote_key} -o 'StrictHostKeyChecking no' ${local_path} ${username}@${remote_ip}:${remote_dir}
     """
 }
 
+def uploadLogWithUserName(String remote_ip,
+                        String remote_port,
+                        String remote_dir,
+                        String username,
+                        String remote_pwd,
+                        String local_path){
+    sh """
+        python3 main.py put_to_dst \
+        -t 0 \
+        -ld $local_path \
+        -dd $remote_dir \
+        -i $remote_ip \
+        -p $remote_port \
+        -u $username \
+        -w $remote_pwd
+    """
+}
+
 def handleLog(String log_file){
-    log_path = "${LOG_DIR}/${log_file}"
+    def log_path = "${Config.LOG_DIR}/${log_file}"
     if (env.isUploadLog != null && env.isUploadLog == "true"){
-        withCredentials([
-            file(credentialsId: openEulerLogRemoteKey, variable: 'openEulerLogKey')
-        ]){
-            def local_log_path = "${AGENT}/${log_path}"
-            uploadLogWithKey(openEulerLogRemoteIP,
-                            openEulerLogRemoteDir,
-                            openEulerLogRemoteUser,
-                            openEulerLogKey,
-                            local_log_path)
+        if (env.openEulerLogCreditType == "UserKey"){
+            withCredentials([
+                file(credentialsId: openEulerLogRemoteId, variable: 'openEulerLogKey')
+            ]){
+                def local_log_path = "${Config.AGENT}/${log_path}"
+                uploadLogWithKey(openEulerLogRemoteIP,
+                                openEulerLogRemoteDir,
+                                openEulerLogRemoteUser,
+                                openEulerLogKey,
+                                local_log_path)
+            }
+        }
+
+        if (env.openEulerLogCreditType == "UserPwd"){
+            withCredentials([
+                usernamePassword(
+                    credentialsId: openEulerLogRemoteId,
+                    usernameVariable: 'openEulerLogUser',
+                    passwordVariable: 'openEulerLogPwd')
+            ]){
+                def local_log_path = "${Config.AGENT}/${log_path}"
+                uploadLogWithUserName(openEulerLogRemoteIP,
+                                openEulerLogRemotePort,
+                                openEulerLogRemoteDir,
+                                openEulerLogUser,
+                                openEulerLogPwd,
+                                local_log_path)
+            }
         }
         log_path = "${openEulerLogRemoteUrl}/${log_file}"
     }else{
@@ -173,15 +264,35 @@ def handleAfterBuildImage(String image_name,
         if (env.isUploadImg != null && env.isUploadImg == "true"){
             // put the image to remote server
             def remote_dir = openEulerImgRemoteDir+"/${arch}/${image_name}"
-            def local_dir = "${OEBUILD_DIR}/build/${image_name}/output/${image_date}/"
-            withCredentials([
-                file(credentialsId: env.openEulerImgRemoteKey, variable: 'openEulerImgKey')
-            ]){
-                uploadTarImageWithKey(openEulerImgRemoteIP,
-                                remote_dir,
-                                openEulerImgRemoteUser,
-                                openEulerImgKey,
-                                local_dir)
+            def local_dir = "${Config.OEBUILD_DIR}/build/${image_name}/output/${image_date}/"
+            if (env.openEulerImgCreditType == "UserKey"){
+                withCredentials([
+                    file(credentialsId: env.openEulerImgRemoteId, variable: 'openEulerImgKey')
+                ]){
+                    uploadImageWithKey(
+                        openEulerImgRemoteIP,
+                        remote_dir,
+                        openEulerImgRemoteUser,
+                        openEulerImgKey,
+                        local_dir)
+                }
+            }
+            if (env.openEulerImgCreditType == "UserPwd"){
+                withCredentials([
+                    usernamePassword(
+                        credentialsId: openEulerImgRemoteId,
+                        usernameVariable: 'openEulerImgUser',
+                        passwordVariable: 'openEulerImgPwd')
+                ]){
+                    uploadTarImageWithUserName(
+                        openEulerImgRemoteIP,
+                        openEulerImgRemotePort,
+                        remote_dir,
+                        openEulerImgUser,
+                        openEulerImgPwd,
+                        local_dir
+                    )
+                }
             }
         }
         if (env.isSaveCache != null && env.isSaveCache == "true"){
@@ -190,7 +301,7 @@ def handleAfterBuildImage(String image_name,
             // sstate_origin_dir, we first copy it to a temporary folder (during copying,
             // soft links are defaulted to copy the actual files they point to), then delete
             // the source folder, and finally perform an mv operation.
-            def sstate_local_dir = "${OEBUILD_DIR}/build/${image_name}/sstate-cache"
+            def sstate_local_dir = "${Config.OEBUILD_DIR}/build/${image_name}/sstate-cache"
             def sstate_dst_dir = "${shareDir}/${ciBranch}/sstate-cache/${image_name}-temp"
             putSStateCacheToDst(sstate_local_dir, sstate_dst_dir)
             def sstate_origin_dir = "${shareDir}/${ciBranch}/sstate-cache/${image_name}"
@@ -206,23 +317,23 @@ def handleAfterBuildImage(String image_name,
                     python3 main.py utest \
                     -target openeuler_image \
                     -a ${arch} \
-                    -td ${OEBUILD_DIR}/build/${image_name} \
+                    -td ${Config.OEBUILD_DIR}/build/${image_name} \
                     -tm ${mugenRemote} \
-                    -tb ${mugenBranch} > ${AGENT}/${LOG_DIR}/Test-${image_name}-${random_str}.log
+                    -tb ${mugenBranch} > ${Config.AGENT}/${Config.LOG_DIR}/Test-${image_name}-${random_str}.log
                 """, returnStatus: true)
                 if (test_res_code == 0){
                     test_res = "success"
                 }
-                log_file = "Test-${image_name}-${random_str}.log"
-                log_path = handleLog(log_file)
+                def log_file = "Test-${image_name}-${random_str}.log"
+                def log_path = handleLog(log_file)
                 STAGES_RES.push(formatRes(image_name, "test", test_res, log_path))
             }
         }
     }
 
     // if need to upload log to remote
-    log_file = "Build-${image_name}-${random_str}.log"
-    log_path = handleLog(log_file)
+    def log_file = "Build-${image_name}-${random_str}.log"
+    def log_path = handleLog(log_file)
     STAGES_RES.push(formatRes(image_name, "build", build_res, log_path))
 }
 
@@ -271,18 +382,18 @@ def dynamicBuild(String yocto_dir,
                 String image_date,
                 String random_str,
                 String cache_src_dir){
-    compile_path = translateCompileToHost(yocto_dir, arch, image_name, image_date, cache_src_dir)
+    def compile_path = translateCompileToHost(yocto_dir, arch, image_name, image_date, cache_src_dir)
     // prepare oebuild build environment
     def task_res_code = sh (script: """
-        oebuild init ${OEBUILD_DIR}
-        cd ${OEBUILD_DIR}
+        oebuild init ${Config.OEBUILD_DIR}
+        cd ${Config.OEBUILD_DIR}
         mkdir -p build
         ln -sf ${yocto_dir} src/yocto-meta-openeuler
-        oebuild ${compile_path} > ${AGENT}/${LOG_DIR}/Build-${image_name}-${random_str}.log
+        oebuild ${compile_path} > ${Config.AGENT}/${Config.LOG_DIR}/Build-${image_name}-${random_str}.log
     """, returnStatus: true)
     handleAfterBuildImage(image_name, arch, task_res_code, random_str, image_date)
     // delete build directory
-    deleteBuildDir(OEBUILD_DIR + "/build/" + image_name)
+    deleteBuildDir(Config.OEBUILD_DIR + "/build/" + image_name)
 }
 
 def stashRepo(String workdir,String stash_name){
@@ -323,11 +434,11 @@ def buildTask(String build_imgs, String image_date){
     dir('/home/jenkins/agent/embedded-ci'){
         def randomStr = getRandomStr()
         mkdirOpeneulerLog()
-        cacheSrcDir = "$shareDir/$ciBranch/oebuild_workspace/src"
+        def cacheSrcDir = "$shareDir/$ciBranch/oebuild_workspace/src"
         for (imageName in build_imgs.split()){
             println "build ${imageName} ..."
-            imageSplit = imageName.split("/")
-            yoctoDir = "/home/jenkins/agent/yocto-meta-openeuler"
+            def imageSplit = imageName.split("/")
+            def yoctoDir = "/home/jenkins/agent/yocto-meta-openeuler"
             dynamicBuild(yoctoDir,
                         imageSplit[0],
                         imageSplit[1],
@@ -342,28 +453,35 @@ def buildTask(String build_imgs, String image_date){
 def get_remote_images(String base_url) {
     def code = """
 import requests
-import subprocess
-try:
-    from bs4 import BeautifulSoup
-except ModuleNotFoundError:
-    subprocess.call(args="pip install bs4 -i https://pypi.tuna.tsinghua.edu.cn/simple",
-                    stdout=subprocess.DEVNULL,
-                    stderr=subprocess.DEVNULL,
-                    shell=True)
-    subprocess.call(args="pip install lxml -i https://pypi.tuna.tsinghua.edu.cn/simple",
-                    stdout=subprocess.DEVNULL,
-                    stderr=subprocess.DEVNULL,
-                    shell=True)
-    from bs4 import BeautifulSoup
 import re
+import html.parser
+
+class PreTextParser(html.parser.HTMLParser):
+    def __init__(self):
+        super().__init__()
+        self.in_pre = False
+        self.pre_content = []
+    
+    def handle_starttag(self, tag, attrs):
+        if tag.lower() == 'pre':
+            self.in_pre = True
+    
+    def handle_endtag(self, tag):
+        if tag.lower() == 'pre':
+            self.in_pre = False
+    
+    def handle_data(self, data):
+        if self.in_pre:
+            self.pre_content.append(data)
 
 def get_pre_text(url, typ):
     res = []
     content = requests.get(url)
-    resHTML = content.text
-    soup = BeautifulSoup(resHTML, 'lxml')
-    for item in soup.pre.children:
-        for dir_name in item.text.split(" "):
+    parser = PreTextParser()
+    parser.feed(content.text)
+    
+    for text in parser.pre_content:
+        for dir_name in text.split():
             if typ == "dir" and dir_name.endswith("/") and not dir_name.startswith("."):
                 res.append(dir_name)
                 continue
@@ -379,18 +497,20 @@ for image in image_list:
     time_list = get_pre_text(base_url + "/" + image, "gz")
     tmp_times = []
     for time_name in time_list:
-        match = re.search("^[0-9]{14}(.tar.gz)\$", time_name)
+        match = re.search("^[0-9]{14}(.tar.gz)", time_name)
         if match:
             tmp_times.append(time_name.replace(".tar.gz", ""))
     tmp_times.sort(reverse=True)
     if len(tmp_times) > 0:
         target_list.append(image + tmp_times[0])
-
 print(" ".join(target_list))
 """
 
+println "base_url: $base_url"
+
 file_name = getRandomStr()
 writeFile file: file_name, text: code, encoding: "UTF-8"
+
 return sh (script: """
     python3 ${file_name}
 """, returnStdout: true).trim()
diff --git a/.oebuild/workflows/init_env.groovy b/.oebuild/workflows/init_env.groovy
index ff60333d90d7b26e539ca6cfe56b01cb026da3f3..5b96c67c02873dddb1936356f12214b310a53ce6 100644
--- a/.oebuild/workflows/init_env.groovy
+++ b/.oebuild/workflows/init_env.groovy
@@ -25,42 +25,57 @@ def init_environment(){
     }
     // set remote log
     if (env.isUploadLog == null || env.isUploadLog == ""){
-        env.isUploadLog = "false"
+        env.isUploadLog = "true"
     }
     if (env.openEulerLogRemoteIP == null || env.openEulerLogRemoteIP == ""){
-        env.openEulerLogRemoteIP = "43.136.114.130"
+        env.openEulerLogRemoteIP = "39.155.145.68"
+    }
+    if (env.openEulerLogRemotePort == null || env.openEulerLogRemotePort == ""){
+        env.openEulerLogRemotePort = "22"
     }
     if (env.openEulerLogRemoteUser == null || env.openEulerLogRemoteUser == ""){
-        env.openEulerLogRemoteUser = "openeuler"
+        env.openEulerLogRemoteUser = "root"
+    }
+    if (env.openEulerLogRemoteId == null || env.openEulerLogRemoteId == ""){
+        env.openEulerLogRemoteId = "AF-Logs-Node-secret"
     }
-    if (env.openEulerLogRemoteKey == null || env.openEulerLogRemoteKey == ""){
-        env.openEulerLogRemoteKey = "openEulerEmbeddedRemoteKey"
+    if (env.openEulerLogCreditType == null || env.openEulerLogCreditType == ""){
+        env.openEulerLogCreditType = "UserPwd"
     }
     if (env.openEulerLogRemoteDir == null || env.openEulerLogRemoteDir == ""){
-        env.openEulerLogRemoteDir = "/var/www/html/openeuler-log"
+        env.openEulerLogRemoteDir = "/data/logs/embedded-log"
     }
     if (env.openEulerLogRemoteUrl == null || env.openEulerLogRemoteUrl == ""){
-        env.openEulerLogRemoteUrl = "http://43.136.114.130/openeuler-log"
+        env.openEulerLogRemoteUrl = "https://build-logs.openeuler.openatom.cn:38080/embedded-log"
     }
     // set remote image
     if (env.isUploadImg == null || env.isUploadImg == ""){
-        env.isUploadImg = "false"
+        env.isUploadImg = "true"
     }
     if (env.openEulerImgRemoteIP == null || env.openEulerImgRemoteIP == ""){
-        env.openEulerImgRemoteIP = "43.136.114.130"
+        env.openEulerImgRemoteIP = "39.155.145.68"
+    }
+    if (env.openEulerImgRemotePort == null || env.openEulerImgRemotePort == ""){
+        env.openEulerImgRemotePort = "22"
     }
     if (env.openEulerImgRemoteUser == null || env.openEulerImgRemoteUser == ""){
-        env.openEulerImgRemoteUser = "openeuler"
+        env.openEulerImgRemoteUser = "root"
     }
-    if (env.openEulerImgRemoteKey == null || env.openEulerImgRemoteKey == ""){
-        env.openEulerImgRemoteKey = "openEulerEmbeddedRemoteKey"
+    if (env.openEulerImgRemoteId == null || env.openEulerImgRemoteId == ""){
+        env.openEulerImgRemoteId = "AF-Logs-Node-secret"
+    }
+    if (env.openEulerImgCreditType == null || env.openEulerImgCreditType == ""){
+        env.openEulerImgCreditType = "UserPwd"
     }
     if (env.openEulerImgRemoteDir == null || env.openEulerImgRemoteDir == ""){
-        env.openEulerImgRemoteDir = "/var/www/html/openeuler-ci/openEuler-24.03-LTS"
+        env.openEulerImgRemoteDir = "/data/logs/packages/openEuler-24.03-LTS"
+    }
+    if (env.openEulerImgRemoteUrl == null || env.openEulerImgRemoteUrl == ""){
+        env.openEulerImgRemoteUrl = "https://build-logs.openeuler.openatom.cn:38080/packages"
     }
     // set comment
     if (env.isComment == null || env.isComment == ""){
-        env.isComment = "false"
+        env.isComment = "true"
     }
     if (env.giteeId == null || env.giteeId == ""){
         env.giteeId = "gitee-api-token"
@@ -88,10 +103,10 @@ def init_environment(){
         env.buildImages = "aarch64/qemu-aarch64 aarch64/hieulerpi1 arm32/qemu-arm riscv/qemu-riscv54 x86-64/x86-64"
     }
     if (env.baseImgUrl == null  || env.baseImgUrl == ""){
-        env.baseImgUrl = "http://43.136.114.130/openeuler-ci/openEuler-24.03-LTS"
+        env.baseImgUrl = "https://build-logs.openeuler.openatom.cn:38080/packages/openEuler-24.03-LTS"
     }
     if (env.targetImgUrl == null || env.targetImgUrl == ""){
-        env.targetImgUrl = "http://121.36.84.172/dailybuild/EBS-openEuler-24.03-LTS/EBS-openEuler-24.03-LTS/embedded_img"
+        env.targetImgUrl = "http://121.36.84.172/dailybuild/EBS-openEuler-24.03-LTS/embedded_img"
     }
     if (env.archList == null || env.archList == ""){
         env.archList = "aarch64 arm32 x86-64 riscv64"
diff --git a/.oebuild/workflows/jenkinsfile_ci b/.oebuild/workflows/jenkinsfile_ci
index e569ab532320755ca7b4ac8c1f7fc75e8460ed84..26a2a38ae7807b3763ee86bac79773913e4066d9 100644
--- a/.oebuild/workflows/jenkinsfile_ci
+++ b/.oebuild/workflows/jenkinsfile_ci
@@ -19,10 +19,10 @@ pipeline {
                             unstash(name: "scm")
                             BUILD_COM = load '.oebuild/workflows/build_common.groovy'
                             IMAGE_DATE = BUILD_COM.getNowDatetime()
-                            INIT_ENV = load '.oebuild/workflows/init_env.groovy'
+                            def INIT_ENV = load '.oebuild/workflows/init_env.groovy'
                             INIT_ENV.init_environment()
                             BUILD_IMGS = BUILD_COM.split_build(env.buildImages, env.parallelNum)
-                        } 
+                        }
                         dir('/home/jenkins/agent'){
                             BUILD_COM.downloadEmbeddedCI(embeddedRemote, embeddedBranch)
                         }
diff --git a/.oebuild/workflows/jenkinsfile_gate b/.oebuild/workflows/jenkinsfile_gate
index 48f7e9942d07515581f851bbfd7d5d9ab4ce44b9..e59918f6eee77c3b2e3bc0df60fd642ef505a2b5 100644
--- a/.oebuild/workflows/jenkinsfile_gate
+++ b/.oebuild/workflows/jenkinsfile_gate
@@ -2,7 +2,7 @@ def BUILD_COM
 def IMAGE_DATE = ""
 
 pipeline {
-    agent any
+    agent { node "${node}" }
     environment {
         PATH = "/home/jenkins/.local/bin:${env.PATH}"
     }
@@ -78,7 +78,7 @@ pipeline {
                     node("${node}"){
                         BUILD_COM.unstashRepo('/home/jenkins/agent', 'embedded-ci')
                         BUILD_COM.unstashRepo('/home/jenkins/agent', 'yocto-meta-openeuler')
-                        def logDir = BUILD_COM.AGENT+"/"+BUILD_COM.LOG_DIR
+                        def logDir = BUILD_COM.getConfig('AGENT')+"/"+BUILD_COM.getConfig('LOG_DIR')
                         dir('/home/jenkins/agent/embedded-ci'){
                             // check commit_msg
                             withCredentials([string(credentialsId: "${giteeId}", variable: 'GITEETOKEN')]){
@@ -109,7 +109,7 @@ pipeline {
                                         "check",
                                         "commit_check",
                                         checkRes,
-                                        "artifact/${BUILD_COM.LOG_DIR}/${randomStr}.log"))
+                                        "artifact/${BUILD_COM.getConfig('LOG_DIR')}/${randomStr}.log"))
                             }
                             // check commit_scope
                             withCredentials([string(credentialsId: "${giteeId}", variable: 'GITEETOKEN')]){
@@ -140,7 +140,7 @@ pipeline {
                                         "check",
                                         "scope_check",
                                         checkRes,
-                                        "artifact/${BUILD_COM.LOG_DIR}/${randomStr}.log"))
+                                        "artifact/${BUILD_COM.getConfig('LOG_DIR')}/${randomStr}.log"))
                             }
                         }
                     }
@@ -165,7 +165,7 @@ pipeline {
                             node("${node}"){
                                 BUILD_COM.unstash('/home/jenkins/agent', 'embedded-ci')
                                 BUILD_COM.unstash('/home/jenkins/agent', 'yocto-meta-openeuler')
-                                def logDir = BUILD_COM.AGENT+"/"+BUILD_COM.LOG_DIR
+                                def logDir = BUILD_COM.getConfig('AGENT')+"/"+BUILD_COM.getConfig('LOG_DIR')
                                 dir('/home/jenkins/agent/embedded-ci'){
                                     // 执行docs编译
                                     def randomStr = BUILD_COM.getRandomStr()
@@ -190,7 +190,7 @@ pipeline {
                                             "docs",
                                             "build",
                                             checkRes,
-                                            "artifact/${BUILD_COM.LOG_DIR}/${randomStr}.log"))
+                                            "artifact/${BUILD_COM.getConfig('LOG_DIR')}/${randomStr}.log"))
                                 }
                             }
                         }
diff --git a/.oebuild/workflows/jenkinsfile_sync_image b/.oebuild/workflows/jenkinsfile_sync_image
index 9e981d44a389b2634ce41d81fb337112ebab6a40..49c371adb7c07cef347518cef8e09250d017207e 100644
--- a/.oebuild/workflows/jenkinsfile_sync_image
+++ b/.oebuild/workflows/jenkinsfile_sync_image
@@ -19,7 +19,7 @@ pipeline {
                 dir('/home/jenkins/agent/embedded-ci'){
                     script{
                         for (arch in env.archList.split(" ")) {
-                            def image_list = BUILD_COM.get_remote_images(env.baseImgUrl+"/"+arch)
+                            def image_list = BUILD_COM.get_remote_images(env.baseImgUrl+"/"+arch+"/")
                             println(image_list)
                             for (image in image_list.split(" ")) {
                                 if(image.contains("/") == false){
@@ -29,7 +29,7 @@ pipeline {
                                 // 检查远程目录是否存在
                                 if (BUILD_COM.remote_address_exists(env.targetImgUrl+"/"+arch+"/"+image) == "no"){
                                     withCredentials([
-                                        file(credentialsId: env.openEulerImgRemoteKey, variable: 'openEulerImgKey')
+                                        file(credentialsId: env.openEulerImgRemoteId, variable: 'openEulerImgKey')
                                     ]){
                                         def file_link = env.baseImgUrl+"/"+arch+"/"+image+".tar.gz"
                                         //下载压缩包
@@ -37,15 +37,15 @@ pipeline {
                                             mkdir -p /home/jenkins/agent/upload
                                             cd /home/jenkins/agent/upload
                                             wget $file_link -q
-                                            tar_file=`basename $file_link`
-                                            tar zxf \$tar_file
-                                            rm -f \$tar_file
+                                            tar zxf `basename $file_link`
+                                            rm -f `basename $file_link`
                                         """
                                         def image_name = image.split("/")[0]
                                         def remote_dir = env.openEulerImgRemoteDir+"/${arch}/${image_name}"
                                         def local_dir = "/home/jenkins/agent/upload"
                                         BUILD_COM.uploadImageWithKey(
                                             openEulerImgRemoteIP,
+                                            openEulerImgRemotePort,
                                             remote_dir,
                                             openEulerImgRemoteUser,
                                             openEulerImgKey,