docker教程
官网：https://www.docker.com/
镜像地址：https://hub.docker.com/
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.com/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.com"] } 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.com改成你们自己的域名就可以了
server_name mp.duomishequ.com;
#ssl on;
#从腾讯云获取到的第一个文件的全路径
ssl_certificate /etc/nginx/cert/1_mp.duomishequ.com_bundle.crt;
#从腾讯云获取到的第二个文件的全路径
ssl_certificate_key /etc/nginx/cert/2_mp.duomishequ.com.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目录中创建my.cnf，内容如下:
[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
<dependency>
<groupId>org.apache.commonsgroupId>
<artifactId>commons-pool2artifactId>
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文件中的配置，具体配置如下：
<plugin> <groupId>com.spotifygroupId> <artifactId>docker-maven-pluginartifactId> <version>1.0.0version> <configuration> <imageName>panku/${project.artifactId}imageName> <imageTags> <imageTag>latestimageTag> imageTags> <baseImage>java:8baseImage> <workdir>/rootworkdir> <volumes>/tempvolumes> <cmd>["java", "-version"]cmd> <entryPoint>["java", "-jar", "/${project.build.finalName}.jar","--spring.proflies.active=test","-c"]entryPoint> <dockerHost>http://8.131.71.176:2475dockerHost> <resources> <resource> <targetPath>/targetPath> <directory>${project.build.directory}directory> <include>${project.build.finalName}.jarinclude> resource> resources> configuration> plugin><plugin> <groupId>com.spotifygroupId> <artifactId>docker-maven-pluginartifactId> <version>1.0.0version> <configuration> <imageName>${project.artifactId}imageName> <imageTags> <imageTag>latestimageTag> imageTags> <dockerDirectory>${project.basedir}/src/main/resourcesdockerDirectory> <dockerHost>https://8.131.71.176:2475dockerHost> <dockerCertPath>D:/docker/caclientdockerCertPath> <resources> <resource> <targetPath>/targetPath> <directory>${project.build.directory}directory> <include>${project.build.finalName}.jarinclude> resource> resources> configuration> plugin> 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.spotifygroupId> <artifactId>docker-maven-pluginartifactId> <version>1.0.0version> <configuration> <imageName>${project.artifactId}imageName> <imageTags> <imageTag>latestimageTag> imageTags> <dockerDirectory>${project.basedir}/src/main/resourcesdockerDirectory> <dockerHost>http://8.131.71.176:2475dockerHost> <resources> <resource> <targetPath>/targetPath> <directory>${project.build.directory}directory> <include>${project.build.finalName}.jarinclude> 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
USER root
ENV TZ=Asia/Shanghai
RUN wget http://dl.mycat.org.cn/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部分内容，之后对主库my.cnf增加以下配置：
#创建主库
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
对从库my.cnf增加以下配置:
[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>idcolumns>
<algorithm>rang-longalgorithm>
rule>
tableRule>
<function name="rang-long"
class="io.mycat.route.function.AutoPartitionByLong">
<property name="mapFile">autopartition-long.txtproperty>
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">
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的配置文件 my.cnf
[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#最终逻辑主机的配置如下： select user()
之后链接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.com/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.com #qq：smtp.qq.com 、163：smtp.163.com
username: [email protected] #邮箱地址 qq地址： [email protected] cvdyjnzdtmbsdjih [email protected]
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.com/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.com/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.com/seata/seata/tree/develop/script/config-center/config.txt
- nacos-config.sh https://github.com/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.com/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