分类 默认分类 下的文章

云与虚拟化：实验2 Docker镜像常用命令的使用

实验要求

了解Docker镜像，掌握Docker镜像常用命令的使用。

前置准备

要求实验主机能够连接外网，已经正确安装Docker，并关闭防火墙和selinux。

实验步骤

步骤1：拉取nginx:latest、busybox:latest和centos:latest镜像

docker pull centos:latest
docker pull nginx:latest
docker pull busybox:latest

步骤2：列出所有本地镜像

docker images

步骤3：搜索收藏数不小于5的redhat镜像，并且完整显示镜像描述信息

docker search -s 5 --no-trunc redhat

docker search --filter stars=5 redhat

其他的命令也可以哦

curl -s "https://registry.hub.docker.com/v2/repositories/redhat/" | jq '.results[] | select(.pull_count >= 5) | .description'

步骤4：拉取收藏数是高的redhat镜像

docker pull redhat/ubi8

步骤5：将redhat镜像标签名修改为redhat:v8.0

docker tag redhat/ubi8:latest redhat:v8.0

步骤6：将nginx:latest镜像导出，命名为nginx.tar

docker save -o nginx.tar nginx:latest

步骤7：删除nginx:latest镜像，并运行docker images命令查看

docker rmi -f nginx:latest

步骤8：将nginx.tar导入，并运行docker images命令查看

docker load --input nginx.tar
docker images

步骤9：删除本地主机中所有的镜像，要求逐一删除

docker rmi nginx:latest
docker rmi busybox:latest
docker rmi centos:latest
docker rmi redhat:v7.0
docker rmi hjd48/redhat:latest
docker rm -v $(docker ps -aq -f status=created)
docker rm -v $(docker ps -aq -f status=exited)

这里还有两个冲突：

K8S

K8S部署

先创建一个debian模板

选择iso

快速安装一下即可：

安装完成克隆成模板：

Master节点

直接克隆一个就可以

克隆两个本地node

sed -i 's/deb.debian.org/mirrors.ustc.edu.cn/g' /etc/apt/sources.list.d/debian.sources
sed -i 's|security.debian.org/debian-security|mirrors.ustc.edu.cn/debian-security|g' /etc/apt/sources.list
echo "export PATH=$PATH:/usr/sbin:/home/$(whoami)/.local/bin" >> ~/.bashrc
source ~/.bashrc
apt install ufw

apt install sudo vim wget curl -y

sudo hostnamectl set-hostname dayi-cloud-k8s-master

这里HOSTS用了tailscile 来进行相互访问

curl -fsSL https://tailscale.com/install.sh | sh

这样就配好hosts了

dayi-cloud-k8s-master
dayi-cloud-k8s-node1
dayi-cloud-k8s-node2

Master

sudo ufw allow 6443/tcp
sudo ufw allow 2379/tcp
sudo ufw allow 2380/tcp
sudo ufw allow 10250/tcp
sudo ufw allow 10251/tcp
sudo ufw allow 10252/tcp
sudo ufw allow 10255/tcp
sudo ufw reload

cat <<EOF | sudo tee /etc/modules-load.d/containerd.conf 
overlay 
br_netfilter
EOF

sudo modprobe overlay 
sudo modprobe br_netfilter
cat <<EOF | sudo tee /etc/sysctl.d/99-kubernetes-k8s.conf
net.bridge.bridge-nf-call-iptables = 1
net.ipv4.ip_forward = 1 
net.bridge.bridge-nf-call-ip6tables = 1 
EOF


sudo sysctl --system

Other

sudo ufw allow 10250/tcp
sudo ufw allow 30000:32767/tcp
sudo ufw reload


cat <<EOF | sudo tee /etc/modules-load.d/containerd.conf 
overlay 
br_netfilter
EOF

sudo modprobe overlay 
sudo modprobe br_netfilter
cat <<EOF | sudo tee /etc/sysctl.d/99-kubernetes-k8s.conf
net.bridge.bridge-nf-call-iptables = 1
net.ipv4.ip_forward = 1 
net.bridge.bridge-nf-call-ip6tables = 1 
EOF


sudo sysctl --system

SSH-密钥复制

mkdir ~/.ssh
echo "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQDk1VvdE9ZZFnK5Bwhi+C74B/rLvT7zKHN4/tUhzLFrMVDQZvsF+8ON9w4xHK1AZyb64GQXs9BtX93N+OJ51t5ZbEl960S0o7BYgcdB7q3+wb9E4uTYNFK7akcBgtxa+3gmZTmttr1l2KT3xzfE9BebkRg+C/DO/PwnaPwOWyeYc90fmcpk7voM2e268wmv6V2eZmIKaA/T7GXCe22qKIcrgWZp78BHL1Je+sqQ72FfzGasDj/iDCcqbW6fsQ4v0QHsuQ4SavcT3xvPDPTwCow4CoV8cQiK4s2nak/5z8lZF07FRJsF0oYcg7m+9qizLv3jBi/P1M26Rhpj5fV6XmdBtIpSY8A958U2bPT/16eAJOcyj+0qFL2E0DWs7Hbh8tni4L51mppQfx4VnozzEzPPaEauGA/GNQ+HlKcaEe43bBia7btW9K9c6EHPvolAf/365gv4BcKArlbOVo4kfxqfX7ybjSnK2pz3kZjFDrXwhQ0LsVqlZIvGu+wkHIVFYHM= root@dayi-cloud-k8s-maste" >> ~/.ssh/authorized_keys

安装containerd

apt install containerd
containerd config default | sudo tee /etc/containerd/config.toml >/dev/null 2>&1
sudo vi /etc/containerd/config.toml

scp /etc/containerd/config.toml dayi-cloud-k8s-node1:/etc/containerd/config.toml
scp /etc/containerd/config.toml dayi-cloud-k8s-node2:/etc/containerd/config.toml

sudo systemctl restart containerd
sudo systemctl enable containerd

安装K8S仓库


sudo apt install gnupg gnupg2 curl software-properties-common -y
curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo gpg --dearmour -o /etc/apt/trusted.gpg.d/cgoogle.gpg
apt-add-repository "deb http://apt.kubernetes.io/ kubernetes-xenial main"

安装K8S

apt update
apt install kubelet kubeadm kubectl -y
apt-mark hold kubelet kubeadm kubectl

初始化集群：

kubeadm init --image-repository registry.aliyuncs.com/google_containers --pod-network-cidr=10.234.0.0/16 --control-plane-endpoint=dayi-cloud-k8s-master --v=5

虚拟化K8S安装

# 设置主机名
hostnamectl set-hostname m1
hostnamectl set-hostname node1
hostnamectl set-hostname node2
、
===== 192.168.0.202 node2

# 使用scp复制/etc/hosts到node1和node2
scp /etc/hosts root@192.168.0.201:/etc/hosts
scp /etc/hosts root@192.168.0.202:/etc/hosts

# 关闭swap并配置内核参数
swapoff -a
sed -i 's/.*swap.*/#&/' /etc/fstab
echo -e 'net.bridge.bridge-nf-call-iptables = 1 \nnet.bridge.bridge-nf-call-ip6tables = 1' >> /etc/sysctl.conf

# 安装基本软件包
yum -y install wget ntpdate

# 配置时间同步
ntpdate ntp1.aliyun.com
crontab -e
# 添加以下内容
*/1 * * * * /usr/sbin/ntpdate ntp1.aliyun.com
systemctl restart crond.service
reboot

# 配置yum源及下载Kubernetes和Docker相关软件包
cd /etc/yum.repos.d
rm -f CentOS-*
wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo
wget -P /etc/yum.repos.d/ http://mirrors.aliyun.com/repo/epel-7.repo
vi /etc/yum.repos.d/kubernetes.repo
# 添加kubernetes源的配置信息
wget https://mirrors.aliyun.com/kubernetes/yum/doc/rpm-package-key.gpg
rpm -import rpm-package-key.gpg
wget https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
yum clean all
yum makecache fast
cd

# 安装docker-ce并启动服务
yum -y install docker-ce
systemctl start docker
systemctl enable docker

# 配置Docker的镜像加速器
vi /etc/docker/daemon.json
# 添加以下内容
{
    "registry-mirrors": ["https://x3nqjrcg.mirror.aliyuncs.com"]
}

# Docker降级为20.10
yum downgrade --setopt=obsoletes=0 -y docker-ce-20.10.24 docker-ce-selinux-20.10.24 containerd.io

# 修改Docker Cgroup Driver为systemd
vi /etc/docker/daemon.json
# 添加以下内容
{
  "exec-opts": ["native.cgroupdriver=systemd"],
  "registry-mirrors": ["https://x3nqjrcg.mirror.aliyuncs.com"]
}

# 重启docker服务
systemctl daemon-reload
systemctl restart docker

# 安装kubeadm、kubectl、kubelet
yum install -y kubelet-1.23.17 kubeadm-1.23.17 kubectl-1.23.17
systemctl start kubelet
systemctl enable kubelet

# 下载Kubernetes镜像
kubeadm config images list --kubernetes-version v1.23.17
kubeadm config images pull --image-repository=registry.aliyuncs.com/google_containers

# 初始化Kubernetes集群
kubeadm init \
--kubernetes-version=v1.23.17 \
--pod-network-cidr=10.244.0.0/16 \
--service-cidr=10.96.0.0/12 \
--apiserver-advertise-address=192.168.8.10 \
--image-repository=registry.aliyuncs.com/google_containers 

# 配置环境变量
mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config

# 安装Flannel网络
wget https://github.com/flannel-io/flannel/releases/latest/download/kube-flannel.yml
kubectl apply -f kube-flannel.yml

# 将节点加入到集群
kubeadm join 192.168.8.10:6443 --token [token] --discovery-token-ca-cert-hash [hash]

# 查看集群状态
kubectl get nodes

Debian安装

K8S2

哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈

换CENTOS

换大牛

Rencher

真男人直接下载：

修改主机名：

ssh-keygen -t ecdsa -b 256
ssh-copy-id node1
ssh-copy-id node2

复制密钥：

ssh-copy-id node2

复制hosts

scp /etc/hosts root@node1:/etc/hosts 
scp /etc/hosts root@node2:/etc/hosts

修改内核配置

/etc/sysctl.conf

vi:

echo -e 'net.bridge.bridge-nf-call-iptables = 1 \nnet.bridge.bridge-nf-call-ip6tables = 1' >> /etc/sysctl.conf

开启模块

modprobe br_netfilter
ls /proc/sys/net/bridge/
echo "br_netfilter" > /etc/modules-load.d/br_netfilter.conf
sysctl -p

发送到从节点：

scp /etc/sysctl.conf root@node1:/etc/sysctl.conf
scp /etc/sysctl.conf root@node2:/etc/sysctl.conf 

#从节点执行：
modprobe br_netfilter
ls /proc/sys/net/bridge/
echo "br_netfilter" > /etc/modules-load.d/br_netfilter.conf
sysctl -p

防火墙 SELINUX：

systemctl stop firewalld
systemctl disable firewalld
systemctl status firewalld



setenforce 0
vi /etc/selinux/config
#修改： SELINUX=disabled

reboot

发送到从节点

scp /etc/selinux/config root@node1:/etc/selinux/config
scp /etc/selinux/config root@node2:/etc/selinux/config

查看SELINUX状态

sestatus

NTP时间同步

yum -y install wget ntpdate


crontab -e
*/1 * * * * /usr/sbin/ntpdate ntp1.aliyun.com

systemctl restart crond.service

添加源


vi /etc/yum.repos.d/kubernetes.repo

[kubernetes]
name=Kubernetes
baseurl=https://packages.cloud.google.com/yum/repos/kubernetes-el7-x86_64
enabled=1
gpgcheck=1
repo_gpgcheck=1
gpgkey=https://packages.cloud.google.com/yum/doc/yum-key.gpg https://packages.cloud.google.com/yum/doc/rpm-package-key.gpg

安装

yum downgrade --setopt=obsoletes=0 -y docker-ce-20.10.24 docker-ce-selinux-20.10.24 containerd.io


yum install -y kubelet-1.23.17 kubeadm-1.23.17 kubectl-1.23.17
systemctl start kubelet
systemctl enable kubelet
systemctl status kubelet
kubeadm config images list --kubernetes-version v1.23.17

初始化

mv /etc/containerd/config.toml /root/config.toml.bak
systemctl restart containerd

/etc/kubernetes/manifests/kube-scheduler.yaml

rm -rf /etc/kubernetes/manifests/kube-apiserver.yaml
rm -rf /etc/kubernetes/manifests/kube-controller-manager.yaml
rm -rf /etc/kubernetes/manifests/kube-scheduler.yaml
rm -rf /etc/kubernetes/manifests/etcd.yaml

kubeadm init \
--pod-network-cidr=10.244.0.0/16 \
--service-cidr=10.96.0.0/12 \
--apiserver-advertise-address=192.168.59.137 \
--image-repository=registry.aliyuncs.com/google_containers
--v=5

rm -f /etc/kubernetes/controller-manager.conf
rm -f /etc/kubernetes/scheduler.conf
rm -f /etc/kubernetes/scheduler.conf
rm -f /etc/kubernetes/admin.conf
rm -f /etc/kubernetes/kubelet.conf

mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config

kubeadm join 192.168.59.137:6443 --token y8m7u7.3ur44mc2ezb87fmq \
        --discovery-token-ca-cert-hash sha256:cb9d1bfa0c3adaabd9a34cd072e1d27c13c9cf9e6e3ef4a0c810b84d6fdf4c9f

节点:

节点：

状态：

云与虚拟化_实验12 Rancher平台部署应用

实验要求

掌握 Rancher 平台部署。

前置准备

要求实验主机能够连接外网，已经正确安装 Docker，并关闭防火墙和 selinux。

实验步骤

这个东西蛮大的。

docker pull rancher/rancher:stable
docker run -d --restart=unless-stopped --privileged -p 8443:443 rancher/rancher:stable

FRP:

FRP：

进入：

加入：

节点添加：

步骤1：拉取 Rancher 镜像。

[root@localhost ~]# docker pull rancher/server:stable

步骤2：利用 Rancher 镜像生成 Rancher 容器。

[root@localhost ~]# docker run -d --restart=unless-stopped -p 8080:8080 rancher/server:stable

主机上复制 Rancher 脚本代码。

[root@localhost ~]# sudo docker run --rm --privileged -v /var/run/docker.sock:/var/run/docker.sock -v /var/lib/rancher:/var/lib/rancher rancher/agent:v1.2.11 http://192.168.5.100:8080/v1/scripts/33363BDEA2105F76C889:1577750400000:7pDzaq5dOUcHCFdLqfZ2lyvGex0

步骤11：添加主机成功。移动窗口底部，点击“创建”按钮。

不过..

更新也容易卡住..

好像不是很稳定的样子..

云与虚拟化_实验10 Compose编排工具应用

实验要求

掌握Compose编排工具的安装和使用。

前置准备

要求实验主机能够连接外网，已经正确安装Docker ce，版本号为18.03.0-ce，并关闭防火墙和selinux。

实验步骤

步骤1：安装Compose编排工具

直接用docker官方安装源代的插件也可以滴！

  1. 测试安装结果。
root@registry:/home/dayi# 
root@registry:/home/dayi# find / -name docker-compose
/usr/libexec/docker/cli-plugins/docker-compose
root@registry:/home/dayi# ln -s /usr/libexec/docker/cli-plugins/docker-compose /bin/docker-compose
root@registry:/home/dayi# docker-compose --version
Docker Compose version v2.21.0
root@registry:/home/dayi#

步骤2：编排启动镜像

  1. 创建文件目录。
[root@docker01 ~]# mkdir /opt/my_wordpress/
[root@docker01 ~]# cd /opt/my_wordpress/
  1. 编写编排文件。
[root@docker01 my_wordpress]# vi docker-compose.yml
version: '3'
services:
   db:
     image: mysql:5.7
     volumes:
       - /data/db_data:/var/lib/mysql
     restart: always
     environment:
       MYSQL_ROOT_PASSWORD: somewordpress
       MYSQL_DATABASE: wordpress
       MYSQL_USER: wordpress
       MYSQL_PASSWORD: wordpress
     ports:
       - "3306:3306"
   wordpress:
     depends_on:
       - db
     image: wordpress:latest
     volumes:
       - /data/web_data:/var/www/html
     ports: 
       - "8000:80"
     restart: always
     environment:
       WORDPRESS_DB_HOST: db:3306
       WORDPRESS_DB_USER: wordpress
       WORDPRESS_DB_PASSWORD: wordpress

  1. 启动。
[root@docker01 my_wordpress]# docker-compose up -d
# 启动方法：docker-compose up
# 后台启动方法：docker-compose up -d

  1. 在浏览器上访问http://192.168.5.100:8000，进行WordPress的安装即可。

  1. 删库跑路

云与虚拟化_实验7 Docker网络管理应用

实验要求

了解Docker常用网络模式，掌握Docker常用网络模式的使用。本实验主要任务是利用busybox镜像建立容器，容器名称为test_busybox1和test_busybox2，将网络模式设置为none，并为容器配置IP地址，容器test_busybox1的IP设置为172.17.0.100，容器test_busybox2的IP设置为172.17.0.200，要求实现两容器互通。

前置准备

要求实验主机能够连接外网，已经正确安装Docker，并关闭防火墙和selinux。

实验过程

步骤1-3

# 步骤1.1: 创建容器test_busybox1，设置网络模式为none
docker run -dit --name=test_busybox1 --net=none busybox:latest

# 进入容器test_busybox1
docker exec -it test_busybox1 /bin/sh

# 步骤1.2: 查看IP地址（容器test_busybox1）
ip addr
# 从现象可以得知容器test_busybox1没有IP地址。

# 退出容器test_busybox1
exit

# 步骤2.1: 创建容器test_busybox2，设置网络模式为none
docker run -dit --name test_busybox2 --net=none busybox:latest
# 进入容器test_busybox2
docker exec -it test_busybox2 /bin/sh
# 步骤2.2: 查看IP地址（容器test_busybox2）
ip address
# 退出容器test_busybox2
exit

从现象可以得知容器test_busybox1,test_busybox2都没有IP地址。

步骤4

# 步骤3: 为容器test_busybox1设置IP地址为172.17.0.100
# 安装bridge-utils软件包
yum -y install bridge-utils

# 创建veth对，并将veth0加入docker0网桥
ip link add veth0 type veth peer name veth1
#           虚拟网桥           peer的name 
brctl addif docker0 veth0
# 桥接管理器 添加 管理桥接
brctl show


# 启动veth0，原神启动 (另外一个veth1也会自动启动)
ip link set veth0 up

# 获取容器test_busybox1的PID
pid1=$(docker inspect -f '{{.State.Pid}}' test_busybox1)
echo "容器test_busybox1的PID是：$pid1"


#有两种途径索引network namespace：名字（例如netns1）或者属于该namespace的进程PID。
#使用命名（Name）：为网络命名空间分配可读的名称，然后使用该名称来引用和操作命名空间。这使得管理网络命名空间更加方便和直观。
#使用进程PID：每个网络命名空间都与一个进程相关联，通常是一个子进程。可以使用该进程的PID来访问和管理与之关联的网络命名空间。

# 创建network namespace软连接
mkdir -p /var/run/netns
ln -s /proc/$pid1/ns/net /var/run/netns/$pid1
ip netns ls

# 将veth1连接到容器test_busybox1的network namespace，并重命名为eth0
ip link set veth1 netns $pid1
ip netns exec $pid1 ip link set dev veth1 name eth0



# 启用eth0
ip netns exec $pid1 ip link set eth0 up

# 分配IP地址和设置网关
ip netns exec $pid1 ip addr add 172.17.0.100/24 dev eth0
ip netns exec $pid1 ip route add default via 172.17.0.1

安装包：

网桥：

veth0启动：

PID:


Docker State信息

  1. .Id: 容器的唯一标识符，通常是一个长字符串，也被称为容器ID。
  2. .Name: 容器的名称，通常是用户定义的名称，可以用来引用容器。
  3. .State.Status: 容器的状态，如运行中、停止等。
  4. .State.Running: 表示容器是否正在运行（布尔值）。
  5. .State.Pid: 容器内部主进程的PID。
  6. .Config.Image: 使用的容器镜像的名称。
  7. .Config.Cmd: 启动容器时使用的命令。
  8. .Config.Env: 容器的环境变量。
  9. .NetworkSettings.IPAddress: 容器的IP地址（如果有网络配置）。
  10. .HostConfig.Binds: 挂载到容器内部的卷或目录。
  11. .Mounts: 容器的挂载点信息。
  12. .Created: 容器创建的时间戳。
  13. .Ports: 容器的端口映射信息。
  14. .Labels: 用户定义的容器标签。
  15. .LogPath: 容器的日志文件路径。
  16. .HostConfig.NetworkMode: 容器的网络模式。

netns:

执行完之后，可以看到已经分配到网卡：

目前这个namespace叫2133

然后再命名空间里执行了一些命令。

步骤5

配置容器test_busybox2的网络

# 创建一对虚拟以太网设备veth2和veth3，这两个设备是成对出现的，数据可以在两个设备之间传送
ip link add veth2 type veth peer name veth3

# 将veth2这端加入到docker0桥接器中，这样veth2就能和docker0桥接器上的其他网络设备进行通信了
brctl addif docker0 veth2

# 显示当前桥接器的信息，可以看到docker0桥接器及其所连接的网络接口
brctl show

# 启用veth2网络接口，使其能够进行数据传输
ip link set veth2 up

# 使用docker命令检查名为test_busybox2的容器，提取容器的进程ID
docker inspect test_busybox2 | grep Pid

# 用docker inspect命令获取名为test_busybox2的容器的PID，并将其存储在变量pid2中
pid2=$(docker inspect -f '{{.State.Pid}}' test_busybox2)

# 输出容器test_busybox2的PID
echo "容器test_busybox2的PID是：$pid2"

# 为容器的网络命名空间创建一个软链接，方便后续的操作。/var/run/netns/目录通常用于存放网络命名空间
ln -s /proc/$pid2/ns/net /var/run/netns/$pid2

# 将veth3这端的网络接口移到容器test_busybox1的网络命名空间中
ip link set veth3 netns $pid2

# 在test_busybox1容器的网络命名空间内，将网络接口veth3重命名为eth0
ip netns exec $pid2 ip link set dev veth3 name eth0

# 启用容器内的eth0网络接口
ip netns exec $pid2 ip link set eth0 up

# 为容器内的eth0接口分配IP地址172.17.0.200，并设置子网掩码为24位
ip netns exec $pid2 ip addr add 172.17.0.200/24 dev eth0

# 设置容器内的网络路由，使其默认网关为172.17.0.1，即docker0桥的IP地址
ip netns exec $pid2 ip route add default via 172.17.0.1


[root@node-a docker]# ip link add veth2 type veth peer name veth3
[root@node-a docker]# brctl addif docker0 veth2
[root@node-a docker]# brctl show
bridge name     bridge id               STP enabled     interfaces
docker0         8000.0242398240fb       no              veth0
                                                        veth2
                                                        veth271d838
                                                        veth588fc94
[root@node-a docker]# ip link set veth2 up
[root@node-a docker]# docker inspect test_busybox2 | grep Pid
            "Pid": 2212,
            "PidMode": "",
            "PidsLimit": null,
[root@node-a docker]# pid2=$(docker inspect -f '{{.State.Pid}}' test_busybox2)
[root@node-a docker]# echo "容器test_busybox2的PID是：$pid2"
容器test_busybox2的PID是：2212
[root@node-a docker]# ln -s /proc/$pid2/ns/net /var/run/netns/$pid2
[root@node-a docker]# ip link set veth3 netns $pid2
[root@node-a docker]# ip netns exec $pid2 ip link set dev veth3 name eth0
[root@node-a docker]# ip netns exec $pid2 ip link set eth0 up
[root@node-a docker]# ip netns exec $pid2 ip addr add 172.17.0.200/24 dev eth0
[root@node-a docker]# ip netns exec $pid2 ip route add default via 172.17.0.1
[root@node-a docker]# docker exec -it test_busybox2 ip addr
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue 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
12: eth0@if13: <BROADCAST,MULTICAST,UP,LOWER_UP,M-DOWN> mtu 1500 qdisc noqueue qlen 1000
    link/ether 92:7f:5d:85:1e:69 brd ff:ff:ff:ff:ff:ff
    inet 172.17.0.200/24 scope global eth0
       valid_lft forever preferred_lft forever
[root@node-a docker]#

步骤6：测试

docker exec -it test_busybox2 ip addr
docker exec -it test_busybox2 ping -c 4 172.17.0.100
docker exec -it test_busybox1 ip addr
docker exec -it test_busybox1 ping -c 4 172.17.0.200

  1. 1
  2. ...
  3. 3
  4. 4
  5. 5
  6. 6
  7. 7
  8. 8
  9. 9
  10. ...
  11. 29