架构师工具-docker

最新推荐文章于 2023-05-28 21:18:55 发布

向着风奔跑

最新推荐文章于 2023-05-28 21:18:55 发布

阅读量2k

点赞数

分类专栏：架构师工具

本文链接：https://blog.csdn.net/liulong1010/article/details/103623967

版权

架构师工具专栏收录该内容

5 篇文章 0 订阅

订阅专栏

01 Docker概述

1.3 底层技术支持

Container是一种轻量级的虚拟化技术，不用模拟硬件创建虚拟机。
Docker是基于Linux Kernel的Namespace,CGroups,UnionFileSystem等技术封装的一种自定义容器格式，从而提供一套虚拟运行环境

Namespace: 用来做隔离的，比如pid[进程]、net[网络]、mnt[挂载点]等
CGroups: Controller Groups用来做资源限制的，比如内存和CPU等
Union file systems: 用来做image和container分层

02、Image and Container

2.1 Image

Docker Image layer

文件和meta data的集合（root filesystem）

对于linux系统来说分为:,就是内核空间(kernel space)和用户空间(user space)，内核空间linux kernel，就理解成root filesystem
用户空间就是在内核上层建立的其实就是：ubuntu，centos，redhat，
Debian。

分层的，并且每一层都是可以添加改变的，成为一个新的Image。例如：先建立个apache的Image，结果在apache的Image上边我有建立的一个mysql的Image。
不同的Image之前可以共享分层。例如：apache的Image可以跟mysql的Image之间进行通信。

Image本身是只读的,由一层一层的layer组成的

2.1.1 官网Image

https://github.com/docker-library

mysql

https//github.com/docker-library/tomcat/blob/master/8.5/jdk/openjdk/Dockerfile

2.1.2 Dockerfile

参考官方Dockerfile制作自己的Image

2.1.2.1 FROM

指定基础镜像，比如FROM ubuntu:14:04

FROM ubuntu:14:04

2.1.2.2 RUN

在镜像内部执行一些命令，比如安装软件，配置环境等，换行用""

RUN groupadd -r mysql && useradd -r g mysql mysql

2.1.2.3 ENV

设置变量的值,ENV MYSQL_MAJOR5.7,可以通过docker run -e key=value修改，后面可以直接使用${MYSQL_MAJOR}

ENV MYSQL_MAJOR 5.7

2.1.2.4 LABEL

设置镜像标签

LABEL email="jack2019@l63.com"
LABEL name="jack2019"

2.1.2.5 VOLUME

指定数据卷映射在宿主机目录

VALUME /var/lib/mysql

2.1.2.6 COPY

将主机的文件复制到镜像内，如果目录不存在，会自动创建所需要的目录，如果目录不存在，会自动创建所需要的目录，注意只是复制，不会提取和解压

COPY docker-entrypoint.sh /usr/local/bin/

2.1.2.7 ADD

将主机的文件复制到镜像内，和COPY类似,只是ADD会对压缩文件提取和解压

ADD application.yaml /etc/jack2019/

2.1.2.8 WORKDIR

指定镜像的工作目录，之后的命令都基于此目录工作，若不存在则创建

WORKDIR /usr/local
WORKDIR tomcat
RUN touch test.txt

会在/usr/local/tomcat下创建test.txt文件

WORKDIR /root
ADD app.yml test/

会在/root/test下多出一个app.yaml文件

2.1.2.9 CMD

容器启动的时候默认会执行的命令，若有多个CMD命令，则最后一个生效

CMD ["mysqld"]
或
CMD mysqld

2.1.2.10 ENTRYPOINT

和CMD的使用类似

ENTRYPOINT ["docker-entrypoint.sh"]

和CMD的不同
docker run执行时，会覆盖CMD的命令，而ENTRYPOINT不会

2.1.2.11 EXPOSE

指定镜像要暴露的端口，启动镜像时，可以使用-p将端口映射给宿主机

EXPOSE 3306

2.1.3 Dockerfile实战Spring Boot项目

2.1.3.1 创建一个Spring Boot标准项目

通过idea或https://start.spring.io/ 创建标准spring boot 工程

2.1.3.2 下一个Controller

@RestController
public class DockerController {
	@GetMapping("/dockerfile")
	@ResponseBody
	String dockerfile() { 
   		return "hello docker";
    }
}

2.1.3.3 mvn 打包jar

mvn clean package

在target下找到dockerfile-demo-0.0.1-SNAPSHOT.jar

2.1.3.4 上传jar并创建Dockerfile

上传dockerfile-demo-0.0.1-SNAPSHOT.jar到centos，并在该目录下创建Dockerfile

FROM openjdk:8
MAINTAINER jack2019
LABEL name="dockerfile-demo" version="1.0" author="jack2019"
COPY dockerfile-demo-0.0.1-SNAPSHOT.jar dockerfile-image.jar
CMD ["java","-jar","dockerfile-image.jar"]

2.1.3.5 基于Dockerfile构建镜像

docker built -t test-docker-image .

2.1.3.6 基于image创建container

docker run -d --name user01 -p 6666:8080 test-docker-image

2.1.3.6 查看启动日志

docker logs user01

2.1.3.7 验证

在宿主机上访问

curl localhost:6666/dockerfile

2.1.3.8 在启动一个

docker run -d --name user02 -p 8081:8080 test-docker-image

2.1.4 镜像仓库

2.1.4.1 docker hub

hub.docker.com 需要自己注册账号，站点在国外，比较慢

(1) 在docker机器上登录
    docker login
(2) 输入用户名和密码
(3) docker push jack2019/test-docker-image
    注意镜像名称要和docker id一致，不然push不成功
(4) 给image重命名,并删除原来的image
    docker tag test-docker-image jack2019/test-docker-image
    docker rmi -f test-docker-image
(5) 再次推送,刷新hub.docker.com,发现成功
(6) 别人下载,并运行
    docker pull jack2019/test-docker-image
    docker run -d --name user01 -p 6661:8080 jack2019/test-docker-image

2.1.4.2 阿里云docker hub

阿里云docker仓库
https://cr.console.aliyun.com/cn-hangzhou/instances/repositories

(1) 登录阿里云docker仓库
sudo docker login --username=jack2019@163.com  registry.cn-hangzhou.aliyuncs.com 
(2) 输入密码
(3) 创建命名空间,比如jack2019
(4) 给image打tag
sudo docker tag [ImageId] registry.cn-hangzhou.aliyuncs.com/jack2019/test-docker-image:v.0
(5) 别人下载,并运行 
docker pull registry.cn-hangzhou.aliyuncs.com/jack2019/test-docker-image:v.0
docker run -d --name user01 -p 6661:8080 registry.cn-hangzhou.aliyuncs.com/jack2019/test-docker-image:v.0

2.1.4.3 搭建自己的Docker Harbor

(1) 访问github的harbor项目
  https://github.com/goharbor/harbor
(2) 下载版本，比如1.7.1
  https://github.com/goharbor/harbor/releases  
(3) 找一台安装docker-compose,上传并解压
   tar -zxvf xxx.tar.gz
(4) 进入到harbor目录
  修改harbor.cfg文件，主要是ip地址修改为当前机器的ip地址
  同时可以看到Harbor的密码，默认是Harbor12345
(5) 安装harbor
  sh install.sh
(6) 浏览企访问验证

2.1.5 Image常见操作

(1) 查看本地image列表
  docker images
  docker image ls
(2) 获取远端镜像
  docker pull 
(3) 删除镜像[注意此镜像如果正在使用，或者有关联的镜像，则需要险处理完]
  docker image rm imageid
  docker rmi -f imageid
  docker rmi -f $(docker image ls) 删除所有镜像
(4) 运行镜像
  docker run image 
(5) 发布镜像
  docker push

2.2 Container

container

container只是基于image之后的layer而已，也就是可以通过docker run image创建出一个container出来

2.2.1 container到image

container是基于image之上的，container可以反推出image?
通过docker run 运行起一个container出来，这时候对container进行修改，然后再生成一个新image，这个image的由来就不仅仅只能通过Dockerfile生成

(1) 拉取一个centos image
  docker pull centos
(2) 根据centos镜像创建出一个container
  docker run -d -it --name my-centos centos
(3) 进入my-centos容器中
  docker exec -it my-centos bash
(4) 输入vim命令
    bash: vim: command not found
(5) 在centos的container中安装vim
  对container进行修改，也就是安装vim命令，然后将起生成一个新的centos
   yum install -y vim
(6) 提出容器，将其生成一个新的centos，名称为"vim-centos-image"
   docker commit my-contes vim-centos-image
(7) 查看镜像列表，并基于"vim-centos-image"创建新的容器
   docker run -d -it --name my-vim-centos vim-centos-image
(8) 进入"vim-centos-image"容器中检查vim命令是否存在
   docker exec -t my-vim-centos
   vim

可以通过docker commit命令基于一个container重新生成一image，但是一般得到image的方式不建议这么做，不然image怎么来的就全然不知

2.2.2 container资源限制

如果不对container的资源做限制，它就会无限制的使用物理机的资源，这样显然是不合适的
查看资源情况:docker stats

2.2.2.1 内存限制

--memory Memory limit
如果 不设置 --memory-swap,其大小和memory一样
docker run -d --memory 100M --name tomcat1 tomcat

2.2.2.2 CPU限制

--cpu-shares   权重
docker run -d --cpu-shares 10 --name tomcat2 tomcat

2.2.2.3 图形化资源监控

https://github.com/weaveworks/scope

sudo curl -L git.io/scope -o /usr/local/bin/scope
sudo chmod a+x /usr/local/bin/scope
scope launch 192.168.0.110 # localhost:4040 查看

# 停止scope
scope stop
# 同时监控两台机器，在两台机器中分别执行如下命令
scope launch ip1 ip2

2.2.3 container常见操作

(1) 根据镜像创建容器
   docker run -d --name -p 9090:8080 my-tomcat tomcat
(2) 查看运行中的container
   docker ps
(3) 查看所有的container[包含退出的] 
   docker ps -a
(4) 删除container
   docker rm containerid
   docker rm -f $(docker ps -a)   删除所有的container
(5) 进入一个continer中
    docker exec -it container bash
(6) 根据container生成image
    docker   commit      
 (7)  查看某个container的日志
    docker logs container
 (8)  查看容器资源使用情况
    docker stats
 (9) 查看容器详情信息
    docker inspect container
 (10) 停止/启动容器
    docker stop/start container

03、Docker网络探讨

3.1 计算机网络模型

网络模型

七层OSI网络模型和4层TCP/IP网络模型

3.2 Linux中网卡

3.2.1 查看网卡[网络接口]

01 ip link show

02 ls /sys/class/net

03 ip a

3.2.2 网卡

3.2.2.1 ip a 解读

状态;UP/DOWN/UNKOWN等
link/ether: MAC地址
inet: 绑定的ip地址

3.2.2.2 配置文件

在linux中网卡对应的就是文件，所以找到对应的网卡文件即可
比如: cat /etc/sysconfig/network-scripts/ifcfg-eth0

3.2.2.3 给网卡添加IP地址

可以直接修改ifcfg-*文件，也可以通过命令添加

(1) 添加IP地址 
   ip addr add 192.168.0.111/24 dev eth0
(2) 删除IP地址
   ip addr delete 192.168.0.111/24 dev eth0

3.3 Network Namespace

在linux上，网络的隔离是通过network namespace来管理的，不同的network namespace是互相隔离的

(1) 查看当前机器上的network namespace
    ip netns list
(2) 添加ns
    ip netns add ns1
(3) 删除ns
    ip netns delete ns1

3.3.1 namespace实战

在这里插入图片描述

(1) 创建一个network namespace
    ip netns add ns1
(2) 查看该namespace下网卡的情况
    ip netns exec ns1 ip a
(3) 启动ns1上的lo网卡
    ip netns exec ns1 ifup lo
    or 
    ip netns exec ns1 ip link set lo up
(4) 再次查看
    可以发现state变成UNKOWN
    ip netns exec ns1 ip a
(5) 再次创建一个network namespace
    ip nets add ns2

在这里插入图片描述

(6) 此时想让两个namespace网络连通起来
    veth pair: Virtural Ethernet Pair,是一个成对的端口，可以实现上述功能
(7) 创建一个link，也就是接下来通过veth pair链接的link
    ip link add veth-ns1 type veth peer name veth-ns2
(8) 查看link
    ip link
(9) 将veth-ns1加入ns1中，veth-ns2加入ns2中
    ip link set veth-ns1 netns ns1
    ip link set veth-ns2 netns ns2
(10) 查看宿主机和ns1，ns2的link情况
    ip link 
    ip netns exec ns1 ip link
    ip netns exec ns2 ip link
(11) 此时veth-ns1和veth-ns2还没有ip地址，显然通信还缺少掉条件
    ip netns exec ns1 ip addr add 192.168.0.11/24 dev veth-ns1
    ip netns exec ns2 ip addr add 192.168.0.12/24 dev veth-ns2
(12) 再次查看，发现state是DOWN,并且是没有IP地址
    ip netns exec ns1 ip link
    ip netns exec ns2 ip link
(13) 启动veth-ns1和veth-ns2
     ip nets exec ns1 ip link set veth-ns1 up
     ip nets exec ns2 ip link set veth-ns2 up
(14) 再次查看，发现state是UP,同时有IP
     ip netns exec ns1 ip a
     ip netns exec ns2 ip a
(15) 此时两个network namespace互相ping一下，发现是可以ping通的
     ip netns exec ns1 ping 192.168.0.12
     ip netns exec ns2 ping 192.168.0.11

3.2.2 Container的NS

按照上面的描述，实际上每个container，都会有自己的network namspace，并且是独立，我们可以进入到容器进行验证

(1) 创建两个container

  docker run -d --name tomcat01 -p 8081:8080 tomcat
  docker run -d --name tomcat02 -p 8082:8080 tomcat

(2) 进入两个容器中，并且查看ip

docker exec -it tomcat01 ip a
docker exec -it tomcat02 ip a

(3) 互相ping一下是可以ping通的

思考：此时tomcat01和tomcat02属于两个network namespace,是如何能够ping通的?
 是否和上面描述的namespace实战一样？注意这里没有veth-pair技术

3.4 Container网络-Bridge

3.4.1 docker0默认bridge

(1) 查看centos的网络:ip a，可以发现

4: docker0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default
    link/ether 02:42:54:ef:23:08 brd ff:ff:ff:ff:ff:ff
    inet 172.17.0.1/16 brd 172.17.255.255 scope global docker0
       valid_lft forever preferred_lft forever
    inet6 fe80::42:54ff:feef:2308/64 scope link
       valid_lft forever preferred_lft forever
8: veth3b72761@if7: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue master docker0 state UP group default
    link/ether 8a:ce:1e:a1:0f:8c brd ff:ff:ff:ff:ff:ff link-netnsid 0
    inet6 fe80::88ce:1eff:fea1:f8c/64 scope link
       valid_lft forever preferred_lft forever

(2) 查看容器tomcat01的网络:docker exec -it tomcat01 ip a，可以发现

[root@localhost ~]# docker exec -it tomcat01 ip a
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
9: eth0@if8: <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

(3) 在centos中ping下tomcat01的网络，发现可以ping通

[root@localhost ~]# 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.068 ms
64 bytes from 172.17.0.2: icmp_seq=2 ttl=64 time=0.047 ms
64 bytes from 172.17.0.2: icmp_seq=3 ttl=64 time=0.068 ms

在这里插入图片描述

(4) 也就是说,在tomcat01中有一个eth0和centos的docker0中一个veth是成对的，类似于之前实战中veth-ns1和veth-ns2,不防在通过一个命令确认下:brctl

yum install bridge-utils
brctl show

(5) 那么为什么tomcat01和tomcat02能ping通？看下图

(6) 这中网络链接方法我们称之为Bridge,其实也可以通过命令查看docker中的网络模式:docker network ls bridge也是docker中默认的网络模式

[root@localhost ~]# docker network ls
NETWORK ID          NAME                DRIVER              SCOPE
84b28b483705        bridge              bridge              local
3c097aac44a8        host                host                local
65afa54ab07b        none                null                local
[root@localhost ~]# docker network inspect bridge
[
    {
        "Name": "bridge",
        "Id": "84b28b483705df9ada1e40ec5e14cd977a2e6ce5714ba9368615a5f9d26843d8",
        "Created": "2019-12-22T05:33:11.234741528Z",
        "Scope": "local",
        "Driver": "bridge",
        "EnableIPv6": false,
        "IPAM": {
            "Driver": "default",
            "Options": null,
            "Config": [
                {
                    "Subnet": "172.17.0.0/16",
                    "Gateway": "172.17.0.1"
                }
            ]
        },
        "Internal": false,
        "Attachable": false,
        "Ingress": false,
        "ConfigFrom": {
            "Network": ""
        },
        "ConfigOnly": false,
        "Containers": {
            "2198174cc63746a0c5200f6978af2233ca9552a0924138b9905ef4c0767ed4c9": {
                "Name": "tomcat02",
                "EndpointID": "4adc55bc6902854a0d9b8c8b86c65f9e6aa937a55ab7f69f9980a87c3d5a4959",
                "MacAddress": "02:42:ac:11:00:03",
                "IPv4Address": "172.17.0.3/16",
                "IPv6Address": ""
            },
            "a4bcf025353f43da57f85fd3e24e550b5252256f00ba586eb0b7f9d18bea6cf4": {
                "Name": "tomcat01",
                "EndpointID": "2d6149d8d00016802a1dc59013a2e82811249114e12667573c0518c6668bcb06",
                "MacAddress": "02:42:ac:11:00:02",
                "IPv4Address": "172.17.0.2/16",
                "IPv6Address": ""
            }
        },
        "Options": {
            "com.docker.network.bridge.default_bridge": "true",
            "com.docker.network.bridge.enable_icc": "true",
            "com.docker.network.bridge.enable_ip_masquerade": "true",
            "com.docker.network.bridge.host_binding_ipv4": "0.0.0.0",
            "com.docker.network.bridge.name": "docker0",
            "com.docker.network.driver.mtu": "1500"
        },
        "Labels": {}
    }
]

(6) 在tomcat01容器中是可以访问互联网的，如下图，NAT是通过iptables实现的

3.4.2 创建自己的network

(1) 创建一个network,l类型为bridge

docker network create tomcat-net
or
docker network create --subnet=172.18.0.0/24 tomcat-net

(2) 查看已有network:docker network ls

[root@localhost ~]# docker network ls
NETWORK ID          NAME                DRIVER              SCOPE
84b28b483705        bridge              bridge              local
3c097aac44a8        host                host                local
65afa54ab07b        none                null                local
84c8a810d5ff        tomcat-net          bridge              local

(3) 查看tomcat-net详情信息:`

docker network inspect tomcat-net

(4) 创建tomcat的容器，并指定使用tomcat-net

docker run -d --name custom-net-tomcat --network tomcat-net tomcat

(5) 查看custom-net-tomcat的网络信息

docker exec -it custom-net-tomcat ip a

(6) 查看网卡信息

  ip a

(7) 查看网卡接口

[root@localhost ~]# brctl show
bridge name     bridge id               STP enabled     interfaces
br-84c8a810d5ff         8000.02425646fc99       no              veth42c1f70
docker0         8000.024254ef2308       no              veth12116fa
                                                        vethf22cd43

(8) 此时在custom-net-tomcat容器中ping一下tomcat01?发现无法ping通
(9) 查看tomcat-net网络，可以发现tomcat01这个容器也在其中

(10) 查看tomcat-net网络，可以发现tomcat01这个容器也在其中
(11) 此时进入到tomcat01或者custom-net-tomcat中,不仅可以通过ip地址ping通,而且可以通过名字ping到，这时候因为都连接了用户自定义的tomcat-net bridge上

[root@localhost ~]# docker exec -it tomcat01 bash
root@a4bcf025353f:/usr/local/tomcat# ping 172.18.0.2
PING 172.18.0.2 (172.18.0.2) 56(84) bytes of data.
64 bytes from 172.18.0.2: icmp_seq=1 ttl=64 time=0.192 ms
64 bytes from 172.18.0.2: icmp_seq=2 ttl=64 time=0.083 ms
--- 172.18.0.2 ping statistics ---
3 packets transmitted, 3 received, 0% packet loss, time 2006ms
rtt min/avg/max/mdev = 0.071/0.115/0.192/0.055 ms
root@a4bcf025353f:/usr/local/tomcat# ping custom-net-tomcat
PING custom-net-tomcat (172.18.0.2) 56(84) bytes of data.
64 bytes from custom-net-tomcat.tomcat-net (172.18.0.2): icmp_seq=1 ttl=64 time=0.053 ms
64 bytes from custom-net-tomcat.tomcat-net (172.18.0.2): icmp_seq=2 ttl=64 time=0.072 ms

但是ping tomcat02是不通的，因为tomcat02没有进入tomcat-net网络中

3.5 Container网络-Host&None

3.5.1 Host

(1) 创建一个tomcat容器，并且指定网络为host

docker run -d --name my-tomcat-host --network host tomcat

(2) 查看ip地址

docker exec -it my-tomcat-host ip a
# 可以发现和centos是一样的

(3) 检查host网络`docker network inspect host

 ...
 "Containers": {
     "72ef8dbd22384fd1d31b8767166e40fcfcaede780c10a8201989d61e9d4df84b": {
         "Name": "my-tomcat-host",
         "EndpointID": "19f0583962c25b71a9f9c4b0fd29244b1b543a1314e9604a3be3dbda52f34ef2",
         "MacAddress": "",
         "IPv4Address": "",
         "IPv6Address": ""
     }
 },
 ...

3.5.2 None

(1) 创建一个tomcat容器，并指定网络为none

docker run -d --name my-tomcat-none --network none tomcat

(2)查看ip地址

[root@localhost ~]# docker exec -it my-tomcat-none ip a
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

检查none网络

[root@localhost ~]# docker network inspect none
...
        "Containers": {
            "a0e7d7804d6bb12e7c2e0e5c7ed7ff5bd2de5ab38c1e983e04c778abed3d1c5a": {
                "Name": "my-tomcat-none",
                "EndpointID": "b60074c403f5b956d94ee0a287b6ebf4d0fbde2468173821166b36ab993a0ecb",
                "MacAddress": "",
                "IPv4Address": "",
                "IPv6Address": ""
            }
        },
  ...

3.6 端口映射

在这里插入图片描述

(1) 创建一个tomcat容器，名称为port-tomcat

docker run -d name port-tomcat tomcat

(2) 思考一下要访问该tomcat怎么做? 肯定通过ip:port方式

docker exec -it port-tomcat bash
curl localhost:8080

(3) 那么如果要在centos7上访问呢?

docker exec -it port-tomcat ip # 得到ip地址，比如172.17.0.4
curl 172.17.0.4:8080

小结: 之所以能够访问成功，是因为centos上的docker0连接了port-tomcat的network namespace

(4) 那么如果在centos7通过curl localhost方式访问？显然要将port-tomcat的8080端口映射到centos上

docker run -f port-tomcat
docker run -d --name port-tomcat -p 8090:8080 tomcat
curl localhost:8090

(5) centos7是运行在win10上的虚拟机，如果想要在win10上通过ip:port方式访问呢?

# 此时需要centos和win网络在同一个网段，所意在Vagrantfile文件中定义
# 这种方式等同于桥接网络。也可以给该网络指定使用物理机那一块网卡，比如
# config.vm.network "public_network",:bridge=>'en1: wi-Fi (AirPort)'
config.vm.network "public_network"
centos7: ip a --> 192.168.0.110
win10浏览器访问 192.168.0.110:9080

(6) 如果也想把centos7上的8090映射到win的某个端口呢? 然后浏览器访问locathost:port

# 此时需要将centos7端口和win上端口做映射
config.vm.network "forwarded_port",guest:8090,host:8090
# vagrant reload生效一下
win:浏览器访问 localhost:8090

3.7 多机之间的Container通信

在同一台centos7机器上，发现无论怎么折腾，我们一定有办法让两个container通信
那如果是在两台centos7机器上呢? 如下图

(1) 使得来两边的eth0能够通信
(2) 前提要确保spring-boot-project container和mysql container的ip地址不一样
(3) 将spring-boot-project中的所有信息当成eth0要传输给另外一端的I信息
(4) 具体通过vxlan技术实现
   www.evoila.de/2015/11/06/what-is-vxlan-and-how-it-works
(5) 处在vxlan的底层:underlay
    处在xxxlan的上层:overlay

vxlan

04 docker 数据持久持久化

4.1 Volume

(1) 创建mysql数据库的container

docker run -d --name mysql01 -e MYSQL_ROOT_PASSWORD=jack123 mysql

(2) 查看volume:docker volume ls
(3) 具体查看该volume docker volume inspect 发现名字特长
(4) 修改名字-v mysql01_volume:/var/lib/mysql 起个别名

docker run -d --name mysql01 -v mysql01_volume:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=jack123 mysql

(5) 查看volume
docker volume ls
docker volume inspect mysql_volume

# 进入容器中 
docker exec -it mysql01 bash 
# 登录mysql服务 
mysql -uroot -pjack123
# 创建测试库
create database db_test 
# 退出mysql服务，退出mysql container 
# 删除mysql容器 
docker rm -f mysql01 
# 查看volume 
docker volume ls
# 发现volume还在 
   DRIVER VOLUME NAME 
   local mysql01_volume
# 新建一个mysql container，并且指定使用"mysql01_volume" 
docker run -d --name test-mysql -v mysql01_volume:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=jack123 mysql
# 进入容器，登录mysql服务，查看数据库
docker exec -it test-mysql bash
mysql -uroot -pjack123 
show database; 
# 可以发现db_test仍然在 
  | information_schema | 
  | db_test | 
  | mysql | 
  | performance_schema | 
  | sys

4.2 Bind Mounting

# 创建一个tomcat容器
docker run -d --name tomcat01 -p 9090:8080 -v \
/tmp/test:/usr/local/tomcat/webapps/test tomcat
# 查看两个目录
centos：cd /tmp/test 
tomcat容器：cd /usr/local/tomcat/webapps/test
# 在centos的/tmp/test中新建1.html，并写一些内容
<p style="color:blue; font-size:20pt;">This is p!</p>
# 进入tomcat01的对应目录查看，发现也有一个1.html，并且也有内容
# 在centos7上访问该路径：
 curl localhost:9090/test/1.html
# 在win浏览器中通过ip访问
 192.168.0.110:9090/test/1.html

向着风奔跑

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
架构师工具-docker

二、Image and Container2.1 Image文件和meta data的集合（root filesystem）对于linux系统来说分为:,就是内核空间(kernel space)和用户空间(user space)，内核空间linux kernel，就理解成root filesystem用户空间就是在内核上层建立的其实就是：ubuntu，centos，redhat，D...
复制链接

扫一扫