docker教程

官网:https://www.docker.com/

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

docker教程_第1张图片

1.docker安装

  1. 卸载原有docker

    yum remove docker \
                      docker-client \
                      docker-client-latest \
                      docker-common \
                      docker-latest \
                      docker-latest-logrotate \
                      docker-logrotate \
                      docker-engine
    
  2. 安装docker 依赖和yum源

    yum install -y yum-utils
    
    yum-config-manager \
        --add-repo \
        https://download.docker.com/linux/centos/docker-ce.repo
    
  3. 下载docker

    yum install docker-ce docker-ce-cli containerd.io
    
  4. 启动docker

    systemctl start docker
    #设置开机启动
    chkconfig docker on
    
  5. 运行容器测试docker

    docker run hello-world
    

2.配置docker镜像

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

  2. 执行下述代码

    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

  1. 拉取nginx镜像

    #不指定版本号则默认拉取最新版本
    docker pull nginx
    
  2. 创建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

  1. 拉取镜像

    docker pull mysql:5.7
    
  2. 创建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
    
  3. 开启root账户远程访问

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

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

5.docker安装redis

  1. 拉取进行

    docker pull redis
    
  2. 创建容器

    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
    
  3. 创建容器后,在/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
    
    
  4. 优化配置

#内存分配策略,直接在宿主机上执行即可
#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一键部署

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

  1. 开启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
  1. 使用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)]

  2. 修改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"]
    
  3. 执行 mvn clean package:build进行构建并将远程创建docker镜像

  4. 启动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)]

  5. 也可以直接在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镜像,构建步骤如下:

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

    2. 之后执行下面的命令:

      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主从复制

docker教程_第2张图片

两个数据库信息

名称 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 双主双从

docker教程_第3张图片

服务器信息

名称 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
  1. 修改主库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
  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分配用户权限,进入主库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         |                  |                   |
+-------------------+----------+--------------+------------------+-------------------+

  1. 主库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链接到主库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;

  1. 配置从库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. 实现双主互备,主库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;



  1. 创建数据库和表进行测试
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 常见问题

  1. 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上下载两个文件:

  1. config.txt https://github.com/seata/seata/tree/develop/script/config-center/config.txt
  2. 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

你可能感兴趣的:(Centos,docker,docker安装,docker,docker安装,docker镜像,docker-compose)