Docker

已于 2022-07-28 09:15:42 修改
阅读量3.2k 收藏
点赞数 1
文章标签： docker 运维 linux
于 2022-06-24 21:00:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44960905/article/details/125452164
版权

Docker

1. Docker概述

​ docker思想来源于集装箱，核心思想：隔离，将多个应用打包装箱，每个箱子都是互相隔离的

​ docker是基于Go语言开发的，开源项目。

虚拟化技术

在这里插入图片描述

​ 缺点：资源占用多、冗余步骤多、启动慢

容器化技术

​ 容器化技术不是模拟一个完整的OS

在这里插入图片描述

Docker与虚拟化技术的不同：

  • 传统虚拟机需要虚拟硬件，运行一个完整的OS，之后运行App
  • 容器内的应用直接运行在宿主机，容器没有自己的内核，没有虚拟硬件
  • 每个容器之间相互隔离，都有自己的文件系统，互不影响

DevOps 开发、运维

  1. 应用更加快捷的交付和部署

    传统：很多帮助文档，需要根据文档安装环境，复杂

    Docker：将开发的应用与环境一起打包成镜像，之后进行发布，就可以一键运行

  2. 更便捷的升级和扩缩容

    项目打包为一个镜像，这个镜像就可以增删

  3. 更简单的系统运维

    在容器化之后，开发和测试环境高度一致

  4. 更高效的计算和资源利用

    Docker是内核级别的虚拟化，可以在一个物理机上运行多个容器，这样就可以使服务器的性能发挥到极致。

2. Docker安装

2.1 基本组成

在这里插入图片描述

镜像（image）

​ docker镜像就像是一个模板，可以通过此模板来创建容器，tomcat镜像---->run---->tomcat01容器（提供服务）,而且可以通过这个镜像创建多个容器，最终项目运行在这个容器中。

容器（container）

​ Docker利用容器技术，独立运行一个或者一组应用，容器是通过镜像创建的。

​ 启动、停止、删除、基本命令

​ 可以将这个容器理解为一个小型的Linux系统

仓库（repository）

​ 存放镜像的地方

​ 公有仓库和私有仓库

​ Docker Hub、阿里云…都有容器服务，需要配置镜像加速

2.2 安装docker

​ 环境查看

# 系统内核是3.10以上的
[root@summer ~]# uname -r
3.10.0-1062.18.1.el7.x86_64

# 系统版本
[root@summer ~]# cat /etc/os-release
NAME="CentOS Linux"
VERSION="7 (Core)"
ID="centos"
ID_LIKE="rhel fedora"
VERSION_ID="7"
PRETTY_NAME="CentOS Linux 7 (Core)"
ANSI_COLOR="0;31"
CPE_NAME="cpe:/o:centos:centos:7"
HOME_URL="https://www.centos.org/"
BUG_REPORT_URL="https://bugs.centos.org/"

CENTOS_MANTISBT_PROJECT="CentOS-7"
CENTOS_MANTISBT_PROJECT_VERSION="7"
REDHAT_SUPPORT_PRODUCT="centos"
REDHAT_SUPPORT_PRODUCT_VERSION="7"

安装

https://docs.docker.com/engine/install/centos/

# 1. 清除之前的版本
yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-engine

# 2.安装需要的软件包
yum install -y yum-utils

# 3.设置stable镜像仓库
yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

# 4.更新yum软件包索引
yum makecache fast

# 5.安装Docker-CE 社区版
yum -y install docker-ce docker-ce-cli containerd.io

# 6.启动docker
systemctl start docker

# 7.测试
docker version

docker run hello-world

docker images

卸载

# 1. 卸载依赖
yum remove docker-ce docker-ce-cli containerd.io
# 2. 删除资源
rm -rf /var/lib/docker
2.3 配置阿里云镜像加速

  1. 登录阿里云，进入镜像服务

  2. 找到镜像加速器

在这里插入图片描述

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

在这里插入图片描述

2.5 底层原理

​ Docker是一个CS模式的系统，Docker的守护进程运行在主机上，通过socket从客户端访问。Docker-server接收Docker-client的指令，就会执行这个命令。

在这里插入图片描述

Docker为什么比VM快？

  1. Docker有比虚拟机更少的抽象层

  2. Docker利用的是宿主机的内核，VM需要的是Guest OS

    新建一个容器的时候，docker不需要和虚拟机一样加载一个OS内核，避免引导。虚拟机需要加载Guest OS，需要分钟级别的时间，而docker是利用宿主机的OS，省略了这个复杂的过程，需要秒级的时间。

3. Docker命令

3.1 帮助命令
docker version # 显示docker的信息
docker info    # 显示docker的系统信息  含镜像和容器数量
dokcer --help  # 帮助
3.2 镜像命令

docker images 查看本机所有的镜像

[root@summer ~]# docker images
REPOSITORY    TAG       IMAGE ID       CREATED        SIZE
hello-world   latest    feb5d9fea6a5   9 months ago   13.3kB
# REPOSITORY 镜像的仓库源   # TAG镜像的标签 # IMAGE ID 镜像id   # CREATED  镜像创建时间 # SIZE 镜像大小


# 可选项
docker images -a
-a # 列出所有的镜像
docker images -q
-q # 只显示镜像的id

docker search 搜索镜像

[root@summer ~]# docker search mysql
NAME                           DESCRIPTION                                     STARS  UTOMATED
mysql                          MySQL is a widely used, open-source relation…   12752

# 可选项 通过收藏来过滤
docker search mysql -f=STARS=3000  # 搜索出的镜像收藏大于3000

docker pull 下载镜像

[root@summer ~]# docker pull mysql # 下载mysql镜像
Using default tag: latest # 默认使用最新版
latest: Pulling from library/mysql
72a69066d2fe: Pull complete # 分层下载 docker image的核心
93619dbc5b36: Pull complete 
99da31dd6142: Pull complete 
626033c43d70: Pull complete 
37d5d7efb64e: Pull complete 
ac563158d721: Pull complete 
d2ba16033dad: Pull complete 
688ba7d5c01a: Pull complete 
00e060b6d11d: Pull complete 
1c04857f594f: Pull complete 
4d7cfa90e6ea: Pull complete 
e0431212d27d: Pull complete 
Digest: sha256:e9027fe4d91c0153429607251656806cc784e914937271037f7738bd5b8e7709 # 签名
Status: Downloaded newer image for mysql:latest
docker.io/library/mysql:latest # 真实地址


docker pull mysql  ==  docker pull docker.io/library/mysql:latest
# 指定版本下载
[root@summer ~]# docker pull mysql:5.7
5.7: Pulling from library/mysql
72a69066d2fe: Already exists  # 上边已经下载过了,这里说已经存在
93619dbc5b36: Already exists 
99da31dd6142: Already exists 
626033c43d70: Already exists 
37d5d7efb64e: Already exists 
ac563158d721: Already exists 
d2ba16033dad: Already exists 
0ceb82207cd7: Pull complete 
37f2405cae96: Pull complete 
e2482e017e53: Pull complete 
70deed891d42: Pull complete 
Digest: sha256:f2ad209efe9c67104167fc609cca6973c8422939491c9345270175a300419f94
Status: Downloaded newer image for mysql:5.7
docker.io/library/mysql:5.7


[root@summer ~]# docker images
REPOSITORY    TAG       IMAGE ID       CREATED        SIZE
mysql         5.7       c20987f18b13   6 months ago   448MB
mysql         latest    3218b38490ce   6 months ago   516MB
hello-world   latest    feb5d9fea6a5   9 months ago   13.3kB

docker rmi 删除镜像

[root@summer ~]# docker rmi -f 3218b38490ce           # 根据镜像id删除镜像
[root@summer ~]# docker rmi -f id id id id id id      # 根据多个镜像id删除镜像
[root@summer ~]# docker rmi -f $(docker images -aq)   # 删除所有的镜像  $(docker images -aq)得到所有的镜像
3.3 容器命令

有了镜像才可以创建容器

docker pull centos

新建容器并启动

docker run [可选参数] image

# 可选参数
--name="name" # 设置容器名字
-d  # 后台运行
-it # 使用交互方式运行,进入容器查看内容
-p  # 指定容器的端口  -p 8080    
# -p 主机端口:容器端口 (常用) / -p 主机IP:主机端口:容器端口 / -p 容器端口 / 容器端口
-P  # 随机指定端口


# 启动并进入容器
[root@summer ~]# docker run -it centos /bin/bash
# 查看容器内的centos 
[root@d49174fa1a95 /]# ls
bin  etc   lib	  lost+found  mnt  proc  run   srv  tmp  var
dev  home  lib64  media       opt  root  sbin  sys  usr
# 退出容器
[root@d49174fa1a95 /]# exit

列出所有运行的容器

# docker ps      列出当前正在运行的容器
[root@summer /]# docker ps   
CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES
# docker ps -a   列出当前正在运行的 + 已经执行过的容器
# docker ps -n=3 列出最近执行的3个容器 
# docker ps -q   只显示容器的编号
[root@summer /]# docker ps -a
CONTAINER ID   IMAGE          COMMAND       CREATED         STATUS                          PORTS     NAMES
d49174fa1a95   centos         "/bin/bash"   3 minutes ago   Exited (0) About a minute ago             beautiful_lamarr
e9ed88804f84   feb5d9fea6a5   "/hello"      28 hours ago    Exited (0) 28 hours ago                   wonderful_gauss

退出容器

exit         # 直接停止容器并退出
Ctrl + p + q # 容器不停止退出

[root@summer /]# docker run -it centos /bin/bash
[root@d764ed07e3c9 /]# [root@summer /]# docker ps 
CONTAINER ID   IMAGE     COMMAND       CREATED          STATUS          PORTS     NAMES
d764ed07e3c9   centos    "/bin/bash"   20 seconds ago   Up 20 seconds             cranky_noyce

删除容器

docker rm 容器id                    # 删除指定的容器 不能删除正在运行的容器 强制删除 docker rm -f 容器id
docker rm -f $(docker ps -aq)      # 删除所有
docker ps -a -q |xargs docker rm   # 删除所有容器

启动和停止容器

docker start 容器id    # 启动容器
docker restart 容器id  # 重启容器
docker stop 容器id     # 停止当前正在执行的容器
docker kill 容器id     # 强制停止当前容器
3.4 其他命令

后台启动容器

# docker run -d centos 容器名
[root@summer /]# docker run -d centos  # 后台启动容器 
# 当后台启动容器后,此时使用docker ps 发现并没有启动的容器,因为docker要求如果没有前台进程使用,后台就会停止

查看日志

[root@summer /]# docker run -d centos /bin/sh -c "while true;do echo hello;sleep 1;done" 
18b16e0b8737399c200bd976fcdc256ac41f4ae568b32328f6b3a37d199cb6bf
[root@summer /]# docker ps
CONTAINER ID   IMAGE     COMMAND                  CREATED         STATUS         PORTS     NAMES
18b16e0b8737   centos    "/bin/sh -c 'while t…"   6 seconds ago   Up 5 seconds             boring_dirac
[root@summer /]# docker logs -ft --tail 10 18b16e0b8737   # 显示指定行数（10条）的日志
2022-06-21T08:33:48.061129786Z hello
2022-06-21T08:33:49.062926733Z hello
2022-06-21T08:33:50.064704484Z hello
2022-06-21T08:33:51.066600393Z hello
2022-06-21T08:33:52.068816136Z hello
2022-06-21T08:33:53.070784213Z hello
2022-06-21T08:33:54.072612454Z hello
2022-06-21T08:33:55.074587258Z hello
2022-06-21T08:33:56.076494828Z hello
2022-06-21T08:33:57.078247385Z hello
2022-06-21T08:33:58.080320482Z hello
2022-06-21T08:33:59.082192594Z hello

查看容器中的进程信息

[root@summer /]# docker top 18b16e0b8737  
UID                 PID                 PPID                C                   STIME               TTY                 TIME                CMD
root                1281                1261                0                   16:27               ?                   00:00:00            /bin/sh -c while true;do echo hello;sleep 1;done
root                3317                1281                0                   16:44               ?                   00:00:00            /usr/bin/coreutils --coreutils-prog-shebang=sleep /usr/bin/sleep 1

查看容器元数据

[root@summer /]# docker inspect 18b16e0b8737
[
    {
        "Id": "18b16e0b8737399c200bd976fcdc256ac41f4ae568b32328f6b3a37d199cb6bf",
        "Created": "2022-06-21T08:27:36.104218525Z",
        "Path": "/bin/sh",
        "Args": [
            "-c",
            "while true;do echo hello;sleep 1;done"
        ],
        "State": {
            "Status": "running",
            "Running": true,
            "Paused": false,
            "Restarting": false,
            "OOMKilled": false,
            "Dead": false,
            "Pid": 1281,
            "ExitCode": 0,
            "Error": "",
            "StartedAt": "2022-06-21T08:27:36.347672878Z",
            "FinishedAt": "0001-01-01T00:00:00Z"
        },
        "Image": "sha256:5d0da3dc976460b72c77d94c8a1ad043720b0416bfc16c52c45d4847e53fadb6",
        "ResolvConfPath": "/var/lib/docker/containers/18b16e0b8737399c200bd976fcdc256ac41f4ae568b32328f6b3a37d199cb6bf/resolv.conf",
        "HostnamePath": "/var/lib/docker/containers/18b16e0b8737399c200bd976fcdc256ac41f4ae568b32328f6b3a37d199cb6bf/hostname",
        "HostsPath": "/var/lib/docker/containers/18b16e0b8737399c200bd976fcdc256ac41f4ae568b32328f6b3a37d199cb6bf/hosts",
        "LogPath": "/var/lib/docker/containers/18b16e0b8737399c200bd976fcdc256ac41f4ae568b32328f6b3a37d199cb6bf/18b16e0b8737399c200bd976fcdc256ac41f4ae568b32328f6b3a37d199cb6bf-json.log",
        "Name": "/boring_dirac",
        "RestartCount": 0,
        "Driver": "overlay2",
        "Platform": "linux",
        "MountLabel": "",
        "ProcessLabel": "",
        "AppArmorProfile": "",
        "ExecIDs": null,
        "HostConfig": {
            "Binds": null,
            "ContainerIDFile": "",
            "LogConfig": {
                "Type": "json-file",
                "Config": {}
            },
            "NetworkMode": "default",
            "PortBindings": {},
            "RestartPolicy": {
                "Name": "no",
                "MaximumRetryCount": 0
            },
            "AutoRemove": false,
            "VolumeDriver": "",
            "VolumesFrom": null,
            "CapAdd": null,
            "CapDrop": null,
            "CgroupnsMode": "host",
            "Dns": [],
            "DnsOptions": [],
            "DnsSearch": [],
            "ExtraHosts": null,
            "GroupAdd": null,
            "IpcMode": "private",
            "Cgroup": "",
            "Links": null,
            "OomScoreAdj": 0,
            "PidMode": "",
            "Privileged": false,
            "PublishAllPorts": false,
            "ReadonlyRootfs": false,
            "SecurityOpt": null,
            "UTSMode": "",
            "UsernsMode": "",
            "ShmSize": 67108864,
            "Runtime": "runc",
            "ConsoleSize": [
                0,
                0
            ],
            "Isolation": "",
            "CpuShares": 0,
            "Memory": 0,
            "NanoCpus": 0,
            "CgroupParent": "",
            "BlkioWeight": 0,
            "BlkioWeightDevice": [],
            "BlkioDeviceReadBps": null,
            "BlkioDeviceWriteBps": null,
            "BlkioDeviceReadIOps": null,
            "BlkioDeviceWriteIOps": null,
            "CpuPeriod": 0,
            "CpuQuota": 0,
            "CpuRealtimePeriod": 0,
            "CpuRealtimeRuntime": 0,
            "CpusetCpus": "",
            "CpusetMems": "",
            "Devices": [],
            "DeviceCgroupRules": null,
            "DeviceRequests": null,
            "KernelMemory": 0,
            "KernelMemoryTCP": 0,
            "MemoryReservation": 0,
            "MemorySwap": 0,
            "MemorySwappiness": null,
            "OomKillDisable": false,
            "PidsLimit": null,
            "Ulimits": null,
            "CpuCount": 0,
            "CpuPercent": 0,
            "IOMaximumIOps": 0,
            "IOMaximumBandwidth": 0,
            "MaskedPaths": [
                "/proc/asound",
                "/proc/acpi",
                "/proc/kcore",
                "/proc/keys",
                "/proc/latency_stats",
                "/proc/timer_list",
                "/proc/timer_stats",
                "/proc/sched_debug",
                "/proc/scsi",
                "/sys/firmware"
            ],
            "ReadonlyPaths": [
                "/proc/bus",
                "/proc/fs",
                "/proc/irq",
                "/proc/sys",
                "/proc/sysrq-trigger"
            ]
        },
        "GraphDriver": {
            "Data": {
                "LowerDir": "/var/lib/docker/overlay2/469ff3e0a100627c7857dcfe7c3439fca033437c15e62d390c208e68bd6b3ddf-init/diff:/var/lib/docker/overlay2/3ebb2f32c933faca3d5031042cc8bc2f60eba06c29db637756b527ed4e698d4f/diff",
                "MergedDir": "/var/lib/docker/overlay2/469ff3e0a100627c7857dcfe7c3439fca033437c15e62d390c208e68bd6b3ddf/merged",
                "UpperDir": "/var/lib/docker/overlay2/469ff3e0a100627c7857dcfe7c3439fca033437c15e62d390c208e68bd6b3ddf/diff",
                "WorkDir": "/var/lib/docker/overlay2/469ff3e0a100627c7857dcfe7c3439fca033437c15e62d390c208e68bd6b3ddf/work"
            },
            "Name": "overlay2"
        },
        "Mounts": [],
        "Config": {
            "Hostname": "18b16e0b8737",
            "Domainname": "",
            "User": "",
            "AttachStdin": false,
            "AttachStdout": false,
            "AttachStderr": false,
            "Tty": false,
            "OpenStdin": false,
            "StdinOnce": false,
            "Env": [
                "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
            ],
            "Cmd": [
                "/bin/sh",
                "-c",
                "while true;do echo hello;sleep 1;done"
            ],
            "Image": "centos",
            "Volumes": null,
            "WorkingDir": "",
            "Entrypoint": null,
            "OnBuild": null,
            "Labels": {
                "org.label-schema.build-date": "20210915",
                "org.label-schema.license": "GPLv2",
                "org.label-schema.name": "CentOS Base Image",
                "org.label-schema.schema-version": "1.0",
                "org.label-schema.vendor": "CentOS"
            }
        },
        "NetworkSettings": {
            "Bridge": "",
            "SandboxID": "7c3363c27460406965fd9119957e8cb06a3cab7859a45737c55e9fee0d69f84a",
            "HairpinMode": false,
            "LinkLocalIPv6Address": "",
            "LinkLocalIPv6PrefixLen": 0,
            "Ports": {},
            "SandboxKey": "/var/run/docker/netns/7c3363c27460",
            "SecondaryIPAddresses": null,
            "SecondaryIPv6Addresses": null,
            "EndpointID": "bcc8bddd53da2d99726adcbdd2f2a408a7ce51476e72b9703f4bc02dbce2db19",
            "Gateway": "172.17.0.1",
            "GlobalIPv6Address": "",
            "GlobalIPv6PrefixLen": 0,
            "IPAddress": "172.17.0.2",
            "IPPrefixLen": 16,
            "IPv6Gateway": "",
            "MacAddress": "02:42:ac:11:00:02",
            "Networks": {
                "bridge": {
                    "IPAMConfig": null,
                    "Links": null,
                    "Aliases": null,
                    "NetworkID": "904ad90e4495dc53ac3d14081e380a3cb7550f16a91291e64d71b7e4f2ece2c6",
                    "EndpointID": "bcc8bddd53da2d99726adcbdd2f2a408a7ce51476e72b9703f4bc02dbce2db19",
                    "Gateway": "172.17.0.1",
                    "IPAddress": "172.17.0.2",
                    "IPPrefixLen": 16,
                    "IPv6Gateway": "",
                    "GlobalIPv6Address": "",
                    "GlobalIPv6PrefixLen": 0,
                    "MacAddress": "02:42:ac:11:00:02",
                    "DriverOpts": null
                }
            }
        }
    }
]

进入当前正在运行的容器

# 通常容器都是使用后台方式运行的,需要进行容器,修改一些配置

docker exec -it 容器id /bin/bash  # 进入容器后开启一个新的终端,可以在里面操作
# 或者
docker attah 容器id  # 进入容器正在执行当前的终端,不会启动新的进程

从容器内拷贝文件到主机上

docker cp 容器id:容器内路径 目的主机路径

在这里插入图片描述

4. 部署Nginx

  1. 搜索镜像
docker search nginx
  1. 下载镜像
docker pull nginx
  1. 创建容器
docker run -d --name nginx01 -p 3344:80 nginx   # 3344为宿主机端口  80为容器内部端口
  1. 本机测试
curl localhost:3344
  1. 公网测试

记得要开启端口号

  1. 进入容器
[root@summer home]# docker exec -it 876c3d0041e7 /bin/bash
root@876c3d0041e7:/# ls
bin   dev		   docker-entrypoint.sh  home  lib64  mnt  proc  run   srv  tmp  var
boot  docker-entrypoint.d  etc			 lib   media  opt  root  sbin  sys  usr
root@876c3d0041e7:/# whereis nginx
nginx: /usr/sbin/nginx /usr/lib/nginx /etc/nginx /usr/share/nginx

5. 部署Tomcat

官方使用：

docker run -it --rm tomcat:9.0  # --rm的意思是运行这个容器,容器就会自动删除,一般用于测试

# 下载再启动
docker pull tomcat:9.0
docker images
docker run -d --name tomcat01 -p 3344:8080 tomcat:9.0
# 使用公网进行访问 测试显示404 
# 进入容器
[root@summer home]# docker exec -it tomcat01 /bin/bash
root@b6deac68e50c:/usr/local/tomcat# ls
BUILDING.txt	 NOTICE		RUNNING.txt  lib	     temp	   work
CONTRIBUTING.md  README.md	bin	     logs	     webapps
LICENSE		 RELEASE-NOTES	conf	     native-jni-lib  webapps.dist
root@b6deac68e50c:/usr/local/tomcat# cd webapps
root@b6deac68e50c:/usr/local/tomcat/webapps# ls
root@b6deac68e50c:/usr/local/tomcat/webapps# 

# 发现tomcat的webapps下是空的   阿里云镜像的原因,默认是最小的镜像,将不必要的都剔除掉,保证最小可运行的环境


root@b6deac68e50c:/usr/local/tomcat/webapps# cp -r webapps.dist/* webapps
# 可以将webapps.dist下的所有文件复制到webapps  再次用公网ip+8080 访问就可见到主页

6. 部署ES+Kibana

# ES 暴露的端口很多
# ES 十分耗内存
# ES 需要外部挂载


# 启动 elasticsearch
docker run -d --name elasticsearch  -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch:7.6.2
# 启动之后特别卡  非常耗内存

# docker stats 容器id 查看当前资源消耗

# 增加内存限制

docker run -d --name elasticsearch  -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" -e ES_JAVA_OPTS="-Xms64m -Xmx512m" elasticsearch:7.6.2 

docker stats e3713b387773[root@summer ~]# curl localhost:9200
{
  "name" : "e3713b387773",
  "cluster_name" : "docker-cluster",
  "cluster_uuid" : "Hu42xgj5SUCTaZWYd-zlAA",
  "version" : {
    "number" : "7.6.2",
    "build_flavor" : "default",
    "build_type" : "docker",
    "build_hash" : "ef48eb35cf30adf4db14086e8aabd07ef6fb113f",
    "build_date" : "2020-03-26T06:34:37.794943Z",
    "build_snapshot" : false,
    "lucene_version" : "8.4.0",
    "minimum_wire_compatibility_version" : "6.8.0",
    "minimum_index_compatibility_version" : "6.0.0-beta1"
  },
  "tagline" : "You Know, for Search"
}

使用Kibana 连接 ES 需要用到docker网络 怎么连接？

7. 可视化面板

portainer

docker的图形化界面工具，提供后台面板供操作

[root@summer ~]# docker run -d -p 8088:9000 --restart=always -v /var/run/docker.sock:/var/run/docker.sock --privileged=true portainer/portainer-ce
Unable to find image 'portainer/portainer-ce:latest' locally
latest: Pulling from portainer/portainer-ce
0ea73420e2bb: Pull complete 
c367f59be2e1: Pull complete 
b71b88d796e2: Pull complete 
Digest: sha256:4f126c5114b63e9d1bceb4b368944d14323329a9a0d4e7bb7eb53c9b7435d498
Status: Downloaded newer image for portainer/portainer-ce:latest
6e2bfd92ba15f2d3b238dacbd2e4c27f060cfc37e073b752494bc5dc8cf0d9f9

访问外网地址+8088

第一次需要设置密码，这里密码为12345678

8. 镜像原理

镜像是一种轻量级、可执行的独立软件包，用来打包软件运行环境和基于环境开发的软件，包含运行某个软件所需的内容，例代码，运行时的库、环境变量和配置文件。

UnionFS (联合文件系统)

UnionFS是一种分层、轻量级并且高性能的文件系统，支持对文件系统的修改作为一次提交来一层一层的叠加，同时可以将不同目录挂载到同一个虚拟文件系统下。

特性：一次同时加载多个文件系统，但从外边来看，只能看到一个文件系统，联合加载会把各层文件系统叠加起来，最终这个文件系统会包含所有底层的文件和目录。

docker镜像加载原理

docker的镜像实际上由一层一层的文件系统组成，这种层级的文件系统UnionFS。

bootfs(boot file system)主要包含bootloader和kernel，bootloader主要是引导加载kernel，Linux刚启动时会加载bootfs文件系统，在Docker镜像的最底层是bootfs。这一层与典型的Linux/Unix系统是一样的，包含boot加载器和内核。当bootfs加载完成之后整个内核就都在内存中了，此时内存的使用权已由bootfs转交给内核，此时系统也会卸载bootfs。

rootfs (root file system) ，在bootfs之上。包含的就是典型Linux系统中的/dev, /proc, /bin, /etc等标准目录和文件。rootfs就是各种不同的操作系统发行版，比如Ubuntu , Centos等等。

对于一个精简的OS，rootfs可以很小，只需要包含最基本的命令、工具和程序库就可以，因为底层直接使用主机的kernel，所以自己只需提供rootfs即可。

分层理解

在这里插入图片描述

为什么采用分层结构？最大的好处就是可以资源共享，例如多个镜像都是从相同的Base镜像构建的，宿主机只需在磁盘中保留一份base镜像，同时内存中也只需加载一份base镜像，这样就可以为所有的容器服务。

特点

docker镜像都只是可读的，当容器启动后，一个新的可写层被加载到镜像的底部，这一层就是容器层，容器之下的层都是镜像层

例如下载了一个tomcat的镜像，运行该镜像创建一个容器，该容器就在镜像的上层，只需修改容器层中的内容，之后若想打包就可以将容器层和镜像层一起打包为一个新镜像。

在这里插入图片描述

提交自定义镜像 commit 镜像

docker commit 提交容器成为一个新的副本

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

测试

# 1.启动创建容器
docker run -it -p 8080:8080 tomcat:9.0


# 2.重新运行一个窗口，进入容器
docker exec -it 3004a46fc66c /bin/bash
# 3.将webapp.dist目录下的文件复制到webapp下
cp -r webapps.dist/* webapps


root@3004a46fc66c:/usr/local/tomcat/webapps# exit
exit
[root@summer ~]# docker ps
CONTAINER ID   IMAGE        COMMAND             CREATED         STATUS         PORTS                    NAMES
3004a46fc66c   tomcat:9.0   "catalina.sh run"   6 minutes ago   Up 6 minutes   0.0.0.0:8080->8080/tcp   vigilant_pascal
# 4.commit新的tomcat
[root@summer ~]# docker commit -a="summer" -m="add webapps app" 3004a46fc66c tomcat1.0
sha256:c3781884a5cf6f6eab3843fd3c203049639097eae10fb359d9f88d6fdf440a7c
[root@summer ~]# docker images
REPOSITORY               TAG       IMAGE ID       CREATED         SIZE
tomcat1.0                latest    c3781884a5cf   4 seconds ago   685MB
tomcat                   9.0       b8e65a4d736d   6 months ago    680MB

9. 容器数据卷

数据不能放在容器中，一旦容器删除，那么容器中存放的数据也会丢失，因此数据可以存贮在本地。

docker容器中产生的数据，同步到本地

卷技术就是将容器内的目录挂载到Linux上。

9.1 指定路径挂载

docker run -it -v 宿主机目录:容器内目录

# docker run -it -v 宿主机目录:容器内目录
[root@summer ~]# docker run -it -v /home/ceshi:/home centos  将宿主机的/home/ceshi 与容器的/home目录进行绑定
[root@ec3a6d6142c2 /]# ls
bin  etc   lib	  lost+found  mnt  proc  run   srv  tmp  var
dev  home  lib64  media       opt  root  sbin  sys  usr
[root@ec3a6d6142c2 /]# cd home
[root@ec3a6d6142c2 home]# ls
[root@ec3a6d6142c2 home]# touch hello  # 在容器的home目录下创建一个hello文件
[root@ec3a6d6142c2 home]# ls
hello
[root@ec3a6d6142c2 home]# exit
exit
[root@summer ~]# cd /home
[root@summer home]# ls
ceshi  jdk  nginx  springboot  test.java  tomcat  www
[root@summer home]# cd ceshi    # 可以看到在宿主机的ceshi目录下也有该文件
[root@summer ceshi]# ls
hello



[root@summer ceshi]# docker inspect ec3a6d6142c2

"Mounts": [
            {   
                "Type": "bind",           # 绑定
                "Source": "/home/ceshi",  # 宿主机地址
                "Destination": "/home",   # 容器地址
                "Mode": "",
                "RW": true,
                "Propagation": "rprivate"
            }
        ],

将容器关掉，在宿主机的目录中进行修改，只要容器存在，容器中的绑定目录会随之改变。

MySQL 同步数据

docker run -d -p 3310:3306 -v /home/mysql/conf:/etc/mysql/conf.d -v /home/
mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=root --name mysql01 mysql:5.7

-d # 后台运行
-p # 端口
-v # 数据挂在
-e # 环境配置
--name # 名字


# 启动成功之后，这样可以使用Navicat 主机为公网地址 端口为3310 用户名为root 密码为root可以连接
# 使用Navicat创建一个数据库 test之后,可以看到在宿主机和容器中都已存在

root@464a873ca54f:/var/lib/mysql# ls
auto.cnf    client-cert.pem  ib_logfile0  ibtmp1	      private_key.pem  server-key.pem
ca-key.pem  client-key.pem   ib_logfile1  mysql		      public_key.pem   sys
ca.pem	    ib_buffer_pool   ibdata1	  performance_schema  server-cert.pem  test

[root@summer data]# ls
auto.cnf    client-cert.pem  ibdata1      ibtmp1              private_key.pem  server-key.pem
ca-key.pem  client-key.pem   ib_logfile0  mysql               public_key.pem   sys
ca.pem      ib_buffer_pool   ib_logfile1  performance_schema  server-cert.pem  test

即使将容器删掉，数据在宿主机中仍然存在，这就实现了容器数据持久化技术。

9.2 具名和匿名挂载
# 匿名挂载
docker run -d -P --name nginx01 -v /etc/nginx nginx  # 没有指定宿主机的目录,只指定了容器内的目录
# 查看所有的volume的情况
[root@summer data]# docker volume ls
DRIVER    VOLUME NAME
local     3be48649f0bb81dc49d218c2803d080d6f9a601ecada40f5b7fb034885ca02d8
local     4fc1dd59fd28b60e77a8ed10063a1ca98edd212205785ae02e2f5bb9f7e07fe0
local     58f0d57232b8d1a0c0805b2daf962de347a8ef97123219d3fb41eaadaf305ffd
local     902c76226bbf780ee5bbae2a760322cd67933215b31e7e9aea5a8cda51ca5da4

# 具名挂载
docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx nginx # 没有指定宿主机的目录,只写了一个卷名
[root@summer data]# docker volume ls
DRIVER    VOLUME NAME
local     3be48649f0bb81dc49d218c2803d080d6f9a601ecada40f5b7fb034885ca02d8
local     4fc1dd59fd28b60e77a8ed10063a1ca98edd212205785ae02e2f5bb9f7e07fe0
local     58f0d57232b8d1a0c0805b2daf962de347a8ef97123219d3fb41eaadaf305ffd
local     902c76226bbf780ee5bbae2a760322cd67933215b31e7e9aea5a8cda51ca5da4
local     juming-nginx

# 没有指定目录下的卷  在该目录下  /var/lib/docker/volumes/xxxx/_data
[root@summer data]# docker volume inspect juming-nginx
[
    {
        "CreatedAt": "2022-06-23T14:52:51+08:00",
        "Driver": "local",
        "Labels": null,
        "Mountpoint": "/var/lib/docker/volumes/juming-nginx/_data",
        "Name": "juming-nginx",
        "Options": null,
        "Scope": "local"
    }
]

-v 容器内路径 		   # 匿名挂载
-v 具名:容器内路径		 # 具名挂载
-v 宿主机路径:容器内路径 # 指定路径挂载

拓展：

docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx:ro nginx # 只能读
docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx:rw nginx # 可读可写

# 如果有ro 则说明该路径下的文件只能通过宿主机来操作，容器内部无法操作
9.3 Dockerfile
[root@summer docker-test-volume]# pwd
/home/docker-test-volume
[root@summer docker-test-volume]# vim dockerfile1
[root@summer docker-test-volume]# cat dockerfile1 
FROM centos

VOLUME ["volume01","volume02"]  # 此时是匿名挂载 

CMD echo "----end----"

CMD /bin/bash

[root@summer docker-test-volume]# docker build -f dockerfile1 -t summer/centos .
Sending build context to Docker daemon  2.048kB
Step 1/4 : FROM centos
 ---> 5d0da3dc9764
Step 2/4 : VOLUME ["volume01","volume02"]
 ---> Running in 230ce724abd7
Removing intermediate container 230ce724abd7
 ---> 5cef6f3b889f
Step 3/4 : CMD echo "----end----"
 ---> Running in d6406fa71310
Removing intermediate container d6406fa71310
 ---> 0270cf09a597
Step 4/4 : CMD /bin/bash
 ---> Running in f63521eaae7e
Removing intermediate container f63521eaae7e
 ---> eaee63229e23
Successfully built eaee63229e23
Successfully tagged summer/centos:latest


[root@summer docker-test-volume]# docker images
REPOSITORY               TAG       IMAGE ID       CREATED              SIZE
summer/centos            latest    eaee63229e23   About a minute ago   231MB


# 启动自定义的镜像
[root@summer docker-test-volume]# docker run -it eaee63229e23 /bin/bash
[root@c3b3f12de6e8 /]# ls -l
total 56
......
drwxr-xr-x   2 root root 4096 Jun 23 07:22 volume01
drwxr-xr-x   2 root root 4096 Jun 23 07:22 volume02
# 可以看到创建镜像时挂载的目录，就是数据卷目录

# 在其中一个目录中创建一个文件hello1
[root@c3b3f12de6e8 /]# cd volume01
[root@c3b3f12de6e8 volume01]# touch hello1
[root@c3b3f12de6e8 volume01]# ls
hello1

# 寻找宿主机对应的目录
[root@summer home]# docker ps
CONTAINER ID   IMAGE          COMMAND       CREATED         STATUS         PORTS     NAMES
c3b3f12de6e8   eaee63229e23   "/bin/bash"   4 minutes ago   Up 4 minutes             gifted_goldstine
[root@summer home]# docker inspect c3b3f12de6e8 

"Mounts": [
            {
                "Type": "volume",
                "Name": "7b70034eb35c1db0b253fe06f3dc130daef501a668ffc672aa903668d73f1db2",
                "Source": "/var/lib/docker/volumes/7b70034eb35c1db0b253fe06f3dc130daef501a668ffc672aa903668d73f1db2/_data",
                "Destination": "volume01",
                "Driver": "local",
                "Mode": "",
                "RW": true,
                "Propagation": ""
            },
            {
                "Type": "volume",
                "Name": "fb1d4ac69f967e0ac90494dbed00a466d89da417cc771e9f117d9a6368182710",
                "Source": "/var/lib/docker/volumes/fb1d4ac69f967e0ac90494dbed00a466d89da417cc771e9f117d9a6368182710/_data",
                "Destination": "volume02",
                "Driver": "local",
                "Mode": "",
                "RW": true,
                "Propagation": ""
            }
        ],
 
[root@summer home]# cd /var/lib/docker/volumes/7b70034eb35c1db0b253fe06f3dc130daef501a668ffc672aa903668d73f1db2/_data
[root@summer _data]# ls
hello1
9.4 数据卷容器

多个centos实现数据同步

[root@summer home]# docker run -it --name centos01 summer/centos /bin/bash
[root@0f8c84e24c61 /]# ls
bin  etc   lib	  lost+found  mnt  proc  run   srv  tmp  var	   volume02
dev  home  lib64  media       opt  root  sbin  sys  usr  volume01

[root@summer home]# docker run -it --name centos02 --volumes-from centos01 summer/centos /bin/bash
# --volumes-from  相当于java的继承关系

# 在centos01容器中的volume01文件夹下创建一个docker01文件,此时在centos02容器的volume01文件夹下发现会有docker01文件
# 这就说明两个容器的volume01文件夹和volume02文件夹实现了数据绑定

[root@summer home]# docker run -it --name centos03 --volumes-from centos01 summer/centos /bin/bash
# 同样在centos03的volume01文件夹下存在docker01文件，同样如果在centos03下的volume01文件夹下下创建新文件，也会同步更新到centos01和centos02中

这样就是实现了centos01、centos02、centos03三个容器的volume01和volume02文件夹的内容同步，即使将centos01容器删掉，另外两个容器中的数据也不会丢失，可以看出并不是02和03映射01的数据，而是将01、02、03的数据同步复制。

多个MySQL实现数据同步

docker run -d -p 3310:3306 -v /etc/mysql/conf.d -v /var/lib/mysql -e MYSQL_ROOT_PASSWORD=root --name mysql01 mysql:5.7

docker run -d -p 3310:3306 -e MYSQL_ROOT_PASSWORD=root --name mysql02 --volumes-from mysql01 mysql:5.7

数据卷容器的生命周期一直持续到没有容器使用为止

10. DockerFile

10.1 简介

dockerfile是用来构建docker镜像的文件，命令参数脚本

构建步骤：

  • 编写一个dockerfile文件

  • docker build 构建成为一个镜像

  • docker run 运行镜像

  • docker push 发布镜像 docker hub 阿里云镜像仓库

10.2 构建过程

基础知识

  1. 每个保留关键字都必须是大写字母
  2. 指令从上到下执行
  3. #表示注释
  4. 每个指令都会创建提交一个新的镜像层，并提交

在这里插入图片描述

DockerFile：构建文件，定义了一切的步骤、源代码

DockerImages：通过DockerFile构建生成的镜像，最终发布和运行的产品

Docker容器：容器就是镜像运行起来提供服务的

10.3 指令
FROM 		# 基础镜像 
MAINTAINER  # 镜像是谁写的  姓名+邮箱
RUN			# 镜像构建的时候需要运行的命令
ADD			# tomcat镜像 tomcat压缩包
WORKDIR		# 镜像的工作目录
VOLUME		# 挂载的目录
EXPOSE		# 保留端口配置
CMD			# 指容器启动要执行的命令 只有最后一个生效，可被替代
ENTRYPOINT  # 指容器启动要执行的命令 可以追加命令
ONBUILD     # 当构建一个被继承DockerFile 这个时候就会运行ONBUILD的指令  触发指令
COPY        # 类似add命令 将文件拷贝到镜像中
ENV			# 构建的时候设置环境变量
10.4 构建自己的centos
[root@summer dockerfile]# vim mydockerfile
# 1.编写Dockerfile的文件
[root@summer dockerfile]# cat mydockerfile 
FROM centos:centos7 
MAINTAINER summer<1234567789@qq.com>

ENV MYPATH /usr/local
WORKDIR $MYPATH
 
RUN yum -y install vim
RUN yum -y install net-tools

EXPOSE 80

CMD echo $MYPATH
CMD echo "---end---"
CMD /bin/bash 


# 2.通过这个文件构建镜像     docker build -f dockerfile文件路径 -t 镜像名:[tag]
[root@summer dockerfile]# docker build -f mydockerfile -t mycentos:0.1 .
[root@summer dockerfile]# docker images
REPOSITORY               TAG       IMAGE ID       CREATED         SIZE
mycentos                 0.1       ecbf11665a8b   6 seconds ago   601MB

# 3.测试
[root@192209b18180 local]# ifconfig
[root@192209b18180 local]# vim test

可以查看镜像的构建历史

[root@summer dockerfile]# docker history ecbf11665a8b
IMAGE          CREATED          CREATED BY                                      SIZE      COMMENT
ecbf11665a8b   8 minutes ago    /bin/sh -c #(nop)  CMD ["/bin/sh" "-c" "/bin…   0B        
d47e5677ae2e   8 minutes ago    /bin/sh -c #(nop)  CMD ["/bin/sh" "-c" "echo…   0B        
cc5070c77dd6   9 minutes ago    /bin/sh -c #(nop)  CMD ["/bin/sh" "-c" "echo…   0B        
17b87c50f41f   9 minutes ago    /bin/sh -c #(nop)  EXPOSE 80                    0B        
144f58dbe64a   9 minutes ago    /bin/sh -c yum -y install net-tools             171MB     
0a4461f757a5   9 minutes ago    /bin/sh -c yum -y install vim                   226MB     
0a00c02cbd9c   10 minutes ago   /bin/sh -c #(nop) WORKDIR /usr/local            0B        
21d36ab390e0   10 minutes ago   /bin/sh -c #(nop)  ENV MYPATH=/usr/local        0B        
81ab9de242c5   10 minutes ago   /bin/sh -c #(nop)  MAINTAINER summer<1234567…   0B        
eeb6ee3f44bd   9 months ago     /bin/sh -c #(nop)  CMD ["/bin/bash"]            0B        
<missing>      9 months ago     /bin/sh -c #(nop)  LABEL org.label-schema.sc…   0B        
<missing>      9 months ago     /bin/sh -c #(nop) ADD file:b3ebbe8bd304723d4…   204MB

CMD 和 ENTRYPOINT 的区别

CMD			# 指容器启动要执行的命令 只有最后一个生效，可被替代
ENTRYPOINT  # 指容器启动要执行的命令 可以追加命令

测试CMD

# 编写dockerfile文件
vim dockerfile-cmd-test
FROM centos
CMD ["ls","-a"]
# 构建镜像
docker build -f dockerfile-cmd-test -t cmdtest .
# 运行镜像
docker run xxxx  
打印 ls -a 的内容


# 运行 
docker run xxxx -l
# 想要显示 ls -al  但是出错,原因是CMD的情况下,-l会替换原来的CMD ["ls","-a"],-l不是命令,所以报错

测试ENTRYPOINT

# 编写dockersfile文件
vim docker-entrypopint
FROM centos
ENTRYPOINT ["ls","-a"]

# 构建镜像
docker build -f docker-entrypoint -t dockerpoint .
# 运行镜像
docker run xxx -l  #可以执行成功
10.5 构建自己的tomcat

  1. 准备镜像文件 tomcat压缩包 jdk压缩包

    apache-tomcat-9.0.64.tar.gz jdk-8u333-linux-x64.tar.gz

  2. 编写dockerfile文件 官方命名 Dockerfile，使用之后就不用在build时加 -f 参数

FROM centos:centos7
MAINTAINER summer<123456789@qq.com>

ADD jdk-8u333-linux-x64.tar.gz /usr/local/  # 此处的意思是将两个压缩包放到容器的/usr/local目录下
ADD apache-tomcat-9.0.64.tar.gz /usr/local/

RUN yum -y install vim 

ENV MYPATH /usr/local
WORKDIR $MYPATH

ENV JAVA_HOME /usr/local/jdk1.8.0_333
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tool.jar
ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.64
ENV CATALINA_BASH /usr/local/apache-tomcat-9.0.64
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin

EXPOSE 8080

CMD /usr/local/apache-tomcat-9.0.64/bin/startup.sh && tail -F /usr/local/apache-tomcat-9.0.64/logs/catalina.out
  1. 构建镜像
[root@summer docker-tomcat]# docker build -t mytomcat .


[root@summer docker-tomcat]# docker images
REPOSITORY               TAG       IMAGE ID       CREATED             SIZE
mytomcat                 latest    ea2a0fdb3a3d   9 seconds ago       815MB
  1. 运行
[root@summer docker-tomcat]# docker run -d -p 3344:8080 --name mytomcat -v /home/tomcat/test:/usr/local/apache-tomcat-9.0.64/webapps/test -v /home/tomcat/logs:/usr/local/apache-tomcat-9.0.64/logs mytomcat
  1. 测试
curl localhost:3344  # 访问成功

# 外网ip+3344 访问成功

[root@summer docker-tomcat]# docker exec -it 4e2a2e681c91 /bin/bash
[root@4e2a2e681c91 local]# ls
aegis                 bin  games    jdk1.8.0_333  lib64    sbin   src
apache-tomcat-9.0.64  etc  include  lib           libexec  share
  1. 发布项目

在本地的test目录下创建一个WEB-INF目录，在该目录下创建一个web.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns="http://java.sun.com/xml/ns/javaee"
    xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
    id="WebApp_ID" version="2.5">
    
</web-app>

然后与WEB-INF同级下新建一个index.html文件

<%@ page language="java" contentType="text/html; charset=utf-8"
    pageEncoding="utf-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>登录</title>
</head>
<body>
	<form action="LoginServlet" method="post">
		<table>
			<tr>
				<td>账号</td>
				<td><input type="text" name="username"></td>
			</tr>
			<tr>
				<td>密码</td>
				<td><input type="password" name="password"></td>
			</tr>
			<tr>
				<td><input type="submit" value="登录"></td>
			</tr>
		</table>
	</form>
</body>
</html>

访问 公网ip+3344/test

11. 发布镜像

11.1 docker hub
  1. 注册自己的账号
  2. 在服务器提交自己的镜像
[root@summer home]# docker login -usummer1245


[root@summer home]# docker push summer1245/mytomcat:1.0
The push refers to repository [docker.io/summer1245/mytomcat]
An image does not exist locally with the tag: summer1245/mytomcat
# 报以上错误,给镜像修改镜像名字
[root@summer home]# docker tag 90a99e710602 summer1245/mytomcat:1.0
[root@summer home]# docker push summer1245/mytomcat:1.0
11.2 阿里云镜像
  1. 登录阿里云
  2. 容器镜像服务
  3. 在实例列表创建个人实例
  4. 创建命名空间
  5. 创建镜像仓库 选择本地镜像
$ docker login --username=aliyun6391782142 registry.cn-beijing.aliyuncs.com
$ docker tag [ImageId] registry.cn-beijing.aliyuncs.com/summer-images/hhhhh:[镜像版本号]
$ docker push registry.cn-beijing.aliyuncs.com/summer-images/hhhhh:[镜像版本号]

12. Docker网络

12.1 Docker0
[root@summer ~]# ip addr
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP group default qlen 1000
    link/ether 00:16:3e:03:81:69 brd ff:ff:ff:ff:ff:ff
    inet 172.28.251.25/20 brd 172.28.255.255 scope global dynamic eth0
       valid_lft 315019035sec preferred_lft 315019035sec
3: docker0: <NO-CARRIER,BROADCAST,MULTICAST,UP> mtu 1500 qdisc noqueue state DOWN group default 
    link/ether 02:42:5f:ee:cc:dc brd ff:ff:ff:ff:ff:ff
    inet 172.17.0.1/16 brd 172.17.255.255 scope global docker0
       valid_lft forever preferred_lft forever
# lo       本机回环地址     127.0.0.1
# eth0     阿里云内网地址   172.28.251.25
# docker0  docker0地址    172.17.0.1

# 测试 创建一个tomcat的容器,容器外该如何访问容器内？
[root@summer ~]# docker run -d -P --name tomcat01 tomcat:7.0
[root@summer ~]# docker exec -it tomcat01 ip addr
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
146: eth0@if147: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default 
    link/ether 02:42:ac:11:00:02 brd ff:ff:ff:ff:ff:ff link-netnsid 0
    inet 172.17.0.2/16 brd 172.17.255.255 scope global eth0
       valid_lft forever preferred_lft forever
       
# 测试 直接使用宿主机 ping 容器的docker0地址  发现可以直接ping
[root@summer ~]# ping 172.17.0.2
PING 172.17.0.2 (172.17.0.2) 56(84) bytes of data.
64 bytes from 172.17.0.2: icmp_seq=1 ttl=64 time=0.065 ms
64 bytes from 172.17.0.2: icmp_seq=2 ttl=64 time=0.050 ms
64 bytes from 172.17.0.2: icmp_seq=3 ttl=64 time=0.047 ms

每启动一个docker容器，docker就会给每个容器分配一个IP，只要安装了docker，就会有一个docker0，采用桥接模式，使用的技术是

evth-pair技术

再次测试ip addr

[root@summer ~]# ip addr
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP group default qlen 1000
    link/ether 00:16:3e:03:81:69 brd ff:ff:ff:ff:ff:ff
    inet 172.28.251.25/20 brd 172.28.255.255 scope global dynamic eth0
       valid_lft 315017326sec preferred_lft 315017326sec
3: docker0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default 
    link/ether 02:42:5f:ee:cc:dc brd ff:ff:ff:ff:ff:ff
    inet 172.17.0.1/16 brd 172.17.255.255 scope global docker0
       valid_lft forever preferred_lft forever
# 这就是刚才启动的容器
147: vethddb9267@if146: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue master docker0 state UP group default 
    link/ether 92:c5:87:d4:f6:4b brd ff:ff:ff:ff:ff:ff link-netnsid 0

再次启动一个容器，发现又多了一个网卡

# 宿主机
149: vethd7c0d22@if148: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue master docker0 state UP group default 
    link/ether 0e:d6:43:08:c8:53 brd ff:ff:ff:ff:ff:ff link-netnsid 1

# 容器
[root@summer ~]# docker exec -it tomcat02 ip addr
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
148: eth0@if149: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default 
    link/ether 02:42:ac:11:00:03 brd ff:ff:ff:ff:ff:ff link-netnsid 0
    inet 172.17.0.3/16 brd 172.17.255.255 scope global eth0
       valid_lft forever preferred_lft forever
       
       
# 可以发现,容器的网卡都是成对的
# evth-pair 就是一对虚拟设备接口,成对出现,一端连接协议,一端彼此相连
# 因为有这种特性,evth-pair 充当一个桥梁,连接各种虚拟网络设备的

# 进入tomcat02,来ping tomcat01
root@65aba89c45fe:/usr/local/tomcat# ping 172.17.0.2
PING 172.17.0.2 (172.17.0.2) 56(84) bytes of data.
64 bytes from 172.17.0.2: icmp_seq=1 ttl=64 time=0.091 ms
64 bytes from 172.17.0.2: icmp_seq=2 ttl=64 time=0.064 ms
64 bytes from 172.17.0.2: icmp_seq=3 ttl=64 time=0.070 ms
64 bytes from 172.17.0.2: icmp_seq=4 ttl=64 time=0.068 ms


# 结论:容器和容器之间可以相互ping通的  只不过要ping的是ip

在这里插入图片描述

结论：tomcat01 和 tomcat02 是公用的路由器，docker0

所有的容器不指定网络的情况下，都是docker0路由的，docker会给容器分配一个默认的可用IP

docker中的所有的网络接口都是虚拟的，虚拟的转发效率高

12.2 --link
[root@summer ~]# docker exec -it tomcat01 ping tomcat02  # 现在ping的是容器名字
# 无法ping通

# 再创建一个容器 tomcat03
[root@summer ~]# docker run -d -P --name tomcat03 --link tomcat02 tomcat:7.0

# tomcat03 可以ping通 tomca02
[root@summer ~]# docker exec -it tomcat03 ping tomcat02
PING tomcat02 (172.17.0.3) 56(84) bytes of data.
64 bytes from tomcat02 (172.17.0.3): icmp_seq=1 ttl=64 time=0.096 ms
64 bytes from tomcat02 (172.17.0.3): icmp_seq=2 ttl=64 time=0.065 ms
64 bytes from tomcat02 (172.17.0.3): icmp_seq=3 ttl=64 time=0.065 ms
64 bytes from tomcat02 (172.17.0.3): icmp_seq=4 ttl=64 time=0.066 ms

# 当反向ping的时候却不通
[root@summer ~]# docker exec -it tomcat02 ping tomcat03
ping: tomcat03: Name or service not known


[root@summer ~]# docker network ls
NETWORK ID     NAME      DRIVER    SCOPE
904ad90e4495   bridge    bridge    local
a223dbad46fd   host      host      local
8e9ea4805c4d   none      null      local
[root@summer ~]# docker network inspect 904ad90e4495 
[
    {
        "Name": "bridge",
        "Id": "904ad90e4495dc53ac3d14081e380a3cb7550f16a91291e64d71b7e4f2ece2c6",
        "Created": "2022-06-21T10:38:23.234856104+08:00",
        "Scope": "local",
        "Driver": "bridge",
        "EnableIPv6": false,
        "IPAM": {
            "Driver": "default",
            "Options": null,
            "Config": [
                {
                    "Subnet": "172.17.0.0/16",
                    "Gateway": "172.17.0.1"
                }
            ]
        },
        "Internal": false,
        "Attachable": false,
        "Ingress": false,
        "ConfigFrom": {
            "Network": ""
        },
        "ConfigOnly": false,
        "Containers": {
            "5a4cdac3dec4650e700ce526999acd3f5c0524a24d215c4b989b3de549ed92ad": {
                "Name": "tomcat03",
                "EndpointID": "e4c91318686e4a1abbe0548990098541517ea00da2118b18f8fdad476c4b43ae",
                "MacAddress": "02:42:ac:11:00:04",
                "IPv4Address": "172.17.0.4/16",
                "IPv6Address": ""
            },
            "b30f0e0fe72d1481fab62c2f21b276a3d6156ddf3af9153420cd12d1bac27ec5": {
                "Name": "tomcat02",
                "EndpointID": "43718b1174788805b6fc380e32c763d2a133f40a2f00164f807b455fa80d5ba2",
                "MacAddress": "02:42:ac:11:00:03",
                "IPv4Address": "172.17.0.3/16",
                "IPv6Address": ""
            },
            "ded5c2e9f0e6d4ab91824bf03d8ad62a2ad0b4c074801d6a7c68c7c25b5f71fd": {
                "Name": "tomcat01",
                "EndpointID": "ad37d0c504839908ec5314e1a9170e0f07b2efd7481ac68b3d6caffd59097984",
                "MacAddress": "02:42:ac:11:00:02",
                "IPv4Address": "172.17.0.2/16",
                "IPv6Address": ""
            }
        },
        "Options": {
            "com.docker.network.bridge.default_bridge": "true",
            "com.docker.network.bridge.enable_icc": "true",
            "com.docker.network.bridge.enable_ip_masquerade": "true",
            "com.docker.network.bridge.host_binding_ipv4": "0.0.0.0",
            "com.docker.network.bridge.name": "docker0",
            "com.docker.network.driver.mtu": "1500"
        },
        "Labels": {}
    }
]

查看tomcat03的etc/hosts目录

[root@summer ~]# docker exec -it tomcat03 cat /etc/hosts
127.0.0.1	localhost
::1	localhost ip6-localhost ip6-loopback
fe00::0	ip6-localnet
ff00::0	ip6-mcastprefix
ff02::1	ip6-allnodes
ff02::2	ip6-allrouters
172.17.0.3	tomcat02 b30f0e0fe72d   # 发现直接将tomcat02配置到了tomcat03的hosts文件,所以使用tomcat03可以直接ping通tomcat02,但是tomcat02的hosts文件中没有配置,所以无法ping通
172.17.0.4	5a4cdac3dec4

–link 的本质就是就是在hosts文件中添加了地址映射。

docker0不推荐使用，因为它不支持容器名连接访问，采用自定义网络

12.3 自定义网络
# 查看所有的docker网路
[root@summer ~]# docker network ls
NETWORK ID     NAME      DRIVER    SCOPE
904ad90e4495   bridge    bridge    local
a223dbad46fd   host      host      local
8e9ea4805c4d   none      null      local

网络模式

  • bridge：桥接模式 默认

  • none：不配置网络

  • host：和宿主机共享网络

  • container：容器内网络连通 局限性大

测试

# 之前的启动命令,写完整的话就是下面写法, 默认添加 --net bridge 这个就是docker0
[root@summer ~]# docker run -d -P --name tomcat01  tomcat:7.0     
[root@summer ~]# docker run -d -P --name tomcat01 --net bridge tomcat:7.0  等价

# docker0特点：默认，域名不能访问，--link可以打通连接 当时相对麻烦

自定义网络

[root@summer ~]# docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet
d4565504978280143480a644aa7417e9cf570664ac2560c3a9018bc79bce8f87
[root@summer ~]# docker network ls
NETWORK ID     NAME      DRIVER    SCOPE
904ad90e4495   bridge    bridge    local
a223dbad46fd   host      host      local
d45655049782   mynet     bridge    local
8e9ea4805c4d   none      null      local
[root@summer ~]#

启动两个容器

docker run -d -P --name tomcat-net-01 --net mynet tomcat:7.0
docker run -d -P --name tomcat-net-02 --net mynet tomcat:7.0

# 查看自己创建的网络
[root@summer ~]# docker inspect mynet
[
    {
        "Name": "mynet",
        "Id": "d4565504978280143480a644aa7417e9cf570664ac2560c3a9018bc79bce8f87",
        "Created": "2022-06-24T14:46:18.524200452+08:00",
        "Scope": "local",
        "Driver": "bridge",
        "EnableIPv6": false,
        "IPAM": {
            "Driver": "default",
            "Options": {},
            "Config": [
                {
                    "Subnet": "192.168.0.0/16",
                    "Gateway": "192.168.0.1"
                }
            ]
        },
        "Internal": false,
        "Attachable": false,
        "Ingress": false,
        "ConfigFrom": {
            "Network": ""
        },
        "ConfigOnly": false,
        "Containers": {
            "2a52adb726cc8c54907365b35be678cf9a4c4e1d52a90cf3bf99ad6cd7aa62eb": {
                "Name": "tomcat-net-02",
                "EndpointID": "aca5f4b8d597e78e655f54f40e676172542b5fa7fc0d54d0aacfdcbe6ac4f535",
                "MacAddress": "02:42:c0:a8:00:03",
                "IPv4Address": "192.168.0.3/16",
                "IPv6Address": ""
            },
            "a01207bf6a5757bc02b0c4c45d5f48eee50c3ab2f79a2ebf229313a11d7297f4": {
                "Name": "tomcat-net-01",
                "EndpointID": "1c074e453cac71671b1ae067a0b3738f2ef1249cfe98652679390b8de28a5d4b",
                "MacAddress": "02:42:c0:a8:00:02",
                "IPv4Address": "192.168.0.2/16",
                "IPv6Address": ""
            }
        },
        "Options": {},
        "Labels": {}
    }
]

# 再次测试ping连接  直接使用名字进行ping  发现已经可以ping通了
[root@summer ~]# docker exec -it tomcat-net-01 ping tomcat-net-02
PING tomcat-net-02 (192.168.0.3) 56(84) bytes of data.
64 bytes from tomcat-net-02.mynet (192.168.0.3): icmp_seq=1 ttl=64 time=0.072 ms
64 bytes from tomcat-net-02.mynet (192.168.0.3): icmp_seq=2 ttl=64 time=0.065 ms

结论：自定义网络 docker已经维护好了所有的对应关系，推荐使用这样的方式。

12.4 网络连通

直接使用tomcat-01 ping tomcat-net-01 发现直接ping不通，进行以下操作，将容器与mynet连接

在这里插入图片描述

连接之后，tomcat01 就放到了mynet网络下 实现了一个容器两个ip

[root@summer ~]# docker network connect mynet tomcat01
[root@summer ~]# docker network inspect mynet
[
    {
        "Name": "mynet",
        "Id": "d4565504978280143480a644aa7417e9cf570664ac2560c3a9018bc79bce8f87",
        "Created": "2022-06-24T14:46:18.524200452+08:00",
        "Scope": "local",
        "Driver": "bridge",
        "EnableIPv6": false,
        "IPAM": {
            "Driver": "default",
            "Options": {},
            "Config": [
                {
                    "Subnet": "192.168.0.0/16",
                    "Gateway": "192.168.0.1"
                }
            ]
        },
        "Internal": false,
        "Attachable": false,
        "Ingress": false,
        "ConfigFrom": {
            "Network": ""
        },
        "ConfigOnly": false,
        "Containers": {
            "2a52adb726cc8c54907365b35be678cf9a4c4e1d52a90cf3bf99ad6cd7aa62eb": {
                "Name": "tomcat-net-02",
                "EndpointID": "aca5f4b8d597e78e655f54f40e676172542b5fa7fc0d54d0aacfdcbe6ac4f535",
                "MacAddress": "02:42:c0:a8:00:03",
                "IPv4Address": "192.168.0.3/16",
                "IPv6Address": ""
            },
            "a01207bf6a5757bc02b0c4c45d5f48eee50c3ab2f79a2ebf229313a11d7297f4": {
                "Name": "tomcat-net-01",
                "EndpointID": "1c074e453cac71671b1ae067a0b3738f2ef1249cfe98652679390b8de28a5d4b",
                "MacAddress": "02:42:c0:a8:00:02",
                "IPv4Address": "192.168.0.2/16",
                "IPv6Address": ""
            },
            "d180d689e711699a1e902ab667c052c44893df169689a5ed593d0a9e72f964a6": {
                "Name": "tomcat01",
                "EndpointID": "ba1d7d11d0a1b75d991dde2d8a9b2e74e2d5161ce3f64006874d50ea855e5037",
                "MacAddress": "02:42:c0:a8:00:04",
                "IPv4Address": "192.168.0.4/16",
                "IPv6Address": ""
            }
        },
        "Options": {},
        "Labels": {}
    }
]


# 连接之后，再次测试，可以ping通了
[root@summer ~]# docker exec -it tomcat01 ping tomcat-net-01
PING tomcat-net-01 (192.168.0.2) 56(84) bytes of data.
64 bytes from tomcat-net-01.mynet (192.168.0.2): icmp_seq=1 ttl=64 time=0.076 ms
64 bytes from tomcat-net-01.mynet (192.168.0.2): icmp_seq=2 ttl=64 time=0.065 ms
64 bytes from tomcat-net-01.mynet (192.168.0.2): icmp_seq=3 ttl=64 time=0.059 ms
64 bytes from tomcat-net-01.mynet (192.168.0.2): icmp_seq=4 ttl=64 time=0.062 ms

# tomcat02 因为没有配置，所以不可能ping通mynet下的容器

13. 部署Redis集群

搭建三主三从集群，模拟其中一个主服务器瘫痪，从服务器是否代替主服务器

# 创建网卡
[root@summer1245 ~]# docker network create redis --subnet 172.38.0.0/16
34a13cf41a8865e7b706dc7b52ab351621e723db2b2843da93146f82e327d290
[root@summer1245 ~]# docker network ls
NETWORK ID     NAME      DRIVER    SCOPE
951192152cbd   bridge    bridge    local
5eda922715e1   host      host      local
843954fdae13   none      null      local
34a13cf41a88   redis     bridge    local


# 通过脚本创建六个reids配置
for port in $(seq 1 6); \
do \
mkdir -p /mydata/redis/node-${port}/conf
touch /mydata/redis/node-${port}/conf/redis.conf
cat << EOF >/mydata/redis/node-${port}/conf/redis.conf
port 6379 
bind 0.0.0.0
cluster-enabled yes 
cluster-config-file nodes.conf
cluster-node-timeout 5000
cluster-announce-ip 172.38.0.1${port}
cluster-announce-port 6379
cluster-announce-bus-port 16379
appendonly yes
EOF
done

# 1
docker run -p 6371:6379 -p 16371:16379 --name redis-01 \
-v /mydata/redis/node-1/data:/data \
-v /mydata/redis/node-1/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.11 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf
# 2
docker run -p 6372:6379 -p 16372:16379 --name redis-02 \
-v /mydata/redis/node-2/data:/data \
-v /mydata/redis/node-2/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.12 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf
# 3
docker run -p 6373:6379 -p 16373:16379 --name redis-03 \
-v /mydata/redis/node-3/data:/data \
-v /mydata/redis/node-3/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.13 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf
# 4
docker run -p 6374:6379 -p 16374:16379 --name redis-04 \
-v /mydata/redis/node-4/data:/data \
-v /mydata/redis/node-4/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.14 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf
# 5
docker run -p 6375:6379 -p 16375:16379 --name redis-05 \
-v /mydata/redis/node-5/data:/data \
-v /mydata/redis/node-5/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.15 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf
# 6
docker run -p 6376:6379 -p 16376:16379 --name redis-06 \
-v /mydata/redis/node-6/data:/data \
-v /mydata/redis/node-6/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.16 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf


[root@summer1245 conf]# docker ps 
CONTAINER ID   IMAGE                    COMMAND                  CREATED              STATUS              PORTS                                              NAMES
c9204a686fb5   redis:5.0.9-alpine3.11   "docker-entrypoint.s…"   3 seconds ago        Up 2 seconds        0.0.0.0:6376->6379/tcp, 0.0.0.0:16376->16379/tcp   redis-06
d5a9cbd0aed5   redis:5.0.9-alpine3.11   "docker-entrypoint.s…"   25 seconds ago       Up 24 seconds       0.0.0.0:6375->6379/tcp, 0.0.0.0:16375->16379/tcp   redis-05
3c45384595b0   redis:5.0.9-alpine3.11   "docker-entrypoint.s…"   48 seconds ago       Up 47 seconds       0.0.0.0:6374->6379/tcp, 0.0.0.0:16374->16379/tcp   redis-04
de38fb5dbba9   redis:5.0.9-alpine3.11   "docker-entrypoint.s…"   About a minute ago   Up About a minute   0.0.0.0:6373->6379/tcp, 0.0.0.0:16373->16379/tcp   redis-03
f44491d7559c   redis:5.0.9-alpine3.11   "docker-entrypoint.s…"   2 minutes ago        Up 2 minutes        0.0.0.0:6372->6379/tcp, 0.0.0.0:16372->16379/tcp   redis-02
ad978bd5c058   redis:5.0.9-alpine3.11   "docker-entrypoint.s…"   4 minutes ago        Up 4 minutes        0.0.0.0:6371->6379/tcp, 0.0.0.0:16371->16379/tcp   redis-01


[root@summer1245 conf]# docker exec -it redis-01 /bin/sh
/data # ls
appendonly.aof  nodes.conf

# 创建redis集群
# --cluster-replicas 1 1其实代表的是一个比例，就是主节点数/从节点数的比例。
#在创建集群的时候，哪些节点是主节点呢？哪些节点是从节点呢？
# 按照命令中IP:PORT的顺序，先是3个主节点，然后是3个从节点。

/data # redis-cli --cluster create 172.38.0.11:6379 172.38.0.12:6379 172.38.0.13:6379 172.38.0.14:6379 172
.38.0.15:6379 172.38.0.16:6379 --cluster-replicas 1 

>>> Performing hash slots allocation on 6 nodes...
Master[0] -> Slots 0 - 5460
Master[1] -> Slots 5461 - 10922
Master[2] -> Slots 10923 - 16383
Adding replica 172.38.0.15:6379 to 172.38.0.11:6379
Adding replica 172.38.0.16:6379 to 172.38.0.12:6379
Adding replica 172.38.0.14:6379 to 172.38.0.13:6379
M: aff03299aab1493a52d25ef725a8a8b600d55bf2 172.38.0.11:6379
   slots:[0-5460] (5461 slots) master
M: 76fc0efeef794e74eee536ec7a39c026c883b9fc 172.38.0.12:6379
   slots:[5461-10922] (5462 slots) master
M: 7a5094cade6b7e4460bcacf98d295f7bc11b2799 172.38.0.13:6379
   slots:[10923-16383] (5461 slots) master
S: 8315e5bcfcf0ba6534a718d17bccd87400aae706 172.38.0.14:6379
   replicates 7a5094cade6b7e4460bcacf98d295f7bc11b2799
S: cbe8a91587452c77c5895961d350f919bb8d2134 172.38.0.15:6379
   replicates aff03299aab1493a52d25ef725a8a8b600d55bf2
S: e84a2d2549dbfbe1047d1947eb4d7fefb575dca9 172.38.0.16:6379
   replicates 76fc0efeef794e74eee536ec7a39c026c883b9fc
Can I set the above configuration? (type 'yes' to accept): yes
>>> Nodes configuration updated
>>> Assign a different config epoch to each node
>>> Sending CLUSTER MEET messages to join the cluster
Waiting for the cluster to join
...
>>> Performing Cluster Check (using node 172.38.0.11:6379)
M: aff03299aab1493a52d25ef725a8a8b600d55bf2 172.38.0.11:6379
   slots:[0-5460] (5461 slots) master
   1 additional replica(s)
S: cbe8a91587452c77c5895961d350f919bb8d2134 172.38.0.15:6379
   slots: (0 slots) slave
   replicates aff03299aab1493a52d25ef725a8a8b600d55bf2
S: e84a2d2549dbfbe1047d1947eb4d7fefb575dca9 172.38.0.16:6379
   slots: (0 slots) slave
   replicates 76fc0efeef794e74eee536ec7a39c026c883b9fc
M: 76fc0efeef794e74eee536ec7a39c026c883b9fc 172.38.0.12:6379
   slots:[5461-10922] (5462 slots) master
   1 additional replica(s)
M: 7a5094cade6b7e4460bcacf98d295f7bc11b2799 172.38.0.13:6379
   slots:[10923-16383] (5461 slots) master
   1 additional replica(s)
S: 8315e5bcfcf0ba6534a718d17bccd87400aae706 172.38.0.14:6379
   slots: (0 slots) slave
   replicates 7a5094cade6b7e4460bcacf98d295f7bc11b2799
[OK] All nodes agree about slots configuration.
>>> Check for open slots...
>>> Check slots coverage...
[OK] All 16384 slots covered.


# 进入集群  集群有三个 三主三从
/data # redis-cli -c
127.0.0.1:6379> cluster info
cluster_state:ok
cluster_slots_assigned:16384
cluster_slots_ok:16384
cluster_slots_pfail:0
cluster_slots_fail:0
cluster_known_nodes:6
cluster_size:3
cluster_current_epoch:6
cluster_my_epoch:1
cluster_stats_messages_ping_sent:120
cluster_stats_messages_pong_sent:126
cluster_stats_messages_sent:246
cluster_stats_messages_ping_received:121
cluster_stats_messages_pong_received:120
cluster_stats_messages_meet_received:5
cluster_stats_messages_received:246
127.0.0.1:6379> cluster nodes
cbe8a91587452c77c5895961d350f919bb8d2134 172.38.0.15:6379@16379 slave aff03299aab1493a52d25ef725a8a8b600d55bf2 0 1657938212618 5 connected
e84a2d2549dbfbe1047d1947eb4d7fefb575dca9 172.38.0.16:6379@16379 slave 76fc0efeef794e74eee536ec7a39c026c883b9fc 0 1657938213519 6 connected
76fc0efeef794e74eee536ec7a39c026c883b9fc 172.38.0.12:6379@16379 master - 0 1657938213619 2 connected 5461-10922
7a5094cade6b7e4460bcacf98d295f7bc11b2799 172.38.0.13:6379@16379 master - 0 1657938212000 3 connected 10923-16383
aff03299aab1493a52d25ef725a8a8b600d55bf2 172.38.0.11:6379@16379 myself,master - 0 1657938211000 1 connected 0-5460
8315e5bcfcf0ba6534a718d17bccd87400aae706 172.38.0.14:6379@16379 slave 7a5094cade6b7e4460bcacf98d295f7bc11b2799 0 1657938212517 4 connected

127.0.0.1:6379> set a b
-> Redirected to slot [15495] located at 172.38.0.13:6379
OK

# 现在模拟172.38.0.13:6379@16379 master 宕机
docker stop redis-03
127.0.0.1:6379> set a b
-> Redirected to slot [15495] located at 172.38.0.13:6379
OK
172.38.0.13:6379> get a  # 此时因为redis-03已经挂掉,固然得不到 ctrl+c退出
/data # redis-cli -c
127.0.0.1:6379> get a
-> Redirected to slot [15495] located at 172.38.0.14:6379  # 可以看到从节点返回
"b"
172.38.0.14:6379> cluster nodes    
# 此时可以看到 
# 172.38.0.13:6379@16379 master,fail    13挂了
# 172.38.0.14:6379@16379 myself,master  14成为主节点
76fc0efeef794e74eee536ec7a39c026c883b9fc 172.38.0.12:6379@16379 master - 0 1657938652000 2 connected 5461-10922
cbe8a91587452c77c5895961d350f919bb8d2134 172.38.0.15:6379@16379 slave aff03299aab1493a52d25ef725a8a8b600d55bf2 0 1657938652237 5 connected
e84a2d2549dbfbe1047d1947eb4d7fefb575dca9 172.38.0.16:6379@16379 slave 76fc0efeef794e74eee536ec7a39c026c883b9fc 0 1657938653238 6 connected
7a5094cade6b7e4460bcacf98d295f7bc11b2799 172.38.0.13:6379@16379 master,fail - 1657938412510 1657938411698 3 connected
8315e5bcfcf0ba6534a718d17bccd87400aae706 172.38.0.14:6379@16379 myself,master - 0 1657938652000 7 connected 10923-16383
aff03299aab1493a52d25ef725a8a8b600d55bf2 172.38.0.11:6379@16379 master - 0 1657938652738 1 connected 0-5460

14. SpringBoot打包Docker镜像

  1. 构建SpringBoot项目

    @RestController
public class TestController {
    @RequestMapping("/test")
    public String test(){
        return "hello docker";
    }
}

  2. 打包应用

    TestDocker.jar

  3. 编写dockerfile

    idea安装docker插件，创建一个Dockerfile文件，Dockerfile文件与jar包在同一目录下，之后上传到Linux上

    FROM java:8

COPY *.jar /app.jar

CMD ["--server.port=8080"]

EXPOSE 8080

ENTRYPOINT ["java","-jar","/app.jar"]

  4. 构建镜像

    [root@summer idea]# ls
Dockerfile  TestDocker.jar
[root@summer idea]# docker build -t springboot .

  5. 发布运行

    [root@summer idea]# docker run -d -p 8080:8080 --name springboot springboot

[root@summer idea]# docker ps
CONTAINER ID   IMAGE        COMMAND                  CREATED          STATUS          PORTS                     NAMES
978b35e6e29c   springboot   "java -jar /app.jar …"   36 seconds ago   Up 35 seconds   0.0.0.0:49168->8080/tcp   springboot

# 内部测试
[root@summer idea]# curl localhost:8080/test   
hello docker[root@summer idea]# 

# 外网测试
公网ip+8080/test 访问成功
伊俊客
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Docker（八）：Docker Compose（容器编排） 管理多容器应用—实战案例演示
✨ 欢迎来到【Seal ^_^ 的CSDN博客】！这里是我记录技术心得、分享经验的地方。✨
09-13 5万+
🟢 Docker（八）：Docker Compose（容器编排） 管理多容器应用—实战案例演示
Docker（十七）：Docker Swarm（集群搭建） —实现容器编排的利器
✨ 欢迎来到【Seal ^_^ 的CSDN博客】！这里是我记录技术心得、分享经验的地方。✨
03-26 2万+
🟢 Docker（十七）：Docker Swarm（集群搭建） —实现容器编排的利器
docker命令详解
m0_52789121的博客
05-01 899
镜像下载 搜索镜像 docker search +镜像名字 #docker search centos 从Docker Hub中搜索符合条件的镜像 下载镜像 #docker pull +镜像名字 #docker pull centos 查看镜像 #docker images 开启网络转发功能（默认为开启状态）若无开启，可以使用以下命令开启 #vim /etc/sysctl.conf 插入一条语句：net.ipv4.ip_forward=1 #sysctl -p // 使得语句生效
docker基本使用
JAVA拾贝
03-12 3万+
docker镜像下载： docker search centos docker pullcentos 注：如果没有指定tag，默认latest 或者： dockre pull redis:3.2 docker pull centos:7 查看镜像： docker images 删除镜像： docker rmi centos:7 运行容器： d...
docker在项目中的使用 docker常用命令
qq_42263473的博客
03-27 374
1，安装需要的软件包， yum-util 提供yum-config-manager功能，另外两个是devicemapper驱动依赖的 yum install -y yum-utils device-mapper-persistent-data lvm2 2,设置下载源为阿里云 yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo 3,安装docker yum instal
【三、Docker 命令大全】
小呆鸟blog
06-12 2079
Docker是怎么工作的Docker 为什么比VM快？所以说，新建一个容器的时候，docker不需要像虚拟机一样重新加载一个操作系统内核，避免引导。虚拟机是加载Guest OS,分钟级别的，而docker是利用宿主主机的操作系统，省略了这个复杂的过程，妙计秒级 帮助文档的地址：https://docs.docker.com/engine/reference/commandline/**docker images **查看所有本地主机上的镜像 docker search 搜索镜像 docker pull下载镜
Docker常用命令
qq_35130231的博客
01-12 390
安装  yum install –y docker 查看docker版本 docker version 启动 service docker start 查看镜像 docker images 运行镜像 docker run centos:7 sleep 1000;本地找不到镜像文件时会自动去官网下载； 下载完成后可通过docker images 再次查看; docker run
docker入门(利用docker部署web应用)
热门推荐
仰望星空
05-26 41万+
前言:本课程是在慕课网上学习 第一个docker化的java应用 课程时所做的笔记,供本人复习之用 目录 第一章 什么是docker 1.1 docker的发展史 1.2 docker国内应用史 1.3 什么是Docker 第二章 了解docker 2.1 docker思想 2.1.1 集装箱 2.1.2 标准化 2.1.3 隔离 2.2 docker解决的问题 2.2.1...
docker windows 安装包
最新发布
05-27
docker windows 安装包
4.4.4版本windows-docker.zip
05-25
【标题】4.4.4版本Windows Docker是一个针对Windows操作系统的Docker容器化平台的特定版本，它提供了在Windows上运行Linux和Windows容器的能力。这个版本可能是针对4.4.4版Docker Engine进行优化和更新的，确保了在...
Kubernetes：为容器设置启动时要执行的命令及其入参
琦彦
03-06 1万+
目录 DockerFile CMD ENTRYPOINT CMD 与 ENTRYPOINT 优先级 CMD 与 ENTRYPOINT 使用建议： 创建 Pod 时设置命令及入参 通过 shell 来执行命令 Docker 与 Kubernetes的对应关系 DockerFile CMD CMD指令在Dockerfile中仅允许一条，若出现多条，那么都会被...
while true ;do ls;sleep 1;done
drcwr的专栏
10-17 7049
while true ;do ls;sleep 1;done
Shell常用命令
啊浪的博客
10-30 1593
基本语法 while [ 1 ]; do sleep 1; ll; done # 无限循环 while [ $i -lt 10 ]; do echo $i;let "i=$i+1"; done # 有限循环 cat raw.txt | while read line; do echo $line; done # readline until [ 1 = 0 ]; do sleep ...
k8s资源对象总结(官方Java api调用)
朱夏彤的博客
08-22 1万+
pod 资源 k8s集群最小的调度单位。 一个或多个container组成的pod,同一个命名空间下的不同pod共享资源 一个pod可以运行多个container。可以通过同一个ClusterIP+不同的端口访问同个pod里面的container。 下面是个标准创建pod的yaml apiVersion: v1 kind: Pod metadata: name: nginx spec: ...
linux shell知识汇总
iris_csdn的博客
06-12 1973
方法一：利用while do循环，举例，while true;do ls;sleep 1;done 方法二：利用for循环，举例1，for((a=1;a<=10;a++));do echo "haha";done 举例2，for i in {host1,host2,host3};do ping -c 4 $i;...
Docker 基本命令
1024困不住
09-21 1590
1.搜索docker镜像 [root@node209 ~]# systemctl enable docker 2.下载docker镜像 docker pull docker.io/hello-world 3.查看docker镜像 docker images docker image ls 4.运行docker镜像 docker run IMAGE ID (镜像ID只需要...
安装docker
weixin_49088841的博客
06-13 161
1、安装所需要的软件包 先查看自己的linux版本，好像有版本要求，似乎是高于与3.0才支持docker ①安装所需要的3个软件包 yum -y install yum-utils device-mapper-persistent-data lvm2 ②设置yum源(windows也支持docker) yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo ③安装docker yum in
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值