docker - 学习笔记

一、简介

1.1 相关地址

1.2 虚拟化技术和容器化技术对比

1.2.1 虚拟化技术的缺点

  • 资源占用十分多
  • 冗余步骤多
  • 启动慢

1.2.2 容器化技术

1.2.3 比较Docker和虚拟化技术的不同
传统虚拟机, 虚拟出一条硬件,运行一个完整的操作系统,然后在这个系统上安装和运行软件
容器内的应用直接运行在宿主机的内部,容器是没有自己的内核的,也没有虚拟硬件,所以轻便
每个容器间是相互隔离的,每个容器内都有一个属于自己的文件系统,互不影响,应用更快速的交互和部署

1.3 DevOps(开发运维)

  • 应用更快速的交付和部署

传统:一堆帮助文档,安装程序

Docker: 打包镜像发布测试,一键运行

  • 更便捷的升级和扩缩容

项目打包成一个镜像,拓展服务器A、服务器B、.....

  • 更简的系统运维

开发、测试环境是高度一致的

  • 更高效的计算资源利用

docker是内核级别的虚拟化,可以在一个物理机上运行很多的容器实例,服务器的性能可以压榨到极致

二、安装

2.1 docker组成

客户端-服务器-仓库

docker服务去运行,守护进程通过镜像运行,生成很多的容器

  • 镜像

docker镜像就像一个模板,可以通过模板来创建容器服务,例如tomcat镜像,通过镜像可以创建多个容器

  • 容器

docker利用容器技术,独立运行一个或者一组应用,通过镜像来创建

  • 仓库

存放镜像的地方

docker hub

阿里云...都有容器服务(可以配置镜像加速)

2.2 安装

1)查看自己服务器的配置

uname -r

cat /etc/os-release

2)安装

  • 卸载旧版本
$ sudo yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-engine

  • 下载需要的安装包
yum install -y yum-utils

  • 设置镜像仓库
 sudo yum install -y yum-utils \
  device-mapper-persistent-data \
  lvm2

 可以使用阿里云、清华园等

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

  • 更新yum软件包索引
yum makecache fast

  •  安装docker引擎
yum install docker-ce docker-ce-cli containerd.io

 docker-ce是社区版的 ee企业版

  •  启动docker
systemctl start docker

  • 验证
docker version

  • 测试 
docker run hello-world

  •  查看helloworld镜像
docker images

  •  卸载docker
# 卸载
yum remove docker-ce docker-ce-cli containerd.io

# 删除资源 默认工作路径
rm -rf /var/lib/docker

 3)阿里云镜像加速

 选择contos,执行命令

sudo mkdir -p /etc/docker

sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://j9yjyaas.mirror.aliyuncs.com"]
}
EOF

sudo systemctl daemon-reload

sudo systemctl restart docker

 2.3 底层原理

其实就是说  docker run helloworld以后  docker到底做了什么事情

2.3.1 工作原理

Docker Engine是一个客户端-服务器应用程序,具有以下主要组件:

一个服务器,它是一种长期运行的程序,称为守护进程(dockerd命令)
一个REST API,它指定程序可以用来与守护进程对话并指示它做什么的接口。

1)结构
Docker是一个Client-Server结构的系统,Docker守护进程运行在主机上,然后通过Socket连接从客户端访问,守护进程从客户端接受命令并管理运行在主机上的容器。容器,是一个运行时环境就是集装箱。

2)为什么Docker比Vm快

  • docker有着比虚拟机更少的抽象层。由于docker不需要Hypervisor实现硬件资源虚拟化,运行在docker容器上的程序直接使用的都是实际物理机的硬件资源。因此在CPU、内存利用率上docker将会在效率上有明显优势。
  • docker利用的是宿主机的内核,而不需要Guest OS。因此,当新建一个容器时,docker不需要和虚拟机一样重新加载一个操作系统内核。仍而避免引寻、加载操作系统内核返个比较费时费资源的过程,当新建一个虚拟机时,虚拟机软件需要加载GuestOS,返个新建过程是分钟级别的。而docker由于直接利用宿主机的操作系统,则省略了返个过程,因此新建一个docker容器只需要几秒钟
     

 三、docker常用命令

docker version    #版本信息
docker info       #系统信息 包括镜像和容器数量

 1)镜像命令

docker images     #查看镜像

--all , -a        # 列出所有镜像
--quiet , -q      # 只显示镜像的id
--filter, -f      # 过滤

搜索镜像

docker search mysql --filter=STARS=3000     #搜索mysql(也可以docker hub直接搜索)

 下载镜像

docker pull mysql       #默认最新版(分层下载-联合文件系统)
docker pull mysql:5.7   #指定版本(hub上存在)

 删除镜像

docker rmi -f $(docker images -aq)    #删除全部
docker rmi -f [id/tag/..]             #指定删除

 2)容器命令

docker pull centos

 容器里下载一个镜像

新建容器并启动

docker run -it centos /bin/bash      #启动并进入容器

--name="name"    #给容器起名字
-d               #后台方式运行
-it              #交互方式运行,进入容器查看内容
-P               #指定容器的端口 -p 8080:8080
    -P ip:主机端口:容器端口
    -P 主机端口:容器端口
    -P 容器端口
    容器端口
-p               #随机端口
docker ps              #正在运行的容器
docker ps -a           #正在运行的容器(包括历史容器)
docker ps -n=[参数]    #最近创建的容器
docker -q              #当前容器的编号

exit               #退出并关闭
ctrl+P+Q           #容器不关闭退出

docker rm -f 容器id                 # 删除指定容器
docker rm -f $(docker ps -aq)       # 删除所有容器
docker ps -a -q|xargs docker rm -f  # 删除所有的容器

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

3)常用命令

docker run -d centos                        #启动容器
# 问题 docker ps, 发现centos停止了
# 常见的坑, docker 容器使用后台运行, 就必须要有一个前台进程,docker发现没有应用,就会自动停止
# nginx, 容器启动后,发现自己没有提供服务,就会立即停止,就是没有程序了

docker logs -tf --tail number 容器id        #查看日志
-tf                                         #显示日志
--tail number                               #显示日志条数

docker top 容器id                           #查看容器中进程信息ps

docker inspect 容器id                       #查看镜像的元数据

docker exec -it 容器id /bin/bash            #进入当前正在运行的容器,进入容器后开启一个新的终端,可以在里面操作
docker attach 容器id                        #进入当前正在运行的容器,进入容器正在执行的终端,不会启动新的进程

docker cp 容器id:容器内路径 目的地主机路径      #从容器中拷贝文件到主机

三、docker部署软件

1、安装nginx

docker images   #查看镜像

docker run -d --name nginx01 -p 3344:80 nginx  # 后台方式启动启动镜像
# -d 后台运行
# -name 给容器命名
# -p 宿主机端口:容器内部端口

docker ps                                #查看当前运行镜像
curl localhost:3344                      #本地访问测试
docker exec -it nginx01 /bin/bash        # 进入容器

2、安装tomcat

docker run -it --rm tomcat:9.0        # 官方的使用
#docker run -it --rm 一般用来测试,用完就删
 
docker pull tomcat
docker run -d -p 3344:8080 --name tomcat01 tomcat
docker exec -it tomcat01 /bin/bash
 
# webapps下内容为空,阿里云默认是最小的镜像,所有不必要的都剔除了,保证最小可运行环境即可

3、安装es、kibana

服务器带不动(todo test)

# es 暴露的端口很多
# es 十分的耗内存
# es 的数据一般需要放置到安全目录! 挂载
# --net somenetwork 网络配置
 
docker pull docker.elastic.co/elasticsearch/elasticsearch:8.6.0            #下载镜像
docker network create elastic                                              #创建网络

 docker run --name es01 \                                                  #运行
 -e ES_JAVA_OPTS="-Xms1g -Xmx1g" \
 -e "discovery.type=single-node"  \
 --net elastic  -p 9200:9200 -p 9300:9300 \
 -d docker.elastic.co/elasticsearch/elasticsearch:8.6.0

docker exec -it es01 /usr/share/elasticsearch/bin/elasticsearch-reset-password        #重置密码

docker cp es01:/usr/share/elasticsearch/config/certs/http_ca.crt .                    #复制 http_ca.crt 证书文件到本地

curl --cacert http_ca.crt -u elastic https://localhost:9200                           #测试访问

docker run -e ES_JAVA_OPTS="-Xms1g -Xmx1g" -e ENROLLMENT_TOKEN="<token>" --name es01 -p 9201:9200 --net elastic -it docker.elastic.co/elasticsearch/elasticsearch:8.6.0    #设置JVM参数

docker pull docker.elastic.co/kibana/kibana:8.6.0                                      #docker拉取kibana镜像

docker run --name kib01 --net elastic -p 5601:5601 docker.elastic.co/kibana/kibana:8.6.0        #启动kibana服务

docker network rm elastic        #卸载
docker rm es01
docker rm kib01




# 增加内存限制,修改配置文件 -e 环境配置修改
docker run -d --name elasticsearch -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" -e ES_JAVA_OPTS="-Xms64m -Xmx512m" elasticsearch:7.6.2

4、可视化

docker run -d -p 8088:9000 --restart=always -v /var/run/docker.sock:/var/run/docker.sock --privileged=true portainer/portainer
 
# 测试
[root@iZ2zeg4ytp0whqtmxbsqiiZ home]# curl localhost:8088
<!DOCTYPE html
><html lang="en" ng-app="portainer">
 
# 外网访问 http://ip:8088
 
  • portainer(先用这个)
  • Rancher(CI/CD再用)

四、原理

4.1 镜像

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

4.1.1 加载

UnionFS(联合文件系统)

UnionFS是一种分层、轻量级并且高性能的文件系统,支持对文件系统的修改,作为一次提交来一层层的叠加,同时可以将不同目录挂载到同一个虚拟文件系统下。Union文件系统是Docker镜像的基础。

镜像可以通过分层进行继承,基于基础镜像,可以制作各种具体的应用镜像。

特性:

一次同时加载多个文件系统,但从外面看起来,只能看到一个文件系统,联合加载会把各层文件系统叠加起来,这样最终的文件系统会包含所有底层的文件和目录。

4.2 docker镜像加载原理

dokcer的镜像实际上由一层一层的文件系统组成,这种层级的文件系统UnionFS。

bootfs(boot file system)主要包含bootloader和kernel,bootloader主要是引导加载kernel,linux刚启动时会加载bootfs文件系统,在docker镜像的最底层是bootfs。

这一层与典型的linux系统一致,包含boot加载器和内核,当boot加载完成之后整个内核就都在内存中了,此时内存的使用权已由bootfs转交给内核,此时系统也会卸载bootfs。

rootfs(root file system),在bootfs之上,包含的就是典型linux系统中的/dev、/proc、/bin、/etc等标准目录和文件。rootfs就是各种不同的操作系统发行版,比如ubantu、centos等。

平时安装的虚拟机和centos都好几个G,为什么docker才200M?

对于一个精简的os,rootfs可以很小,只需要包含最基本的命令、工具、程序库就可以了,因为底层直接用host的kernel,自己只需要提供rootfs就可以了。

对于不同的linux发行版,bootfs基本是一致的,rootfs会有差别,因此不同的发行版可以共用bootfs。

理解:

所有的dokcer镜像都起始于一个基础镜像层,当进行修改或增加新的内容时,就会在当前镜像层之上,创建新的镜像层。

举个例子 ,基于ubantu linux16.04创建一个新的镜像,这就是新镜像的第一层,如果在该镜像添加Python包,就会在基础镜像层上创建第二个镜像层,诸如此类。

在添加额外的镜像层的同时,镜像始终保持是当前所有镜像的组合。

下图中,每个镜像层都包含3个文件,而镜像包含了来自两个镜像层的6个文件。

下图中展示了一个稍微复杂的三层镜像,在外部看来整个镜像只有6个文件,这是因为最上层的文件7是文件5的更新版本。

这种情况,上次镜像层中的文件覆盖了底层镜像层的文件,这样就使得文件的更新版本作为一个新镜像层添加到镜像中,

docker通过存储引擎(新版本采用快照机制)的方式来实现镜像层堆栈,并保证多镜像层对外展示为统一的文件系统。

linux上可用的存储引擎有AUFS、OVERLAY2、DEVICE MAPPER、BTRFS以及ZFS。每种存储引擎都基于linux中对应的文件系统或者块设备技术,并且每种存储引擎都有独有的性能特点。

4.3 特点

Docker镜像都是只读的,当容器启动时, 一个新的可写层被加载到镜像的顶部!

这一层就是我们通常说的容器层, 容器之下的都叫做镜像层

docker commit 提交容器成为一个新的版本
 
# 命令和git 原理类似
docker commit -m="提交的描述信息" -a="作者" 容器id 目标镜像名:[TAG]
 
docker commit -a="xiaofan" -m="add webapps app" d798a5946c1f tomcat007:1.0
 
# 1. 启动一个默认的tomcat
# 2. 发现这个默认的tomcat是没有webapps应用, 镜像的原因,官方镜像默认webapps下面是没有内容的
# 3. 我自己拷贝进去了基本的文件
# 4. 将我们操作过的容器通过commit提价为一个镜镜像!我们以后就使用我们自己制作的镜像了

五,容器数据卷


5.1. 容器数据卷


5.1.1. docker的理解回顾


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

如果数据都在容器中,那么我们容器删除,数据就会丢失!需求:数据可以持久化

MySQL,容器删了,删库跑路!需求:MySQL数据可以存储在本地!

容器之间可以有一个数据共享技术!Docker容器中产生的数据,同步到本地!

这就是卷技术,目录的挂载,将我们容器内的目录挂载到linux目录上面!

总结:容器的持久化和同步操作!容器间数据也是可以共享的!

5.1.2 数据卷

  • 命令
docker run -it -v 主机目录:容器目录
docker run -it -v /home/ceshi:/home centos /bin/bash

5.1.3 具名挂载和匿名挂载

# 匿名挂载
-P 随机指定端口
-v 容器内路径
docker run -d -P --name nginx01 -v /etc/nginx nginx    
 
# 查看所有volume的情况
# 这里发现,这种情况就是匿名挂载,我们在-v 后面只写了容器内的路径,没有写容器外的路径!
docker volume ls
DRIVER              VOLUME NAME
local               561b81a03506f31d45ada3f9fb7bd8d7c9b5e0f826c877221a17e45d4c80e096
 
# 具名挂载
docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx nginx

docker volume ls
DRIVER              VOLUME NAME
local               561b81a03506f31d45ada3f9fb7bd8d7c9b5e0f826c877221a17e45d4c80e096
local               36083fb6ca083005094cbd49572a0bffeec6daadfbc5ce772909bb00be760882
local               juming-nginx
 
# 通过-v 卷名:容器内的路径
# 查看一下这个卷
docker volume inspect juming-nginx
[
  {
      "CreatedAt": "2023-01-12T18:15:21+08:00",
      "Driver": "local",
      "Labels": null,
      "Mountpoint": "/var/lib/docker/volumes/juming-nginx/_data",
      "Name": "juming-nginx",
      "Options": null,
      "Scope": "local"
  }
]

所有docker容器内的卷,没有指定目录的情况下都是在/var/lib/docker/volumes/xxxxx/_data

我们通过具名挂载可以方便的找到我们的一个卷,大多数情况下使用的是具名挂载

# 通过 -v 容器内容路径 ro rw 改变读写权限
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
 
# ro 只要看到ro就说明这个路径只能通过宿主机来操作,容器内容无法操作

5.2 docker file

用来构建docker镜像的构建文件,通过这个脚本生成镜像。

镜像是一层一层的,命令就是一个一个的,一个命令相当于一个镜像。

# 创建一个dockerfile文件, 名字可以随机
# 文件的内容 指定(大写) 参数
vim dockerfile1

FROM centos
VOLUME ["volume01", "volume02"]
CMD echo "----end----"
CMD /bin/bash
 
# 这里的每一个命令都是镜像的一层!

构建镜像

docker build -f 文件路径 -t 镜像名:tag .
docker build -f dockerfile1 -t centos:1.0 .

 启动

docker run -it centos /bin/bash

 数据卷容器:

#启动三个容器
docker run -it --name docker01 centos:1.0
docker run -it --name docker02 --volumes-from docker01 centos:1.0
docker run -it --name docker03 --volumes-from docker01 centos:1.0

 docker02和docker03挂载到docker01上

数据共享,例如删除docker01,但是01和03依旧有数据,只要有一个容器还在用,数据就不会消失。

多个mysql共享数据:

docker run -d -p 3344:3306 -v /etc/mysql/conf.d -v /var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql01 mysql:5.7
 
 docker run -d -p 3344:3306 -v /etc/mysql/conf.d -v /var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql02 --volumes-from mysql01 mysql:5.7

结论

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

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

 六、docker file

6.1 构建步骤

① 编写dockerfile文件

② docker build构建成镜像

③ docker run 运行

④ docker push 发布

在github上找到一个镜像,带有tag的文件,点击进入,出现的就是dockerfile的脚本。

很多官方的镜像都是基础包,通常自己去拓展。

dockerfile构建:

  1. 每个保留关键字(指令)都是必须大写字母
  2. 执行从上到下顺序执行
  3. # 表示注释
  4. 每个指令都会创建提交一个新的镜像层,并提交!

6.2 指令

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

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

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

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

 6.3 创建

# 1. 编写Dockerfile的文件
cat mydockerfile-centos 

FROM centos
MAINTAINER xxxxx<123456@qq.com>
ENV MYPATH /usr/local           # 相当于k-v形式
WORKDIR $MYPATH                 # 镜像的工作目录
RUN yum -y install vim
RUN yum -y install net-tools
EXPOSE 80
CMD echo $MYPATH
CMD echo "---end---"
CMD /bin/bash
 
# 2. 通过这个文件构建镜像
# 命令 docker build -f dockerfile文件路径 -t 镜像名:[tag] .
 
docker build -f mydockerfile-centos -t mycentos:0.1 .
 
Successfully built d2d9f0ea8cb2
Successfully tagged mycentos:0.1

6.3.1  CMD 和ENTRYPOINT区别

CMD             # 指定这个容器启动的时候要运行的命令,只有最后一个会生效可被替代
ENTRYPOINT      # 指定这个容器启动的时候要运行的命令, 可以追加命令

 CMD测试
# 1. 编写dockerfile文件
vim dockerfile-cmd-test 

FROM centos
CMD ["ls", "-a"]

# 2. 构建镜像
docker build -f dockerfile-cmd-test -t cmdtest .
 
# 3. run运行, 发现我们的ls -a 命令生效
docker run ebe6a52bb125
.
..
.dockerenv
bin
dev
etc
home
lib
lib64
 
# 想追加一个命令 -l 变成 ls -al
docker run ebe6a52bb125 -l
docker: Error response from daemon: OCI runtime create failed: container_linux.go:349: starting container process caused "exec: \"-l\": executable file not found in $PATH": unknown.

docker run ebe6a52bb125 ls -l
 
# cmd的情况下 -l替换了CMD["ls", "-a"]命令, -l不是命令,所以报错了

 测试ENTRYPOINT
# 1. 编写dockerfile文件
vim dockerfile-entrypoint-test 

FROM centos
ENTRYPOINT ["ls", "-a"]
 
# 2. 构建文件
docker build -f dockerfile-entrypoint-test -t entrypoint-test .
 
# 3. run运行 发现我们的ls -a 命令同样生效
docker run entrypoint-test

.
..
.dockerenv
bin
dev
etc
home
lib
 
# 4. 我们的追加命令, 是直接拼接到ENTRYPOINT命令的后面的!
docker run entrypoint-test -l

total 56
drwxr-xr-x  1 root root 4096 Aug 13 07:52 .
drwxr-xr-x  1 root root 4096 Aug 13 07:52 ..
-rwxr-xr-x  1 root root    0 Aug 13 07:52 .dockerenv
lrwxrwxrwx  1 root root    7 May 11  2019 bin -> usr/bin
drwxr-xr-x  5 root root  340 Aug 13 07:52 dev
drwxr-xr-x  1 root root 4096 Aug 13 07:52 etc
drwxr-xr-x  2 root root 4096 May 11  2019 home
lrwxrwxrwx  1 root root    7 May 11  2019 lib -> usr/lib
lrwxrwxrwx  1 root root    9 May 11  2019 lib64 -> usr/lib64
drwx------  2 root root 4096 Aug  9 21:40 lost+found

七、tomcat实战

7.1 部署

① tomcat、jdk安装包上传到服务器

② dockerfile

cat Dockerfile 

FROM centos
MAINTAINER xxxx<123456@qq.com>
 
COPY readme.txt /usr/local/readme.txt
 
ADD jdk-8u73-linux-x64.tar.gz /usr/local/            #ADD命令自动解压
ADD apache-tomcat-9.0.37.tar.gz /usr/local/
 
RUN yum -y install vim
 
ENV MYPATH /usr/local
WORKDIR $MYPATH
 
ENV JAVA_HOME /usr/local/jdk1.8.0_73
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.37
ENV CATALINA_BASH /usr/local/apache-tomcat-9.0.37
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin
 
EXPOSE 8080
 
CMD /usr/local/apache-tomcat-9.0.37/bin/startup.sh && tail -F /usr/local/apache-tomcat-9.0.37/bin/logs/catalina.out

这里提供一个简易版的安装

# 使用基于 CentOS 的镜像
FROM centos:7
MAINTAINER shirley<1470762087@qq.com>


# 更新 CentOS 系统并安装 OpenJDK 和 curl 工具
RUN yum -y install vim
RUN yum update -y 
RUN yum install -y java-1.8.0-openjdk.x86_64 curl

ENV MYPATH /usr/local
WORKDIR $MYPATH

# 下载 Tomcat 压缩包并解压  如果报错,看下载地址是否正确
RUN curl -O https://downloads.apache.org/tomcat/tomcat-8/v8.5.85/bin/apache-tomcat-8.5.85.tar.gz
RUN tar xvzf apache-tomcat-8.5.85.tar.gz 
RUN mv apache-tomcat-8.5.85  /usr/local/tomcat 
RUN rm apache-tomcat-8.5.85.tar.gz

# 设置环境变量
ENV CATALINA_HOME /usr/local/tomcat
ENV PATH $CATALINA_HOME/bin:$PATH

# 开放 8080 端口
EXPOSE 8080

# 启动 Tomcat
CMD ["catalina.sh", "run"]

③ 构建镜像

docker build -t diytomcat .
#diytomcat自己定义的名字

④  启动

docker run -d -p 3344:8080 --name youtomcat -v /home/youtomcat/build/tomcat/test:/usr/local/apache-tomcat-9.0.37/webapps/test -v /home/youtomcat/build/tomcat/tomcatlogs/:/usr/local/apache-tomcat-9.0.37/logs diytomcat

不挂载简单的测试

docker run -it --rm -p 8080:8080 my-tomcat

⑤ 访问测试

⑥ 发布项目(由于做了卷挂载, 我们直接在本地编写项目就可以发布了)

7.2 发布到docker hub

① 注册账号、登录

docker login -u 码

② 提交

# push到我们的服务器上
docker push diytomcat

The push refers to repository [docker.io/library/diytomcat]
2eaca873a720: Preparing 
1b38cc4085a8: Preparing 
088ebb58d264: Preparing 
c06785a2723d: Preparing 
291f6e44771a: Preparing 
denied: requested access to the resource is denied  # 拒绝
 
# push镜像的问题?
The push refers to repository [docker.io/1314520007/diytomcat]
An image does not exist locally with the tag: 1314520007/diytomcat
 
# 解决,增加一个tag
docker tag diytomcat 1314520007/tomcat:1.0
docker push diytomcat 1314520007/tomcat:1.0

 7.3 发布到阿里云

① 登录阿里云

② 找到容器镜像服务

③ 创建命名空间

④ 创建容器镜像

⑥ 点击仓库名称,参考官方文档即可

在这里插入图片描述

总结

在这里插入图片描述

八、docker网络

8.1 docker0

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

# docker run -d -P --name tomcat01 tomcat
# docker run -d -P --name tomcat02 tomcat
 
# 查看容器内部的网络地址 ip addr
# docker exec -it tomcat01 ip addr, 发现容器启动的时候得到一个eth0@if115 ip地址,docker分配的!
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
114: eth0@if115: <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
 
# 思考: linux 能不能ping通容器?
ping 172.17.0.2
 
# linux 可以 ping 通docker容器内部!

原理:

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

2、这个容器带来网卡,都是一对对的。veth-pair 就是一对的虚拟设备接口,他们都是成对出现的,一端连着协议,一端彼此相连。正因这个特性,veth-pair充当一个桥梁, 连接各种虚拟网络设备。
OpenStac, Docker容器之间的链接,OVS的链接, 都是使用veth-pair技术

测试:

docker exec -it tomcat01 ip addr           #获取一个ip地址
docker exec -it tomcat02 ping 172.2.0.2    #测试是否能ping通

 容器与容器之间是可以相互ping通的

tomcat01和tomcat02是共用的一个路由器,docker0

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

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

Docker中的所有的网络接口都是虚拟的,虚拟的转发效率高,适用于内网传递文件

 8.2 link

编写了一个微服务,database url =ip; 项目不重启,数据ip换掉了,希望可以处理这个问题,可以按名字来进行访问容器

# docker exec -it tomcat02 ping tomcat01
ping: tomcat01: Name or service not known
 
# 如何可以解决呢?
# 通过--link既可以解决网络连通问题
# docker run -d -P  --name tomcat03 --link tomcat02 tomcat
3a2bcaba804c5980d94d168457c436fbd139820be2ee77246888f1744e6bb473

# docker ps
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS                     NAMES
3a2bcaba804c        tomcat              "catalina.sh run"   4 seconds ago       Up 3 seconds        0.0.0.0:32772->8080/tcp   tomcat03
f22ed47ed1be        tomcat              "catalina.sh run"   57 minutes ago      Up 57 minutes       0.0.0.0:32771->8080/tcp   tomcat02
9d97f93401a0        tomcat              "catalina.sh run"   About an hour ago   Up About an hour    0.0.0.0:32770->8080/tcp   tomcat01

# 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.129 ms
64 bytes from tomcat02 (172.17.0.3): icmp_seq=2 ttl=64 time=0.100 ms
64 bytes from tomcat02 (172.17.0.3): icmp_seq=3 ttl=64 time=0.110 ms
64 bytes from tomcat02 (172.17.0.3): icmp_seq=4 ttl=64 time=0.107 ms
 
# 反向可以ping通吗?
# docker exec -it tomcat02 ping tomcat03
ping: tomcat03: Name or service not known

# docker exec -it tomcat03 cat /etc/hosts
127.0.0.1   localhost
::1 localhost ip6-localhost ip6-loopback
fe00::0 ip6-localnet
ff00::0 ip6-mcastprefix
ff02::1 ip6-allnodes
ff02::2 ip6-allrouters
172.17.0.3  tomcat02 f22ed47ed1be
172.17.0.4  3a2bcaba804c

--link 就是在hosts配置中增加了一个172.17.0.3 tomcat02 f22ed47ed1be

现在Docker已经不建议使用--link了

自定义网络!不使用Docker0!

Docker0的问题:它不支持容器名链接访问。而link解决了这个问题。

8.3 自定义网络

查看所有docker网络

docker network ls

8.3.1 所有网络

bridge: 桥接模式,桥接 docker 默认,自己创建的也是用brdge模式

none: 不配置网络

host: 和宿主机共享网络

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

 8.3.2 创建一个

# 我们直接启动的命令默认有一个 --net bridge,而这个就是我们的docker0
docker run -d -P --name tomcat01 tomcat
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

# docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet
26a5afdf4805d7ee0a660b82244929a4226470d99a179355558dca35a2b983ec
# docker network ls
NETWORK ID          NAME                DRIVER              SCOPE
30d601788862        bridge              bridge              local
226019b14d91        host                host                local
26a5afdf4805        mynet               bridge              local
7496c014f74b        none                null                local
#查看网络
docker network inspect mynet

自己创建的网络下,启动容器

# docker run -d -P --name tomcat-net-01 --net mynet tomcat
# docker run -d -P --name tomcat-net-02 --net mynet tomcat

# docker network inspect mynet
 
# 再次拼连接
# docker exec -it tomcat-net-01 ping 192.168.0.3
PING 192.168.0.3 (192.168.0.3) 56(84) bytes of data.
64 bytes from 192.168.0.3: icmp_seq=1 ttl=64 time=0.113 ms
64 bytes from 192.168.0.3: icmp_seq=2 ttl=64 time=0.093 ms

# 现在不使用 --link也可以ping名字了!
# docker exec -it tomcat-net-01 ping tomcat-net-02
PING tomcat-net-02 (192.168.0.3) 56(84) bytes of data.
64 bytes from tomcat-net-02.mynet (192.168.0.3): icmp_seq=1 ttl=64 time=0.068 ms
64 bytes from tomcat-net-02.mynet (192.168.0.3): icmp_seq=2 ttl=64 time=0.096 ms
64 bytes from tomcat-net-02.mynet (192.168.0.3): icmp_seq=3 ttl=64 time=0.094 ms

好处:

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

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

 8.4 网络连通

# docker network connect  mynet tomcat01
 
# 连通之后就是讲tomcat01 放到了mynet网路下
# 一个容器两个ip地址:
# 阿里云服务器,公网ip,私网ip
# 连通ok
# docker exec -it tomcat01 ping tomcat-net-01
PING tomcat-net-01 (192.168.0.2) 56(84) bytes of data.
64 bytes from tomcat-net-01.mynet (192.168.0.2): icmp_seq=1 ttl=64 time=0.100 ms
64 bytes from tomcat-net-01.mynet (192.168.0.2): icmp_seq=2 ttl=64 time=0.085 ms

# 依旧无法连通,没有connect
# docker exec -it tomcat02 ping tomcat-net-01
ping: tomcat-net-01: Name or service not known
 

8.4.1   集成redis

① 创建网卡

# 创建网卡
docker network create redis --subnet 172.38.0.0/16

 ② redis集成

可参考redis学习,集成脚本配置

# 通过脚本创建六个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
 
# 创建集群
# 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
>>> Performing hash slots allocation on 6 nodes...
Master[0] -> Slots 0 - 5460
Master[1] -> Slots 5461 - 10922
Master[2] -> Slots 10923 - 16383
Adding replica 172.38.0.15:6379 to 172.38.0.11:6379
Adding replica 172.38.0.16:6379 to 172.38.0.12:6379
Adding replica 172.38.0.14:6379 to 172.38.0.13:6379
M: 541b7d237b641ac2ffc94d17c6ab96b18b26a638 172.38.0.11:6379
   slots:[0-5460] (5461 slots) master
M: a89c1f1245b264e4a402a3cf99766bcb6138dbca 172.38.0.12:6379
   slots:[5461-10922] (5462 slots) master
M: 259e804d6df74e67a72e4206d7db691a300c775e 172.38.0.13:6379
   slots:[10923-16383] (5461 slots) master
S: 9b19170eea3ea1b92c58ad18c0b5522633a9e271 172.38.0.14:6379
   replicates 259e804d6df74e67a72e4206d7db691a300c775e
S: 061a9d38f22910aaf0ba1dbd21bf1d8f57bcb7d5 172.38.0.15:6379
   replicates 541b7d237b641ac2ffc94d17c6ab96b18b26a638
S: 7a16b9bbb0615ec95fc978fa62fc054df60536f0 172.38.0.16:6379
   replicates a89c1f1245b264e4a402a3cf99766bcb6138dbca
Can I set the above configuration? (type 'yes' to accept): yes
>>> Nodes configuration updated
>>> Assign a different config epoch to each node
>>> Sending CLUSTER MEET messages to join the cluster
Waiting for the cluster to join
...
>>> Performing Cluster Check (using node 172.38.0.11:6379)
M: 541b7d237b641ac2ffc94d17c6ab96b18b26a638 172.38.0.11:6379
   slots:[0-5460] (5461 slots) master
   1 additional replica(s)
M: a89c1f1245b264e4a402a3cf99766bcb6138dbca 172.38.0.12:6379
   slots:[5461-10922] (5462 slots) master
   1 additional replica(s)
S: 7a16b9bbb0615ec95fc978fa62fc054df60536f0 172.38.0.16:6379
   slots: (0 slots) slave
   replicates a89c1f1245b264e4a402a3cf99766bcb6138dbca
S: 061a9d38f22910aaf0ba1dbd21bf1d8f57bcb7d5 172.38.0.15:6379
   slots: (0 slots) slave
   replicates 541b7d237b641ac2ffc94d17c6ab96b18b26a638
M: 259e804d6df74e67a72e4206d7db691a300c775e 172.38.0.13:6379
   slots:[10923-16383] (5461 slots) master
   1 additional replica(s)
S: 9b19170eea3ea1b92c58ad18c0b5522633a9e271 172.38.0.14:6379
   slots: (0 slots) slave
   replicates 259e804d6df74e67a72e4206d7db691a300c775e
[OK] All nodes agree about slots configuration.
>>> Check for open slots...
>>> Check slots coverage...
[OK] All 16384 slots covered.
 
 

 九、docker compose

9.1 安装

① 下载

curl -L https://get.daocloud.io/docker/compose/releases/download/1.25.5/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose

② 授权

chmod +x /usr/local/bin/docker-compose

官网实例:

https://docs.docker.com/compose/gettingstarted/

9.2 实例

① 编写项目微服务

② Dockerfile构建镜像

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

③ 服务器

docker-compose down         # 关闭容器
docker-compose up --build   # 重新构建

④ 登录

xxxxxxx:8080/hello

十、socker swarm

10.1 服务器

购买4台服务器,安装docker

① 初始化

docker swarm init --help
 
ip addr # 获取自己的ip(用内网的不要流量)
 
# docker swarm init --advertise-addr 172.16.250.97
Swarm initialized: current node (otdyxbk2ffbogdqq1kigysj1d) is now a manager.
 
To add a worker to this swarm, run the following command:
    docker swarm join --token SWMTKN-1-3vovnwb5pkkno2i3u2a42yrxc1dk51zxvto5hrm4asgn37syfn-0xkrprkuyyhrx7cidg381pdir 172.16.250.97:2377
To add a manager to this swarm, run 'docker swarm join-token manager' and follow the instructions.
 

② 加入一个节点

# 获取令牌
docker swarm join-token manager
docker swarm join-token worker

# docker swarm join --token SWMTKN-1-3vovnwb5pkkno2i3u2a42yrxc1dk51zxvto5hrm4asgn37syfn-0xkrprkuyyhrx7cidg381pdir 172.16.250.97:2377
This node joined a swarm as a worker.
 

4台同样的操作

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值