Jenkinsfile使用k3s构建示例

已于 2024-07-11 11:22:01 修改
阅读量297 收藏
点赞数
文章标签： 运维 jenkins kubernetes
于 2023-03-17 16:44:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33285694/article/details/129622179
版权

  1. 安装k3s

        官方文档一键安装

修改k3s.service配置文件，使用docker

jenkins版本：2.542.2

  1. 我们使用gitee插件

 

3.配置k3s构建

Pod template settings

4.编写Jenkinsfile (声明式)(java)（注：钉钉通知只能用在声明式里，不能用在脚本式里）

pipeline{
    agent {
        kubernetes{
            cloud 'kubernetes'
            yaml '''apiVersion: "v1"
kind: "Pod"
metadata:
  namespace: "default"
spec:
  containers:
  - command:
    - "cat"
    image: "maven:3.8.5-jdk-8"
    imagePullPolicy: "IfNotPresent"
    name: "maven"
    tty: true
    volumeMounts:
    - mountPath: "/opt/maven/specialdisease"
      name: "volume-1"
      readOnly: false
    - mountPath: "/root/.docker"
      name: "volume-3"
      readOnly: false
    - mountPath: "/root/.m2"
      name: "volume-2"
      readOnly: false
    - mountPath: "/var/run/docker.sock"
      name: "volume-0"
      readOnly: false
    - mountPath: "/home/jenkins/agent"
      name: "workspace-volume"
      readOnly: false
  - command:
    - "cat"
    image: "docker:latest"
    imagePullPolicy: "IfNotPresent"
    name: "dnd"
    tty: true
    volumeMounts:
    - mountPath: "/opt/maven/specialdisease"
      name: "volume-1"
      readOnly: false
    - mountPath: "/root/.docker"
      name: "volume-3"
      readOnly: false
    - mountPath: "/root/.m2"
      name: "volume-2"
      readOnly: false
    - mountPath: "/var/run/docker.sock"
      name: "volume-0"
      readOnly: false
    - mountPath: "/home/jenkins/agent"
      name: "workspace-volume"
      readOnly: false
  restartPolicy: "Never"
  volumes:
  - hostPath:
      path: "/var/run/docker.sock"
    name: "volume-0"
  - hostPath:
      path: "/opt/maven/.m2"
    name: "volume-2"
  - hostPath:
      path: "/opt/maven/specialdisease"
    name: "volume-1"
  - emptyDir:
      medium: ""
    name: "workspace-volume"
  - hostPath:
      path: "/root/.docker"
    name: "volume-3"
'''
        }
    }
    stages {
        stage('gitee checkout') {
            steps{
                git branch: "${env.giteeBranch}", credentialsId: 'gitee-kk', url: "${env.giteeSourceRepoHttpUrl}"
                echo "giteeBranch ${env.giteeBranch}"
                echo "giteeSourceBranch ${env.giteeSourceBranch}"
                echo "giteeActionType ${env.giteeActionType}"
                echo "giteeUserName ${env.giteeUserName}"
                echo "giteeUserEmail ${env.giteeUserEmail}"
                echo "giteeSourceRepoURL ${env.giteeSourceRepoURL}"
                echo "giteeSourceRepoName ${env.giteeSourceRepoName}"
            }
        }
        stage('maven build') {
            steps {
                container('maven') {
                    script {
                        if("${env.giteeBranch}" == 'dev' && "${env.giteeActionType}" == 'PUSH'){
                            sh 'mvn -e clean deploy  --batch-mode -U -Dmaven.test.skip=true -s /opt/maven/specialdisease/settings.xml'
                        }else if("${env.giteeBranch}" == 'test' && "${env.giteeActionType}" == 'PUSH'){
                            sh 'sed -i "s/-SNAPSHOT/-Alpha/" pom.xml'
                            sh 'mvn -e clean deploy  --batch-mode -U -Dmaven.test.skip=true -s /opt/maven/specialdisease/settings.xml'
                        }else if("${env.giteeBranch}" == 'master' && "${env.giteeActionType}" == 'PUSH'){
                            sh 'sed -i "s/-SNAPSHOT/-Beta/" pom.xml'
                            sh 'mvn -e clean deploy  --batch-mode -U -Dmaven.test.skip=true -s /opt/maven/specialdisease/settings.xml'
                        }else if("${env.giteeBranch}" == 'releases' && "${env.giteeActionType}" == 'PUSH'){
                            sh 'sed -i "s/-SNAPSHOT/-RELEASES/" pom.xml'
                            sh 'mvn -e clean deploy  --batch-mode -U -Dmaven.test.skip=true -s /opt/maven/specialdisease/settings.xml'
                        }
                    }
                }
            }
        }
        stage('docker build and push') {
            steps {
                container('dnd') {
                    script {
                        if("${env.giteeBranch}" == 'dev' || "${env.giteeBranch}" == 'test' || "${env.giteeBranch}" == 'master' || "${env.giteeBranch}" == 'releases'){
                            withCredentials([usernamePassword(credentialsId: 'harbor', passwordVariable: 'password', usernameVariable: 'username')]) {
                            sh 'echo "$password" | docker login -u $username --password-stdin harbor.xxxxxx.cn'
                            sh "docker build -t harbor.xxxxxx.cn/specialdisease/${env.giteeSourceRepoName}-${env.giteeBranch}:latest ."
                            sh "docker push harbor.xxxxxx.cn/specialdisease/${env.giteeSourceRepoName}-${env.giteeBranch}:latest"
                            }
                        }
                    }
                }
            }
        }
        stage('k8s-deploy') {
            steps {
                script {
                    def remote = [:]
                    def cert
                    def run_opts
                    def run_profile
                    remote.allowAnyHosts = true
                    remote.name = "test_remote"
                    remote.host = '192.168.31.61'
                    remote.port = 22
                    cert='master-61'
                    withCredentials([usernamePassword(credentialsId: cert, passwordVariable: 'password', usernameVariable: 'userName')]){
                        remote.user = "${userName}"
                        remote.password = "${password}"
                    }
                    if("${env.giteeBranch}" == 'test'){
                        sshCommand failOnError: false, remote: remote, command: "kubectl rollout restart deploy ${env.giteeSourceRepoName} -n specialdisease-test"
                    }else if ("${env.giteeBranch}" == 'dev'){
                        sshCommand failOnError: false, remote: remote, command: "kubectl rollout restart deploy ${env.giteeSourceRepoName} -n specialdisease-dev"
                    }
                }
            }
            post {
                failure {
                    dingtalk (robot:'20271ef1-6b9e-429c-9682-ab10dda25ddf',
                    type:'TEXT',
                    text: [
                        "构建失败",
                        "仓库： ${env.giteeSourceRepoName}",
                        "触发事件: ${env.giteeActionType}",
                        "目标分支: ${env.giteeBranch}",
                        "发起人: ${env.giteeUserName}",
                        "详情：${env.giteeSourceRepoURL}"
                    ]
                    )
                }
                success {
                    dingtalk (robot:'20271ef1-6b9e-429c-9682-ab10dda25ddf',
                    type:'TEXT',
                    text: [
                        "构建成功",
                        "仓库： ${env.giteeSourceRepoName}",
                        "触发事件: ${env.giteeActionType}",
                        "目标分支: ${env.giteeBranch}",
                        "发起人: ${env.giteeUserName}",
                        "详情：${env.giteeSourceRepoURL}"
                    ]
                    )
                }
            }
        }
    }
}

5.编写Jenkinsfile (脚本式)(java)

podTemplate(containers: [
    containerTemplate(name: 'maven', image: 'maven:3.3.9-jdk-8-alpine', ttyEnabled: true, command: 'cat'),
    containerTemplate(name: 'dnd', image: 'docker:latest', ttyEnabled: true, command: 'cat')
  ],
  volumes: [
        hostPathVolume(mountPath: '/var/run/docker.sock',hostPath: '/var/run/docker.sock'),
        hostPathVolume(mountPath: '/opt/maven/specialdisease', hostPath: '/opt/maven/specialdisease'),
        hostPathVolume(mountPath: '/root/.m2', hostPath: '/opt/maven/.m2'),
        hostPathVolume(mountPath: '/root/.docker', hostPath: '/root/.docker')
    ])
    
{
    node(POD_LABEL) {
        stage('gitee checkout') {
            git branch: "${env.giteeBranch}", credentialsId: 'gitee-kk', url: "${env.giteeSourceRepoHttpUrl}"
            echo "giteeBranch ${env.giteeBranch}"
            echo "giteeSourceBranch ${env.giteeSourceBranch}"
            echo "giteeActionType ${env.giteeActionType}"
            echo "giteeUserName ${env.giteeUserName}"
            echo "giteeUserEmail ${env.giteeUserEmail}"
            echo "giteeSourceRepoURL ${env.giteeSourceRepoURL}"
            echo "giteeSourceRepoName ${env.giteeSourceRepoName}"
        }
        stage('maven build') {
            container('maven') {
                script {
                    if("${env.giteeBranch}" == 'dev' && "${env.giteeActionType}" == 'PUSH'){
                        sh 'mvn -e clean deploy  --batch-mode -U -Dmaven.test.skip=true -s /opt/maven/specialdisease/settings.xml'

                    }else if("${env.giteeBranch}" == 'test' && "${env.giteeActionType}" == 'PUSH'){
                        sh 'sed -i "s/-SNAPSHOT/-Alpha/" pom.xml'
                        sh 'mvn -e clean deploy  --batch-mode -U -Dmaven.test.skip=true -s /opt/maven/specialdisease/settings.xml'
                    }else if("${env.giteeBranch}" == 'master' && "${env.giteeActionType}" == 'PUSH'){
                        sh 'sed -i "s/-SNAPSHOT/-Beta/" pom.xml'
                        sh 'mvn -e clean deploy  --batch-mode -U -Dmaven.test.skip=true -s /opt/maven/specialdisease/settings.xml'
                    }else if("${env.giteeBranch}" == 'releases' && "${env.giteeActionType}" == 'PUSH'){
                        sh 'sed -i "s/-SNAPSHOT/-RELEASES/" pom.xml'
                        sh 'mvn -e clean deploy  --batch-mode -U -Dmaven.test.skip=true -s /opt/maven/specialdisease/settings.xml'
                    }
                }
            }
        }
        stage('docker build and push') {
            container('dnd') {
                script {
                    if("${env.giteeBranch}" == 'dev' || "${env.giteeBranch}" == 'test' || "${env.giteeBranch}" == 'master' || "${env.giteeBranch}" == 'releases'){
                        withCredentials([usernamePassword(credentialsId: 'harbor', passwordVariable: 'password', usernameVariable: 'username')]) {
                        sh 'echo "$password" | docker login -u $username --password-stdin harbor.xxxxxx.cn'
                        sh "docker build -t harbor.xxxxxx.cn/specialdisease/${env.giteeSourceRepoName}-${env.giteeBranch}:latest ."
                        sh "docker push harbor.xxxxxx.cn/specialdisease/${env.giteeSourceRepoName}-${env.giteeBranch}:latest"
                        }
                    }
                }
            }
        }
        stage('k8s-deploy') {
            script {
                def remote = [:]
                def cert
                def run_opts
                def run_profile
                remote.allowAnyHosts = true
                remote.name = "test_remote"
                remote.host = '192.168.31.61'
                remote.port = 22
                cert='master-61'
                withCredentials([usernamePassword(credentialsId: cert, passwordVariable: 'password', usernameVariable: 'userName')]){
                    remote.user = "${userName}"
                    remote.password = "${password}"
                }
                if("${env.giteeBranch}" == 'test'){
                    sshCommand failOnError: false, remote: remote, command: "kubectl rollout restart deploy ${env.giteeSourceRepoName} -n specialdisease-test"
                }else if ("${env.giteeBranch}" == 'dev'){
                    sshCommand failOnError: false, remote: remote, command: "kubectl rollout restart deploy ${env.giteeSourceRepoName} -n specialdisease-dev"
                }
            }
            post {
                failure {
                    dingtalk (robot:'20271ef1-6b9e-429c-9682-ab10dda25ddf',
                    type:'TEXT',
                    text: [
                        "构建失败",
                        //   "仓库： ${REPO_NAME}",
                        //   "触发事件: ${env.giteeActionType}",
                        //   "目标分支: ${env.giteeBranch}",
                        //   "发起人: ${env.giteeUserName}",
                        //   "详情：${env.BUILD_URL}"
                    ]
                    )
                }
                success {
                    dingtalk (robot:'20271ef1-6b9e-429c-9682-ab10dda25ddf',
                    type:'TEXT',
                    text: [
                        "构建成功",
                        //   "仓库： ${REPO_NAME}",
                        //   "触发事件: ${env.giteeActionType}",
                        //   "目标分支: ${env.giteeBranch}",
                        //   "发起人: ${env.giteeUserName}",
                        //   "详情：${env.BUILD_URL}"
                    ]
                    )
                }
            }
        }
    }
}

6.编写Jenkinsfile (声明式)(nodejs)

pipeline{
    agent {
        kubernetes{
            cloud 'kubernetes'
            yaml '''apiVersion: "v1"
kind: "Pod"
metadata:
  namespace: "default"
spec:
  containers:
  - command:
    - "cat"
    image: "node:16.17.1"
    imagePullPolicy: "IfNotPresent"
    name: "node"
    tty: true
    volumeMounts:
    - mountPath: "/root/.docker"
      name: "volume-3"
      readOnly: false
    - mountPath: "/var/run/docker.sock"
      name: "volume-0"
      readOnly: false
    - mountPath: "/home/jenkins/agent"
      name: "workspace-volume"
      readOnly: false
  - command:
    - "cat"
    image: "docker:latest"
    imagePullPolicy: "IfNotPresent"
    name: "dnd"
    tty: true
    volumeMounts:
    - mountPath: "/root/.docker"
      name: "volume-3"
      readOnly: false
    - mountPath: "/var/run/docker.sock"
      name: "volume-0"
      readOnly: false
    - mountPath: "/home/jenkins/agent"
      name: "workspace-volume"
      readOnly: false
  restartPolicy: "Never"
  volumes:
  - hostPath:
      path: "/var/run/docker.sock"
    name: "volume-0"
  - emptyDir:
      medium: ""
    name: "workspace-volume"
  - hostPath:
      path: "/root/.docker"
    name: "volume-3"
'''
        }
    }
    stages {
        stage('gitee checkout') {
            steps{
                git branch: "${env.giteeBranch}", credentialsId: 'gitee-kk', url: "${env.giteeSourceRepoHttpUrl}"
                echo "giteeBranch ${env.giteeBranch}"
                echo "giteeSourceBranch ${env.giteeSourceBranch}"
                echo "giteeActionType ${env.giteeActionType}"
                echo "giteeUserName ${env.giteeUserName}"
                echo "giteeUserEmail ${env.giteeUserEmail}"
                echo "giteeSourceRepoName ${env.giteeSourceRepoName}"
                echo "giteeSourceRepoURL ${env.giteeSourceRepoURL}"
                echo "giteeSourceRepoHttpUrl ${env.giteeSourceRepoHttpUrl}"
            }
        }
        stage('npm build') {
            steps {
                container('node') {
                    sh 'npm install'
                    script {
                        if("${env.giteeBranch}" == 'dev' && "${env.giteeActionType}" == 'PUSH'){
                            sh 'npm run sit'
                        }else if("${env.giteeBranch}" == 'test' || "${env.giteeBranch}" == 'test-drug' || "${env.giteeBranch}" == 'test-settle'){
                            sh 'npm run test'
                        }else if("${env.giteeBranch}" == 'releases' && "${env.giteeActionType}" == 'PUSH'){
                            sh 'npm run build'
                        }
                    }
                }
            }
        }
        stage('docker build and push') {
            steps {
                container('dnd') {
                    withCredentials([usernamePassword(credentialsId: 'harbor', passwordVariable: 'password', usernameVariable: 'username')]) {
                    sh 'echo "$password" | docker login -u $username --password-stdin harbor.xxxxxx.cn'
                    sh "docker build -t harbor.xxxxxx.cn/specialdisease/${env.giteeSourceRepoName}-${env.giteeBranch}:latest ."
                    sh "docker push harbor.xxxxxx.cn/specialdisease/${env.giteeSourceRepoName}-${env.giteeBranch}:latest"
                    }
                }
            }
        }
        stage('k8s-deploy') {
            steps {
                script {
                    def remote = [:]
                    def cert
                    def run_opts
                    def run_profile
                    remote.allowAnyHosts = true
                    remote.name = "test_remote"
                    remote.host = '192.168.31.61'
                    remote.port = 22
                    cert='master-61'
                    withCredentials([usernamePassword(credentialsId: cert, passwordVariable: 'password', usernameVariable: 'userName')]){
                        remote.user = "${userName}"
                        remote.password = "${password}"
                    }
                    if("${env.giteeBranch}" == 'test' || "${env.giteeBranch}" == 'test-drug' || "${env.giteeBranch}" == 'test-settle'){
                        sshCommand failOnError: false, remote: remote, command: "kubectl rollout restart deploy specialdisease-${env.giteeSourceRepoName} -n specialdisease-test"
                    }else if ("${env.giteeBranch}" == 'dev'){
                        sshCommand failOnError: false, remote: remote, command: "kubectl rollout restart deploy specialdisease-${env.giteeSourceRepoName} -n specialdisease-dev"
                    }
                }
            }
            post {
                failure {
                    dingtalk (robot:'20271ef1-6b9e-429c-9682-ab10dda25ddf',
                    type:'TEXT',
                    text: [
                        "构建失败",
                        "仓库： ${env.giteeSourceRepoName}",
                        "触发事件: ${env.giteeActionType}",
                        "目标分支: ${env.giteeBranch}",
                        "发起人: ${env.giteeUserName}",
                        "详情：${env.giteeSourceRepoURL}"
                    ]
                    )
                }
                success {
                    dingtalk (robot:'20271ef1-6b9e-429c-9682-ab10dda25ddf',
                    type:'TEXT',
                    text: [
                        "构建成功",
                        "仓库： ${env.giteeSourceRepoName}",
                        "触发事件: ${env.giteeActionType}",
                        "目标分支: ${env.giteeBranch}",
                        "发起人: ${env.giteeUserName}",
                        "详情：${env.giteeSourceRepoURL}"
                    ]
                    )
                }
            }
        }
    }
}

7.编写Jenkinsfile (脚本式)(nodejs)

podTemplate(containers: [
    containerTemplate(name: 'node', image: 'node:14', ttyEnabled: true, command: 'cat'),
    containerTemplate(name: 'dnd', image: 'docker:latest', ttyEnabled: true, command: 'cat')
  ],
  volumes: [
        hostPathVolume(mountPath: '/var/run/docker.sock',hostPath: '/var/run/docker.sock'),
        hostPathVolume(mountPath: '/root/.docker', hostPath: '/root/.docker')
    ])
    
{
    node(POD_LABEL) {
        stage('gitee checkout') {
            git branch: "${env.giteeBranch}", credentialsId: 'gitee-kk', url: "${env.giteeSourceRepoHttpUrl}"
            echo "giteeBranch ${env.giteeBranch}"
            echo "giteeSourceBranch ${env.giteeSourceBranch}"
            echo "giteeActionType ${env.giteeActionType}"
            echo "giteeUserName ${env.giteeUserName}"
            echo "giteeUserEmail ${env.giteeUserEmail}"
            echo "giteeSourceRepoName ${env.giteeSourceRepoName}"
            echo "giteeSourceRepoURL ${env.giteeSourceRepoURL}"
            echo "giteeSourceRepoHttpUrl ${env.giteeSourceRepoHttpUrl}"
        }
        stage('npm build') {
            container('node') {
                sh 'npm install -g cnpm --registry=https://registry.npmmirror.com'
                sh 'cnpm -v'
                sh 'npm install'
                script {
                    if("${env.giteeBranch}" == 'dev' && "${env.giteeActionType}" == 'PUSH'){
                        sh 'cnpm run sit'
                    }else if("${env.giteeBranch}" == 'test' && "${env.giteeActionType}" == 'PUSH'){
                        sh 'npm run test'
                    }else if("${env.giteeBranch}" == 'master' && "${env.giteeActionType}" == 'PUSH'){
                        sh 'npm run build'
                }
              }
          }
        }
        stage('docker build and push') {
            container('dnd') {
                    withCredentials([usernamePassword(credentialsId: 'harbor', passwordVariable: 'password', usernameVariable: 'username')]) {
                    sh 'echo "$password" | docker login -u $username --password-stdin harbor.xxxxxx.cn'
                    sh "docker build -t harbor.xxxxxx.cn/drug/${env.giteeSourceRepoName}-${env.giteeBranch}:latest ."
                    sh "docker push harbor.xxxxxx.cn/drug/${env.giteeSourceRepoName}-${env.giteeBranch}:latest"
                }
            }
        }
//         stage('deploy') {
//             script {
//                 def remote = [:]
//                 def cert
//                 def run_opts
//                 def run_profile
//                 remote.allowAnyHosts = true
//                 if("${env.giteeBranch}" == 'dev' && "${env.giteeActionType}" == 'PUSH'){
//                     remote.name = "dev_remote"
//                     remote.host = '192.168.31.39'
//                     remote.port = 22
//                     cert='dev-39'
//                 }else if("${env.giteeBranch}" == 'test' && "${env.giteeActionType}" == 'PUSH'){
//                     remote.name = "test_remote"
//                     remote.host = '192.168.31.40'
//                     remote.port = 22
//                     cert='dev-39'
//                 }
//                 if("${env.giteeBranch}" == 'dev' || "${env.giteeBranch}" == 'test' ){
//                     withCredentials([usernamePassword(credentialsId: cert, passwordVariable: 'password', usernameVariable: 'userName')]){
//                         remote.user = "${userName}"
//                         remote.password = "${password}"
//                     }
//                     sshCommand failOnError: false, remote: remote, command: "docker stop ${env.giteeSourceRepoName}"
//                     sshCommand failOnError: false, remote: remote, command: "docker rm ${env.giteeSourceRepoName}"
//                     sshCommand failOnError: false, remote: remote, command: "docker rmi harbor.xxxxxx.cn/drug/${env.giteeSourceRepoName}-${env.giteeBranch}"
//                     sshCommand failOnError: false, remote: remote, command: "docker run -d --name ${env.giteeSourceRepoName} -p 8082:80 harbor.xxxxxx.cn/drug/${env.giteeSourceRepoName}-${env.giteeBranch}"
//                 }
//             }
//         }
        stage('k8s-deploy') {
            script {
                def remote = [:]
                def cert
                def run_opts
                def run_profile
                remote.allowAnyHosts = true
                remote.name = "test_remote"
                remote.host = '192.168.31.61'
                remote.port = 22
                cert='master-61'
                withCredentials([usernamePassword(credentialsId: cert, passwordVariable: 'password', usernameVariable: 'userName')]){
                    remote.user = "${userName}"
                    remote.password = "${password}"
                }
                if("${env.giteeBranch}" == 'test'){
                    sshCommand failOnError: false, remote: remote, command: "kubectl rollout restart deploy drug-patient-h5 -n drug-test"
                }else if ("${env.giteeBranch}" == 'dev'){
                    sshCommand failOnError: false, remote: remote, command: "kubectl rollout restart deploy drug-patient-h5 -n drug-dev"
                }
            }
        }
    }
}
乐世东方客
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
k3s 1.29 最新离线包
02-03
【k3s 1.29 最新离线包】是一个专为x86架构设计的Kubernetes轻量级发行版，适用于那些无法或不希望连接到互联网进行在线安装的环境。K3s是由Rancher Labs开发的，旨在简化在边缘计算、物联网(IoT)设备以及对资源需求...
automation:使用Ansible和k3s进行TuringPi集群管理
03-13
设置使用首选的软件包管理器安装ansible ： brew install ansiblepython3 -m pip install ansiblesudo apt update -ysudo apt install ansible服务器自动化配置请按照服务器的特定说明进行自动化的服务器部署和拆卸...
k3s+docker+rancher+gitlab+gitlab-runner+jenkins 持续集成系统在容器集群下的搭建
weixin_40729260的博客
09-08 3632
文章来源bitllion的私人博客 生产环境 centos7 nfs服务器 centos7 管理服务器 ubuntu18.04 总的流程：安装k3s容器编排系统，使用docker安装rancher os，将k3s交给rancher管理（web可视化），再用rancher部署其他应用 安装K3S 选择k3s 而不是k8s：轻量，使用container而不是完全体的docker，加入SQLite...
Jenkins工具集成与Jenkinsfile实践篇
06-12
介绍docker的前世今生，了 解docker的实现原理，以Django项目为例，教大家如何编写最佳的Dockerfile实现构业务镜像的制作。通过本章的学习，大家会知道docker的概念及基本操作，并学会构建自己的业务镜像，并通过抓包的方式掌握Docker最常用的bridge网络模式的通信。
k8s实操实践大佬带你飞_下
06-12
最近的三年多时间，随着容器技术的火爆及Kubernetes成为容器编排管理的标准，国内外厂商均已开始了全面拥抱Kubernetes的转型， 无数中小型企业已经落地 Kubernetes，或正走在容器化的道路上 。介绍docker的前世今生，了 解docker的实现原理，以Django项目为例，教大家如何编写最佳的Dockerfile实现构业务镜像的制作。通过本章的学习，大家会知道docker的概念及基本操作，并学会构建自己的业务镜像，并通过抓包的方式掌握Docker最常用的bridge网络模式的通信。
Kubernetes/K8S企业容器云平台入门与进阶实战
06-23
第一章介绍docker的前世今生，了 解docker的实现原理，以Django项目为例，教大家如何编写最佳的Dockerfile实现构业务镜像的制作。通过本章的学习，大家会知道docker的概念及基本操作，并学会构建自己的业务镜像，并通过抓包的方式掌握Docker最常用的bridge网络模式的通信。第二章本章学习kubernetes的架构及工作流程，重点介绍如本章学习kubernetes的架构及工作流程，重点介绍如断的滚动更新，通过服务发现来实现集群内部的服务间访问，并通过ingress- -nginx实现外部使用域名访问集群内部的服务。同时介绍基于EFK如何搭建Kubernetes集群的日志收集系统。学完本章，我们的Django demo项目已经可以运行在k8s集群中，同时我们可以使用域名进行服务的访问。第三章本章基于k8s集群部署gitlab、sonarQube、 Jenkins等工具，并把上述工具集成到Jenkins中，以Django项目为例，通过多分支流水线及Jenkinsfle实现项目代码提交到不同的仓库分支，实现自动代码扫描、单元测试、docker容器构建、k8s服务的自动部署。第四章由于公司内部项目众多，大量的项目使用同一套流程做CICD,那么势必会存在大量的重复代码，因此本章主要通过使用groovy实现Jenkins的sharedL ibrary的开发，以提取项目在CICD实践过程中的公共逻辑，提供一系列的流程的接口供公司内各项目调用，开发完成后，还是以Django的demo项目为例，进行Jenkinsfle的改造，最后仅需通过简单的Jenkinsfle的配置，即可优雅的完成CICD流程的整个过程，此方式已在大型企业内部落地应用。
K3S搭建jenkins环境
weixin_45531197的博客
05-29 430
【代码】K3S搭建jenkins环境。
逃脱只会部署集群系列 —— jenkins集成kubernetes动态构建
一别两宽丶各生欢喜
12-21 1897
Jenkins的slave端，没有任务的时候处于闲置状态，slave节点多的话造成资源浪费；是否可以利用kubernetes的Pod来启动slave，动态slave pod来执行构建任务，本文主要介绍利用kubernetes动态创建slave执行构建任务，执行完毕自动销毁。 一、kubernetes插件安装及配置 1、安装kubernetes插件 [系统管理] -> [插件管理] -> [搜索kubernetes]->直接安装，报错是依赖无影响 2、配置Kub...
RancherCNDocsPDF_K3s.pdf
10-06
【K3s - 轻量级 Kubernetes】 K3s是由Rancher Labs开发的一款针对边缘计算和物联网(IoT)场景高度优化的轻量级Kubernetes发行版。它的设计目标是简化部署和管理，同时降低对硬件资源的需求。K3s的核心特性包括： 1....
k3s实验室
02-06
在“k3s-lab-master”压缩包中，我们期望找到一系列用于构建K3s集群的脚本和配置文件。首先，你需要安装Vagrant和VirtualBox（或其他支持的虚拟化软件）。接着，解压k3s-lab-master文件，进入目录并按照提供的README...
lbuw.rar_K3S
09-23
【标题】"lbuw.rar_K3S" 指示了这个压缩包与K3S有关，可能包含了与K3S系统或者软件相关的文件。K3S是Kubernetes的一个轻量级版本，专为边缘计算和小型集群设计，它是Rancher Labs推出的一款开源容器管理平台。K3S的...
jenkins触发式自动构建docker镜像上传至harbor并发布
weixin_33785108的博客
02-22 4030
一、制作Dockerfile文件1.在172.19.2.51上部署mkdir-pv/opt/git gitclonehttp://172.19.2.140:18080/lvqingshan/gcgj.git cd/opt/git/gcgj scpapp@172.19.2.1:/home/app/portal-tomcat/webapps/portal.war./...
06 Jenkins file的优化
荒-于嬉的博客
05-28 450
Jenkins file的变量
持续集成概念是什么？好处有哪些？
热门推荐
Java潘老师
06-17 1万+
什么事持续集成？ 持续集成（CI）是一种实践，可以让团队在持续的基础 上收到反馈并进行改进，不必等到开发周期后期才寻找和修复缺陷。通俗一点儿说，就是指对于开发人员的每一次代码提交， 都自动地把Repository中所有代码Check out到一个空目录，并且自动运行所有Test Case。如果成功则接受这次提交，否则告诉所有人，这是一个失败的Revision。  常用的持续
k3s安装jenkins-x
nuptaxin的专栏
03-28 482
本地运行的K3s集群上安装Jenkins X 注意 确保你已经登录了GitHub，否则点击以下链接你将得到一个404错误 本篇指南将指导你如何在你使用k3s的笔记本电脑上安装Jenkins X 如果你正在使用Mac OS，你可以参照这篇指南来构建k3s。你无需在剩余部分的教程中安装kalm 前提条件 K3s 确保你已经创建了一个k3s集群 如果你没有安装好的k3s集群，你可以通过执行以下指令安装一个： # We don't support Kubernetes 1.22+ yet curl -sfL ht
jenkins-使用继承实现基于 kubernetes Pod 的多容器的多构建环境的 Jenkins Slave
qq_22648091的博客
07-17 1503
一、概要 当我们碰到如下需求： 项目需要多个环境，比如 go 、java、maven 需要把构建的成品制作成 docker 镜像 此时，我们都需要 Pod 模板的多容器的支持，接下来就来聊聊关于这方面的最佳实战。 此篇文章的内容是基于之前两篇文件内容的基础上来阐述的，因此，这里只对多容器的相关内容做详细说明，其他就不再详细阐述，如有需要请参考： 1 Jenkins-Kubernetes插件实现使用Pod作为 Agent-超详细 2 jenkins-使用 Pod 构建任务时挂载 NFS 持久卷到工作目录
如何在 Kubernetes Pod 上设置 Jenkins 构建代理
Meta.Qing的博客
09-28 997
对于在集群内部运行的 Jenkins master，您可以使用 Kubernetes 集群的 Service 端点作为 Jenkins URL，因为代理 pod 可以通过内部服务 DNS 连接到集群。此外，基于 Kubernetes pod 的临时 Jenkins 代理是降低 CI 环境成本的好方法，因为 Jenkins 代理只有在有构建请求时才会启动。如果您使用 Docker 部署应用程序，您可以在 Kubernetes 代理上集成您的 CI Docker 构建管道。如果您有现有的设置，也可以使用它。
jenkinsfile2
weixin_45826282的博客
05-29 124
jenkinsfile2 def label = "jenkins-slave" podTemplate(label: label, cloud: 'kubernetes') { node(label) { stage('pull code') { git credentialsId: '732e79e2-7085-4882-ae31-4b50c7f7c4ea', url: 'git@192.168.29.182:demon/java-demon.git'
k3s使用示例(安装+部署demo应用)
homesangsang的博客
10-17 9449
1. docker配置 参考链接https://yq.aliyun.com/articles/110806 安装命令 curl -fsSL https://get.docker.com | bash -s docker --mirror Aliyun 阿里云镜像加速：登录阿里云，选择“容器镜像服务”->“镜像中心”->"镜像加速器“ 2. k3s配置 安装： curl -sfL ht...
k3s和jenkins
最新发布
08-19
K3s和Jenkins是两个不同的工具或技术。 K3s是一个轻量级的Kubernetes发行版，它是Rancher Labs开发的，旨在...它们可以结合使用，通过K3s来管理和部署应用程序的Kubernetes集群，并使用Jenkins进行自动化构建和部署。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值