jenkins svn idea docker docker-compose一键部署运行构建

1.需要安装的工具注意开放对应端口

docker安装

安装docker 并且配置docker对外开放端口，使用idea，remote连接，链接如下

Dcoker三剑客安装和基本使用

docker-compose安装

下载

curl -L https://github.com/docker/compose/releases/download/1.21.2/docker-compose-$(uname -s)-$(uname -m) -o /usr/local/bin/docker-compose

下载成功后添加可执行权限

chmod +x /usr/local/bin/docker-compose

版本更新后，旧的下载地址可能会过期，可以直接前往https://github.com/docker/compose/releases查看下载链接

验证是否成功

docker-compose -v

docker本地镜像仓库搭建

下载Registry镜像并启动

拉取镜像
docker pull registry 

启动容器
docker run -d -v /edc/images/registry:/var/lib/registry -p 5000:5000 --restart=always --name registry registry

配置私有仓库的可信任
vim /etc/docker/daemon.json
添加
{ 
    "insecure-registries" : [ "your-server-ip:5000" ] 
}

重启docker 
systemctl restart docker

查看仓库
curl http://your-server-ip:5000/v2/_catalog

查看镜像标签
curl http://your-server-ip:5000/v2/镜像名/tags/list

svn服务器和window客户端安装

服务器链接如下

https://blog.csdn.net/tojohnonly/article/details/79765583

客户端链接如下

https://blog.csdn.net/qq_38225558/article/details/85060370

安装完成后,测试连接服务器

jenkins安装

yum install -y java-1.8.0-openjdk		#如果自己配置了jdk，就要创建软连接，在下面教程

wget -O /etc/yum.repos.d/jenkins.repo https://pkg.jenkins.io/redhat/jenkins.repo				

rpm --import https://pkg.jenkins.io/redhat/jenkins.io.key	#安装jenkins key

yum install -y jenkins 安装

安装完成后可以对jenkins进行一些基础配置
修改配置文件
vim /etc/sysconfig/jenkins

可需要修改内容

JENKINS_USER="root"  为避免权限问题，建议直接将jenkins用户设置为root
JENKINS_PORT="5555"   启动端口号


修改目录权限

chown -R root:root /var/lib/jenkins

chown -R root:root /var/cache/jenkins

chown -R root:root /var/log/jenkins

重启服务

service jenkins restart

启动jenkins

systemctl start jenkins

cat  /var/log/jenkins/jenkins.log  查看启动日志

jenkins依赖java环境，如果没有安装请先安装jdk

如果安装了jdk还是不能启动，检查一下是否jdk安装目录不是一般的默认目录，比如/usr/bin/，
如果不是，创建一个软链接即可。

ln -s /usr/local/java/jdk1.8.0_171/bin/java /usr/bin/java

其中/usr/local/java/jdk1.8.0_171/bin/java是你本机jdk的安装目录

• 访问安装：

打开浏览器，访问ip:5555进行安装，ip为服务器外网ip

• 选择安装推荐插件

• 等待安装，注意该步骤安装缓慢。经常失败重试。慢慢等到装好就行了

• 安装完成后创建用户，开始使用。

2.项目搭建(spring cloud demo)

不懂docker怎么连接，使用的请看 Dcoker三剑客安装和基本使用

• 项目基本目录结构,项目搭建省略，搭建成功后并在本机运行测试成功
  
• Dockerfile文件代码

# 基础镜像使用java
FROM java:8
# 作者
MAINTAINER eangulee <[email protected]>
# VOLUME 指定了临时文件目录为/tmp。
# 其效果是在主机 /var/lib/docker 目录下创建了一个临时文件，并链接到容器的/tmp
#VOLUME  /home/tmp


#ADD  ../../../target/springboot-demo-0.0.1-SNAPSHOT.jar  springboot-demo.jar

#插件定义的jar包路径参数
ARG JAR_FILE

#端口暴露
EXPOSE 8080

# 将jar包添加到容器中并更名为jz-cloud-consumer.jar
ADD ${JAR_FILE} /home/service/jz-cloud-consumer.jar

#运行jar包
ENTRYPOINT ["java", "-jar", "/home/service/jz-cloud-consumer.jar"]

• docker-compose.yml文件代码

version: '2'
services:
  jz-euraka:
    image: 101.37.30.142:5000/jz-euraka:xiao7
    container_name: jz-euraka
    restart: always
    ports:
      - "7001:7001"

  jz-cloud-provider:
    image: 101.37.30.142:5000/jz-cloud-provider:xiao7
    container_name: jz-cloud-provider
    ports:
      - "7002:7002"
    restart: always
    depends_on:
      -  jz-euraka

  jz-cloud-consumer:
    image: 101.37.30.142:5000/jz-cloud-consumer:xiao7
    container_name: jz-cloud-consumer
    restart: always
    ports:
      - "7003:7003"
    depends_on:
      - jz-euraka

• docker插件配置，配置打包同步创建镜像，push镜像到docker仓库
• pom.xml部分代码

     <properties>
        <java.version>1.8java.version>
        <spring-cloud.version>Hoxton.SR3spring-cloud.version>
        <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
        
        <docker.image.prefix>101.37.30.142:5000docker.image.prefix>
        
        <docker.host>http://101.37.30.142:2375docker.host>
           
        <docker.maven.version>1.2.0docker.maven.version>
    properties>

    <build>
         
        <finalName>jz-eurakafinalName>
          
        <defaultGoal>compiledefaultGoal>  
        <plugins>
            
            <plugin>
                <groupId>org.springframework.bootgroupId>
                <artifactId>spring-boot-maven-pluginartifactId>
            plugin>
  			
            <plugin>
                <groupId>com.spotifygroupId>
                <artifactId>docker-maven-pluginartifactId>
                <version>${docker.maven.version}version>
                <executions>
                  
                    <execution>
                        <id>build-imageid>
                        <phase>packagephase>
                        <goals>
                            <goal>buildgoal>
                        goals>
                    execution>
                    
                    <execution>
                        <id>tag-imageid>
                        <phase>packagephase>
                        <goals>
                            <goal>taggoal>
                        goals>
                        <configuration>
                              
                			<image>${docker.image.prefix}/${project.build.finalName}:latestimage>
                			
                         	 
                         	 <newName>${docker.image.prefix}/${project.build.finalName}:xiao7newName>
                        configuration>
                    execution>
                    
                    <execution>
                        <id>push-imageid>
                        <phase>deployphase>
                        <goals>
                            <goal>pushgoal>
                        goals>
                        <configuration>
                            <imageName>${docker.image.prefix}/${project.build.finalName}:latestimageName>
                        configuration>
                    execution>
                executions>
                
                <configuration>
                     
                    <imageName>${docker.image.prefix}/${project.build.finalName}imageName>
                     
                    <dockerHost>${docker.host}dockerHost>
                    
                    <dockerDirectory>${basedir}/src/main/dockerdockerDirectory>
                    
                    
                    <skipDockerBuild>falseskipDockerBuild>
                    
                    <buildArgs>
                        <JAR_FILE>${project.build.finalName}.jarJAR_FILE>
                    buildArgs>
                    
                    <resources>
                        <resource>
                            <targetPath>/targetPath>
                            <directory>${project.build.directory}directory>
                            <include>${project.build.finalName}.jarinclude>
                        resource>
                    resources>
        
                    
                    <pushImage>truepushImage>
                configuration>
            plugin>
        plugins>
    build>

• 打包后的结果
• 

• 查看镜像和仓库

3.jenkins配置和搭建

也可以装window版本的jenkins，配置本地的配置就行了

• 插件准备,安装maven,ssh,svn插件
  
• 配置全局ssh连接阿里云服务器
  
  
• 配置全局工具
  

• 创建任务

• 配置任务
  

• 开始构建
• 
• 查看控制台输出

• 最后查看服务器情况

这样启动可能会失败，因为不同容器内的服务启动有时间先后问题。
docker-compose在配置分布式依赖项目的时候存在启动先后的问题:

解决方案:
https://www.jianshu.com/p/d2f39703bcb5
https://blog.csdn.net/xiao_jun_0820/article/details/78676765

完毕~~~