【docker安装笔记】

sxsl_lwp

已于 2022-12-14 16:00:10 修改

阅读量2.5k

点赞数

分类专栏：技术类文章标签： docker linux centos

于 2022-03-15 16:22:01 首次发布

本文链接：https://blog.csdn.net/sxsl_lwp/article/details/123502608

版权

技术类专栏收录该内容

21 篇文章 1 订阅

订阅专栏

docker安装笔记

一、前期准备
- 1、准备3台虚拟机
- 2、更改hosts和hostname
- 3、检查linux的内核
- 4、非root安装时修改 /etc/sudoers
- 5、阿里云yum源
二、安装步骤
- 1、安装依赖
- 2、设置yum源
- 3、安装docker
- 4、docker卸载
三、常用命令
- 1、启停docker（Centos7+）
- 2、Docker命令权限拒绝
- 3、其他常用命令
四、搭建测试环境
- 1、搭建Nginx环境
- 2、Docker安装tomcat
- 3、部署es+kibana
五、Docker镜像
- 1、概念
- 2、Docker镜像加载原理
- 3、加深理解
- 4、镜像commit
- - 4.1 概念
  - 4.2 实例
- 5、小结
六、容器数据卷
- 1、概念
- 2、数据卷挂载方式
七、DockerFile
- 1、DockerFile基础
- 2、实战测试
八、Docker网络
- 1、准备环境
- 2、测试
- 3、 veth pair技术
- 4、docker网络本质
- 5、--link
- 6、自定义网络
- - 6.1 查看所有的docker网络
  - 6.2 测试
- 7、网络连通
九、搭建redis集群
- 1、创建redis网络
- 2、创建6个redis目录及配置文件
- 3、启动6个redis容器
- 4、创建集群
十、springboot微服务打包docker镜像
- 1、构建springboot微服务项目
- 2、打包镜像
- 3、编写dockerfile
- 4、构建镜像
- 5、发布运行

一、前期准备

1、准备3台虚拟机

128.128.7.11，主机名为lwp11
128.128.7.12，主机名为lwp12
128.128.7.13，主机名为lwp13

2、更改hosts和hostname

（1）vi /etc/hosts --每台虚拟机的hosts文件末尾增加

128.128.7.11 lwp11
128.128.7.12 lwp12
128.128.7.13 lwp13

（2）vi /etc/hostname --对应每台虚拟机修改主机名

3、检查linux的内核

uname -r --Docker要求安装环境为 64位系统，且内核在3.8以上

4、非root安装时修改 /etc/sudoers

sudo 使用，没有在sudoers中，修改 /etc/sudoers文件（可以直接使用root账号，不需要这些设置）

5、阿里云yum源

（1）目前只有阿里云yum源可用，对于非阿里云yum源，采取先步骤

cd /etc/yum.repos.d/
mv CentOS-CR.repo CentOS-CR.repo.bak --备份旧镜像文件
wget http://mirrors.aliyun.com/repo/Centos-7.repo

二、安装步骤

1、安装依赖

sudo yum install -y yum-utils device-mapper-persistent-data lvm2

2、设置yum源

yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

3、安装docker

//查看车库中可安装的docker版本
yum list docker-ce --showduplicates | sort -r
 yum install docker-ce-20.10.12-3.el7  docker-ce-cli-20.10.12-3.el7 containerd.io-20.10.12-3.el7

如果(尝试在命令行中添加 ‘–allowerasing’ 来替换冲突的软件包或 ‘–skip-broken’ 来跳过无法安装的软件包或 ‘–nobest’ 来不只使用软件包的最佳候选)出现这个错误，先手动安装最新版的containerd.io 在 yum install docker-ce docker-ce-cli
安装containerd.io yum install -y https://mirrors.aliyun.com/docker-ce/linux/centos/8/x86_64/stable/Packages/containerd.io-1.4.6-3.1.el8.x86_64.rpm
安装containerd.io出现上述问题，则在后面机上–allowerasing在安装

4、docker卸载

（1）卸载Docker Engine，CLI和Containerd软件包：（卸载依赖）

yum remove docker-ce docker-ce-cli containerd.io

（2）主机上的映像，容器，卷或自定义配置文件不会自动删除。要删除所有图像，容器和卷：（删除目录）

rm -rf /var/lib/docker

三、常用命令

1、启停docker（Centos7+）

systemctl start docker
systemctl restart  docker
systemctl stop docker

2、Docker命令权限拒绝

sudo groupadd docker #添加docker用户组，这个用户组应该是已存在了
sudo gpasswd -a $USER docker #将当前用户加入到docker用户组中
newgrp docker #更新用户组docker

3、其他常用命令

（1）搜索相应的镜像

docker search gitlab

（2）进入容器目录

docker exec -it 容器ID /bin/bash

（3）删除指定的镜像 docker rmi 镜像ID；运行docker run… ; 停止 docker stop ID; 查看镜像 docker images
删除镜像时，不能删除已经被容器使用的镜像，需要先删除容器
多个id相同的镜像，可以通过REPODITORY[:TAG]的组合进行删除

在这里插入图片描述
（4）删除指定的容器 docker rm 容器ID；查看容器 docker ps…
（5）docker container update --restart=always 容器名字

四、搭建测试环境

1、搭建Nginx环境

（1）搜索镜像

docker search nginx

（2）下载镜像

docker pull nginx

（3）启动nginx

docker run -d --name nginx01 -p 3344:80 nginx --后台方式运行，指定外部地址端口为3344，nginx容器内部端口为80

（4）查看容器是否运行

docker ps
网页访问：http://128.128.7.254:3344

2、Docker安装tomcat

#官方使用
docker run -it --rm tomcat:9.0
--rm:用完之后立即删掉
#docker启动的tomcat发现以下问题：1、Linux命令少了；2、没有webapps 3、阿里云镜像默认是最小得镜像，所有不必要的都剔除掉，保证最小的可运行环境

3、部署es+kibana

（1） es特点：es暴露的端口很多，十分耗内存，数据一般要放到安全目录，挂载
（2）拉取镜像

docker pull elasticsearch:7.14.2

（3）创建网络

docker network create hahanetwork

（4）运行es：

docker run --name elasticsearch --net hahanetwork -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" -e ES_JAVA_OPTS="-Xms64m -Xmx512m" -d elasticsearch:7.14.2
---e ES_JAVA_OPTS="-Xms64m -Xmx512m" 用于限制容器使用内存资源

（5）查看容器使用资源情况

docker stats

五、Docker镜像

1、概念

镜像是一种轻量级、可执行的独立软件包，用来打包软件运行环境和基于运行环境开发的软件，它包含运行某个软件所需的所有内容，包括代码、运行时库、环境变量和配置文件。

2、Docker镜像加载原理

2.1 UnionFS（联合文件系统）

（1）UnionFS（联合文件系统）：Union文件系统（UnionFS）是一种分层、轻量级并且高性能的文件系统，它支持对文件系统的修改作为一次提交来一层层的叠加，同时可以将不同目录挂载到同一个虚拟文件系统下(unite several directories into a single virtual filesystem)。
（2）Union 文件系统是 Docker 镜像的基础。镜像可以通过分层来进行继承，基于基础镜像（没有父镜像），可以制作各种具体的应用镜像。

2.2 Docker镜像加载原理

（1）docker的镜像实际上由一层一层的文件系统组成，这种层级的文件系统通过UnionFS构成了一个完整的镜像。
（2）bootfs(boot file system)主要包含bootloader和kernel，bootloader主要是引导加载kernel，Linux刚启动时会加载bootfs文件系统，在Docker镜像的最底层是bootfs。这一层与我们典型的Linux/Unix系统是一样的，包含boot加载器和内核。当boot加载完成之后整个内核就都在内存中了，此时内存的使用权已由bootfs转交给内核，此时系统也会卸载bootfs。
（3）ootfs (root file system) ，在bootfs之上。包含的就是典型 Linux 系统中的 /dev, /proc, /bin, /etc 等标准目录和文件。rootfs就是各种不同的操作系统发行版，比如Ubuntu，Centos等等。
在这里插入图片描述
（4）其实就是我们看到的镜像只包含了rootfs的部分，bootfs的部分只是作为底层的引导作用，在镜像生成完会被卸载，并不存在于镜像中。这也就是为啥我们使用Docker制作的Centos镜像只要几百兆，而使用虚拟机安装的Centos需要好几个G。
（5）对于一个精简的OS，rootfs 可以很小，只需要包含最基本的命令，工具和程序库就可以了，因为底层直接用Host的kernel，自己只需要提供rootfs就可以了。由此可见对于不同的linux发行版，bootfs基本是一致的，rootfs会有差别，因此不同的发行版可以公用bootfs

2.3 分层理解

（1）docker pull tomcat，拉最新Tomcat镜像查看分层状况

[root@jiangnan ~]# docker pull tomcat
Using default tag: latest
latest: Pulling from library/tomcat
0e29546d541c: Pull complete 
9b829c73b52b: Pull complete 
cb5b7ae36172: Pull complete 
6494e4811622: Pull complete 
668f6fcc5fa5: Pull complete 
dc120c3e0290: Pull complete 
8f7c0eebb7b1: Pull complete 
77b694f83996: Pull complete 
0f611256ec3a: Pull complete 
4f25def12f23: Pull complete 
Digest: sha256:9dee185c3b161cdfede1f5e35e8b56ebc9de88ed3a79526939701f3537a52324
Status: Downloaded newer image for tomcat:latest
docker.io/library/tomcat:latest
[root@jiangnan ~]#

（2）docker pull tomcat:9.0，拉Tomcat9.0镜像

[root@localhost ~]# docker pull tomcat:9.0
9.0: Pulling from library/tomcat
dbba69284b27: Already exists 
9baf437a1bad: Already exists 
6ade5c59e324: Already exists 
b19a994f6d4c: Already exists 
43c0aceedb57: Already exists 
24e7c71ec633: Already exists 
612cf131e488: Already exists 
dc655e69dd90: Already exists 
9fef2bfb252c: Pull complete 
9286f8690b8d: Pull complete 
Digest: sha256:65d767bb4b2992ed8cdfca3769e33780fd826fe69003793a6fb20c93087ae59a
Status: Downloaded newer image for tomcat:9.0
docker.io/library/tomcat:9.0

（3）对比两层操作
Tomcat分为10层，第一次拉最新镜像时，将10层全部拉下来，当拉9.0镜像时，只拉与9.0相关的2层，其余沿用最新镜像的层。
（4）通过docker inspect 可以看得更加清晰，主要看layer（层）部分

"RootFS": {
            "Type": "layers",
            "Layers": [
                "sha256:11936051f93baf5a4fb090a8fa0999309b8173556f7826598e235e8a82127bce",
                "sha256:31892cc314cb1993ba1b8eb5f3002c4e9f099a9237af0d03d1893c6fcc559aab",
                "sha256:8bf42db0de72f74f4ef0c1d1743f5d54efc3491ee38f4af6d914a6032148b78e",
                "sha256:26a504e63be4c63395f216d70b1b8af52263a5289908df8e96a0e7c840813adc",
                "sha256:f9e18e59a5651609a1503ac17dcfc05856b5bea21e41595828471f02ad56a225",
                "sha256:832e177bb5008934e2f5ed723247c04e1dd220d59a90ce32000b7c22bd9d9b54",
                "sha256:3bb5258f46d2a511ddca2a4ec8f9091d676a116830a7f336815f02c4b34dbb23",
                "sha256:59c516e5b6fafa2e6b63d76492702371ca008ade6e37d931089fe368385041a0",
                "sha256:bd2befca2f7ef51f03b757caab549cc040a36143f3b7e3dab94fb308322f2953",
                "sha256:3e2ed6847c7a081bd90ab8805efcb39a2933a807627eb7a4016728f881430f5f"
            ]
        }

3、加深理解

（1）所有的 Docker 镜像都起始于一个基础镜像层，当进行修改或增加新的内容时，就会在当前镜像层之上，创建新的镜像层。
（2）在添加额外的镜像层的同时，镜像始终保持是当前所有镜像的组合，理解这一点非常重要。下图中举了一个简单的例子，每个镜像层包含 3 个文件，而镜像包含了来自两个镜像层的 6 个文件。
在这里插入图片描述
（3）图中展示了一个稍微复杂的三层镜像，在外部看来整个镜像只有 6 个文件，这是因为最上层中的文件7 是文件 5 的一个更新版本。

（4）镜像是分层的，从基础镜像开始，一层一层叠加起来的。上一层始终是以下面的层为基础，下面的层相对于上面的层就是一个完整的镜像，我们所有的操作都是在最上面的一层进行。在外面看来你是一个镜像，但是在内是多个层（镜像）叠加起来的。比如我的一个镜像有3层，制作的时候从第1层开始有了第2层，这两层合起来供第三层使用，那对于第3层来说，第1、2层合起来是不是就是一个完整的镜像呢？但是这3层合起来相对于第4层（假如有）就又是一个完整的镜像。以此类推，都是一样的。
（5）Docker镜像都是只读的，当容器启动时，一个新的可写层被加载到镜像的顶部！这一层就是我们通常说的容器层，容器之下的都叫镜像层！

4、镜像commit

4.1 概念

（1）docker commit 从容器创建一个新的镜像
（2）我们知道了，运行态的镜像叫做容器，我们可以在里面做一些修改，添加，删除等操作。做完操作之后，我觉得这是一个很好的模板，我下次可以直接拿来使用，怎么做呢，使用docker commit将当前容器创建一个镜像出来，下次要使用的时候直接使用即可。

4.2 实例

（1）前面我们下载了一个tomcat镜像，但是当我运行起来之后，页面显示404，这不是不能访问，而是没有资源，什么意思呢？默认的tomcat中webapps中是空的。

[root@jiangnan ~]# docker run -it -p 8081:8080 tomcat:latest
Using CATALINA_BASE:   /usr/local/tomcat
Using CATALINA_HOME:   /usr/local/tomcat
Using CATALINA_TMPDIR: /usr/local/tomcat/temp
Using JRE_HOME:        /usr/local/openjdk-11
Using CLASSPATH:       /usr/local/tomcat/bin/bootstrap.jar:/usr/local/tomcat/bin/tomcat-juli.jar
Using CATALINA_OPTS:   
NOTE: Picked up JDK_JAVA_OPTIONS:  --add-opens=java.base/java.lang=ALL-UNNAMED --add-opens=java.base/java.io=ALL-UNNAMED --add-opens=java.base/java.util=ALL-UNNAMED --add-opens=java.base/java.util.concurrent=ALL-UNNAMED --add-opens=java.rmi/sun.rmi.transport=ALL-UNNAMED
21-Feb-2022 15:11:00.005 INFO [main] org.apache.catalina.startup.VersionLoggerListener.log Server version name:   Apache Tomcat/10.0.14
21-Feb-2022 15:11:00.029 INFO [main] org.apache.catalina.startup.VersionLoggerListener.log Server built:          Dec 2 2021 22:01:36 UTC
21-Feb-2022 15:11:00.029 INFO [main] org.apache.catalina.startup.VersionLoggerListener.log Server version number: 10.0.14.0
21-Feb-2022 15:11:00.029 INFO [main] org.apache.catalina.startup.VersionLoggerListener.log OS Name:               Linux
21-Feb-2022 15:11:00.029 INFO [main] org.apache.catalina.startup.VersionLoggerListener.log OS Version:            3.10.0-1127.19.1.el7.x86_64
21-Feb-2022 15:11:00.029 INFO [main]

# webapps下是空的，肯定包404
[root@jiangnan ~]# docker ps
CONTAINER ID   IMAGE           COMMAND             CREATED          STATUS          PORTS                                       NAMES
677a42e9efab   tomcat:latest   "catalina.sh run"   21 seconds ago   Up 21 seconds   0.0.0.0:8081->8080/tcp, :::8081->8080/tcp   strange_ptolemy
[root@jiangnan ~]# docker exec -it 677a42e9efab /bin/bash
root@677a42e9efab:/usr/local/tomcat# ls
BUILDING.txt	 LICENSE  README.md	 RUNNING.txt  conf  logs	    temp     webapps.dist
CONTRIBUTING.md  NOTICE   RELEASE-NOTES  bin	      lib   native-jni-lib  webapps  work
root@677a42e9efab:/usr/local/tomcat# cd webapps
root@677a42e9efab:/usr/local/tomcat/webapps# ls
root@677a42e9efab:/usr/local/tomcat/webapps#

在这里插入图片描述
（2）进入容器后，将webapps.dist下的文件复制到webapps下

（3）将运行的容器生存新的镜像：docker commit -a=“作者名” -m=“备注信息” 容器id 新的镜像名:版本

docker commit -a="lwp" -m="add webapps" 75f15b94c329 tomcat01:1.0

5、小结

（1）镜像是一种轻量级、可执行的独立软件包，是一种分层结构的系统。
（2）使用分层结构+UnionFS（联合文件系统）可以实现资源共享，资源整合。
（3）镜像的非运行态叫做镜像，运行态称之为容器，最上层可读可写。
（4）容器通过commit可以形成新的镜像，相当于给容器做了一次快照。

六、容器数据卷

1、概念

（1）数据卷就是数据(一个文件或者文件夹)。数据卷是特殊的目录，可以绕过联合文件系统，为一个或多个容器提供访问。
（2）数据卷设计的目的是数据的永久化，是完全独立于容器的生命周期，不会在容器删除时删除其挂载的数据卷，也不会存在类似垃圾收集机制，对容器引用的数据卷进行处理。
（3）在docker的使用过程中，往往需要对数据进行持久化，或者需要在多个容器之间进行数据共享，所以这就涉及到Docker容器的数据操作。容器中数据管理主要有两种方式：数据卷和数据卷容器。
（4）数据卷存在于宿主机中，独立于容器，和容器的生命周期是分离的，数据卷存在于宿主机的文件系统中，数据卷可以目录也可以是文件，容器可以利用数据卷与宿主机进行数据共享，实现了容器间的数据共享和交换。
（5）总结一句话：容器的持久化和同步操作！容器间也是可以数据共享的

2、数据卷挂载方式

2.1 直接使用命令来挂载 -v

（1）命令格式

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

# 测试
[root@ajie ~]# docker run -it -v /home/test:/home centos /bin/bash

# 启动成功以后，我们可以通过 docker inspect 容器id 来查看相关的信息

在这里插入图片描述
（2）mysql实战

docker run -d -p 3310:3306 -v /home/mysql/conf:/etc/mysql/conf  -v /home/mysq/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=dwgslwp8 --name mysql01 mysql:5.7

在这里插入图片描述

2.2 具名和匿名挂载

（1）匿名挂载

# 匿名挂载
# -v 容器内路径
[root@ajie ~]# docker run -d -P --name nginx01 -v /etc/nginx nginx

# 查看 volume 的情况
[root@ajie ~]# docker volume ls

在这里插入图片描述

（2）具名挂载

# 具名挂载
# -v 卷名称:容器内路径
[root@ajie ~]# docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx nginx

在这里插入图片描述
（3）查看具名挂载路径

# docker volume inspect 卷名称
[root@ajie ~]# docker volume inspect juming-nginx

在这里插入图片描述
（4）小结

# 如何确定是具名挂载还是匿名挂载，还是指定路径挂载！
-v 容器内路径            # 匿名挂载
-v 卷名:容器内路径		   # 具名挂载 
-v /宿主机路径:容器内路径  # 指定路径挂载

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

2.3 Dockerfile中设置数据卷

（1）创建命令和输出内容：首先启动容器1，volume01、volume02为挂载目录。

下面使用Dockerfile构建一个新的镜像，dockerfile01文件的内容，匿名挂载了volume01和volume02两个目录：
FROM centos

VOLUME ["volume01","volume02"]

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

#构建镜像
[root@iZwz99sm8v95sckz8bd2c4Z docker-test-volume]# docker build -f /home/docker-test-volume/dockerfile01 -t ethan/centos:1.0 .
Sending build context to Docker daemon  2.048kB
Step 1/4 : FROM centos
 ---> 300e315adb2f
Step 2/4 : VOLUME ["volume01","volume02"]
 ---> Running in 215ef28fd5a6
Removing intermediate container 215ef28fd5a6
 ---> f506ddf133d2
Step 3/4 : CMD echo "----end----"
 ---> Running in 62a1c4b9dc7b
Removing intermediate container 62a1c4b9dc7b
 ---> bbea81a6e94e
Step 4/4 : CMD /bin/bash
 ---> Running in 245d239f3776
Removing intermediate container 245d239f3776
 ---> 1df90e6fd790
Successfully built 1df90e6fd790
Successfully tagged ethan/centos:1.0

#完成镜像的生成后，启动自己生成的容器
[root@iZwz99sm8v95sckz8bd2c4Z docker-test-volume]# docker run -it 1df90e6fd790 /bin/bash
[root@828d43dba78e /]# ls -l
total 56
lrwxrwxrwx   1 root root    7 Nov  3 15:22 bin -> usr/bin
drwxr-xr-x   5 root root  360 Dec 29 15:41 dev
drwxr-xr-x   1 root root 4096 Dec 29 15:41 etc
drwxr-xr-x   2 root root 4096 Nov  3 15:22 home
lrwxrwxrwx   1 root root    7 Nov  3 15:22 lib -> usr/lib
lrwxrwxrwx   1 root root    9 Nov  3 15:22 lib64 -> usr/lib64
drwx------   2 root root 4096 Dec  4 17:37 lost+found
drwxr-xr-x   2 root root 4096 Nov  3 15:22 media
drwxr-xr-x   2 root root 4096 Nov  3 15:22 mnt
drwxr-xr-x   2 root root 4096 Nov  3 15:22 opt
dr-xr-xr-x 111 root root    0 Dec 29 15:41 proc
dr-xr-x---   2 root root 4096 Dec  4 17:37 root
drwxr-xr-x  11 root root 4096 Dec  4 17:37 run
lrwxrwxrwx   1 root root    8 Nov  3 15:22 sbin -> usr/sbin
drwxr-xr-x   2 root root 4096 Nov  3 15:22 srv
dr-xr-xr-x  13 root root    0 Dec 29 15:41 sys
drwxrwxrwt   7 root root 4096 Dec  4 17:37 tmp
drwxr-xr-x  12 root root 4096 Dec  4 17:37 usr
drwxr-xr-x  20 root root 4096 Dec  4 17:37 var
drwxr-xr-x   2 root root 4096 Dec 29 15:41 volume01
drwxr-xr-x   2 root root 4096 Dec 29 15:41 volume02

（2）容器间的数据卷：容器数据卷是指建立数据卷，来同步多个容器间的数据，实现容器间的数据同步。

#启动docker01，有上一步建的镜像，名为 lwp/centos
docker run -it --name docker01 lwp/centos
#启动docker02，卷来源于docker01 
ocker run -it --name docker02 --volumes-from docker01 lwp/centos
#启动docker03，卷来源于docker01 
ocker run -it --name docker03 --volumes-from docker01 lwp/centos
#在volume1或volume2中任何一个容器修改数据后，其他容器均能看得到，实现共享，docker01删除后，数据卷还存在。
#结论：只要有一个使用该数据卷的容器存在，则该数据卷就存在

在这里插入图片描述

七、DockerFile

1、DockerFile基础

1.1 什么是Dockerfile

（1）Dockerfile 是一个文本文件，其内包含了一条条的指令(Instruction)，用于构建镜像。每一条指令构建一层镜像，因此每一条指令的内容，就是描述该层镜像应当如何构建。

dockerfile 用于指示 docker image build 命令自动构建Image的源代码
dockerfile 是纯文本文件

（2）dockerfile 完整逻辑图
在这里插入图片描述

1.2 DockerFile构建步骤

（1）编写一个dockerfile 文件
（2）docker build 构建成为一个镜像
（3）docker run 运行镜像
（4）docker push 发布镜像（Docker Hub，阿里云镜像仓库！）

1.3 DockerFile 构建过程

（1）语法特点

每个保留关键字（指令）都是必须是大写字母
执行从上到下顺序执行
#表示注释
每一个指令都会创建提交一个新的镜像层，并提交！

（2）步骤：开发，部署，运维

DockerFile：构建文件，定义了一切的步骤，源代码
Dockerimages：通过DockerFile 构建生成的镜像，最终发布和运行的产品！
Docker容器：容器就是镜像运行起来提供服务器

1.4 DockerFile常用指令

FROM                     # 基础镜像，一切从这里开始构建
MAINTAINER               # 镜像是谁写的，姓名+邮箱
RUN                      # 镜像构建的时候需要运行的命令
ADD                      # 步骤：tomcat镜像，这个tomcat压缩包！添加内容
WROKDIR                  # 镜像的工作目录
VOLUME                   # 挂载的目录
EXPOSE                   # 暴露端口配置
CMD                      # 指定这个容器启动的时候要运行的命令，只有最后一个会生效，可被替代
ENTRYPOINT               # 指定这个容器启动的时候要运行的命令,可以追加命令
ONBUTLD                  # 当构建一个被继承 DockerFile 这个时候就会运行 ONBUTLD 的指令，出发指令
COPY                     # 类似ADD，将我们文件拷贝到镜像中
ENV                      # 构建的时候设置环境变量

在这里插入图片描述

2、实战测试

2.1 搭建自己的centos

FROM centos:centos7  #如果没有:centos7，报错

MAINTAINER lwp<675327425@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

docker build -f mydockerfile-centos -t mycentos:0.1 .

2.2 搭建tomcat镜像

（1）准镜像文件要用到的tomcat和jdk包

-rw-r-----. 1 root root  11560971 Apr 19 16:56 apache-tomcat-9.0.62.tar.gz
-rw-r-----. 1 root root 189756259 Apr 19 16:57 jdk-8u161-linux-x64.tar.gz

（2）编写dockerfile文件，官方命名为：“DockerFile”，build时会自动寻找该文件，不用参数-f指定

FROM centos:centos7

MAINTAINER lwp<675327425@qq.com>

COPY readerme.txt /usr/local/readerme.txt

ADD jdk-8u161-linux-x64.tar.gz /usr/local/

ADD apache-tomcat-9.0.62.tar.gz /usr/local/

RUN yum -y install vim

ENV MYPATH /usr/local

WORKDIR $MYPATH

ENV JAVA_HOME /usr/local/jdk1.8.0_161

ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar

ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.62

ENV CATALINA_BASE /usr/local/apache-tomcat-9.0.62

ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin

EXPOSE 8080

CMD /usr/local/apache-tomcat-9.0.62/bin/startup.sh && tail -F /usr/local/apache-tomcat-9.0.62/bin/logs/catalina.out

（3）构建镜像

docker build -t lwptomcat .   --注意末尾的点“.”

（4）运行镜像

docker run -d -p 9090:8080 --name lwpcentos -v /home/lwp/tomcat/test:/usr/local/apache-tomcat-9.0.62/webapps/test -v /home/lwp/tomcat/tomcatlogs/:/usr/local/apache-tomcat-9.0.62/logs lwptomcat

（5）可以在宿主机的/home/lwp/tomcat/test/目录下部署自己的应用

2.3 发布到hub.docker.com

（1）注册hub.docker.com，sxsllwp，密码dwXXXXXX！
（2）命令行登录 docker login -u sxsllwp
（3）docker tag imageid lwp/容器名:版本号
（4）docker push lwp/容器名:版本号
在这里插入图片描述

八、Docker网络

1、准备环境

（1）删除所有容器

docker rm -f $(docker ps -aq)

（2）删除所有镜像

docker rmi -f $(docker images -aq)

（3）查看linux地址

ip addr

在这里插入图片描述

2、测试

（1）下载运行tomcat

docker run -d -p --name tomcat01 tomcat:9.0

（2）查看容器地址,

docker exec -it tomcat01 ip addr

在这里插入图片描述

3、 veth pair技术

（1）veth pair是成对出现的，用来连接两个虚拟以太端口。如果两个namespace需要网络连接，就可以通过veth pair进行操作。
（2）直接相连
在这里插入图片描述
（3）通过Bridge相连

4、docker网络本质

（1）每启动一个docker容器，docker给容器分配一个ip，只要我们安装了docker，系统会产生一个默认的Docker0网卡，以桥接模式，采用veth-pair技术相连。
（2）docker网络-veth-pair技术图解
在这里插入图片描述

在这里插入图片描述

5、–link

（1）我们编写一个微服务，database url =ip.项目不重启，数据库ip掉了，我们希望可也处理这个问题，可也名字来进行访问容器.

docker run -d -P --name tomcat02 --link tomcat01 tomcat

通过 --link  tomcat02就可以直接ping tomcat02。

（2）本质：使用了link机制后，可以通过指定的名字来和目标容器通信，这其实是通过给/etc/hosts中加入名称和IP的解析关系来实现的，下面是名为web的容器中的/etc/hosts信息.
在这里插入图片描述

6、自定义网络

6.1 查看所有的docker网络

docker network ls

在这里插入图片描述

6.2 测试

（1）以前启动容器，其实是自动添加了 --net bridge，即使用docker0网卡桥接

docker run -d -P --name tomcat02  tomcat  
 --默认启动，实际是自动添加--net bridge，如下
docker run -d -P --name tomcat02 --net bridge tomcat

（2）docker0，默认，域名不能访问，–link使用麻烦，不推荐
（3）创建自己的网络

docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet

[root@localhost tomcat]# docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet 
297ef68945c39102b773dc107ee32d78e330576d1f2478be010b529782247e29
[root@localhost tomcat]# docker network ls
NETWORK ID     NAME      DRIVER    SCOPE
219bfd982f2e   bridge    bridge    local
37b48ffce026   host      host      local
297ef68945c3   mynet     bridge    local   --自己创建的网络
55f6002f8202   none      null      local

查看自建网络的详情

 docker network inspect mynet
--输出结果
[
    {
        "Name": "mynet",
        "Id": "297ef68945c39102b773dc107ee32d78e330576d1f2478be010b529782247e29",
        "Created": "2022-04-21T14:46:16.825561241+08:00",
        "Scope": "local",
        "Driver": "bridge",
        "EnableIPv6": false,
        "IPAM": {
            "Driver": "default",
            "Options": {},
            "Config": [
                {
                    "Subnet": "192.168.0.0/16",
                    "Gateway": "192.168.0.1"
                }
            ]
        },
        "Internal": false,
        "Attachable": false,
        "Ingress": false,
        "ConfigFrom": {
            "Network": ""
        },
        "ConfigOnly": false,
        "Containers": {},
        "Options": {},
        "Labels": {}
    }
]

（4）使用自定义网络创建容器

docker run -d -P --name lwptomcat-mynet01 --net mynet lwptomcat
docker run -d -P --name lwptomcat-mynet02 --net mynet lwptomcat

（5）查看网络情况

docker network inspect mynet 
--输出
[
    {
        "Name": "mynet",
        "Id": "297ef68945c39102b773dc107ee32d78e330576d1f2478be010b529782247e29",
        "Created": "2022-04-21T14:46:16.825561241+08:00",
        "Scope": "local",
        "Driver": "bridge",
        "EnableIPv6": false,
        "IPAM": {
            "Driver": "default",
            "Options": {},
            "Config": [
                {
                    "Subnet": "192.168.0.0/16",
                    "Gateway": "192.168.0.1"
                }
            ]
        },
        "Internal": false,
        "Attachable": false,
        "Ingress": false,
        "ConfigFrom": {
            "Network": ""
        },
        "ConfigOnly": false,
        "Containers": {
            "542e816f73f7b1ef32492ff2d58733923a66ed5348664fa1ff600bad6f8dbb41": {
                "Name": "lwptomcat-mynet01",
                "EndpointID": "9241fc7833fa43ed7339d516fa363511a985b220885c483d0950d466c7aefb7e",
                "MacAddress": "02:42:c0:a8:00:02",
                "IPv4Address": "192.168.0.2/16",
                "IPv6Address": ""
            },
            "657c68b171c4198a3fbed890fe8a1f76f827dda2498a3d5f53d0c07181177171": {
                "Name": "lwptomcat-mynet02",
                "EndpointID": "9be5f5e384e6eb028d3721c90ee07e03b9d25ff860ed7e009491796da627e835",
                "MacAddress": "02:42:c0:a8:00:03",
                "IPv4Address": "192.168.0.3/16",
                "IPv6Address": ""
            }
        },
        "Options": {},
        "Labels": {}
    }
]

（6）再测试网络
在这里插入图片描述
（7）结论：我们自定义的网络docker都已经帮我们维护好了对应关系

7、网络连通

（1）打通容器tomcat01到网络mynet

docker network connect mynet tomcat01

（2）查看mynet网络，tomcat01一个容器两个IP

docker network inspect mynet

在这里插入图片描述

九、搭建redis集群

1、创建redis网络

docker network create redis --subnet 172.38.0.0/16

2、创建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

3、启动6个redis容器

docker run -p 6371:6379 -p 16671: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 16672: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 16673: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 16674: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 16675: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 16676: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

4、创建集群

（1）搭建集群命令

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

（2）测试命令

redis-cli -c

 cluster nodes
 set a b

在这里插入图片描述

十、springboot微服务打包docker镜像

1、构建springboot微服务项目

（1）下载Dockerfile插件
（2）编写springboot微服务

2、打包镜像

idea package打包

3、编写dockerfile

FROM java:8

COPY *.jar /app.jar

CMD ["--server.port=9000"]

EXPOSE 9000

ENTRYPOINT ["java","-jar","/app.jar"]

4、构建镜像

docker build -t lwpapp .

5、发布运行

docker run -d  -P --name lwp1 lwpapp
#查看宿主机的哪个端口对应9000
docker ps
#网页浏览
http:宿主机ip:端口/wu

sxsl_lwp

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录