gitlab ci 自动编译部署.gitlab-ci.yml配置文件示例

# This file is a template, and might need editing before it works on your project.
image: docker.io/ssoor/gcc-bydld

variables:
  GIT_SUBMODULE_STRATEGY: recursive

  CI_REPOSITORY_NAME: git.huoys.com/${CI_PROJECT_PATH}
  
  CI_CONSUL_ADDR: "http://172.13.0.52:8500"
  
  CI_DOCKER_ROOTDIR: "build"
  CI_DOCKER_REPOSITORY: ${CI_REGISTRY_IMAGE}
  CI_DOCKER_REPOSITORY_TAG: "${CI_COMMIT_REF_NAME}-1.0.${CI_PIPELINE_IID}"

stages:
    - build
    - update
    - deploy

compile:
  stage: build
  cache:
    untracked: true
  script:
    - mkdir -p /cache/bydld
    - ln -s /cache/bydld obj
    - chmod +x build.sh 
    - ./build.sh --save-cache
    - cp -rf lib ${CI_DOCKER_ROOTDIR}/
    - cp -f bydld ${CI_DOCKER_ROOTDIR}/
    - chmod +x ${CI_DOCKER_ROOTDIR}/bydld
    - cp -f start.sh ${CI_DOCKER_ROOTDIR}/start.sh
    - mkdir -p ${CI_DOCKER_ROOTDIR}/res && cp -rf res/* ${CI_DOCKER_ROOTDIR}/res
    - mkdir -p ${CI_DOCKER_ROOTDIR}/lib 
    - cp -f /usr/local/lib/libuv.so.1 ${CI_DOCKER_ROOTDIR}/lib
    - cp -f /usr/local/lib/libiconv.so.2 ${CI_DOCKER_ROOTDIR}/lib
    - cp -f /usr/local/lib/libprotobuf.so.13 ${CI_DOCKER_ROOTDIR}/lib
    - cp -f /usr/local/lib/libhiredis.so.0.13 ${CI_DOCKER_ROOTDIR}/lib
    # - cp -f /usr/local/lib/libcurl.so.4 ${CI_DOCKER_ROOTDIR}/lib # 冲突
    # - cp -f /usr/local/lib64/libstdc++.so.6 ${CI_DOCKER_ROOTDIR}/lib # 冲突
  artifacts:
    paths:
      - ${CI_DOCKER_ROOTDIR}/
  only:
    - test
    - testing

update_image:
  tags:
    - docker
  stage: update
  image: git.huoys.com:9999/docker-image/docker-stable
  variables:
    DOCKER_HOST: tcp://172.13.0.52:2375
    DOCKER_DRIVER: overlay2
  script:
    # 生成服务定义
    - SRV_IMAGE='alpine'
    - SRV_WORKDIR="/${CI_PROJECT_NAME}"
    - SRV_REPOSITORY="${CI_DOCKER_REPOSITORY}"
    - SRV_REPOSITORY_TAG="${CI_DOCKER_REPOSITORY_TAG}"
      
    # 生成镜像
    - docker_build ${CI_DOCKER_REPOSITORY}:latest "./${CI_PROJECT_NAME}"
    - docker_build ${CI_DOCKER_REPOSITORY}:${CI_DOCKER_REPOSITORY_TAG} "./${CI_PROJECT_NAME}"
  only:
    - test
    - testing

update_systemd:
  stage: update
  image: git.huoys.com:9999/docker-image/docker-stable
  script:
    # 环境变量
    - ROOTFS="/usr/local/gitlab-runner/gank"

    - SRV_SSH='[email protected]'
    - SRV_WORKDIR="${ROOTFS}/${CI_PROJECT_NAME}"
    - SRV_DEFINEDIR="${ROOTFS}/service.conf/${CI_PROJECT_NAME}"
    - SRV_ENVIRONMENT='"HTTP_PROXY=172.13.0.52:8118" "HTTPS_PROXY=172.13.0.52:8118"'


    # 更新项目文件
    - echo "Delete old files ..."
    - ssh ${SRV_SSH} rm -rf "${SRV_WORKDIR}"

    - echo "Generate deploy dirs ..."
    - ssh ${SRV_SSH} "mkdir -p ${SRV_WORKDIR} && mkdir -p ${SRV_DEFINEDIR}"

    - echo "Generate deploy files ..."
    - scp -r ${CI_DOCKER_ROOTDIR}/* "${SRV_SSH}:${SRV_WORKDIR}"

    # 重新生成并启动服务 - 已禁用启动服务只生成
    - service_generate "${CI_PROJECT_NAME}_1" "./${CI_PROJECT_NAME} -c ./res/url.json -g 3002 -a 1 -s 1 -e ./res -db ./res/db.json"
    - service_generate "${CI_PROJECT_NAME}_2" "./${CI_PROJECT_NAME} -c ./res/url.json -g 3002 -a 2 -s 2 -e ./res -db ./res/db.json"
    - service_generate "${CI_PROJECT_NAME}_3" "./${CI_PROJECT_NAME} -c ./res/url.json -g 3002 -a 3 -s 3 -e ./res -db ./res/db.json"
    - service_generate "${CI_PROJECT_NAME}_4" "./${CI_PROJECT_NAME} -c ./res/url.json -g 3002 -a 4 -s 4 -e ./res -db ./res/db.json"
  dependencies:
    - compile
  only:
    - test
    - testing

deploy:
  tags:
    - kubectl
  stage: deploy
  script:
    # 更新镜像
    - kubectl -n huoys set image deployment/bydld *="${CI_DOCKER_REPOSITORY}:${CI_DOCKER_REPOSITORY_TAG}"
  dependencies:
    - compile
  environment:
    name: testing
    url: https://172.13.0.53:5001
  only:
    - test
    - testing


# --------------------------------------------------------------------------

.golang_init: &golang_init | 

  function setup_golang() {
    mkdir -p $GOPATH/src/$(dirname $CI_REPOSITORY_NAME)
    ln -svf $CI_PROJECT_DIR $GOPATH/src/$CI_REPOSITORY_NAME
    cd $GOPATH/src/$CI_REPOSITORY_NAME
  }

.docker_init: &docker_init | 

  function docker_setup() {
    if ! docker info &>/dev/null; then
      if [ -z "$DOCKER_HOST" -a "$KUBERNETES_PORT" ]; then
        export DOCKER_HOST='tcp://localhost:2375'
      fi
    fi

    if [[ -n "$CI_REGISTRY_USER" ]]; then
      echo "Logging to GitLab Container Registry with CI credentials..."
      docker login -u "$CI_REGISTRY_USER" -p "$CI_REGISTRY_PASSWORD" "$CI_REGISTRY"
      echo ""
    fi
  }

  function docker_composeup() {
    docker_setup
    
    PARAM_PROJECTNAME=${1:-ci}
    PARAM_COMPOSEFILE=${2:-compose.yml}

    if [[ -f "${PARAM_COMPOSEFILE}" ]]; then
      echo "Update compose container..."

      docker stack deploy -c ${PARAM_COMPOSEFILE} ${PARAM_PROJECTNAME} --with-registry-auth
    else
      echo "Compose file is not found, skip to update container..."
    fi

    echo ""
  }

  function docker_build() {
    docker_setup

    _l_ROOTFS=${CI_DOCKER_ROOTDIR}

    _l_DEPLOY_IMAGE=${SRV_IMAGE:-alpine}
    _l_DEPLOY_WORKDIR=${SRV_WORKDIR}
    _l_DEPLOY_ENVIRONMENT=${SRV_ENVIRONMENT}

    _param_TAG=${1}
    _param_CMD=${2}

    if [[ -z "${_param_TAG}" ]]; then
      echo "Building respository address is not null" >&2
      exit -1
    fi

    # if [[ -d "${_param_MERGEDIR}" ]]; then
    #   cp -rf "${_param_MERGEDIR}"/* "${_l_ROOTFS}/"
      
    #   if [[ $? -ne 0 ]]; then
    #     echo "Copy Dockerfile-based dir ${_param_MERGEDIR} to ${_l_ROOTFS} failed" >&2
    #     exit -1
    #   fi
    # fi

    DOCKER_ARGS=""
    DOCKER_FILE="${_l_ROOTFS}/.dockerfile"

    echo "FROM ${_l_DEPLOY_IMAGE}"        >> ${DOCKER_FILE}

    if [[ -n "${_l_DEPLOY_ENVIRONMENT}" ]]; then
      echo "ENV ${_l_DEPLOY_ENVIRONMENT}"   >> ${DOCKER_FILE}
    fi

    echo "WORKDIR ${_l_DEPLOY_WORKDIR}"   >> ${DOCKER_FILE}
    echo "COPY . ."                       >> ${DOCKER_FILE}
    echo "CMD ${_param_CMD}"              >> ${DOCKER_FILE}

    echo "Building Dockerfile-based application..."
    cat "${DOCKER_FILE}"
    docker build ${DOCKER_ARGS} -t "${_param_TAG}" -f "${DOCKER_FILE}" "${_l_ROOTFS}"

    echo "Pushing [${_param_TAG}] to GitLab Container Registry..."
    docker push "${_param_TAG}"

    echo ""
  }

.service_init: &service_init | 
  function service_define(){
    SRV_PATH="${1}"
    SRV_COMMAND=${2}
    GIT_DEPOT=${CI_PROJECT_PATH:-'none'}

    mkdir -p `dirname ${SRV_PATH}`

    # [Unit]
    # Description=[Gitlab-CI] ${GIT_DEPOT}
    # Documentation=https://git.huoys.com/${GIT_DEPOT}.git
    # Wants=network-online.target
    # After=network-online.target firewalld.service
    # BindsTo=

    # [Service]
    # Type=${SRV_TYPE:-simple}

    # ExecStart=${SRV_COMMAND}
    # WorkingDirectory=${SRV_WORKDIR}

    # # ulimit
    # LimitCORE=infinity
    # LimitNPROC=infinity
    # LimitNOFILE=infinity

    # # restart the docker process if it exits prematurely
    # Restart=${SRV_RESTART:-on-failure}
    # RestartSec=3s
    # #StartLimitBurst=3
    # #StartLimitInterval=60s

    # [Install]
    # WantedBy=multi-user.target
    echo "[Unit]" > ${SRV_PATH}
    echo "Description=[Gitlab-CI] ${GIT_DEPOT}" >> ${SRV_PATH}
    echo "Documentation=https://git.huoys.com/${GIT_DEPOT}.git" >> ${SRV_PATH}
    echo "Wants=network-online.target" >> ${SRV_PATH}
    echo "After=network-online.target ${SRV_BINDSTO} ${SRV_REQUIRES}" >> ${SRV_PATH}
    echo "BindsTo=${SRV_BINDSTO}" >> ${SRV_PATH}
    echo "Requires=${SRV_REQUIRES}" >> ${SRV_PATH}
    echo "" >> ${SRV_PATH}
    echo "[Service]" >> ${SRV_PATH}
    echo "Type=${SRV_TYPE:-simple}" >> ${SRV_PATH}
    echo "Environment=${SRV_ENVIRONMENT}" >> ${SRV_PATH}
    echo "" >> ${SRV_PATH}
    echo "ExecStart=${SRV_COMMAND}" >> ${SRV_PATH}
    echo "WorkingDirectory=${SRV_WORKDIR}" >> ${SRV_PATH}
    echo "" >> ${SRV_PATH}
    echo "# ulimit" >> ${SRV_PATH}
    echo "LimitCORE=infinity" >> ${SRV_PATH}
    echo "LimitNPROC=infinity" >> ${SRV_PATH}
    echo "LimitNOFILE=infinity" >> ${SRV_PATH}
    echo "" >> ${SRV_PATH}
    echo "# restart the docker process if it exits prematurely" >> ${SRV_PATH}
    echo "Restart=${SRV_RESTART:-on-failure}" >> ${SRV_PATH}
    echo "RestartSec=${SRV_RESTARTSEC:-3s}" >> ${SRV_PATH}
    echo "" >> ${SRV_PATH}
    echo "[Install]" >> ${SRV_PATH}
    echo "WantedBy=multi-user.target" >> ${SRV_PATH}
  }

  function service_generate() {
    _param_NAME=${1}
    _param_COMMAND="${2}"

    _l_SSH=${SRV_SSH}
    _l_DEFINE=${SRV_DEFINEDIR}

    SRV_WORKDIR=${SRV_WORKDIR}
    SRV_ENVIRONMENT=${SRV_ENVIRONMENT}

    if [[ -n "${_l_SSH}" ]]; then
      echo "Generate deploy service ${_param_NAME} ..."
      _l_ENTRY_FILE=$(mktemp)
      _l_SERVICE_FILE=$(mktemp)

      echo "#!/bin/sh"              >> ${_l_ENTRY_FILE}
      echo "exec ${_param_COMMAND}" >> ${_l_ENTRY_FILE}
      service_define "${_l_SERVICE_FILE}" "${_l_DEFINE}/${_param_NAME}.entry.sh"

      scp "${_l_ENTRY_FILE}" "${_l_SSH}:${_l_DEFINE}/${_param_NAME}.entry.sh"
      ssh ${_l_SSH} "chmod +x ${_l_DEFINE}/${_param_NAME}.entry.sh"
      scp "${_l_SERVICE_FILE}" "${_l_SSH}:${_l_DEFINE}/${_param_NAME}.service"

      echo "Disable service ${_param_NAME} ..."
      ssh ${_l_SSH} "systemctl stop ${_param_NAME} 2>/dev/null || echo >/dev/null"
      ssh ${_l_SSH} "systemctl disable '${_l_DEFINE}/${_param_NAME}.service' 2>/dev/null || echo >/dev/null"

      echo "Enable and start service ${_param_NAME} ..."
      ssh ${_l_SSH} systemctl enable "${_l_DEFINE}/${_param_NAME}.service"
      ssh ${_l_SSH} systemctl start ${_param_NAME}
    fi
  }
    
.functions_init: &functions_init | 
  function del_and_cpdir(){
    _l_SOURCE_PATH=${1}
    _l_TARGET_PATH=${2}
    
    if [[ -e "${_l_TARGET_PATH}" ]]; then
      echo "delete dir ${_l_TARGET_PATH} ..."
      rm -rf ${_l_TARGET_PATH}
    fi

    echo "copy dir ${_l_SOURCE_PATH} => ${_l_TARGET_PATH} ..."
    mkdir -p ${_l_TARGET_PATH} && cp -rf ${_l_SOURCE_PATH}/* ${_l_TARGET_PATH}
  }

before_script:
  - *golang_init
  - *docker_init
  - *service_init
  - *functions_init