Docker

五、Docker鏡像講解

1.鏡像是什么

鏡像是一種輕量級、可執行的獨立軟體包，用來打包軟體運行環境和基于運行環境開發的軟體，他包含運行某個軟體所需的所有內容，包括代碼、運行時庫、環境變數和組態檔，

所有應用，直接打包docker鏡像，就可以直接跑起來！

如何得到鏡像：

• 從遠程倉庫下載
• 朋友拷貝給你
• 自己制作

2.Docker鏡像加載原理

UnionFS (聯合檔案系統)

**UnionFs（聯合檔案系統）：**Union檔案系統（UnionFs）是一種分層、輕量級并且高性能的檔案系統，他支持對檔案系統的修改作為一次提交來一層層的疊加，同時可以將不同目錄掛載到同一個虛擬檔案系統下（ unite several directories into a single virtual filesystem)，Union檔案系統是 Docker鏡像的基礎，鏡像可以通過分層來進行繼承，基于基礎鏡像（沒有父鏡像），可以制作各種具體的應用鏡像，
**特性：**一次同時加載多個檔案系統，但從外面看起來，只能看到一個檔案系統，聯合加載會把各層檔案系統疊加起來，這樣最終的檔案系統會包含所有底層的檔案和目錄，

Docker鏡像加載原理

Docker的鏡像實際上由一層一層的檔案系統組成，這種層級的檔案系統UnionFS，
**boots(boot file system）😗*主要包含 bootloader和 Kernel, bootloader主要是引導加 kernel, Linux剛啟動時會加bootfs檔案系統，在 Docker鏡像的最底層是 boots，這一層與我們典型的Linux/Unix系統是一樣的，包含boot加載器和內核，當boot加載完成之后整個內核就都在記憶體中了，此時記憶體的使用權已由 bootfs轉交給內核，此時系統也會卸載bootfs，
rootfs（root file system),在 bootfs之上，包含的就是典型 Linux系統中的/dev,/proc,/bin,/etc等標準目錄和檔案， rootfs就是各種不同的作業系統發行版，比如 Ubuntu, Centos等等，

平時我們安裝進虛擬機的CentOS都是好幾個G，為什么Docker這里才200M？

對于個精簡的OS,rootfs可以很小，只需要包合最基本的命令，工具和程式庫就可以了，因為底層直接用Host的kernel，自己只需要提供rootfs就可以了，由此可見對于不同的Linux發行版， boots基本是一致的， rootfs會有差別，因此不同的發行版可以公用bootfs.

虛擬機是分鐘級別，容器是秒級！

3.分層理解

分層的鏡像

我們可以去下載一個鏡像，注意觀察下載的日志輸出，可以看到是一層層的在下載

思考：為什么Docker采用這種分層的結構呢？

最大的好處，我覺得莫過于資源共享了！比如有多個鏡像都從相同的Base鏡像構建而來，那么宿主機只需在磁盤上保留一份base鏡像，同時記憶體中也只需要加載一份base鏡像，這樣就可以為所有的容器服務了，而且鏡像的每一層都可以被共享，

查看鏡像分層的方式可以通過docker image inspect 命令

[root@zjdzka ~]# docker image inspect redis
[
    {
        "Id": "sha256:621ceef7494adfcbe0e523593639f6625795cc0dc91a750629367a8c7b3ccebb",
        "RepoTags": [
            "redis:latest"
        ],
        "RepoDigests": [
            "redis@sha256:0f97c1c9daf5b69b93390ccbe8d3e2971617ec4801fd0882c72bf7cad3a13494"
        ],
        "Parent": "",
        "Comment": "",
        "Created": "2021-01-13T09:45:41.527587343Z",
        "Container": "16535cfaf84a4049b6c02840219e8473787d5610e29409049df3a41bbf77a333",
        "ContainerConfig": {
            "Hostname": "16535cfaf84a",
            "Domainname": "",
            "User": "",
            "AttachStdin": false,
            "AttachStdout": false,
            "AttachStderr": false,
            "ExposedPorts": {
                "6379/tcp": {}
            },
            "Tty": false,
            "OpenStdin": false,
            "StdinOnce": false,
            "Env": [
                "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
                "GOSU_VERSION=1.12",
                "REDIS_VERSION=6.0.10",
                "REDIS_DOWNLOAD_URL=http://download.redis.io/releases/redis-6.0.10.tar.gz",
                "REDIS_DOWNLOAD_SHA=79bbb894f9dceb33ca699ee3ca4a4e1228be7fb5547aeb2f99d921e86c1285bd"
            ],
            "Cmd": [
                "/bin/sh",
                "-c",
                "#(nop) ",
                "CMD [\"redis-server\"]"
            ],
            "Image": "sha256:222c0cecc006d8c73a04a58b5fa15ebae171a6e82a8ee8650ae616f6f1798ef4",
            "Volumes": {
                "/data": {}
            },
            "WorkingDir": "/data",
            "Entrypoint": [
                "docker-entrypoint.sh"
            ],
            "OnBuild": null,
            "Labels": {}
        },
        "DockerVersion": "19.03.12",
        "Author": "",
        "Config": {
            "Hostname": "",
            "Domainname": "",
            "User": "",
            "AttachStdin": false,
            "AttachStdout": false,
            "AttachStderr": false,
            "ExposedPorts": {
                "6379/tcp": {}
            },
            "Tty": false,
            "OpenStdin": false,
            "StdinOnce": false,
            "Env": [
                "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
                "GOSU_VERSION=1.12",
                "REDIS_VERSION=6.0.10",
                "REDIS_DOWNLOAD_URL=http://download.redis.io/releases/redis-6.0.10.tar.gz",
                "REDIS_DOWNLOAD_SHA=79bbb894f9dceb33ca699ee3ca4a4e1228be7fb5547aeb2f99d921e86c1285bd"
            ],
            "Cmd": [
                "redis-server"
            ],
            "Image": "sha256:222c0cecc006d8c73a04a58b5fa15ebae171a6e82a8ee8650ae616f6f1798ef4",
            "Volumes": {
                "/data": {}
            },
            "WorkingDir": "/data",
            "Entrypoint": [
                "docker-entrypoint.sh"
            ],
            "OnBuild": null,
            "Labels": null
        },
        "Architecture": "amd64",
        "Os": "linux",
        "Size": 104285909,
        "VirtualSize": 104285909,
        "GraphDriver": {
            "Data": {
                "LowerDir": "/var/lib/docker/overlay2/4ea64043cf121b3633eca9ba2cb2a85682c62a1c6f074c501569766c1e0ce945/diff:/var/lib/docker/overlay2/2c49976e43d1f9bb6ce97a8edf287e418e46a99e454ea95a6a443ea2973f18ad/diff:/var/lib/docker/overlay2/782c232af88b85bb60cf2f6e36b958e699367045fe7bea2ac770818270571b1d/diff:/var/lib/docker/overlay2/9606bb1f1b3ff06a56813d192546dd20ed5f9f6fd2384c4b28ed0cdc1becab15/diff:/var/lib/docker/overlay2/42ff0bd2b7e0e2c6cd1a5d856eeca813dd1414fcba4864fb87f62a87344c10a0/diff",
                "MergedDir": "/var/lib/docker/overlay2/a5609f3560fc767cca20491b9814fd52cedbe4a7ce2cd330d04bd320d6f4c5b7/merged",
                "UpperDir": "/var/lib/docker/overlay2/a5609f3560fc767cca20491b9814fd52cedbe4a7ce2cd330d04bd320d6f4c5b7/diff",
                "WorkDir": "/var/lib/docker/overlay2/a5609f3560fc767cca20491b9814fd52cedbe4a7ce2cd330d04bd320d6f4c5b7/work"
            },
            "Name": "overlay2"
        },
        "RootFS": {
            "Type": "layers",
            "Layers": [
                "sha256:cb42413394c4059335228c137fe884ff3ab8946a014014309676c25e3ac86864",
                "sha256:8e14cb7841faede6e42ab797f915c329c22f3b39026f8338c4c75de26e5d4e82",
                "sha256:1450b8f0019c829e638ab5c1f3c2674d117517669e41dd2d0409a668e0807e96",
                "sha256:f927192cc30cb53065dc266f78ff12dc06651d6eb84088e82be2d98ac47d42a0",
                "sha256:a24a292d018421783c491bc72f6601908cb844b17427bac92f0a22f5fd809665",
                "sha256:3480f9cdd491225670e9899786128ffe47054b0a5d54c48f6b10623d2f340632"
            ]
        },
        "Metadata": {
            "LastTagTime": "0001-01-01T00:00:00Z"
        }
    }
]

理解:

所有的 Docker鏡像都起始于一個基礎鏡像層，當進行修改或培加新的內容時，就會在當前鏡像層之上，創建新的鏡像層，

舉一個簡單的例子，假如基于 Ubuntu Linux16.04創建一個新的鏡像，這就是新鏡像的第一層；如果在該鏡像中添加 Python包，
就會在基礎鏡像層之上創建第二個鏡像層；如果繼續添加一個安全補丁，就會創健第三個鏡像層該像當前已經包含3個鏡像層，如下圖所示（這只是一個用于演示的很簡單的例子），

在添加額外的鏡像層的同時，鏡像始終保持是當前所有鏡像的組合，理解這一點.

在添加額外的鏡像層的同時，鏡像始終保持是當前所有鏡像的組合，理解這一點非常重要，下圖中舉了一個簡單的例子，每個鏡像層包含3個檔案，而鏡像包含了來自兩個鏡像層的6個檔案，

上圖中的鏡像層跟之前圖中的略有區別，主要目的是便于展示檔案
下圖中展示了一個稍微復雜的三層鏡像，在外部看來整個鏡像只有6個檔案，這是因為最上層中的檔案7是檔案5的一個更新版，

文種情況下，上層鏡像層中的檔案覆寫了底層鏡像層中的檔案，這樣就使得檔案的更新版本作為一個新鏡像層添加到鏡像當中

Docker通過存盤引擎（新版本采用快斬訓制）的方式來實作鏡像層堆疊，并保證多鏡像層對外展示為統一的檔案系統

Linux上可用的存盤引撃有AUFS、 Overlay2、 Device Mapper、Btrfs以及ZFS，顧名思義，每種存盤引擎都基于 Linux中對應的
件系統或者塊設備技術，井且每種存盤引擎都有其獨有的性能特點，

Docker在 Windows上僅支持 windowsfilter 一種存盤引擎，該引擎基于NTFS檔案系統之上實作了分層和CoW [1]，

下圖展示了與系統顯示相同的三層鏡像，所有鏡像層堆并合井，對外提供統一的視圖，

特點

Docker 鏡像都是只讀的，當容器啟動時，一個新的可寫層加載到鏡像的頂部！

這一層就是我們通常說的容器層，容器之下的都叫鏡像層！

4.commit鏡像

docker commit 提交容器成為一個新的副本

# 命令和git原理類似
docker commit -m="描述資訊" -a="作者" 容器id 目標鏡像名:[版本TAG]

實戰測驗

# 1、啟動一個默認的tomcat
[root@iz2zeak7sgj6i7hrb2g862z ~]# docker run -d -p 8080:8080 tomcat
de57d0ace5716d27d0e3a7341503d07ed4695ffc266aef78e0a855b270c4064e

# 2、發現這個默認的tomcat 是沒有webapps應用，官方的鏡像默認webapps下面是沒有檔案的！
#docker exec -it 容器id /bin/bash
[root@iz2zeak7sgj6i7hrb2g862z ~]# docker exec -it de57d0ace571 /bin/bash
root@de57d0ace571:/usr/local/tomcat# 

# 3、從webapps.dist拷貝檔案進去webapp
root@de57d0ace571:/usr/local/tomcat# cp -r webapps.dist/* webapps
root@de57d0ace571:/usr/local/tomcat# cd webapps
root@de57d0ace571:/usr/local/tomcat/webapps# ls
ROOT  docs  examples  host-manager  manager

# 4、將操作過的容器通過commit調教為一個鏡像！我們以后就使用我們修改過的鏡像即可，而不需要每次都重新拷貝webapps.dist下的檔案到webapps了，這就是我們自己的一個修改的鏡像，
docker commit -m="描述資訊" -a="作者" 容器id 目標鏡像名:[TAG]
docker commit -a="zjdzka" -m="add webapps app" 容器id tomcat02:1.0

[root@iz2zeak7sgj6i7hrb2g862z ~]# docker commit -a="csp提交的" -m="add webapps app" de57d0ace571 tomcat02:1.0
sha256:d5f28a0bb0d0b6522fdcb56f100d11298377b2b7c51b9a9e621379b01cf1487e

[root@iz2zeak7sgj6i7hrb2g862z ~]# docker images
REPOSITORY            TAG                 IMAGE ID            CREATED             SIZE
tomcat02.1.0          latest              d5f28a0bb0d0        14 seconds ago      652MB
tomcat                latest              1b6b1fe7261e        5 days ago          647MB
nginx                 latest              9beeba249f3e        5 days ago          127MB
mysql                 5.7                 b84d68d0a7db        5 days ago          448MB
elasticsearch         7.6.2               f29a1ee41030        8 weeks ago         791MB
portainer/portainer   latest              2869fc110bf7        2 months ago        78.6MB
centos                latest              470671670cac        4 months ago        237MB
hello-world           latest              bf756fb1ae65        4 months ago        13.3kB

如果你想要保存當前容器的狀態，就可以通過commit來提交，獲得一個鏡像，就好比我們我們使用虛擬機的快照，

六、容器資料卷

1.什么是容器資料卷？

Docker的理念：將應用和環境打包成一個鏡像！

資料？如果都在容器中，那么我們洗掉容器，資料就會丟失！

資料可以持久化

例如：Mysql，容器刪了=刪庫跑路！===>Mysql的資料可以存盤在本地！

**容器之間可以有一個資料共享的技術！**Docker容器中產生的資料，同步到本地！

這就是卷技術！目錄的掛載，將我們容器內的目錄，掛載到Linux上！

**總結：**容器的持久化和同步操作！容器間也是可以資料共享的！

2.使用資料卷

方式一：直接使用命令掛載 -v

docker run -it -v 主機目錄:容器內目錄

#測驗系結資料卷
docker run -it -v /home/ceshi:/home centos /bin/bash

#用另一個會話測驗：查看資訊
docker inspect a0d694176556

測驗檔案同步

再次測驗：

容器關閉，在本地更新檔案，再將檔案開啟，發現資料仍然同步

3.Mysql資料同步

思考：Mysql的資料持久化問題

#1.獲取鏡像
docker pull mysql:5.7
#2.運行容器，需要做資料掛載
# -d 后臺運行
# -p 埠映射
# -v 卷掛載
# -e 環境配置
#--name 名字
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

#3.啟動成功后，測驗連接mysql
#sqlyog-連接到服務器的3310---3310和容器內的3306映射，這個時候，我們就可以連接上！

如果我們將容器洗掉，我們掛載到本地的資料依舊存在，這就是資料卷持久化！

4.具名和匿名掛載

# 匿名掛載
-v 容器內路徑！
docker run -d -p --name nginx01 -v /etc/nginx nginx

#查看所有卷的情況
docker volume ls

#具名掛載
-v 卷名:容器內目錄
-v juming-nginx:/etc/nginx

所有的docker容器內的卷，沒有指定目錄的情況下都是在/var/lib/docker/volumes/xxx/_data

#如何確定是哪種形式的掛載？
-v 容器內路徑 #匿名
-v 卷名:容器內路徑 #具名
-v /宿主機路徑/..:容器內路徑 #指定路徑

擴展：

docker run -d -p -m --name nginx01 -v juming-nginx:/etc/nginx:ro nginx

#ro 或者 rw
ro：read only
rw：read write
#一旦設定了容器權限，容器對我們掛載出來的內容就有限定了！

5.初始Dockerfile

Dockerfile就是用來構建docker鏡像的構建檔案！-----命令腳本

方式二：通過腳本生成鏡像

#1.創建一個docker檔案
#2.撰寫Dockerfile
FROM centos

VOLUME ["volume01","volume02"]

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

#3.構建鏡像

#4.測驗一下自己寫的鏡像

這個卷一定和外部有一個同步的目錄！

測驗檔案是否同步？

6.資料卷容器

多個Mysql資料同步！

#啟動三個容器，通過我們自己寫的鏡像測驗

如果把其中一個資料卷洗掉了，其他資料卷檔案依舊存在！

結論：

容器之間配置資訊的傳遞，資料卷容器的生命周期一直持續到沒有容器使用為止，

但是一旦你持久化到了本地，本地的資料是不會洗掉的！

七、DockerFile

1.DockerFile介紹

Dockerfile是用來構建docker鏡像檔案！

構建步驟：

• 撰寫一個dockerfile檔案
• docker build構建成一個鏡像
• docker run 運行鏡像
• docker push 發布鏡像(DockerHub、阿里云鏡像倉庫！)

2.DockerFile構建程序：

基礎知識：

1.每個保留關鍵字(指令)都必須是大寫字母

2.執行順序從上到下

3.#表示注釋

4.每一個指令都會創建提交一個新的鏡像層，并提交！

dockerfile是面向開發的，我們以后要發布專案，做鏡像，就需要撰寫dockerfile檔案，這個檔案十分簡單！

Docker鏡像逐漸成為企業交付的標準！

DockerFile:構建檔案，定義了一切的步驟，源代碼

DockerImages：通過DockerFile構建生成的鏡像，最終發布和運行的產品

Docker容器：容器就是鏡像運行起來提供服務的

3.DockerFile指令

FROM #基礎鏡像，一切從這里開始
MAINTAINER #鏡像的作者，名字+郵箱
RUN #鏡像構建的時候運行的命令
ADD #步驟：tomcat鏡像，這個tomcat壓縮包！添加內容
WORKDIR #鏡像的作業目錄
VOLUME #掛載的目錄
EXPORT #暴露埠配置= -p
CMD #指定容器啟動的時候，運行的命令==>只要最后一個會生效，可替代
ENTRYPOINT #指定容器啟動的時候，運行的命令==>可以追加命令
ONBUILD #當構建一個被繼承DockerFile 這個時候就會運行這個指令，觸發指令
COPY #類似ADD，拷貝
ENV #構建的時候，設定環境變數

圖示：

4.實戰：構建自己的Centos

第一步：撰寫dockerfile

[root@zjdzka dockerfile]# vim mydockerfile-centos
[root@zjdzka dockerfile]# cat mydockerfile-centos 
FROM centos
MAINTAINER zjdzka<245821335@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

第二步：通過檔案構建鏡像

[root@zjdzka dockerfile]# docker build -f mydockerfile-centos -t zjdzkacentos:0.1 .

第三步：測驗運行

測驗成功！

我們可以列出本地鏡像的歷史

CMD和ENTRYPOINT區別

CMD #指定容器啟動的時候，運行的命令==>只要最后一個會生效，可替代
ENTRYPOINT #指定容器啟動的時候，運行的命令==>可以追加命令

Dockrfile中很多命令十分相似，我們要對比學習，測驗效果！

測驗CMD

# 1. 撰寫dockerfile檔案
[root@iZ2zeg4ytp0whqtmxbsqiiZ dockerfile]# vim dockerfile-cmd-test 
FROM centos
CMD ["ls", "-a"]
 
# 2. 構建鏡像
[root@iZ2zeg4ytp0whqtmxbsqiiZ dockerfile]# docker build -f dockerfile-cmd-test -t cmdtest .
 
# 3. run運行， 發現我們的ls -a 命令生效
[root@iZ2zeg4ytp0whqtmxbsqiiZ dockerfile]# docker run ebe6a52bb125
.
..
.dockerenv
bin
dev
etc
home
lib
lib64
 
# 想追加一個命令 -l 變成 ls -al
[root@iZ2zeg4ytp0whqtmxbsqiiZ dockerfile]# docker run ebe6a52bb125 -l
docker: Error response from daemon: OCI runtime create failed: container_linux.go:349: starting container process caused "exec: \"-l\": executable file not found in $PATH": unknown.
[root@iZ2zeg4ytp0whqtmxbsqiiZ dockerfile]# docker run ebe6a52bb125 ls -l
 
# cmd的情況下 -l替換了CMD["ls", "-a"]命令， -l不是命令，所以報錯了

測驗ENTRYPOINT

# 1. 撰寫dockerfile檔案
[root@iZ2zeg4ytp0whqtmxbsqiiZ dockerfile]# vim dockerfile-entrypoint-test 
FROM centos
ENTRYPOINT ["ls", "-a"]
 
# 2. 構建檔案
[root@iZ2zeg4ytp0whqtmxbsqiiZ dockerfile]# docker build -f dockerfile-entrypoint-test -t entrypoint-test .
 
# 3. run運行 發現我們的ls -a 命令同樣生效
[root@iZ2zeg4ytp0whqtmxbsqiiZ dockerfile]# docker run entrypoint-test
.
..
.dockerenv
bin
dev
etc
home
lib
 
# 4. 我們的追加命令， 是直接拼接到ENTRYPOINT命令的后面的！
[root@iZ2zeg4ytp0whqtmxbsqiiZ dockerfile]# docker run entrypoint-test -l
total 56
drwxr-xr-x  1 root root 4096 Aug 13 07:52 .
drwxr-xr-x  1 root root 4096 Aug 13 07:52 ..
-rwxr-xr-x  1 root root    0 Aug 13 07:52 .dockerenv
lrwxrwxrwx  1 root root    7 May 11  2019 bin -> usr/bin
drwxr-xr-x  5 root root  340 Aug 13 07:52 dev
drwxr-xr-x  1 root root 4096 Aug 13 07:52 etc
drwxr-xr-x  2 root root 4096 May 11  2019 home
lrwxrwxrwx  1 root root    7 May 11  2019 lib -> usr/lib
lrwxrwxrwx  1 root root    9 May 11  2019 lib64 -> usr/lib64
drwx------  2 root root 4096 Aug  9 21:40 lost+found

5.小結：

八、Docker網路

1.理解Docker0

• 清空所有環境

測驗

三個網路

# docker 是如何處理容器的網路訪問的？

測驗：

#1.啟動tomcat
docker run -d -P --name tomcat01 tomcat
#2.查看容器的內網地址 ip addr
#docker exec -it tomcat01 ip addr
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
26: eth0@if27: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default 
    link/ether 02:42:ac:11:00:02 brd ff:ff:ff:ff:ff:ff link-netnsid 0
    inet 172.17.0.2/16 brd 172.17.255.255 scope global eth0
       valid_lft forever preferred_lft forever
#思考：linux可以ping通docker容器？
# ping 172.17.0.2
PING 172.17.0.2 (172.17.0.2) 56(84) bytes of data.
64 bytes from 172.17.0.2: icmp_seq=1 ttl=64 time=0.076 ms
64 bytes from 172.17.0.2: icmp_seq=2 ttl=64 time=0.042 ms
64 bytes from 172.17.0.2: icmp_seq=3 ttl=64 time=0.052 ms
#linux可以ping通容器內部

分析原理

1.我們每啟動一個docker容器，docker就會給docker容器分配一個ip，我們只要安裝了docker，就會有一個網卡docker0橋接技術，使用的技術是evth—pair技術！

再次測驗ip addr 發現又多了一對網卡

#我們發現這個容器帶來的網卡，都是一對對的
#evth-pair 就是一對的虛擬設備介面，他們都是成對出現的，一段連著協議，一段彼此相連
#正因為有這個特性，evth-pair 充當一個橋梁，連接各種虛擬網路設備的

2.我們測驗tomcat01 和tomcat02 是否可以ping通

#測驗成功，ping通！
docker exec -it tomcat02 ping 172.17.0.2

總結：

容器和容器之間是可以互相ping通的！

• tomcat01和tomcat02共用的一個路由器：docker0

• 所有的容器不知道網路的情況下，都是docker0路由的，docker會給我們容器分配一個默認的可用ip

• 只要容器洗掉，對應的網橋也隨之沒了

小結

Docker 使用的是Linux的橋接網卡，宿主機中是一個Docker容器的網橋 docker0，

Docker中的所有的網路介面都是虛擬的，虛擬的轉發效率高！

2.–link

思考一個場景，我們撰寫了一個微服務，database url=ip:,專案不重啟，資料庫ip換掉了，我們希望可以處理這個問題：通過名字來訪問容器

我們發現直接ping，并不能解決問題

測驗：

[root@zjdzka ~]# docker run -d -P --name tomcat03 --link tomcat02 tomcat
e1cfed7c63e87d6b74eb0a17fc23270881d9f7258d9bd5497ec5158157176a78
[root@zjdzka ~]# 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.103 ms
64 bytes from tomcat02 (172.17.0.3): icmp_seq=2 ttl=64 time=0.070 ms
64 bytes from tomcat02 (172.17.0.3): icmp_seq=3 ttl=64 time=0.085 ms
#發現通過--link就可解決問題，但是反向可以嘛? tomcat02 ping tomcat03
[root@zjdzka ~]# docker exec -it tomcat02 ping tomcat 03
ping: tomcat: Name or service not known

探究:

tomcat03和tomcat02通過–link建立連接，其中發生了什么？

原理：其實就是在我們的hosts配置中添加了一個映射

docker0問題：不支持容器名連接訪問!

3.自定義網路

查看所有的docker網路

網路模式：

bridge：橋接 docker(默認)

none：不配置網路

host: 和宿主機共享網路

container：容器網路連通(用到少！)

測驗：

#w我們直接啟動的命令 --net bridge，而這個就是我們的docker0
docker run -d -P --name tomcat01 tomcat
docker run -d -P --name tomcat01 --net bridge tomcat

#自定義網路
# --driver bridge
# --subnet 192.168.0.0/16 
# --gateway 192.168.0.1
docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet

查看自己的網路配置：

docker network inspect mynet

將tomcat發布到自己的網路進行測驗:

[root@zjdzka ~]# docker run -d -P --name tomcat-net-01 --net mynet tomcat  
70cef0b1886e7488e9f1bbcdebcddad27e0c8b95e3008499051977e45a5baaea
[root@zjdzka ~]# docker run -d -P --name tomcat-net-02 --net mynet tomcat  
ee6882df470433c46df318634b83f912aabb0c08562e50503f52c7ca5a490a09
[root@zjdzka ~]# docker exec -it tomcat-net-01 ping tomcat-net-02

我們可以發現這種自定義網路，直接可以ping連接成功！

好處：

redis-不同的集群使用不同的網路，保證集群是安全和健康的

mysql-不同的集群使用不同的網路，保證集群是安全和健康的

4.網路連通

實作這種方式的連通，用啥方法呢？

測驗：

#打通tomcat01---tomcat-net-01
docker network connect mynet tomcat01
#連通之后，將我們的tomcat01放到了mynet網路下

#一個容器兩個ip：公網ip，私網ip

docker exec -it tomcat01 ping tomcat-net-01