Docker笔记

Docker笔记（学习视频：B站遇见狂神说）

Linux准备

1、安装JDK

# 下载JDK的rmp包
jdk-8u311-linux-x64.rpm

# 安装
rpm -ivh jdk-8u311-linux-x64.rpm
# 配置环境变量
# 1、输入命令 vi /etc/profile
# 2、按下 i ，在最后加入以下代码
unset i
unset -f pathmunge

JAVA_HOME=/usr/java/jdk1.8.0_311-amd64			# 这里的jdk1.8.0_311-amd64需要自己去/usr/java目录下确认，不同版本的JDK都不一样
CLASSPATH=%JAVA_HOME%/lib;%JAVA_HOME%/jre/lib
PATH=$JAVA_HOME/bin;$JAVA_HOME/jre/bin
export PATH CLASSPATH JAVA_HOME

2、安装Tomcat

# 下载Tomcat的压缩包（.tar.gz）后缀
# 切换到压缩包所在目录
# 解压
tar zxvf apache-tomcat-9.0.54.tar.gz
# 运行tomcat测试
# 1、进去tomcat的bin文件夹，运行startup.sh
[root@localhost bin]# ls
bootstrap.jar                 configtest.sh     shutdown.sh
catalina.bat                  daemon.sh         startup.bat
catalina.sh                   digest.bat        startup.sh
catalina-tasks.xml            digest.sh         tomcat-juli.jar
ciphers.bat                   makebase.bat      tomcat-native.tar.gz
ciphers.sh                    makebase.sh       tool-wrapper.bat
commons-daemon.jar            setclasspath.bat  tool-wrapper.sh
commons-daemon-native.tar.gz  setclasspath.sh   version.bat
configtest.bat                shutdown.bat      version.sh
[root@localhost bin]# ./startup.sh					# 运行
Using CATALINA_BASE:   /download/apache-tomcat-9.0.54
Using CATALINA_HOME:   /download/apache-tomcat-9.0.54
Using CATALINA_TMPDIR: /download/apache-tomcat-9.0.54/temp
Using JRE_HOME:        /usr
Using CLASSPATH:       /download/apache-tomcat-9.0.54/bin/bootstrap.jar:/download/apache-tomcat-9.0.54/bin/tomcat-juli.jar
Using CATALINA_OPTS:   
Tomcat started.

安装

1、确保Linux系统版本在CentOS7以上

2、yum安装gcc相关

yum -y install gcc
yum -y install gcc-c++

3、卸载旧版本

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

4、安装需要的软件包

yum install -y yum-utils device-mapper-persistent-data lvm2

5、设置镜像仓库

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

6、更新yum软件包索引 （可能会出错，直接跳到下一步即可）

yum makecache fast

7、安装Docker

yum -y install docker-ce docker-ce-cli containerd.io

8、测试启动Docker

systemctl start docker

9、测试

#查看版本
docker version

#运行hello world，一开始没有这个镜像，输入命令后会自动下载
docker run hello-world

#查看镜像
docker images

阿里云镜像加速

四个命令依次在Linux控制台输入即可

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

Docker run 镜像名—的工作流程

底层原理

Docker是怎么工作的？

​ Docker是一个Client-Server结构的系统，Docker的守护进程运行在主机上，通过Socket从客户端访问！

​ DockerServer接收到Docker-Client的指令，就会执行该指令

Docker为什么比虚拟机快？

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

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

Docker新建一个容器的时候，不需要重新加载系统内核；虚拟机需要加载Guest OS（分钟级别），Docker利用了宿主机的操作系统（秒级），省略了这个复杂的过程

Docker的常用命令

帮助命令

docker version 		#显示docker的版本信息
docker info			#显示docker的系统信息，包括镜像和容器的数量
docker 命令 --help   #帮助命令

帮助文档的地址：Reference documentation | Docker Documentation

镜像命令

docker images 查看所有本地的主机上的镜像

[root@localhost /]# docker images
REPOSITORY    TAG       IMAGE ID       CREATED       SIZE
hello-world   latest    feb5d9fea6a5   5 weeks ago   13.3kB

#解释
REPOSITORY	镜像的仓库源
TAG			镜像的标签
IMAGE ID	镜像的id
CREATED		镜像的创建时间
SIZE		镜像的大小

#可选项
	-a, --all		#列出所有镜像
	-q, --quiet		#只显示镜像的id

docker rmi 镜像id 删除指定id的镜像（删之前要先把对应的container删除，因为该镜像可能被container引用

也可以直接使用 docker rmi -f 镜像id 强制删除）

[root@localhost /]# docker rmi feb5d9fea6a5
Untagged: hello-world:latest
Untagged: hello-world@sha256:37a0b92b08d4919615c3ee023f7ddb068d12b8387475d64c622ac30f45c29c51
Deleted: sha256:feb5d9fea6a5e9606aa995e879d862b825965ba48de054caab5ef356dc6b3412
Deleted: sha256:e07ee1baac5fae6a26f30cabfe54a36d3402f96afda318fe0a96cec4ca393359

docker ps -a 列出所有容器 （要删除hello-world镜像，就要先找出引用hello-world的容器id）

[root@localhost /]# docker ps -a
CONTAINER ID   IMAGE         COMMAND    CREATED         STATUS                     PORTS     NAMES
7657ea7ed321   hello-world   "/hello"   6 minutes ago   Exited (0) 6 minutes ago             epic_goldwasser

docker rm 容器id 删除指定id的容器（之后就可以删除hello-world的镜像了）

[root@localhost /]# docker rm 7657ea7ed321
7657ea7ed321

docker search 镜像名 搜索镜像

[root@localhost /]# docker search mysql
NAME                              DESCRIPTION                                     STARS     OFFICIAL   AUTOMATED
mysql                             MySQL is a widely used, open-source relation…   11611     [OK]       
mariadb                           MariaDB Server is a high performing open sou…   4417      [OK]       
mysql/mysql-server                Optimized MySQL Server Docker images. Create…   857                  [OK]

#可选项，通过收藏来过滤
--filter=STARS=3000		搜索出来的镜像就是收藏是大于3000的

[root@localhost /]# docker search mysql --filter=STARS=3000
NAME      DESCRIPTION                                     STARS     OFFICIAL   AUTOMATED
mysql     MySQL is a widely used, open-source relation…   11611     [OK]       
mariadb   MariaDB Server is a high performing open sou…   4417      [OK]

docker pull 镜像名 下载镜像（默认下载最新版）

# 下载镜像 docker pull 镜像名[:tag]
[root@localhost /]# docker pull mysql
Using default tag: latest	# 如果不写[:tag]，默认就是latest
latest: Pulling from library/mysql	
b380bbd43752: Pull complete 	# 分层下载， docker image的核心  联合文件系统
f23cbf2ecc5d: Pull complete 
30cfc6c29c0a: Pull complete 
b38609286cbe: Pull complete 
8211d9e66cd6: Pull complete 
2313f9eeca4a: Pull complete 
7eb487d00da0: Pull complete 
4d7421c8152e: Pull complete 
77f3d8811a28: Pull complete 
cce755338cba: Pull complete 
69b753046b9f: Pull complete 
b2e64b0ab53c: Pull complete 
Digest: sha256:6d7d4524463fe6e2b893ffc2b89543c81dec7ef82fb2020a1b27606666464d87		# 签名
Status: Downloaded newer image for mysql:latest
docker.io/library/mysql:latest		# 真实地址

# 以上一条命令等价于
docker pull mysql
docker pull docker.io/library/mysql:latest

# 指定版本下载
[root@localhost /]# docker pull mysql:5.7
5.7: Pulling from library/mysql
b380bbd43752: Already exists 
f23cbf2ecc5d: Already exists 
30cfc6c29c0a: Already exists 
b38609286cbe: Already exists 
8211d9e66cd6: Already exists 
2313f9eeca4a: Already exists 
7eb487d00da0: Already exists 
a71aacf913e7: Pull complete 
393153c555df: Pull complete 
06628e2290d7: Pull complete 
ff2ab8dac9ac: Pull complete 
Digest: sha256:2db8bfd2656b51ded5d938abcded8d32ec6181a9eae8dfc7ddf87a656ef97e97
Status: Downloaded newer image for mysql:5.7
docker.io/library/mysql:5.7

# 查看
[root@localhost /]# docker images
REPOSITORY   TAG       IMAGE ID       CREATED       SIZE
mysql        5.7       938b57d64674   13 days ago   448MB
mysql        latest    ecac195d15af   13 days ago   516MB

容器命令

说明：有了镜像才可以创建容器，linux，下载一个centos镜像测试学习

docker pull centos

[root@localhost /]# docker pull centos
Using default tag: latest
latest: Pulling from library/centos
a1d0c7532777: Pull complete 
Digest: sha256:a27fd8080b517143cbbbab9dfb7c8571c40d67d534bbdee55bd6c473f432b177
Status: Downloaded newer image for centos:latest
docker.io/library/centos:latest

新建容器并启动

docker run [可选参数] image

# 参数说明
--name="Name"	容器名字 tomcat01 tomcat02 用来区分容器
-d				后台方式运行
-it				使用交互方式运行，进入容器查看内容
-p				指定容器的端口 -p 8080：8080
	-p ip:主机端口:容器端口
	-p 主机端口：容器端口（常用）
	-p 容器端口
-p  			随机指定端口

# 测试，启动并进入容器
[root@localhost /]# docker run -it centos /bin/bash
[root@c8a8a13ac174 /]# ls	# 查看容器内的centos，基础版本，很多命令还不完善
bin  etc   lib	  lost+found  mnt  proc  run   srv  tmp  var
dev  home  lib64  media       opt  root  sbin  sys  usr

# 退出容器，从容器退出到主机
[root@c8a8a13ac174 /]# exit		
exit

列出所有运行的容器

docker ps 命令
		# 列出当前正在运行的容器
-a		# 列出当前正在运行的容器 以及 历史运行过的容器
-n=?	# 显示最近创建的容器
-aq		# 显示所有当前容器的编号

[root@localhost /]# docker ps
CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES
[root@localhost /]# docker ps -a
CONTAINER ID   IMAGE     COMMAND       CREATED         STATUS                     PORTS     NAMES
c8a8a13ac174   centos    "/bin/bash"   4 minutes ago   Exited (0) 2 minutes ago             optimistic_carver

退出容器

exit 	# 直接停止并退出容器
Ctrl + P + Q 	# 退出容器但不停止

删除容器

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 镜像名

# 问题：docker ps， 发现centos停止了

# 常见的坑：docker容器使用后台运行，就必须有一个前台进程，docker发现没有应用，就会自动停止

# nginx，容器启动后，发现自己没有提供服务，就会立刻停止，就是没有程序了

查看日志

docker logs -f -t --tail 日志条数 容器id  

# 自己编写一段shell脚本
[root@localhost /]# docker run -d centos /bin/sh -c "while true; do echo localhost;sleep 1;done"
d2a45bc782a75a22e7da22fa06cf0b33274f449025add419811bfc1c816fa11a

[root@localhost /]# docker ps
CONTAINER ID   IMAGE     COMMAND                  CREATED         STATUS         PORTS     NAMES
d2a45bc782a7   centos    "/bin/sh -c 'while t…"   5 seconds ago   Up 3 seconds             great_edison

# 显示日志
-f -t 可以结合起来 -tf	# 显示日志
--tail number			# 要显示的日志条数
[root@localhost /]# docker logs -f -t --tail 10 d2a45bc782a7
2021-11-01T02:42:16.625371264Z localhost
2021-11-01T02:42:17.628116952Z localhost
2021-11-01T02:42:18.633494886Z localhost
2021-11-01T02:42:19.635309795Z localhost
2021-11-01T02:42:20.638327390Z localhost
2021-11-01T02:42:21.641747570Z localhost
2021-11-01T02:42:22.644098419Z localhost
2021-11-01T02:42:23.655560465Z localhost
2021-11-01T02:42:24.659873927Z localhost
2021-11-01T02:42:25.666505490Z localhost
2021-11-01T02:42:26.669244649Z localhost
2021-11-01T02:42:27.674658522Z localhost
2021-11-01T02:42:28.676837277Z localhost
2021-11-01T02:42:29.678706504Z localhost
2021-11-01T02:42:30.681514524Z localhost
2021-11-01T02:42:31.684640413Z localhost
2021-11-01T02:42:32.688320038Z localhost

查看容器中的进程信息ps

top命令
docker top 容器id
[root@localhost /]# docker top d2a45bc782a7
UID        PID        PPID        C     STIME       TTY        TIME          CMD
root      46808       46787       0     19:40        ?        00:00:00      /bin/sh -c while true; do echo localhost;sleep 1;done
root      47806       46808       0     19:51        ?        00:00:00      /usr/bin/coreutils --coreutils-prog-shebang=sleep /usr/bin/sleep 1

查看镜像的元数据

[root@localhost /]# docker inspect d2a45bc782a7
[
    {
        "Id": "d2a45bc782a75a22e7da22fa06cf0b33274f449025add419811bfc1c816fa11a",
        "Created": "2021-11-01T02:40:13.810286187Z",
        "Path": "/bin/sh",
        "Args": [
            "-c",
            "while true; do echo localhost;sleep 1;done"
        ],
        "State": {
            "Status": "running",
            "Running": true,
            "Paused": false,
            "Restarting": false,
            "OOMKilled": false,
            "Dead": false,
            "Pid": 46808,
            "ExitCode": 0,
            "Error": "",
            "StartedAt": "2021-11-01T02:40:15.10685646Z",
            "FinishedAt": "0001-01-01T00:00:00Z"
        },
        "Image": "sha256:5d0da3dc976460b72c77d94c8a1ad043720b0416bfc16c52c45d4847e53fadb6",
        "ResolvConfPath": "/var/lib/docker/containers/d2a45bc782a75a22e7da22fa06cf0b33274f449025add419811bfc1c816fa11a/resolv.conf",
        "HostnamePath": "/var/lib/docker/containers/d2a45bc782a75a22e7da22fa06cf0b33274f449025add419811bfc1c816fa11a/hostname",
        "HostsPath": "/var/lib/docker/containers/d2a45bc782a75a22e7da22fa06cf0b33274f449025add419811bfc1c816fa11a/hosts",
        "LogPath": "/var/lib/docker/containers/d2a45bc782a75a22e7da22fa06cf0b33274f449025add419811bfc1c816fa11a/d2a45bc782a75a22e7da22fa06cf0b33274f449025add419811bfc1c816fa11a-json.log",
        "Name": "/great_edison",
        "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/c307f898f9671783187b56ad9ed55fee41fb2f656628d3b0987766149ea2a575-init/diff:/var/lib/docker/overlay2/7cb20a1f4cfe9fc6ad65a4ea72b8a104d21ff660ccdfffc9712453fe3354af9e/diff",
                "MergedDir": "/var/lib/docker/overlay2/c307f898f9671783187b56ad9ed55fee41fb2f656628d3b0987766149ea2a575/merged",
                "UpperDir": "/var/lib/docker/overlay2/c307f898f9671783187b56ad9ed55fee41fb2f656628d3b0987766149ea2a575/diff",
                "WorkDir": "/var/lib/docker/overlay2/c307f898f9671783187b56ad9ed55fee41fb2f656628d3b0987766149ea2a575/work"
            },
            "Name": "overlay2"
        },
        "Mounts": [],
        "Config": {
            "Hostname": "d2a45bc782a7",
            "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 localhost;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": "b49f708ff0471ee14616af910fd1cf1133cccd117ce2482f61f4abe11180465a",
            "HairpinMode": false,
            "LinkLocalIPv6Address": "",
            "LinkLocalIPv6PrefixLen": 0,
            "Ports": {},
            "SandboxKey": "/var/run/docker/netns/b49f708ff047",
            "SecondaryIPAddresses": null,
            "SecondaryIPv6Addresses": null,
            "EndpointID": "6a34e701efdfb506b7ed06bd1fcb85453739e07b174706e76674d631f765b47e",
            "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": "fd84308c776289830911fb47eb63666f072e40818d2bc5a07e21bba0254b808f",
                    "EndpointID": "6a34e701efdfb506b7ed06bd1fcb85453739e07b174706e76674d631f765b47e",
                    "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 bashShell

# 测试
[root@localhost /]# docker exec -it d2a45bc782a7 /bin/bash
[root@d2a45bc782a7 /]# ls
bin  etc   lib	  lost+found  mnt  proc  run   srv  tmp  var
dev  home  lib64  media       opt  root  sbin  sys  usr
[root@d2a45bc782a7 /]# ps -ef
UID          PID    PPID  C STIME TTY          TIME CMD
root           1       0  0 02:40 ?        00:00:00 /bin/sh -c while true; do 
root        1995       0  0 03:13 pts/0    00:00:00 /bin/bash
root        2045       1  0 03:14 ?        00:00:00 /usr/bin/coreutils --coreu
root        2046    1995  0 03:14 pts/0    00:00:00 ps -ef

# 方式二
docker attach 容器id
[root@localhost /]# docker attach d2a45bc782a7
正在执行当前代码...

# docker exec 		# 进入容器后开启一个新的中断，可以再里面操作（常用）
# dockers attach	# 进入容器正在执行的终端，不会启动新的进程

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

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

# 测试
[root@localhost ~]# docker run -it centos /bin/bash		# 运行并进入容器
[root@abebb18b9e26 /]# cd /home						
[root@abebb18b9e26 home]# ls
[root@abebb18b9e26 home]# touch test.java				# 创建test.java文件
[root@abebb18b9e26 home]# ls
test.java
[root@abebb18b9e26 home]# exit							# 退出并停止容器
exit
[root@localhost ~]# docker ps -a
CONTAINER ID   IMAGE     COMMAND       CREATED              STATUS                          PORTS     NAMES
abebb18b9e26   centos    "/bin/bash"   32 seconds ago       Exited (0) 7 seconds ago                  stupefied_noyce
[root@localhost ~]# docker cp abebb18b9e26:/home/test.java /home		# 复制文件到本机路径
[root@localhost ~]# cd /
[root@localhost /]# cd home
[root@localhost home]# ls		# 查看
admin  test.java

# 拷贝是一个手动过程，以后使用 -v 卷的技术，可以实现

常用命令小结

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

容器连接

端口映射并不是唯一把 docker 连接到另一个容器的方法。

docker 有一个连接系统允许将多个容器连接在一起，共享连接信息。

docker 连接会创建一个父子关系，其中父容器可以看到子容器的信息。

# 新建网络
	docker network create -d bridge net01
	## -d 指定Docker网络的类型 有 bridge、overlay
# 连接容器
	## 运行两个容器并都连接到新建的test01网络
	docker run -itd --name test1 --network net01 tomcat /bin/bash
	docker run -itd --name test2 --network net01 tomcat /bin/bash
	## 这样两个容器之间就建立的互联关系，可以进入容器终端使用ping来测试
	## 容器内可能没有ping命令，需要在容器内执行以下命令安装ping
	apt-get update
	apt install iputils-ping
	## 安装完后提交容器到镜像
	### -a 提交人
	### -m 消息，相当于描述
	docker commit -m="ping update" -a="ping" 容器id 新的镜像名:TAG标签
	例如：docker commit -m="ping update" -a="ping" c22c74d7d8b0 ping/tomcat:v1
	## 再以新的镜像运行并进入两个容器，再用ping测试
	docker run -itd --name test1 --network net01 ping/tomcat:v1 /bin/bash
	docker run -itd --name test2 --network net01 ping/tomcat:v1 /bin/bash

可视化

Docker图形化界面管理工具：portainer（不常使用）

# 安装并运行
docker run -d -p 8088:9000\
--restart=always -v /var/run/docker.sock:/var/run/docker.sock --privileged=true portainer/portainer

访问测试：ip：端口号

作业练习

Docker安装Nginx

# 1、搜索镜像	（建议取docker hub搜索，可以看到详细信息）
	docker search nginx
# 2、下载镜像
	docker pull nginx
# 3、运行测试
[root@localhost /]# docker images
REPOSITORY    TAG       IMAGE ID       CREATED       SIZE
nginx         latest    87a94228f133   2 weeks ago   133MB
hello-world   latest    feb5d9fea6a5   5 weeks ago   13.3kB
centos        latest    5d0da3dc9764   6 weeks ago   231MB

# -d 后台运行
# --name 设置别名
# -p 设置端口
[root@localhost /]# docker run -d --name nginx01 -p 3344:80 nginx		后台运行nginx，并设置别名以及主机端口和容器端口
c2e9aef8b5475fa9ecad08e535db9229e8a55e41ccf15d344706cc3972fe6903
[root@localhost /]# docker ps
CONTAINER ID   IMAGE     COMMAND                  CREATED         STATUS         PORTS                                   NAMES
c2e9aef8b547   nginx     "/docker-entrypoint.…"   5 seconds ago   Up 2 seconds   0.0.0.0:3344->80/tcp, :::3344->80/tcp   nginx01
# 页面访问测试
[root@localhost /]# curl localhost:3344
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
<style>
html { color-scheme: light dark; }
body { width: 35em; margin: 0 auto;
font-family: Tahoma, Verdana, Arial, sans-serif; }
<yle>
</head>
<body>
<h1>Welcome to nginx!</h1>
<p>If you see this page, the nginx web server is successfully installed and
working. Further configuration is required.</p>

<p>For online documentation and support please refer to
<a href="http://nginx.org/">nginx.org</a>.<br/>
Commercial support is available at
<a href="http://nginx.com/">nginx.com</a>.</p>

<p><em>Thank you for using nginx.</em></p>
</body>
<ml>

# 进入容器
[root@localhost /]# docker exec -it nginx01 /bin/bash
root@c2e9aef8b547:/# whereis nginx
nginx: /usr/sbininx /usr/lib/nginx /etc/nginx /usr/share/nginx
root@c2e9aef8b547:/# cd /etcinx
root@c2e9aef8b547:/etcinx# ls
conf.d		mime.types  nginx.conf	 uwsgi_params
fastcgi_params	modules     scgi_params
root@c2e9aef8b547:/etcinx#

思考问题：每次改动nginx配置文件，都需要进入容器内部，十分麻烦。如果可以再容器外部提供一个映射路径，达到在容器修改文件夹名，容器内部就可以自动修改？-v 数据卷！

Docker安装Tomcat

# 官方的使用方法  这种一般用来测试，用完就会自动删（容器和镜像都删掉）
docker run -it --rm tomcat：9.0
# 下载再启动
docker pull tomcat:9.0
# 启动运行
[root@localhost ~]# docker run -d -p 3355:8080 --name tomcat01 tomcat:9.0
5abea76c7c31dc18086dc214f7f308c16dba17327c130a9bd238412f5d883d8f
# 测试访问页面为404，没有问题，因为webapps文件夹中没有内容
# 进去容器
[root@localhost ~]# docker exec -it tomcat01 /bin/bash
root@5abea76c7c31:/usr/local/tomcat# ls
BUILDING.txt	 README.md	conf		temp
CONTRIBUTING.md  RELEASE-NOTES	lib		webapps
LICENSE		 RUNNING.txt	logs		webapps.dist
NOTICE		 bin		native-jni-lib	work
root@5abea76c7c31:/usr/local/tomcat# cd webapps
root@5abea76c7c31:/usr/local/tomcat/webapps# ls
root@5abea76c7c31:/usr/local/tomcat/webapps#
# 发现问题：1、Linux命令少了。 2、webapps没有内容。阿里云镜像的原因，默认是最小的镜像，所有不必要的都剔除掉
# webapps.dist目录下有原本webapps因该有的内容，可以使用 cp -r webapps.dist/* webapps拷贝过去，这样就可以正常访问到欢迎页面了

思考问题：以后部署项目，如果每次都要进入容器会十分麻烦，要是可以在容器外部提供一个映射路径，我们在外部放置项目，就自动同步到内部就好了

部署es + kibana

# es 暴露的端口很多
# es 十分耗内存
# es 的数据一般需要放置到安全目录！挂载

# --net somenetwork	网络配置  需要用到daemon配置文件中的配置，可以不写
# 最后的tag要改成版本号 如：7.6.2
# 启动elasticsearch
$ docker run -d --name elasticsearch --net somenetwork -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch:tag

# 启动之后会非常卡 因为es十分耗内存
# docker stats 查看cpu状态
# 测试一下es是否成功了
[root@localhost ~]# curl localhost:9200
{
  "name" : "77c87eb49bca",
  "cluster_name" : "docker-cluster",
  "cluster_uuid" : "ENkH4T7zQUStpUFcQ91-FQ",
  "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"
}

# 退出es，增加内存的限制，修改配置文件 -e 环境配置修改
$ docker run -d --name elasticsearch --net somenetwork -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" -e ES_JAVA_OPTS="-Xms64m -Xmx512m" elasticsearch:7.6.2

# docker stats 查看cpu状态

作业：使用kibana连接es，思考网络如何才能连接过去

Docker镜像

什么是镜像

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

所有的应用，直接打包docker镜像，就可以跑起来

Docker镜像加载原理（视频没细说）

UnionFS（联合文件系统）

UnionFS：UnionFS文件系统那个是一种分层、轻量级并且高性能的文件系统，它支持对文件系统的修改作为一次提交来一层层的叠加，同时可以将不同目录挂载到同一个虚拟文件系统下。Union文件系统时Docker镜像的基础。镜像可以通过分层来进行继承，基于基础镜像（无父镜像），可以制作各种具体的应用镜像。

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

Docker镜像加载原理

容器数据卷

什么是容器数据卷

容器之间可以有一个数据共享的技术！Docker容器中产生的数据，同步到本地！这就是卷技术！目录的挂载，将我们容器内的目录，挂载到Linux上面！

使用数据卷

方式一：直接使用命令来挂载 -v

# 与 -p 映射端口的功能相似
docker run -it -v 主机目录:容器内目录

在主机内添加或修改文件，容器内绑定的目录下也会进行同样的操作。即使容器不再运行，在主机目录操作文件，也会在容器内进行相同操作

相反，在容器内添加或修改文件，主机目录下也会进行同样的操作。这是一个双向同步。

实战：安装MySql

思考：MySql的数据持久化问题

# 获取镜像
docker pull mysql:5.7
# 运行容器,需要做数据挂载
## 目录映射可以同时映射多个目录
## mysql运行需要配置密码
## 使用镜像时建议查看Docker hub该镜像的使用方法，有的镜像可能需要配置参数
docker run -d -p 3344:3306 -v /docker/vTest:/etc/mysql/conf.d -v /home/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql01 mysql:5.7
# 启动之后，可以通过Navicat来连接测试

将容器删除后，同步到本机目录的文件不会受到任何影响

具名挂载和匿名挂载

# 匿名挂载
-v 容器内路径！
docker run -d -p --name nginx01 -v /etc/nginx nginx
# 查看所有的卷volume的情况
docker volume ls 
[root@localhost vTest]# docker volume ls
DRIVER    VOLUME NAME
local     1df80122f10be1a897a7e45ab6d66c40d202edeb851c886cc200e5b7cd4b2f5d
local     3f106ecf81bf3bcc4f0193d0a8dea3bc3b1680b51a5519adf83ef210aca659e7
local     7b6b6da6ff0f1add465fb17a4152201f413beef0b11d84064386be0c95c46cc6
local     469d987b3ac3f168f5250366dc30564446a7e9204e6e63def5dfcdad8c948923
local     a81756cd9d566a2418386043c695084028ad2cf8f68af98bff2518ed54ecc557
local     b08a210135e724bd63629bd3b6944ac1ce29772c1fabed2140b3bdf4776eec4f
local     b910f645b3b888a7d8aeaa773d109bdea3428f995e375f81c7ebfba807be88cd
local     c967934041a2220b4089b9848f27ed33f9e2c99591581dfc50c5be804f839df5
## 这种VOLUME NAME形式的就是匿名挂载， -v只写了容器内路径，没有写主机路径

# 具名挂载（常用）
## 通过 -v 卷名:容器内路径
[root@localhost vTest]# docker run -d -P --name tomcat01 -v juming-tomcat:/webapps tomcat
18a44d7a0dba94a56f5c4389cb5a47c6bb1d1ee1f63b2bb291a40679451076b5
[root@localhost vTest]# docker volume ls
DRIVER    VOLUME NAME
local     1df80122f10be1a897a7e45ab6d66c40d202edeb851c886cc200e5b7cd4b2f5d
local     juming-tomcat
# 查看这个卷
[root@localhost vTest]# docker volume inspect juming-tomcat
[
    {
        "CreatedAt": "2021-11-04T23:47:56-07:00",
        "Driver": "local",
        "Labels": null,
        "Mountpoint": "/var/lib/docker/volumes/juming-tomcat/_data",
        "Name": "juming-tomcat",
        "Options": null,
        "Scope": "local"
    }
]
## 所有的docker容器内的卷，没有指定目录的情况下都是在 “/var/lib/docker/volumes/具名/_data”
## 通过具名挂载可以方便的找到一个卷，大多数情况使用具名挂载

# 如何确定时具名挂载还是匿名挂载，还是指定路径挂载
-v 容器内路径	# 匿名挂载
-v 卷名：容器内路径 	# 具名挂载
-v 主机路径：容器内路径	# 指定路径挂载
# 通过 -v 容器内路径：ro  rw 改变读写权限
ro  # 只读
rw  # 可读可写
# 一旦设置了容器权限，容器对我们挂载出来的内容就有限定了
docker run -d -P --name nginx01 -v juming-nginx:/etc/nginx:ro nginx
docker run -d -P --name nginx01 -v juming-nginx:/etc/nginx:rw nginx
# 只要看到ro就说明这个路径只能通过宿主机来操作，容器内部无法操作

Dockerfile

初识Dockerfile

Dockerfile就是用来构建docker镜像的构建文件！命令脚本！

通过这个脚本可以生成镜像，镜像是一层一层的，脚本一个个的命令，每个命令都是一层

# 创建一个Dockerfile文件，名字可以随机，建议Dockerfile
# 在文件内编写脚本
# 指令(大写)  参数
FROM centos

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

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

# 使用Dockerfile文件构建一个镜像
## -f 指定文件路径
## -t 指定镜像名
## 最后有一个 . 不要忘了
[root@localhost Dockerfile]# docker build -f /docker/Dockerfile/Dockerfile -t dockerfile/centos .
Sending build context to Docker daemon  3.072kB
Step 1/4 : FROM centos
 ---> 5d0da3dc9764
Step 2/4 : VOLUME ["volume01","volume02"]
 ---> Running in 9d855047bb46
Removing intermediate container 9d855047bb46
 ---> d735d232d302
Step 3/4 : CMD echo "-------end--------"
 ---> Running in a40bafadbddb
Removing intermediate container a40bafadbddb
 ---> 5823728d8557
Step 4/4 : CMD /bin/bash
 ---> Running in 5de59204d7a7
Removing intermediate container 5de59204d7a7
 ---> 566eaeb46b8e
Successfully built 566eaeb46b8e
Successfully tagged dockerfile/centos:latest
# 查看镜像
[root@localhost Dockerfile]# docker images
REPOSITORY            TAG       IMAGE ID       CREATED         SIZE
dockerfile/centos     latest    566eaeb46b8e   5 seconds ago   231MB
centos                latest    5d0da3dc9764   7 weeks ago     231MB

# 启动自己写的镜像
[root@localhost Dockerfile]# docker run -it 566eaeb46b8e /bin/bash
[root@0123d60fba1a /]# ls
bin  etc   lib	  lost+found  mnt  proc  run   srv  tmp  var	   volume02
dev  home  lib64  media       opt  root  sbin  sys  usr  volume01
[root@0123d60fba1a /]# ls -l
total 0
lrwxrwxrwx.   1 root root   7 Nov  3  2020 bin -> usr/bin
drwxr-xr-x.   5 root root 360 Nov  5 07:36 dev
drwxr-xr-x.   1 root root  66 Nov  5 07:36 etc
drwxr-xr-x.   2 root root   6 Nov  3  2020 home
lrwxrwxrwx.   1 root root   7 Nov  3  2020 lib -> usrb
lrwxrwxrwx.   1 root root   9 Nov  3  2020 lib64 -> usrb64
drwx------.   2 root root   6 Sep 15 14:17 lost+found
drwxr-xr-x.   2 root root   6 Nov  3  2020 media
drwxr-xr-x.   2 root root   6 Nov  3  2020 mnt
drwxr-xr-x.   2 root root   6 Nov  3  2020 opt
dr-xr-xr-x. 243 root root   0 Nov  5 07:36 proc
dr-xr-x---.   2 root root 162 Sep 15 14:17 root
drwxr-xr-x.  11 root root 163 Sep 15 14:17 run
lrwxrwxrwx.   1 root root   8 Nov  3  2020 sbin -> usr/sbin
drwxr-xr-x.   2 root root   6 Nov  3  2020 srv
dr-xr-xr-x.  13 root root   0 Nov  5 00:22 sys
drwxrwxrwt.   7 root root 171 Sep 15 14:17 tmp
drwxr-xr-x.  12 root root 144 Sep 15 14:17 usr
drwxr-xr-x.  20 root root 262 Sep 15 14:17 var
drwxr-xr-x.   2 root root   6 Nov  5 07:36 volume01			#
drwxr-xr-x.   2 root root   6 Nov  5 07:36 volume02			# 这两个目录就是生成镜像的时候自动挂载的，数据卷目录

# 这种方式使用的很多，我们通常会构建自己的镜像
# 假设构建镜像时没有挂载卷，就需要手动挂载 -v 卷名:容器内路径

数据卷容器

多个mysql 同步数据！

# 启动三个容器，通过上面自己写的镜像启动
docker run -it --name docker01 dockerfile/centos /bin/bash
# 之后启动的容器可以进行继承docker01，这样就可以将 数据卷 挂载到一起
docker run -it --name docker02 --volumes-from docker01 dockerfile/centos
docker run -it --name docker03 --volumes-from docker01 dockerfile/centos

# 测试：可以删除docker01，查看docker02和docker03是否还可以访问这个文件
# 测试依旧可以访问，因为 数据卷不只是共享数据，还会备份，每个容器内都备份有数据

结论：

​ 容器之间配置信息的传递，数据卷容器的生命周期一直持续到没有容器使用为止

​ 但是一旦你持久化到了本地，这个时候，本地的数据是不会删除的

Dockerfile介绍

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

构建过程：

1、编写一个dockerfile文件

2、docker build构建成为一个镜像

3、docker run运行镜像

4、docker push发布镜像

很多官方镜像都是基础包，很多功能没有，我们通常会自己搭建自己的镜像！

Dockerfile构建过程

基础知识：

​ 1、每个保留关键字（指令）都必须是大写字母

​ 2、执行从上到下顺序执行

​ 3、# 表示注释

​ 4、每一个指令都会创建一个新的镜像层，并提交！

dockerfile是面向开发的，以后发布项目，做镜像，就需要编写dockerfile文件！

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

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

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

Dockerfile的命令

FROM			# 基础镜像，一切从这里开始构建
MAINTAINER		# 镜像是谁写的，姓名+邮箱
RUN				# 镜像构建的时候需要运行的命令
ADD				# 步骤：tomcat镜像，这个tomcat压缩包！添加内容
WORKDIR			# 镜像的工作目录
VOLUME			# 挂载的目录
EXPOSE			# 保留端口配置 -p
CMD				# 指定这个容器启动的时候要运行的命令，只有最后一个会生效，可被替代
ENTRYPOINT		# 指定这个容器启动的时候要运行的命令，可以追加命令
ONBUILD			# 当构建一个被继承Dockerfile 这个时候就会运行ONBUILD的指令，触发指令
COPY			# 类似ADD，将我们文件拷贝到镜像中
ENV				# 构建的时候设置环境变量！

实战：构建自己的centos

Docker Hub中88%镜像都是从这个基础镜像过来的FROM scratch，然后配置需要的软件和配置来进行的构建

创建一个自己的centos

# 编写Dockerfile文件
[root@localhost Dockerfile]# cat mydockerfile
FROM centos		# 基础镜像
MAINTAINER zhehao<1477531126@qq.com>	# 维护者信息

ENV MYPATH /usr/local		# 配置环境
WORKDIR $MYPATH		# 工作目录，进入容器默认在此目录下

RUN yum -y install vim		# 安装 vim
RUN yum -y install net-tools	# 安装 net-tools
	
EXPOSE 80		# 设置暴露的端口
CMD echo $MYPATH	# 输出MYPATH
CMD echo "----end----"
CMD /bin/bash

# 通过这个文件构建镜像
## 不要忘了 .
docker build -f /docker/Dockerfile/mydockerfile -t mycentos .

我们可以列出本地镜像的变更历史

# 查看镜像的变更历史（构建过程）
docker history 镜像id

CMD 和 ENTRYPOINT 的区别

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

实战：Tomcat镜像

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

2、编写dockerfile文件，官方命名Dockerfile，build会自动寻找这个文件，就不需要-f指定了

FROM centos
MAINTAINER zhehao<1477531126@qq.com>

COPY readme.txt /usr/local/readme.txt		# 复制文件到容器内路径（如果该文件与Dockerfile同目录，直接写文件名即可，否则要写全路径）

ADD jdk-8u161-linux-x64.tar.gz /usr/local/	# 安装jdk（这里的jdk与Dockerfile同目录，所以也只写文件名即可，后边是要安装到容器内的目录）
ADD apache-tomcat-9.0.54.tar.gz /usr/local/ # 同上
		
RUN yum -y install vim						# 运行yum命令安装vim

ENV MYPATH /usr/local						
WORKDIR SMYPATH

ENV JAVA_HOME /usr/local/jdk1.8.0_161		# 配置环境变量
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.54
ENV CATALINA_BASH /usr/local/apache-tomcat-9.0.54
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin

EXPOSE 8080									# 暴露端口号

CMD /usr/local/apache-tomcat-9.0.54/bin/startup.sh && tail -F /usr/local/apache-tomcat-9.0.54/bin/logs/catalina.out

3、构建镜像

# docker build -t 镜像名 .

4、启动镜像

# docker run -d -p 9090:8080 --name mytomcat -v /docker/Dockerfile/tomcat/test:/usr/local/apache-tomcat-9.0.54/webapps -v /docker/Dockerfile/tomcat/logs:/usr/local/apache-tomcat-9.0.54/logs diytomcat

5、进入容器启动tomcat

6、发布项目（由于做了卷挂载，我们直接在本地就可发布项目）

7、访问测试

发布自己的镜像

发布到DockerHub

1、Docker Hub 注册自己的账号

2、提交镜像

# 1、使用命令登录Docker Hub
[root@localhost ~]# docker login -u 用户名 -p 密码
WARNING! Using --password via the CLI is insecure. Use --password-stdin.
WARNING! Your password will be stored unencrypted in /root/.docker/config.json.
Configure a credential helper to remove this warning. See
https://docs.docker.com/engine/reference/commandline/login/#credentials-store

Login Succeeded

# 2、提交镜像
[root@localhost ~]# docker push diytomcat
Using default tag: latest
The push refers to repository [docker.io/library/diytomcat]
dd1ed0d0e1d1: Preparing 
a620338a6086: Preparing 
8815f1fb7c84: Preparing 
e84eea66db91: Preparing 
9abbea56fa36: Preparing 
74ddd0ec08fa: Waiting 
denied: requested access to the resource is denied		# 失败

# ***** 注意：push 后跟的镜像名必须是  用户名/镜像名:镜像标签  例如：lzhkk/diytomcat:1.0  所以push之前必须将镜像名改成这种格式
#       用户名就是你上面登录时的用户名
[root@localhost ~]# docker push lzhkk/diytomcat:1.0
The push refers to repository [docker.io/lzhkk/diytomcat]
dd1ed0d0e1d1: Pushed 
a620338a6086: Pushed 
8815f1fb7c84: Pushed 
e84eea66db91: Pushed 
9abbea56fa36: Pushed 
74ddd0ec08fa: Pushed 
1.0: digest: sha256:f328f8b2944c7b755cecd7c4ce313068cc24fe2b5dcd0961643439eff2817576 size: 1580		# 成功
# 提交的时候也是按照镜像的层级来进行提交的

发布到阿里云

1、登录阿里云

2、进入容器镜像服务

3、创建命名空间

4、创建容器镜像

输入仓库信息，点击下一步，代码源选择本地仓库

5、浏览阿里云（镜像仓库信息）

6、提交到阿里云

# 按照上图中的说明提交即可

提交完成后就可以在阿里云查看到

Dockerfile小结

Docker网络

理解Docker0

问题：docker 是如何处理容器网络访问的？

# Linux 可以直接Ping 通 dockers 容器内部
# 容器 和 容器 之间也是可以互相ping通的

原理（没办法测试，就没记笔记，视频地址：https://www.bilibili.com/video/BV1og4y1q7M4?p=34&spm_id_from=pageDriver

每启动一个docker容器，docker就会给docker容器分配一个ip，只要安装了docker，就会有一个网卡docker桥接模式，使用的技术是evth-pair技术！

# 结论：tomcat01和tomcat02是共用的一个路由器，docker0。所有的容器不指定网络的情况下，都是docker0路由的，docker会给我们的容器分配一个默认的可用IP

Docker0小结

Docker使用的是Linux的桥接，宿主机中是一个Docker容器的网桥 docker0。

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

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

–link

通过容器名来访问容器

[root@localhost ~]# docker run -itd -P --name tomcat01 ping/tomcat:v1 /bin/bash
f87e8c143237bff42675fd89d381621a0b76341a85bf82dcd7e79c926c668f89
# 使用 --link 连接其他容器
[root@localhost ~]# docker run -itd -P --name tomcat02 --link tomcat01 ping/tomcat:v1 /bin/bash
cc108b52a553d30313b1d9b669428f050319a49ad6fb6eb84e7ea2a16c2e40f4
# 这样就可以使用容器名来进行Ping
[root@localhost ~]# docker exec -it tomcat02 ping tomcat01
PING tomcat01 (172.17.0.2) 56(84) bytes of data.
64 bytes from tomcat01 (172.17.0.2): icmp_seq=1 ttl=64 time=0.115 ms
64 bytes from tomcat01 (172.17.0.2): icmp_seq=2 ttl=64 time=0.056 ms
64 bytes from tomcat01 (172.17.0.2): icmp_seq=3 ttl=64 time=0.054 ms
# 反向Ping不能Ping通，需要配置一些东西
[root@localhost ~]# docker exec -it tomcat01 ping tomcat02
ping: tomcat02: Name or service not known

# 查看tomcat02的网络配置
[root@localhost ~]# docker exec -it tomcat02 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.2	tomcat01 f87e8c143237		# --link直接将tomcat01映射写在了hosts文件中
172.17.0.3	cc108b52a553

# 查看tomcat01的配置
[root@localhost ~]# docker exec -it tomcat01 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.2	f87e8c143237				# 没有将tomcat02的映射写在里面，所以不能Ping通，需要自己手动写

# 现在不建议使用--link，比较麻烦
# 自定义网络，不适合docker0
# docker0问题：不支持容器名连接访问

自定义网络

查看所有的docker网络

[root@localhost ~]# docker network ls
NETWORK ID     NAME      DRIVER    SCOPE
55e6cbe1da69   bridge    bridge    local
4ab672893dd6   host      host      local
cf0dfc303c90   net01     bridge    local
69a9c7c3fc2b   none      null      local

网络模式

bridge：桥接 docker（默认，自己创建也是用bridge模式）

none：不配置网络

host： 和宿主机共享网络

container：容器网络连通（用的少，局限很大）

测试

# 直接启动的命令 --net bridge，而这个就是docker0
docker run -d -P --name tomcat01 --net bridge ping/tomcat:v1

# docker0 特点：默认，域名不能访问，--link可以打通连接

# 我们可以自定义一个网络

# 创建一个网络
## --driver		网络模式
## --subnet		子网
## --gateway	网关
## mynet	网络名
[root@localhost ~]# docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet
2f011cc000dc715ad2d6df6afb923fa7f7298b453b80209610aa2a26fd564420

# 运行两个使用同一个网络的容器
## 这种方式，即使不使用 --link 也可以直接 ping 容器名
[root@localhost ~]# docker run -itd -P --name tomcat-mynet01 --net mynet ping/tomcat:v1
47b80980071318281ca765780f6bbc777795223deccd246e73984d1d1fc8b024
[root@localhost ~]# docker run -itd -P --name tomcat-mynet02 --net mynet ping/tomcat:v1
3a5b72b57f008c067d21f30ce6f7e15522f547d90068b0afd9ad54cee2059034
[root@localhost ~]# docker exec -it tomcat-mynet02 ping tomcat-mynet01
PING tomcat-mynet01 (192.168.0.2) 56(84) bytes of data.
64 bytes from tomcat-mynet01.mynet (192.168.0.2): icmp_seq=1 ttl=64 time=0.079 ms
[root@localhost ~]# docker exec -it tomcat-mynet01 ping tomcat-mynet02
PING tomcat-mynet02 (192.168.0.3) 56(84) bytes of data.
64 bytes from tomcat-mynet02.mynet (192.168.0.3): icmp_seq=1 ttl=64 time=0.061 ms
64 bytes from tomcat-mynet02.mynet (192.168.0.3): icmp_seq=2 ttl=64 time=0.063 ms
[root@localhost ~]# docker exec -it tomcat-mynet01 ping 192.168.0.3
PING 192.168.0.3 (192.168.0.3) 56(84) bytes of data.
64 bytes from 192.168.0.3: icmp_seq=1 ttl=64 time=0.084 ms
64 bytes from 192.168.0.3: icmp_seq=2 ttl=64 time=0.062 ms

我们自定义的网络docker都已经帮我们维护好了对应的关系，推荐平时这样使用网络！

好处：

​ redis ------ 不同的集群使用不同的网络，保证集群是安全和健康的

​ mysql ----- 不同的集群使用不同的网络，保证集群是安全和健康的

网络连通

[root@localhost ~]# docker network --help

Usage:  docker network COMMAND

Manage networks

Commands:
  connect     Connect a container to a network			# 连接一个容器到一个网络（用于网络连通）
  create      Create a network							# 创建一个网络（用于自定义网络）
  disconnect  Disconnect a container from a network
  inspect     Display detailed information on one or more networks
  ls          List networks
  prune       Remove all unused networks
  rm          Remove one or more networks

Run 'docker network COMMAND --help' for more information on a command.


# 测试打通 tomcat01 -- mynet
docker network connect mynet tomcat01

# 查看mynet中的变化
# 连通之后就是将 tomcat01 放到了 mynet 网络下
# 相当于一个容器拥有了两个ip
[root@localhost ~]# docker network inspect mynet
[
    {
        "Name": "mynet",
        "Id": "2f011cc000dc715ad2d6df6afb923fa7f7298b453b80209610aa2a26fd564420",
        "Created": "2021-11-13T22:52:13.870308045-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": {
            "3a5b72b57f008c067d21f30ce6f7e15522f547d90068b0afd9ad54cee2059034": {
                "Name": "tomcat-mynet02",
                "EndpointID": "56a6eea55e9f2c678ad6f24afa7db0c8b39e1810837154c029952247a2ece64a",
                "MacAddress": "02:42:c0:a8:00:03",
                "IPv4Address": "192.168.0.3/16",
                "IPv6Address": ""
            },
            "47b80980071318281ca765780f6bbc777795223deccd246e73984d1d1fc8b024": {
                "Name": "tomcat-mynet01",
                "EndpointID": "1e7079468e8d51f37760566207e173902a493ba532365a3b8e55c37486f4dd77",
                "MacAddress": "02:42:c0:a8:00:02",
                "IPv4Address": "192.168.0.2/16",
                "IPv6Address": ""
            },
            
            #### 直接把tomcat01加入到了mynet网络
            
            "91658b1734719c7c63b1df31349f97f085e7d6e1f4fc996c7c4b5cc92a27bbfb": {
                "Name": "tomcat01",
                "EndpointID": "bf19063c2baa0404c69cd62be5f0585b7ef5498df84dd613870a6439fd2053a5",
                "MacAddress": "02:42:c0:a8:00:04",
                "IPv4Address": "192.168.0.4/16",
                "IPv6Address": ""
            }
        },
        "Options": {},
        "Labels": {}
    }
]

实战：部署Redis集群（这一部分需要用到Redis的知识）

# 创建网络
docker network create redis --subnet 172.38.0.0/16

# 通过脚本创建六个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 >/mdata/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

# 可以使用脚本启动6个容器
for port in $(seq 1 6);\
do \
docker run -p 637${port}:6379 -p 1637${port}:16379 --name redis-${port} \
-v /mydata/redis/node-${port}/data:/data \
-v /mydata/redis/node-${port}/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.1${port} redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf; \
done

# 一个一个启动
docker run -p 6371:6379 -p 16371: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 172.38.0.11 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf; \

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 172.38.0.12 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf; \

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 172.38.0.13 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf; \

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 172.38.0.14 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf; \

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 172.38.0.15 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf; \

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 172.38.0.16 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf; \

# 进入redis容器
[root@localhost conf]# docker exec -it redis-1 /bin/sh
/data #

# 创建集群
/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: 9b39477286ed77ad9ecd058533c170756f0aeb57 172.38.0.11:6379
   slots:[0-5460] (5461 slots) master
M: 6692bdc8724782fb8a881444d588adc23e225781 172.38.0.12:6379
   slots:[5461-10922] (5462 slots) master
M: d3dfbbc4d2424797c487d4ae1184e19f43431220 172.38.0.13:6379
   slots:[10923-16383] (5461 slots) master
S: d0197959655a6e3bcad615b9b45ee6724e4c1ddb 172.38.0.14:6379
   replicates d3dfbbc4d2424797c487d4ae1184e19f43431220
S: 384a2c33fbaf51c01c34b39a85b0c61ce16eded6 172.38.0.15:6379
   replicates 9b39477286ed77ad9ecd058533c170756f0aeb57
S: 7f86e7d38c410265a3a30159455820a494292e86 172.38.0.16:6379
   replicates 6692bdc8724782fb8a881444d588adc23e225781
Can I set the above configuration? (type 'yes' to accept): yes		# 这里要输入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: 9b39477286ed77ad9ecd058533c170756f0aeb57 172.38.0.11:6379
   slots:[0-5460] (5461 slots) master
   1 additional replica(s)
M: d3dfbbc4d2424797c487d4ae1184e19f43431220 172.38.0.13:6379
   slots:[10923-16383] (5461 slots) master
   1 additional replica(s)
S: 384a2c33fbaf51c01c34b39a85b0c61ce16eded6 172.38.0.15:6379
   slots: (0 slots) slave
   replicates 9b39477286ed77ad9ecd058533c170756f0aeb57
S: 7f86e7d38c410265a3a30159455820a494292e86 172.38.0.16:6379
   slots: (0 slots) slave
   replicates 6692bdc8724782fb8a881444d588adc23e225781
S: d0197959655a6e3bcad615b9b45ee6724e4c1ddb 172.38.0.14:6379
   slots: (0 slots) slave
   replicates d3dfbbc4d2424797c487d4ae1184e19f43431220
M: 6692bdc8724782fb8a881444d588adc23e225781 172.38.0.12:6379
   slots:[5461-10922] (5462 slots) master
   1 additional replica(s)
[OK] All nodes agree about slots configuration.
>>> Check for open slots...
>>> Check slots coverage...
[OK] All 16384 slots covered.

SpringBoot微服务打包Docker镜像

1、构建SpringBoot项目

# 编写一个SpringBoot项目

2、打包应用

# 将项目打包

3、编写Dockerfile

FROM java:8

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

4、构建镜像

# docker build -t 镜像名

5、发布运行

# 运行镜像容器

6、访问测试

使用Docker之后，给别人交付的就是一个镜像即

高级进阶笔记

Docker Compose

Docker Swarm

CI/CD之Jenkins