官网：https://www.docker/

镜像地址：https://hub.docker/

1.docker安装

卸载原有docker

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

安装docker 依赖和yum源

yum install -y yum-utils

yum-config-manager \
    --add-repo \
    https://download.docker/linux/centos/docker-ce.repo

下载docker

yum install docker-ce docker-ce-cli containerd.io

启动docker

systemctl start docker
#设置开机启动
chkconfig docker on

运行容器测试docker
```
docker run hello-world
```

2.配置docker镜像

注册阿里云账号，之后进入控制台，打开【容器镜像服务】的【镜像加速器】，如图：

执行下述代码

sudo mkdir -p /etc/docker

sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://cor2v6iv.mirror.aliyuncs"]
}
EOF

sudo systemctl daemon-reload

sudo systemctl restart docker

3. docker安装nginx

拉取nginx镜像

#不指定版本号则默认拉取最新版本
docker pull nginx

创建nginx容器

创建容器镜像时，需要先把nginx.conf和default.conf从容器中copy到准备映射的目录，命令如下

docker cp [容器ID]:容器路径 宿主机路径

#复制nginx.conf
docker cp nginx:/etc/nginx/nginx.conf /mnt/docker/nginx/conf
#复制default.conf
docker cp nginx:/etc/nginx/conf.d/default.conf /mnt/docker/nginx/conf.d/
#复制index.html
docker cp nginx:/usr/share/nginx/ /mnt/docker/nginx/html/

或者自己手动创建文件

之后再来启动

```shell
#如果想直接交互的话，可以把-d 改为 -it
docker run -d --name nginx -p 8000:80 -p 443:443 \
-v /mnt/docker/nginx/conf/nginx.conf:/etc/nginx/nginx.conf \
-v /mnt/docker/nginx/html/:/usr/share/nginx/html \
-v /mnt/docker/nginx/conf.d/default.conf:/etc/nginx/conf.d/default.conf \
-v /mnt/docker/nginx/cert/:/etc/nginx/cert \
-v /mnt/docker/nginx/logs:/var/log/nginx  \
-v /etc/localtime:/etc/localtime --restart=always nginx

nginx配置ssl

server{
          #监听443端口
          listen 443 ssl;
          #对应的域名，把baofeidyz改成你们自己的域名就可以了
          server_name mp.duomishequ;
          #ssl on;
          #从腾讯云获取到的第一个文件的全路径
          ssl_certificate /etc/nginx/cert/1_mp.duomishequ_bundle.crt;
          #从腾讯云获取到的第二个文件的全路径
          ssl_certificate_key /etc/nginx/cert/2_mp.duomishequ.key;
          ssl_session_timeout 5m;
          ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
          ssl_ciphers ECDHE-RSA-AES128-GCM-SHA256:HIGH:!aNULL:!MD5:!RC4:!DHE;
          ssl_prefer_server_ciphers on;
          #这是我的主页访问地址，因为使用的是静态的html网页，所以直接使用location就可以完成了。
          location / {
                  #root /usr/share/nginx/html;
                  proxy_pass http://39.100.69.145:7527;
          }
      }

4.docker安装mysql

拉取镜像
```
docker pull mysql:5.7
```

创建mysql容器

docker run --name mysql3366 -p 3366:3306 \
-v /mnt/docker/mysql3366/data:/var/lib/mysql \
-v /mnt/docker/mysql3366/conf:/etc/mysql/conf.d \
-v /mnt/docker/mysql3366/logs:/logs \
-e MYSQL_ROOT_PASSWORD=pankujava -e TZ=Asia/Shanghai -d --restart=always mysql:5.7

之后再在/mnt/docker/mysql3366/conf目录中创建myf，内容如下:

[mysqld]
user=mysql
port=3366
character-set-server=utf8
default_authentication_plugin=mysql_native_password
secure_file_priv=/var/lib/mysql
expire_logs_days=7
sql_mode=STRICT_TRANS_TABLES,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION
max_connections=1000
#禁用dns反向查询，可解决IP address 'xxxx' could not be resolved: Name or service not known
skip-name-resolve
#忽略大小写
lower_case_table_names=1

[client]
default-character-set=utf8

[mysql]
default-character-set=utf8

开启root账户远程访问

#进入容器中
docker exec -it [容器id]  /bin/bash
#登录mysql客户端
mysql -uroot -p
#授权
grant all privileges on *.* to root@'%' identified by 'pankujava';
#刷新权限
flush privileges;

docker mysql数据库备份

#可以将下述命令编写在shell脚本中，定时运行，定时进行备份
docker exec -it mysql3366 mysqldump -uroot -p pankujava dataBaseName > backup.sql

5.docker安装redis

拉取进行
```
docker pull redis
```

创建容器

docker run -p 6399:6379 --name redis6399 --sysctl net.core.somaxconn=1024 \
-v /mnt/docker/redis6399/data:/data \
-v /mnt/docker/redis6399/conf/:/usr/local/etc/redis/ \
-e TIME_ZONE="Asia/Shanghai" -e TZ="Asia/Shanghai" \
-d --restart=always redis redis-server /usr/local/etc/redis/redis.conf --appendonly yes

创建容器后，在/mnt/docker/redis6399/conf/redis.conf/中创建redis.conf文件，文件可从github中对应的版本中下载，具体内容如下:

#内容比较多，此处不列举，只说明下载完之后需要修改的地方
#下载完成之后找到redis.conf这个文件
#在配置文件中找到这个配置,注释掉(注释掉才可以远程连接redis)
bind 127.0.0.1
#找到这个配置改为protected-mode no
protected-mode yes
#找到这个配置,注释掉
daemonize yes

优化配置

#内存分配策略,直接在宿主机上执行即可
#0: 表示内核将检查是否有足够的可用内存供应用进程使用；如果有足够的可用内存，内存申请允许；否则，内存申请失败，并把错误返回给应用进程。
#1: 表示内核允许分配所有的物理内存，而不管当前的内存状态如何。
#2: 表示内核允许分配超过所有物理内存和交换空间总和的内存
sysctl vm.overcommit_memory=1

#解决警告：在运行容器的时候增加参数
#The TCP backlog setting of 511 cannot be enforced because /proc/sys/net/core/somaxconn is set to the lower value of 128.
docker在run的时候增加参数“--sysctl net.core.somaxconn=1024”即可解决，在宿主机上无法解决此问题,网上说的都是骗人的

#解决警告 在宿主机上执行
#WARNING you have Transparent Huge Pages (THP) support enabled in your kernel. 
#This will create latency and memory usage issues with Redis. 
#To fix this issue run the command 'echo never > /sys/kernel/mm/transparent_hugepage/enabled' as root, 
#and add it to your /etc/rc.local in order to retain the setting after a reboot. Redis must be restarted after THP is disabled.

echo never > /sys/kernel/mm/transparent_hugepage/enabled
vi /etc/rc.local
if test -f /sys/kernel/mm/transparent_hugepage/enabled; then
   echo never > /sys/kernel/mm/transparent_hugepage/enabled
fi
if test -f /sys/kernel/mm/transparent_hugepage/defrag; then
   echo never > /sys/kernel/mm/transparent_hugepage/defrag
fi

异常解决：nested exception is io.lettuce.core.RedisException:

springboot2.x之后使用springboot-starter-data-redis 使用的是lettuce,需要修改配置：

redis:
    host: 8.131.71.176
    port: 6399
    password: ''
    lettuce:
      pool:
        max-idle: 500
        max-wait: 500
        max-active: 500
        min-idle: 0
    timeout: 500

<!--同时需要在pom中增加依赖-->
<dependency>
	<groupId>org.apachemons</groupId>
	<artifactId>commons-pool2</artifactId>
</dependency>

docker安装oracle11g

docker pull rohitbasu77/oracle11g

#将核心文件复制出来
docker cp oracle11g:/u01/app/oracle ./

docker run -d -p 41521:1521  -p 40022:22  -p 48080:8080 --name oracle11g --restart=always \
    -v /mnt/docker/oracle11g/oracle:/u01/app/oracle \
    -v /etc/localtime:/etc/localtime \
    rohitbasu77/oracle11g:latest
    
#账户信息
Connect database:
hostname: localhost or docker machine ip
port: 41521
sid: xe
username: system
password: oracle
Password for SYS & SYSTEM is oracle
Password for fareuser, searchuser, bookinguser, checkinuser is rohit123

Login by SSH:
ssh root@docker_machine_ip -p 40022

password: admin

7.开放firewalld端口

firewall-cmd --zone=public --add-port=80/tcp --permanent
#重新加载防火墙
firewall-cmd --reload

6.idea远程连接docker一键部署

开发测试可行，正式不可以这样做

开启docker远程访问

#修改Docker服务文件，需要先切换到root用户
vim /lib/systemd/system/docker.service
#注释掉"ExecStart"这一行，并添加下面这一行信息，默认端口为2375，最好不要使用
ExecStart=/usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock -H tcp://0.0.0.0:2375

使用idea docker插件连接docker，连接配置如下

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JzH2zG1o-1628043031660)(E:\01_project\01_盘古_2020\100_部门文档\学习记录\docker教程.assets\image-20201216155805944.png)]

配置成功后，可以看到以下界面：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YSnGptFy-1628043031663)(E:\01_project\01_盘古_2020\100_部门文档\学习记录\docker教程.assets\image-20201214135219270.png)]

修改pom文件中的配置，具体配置如下：

<!--采用maven插件中编写dockerfile-->
<plugin>
                <groupId>com.spotify</groupId>
                <artifactId>docker-maven-plugin</artifactId>
                <version>1.0.0</version>
                <!--将插件绑定在某个phase执行-->
<!--                <executions>-->
<!--                    <execution>-->
<!--                        <id>build-image</id>-->
<!--                        &lt;!&ndash;用户只需执行mvn package ，就会自动执行mvn docker:build&ndash;&gt;-->
<!--                        <phase>package</phase>-->
<!--                        <goals>-->
<!--                            <goal>build</goal>-->
<!--                        </goals>-->
<!--                    </execution>-->
<!--                </executions>-->

                <configuration>
                    <!--指定生成的镜像名,这里是我们的作者名+项目名-->
                    <imageName>panku/${project.artifactId}</imageName>

                    <!--指定标签 这里指定的是镜像的版本，我们默认版本是latest-->
                    <imageTags>
                        <imageTag>latest</imageTag>
                    </imageTags>

                    <!--指定基础镜像jdk1.8-->
                    <baseImage>java:8</baseImage>
                    <!--
                    镜像制作人本人信息
                    <maintainer>bruceliu@email</maintainer>
                    -->
                    <!--切换到ROOT目录-->
                    <workdir>/root</workdir>

                    <!--对外暴漏的映射目录-->
                    <volumes>/temp</volumes>
                    <!--查看我们的java版本-->
                    <cmd>["java", "-version"]</cmd>

                    <!--${project.build.finalName}.jar是打包后生成的jar包的名字-->
                    <entryPoint>["java", "-jar", "/${project.build.finalName}.jar","--spring.proflies.active=test","-c"]</entryPoint>

                    <!--指定远程 docker api地址-->
                    <dockerHost>http://8.131.71.176:2475</dockerHost>

                    <!-- 这里是复制 jar 包到 docker 容器指定目录配置 -->
                    <resources>
                        <resource>
                            <targetPath>/</targetPath>
                            <!--jar 包所在的路径  此处配置的 即对应 target 目录-->
                            <directory>${project.build.directory}</directory>
                            <!--用于指定需要复制的文件 需要包含的 jar包 ，这里对应的是 Dockerfile中添加的文件名　-->
                            <include>${project.build.finalName}.jar</include>
                        </resource>
                    </resources>

                </configuration>
            </plugin>

<!-- 采用外部dockerfile -->
<plugin>
    <groupId>com.spotify</groupId>
    <artifactId>docker-maven-plugin</artifactId>
    <version>1.0.0</version>

    <configuration>
        <imageName>${project.artifactId}</imageName>
        <imageTags>
            <imageTag>latest</imageTag>
        </imageTags>
        <dockerDirectory>${project.basedir}/src/main/resources</dockerDirectory>
        <!--指定远程 docker api地址-->
        <dockerHost>https://8.131.71.176:2475</dockerHost>
        <dockerCertPath>D:/docker/caclient</dockerCertPath>
        <!-- 这里是复制 jar 包到 docker 容器指定目录配置 -->
        <resources>
            <resource>
                <targetPath>/</targetPath>
                <!--jar 包所在的路径  此处配置的 即对应 target 目录-->
                <directory>${project.build.directory}</directory>
                <!--用于指定需要复制的文件 需要包含的 jar包 ，这里对应的是 Dockerfile中添加的文件名　-->
                <include>${project.build.finalName}.jar</include>
            </resource>
        </resources>
    </configuration>
</plugin>

<!--dockerfile内容-->
FROM java:8
ENV TZ=Asia/Shanghai
ADD panku-einvoice-service-region.jar /panku-einvoice-service-region.jar
EXPOSE 9977
VOLUME /temp
ENTRYPOINT ["java","-jar","-Djava.security.egd=file:/dev/./urandom","/panku-einvoice-service-region.jar","--spring.profiles.active=test","-c"]

执行 mvn clean package:build进行构建并将远程创建docker镜像
启动docker镜像，命令如下：
```
# 在服务器执行下面命令
docker run -it --name einvoice-service7000 -p 9977:9977 -v /mnt/docker/data:/temp --restart=always [容器id]
```
或者，在idea中的镜像上右键创建容器，如下图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-imEkJKPM-1628043031667)(E:\01_project\01_盘古_2020\100_部门文档\学习记录\docker教程.assets\image-20201215094837264.png)]

也可以直接在pom中导入Dockerfile文件，内容如下:

<plugin>
                <groupId>com.spotify</groupId>
                <artifactId>docker-maven-plugin</artifactId>
                <version>1.0.0</version>

                <configuration>
                    <imageName>${project.artifactId}</imageName>
                    <imageTags>
                        <imageTag>latest</imageTag>
                    </imageTags>
                    <dockerDirectory>${project.basedir}/src/main/resources</dockerDirectory>
                    <!--指定远程 docker api地址-->
                    <dockerHost>http://8.131.71.176:2475</dockerHost>
                    <!-- 这里是复制 jar 包到 docker 容器指定目录配置 -->
                    <resources>
                        <resource>
                            <targetPath>/</targetPath>
                            <!--jar 包所在的路径  此处配置的 即对应 target 目录-->
                            <directory>${project.build.directory}</directory>
                            <!--用于指定需要复制的文件 需要包含的 jar包 ，这里对应的是 Dockerfile中添加的文件名　-->
                            <include>${project.build.finalName}.jar</include>
                        </resource>
                    </resources>
                </configuration>
            </plugin>

DockerFile内容如下:

#基础镜像，也可以使用openjdk:8FROM java:8#设置时区为东八区，否则会相差8小时ENV TZ=Asia/Shanghai#将打包好的jar，添加到容器中ADD panku-einvoice-service-region.jar /panku-einvoice-service-region.jar#暴露9977端口，用于访问容器中的服务EXPOSE 9977#暴露容器卷，用于在宿主机中访问容器中的日志、pdf文件等VOLUME /temp#启动容器内的服务 -Djava.security.egd=file:/dev/./urandom 可以提高随机数生成速度，内部有发票校验码是随机数获取的，还有UUIDENTRYPOINT ["java","-jar","-Djava.security.egd=file:/dev/./urandom","/panku-einvoice-service-region.jar","--spring.profiles.active=test"]

7. 生产环境部署docker

开发环境可以使用docker进行一键部署，但是由于暴露了docker远程连接的端口，不建议生产环境这样做

生产环境下，根据dockerfile进行构建docker镜像，构建步骤如下：

将jar包和dockerfile上传到服务器，两者最好处于同一目录

之后执行下面的命令：

docker build -f Dockerfile的绝对路径，如果当前目录下有Dockerfile则可省略 -t panku-einvoice-service-region:latest .示例：docker build -t panku-einvoice-check:latest .

docker 时区问题

如果容器已经启动，进入容器执行

ln -sf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime#date查看当前日期

docker-mycat安装

用1.6.7.1不要用，再新的版本，否则有坑，最大的坑就是不能连表查询

1.编写Dockerfile

dockerfile内容如下

FROM java:8-jre
MAINTAINER <jackshen 314521831@qq>
USER root
ENV TZ=Asia/Shanghai
RUN wget http://dl.mycat/1.6.7.1/Mycat-server-1.6.7.1-release-20200209222254-linux.tar.gz
RUN tar -zxvf Mycat-server-1.6.7.1-release-20200209222254-linux.tar.gz -C /
ENV MYCAT_HOME=/mycat
ENV PATH=$PATH:$MYCAT_HOME/bin
WORKDIR $MYCAT_HOME/bin
VOLUME /mycat/conf
RUN chmod u+x ./mycat
EXPOSE 8066 9066
CMD ["./mycat","console"]

备注:

8066 数据访问端口，即进行 DML 和 DDL 操作。
9066 数据库管理端口，即 mycat 服务管理控制功能，用于管理mycat的整个集群状态。

2.构建镜像

执行下述命令

#最后面有个点,代表当前目录
docker build -t panku/mycat:1.6.7 .

3.创建容器

需要提前将配置信息从容器中拷贝出来

docker copy 容器ID:/mycat/conf/* /mnt/docker/mycat8066/conf

docker run -it --name mycat8066 --restart=always \
-v /mnt/docker/mycat8066/conf:/mycat/conf \
-v /mnt/docker/mycat8066/logs:/mycat/logs \
-p 8066:8066 -p 9066:9066  \
panku/mycat:1.6.7.1

mysql主从复制

两个数据库信息

名称	ip	端口
mysql主库	172.17.39.13	3377
mysql从库	172.17.39.13	3388

先用docker 运行两个容器，参考安装mysql部分内容，之后对主库myf增加以下配置：

#创建主库
docker run --name mysql3377 -p 3377:3306 \
-v /mnt/docker/mysql3377/data:/var/lib/mysql \
-v /mnt/docker/mysql3377/conf:/etc/mysql/conf.d \
-v /mnt/docker/mysql3377/logs:/logs \
-e MYSQL_ROOT_PASSWORD=pankujava -d --restart=always mysql:5.7

#创建从库
docker run --name mysql3388 -p 3388:3306 \
-v /mnt/docker/mysql3388/data:/var/lib/mysql \
-v /mnt/docker/mysql3388/conf:/etc/mysql/conf.d \
-v /mnt/docker/mysql3388/logs:/logs \
-e MYSQL_ROOT_PASSWORD=pankujava -d --restart=always mysql:5.7

[mysqld]
#主服务器ID
server-id=1
##binlog日志前缀
log-bin=master-log
##需要复制的数据
binlog-do-db=test
#设置binlog格式
binlog_format=STATEMENT

对从库myf增加以下配置:

[mysqld]#从服务器IDserver-id=2#开启中继日志relay-log=slave-log

在主库中创建从库用户并授权

#创建slave用户并授权读取binloggrant replication slave on *.* to 'slave'@'%' identified by 'pankujava';#刷新权限表flush privileges;#查看主库状态show master status;#展示出如下内容说明主库配置成功，否则失败+-------------------+----------+--------------+------------------+-------------------+| File              | Position | Binlog_Do_DB | Binlog_Ignore_DB | Executed_Gtid_Set |+-------------------+----------+--------------+------------------+-------------------+| master-log.000001 |      590 | test         |                  |                   |+-------------------+----------+--------------+------------------+-------------------+

配置从库链接到主库

#查看主库ip地址,可以直接使用宿主机的ip地址，通过端口进行映射，不用输入docker容器的ip
docker inspect mysql3377|grep IPAddress
#从库链接主库的命令
change master to 
master_host='172.17.39.13',
master_port=3377,
master_user='slave',
master_password='pankujava',
master_log_file='master-log.000001',
master_log_pos=590;
#启动从库
start slave;
#查看从库状态，以列的模式
show slave status \G;
#展示出来的内容中如果是下面这样的代表成功，否则，查看erro输入的内容,其中一个为no，就需要排查罗列出来的错误信息进行解决
Slave_IO_Running: Yes
Slave_SQL_Running: Yes


#如果如要重置链接主库的信息，可以执行下面的命令
stop slave;
reset master;

主库创建数据库进行测试：

-- 这里的数据库必须是上面定义要同步的数据
create database test;
--查看从库是否有这个数据库
show databases;
--主库创建表
use test;
create table mytable(id int,name varchar(20));
--查看从库
use test;
show tables;
-- 如果都出现了证明成功，可以进一步测试插入数据

mycat 单库分表

按照ID分表(auto-sharding-long)

在autopartition-long.txt中指定每个分区所放的数据范围

rule配置

<tableRule name="auto-sharding-long">
    <rule>
        <columns>id</columns>
        <algorithm>rang-long</algorithm>
    </rule>
</tableRule>
<function name="rang-long"
          class="io.mycat.route.function.AutoPartitionByLong">
    <property name="mapFile">autopartition-long.txt</property>
</function>

#autopartition-long.txt
# range start-end ,data node index
# K=1000,M=10000.
#测试一万条到一万零10条在第一个分区
10000-10010=0
10010-10020=1
10020-10030=2

schemal配置

<schema name="Demo" checkSQLschema="false" sqlMaxLimit="100" dataNode="demoNode01" >
                <table name="t_biz_invoice_req" primaryKey="id" autoIncrement="true" dataNode="demoNode01" subTables="t_biz_invoice_req$0-2" rule="auto-sharding-long"/>
                <table name="t_biz_invoice_info" primaryKey="id" autoIncrement="true" dataNode="demoNode01" subTables="t_biz_invoice_info$0-2"  rule="auto-sharding-long">
                        <!--<childTable name="t_biz_invoice_req" joinKey="biz_num" parentKey="serial_number"/>-->
                </table>
                <table name="t_biz_invoice_item" primaryKey="id" autoIncrement="true" dataNode="demoNode01" subTables="t_biz_invoice_item$0-2"  rule="auto-sharding-long"/>
                <table name="t_biz_invoice_item_detail" primaryKey="id" autoIncrement="true" dataNode="demoNode01" subTables="t_biz_invoice_item_detail$0-2"  rule="auto-sharding-long"/>
                <table name="t_biz_hospital_info" primaryKey="id" autoIncrement="true" dataNode="demoNode01" type="global"  />
                <table name="t_sys_param" primaryKey="id" autoIncrement="true" dataNode="demoNode01" type="global"  />
                <table name="t_sys_dict" primaryKey="id" autoIncrement="true" dataNode="demoNode01" type="global"  />
                <table name="t_hosp_params" primaryKey="id" autoIncrement="true" dataNode="demoNode01" type="global"  />
</schema>

重新加载mycat配置

#随便找一个mysql客户端，我这边用的是docker的docker exec -it mysql3366 /bin/bash#进入后执行连接管理端的sqlmysql -uroot -P9066 -h172.17.39.13 -p#查看所有命令show @@help;#重新加载配置命令reload @@config;

mycat全局序列-数据库模式

1.在schemal的table中指定主键名称并开启自增，具体配置如下：

<schema name="Demo" checkSQLschema="false" sqlMaxLimit="100" dataNode="demoNode01" >   <table name="mytable" primaryKey="id" autoIncrement="true" dataNode="demoNode01" subTables="mytable_0$0-2" rule="mod-long"/></schema>

2.在数据库中创建序列表和函数

CREATE TABLE MYCAT_SEQUENCE (name VARCHAR(50) NOT NULL,current_value INT NOT NULL,increment INT NOT NULL DEFAULT 100, PRIMARY KEY(name)) ENGINE=InnoDB;
– name sequence 名称
– current_value 当前 value
– increment 增长步长! 可理解为 mycat 在数据库中一次读取多少个 sequence. 当这些用完后, 下次再从数
-- 插入当前表的序列信息
INSERT INTO MYCAT_SEQUENCE(name,current_value,increment) VALUES ('MYTABLE', 1,100);

-- 获取当前 sequence 的值 (返回当前值,增量)
CREATE FUNCTION mycat_seq_currval(seq_name VARCHAR(50)) RETURNS varchar(64) 
DETERMINISTIC
BEGIN
DECLARE retval VARCHAR(64);
SET retval='-999999999,null';
SELECT concat(CAST(current_value AS CHAR),“,”,CAST(increment AS CHAR)) INTO retval FROM
MYCAT_SEQUENCE WHERE name = seq_name;
RETURN retval;
END;

--设置 sequence 值
CREATE FUNCTION mycat_seq_setval(seq_name VARCHAR(50),value INTEGER) RETURNS varchar(64)
DETERMINISTIC
BEGIN
UPDATE MYCAT_SEQUENCE
SET current_value = value
WHERE name = seq_name;
RETURN mycat_seq_currval(seq_name);
END;

-- 获取下一个 sequence 值
CREATE FUNCTION mycat_seq_nextval(seq_name VARCHAR(50)) RETURNS varchar(64) 
DETERMINISTIC
BEGIN
UPDATE MYCAT_SEQUENCE
SET current_value = current_value + increment WHERE name = seq_name;
RETURN mycat_seq_currval(seq_name);
END;

mysql 双主双从

服务器信息

名称	ip	端口
主库1	172.17.39.13	3377
从库1	172.17.39.13	3388
主库2	172.17.39.13	3399
从库2	172.17.39.13	3300

基于之前的单机主从扩展为双主双从时，需要停止主从复制，即在从库中执行

stop slave;
reset master;

主库2和从库2的docker创建语句如下

#主库2
docker run --name mysql3399 -p 3399:3306 \
-v /mnt/docker/mysql3399/data:/var/lib/mysql \
-v /mnt/docker/mysql3399/conf:/etc/mysql/conf.d \
-v /mnt/docker/mysql3399/logs:/logs \
-e MYSQL_ROOT_PASSWORD=pankujava -d --restart=always mysql:5.7
#从库2
docker run --name mysql3300 -p 3300:3306 \
-v /mnt/docker/mysql3300/data:/var/lib/mysql \
-v /mnt/docker/mysql3300/conf:/etc/mysql/conf.d \
-v /mnt/docker/mysql3300/logs:/logs \
-e MYSQL_ROOT_PASSWORD=pankujava -d --restart=always mysql:5.7

修改主库M1的配置文件 myf

[mysqld]
#主服务器ID
server-id=1
##binlog日志前缀
log-bin=master-log
##需要复制的数据
binlog-do-db=test
#设置binlog格式
binlog_format=STATEMENT
#双主双从，增加以下配置
#主库在作为从库时，有写入操作也要更新二进制日志文件
log-slave-updates
#自增长字段每次递增的量，指自增字段的起始值，默认值是1，取值范围是1...65535
auto-increment-increment=2
#自增长字段从哪个数开始，指字段一次递增多少，取值范围是1...65535
auto-increment-offset=1

修改主备库M2的配置，与主库的配置基本一致，需要修改server-id、auto-increment-offset=2，不能与主库一致

[mysqld]
#主服务器ID
server-id=3
##binlog日志前缀
log-bin=master2-log
##需要复制的数据
binlog-do-db=test
#设置binlog格式
binlog_format=STATEMENT
#双主双从，增加以下配置
#主库在作为从库时，有写入操作也要更新二进制日志文件
log-slave-updates
#自增长字段每次递增的量，指自增字段的起始值，默认值是1，取值范围是1...65535
auto-increment-increment=2
#自增长字段从哪个数开始，指字段一次递增多少，取值范围是1...65535
auto-increment-offset=2

3.从库1配置保持不变，内容如下

[mysqld]#从服务器IDserver-id=2#开启中继日志relay-log=slave-log

4.从库2配置内容如下

[mysqld]#从服务器IDserver-id=4#开启中继日志relay-log=slave-log2

主库1为从库1分配用户权限，进入主库1的sql命令界面，执行下面的语句：

#创建slave用户并授权读取binlog
grant replication slave on *.* to 'slave'@'%' identified by 'pankujava';
#刷新权限表
flush privileges;
#停止从库
stop slave;
#重置主库
reset master;
#查看主库状态
show master status;
#展示出如下内容说明主库配置成功，否则失败
+-------------------+----------+--------------+------------------+-------------------+
| File              | Position | Binlog_Do_DB | Binlog_Ignore_DB | Executed_Gtid_Set |
+-------------------+----------+--------------+------------------+-------------------+
| master-log.000001 |      154 | test         |                  |                   |
+-------------------+----------+--------------+------------------+-------------------+

主库2为从库2分配用户权限，进入主库2的sql命令界面，执行下面的语句：

#创建slave用户并授权读取binlog
grant replication slave on *.* to 'slave'@'%' identified by 'pankujava';
#刷新权限表
flush privileges;
#停止从库
stop slave;
#重置主库
reset master;
#查看主库状态
show master status;
#展示出如下内容说明主库配置成功，否则失败
+--------------------+----------+--------------+------------------+-------------------+
| File               | Position | Binlog_Do_DB | Binlog_Ignore_DB | Executed_Gtid_Set |
+--------------------+----------+--------------+------------------+-------------------+
| master2-log.000001 |      154 | test         |                  |                   |
+--------------------+----------+--------------+------------------+-------------------+

配置从库1链接到主库1

#查看主库ip地址,可以直接使用宿主机的ip地址，通过端口进行映射，不用输入docker容器的ip
docker inspect mysql3377|grep IPAddress
#从库链接主库的命令
change master to 
master_host='172.17.39.13',
master_port=3377,
master_user='slave',
master_password='pankujava',
master_log_file='master-log.000001',
master_log_pos=154;
#启动从库
start slave;
#查看从库状态，以列的模式
show slave status \G;
#展示出来的内容中如果是下面这样的代表成功，否则，查看erro输入的内容,其中一个为no，就需要排查罗列出来的错误信息进行解决
Slave_IO_Running: Yes
Slave_SQL_Running: Yes


#如果如要重置链接主库的信息，可以执行下面的命令
stop slave;
reset master;

配置从库2链接到主库2

#查看主库ip地址,可以直接使用宿主机的ip地址，通过端口进行映射，不用输入docker容器的ip
docker inspect mysql3399|grep IPAddress
#从库链接主库的命令
change master to 
master_host='172.17.39.13',
master_port=3399,
master_user='slave',
master_password='pankujava',
master_log_file='master2-log.000001',
master_log_pos=154;
#启动从库
start slave;
#查看从库状态，以列的模式
show slave status \G;
#展示出来的内容中如果是下面这样的代表成功，否则，查看erro输入的内容,其中一个为no，就需要排查罗列出来的错误信息进行解决
Slave_IO_Running: Yes
Slave_SQL_Running: Yes


#如果如要重置链接主库的信息，可以执行下面的命令
stop slave;
reset master;

实现双主互备，主库1复制主库2，主库2复制主库1

# 主库1链接到主库2
change master to 
master_host='172.17.39.13',
master_port=3399,
master_user='slave',
master_password='pankujava',
master_log_file='master2-log.000001',
master_log_pos=154;

#启动从库
start slave;
#查看从库状态，以列的模式
show slave status \G;

#展示出来的内容中如果是下面这样的代表成功，否则，查看erro输入的内容,其中一个为no，就需要排查罗列出来的错误信息进行解决
Slave_IO_Running: Yes
Slave_SQL_Running: Yes

#主库2链接到主库1
change master to 
master_host='172.17.39.13',
master_port=3377,
master_user='slave',
master_password='pankujava',
master_log_file='master-log.000001',
master_log_pos=154;

#启动从库
start slave;
#查看从库状态，以列的模式
show slave status \G;

#展示出来的内容中如果是下面这样的代表成功，否则，查看erro输入的内容,其中一个为no，就需要排查罗列出来的错误信息进行解决
Slave_IO_Running: Yes
Slave_SQL_Running: Yes


#如果如要重置链接主库的信息，可以执行下面的命令
stop slave;
reset master;

创建数据库和表进行测试

create database test;create table mytable(id int,name varchar(20));insert into mytable values(1,'zhangsan');

使用mycat实现读写分离

首先需要把dataHost节点的balance改为1,0为关闭读写分离，所有读操作都发生在写主机上

1. balance="0", 不开启读写分离机制，所有读操作都发送到当前可用的 writeHost 上。2. balance="1"，全部的 readHost 与 stand by writeHost 参与 select 语句的负载均衡，简单的说，当双主双从模式(M1->S1，M2->S2，并且 M1 与 M2 互为主备)，正常情况下，M2,S1,S2 都参与 select 语句的负载均衡。3. balance="2"，所有读操作都随机的在 writeHost、readhost 上分发。4. balance="3"，所有读请求随机的分发到 wiriterHost 对应的 readhost 执行，writerHost 不负担读压力，注意 balance=3 只在 1.4 及其以后版本有，1.3 没有。writeTypewriteType=0 所有的写操作发送到第一台写主机，第一个挂了切到还生存的第二个wirteType=1 所有的写操作随机发送到写主机，1.5之后废弃不推荐switchType 1 自动切换 -1 不自动切换 2 基于mysql主从同步的状态决定是否切换，建议使用1#最终逻辑主机的配置如下：<dataHost name="demoHost2" maxCon="1000" minCon="10" balance="1" switchType="1" writeType="0" dbType="mysql" dbDriver="native">    <heartbeat>select user()</heartbeat>    <writeHost host="HostM2" url="8.131.71.176:3377" user="root" password="pankujava">    <readHost host="HostS2" url="172.17.39.13:3388" user="root" password="pankujava"></readHost>    </writeHost>    <writeHost host="HostM3" url="8.131.71.176:3399" user="root" password="pankujava">    <readHost host="HostS2" url="172.17.39.13:3300" user="root" password="pankujava"></readHost>    </writeHost></dataHost>

之后链接mycat进行测试，随便进入一个mysql容器，执行链接mycat的命令

docker exec -it mysql3377 /bin/bashmysql -uroot -h 172.17.39.13 -P 8066 -puse test;-- @@hostname 是mysql系统变量，用于获取当前服务器的名称，可以用来判断当前是从哪个mysql服务中获取数据的insert into mytable values(2,@@hostname)#主库mysql> select * from mytable;+------+--------------+| id   | name         |+------+--------------+|    1 | zhangsan     ||    2 | 8c614f9853bb |+------+--------------+#从库mysql> select * from mytable;+------+--------------+| id   | name         |+------+--------------+|    1 | zhangsan     ||    2 | 9eb4c0015987 |+------+--------------+2 rows in set (0.00 sec)#主库2mysql> select * from mytable;+------+--------------+| id   | name         |+------+--------------+|    1 | zhangsan     ||    2 | 342741a32bbc |+------+--------------+#从库2mysql> select * from mytable;+------+--------------+| id   | name         |+------+--------------+|    1 | zhangsan     ||    2 | 4c2b40ce7752 |+------+--------------+2 rows in set (0.00 sec)#得到每个数据库中的值都不相同则证明配置成功#mycat链接中执行查询，多执行几次，会发现#主库2、从库1、从库2会交替返回查询内容

docker远程加密连接

参考此博文，切记一步一步按照来

https://www.imooc/article/290381?block_id=tuijian_wz

nginx负载均衡配置

主要配置文件内容

upstream einvoice-service {    #分配给连接数少的主机    least_conn;    #由于nginx在docker容器中，此处ip建议设置为内网ip，不要设置为公网ip，因为设置公网ip需要开放阿里云端口和防火墙端口    server 172.17.39.13:7000 weight=1;    server 173.17.39.13:8000 weight=1;}server {	listen       80;		location /invoice-service-region/ {        proxy_pass http://einvoice-service;   }	}

nginx部署vue配置

如果配置root目录不生效，需要写一个全局的root

#在server之外编写root,可以解决location中配置root不生效问题root /usr/share/nginx/html;location /einvoice{      root /usr/share/nginx/html;      index index.html index.htm;      try_files $uri $uri/ /einvoice/index.html;  }

docker常用命令

#查看镜像列表
docker images
#拉取镜像
docker pull mysql:5.7
#删除镜像
docker rmi 镜像ID|镜像名称
#创建容器交互终端的模式创建容器，创建后可以通过 exit和ctrl+p+q退出容器
docker run -it -name mysql3366 -p 3366:3306 -v 宿主机卷:容器卷  mysql:5.7
#创建容器并后台运行
docker run -d -name mysql3366 -p 3366:3306 -v 宿主机卷:容器卷  mysql:5.7
#重启 docker
systemctl daemon-reload
systemctl restart docker
#重启docker后批量启动容器
docker start $(docker ps -qa)
#删除tag为none的镜像
docker image prune 
#列出镜像from的镜像,xxxxxx=报错的当前镜像id  可以用来解决此问题image has dependent child images
docker image inspect --format='{{.RepoTags}} {{.Id}} {{.Parent}}' $(docker image ls -q --filter since=xxxxxx)
#查看docker日志
journalctl -u docker.service
#查看镜像的构建过程
docker history 镜像名称或者id

docker修改容器参数

以修改容器自动启动为例：

有时候创建容器时忘记添加参数 --restart=always ,当docker重启时，容器未能重新启动

#更改容器自动启动
docker container update --restart=always 容器ID或者容器名称

或者直接修改配置文件

1.停止容器
2.找到容器id
docker ps -a --no-trunc
3.找到容器配置文件，路径为
/var/lib/docker/containers/容器ID
4.修改hostconfig.json，找到该文件中关键字 RestartPolicy
改前配置："RestartPolicy":{"Name":"no","MaximumRetryCount":0}
修改后配置："RestartPolicy":{"Name":"always","MaximumRetryCount":0}
最后启动容器。

更改docker默认镜像和容器存储位置

1. 停止docker服务
systemctl stop docker
2. 修改docker配置  vim /usr/lib/systemd/system/docker.service
ExecStart= 在最后追加 --graph=/mnt/data/docker
3.重新加载配置并重启服务
systemctl daemon-reload
systemctl start docker

#如果之前已经创建了镜像和容器，可以把/var/lib/docker 中的内容全部复制到迁移目标位置；同时一定要删除/var/lib/docker中的所有文件
4.查看是否修改成功
docker info|grep "Root Dir"
Docker Root Dir: /mnt/data/docker

docker 常见问题

springboot项目无法发送邮件问题，需要更改为smtps协议，端口改为465，具体配置如下：

mail: #mail配置
    host: smtp.163 #qq：smtp.qq 、163：smtp.163
    username:  panku2019@163 #邮箱地址 qq地址： 2211910447@qq cvdyjnzdtmbsdjih 15837174334@163
    password:  panku2019123     #qq:邮箱授权码 QQ邮箱->设置->账户->POP3/SMTP服务:开启服务后会获得QQ的授权码.、163 :邮箱密码 xwf123456789
    default-encoding: UTF-8
    properties:
      mail:
        smtp:
          auth: true
          starttls:
            enable: true
            required: true
    port: 465
    protocol: smtps

firewalld

1. 开放端口

开启端口
     firewall-cmd --zone=public --add-port=80/tcp --permanent
 
命令含义：
  --zone #作用域
  --add-port=80/tcp  #添加端口，格式为：端口/通讯协议
  --permanent   #永久生效，没有此参数重启后失效

2.关闭端口

firewall-cmd --zone=public --remove-port=80/tcp --permanent

3.重启服务

 firewall-cmd --reload

4.查看开放的所有端口

firewall-cmd --list-all

docker compose 安装

# 下载docker-compose
curl -L https://get.daocloud.io/docker/compose/releases/download/1.26.2/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose
# 添加可执行权限(这里不懂可以看一下菜鸟教程-linux教程-文件权限)
sudo chmod +x /usr/local/bin/docker-compose
# 创建软连接
ln -s /usr/local/bin/docker-compose /usr/bin/docker-compose
# 查看docker-compose版本
docker-compose --version

docker nacos 安装

git clone https://github/nacos-group/nacos-docker.git
cd nacos-docker
docker-compose -f example/standalone-mysql-5.7.yaml up -d
#停止容器并删除
docker-compose -f example/standalone-mysql-5.7.yaml down
#停止容器不删除
docker-compose -f example/standalone-mysql-5.7.yaml stop
#停止指定的容器
docker-compose -f example/standalone-mysql-5.7.yaml down containerName
#启动指定的容器
docker-compose -f example/standalone-mysql-5.7.yaml start containerName


#查看日志
docker-compose logs -f

#内存不足解决方法
#1. 新建swap
dd if=/dev/zero of=/tmp/newdisk bs=1M count=1000
#2. 激活swap文件，查看内存空间
swapon /tmp/newdisk
#重启nacos服务

docker rabbitmq安装

docker pull rabbitmq:3.8.9-management#5672为服务端口 15672为界面管理端口docker run -it  -d --name rabbitmq -e RABBITMQ_DEFAULT_USER=domi -e RABBITMQ_DEFAULT_PASS=domi -p 15672:15672 -p 5672:5672 rabbit:3.8.9-management#之后安装rabbitmq_delayed_message_exchange#1.首先下载rabbitmq_delayed_message_exchangehttps://github/rabbitmq/rabbitmq-delayed-message-exchange/releases/tag/3.8.9#2.将文件拷贝到容器内部docker cp rabbitmq_delayed_message_exchange-3.8.9-0199d11c.ez rabbitmq:/plugins#3.安装组件rabbitmq-plugins enable rabbitmq_delayed_message_exchange

docker seata-server 安装

#拉取镜像
docker pull seataio/seata-server
#先启动容器
docker run -d --name seata-server -p 8091:8091 --restart always \
-e SEATA_IP=39.100.69.145 -e SEATA_PORT=8091 \
seataio/seata-server:latest
#之后拷贝/seata-server下的文件到宿主机上
docker cp seata-server:/seata-server /mnt/docker/seata/
#最后，先删除之前启动的容器，再正式启动新容器
docker run -d --name seata-server -p 8091:8091 --restart always \
-e SEATA_IP=39.100.69.145 -e SEATA_PORT=8091 \
-v /mnt/docker/seata/seata-server:/seata-server \
seataio/seata-server:latest
#修改nacos registry.conf /mnt/docker/seata/seata-server/resources/registry.conf
#registry部分：
type="nacos"
nacos {
    application = "seata-server"
    serverAddr = "39.100.69.145:8848"
    group = "SEATA_GROUP"
    namespace = "seata"
    cluster = "default"
    username = "nacos"
    password = "nacos"
  }

#config部分
type="nacos"
nacos {
    serverAddr = "39.100.69.145:8848"
    namespace = "seata"
    group = "SEATA_GROUP"
    username = "nacos"
    password = "nacos"
    dataId = "seataServer.properties"
  }
#修改 file.conf /mnt/docker/seata/seata-server/resources/file.conf
mode = "db"
 url = "jdbc:mysql://39.100.69.145:3366/seata?rewriteBatchedStatements=true"
    user = "root"
    password = "pankujava"
    minConn = 5
    maxConn = 100
    globalTable = "global_table"
    branchTable = "branch_table"
    lockTable = "lock_table"
    queryLimit = 100
    maxWait = 5000

之后创建数据库seata，添加一下几个表

CREATE TABLE IF NOT EXISTS `undo_log`
(
    `branch_id`     BIGINT(20)   NOT NULL COMMENT 'branch transaction id',
    `xid`           VARCHAR(100) NOT NULL COMMENT 'global transaction id',
    `context`       VARCHAR(128) NOT NULL COMMENT 'undo_log context,such as serialization',
    `rollback_info` LONGBLOB     NOT NULL COMMENT 'rollback info',
    `log_status`    INT(11)      NOT NULL COMMENT '0:normal status,1:defense status',
    `log_created`   DATETIME(6)  NOT NULL COMMENT 'create datetime',
    `log_modified`  DATETIME(6)  NOT NULL COMMENT 'modify datetime',
    UNIQUE KEY `ux_undo_log` (`xid`, `branch_id`)
) ENGINE = InnoDB
  AUTO_INCREMENT = 1
  DEFAULT CHARSET = utf8 COMMENT ='AT transaction mode undo table';
  
-- the table to store GlobalSession data
CREATE TABLE IF NOT EXISTS `global_table`
(
    `xid`                       VARCHAR(128) NOT NULL,
    `transaction_id`            BIGINT,
    `status`                    TINYINT      NOT NULL,
    `application_id`            VARCHAR(32),
    `transaction_service_group` VARCHAR(32),
    `transaction_name`          VARCHAR(128),
    `timeout`                   INT,
    `begin_time`                BIGINT,
    `application_data`          VARCHAR(2000),
    `gmt_create`                DATETIME,
    `gmt_modified`              DATETIME,
    PRIMARY KEY (`xid`),
    KEY `idx_gmt_modified_status` (`gmt_modified`, `status`),
    KEY `idx_transaction_id` (`transaction_id`)
) ENGINE = InnoDB
  DEFAULT CHARSET = utf8;

-- the table to store BranchSession data
CREATE TABLE IF NOT EXISTS `branch_table`
(
    `branch_id`         BIGINT       NOT NULL,
    `xid`               VARCHAR(128) NOT NULL,
    `transaction_id`    BIGINT,
    `resource_group_id` VARCHAR(32),
    `resource_id`       VARCHAR(256),
    `branch_type`       VARCHAR(8),
    `status`            TINYINT,
    `client_id`         VARCHAR(64),
    `application_data`  VARCHAR(2000),
    `gmt_create`        DATETIME(6),
    `gmt_modified`      DATETIME(6),
    PRIMARY KEY (`branch_id`),
    KEY `idx_xid` (`xid`)
) ENGINE = InnoDB
  DEFAULT CHARSET = utf8;

-- the table to store lock data
CREATE TABLE IF NOT EXISTS `lock_table`
(
    `row_key`        VARCHAR(128) NOT NULL,
    `xid`            VARCHAR(96),
    `transaction_id` BIGINT,
    `branch_id`      BIGINT       NOT NULL,
    `resource_id`    VARCHAR(256),
    `table_name`     VARCHAR(32),
    `pk`             VARCHAR(36),
    `gmt_create`     DATETIME,
    `gmt_modified`   DATETIME,
    PRIMARY KEY (`row_key`),
    KEY `idx_branch_id` (`branch_id`)
) ENGINE = InnoDB
  DEFAULT CHARSET = utf8;

之后使用nacos作为配置中心：

首先从git上下载两个文件：

config.txt https://github/seata/seata/tree/develop/script/config-center/config.txt
nacos-config.sh https://github/seata/seata/tree/develop/script/config-center/nacos/nacos-config.sh

将config.txt放在 /mnt/docker/seata/seata-server/目录下，之后执行命令，将seata配置上传到配置中心：

sh ./nacos-config.sh -h39.100.69.145 -p 8848 -g SEATA_GROUP -t seata -u nacos -w nacos

docker elasticsearch安装

#拉取镜像
docker pull elasticsearch:7.10.1
#创建容器
#需要提前从容器中拷贝出来elasticsearch.yml 和data目录
docker run --name es -d -p 9200:9200 -p 9300:9300  -e "discovery.type=single-node" \
-v /etc/localtime:/etc/localtime \
-v /mnt/docker/elasticsearch/config/elasticsearch.yml:/usr/share/elasticsearch/config/elasticsearch.yml \
-v /mnt/docker/elasticsearch/data:/usr/share/elasticsearch/data \
-v /mnt/docker/elasticsearch/plugins:/usr/share/elasticsearch/plugins \
--restart=always elasticsearch:7.10.1

docker es+kibana安装

#让两者处于同一个网络，最新7.13.0
docker network create elastic
docker pull docker.elastic.co/elasticsearch/elasticsearch:7.13.0
docker run --name es -d --net elastic -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" \
-e ES_JAVA_OPTS="-Xms64m  -Xmx512m" \
-v /etc/localtime:/etc/localtime \
-v /home/docker/es/config/elasticsearch.yml:/usr/share/elasticsearch/config/elasticsearch.yml \
-v /home/docker/es/data:/usr/share/elasticsearch/data \
-v /home/docker/es/plugins:/usr/share/elasticsearch/plugins \
--restart=always docker.elastic.co/elasticsearch/elasticsearch:7.13.0

docker pull docker.elastic.co/kibana/kibana:7.13.0
docker run --name kibana -d --net elastic -p 5601:5601 \
-e "ELASTICSEARCH_HOSTS=http://es:9200" \
-v /etc/localtime:/etc/localtime \
-v /home/docker/kibana/config/kibana.yml:/usr/share/kibana/config/kibana.yml \
--restart=always docker.elastic.co/kibana/kibana:7.13.0 

#7.6.2对应springboot2.3.7
docker network create elastic
docker pull elasticsearch:7.6.2
docker run --name es -d --net elastic -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" \
-e ES_JAVA_OPTS="-Xms64m  -Xmx512m" \
-v /etc/localtime:/etc/localtime \
-v /home/docker/es/config/elasticsearch.yml:/usr/share/elasticsearch/config/elasticsearch.yml \
-v /home/docker/es/data:/usr/share/elasticsearch/data \
-v /home/docker/es/plugins:/usr/share/elasticsearch/plugins \
--restart=always elasticsearch:7.6.2

docker pull kibana:7.6.2
docker run --name kibana -d --net elastic -p 5601:5601 \
-e "ELASTICSEARCH_HOSTS=http://es:9200" \
-v /etc/localtime:/etc/localtime \
-v /home/docker/kibana/config/kibana.yml:/usr/share/kibana/config/kibana.yml \
--restart=always kibana:7.6.2

磁盘挂载

#查看当前挂载磁盘
[root@pankuivc ~]# df -h
文件系统                 容量  已用  可用 已用% 挂载点
/dev/mapper/centos-root   50G  4.7G   46G   10% /
devtmpfs                  16G     0   16G    0% /dev
tmpfs                     16G     0   16G    0% /dev/shm
tmpfs                     16G   13M   16G    1% /run
tmpfs                     16G     0   16G    0% /sys/fs/cgroup
/dev/sda2               1014M  162M  853M   16% /boot
/dev/sda1                200M  9.8M  191M    5% /boot/efi
/dev/mapper/centos-home  134G   38M  134G    1% /home
tmpfs                    3.1G  8.0K  3.1G    1% /run/user/42
tmpfs                    3.1G   32K  3.1G    1% /run/user/0

#查看磁盘信息
[root@pankuivc ~]# fdisk -l
WARNING: fdisk GPT support is currently new, and therefore in an experimental phase. Use at your own discretion.

磁盘 /dev/sda：214.7 GB, 214748364800 字节，419430400 个扇区
Units = 扇区 of 1 * 512 = 512 bytes
扇区大小(逻辑/物理)：512 字节 / 512 字节
I/O 大小(最小/最佳)：65536 字节 / 65536 字节
磁盘标签类型：gpt
Disk identifier: 7659DCA7-0CB8-4CF4-BBB6-3C6B34D38B1E


#         Start          End    Size  Type            Name
 1         2048       411647    200M  EFI System      EFI System Partition
 2       411648      2508799      1G  Microsoft basic 
 3      2508800    419428351  198.8G  Linux LVM       
WARNING: fdisk GPT support is currently new, and therefore in an experimental phase. Use at your own discretion.

磁盘 /dev/sdb：3785.3 GB, 3785251356672 字节，7393069056 个扇区
Units = 扇区 of 1 * 512 = 512 bytes
扇区大小(逻辑/物理)：512 字节 / 512 字节
I/O 大小(最小/最佳)：65536 字节 / 65536 字节
磁盘标签类型：gpt
Disk identifier: D41F4B88-9C99-49DF-AEF1-5DD4AC838CD7


#         Start          End    Size  Type            Name
 1           34       262177    128M  Microsoft reser Microsoft reserved partition
Partition 1 does not start on physical sector boundary.
 2       264192   7393067007    3.5T  Microsoft basic Basic data partition

磁盘 /dev/mapper/centos-root：53.7 GB, 53687091200 字节，104857600 个扇区
Units = 扇区 of 1 * 512 = 512 bytes
扇区大小(逻辑/物理)：512 字节 / 512 字节
I/O 大小(最小/最佳)：65536 字节 / 65536 字节


磁盘 /dev/mapper/centos-swap：16.7 GB, 16710107136 字节，32636928 个扇区
Units = 扇区 of 1 * 512 = 512 bytes
扇区大小(逻辑/物理)：512 字节 / 512 字节
I/O 大小(最小/最佳)：65536 字节 / 65536 字节


磁盘 /dev/mapper/centos-home：143.1 GB, 143059320832 字节，279412736 个扇区
Units = 扇区 of 1 * 512 = 512 bytes
扇区大小(逻辑/物理)：512 字节 / 512 字节
I/O 大小(最小/最佳)：65536 字节 / 65536 字节


#挂载 n 1 wq 如果出现的分区不是一个则执行d，删除所有分区
[root@pankuivc ~]# fdisk /dev/sdb
WARNING: fdisk GPT support is currently new, and therefore in an experimental phase. Use at your own discretion.
欢迎使用 fdisk (util-linux 2.23.2)。

更改将停留在内存中，直到您决定将更改写入磁盘。
使用写入命令前请三思。


命令(输入 m 获取帮助)：m
命令操作
   d   delete a partition
   g   create a new empty GPT partition table
   G   create an IRIX (SGI) partition table
   l   list known partition types
   m   print this menu
   n   add a new partition
   o   create a new empty DOS partition table
   p   print the partition table
   q   quit without saving changes
   s   create a new empty Sun disklabel
   t   change a partition's system id
   v   verify the partition table
   w   write table to disk and exit
   x   extra functionality (experts only)

命令(输入 m 获取帮助)：

#注意：如果当前磁盘分过多个区，则需要删除所有分区，后再重新分区
#d 删除分区

# n创建新分区

# Wq保存分区

# 格式化分区
mkfs.ext4 /dev/sdb

#写入挂载信息
echo /dev/sdb /mnt ext4 defaults 0 0 >> /etc/fstab
#挂载分区
#挂载所有写入的分区信息
mount  -a
#挂载指定分区
mount /dev/sdb /mnt

#挂载完成后重启进行校验

docker 安装 plumelog

#1.下载3.3版本源码并打包 https://gitee/frankchenlong/plumelog?_from=gitee_search#https://whnb.wang/frankchenlong/plumelog
#2.修改配置，可以把源码中的配置拷贝一份，然后进行修改
#3.编写dockerfile构建镜像，构建镜像时需要指定外部配置文件，内容如下
FROM java:8
ENV TZ=Asia/Shanghai
ADD plumelog-server-3.3.jar /plumelog-server-3.3.jar
EXPOSE 8891
VOLUME /plumelog-server
ENTRYPOINT ["java","-jar","-Djava.security.egd=file:/dev/./urandom","-Dspring.config.location=/plumelog-server/config/application.properties","/plumelog-server-3.3.jar","-c"]
#4.创建容器
docker run -d --name plumelog -v $(pwd)/plumelog-server:/plumelog-server -p 8891:8891 plumelog:3.3

docker 安装 mongodb

docker pull mongo

docker run -d  --name mongo \
	-v /mnt/docker/mongo/db:/data/db  \
	-p 27017:27017 \
    -e MONGO_INITDB_ROOT_USERNAME=panku \
    -e MONGO_INITDB_ROOT_PASSWORD=pankujava \
    --restart=always \
    mongo