docker network 、compose

爱被打了一巴掌 2022-10-30 01:23 144阅读 0赞

# docker 进阶 #

### docker网络 ###

# 删除全部容器
    $ docker rm -f $(docker ps -aq)
    
    # 删除全部镜像
    $ docker rmi -f $(docker images -aq)

#### 原理 ####

每启动一个docker容器，docker就会给docker容器分配一个ip，就会有一个docker0桥接模式，使用的技术是[veth-pair技术][veth-pair]

# 测试 运行一个tomcat
    $ docker run -d -P --name tomcat01 tomcat
    
    # 查看容器内部网络地址
    $ docker exec -it 容器id ip addr
    
    # 发现容器启动的时候会得到一个 eth0@if5 ip地址，docker分配！
    $ ip addr
    1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN 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
    4: eth0@if5: <BROADCAST,MULTICAST,UP,LOWER_UP,M-DOWN> mtu 1500 qdisc noqueue state UP 
        link/ether 02:42:ac:11:00:02 brd ff:ff:ff:ff:ff:ff
        inet 172.17.0.2/16 brd 172.17.255.255 scope global eth0
           valid_lft forever preferred_lft forever
    
    # linux与容器内部可以相互ping通
    $ 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.047 ms
    64 bytes from 172.17.0.2: icmp_seq=2 ttl=64 time=0.115 ms
    
    # 容器带来网卡，都是一对对的
    # veth-pair 就是一对的虚拟设备接口，他们都是成对出现的，一端连着协议，一端彼此相连
    # 正因为有这个特性 veth-pair 充当一个桥梁，连接各种虚拟网络设备的
    # OpenStac,Docker容器之间的连接，OVS的连接，都是使用evth-pair技术
    #再启动一个容器，容器之间也是可以互相ping通的

Docker使用的是Linux的桥接，宿主机是一个Docker容器的网桥 docker0。所有的容器不指定网络的情况下，都是docker0路由的，docker会给我们的容器分配一个默认的可用ip。Docker中所有网络接口都是虚拟的，虚拟的转发效率高（内网传递文件）只要容器删除，对应的网桥一对就没了！

#### 容器互联–-link ####

$ docker exec -it tomcat02 ping tomca01   # ping不通
    ping: tomca01: Name or service not known
    
    # 运行一个tomcat03 --link tomcat02 
    $ docker run -d -P --name tomcat03 --link tomcat02 tomcat
    5f9331566980a9e92bc54681caaac14e9fc993f14ad13d98534026c08c0a9aef
    
    # 3连接2
    # 用tomcat03 ping tomcat02 可以ping通
    $ 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.115 ms
    64 bytes from tomcat02 (172.17.0.3): icmp_seq=2 ttl=64 time=0.080 ms
    
    # 2连接3
    # 用tomcat02 ping tomcat03 ping不通

`–link` 本质就是在hosts配置中添加映射。现在使用Docker已经不建议使用 `–link` 了！

#### 自定义网络 ####

docker network
    connect     -- Connect a container to a network
    create      -- Creates a new network with a name specified by the
    disconnect  -- Disconnects a container from a network
    inspect     -- Displays detailed information on a network
    ls          -- Lists all the networks created by the user
    prune       -- Remove all unused networks
    rm          -- Deletes one or more networks

**网络模式**

查看所有docker网络 `docker network ls`

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

none ：不配置网络，一般不用

host ：和所主机共享网络

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

**测试**

# 我们直接启动的命令 --net bridge,而这个就是我们得docker0
    # bridge就是docker0
    $ docker run -d -P --name tomcat01 tomcat
    等价于 => docker run -d -P --name tomcat01 --net bridge tomcat
    
    # docker0，特点：默认，域名不能访问。 --link可以打通连接，但是很麻烦！
    # 我们可以 自定义一个网络
    $ docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet
    
    
    $ docker network inspect mynet;
    
    #在自定义的网络下，服务可以互相ping通(名字与ip都可以)，不用使用–link
    
    $ docker run -d -P --name tomcat-net-01 --net mynet tomcat
    $ docker run -d -P --name tomcat-net-02 --net mynet tomcat

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

好处：

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

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

#### 网络连通 ####

# 测试两个不同的网络连通 再启动两个tomcat 使用默认网络，即docker0
    $ docker run -d -P --name tomcat01 tomcat
    $ docker run -d -P --name tomcat02 tomcat
    # 此时ping不通
    
    # 要将tomcat01 连通 tomcat—net-01 ，连通就是将 tomcat01加到 mynet网络
    # 一个容器两个ip（tomcat01）
    $ docker network connect mynet tomcat01
    # 01连通 ，加入后此时，已经可以tomcat01 和 tomcat-01-net ping通了
    $ docker exec -it tomcat01 ping tomcat-net-01
    
    $docker exec -it tomcat02 ping tomcat-net-01
    # 02是依旧不通的

#### 部署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 >> /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
    
    # 通过脚本运行六个redis
    for port in $(seq 1 6);\
    docker run -p 637${port}:6379 -p 1667${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
    docker exec -it redis-1 /bin/sh #redis默认没有bash
    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

### docker compose ###

#### 概念 ####

Docker Compose 用于定义运行使用多个容器的应用，可以一条命令启动应用（多个容器）。

使用Docker Compose 的步骤：

1.  定义容器 Dockerfile
2.  定义应用的各个服务 docker-compose.yml
3.  启动应用 docker-compose up

#### [安装][Link 1] ####

sudo curl -L "https://github.com/docker/compose/releases/download/1.28.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
    
    sudo chmod +x /usr/local/bin/docker-compose
    
    sudo ln -s /usr/local/bin/docker-compose /usr/bin/docker-compose
     
    docker-compose --version

#### [应用入门][Link 2] ####

**创建python项目，使用FlasK，将数值计入Redis。**

# mkdir composetest
    # cd composetest
    
    # vi app.py
    import time
    
    import redis
    from flask import Flask
    
    app = Flask(__name__)
    cache = redis.Redis(host='redis', port=6379)
    
    def get_hit_count():
        retries = 5
        while True:
            try:
                return cache.incr('hits')
            except redis.exceptions.ConnectionError as exc:
                if retries == 0:
                    raise exc
                retries -= 1
                time.sleep(0.5)
    
    @app.route('/')
    def hello():
        count = get_hit_count()
        return 'Hello World! I have been seen {} times.\n'.format(count)
    
    # vi requirements.txt 
    flask
    redis

**创建 Dockerfile**

# vi Dockerfile
    FROM python:3.7-alpine
    WORKDIR /code
    ENV FLASK_APP=app.py
    ENV FLASK_RUN_HOST=0.0.0.0
    RUN apk add --no-cache gcc musl-dev linux-headers
    COPY requirements.txt requirements.txt
    RUN pip install -r requirements.txt
    EXPOSE 5000
    COPY . .
    CMD ["flask", "run"]

这告诉Docker：

*  从Python 3.7映像开始构建映像。
 *  将工作目录设置为`/code`。
 *  设置`flask`命令使用的环境变量。
 *  安装gcc和其他依赖项
 *  复制`requirements.txt`并安装Python依赖项。
 *  向图像添加元数据以描述容器正在侦听端口5000
 *  将`.`项目中的当前目录复制到`.`映像中的工作目录。
 *  将容器的默认命令设置为`flask run`。

**定义服务**:`web`和`redis`

# vi docker-compose.yml
    version: "3.9"
    services:
      web:
        build: .
        ports:
          - "5000:5000"
      redis:
        image: "redis:alpine"

**启动应用**

`# docker-compose up`

**访问应用**

http://localhost:5000/

#### 命令 ####

# 1. 基于docker-compose.yml启动管理的容器
    docker-compose up -d
    # 2. 关闭并删除容器
    docker-compose down
    # 3. 开启|关闭|重启已经存在的由docker-compose维护的容器
    docker-compose start|stop|restart
    # 4. 查看由docker-compose管理的容器
    docker-compose ps
    # 5. 查看日志
    docker-compose logs -f
    
    #对容器执行命令（一次）
    docker-compose run services cmd
    #例如：查看web容器环境变量
    docker-compose run web env

#### Docker-Compose管理MySQL和Tomcat容器 ####

> yml文件以key:value方式指定配置信息  
> 多个配置信息以换行+缩进的方式来区分  
> docker-compose.yml文件中，不要使用制表符  
> 关键词：后面都是有一个空格的，比如：restart: always

以一个管理mysql+tomcat的yaml的容器为例

version:'3.1'
    services:
      mysql:                     # 服务的名称
        restart: always          # 代表只要Docker启动，那么这个容器就跟着一起启动
        image: daocloud.io/library/mysql:5.7.4     # 指定镜像路径
        container_name: mysql    # 指定容器名称
        ports:
          - 3306:3306        # 指定端口号的映射
        environment:
          MYSQL_ROOT_PASSWORD: root         # 指定MySQL的ROOT用户登录密码
          TZ: Asia/Shanghai                 # 指定时区
        volumes:
          - /opt/docker_mysql-tomcat/mysql_data:/var/lib/mysql        # 映射数据卷
      tomcat:
        restart: always          # 代表只要Docker启动，那么这个容器就跟着一起启动
        image: daocloud.io/library/tomcat:8.5.15-jre8     # 指定镜像路径
        container_name: tomcat    # 指定容器名称
        ports:
          - 8080:8080        # 指定端口号的映射
        environment:
          MYSQL_ROOT_PASSWORD: root         # 指定MySQL的ROOT用户登录密码
          TZ: Asia/Shanghai                 # 指定时区
        volumes:
          - /opt/docker_mysql-tomcat/tomcat_webapps:/usr/local/tomcat/webapps        # 映射数据卷
          - /opt/docker_mysql-tomcat/tomcat_logs:/usr/local/tomcat/logs        # 映射数据卷

#### docker-compose配合Dockerfile使用 ####

使用docker-compose.yml文件以及Dockerfile文件在生成自定义镜像的同时启动当前镜像，并且由docker-compose去管理容器  
docker-compose.yml：

# yml文件
    version: '3.1'
    services:
      ssm:
        restart: always
        build:                           # 构建自定义镜像
          context: ../                   # 指定Dockerfile文件所在路径
          dockerfile: Dockerfile         # 指定Dockerfile文件名称
        image: ssm:1.0.1
        container_name: ssm
        ports:
          8081:8080
        environment:
          TZ: Asia/Shanghai

Dockerfile文件：

from daocloud.io/library/tomcat:8.5.15-jre8
    copy ssm.war /usr/local/tomcat/webapps

在Dockerfile文件所在的目录下，启动

# 可以直接启动基于docker-compose.yml以及Dockerfile文件构建的自定义镜像
    docker-compose up -d
    # 如果自定义镜像不存在，会帮助我们构建出自定义镜像，如果自定义镜像已经存在，会直接运行这个自定义镜像
    # 重新构建的话
    # 重新构建自定义镜像
    docker-compose build
    # 运行前，重新构建
    docker-compose up -d --build

[Compose and WordPress][]

[veth-pair]: https://www.cnblogs.com/bakari/p/10613710.html
[Link 1]: https://docs.docker.com/compose/install/
[Link 2]: https://docs.docker.com/compose/gettingstarted/
[Compose and WordPress]: https://docs.docker.com/compose/wordpress/