docker技术学习流程

docker安装

安装docker（乌班图）-需要su权限

官网： Install Docker Engine on Ubuntu | Docker Documentation

帮助文档：

1.卸载旧的

apt-get remove docker docker-engine docker.io containerd runc

2.设置存储库

sudo apt-get update
 sudo apt-get install \
    ca-certificates \
    curl \
    gnupg \
    lsb-release

3.添加 Docker 的官方 GPG 密钥：

sudo mkdir -p /etc/apt/keyrings
 curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

4.用以下命令设置存储库：

echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

4.安装docker相关

ce是社区，ee是企业

apt-get install docker-ce docker-ce-cli containerd.io docker-compose-plugin

5启动docker 验证 Docker 引擎是否已正确安装。

docker run hello-world

6查看版本

docker version

显示

Client: Docker Engine - Community
 Version:           20.10.17
 API version:       1.41
 Go version:        go1.17.11
 Git commit:        100c701
 Built:             Mon Jun  6 23:02:57 2022
 OS/Arch:           linux/amd64
 Context:           default
 Experimental:      true

Server: Docker Engine - Community
 Engine:
  Version:          20.10.17
  API version:      1.41 (minimum version 1.12)
  Go version:       go1.17.11
  Git commit:       a89b842
  Built:            Mon Jun  6 23:01:03 2022
  OS/Arch:          linux/amd64
  Experimental:     false
 containerd:
  Version:          1.6.6
  GitCommit:        10c12954828e7c7c9b6e0ea9b0c02b01407d3ae1
 runc:
  Version:          1.1.2
  GitCommit:        v1.1.2-0-ga916309
 docker-init:
  Version:          0.19.0
  GitCommit:        de40ad0

8.查看image

docker images

9.修改默认的拉取镜像地址

/etc/docker/daemon.json

9.卸载docker的时候用

apt-get purge docker-ce docker-ce-cli containerd.io docker-compose-plugin

主机上的映像、容器、卷或自定义配置文件不会自动删除。要删除所有映像、容器和卷：

sudo rm -rf /var/lib/docker
 sudo rm -rf /var/lib/containerd

10.启动docker

11。停止docker

阿里云镜像加速

1.登录阿里云

2.直接搜索：镜像容器服务，点击进入控制台->镜像工具->镜像加速器

使用加速器可以提升获取Docker官方镜像的速度

加速器地址
https://cgys1rlc.mirror.aliyuncs.com

针对Docker客户端版本大于 1.10.0 的用户

您可以通过修改daemon配置文件/etc/docker/daemon.json来使用加速器

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

回顾helloword的整个流程

开始，在本机找镜像，有就用，没有就在dockerhub下载，如果dockerhub找到，下载本地运行，找不到报错。

docker常用命令

帮助命令

docker version #显示版本信息
docker info  #显示更详细信息
docker --help #帮助信息

帮助文档地址：

镜像命令：

docker images #查看所有镜像

docker images --help 


REPOSITORY    TAG       IMAGE ID       CREATED        SIZE
hello-world   latest    feb5d9fea6a5   8 months ago   13.3kB
#解释
REPOSITORY 镜像的仓库源
TAG 镜像的标签
IMAGE ID 镜像的id
CREATED 镜像的创建时间
SIZE 镜像的大小

docker search #搜索镜像

docker search mysql  #搜索mysql
docker search mysql --filter=STARS=3000 #搜索出来的大于等于3000

docker pull #下载镜像

docker pull mysql #下载mysql

docker pull 镜像名[:tag]如果不写是默认latest 
采用分层下载，联合文件系统，还有签名 ，docker.io是真实地址

docker pull mysql==docker pull docker.io/library/mysql:latest

docker images#查看镜像

docker rmi #删除镜像

docker rmi-f 删除制定的镜像
docker rmi -f id id 删除多个镜像

docker rmi-f $(docker images -aq) 递归删除全部镜像

容器命令

启动并进入容器内部

docker run -it centos /bin/bash

docker run [跟的常用命令]

--name 给容器的别名
-P 随机外部端口映射容器内部端口
-p 指定端口   比如:   -p 5000:5000 
-d 容器后台运行

退回主机

exit #容器停止退出
ctrl+p+q#不停止退出

列出所有运行中的容器

docker ps

查看运行过的容器

docker -ps -a

docker 容器运行的状态

容器状态有7种：
created（已创建）
restarting（重启中）
running（运行中）
removing（迁移中）
paused（暂停）
exited（停止）
dead（死亡）

删除容器

docker rm 容器id			#删除制定的容器 ，如果删除正在运行的容器  -f
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  #强制停止容器

后台启动容器

docker run -d  -it 镜像名

查看日志

docker logs -f -t 容器id
docker logs -t -f --tail 20   容器id查看20条

写一段脚本

while true;do echo kuangshen;sleep 1;done

查看容器进程信息

docker top 容器id
 UID                 PID                 PPID                C                   STIME               TTY                 TIME                CMD
root                18275               18256               0                   15:17               ?                   00:00:00            /bin/sh -c while true;do echo kuangshen;sleep 1;done
root                20274               18275               0                   15:31               ?                   00:00:00            /usr/bin/coreutils --coreutils-prog-shebang=sleep /usr/bin/sleep 1

查看镜像元数据

docker inspect  容器id

返回的数据

[
    {
        "Id": "345af6e6f41f2364d48cb91e66afbf50c994e9a4619e66f0af5ae6a42610ee8d",
        "Created": "2022-06-17T07:17:00.304042239Z",
        "Path": "/bin/sh",
        "Args": [
            "-c",
            "while true;do echo kuangshen;sleep 1;done"
        ],
        "State": {
            "Status": "running",
            "Running": true,
            "Paused": false,
            "Restarting": false,
            "OOMKilled": false,
            "Dead": false,
            "Pid": 18275,
            "ExitCode": 0,
            "Error": "",
            "StartedAt": "2022-06-17T07:17:00.902769488Z",
            "FinishedAt": "0001-01-01T00:00:00Z"
        },
        "Image": "sha256:5d0da3dc976460b72c77d94c8a1ad043720b0416bfc16c52c45d4847e53fadb6",
        "ResolvConfPath": "/var/lib/docker/containers/345af6e6f41f2364d48cb91e66afbf50c994e9a4619e66f0af5ae6a42610ee8d/resolv.conf",
        "HostnamePath": "/var/lib/docker/containers/345af6e6f41f2364d48cb91e66afbf50c994e9a4619e66f0af5ae6a42610ee8d/hostname",
        "HostsPath": "/var/lib/docker/containers/345af6e6f41f2364d48cb91e66afbf50c994e9a4619e66f0af5ae6a42610ee8d/hosts",
        "LogPath": "/var/lib/docker/containers/345af6e6f41f2364d48cb91e66afbf50c994e9a4619e66f0af5ae6a42610ee8d/345af6e6f41f2364d48cb91e66afbf50c994e9a4619e66f0af5ae6a42610ee8d-json.log",
        "Name": "/vigilant_panini",
        "RestartCount": 0,
        "Driver": "overlay2",
        "Platform": "linux",
        "MountLabel": "",
        "ProcessLabel": "",
        "AppArmorProfile": "docker-default",
        "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/28560556e74af8a61d99ee96d3b98c2defa0774274384161c559187b5fac0473-init/diff:/var/lib/docker/overlay2/fcb5c270854d34709d71337480437be0e69003ebca9daf39fd1796c293b88d2d/diff",
                "MergedDir": "/var/lib/docker/overlay2/28560556e74af8a61d99ee96d3b98c2defa0774274384161c559187b5fac0473/merged",
                "UpperDir": "/var/lib/docker/overlay2/28560556e74af8a61d99ee96d3b98c2defa0774274384161c559187b5fac0473/diff",
                "WorkDir": "/var/lib/docker/overlay2/28560556e74af8a61d99ee96d3b98c2defa0774274384161c559187b5fac0473/work"
            },
            "Name": "overlay2"
        },
        "Mounts": [],
        "Config": {
            "Hostname": "345af6e6f41f",
            "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 kuangshen;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": "dae4f55d59e869c39417f01d08885567f026c3682c52ef279a2d544fb30e5b63",
            "HairpinMode": false,
            "LinkLocalIPv6Address": "",
            "LinkLocalIPv6PrefixLen": 0,
            "Ports": {},
            "SandboxKey": "/var/run/docker/netns/dae4f55d59e8",
            "SecondaryIPAddresses": null,
            "SecondaryIPv6Addresses": null,
            "EndpointID": "90bf5aedb85730b19d7cfd87f940180253850909f80bd464ca857179becad8ef",
            "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": "1e8be48fc967fe40643b0e7ab45fd195182b044fc7e654375cb49dba6af35861",
                    "EndpointID": "90bf5aedb85730b19d7cfd87f940180253850909f80bd464ca857179becad8ef",
                    "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 attach  容器id  #进入容器在原来的终端，可以看到之前的代码

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

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

小结

attach  当前shell下attach连接制定运行镜像
build 通过dockerfile定制镜像
commit 提交当前容器为新的镜像
cp 从容器拷贝制定文件或者目录到宿主机
create 创建一个新的容器，不启动
diff 查看容器变化
events 从服务获取容器实时时间
exec 在已存在的容器上运行命令
export 导出容器的内容流作为一个tar归档文件对应import
history 展示一个镜像形成历史
images 列出系统当前镜像
import 从tar包中的内容创建一个新的文件系统镜像
info 显示系统的相关信息
inspect 查看容器详细信息
kill kill掉制定容器
load 从一个tar包加载一个镜像[对应一个save]
login 注册或登录一个docker服务器源
logout 从当前原服务器退出
logs 输出当前服务器日志
port 查看映射端口对应的容器源端
pause 暂停容器
ps 列出容器列表
pull 从docker源拉取镜像
push 推送到制定镜像或者docker源
restart 重启运行中的镜像
rm一处一个或多个容器
rmi 移除镜像
run 创建一个容器并运行
save 保存一个镜像为tar包[对应load]
search 在dockerhub搜镜像
start 启动镜像
stop 停止镜像
tag 给源镜像打标签
top 看容器运行进程
unpause 取消暂停容器
version 查看docker版本
wait 截取容器停止时的退出状态值
status  查看docker 状态

作业

docker-nginx

1.搜索镜像
2.下载镜像
3.启动镜像
4。运行测试:docker run -d --name nginx01 -p 3344:80 nginx

docker -tomcat

es+kibana

es需要挂载
es需要内存
es需要暴露多端口

可视化工具

portainer(先用这个)
docker图形化管理工具

Rancher(ci/cd再用)

docker镜像

提交一个自己的镜像

docker commit 提交容器成为一个新副本
docker commit -m "内容" -a "作者" 容器id 目标镜像名:[tag]

数据卷

防止容器删除后数据丢失，有了数据卷可以保存到电脑，将容器目录挂载到linux上面

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

挂载完成之后：

Mounts里就会绑定两者的关系
source 主机内地址
destination docker容器内的地址

容器内添加可以添加到外部，属于双向绑定了是

作业安装mysql挂载数据

1.查找mysql
2.下载镜像
3.启动，需要数据挂载

具名挂载和匿名挂载

不指定主机名 直接是容器内的目录： docker run -d -P --name nginx01 -v /ect/nginx nginx
所有不指定宁docker容器内的卷，在没有指定 /var/lib/docker/volumes/xxx/_data

区分具名匿名
-v 容器内路径   是匿名挂载
-v 卷名：容器内路径 具名挂载
-v /宿主机器路径::容器内路径 指定路径挂载

扩展

通过 -v 容器内路径：ro rw 改变读写权限
ro 只读
rw 可读可写
一旦设置了这个容器权限 只能通过宿主机来操作，容器内部无法操作的 ,ro说明只能通过宿主机来操作，容器内部无法操作
docker run -d -p --name nginx01 -v juming-nginx:/etc/nginx:rw nginx
docker run -d -p --name nginx01 -v juming-nginx:/etc/nginx:ro nginx

dockerfile

1编写镜像文件dockerfile1

FROM centos
VOLUME ["volume01","volume02"]
CMD echo "--------end------------"
CMD /bin/bash

1. 执行docker命令执行文件注意上全路径，结尾有个空格点

   docker build  -f  /home/player3/文档/dockerfile1.Dockerfile  -t  player3/centos   .

3.启动容器

docker run -it player3/centos /bin/bash

4.查看文件

[root@d6bb2b70632d /]# ls
bin  etc   lib	  lost+found  mnt  proc  run   srv  tmp  var	   volume02
dev  home  lib64  media       opt  root  sbin  sys  usr  volume01

我们生成的目录自动挂载的

5.在容器内创建一个目录，查看容器里是否有，查看匿名挂载路径

docker inspect d6bb2b70632d

"Mounts": [
            {
                "Type": "volume",
                "Name": "d451a845fdd349e203b65f76080c57e070d7fcfecb9744363780ccc13db286b0",
                "Source": "/var/lib/docker/volumes/d451a845fdd349e203b65f76080c57e070d7fcfecb9744363780ccc13db286b0/_data",
                "Destination": "volume01",
                "Driver": "local",
                "Mode": "",
                "RW": true,
                "Propagation": ""
            },
            {
                "Type": "volume",
                "Name": "438fcc6181fde2565c4e8c995a3a1aa7973cc91fa345c2b396415f4453e3f8a9",
                "Source": "/var/lib/docker/volumes/438fcc6181fde2565c4e8c995a3a1aa7973cc91fa345c2b396415f4453e3f8a9/_data",
                "Destination": "volume02",
                "Driver": "local",
                "Mode": "",
                "RW": true,
                "Propagation": ""
            }
        ],

6进入本地目录看是否出现,本地电脑添加一个都有

root@player3-TM1613:/var/lib/docker/volumes/d451a845fdd349e203b65f76080c57e070d7fcfecb9744363780ccc13db286b0/_data# ls
demo01.txt

7.测试删除容器，发现这个本地挂载的数据还在

可以实现什么，比如多个mysql同步数据？

小作业两个mysql进行数据同步

volumes-form 容器名，将容器数据卷挂载到其他的数据卷上，属于继承了上一层的数据卷，多个数据卷的数据相互复制，删除掉源头docker并不会对现有文件造成影响

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

docker run -d -p 3311:3307 -v /etc/mysql/conf.d -e MYSQL_ROOT_PASSWORD=123456 --name mysql02 mysql:5.7 --volumes-form mysql01

结论：容器之间的生命周期，一直到所有容器都没有使用为止，本地数据卷的数据是不会删除的。

编写docker的具体步骤

1.编写dockerfile文件，文件首字母大写

2.dockerbuild 构件成一个镜像

3.docker run 运行镜像

4.docker push 发布镜像 （ducherhub，阿里云镜像仓库）

dockerfile构建过程

dockerFile:构建文件，定义了一切的步骤，源代码

dockerimages:通过dockerfile构建生成的镜像，最终发布和运行的产品，原来是jar，war。

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

基础知识：

1.每个保留关键字（指令）都是必须大写的

2.执行从上到下顺序执行

3。#表示注释

4.每个指令都会创建提交一个新的镜像层

dockerfile常见命令

FROM   指定基本镜像，一切镜像从这里开始
MAINTAINER 负责人，一般姓名+邮箱
RUN 构建镜像的时候需要运行的命令
ADD 步骤，tomcat镜像的化tomcat的压缩包，添加内容
WORKDIR 镜像的工作目录
VOLUME 挂载的目录
EXPOSE 对外暴露的端口
CMD 命令行操作
ENTRYPOINT 指定容器启动的时候要运行的命令，可以追加命令
ONBUILD 当构建一个被继承dockerfile 这个时候就会运行ONBUILD的指令，触发指令
COPY 类似add，将文件拷贝到镜像中
ENV 设置构建的环境变量

小作业

1.构建一个自己的centos镜像
mycentos.Dockerfile

FROM centos
MAINTAINER  kuangshen<24736743@qq.com>

ENV MYPATH /usr/local
WORKDIR $MYPATH
RUN yum -y install vim
RUN  yum  -y install net-tools
EXPOSE 80
CMD echo A$MYPATH
CMD  /bin/bash

2.build

docker build  -f  /home/player3/文档/mycentos.Dockerfile  -t  player3/mycentos   .

3.运行 docker run -it dsoadihaso /bin/bash

查看镜像的构建过程 docker history odsakdlkasjdl

cnd和entrypoint区别

cmd 指定这个容器启动要运行的命令，之后最后一个会生效，可以被替代
entrypoint  指定这个容器启动要运行的命令，可以追加命令

cmd的file

FROM centos
CMD ['ls',"-a"]

docker build -f xxx -t cmdtest .

docker run aa1111  

会自动将最后的cmd命令执行，如果想追加命令不能在后面直接加应该这样写
docker run aa1111  ls-al

entrypoint的file

FROM centos
ENTRYPOINT ['ls',"-a"]

docker build -f xxx -t entrypointtest .

docker run aa1111  

会自动将最后的cmd命令执行，如果想追加命令可以直接填上后面
docker run aa1111  l

小作业tomcat镜像

发布自己的镜像

ducokerhub

1.地址： https://hub.docker.com 注册自己的账号

2.确定账号可以正常登录

3.在服务器上提交我们的镜像

dockerlogin --help

-u -p
用户名，密码

4登录之后可以提交镜像，docker push

本地提交到远程尽量带上版本信息和tag

docker tag 5d0da3dc9764 player3/centos:0.0.1

docker push player3/centos:0.0.1

发布到阿里云

1.登录到阿里云
2.找到容器镜像服务
3.找到镜像仓库
4.创建命名空间
5。创建镜像仓库
6其他参考官方文档

docker save

docker load

docker网络

docker0

ip addr

第一个是回环地址，第二个是内网地址，第三个是docker地址

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
    inet6 ::1/128 scope host 
       valid_lft forever preferred_lft forever
2: wlp2s0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default qlen 1000
    link/ether a0:c5:89:32:9c:d1 brd ff:ff:ff:ff:ff:ff
    inet 192.168.10.109/24 brd 192.168.10.255 scope global dynamic noprefixroute wlp2s0
       valid_lft 6054sec preferred_lft 6054sec
    inet6 fe80::8d0a:e31a:72d0:f111/64 scope link noprefixroute 
       valid_lft forever preferred_lft forever
3: docker0: <NO-CARRIER,BROADCAST,MULTICAST,UP> mtu 1500 qdisc noqueue state DOWN group default 
    link/ether 02:42:83:6a:8a:86 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

docker是如何处理网络问题

docker 可以ping通容器内部

正常电脑本机192.168.0.1 路由器地址，手机连接WiFi了，192.168.0.2，可以相互ping 可以相互ping通。

原理

1.我们每启动一个docker容器，docker就会给docker容器分配一个ip，我们只需要安装docker就会有一个网卡docker0

使用桥接模式，使用的技术是evth-pair 技术（虚拟设备接口）。

启动容器后出现的网卡是成对出现的，一端连着协议，一端彼此相连。

2.不同容器之间可以ping通的

docker exec -it tomcat2 ping  xxx

3.结论，tomcat1和tomcat是公用一个路由，docker0，所有容器不指定网络的情况下，都是使用docker0路由的，docker会给我们的容器分配一个默认的可用ip

4.docker中所有的网络接口都是虚拟的，虚拟转发效率高（内网传递文件）

只要容器删除，对应的网桥一对就没了

–link

场景：编写了一个微服务，database.rul=ip;; 项目不重启，ip换掉了，希望处理这个问题，可以名字来访问容器.

想通过服务去ping tomcat02能ping通吗？

docker exec -it tomcat02 ping tomcat01

ping不通

启动tomcat03

docker run -d -P --name tomcat3 --link tomcat02 tomcat01

通过—link就解决了这个问题，反向是不可以ping通的

当我们配置容器的时候不配置ip会给容器配置默认ip，我们可以通过docker inspect去看

docker exec -it tomcat03 cat /etc/hosts

通过查看tomcat03的docker host ，增加了tomcat02，tomcat01的本地映射

现在玩docker的时候已经不建议使用–link了，自定义网络，不适用docker0，docker0的问题，不支持容器名连接访问

docker network

docker network ls 查看所有的温昂罗
 
  docker network rm id  删除某个网络
  docker create

网络模式

bridge:桥接，默认

none:不配置网络

host:和宿主机共享网络

container：容器网络连接(用的少，局限很大)

测试

docker run -d -p --name tomcat01 tomcat
docker run -d -p --name tomcat01 tomcat --net bridge tomcat  上面的默认执行了这个
docker0特点；默认，域名不能访问，--link可以打通连接

我们可以自定一个网络

--driver bridge 模式

--subnet 192.168.0.0/16 多少个子网

--gateway 192.168.0.1 +网关路由

docker network create  --driver bridge  --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet

root@player3-TM1613:/home/player3# docker network ls
NETWORK ID     NAME      DRIVER    SCOPE
430c633bd795   bridge    bridge    local
a288f78f519b   host      host      local
74783c519ad2   mynet     bridge    local
7d3b1deefd46   none      null      local

docker run -d -P --name tomcat01 --net mynet tomcat

当你不适用–link也可以ping通名字 了

好处：不同的集群使用不同的网络，集群是安全和健康的

我们都知道网段不同是无法ping通的，如何打通docker0和自定义网络呢？

docker network connect 可以打通网络

docker network connect mynet tomcat01

联通之后就是将tomcat01放到了mynet网络下，一个容器两个ip

搭建redis集群

1.创建网卡

docker network create  redis --subnet 192.168.0.0/16

2.查看服务

docker network ls
docker network inspect redis

3.创建6个redis服务

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 192.168.0.1${port}
Cluster-announce-port 6379
Cluster-announce-bus-port 16379
appendonly yes
EOF
done

4.启动redis（6个）

node-1

docker run -p 6379:6379 -p 16379:16379 --name redis-1 \
-v /mydata/redis/node-1/data:/data \
-v /mydata/redis/node-1/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 192.168.0.11 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf

node-2

docker run -p 6372:6379 -p 16372:16379 --name redis-2 \
-v /mydata/redis/node-2/data:/data \
-v /mydata/redis/node-2/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 192.168.0.12 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf

node-3

docker run -p 6373:6379 -p 16373:16379 --name redis-3 \
-v /mydata/redis/node-3/data:/data \
-v /mydata/redis/node-3/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 192.168.0.13 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf

node-4

docker run -p 6374:6379 -p 16374:16379 --name redis-4 \
-v /mydata/redis/node-4/data:/data \
-v /mydata/redis/node-4/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 192.168.0.14 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf

node-5

docker run -p 6375:6379 -p 16375:16379 --name redis-5 \
-v /mydata/redis/node-5/data:/data \
-v /mydata/redis/node-5/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 192.168.0.15 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf

node-6

docker run -p 6376:6379 -p 16376:16379 --name redis-6 \
-v /mydata/redis/node-6/data:/data \
-v /mydata/redis/node-6/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 192.168.0.16 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf

redis中没有bash只有 sh

5.进入其中一个容器

docker exec -it redis-1 /bin/sh

6执行集群命令

redis-cli --cluster create 192.168.0.11:6379 192.168.0.12:6379  192.168.0.13:6379  192.168.0.14:6379  192.168.0.15:6379  192.168.0.16:6379 --cluster-replicas 1

输入yes

7.连接集群

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:209
cluster_stats_messages_pong_sent:229
cluster_stats_messages_sent:438
cluster_stats_messages_ping_received:224
cluster_stats_messages_pong_received:209
cluster_stats_messages_meet_received:5
cluster_stats_messages_received:438

8.设置值

set a b
get a
可以正常获取

9.查看主从节点，13的从是14

192.168.0.13:6379> cluster nodes
dda9df6e38727c5ad0667278cb77f96d91973f65 192.168.0.15:6379@16379 slave f6dc83295bb2d7e9a0436fff935dbd6e441ef8cf 0 1655738988807 5 connected
cf8b3f0cc101c2bce9f57d10349676a37ed0538c 192.168.0.14:6379@16379 slave 2c1949dcb59bff7a4cb49b0af04d15978987daaa 0 1655738988507 4 connected
2c1949dcb59bff7a4cb49b0af04d15978987daaa 192.168.0.13:6379@16379 myself,master - 0 1655738986000 3 connected 10923-16383
86ad41983210bdd6fd8c723851820852e57f2c0d 192.168.0.12:6379@16379 master - 0 1655738988306 2 connected 5461-10922
1e1386760e3421384022567658601b9dcae3ef02 192.168.0.16:6379@16379 slave 86ad41983210bdd6fd8c723851820852e57f2c0d 0 1655738988000 6 connected
f6dc83295bb2d7e9a0436fff935dbd6e441ef8cf 192.168.0.11:6379@16379 master - 0 1655738987000 1 connected 0-5460

10.停止docker的node-3节点

docker stop node-3

11.重新获取，发现卡顿，ctrl+c结束后，重新登录，发现从节点已经切换成功

-> Redirected to slot [15495] located at 192.168.0.14:6379
"b"
192.

将springboot打包成docker镜像

1.构建springboot项目

正常编写web项目并且测试

1.1下载dockerfile插件

2.打包应用

3.编写dockerfile

FROM java:8
COPY *.jar /app.jar
CMD ["--server.port=8080"]
EXPOSE 8080
ENTRYPOINT ["java","-jar","/app.jar"]

4.构建镜像

将dockerfile+jar包上传到服务器

docker build -t kuangshen666 .

5发布运行

docker run -d -p 8080:8080 --name kunagshen-springboot-web kuangshen666