Redash详细Docker部署教程

发表于 | 分类于

Redash详细部署教程

1、安装Docker-CE

1.1、安装步骤

Docker 运行在 CentOS 7 上，要求系统为64位、系统内核版本为 3.10 以上。

Docker 运行在 CentOS-6.5 或更高的版本的 CentOS 上，要求系统为64位、系统内核版本为 2.6.32-431 或者更高版本。

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
#检测Linux版本  命令：uname -r
[root@mongodb-salve ~]# uname -r
3.10.0-693.2.2.el7.x86_64

#安装系统依赖
sudo yum install -y yum-utils device-mapper-persistent-data lvm2

#添加软件源信息
sudo yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

#更新yum缓存
sudo yum makecache fast

#查看所有docker版本
#yum list docker-ce --showduplicates | sort -r

#安装Docker-ce
sudo yum -y install docker-ce

#启动 Docker 后台服务
sudo systemctl start docker

#设置开机启动
sudo systemctl enable docker

#安装检测  当提示安装的版本号就已经标示安装完成
[root@mongodb-salve ~]# docker --version
Docker version 18.09.6, build 481bc77156
#或
[root@mongodb-salve ~]# docker version
Client:
 Version:           18.09.6
 API version:       1.39
 Go version:        go1.10.8
 Git commit:        481bc77156
 Built:             Sat May  4 02:34:58 2019
 OS/Arch:           linux/amd64
 Experimental:      false

Server: Docker Engine - Community
 Engine:
  Version:          18.09.6
  API version:      1.39 (minimum version 1.12)
  Go version:       go1.10.8
  Git commit:       481bc77
  Built:            Sat May  4 02:02:43 2019
  OS/Arch:          linux/amd64
  Experimental:     false

1.2、卸载Docker-CE

1
2
sudo yum remove docker-ce
sudo rm -rf /var/lib/docker

注：移除旧版本Docker

1
2
3
4
5
6
7
8
9
10
sudo yum remove docker \
                 docker-client \
                 docker-client-latest \
                 docker-common \
                 docker-latest \
                 docker-latest-logrotate \
                 docker-logrotate \
                 docker-selinux \
                 docker-engine-selinux \
                 docker-engine

1.3、镜像加速

鉴于国内网络问题，后续拉取 Docker 镜像十分缓慢，我们可以需要配置加速器来解决，我使用的是网易的镜像地址：http://hub-mirror.c.163.com。(或者使用其他的镜像)

新版的 Docker 使用 /etc/docker/daemon.json（Linux） 或者 %programdata%\docker\config\daemon.json（Windows） 来配置 Daemon。

请在该配置文件中加入（没有该文件的话，请先建一个）：

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

1.4、常见错误

  • 不能正常使用命令，报错信息如下

    1
    2
    3
    Cannot connect to the Docker daemon at unix:///var/run/docker.sock. Is the docker daemon running? 

    解决：检测Docker服务是否启动，是否需要超级管理员权限

2、安装Docker-compose

  • 安装方式(二进制文件)
1
2
3
4
5
6
7
8
9
10
#下载最新版的docker-compose文件   github地址：https://github.com/docker/compose/releases
curl -L https://github.com/docker/compose/releases/download/1.24.0/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose
chmod +x /usr/local/bin/docker-compose

#添加可执行权限 
sudo chmod +x /usr/local/bin/docker-compose

#测试安装结果 
docker-compose --version 
docker-compose version 1.24.0, build 0aa59064

  • 删除方式

    1
    2
    #直接删除二进制文件
    sudo rm -rf /usr/local/bin/docker-compose

    注：另一种方式请自行百度，这里不做过多介绍

3、安装Redash

Redash介绍

​ 此处省略一万字

  • 安装过程

    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
    #从GitHub下载源码
    git clone https://github.com/getredash/redash.git

    #进入redash目录
    cd redash

    #创建docker-compose.production.yml文件,内容参考yml配置
    touch docker-compose.production.yml


    #创建db
    docker-compose -f docker-compose.production.yml run --rm server create_db
     
    #Starting redash_redis_1
    #Starting redash_postgres_1
    #[2019-06-11 09:02:39,580][PID:1][INFO][root] Generating grammar tables from /usr/lib/python2.7/lib2to3/Grammar.txt
    #[2019-06-11 09:02:39,601][PID:1][INFO][root] Generating grammar tables from /usr/lib/python2.7/lib2to3/PatternGrammar.txt
    #[2019-06-11 09:02:41,707][PID:1][INFO][alembic.runtime.migration] Context impl PostgresqlImpl.
    #[2019-06-11 09:02:41,708][PID:1][INFO][alembic.runtime.migration] Will assume transactional DDL.
    #[2019-06-11 09:02:41,724][PID:1][INFO][alembic.runtime.migration] Running stamp_revision -> 969126bd800f
     
    #redash运行
    docker-compose -f docker-compose.production.yml up
    #redash运行后台运行
    docker-compose -f docker-compose.production.yml up -d


    #如果配置邮箱预警可用以下命令检测 可以接受到邮件，如有问题可检测你的邮件配置
    docker exec -it redash_server_1 python manage.py send_test_mail

  • docker-compose.production.yml(注意用yml的编写格式)

    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
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    # This is an example configuration for Docker Compose. Make sure to atleast update
    # the cookie secret & postgres database password.
    #
    # Some other recommendations:
    # 1. To persist Postgres data, assign it a volume host location.
    # 2. Split the worker service to adhoc workers and scheduled queries workers.
    version: '2'
    services:
      server:
        image: redash/redash:6.0.0.b8537
        command: server
        depends_on:
          - postgres
          - redis
        ports:
          - "5000:5000"
        environment:
          PYTHONUNBUFFERED: 0
          REDASH_LOG_LEVEL: "INFO"
          REDASH_REDIS_URL: "redis://redis:6379/0"
          REDASH_DATABASE_URL: "postgresql://postgres@postgres/postgres"
          REDASH_COOKIE_SECRET: "yongzheng"
          REDASH_WEB_WORKERS: 4   
          #邮箱 
          REDASH_MAIL_SERVER: "smtp.exmail.qq.com"
          REDASH_MAIL_PORT: 465
          REDASH_MAIL_USE_TLS: "true"
          REDASH_MAIL_USE_SSL: "true"
          REDASH_MAIL_USERNAME: "yongzheng@qq.com"
          REDASH_MAIL_PASSWORD: "yongzheng"
          REDASH_MAIL_DEFAULT_SENDER: "yongzheng@qq.com"
          REDASH_HOST: "http://192.168.3.110:88"
        restart: always
      worker:
        image: redash/redash:6.0.0.b8537
        command: scheduler
        environment:
          PYTHONUNBUFFERED: 0
          REDASH_LOG_LEVEL: "INFO"
          REDASH_REDIS_URL: "redis://redis:6379/0"
          REDASH_DATABASE_URL: "postgresql://postgres@postgres/postgres"
          QUEUES: "queries,scheduled_queries,celery"
          WORKERS_COUNT: 2
        restart: always
      redis:
        image: redis:3.0-alpine
        ports:
         - "6379:6379"
        volumes: 
          - ./data/redis_data:/data
        restart: always
      postgres:
        image: postgres:9.5.6-alpine
        ports:
         - "5432:5432"
        volumes:
          - ./data/postgresql_data:/var/lib/postgresql/data
        restart: always
      nginx:
        image: redash/nginx:latest
        ports:
          - "88:80"
        volumes:
          - ./data/nginx:/etc/nginx
        #depends_on:
        #  - server
        links:
          - server:redash
        restart: always

    注：Redash的版本请勿使用latest，否则则会query查询不出。

    ​ 网上很多教程都是使用latest版本，但是文章写得

4、使用介绍

使用请自行找度娘

Docker命令及软件安装

发表于 | 更新于 | 分类于

Docker命令及软件安装

一、Docker简介

Docker的简介及一些说明请自行百度，主要了解虚拟化，镜像，容器等概念。

二、Docker安装

​ Docker官方建议在Ubuntu中安装，因为Docker是基于Ubuntu发布的，而且一般Docker出现的问题Ubuntu是最先更新或者打补丁的。在很多版本中CentOS是不支持更新最新的一些补丁包的的。写本文时三个版本都体验过这里主要以Deepin（Ubuntu的衍生版）。

2.2、Ubuntu中安装

  • 注：如果安装过则可以，/var/lib/docker/保留包括图像，容器，卷和网络在内的内容。
  • 使用apt-get命令安装
1
sudo apt-get install docker.io -y
  • 查看Docker版本
1
sudo docker -v
  • 查看Docker的信息
1
sudo docker info
  • 查看帮助文档
1
sudo docker --help

2.2、CentOS中安装

  • 使用yun命令安装
1
yum install docker -y
  • 查看Docker版本
1
docker -v

注意：centos中查看ip ip addr

2.3、windows中安装

Windows中安装需要注意，Windows版本不同安装包会有所不同，这里介绍使用Windows10系统安装。

三、Docker服务的启动与关闭

这里主要介绍Linux版的Docker服务启动与关闭，如需Windows的请询问度娘，个人认为Windows版Docker还是很少装。本人也体验过Windows版从安装到使用都没用Linux版的好用。

注：systemctl命令是系统服务管理器指令，它是 service 和 chkconfig 两个命令组合

3.1、Docker服务的启动

1
systemctl start docker

3.2、Docker服务的停止

1
systemctl stop docker

3.3、Docker服务的重启

1
systemctl restart docker

3.4、查看Docker服务状态

1
systemctl status docker

3.5、设置Docker开机启动

1
systemctl enable docker

3.6、开放Docker的2375端口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#编辑docker文件
sudo vim /lib/systemd/system/docker.service

#找到ExecStart=/usr/bin/dockerd
#在ExecStart=/usr/bin/dockerd后追加 -H tcp://0.0.0.0:2375 -H unix:///var/run/docker.sock
ExecStart=/usr/bin/dockerd -H tcp://0.0.0.0:2375 -H unix:///var/run/docker.sock


#加载Docker守护线程
systemctl daemon-reload
#重启Docker
systemctl restart docker

#查看端口
 netstat -tnlp |grep 2375
 
#进行2375端口（或浏览器访问http://ip:2375/info）
 curl 127.0.0.1:2375/info

四、Docker镜像

  • 什么是Docker镜像

​ Docker镜像是由文件系统叠加而成（是一种文件的存储形式）。最底端是一个文件引导系统，即bootfs，这很像典型的Linux/Unix的引导文件系统。Docker用户几乎永远不会和引导系统有什么交互。实际上，当一个容器启动后，它将会被移动到内存中，而引导文件系统则会被卸载，以留出更多的内存供磁盘镜像使用。Docker容器启动是需要的一些文件，而这些文件就可以称为Docker镜像。

4.1、查询镜像

1
sudo docker search mysql

注：

  • NAME：仓库名称
  • DESCRIPTION：镜像描述
  • STARS：用户评价，反应一个镜像的受欢迎程度
  • OFFICIAL：是否官方
  • AUTOMATED：自动构建，表示该镜像由Docker Hub自动构建流程创建的

4.2、获得镜像列表

1
sudo docker images

注:

  • REPOSITORY：镜像所在的仓库名称
  • TAG：镜像标签
  • IMAGE ID：镜像ID
  • CREATE：镜像的创建日期
  • SIZE：镜像大小

注：这些镜像都在Docker宿主机的/var/lib/docker目录下

4.3、拉取镜像

1
2
3
4
#默认latest
sudo docker pull mysql
#指定版本
sudo docker pull mysql:5.7

注：默认在Docker Hub上拉取镜像，在没指定标签时，默认拉取latest版本。

4.4、删除镜像

1
2
3
4
5
6
# 删除指定镜像
sudo docker rmi $IMAGES_ID
sudo docker rmi $REPOSITORY:$TAG

# 删除所有镜像
sudo docker rmi `sudo docker images -q`

4.5、创建镜像

  • 根据已有容器创建
1
sudo docker commit -a "Yongzheng" -m "Ubuntu:16" 4968e97f588d ubuntu:16.6

  • 根据Dockerfile创建

    编写好Dockerfile文件，在同级目录下执行shell语句。

    • 注：

    Dockerfile的编写请参考官网

    1
    2
    3
    4
    #server:v1.0  server为镜像名字   v1.0为TAG（标签）    
    # . 代表DockerFile 与当前目录为同级目录
    sudo docker build -t server:v1.0 . 
    sudo docker build -t registry.cn-hangzhou.aliyuncs.com/yongzheng/jenkins:lts .

4.6、镜像的备份与恢复

  • 镜像的备份
1
2
3
4
# sudo docker save -o 宿主机目录/镜像名.tar $IMAGES_ID/$REPOSITORY:$TAG
sudo docker  save -o nginx.tar nginx

`
  • 镜像的恢复
1
2
3
4

# sudo docker load -i 宿主机目录/镜像名.tar

sudo docker load -i nginx.tar

五、Docker容器

5.1、查看容器

  • 查看正在运行的容器
1
sudo docker ps
  • 查看所有容器（启动过的历史容器）

​

1
sudo docker ps -a

  • 查看最后一期运行的容器
1
sudo docker ps -l
  • 查看停止的容器
1
sudo docker ps -f status-exited

5.2、创建与启动容器

  • 守护运行
1
2
sudo docker run -id ubuntu /bin/bash
 # 注：运行一个需要长时间运行的容器，也可以理解为后台运行
  • 交互式运行
1
2
sudo docker run -it ubuntu /bin/bash
# 注：退出交互式运行（退出时容器停止）   exit

注：

  • -i：表示运行容器
  • -t：表示运行容器并进入终端命令行（交互运行）
  • -d：表示运行容器（后台运行守护运行）
  • -p：表示端口映射，前者是宿主机端口，后者是容器的映射锻课，可以指定多个端口映射。
  • –name：表示为容器命名
  • -v：表示目录映射关系，前者宿主机目录，后者容器目录，可以使用多个目录映射。（最好目录映射,将宿主机的目录与容器内的目录进行映射，这样我们就可以通过修改宿主机某个目录的文件从而去影响容器。如果出现目录没有权限问题，加上--privileged=true）

5.3、启动容器

1
sudo docker start $CONTAINER_ID/$NAME

5.4、重新启动容器

1
sudo docker restart $CONTAINER_ID/$NAME

5.5、终止容器

  • 立即终止
1
sudo docker stop $CONTAINER_ID/$NAME
  • 延时终止 （秒）
1
sudo docker stop -t 20  $CONTAINER_ID/$NAME

5.6、删除容器

1
2
3
4
sudo docker rm $CONTAINER_ID/$NAME
		 -f, --force=false 强制终止并删除一个运行中的容器
		 -l， --link=false 删除容器的连接，但保留容器
 		-v， --volumes=false删除容器所挂载的数据卷

5.7、查看容器IP

  • 查看容器运行的各种参数
1
sudo docker inspect $CONTAINER_ID/$NAME
  • 查询容器的IP
1
sudo docker inspect --format '{{ .NetworkSettings.IPAddress }}' $CONTAINER_ID/$NAME

5.8、容器的导入导出

  • 导出容器
1
sudo docker export 4968e97f588d -ubuntu.tar
  • 导入容器
1
cat ubuntu.tar | sudo docker import - yongzheng/ubuntu:v1.0

5.9、进入容器内部

  • attach命令
1
sudo docker attach $CONTAINER_ID/$NAME
  • exec命令
1
sudo docker exec -it $CONTAINER_ID/$NAME /bin/bash

6.0、文件拷贝

  • 将文件拷贝到容器
1
2
sudo docker cp 需要拷贝的文件或目录 容器名称:容器目录
sudo docker cp nginx.conf  $CONTAINER_ID/$NAME:/etc/nginx/nginx.conf
  • 从容器拷贝到宿主机
1
2
# sudo docker cp 容器名称:容器文件或目录 需要拷贝的文件或目录
sudo docker cp $CONTAINER_ID/$NAME:/etc/nginx/nginx.conf nginx.conf

六、安装Docker应用

6.1、安装SQL Server

  • 拉取镜像
1
sudo docker pull microsoft/mssql-server-linux
  • 创建容器并运行
1
2
3
4
5
6
7
8
9
10
11
12
13
#端口映射
sudo docker run --name mssql --restart always -id \
	-e 'ACCEPT_EULA=Y' -m 512m \
	-e 'MSSQL_SA_PASSWORD=YongZheng@1995' \
	-v /home/yongzheng/mssql:/var/opt/mssql \
	-p 1433:1433 microsoft/mssql-server-linux

# 不使用端口映射直接使用宿主机
sudo docker run --name mssql --net=host --restart always -id \
 -e 'ACCEPT_EULA=Y' \
 -e 'MSSQL_SA_PASSWORD=YongZheng@1995' \
    -v /home/yongzheng/mssql:/var/opt/mssql \
    -p 1433:1433 microsoft/mssql-server-linux
  • 注：密码需要复杂密码，要有大小写和特殊符号

6.2、安装jenkins

  • 拉取镜像
1
sudo docker pull jenkins/jenkins:lts
  • 创建容器并运行
1
2
3
sudo docker run --name jenkins --restart always -id \
     	-v /home/yongzheng/jenkins:/var/jenkins_home \
     	-p 8888:8080 -p 50000:50000  jenkins/jenkins:lts

6.3、安装Zookeeper

  • 拉取镜像
1
sudo docker pull zookeeper

  • 创建容器并运行

    1
    2
    3
    4
    5
    6
    7
    sudo docker run  --name zookeeper --restart always -id \
    	-e ZOO_LOG4J_PROP="INFO,ROLLINGFILE" \
    	-e TZ="Asia/Shanghai" \
    	-v /home/yongzheng/zookeeper/data:/data \
    	-v /home/yongzheng/zookeeper/datalog:/datalog \
    	-v /home/yongzheng/zookeeper/logs:/logs \
    	-p 2181:2181  zookeeper
  • 注：
    • ZOO_TICK_TIME：ZooKeeper以毫秒为单位。它用于调节心跳和超时（默认2000）
    • ZOO_INIT_LIMIT：（默认5）
    • ZOO_SYNC_LIMIT：（默认2）
    • ZOO_MAX_CLIENT_CNXNS：单个IP的兵法连接数（默认60）
    • ZOO_STANDALONE_ENABLED：（默认flase）
    • ZOO_AUTOPURGE_PURGEINTERVAL：（默认0）
    • ZOO_AUTOPURGE_SNAPRETAINCOUNT：（默认3）3.4.0中的新增功能：启用后，ZooKeeper自动清除功能分别在dataDir和dataLogDir中保留autopurge.snapRetainCount最新快照和相应的事务日志，并删除其余日志。默认为3.最小值为3。

6.4、安装Redis

  • 拉取镜像
1
sudo docker pull redis:3.2.9
  • 创建容器并运行
1
2
3
4
5
6
sudo docker run --name redis --restart=always -id \
	-v /home/yongzheng/redis/data:/data \
	-e TZ="Asia/Shanghai" \
	-p 6379:6379  redis \
	--appendonly yes \
	--requirepass "yongzheng"
  • 注：
    • redis-server --appendonly yes: 在容器执行redis-server启动命令，并打开redis持久化配置
    • requirepass “your passwd”:设置认证密码
    • –restart=always: 随docker启动而启动
  • 进入容器执行Redis客户端
1
2
3
sudo docker exec -it 容器id或name redis-cli -a 'your passwd'

#sudo docker exec -it a126ec987cfe redis-cli -h 127.0.0.1 -p 6379 -a 'your passwd'
  • 注：
    • -h 127.0.0.1 :默认不加为-h 127.0.0.1
    • -p 6379 :默认不加为 -p 6379

6.5、安装MongoDB

  • 拉取镜像
1
sudo docker pull mongo
  • 创建容器并运行
1
2
3
4
5
6
sudo docker run --name mongo --restart always -id \
	-e MONGO_INITDB_ROOT_USERNAME=yongzheng \
	-e MONGO_INITDB_ROOT_PASSWORD=yongzheng \
	-e MONGO_INITDB_DATABASE=admin \
	-v /home/yongzheng/mongo:/date/db \
	-p 27017:27017 mongo --storageEngine wiredTiger
  • 注：
    • --storageEngine wiredTiger:指定你需要的储存引擎
    • MONGO_INITDB_ROOT_USERNAME`, `MONGO_INITDB_ROOT_PASSWORD:创建一个新用户并设置该用户的密码
    • MONGO_INITDB_DATABASE:允许您指定要用于创建脚本的数据库的名称
  • 查看MongoDB日志
1
2
sudo docker exec -it some-mongo bash
sudo docker logs some-mongo

  • 设置MongoDB的密码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    # 进入容器
    sudo docker exec -it mongo /bash/bin
    #选择数据库

    use admin;
    #设置密码

    db.createUser({user: "yongzheng",pwd: "yongzheng",roles: [{role: "userAdminAnyDatabase",db: "admin"}]})

    #验证是否创建成功
    db.auth("yongzheng","yongzheng")

    # 选择数据库
    use test;
    #设置密码
    db.createUser({user:"testuser",pwd:"testpass",roles:["readWrite"]});
    #验证是否创建成功
    db.auth("testuser","testpass")

6.6、安装RabbitMQ

  • 拉取镜像
1
2
sudo docker pull rabbitmq:management  或
sudo docker pull daocloud.io/library/rabbitmq:management
  • 创建容器并运行
1
2
3
4
5
6
7
sudo docker run --name rabbitmq --restart always -id \
    -e TZ="Asia/Shanghai" \
    -e RABBITMQ_DEFAULT_USER=yongzheng \
    -e RABBITMQ_DEFAULT_PASS=yongzheng \
    -p 15671:15671 -p 15672:15672 -p 5671:5671 -p 5672:5672 \
    -v /home/yongzheng/rabbitmq:/var/lib/rabbitmq \
    --hostname rabbitmq rabbitmq:management
  • 注：镜像一定要拉management的，否则无管理界面

6.7、安装KafKa

  • 因为kafka需要借助zookeeper，所以首先要安装zookeeper

  • 拉取镜像

    1
    sudo docker pull wurstmeister/kafka

  • 创建容器并运行

    1
    2
    3
    4
    5
    sudo docker run -id --name kafka --restart always -p 9092:9092 --link zookeeper -e KAFKA_ZOOKEEPER_CONNECT=zookeeper:2181 -e KAFKA_ADVERTISED_HOST_NAME=192.168.3.244 -e KAFKA_ADVERTISED_PORT=9092 wurstmeister/kafka:latest



    sudo docker run -id --name kafka --restart always -p 9092:9092 --link zookeeper  -e KAFKA_BROKER_ID=0  -e KAFKA_ADVERTISED_PORT=9092 -e KAFKA_ADVERTISED_HOST_NAME=192.168.3.244 -e KAFKA_ZOOKEEPER_CONNECT=192.168.3.244:2181 -e KAFKA_ADVERTISED_LISTENERS=PLAINTEXT://192.168.3.244:9092 -e KAFKA_LISTENERS=PLAINTEXT://0.0.0.0:9092 wurstmeister/kafka

  • 安装KafKa监控

1
sudo docker run --name kafkamanager --restart always -id -p 9000:9000 --link zookeeper -e ZK_HOSTS="zookeeper:2181" -e APPLICATION_SECRET=letmein sheepkiller/kafka-manager
1
sudo docker run --restart always -id -p 9001:9000 --link zookeeper -e ZKHOSTS="zookeeper:2181" --name="kafka-manager" srangwal/kafkamanager

  • KafKa简单命令行操作

    进入安装kafka安装目录下的bin目录，执行以下shell

    • 创建topic

      1
      ./kafka-topics.sh --zookeeper zookeeper:2181 --create --topic yongzheng --partitions 30  --replication-factor 1

    • 删除topic

      1
      ./kafka-topics.sh --delete --zookeeper zookeeper:2181 --topic yongzheng

    • 查询所有topic list

      1
      ./kafka-topics.sh --list --zookeeper zookeeper:2181

    • 生产者

      1
      ./kafka-console-producer.sh --broker-list 127.0.0.1:9092 --topic yongzheng

    • 消费者

      1
      ./kafka-console-consumer.sh --bootstrap-server zookeeper:2181 --from-beginning --topic yongzheng

  • zookeeper中删除topic

    1
    2
    3
    4
    5
    6
    # 进入zookeeper安装的bin目录 启动
    ./zkCli.sh 
    # 查看所有topic
    ls /brokers/topics
    # 删除指定的topic
     rmr /brokers/topics/topic-name

6.8、安装MySQL

  • 拉取镜像
1
2
sudo docker pull mysql:5.7  或
sudo docker pull daocloud.io/library/mysql:5.7
  • 创建容器并运行
1
2
3
4
5
6
7
sudo docker run --name mysql --restart always -id \
    -e TZ="Asia/Shanghai" \
    -e MYSQL_ROOT_PASSWORD=yongzheng \
    -e MYSQL_USER=yongzheng \
    -e MYSQL_PASSWORD=yongzheng \
    -v /home/yongzheng/mysql:/var/lib/mysql \
    -p 3306:3306 -id mysql:5.7
  • 注：
    • MYSQL_ROOT_PASSWORD:指定ROOT超级用户的密码
    • MYSQL_DATABASE：指定要在镜像启动时创建的数据库的名称。如果提供了用户/密码，则该用户将被授予对该数据库的超级用户访问权限
    • MYSQL_USER, MYSQL_PASSWORD：创建新用户并设置该用户的密码。此用户将被授予MYSQL_DATABASE变量指定的数据库的超级用户权限
    • MYSQL_ALLOW_EMPTY_PASSWORD=yes：设置为yes允许以root用户的空密码启动容器（不建议操作）
    • MYSQL_RANDOM_ROOT_PASSWORD=yes、：设置yes为root用户生成随机初始密码将打印到stdout（GENERATED ROOT PASSWORD: .....）
    • MYSQL_ONETIME_PASSWORD：ROOT首次登录时强制更改密码，在MySQL5.6+上支持
  • 查看日志
1
2
sudo docker exec -it mysql bash
sudo docker logs mysql

6.9、安装Nginx

  • 拉取镜像
1
sudo docker pull nginx
  • 创建容器并运行
1
2
3
sudo docker run --name=nginx --restart always -di  \
	-v /home/ubuntu/nginx:/etc/nginx/conf.d \
	--link gitlab -e TZ="Asia/Shanghai" -p 80:80 nginx

注：官方的nginx镜像,nginx配置文件nginx.conf 在/etc/nginx/目录下

7.0、安装Orcare

  • 拉取镜像
1
2


7.1、安装ActiveMQ

  • 拉取镜像
1
sudo docker pull webcenter/activemq
  • 创建容器并运行
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
sudo docker run --name activemq -id --restart always \
	-e 'ACTIVEMQ_CONFIG_NAME=activemq' \
	-e 'ACTIVEMQ_CONFIG_DEFAULTACCOUNT=false' \
	-e 'ACTIVEMQ_ADMIN_LOGIN=yongzheng' \
	-e 'ACTIVEMQ_ADMIN_PASSWORD=yongzheng' \
	-v /home/yongzheng/activemq/data:/data \
	-v /home/yongzheng/activemq/datalog:/var/log/activemq  \
	-p 61616:61616 \
	-p 8161:8161 \
	webcenter/activemq

sudo docker run --name='activemq' -d \
-e 'ACTIVEMQ_CONFIG_NAME=amqp-srv1' \
-e 'ACTIVEMQ_CONFIG_DEFAULTACCOUNT=false' \
-e 'ACTIVEMQ_ADMIN_LOGIN=yongzheng' -e 'ACTIVEMQ_ADMIN_PASSWORD=yongzheng' \
-e 'ACTIVEMQ_USERS_myproducer=producerpassword' -e 'ACTIVEMQ_GROUPS_writes=myproducer' \
-e 'ACTIVEMQ_USERS_myconsumer=consumerpassword' -e 'ACTIVEMQ_GROUPS_reads=myconsumer' \
-e 'ACTIVEMQ_JMX_user1_role=readwrite' -e 'ACTIVEMQ_JMX_user1_password=jmx_password' \
-e 'ACTIVEMQ_JMX_user2_role=read' -e 'ACTIVEMQ_JMX_user2_password=jmx2_password'
-e 'ACTIVEMQ_CONFIG_TOPICS_topic1=mytopic1' -e 'ACTIVEMQ_CONFIG_TOPICS_topic2=mytopic2'  \
-e 'ACTIVEMQ_CONFIG_QUEUES_queue1=myqueue1' -e 'ACTIVEMQ_CONFIG_QUEUES_queue2=myqueue2'  \
-e 'ACTIVEMQ_CONFIG_MINMEMORY=1024' -e  'ACTIVEMQ_CONFIG_MAXMEMORY=4096' \
-e 'ACTIVEMQ_CONFIG_SCHEDULERENABLED=true' \
-v /data/activemq:/data \
-v /var/log/activemq:/var/log/activemq \
-p 8161:8161 \
-p 61616:61616 \
-p 61613:61613 \
webcenter/activemq

7.2、安装elasticsearch

  • 拉取镜像

    1
    sudo docker pull elasticsearch

  • 安装容器并运行

    1
    2
    3
    4
    5
    6
    sudo docker run --name elasticsearch --restart always -id \
        -e "discovery.type=single-node" \
        -e ES_JAVA_OPTS="-Xms256m -Xmx256m" \
      -p 9200:9200 \
        -p 9300:9300 \
      elasticsearch:2.4

    • 注：5.0默认分配jvm空间大小为2G /5.0之前好像是1G

    • 注：进入容器运行

    • 1
      /usr/share/elasticsearch/bin/plugin install mobz/elasticsearch-head

7.3、安装Solr

  • 创建容器并运行

    1
    sudo docker run --name solr -id -p 8983:8983 solr

7.4、安装Tomcat

  • 运行容器
1
2
3
4
5
6
7
8
9
10
11
sudo docker run--name=tomcat --restart always -di \
	-p 9000:8080 \
	-v /home/yongzheng/tomcat:/usr/local/tomcat/webapps \
    --privileged=true tomcat:7-jre7

sudo docker run --name=tomcat --restart always -di \
	-v /mnt/docker/tomcat:/usr/local/tomcat/webapps \
	-e TZ="Asia/Shanghai" \
	--privileged=true \
	-p 9000:8080 \
    tomcat:7-jre7

7.5、安装FastDFS

  • 拉取镜像

    1
    sudo docker pull morunchang/fastdfs

  • 创建容器并运行

    1
    2
    3
    4
    5
    #创建tracker(跟踪服务器) 
    sudo docker run -d --name fastdfs-tracker --restart always --net=host -v /home/yongzheng/fastdfs/tracker/data:/data/fast_data/data morunchang/fastdfs sh tracker.sh

    #创建storage(存储服务器)
    sudo docker run -d --name fastdfs-storage --restart always --net=host -v /home/yongzheng/fastdfs/storage/data:/data/fast_data -e TRACKER_IP=192.168.3.244:22122 -e GROUP_NAME=yongzheng morunchang/fastdfs sh storage.sh
    • 修改容器的ng（可不修改）
    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
    # 进入容器中
    sudo docker exec -it fastdfs-storage /bin/bash
    #修改nginx的配置文件
    vi /data/nginx/conf/nginx.conf
    #修改nginx的配置，不拦截上传内容
      server {
            listen       8080;
            server_name  localhost;

            location /yongzheng/M00 {
      			 proxy_next_upstream http_502 http_504 error timeout invalid_header;
        		 proxy_cache http-cache;
      		     proxy_cache_valid  200 304 12h;
         		 proxy_cache_key $uri$is_args$args;
         		 proxy_pass http://fdfs_yongzheng;
         		 expires 30d;
     		}
      
            error_page   500 502 503 504  /50x.html;
            location = /50x.html {
                root   html;
            }
        }

    #退出容器并重启
    sudo docker restart fastdfs-storage

7.6、安装FastDFS

  • 拉取镜像

    1
    sudo docker pull season/fastdfs

  • 创建容器并运行

    1
    2
    3
    4
    5
    6
    #创建tracker(跟踪服务器) 
    sudo docker run -di -d --name trakcer -v /home/yongzheng/Desktop/fastdfs/tracker_data:/fastdfs/tracker/data --net=host season/fastdfs tracker


    #创建storage(存储服务器)
    sudo docker run -di --name storage -v /home/yongzheng/Desktop/fastdfs/storage_data:/fastdfs/storage/data -v /home/yongzheng/Desktop/fastdfs/storage_data/store_path:/fastdfs/store_path --net=host -e TRACKER_SERVER:192.168.3.244:22122 season/fastdfs storage

    • 修改storage服务器的配置

      1
      2
      3
      4
      5
      6
      7
      8
      #将配置文件从容器复制出来
      sudo docker cp storage:/fdfs_conf/storage.conf  /home
      #将配置文件复制到容器中
      sudo docker cp /home/storage.conf  storage:/fdfs_conf
      #重启容器
      sudo docker restart storage

      注：将storage.conf中tracker_server的设置为自己的ip（宿主机ip）

7.7、安装RocketMQ

  • 拉取镜像

    拉取一下镜像，在创建时若没有，会先pull镜像，在创建容器

  • 创建容器并运行

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    # 创建RocketMQ的server
    sudo docker run -d -p 9876:9876 --name rmqserver  foxiswho/rocketmq:server

    # 创建RocketMQ的broker
    sudo docker run -d -p 10911:10911 -p 10909:10909 --name rmqbroker --link rmqserver:namesrv \
    -e "NAMESRV_ADDR=namesrv:9876" \
    -e "JAVA_OPTS=-Duser.home=/opt"  \
    -e "JAVA_OPT_EXT=-server -Xms128m -Xmx128m -Xmn128m" \
    -v /home/yongzheng/Desktop/docker-rocketmq-master/rmq/rmq/brokerconf/broker.conf:/etc/rocketmq/broker.conf \
    foxiswho/rocketmq:broker

    # 创建图形界面化监控 浏览器访问localhost:8180
    docker run --name rmqconsole -p 8180:8080 --link rmqserver:namesrv -e "JAVA_OPTS=-Drocketmq.namesrv.addr=namesrv:9876 -Dcom.rocketmq.sendMessageWithVIPChannel=false" -t styletang/rocketmq-console-ng

    • 注：/home/yongzheng/Desktop/docker-rocketmq-master/rmq/rmq/brokerconf/broker.conf为本地配置文件。配置文件下载地址

    • 注: 如果你的微服务或者项目在开发的时候rocketmq容器不能直接用IP访问，
      那么请把broker.conf中的 #brokerIP1=192.168.0.253前面#号去掉，并且把后面的IP地址改成你的rocketmq容器宿主机IP地址,否则报 com.alibaba.rocketmq.remoting.exception.RemotingConnectException: connect to <172.0.0.120:10909> failed

7.8、安装gitLab

  • 拉取镜像

    1
    sudo docker pull gitlab/gitlab-ce:latest

  • 创建容器并运行

    1
    2
    3
    4
    5
    6
    7
    8
    9
     # 安装最新版
     sudo docker run --name gitlab-ce --restart always -id \
     	--hostname gitlab.aloneme.com \
     	-e TZ="Asia/Shanghai" \
    -p 8443:443 -p 8800:80 -p 2222:22 \
     	-v /home/yongzheng/gitlab-ce/config:/etc/gitlab \
     	-v /home/yongzheng/gitlab-ce/logs:/var/log/gitlab \
     	-v /home/yongzheng/gitlab-ce/data:/var/opt/gitlab \
         gitlab/gitlab-ce:latest

7.9、安装H5ai

1
2
3
4
5
> h5ai 是一个轻量，强大，美观的网站目录列表程序。
> 可将服务器文件列表以网页形式呈现在浏览器中。同时可播放视频，查看图片，查看 pdf 等。可以实现半个网盘的功能。
> 本教程将使用 Docker 快速的部署 h5ai ，并绑定域名和开启 https 。
> 
>

  • 拉取镜像

    1

  • 创建容器并运行

    1
    sudo docker run --restart=always -d -p 8811:80 -v /home/yongzheng/h5ai:/h5ai --name h5ai ilemonrain/h5ai:full

8.0、安装registry私服

  • 拉取镜像

    1
    sudo docker pull registry:2

  • 创建容器并运行

    1
    sudo docker run -d -p 5000:5000 --restart=always --name registry -v /home/yongzheng/registry:/var/lib/registry registry:2

8.1、安装gogs

  • 创建容器并运行
1
sudo docker run --restart=always -di --name=gogs -p 10022:22 -p 3000:3000 -v /var/gogsdata:/data gogs/gogs

8.2、安装influxdb

1
2
3
4
5
6
docker run -di -p 8083:8083 \
   -p 8086:8086 \
   --expose 8090 \
   --expose 8099 \
   --name influxsrv \
   tutum/influxdb

8.3、安装cadvisor

1
docker run --volume=/:/rootfs:ro --volume=/var/run:/var/run:rw --volume=/sys:/sys:ro --volume=/var/lib/docker/:/var/lib/docker:ro --publish=8080:8080 --detach=true --link influxsrv:influxsrv --name=cadvisor google/cadvisor -storage_driver=influxdb -storage_driver_db=cadvisor -storage_driver_host=influxsrv:8086

8.4、安装Maven私服

1
sudo docker run -id --privileged=true --name=nexus3 --restart=always -p 8081:8081 -v /home/yongzheng/nexus3/nexus-data:/var/nexus-data sonatype/nexus3

8.5、安装Memcached分布式缓存

1
2
#设置容器守护式运行，并且随Docker自动启动
sudo docker run --restart=always --name memcached -d -p 11211:11211 memcached

  • 检测是否安装成功

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    #测试是否启动成功
    netstat -luntp|grep 11211
    #或者
    docker ps


    #安装telnet
    #Centos安装
    yum install -y telnet
    #ubuntu安装
    sudo apt-get install -y telnet 
    #通过telnet方式连接memcached
    telnet 127.0.0.1 11211
    #设置值，age是key，0是标志位，900是生命周期，8代表所占字节数，回车之后的10是value
    set age 0 900 8
    10
    #获取值
    get age
    #退出telnet
    quit

8.6、安装ZABBIX

1
2
3
4
5
6
7
sudo docker run --name mysql --restart always -id -v /mnt/docker/mysql:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=root -e MYSQL_USER=yongzheng -e MYSQL_PASSWORD=yongzheng -p 3306:3306 -id mysql:5.7


docker run --name zabbix-server -e DB_SERVER_HOST="mysql" -e MYSQL_USER="yongzheng" -e MYSQL_PASSWORD="yongzheng" -e MYSQL_DATABASE='zabbix' --link mysql:mysql -p 10051:10051 -d zabbix/zabbix-server-mysql:latest 


docker run --name zabbix-web-nginx --link zabbix-server:zabbix-server --link mysql:mysql -e DB_SERVER_HOST="mysql" -e MYSQL_USER="yongzheng" -e MYSQL_PASSWORD="yongzheng" -e ZBX_SERVER_HOST="zabbix-server" -d -p 8020:80 zabbix/zabbix-web-nginx-mysql

8.7、安装禅道

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#专业版  企业版
docker run -d -p 80:80 -p 3306:3306 \
        -e TZ="Asia/Shanghai" \
        -e USER="yongzheng" -e PASSWD="yongzheng" \
        -e BIND_ADDRESS="false" \
        --name zentao-server \
        idoop/zentao:pro


#开源版
docker run -d -p 8020:80 -p 3307:3306 \
       -e TZ="Asia/Shanghai" \
        -e ADMINER_USER="root" -e ADMINER_PASSWD="xrkj123456" \
        -e BIND_ADDRESS="false" \
        -v /mnt/docker/zentao/:/opt/zbox/ \
        --add-host smtp.exmail.qq.com:163.177.90.125 \
        --name zentao-server \
        idoop/zentao:latest

Docker入门

发表于 | 分类于

Docker

​

1 Docker简介

1.1 什么是虚拟化

​ 在计算机中，虚拟化（英语：Virtualization）是一种资源管理技术，是将计算机的各种实体资源，如服务器、网络、内存及存储等，予以抽象、转换后呈现出来，打破实体结构间的不可切割的障碍，使用户可以比原本的组态更好的方式来应用这些资源。这些资源的新虚拟部份是不受现有资源的架设方式，地域或物理组态所限制。一般所指的虚拟化资源包括计算能力和资料存储。

​ 在实际的生产环境中，虚拟化技术主要用来解决高性能的物理硬件产能过剩和老的旧的硬件产能过低的重组重用，透明化底层物理硬件，从而最大化的利用物理硬件 对资源充分利用

​ 虚拟化技术种类很多，例如：软件虚拟化、硬件虚拟化、内存虚拟化、网络虚拟化(vip)、桌面虚拟化、服务虚拟化、虚拟机等等。

1.2 什么是Docker

​ Docker 是一个开源项目，诞生于 2013 年初，最初是 dotCloud 公司内部的一个业余项目。它基于 Google 公司推出的 Go 语言实现。 项目后来加入了 Linux 基金会，遵从了 Apache 2.0 协议，项目代码在 GitHub 上进行维护。

​

​ Docker 自开源后受到广泛的关注和讨论，以至于 dotCloud 公司后来都改名为 Docker Inc。Redhat 已经在其 RHEL6.5 中集中支持 Docker；Google 也在其 PaaS 产品中广泛应用。

​ Docker 项目的目标是实现轻量级的操作系统虚拟化解决方案。 Docker 的基础是 Linux 容器（LXC）等技术。

​ 在 LXC 的基础上 Docker 进行了进一步的封装，让用户不需要去关心容器的管理，使得操作更为简便。用户操作 Docker 的容器就像操作一个快速轻量级的虚拟机一样简单。

为什么选择Docker?

（1）上手快。

​ 用户只需要几分钟，就可以把自己的程序“Docker化”。Docker依赖于“写时复制”（copy-on-write）模型，使修改应用程序也非常迅速，可以说达到“随心所致，代码即改”的境界。 

随后，就可以创建容器来运行应用程序了。大多数Docker容器只需要不到1秒中即可启动。由于去除了管理程序的开销，Docker容器拥有很高的性能，同时同一台宿主机中也可以运行更多的容器，使用户尽可能的充分利用系统资源。

（2）职责的逻辑分类

​ 使用Docker，开发人员只需要关心容器中运行的应用程序，而运维人员只需要关心如何管理容器。Docker设计的目的就是要加强开发人员写代码的开发环境与应用程序要部署的生产环境一致性。从而降低那种“开发时一切正常，肯定是运维的问题（测试环境都是正常的，上线后出了问题就归结为肯定是运维的问题）”

（3）快速高效的开发生命周期

​ Docker的目标之一就是缩短代码从开发、测试到部署、上线运行的周期，让你的应用程序具备可移植性，易于构建，并易于协作。（通俗一点说，Docker就像一个盒子，里面可以装很多物件，如果需要这些物件的可以直接将该大盒子拿走，而不需要从该盒子中一件件的取。）

（4）鼓励使用面向服务的架构

​ Docker还鼓励面向服务的体系结构和微服务架构。Docker推荐单个容器只运行一个应用程序或进程，这样就形成了一个分布式的应用程序模型，在这种模型下，应用程序或者服务都可以表示为一系列内部互联的容器，从而使分布式部署应用程序，扩展或调试应用程序都变得非常简单，同时也提高了程序的内省性。（当然，可以在一个容器中运行多个应用程序）

1.3 容器与虚拟机比较

​ 下面的图片比较了 Docker 和传统虚拟化方式的不同之处，可见容器是在操作系统层面上实现虚拟化，直接复用本地主机的操作系统，而传统方式则是在硬件层面实现。

与传统的虚拟机相比，Docker优势体现为启动速度快、占用体积小。

1.4 Docker 组件

1.4.1 Docker服务器与客户端

​ Docker是一个客户端-服务器（C/S）架构程序。Docker客户端只需要向Docker服务器或者守护进程发出请求，服务器或者守护进程将完成所有工作并返回结果。Docker提供了一个命令行工具Docker以及一整套RESTful API。你可以在同一台宿主机上运行Docker守护进程和客户端，也可以从本地的Docker客户端连接到运行在另一台宿主机上的远程Docker守护进程。

1.4.2 Docker镜像与容器

​ 镜像是构建Docker的基石。用户基于镜像来运行自己的容器。镜像也是Docker生命周期中的“构建”部分。镜像是基于联合文件系统的一种层式结构，由一系列指令一步一步构建出来。例如：

添加一个文件；

执行一个命令；

打开一个窗口。

也可以将镜像当作容器的“源代码”。镜像体积很小，非常“便携”，易于分享、存储和更新。

​ Docker可以帮助你构建和部署容器，你只需要把自己的应用程序或者服务打包放进容器即可。容器是基于镜像启动起来的，容器中可以运行一个或多个进程。我们可以认为，镜像是Docker生命周期中的构建或者打包阶段，而容器则是启动或者执行阶段。 容器基于镜像启动，一旦容器启动完成后，我们就可以登录到容器中安装自己需要的软件或者服务。

所以Docker容器就是：

​ 一个镜像格式；

​ 一些列标准操作；

​ 一个执行环境。

​ Docker借鉴了标准集装箱的概念。标准集装箱将货物运往世界各地，Docker将这个模型运用到自己的设计中，唯一不同的是：集装箱运输货物，而Docker运输软件。

和集装箱一样，Docker在执行上述操作时，并不关心容器中到底装了什么，它不管是web服务器，还是数据库，或者是应用程序服务器什么的。所有的容器都按照相同的方式将内容“装载”进去。

Docker也不关心你要把容器运到何方：我们可以在自己的笔记本中构建容器，上传到Registry，然后下载到一个物理的或者虚拟的服务器来测试，在把容器部署到具体的主机中。像标准集装箱一样，Docker容器方便替换，可以叠加，易于分发，并且尽量通用。

1.4.3 Registry（注册中心）

​ Docker用Registry来保存用户构建的镜像。Registry分为公共和私有两种。Docker公司运营公共的Registry叫做Docker Hub。用户可以在Docker Hub注册账号，分享并保存自己的镜像（说明：在Docker Hub下载镜像巨慢，可以自己构建私有的Registry）。

​ https://hub.docker.com/

2 Docker安装与启动

2.1 安装Docker

​ Docker官方建议在Ubuntu中安装，因为Docker是基于Ubuntu发布的，而且一般Docker出现的问题Ubuntu是最先更新或者打补丁的。在很多版本的CentOS中是不支持更新最新的一些补丁包的。

​ 由于我们学习的环境都使用的是CentOS，因此这里我们将Docker安装到CentOS上。注意：这里建议安装在CentOS7.x以上的版本，在CentOS6.x的版本中，安装前需要安装其他很多的环境而且Docker很多补丁不支持更新。

​ 请直接挂载课程配套的Centos7.x镜像

（1）yum 包更新到最新

1
sudo yum update

（2）安装需要的软件包， yum-util 提供yum-config-manager功能，另外两个是devicemapper驱动依赖的

1
sudo yum install -y yum-utils device-mapper-persistent-data lvm2

（3）设置yum源为阿里云

1
sudo yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

（4）安装docker

1
sudo yum install docker-ce

（5）安装后查看docker版本

1
docker -v

2.2 设置ustc的镜像

ustc是老牌的linux镜像服务提供者了，还在遥远的ubuntu 5.04版本的时候就在用。ustc的docker镜像加速器速度很快。ustc docker mirror的优势之一就是不需要注册，是真正的公共服务。

https://lug.ustc.edu.cn/wiki/mirrors/help/docker

编辑该文件：

1
vi /etc/docker/daemon.json

在该文件中输入如下内容：

1
2
3
{
"registry-mirrors": ["https://docker.mirrors.ustc.edu.cn"]
}

2.3 Docker的启动与停止

systemctl命令是系统服务管理器指令

启动docker：

1
systemctl start docker

停止docker：

1
systemctl stop docker

重启docker：

1
systemctl restart docker

查看docker状态：

1
systemctl status docker

开机启动：

1
systemctl enable docker

查看docker概要信息

1
docker info

查看docker帮助文档

1
docker --help

3 常用命令

3.1 镜像相关命令

3.1.1 查看镜像

1
docker imgs/dockers

REPOSITORY：镜像名称

TAG：镜像标签

imgs/docker ID：镜像ID

CREATED：镜像的创建日期（不是获取该镜像的日期）

SIZE：镜像大小

这些镜像都是存储在Docker宿主机的/var/lib/docker目录下

3.1.2 搜索镜像

如果你需要从网络中查找需要的镜像，可以通过以下命令搜索

1
docker search 镜像名称

NAME：仓库名称

DESCRIPTION：镜像描述

STARS：用户评价，反应一个镜像的受欢迎程度

OFFICIAL：是否官方

AUTOMATED：自动构建，表示该镜像由Docker Hub自动构建流程创建的

3.1.3 拉取镜像

拉取镜像就是从中央仓库中下载镜像到本地

1
docker pull 镜像名称

例如，我要下载centos7镜像

1
docker pull centos:7

3.1.4 删除镜像

按镜像ID删除镜像

1
docker rmi 镜像ID

删除所有镜像

1
docker rmi `docker imgs/dockers -q`

3.2 容器相关命令

3.2.1 查看容器

查看正在运行的容器

1
docker ps

查看所有容器

1
docker ps –a

查看最后一次运行的容器

1
docker ps –l

查看停止的容器

1
docker ps -f status=exited

3.2.2 创建与启动容器

创建容器常用的参数说明：

创建容器命令：docker run

-i：表示运行容器

-t：表示容器启动后会进入其命令行。加入这两个参数后，容器创建就能登录进去。即分配一个伪终端。

–name :为创建的容器命名。

-v：表示目录映射关系（前者是宿主机目录，后者是映射到宿主机上的目录），可以使用多个－v做多个目录或文件映射。注意：最好做目录映射，在宿主机上做修改，然后共享到容器上。

-d：在run后面加上-d参数,则会创建一个守护式容器在后台运行（这样创建容器后不会自动登录容器，如果只加-i -t两个参数，创建后就会自动进去容器）。

-p：表示端口映射，前者是宿主机端口，后者是容器内的映射端口。可以使用多个-p做多个端口映射

（1）交互式方式创建容器

1
docker run -it --name=容器名称 镜像名称:标签 /bin/bash

这时我们通过ps命令查看，发现可以看到启动的容器，状态为启动状态

退出当前容器

1
exit

（2）守护式方式创建容器：

1
docker run -di --name=容器名称 镜像名称:标签

登录守护式容器方式：

1
docker exec -it 容器名称 (或者容器ID)  /bin/bash

3.2.3 停止与启动容器

停止容器：

1
docker stop 容器名称（或者容器ID）

启动容器：

1
docker start 容器名称（或者容器ID）

3.2.4 文件拷贝

如果我们需要将文件拷贝到容器内可以使用cp命令

1
docker cp 需要拷贝的文件或目录 容器名称:容器目录

也可以将文件从容器内拷贝出来

1
docker cp 容器名称:容器目录 需要拷贝的文件或目录

3.2.5 目录挂载

我们可以在创建容器的时候，将宿主机的目录与容器内的目录进行映射，这样我们就可以通过修改宿主机某个目录的文件从而去影响容器。
创建容器 添加-v参数 后边为 宿主机目录:容器目录，例如：

1
docker run -di -v /usr/local/myhtml:/usr/local/myhtml --name=mycentos3 centos:7

如果你共享的是多级的目录，可能会出现权限不足的提示。

这是因为CentOS7中的安全模块selinux把权限禁掉了，我们需要添加参数 –privileged=true 来解决挂载的目录没有权限的问题

3.2.6 查看容器IP地址

我们可以通过以下命令查看容器运行的各种数据

1
docker inspect 容器名称（容器ID）

也可以直接执行下面的命令直接输出IP地址

1
docker inspect --format='{{.NetworkSettings.IPAddress}}' 容器名称（容器ID）

3.2.7 删除容器

删除指定的容器：

1
docker rm 容器名称（容器ID）

4 应用部署

4.1 MySQL部署

（1）拉取mysql镜像

1
docker pull centos/mysql-57-centos7

（2）创建容器

1
docker run -di --name=tensquare_mysql -p 33306:3306 -e MYSQL_ROOT_PASSWORD=123456 mysql

-p 代表端口映射，格式为 宿主机映射端口:容器运行端口

-e 代表添加环境变量 MYSQL_ROOT_PASSWORD 是root用户的登陆密码

（3）远程登录mysql

连接宿主机的IP ,指定端口为33306

4.2 tomcat部署

（1）拉取镜像

1
docker pull tomcat:7-jre7

（2）创建容器

创建容器 -p表示地址映射

1
2
docker run -di --name=mytomcat -p 9000:8080 
-v /usr/local/webapps:/usr/local/tomcat/webapps tomcat:7-jre7

4.3 Nginx部署

（1）拉取镜像 

1
docker pull nginx

（2）创建Nginx容器

1
docker run -di --name=mynginx -p 80:80 nginx

4.4 Redis部署

（1）拉取镜像

1
docker pull redis

（2）创建容器

1
docker run -di --name=myredis -p 6379:6379 redis

5 迁移与备份

5.1 容器保存为镜像

我们可以通过以下命令将容器保存为镜像

1
docker commit mynginx mynginx_i

5.2 镜像备份

我们可以通过以下命令将镜像保存为tar 文件

1
docker  save -o mynginx.tar mynginx_i

5.3 镜像恢复与迁移

首先我们先删除掉mynginx_img镜像 然后执行此命令进行恢复

1
docker load -i mynginx.tar

-i 输入的文件

执行后再次查看镜像，可以看到镜像已经恢复

6 Dockerfile

6.1 什么是Dockerfile

Dockerfile是由一系列命令和参数构成的脚本，这些命令应用于基础镜像并最终创建一个新的镜像。

1、对于开发人员：可以为开发团队提供一个完全一致的开发环境；
2、对于测试人员：可以直接拿开发时所构建的镜像或者通过Dockerfile文件构建一个新的镜像开始工作了；
3、对于运维人员：在部署时，可以实现应用的无缝移植。

6.2 常用命令

命令 作用
FROM imgs/docker_name:tag 定义了使用哪个基础镜像启动构建流程
MAINTAINER user_name 声明镜像的创建者
ENV key value 设置环境变量 (可以写多条)
RUN command 是Dockerfile的核心部分(可以写多条)
ADD source_dir/file dest_dir/file 将宿主机的文件复制到容器内，如果是一个压缩文件，将会在复制后自动解压
COPY source_dir/file dest_dir/file 和ADD相似，但是如果有压缩文件并不能解压
WORKDIR path_dir 设置工作目录

6.3 使用脚本创建镜像

步骤：

（1）创建目录

1
mkdir –p /usr/local/dockerjdk8

（2）下载jdk-8u171-linux-x64.tar.gz并上传到服务器（虚拟机）中的/usr/local/dockerjdk8目录

（3）创建文件Dockerfile vi Dockerfile

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#依赖镜像名称和ID
FROM centos:7
#指定镜像创建者信息
MAINTAINER ITCAST
#切换工作目录
WORKDIR /usr
RUN mkdir  /usr/local/java
#ADD 是相对路径jar,把java添加到容器中
ADD jdk-8u171-linux-x64.tar.gz /usr/local/java/

#配置java环境变量
ENV JAVA_HOME /usr/local/java/jdk1.8.0_171
ENV JRE_HOME $JAVA_HOME/jre
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar:$JRE_HOME/lib:$CLASSPATH
ENV PATH $JAVA_HOME/bin:$PATH

（4）执行命令构建镜像

1
docker build -t='jdk1.8' .

注意后边的空格和点，不要省略

（5）查看镜像是否建立完成

1
docker imgs/dockers

7 Docker私有仓库

7.1 私有仓库搭建与配置

（1）拉取私有仓库镜像（此步省略）

1
docker pull registry

（2）启动私有仓库容器

1
docker run -di --name=registry -p 5000:5000 registry

（3）打开浏览器 输入地址http://192.168.184.141:5000/v2/_catalog看到`{"repositories":[]}` 表示私有仓库搭建成功并且内容为空

（4）修改daemon.json

1
vi /etc/docker/daemon.json

添加以下内容，保存退出。

1
{"insecure-registries":["192.168.184.141:5000"]}

此步用于让 docker信任私有仓库地址

（5）重启docker 服务

1
systemctl restart docker

7.2 镜像上传至私有仓库

（1）标记此镜像为私有仓库的镜像

1
docker tag jdk1.8 192.168.184.141:5000/jdk1.8

（2）再次启动私服容器

1
docker start registry

（3）上传标记的镜像

1
docker push 192.168.184.141:5000/jdk1.8

IDEA的破解激活

发表于 | 分类于

1、下载 破解补丁，放在idea的目录下（建议放在lib下）

2、修改软件根部录下的bin/idea.exe.vmoptions和bin/idea64.exe.vmoptions文件

在末尾添加一句话引入补丁的路径（JetbrainsCrack-2.8-release-enc.jar的绝对路径）
​
-javaagent:D:\IntelliJ IDEA\lib\JetbrainsCrack-2.8-release-enc.jar

​

3.重新启动IDEA –> 选择Activation Code –>输入激活码

  • 激活码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
ThisCrackLicenseId-{  
"licenseId":"ThisCrackLicenseId",  
"licenseeName":"idea",  
"assigneeName":"",  
"assigneeEmail":"idea@163.com",  
"licenseRestriction":"For This Crack, Only Test! Please support genuine!!!",  
"checkConcurrentUse":false,  
"products":[  
{"code":"II","paidUpTo":"2099-12-31"},  
{"code":"DM","paidUpTo":"2099-12-31"},  
{"code":"AC","paidUpTo":"2099-12-31"},  
{"code":"RS0","paidUpTo":"2099-12-31"},  
{"code":"WS","paidUpTo":"2099-12-31"},  
{"code":"DPN","paidUpTo":"2099-12-31"},  
{"code":"RC","paidUpTo":"2099-12-31"},  
{"code":"PS","paidUpTo":"2099-12-31"},  
{"code":"DC","paidUpTo":"2099-12-31"},  
{"code":"RM","paidUpTo":"2099-12-31"},  
{"code":"CL","paidUpTo":"2099-12-31"},  
{"code":"PC","paidUpTo":"2099-12-31"}  
],  
"hash":"2911276/0",  
"gracePeriodDays":7,  
"autoProlongated":false}

Linux宝塔的基本命令

发表于 | 分类于

安装宝塔

Centos安装脚本

yum install -y wget && wget -O install.sh http://download.bt.cn/install/install.sh && sh install.sh

Ubuntu/Deepin安装脚本

wget -O install.sh http://download.bt.cn/install/install-ubuntu.sh && sudo bash install.sh

Debian安装脚本

wget -O install.sh http://download.bt.cn/install/install-ubuntu.sh && bash install.sh

Fedora安装脚本

wget -O install.sh http://download.bt.cn/install/install.sh && bash install.sh

更新命令（仅限3.X/4.X面板使用！不支持2.X面板！）：

wget -O update.sh http://download.bt.cn/install/update.sh && sh update.sh 5.3.0

若点击更新后没生效，请尝试重启面板服务：

service bt restart

管理宝塔

停止

/etc/init.d/bt stop

启动

/etc/init.d/bt start

重启

/etc/init.d/bt restart

卸载

/etc/init.d/bt stop && chkconfig –del bt && rm -f /etc/init.d/bt && rm -rf /www/server/panel

查看当前面板端口

cat /www/server/panel/data/port.pl

修改面板端口，如要改成8881（centos 6 系统）

echo ‘8881’ > /www/server/panel/data/port.pl && /etc/init.d/bt restart
iptables -I INPUT -p tcp -m state –state NEW -m tcp –dport 8881 -j ACCEPT
service iptables save
service iptables restart

修改面板端口，如要改成8881（centos 7 系统）

echo ‘8881’ > /www/server/panel/data/port.pl && /etc/init.d/bt restart
firewall-cmd –permanent –zone=public –add-port=8881/tcp
firewall-cmd –reload

强制修改MySQL管理(root)密码，如要改成123456

cd /www/server/panel && python tools.pyc root 123456

修改面板密码，如要改成123456

cd /www/server/panel && python tools.pyc panel 123456

站点配置文件位置

/www/server/panel/vhost

删除域名绑定面板

rm -f /www/server/panel/data/domain.conf

清理登陆限制

rm -f /www/server/panel/data/*.login

查看面板授权IP

cat /www/server/panel/data/limitip.conf

关闭访问限制

rm -f /www/server/panel/data/limitip.conf

查看许可域名

cat /www/server/panel/data/domain.conf

关闭面板SSL

rm -f /www/server/panel/data/ssl.pl && /etc/init.d/bt restart

查看面板错误日志

cat /tmp/panelBoot

查看数据库错误日志

cat /www/server/data/*.err

站点配置文件目录(nginx)

/www/server/panel/vhost/nginx

站点配置文件目录(apache)

/www/server/panel/vhost/apache

站点默认目录

/www/wwwroot

数据库备份目录

/www/backup/database

站点备份目录

/www/backup/site

站点日志

/www/wwwlogs

Nginx服务管理

nginx安装目录

/www/server/nginx

启动

/etc/init.d/nginx start

停止

/etc/init.d/nginx stop

重启

/etc/init.d/nginx restart

启载

/etc/init.d/nginx reload

nginx配置文件

/www/server/nginx/conf/nginx.conf

Apache服务管理

apache安装目录

/www/server/httpd

启动

/etc/init.d/httpd start

停止

/etc/init.d/httpd stop

重启

/etc/init.d/httpd restart

启载

/etc/init.d/httpd reload

apache配置文件

/www/server/apache/conf/httpd.conf

MySQL服务管理

mysql安装目录

/www/server/mysql

phpmyadmin安装目录

/www/server/phpmyadmin

数据存储目录

/www/server/data

启动

/etc/init.d/mysqld start

停止

/etc/init.d/mysqld stop

重启

/etc/init.d/mysqld restart

启载

/etc/init.d/mysqld reload

mysql配置文件

/etc/my.cnf

FTP服务管理

ftp安装目录

/www/server/pure-ftpd

启动

/etc/init.d/pure-ftpd start

停止

/etc/init.d/pure-ftpd stop

重启

/etc/init.d/pure-ftpd restart

ftp配置文件

/www/server/pure-ftpd/etc/pure-ftpd.conf

PHP服务管理

php安装目录

/www/server/php

启动(请根据安装PHP版本号做更改，例如：/etc/init.d/php-fpm-54 start)

/etc/init.d/php-fpm-{52|53|54|55|56|70|71} start

停止(请根据安装PHP版本号做更改，例如：/etc/init.d/php-fpm-54 stop)

/etc/init.d/php-fpm-{52|53|54|55|56|70|71} stop

重启(请根据安装PHP版本号做更改，例如：/etc/init.d/php-fpm-54 restart)

/etc/init.d/php-fpm-{52|53|54|55|56|70|71} restart

启载(请根据安装PHP版本号做更改，例如：/etc/init.d/php-fpm-54 reload)

/etc/init.d/php-fpm-{52|53|54|55|56|70|71} reload

配置文件(请根据安装PHP版本号做更改，例如：/www/server/php/52/etc/php.ini)

/www/server/php/{52|53|54|55|56|70|71}/etc/php.ini

Redis服务管理

redis安装目录

/www/server/redis

启动

/etc/init.d/redis start

停止

/etc/init.d/redis stop

redis配置文件

/www/server/redis/redis.conf

Memcached服务管理

memcached安装目录

/usr/local/memcached

启动

/etc/init.d/memcached start

停止

/etc/init.d/memcached stop

重启

/etc/init.d/memcached restart

启载

/etc/init.d/memcached reload

SpringTask动态配置定时任务的使用

发表于 | 分类于 ，

SpringTask动态配置定时任务的使用

一、需求

  • 在项目开发中、根据业务的需求需要要在在一定的时间或每隔多长时间去执行特定的程序，比如：每天凌晨去统计一些报表。

二、技术分类

2.1、java自带的java.util.Timer类

这个类允许调度一个`java.utils.TimerTask`任务。使用这种方式可以让程序在某一个时间间隔循环执行，但不能在指定时间运行。（一般用的较少）

2.2、使用Quartz

这个是一个功能比较强大的任务调度器，可以让你的程序在每到指定时间执行，也可以按照某一时间间隔循环执行。在功能强大的同时，配置起来稍微的复杂。

2.3、SpringTask（自Spring3.0以后自带task功能）

SpringTask可以看成一个轻量级的Quartz，用起来比Quartz简单的多，配置也比较少，和自家的集成也是非常方便。（同样支持每隔指定时间触发执行、每到指定时间触发执行）
  • 注：
    • 时间间隔为毫秒
    • 指定时间为cron表达式

三、SpringTask普通用法说明

3.1、SpringTask简述

本文使用的是Spring3.0以后自主开发的定时任务工具，他可以看做一个轻量级的Quartz，而且使用起来很简单，除spring相关的包外不需要额外的包，而且支持注解和配置文件两种方式。这里两种方式都介绍一下：

3.2、XML配置文件的使用

  • 第一步：在spring的配置文件中引入命名空间

    1
    2
    3
    4
    xmlns:task="http://www.springframework.org/schema/task"

    http://www.springframework.org/schema/task
         http://www.springframework.org/schema/task/spring-task-3.1.xsd"

  • 第二步：添加定时任务扫描注解

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    <context:component-scan base-package="package" />
    <!-- 定时任务扫描注解（使用@Scheduled时可不配置）-->
    <task:annotation-driven/>
    <task:scheduled-tasks scheduler="scheduler">  
    	<task:scheduled ref="ReportCacheTask" method="cacheUpdateSchedule"  cron="0 17 16 * * ?" />
    </task:scheduled-tasks>

    <task:scheduler id="scheduler" pool-size="10" /> 
    <!--注意这边需要配置供扫描的包 （如果类上加@Service可不配置）-->
    <bean id="ReportCacheTask" class="com.cym.bip.report.data.cache.ReportCacheTask" />

  • 第三步：创建一个com.cym.bip.report.data.cache.ReportCacheTask类，里面

有个cacheUpdateSchedule方法。（代码省略）

3.3、注解方式（重点）

  • 第一步：在spring的配置文件中引入task的命名空间

    1
    2
    3
    4
    xmlns:task="http://www.springframework.org/schema/task"

    http://www.springframework.org/schema/task
         http://www.springframework.org/schema/task/spring-task-3.1.xsd"

  • 第二步：添加定时任务扫描注解

    1
    2
    3
    4
    5
    <context:component-scan base-package="package" />
    <!-- 定时任务扫描注解（使用@Scheduled时可不配置）-->
    <task:annotation-driven scheduler="scheduler"/>
    <!--配置定时任务的线程池（推荐配，若不配置多任务下可能有问题）-->
    <task:scheduler id="scheduler" pool-size="10" />

  • 第三步：创建定时任务类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    package com.leaseBack.apollo;

    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.scheduling.annotation.EnableScheduling;
    import org.springframework.scheduling.annotation.Scheduled;
    import org.springframework.stereotype.Component;

    /**
     * 定时获得定时任务列表
     */
    @Component
    @EnableScheduling //可不配置
    public class SpringTimeTask {
        private static Logger logger = LoggerFactory.getLogger(SpringTimeTask.class);

        // @Scheduled(cron = "0 0/6 * * * ?")  //根据cron表达式执行
        @Scheduled(fixedDelay = 10 * 1000)   //每隔10秒执行一次
        public void timeTaskRun() {
            logger.info("Refresh TimeTask......");
        }
    }

    注：

    • @EnableScheduling：此注解添加在类上表示开启对定时任务的支持（添加此注解，可不在xml中配置注解驱动）
    • @Scheduled：此注解表示在方法上表示此方法按一定时间规则执行

四、SpringTask高级应用（实现动态配置定时任务）

4.1、简述

  • 业务需求

    根据项目需要定时任务方法的逐渐增多和时间规则有可能发变化，以上普通做法在变动时改动比较大，并且定时任务运行起来无法手动操作，不易编码及操作。所以就有了实现动态配置定时任务的想法。

  • 动态定时任务设想

    当我们想定时执行一个任务时，只需要告诉程序要执行的类名（类的全路径）、方法名及cron表达式即可，并且定时任务有开启和关闭功能，根据需求来配置就行。这样做优点：增加了程序的灵活性，减少了硬编码，易于维护。

  • 实现方案

    当我们开启定时任务时，从数据库中获得类的全路径、方法名、cron表达式，根据全路径方法名利用反射机制来新建一个线程去执行方法，并且指定一个cron时间规则

4.2、动态定时任务的实（注解方式）

4.2.1、配置参考普通应用配置（在此省略）
4.2.2、创建一个反射类实现Runnable接口
  • 根据类名，方法名利用反射机制创建一个线程去执行
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
package com.leaseBack.apollo;

import com.apollo.entity.TimeTaskLog;
import com.apollo.interfaces.ITimeTaskLogService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.lang.reflect.Method;
import java.util.Date;

/**
 * 利用反射执行方法，并将日志持久化
 */
public class TaskRun implements Runnable {
    private static Logger logger = LoggerFactory.getLogger(TaskRun.class);

    private String classPath;
    private String methodName;

    static private ITimeTaskLogService timeTaskLogService=          SpringContextHolder.getBean(ITimeTaskLogService.class);

    public TaskRun(String classPath, String methodName) {
        this.classPath = classPath;
        this.methodName = methodName;
    }

    @Override
    public void run() {
        try {
            //获得字节码对象
            Class<?> clazz = Class.forName(classPath);
            Object obj = clazz.newInstance();
            //获得方法
            Method run = clazz.getMethod(methodName);
            //执行方法
            run.invoke(obj);
            logger.info("Start TimeTask Success --" + classPath + "--" + methodName + "--" + new Date().toLocaleString());
        } catch (Exception e) {
            e.printStackTrace();
            logger.error("Start TimeTask Failure --" + classPath + "--" + methodName + "--" + new Date().toLocaleString());
        } 
    }
}
4.2.3、定时任务开启关闭的Service、
  • 用ThreadPoolTaskScheduler（定时任务线程池）去执行一个线程并且按cron时间表达式去执行任务，将返回的ScheduledFuture（线程信息）保存在private static Map<String, ScheduledFuture> map = new HashMap<>();，后面根据ScheduledFuture信息来进行关闭。
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
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
package com.leaseBack.apollo;

import com.apollo.entity.TimeTask;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.data.redis.core.BoundHashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
import org.springframework.scheduling.support.CronTrigger;
import org.springframework.stereotype.Component;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ScheduledFuture;

/**
 * 启动定时任务
 * 关闭定时任务
 */
@Component
public class TaskService {
    private static Logger logger = LoggerFactory.getLogger(TaskService.class);

    @Autowired
    private RedisTemplate redisTemplate;

    @Autowired
    private ThreadPoolTaskScheduler threadPoolTaskScheduler;
    //创建定时任务的线程池
    @Bean
    public ThreadPoolTaskScheduler threadPoolTaskScheduler() {
        return new ThreadPoolTaskScheduler();
    }

    //正在执行的任务
    //ScheduledFuture继承了Future是对于具体的 Runnable任务的执行的储存
    //可以对ScheduledFuture操作当前线程任务的取消、完成状态、获取结果。
    //必要时可以通过get方法获取执行结果，该方法会阻塞直到任务返回结果。
    private static Map<String, ScheduledFuture> map = new HashMap<>();

    /**
     * 开启定时任务
     * @param timeTask
     * @return
     */
    public boolean startTimeTask(TimeTask timeTask) {

		//获得类路径
        String classPath = timeTask.getClassPath();
        //获得方法名
        String methodName = timeTask.getMethodName();
        //获得cron表达式
        String cron = timeTask.getCron();
        //判断线程是否正在运行
        ScheduledFuture sFuture = map.get(classPath + methodName);
        if (sFuture == null) {
        	//利用反射获得一个线程
            TaskRun taskRun = new TaskRun(timeTask.getId(), classPath, methodName);
            //按一定时间规则运行定时任务
            ScheduledFuture schedule = threadPoolTaskScheduler.schedule(taskRun, new CronTrigger(cron));
            logger.info("Start TimeTask......" + classPath + "--" + methodName + "--" + cron + "--" + new Date().toLocaleString());
            //将当前线程信息保存
            map.put(classPath + methodName, schedule);
            return true;
        }
        return false;
    }

    /**
     * 停止定时任务
     * @param timeTask
     * @return
     */
    public boolean stopTimeTask(TimeTask timeTask) {
        String key = timeTask.getClassPath() + timeTask.getMethodName();
        //获得储存线程的信息
        ScheduledFuture sf = map.get(key);
        if (sf != null) {
           //取消当前线程任务
            sf.cancel(true);
            //从map中删除掉
            map.remove(key);
            logger.info("Stop TimeTask......" + timeTask.getClassPath() + "--" + timeTask.getMethodName() + "--" + new Date().toLocaleString());
            return true;
        }
        return false;
    }

    /**
     * 获得定时任务详细信息，并且执行对应的方法
     */
    public void timeTaskRun() {
        BoundHashOperations timetaskRedis = redisTemplate.boundHashOps("timeTask");
        Set keys = timetaskRedis.keys();
        for (Object key : keys) {
            TimeTask timeTask = (TimeTask) timetaskRedis.get(key);
            if (timeTask.getIsStart() == 1) {
                boolean result = startTimeTask(timeTask);
            }
            if (timeTask.getIsStart() == 0) {
                boolean result = stopTimeTask(timeTask);
                timetaskRedis.delete(key);
            }
        }
    }
}

4.2.4、编写定时任务的方法

  • 创建一个普通类
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
package com.timetask.apollo;

import com.apollo.interfaces.ICollectionDailyReportService;
import com.leaseBack.apollo.SpringContextHolder;
import com.xy52.common.utils.DateUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Date;

/**
 * 定时任务报表统计功能
 * @author YongZheng
 */
public class ReportStatistics implements ApplicationContextAware {
    private static Logger logger = LoggerFactory.getLogger(ReportStatistics.class);
    
     private static ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }
    
    /**
     *  催收员业绩日报统计
     *  按日，统计昨天的数据
     */
    public void collectionDailyReport() {
        logger.info("collectionDailyReport starting......");
        //从applicationContext中获得bean
        ICollectionDailyReportService collectionDailyReportService = applicationContext.getBean(ICollectionDailyReportService.class);
        collectionDailyReportService.insertCollectionDailyReport(DateUtil.getYesterdayDate(new Date(), null));
        logger.info("collectionDailyReport end......");
    }
}

五、总结

  • 传输定时任务详细信息时：

    问题：因为p2p-schedule、P2PManager是都web项目service不能相互调用，导致定时任务详细信息不能传递。

    解决方案：一、模仿HTTP请求 二、借助于Redis来储存信息，并且写个定时任务每十秒获得一次Redis中的信息，根据信息去执行（本项目中使用的）

  • 利用反射执行方法时，嵌套了其他service

    问题：利用反射执行方法时，嵌套了其他service（用@Autowired注入），在执行时service报空指针异常，不能正常注入。

    解决方案：一、编写一个工具类 二、实现ApplicationContextAware接口本文章中定时任务的service方法）

  • p2p-schedule项目启动就要执行开启的定时任务

    问题：p2p-schedule项目启动就要执行开启的定时任务，并且还要把所有service都注入之后执行。

    一开始试了好几种方式，都是加载service报错(貌似是null指针异常，具体忘啦)，经过一番查资料找到了一些解决办法。

    解决方案：编写一个类实现了ApplicationListener<ContextRefreshedEvent>接口，重写onApplicationEvent方法。业务编码逻辑:当加载完所有Bean时去掉用service服务方法。

    代码如下：

    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
    > package com.leaseBack.apollo;
    > 
    > import org.slf4j.Logger;
    > import org.slf4j.LoggerFactory;
    > import org.springframework.beans.factory.annotation.Autowired;
    > import org.springframework.context.ApplicationListener;
    > import org.springframework.context.event.ContextRefreshedEvent;
    > import org.springframework.stereotype.Component;
    > import java.util.Date;
    > 
    > /**
    >  * 项目启动时执行定时任务
    >  */
    > @Component
    > public class StartConstruct implements ApplicationListener<ContextRefreshedEvent> {
    >     private static Logger logger = LoggerFactory.getLogger(StartConstruct.class);
    >     @Autowired
    >     private TaskService taskService;
    > 
    >     @Override
    >     public void onApplicationEvent(ContextRefreshedEvent event) {
    >         if (event.getApplicationContext().getParent() == null) {
    >             logger.info("Start all TimeTask--"+new Date().toLocaleString());
    >             taskService.timeTaskRun();
    >             logger.info("Start all TimeTask Success--" + new Date().toLocaleString());
    >         }
    >     }
    > }
    >

安装MySQL8.0问题

发表于 | 分类于

命令行不能识别mysql指令

  • 原因是没有配置环境变量，我们只要配置环境 MYSQL_HOME 与Path就可以解决

  • 1、MYSQL_HOME环境变量的设置

    变量名： MYSQL_HOME
变量值： C:\Program Files\MySQL\MySQL Server 8.0

  • 2、Path环境变量的设置，在之前或之后添加一下变量值

    变量名： Path
变量值： %MYSQL_HOME%\bin

安装完成之后用SQLyog或 Navicat不能登录问题

​

  • 1、在命令行登录mysql

    mysql -u用户名 -p密码   
或   
mysql -u用户名 -p  然后输入密码

  • 2、选择user数据库

    use mysql;

  • 3、修改账号信息

     ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY '你的密码';

>  root是你的用户名(user表中的user)
   localhost是你的地址（user表中的host）

    • 4、查询所有账号的用户名和地址用

      select host,user from user;