学习总结之CentOS7安装Docker

docker安装步骤

1.卸载旧版本

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

2.安装yum-utils包（它提供了yum-config-manager实用程序）并设置国内存储库地址。

sudo yum install -y yum-utils

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

3.更新yum软件包索引

yum makecache fast

4.安装docker

#安装最新版本
sudo yum install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

5.启动docker

 sudo systemctl start docker

6.查看docker版本

docker version
#说明docker安装成功
sudo docker run hello-world

7.卸载docker

ststemctl stop docker

sudo yum remove docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin docker-ce-rootless-extras

sudo rm -rf /var/lib/docker

sudo rm -rf /var/lib/containerd

8.设置阿里云加速器

sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://kvluu6ej.mirror.aliyuncs.com"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker

docker常用命令

1.帮助启动类命令

启动docker: systemctl start docker
停止docker: systemctl stop docker
重启docker: systemctl restart docker
查看docker状态: systemctl status docker
开机启动: systemctl enable docker
查看docker概要信息: docker info
查看docker总体帮助文档: docker --help
查看docker命令帮助文档: docker 具体命令 --help

2.镜像命令

#列出本地主机上的所有镜像
docker images  

#查询某个镜像
docker search [--limit 5] 镜像名称

#拉取某个镜像
docker pull 镜像名称

#查看镜像/容器/数据卷所占的空间
docker system df 

#删除某个镜像
docker rmi 镜像名称
	#删除单个镜像
	docker rmi -f 镜像ID
	#删除多个镜像
	docker rmi -f 镜像名称1:TAG 镜像名称2:TAG ...
	#删除所有镜像
	docker rmi -f $(docker images -qa)

3.容器命令

1.创建+启动容器

#创建+启动容器
docker run [Options] 镜像名称 [Command][Arg]
#例如 docker run -it ubuntu /bin/bash
#Options:
#	-it :开启容器中的命令行窗口用于交互
#	-name=xxx :给容器命名
##	-d 后台运行

2.列出当前正在运行的容器

#列出当前正在运行的容器
docker ps [Options]
# Options:
#	-a:列出当前所有正在运行的容器+历史上运行过的容器
#	-i:显示最近创建的容器
#	-n:显示最近n个创建的容器
#	-q:静默模式,只显示容器编号

3.退出容器

#run进入容器,exit退出,容器停止
exit

#run进入容器,Ctrl+p+q 退出,容器不停止
Ctrl+p+q

4.启动已停止运行的容器

docker start 容器ID/容器名称

5.重启容器

docker restart 容器ID/容器名称

6.停止容器

docker stop 容器ID/容器名称

7.强制停止容器

docker kill 容器ID/容器名称

8.删除已经停止的容器

docker rm 容器ID

#强制删除
docker rm -f 容器ID
#强制删除多个容器
docker rm -f $(docker ps -a -q)
#强制删除多个容器
docker ps -a -q | xargs docker rm

9.查看容器日志

docker logs 容器ID

10.查看容器内运行的进程

docker top 容器ID

11.查看容器内部细节

docker inspect 容器ID

12.进入正在运行的容器并以命令行交互

# Ctrl+p+q,退出容器后,重新进入容器.exit退出后容器不会停止
docker exec -it 容器ID /bin/bash

# Ctrl+p+q,退出容器后,重新进入容器.exit退出后容器会停止
docker attach 容器ID /bin/bash

13.将文件复制到主机上

docker cp 容器ID:容器内文件路径 目的主机路径

14.导入和导出容器

#导出
docker export 容器ID > 文件名.tar

#导入
cat 文件名.tar | docker import-镜像用户/镜像名:镜像版本号
#镜像用户:可以自己命名
#镜像名:可以自己命名
#镜像版本号:可以自己命名

4.docker镜像commit操作

docker commit 提交容器副本使之成为一个新的镜像

# docker commit -m="提交的描述信息" -a="作者" 容器ID 要创建的目标镜像名:[TAG]

举例:在ubuntu容器中不能使用"vim"命令,怎么使它支持???

#拉取ubuntu容器
docker pull ubuntu
#运行ubuntu
docker run -it ubuntu /bin/bash
#docker run -it --name test --net=host ubuntu
#	--net=host  设置网络

#更新包管理工具
容器中> apt-get update
#安装vim
容器中>apt-get-y install vim
#ctrl+p+q退出容器
ctrl+p+q
#提交新的镜像
docker commit -m="add vim" -a="0FJO" 922f025f93ab ofjo/myubuntu:1.0

5.将自己增强的镜像推送到阿里云

1.进入阿里云容器镜像服务/实例列表/镜像仓库/基本信息

#自己的
https://cr.console.aliyun.com/repository/cn-shenzhen/lingfz_20240503/myubuntu/details

2.将镜像推送到阿里云Registry

#登录阿里云 密码:Ling520..
$ docker login --username=aliyun1579881798 registry.cn-shenzhen.aliyuncs.com

#选择需要推送的镜像
$ docker tag [ImageId] registry.cn-shenzhen.aliyuncs.com/lingfz_20240503/myubuntu:[镜像版本号]
#docker tag c6c77b82a4d5 registry.cn-shenzhen.aliyuncs.com/lingfz_20240503/myubuntu:1.0

$ docker push registry.cn-shenzhen.aliyuncs.com/lingfz_20240503/myubuntu:[镜像版本号]

3.从阿里云拉取镜像

docker pull registry.cn-shenzhen.aliyuncs.com/lingfz_20240503/myubuntu:[镜像版本号]

6.将镜像推送到私有库

1.拉取本地私人仓库

docker pull registry

2.启动本地私有仓库

docker run -d -p 5000:5000 -v /usr/local/myregistry:/tmp/registry --privileged=true registry

# -d  后台运行
# -p 5000:500   小p 设置映射端口 虚拟机端口:容器端口
# /usr/local/myregistry 虚拟机文件路径
# /tmp/registry 容器内目录
# --privileged=true 开启访问权限
# registry 镜像名称

3.提交镜像到本地私有仓库

举例:ifconfig 命令

#启动容器
docker run -it --net=host c6c77b82a4d5 /bin/bash
#更新包管理工具
容器中> apt-get update
#安装net-tools
容器中>apt-get install net-tools
#测试  172.17.0.1 
容器中>ifconfig

提交commit命令

#提交新的镜像
docker commit -m="add net-tools" -a="0FJO" 922f025f93ab ofjo/myubuntu:1.0
#查看镜像 多出:98dc1b2aabf7
docker images

验证私服库上有什么镜像

#模拟网络get请求
curl -XGET http://192.168.131.128:5000/v2/_catalog
# {"repositories":[]}  --空的

将新镜像修改成符合私服规范的tag

#公式:docker tag 镜像:TAG host:port/Repositiry.TAG
docker tag myubuntu:1.1 192.168.131.128:5000/myubuntu:1.1
#查看镜像  多出:192.168.131.128:5000/myubuntu  
docker images

修改配置文件使之支持http

#vim  /etc/docker/daemon.json
vim /etc/docker/daemon.json

#修改内容如下
{
  "registry-mirrors": ["https://kvluu6ej.mirror.aliyuncs.com"],
  "insecure-registries":["192.168.131.128:5000"]
}
#重启docker
#启动本地私有仓库

开始推送到私服

docker push 192.168.131.128:5000/myubuntu:1.1
#192.168.131.128:5000  本地虚拟机host:port
#myubuntu:1.1 镜像名称:版本号

#重新验证 私服仓库
curl -XGET http://192.168.131.128:5000/v2/_catalog
#{"repositories":["myubuntu"]}

4.从上私服仓库中拉取镜像

docker pull 192.168.131.128:5000/myubuntu:1.1

容器数据卷

1.作用:

将docker容器内的数据保存进宿主机的磁盘中,实现数据共享,容器重启后会自动同步数据

#公式:docker run -it --privileged=true -v /宿主机绝对路径:/容器内目录 镜像名
$ docker run -it --privileged=true -v /usr/local/host_doc:/tem/docker_doc ubuntu

2.读写规则映射添加说明

​ 默认规则

#默认支持读写
$ docker run -it --privileged=true -v /usr/local/host_doc:/tem/docker_doc ubuntu
#或者
$ docker run -it --privileged=true -v /usr/local/host_doc:/tem/docker_doc:rw ubuntu

​ 只读:限制容器内只能支持读取数据

$ docker run -it --privileged=true -v /usr/local/host_doc:/tem/docker_doc:ro ubuntu

3.容器数据卷的继承和共享

1.容器1完成和宿主机的映射

docker run -it --privileged=true -v /usr/local/host_doc:/tem/docker_doc --name=u1 ubuntu

2.容器2继承容器1的卷规则

docker run -it --privileged=true --volumes-from 父类 --name=n2 ubuntu

docker之mysql:5.7主从配置

镜像拉取

运行主机器

docker run -p 3307:3306 --name mysql-master \
-v /usr/local/mydata/mysql-master/log:/var/log/mysql \
-v /usr/local/mydata/mysql-master/data:/var/lib/mysql \
-v /usr/local/mydata/mysql-master/conf:/etc/mysql \
-e MYSQL_ROOT_PASSWORD=root \
-d mysql:5.7

进入/mydata/mysql-master/conf目录下新建my.cnf

vim my.cnf
复制如下内容:
[mysqld]
## 设置server_id，同一局域网中需要唯一
server_id=101 
## 指定不需要同步的数据库名称
binlog-ignore-db=mysql  
## 开启二进制日志功能
log-bin=mall-mysql-bin  
## 设置二进制日志使用内存大小（事务）
binlog_cache_size=1M  
## 设置使用的二进制日志格式（mixed,statement,row)
binlog_format=mixed
##二进制日志过期清理时间,默认值为0,表示不自动清理
expire_logs_days=7
##mysql8使用
##binlog_expire_logs_seconds = 604800
##跳过主从复制中遇到的所有错误或指定类型的错误,避免slave端复制中断
##如:1062错误是指一些主键重复,1032错误是因为主从数据不一致
slave_skip_errors=1062

修改完配置后重启master实例

docker restart mysql-master

进入mysql-master容器

docker exec -it mysql-master /bin/bash

mysql -uroot -proot

master容器实例内创建数据同步用户

CREATE USER 'slave'@'%' IDENTIFIED BY '123456';

GRANT REPLICATION SLAVE, REPLICATION CLIENT ON *.* TO 'slave'@'%';

运行从机器

docker run -p 3308:3306 --name mysql-slave \
-v /usr/local/mydata/mysql-slave/log:/var/log/mysql \
-v /usr/local/mydata/mysql-slave/data:/var/lib/mysql \
-v /usr/local/mydata/mysql-slave/conf:/etc/mysql \
-e MYSQL_ROOT_PASSWORD=root  \
-d mysql:5.7

进入/mydata/mysql-slave/conf目录下新建my.cnf

vim my.cnf

[mysqld]
## 设置server_id，同一局域网中需要唯一
server_id=102 
## 指定不需要同步的数据库名称
binlog-ignore-db=mysql  
## 开启二进制日志功能
log-bin=mall-mysql-slave-bin  
## 设置二进制日志使用内存大小（事务）
binlog_cache_size=1M  
## 设置使用的二进制日志格式（mixed,statement,row)
binlog_format=mixed
##二进制日志过期清理时间,默认值为0,表示不自动清理
expire_logs_days=7
##mysql8使用
##binlog_expire_logs_seconds = 604800
##跳过主从复制中遇到的所有错误或指定类型的错误,避免slave端复制中断
##如:1062错误是指一些主键重复,1032错误是因为主从数据不一致
slave_skip_errors=1062
##relay_log配置中继日志
relay_log=mall-mysql-relay-bin
##slave设置为只读(具有super权限的用户除外)
read_only=1

修改完配置后重启slave实例

docker restart mysql-slave

在主数据库中查看主从同步状态

show master status;

进入mysql-slave容器

docker exec -it mysql-slave /bin/bash

mysql -uroot -proot

在从数据库中配置主从复制

change master to master_host='宿主机ip', master_user='slave', master_password='123456', master_port=3307, master_log_file='mall-mysql-bin.000001', master_log_pos=617, master_connect_retry=30;
/**
master_host：主数据库的IP地址；
master_port：主数据库的运行端口；
master_user：在主数据库创建的用于同步数据的用户账号；
master_password：在主数据库创建的用于同步数据的用户密码；
master_log_file：指定从数据库要复制数据的日志文件，通过查看主数据的状态，获取File参数；
master_log_pos：指定从数据库从哪个位置开始复制数据，通过查看主数据的状态，获取Position参数；
master_connect_retry：连接失败重试的时间间隔，单位为秒。
*/

在从数据库中查看主从同步状态

show slave status \G;

在从数据库中开启主从同步

start slave;

验证…

docker之Redis三主三从搭建

思考:1~2亿条数据需要缓存，请问如何设计这个存储案例?

一般业界有3种解决方案:
1.哈希取余分区
2.一致性哈希算法分区
3.哈希槽分区(大厂采用的方案)

新建6个docker容器redis实例

docker run -d --name redis-node-1 --net host --privileged=true -v /data/redis/share/redis-node-1:/data redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6381
.
.
.
# --net host 使用宿主机的IP和端口，默认
# --privileged=true 获取宿主机root用户权限
# --cluster-enabled yes 开启redis集群
# --appendonly yes 开启持久化
# --port 6386 redis端口号

进入容器redis-node-1并为6台机器构建集群关系

#进入容器
docker exec -it redis-node-1 /bin/bash
#构建主从关系
//注意，进入docker容器后才能执行一下命令，且注意自己的真实IP地址
redis-cli --cluster create 192.168.131.131:6381 192.168.131.131:6382 192.168.131.131:6383 192.168.131.131:6384 192.168.131.131:6385 192.168.131.131:6386 --cluster-replicas 1
#--cluster-replicas 1 表示为每个master创建一个slave节点

链接进入6381作为切入点，查看集群状态

#进入Redis容器
redis-cli -p 6381 (单机版)

cluster info

cluster nodes
#主         	从   主从机器是有机器自动分配的
node1 ---->	node5
node2 ----> node6
node3 ---->	node4

进入Redis集群

#进入容器
docker exec -it redis-node-1 /bin/bash
## 连接Redis-node-1 集群版
redis-cli -p 6381 -c

退出Redis,查看集群信息

redis-cli --cluster check 192.168.131.131:6381
## --cluster check

Redis扩容

运行redis-node-7,redis-node-8

docker run -d --name redis-node-7 --net host --privileged=true -v /usr/local/mydata/redis/share/redis-node-7:/data redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6387
docker run -d --name redis-node-8 --net host --privileged=true -v /usr/local/mydata/redis/share/redis-node-8:/data redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6388

进入Redis-node-7容器(此时并未加入集群也还未分配哈希槽位)

docker exec -it redis-node-7 /bin/bash
##加入集群 将新增的6387作为master节点加入集群
redis-cli --cluster add-node 自己实际IP地址:6387 自己实际IP地址:6381
6387 就是将要作为master新增节点
6381 就是原来集群节点里面的领路人，相当于6387拜拜6381的码头从而找到组织加入集群
#redis-cli --cluster add-node 192.168.131.131:6387 192.168.131.131:6381

#检查发现redis-node-7 已经加入集群,但是未分配槽位
redis-cli --cluster check 192.168.131.131:6387

重新分派槽号

命令:redis-cli --cluster reshard IP地址:端口号
redis-cli --cluster reshard 192.168.131.131:6387

主机分配从机

命令：redis-cli --cluster add-node ip:新slave端口 ip:新master端口 --cluster-slave --cluster-master-id 新主机节点ID
 
redis-cli --cluster add-node 192.168.111.147:6388 192.168.111.147:6387 --cluster-slave --cluster-master-id e4781f644d4a4e4d4b4d107157b9ba8144631451-------这个是6387的编号，按照自己实际情况

Redis缩容

先删除从机节点

命令：redis-cli --cluster del-node ip:从机端口 从机6388节点ID
 
redis-cli --cluster del-node 192.168.111.147:6388 5d149074b7e57b802287d1797a874ed7a1a284a8
 

redis-cli --cluster check 192.168.111.147:6382
 
 检查一下发现，6388被删除了，只剩下7台机器了。

清空主机中的槽位重新分配给其他主机

redis-cli --cluster reshard 192.168.111.147:6381
命令执行后需要填写三个参数
1:需要分配的槽数? 4096
2:那个主机接收这些槽位? 主机1ID  
3:从那个主机释放槽位 ?主机4ID
4:确认? done

删除主机

命令：redis-cli --cluster del-node 主机ip:主机机端口 主机6387节点ID

docker之Dockerfile文件

什么是Dockerfile

Dockerfile是用来构建Docker镜像的文本文件，是由一条条构建镜像所需的指令和参数构成的脚本。可以理解成中药的药方
	构建三步:
		编写Dockerfile文件;
		docker build命令构建镜像
		docker run依镜像运行容器实例

常用关键字

FROM           #基础镜像，一切都从这里构建，比如centos scratch
 
MAINTAINER     #镜像作者，姓名+邮箱
 
RUN            #镜像构建的时候需要运行的命令
 
ADD            #镜像添加内容，比如添加tomcat等，如果我们直接ADD压缩包，ADD命令会自动帮助我们解压
 
WORKDIR        #镜像的工作目录
 
VOLUME         #镜像挂载的目录
 
EXPOSE         #镜像暴露的端口号
 
CMD            #指定这个容器启动的时候需要运行的命令，只有最后一个会生效，可以被替代
 
ENTRYPOINT     #指定这个容器启动的时候需要运行的命令，可以追加命令 不会被覆盖
 
COPY           #类似于ADD，将我们的文件拷贝到镜像中
 
ENV            #构建的时候设置环境变量

举例

#创建Dockerfile文件  Dockerfile的'D'必须大小 最好将需要依赖的文件和Dockerfile放在同一路径下
vim Dockerfile
#输入以下内容"

# 基础镜像使用java
FROM java:8
# 作者
MAINTAINER zzyy
# VOLUME 指定临时文件目录为/tmp，在主机/var/lib/docker目录下创建了一个临时文件并链接到容器的/tmp
VOLUME /tmp
# 将jar包添加到容器中并更名为zzyy_docker.jar
ADD docker_boot-0.0.1-SNAPSHOT.jar zzyy_docker.jar
# 运行jar包
RUN bash -c 'touch /zzyy_docker.jar'
ENTRYPOINT ["java","-jar","/zzyy_docker.jar"]
#暴露端口
EXPOSE 6001

esc
:wq

#构建镜像 (抓好的药)
docker build -t zzyy_docker:1.6 .    # 结尾的"." 不能省略

#运行镜像(煎好的药)
docker run -d -p 6001:6001 zzyy_docker:1.6

Docker之Docker-compose容器编排

Docker-compose是什么?

Docker-Compose是Docker官方的开源项目，负责实现对Docker容器集群的快速编排。

如果我需要同时部署好多个服务,难道要每个服务单独写Dockerfile然后在构建镜像,构建容器,这样累都累死了,所以docker官方给我们提供了docker-compose多服务部署的工具

例如要实现一个Web微服务项目，除了Web服务容器本身，往往还需要再加上后端的数据库mysql服务容器，redis服务器，注册中心eureka，甚至还包括负载均衡容器等等。。。。。。

Compose允许用户通过一个单独的docker-compose.yml模板文件（YAML 格式）来定义一组相关联的应用容器为一个项目（project）。然后只需要一个命令就可以做到一键启动/停止

下载安装

 #执行:https://docs.docker.com/compose/install/standalone/
 curl -SL https://github.com/docker/compose/releases/download/v2.27.0/docker-compose-linux-x86_64 -o /usr/local/bin/docker-compose
 
 curl -L https://github.com/docker/compose/releases/download/1.21.1/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose


 #将可执行权限应用于安装目标路径中的独立二进制文件。
 sudo chmod +x /usr/local/lib/docker/cli-plugins/docker-compose
 #测试
 docker compose version

Docker compose 常用命令

Compose常用命令
docker-compose -h                           # 查看帮助
docker-compose up                           # 启动所有docker-compose服务
docker-compose up -d                        # 启动所有docker-compose服务并后台运行
docker-compose down                         # 停止并删除容器、网络、卷、镜像。
docker-compose exec  yml里面的服务id          # 进入容器实例内部  docker-compose exec docker-compose.yml文件中写的服务id /bin/bash
docker-compose ps                      	# 展示当前docker-compose编排过的运行的所有容器
docker-compose top                     	# 展示当前docker-compose编排过的容器进程
docker-compose logs yml文件中的服务ID		#查看容器输出日志
docker-compose config					#配置检查
docker-compose config -q				#检查配置,有问题才输出
docker-compose restart					#重启服务
docker-compose start					#启动服务
docker-compose stop						#停止服务

示例:docker-compose.yml

# Compose 版本 Version 2支持更多的指令。Version 1将来会被弃用。
version: "3"

# 定义服务
services:

  # 为project定义服务
  redis:
    # 服务的镜像名称或镜像ID。如果镜像在本地不存在，Compose将会尝试拉取镜像
    image: redis:4.0
    # 配置端口 - "宿主机端口:容器暴露端口"
    ports:
      - 6379:6379
    # 配置容器连接的网络，引用顶级 networks 下的条目(就是最下面配置的networks(一级目录))
    networks:
      network_name:
       # 为单redis创建别名, REDIS_URL标记为redis服务的地址. (不配置aliases也可以, 这样就通过定义的服务名: redis链接)
       aliases:
         - REDIS_URL
    # 挂载
    volumes:
      - "/docker/redis/conf/redis.conf:/etc/redis/redis.conf"
      - "/docker/redis/data:/data"
    # 容器总是重新启动
    restart: always
    # 相当于执行一些命令
    command:
      redis-server /etc/redis/redis.conf --appendonly yes
    # 指定一个自定义容器名称，而不是生成的默认名称。
    container_name: redis
    # 使用该参数，container内的root拥有真正的root权限。
    privileged: true

  db:
    image: mysql:5.7
    ports:
      - 3306:3306
    # 添加环境变量
    environment:
      MYSQL_ROOT_PASSWORD: "123456"
    volumes:
      - "/docker/mysql/conf/my.cnf:/etc/mysql/conf.d/my.cnf"
      - "/docker/mysql/logs:/var/log/mysql"
      - "/docker/mysql/data:/var/lib/mysql"
      - "/docker/mysql/sql/init.sql:/docker-entrypoint-initdb.d/init.sql"
      - "/etc/localtime:/etc/localtime"
    networks:
      network_name:
        aliases:
         - MYSQL_URL
    restart: always
    command: --init-file /docker-entrypoint-initdb.d/init.sql
    container_name: mysql
    privileged: true
    
  project-name:
    # 服务的镜像名称或镜像ID。如果镜像在本地不存在，Compose将会尝试拉取镜像
    image: project-name:1.0.0
    # 构建镜像
    build:
      # 指定项目的地址
      context: /root/docker_mysql_redis
      # 指定Dockerfile
      dockerfile: Dockerfile
    ports:
      - 8080:8080
    # 从文件添加环境变量
    env_file:
      - /root/environment.env
    networks:
      network_name:
       aliases:
        - PROJECT_URL
    privileged: true
    restart: always
    container_name: test-name
    
  # ........可以继续添加


networks:
  # bridge：默认，需要单独配置ports映射主机port和服务的port，并且开启了容器间通信
  network_name:
    driver: bridge

执行Docker compose

执行 docker-compose up
或者
执行 docker-compose up -d