docker run --name ccaa -d -p 6800:6800 -p 6080:6080 -v /home/root/aria-download:/Down moerats/ccaa:latest

docker run -d --restart=always --name nextcloud -p 8888:80 -v /root/nextcloud:/data -v /home/root/aria-download:/aria docker.io/nextcloud

更新代码 ==> 触发Jenkins流水线的构建 ==> Maven打包项目 ==> 制作docker image ==> 
上传image(这里使用阿里的镜像服务) ==> 远程服务器执行部署脚本 ==> 判断部署状态(nacos api)

FROM docker.io/jenkins/jenkins:latest

USER root
RUN apt-get update -qq \
    && apt-get install -qqy apt-transport-https ca-certificates curl gnupg2 software-properties-common 
RUN curl -fsSL https://download.docker.com/linux/debian/gpg | apt-key add -
RUN add-apt-repository \
   "deb [arch=amd64] https://download.docker.com/linux/debian \
   $(lsb_release -cs) \
   stable"
RUN apt-get update  -qq \
    && apt-get install docker-ce=17.12.1~ce-0~debian -y
RUN usermod -aG docker jenkins

docker image build -t jenkins-docker .

/*
在接触Jenkins流水线的时候最迷惑的就是语法中的pipelinee和node两种组织形式，
一开始使用的是pipeline，但是在看文档的时候又有很多node的写法就感到非常的难受，
总体感觉上node的写法似乎支持更多的插件并且语法更友好但是发现的时候已经差不多写完了也就没有更改
*/
def host() {
    def remote = [:]
    remote.name = 'test'
    remote.host = 'xxxx'
    remote.user = 'xxx'
    remote.password = 'xxxx'
    remote.allowAnyHosts = true
    return remote
}

pipeline {

    agent any

    environment {
        // 这里主要是配置整个流水线所需要的变量，核心思想是要复用流水线和部署脚本的代码而只更改参数
        ENV = 'xx'
        SERVICE_NAME = 'xx'
        SERVER_IP = 'xx'
        SERVER_PORT = 'xx'
        SERVER_USER = 'xx'
        SERVICE_VERSION = 'xx'
        DOCKER_REPO = 'xx'
        DOCKER_NAMESPACE = 'xx'
        DOCKER_USERNAME = 'xx'
        DOCKER_PASSWORD = 'xx'
        NACOS_IP = 'xx'
        NAMESPACE_ID = 'xx'
        // jvm参数
        JAVA_OPTS = 'xx'
    }

    stages {
        stage('构建MAVEN项目') {
            agent {
                // docker in docker就是应用在这里了，使用maven的docker镜像来执行构建
                docker {
                    image 'maven:3-alpine'
                    // 映射本地的maven仓库到docker里防止每次都去远程仓库下载jar
                    args '-v /var/jenkins_home/.m2:/root/.m2'
                }
            }
            steps {
                // maven package
                sh 'mvn clean install -Dmaven.test.skip=true -Dproject.type=jar -Ptest package'
            }
        }

        stage('构建docker镜像') {
            agent {
                docker {
                    image 'docker'
                    // 这里的挂载比较奇怪，因为在上一步maven构建完成之后并没有生成target(现在想来可能是docker的缘故)，
                    // 所以把本地的maven仓库给挂载进来获取jar包使用了
                    args '-v /var/jenkins_home/.m2/repository/com/ghaoqi:/root/jar'
                }
            }
            steps {
                sh '''
                    rm -f docker/*.jar
                    cp /root/jar/${SERVICE_NAME}/${SERVICE_VERSION}-${ENV}/${SERVICE_NAME}-${SERVICE_VERSION}-${ENV}.jar ./docker/${SERVICE_NAME}.jar
                    cd docker
                    docker build -t ${SERVICE_NAME}:${SERVICE_VERSION} .
                '''
            }
        }

        stage('推送构建的镜像') {
            steps {
                // 这里使用了阿里云的容器镜像服务
                sh '''
                    docker login -u ${DOCKER_USERNAME} -p ${DOCKER_PASSWORD} ${DOCKER_REPO}
                    docker tag ${SERVICE_NAME}:${SERVICE_VERSION} ${DOCKER_REPO}/${DOCKER_NAMESPACE}/${SERVICE_NAME}:${SERVICE_VERSION}
                    docker push ${DOCKER_REPO}/${DOCKER_NAMESPACE}/${SERVICE_NAME}:${SERVICE_VERSION}
                    docker image rm ${SERVICE_NAME}:${SERVICE_VERSION}
                    docker image rm ${DOCKER_REPO}/${DOCKER_NAMESPACE}/${SERVICE_NAME}:${SERVICE_VERSION}
                '''
            }
        }

        stage('部署到远程机器') {
             steps {
                 // 使用sed的核心思路还是保证脚本能够复用而只需要修改参数
                sh """
                    sed -e 's/__nacos_ip__/${NACOS_IP}/' \
                    -e 's/__serviceName__/${SERVICE_NAME}/' \
                    -e 's/__ip__/${SERVER_IP}/' \
                    -e 's/__port__/${SERVER_PORT}/' \
                    -e 's/__docker_repo__/${DOCKER_REPO}/' \
                    -e 's/__docker_namespace__/${DOCKER_NAMESPACE}/' \
                    -e 's/__docker_username__/${DOCKER_USERNAME}/' \
                    -e 's/__docker_password__/${DOCKER_PASSWORD}/' \
                    -e 's/__version__/${SERVICE_VERSION}/' \
                    -e 's/__user__/${SERVER_USER}/' \
                    -e 's#__JAVA_OPTS__#${JAVA_OPTS}#' \
                    -e 's/__namespaceId__/${NAMESPACE_ID}/' deploy.sh > replace.sh;
                """

                // Jenkins自带的ssh插件
                sshScript remote: host(), script: "replace.sh"
             }
        }
    }
}

pipeline {

    agent any

    environment {
        // 环境
        ENV = 'PRO'
        // 服务名 ip 端口 版本
        SERVICE_NAME = 'xx'
        SERVER_IP = 'xx'
        SERVER_PORT = 'xx'
        SERVER_USER = 'xx'
        SERVICE_VERSION = 'xx'
        // docker repo 内网ip
        DOCKER_INTERNAL_REPO = 'xx'
        // docker repo 外网ip（上传镜像用）
        DOCKER_PUBLIC_REPO = 'xx'
        // docker repo 命令空间 帐号密码
        DOCKER_NAMESPACE = 'xx'
        DOCKER_USERNAME = 'xx'
        DOCKER_PASSWORD = 'xx'
        // 注册中心地址 命名空间
        NACOS_IP = 'xx'
        NAMESPACE_ID = 'xx'
        // ssh 密钥文件
        SECRET_FILE = credentials('xx')
        // jvm参数
        JAVA_OPTS = 'xx'
    }

    stages {

        stage('构建MAVEN项目') {
            agent {
                docker {
                    image 'maven:3-alpine'
                    args '-v /var/jenkins_home/.m2:/root/.m2'
                }
            }
            steps {
                sh 'mvn clean install -Dmaven.test.skip=true -Dproject.type=jar -Ppro package'
            }
        }

        stage('构建docker镜像') {
            agent {
                docker {
                    image 'docker'
                    args '-v /var/jenkins_home/.m2/repository/com/ghaoqi:/root/jar'
                }
            }
            steps {
                sh '''
                    rm -f docker/*.jar
                    cp /root/jar/${SERVICE_NAME}/${SERVICE_VERSION}-${ENV}/${SERVICE_NAME}-${SERVICE_VERSION}-${ENV}.jar ./docker/${SERVICE_NAME}.jar
                    cd docker
                    docker build -t ${SERVICE_NAME}:${SERVICE_VERSION} .
                '''
            }
        }

        stage('推送构建的镜像') {
            steps {
                sh '''
                    docker login -u ${DOCKER_USERNAME} -p ${DOCKER_PASSWORD} ${DOCKER_PUBLIC_REPO}
                    docker tag ${SERVICE_NAME}:${SERVICE_VERSION} ${DOCKER_PUBLIC_REPO}/${DOCKER_NAMESPACE}/${SERVICE_NAME}:${SERVICE_VERSION}
                    docker push ${DOCKER_PUBLIC_REPO}/${DOCKER_NAMESPACE}/${SERVICE_NAME}:${SERVICE_VERSION}
                    docker image rm ${SERVICE_NAME}:${SERVICE_VERSION}
                    docker image rm ${DOCKER_PUBLIC_REPO}/${DOCKER_NAMESPACE}/${SERVICE_NAME}:${SERVICE_VERSION}
                '''
            }
        }

        stage('部署到远程机器') {
             steps {
                sh """
                    sed -e 's/__nacos_ip__/${NACOS_IP}/' \
                        -e 's/__serviceName__/${SERVICE_NAME}/' \
                        -e 's/__ip__/${SERVER_IP}/' \
                        -e 's/__port__/${SERVER_PORT}/' \
                        -e 's/__docker_repo__/${DOCKER_INTERNAL_REPO}/' \
                        -e 's/__docker_namespace__/${DOCKER_NAMESPACE}/' \
                        -e 's/__docker_username__/${DOCKER_USERNAME}/' \
                        -e 's/__docker_password__/${DOCKER_PASSWORD}/' \
                        -e 's/__version__/${SERVICE_VERSION}/' \
                        -e 's/__user__/${SERVER_USER}/' \
                        -e 's#__JAVA_OPTS__#${JAVA_OPTS}#' \
                        -e 's/__namespaceId__/${NAMESPACE_ID}/' deploy.sh > replace.sh;
                """
                // 和测试唯一的区别就是在这里，主要是需要跳板服务器去部署线上的服务器(没有外网IP)
                // $SECRET_FILE是在Jenkins中保存的凭证，原本是可以直接保持ssh凭证然后使用对应的函数来获取的
                // 但是无奈不知为何不能获取，就直接使用了这种简单暴力的文件的形式来读取了
                // -oStrictHostKeyChecking=no 这个参数比较重要因为脚本执行的时候可不会自动输入yes
                // ssh xxx@xxx -C "/bin/bash" < xx.sh 可以用来在远程服务器上执行脚本
                // 在写sh脚本的时候选择使用 “” 还是 '' 来包含参数是很重要的，'' 的形式是完全不转义的也就是说不能使用sh的变量
                // 注意: 需要在服务器上配置ssh免密
                sh """
                    cat $SECRET_FILE > pc-libs
                    chmod 400 pc-libs
                    scp -i pc-libs -oStrictHostKeyChecking=no replace.sh libs@47.110.85.172:/home/libs/${SERVICE_NAME}.sh
                    ssh -oStrictHostKeyChecking=no -i pc-libs libs@47.110.85.172 \
                        'ssh -oStrictHostKeyChecking=no webs@${SERVER_IP} -C "/bin/bash" < /home/libs/${SERVICE_NAME}.sh';
                """
             }
        }
    }
}

$ curl -fsSL get.docker.com -o get-docker.sh
$ sudo sh get-docker.sh --mirror Aliyun
# 将当前用户加入 docker 组
$ sudo usermod -aG docker $USER

FROM java:8

ENV TimeZone=Asia/Shanghai

USER root
# 这里添加组和用户主要是线上服务是不用root启动的
# 如果不修改用户的话应用生成的日志都是root权限的无法操作
# 注意：简单来说，容器内外的所有用户是一样的，容器内的root可以看作就是服务器上的root
RUN mkdir /data \
    && groupadd -r webs \
    && useradd -d /data/webs -r -g webs webs \
    && mkdir -p /data/webs/common-data/logs \
    && mkdir -p /data/webs/common-data/logs/jvm-log \
    && chown -R webs:webs /data/webs \
    # 应用的时区修改，否则日志时间相差8小时
    && ln -snf /usr/share/zoneinfo/$TimeZone /etc/localtime \
    && echo $TimeZone > /etc/timezone

USER webs
ADD common-data.jar common-data.jar
# 启动应用的命令， JAVA_OPTS 在启动脚本中配置，在上面的pipeline变量中应该已经看到
# 目的是为了将全部变量都放置在一起配置保证复用
ENTRYPOINT java ${JAVA_OPTS} -jar common-data.jar