docker的安装与使用

0.安装Docker

Docker 分为 CE 和 EE 两大版本。CE 即社区版（免费，支持周期 7 个月），EE 即企业版，强调安全，付费使用，支持周期 24 个月。

Docker CE 分为 stable test 和 nightly 三个更新频道。

官方网站上有各种环境下的 安装指南，这里主要介绍 Docker CE 在 CentOS上的安装。

让我们一起来认识一下docker：
1.为什么使用Docker？
答：因操作系统不同，带来环境不兼容问题，持续集成

2.docker如何解决环境不兼容问题？
答：将应用、依赖、函数库、配置一起打包，形成镜像，将镜像运行起来叫容器，底层调用linux内核。

3.Docker和虚拟机区别？
答：
docker是一个系统进程；虚拟机是在操作系统中的操作系统
docker体积小、启动速度快、性能好；虚拟机体积大、启动速度慢、性能一般

4.什么是镜像？
答：将应用程序及其依赖、函数库、配置打包在一起，形成镜像

5.什么是容器？
答：镜像运行起来就是容器，一个镜像可以运行多个容器，每个容器就是一个进程，容器之间相互隔离

6.Docker使用架构流程是怎么样的？（在docker中安装mysql）
答：客户端发起docker pull命令到docker服务端，服务端连接远程仓库拉取镜像到本地
客户端发起docker run命令到docker服务端，服务端基于本地镜像文件构建容器

1.CentOS安装Docker

Docker CE 支持 64 位版本 CentOS 7，并且要求内核版本不低于 3.10， CentOS 7 满足最低内核的要求，所以我们在CentOS 7安装Docker。

1.1.卸载（可选）

如果之前安装过旧版本的Docker，可以使用下面命令卸载：

yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-selinux \
                  docker-engine-selinux \
                  docker-engine \
                  docker-ce

1.2.安装docker

首先需要大家虚拟机联网，安装yum工具

yum install -y yum-utils \
           device-mapper-persistent-data \
           lvm2 --skip-broken

然后更新本地镜像源：

# 设置docker镜像源
yum-config-manager \
    --add-repo \
    https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
    
sed -i 's/download.docker.com/mirrors.aliyun.com\/docker-ce/g' /etc/yum.repos.d/docker-ce.repo

yum makecache fast

然后输入命令：

yum install -y docker-ce

docker-ce为社区免费版本。稍等片刻，docker即可安装成功。

1.3.启动docker

Docker应用需要用到各种端口，逐一去修改防火墙设置。非常麻烦，因此建议大家直接关闭防火墙！

启动docker前，一定要关闭防火墙后！！

启动docker前，一定要关闭防火墙后！！

启动docker前，一定要关闭防火墙后！！

# 关闭
systemctl stop firewalld
# 禁止开机启动防火墙
systemctl disable firewalld

通过命令启动docker：

systemctl start docker  # 启动docker服务

systemctl stop docker  # 停止docker服务

systemctl restart docker  # 重启docker服务

然后输入命令，可以查看docker版本：

docker -v

离线安装docker

由于公司内网无法访问互联网所以要离线安装
一、离线安装docker
1.下载离线包
去官网下载离线包
https://download.docker.com/linux/static/stable/

下载上传就行了
参考文档：https://docs.docker.com/engine/install/binaries/

机房设备无法访问互联网原因，需要进行离线安装

有虚拟机的可以这么下载
一、安装docker
1.下载 Docker 二进制文件

wget https://download.docker.com/linux/static/stable/x86_64/docker-20.10.14.tgz

2.导入到公司服务器并且解压缩

tar -zxvf docker-20.10.14.tgz

3.将docker 相关命令拷贝到 /usr/bin

cp docker/* /usr/bin/

4.docker注册成系统服务

vim /etc/systemd/system/docker.service

5.内容如下

[Unit]
Description=Docker Application Container Engine
Documentation=http://docs.docker.com
After=network.target docker.socket
[Service]
Type=notify
EnvironmentFile=-/run/flannel/docker
WorkingDirectory=/usr/local/bin
ExecStart=/usr/bin/dockerd \
                -H tcp://0.0.0.0:4243 \
                -H unix:///var/run/docker.sock \
                --selinux-enabled=false \
                --log-opt max-size=1g
ExecReload=/bin/kill -s HUP $MAINPID
# Having non-zero Limit*s causes performance problems due to accounting overhead
# in the kernel. We recommend using cgroups to do container-local accounting.
LimitNOFILE=infinity
LimitNPROC=infinity
LimitCORE=infinity
# Uncomment TasksMax if your systemd version supports it.
# Only systemd 226 and above support this version.
#TasksMax=infinity
TimeoutStartSec=0
# set delegate yes so that systemd does not reset the cgroups of docker containers
Delegate=yes
# kill only the docker process, not all processes in the cgroup
KillMode=process
Restart=on-failure
[Install]
WantedBy=multi-user.target

6.添加执行权限

chmod +x /etc/systemd/system/docker.service

7.重新加载配置文件，启动服务，设置开机自启

systemctl daemon-reload
systemctl start docker
systemctl enable docker.service

8.查看状态

systemctl status docker

9.查看Docker版本

docker -v

1.配置镜像加速器

echo "{
  "registry-mirrors": ["https://docker.mirrors.ustc.edu.cn"]
}"
>> /etc/docker/daemon.json

2.重载配置

systemctl daemon-reload

3.重启docker

systemctl restart docker

douker的镜像操作

docker build 构建镜像

docker pull拉取镜像

docker save 将镜像保存为tar
docker load 将tar恢复成镜像
docker images 查询所有镜像

docker rmi 删除镜像(docker rmi 镜像名称:镜像版本号 docker rmi 镜像id)

docker的容器操作命令

docker run 创建并运行容器 ok
docker run --name nginx -v html:/usr/share/nginx/html -v conf:/etc/nginx/nginx.conf -p 8080:80 -d nginx:1.20

docker start 启动容器 ok

docker stop 停止容器 ok

docker ps 查询所有运行的容器和状态 ok
docker ps -a 查询所有容器 包括停止的容器 ok

docker logs 查询容器运行日志 ok

docker exec 进入容器内部 ok

docker rm 删除容器

数据卷的问题

为什么使用数据卷？
答：直接在容器中修改不方便
容器中数据不可复用（仅仅只能在容器中使用）
升级维护困难（例如：redis从4版本升级到6）

什么是数据卷？
数据卷是虚拟目录，数据卷是一种逻辑概念，是虚拟的，并非真实存在，与容器内的文件有映射关系，还指向宿主文件系统中的某个目录

数据卷常用命令
create 创建一个volume ok
inspect 显示一个或多个volume的信息 ok
ls 列出所有的volume ok
prune 删除未使用的volume
rm 删除一个或多个指定的volume

数据卷挂载分为：数据卷挂载 目录挂载

数据卷挂载跟目录挂载区别？
答：
数据卷挂载耦合度低，由docker来管理目录，但是目录较深，不好找（docker volume命令查询）
目录挂载耦合度高，需要我们自己管理目录，不过目录容易寻找查看（自己需要记住目录在哪里）

如果要用数据卷来配置一个MySQL容器，先下载镜像

创建mysql.cnf文件，且内容为[mysql]

mkdir mysql && echo [mysql] > mysql/mysql.cnf

使用直接挂载的方式来创建mysql容器

docker run -di --name=mysql2 -e MYSQL_ROOT_PASSWORD=123456 -p 23306:3306
-v /root/mysql/mysql.cnf:/etc/mysql/conf.d/mysql.cnf
-v /root/mysql/data:/var/lib/mysql
mysql:5.7

-v /root/mysql/mysql.cnf:/etc/mysql/conf.d/mysql.cnf :映射文件
-v /root/mysql/data:/var/lib/mysql映射宿主机下的/root/mysql目录与容器里的/var/lib/mysql

然后测试链接就行，外部访问端口改成了23306

自定义镜像

先了解镜像的结构

Docker镜像原理

问题

• Docker镜像本质是什么？
• Docker中的一个centos镜像为什么只有200MB，而一个centos操作系统的iso文件却要几个G？
• Docker中一个tomcat镜像为什么有500MB，而一个tomcat安装包只有70+MB？

Linux文件系统

Linux文件系统由bootfs和rootfs两部分组成

• bootfs：包含bootloader（引导加载程序）和kernel（内核）

  rootfs：root文件系统，包含的就是典型的linux系统中的/dev，/proc，/bin，/etc等标准目录和文件

• 不同的linux发行版本，bootfs基本一样，而rootfs不同。如：ubuntu，centos等

Docker镜像文件

Docker镜像是由特殊的文件系统叠加而成

最底端的是bootfs，并使用宿主机的bootfs

第二层是root文件系统rootfs，称为base image

然后再往上可以叠加其它的镜像文件

统一文件系统（Union File System）技术将不同的层整合成一个文件系统，为这些层提供了一个统一的视角，这样就隐藏了多层的存在，在用户的角度看来，只存在一个文件系统（镜像）

一个镜像可以放在另一个镜像的上面，位于下面的镜像称为父镜像，最底部的为基础镜像

问题解答

• Docker镜像本质是什么？
  • 是一个分层的文件系统，将不同的分层合成一个文件系统。
• Docker中的一个centos镜像为什么只有200MB，而一个centos操作系统的iso文件却要几个G？
  • CentOS的镜像文件包含bootfs和rootfs，而docker的centos镜像复用操作系统的bootfs，只有rootfs和其镜像层，因此文件要小得多。
• Docker中一个tomcat镜像为什么有500MB，而一个tomcat安装包只有70+MB？
  • 由于docker镜像是分层的，tomcat虽然只有70多M，但他需要依赖于交镜像和基础镜像，所有整个对外暴露的tomcat镜像要比安装文件的多。
    镜像底层结构是什么样？
    答：
    基础镜像（BaseImage） 应用依赖的系统函数库、环境、配置、文件等

入口（Entrypoint）镜像运行入口，一般是程序启动的脚本和参数

层（ Layer ）在BaseImage基础上添加安装包、依赖、配置等，每次操作都形成新的一层。

什么是Dockerfile?
答：dockerfile是有一系列指令构成的，每一个指令执行都会形成一个layer层，镜像是由很多层构成的
列如这
FROM centos:7
ENV JAVA_DIR=/usr/local
COPY ./jdk8.tar.gz $JAVA_DIR/
COPY ./docker-demo.jar /tmp/app.jar
RUN cd KaTeX parse error: Undefined control sequence: \ at position 10: JAVA_DIR \̲ ̲ && tar -xf ./j…JAVA_DIR/java8
ENV PATH=$PATH:$JAVA_HOME/bin
EXPOSE 8090
ENTRYPOINT java -jar /tmp/app.jar
自定义镜像步骤
自定义构建一个镜像步骤（Dockerfile能够阅读更改此文件即可）
步骤1：新建一个空文件夹docker-demo
步骤2：拷贝资料中的docker-demo.jar文件到docker-demo这个目录
步骤3：拷贝资料中的jdk8.tar.gz文件到docker-demo这个目录
步骤4：拷贝资料提供的Dockerfile到docker-demo这个目录
步骤5：进入docker-demo
步骤6：docker load -i centos7.tar
步骤7：使用docker build命令构建镜像
步骤8：使用docker run创建容器并运行
最后访问 http://192.168.150.101:8090/hello/count，其中的ip改成你的虚拟机ip

docker-compose.yml
version: “3.5”
services:
nacos:
image: nacos/nacos-server:1.4.1
container_name: nacos
ports:
- 8848:8848
environment:
- MODE=standalone
- JVM_XMS=512m
- JVM_XMX=512m
- JVM_XMN=256m
mysql:
image: mysql:5.7
environment:
MYSQL_ROOT_PASSWORD: root
volumes:
- “$PWD/mysql/data:/var/lib/mysql"-"$PWD/mysql/conf:/etc/mysql/conf.d/”
userservice:
build: ./user-service
orderservice:
build: ./order-service
gateway:
build: ./gateway
ports:
- “7001:7001”

以上资料在本人（添砖java的亮哥）博客资源下免费下载

第二版本，仅供参考（部署各种服务，供运维人员使用）

1 linux 防火墙

systemctl stop firewalld
systemctl disable firewalld # 禁止开机启动

2 安装docker

--卸载旧版本
yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-engine

--设置仓库
yum install -y yum-utils \
  device-mapper-persistent-data \
  lvm2
--设置仓库源 使用阿里云  还是比较慢 得需要配置/etc/docker/damone.json
yum-config-manager \
    --add-repo \
    http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
-- 安装
yum install docker-ce docker-ce-cli containerd.io

如果提示您接受 GPG 密钥，请选是。

--配置/etc/docker/damone.json
vim  /etc/docker/damone.json
内容如下：
{
"registry-mirrors": ["https://alzgoonw.mirror.aliyuncs.com"]
}

--开启自启
 systemctl enable docker

--启动docker
systemctl restart docker

3 docker 安装mysql（没有镜像也没有关系发，执行运行命令时候会更具MySQL版本自动去拉取，docker很智能的哦）

## 创建卷，用于挂载数据
docker volume create mysqlconf
docker volume create mysqldata
## 创建容器 
docker run -d --name mysql -p 3306:3306 -e MYSQL_ROOT_PASSWORD=123456 -e TZ=Asia/Shanghai \
-v mysqlconf:/etc/mysql/conf.d \
-v mysqldata:/var/lib/mysql \
mysql:5.7 --character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci --default-time_zone='+8:00' 

## 开机自启 容器重启策略--restart  always：随着docker的启动而启动
docker update --restart=always mysql

## 如果没有生效 查看如下
https://www.cnblogs.com/double-dong/p/11533341.html

## 时区设置为统一东八区 上海  此处为设置mysql的时区
docker cp /usr/share/zoneinfo/Asia/Shanghai mysql:/usr/share/zoneinfo/Asia

4 修改docker容器时区

docker cp /usr/share/zoneinfo/Asia/Shanghai 容器ID或容器名:/usr/share/zoneinfo/Asia

或者

1. 进入容器之后
2. cd /usr/share/zoneinfo/Asia
3. cp Shanghai /etc/localtime

java 数据源配置参考：

spring:
  application:
    name: order
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://192.168.211.128:3306/数据库名?useSSL=false&useUnicode=true&characterEncoding=UTF8&serverTimezone=Asia/Shanghai
    username: root
    password: 123456

5 安装portainer

它是一个docker图形化界面。

-- 拉取镜像， 已有镜像，不需要拉取
docker pull portainer/portainer-ce
-- 命令行创建容器
docker run -d -p 9000:9000 -v /var/run/docker.sock:/var/run/docker.sock --restart=always --name prtainer portainer/portainer-ce

http://192.168.211.128:9000

用户名/密码：admin/admin1234

6 安装nacos

-- 拉取镜像
docker pull nacos/nacos-server:1.4.1
-- 创建容器
docker run -d --restart=always --name nacos -p 8848:8848 -e MODE=standalone -e NACOS_SERVER_IP=192.168.211.128 -e JVM_XMS=256m -e JVM_XMX=256m -e JVM_XMN=256m nacos/nacos-server:1.4.1

7 安装ES

docker network create es-net
#如果es-net已经存在，则会报: Error response from daemon: network with name es-net already exists 忽略它即可
docker volume create es-data
docker volume create es-plugins
docker run -d \
--name es \
    -e "ES_JAVA_OPTS=-Xms512m -Xmx512m" \
    -e "discovery.type=single-node" \
    -v es-data:/usr/share/elasticsearch/data \
    -v es-plugins:/usr/share/elasticsearch/plugins \
    --privileged \
    --network es-net \
    -p 9200:9200 \
    -p 9300:9300 \
elasticsearch:7.12.1

8 安装Kibana

docker run -d \
--name kibana \
-e ELASTICSEARCH_HOSTS=http://es:9200 \
--network=es-net \
-p 5601:5601  \
kibana:7.12.1

9.安装Mongodb

linux中执行命令

docker volume create mongo-data
docker run -di --name mongodb -p 27017:27017 -v mongo-data:/data --restart=always mongo:4.4

10.安装xxl-job

导入以下脚本

#
# XXL-JOB v2.1.2
# Copyright (c) 2015-present, xuxueli.

CREATE database if NOT EXISTS `xxl_job` default character set utf8mb4 collate utf8mb4_unicode_ci;
use `xxl_job`;


CREATE TABLE `xxl_job_info` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `job_group` int(11) NOT NULL COMMENT '执行器主键ID',
  `job_cron` varchar(128) NOT NULL COMMENT '任务执行CRON',
  `job_desc` varchar(255) NOT NULL,
  `add_time` datetime DEFAULT NULL,
  `update_time` datetime DEFAULT NULL,
  `author` varchar(64) DEFAULT NULL COMMENT '作者',
  `alarm_email` varchar(255) DEFAULT NULL COMMENT '报警邮件',
  `executor_route_strategy` varchar(50) DEFAULT NULL COMMENT '执行器路由策略',
  `executor_handler` varchar(255) DEFAULT NULL COMMENT '执行器任务handler',
  `executor_param` varchar(512) DEFAULT NULL COMMENT '执行器任务参数',
  `executor_block_strategy` varchar(50) DEFAULT NULL COMMENT '阻塞处理策略',
  `executor_timeout` int(11) NOT NULL DEFAULT '0' COMMENT '任务执行超时时间，单位秒',
  `executor_fail_retry_count` int(11) NOT NULL DEFAULT '0' COMMENT '失败重试次数',
  `glue_type` varchar(50) NOT NULL COMMENT 'GLUE类型',
  `glue_source` mediumtext COMMENT 'GLUE源代码',
  `glue_remark` varchar(128) DEFAULT NULL COMMENT 'GLUE备注',
  `glue_updatetime` datetime DEFAULT NULL COMMENT 'GLUE更新时间',
  `child_jobid` varchar(255) DEFAULT NULL COMMENT '子任务ID，多个逗号分隔',
  `trigger_status` tinyint(4) NOT NULL DEFAULT '0' COMMENT '调度状态：0-停止，1-运行',
  `trigger_last_time` bigint(13) NOT NULL DEFAULT '0' COMMENT '上次调度时间',
  `trigger_next_time` bigint(13) NOT NULL DEFAULT '0' COMMENT '下次调度时间',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

CREATE TABLE `xxl_job_log` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `job_group` int(11) NOT NULL COMMENT '执行器主键ID',
  `job_id` int(11) NOT NULL COMMENT '任务，主键ID',
  `executor_address` varchar(255) DEFAULT NULL COMMENT '执行器地址，本次执行的地址',
  `executor_handler` varchar(255) DEFAULT NULL COMMENT '执行器任务handler',
  `executor_param` varchar(512) DEFAULT NULL COMMENT '执行器任务参数',
  `executor_sharding_param` varchar(20) DEFAULT NULL COMMENT '执行器任务分片参数，格式如 1/2',
  `executor_fail_retry_count` int(11) NOT NULL DEFAULT '0' COMMENT '失败重试次数',
  `trigger_time` datetime DEFAULT NULL COMMENT '调度-时间',
  `trigger_code` int(11) NOT NULL COMMENT '调度-结果',
  `trigger_msg` text COMMENT '调度-日志',
  `handle_time` datetime DEFAULT NULL COMMENT '执行-时间',
  `handle_code` int(11) NOT NULL COMMENT '执行-状态',
  `handle_msg` text COMMENT '执行-日志',
  `alarm_status` tinyint(4) NOT NULL DEFAULT '0' COMMENT '告警状态：0-默认、1-无需告警、2-告警成功、3-告警失败',
  PRIMARY KEY (`id`),
  KEY `I_trigger_time` (`trigger_time`),
  KEY `I_handle_code` (`handle_code`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

CREATE TABLE `xxl_job_log_report` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `trigger_day` datetime DEFAULT NULL COMMENT '调度-时间',
  `running_count` int(11) NOT NULL DEFAULT '0' COMMENT '运行中-日志数量',
  `suc_count` int(11) NOT NULL DEFAULT '0' COMMENT '执行成功-日志数量',
  `fail_count` int(11) NOT NULL DEFAULT '0' COMMENT '执行失败-日志数量',
  PRIMARY KEY (`id`),
  UNIQUE KEY `i_trigger_day` (`trigger_day`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

CREATE TABLE `xxl_job_logglue` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `job_id` int(11) NOT NULL COMMENT '任务，主键ID',
  `glue_type` varchar(50) DEFAULT NULL COMMENT 'GLUE类型',
  `glue_source` mediumtext COMMENT 'GLUE源代码',
  `glue_remark` varchar(128) NOT NULL COMMENT 'GLUE备注',
  `add_time` datetime DEFAULT NULL,
  `update_time` datetime DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

CREATE TABLE `xxl_job_registry` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `registry_group` varchar(50) NOT NULL,
  `registry_key` varchar(255) NOT NULL,
  `registry_value` varchar(255) NOT NULL,
  `update_time` datetime DEFAULT NULL,
  PRIMARY KEY (`id`),
  KEY `i_g_k_v` (`registry_group`,`registry_key`,`registry_value`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

CREATE TABLE `xxl_job_group` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `app_name` varchar(64) NOT NULL COMMENT '执行器AppName',
  `title` varchar(12) NOT NULL COMMENT '执行器名称',
  `order` int(11) NOT NULL DEFAULT '0' COMMENT '排序',
  `address_type` tinyint(4) NOT NULL DEFAULT '0' COMMENT '执行器地址类型：0=自动注册、1=手动录入',
  `address_list` varchar(512) DEFAULT NULL COMMENT '执行器地址列表，多地址逗号分隔',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

CREATE TABLE `xxl_job_user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(50) NOT NULL COMMENT '账号',
  `password` varchar(50) NOT NULL COMMENT '密码',
  `role` tinyint(4) NOT NULL COMMENT '角色：0-普通用户、1-管理员',
  `permission` varchar(255) DEFAULT NULL COMMENT '权限：执行器ID列表，多个逗号分割',
  PRIMARY KEY (`id`),
  UNIQUE KEY `i_username` (`username`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

CREATE TABLE `xxl_job_lock` (
  `lock_name` varchar(50) NOT NULL COMMENT '锁名称',
  PRIMARY KEY (`lock_name`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;


INSERT INTO `xxl_job_group`(`id`, `app_name`, `title`, `order`, `address_type`, `address_list`) VALUES (1, 'xxl-job-executor-sample', '示例执行器', 1, 0, NULL);
INSERT INTO `xxl_job_info`(`id`, `job_group`, `job_cron`, `job_desc`, `add_time`, `update_time`, `author`, `alarm_email`, `executor_route_strategy`, `executor_handler`, `executor_param`, `executor_block_strategy`, `executor_timeout`, `executor_fail_retry_count`, `glue_type`, `glue_source`, `glue_remark`, `glue_updatetime`, `child_jobid`) VALUES (1, 1, '0 0 0 * * ? *', '测试任务1', '2018-11-03 22:21:31', '2018-11-03 22:21:31', 'XXL', '', 'FIRST', 'demoJobHandler', '', 'SERIAL_EXECUTION', 0, 0, 'BEAN', '', 'GLUE代码初始化', '2018-11-03 22:21:31', '');
INSERT INTO `xxl_job_user`(`id`, `username`, `password`, `role`, `permission`) VALUES (1, 'admin', 'e10adc3949ba59abbe56e057f20f883e', 1, NULL);
INSERT INTO `xxl_job_lock` ( `lock_name`) VALUES ( 'schedule_lock');

commit;

创建容器

docker run -e PARAMS="--spring.datasource.url=jdbc:mysql://192.168.211.128:3306/xxl_job?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&serverTimezone=Asia/Shanghai --spring.datasource.username=root --spring.datasource.password=123456 --spring.datasource.driver-class-name=com.mysql.jdbc.Driver" -p 18080:8080 -v /tmp:/data/applogs --name xxl-job-admin  -d --restart=always xuxueli/xxl-job-admin:2.1.2

浏览器地址访问：
http://192.168.211.128:8080/xxl-job-admin   
登录并输入用户名和密码：admin/123456

如上图还需要导入SQL脚本到头条数据库中。

11 安装spring cloud alibaba sentinel dashbord

docker pull bladex/sentinel-dashboard

docker run --name sentinel -d -p 8858:8858 -d  bladex/sentinel-dashboard

浏览器访问

http://192.168.211.128:8858/

输入用户名和密码：

sentinel/sentinel

12 docker安装kafka

下载镜像

docker pull wurstmeister/zookeeper
docker pull wurstmeister/kafka
docker pull obsidiandynamics/kafdrop:3.30.0

创建容器

# docker volume create zk-data
docker run -d --name zookeeper --restart=always -p 2181:2181 wurstmeister/zookeeper

docker volume create kafka-log

docker run -d --name kafka -p 9092:9092 \
-e KAFKA_BROKER_ID=0 \
-e KAFKA_ZOOKEEPER_CONNECT=192.168.211.128:2181/kafka \
-e KAFKA_ADVERTISED_LISTENERS=PLAINTEXT://192.168.211.128:9092 \
-e KAFKA_LISTENERS=PLAINTEXT://0.0.0.0:9092 \
-e KAFKA_HEAP_OPTS="-Xmx512M -Xms256M" \
-v kafka-log:/kafka \
wurstmeister/kafka

docker run -d -p 9100:9000 --name=kafdrop \
    -e KAFKA_BROKERCONNECT=192.168.211.128:9092 \
    -e JVM_OPTS="-Xms32M -Xmx64M" \
    -e SERVER_SERVLET_CONTEXTPATH="/" \
    obsidiandynamics/kafdrop:3.30.0
# 启动成功后访问
http://192.168.211.128:9100

Linux下的安装（了解）

jdk环境

首先需要安装Java环境，同时配置环境变量

zookeeper安装

(1)下载安装包

wget http://mirrors.hust.edu.cn/apache/zookeeper/zookeeper-3.5.8/apache-zookeeper-3.5.8-bin.tar.gz

(2)解压

tar -xvf apache-zookeeper-3.5.8-bin.tar.gz  -C /usr/local/server/

(3)创建data 目录

 cd /usr/local/server/apache-zookeeper-3.5.8-bin/
 mkdir data 

(4)配置cfg

cd /usr/local/server/apache-zookeeper-3.5.8-bin/conf
mv zoo_sample.cfg zoo.cfg

修改配置zoo.cfg:

（5）启动

cd /usr/local/server/apache-zookeeper-3.5.8-bin/bin
./zkServer.sh start

kafka安装

（1）下载

（2）上传到虚拟机服务器并进行解压,解压到/usr/local/server下

tar -xvf kafka_2.12-2.3.0.tgz -C /usr/local/server/

（3）修改配置文件：/usr/local/server/kafka_2.12-2.3.0/config/server.properties

（4）创建如上图所示的log目录

mkdir -p /usr/local/server/kafka_2.12-2.3.0/logs

（5）启动zookeeper 和 kafka

启动zookeeper

cd /usr/local/server/apache-zookeeper-3.5.8-bin/bin

./zkServer.sh start

启动kafka

cd /usr/local/server/kafka_2.12-2.3.0/

bin/kafka-server-start.sh config/server.properties

13 安装seata-server

13.1 配置文件准备

# 创建配置文件存放的卷, 方便修改
docker volume create seata-config
# 进入映射的seata-server配置文件目录下
cd /var/lib/docker/volumes/seata-config/_data
上传资料中的 "docker布置seata需要的配置文件" 到 /var/lib/docker/volumes/seata-config/_data 这个目录下

13.2 nacos中添加seataServer.properties文件

进入nacos配置管理，在public命名空间下，创建seataServer.properties

内容如下：

#****************= 数据库配置 ****************=#
# 事务会话信息存储方式，db代表数据库
store.mode=db
# db模式数据源类型。dbcp、druid、hikari；无默认值，store.mode=db时必须指定
store.db.datasource=druid
# db模式数据库类型。无默认值，store.mode=db时必须指定。
store.db.dbType=mysql
# db模式数据库驱动
store.db.driverClassName=com.mysql.jdbc.Driver
# db模式数据库url
store.db.url=jdbc:mysql://192.168.211.128:3306/seata?useUnicode=true&rewriteBatchedStatements=true
# db模式数据库账户
store.db.user=root
# db模式数据库账户密码
store.db.password=123456
# db模式数据库初始连接数 默认1
store.db.minConn=5
# db模式数据库最大连接数 默认20
store.db.maxConn=30
# db模式全局事务表名 默认global_table
store.db.globalTable=global_table
# db模式分支事务表名 默认branch_table
store.db.branchTable=branch_table
# db模式查询全局事务一次的最大条数 默认100
store.db.queryLimit=100
# db模式全局锁表名 默认lock_table
store.db.lockTable=lock_table
# db模式获取连接时最大等待时间 默认5000，单位毫秒
store.db.maxWait=5000
# ****************** 事务、日志等配置 ******************#
# 二阶段提交未完成状态全局事务重试提交线程间隔时间 默认1000，单位毫秒
server.recovery.committingRetryPeriod=1000
# 二阶段异步提交状态重试提交线程间隔时间 默认1000，单位毫秒
server.recovery.asynCommittingRetryPeriod=1000
# 二阶段回滚状态重试回滚线程间隔时间
server.recovery.rollbackingRetryPeriod=1000
# 超时状态检测重试线程间隔时间 默认1000，单位毫秒，检测出超时将全局事务置入回滚会话管理器
server.recovery.timeoutRetryPeriod=1000
# 二阶段提交重试超时时长。单位ms,s,m,h,d,对应毫秒,秒,分,小时,天,默认毫秒。默认值-1表示无限重试。公式: timeout>=now-globalTransactionBeginTime,true表示超时则不再重试(注: 达到超时时间后将不会做任何重试,有数据不一致风险,除非业务自行可校准数据,否者慎用)
server.maxCommitRetryTimeout=-1
# 	二阶段回滚重试超时时长 与maxCommitRetryTimeout类似
server.maxRollbackRetryTimeout=-1
server.rollbackRetryTimeoutUnlockEnable=false
# undo保留天数 默认7天
server.undo.logSaveDays=7
# undo清理线程间隔时间 默认86400000，单位毫秒
server.undo.logDeletePeriod=86400000

# client和server通信编解码方式 默认seata(ByteBuf)
transport.serialization=seata
# client和server通信数据压缩方式 none、gzip，默认none
transport.compressor=none
# 关闭metrics功能，默认false关闭，在False状态下，所有与Metrics相关的组件将不会被初始化，使得性能损耗最低
metrics.enabled=false

执行sql脚本

13.3 创建容器

docker run -d --restart=always --name seata-server \
-p 8091:8091 \
-v seata-config:/seata-server/resources  \
-e SEATA_IP=192.168.211.128 \
-e SEATA_PORT=8091 \
seataio/seata-server:1.3.0

14 安装redis-server

docker volume create redis-data
docker run -d --restart=always --name redis -p 6379:6379 -v redis-data:/data redis:5.0.2

15 FastDFS服务端搭建

# 拉取镜像
docker pull morunchang/fastdfs

# 创建storage的数据卷
docker volume create fdfs-data

# 运行tracker
docker run -d --name tracker --restart=always --net=host morunchang/fastdfs sh tracker.sh

# 运行storage
docker run -d --name storage --net=host -e TRACKER_IP=192.168.211.128:22122 -e GROUP_NAME=group1 -v fdfs-data:/data/fast_data morunchang/fastdfs sh storage.sh

删除所有容器

docker rm -f docker ps -a -q

删除所有无关的数据卷

docker volume rm $(docker volume ls -qf dangling=true)