docker指令存档

目录

Docker

1、概念

2、架构图

3、安装

4、Docker怎么工作的?

5、Docker常用命令

帮助命令

镜像命令

1、查看镜像

2、帮助命令

3、搜索镜像

4、拉取镜像

5、删除镜像

容器命令

1、启动

2、查看运行的容器

3、删除容器

4、启动&停止

其他命令

1、后台启动容器

2、查看日志

3、查看容器内的进程信息

4、查看镜像的元数据

5、进入当前正在运行的容器

方式一

方式二

6、从容器内拷贝文件到主机上

6、小结

7、Docker安装Nginx

1、搜索镜像

2、下载镜像

3、运行镜像

4、测试

停止

流程

思考

8、Docker安装Tomcat

1、下载并启动

2、测试&问题

3、解决问题

4、再测试

思考

9、部署es&kibana

1、启动

2、查看内存状态

3、停掉

4、增加内存限制

5、测试

思考

10、可视化

1、什么是portainer?

2、测试

11、镜像

1、是什么?

2、怎么获得?

2.镜像加载原理

3、镜像层&容器层

4、提交自己的镜像

1、启动

2、进入并拷贝

3、提交镜像

12、Docker理念

持久化

同步操作

13、容器数据卷(Volume)

同步文件

[1、挂载 -v](#1、挂载 -v)

2、测试

3、反向测试

安装MySQL

1、下载

2、测试连接

具名&匿名挂载

1、匿名挂载

2、具名挂载

3、卷路径

4、判断是哪种挂载?

初识DockerFile

1、构建自己的镜像

2、匿名挂载同步查看

数据卷容器

1、容器挂载

2、删除测试

多个MySQL实现数据共享

结论

再见DockerFile

构建步骤

构建过程

DockerFile指令

实战测试

1、编写DockerFile

2、测试

查看构建历史

CMD&ENTRYPOINT

1、测试CMD

2、测试ENTRYPOINT

Tomcat镜像

Dockerfile

运行&挂载

测试

主机修改tomcat

外网访问

catalina.out

发布自己的镜像

DockerHub

阿里云

Docker流程

14、Docker网络

1、清空环境

2、查看地址

3、问题

1、启动容器并查ip

2、ping测试

[启动容器后我们再次测试 ip a](#启动容器后我们再次测试 ip a)

再启动一个tomcat测试

绘制网络模型图

3、容器互联--link

4、自定义网络

网络模式

1、清理环境

2、创建我们自己的网络

3、启动测试我们自己的网络

4、网络连通

15、Redis集群部署实战

1、redis集群的搭建

2、停掉主机&获取值

3、查看集群节点信息

16、打包镜像

1、打包项目

2、编写Dockerfile

3、构建镜像

4、测试访问

本地测试

外网访问


Docker

1、概念

Docker核心思想:隔离,每个箱子是隔离的,打包装箱。

虚拟机技术缺点

1、资源占用多

2、冗余步骤多

3、启动慢

容器技术

容器化技术不是模拟的一个完整的操作系统。

比较Docker和虚拟机技术的不同:

  • 传统虚拟机,虚拟出一条硬件,运行一个完整的操作系统,然后在这个系统上安装和运行软件。

  • 容器内的应用直接运行在宿主机,容器是没有自己内核的,也没有虚拟我们的硬件,所以就轻便了。

  • 每个容器间是相互隔离的,每个容器内都有一个属于自己的文件系统,互不影响。

优点:

2、架构图

镜像(image):【类】

docker镜像就好比是一个模板,可以通过这个模板来创建容器服务,Tomcat镜像-->run-->tomcat1容器(提供服务器),通过这个镜像可以创建多个容器(最终服务运行或者项目运行就是在容器中的)。

容器(container):【对象】

Docker利用容器技术,独立运行一个或者一个组应用,通过镜像来创建。目前可以把这个容器理解为就是一个简易的Linux系统。

仓库(repository):存放镜像的地方。分为共有仓库和私有仓库。

3、安装

环境准备:

1、保证系统内核在3.10以上

复制代码
uname -r

我的版本:3.10.0-1160.el7.x86_64

2、查看镜像是否是centos7

复制代码
cat /etc/os-release

3、进入帮助文档

Get Docker | Docker Docs

开始

1、旧版本的 Docker

复制代码
yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-engine

2、需要的安装包

复制代码
yum install -y yum-utils

3、\textcolor{red}{设置镜像仓库} ,解决下载慢

复制代码
yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo

4、更新软件包索引

复制代码
yum makecache fast

5、安装docker引擎(ce 社区版)

复制代码
yum install docker-ce docker-ce-cli containerd.io

6、启动docker

复制代码
systemctl start docker

7、通过版本号查看是否启动成功

复制代码
docker version

8、测试运行

复制代码
docker run hello-world

9、查看拉取的镜像

复制代码
docker images

附:怎么卸载引擎?

复制代码
1、卸载依赖
yum remove docker-ce docker-ce-cli containerd.io
​
2、删除资源
rm -rf /var/lib/docker
​
/var/lib/docker   这个是docker的默认工作路径。

4、Docker怎么工作的?

Docker是一个Client-Server结构的系统,Docker的守护进程运行在主机上,通过Socket从客户端访问!

DockerServer接收到Docker-Client的指令,就会执行这个命令!

Docker为什么比VM快?

1、Docker有着比虚拟机更少的抽象层。

2、Docker利用的是宿主机的内核,vm 需要 guest os

新建一个容器的时候,docker不需要像虚拟机一样重新加载一个操作系统内核,避免引导。虚拟机是加载 guest os ,分钟级别的,而docker是利用宿主机的操作系统,省略了这个复杂的过程,秒级。

5、Docker常用命令

docker | Docker Docs

镜像就像手机中APP安装包,容器就像已安装的APP应用

帮助命令

复制代码
1、查看版本
docker version
​
2、查看信息(镜像和容器的数量等)
docker info
​
3、查看命令
docker 命令 --help

镜像命令

1、查看镜像
复制代码
1、查看本地主机上所有的镜像
[root@localhost ~]# docker images
REPOSITORY    TAG       IMAGE ID       CREATED       SIZE
hello-world   latest    feb5d9fea6a5   4 weeks ago   13.3kB
​
REPOSITORY      镜像的仓库源
TAG             镜像的标签
IMAGE ID        镜像的id
CREATED         镜像的创建时间
SIZE            镜像的大小
​
Options(选项):
  -a, --all             # 列出所有的镜像
​
  -q, --quiet           # 只显示镜像的id
2、帮助命令
复制代码
docker images --help
3、搜索镜像
复制代码
搜索镜像
[root@localhost ~]# docker search mysql
NAME                              DESCRIPTION                                     STARS     OFFICIAL   AUTOMATED
mysql                             MySQL is a widely used, open-source relation…   11593         
mariadb                           MariaDB Server is a high performing open sou…   4409     
​
mysql/mysql-server                Optimized MySQL Server Docker images. Create…   857       
​
​
STARS:收藏量
--filter=STARS=3000     搜索出来的镜像就是收藏量大于3000的。

过滤搜索镜像:

4、拉取镜像
复制代码
下载镜像
docker pull 镜像名[:tag]    # 如果不写tag,默认就是最新版本

解决下载镜像慢!

复制代码
##使用阿里云镜像加速器
[root@localhost ~]# mkdir -p /etc/docker
[root@localhost ~]# tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://9cpn8tt6.mirror.aliyuncs.com"]
}
EOF
[root@localhost ~]# systemctl daemon-reload
[root@localhost ~]# systemctl restart docker

指定版本下载:

复制代码
docker pull mysql:5.7

查看下载的镜像:

5、删除镜像

删除镜像:

rm:删除 i:images -f:强制删除 后面可以指定id来删除

复制代码
docker rmi -f 容器id  #删除指定的容器
docker rmi -f 容器id 容器id 容器id  #删除多个容器
docker rmi -f $(docker images -aq)  #删除全部的容器

容器命令

前提:必须有镜像才能创建容器,我们来下载一个centos镜像来测试学习。

复制代码
docker pull centos
1、启动
复制代码
docker run [可选参数] image /bin/bash
​
#  参数说明
--name="Name"       容器名称  Tomcat01  Tomcat02  用来区分容器
-d                  后台方式运行
-it                 使用交互方式(需要给定控制台)运行,进入容器查看内容
​
-p                  指定容器的端口(四种方式)
    -p  ip:主机端口:容器端口
    -p  主机端口:容器端口(常用)
    -p  容器端口
    -p  随机指定端口
​

通过启动镜像进入容器:

/bin/bash:这个是指定的控制台

复制代码
docker run -it  centos /bin/bash

查看容器内的centos并退出:

复制代码
exit            #   从容器中退回主机
Ctrl + P + Q    #   容器不停止退回主机
2、查看运行的容器
复制代码
1、查看运行中的容器
docker ps
2、查看运行过的容器
docker ps -a
3、查看最近运行的容器
docker ps -a -n=1
4、查看当前所有容器的编号
docker ps -aq
3、删除容器
复制代码
docker rm 容器id                  #  删除指定的容器  ,不能删除正在运行的容器,如果要强制删除,rm -f  
​
docker rm -f $(docker ps -aq)    #  删除所有的容器
​
docker ps -a -q|xargs docker rm  #删除所有的容器

xargs 作用:将上个命令的输出作为参数传给 docker rm 这个命令

4、启动&停止

注意:这里跟之前的 docker run [可选参数] image /bin/bash 不同,之前是第一次,没有容器id。

\textcolor{red}{启动容器后,还是在主机,并没有进入容器} !

复制代码
docker start 容器id       #  启动容器
docker restart 容器id     #  重启容器
docker stop 容器id        #  停止当前正在运行的容器
docker kill 容器id        #  强制停止当前容器

其他命令

1、后台启动容器
复制代码
#  命令docker run -d 镜像名
docker run -d centos

出现问题:

我们使用命令 docker ps 后,发现 centos 停止了。

\textcolor{blue}{常见的坑}:docker 容器使用后台运行,就必须要有一个前台进程,因为docker发现没有应用,就会自动停止。

例如安装Nginx:容器启动后,docker发现自己没有提供服务,就会立刻停止,就是没有程序了。

2、查看日志
复制代码
# 自己编写一段shell脚本
docker run -d centos /bin/sh -c "while true;do echo giegie;sleep 1;done"
​
#  显示日志
--tf                #  显示日志  f:跟踪日志(实时显示)  t:时间戳(timestamps)
--tail number       #  要显示的尾部日志条数
​
[root@localhost ~]# docker logs -tf --tail 10 4b121dd5bc49
3、查看容器内的进程信息
复制代码
[root@localhost ~]# docker top 4b121dd5bc49
UID                 PID                 PPID                C                   STIME               TTY                 TIME                CMD
root                70910               70890               0                   20:52               ?                   00:00:00            /bin/sh -c while true;do echo giegie;sleep 1;done
root                73560               70910               0                   21:14               ?                   00:00:00            /usr/bin/coreutils --coreutils-prog-shebang=sleep /usr/bin/sleep 1
​

UID:用户id

PID:当前进程id

PPID:父进程id

4、查看镜像的元数据
复制代码
docker inspect 容器id
5、进入当前正在运行的容器

我们通常使用的容器是由后台方式运行的,所以需要进入容器内来修改一些配置。

方式一

docker exec:\textcolor{red}{进入容器后开启一个新的终端,可以在里面操作(常用)} 。

复制代码
#  exec -it  前后台交互执行
docker exec -it 容器id /bin/bash
方式二

docker attach:\textcolor{red}{进入容器正在执行的终端,不会启动新的进程} 。

复制代码
docker attach 容器id
6、从容器内拷贝文件到主机上

拷贝是一个手动过程,未来我们使用 -v 卷 的技术,可以实现。

复制代码
docker cp 容器id:容器内路径    目的的主机路径

6、小结

7、Docker安装Nginx

1、搜索镜像
复制代码
docker search nginx
2、下载镜像
复制代码
docker pull nginx
3、运行镜像
复制代码
#  先查看镜像
docker images
​
#  取别名后运行
docker run -d --name nginx01 -p 3344:80 nginx
4、测试

1、本地测试

复制代码
curl localhost:3344

2、外网测试(通过互联网)

停止
流程
思考

我们每次改动Nginx配置文件,都需要进入容器内部?这就十分的麻烦,我们通过在容器外部提供一个映射路径,达到在容器外部修改文件,容器内部就可以自动修改。 -v 数据卷!

8、Docker安装Tomcat

我们之前的启动都是后台,停止容器之后,容器还是可以查到的

复制代码
#  官方的使用,下载下来,运行后,就删除容器了(镜像还在)
docker run -it --rm tomcat:9.0
1、下载并启动
复制代码
#  下载最新的Tomcat
docker pull tomcat
​
#  通过虚拟机端口3355映射内部tomcat端口8080,启动tomcat镜像来启动tomcat容器,取名为tomcat01
docker run -d -p 3355:8080 --name tomcat01 tomcat
2、测试&问题

首先进入网站测试,404。之后我们进入容器:

复制代码
docker exec -it tomcat01 /bin/sh

进入容器内发现问题:

1、Linux命令少了。

2、没有webapps。

原因:阿里云镜像的原因,默认是最小的镜像,所有不必要的都剔除出去了。它是保证最小的可运行环境。

3、解决问题

将webapps.dist的内容全部拷贝到webapps里面。

复制代码
cp -r webapps.dist/* webapps
4、再测试
思考

我们以后部署项目,每次都要进入容器,十分麻烦。我们要是可以在容器外提供一个映射路径,webapps,我们在外部放置项目,就自动同步到内部就好了。

9、部署es&kibana

es:暴露的端口多,而且十分耗内存,它的数据一般需要放置到安全目录,挂载。

官网启动弹性搜索(elasticsearch)

复制代码
#  --net somenetwork:网络配置,暂时不需要
docker run -d --name elasticsearch --net somenetwork -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch:tag
1、启动
复制代码
docker run -d --name elasticsearch -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch:7.6.2

CPU资源有限,所以可能会卡。

2、查看内存状态
复制代码
docker stats
3、停掉
4、增加内存限制
复制代码
#  修改配置文件  -e  环境配置修改
docker run -d --name elasticsearch02 -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" -e ES_JAVA_OPTS="-Xms64m -Xmx512m" elasticsearch:7.6.2
5、测试
思考

使用kibana怎么用网络连接到es?

10、可视化

portainer和Rancher(CI/CD)

1、什么是portainer?

Docker图形化界面管理工具!提供一个后台面板供我们操作。

复制代码
docker run -d -p 8088:9000 --restart=always -v /var/run/docker.sock:/var/run/docker.sock --privileged=true portainer/portainer
2、测试

外网测试:

http://192.168.85.129:8088/

内网测试:

复制代码
curl localhost:8088

11、镜像

1、是什么?

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

所有的应用,直接打包docker镜像,就可以直接跑起来!

2、怎么获得?

1、从远程仓库下载

2、从朋友拷贝过来

3、自己制作DockerFile

1、UnionFS

2.镜像加载原理

bootfs(文件加载系统):就像我们启动电脑->加载->界面,界面加载完成后,不需要加载了。

阉割版

资源复用

3、镜像层&容器层
4、提交自己的镜像

docker commit 提交容器成为一个新的副本

复制代码
#  命令和git原理类似
docker commit -m="提交的描述信息" -a="作者" 容器id 目标镜像名:[TAG]
1、启动
复制代码
#  启动一个默认的tomcat
docker run -it -p 8080:8080 tomcat
2、进入并拷贝
复制代码
#  发现这个默认的tomcat是没有webapps应用,镜像的原因,官方的镜像默认webapps下面是没有文件的!我们自行拷贝文件。
注意:这里新开了一个shell,之前的tomcat不要关闭了。
3、提交镜像
复制代码
#  将我们操作过的容器通过commit提交为一个镜像,我们以后就使用这个我们修改过的镜像即可。
docker commit -a="gay" -m="add webapps app" 709df7e3e649 tomcat02:1.0

提交容器id后,在镜像中能看到新的镜像。也就是当前容器的状态!

类似于虚拟机里面的快照,可以回滚。

12、Docker理念

将应用和环境打包成一个镜像。

持久化

如果数据都在容器中,那么我们容器删除,数据就会丢失。

\textcolor{red}{需求:数据可以持久化} 。

MySQL的容器删了,删库跑路?

\textcolor{red}{需求:MySQL的数据可以存储在本地} 。

容器之间可以有一个数据共享的技术,Docker容器中产生的数据,同步到本地!这就是卷技术,\textcolor{red}{目录的挂载} ,将我们容器内的目录挂载到Linux虚拟机上面。

同步操作

13、容器数据卷(Volume)

容器的\textcolor{red}{持久化} 和\textcolor{red}{同步操作} ,容器间也是可以数据共享的。

方式一

同步文件

1、挂载 -v
复制代码
#  直接使用命令来挂载  -v    通过主机目录映射容器内目录
docker run -it -v 主机目录:容器内目录 镜像 /bin/bash
​
#  测试:挂载到主机后进入容器
[root@localhost home]# docker run -it -v /home/ceshi:/home centos /bin/bash

查看

复制代码
#  在主机上查看上面的那个容器详情
docker inspect 容器id

理解成在主机上创建了一个快捷方式,那么容器没了,主机上的那个也就没啥用了,跟着没了。有点不同的是,它文件内容是双向绑定的!

2、测试

在容器内建一个文件,测试主机上是否也生成一个对应的文件

3、反向测试

在主机内修改文件,已经退出的容器依旧可以获取到文件内容!

复制代码
#  exit 退出并停止容器   
#  ctrl + p + q 退出不会停止容器

好处:\textcolor{red}{我们以后修改只需要在本地修改即可,容器内会自动同步} !

安装MySQL

1、下载
复制代码
#  获取镜像
[root@localhost home]# docker pull mysql:5.7
​
#  运行容器,需要做数据挂载
#  -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
2、测试连接

本地使用Navicat连接

本地新建一个数据库,去Linux上面查看

假设我们将主机上的容器删除,我们挂载到本地的数据卷依旧存在,这就实现了容器的持久化功能。

相当于只删除了一个快捷方式而已。

具名&匿名挂载

1、匿名挂载
复制代码
#  匿名挂载
-v 容器内路径! -P 随机映射端口(注:p是大写的)
docker run -d -P --name nginx01 -v /etc/nginx nginx
​
#  查看所有的volume的情况
docker volume ls
2、具名挂载
复制代码
#  具名挂载  -v  卷名:容器内路径  区别之前我们是:  -v /xx/xx:/xx/xx
docker run -d -P --name nginxginx02 -v juming-nginx:/etc/nginx nginx
​
#  查看一下这个卷
docker volume inspect juming-nginx
3、卷路径

所有的docker容器内的卷,没有指定目录的情况下都是在

/var/lib/docker/volumes/xxxx/_data

4、判断是哪种挂载?
复制代码
#  如何确定是具名挂载还是匿名挂载,还是指定路径挂载?
#   1、匿名挂载
-v  容器内路径
#   2、具名挂载
-v  卷名:容器内路径
#   3、指定路径挂载
-v  /宿主机路径:容器内路径
​
拓展:
#   通过 -v 容器内路径:ro rw 改变读写权限
只要看到ro就说明这个路径只能通过宿主机来操作,容器内部是无法操作的。
ro:     readonly        #只读
rw:     readwrite       #可读可写,默认是这个
​
#   一旦设置了容器权限,那么容器对我们挂载出来的内容就有限定了。
docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx:ro nginx
​
docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx:rw nginx

初识DockerFile

方式二

DockerFile就是用来构建docker镜像的构建文件!命令脚本!

通过这个脚本可以生成镜像,镜像是一层一层的,所以脚本是一个一个的命令,每个命令都是一层。

1、构建自己的镜像
复制代码
#  创建一个dockerfile文件,名字可以随机,建议DockerFile
​
[root@localhost docker-test-volume]# cat dockerfile1 
FROM centos
​
#  -f:文件的地址  -t:生成的镜像名               构建,在哪里呢?名字呢?
[root@localhost docker-test-volume]# docker build -f /home/docker-test-volume/dockerfile1 -t chenjun/centos:1.0 .
​
#  文件中内容,注意VOLUME之后要有个空格。指令(大写)参数,这里的每个命令,就是镜像的一层,这种是匿名挂载
FROM centos
​
VOLUME ["volume01","volume02"]
​
CMD echo "----end----"
​
CMD /bin/bash

将chenjun/contos:1.0挂载到cenos(即FROM centos)

2、匿名挂载同步查看

数据卷容器

1、容器挂载
复制代码
通过我们刚才写的自己的镜像来启动三个容器
docker run -it --name docker01 容器id或者自己取的容器名
#  --volumes-fom:将docker02挂载到docker01上面
docker run -it --name docker02 --volumes-fom docker01 容器id或者自己取的容器名

docker03挂载到docker01上面

2、删除测试

哪怕你删除了docker01,其他两个不会收到影响, --volumes-fom 类似于备份一样。他们都是挂载到宿主机上面了!

区别于之前的挂载,那是一种类似创建快捷方式(双向、共享),!

注意:容器需要先启动,你才能通过 exec -it 或者 attach 进入。

多个MySQL实现数据共享
复制代码
docker run -d -p 3310:3306 -v /etc/mysql/conf.d -v /var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql01 mysql:5.7
​
docker run -d -p 3310:3306 -v /etc/mysql/conf.d -v /var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql02 mysql:5.7
结论

容器之间配置信息的传递,数据卷容器的声明周期一直持续到没有容器使用为止。

但是一旦你持久化到了本地(-v),这个时候,本地的数据是不会删除的。

再见DockerFile

DockerFile就是用来构建docker镜像的构建文件!命令脚本!

构建步骤
  • 1、编写一个DockerFile文件

  • 2、docker build 构建成为一个镜像

  • 3、docker run 运行镜像

  • 4、docker pull 发布镜像(DockerHub、阿里云镜像仓库!)

很多官方镜像都是基础包,很多功能没有,我们通常会自己搭建自己的镜像。

构建过程
  • 1、每个保留关键字(指令)都必须是大写字母

  • 2、从上到下的顺序执行

  • 3、# 表示注释

  • 4、每一个指令都会创建提交一个新的镜像层,并提交!

DockerFile是面向开发的,我们以后需要发布项目,做镜像,就需要编写DockerFile文件。Docker镜像逐渐成为企业交付的标准。

DockerFile:构建文件,定义了一切的步骤,源代码。

DockerImages:通过DockerFile构建生成的镜像,最终发布和运行的产品。

Docker容器:容器就是镜像运行起来提供服务器。

DockerFile指令

通过DockerFile指令,我们可以自己写镜像!

复制代码
FROM        # 基础镜像,一切从这里构建 centos
MAINTAINER  # 镜像是谁写的,姓名+邮箱
RUN         # 镜像构建时需要运行的命令
ADD         # 步骤:tomcat镜像,这个tomcat压缩包,添加内容
WORKDIR     # 镜像的工作目录   例如:/bin/bash
VOLUME      # 挂载的目录
EXPOSE      # 暴露端口配置
CMD         # 指定这个容器启动时需要运行的命令,只有最后一个会生效,可被替代。
ENTERYPOINT # 指定这个容器启动的时候要运行的命令,可以追加命令
ONBUILD     # 当构建一个被继承DockerFile时,就会运行ONBUILD的指令,触发指令。
COPY        # 类似ADD,将我们文件拷贝到镜像中
ENV         # 构建的时候设置环境变量
实战测试
1、编写DockerFile
复制代码
#  编写一个自己的DockerFile文件  echo:输出  在原有的centos上写自己的镜像。
​
FROM centos
MAINTAINER chenjun<1318593513@qq.com>
​
ENV MYPATH /usr/local
WORKDIR $MYPATH
​
RUN yum install -y vim
RUN yum install -y net-tools
​
EXPOSE 80
​
CMD echo $MYPATH
CMD echo "----end----"
CMD /bin/bash
​
​
#  构建  -f:DockerFile文件路径  -t:镜像名:[tag]
docker build -f mydockerfile-centos -t mycentos:0.1 .

原本是没有vim命令的,现在我们给他装上。

2、测试
查看构建历史

这个查看历史可以方便我们查看别的镜像是怎么构建的!!!

复制代码
[root@localhost docker-file]# docker history 镜像id
CMD&ENTRYPOINT
复制代码
CMD         # 指定这个容器启动时需要运行的命令,只有最后一个会生效,可被替代。
ENTERYPOINT # 指定这个容器启动的时候要运行的命令,可以追加命令
1、测试CMD
复制代码
vim dockerfile-cmd-test  #  建文件
​
FROM centos
CMD ["ls","-a"]
​
#  构建DockerFile,即自己的镜像
docker build -f dockerfile-cmd-test -t cmdtest .
​
#  运行,这里的镜像没有版本号,所以不用加
docker run -it cmdtest

替换,不可追加!

复制代码
[root@localhost docker-file]# docker run -it cmdtest -l
​
docker: Error response from daemon: OCI runtime create failed: container_linux.go:380: starting container process caused: exec: "-l": executable file not found in $PATH: unknown.
ERRO[0000] error waiting for container: context canceled
​
#  cmd的情况下,-l 替换了CMD["ls","-a"]命令,-l不是命令,所以报错了。
2、测试ENTRYPOINT

可追加!

复制代码
vim dockerfile-cmd-entrypoint  #  建文件
​
FROM centos
ENTRYPOINT ["ls","-a"]
​
#  构建DockerFile,即自己的镜像
docker build -f dockerfile-cmd-entrypoint -t entrypoint-test .
Tomcat镜像
  • 1、准备镜像文件 tomcat 压缩包,jdk 的压缩包。
  • 2、编写DockerFile文件,官方命名\textcolor{red}{Dockerfile} ,build会自动寻找这个文件,就不用 -f 去指定了。

  • 3、构建生成的目标镜像 docker build -t diytomcat . 这个 diytomcat 就是我们的镜像!

Dockerfile
复制代码
FROM centos
MAINTAINER chenjun<1318593513@qq.com>
​
COPY readme.txt /usr/local/readme.txt
​
ADD jdk-8u11-linux-x64.tar.gz /usr/local/
ADD apache-tomcat-9.0.22.tar.gz /usr/local/
​
RUN yum install -y vim
​
ENV MYPATH /usr/local
WORKDIR $MYPATH
​
​
ENV MYPATH /usr/local
WORKDIR $MYPATH
​
ENV JAVA_HOME /usr/local/jdk1.8.0_11
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.22
ENV CATALINA_BASH /usr/local/apache-tomcat-9.0.22
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin
​
EXPOSE 8080
​
​
CMD /usr/local/apache-tomcat-9.0.22/bin/startup.sh && tail -F /usr/local/apache-tomcat-9.0.22/bin/logs/catalina.out
运行&挂载
复制代码
[root@localhost tomcat]# docker run -d -p 9090:8080 --name chenjuntomcat -v /home/chenjun/build/tomcat/test://usr/local/apache-tomcat-9.0.22/webapps/test -v /home/chenjun/build/tomcat/tomcatlogs:/usr/local/apache-tomcat-9.0.22/logs diytomcat
测试
主机修改tomcat

web.xml

复制代码
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.4" 
    xmlns="http://java.sun.com/xml/ns/j2ee" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee 
        http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">     
</web-app>

index.jsp

复制代码
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>hello. xiaofan</title>
</head>
<body>
Hello World!<br/>
<%
System.out.println("-----my test web logs------");
%>
</body>
</html>
外网访问
catalina.out
复制代码
[root@localhost tomcatlogs]# pwd
/home/chenjun/build/tomcat/tomcatlogs

#  查看多少人访问了我们的这个服务器
[root@localhost tomcatlogs]# cat catalina.out 
发布自己的镜像

DockerHub

  • 1、地址:https://hub.docker.com/ 注册自己的账号

  • 2、登录:docker login -u jc110

  • 3、标签:docker tag 镜像id jc110/tomcat:1.0

  • 4、推送:docker push jc110/tomcat:1.0

DockerHub
阿里云

阿里云镜像服务

  • 1、登录阿里云

  • 2、找到容器镜像服务

  • 3、创建命名空间

  • 4、创建容器镜像

  • 5、docker登录后推送

复制代码
$ docker login --username=jc_s**** registry.cn-hangzhou.aliyuncs.com
$ docker tag [ImageId] registry.cn-hangzhou.aliyuncs.com/gay/gaytest:[镜像版本号]
$ docker push registry.cn-hangzhou.aliyuncs.com/gay/gaytest:[镜像版本号]

报错:

复制代码
Error response from daemon: Get "https://registry.cn-hangzhou.aliyuncs.com/v2/": unauthorized: authentication required

解决:

登录

复制代码
docker login --username=jc_study registry.cn-hangzhou.aliyuncs.com

查看

Docker流程

docker save保存的是镜像(image),docker export保存的是容器(container)。

docker load用来载入镜像包,docker import用来载入容器包,但两者都会恢复为镜像。

14、Docker网络

1、清空环境
复制代码
#   我们先删除所有的容器和镜像
#   强制删除所有的容器
[root@localhost ~]# docker rm -f $(docker ps -aq)
#   强制删除所有的镜像
[root@localhost ~]# docker rmi -f $(docker images -aq)
2、查看地址
复制代码
#   查看地址 ip a  或者  ip addr  或者  ifconfig
[root@localhost ~]# ip a
3、问题

docker是如何处理容器网络访问的?

1、启动容器并查ip
复制代码
#   拉取并通过后台运行tomcat镜像来启动容器
[root@localhost ~]# docker run -d -P --name tomcat01 tomcat

#   查看容器的内部网络地址  ip addr
[root@localhost ~]# docker exec -it tomcat01 ip addr

遇到问题:

复制代码
#   docker exec -it tomcat01 ip addr错误docker没有ip指令
OCI runtime exec failed: exec failed: container_linux.go:380: starting container process caused: exec: "ip": executable file not found in $PATH: unknown

解决问题:

复制代码
#   进入容器执行    apt-get update & apt-get install -y iproute2
root@93989b839391:/usr/local/tomcat# apt-get update & apt-get install -y iproute2
复制代码
#   发现容器启动的时候会得到一个docker分配的  eth0@if97 的ip地址
2、ping测试
复制代码
#   Linux虚拟机ping通docker容器内部
[root@localhost ~]# ping 容器ip

原理

172.17.0.1 这个是docker给我们的主机的ip

172.17.0.2 这个是docker给我们的容器(tomcat01)的ip

我们每启动一个docker容器,docker就会给docker容器分配一个ip,我们只要安装了docker,就会有一个网卡docker0桥接模式,使用的技术是 veth-pair 技术!

启动容器后我们再次测试 ip a

97: eth0@if96

容器内 ip addr

96: eth0@if97

再启动一个tomcat测试

99: vethd82c62d@if98

进入容器后 ip a

172.17.0.2 这个是docker给我们的容器(tomcat02)的ip

98: eth0@if99

我们发现这个容器带来网卡,都是一对一对的

veth-pair就是一对的虚拟机接口,他们都是成对出现的,一端连着协议,一端彼此相连。(veth意思是virtual ethernet,虚拟以太网连接)

正因为这个特性,veth-pair 充当一个桥梁,连接各种 虚拟网络设备的

OpenStac,Docker容器之间的连接,OVS的连接,都是使用veth-pair

tomcat01和tomcat02 都在同一个网段,所以它两都是可以相互ping通的,即:容器和容器之间是可以相互ping通的!

复制代码
docker exec -it tomcat02 ping 172.17.0.2
绘制网络模型图

结论:tomcat01和tomcat02 是共用的一个路由器,docker0。

所有的容器不指定网络的情况下,都是docker0路由的,docker会给我们的容器分配一个默认的可用ip。

小结

Docker使用的是Linux的桥接,宿主机中是一个Docker容器的网桥 docker0 。

Docker中所有的网络接口都是虚拟的,虚拟的转发效率高!(内网传递文件,很快。)

只要容器停止/删除,对应的网桥一对就没有了。

255.255.0.1/16

可用主机数:2 的16次方 -2 (减去网关和广播)= 65 534

255.255.255.255

11111111.11111111.11111111.11111111

前16个叫网络位,后16个是主机位。与或算法

思考

我们编写微服务的时候需要绑定数据库,database url=ip:,项目不重启,数据库ip换掉了,我们怎么处理这个问题?可以用名字来进行容器的访问。

这里启动不同的容器ip都不同,这怎搞?

解决:类似springcloud的feign去Nacos找服务名即可。

复制代码
#   以交互方式进入正在运行的容器  tomcat02
[root@localhost ~]# docker exec -it tomcat02 /bin/bash
#   发现  tomcat02的 ping 命令无法使用
root@db1ab920ec45:/usr/local/tomcat# ping tomcat01

#   解决   apt install iputils-ping
#   如果执行错误,先执行这个: apt-get update
root@db1ab920ec45:/usr/local/tomcat# apt install iputils-ping

tomcat02去ping通tomcat01测试

复制代码
#   出现问题
root@db1ab920ec45:/usr/local/tomcat# ping tomcat01
ping: tomcat01: Name or service not known
#   怎么解决?
[root@localhost ~]# docker run -d -P --name tomcat03 --link tomcat02 tomcat


#   出现问题
OCI runtime exec failed: exec failed: container_linux.go:380: starting container process caused: exec: "ping": executable file not found in $PATH: unknown
#   怎么解决?
root@dfdd58783733:/usr/local/tomcat# apt-get update & apt-get install -y iproute2


#   出现问题
bash: ping: command not found
#   怎么解决?
root@dfdd58783733:/usr/local/tomcat# apt install iputils-ping
#   如果执行错误,先执行这个: apt-get update

之前我们是通过ip去ping通的,现在我们link过后直接通过服务名去ping通!

复制代码
#   列举网络
[root@localhost ~]# docker network ls

#   查看网络详情
[root@localhost ~]# docker network inspect 2704ec4445bc

之前我们用tomcat03去连接tomcat02

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

复制代码
#   查看host配置,在这里原理发现!
[root@localhost ~]# docker exec -it tomcat03 cat /etc/hosts

--link 就是我们在 hosts 配置中增加了一个 172.17.0.3 tomcat02 db1ab920ec45,但是tomcat02却没有绑定tomcat01。

我们现在已经不建议使用--link了。自定义网络,不使用docker0.

docker0的问题:他不支持容器名连接访问。

4、自定义网络
复制代码
#   查看所有的docker网络
[root@localhost ~]# docker network ls
网络模式

bridge:桥接 docker 搭桥(默认,自己架构也使用这个)

host:和宿主机共享网络

none: 不配置网络

container:容器内网络连通(用的少,局限很大)

测试

1、清理环境
2、创建我们自己的网络
复制代码
#   我们直接启动命令  --net bridge ,而这个是我们的docker0
#   平常写法
[root@localhost ~]# docker run -d -P --name tomcat01
#   相当于下面这种默认的
[root@localhost ~]# docker run -d -P --name tomcat01 --net bridge tomcat


#   docker0特点:默认的,域名不能访问,--link可以打通连接。
#   我们可以自定义一个网络

#   --driver bridge
#   --subnet 192.168.0.0/16 可以支持255*255个网络 192.168.0.2 ~ 192.168.255.254
# 	--gateway 192.168.0.1

[root@localhost ~]# docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet

查看我们自己配置的网络的详情

复制代码
[root@localhost ~]# docker network inspect mynet
3、启动测试我们自己的网络
复制代码
[root@localhost ~]# docker run -d -P --name tomcat-net-01 --net mynet tomcat
​
[root@localhost ~]# docker run -d -P --name tomcat-net-02 --net mynet tomcat
​
[root@localhost ~]# docker network inspect mynet
复制代码
#   再次测试两个容器的ping连接,可以成功
docker exec -it tomcat-net-01 ping 192.168.0.3

我们自定义的网络docker都已经帮我们维护好了对应的关系,推荐平时这样使用网络!

好处:不同的集群使用不同的网络,保证集群是安全和健康的。

4、网络连通
复制代码
#   将tomcat01和mynet连通
docker network connect  mynet tomcat01
 
#   连通之后就是将tomcat01 放到了mynet网路下
#   一个容器两个ip地址:
#   例如:阿里云服务器,公网ip,私网ip

#   tomcat01容器去ping我们自己的网络
docker exec -it tomcat01 ping tomcat-net-01

结论:假设我们需要跨网络操作别人,就需要使用 docker network connect 连通!

15、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

# 创建结点1
docker run -p 6371:6379 -p 16371: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
 
#创建结点2
docker run -p 6372:6379 -p 16372: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

#创建结点3
docker run -p 6373:6379 -p 16373: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

#创建结点4
docker run -p 6374:6379 -p 16374: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

#创建结点5
docker run -p 6375:6379 -p 16375: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

#创建结点6
docker run -p 6376:6379 -p 16376: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
 

# 创建集群
[root@iZ2zeg4ytp0whqtmxbsqiiZ ~]# docker exec -it redis-1 /bin/sh
/data # ls
appendonly.aof  nodes.conf

/data # 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

1、redis集群的搭建

2、停掉主机&获取值

3、查看集群节点信息

16、打包镜像

Springboot微服务打包Docker镜像

  • 1、架构springboot项目

  • 2、打包应用

  • 3、编写DockerFile

  • 4、构建镜像

  • 5、发布运行

1、打包项目

打开 demo-0.0.1-SNAPSHOT.jar 的文件位置,然后cmd

复制代码
java -jar demo-0.0.1-SNAPSHOT.jar

下载docker插件

2、编写Dockerfile

复制代码
FROM java:8
​
COPY *.jar /app.jar
​
CMD ["--server.port=8080"]
​
EXPOSE 8080
​
ENTRYPOINT ["java", "-jar", "/app.jar"]

3、构建镜像

4、测试访问

本地测试

使用了Docker之后,给别人交付的就是一个镜像就可以了!!!

外网访问

关闭防火墙

systemctl stop firewalld

开机自动关闭防火墙

systemctl disable firewalld

相关推荐
少妇的美梦3 小时前
logstash教程
运维
容器魔方3 小时前
Bloomberg 正式加入 Karmada 用户组!
云原生·容器·云计算
chen9454 小时前
k8s集群部署vector日志采集器
运维
chen9454 小时前
aws ec2部署harbor,使用s3存储
运维
muyun28009 小时前
Docker 下部署 Elasticsearch 8 并集成 Kibana 和 IK 分词器
elasticsearch·docker·容器
東雪蓮☆9 小时前
深入理解 LVS-DR 模式与 Keepalived 高可用集群
linux·运维·服务器·lvs
qq_264220899 小时前
LVS负载均衡群集和LVS+Keepalived群集
运维·负载均衡·lvs
乌萨奇也要立志学C++9 小时前
【Linux】进程概念(二):进程查看与 fork 初探
linux·运维·服务器
雨落Liy9 小时前
Nginx 从入门到进阶:反向代理、负载均衡与高性能实战指南
运维·nginx·负载均衡
Nazi69 小时前
k8s的dashboard
云原生·容器·kubernetes