更改删除jenkins机器上旧镜像步骤

SCM/build_image_flymoon_admin.groovy

@@ -152,10 +152,7 @@ pipeline {
                 script {
                     // 推送主镜像（带唯一 Tag）
                     sh "docker push ${REGISTRY}/${NAMESPACE}/${IMAGE_NAME}:${IMAGE_TAG}"
-
+                    echo "推送镜像成功：${REGISTRY}/${NAMESPACE}/${IMAGE_NAME}:${IMAGE_TAG}"
-                    // 推送 latest 标签（包含命名空间）
-                    sh "docker tag ${REGISTRY}/${NAMESPACE}/${IMAGE_NAME}:${IMAGE_TAG} ${REGISTRY}/${NAMESPACE}/${IMAGE_NAME}:latest"
-                    sh "docker push ${REGISTRY}/${NAMESPACE}/${IMAGE_NAME}:latest"
                 }
             }
         }
@@ -164,39 +161,41 @@ pipeline {
     post {
         always {
             script {
-                echo "开始清理本地旧镜像，仅保留最近 3 个构建版本 + latest"
+                echo "开始清理本地旧镜像，仅保留最近 1 个构建版本"
-                // 保留镜像数量
+                def keepCount =1
-                def keepCount = 3
                 def imagePrefix = "${REGISTRY}/${NAMESPACE}/${IMAGE_NAME}"
-                // 获取当前镜像的 IMAGE ID
+
-                def currentImageId = sh(script: "docker images -q ${imagePrefix}:${IMAGE_TAG}", returnStdout: true).trim()
+                // 获取所有镜像（按创建时间排序，越新的越前）
-                // 获取所有该镜像的本地版本（按创建时间排序）
+                def allImagesRaw = sh(script: "docker images ${imagePrefix} --format '{{.Repository}}:{{.Tag}} {{.CreatedAt}}' | sort -rk2", returnStdout: true).trim()
-                def allImages = sh(script: "docker images ${imagePrefix} --format '{{.ID}} {{.Tag}}' | sort -rk2", returnStdout: true).trim().split('\n')
+                if (!allImagesRaw) {
-                if (allImages.size() > keepCount + 1) { // +1 保留 latest
+                    echo "未找到任何镜像，无需清理"
-                    def oldImages = allImages.drop(keepCount + 1)
+                    return
+                }
+
+                def allImages = allImagesRaw.split('\n')
+                if (allImages.size() <= keepCount) {
+                    echo "当前镜像数未超过 ${keepCount} 个，无需清理"
+                    return
+                }
+
+                def oldImages = allImages.drop(keepCount)
                 echo "发现 ${oldImages.size()} 个旧镜像需要清理"
 
                 oldImages.each { line ->
-                        def parts = line.split(' ')
+                    def imageTag = line.split(' ')[0]
-                        def imageId = parts[0]
+                    if (imageTag.contains("<none>")) {
-                        def tag = parts[1]
+                        echo "跳过无效镜像：${imageTag}"
+                        return
+                    }
+                    echo "删除旧镜像: ${imageTag}"
+                    sh(returnStatus: true, script: "docker rmi -f ${imageTag} || true")
+                }
 
-                        if (tag == "<none>") {
+                echo "清理完成，当前镜像状态："
-                            echo "删除旧镜像（无标签）: ${imageId}"
-                            sh(returnStatus: true, script: "docker rmi -f ${imageId}")
-                        } else if (tag != "latest") {
-                            echo "删除旧镜像: ${imagePrefix}:${tag}"
-                            sh(returnStatus: true, script: "docker rmi -f ${imagePrefix}:${tag}")
-                        }
-                    }
-                } else {
-                    echo "当前镜像数未超过 ${keepCount + 1} 个，无需清理"
-                }
                 sh """
-                    echo "当前镜像状态："
+                    docker images ${imagePrefix} --format 'table {{.Repository}}\\t{{.Tag}}\\t{{.CreatedAt}}\\t{{.Size}}'
-                    docker images ${REGISTRY}/${NAMESPACE}/${IMAGE_NAME} --format 'table {{.Repository}}\\t{{.Tag}}\\t{{.CreatedAt}}\\t{{.Size}}'
                 """
-                // 无论成败都登出，清理凭证
+
                 sh "docker logout ${REGISTRY}"
                 echo "容器仓库已登出，本地凭证已清理"
             }
@@ -210,7 +209,7 @@ pipeline {
         }
         failure {
             // 输出构建结果
-            echo "镜像构建失败！"
+            echo "有步骤失败，请检查！"
         }
     }
 }

SCM/build_image_flymoon_agent.groovy

@@ -152,10 +152,7 @@ pipeline {
                 script {
                     // 推送主镜像（带唯一 Tag）
                     sh "docker push ${REGISTRY}/${NAMESPACE}/${IMAGE_NAME}:${IMAGE_TAG}"
-
+                    echo "推送镜像成功：${REGISTRY}/${NAMESPACE}/${IMAGE_NAME}:${IMAGE_TAG}"
-                    // 推送 latest 标签（包含命名空间）
-                    sh "docker tag ${REGISTRY}/${NAMESPACE}/${IMAGE_NAME}:${IMAGE_TAG} ${REGISTRY}/${NAMESPACE}/${IMAGE_NAME}:latest"
-                    sh "docker push ${REGISTRY}/${NAMESPACE}/${IMAGE_NAME}:latest"
                 }
             }
         }
@@ -164,39 +161,41 @@ pipeline {
     post {
         always {
             script {
-                echo "开始清理本地旧镜像，仅保留最近 3 个构建版本 + latest"
+                echo "开始清理本地旧镜像，仅保留最近 1 个构建版本"
-                // 保留镜像数量
+                def keepCount = 1
-                def keepCount = 3
                 def imagePrefix = "${REGISTRY}/${NAMESPACE}/${IMAGE_NAME}"
-                // 获取当前镜像的 IMAGE ID
+
-                def currentImageId = sh(script: "docker images -q ${imagePrefix}:${IMAGE_TAG}", returnStdout: true).trim()
+                // 获取所有镜像（按创建时间排序，越新的越前）
-                // 获取所有该镜像的本地版本（按创建时间排序）
+                def allImagesRaw = sh(script: "docker images ${imagePrefix} --format '{{.Repository}}:{{.Tag}} {{.CreatedAt}}' | sort -rk2", returnStdout: true).trim()
-                def allImages = sh(script: "docker images ${imagePrefix} --format '{{.ID}} {{.Tag}}' | sort -rk2", returnStdout: true).trim().split('\n')
+                if (!allImagesRaw) {
-                if (allImages.size() > keepCount + 1) { // +1 是因为还要保留 latest
+                    echo "未找到任何镜像，无需清理"
-                    def oldImages = allImages.drop(keepCount + 1)
+                    return
+                }
+
+                def allImages = allImagesRaw.split('\n')
+                if (allImages.size() <= keepCount) {
+                    echo "当前镜像数未超过 ${keepCount} 个，无需清理"
+                    return
+                }
+
+                def oldImages = allImages.drop(keepCount)
                 echo "发现 ${oldImages.size()} 个旧镜像需要清理"
 
                 oldImages.each { line ->
-                        def parts = line.split(' ')
+                    def imageTag = line.split(' ')[0]
-                        def imageId = parts[0]
+                    if (imageTag.contains("<none>")) {
-                        def tag = parts[1]
+                        echo "跳过无效镜像：${imageTag}"
+                        return
+                    }
+                    echo "删除旧镜像: ${imageTag}"
+                    sh(returnStatus: true, script: "docker rmi -f ${imageTag} || true")
+                }
 
-                        if (tag == "<none>") {
+                echo "清理完成，当前镜像状态："
-                            echo "删除旧镜像（无标签）: ${imageId}"
-                            sh(returnStatus: true, script: "docker rmi -f ${imageId}")
-                        } else if (tag != "latest") {
-                            echo "删除旧镜像: ${imagePrefix}:${tag}"
-                            sh(returnStatus: true, script: "docker rmi -f ${imagePrefix}:${tag}")
-                        }
-                    }
-                } else {
-                    echo "当前镜像数未超过 ${keepCount + 1} 个，无需清理"
-                }
                 sh """
-                    echo "当前镜像状态："
+                    docker images ${imagePrefix} --format 'table {{.Repository}}\\t{{.Tag}}\\t{{.CreatedAt}}\\t{{.Size}}'
-                    docker images ${REGISTRY}/${NAMESPACE}/${IMAGE_NAME} --format 'table {{.Repository}}\\t{{.Tag}}\\t{{.CreatedAt}}\\t{{.Size}}'
                 """
-                // 无论成败都登出，清理凭证
+
                 sh "docker logout ${REGISTRY}"
                 echo "容器仓库已登出，本地凭证已清理"
             }
@@ -210,7 +209,7 @@ pipeline {
         }
         failure {
             // 输出构建结果
-            echo "镜像构建失败！"
+            echo "有步骤出错！"
         }
     }
 }

SCM/build_image_flymoon_payment.groovy

@@ -152,10 +152,7 @@ pipeline {
                 script {
                     // 推送主镜像（带唯一 Tag）
                     sh "docker push ${REGISTRY}/${NAMESPACE}/${IMAGE_NAME}:${IMAGE_TAG}"
-
+                    echo "推送镜像成功：${REGISTRY}/${NAMESPACE}/${IMAGE_NAME}:${IMAGE_TAG}"
-                    // 推送 latest 标签（包含命名空间）
-                    sh "docker tag ${REGISTRY}/${NAMESPACE}/${IMAGE_NAME}:${IMAGE_TAG} ${REGISTRY}/${NAMESPACE}/${IMAGE_NAME}:latest"
-                    sh "docker push ${REGISTRY}/${NAMESPACE}/${IMAGE_NAME}:latest"
                 }
             }
         }
@@ -164,39 +161,41 @@ pipeline {
     post {
         always {
             script {
-                echo "开始清理本地旧镜像，仅保留最近 3 个构建版本 + latest"
+                echo "开始清理本地旧镜像，仅保留最近 1 个构建版本"
-                // 保留镜像数量
+                def keepCount =1
-                def keepCount = 3
                 def imagePrefix = "${REGISTRY}/${NAMESPACE}/${IMAGE_NAME}"
-                // 获取当前镜像的 IMAGE ID
+
-                def currentImageId = sh(script: "docker images -q ${imagePrefix}:${IMAGE_TAG}", returnStdout: true).trim()
+                // 获取所有镜像（按创建时间排序，越新的越前）
-                // 获取所有该镜像的本地版本（按创建时间排序）
+                def allImagesRaw = sh(script: "docker images ${imagePrefix} --format '{{.Repository}}:{{.Tag}} {{.CreatedAt}}' | sort -rk2", returnStdout: true).trim()
-                def allImages = sh(script: "docker images ${imagePrefix} --format '{{.ID}} {{.Tag}}' | sort -rk2", returnStdout: true).trim().split('\n')
+                if (!allImagesRaw) {
-                if (allImages.size() > keepCount + 1) { // +1 是因为还要保留 latest
+                    echo "未找到任何镜像，无需清理"
-                    def oldImages = allImages.drop(keepCount + 1)
+                    return
+                }
+
+                def allImages = allImagesRaw.split('\n')
+                if (allImages.size() <= keepCount) {
+                    echo "当前镜像数未超过 ${keepCount} 个，无需清理"
+                    return
+                }
+
+                def oldImages = allImages.drop(keepCount)
                 echo "发现 ${oldImages.size()} 个旧镜像需要清理"
 
                 oldImages.each { line ->
-                        def parts = line.split(' ')
+                    def imageTag = line.split(' ')[0]
-                        def imageId = parts[0]
+                    if (imageTag.contains("<none>")) {
-                        def tag = parts[1]
+                        echo "跳过无效镜像：${imageTag}"
+                        return
+                    }
+                    echo "删除旧镜像: ${imageTag}"
+                    sh(returnStatus: true, script: "docker rmi -f ${imageTag} || true")
+                }
 
-                        if (tag == "<none>") {
+                echo "清理完成，当前镜像状态："
-                            echo "删除旧镜像（无标签）: ${imageId}"
-                            sh(returnStatus: true, script: "docker rmi -f ${imageId}")
-                        } else if (tag != "latest") {
-                            echo "删除旧镜像: ${imagePrefix}:${tag}"
-                            sh(returnStatus: true, script: "docker rmi -f ${imagePrefix}:${tag}")
-                        }
-                    }
-                } else {
-                    echo "当前镜像数未超过 ${keepCount + 1} 个，无需清理"
-                }
                 sh """
-                    echo "当前镜像状态："
+                    docker images ${imagePrefix} --format 'table {{.Repository}}\\t{{.Tag}}\\t{{.CreatedAt}}\\t{{.Size}}'
-                    docker images ${REGISTRY}/${NAMESPACE}/${IMAGE_NAME} --format 'table {{.Repository}}\\t{{.Tag}}\\t{{.CreatedAt}}\\t{{.Size}}'
                 """
-                // 无论成败都登出，清理凭证
+
                 sh "docker logout ${REGISTRY}"
                 echo "容器仓库已登出，本地凭证已清理"
             }

SCM/build_image_go_lessie_sourcing_api.groovy

@@ -155,10 +155,7 @@ pipeline {
                 script {
                     // 推送主镜像（带唯一 Tag）
                     sh "docker push ${REGISTRY}/${NAMESPACE}/${IMAGE_NAME}:${IMAGE_TAG}"
-
+                    echo "推送镜像成功：${REGISTRY}/${NAMESPACE}/${IMAGE_NAME}:${IMAGE_TAG}"
-                    // 推送 latest 标签（包含命名空间）
-                    sh "docker tag ${REGISTRY}/${NAMESPACE}/${IMAGE_NAME}:${IMAGE_TAG} ${REGISTRY}/${NAMESPACE}/${IMAGE_NAME}:latest"
-                    sh "docker push ${REGISTRY}/${NAMESPACE}/${IMAGE_NAME}:latest"
                 }
             }
         }
@@ -166,39 +163,41 @@ pipeline {
     post {
         always {
             script {
-                echo "开始清理本地旧镜像，仅保留最近 3 个构建版本 + latest"
+                echo "开始清理本地旧镜像，仅保留最近 1 个构建版本"
-                // 保留镜像数量
+                def keepCount =1
-                def keepCount = 3
                 def imagePrefix = "${REGISTRY}/${NAMESPACE}/${IMAGE_NAME}"
-                // 获取当前镜像的 IMAGE ID
+
-                def currentImageId = sh(script: "docker images -q ${imagePrefix}:${IMAGE_TAG}", returnStdout: true).trim()
+                // 获取所有镜像（按创建时间排序，越新的越前）
-                // 获取所有该镜像的本地版本（按创建时间排序）
+                def allImagesRaw = sh(script: "docker images ${imagePrefix} --format '{{.Repository}}:{{.Tag}} {{.CreatedAt}}' | sort -rk2", returnStdout: true).trim()
-                def allImages = sh(script: "docker images ${imagePrefix} --format '{{.ID}} {{.Tag}}' | sort -rk2", returnStdout: true).trim().split('\n')
+                if (!allImagesRaw) {
-                if (allImages.size() > keepCount + 1) { // +1 保留 latest
+                    echo "未找到任何镜像，无需清理"
-                    def oldImages = allImages.drop(keepCount + 1)
+                    return
+                }
+
+                def allImages = allImagesRaw.split('\n')
+                if (allImages.size() <= keepCount) {
+                    echo "当前镜像数未超过 ${keepCount} 个，无需清理"
+                    return
+                }
+
+                def oldImages = allImages.drop(keepCount)
                 echo "发现 ${oldImages.size()} 个旧镜像需要清理"
 
                 oldImages.each { line ->
-                        def parts = line.split(' ')
+                    def imageTag = line.split(' ')[0]
-                        def imageId = parts[0]
+                    if (imageTag.contains("<none>")) {
-                        def tag = parts[1]
+                        echo "跳过无效镜像：${imageTag}"
+                        return
+                    }
+                    echo "删除旧镜像: ${imageTag}"
+                    sh(returnStatus: true, script: "docker rmi -f ${imageTag} || true")
+                }
 
-                        if (tag == "<none>") {
+                echo "清理完成，当前镜像状态："
-                            echo "删除旧镜像（无标签）: ${imageId}"
-                            sh(returnStatus: true, script: "docker rmi -f ${imageId}")
-                        } else if (tag != "latest") {
-                            echo "删除旧镜像: ${imagePrefix}:${tag}"
-                            sh(returnStatus: true, script: "docker rmi -f ${imagePrefix}:${tag}")
-                        }
-                    }
-                } else {
-                    echo "当前镜像数未超过 ${keepCount + 1} 个，无需清理"
-                }
                 sh """
-                    echo "当前镜像状态："
+                    docker images ${imagePrefix} --format 'table {{.Repository}}\\t{{.Tag}}\\t{{.CreatedAt}}\\t{{.Size}}'
-                    docker images ${REGISTRY}/${NAMESPACE}/${IMAGE_NAME} --format 'table {{.Repository}}\\t{{.Tag}}\\t{{.CreatedAt}}\\t{{.Size}}'
                 """
-                // 无论成败都登出，清理凭证
+
                 sh "docker logout ${REGISTRY}"
                 echo "容器仓库已登出，本地凭证已清理"
             }

SCM/build_image_lessie_ai_web.groovy

@@ -165,10 +165,7 @@ pipeline {
                 script {
                     // 推送主镜像（带唯一 Tag）
                     sh "docker push ${REGISTRY}/${NAMESPACE}/${IMAGE_NAME}:${IMAGE_TAG}"
-
+                    echo "推送镜像成功：${REGISTRY}/${NAMESPACE}/${IMAGE_NAME}:${IMAGE_TAG}"
-                    // 推送 latest 标签（包含命名空间）
-                    sh "docker tag ${REGISTRY}/${NAMESPACE}/${IMAGE_NAME}:${IMAGE_TAG} ${REGISTRY}/${NAMESPACE}/${IMAGE_NAME}:latest"
-                    sh "docker push ${REGISTRY}/${NAMESPACE}/${IMAGE_NAME}:latest"
                 }
             }
         }
@@ -177,39 +174,41 @@ pipeline {
     post {
         always {
             script {
-                echo "开始清理本地旧镜像，仅保留最近 3 个构建版本 + latest"
+                echo "开始清理本地旧镜像，仅保留最近 1 个构建版本"
-                // 保留镜像数量
+                def keepCount =1
-                def keepCount = 3
                 def imagePrefix = "${REGISTRY}/${NAMESPACE}/${IMAGE_NAME}"
-                // 获取当前镜像的 IMAGE ID
+
-                def currentImageId = sh(script: "docker images -q ${imagePrefix}:${IMAGE_TAG}", returnStdout: true).trim()
+                // 获取所有镜像（按创建时间排序，越新的越前）
-                // 获取所有该镜像的本地版本（按创建时间排序）
+                def allImagesRaw = sh(script: "docker images ${imagePrefix} --format '{{.Repository}}:{{.Tag}} {{.CreatedAt}}' | sort -rk2", returnStdout: true).trim()
-                def allImages = sh(script: "docker images ${imagePrefix} --format '{{.ID}} {{.Tag}}' | sort -rk2", returnStdout: true).trim().split('\n')
+                if (!allImagesRaw) {
-                if (allImages.size() > keepCount + 1) { // +1 保留 latest
+                    echo "未找到任何镜像，无需清理"
-                    def oldImages = allImages.drop(keepCount + 1)
+                    return
+                }
+
+                def allImages = allImagesRaw.split('\n')
+                if (allImages.size() <= keepCount) {
+                    echo "当前镜像数未超过 ${keepCount} 个，无需清理"
+                    return
+                }
+
+                def oldImages = allImages.drop(keepCount)
                 echo "发现 ${oldImages.size()} 个旧镜像需要清理"
 
                 oldImages.each { line ->
-                        def parts = line.split(' ')
+                    def imageTag = line.split(' ')[0]
-                        def imageId = parts[0]
+                    if (imageTag.contains("<none>")) {
-                        def tag = parts[1]
+                        echo "跳过无效镜像：${imageTag}"
+                        return
+                    }
+                    echo "删除旧镜像: ${imageTag}"
+                    sh(returnStatus: true, script: "docker rmi -f ${imageTag} || true")
+                }
 
-                        if (tag == "<none>") {
+                echo "清理完成，当前镜像状态："
-                            echo "删除旧镜像（无标签）: ${imageId}"
-                            sh(returnStatus: true, script: "docker rmi -f ${imageId}")
-                        } else if (tag != "latest") {
-                            echo "删除旧镜像: ${imagePrefix}:${tag}"
-                            sh(returnStatus: true, script: "docker rmi -f ${imagePrefix}:${tag}")
-                        }
-                    }
-                } else {
-                    echo "当前镜像数未超过 ${keepCount + 1} 个，无需清理"
-                }
                 sh """
-                    echo "当前镜像状态："
+                    docker images ${imagePrefix} --format 'table {{.Repository}}\\t{{.Tag}}\\t{{.CreatedAt}}\\t{{.Size}}'
-                    docker images ${REGISTRY}/${NAMESPACE}/${IMAGE_NAME} --format 'table {{.Repository}}\\t{{.Tag}}\\t{{.CreatedAt}}\\t{{.Size}}'
                 """
-                // 无论成败都登出，清理凭证
+
                 sh "docker logout ${REGISTRY}"
                 echo "容器仓库已登出，本地凭证已清理"
             }

SCM/build_image_lessie_sourcing_agents.groovy

@@ -135,10 +135,7 @@ pipeline {
                 script {
                     // 推送主镜像（带唯一 Tag）
                     sh "docker push ${REGISTRY}/${NAMESPACE}/${IMAGE_NAME}:${IMAGE_TAG}"
-
+                    echo "推送镜像成功：${REGISTRY}/${NAMESPACE}/${IMAGE_NAME}:${IMAGE_TAG}"
-                    // 推送 latest 标签（包含命名空间）
-                    sh "docker tag ${REGISTRY}/${NAMESPACE}/${IMAGE_NAME}:${IMAGE_TAG} ${REGISTRY}/${NAMESPACE}/${IMAGE_NAME}:latest"
-                    sh "docker push ${REGISTRY}/${NAMESPACE}/${IMAGE_NAME}:latest"
                 }
             }
         }
@@ -147,39 +144,41 @@ pipeline {
     post {
         always {
             script {
-                echo "开始清理本地旧镜像，仅保留最近 3 个构建版本 + latest"
+                echo "开始清理本地旧镜像，仅保留最近 2 个构建版本"
-                // 保留镜像数量
+                def keepCount = 2
-                def keepCount = 3
                 def imagePrefix = "${REGISTRY}/${NAMESPACE}/${IMAGE_NAME}"
-                // 获取当前镜像的 IMAGE ID
+
-                def currentImageId = sh(script: "docker images -q ${imagePrefix}:${IMAGE_TAG}", returnStdout: true).trim()
+                // 获取所有镜像（按创建时间排序，越新的越前）
-                // 获取所有该镜像的本地版本（按创建时间排序）
+                def allImagesRaw = sh(script: "docker images ${imagePrefix} --format '{{.Repository}}:{{.Tag}} {{.CreatedAt}}' | sort -rk2", returnStdout: true).trim()
-                def allImages = sh(script: "docker images ${imagePrefix} --format '{{.ID}} {{.Tag}}' | sort -rk2", returnStdout: true).trim().split('\n')
+                if (!allImagesRaw) {
-                if (allImages.size() > keepCount + 1) { // +1 是因为还要保留 latest
+                    echo "未找到任何镜像，无需清理"
-                    def oldImages = allImages.drop(keepCount + 1)
+                    return
+                }
+
+                def allImages = allImagesRaw.split('\n')
+                if (allImages.size() <= keepCount) {
+                    echo "当前镜像数未超过 ${keepCount} 个，无需清理"
+                    return
+                }
+
+                def oldImages = allImages.drop(keepCount)
                 echo "发现 ${oldImages.size()} 个旧镜像需要清理"
 
                 oldImages.each { line ->
-                        def parts = line.split(' ')
+                    def imageTag = line.split(' ')[0]
-                        def imageId = parts[0]
+                    if (imageTag.contains("<none>")) {
-                        def tag = parts[1]
+                        echo "跳过无效镜像：${imageTag}"
+                        return
+                    }
+                    echo "删除旧镜像: ${imageTag}"
+                    sh(returnStatus: true, script: "docker rmi -f ${imageTag} || true")
+                }
 
-                        if (tag == "<none>") {
+                echo "清理完成，当前镜像状态："
-                            echo "删除旧镜像（无标签）: ${imageId}"
-                            sh(returnStatus: true, script: "docker rmi -f ${imageId}")
-                        } else if (tag != "latest") {
-                            echo "删除旧镜像: ${imagePrefix}:${tag}"
-                            sh(returnStatus: true, script: "docker rmi -f ${imagePrefix}:${tag}")
-                        }
-                    }
-                } else {
-                    echo "当前镜像数未超过 ${keepCount + 1} 个，无需清理"
-                }
                 sh """
-                    echo "当前镜像状态："
+                    docker images ${imagePrefix} --format 'table {{.Repository}}\\t{{.Tag}}\\t{{.CreatedAt}}\\t{{.Size}}'
-                    docker images ${REGISTRY}/${NAMESPACE}/${IMAGE_NAME} --format 'table {{.Repository}}\\t{{.Tag}}\\t{{.CreatedAt}}\\t{{.Size}}'
                 """
-                // 无论成败都登出，清理凭证
+
                 sh "docker logout ${REGISTRY}"
                 echo "容器仓库已登出，本地凭证已清理"
             }
@@ -193,7 +192,7 @@ pipeline {
         }
         failure {
             // 输出构建结果
-            echo "镜像构建失败！"
+            echo "有失败步骤！"
         }
     }
 }

k8s_yaml/test/test-flymoon-admin.yaml

@@ -20,8 +20,8 @@ spec:
   strategy:
     type: RollingUpdate # 滚动更新策略
     rollingUpdate:
-      maxSurge: 1 # 最大新增副本数
+      maxSurge: 1 # 最大新增副本数，更新过程中「超出期望副本数」最多为1（每次只创建1个新 Pod）
-      maxUnavailable: 0 # 最大不可用副本数
+      maxUnavailable: 0 # 最大不可用副本数，更新过程中「不可用 Pod 数」最多为0（不允许服务降级）
   template:
     metadata:
       labels:
@@ -39,7 +39,7 @@ spec:
       containers:
         - name: test-flymoon-admin # 容器名称
           image: uswccr.ccs.tencentyun.com/lessietest/flymoon-admin:v0.0.1 # 容器镜像
-          imagePullPolicy: IfNotPresent # 镜像拉取策略 ,有则不拉
+          imagePullPolicy: Always # 镜像拉取策略 拉
           env:
             - name: POD_NAME
               valueFrom:

k8s_yaml/test/test-flymoon-agent.yaml

@@ -39,7 +39,7 @@ spec:
       containers:
         - name: test-flymoon-agent # 容器名称
           image: uswccr.ccs.tencentyun.com/lessietest/flymoon-agent:v0.0.5 # 容器镜像
-          imagePullPolicy: Always # 镜像拉取策略 ,有则不拉
+          imagePullPolicy: Always # 镜像拉取策略，拉
           env:
             - name: POD_NAME
               valueFrom:

k8s_yaml/test/test-lessie-agents.yaml

@@ -45,7 +45,7 @@ spec:
       containers:
         - name: test-lessie-agents # 容器名称
           image: uswccr.ccs.tencentyun.com/lessietest/lessie-sourcing-agents:v0.0.2 # 容器镜像
-          imagePullPolicy: IfNotPresent # 镜像拉取策略 ,有则不拉
+          imagePullPolicy: Always # 镜像拉取策略拉
           env:
             - name: POD_NAME
               valueFrom:
@@ -69,7 +69,7 @@ spec:
               memory: "2Gi" # 容器请求分配1Gi内存（这会实际预留）
             limits:
               cpu: "2" # 最多可以使用2个CPU核心
-              memory: "8Gi" # 容器最多可以使用8Gi内存
+              memory: "10Gi" # 容器最多可以使用8Gi内存
           volumeMounts:
             - name: aws-credentials-volume
               mountPath: /root/.aws/

k8s_yaml/test/test-lessie-ai-web.yaml

@@ -38,7 +38,7 @@ spec:
       containers:
         - name: test-lessie-ai-web
           image: uswccr.ccs.tencentyun.com/lessiesit/lessie-ai-web:latest
-          imagePullPolicy: IfNotPresent
+          imagePullPolicy: Always
           ports:
             - containerPort: 80
           resources:

k8s_yaml/test/test-lessie-go-api.yaml

@@ -39,7 +39,7 @@ spec:
       containers:
         - name: test-lessie-go-api      # 容器名称
           image: uswccr.ccs.tencentyun.com/lessietest/go_lessie-sourcing-api:v0.0.2 # 容器镜像
-          imagePullPolicy: IfNotPresent # 镜像拉取策略 ,有则不拉
+          imagePullPolicy: Always # 镜像拉取策略 ,总是拉
           env:
             - name: POD_NAME
               valueFrom:
@@ -62,6 +62,22 @@ spec:
             - name: go-logs-volume
               mountPath: /app/logs/
               subPathExpr: go-log-$(POD_NAME)
+          readinessProbe:           # 就绪探针，用于判断容器是否已准备好接收流量
+            httpGet:
+              path: /health
+              port: 8100
+            initialDelaySeconds: 5  # 就绪探测在容器启动后等待多少秒才开始第一次探测（避免应用启动未完成即被判为不就绪）
+            periodSeconds: 10       # 就绪探测的间隔秒数，每隔多少秒执行一次探测
+            timeoutSeconds: 5       # 单次就绪探测的超时时间（秒），超过则该次探测视为失败
+            failureThreshold: 3     # 连续失败多少次后认为就绪探测失败（Pod 不再被视为就绪）
+          livenessProbe:            # 存活探针，用于判断容器是否仍然健康，失败会触发重启
+            httpGet:
+              path: /health         
+              port: 8100            
+            initialDelaySeconds: 10 # 存活探测在容器启动后等待多少秒才开始第一次探测
+            periodSeconds: 30       # 存活探测的间隔秒数
+            timeoutSeconds: 5       # 单次存活探测的超时时间（秒）
+            failureThreshold: 3     # 连续失败多少次后认为容器不健康并触发重启
 
 ---
 # ----------------------------