发表于
字数统计: 341 字 | 阅读时长 ≈ 2 min

安装MySQL(指定版本)

1
docker pull mysql:8.0

注：值得注意的是，如果主机已经安装了mysql，那么它会占用3306端口，docker中的mysql将无法正常启动。

解决方式：

1.卸载或暂停主机的mysql服务。

暂停主机上的mysql

1
systemctl stop mysqld

2.创建容器时，修改docker容器的端口映射

启动MySQL

1
docker run -p 3306:3306 --name mysql80 -v /mydata/mysql80/conf:/etc/mysql/conf.d -v /mydata/mysql80/logs:/logs -v /mydata/mysql80/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=root -d mysql:8.0

参数讲解：

-p是将docker中mysql端口号3306映射成为12345端口,也可以选择不映射，使用默认的3306

–name mysql: 运行服务的取名

-v是将主机目录下的文件挂载到容器中路径下(/mydata是我本人数存放目录)

-e MYSQL_ROOT_PASSWORD:初始化root用户密码

-d mysql:8.0 : 后台运行mysql8.0

设置远程访问

进入mysql镜像

1
docker exec -it mysql8 bash

进入mysql命令行

1
mysql -uroot -p

选择mysql数据库

1
use mysql;

设置远程访问

mysql8.0.22设置远程连接

1
update user set host='%' where user='root';
1
flush privileges;

较旧版本的mysql 和 还需要以下设置：

1
2
GRANT ALL PRIVILEGES ON *.* TO 'root'@'%' IDENTIFIED BY 'root' WITH GRANT OPTION; # 设置远程访问
 ```

ALTER USER ‘root‘@’%’ IDENTIFIED WITH mysql_native_password BY ‘root’; #更新一下用户的密码

1
2
```
FLUSH PRIVILEGES; #刷新权限

发表于
字数统计: 191 字 | 阅读时长 ≈ 1 min

拉取禅道

开源版12.3.3
点击这里查看官网文档

拉取禅道开源版12.3.3版本命令如下：

1
sudo docker pull easysoft/zentao:12.3.3

下载地址：http://dl.cnezsoft.com/docker/zentao_12.3.3.tar.gz

拉取禅道开源版12.3.3版本命令如下：

1
sudo gunzip -c zentao_12.3.3.tar.gz | docker load

设置网络驱动

网络驱动名：创建的网络驱动名，可随意指定；

1
sudo docker network create --subnet=192.168.43.0/24 zentaonet

创建映射文件

在根目录新建文件夹

1
2
mkdir /zentao/zentaopms
mkdir /zentao/mysqldata

运行

1
sudo docker run --name zentaoky -p 9997:80 --network=zentaonet --ip 192.168.43.10 --mac-address 02:42:ac:11:00:00 -v /zentao/zentaopms:/www/zentaopms -v /zentao/mysqldata:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 -d easysoft/zentao:12.3.3

发表于
字数统计: 285 字 | 阅读时长 ≈ 2 min

查看mysql安装情况

1
rpm -qa|grep -i mysql
1
2
3
4
5
[root@iZ25rsnm9crfk8Z ~]# rpm -qa|grep -i mysql
mysql-community-libs-5.7.13-1.el6.x86_64
mysql-community-client-5.7.13-1.el6.x86_64
mysql-community-server-5.7.13-1.el6.x86_64
mysql-community-common-5.7.13-1.el6.x86_64

停止mysql服务

1
/etc/init.d/mysqld stop

同上删除所有安装的mysql

1
2
3
4
rpm -ev mysql-community-libs-5.7.13-1.el6.x86_64 --nodeps
rpm -ev mysql-community-client-5.7.13-1.el6.x86_64 --nodeps
rpm -ev mysql-community-server-5.7.13-1.el6.x86_64 --nodeps
rpm -ev mysql-community-common-5.7.13-1.el6.x86_64 --nodeps
1
2
3
4
[root@iZ25rsnm9crfk8Z ~]# rpm -ev mysql-community-server-5.7.13-1.el6.x86_64 --nodeps
Preparing packages...
mysql-community-server-5.7.13-1.el6.x86_64
warning: /etc/my.cnf saved as /etc/my.cnf.rpmsave

查找所有mysql目录并删除

1
find / -name mysql
1
2
3
4
[root@iZ25rsnm9crfk8Z ~]# find / -name mysql
/var/lib/selinux/targeted/active/modules/100/mysql
/var/lib/mysql
/var/lib/mysql/mysql

删除 : 

1
2
3
4
5
6
rm -rf /var/lib/mysql  
rm -rf /var/lib/selinux/targeted/active/modules/100/mysql
rm -rf /opt/mysql
rm -rf /usr/share/bash-completion/completions/mysql
rm -rf /usr/share/selinux/targeted/default/active/modules/100/mysql
rm -rf /usr/share/mysql

删除/etc/my.cnf

1
rm -f /etc/my.cnf

确认是否删除完毕

1
find / -name mysql

发表于
字数统计: 1,466 字 | 阅读时长 ≈ 7 min

常用命令

常用docker命令

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
启动docker：
systemctl start docker
停止docker：
systemctl stop docker
重启docker：
systemctl restart docker

停止已经运行的容器
docker stop aeb8e8618b0c
移除容器
docker rm aeb8e8618b0c
移除镜像
docker rmi f28461be398f


进入对应容器中
docker exec -it c24f74677f5a bash

退出容器
exit

查找文件
find / -name my.php

查找docker容器的ip
docker exec -it c24f74677f5a ip addr

docker 查看缓存
docker system df
docker 删除缓存
docker system prune --volumes
docker 删除悬挂状态的镜像
docker image ls -f dangling=true
docker 删除数据卷中的（数据卷是容器自身文件体统之外的数据存储。
               例如容器中的应用有上传图片的功能，上传之后肯定不能保存在容器内部，因为容器内部的数据会随着容器的死掉而被删除，所以，这些图片要保存在容器之外，也就是数据卷。
               比如我们运行了一个 MongoDB 容器做测试，导入了很多测试数据，这些数据就不是在容器内部的，是在数据卷中，因为 MongoDB 的 Dockerfile 中使用了数据卷。
               测试完成后，删除了这个 MongoDB 容器，但测试数据还在，没被删除。）
docker volume prune
Build Cache 的磁盘占用
Docker 18.09 引入了 BuildKit，提升了构建过程的性能、安全、存储管理等能力。
删除 build cache 可以使用命令：
docker builder prune

以下命令已下载禅道项目为例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
//查找
docker search zentao
 //下载
 docker pull idoop/zentao
 //运行
 docker run -d -p 9998:80 -p 9997:3306 -e ADMINER_USER="root" -e ADMINER_PASSWD="zentao" -e BIND_ADDRESS="false" -v $PWD/zentao:/opt/zbox --name zentao idoop/zentao
//保存镜像到压缩文件
docker save -o zentao.tar zentao
//下载镜像到压缩文件
sz zentao.tar
//上传镜像到压缩文件
rz 
//将镜像tar包加载到镜像中去
docker load -i zentao.tar

拉取禅道开源版12.3.3

点击这里查看官网文档

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
拉取禅道开源版12.3.3版本命令如下：
sudo docker pull easysoft/zentao:12.3.3

下载地址：http://dl.cnezsoft.com/docker/zentao_12.3.3.tar.gz

拉取禅道开源版12.3.3版本命令如下：
sudo gunzip -c zentao_12.3.3.tar.gz | docker load 

网络驱动名：创建的网络驱动名，可随意指定；
 
sudo docker network create --subnet=192.168.43.0/24 zentaonet

在根目录新建文件夹

mkdir /zentao/zentaopms
mkdir /zentao/mysqldata
运行
sudo docker run --name zentaoky -p 9997:80 --network=zentaonet --ip 192.168.43.10 --mac-address 02:42:ac:11:00:00 -v /zentao/zentaopms:/www/zentaopms -v /zentao/mysqldata:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 -d easysoft/zentao:12.3.3

docker从容器里面拷文件到宿主机或从宿主机拷文件到docker容器里面

1、从容器里面拷文件到宿主机？

 答：在宿主机里面执行以下命令

         docker cp 容器名：要拷贝的文件在容器里面的路径       要拷贝到宿主机的相应路径 

 示例： 假设容器名为testtomcat,要从容器里面拷贝的文件路为：/usr/local/tomcat/webapps/test/js/test.js,  现在要将test.js从容器里面拷到宿主机的/opt路径下面，那么命令应该怎么写呢？

 答案：在宿主机上面执行命令

1
docker cp testtomcat：/usr/local/tomcat/webapps/test/js/test.js /opt

2、从宿主机拷文件到容器里面

  答：在宿主机里面执行如下命令

          docker cp 要拷贝的文件路径 容器名：要拷贝到容器里面对应的路径

   示例：假设容器名为testtomcat,现在要将宿主机/opt/test.js文件拷贝到容器里面的/usr/local/tomcat/webapps/test/js路径下面，那么命令该怎么写呢？

   答案：在宿主机上面执行如下命令     

1
docker cp /opt/test.js testtomcat：/usr/local/tomcat/webapps/test/js

3、在这里在记录一个问题，怎么看容器名称？

  执行命令：docker ps，出现如图所示，其中NAMES就是容器名了。

4.需要注意的是，不管容器有没有启动，拷贝命令都会生效。

查看当前docker 版本

1
2
3
4
//方法一
docker --version
//方法二
docker info
1
2
3
4
5
6
7
8
9
10
11
12
13
[root@iZ25rsnm9crfk8Z mydata]# docker --version
Docker version 19.03.8, build afacb8b
[root@iZ25rsnm9crfk8Z mydata]# docker info
Client:
 Debug Mode: false

Server:
 Containers: 3
  Running: 3
  Paused: 0
  Stopped: 0
 Images: 5
 Server Version: 19.03.8

查看 docker 容器指定时间的最后一百条日志数据

1
docker logs -f -t --since="2020-09-07" --tail=100 4ae7018fbd87

重命名镜像

1
docker tag IMAGEID(镜像id) REPOSITORY:TAG（仓库：标签）

例子

1
docker tag ca1b6b825289 registry.cn-hangzhou.aliyuncs.com/xxxxxxx:v1.0

当 docker 重启时，容器自动启动

创建容器时添加参数 –restart=always 后，。

使用方法：

1
docker container update --restart=always 容器名字

关闭方法

1
2
docker update --restart=no <container-id>
docker stop <container-id>

查看docker容器的 ip 地址

第一种，进入容器中查看

因为docker容器是彼此隔离的，所以容器内的ip是不一样的

容器启动后

1
docker exec -it 3062891ce665  bash

进入容器 3062891ce665为这个容器的id 

1
cat /etc/hosts

查看容器的ip

1
2
3
4
5
6
7
8
root@3062891ce665:/var/www/html# cat /etc/hosts
127.0.0.1    localhost
::1	localhost ip6-localhost ip6-loopback
fe00::0	ip6-localnet
ff00::0	ip6-mcastprefix
ff02::1	ip6-allnodes
ff02::2	ip6-allrouters
192.168.10.5	3062891ce665

ip为 192.168.10.5

第二种，直接在外部查看

使用 docker inspect

1
docker inspect --format='{{.NetworkSettings.IPAddress}}' 3062891ce665
1
2
root@wjk-pc:/# docker inspect --format='{{.NetworkSettings.IPAddress}}' 3062891ce665
192.168.10.5

提示

1
docker inspect 3062891ce665

可以返回容器的所有信息

查看docker 容器的端口映射

1
docker port 3062891ce665
1
2
root@wjk-pc:/# docker port 3062891ce665
80/tcp -> 0.0.0.0:9999

docker update –restart=no 113715fa8a4d

发表于
字数统计: 644 字 | 阅读时长 ≈ 3 min

先期工作：安装docker

Centos 8 下安装：

命令：

1
2
3
yum install https://download.docker.com/linux/fedora/30/x86_64/stable/Packages/containerd.io-1.2.6-3.3.fc30.x86_64.rpm
curl -fsSL get.docker.com -o get-docker.sh
sudo sh get-docker.sh --mirror Aliyun

Centos 7 下安装：

1
2
curl -fsSL get.docker.com -o get-docker.sh
sudo sh get-docker.sh --mirror Aliyun

docker启动：

1
2
systemctl enable docker
systemctl start docker

docker 验证：

1
docker run hello-world

当输出以下信息以后，说明docker安装成功

1
Hello from Docker!

打包

第一步：通过svn拉取最新代码

第二步：点击项目目录，点击Project，点击Clean 清除编译信息

第三步：点击项目目录，右键，点击右键菜单中的Gradle(STS)，点击Refresh All，或者按下Ctrl + F5刷新依赖

第四步：点击项目目录，右键，点击右键菜单中的Gradle(STS)，点击Tasks Quick Launcher，或者按下Ctrl + Alt + Shift + R打开并输入Build编译并打包

第五步：打开jar包的目录，并将最新时间的jar包放入linux中打包

 
第六步：查看docker当前镜像列表，防止打出重复镜像（非必要）
命令：

1
docker images

第七步：打开含有要打包的jar包、打包配置文件和项目配置文件的目录，根据打包的配置文件将jar包打成docker镜像

1
2
#下面为文件和目录
application.properties Dockerfile jcz-admin-1.0.jar

文件解释：

1
2
3
application.properties：项目的配置文件；
****.jar：要打的jar包，这里为jcz-admin-1.0.jar；
Dockerfile 打包的配置文件，内容如下；

文件内容的解释：

1
2
3
4
FROM java:8-alpine   使用的JDK
ADD jcz-admin-1.0.jar jczl-admin.jar  要打的Jar包
COPY application.properties application.properties 项目的配置文件，非必要用于，修改项目配置
EXPOSE 8088		指定的端口

命令：

1
docker build -t [要建立的镜像名称]:[版本号] .

例：

1
docker build -t app:3.1.31 .

参数 -t: 镜像的名字及标签，通常 name:tag 或者 name 格式；可以在一次构建中为一个镜像设置多个标签。命令最后有一个空格和小数点一定不要忽略。

此处需要注意：要建立的镜像名称不能包含大写

第八步：查看docker当前镜像列表（非必要）
命令：

1
docker images

第九步：将指定镜像保存成 tar 归档文件，可放到其他服务器部署
命令：

1
docker save -o [保存文件名].tar [镜像名]:[镜像版本]

例：

1
docker save -o app.3.1.31.tar app:3.1.31

PS：参数 -o :输出到的文件。

发表于
字数统计: 2,769 字 | 阅读时长 ≈ 11 min

说明

​ xxl-job是一个分布式任务调度平台 ,
​ 将调度行为抽象形成“调度中心”公共平台，而平台自身并不承担业务逻辑，“调度中心”负责发起调度请求。
​ 将任务抽象成分散的JobHandler，交由“执行器”统一管理，“执行器”负责接收调度请求并执行对应任务的业务逻辑。

一、步骤

1. pom.xml

pom.xml 文件内引入xxl-job

1
2
3
4
5
6
<!-- xxl-job-core 分布式任务调度-->
<dependency>
    <groupId>com.xuxueli</groupId>
    <artifactId>xxl-job-core</artifactId>
    <version>2.3.0</version>
</dependency>

2.application.yml

application.yml 文件中增加配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
xxl:
  job:
    # 执行器通讯TOKEN
    accessToken: ''
    executor:
      # 执行器AppName [选填]：执行器心跳注册分组依据
      appname: my-group
      # 执行器注册 [选填]：优先使用该配置作为注册地址，为空时使用内嵌服务 ”IP:PORT“ 作为注册地址。
      address: http://127.0.0.1:80/
      #  执行器IP [选填]：默认为空表示自动获取IP，多网卡时可手动设置指定IP，该IP不会绑定Host仅作为通讯实用
      ip: ''
      # 执行器端口号 [选填]：小于等于0则自动获取；默认端口为9999，单机部署多个执行器时，注意要配置不同执行器端口；
      port: 9999
      # 执行器运行日志文件存储磁盘路径 [选填] ：需要对该路径拥有读写权限；为空则使用默认路径； 
      logpath: /data/applogs/xxl-job/jobhandler
      # 执行器日志文件保存天数 [选填] ： 过期日志自动清理, 限制值大于等于3时生效; 否则, 如-1, 关闭自动清理功能；
      logretentiondays: 3
    admin:
      # 调度中心部署地址,
      addresses: http://127.0.0.1:9001

3.XxlJobConfig.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

import com.xxl.job.core.executor.impl.XxlJobSpringExecutor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * xxl-job config
 */
@Configuration
public class XxlJobConfig {
    private Logger logger = LoggerFactory.getLogger(XxlJobConfig.class);

    @Value("${xxl.job.admin.addresses}")
    private String adminAddresses;

    @Value("${xxl.job.accessToken}")
    private String accessToken;

    @Value("${xxl.job.executor.appname}")
    private String appname;

    @Value("${xxl.job.executor.address}")
    private String address;

    @Value("${xxl.job.executor.ip}")
    private String ip;

    @Value("${xxl.job.executor.port}")
    private int port;

    @Value("${xxl.job.executor.logpath}")
    private String logPath;

    @Value("${xxl.job.executor.logretentiondays}")
    private int logRetentionDays;


    @Bean
    public XxlJobSpringExecutor xxlJobExecutor() {
        logger.info(">>>>>>>>>>> xxl-job config init.");
        XxlJobSpringExecutor xxlJobSpringExecutor = new XxlJobSpringExecutor();
        xxlJobSpringExecutor.setAdminAddresses(adminAddresses);
        xxlJobSpringExecutor.setAppname(appname);
        xxlJobSpringExecutor.setAddress(address);
        xxlJobSpringExecutor.setIp(ip);
        xxlJobSpringExecutor.setPort(port);
        xxlJobSpringExecutor.setAccessToken(accessToken);
        xxlJobSpringExecutor.setLogPath(logPath);
        xxlJobSpringExecutor.setLogRetentionDays(logRetentionDays);

        return xxlJobSpringExecutor;
    }
}

4.XxlJobTest.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
import com.xxl.job.core.context.XxlJobHelper;
import com.xxl.job.core.handler.annotation.XxlJob;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.List;

@Component
public class XxlJobTest {
    private static Logger logger = LoggerFactory.getLogger(XxlJobTest.class);
 
    /** 
     * 执行器中开发JOB方法  
     */
    @XxlJob("JobHandlerTest")
    public void JobHandlerTest() throws Exception {
        // 打印执行日志
        XxlJobHelper.log("测试JobHandlerTest,执行成功");
        //任务默认为成功状态
        //自定义任务结果可以通过 "XxlJobHelper.handleFail/handleSuccess" 自主设置任务结果
        // default success
        
        logger.info("测试JobHandlerTest,执行成功");
    }
}

注解value值对应的是调度中心新建任务的JobHandler属性的值。
在上述例子中即 JobHandlerTest 对应的是调度中心新建任务的JobHandler属性的值。

二、xxj-job 配置说明

配置执行器

执行器列表 显示手动配置的执行器内容，online机器 展示符合执行器名称的在线机器IP。

  • AppName: 是每个执行器集群的唯一标示AppName, 执行器会周期性以AppName为对象进行自动注册。可通过该配置自动发现注册成功的执行器, 供任务调度时使用;
  • 名称: 执行器的名称,名称为了提高执行器的可读性;
  • 排序: 执行器的排序;
  • 注册方式：调度中心获取执行器地址的方式；
    • 自动注册：执行器自动进行执行器注册，调度中心通过底层注册表可以动态发现执行器机器地址；
    • 手动录入：人工手动录入执行器的地址信息，多地址逗号分隔，供调度中心使用；
  • 机器地址：”注册方式”为”手动录入”时有效，支持人工维护执行器的地址信息；
  • 任务注册方式

采用DB方式进行任务注册发现

  • 执行器注册: 任务注册Beat周期默认30s; 执行器以一倍Beat进行执行器注册, 调度中心以一倍Beat进行动态任务发现; 注册信息的失效时间为三倍Beat;
  • 执行器注册摘除：执行器销毁时，将会主动上报调度中心并摘除对应的执行器机器信息，提高心跳注册的实时性；

配置任务

基础配置：

  • 执行器：任务的绑定的执行器
  • 任务描述：描述信息
  • 负责人：任务的负责人；
  • 报警邮件：任务调度失败时邮件通知的邮箱地址，支持配置多邮箱地址，配置多个邮箱地址时用逗号分隔；

触发配置：

  • 调度类型：
    • 无：该类型不会主动触发调度；
    • CRON：该类型将会通过CRON，触发任务调度；
    • 固定速度：该类型将会以固定速度，触发任务调度；按照固定的间隔时间，周期性触发；

任务配置：

  • 运行模式：
    • BEAN模式：任务以JobHandler方式维护在执行器端；需要结合 “JobHandler” 属性匹配执行器中任务；
    • GLUE模式(Java)：任务以源码方式维护在调度中心；该模式的任务实际上是一段继承自IJobHandler的Java类代码并 “groovy” 源码方式维护，它在执行器项目中运行，可使用@Resource/@Autowire注入执行器里中的其他服务；
    • GLUE模式(Shell)：任务以源码方式维护在调度中心；该模式的任务实际上是一段 “shell” 脚本；
    • GLUE模式(Python)：任务以源码方式维护在调度中心；该模式的任务实际上是一段 “python” 脚本；
    • GLUE模式(PHP)：任务以源码方式维护在调度中心；该模式的任务实际上是一段 “php” 脚本；
    • GLUE模式(NodeJS)：任务以源码方式维护在调度中心；该模式的任务实际上是一段 “nodejs” 脚本；
    • GLUE模式(PowerShell)：任务以源码方式维护在调度中心；该模式的任务实际上是一段 “PowerShell” 脚本；
  • JobHandler：运行模式为 “BEAN模式” 时生效，对应执行器中新开发的JobHandler类“@JobHandler”注解自定义的value值；
  • 执行参数：任务执行所需的参数；

高级配置：

  • 路由策略：当执行器集群部署时，提供丰富的路由策略，包括；
    • FIRST（第一个）：固定选择第一个机器；
    • LAST（最后一个）：固定选择最后一个机器；
    • ROUND（轮询）：；
    • RANDOM（随机）：随机选择在线的机器；
    • CONSISTENT_HASH（一致性HASH）：每个任务按照Hash算法固定选择某一台机器，且所有任务均匀散列在不同机器上。
    • LEAST_FREQUENTLY_USED（最不经常使用）：使用频率最低的机器优先被选举；
    • LEAST_RECENTLY_USED（最近最久未使用）：最久未使用的机器优先被选举；
    • FAILOVER（故障转移）：按照顺序依次进行心跳检测，第一个心跳检测成功的机器选定为目标执行器并发起调度；
    • BUSYOVER（忙碌转移）：按照顺序依次进行空闲检测，第一个空闲检测成功的机器选定为目标执行器并发起调度；
    • SHARDING_BROADCAST(分片广播)：广播触发对应集群中所有机器执行一次任务，同时系统自动传递分片参数；可根据分片参数开发分片任务；
  • 子任务：每个任务都拥有一个唯一的任务ID(任务ID可以从任务列表获取)，当本任务执行结束并且执行成功时，将会触发子任务ID所对应的任务的一次主动调度。
  • 调度过期策略：
    • 忽略：调度过期后，忽略过期的任务，从当前时间开始重新计算下次触发时间；
    • 立即执行一次：调度过期后，立即执行一次，并从当前时间开始重新计算下次触发时间；
  • 阻塞处理策略：调度过于密集执行器来不及处理时的处理策略；
    • 单机串行（默认）：调度请求进入单机执行器后，调度请求进入FIFO队列并以串行方式运行；
    • 丢弃后续调度：调度请求进入单机执行器后，发现执行器存在运行的调度任务，本次请求将会被丢弃并标记为失败；
    • 覆盖之前调度：调度请求进入单机执行器后，发现执行器存在运行的调度任务，将会终止运行中的调度任务并清空队列，然后运行本地调度任务；
  • 任务超时时间：支持自定义任务超时时间，任务运行超时将会主动中断任务；
  • 失败重试次数；支持自定义任务失败重试次数，当任务失败时将会按照预设的失败重试次数主动进行重试；

调度日志

调度中心每次进行任务调度，都会记录一条任务日志，任务日志主要包括以下三部分内容：

任务信息：包括“执行器地址”、“JobHandler”和“执行参数”等属性；

调度信息：包括“调度时间”、“调度结果”和“调度日志”等。

执行信息：包括“执行时间”、“执行结果”和“执行日志”等；

执行器灰度上线

调度中心与业务解耦，只需部署一次后常年不需要维护。但是，执行器中托管运行着业务作业，作业上线和变更需要重启执行器，尤其是Bean模式任务。
执行器重启可能会中断运行中的任务。但是，XXL-JOB得益于自建执行器与自建注册中心，可以通过灰度上线的方式，避免因重启导致的任务中断的问题。

步骤如下：
1、执行器改为手动注册，下线一半机器列表（A组），线上运行另一半机器列表（B组）；
2、等待A组机器任务运行结束并编译上线；执行器注册地址替换为A组；
3、等待B组机器任务运行结束并编译上线；执行器注册地址替换为A组+B组。

一辈子很短，努力的做好两件事就好：
第一件事是热爱生活，好好的去爱身边的人；
第二件事是努力学习，在工作中取得不一样的成绩，实现自己的价值，而不是仅仅为了赚钱。

发表于
字数统计: 423 字 | 阅读时长 ≈ 2 min

说明

access访问日志：
调用接口的时候，对于每一个调用都记录一下访问日志。方便后面的请求追踪

步骤

1.pom.xml

找到springboot项目中的pom.xml文件，将以下maven坐标加入自己项目的pom文件中：

1
2
3
4
5
<dependency>
    <groupId>net.rakugakibox.spring.boot</groupId>
    <artifactId>logback-access-spring-boot-starter</artifactId>
    <version>2.7.1</version>
</dependency>

2.application.yml 或 application.properties

项目原配置文件为application.yml，则增加以下配置：


  tomcat:
    basedir: ./logs
    background-processor-delay: 30
    port-header: X-Forwarded-Port
    protocol-header: X-Forwarded-Proto
    protocol-header-https-value: https
    redirect-context-root: true
    remote-ip-header: X-Forwarded-For
    uri-encoding: UTF-8
    accesslog:
      enabled: true
      buffered: true
      directory: ./log
      file-date-format: .yyyy-MM-dd
      pattern: '%h %l %u %t "%r" %s %b "%{Referer}i" "%{User-Agent}i" %D ms'
      prefix: access_log
      rename-on-rotate: false
      request-attributes-enabled: false
      rotate: true
      suffix: .log

项目原配置文件为application.properties，则增加以下配置：


#tomcat?accesslog??
server.tomcat.accesslog.buffered=true
server.tomcat.accesslog.enabled=true
server.tomcat.accesslog.file-date-format=.yyyy-MM-dd
server.tomcat.accesslog.pattern=%h %l %u %t "%r" %s %b %D
server.tomcat.accesslog.prefix=access_log 
server.tomcat.accesslog.rename-on-rotate=false 
server.tomcat.accesslog.request-attributes-enabled=false 
server.tomcat.accesslog.rotate=true 
server.tomcat.accesslog.suffix=.log 
server.tomcat.accesslog.directory=logs
server.tomcat.basedir=/opt/restInterface/tomcat

3.新建 logback-access.xml

同时在控制台打印accesslog日志，需加入以下配置


<configuration>
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>common</pattern>
        </encoder>
    </appender>
    <appender-ref ref="CONSOLE" />
</configuration>

结果

项目accesslog 日志输出将在项目根目录下logs.log 下查看

一辈子很短，努力的做好两件事就好：
第一件事是热爱生活，好好的去爱身边的人；
第二件事是努力学习，在工作中取得不一样的成绩，实现自己的价值，而不是仅仅为了赚钱。

发表于
字数统计: 703 字 | 阅读时长 ≈ 3 min

CentOS安装Docker

1.系统要求

Docker CE支持64位版本CentOS7,并且要求内核版本不低于3.10。
查看当前系统内核

1
uname -r

2.卸载旧版本

旧版本的Docker称为docker或者docker-engine,使用以下命令卸载旧版本：

1
sudo yum remove docker docker-common docker-selinux docker-engine

3.使用yum安装

1
sudo yum install docker-ce

若报错

1
2
No match for argument: docker-ce
错误：没有任何匹配: docker-ce

使用下面的安装方式

1
curl -sSL https://get.daocloud.io/docker | sh

4.使用脚本安装

在测试或开发环境中Docker官方为了简化安装流程,提供了一套便捷的安装脚本，系统上可以使用这套脚本安装：

1
2
3
apt install curl

curl -fsSL https://get.docker.com | bash -s docker --mirror Aliyun

或者

1
2
3
curl -fsSL https://get.docker.com -o get-docker.sh

sudo sh get-docker.sh --mirror Aliyun

执行这个命令后，脚本就会自动的将一切做准备工作做好，并且把Docker CE的Edge装在系统中。

5.启动Docker CE

1
2
sudo systemctl enable docker #设置开启启动
sudo systemctl start docker

6.建立docker用户组

默认情况下，docker命令会使用Unix socket与Docker引擎通讯。而只有root用户和docker组的用户才可以访问Docker引擎的Unix socket。一般Linux系统上不会直接使用root用户进行操作。因此，需要将使用docker的用户加入docker用户组。

1
2
sudo groupadd docker #建立docker组
sudo usermod -aG docker #USER #将当前用户加入docker组

7.测试Docker是否安装正确

1
docker run hello-world #启动一个基于hello-world镜像的容器

若能正常输出以上信息，则说明安装成功。

CentOS卸载Docker

1. 删除docker安装包

1
sudo yum remove docker-ce

2.删除docker镜像

1
sudo rm -rf /var/lib/docker

镜像加速器

国内从Docker Hub拉取镜像有时会遇到困难，此时可以配置镜像加速器。Docker官方和国内很多云服务商都提供了国内加速器服务，例如：

Docker官方提供的中国registry mirror

阿里云加速器

DaoCloud加速器

163加速器

接下来我们以163加速器为例进行介绍。

CentOS7配置镜像加速

对于使用systemd的系统，请在/etc/docker/daemon.json中写入如下内容(如果文件不存在请新建该文件)

1
2
3
4
5
{
    "registry-mirrors":[
        "http://hub-mirror.c.163.com"
    ]
}

重新启动服务生效

1
2
sudo systemctl daemon-reload
sudo systemctl restart docker

查看当前docker信息

1
docker info
1
2
3
4
5
6
7
8
9
10
11
ID: LGPL:TEHS:FIKG:GAGO:2LFS:LXC5:LAXC:HYYZ:TU2S:FFD2:ZQ5I:LWJM
Docker Root Dir: /var/lib/docker
Debug Mode: false
Registry: https://index.docker.io/v1/
Labels:
Experimental: false
Insecure Registries:
 127.0.0.0/8
Registry Mirrors:
 http://hub-mirror.c.163.com              ##这里显示地址正确就配置成功了
Live Restore Enabled: false