Docker学习笔记

Docker基本概念

镜像（image）

docker镜像类似模版，通过模版创建容器服务，通过镜像可以创建多个容器

容器（container）

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

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

容器可以理解为一个缩小版的虚拟机

仓库（repository）

仓库可以用来存储镜像

docker hub

阿里云

Doceker安装

环境准备

CentOS 7.9

Xshell

环境查看

[root@iZ0jl56q5vah4fbaul14gvZ ~]# uname -r
3.10.0-1160.90.1.el7.x86_64

[root@iZ0jl56q5vah4fbaul14gvZ ~]# 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”

安装

帮助文档

1.#移除旧版本
$ sudo yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-engine

2.#下载所需要的安装包
$ sudo yum install -y yum-utils

3.#设置镜像仓库
$ sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo  #默认国外镜像仓库，推荐使用阿里云
$ sudo yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo #阿里云镜像仓库

4.#更新yum
$ yum makecache fast

5.#安装docker
$ sudo yum install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin #ce为社区版

6.#启动docker
$ sudo systemctl start docker

7.#查看安装的docker版本
$ sudo docker version

8.#使用hello world测试docker
$ sudo docker run hello-world

9.#查看安装的docker镜像
$ sudo docker images

10.#配置镜像加速器（Cent OS）
sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://ms4l8wr7.mirror.aliyuncs.com"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker

至此docker安装基本完成

运行Hello world的流程

底层原理

1.Docker是如何工作的？

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

Docker-Server接收到一个Docker-Client的指令，就会执行这个命令。

2.Docker为什么比虚拟机更快？

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

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

在Docker新建一个容器时，不需要像虚拟机一样重新加载一个操作系统的内核，而是直接使用宿主机的内核。因此虚拟机加载是分级别，而Docker是秒级别

Docker常用命令

帮助命令

docker version 			#显示docker的版本信息  
docker info    			#显示docker的系统信息
docker  命令 --help	   #帮助命令

命令帮助文档：Reference documentation | Docker Documentation

镜像命令

docker images（镜像的命令）

Name, shorthand	Description
--all , -a	Show all images (default hides intermediate images)
--digests	Show digests
--filter , -f	Filter output based on conditions provided
--format	Format output using a custom template: ‘table’: Print output in table format with column headers (default) ‘table TEMPLATE’: Print output in table format using the given Go template ‘json’: Print in JSON format ‘TEMPLATE’: Print output using the given Go template. Refer to https://docs.docker.com/go/formatting/ for more information about formatting output with templates
--no-trunc	Don’t truncate output
--quiet , -q	Only show image IDs

[root@iZ0jl56q5vah4fbaul14gvZ ~]# docker images
REPOSITORY    TAG       IMAGE ID       CREATED        SIZE
hello-world   latest    9c7a54a9a43c   2 months ago   13.3kB

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

Docker search（搜索相关的镜像）

Name, shorthand	Description
--filter , -f	Filter output based on conditions provided
--format	Pretty-print search using a Go template
--limit	Max number of search results
--no-trunc	Don’t truncate output

[root@iZ0jl56q5vah4fbaul14gvZ ~]# docker search mysql
NAME                            DESCRIPTION                                     STARS     OFFICIAL   AUTOMATED
mysql                           MySQL is a widely used, open-source relation…   14321     [OK]       
mariadb                         MariaDB Server is a high performing open sou…   5467      [OK]       
percona                         Percona Server is a fork of the MySQL relati…   617       [OK]       
phpmyadmin                      phpMyAdmin - A web interface for MySQL and M…   836       [OK]  

Docker pull（镜像下载）

Name, shorthand	Default	Description
--all-tags , -a		Download all tagged images in the repository
--disable-content-trust	true	Skip image verification
--platform		Set platform if server is multi-platform capable
--quiet , -q		Suppress verbose output

[root@iZ0jl56q5vah4fbaul14gvZ ~]# docker pull mysql
Using default tag: latest      #如果不指定一个tag，会下载最新版
latest: Pulling from library/mysql
72a69066d2fe: Pull complete 	#分层下载，docker images的核心：联合文件系统    
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   命令等价

Docker rmi（删除镜像）

docker rmi -f [镜像id] [镜像id] [镜像id] #可单独删除一个或多个docker镜像
[root@iZ0jl56q5vah4fbaul14gvZ ~]# docker rmi -f 9c7a54a9a43c
Untagged: hello-world:latest
Untagged: hello-world@sha256:926fac19d22aa2d60f1a276b66a20eb765fbeea2db5dbdaafeb456ad8ce81598
Deleted: sha256:9c7a54a9a43cca047013b82af109fe963fde787f63f9e016fdc3384500c2823d

docker rmi -f $(docker images -aq) #删除所有的docker镜像
[root@iZ0jl56q5vah4fbaul14gvZ ~]# docker rmi -f $(docker images -aq)
Untagged: mysql:latest
Untagged: mysql@sha256:e9027fe4d91c0153429607251656806cc784e914937271037f7738bd5b8e7709
Deleted: sha256:3218b38490cec8d31976a40b92e09d61377359eab878db49f025e5d464367f3b
Deleted: sha256:aa81ca46575069829fe1b3c654d9e8feb43b4373932159fe2cad1ac13524a2f5
Deleted: sha256:0558823b9fbe967ea6d7174999be3cc9250b3423036370dc1a6888168cbd224d
Deleted: sha256:a46013db1d31231a0e1bac7eeda5ad4786dea0b1773927b45f92ea352a6d7ff9
Deleted: sha256:af161a47bb22852e9e3caf39f1dcd590b64bb8fae54315f9c2e7dc35b025e4e3
Deleted: sha256:feff1495e6982a7e91edc59b96ea74fd80e03674d92c7ec8a502b417268822ff
Deleted: sha256:8805862fcb6ef9deb32d4218e9e6377f35fb351a8be7abafdf1da358b2b287ba
Deleted: sha256:872d2f24c4c64a6795e86958fde075a273c35c82815f0a5025cce41edfef50c7
Deleted: sha256:6fdb3143b79e1be7181d32748dd9d4a845056dfe16ee4c827410e0edef5ad3da
Deleted: sha256:b0527c827c82a8f8f37f706fcb86c420819bb7d707a8de7b664b9ca491c96838
Deleted: sha256:75147f61f29796d6528486d8b1f9fb5d122709ea35620f8ffcea0e0ad2ab0cd0
Deleted: sha256:2938c71ddf01643685879bf182b626f0a53b1356138ef73c40496182e84548aa
Deleted: sha256:ad6b69b549193f81b039a1d478bc896f6e460c77c1849a4374ab95f9a3d2cea2

容器命令

有镜像才能创建容器，在服务器中再拉取一个Cent OS镜像，可以当做虚拟机进行学习

docker pull centos

新建容器并启动

docker run [可选参数] image

#参数说明
--name=“Name”    			#给容器取名
-d							#后台方式运行
-it							#使用交互方式运行，进入容器查看内容
-p							#指定容器的端口  如-p  8080:8080
							-p ip:主机端口:容器端口
							-p 主机端口:容器端口（常用）
							-p 容器端口
							容器端口
-P							#随机指定端口

[root@iZ0jl56q5vah4fbaul14gvZ ~]# docker run -it centos /bin/bash		#交互方式运行centos，并使用bash命令

[root@f5d9325ce6fa /]# ls												#进入了centos的交互页面
bin  dev  etc  home  lib  lib64  lost+found  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var
[root@f5d9325ce6fa /]# exit												#退出
exit

列出容器

docker ps			#可以查看正在运行的容器
#参数说明
-a					#曾经运行过+正在运行的容器
-n=?				#显示最近创建的容器
-q					#只显示容器的编号

[root@iZ0jl56q5vah4fbaul14gvZ ~]# docker ps
CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES
[root@iZ0jl56q5vah4fbaul14gvZ ~]# docker ps -a
CONTAINER ID   IMAGE          COMMAND       CREATED          STATUS                     PORTS     NAMES
f5d9325ce6fa   centos         "/bin/bash"   12 minutes ago   Exited (0) 6 minutes ago             romantic_chebyshev
b99c00522329   9c7a54a9a43c   "/hello"      2 hours ago      Exited (0) 2 hours ago               relaxed_shockley
[root@iZ0jl56q5vah4fbaul14gvZ ~]# docker ps -n=1
CONTAINER ID   IMAGE     COMMAND       CREATED          STATUS                     PORTS     NAMES
f5d9325ce6fa   centos    "/bin/bash"   12 minutes ago   Exited (0) 6 minutes ago             romantic_chebyshev
[root@iZ0jl56q5vah4fbaul14gvZ ~]# docker ps -q
[root@iZ0jl56q5vah4fbaul14gvZ ~]# docker ps -aq
f5d9325ce6fa
b99c00522329

退出容器

exit #直接停止容器并退出

Ctrl+p+q #只退出并不停止容器

删除容器

docker rm 容器id
docker rmi -f 容器id    #强制删除
#参数说明
-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 centos   #运行该命令会发现centos停止了，docker容器使用后台运行，必须要有一个前台进程。
#如nginx的容器启动后，无法给前台进程提供服务，就会立即停止该容器。

查看日志

docker logs -tf --tail 10 [容器id]		#显示10条最新的日志
-t					#显示时间戳
-f					#实时显示
--tail number		#要显示的日志条数

查看容器进程信息

docker top [容器id]

查看镜像元数据

docker inspect [容器id]

[root@iZ0jl56q5vah4fbaul14gvZ ~]# docker inspect centos
[
    {
        "Id": "sha256:5d0da3dc976460b72c77d94c8a1ad043720b0416bfc16c52c45d4847e53fadb6",
        "RepoTags": [
            "centos:latest"
        ],
        "RepoDigests": [
            "centos@sha256:a27fd8080b517143cbbbab9dfb7c8571c40d67d534bbdee55bd6c473f432b177"
        ],
        "Parent": "",
        "Comment": "",
        "Created": "2021-09-15T18:20:05.184694267Z",
        "Container": "9bf8a9e2ddff4c0d76a587c40239679f29c863a967f23abf7a5babb6c2121bf1",
        "ContainerConfig": {
            "Hostname": "9bf8a9e2ddff",
            "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",
                "#(nop) ",
                "CMD [\"/bin/bash\"]"
            ],
            "Image": "sha256:f5b050f177fd426be8fe998a8ecf3fb1858d7e26dff4080b29a327d1bd5ba422",
            "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"
            }
        },
        "DockerVersion": "20.10.7",
        "Author": "",
        "Config": {
            "Hostname": "",
            "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/bash"
            ],
            "Image": "sha256:f5b050f177fd426be8fe998a8ecf3fb1858d7e26dff4080b29a327d1bd5ba422",
            "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"
            }
        },
        "Architecture": "amd64",
        "Os": "linux",
        "Size": 231268856,
        "VirtualSize": 231268856,
        "GraphDriver": {
            "Data": {
                "MergedDir": "/var/lib/docker/overlay2/39c798c68c9e854aff3880d584176ad5dc49c6a74d08c2410c65215b78cc9b08/merged",
                "UpperDir": "/var/lib/docker/overlay2/39c798c68c9e854aff3880d584176ad5dc49c6a74d08c2410c65215b78cc9b08/diff",
                "WorkDir": "/var/lib/docker/overlay2/39c798c68c9e854aff3880d584176ad5dc49c6a74d08c2410c65215b78cc9b08/work"
            },
            "Name": "overlay2"
        },
        "RootFS": {
            "Type": "layers",
            "Layers": [
                "sha256:74ddd0ec08fa43d09f32636ba91a0a3053b02cb4627c35051aff89f853606b59"
            ]
        },
        "Metadata": {
            "LastTagTime": "0001-01-01T00:00:00Z"
        }
    }
]

进入当前正在运行的容器

#方式一
docker exec -it [容器id] /bin/bash

[root@iZ0jl56q5vah4fbaul14gvZ ~]# docker run -it centos /bin/bash
[root@7f9b3dd371b1 /]# [root@iZ0jl56q5vah4fbaul14gvZ ~]# docker ps
CONTAINER ID   IMAGE     COMMAND       CREATED          STATUS          PORTS     NAMES
7f9b3dd371b1   centos    "/bin/bash"   16 seconds ago   Up 16 seconds             dazzling_bardeen
[root@iZ0jl56q5vah4fbaul14gvZ ~]# docker exec -it 7f9b3dd371b1 /bin/bash
[root@7f9b3dd371b1 /]# ps
  PID TTY          TIME CMD
   21 pts/1    00:00:00 bash
   35 pts/1    00:00:00 ps
   
#方式二
docker attach [容器id]

[root@7f9b3dd371b1 /]# exit
exit
[root@iZ0jl56q5vah4fbaul14gvZ ~]# docker attach 7f9b3dd371b1
[root@7f9b3dd371b1 /]

两种方式的区别
docker exec 		#进入容器后开启新的终端，可以在里面进行操作
docker attach 		#进入容器正在执行的终端，不会启动新的进程

从容器内拷贝到主机

#命令
docker cp [容器id]:容器内路径 容器外路径

#容器内部在home目录下创建test.java
[root@7f9b3dd371b1 /]# cd /home
[root@7f9b3dd371b1 home]# touch test.java
[root@7f9b3dd371b1 home]# ls
test.java

#将test.java从容器拷贝到主机中
[root@iZ0jl56q5vah4fbaul14gvZ ~]# cd /home
[root@iZ0jl56q5vah4fbaul14gvZ home]# ls
[root@iZ0jl56q5vah4fbaul14gvZ home]# docker cp 7f9b3dd371b1:/home/test.java /home
Successfully copied 1.54kB to /home
[root@iZ0jl56q5vah4fbaul14gvZ home]# ls
test.java

小结

命令图

部署练习

部署nginx

1.#搜索相关的nginx镜像
docker search nginx

2.#拉取镜像
docker pull nginx

3.#启动nginx镜像并测试
docker run -d --name nginx01 -p 3340:80 nginx 

[root@iZ0jl56q5vah4fbaul14gvZ ~]# docker ps
CONTAINER ID   IMAGE     COMMAND                  CREATED         STATUS         PORTS                                   NAMES
5f0e7a77a3e4   nginx     "/docker-entrypoint.…"   7 seconds ago   Up 6 seconds   0.0.0.0:3340->80/tcp, :::3340->80/tcp   nginx01
4.#通过本地端口3344查看nginx01的网页内容

[root@iZ0jl56q5vah4fbaul14gvZ ~]# curl localhost:3340
curl: (7) Failed connect to localhost:3344; Connection refused			#发现错误，3340端口访问被拒绝连接。

查询资料发现是因为阿里服务器的安全组规则中没有加入3340端口，需要在阿里云控制台的安全组中加入3340端口的访问。再加入后即可查看内容，并且进入网页。

本地访问3340端口。

5.#进入nginx容器，查看相关配置文件。

root@iZ0jl56q5vah4fbaul14gvZ ~]# docker exec -it nginx01 /bin/bash			#以交互式进入nginx01容器中

root@5f0e7a77a3e4:/# whereis nginx																	#查看所有nginx文件夹所在的目录
nginx: /usr/sbin/nginx /usr/lib/nginx /etc/nginx /usr/share/nginx
root@5f0e7a77a3e4:/# cd  /etc/nginx
root@5f0e7a77a3e4:/etc/nginx# ls																			#查看相关配置文件
conf.d  fastcgi_params  mime.types  modules  nginx.conf  scgi_params  uwsgi_params

问题：每次改动nginx的配置文件都需要进入容器内部，因此可以在容器外部提供一个映射路径，达到在容器外修改文件名，容器内就可以自动修改。 这也就引出数据卷概念。

部署tomcat

#官方使用方法
docker run -it --rm tomcat:9.0(版本号)					#一般用来测试，即直接下载下来并运行，用完即删除，在docker ps -aq中查询不到。

1.#下载tomcat镜像
docker pull tomcat

2.#以暴露宿主机3355端口和容器8080端口方式启动tomcat01
#docker run -d -p 3355:8080 --name tomcat01 tomcat		#安全组中要加入3355端口

问题：#进入该网页发现是404页面

3.#进入容器内部并查看配置文件
docker exec -it tomcat01 /bin/bash

root@6a45c8c3bec0:/usr/local/tomcat# ls
BUILDING.txt  CONTRIBUTING.md  LICENSE  NOTICE  README.md  RELEASE-NOTES  RUNNING.txt  bin  conf  lib  logs  native-jni-lib  temp  webapps  webapps.dist  work
 
root@6a45c8c3bec0:/usr/local/tomcat# ll				问题1：#可以发现进入后缺少linux命令
bash: ll: command not found

root@6a45c8c3bec0:/usr/local/tomcat# cd webapps	
root@6a45c8c3bec0:/usr/local/tomcat/webapps# ls		问题2：#可以发现webapps中没有文件，阿里云镜像默认是最小的镜像，只保证最小的运行环境

4.阿里云的配置文件在webapps.dist中，将webapps.dist中的文件拷贝到webapps中
cp -r webapps.dist/* webapps

root@6a45c8c3bec0:/usr/local/tomcat# cd webapps
root@6a45c8c3bec0:/usr/local/tomcat/webapps# ls
ROOT  docs  examples  host-manager  manager				#webapps.dist中的文件已经被拷贝到webapps中

5.退出容器，再次通过公网进入网页

问题：部署项目后，配置文件都需要进入容器，十分麻烦。因此可以在容器外部提供一个映射的路径，在容器外部放置项目时，自动同步内部。

部署es+kibana

#es 暴露的端口多
#es 十分耗费内存
#es 数据一般需要放置到安全目录（挂载）
#	--net somenetwork 网络配置

1.下载启动es
docker run -d --name elasticsearch --net somenetwork -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch:7.6.2

#启动后 查看cpu状态 测试
docker status    #查看状态
CONTAINER ID   NAME            CPU %     MEM USAGE / LIMIT     MEM %     NET I/O      BLOCK I/O       PIDS
631bd6fe8a87   elasticsearch   1.76%     1.241GiB / 1.694GiB   73.26%    1.1kB / 0B   263MB / 729kB   42

#查看端口状态
[root@iZ0jl56q5vah4fbaul14gvZ ~]# curl localhost:9200
{
  "name" : "631bd6fe8a87",
  "cluster_name" : "docker-cluster",
  "cluster_uuid" : "3ci_kcMyQX-rGe-3_dMbyw",
  "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"
}
[root@iZ0jl56q5vah4fbaul14gvZ ~]# curl localhost:9300
This is not an HTTP port


#停止es后修改内存限制，修改配置文件，-e环境配置修改
docker run -d --name elasticsearch01 --net somenetwork -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" -e ES_JAVA_OPTS="-Xms64m -Xmx512m" elasticsearch:7.6.2

[root@iZ0jl56q5vah4fbaul14gvZ ~]# docker run -d --name elasticsearch01 --net somenetwork -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" -e ES_JAVA_OPTS="-Xms64m -Xmx512m" elasticsearch:7.6.2
bed2c7f632191aeeb415221e0b7a988485d5116af47b7bbfd6f7bfe8b63416c3
[root@iZ0jl56q5vah4fbaul14gvZ ~]# docker ps
CONTAINER ID   IMAGE                 COMMAND                  CREATED          STATUS          PORTS                                                                                  NAMES
bed2c7f63219   elasticsearch:7.6.2   "/usr/local/bin/dock…"   16 seconds ago   Up 15 seconds   0.0.0.0:9200->9200/tcp, :::9200->9200/tcp, 0.0.0.0:9300->9300/tcp, :::9300->9300/tcp   elasticsearch01

docker status    #查看状态,keyi
CONTAINER ID   NAME              CPU %     MEM USAGE / LIMIT     MEM %     NET I/O     BLOCK I/O       PIDS
bed2c7f63219   elasticsearch01   1.05%     394.8MiB / 1.694GiB   22.76%    656B / 0B   126MB / 729kB   44

kibana的启动需要es先启动，但需要配置网络 doker网络原理

可视化面板安装

• portainer

docker run -d -p 8088:9000 \
--restart=always -v /var/run/docker.sock:/var/run/docker.sock --privileged=true portainer/portainer

• Rancher(CI/CD再用)

什么是protainer

Docker图形化界面管理工具，提供一个后台面板供我们操作。

访问测试：外网：8088，选择本地连接后，就会进入可视化界面。

因为点了两次local，因此出现了两个local

Docker镜像

镜像是什么

镜像可以理解为应用程序的集装箱，是一种轻量级、可执行的独立软件包，用来打包软件运行环境和基于运行环境开发的软件，包含运行某个软件所需的所有内容，包括代码、运行时库、环境变量和配置文件。而docker用来装卸集装箱，docker镜像含有启动容器所需要的文件系统及其内容，因此，其用于创建并启动容器

Docker镜像加载原理

UnionFS（联合文件系统）

2004年由纽约州立大学石溪分校开发，它可以把多个目录(也叫分支)内容联合挂载到同一个目录下，而目录的物理位置是分开的。UnionFS允许只读和可读写目录并存，就是说可同时删除和增加内容。docker中使用到了UnionFS，任何程序运行时都会有依赖，无论是开发语言层的依赖库，还是各种系统lib、操作系统等，不同的系统上这些库可能是不一样的，或者有缺失的。为了让容器运行时一致，docker将依赖的操作系统、各种lib依赖整合打包在一起（即镜像），然后容器启动时，作为它的根目录（根文件系统rootfs），使得容器进程的各种依赖调用都在这个根目录里，这样就做到了环境的一致性。

docker镜像加载原理

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

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

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

对于一个精简的OS，rootfs可以很小，只需要包含最基本的命令、工具和程序库就可以了，因为底层直接用Host的kernel，自己只需要提供rootfs就可以了。由此可见对于不同的linux发行版，bootfs基本是一致的，rootfs会有差别，因此不同发行版可以公用bootfs。这也就是容器的启动比虚拟机快的原因。

分层理解

#下载镜像时的下载过程
[root@iZ0jl56q5vah4fbaul14gvZ ~]# docker pull redis			//下载一个镜像
Using default tag: latest
latest: Pulling from library/redis			
a2abf6c4d29d: Already exists 				#已经下载过的文件不需要重新下载
c7a4e4382001: Pull complete 
4044b9ba67c9: Pull complete 
c8388a79482f: Pull complete 
413c8bb60be2: Pull complete 
1abfd3011519: Pull complete 

#查看镜像分层
[root@iZ0jl56q5vah4fbaul14gvZ ~]# docker image inspect redis:latest

"RootFS": {																						#rootfs文件系统
            "Type": "layers",
            "Layers": [
                "sha256:2edcec3590a4ec7f40cf0743c15d78fb39d8326bc029073b41ef9727da6c851f",		#第一层为centos系统层
                "sha256:9b24afeb7c2f21e50a686ead025823cd2c6e9730c013ca77ad5f115c079b57cb",
                "sha256:4b8e2801e0f956a4220c32e2c8b0a590e6f9bd2420ec65453685246b82766ea1",
                "sha256:529cdb636f61e95ab91a62a51526a84fd7314d6aab0d414040796150b4522372",
                "sha256:9975392591f2777d6bf4d9919ad1b2c9afa12f9a9b4d260f45025ec3cc9b18ed",
                "sha256:8e5669d8329116b8444b9bbb1663dda568ede12d3dbcce950199b582f6e94952"
            ]
        },

所有的Docker镜像起始于一个基础镜像层，当进行修改或增加新的内容时，就会在当前镜像层之上，创建新的镜像层。

如下图，基于Ununtu Linux 16.04创建一个新的镜像，这是新镜像的第一层；如果在该镜像中添加Python包，该镜像当前已经包含了三个镜像层。

特点

Docker镜像默认只读。只有当容器启动时，一个新的可写层才会被加载到镜像的顶部！

这一层就是我们说的容器层，容器之下都叫做镜像层。

如将一个镜像下载后，可以在镜像之上也就是容器层进行操作，在此之后可以将该容器再打包成一个镜像。

commit镜像

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

#命令和git操作类似
docker commit -m-"提交的描述信息" -a-"作者" 容器id 目标镜像名:tag

实战测试

#1.启动一个默认的tomcat
docker run -d -p 3355:8080 --name tomcat01 tomcat

#2.发现这个默认的tomcat是没有webapps应用，因此拷贝了webapps.dist中的文件进去
cp -r webapps.dist/* webapps

#3.将修改过的tomcat01打包成一个容器上传的到本地镜像中
docker commit -m-"add webapps.dist to webapps" -a-"wxl" 6f1c12c87545 tomcatadd:1.0
 
[root@iZ0jl56q5vah4fbaul14gvZ ~]# docker images
REPOSITORY            TAG       IMAGE ID       CREATED          SIZE
tomcatadd             1.0       f7a6500a6574   42 seconds ago   684MB			#可以看到tomcatadd已经添加到本地镜像库
nginx                 latest    605c77e624dd   18 months ago    141MB
tomcat                latest    fb5657adc892   19 months ago    680MB
redis                 latest    7614ae9453d1   19 months ago    113MB
centos                latest    5d0da3dc9764   22 months ago    231MB
portainer/portainer   latest    580c0e4e98b0   2 years ago      79.1MB
elasticsearch         7.6.2     f29a1ee41030   3 years ago      791MB

容器数据卷

什么是容器数据卷

如果数据都在容器中，如果将容器删除，数据就会丢失。因此需要将数据持久化。

例：将mysql容器删除后，数据也被删除了。但mysql中的数据并不能被删除，需要存储在本地。

容器之间有一个数据共享的技术！Docker容器中产生的数据，同步到本地。

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

因此总结是：容器的持久化和同步操作。容器间也可以进行数据共享

使用数据卷

方式一：命令挂载

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

#以命令挂载方式运行centos镜像
docker run -it -v /home/test:/home centos /bin/bash

#查看该容器的元数据
docker inspect 3cc83c9e94f9

挂载信息

#在宿主机的/home/test目录下创建test.cc
touch test.cc

#可以看到宿主机的/home/test目录下的文件和容器中/home目录下是实现了共享
[root@iZ0jl56q5vah4fbaul14gvZ test]# ls
test.cc

[root@3cc83c9e94f9 home]# ls
test.cc

#如果在容器停止后，在宿主机上修改挂载的文件，容器内部依旧是同步的

总结：以后修改只需在宿主机修改数据，不需要再进入容器中修改。

实战：安装MySQL

#拉取mysql镜像
docker pull mysql:5.7

#官方启动命令  需要配置密码
docker run --name some-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag

#运行mysql，-d为后台启动，-p将端口进行映射，-v数据卷挂载，-e环境配置
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=123456 --name mysql01 mysql:5.7

[root@iZ0jl56q5vah4fbaul14gvZ /]# 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=123456 --name mysql01 mysql:5.7
8bb26c90a10242353e56099b7fd9d1c56ccd50325147bfaffaee4846fab7003e
[root@iZ0jl56q5vah4fbaul14gvZ /]# docker ps
CONTAINER ID   IMAGE       COMMAND                  CREATED          STATUS          PORTS                                                  NAMES
8bb26c90a102   mysql:5.7   "docker-entrypoint.s…"   54 seconds ago   Up 53 seconds   33060/tcp, 0.0.0.0:3310->3306/tcp, :::3310->3306/tcp   mysql01

#数据已经挂载，同步
[root@iZ0jl56q5vah4fbaul14gvZ home]# ls
mysql  test  test.java

#启动成功后，使用本地sqlyog测试

#sqlyog-连接到服务器的3310，服务器的3310端口和容器内的3306映射。

#将容器删除后，挂载到本地的数据卷依旧没有丢失。

具名挂载和匿名挂载

#匿名挂载
-v容器内路径
docker run -d -P --name nginx01 -v /etc/nginx nginx

#查看所有卷
docker volume ls

[root@iZ0jl56q5vah4fbaul14gvZ /]# docker volume ls
DRIVER    VOLUME NAME	
local     b742eafb809a56eb493e7cc002e25417d7e787255c9e82e3bd6faa4f0b2bfb6d			#无指定名字，都属于匿名挂载，匿名卷
local     e9ba895fa00dcdfa8933ae211e3330472baff5b514c518369539875a5a8ed304			#-v时只写了容器内的路径，未写容器外路径

#具名挂载	-v 卷名:容器内路径
docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx nginx

[root@iZ0jl56q5vah4fbaul14gvZ /]# docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx nginx
9dd5e7667ebaa99f69aaaf843ea6401a422f847b681b20e8928566d9b64cd1a1

#查看所有卷，可以看到是刚刚创建的juming-nginx
[root@iZ0jl56q5vah4fbaul14gvZ /]# docker volume ls		
DRIVER    VOLUME NAME
local     b742eafb809a56eb493e7cc002e25417d7e787255c9e82e3bd6faa4f0b2bfb6d
local     e9ba895fa00dcdfa8933ae211e3330472baff5b514c518369539875a5a8ed304
local     juming-nginx

#查看具名挂载的具体目录位置
docker volume inspect juming-nginx

[root@iZ0jl56q5vah4fbaul14gvZ /]# docker volume inspect juming-nginx
[
    {
        "CreatedAt": "2023-07-21T16:53:01+08:00",
        "Driver": "local",
        "Labels": null,
        "Mountpoint": "/var/lib/docker/volumes/juming-nginx/_data",		#容器挂载在宿主机中的具体位置
        "Name": "juming-nginx",
        "Options": null,
        "Scope": "local"
    }
]
#所有docker容器内的卷，在没有指定宿主机目录的情况下都默认在/var/lib/docker/volumes/卷名/_data
具名挂载可以找到挂载的位置。

#确定匿名挂载和具名挂载、指定路径挂载
-v 容器内路径			#匿名挂载
-v 卷名:容器内路径			#具名挂载
-v /宿主机路径::容器内路径	#指定路径挂载

拓展：

# 通过-v容器内路径：ro，rw改变读写权限
ro		readonly	#只读
rw		readwrite	#可读可写

#一旦设置了容器权限，容器对我们挂载出来的内容就有限定
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

DockerFile

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

构建步骤：

1.编写一个dockerfile文件

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

3.docker run运行镜像

4.docker push 发布镜像（DockerHub、阿里云）

Dockerfile构建过程

基础知识：

1.每个保留关键字都必须是大写字母

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

3.#表示注释

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

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

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

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

docker容器：容器就是镜像运行后提供服务的

DockerFile指令

FROM						#基础镜像，从此构建，如centos
MAINTAINER					#构建者，姓名+邮箱
RUN							#镜像构建时需要的命令
ADD							#添加内容，如添加tomcat镜像
WORKDIR						#镜像的工作目录
VOLUME						#挂载的目录位置
EXPOSE						#保留端口位置
CMD							#指定这个容器启动的时候要运行的命令，只有最后一个会生效，可被替代
ENTRYPOINT					#指定这个容器启动的时候要运行的命令，可以追加命令
ONBUTLD						#当构建一个呗继承DockerFile，这个时候就运行ONBUTLD的指令，触发指令。
COPY						#类似ADD，将文件拷贝到镜像中
ENV							#构建的时候配置环境变量

CMD 和ENTRYPOINT区别

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

#cmd命令

#编写dockerfile文件
[root@iZ0jl56q5vah4fbaul14gvZ dockerfile]# cat dockerfile-cmd-test 
FROM centos
CMD ["ls","-a"]

#构建镜像
[root@iZ0jl56q5vah4fbaul14gvZ dockerfile]# docker build -f dockerfile-cmd-test -t cmdtest .

#run运行，命令生效
[root@iZ0jl56q5vah4fbaul14gvZ dockerfile]# docker run 7d202bdf002b
.
..
.dockerenv
bin
dev
etc
home
lib
lib64

#追加-l命令发生错误
[root@iZ0jl56q5vah4fbaul14gvZ dockerfile]# docker run 7d202bdf002b -l
docker: Error response from daemon: failed to create task for container: failed to create shim task: OCI runtime create failed: runc create failed: unable to start container process: exec: "-l": executable file not found in $PATH: unknown.

#需要在最后加上完整的cmd命令，解释了“指定这个容器启动的时候要运行的命令，只有最后一个命令会生效，且可替代之前的命令”
[root@iZ0jl56q5vah4fbaul14gvZ dockerfile]# docker run 7d202bdf002b ls -al
total 56
drwxr-xr-x   1 root root 4096 Jul 24 06:37 .
drwxr-xr-x   1 root root 4096 Jul 24 06:37 ..
-rwxr-xr-x   1 root root    0 Jul 24 06:37 .dockerenv
lrwxrwxrwx   1 root root    7 Nov  3  2020 bin -> usr/bin
drwxr-xr-x   5 root root  340 Jul 24 06:37 dev
drwxr-xr-x   1 root root 4096 Jul 24 06:37 etc
drwxr-xr-x   2 root root 4096 Nov  3  2020 home
lrwxrwxrwx   1 root root    7 Nov  3  2020 lib -> usr/lib
lrwxrwxrwx   1 root root    9 Nov  3  2020 lib64 -> usr/lib64

#ENTRYPOINT命令

#编写dockerfile文件
[root@iZ0jl56q5vah4fbaul14gvZ dockerfile]# cat dockerfile-cmd-test01
FROM centos

ENTRYPOINT [“ls”,“-a”]

#构建镜像
[root@iZ0jl56q5vah4fbaul14gvZ dockerfile]# docker build -f dockerfile-cmd-test01 -t cmdtest01 .

#在命令后面追加-l运行，可以发现是可以运行的，解释了“指定这个容器启动的时候要运行的命令，可以追加命令”

[root@iZ0jl56q5vah4fbaul14gvZ dockerfile]# docker run cmdtest01 -l
total 56
drwxr-xr-x 1 root root 4096 Jul 24 06:43 .
drwxr-xr-x 1 root root 4096 Jul 24 06:43 …
-rwxr-xr-x 1 root root 0 Jul 24 06:43 .dockerenv
lrwxrwxrwx 1 root root 7 Nov 3 2020 bin -> usr/bin
drwxr-xr-x 5 root root 340 Jul 24 06:43 dev
drwxr-xr-x 1 root root 4096 Jul 24 06:43 etc
drwxr-xr-x 2 root root 4096 Nov 3 2020 home
lrwxrwxrwx 1 root root 7 Nov 3 2020 lib -> usr/lib
lrwxrwxrwx 1 root root 9 Nov 3 2020 lib64 -> usr/lib64

练习

Docker Hub中99%的镜像都是从基础镜像scratch配置出来的

创建一个自己的centos

1.编写dockerfile文件

在home目录下创建dockerfile文件夹，在该文件夹中创建mydockerfile-centos

在该文件夹中添加内容

[root@iZ0jl56q5vah4fbaul14gvZ dockerfile]# cat mydockerfile-centos FROM centos

MAINTAINER wuxuanlong<727087616@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 docker文件路径 -t 想要的镜像名:[tag]
docker build -f mydockerfile-centos -t mycentos:1.0 .

安装出现问题

yum下载出现No URLs in mirrorlist error的原因大致为：
Centos8不再维护，在2022年1月31日，CentOS团队从官方镜像中移除CentOS 8的所有包。
解决方式：dockerfile第一行FROM centos:7

3.测试运行

docker run -it mycentos:1.0

创建Tomcat镜像

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

2.编写dockerfile文件，官方命名Dockerfile，build会自动寻找

3.构建镜像

4.启动镜像

5.访问测试

6.发布项目（做了卷挂载，可以只在本地编写项目并发布）

结论：掌握Dokcerfile的编写，使用docker镜像来发布运行

发布镜像

发布镜像到DockerHub

1.注册账号

2.确定账号可以登录docker login -u 用户名

3.在自己的服务器中提交自己的镜像

4.登录完毕后就可以提交镜像，一步docker push 用户名/镜像名:tag

发布镜像到阿里云

1.登录阿里云

2.找到容器镜像服务

3.创建命名空间

4.创建创建容器镜像

5.浏览基本信息，其中包含登录、提交镜像等命令

小结

Docker网络

主要研究Docker如何处理容器网络访问

理解Docker0

#原始网络配置

[root@iZ0jl56q5vah4fbaul14gvZ ~]# 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
    inet6 ::1/128 scope host 
       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:cc:e9 brd ff:ff:ff:ff:ff:ff
    inet 172.21.144.95/20 brd 172.21.159.255 scope global dynamic eth0			#阿里云内网地址
       valid_lft 314929269sec preferred_lft 314929269sec
    inet6 fe80::216:3eff:fe03:cce9/64 scope link 
       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:23:75:1d:3d brd ff:ff:ff:ff:ff:ff
    inet 172.17.0.1/16 brd 172.17.255.255 scope global docker0					#docker0地址
       valid_lft forever preferred_lft forever
    inet6 fe80::42:23ff:fe75:1d3d/64 scope link 
       valid_lft forever preferred_lft forever

测试

[root@iZ0jl56q5vah4fbaul14gvZ ~]# docker run -d -P --name tomcat01 tomcat					#运行tomcat

[root@iZ0jl56q5vah4fbaul14gvZ ~]# docker exec -it tomcat01 ifconfig							#查看容器tomcat01地址
eth0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
        inet 172.17.0.2  netmask 255.255.0.0  broadcast 172.17.255.255
        ether 02:42:ac:11:00:02  txqueuelen 0  (Ethernet)
        RX packets 4860  bytes 9357688 (8.9 MiB)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 4708  bytes 328902 (321.1 KiB)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

lo: flags=73<UP,LOOPBACK,RUNNING>  mtu 65536
        inet 127.0.0.1  netmask 255.0.0.0
        loop  txqueuelen 1000  (Local Loopback)
        RX packets 0  bytes 0 (0.0 B)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 0  bytes 0 (0.0 B)
        
[root@iZ0jl56q5vah4fbaul14gvZ ~]# ping 172.17.0.2									#在宿主机可以ping通容器
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.045 ms
64 bytes from 172.17.0.2: icmp_seq=2 ttl=64 time=0.045 ms

原理

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

[root@iZ0jl56q5vah4fbaul14gvZ ~]# docker run -d -P --name tomcat01 tomcat
[root@iZ0jl56q5vah4fbaul14gvZ ~]#  ip addr				#启动容器后，地址中出现新的网卡
72: vethffe85e6@if71: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue master docker0 state UP group default 
    link/ether 5a:14:ba:c5:c7:69 brd ff:ff:ff:ff:ff:ff link-netnsid 0
    inet6 fe80::5814:baff:fec5:c769/64 scope link 
    	valid_lft forever preferred_lft forever

​

2.再启动一个容器，还会出现新网卡

[root@iZ0jl56q5vah4fbaul14gvZ ~]# docker run -d -P --name tomcat02 tomcat
[root@iZ0jl56q5vah4fbaul14gvZ ~]#  ip addr
72: vethffe85e6@if71: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue master docker0 state UP group default 
    link/ether 5a:14:ba:c5:c7:69 brd ff:ff:ff:ff:ff:ff link-netnsid 0
    inet6 fe80::5814:baff:fec5:c769/64 scope link 
       valid_lft forever preferred_lft forever
74: veth94fccba@if73: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue master docker0 state UP group default 
    link/ether a2:65:f1:4a:2b:8e brd ff:ff:ff:ff:ff:ff link-netnsid 1
    inet6 fe80::a065:f1ff:fe4a:2b8e/64 scope link 
       valid_lft forever preferred_lft forever

​ #可以发现容器带来的网卡都是一对一对的，是因为evth-pair就是一对的虚拟设备接口，都是成对出现，一段连着协议，一段彼此相连，正因为这个特性，evth-pair是充当一个桥梁，连接着各种虚拟网络设备。

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

#Dokcer中的所有网络接口都是虚拟的。当容器删除后，对应网桥就断了。

–link

项目不重启，ip被换掉，能否通过名字来访问容器？

–link：在启动容器时可以在容器的hosts配置容器名和ip地址的映射关系，与dns本质是一样的，实际上现在已经不实用。

#在启动tomcat03时，将tomcat02与tomcat03连接

docker run -d -P --name tomcat03 --link tomcat02 tomcat
docker exec it tomcat03 ping tomcat02


[root@iZ0jl56q5vah4fbaul14gvZ ~]# docker run -d -P --name tomcat03 --link tomcat02 tomcat

#可以看到，可以通过容器名直接ping通，但反之不行
[root@iZ0jl56q5vah4fbaul14gvZ ~]# 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.080 ms
64 bytes from tomcat02 (172.17.0.3): icmp_seq=2 ttl=64 time=0.054 ms
64 bytes from tomcat02 (172.17.0.3): icmp_seq=3 ttl=64 time=0.051 ms

[root@iZ0jl56q5vah4fbaul14gvZ ~]# docker exec -it tomcat02 ping tomcat03
ping: tomcat03: Name or service not known

#原理：进入tomcat03的hosts配置文件，可以看到已经配置了映射关系
[root@iZ0jl56q5vah4fbaul14gvZ ~]# 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 4beebb96f77d
172.17.0.4      13cd00513c8a

自定义网络

容器互联

#查看所有网络
[root@iZ0jl56q5vah4fbaul14gvZ ~]# docker network ls
NETWORK ID     NAME          DRIVER    SCOPE
9db7598bd206   bridge        bridge    local
cead555f8864   host          host      local
6e5953d1163d   none          null      local
b65636a27fef   somenetwork   bridge    local

网络模式

bridge：桥接docker（默认）

none：不配置网络

host：和宿主机共享网络

container：容器网络联通(局限大)

测试

#默认--net bridge
docker run -it --name tomcat01 --net bridge tomcat

#创建网络
docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet

#可以看到mynet已经被添加在网络中
[root@iZ0jl56q5vah4fbaul14gvZ ~]# docker network ls
NETWORK ID     NAME          DRIVER    SCOPE
9db7598bd206   bridge        bridge    local
cead555f8864   host          host      local
6fb7d73bf669   mynet         bridge    local
6e5953d1163d   none          null      local
b65636a27fef   somenetwork   bridge    local

#以设置好的网络启动两个容器
docker run -d -P --name tomcat-net-01 --net mynet tomcat
docker run -d -P --name tomcat-net-02 --net mynet tomcat

#查看网络配置信息，可以看到两个容器的网络已经分配在该网络配置中，容器处于同一个局域网中，且容器之间可以相互ping通
"Containers": {
            "532b358f73abb617168c9320ccaa6561ffc20cf34d27586e1e4a90ddb4168304": {
                "Name": "tomcat-net-01",	
                "EndpointID": "2deb616b132240467fa345ba3ba114dff73c283da03cb8ad1d0054e08d4ead6b",
                "MacAddress": "02:42:c0:a8:00:02",
                "IPv4Address": "192.168.0.2/16",		
                "IPv6Address": ""
            },
            "5432c51c6aff084734daaccdee04d3f056f2ac6ee0a77deb0f35e81101f5a808": {
                "Name": "tomcat-net-02",
                "EndpointID": "159bafabea8c18ab13e8b70fc97706af31686cd6b804ffb3d56af31a2a7dddd7",
                "MacAddress": "02:42:c0:a8:00:03",
                "IPv4Address": "192.168.0.3/16",
                "IPv6Address": ""
            }
        },

自定义网络优点：

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

网络连通

两个网段不同，不能相连，只能通过创建的自定义网络进行连接。

#查看docker的网络命令
[root@iZ0jl56q5vah4fbaul14gvZ ~]# 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
  

#可以发现容器ping不通已经加入mynet网络中的容器
[root@iZ0jl56q5vah4fbaul14gvZ ~]# docker exec -it tomcat01 ping tomcat-net-01
ping: tomcat-net-01: Name or service not known

#使用network将tomcat01加入到mynet网段中，发现可以ping通
[root@iZ0jl56q5vah4fbaul14gvZ ~]# docker network connect mynet tomcat01
[root@iZ0jl56q5vah4fbaul14gvZ ~]# 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.062 ms
64 bytes from tomcat-net-01.mynet (192.168.0.2): icmp_seq=2 ttl=64 time=0.054 ms
64 bytes from tomcat-net-01.mynet (192.168.0.2): icmp_seq=3 ttl=64 time=0.056 ms

#查看网络配置信息，发现tomcat01也已经被加入到mynet网段中
        "Containers": {
            "532b358f73abb617168c9320ccaa6561ffc20cf34d27586e1e4a90ddb4168304": {
                "Name": "tomcat-net-01",
                "EndpointID": "2deb616b132240467fa345ba3ba114dff73c283da03cb8ad1d0054e08d4ead6b",
                "MacAddress": "02:42:c0:a8:00:02",
                "IPv4Address": "192.168.0.2/16",
                "IPv6Address": ""
            },
            "5432c51c6aff084734daaccdee04d3f056f2ac6ee0a77deb0f35e81101f5a808": {
                "Name": "tomcat-net-02",
                "EndpointID": "159bafabea8c18ab13e8b70fc97706af31686cd6b804ffb3d56af31a2a7dddd7",
                "MacAddress": "02:42:c0:a8:00:03",
                "IPv4Address": "192.168.0.3/16",
                "IPv6Address": ""
            },
            "b4ddcfa224c22fdb1204f856c49ed3246baf601b682fda2ff3726e3d7420c7bd": {
                "Name": "tomcat01",
                "EndpointID": "3cfd4c21188241e07495431f6436c7b478ff0c0337ed8c0eb3d234e4245f3a99",
                "MacAddress": "02:42:c0:a8:00:04",
                "IPv4Address": "192.168.0.4/16",
                "IPv6Address": ""
            }
        },
        
#同时发现tomcat01中的网络配置中有两个ip地址，一个是在docker中的，一个是在mynet中的
[root@iZ0jl56q5vah4fbaul14gvZ ~]# docker exec -it tomcat01 ifconfig
eth0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
        inet 172.17.0.2  netmask 255.255.0.0  broadcast 172.17.255.255
        ether 02:42:ac:11:00:02  txqueuelen 0  (Ethernet)
        RX packets 4875  bytes 9358756 (8.9 MiB)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 4728  bytes 330476 (322.7 KiB)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

eth1: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
        inet 192.168.0.4  netmask 255.255.0.0  broadcast 192.168.255.255
        ether 02:42:c0:a8:00:04  txqueuelen 0  (Ethernet)
        RX packets 13  bytes 1034 (1.0 KiB)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 5  bytes 378 (378.0 B)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

实战：部署Redis集群

部署一个集群需要创建6个容器，因此使用shell脚本进行创建

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

[root@iZ0jl56q5vah4fbaul14gvZ ~]# docker network ls
NETWORK ID     NAME          DRIVER    SCOPE
9db7598bd206   bridge        bridge    local
cead555f8864   host          host      local
6fb7d73bf669   mynet         bridge    local
6e5953d1163d   none          null      local
463fc9fe54e9   redis         bridge    local
b65636a27fef   somenetwork   bridge    local

#通过脚本创建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 172.38.0.1${port}
cluster-announce-port 6379
cluster-announce-bus-port 16379
appendonly yes
EOF
done

#可以看到运行shell命令后，文件都已经配置好
[root@iZ0jl56q5vah4fbaul14gvZ ~]# 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
[root@iZ0jl56q5vah4fbaul14gvZ ~]# cd /mydata/
[root@iZ0jl56q5vah4fbaul14gvZ mydata]# ls
redis
[root@iZ0jl56q5vah4fbaul14gvZ mydata]# cd redis/
[root@iZ0jl56q5vah4fbaul14gvZ redis]# ls
node-1  node-2  node-3  node-4  node-5  node-6
[root@iZ0jl56q5vah4fbaul14gvZ redis]# cd node-1
[root@iZ0jl56q5vah4fbaul14gvZ node-1]# ls
conf
[root@iZ0jl56q5vah4fbaul14gvZ node-1]# cd conf/
[root@iZ0jl56q5vah4fbaul14gvZ conf]# ls
redis.conf
[root@iZ0jl56q5vah4fbaul14gvZ conf]# cat 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.11
cluster-announce-port 6379
cluster-announce-bus-port 16379
appendonly yes


#启动redis服务,需要启动6个结点
#启动结点1
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

#进入第一个结点,并创建集群
docker exec -it redis-1 /bin/sh
[root@iZ0jl56q5vah4fbaul14gvZ conf]# docker exec -it redis-1 /bin/sh
/data # ls
appendonly.aof  nodes.conf

#配置集群
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

#集群配置完成
/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: c17f9c56ba671110a5a3fd4ea30c7509eed4a923 172.38.0.11:6379
   slots:[0-5460] (5461 slots) master
M: 672134d9fce7fe959644e58bc268454c64f7d2a6 172.38.0.12:6379
   slots:[5461-10922] (5462 slots) master
M: 3638f248d1a2fc75b042d7fc305937e6c2bb2180 172.38.0.13:6379
   slots:[10923-16383] (5461 slots) master
S: 1cbf088496b721beb34321a7f298331123468a2b 172.38.0.14:6379
   replicates 3638f248d1a2fc75b042d7fc305937e6c2bb2180
S: 87e9d6d4238d009d77fb5af9c3efe6f0aeee9556 172.38.0.15:6379
   replicates c17f9c56ba671110a5a3fd4ea30c7509eed4a923
S: 1bf3bf310ea6017a6077b264afd7f724b654ecdc 172.38.0.16:6379
   replicates 672134d9fce7fe959644e58bc268454c64f7d2a6
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: c17f9c56ba671110a5a3fd4ea30c7509eed4a923 172.38.0.11:6379
   slots:[0-5460] (5461 slots) master
   1 additional replica(s)
S: 87e9d6d4238d009d77fb5af9c3efe6f0aeee9556 172.38.0.15:6379
   slots: (0 slots) slave
   replicates c17f9c56ba671110a5a3fd4ea30c7509eed4a923
S: 1bf3bf310ea6017a6077b264afd7f724b654ecdc 172.38.0.16:6379
   slots: (0 slots) slave
   replicates 672134d9fce7fe959644e58bc268454c64f7d2a6
S: 1cbf088496b721beb34321a7f298331123468a2b 172.38.0.14:6379
   slots: (0 slots) slave
   replicates 3638f248d1a2fc75b042d7fc305937e6c2bb2180
M: 3638f248d1a2fc75b042d7fc305937e6c2bb2180 172.38.0.13:6379
   slots:[10923-16383] (5461 slots) master
   1 additional replica(s)
M: 672134d9fce7fe959644e58bc268454c64f7d2a6 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.

#进入redis控制，可以看到redis集群搭建完成，且显示了主从结点
/data # redis-cli -c
127.0.0.1:6379> cluster nodes
87e9d6d4238d009d77fb5af9c3efe6f0aeee9556 172.38.0.15:6379@16379 slave c17f9c56ba671110a5a3fd4ea30c7509eed4a923 0 1690340087210 5 connected
1bf3bf310ea6017a6077b264afd7f724b654ecdc 172.38.0.16:6379@16379 slave 672134d9fce7fe959644e58bc268454c64f7d2a6 0 1690340086000 6 connected
c17f9c56ba671110a5a3fd4ea30c7509eed4a923 172.38.0.11:6379@16379 myself,master - 0 1690340086000 1 connected 0-5460
1cbf088496b721beb34321a7f298331123468a2b 172.38.0.14:6379@16379 slave 3638f248d1a2fc75b042d7fc305937e6c2bb2180 0 1690340087539 4 connected
3638f248d1a2fc75b042d7fc305937e6c2bb2180 172.38.0.13:6379@16379 master - 0 1690340087738 3 connected 10923-16383
672134d9fce7fe959644e58bc268454c64f7d2a6 172.38.0.12:6379@16379 master - 0 1690340086207 2 connected 5461-10922

SpringBoot微服务打包docker镜像

1.构架springboot项目（未学会）

2.打包应用

3.编写DockerFile

4.构建镜像

疑问：如果有很多镜像？不可能一个个启动

Docker Compose

Docker Swarm

CI/CD之Jenkins

1bf3bf310ea6017a6077b264afd7f724b654ecdc 172.38.0.16:6379
slots: (0 slots) slave
replicates 672134d9fce7fe959644e58bc268454c64f7d2a6
S: 1cbf088496b721beb34321a7f298331123468a2b 172.38.0.14:6379
slots: (0 slots) slave
replicates 3638f248d1a2fc75b042d7fc305937e6c2bb2180
M: 3638f248d1a2fc75b042d7fc305937e6c2bb2180 172.38.0.13:6379
slots:[10923-16383] (5461 slots) master
1 additional replica(s)
M: 672134d9fce7fe959644e58bc268454c64f7d2a6 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.

#进入redis控制，可以看到redis集群搭建完成，且显示了主从结点
/data # redis-cli -c
127.0.0.1:6379> cluster nodes
87e9d6d4238d009d77fb5af9c3efe6f0aeee9556 172.38.0.15:6379@16379 slave c17f9c56ba671110a5a3fd4ea30c7509eed4a923 0 1690340087210 5 connected
1bf3bf310ea6017a6077b264afd7f724b654ecdc 172.38.0.16:6379@16379 slave 672134d9fce7fe959644e58bc268454c64f7d2a6 0 1690340086000 6 connected
c17f9c56ba671110a5a3fd4ea30c7509eed4a923 172.38.0.11:6379@16379 myself,master - 0 1690340086000 1 connected 0-5460
1cbf088496b721beb34321a7f298331123468a2b 172.38.0.14:6379@16379 slave 3638f248d1a2fc75b042d7fc305937e6c2bb2180 0 1690340087539 4 connected
3638f248d1a2fc75b042d7fc305937e6c2bb2180 172.38.0.13:6379@16379 master - 0 1690340087738 3 connected 10923-16383
672134d9fce7fe959644e58bc268454c64f7d2a6 172.38.0.12:6379@16379 master - 0 1690340086207 2 connected 5461-10922

SpringBoot微服务打包docker镜像

1.构架springboot项目（未学会）

2.打包应用

3.编写DockerFile

4.构建镜像

疑问：如果有很多镜像？不可能一个个启动

Docker Compose

Docker Swarm

CI/CD之Jenkins