在这里插入图片描述

初始Docker

我们面临的问题

软件开发最大的麻烦事之一，就是环境配置。用户计算机的环境都不相同，你怎么知道自家的软件，能在那些机器跑起来？用户必须保证两件事：操作系统的设置，各种库和组件的安装。只有它们都正确，软件才能运行。举例来说，安装一个 Python 应用，计算机必须有 Python 引擎，还必须有各种依赖，可能还要配置环境变量。如果某些老旧的模块与当前环境不兼容，那就麻烦了。开发者常常会说：“它在我的机器可以跑了”（It works on my machine），言下之意就是，其他机器很可能跑不了。环境配置如此麻烦，换一台机器，就要重来一次，旷日费时。很多人想到，能不能从根本上解决问题，软件可以带环境安装？也就是说，安装的时候，把原始环境一模一样地复制过来。

我们写的代码也会接触到好几个环境：开发环境、测试环境以及生产环境：
**
由于环境的不同可能我们写的代码明明可以在我们本地运行，但是当我们发布到生产环境中的时候它就不可以运行了

在这里插入图片描述

所以我们需要把我们写的代码和环境一起迁移过去，我们可以使用一个容器把代码和原始环境都给复制过去
在这里插入图片描述

Docker是什么

一句话介绍

Docker是一种容器技术，解决软件跨环境迁移的问题

基本信息

1.Docker 是一个开源的应用容器引擎

2.诞生于 2013 年初，基于 Go 语言实现， dotCloud 公司出品（后改名为Docker Inc）

3.Docker 可以让开发者打包他们的应用以及依赖包到一个轻量级、可移植的容器中，然后发布到

4.任何流行的 Linux 机器上。

5.容器是完全使用沙箱机制，相互隔离容器性能开销极低。（比如一个容器中装着Tomcat另一个容器中装着redis，如果redis出现了故障它不会影响另一个容器中的Tomcat，二者是隔离的，不会互相影响）

就像下面鲸鱼头上的一个个集装箱一样，相互之间是隔离的
在这里插入图片描述

6.Docker 从 17.03 版本之后分为 CE（Community Edition: 社区版）和 EE（Enterprise Edition: 企业版）

Docker架构

架构图

在这里插入图片描述

镜像（Image）：

Docker 镜像（Image），就相当于是一个 root 文件系统。比如官方镜像 ubuntu:16.04 就包含了完整的一套 Ubuntu16.04 最小系统的 root 文件系统。

容器（Container）：

镜像（Image）和容器（Container）的关系，就像是面向对象程序设计中的类和对象一样，镜像是静态的定义，容器是镜像运行时的实体。容器可以被创建、启动、停止、删除、暂停等。

仓库（Repository）：

仓库可看成一个代码控制中心，用来保存镜像。

安装Docker

安装步骤

1、yum 包更新到最新

yum update

2、安装需要的软件包， yum-util 提供yum-config-manager功能，另外两个是devicemapper驱动依赖的

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

3、设置yum源

yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo

4、安装docker，出现输入的界面都按 y

yum install -y docker-ce

5、查看docker版本，验证是否验证成功

docker -v

在这里插入图片描述

Docker命令

Doker服务相关命令

systemctl理解

Linux 服务管理两种方式service和systemctl
systemd是Linux系统最新的初始化系统(init),作用是提高系统的启动速度，尽可能启动较少的进程，尽可能更多进程并发启动。
systemd对应的进程管理命令是systemctl

1.启动docker服务

systemctl start docker

2.停止docker服务

systemctl start docker

3.重启docker服务

systemctl restart docker

4.查看docker服务状态

systemctl status docker

在这里插入图片描述

5.开机启动docker服务

systemctl enable docker

在这里插入图片描述

Docker镜像相关命令

1.查看镜像

查看镜像: 查看本地所有的镜像

docker images
docker images -q //查看所用镜像的id

2.搜索镜像

搜索镜像:从网络中查找需要的镜像

docker search 镜像名称

在这里插入图片描述

3.拉取镜像

拉取镜像:从Docker仓库下载镜像到本地，镜像名称格式为名称:版本号，如果版本号不指定则是最新的版本。如果不知道镜像版本，可以去docker hub 搜索对应镜像查看。

docker pull 镜像名称

4.删除镜像

删除本地镜像

docker rmi 镜像id #删除本地指定镜像
docker rmi 'docker images -q' #删除本地所用的镜像

Docker 容器相关命令

1查看容器

docker ps # 查看所有正在运行的容器
docker ps -a #查看所有容器

2.创建容器

创建并启动容器

docker run 参数

参数说明：

** -i：**保持容器运行。通常与 -t 同时使用。加入it这两个参数后，容器创建后自动进入容器中，退出容器后，容器自动关闭。

**-t：**为容器重新分配一个伪输入终端，通常与 -i 同时使用。

**-d：**以守护（后台）模式运行容器。创建一个容器在后台运行，需要使用docker exec 进入容器。退出后，容器不会关闭。

** -it： **创建的容器一般称为交互式容器，

-id： 创建的容器一般称为守护式容器

**–name：**为创建的容器命名

例

**
创建一个容器并让它在后台运行

在这里插入图片描述

3.进入容器

docker exec 参数 #退出容器 容器不会关闭

例

进入刚刚创建的C3容器内部

在这里插入图片描述

4.启动容器

docker start 容器名称

5.停止容器

如果容器是运行状态则删除失败，需要停止容器才能删除

docker stop 容器名称

6.删除容器

docker rm 容器名称

7.查看容器信息

docker inspect 容器名称

Docker容器数据卷

思考

Docker 容器删除后，在容器中产生的数据也会随之销毁

在这里插入图片描述

可以将容器挂载到数据卷，容器删除数据卷不会被删除
在这里插入图片描述

Docker 容器和外部机器可以直接交换文件吗？

不可以，外部机器与容器之间网络不互通
在这里插入图片描述

容器之间想要进行数据交互？

使用数据卷，两个容器挂载到同一个数据卷
在这里插入图片描述

数据卷及其作用介绍

介绍

1.数据卷是宿主机中的一个目录或文件
2.当容器目录和数据卷目录绑定后，对方的修改会立即同步
3.一个数据卷可以被多个容器同时挂载
4.一个容器也可以被挂载多个数据卷

作用

1：数据卷可在容器之间共享或重用数据
2：卷中的更改可以直接生效
3：数据卷中的更改不会包含在镜像的更新中
4：数据卷的生命周期一直持续到没有容器使用它为止
5.容器数据持久化（完全独立于容器的生存周期，因此Docker不会在容器删除时删除其挂载的数据卷）
6.外部机器和容器间接通信
7.容器之间数据交换

配置数据卷

创建启动容器时，使用 –v 参数设置数据卷

docker run ... –v 宿主机目录(文件):容器内目录(文件) ...

举例

创建一个名为test容器并挂载到数据卷/root/data_contain中

docker run -it --name=test -v /root/data:/root/data_contain redis:lastest

注意事项：

目录必须是绝对路径
如果目录不存在，会自动创建
可以挂载多个数据卷

多容器进行数据交换

多个容器挂载同一个数据卷
数据卷容器

在这里插入图片描述

1.创建启动c3数据卷容器，使用 –v 参数设置数据卷

docker run –it --name=c3 –v /volume centos:7 /bin/bash

创建启动 c1 c2 容器，使用 –-volumes-from 参数设置数据卷

docker run –it --name=c1 --volumes-from c3 centos:7 /bin/bash

docker run –it --name=c2 --volumes-from c3 centos:7 /bin/bash

小结

数据卷概念

宿主机的一个目录或文件

数据卷作用

容器数据持久化

客户端和容器数据交换

容器间数据交换

数据卷容器

创建一个容器，挂载一个目录，让其他容器继承自该容器( --volume-from )。
通过简单方式实现数据卷配置

注意

1.数据卷中的内容改变容器中的内容也会改变
2.容器中的内容改变数据卷中的内容也会改变
3.一个容器挂载到一个已经有内容的数据卷中，容器中会直接有该数据卷的内容
4.容器内容与数据卷内容一致
5.容器删除数据卷不会删除

Docker应用部署

1.MySQL部署

具体步骤

1.搜索mysql镜像
2.拉取mysql镜像
3.创建容器
4.操作容器中的mysql

1.搜索mysql镜像

2.拉取mysql镜像

3.创建容器

4.操作容器中的mysql

2.Tomcat部署

具体步骤

1.搜索tomcat镜像
2.拉取tomcat镜像
3.创建容器
4.使用外部机器访问tomcat

1.搜索tomcat镜像

docker search tomcat

2.拉取tomcat镜像

docker pull tomcat

3.创建容器

# 在/root目录下创建tomcat目录用于存储tomcat数据信息
mkdir ~/tomcat
cd ~/tomcat

docker run -id --name=c_tomcat \
-p 8080:8080 \
-v $PWD:/usr/local/tomcat/webapps \
tomcat

他会自动帮你把tomcat启动起来
在这里插入图片描述

参数说明：

**-p 8080:8080：**将容器的8080端口映射到主机的8080端口
**-v $PWD:/usr/local/tomcat/webapps：**将主机中当前目录挂载到容器的webapps

4.使用外部机器访问tomcat

在tomcat目录下创建一个test文件夹，在文件夹中添加index.html页面
在这里插入图片描述

在这里插入图片描述

注意

这个访问路径是相对于我们创建的tomcat的根路径，以后我们要将项目部署到tomcat上只需要吧创建的项目放到tomcat目录下即可

3.Nginx部署

具体步骤

1.搜索Nginx镜像
2.拉取Nginx镜像
3.创建容器，设置端口映射、目录映射
4.使用外部机器访问nginx

1.搜索Nginx镜像

docker search nginx

2.拉取Nginx镜像

docker pull nginx

3.创建容器，设置端口映射、目录映射

# 在/root目录下创建nginx目录用于存储nginx数据信息
mkdir ~/nginx
cd ~/nginx
mkdir conf
cd conf
# 在~/nginx/conf/下创建nginx.conf文件,粘贴下面内容
vim nginx.conf

user  nginx;
worker_processes  1;

error_log  /var/log/nginx/error.log warn;
pid        /var/run/nginx.pid;


events {
    worker_connections  1024;
}


http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;

    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    access_log  /var/log/nginx/access.log  main;

    sendfile        on;
    #tcp_nopush     on;

    keepalive_timeout  65;

    #gzip  on;

    include /etc/nginx/conf.d/*.conf;
}

这句话在nginx目录下执行
**

docker run -id --name=c_nginx \
-p 80:80 \
-v $PWD/conf/nginx.conf:/etc/nginx/nginx.conf \
-v $PWD/logs:/var/log/nginx \
-v $PWD/html:/usr/share/nginx/html \
nginx

在这里插入图片描述

参数说明：

-p 80:80：将容器的 80端口映射到宿主机的 80 端口。
-v $PWD/conf/nginx.conf:/etc/nginx/nginx.conf：将主机当前目录下的 /conf/nginx.conf 挂载到容器的 :/etc/nginx/nginx.conf。配置目录
-v $PWD/logs:/var/log/nginx：将主机当前目录下的 logs 目录挂载到容器的/var/log/nginx。日志目录

4.使用外部机器访问nginx

在这里插入图片描述

注意事项

1.容器内的网络服务和外部机器不能直接通信

2.外部机器和宿主机可以直接通信

3.宿主机和容器可以直接通信

4.当容器中的网络服务需要被外部机器访问时，可以将容器中提供服务的端口映射到宿主机的端口上。外部机器访问宿主机的该端口，从而间接访问容器的服务。

5.这种操作称为：端口映射

在这里插入图片描述

1.搜索mysql镜像

docker search mysql

2.拉取mysql镜像

docker pull mysql

3.创建容器

# 在/root目录下创建mysql目录用于存储mysql数据信息
mkdir ~/mysql
cd ~/mysql

docker run -id \
-p 3307:3306 \
--name=c_mysql \
-v $PWD/conf:/etc/mysql/conf.d \
-v $PWD/logs:/logs \
-v $PWD/data:/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=123456 \
mysql:5.6

在这里插入图片描述

进入容器登入mysql
在这里插入图片描述

使用数据库连接器连接mysql
**
注意这里的连接端口是连接到服务器的端口不是到容器的，我们将服务器3307端口映射到容器的3306端口
在这里插入图片描述

参数说明

-p 3307:3306：将容器的 3306 端口映射到宿主机的 3307 端口。
-v $PWD/conf:/etc/mysql/conf.d：将主机当前目录下的 conf/my.cnf 挂载到容器的 /etc/mysql/my.cnf。配置目录
-v $PWD/logs:/logs：将主机当前目录下的 logs 目录挂载到容器的 /logs。日志目录
-v $PWD/data:/var/lib/mysql ：将主机当前目录下的data目录挂载到容器的 /var/lib/mysql 。数据目录
**-e MYSQL_ROOT_PASSWORD=123456：**初始化 root 用户的密码。

4.操作容器中的mysql

4.Redis部署

具体步骤

1.搜索redis镜像
2.拉取redisl镜像
3.创建容器，设置端口映射
4.使用外部机器连接redis

1.搜索redis镜像

docker search redis

2.拉取redisl镜像

docker pull redis:5.0

3.创建容器，设置端口映射

docker run -id --name=c_redis -p 6379:6379 redis:5.0

在这里插入图片描述

4.使用外部机器连接redis

在这里插入图片描述

DockerFile

镜像原理

镜像是什么

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

思考

Docker 镜像本质是什么？

Docker 中一个centos镜像为什么只有200MB，而一个centos操作系统的iso文件要几个个G？

Docker 中一个tomcat镜像为什么有500MB，而一个tomcat安装包只有70多MB？
**
**

操作系统组成部分

进程调度子系统
进程通信子系统
内存管理子系统
设备管理子系统
文件管理子系统
网络通信子系统
作业控制子系统

文件管理子系统

Linux文件系统由bootfs和rootfs两部分组成

bootfs：包含bootloader（引导加载程序）和 kernel（内核）

rootfs： root文件系统，包含的就是典型 Linux 系统中的/dev，/proc，/bin，/etc等标准目录和文件

不同的linux发行版，bootfs基本一样，而rootfs不同，如ubuntu，centos等

在这里插入图片描述

1）UnionFS(联合文件系统)

**
UnionFS（联合文件系统）：Union文件系统是一种分层、轻量级并且高性能的文件系统，它支持对文件系统的修改作为一次提交来一层层的叠加，同时可以将不同目录挂载到同一个虚拟文件系统下，Union文件系统是Dokcer镜像的基础。镜像可以通过分层来进行继承，基于基础镜像（没有父镜像），可以制作各种具体的镜像。
特性：一次同时加载多个文件系统，但从外面看起来，只能看到一个文件系统，联合加载会把各层文件系统加载起来，这样最终的文件系统会包含所有的底层文件和目录
**
**

2）Docker镜像加载原理

docker的镜像实际上是由一层一层的文件系统构成，这种层级的文件系统UnionFS。
主要包含bootloader和kernel，bootloader主要是引导加载kernel，Linux刚启动时会加载bootfs文件系统，在Docker镜像的最底层是bootfs。这一层与我们典型的linux/unix系统是一样的，包含boot加载器内核。当boot加载完之后整个内核就都在内存中了，此时内存的使用权已经由bootfs交给内核了，此时系统也会卸载bootfs

平时我们安装进虚拟机的CentOS都是好几个G，为什么docker这里才200M
**
在这里插入图片描述

对以一个精简的OS，rootfs可以很小，只需要包括最基本的命令、工具和程序库就行，因为底层直接用host和kernel，自己只需要提供rootfs就行。由此可见对于不同的Linux发行版，bootfs基本是一致的，rootfs会有差别，因此不同的发行版可以公用bootfs。
**

3）分层的镜像

**
以pull为例，在下载的过程中我么可以看到docker的镜像好像是在一层一层的下载

在这里插入图片描述

4）为什么Docker镜像要采用这种分层的结构

**
最大一个好处就是——共享资源
比如：有多个镜像都从相同的base镜像构建而来，那么宿主机只需要在磁盘上保存一份base镜像，同时内存中也需要加载一份base镜像，就可以为所有服务器服务了。而且镜像的每一层都可以被共享。
**

2.特点

**
docker镜像都是只读的
当容器启动时，一个新的可写层被加载到镜像的顶部。
这一层通常被称作“容器层”，“容器层”之下都叫“镜像层”

5）深入理解

所有的 Docker 镜像都起始于一个基础镜像层，当进行修改或增加新的内容时，就会在当前镜像层之上，创建新的镜像层。举一个简单的例子，假如基于 Ubuntu Linux 16.04 创建一个新的镜像，这就是新镜像的第一层；如果在该镜像中添加 Python包，就会在基础镜像层之上创建第二个镜像层；如果继续添加一个安全补丁，就会创建第三个镜像层。该镜像当前已经包含 3 个镜像层，如下图所示（这只是一个用于演示的很简单的例子）。

在这里插入图片描述

在添加额外的镜像层的同时，镜像始终保持是当前所有镜像的组合，理解这一点非常重要。下图中举了一个简单的例子，每个镜像层包含 3 个文件，而镜像包含了来自两个镜像层的 6 个文件。

在这里插入图片描述

上图中的镜像层跟之前图中的略有区别，主要目的是便于展示文件。下图中展示了一个稍微复杂的三层镜像，在外部看来整个镜像只有 6 个文件，这是因为最上层中的文件 7 是文件 5 的一个更新版本。

在这里插入图片描述

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

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

Linux 上可用的存储引擎有 AUFS、Overlay2、Device Mapper、Btrfs 以及 ZFS。顾名思义，每种存储引擎都基于 Linux 中对应的文件系统或者块设备技术，并且每种存储引擎都有其独有的性能特点。

Docker 在 Windows 上仅支持 windowsfilter 一种存储引擎，该引擎基于 NTFS 文件系统之上实现了分层和 CoW[1]。

下图展示了与系统显示相同的三层镜像。所有镜像层堆叠并合并，对外提供统一的视图。

在这里插入图片描述

小结

1.Docker镜像是由特殊的文件系统叠加而成
2.最底端是 bootfs，并使用宿主机的bootfs

3.第二层是 root文件系统rootfs,称为base image

4.然后再往上可以叠加其他的镜像文件

5.统一文件系统（Union File System）技术能够将不同的层整合成一个文件系统，为这些层提供了一个统一的视角，这样就隐藏了多层的存在，在用户的角度看来，只存在一个文件系统。

6.一个镜像可以放在另一个镜像的上面。位于下面的镜像称为父镜像，最底部的镜像成为基础镜像。

7.当从一个镜像启动容器时，Docker会在最顶层加载一个读写文件系统作为容器

解决思考题中的问题

1.Docker 镜像本质是什么？

是一个分层文件系统

2.Docker 中一个centos镜像为什么只有200MB，而一个centos操作系统的iso文件要几个个G？

Centos的iso镜像文件包含bootfs和rootfs，而docker的centos镜像复用操作系统的bootfs，只有rootfs和其他镜像层

3.Docker 中一个tomcat镜像为什么有500MB，而一个tomcat安装包只有70多MB？

由于docker中镜像是分层的，tomcat虽然只有70多MB，但他需要依赖于父镜像和基础镜像，所有整个对外暴露的tomcat镜像大小500多MB

在这里插入图片描述

镜像制作

1.容器转为镜像

作用：比如我们在tomcat上新建了一个应用，但是我们要把应用发送给测试人员进行测试，这时候就可以把这个应用放在容器之中然后将其转换为镜像，然后发送给测试人员测试

docker commit 容器id 镜像名称:版本号
#镜像是不可以直接传输的
#所以可以将其压缩为压缩文件进行传输
docker save -o 压缩文件名称 镜像名称:版本号

docker load -i 压缩文件名称

在这里插入图片描述

2.DockerFile

什么是DockerFile

1.Dockerfile 是一个文本文件

2.包含了一条条的指令

3.每一条指令构建一层，基于基础镜像，最终构建出一个新的镜像

4.对于开发人员：可以为开发团队提供一个完全一致的开发环境

5.对于测试人员：可以直接拿开发时所构建的镜像或者通过Dockerfile文件构建一个新的镜像开始工作了

6.对于运维人员：在部署时，可以实现应用的无缝移植

Dochub网址：https://hub.docker.com

在这里插入图片描述

3.DockerFile关键字

关键字	作用	备注
FROM	指定父镜像	指定dockerfile基于那个image构建
MAINTAINER	作者信息	用来标明这个dockerfile谁写的
LABEL	标签	用来标明dockerfile的标签可以使用Label代替Maintainer 最终都是在docker image基本信息中可以查看
RUN	执行命令	执行一段命令默认是/bin/sh 格式: RUN command 或者 RUN [“command” , “param1”,“param2”]
CMD	容器启动命令	提供启动容器时候的默认命令和ENTRYPOINT配合使用.格式 CMD command param1 param2 或者 CMD [“command” , “param1”,“param2”]
ENTRYPOINT	入口	一般在制作一些执行就关闭的容器中会使用
COPY	复制文件	build的时候复制文件到image中
ADD	添加文件	build的时候添加文件到image中不仅仅局限于当前build上下文可以来源于远程服务
ENV	环境变量	指定build时候的环境变量可以在启动的容器的时候通过-e覆盖格式ENV name=value
ARG	构建参数	构建参数只在构建的时候使用的参数如果有ENV 那么ENV的相同名字的值始终覆盖arg的参数
VOLUME	定义外部可以挂载的数据卷	指定build的image那些目录可以启动的时候挂载到文件系统中启动容器的时候使用 -v 绑定格式 VOLUME [“目录”]
EXPOSE	暴露端口	定义容器运行的时候监听的端口启动容器的使用-p来绑定暴露端口格式: EXPOSE 8080 或者 EXPOSE 8080/udp
WORKDIR	工作目录	指定容器内部的工作目录如果没有创建则自动创建如果指定/ 使用的是绝对地址如果不是/开头那么是在上一条workdir的路径的相对路径
USER	指定执行用户	指定build或者启动的时候用户在RUN CMD ENTRYPONT执行的时候的用户
HEALTHCHECK	健康检查	指定监测当前容器的健康监测的命令基本上没用因为很多时候应用本身有健康监测机制
ONBUILD	触发器	当存在ONBUILD关键字的镜像作为基础镜像的时候当执行FROM完成之后会执行 ONBUILD的命令但是不影响当前镜像用处也不怎么大
STOPSIGNAL	发送信号量到宿主机	该STOPSIGNAL指令设置将发送到容器的系统调用信号以退出。
SHELL	指定执行脚本的shell	指定RUN CMD ENTRYPOINT 执行命令的时候使用的shell

4…制作一个基于Centos7的镜像

需求

自定义centos7镜像。
要求：

默认登录路径为 /usr
可以使用vim

实现步骤

1.定义父镜像：FROM centos:7

2.定义作者信息：MAINTAINER itheima [email protected]

3.执行安装vim命令： RUN yum install -y vim

4.定义默认的工作目录：WORKDIR /usr

5.定义容器启动执行的命令：CMD /bin/bash

6.通过dockerfile构建镜像：docker bulid –f dockerfile文件路径 –t 镜像名称:版本 .

例

注意末尾有一个点号否则会报错

docker bulid –f centos_dockerfile –t pjhcentos:1  .

演示

在root目录下创建一个docker-files目录

在这里插入图片描述

创建一个名为centos_dockerfile的文件内容

在这里插入图片描述

输入命令创建镜像

在这里插入图片描述

创建成功
在这里插入图片描述

将SpringBoot项目部署到容器中

需求

定义dockerfile，发布springboot项目

实现步骤

1.定义父镜像：FROM java:8

2.定义作者信息：MAINTAINER itheima [email protected]

3.将jar包添加到容器： ADD springboot.jar app.jar

4.定义容器启动执行的命令：CMD java–jar app.jar

5.通过dockerfile构建镜像：docker bulid –f dockerfile文件路径 –t 镜像名称:版本

演示

创建一个springboot项目
在这里插入图片描述

将其打包为jar包
在这里插入图片描述

上传到服务器上
在这里插入图片描述

传到对应的dockerfile目录中
在这里插入图片描述

将对应的jar包添加到对应的镜像中就有了
编写对应的DockerFile配置文件
在这里插入图片描述

构建镜像
在这里插入图片描述

创建对应的容器
在这里插入图片描述

在这里插入图片描述

测试访问
在这里插入图片描述

服务编排

微服务架构的应用系统中一般包含若干个微服务，每个微服务一般都会部署多个实例，如果每个微服务都要手动启停，维护的工作量会很大。

1.要从Dockerfile build image 或者去dockerhub拉取image
2.要创建多个container
3.要管理这些container（启动停止删除）

概念：

按照一定的业务规则批量管理容器

DockerCompose

概念介绍

Docker Compose是一个编排多容器分布式部署的工具，提供命令集管理容器化应用的完整开发周期，包括服务构建，启动和停止。使用步骤：利用 Dockerfile 定义运行环境镜像使用 docker-compose.yml 定义组成应用的各服务运行 docker-compose up 启动应用

在这里插入图片描述

DockerCompose的安装使用

1.安装方法

# Compose目前已经完全支持Linux、Mac OS和Windows，在我们安装Compose之前，需要先安装Docker。下面我 们以编译好的二进制包方式安装在Linux系统中。 
curl -L https://github.com/docker/compose/releases/download/1.22.0/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose
# 设置文件可执行权限 
chmod +x /usr/local/bin/docker-compose
# 查看版本信息 
docker-compose -version

在这里插入图片描述

2.卸载方法

# 二进制包方式安装的，删除二进制文件即可
rm /usr/local/bin/docker-compose

3、使用docker compose编排nginx+springboot项目

1.创建docker-compose目录

mkdir ~/docker-compose
cd ~/docker-compose

在这里插入图片描述

2.编写 docker-compose.yml 文件

注意名字必须为

docker-compose.yml

#版本号
version: '3'
services:
  nginx:
  #对应的nginx镜像名称
   image: nginx
   #容器与虚拟机的端口映射
   ports:
    - 80:80
    #当前的项目可以访问到对应的app项目于下面定义的app相联系
   links:
    - app
    #挂载数据卷，前面为宿主机目录后面为容器的目录
   volumes:
    - ./nginx/conf.d:/etc/nginx/conf.d
  app:
  #对应应用的镜像名称
    image: app
    expose:
      - "8080"

在这里插入图片描述

3.创建./nginx/conf.d目录

mkdir -p ./nginx/conf.d

在这里插入图片描述

4.在./nginx/conf.d目录下编写itheima.conf文件

server {
    listen 80;
    access_log off;
    location / {
        proxy_pass http://app:8080;
    }
   
}

在这里插入图片描述

5.在~/docker-compose 目录下使用docker-compose 启动容器

docker-compose up

在这里插入图片描述

6.测试访问

http://192.168.149.135/hello

在这里插入图片描述

Docker搭建私有仓库

一、私有仓库搭建

# 1、拉取私有仓库镜像 
docker pull registry
# 2、启动私有仓库容器 
docker run -id --name=registry -p 5000:5000 registry
# 3、打开浏览器 输入地址http://私有仓库服务器ip:5000/v2/_catalog，看到{"repositories":[]} 表示私有仓库 搭建成功
# 4、修改daemon.json   
vim /etc/docker/daemon.json    
# 在上述文件中添加一个key，保存退出。此步用于让 docker 信任私有仓库地址；注意将私有仓库服务器ip修改为自己私有仓库服务器真实ip 
{"insecure-registries":["121.196.111.120:5000"]} 
# 5、重启docker 服务 
systemctl restart docker
docker start registry

拉取镜像
在这里插入图片描述

创建容器 在这里插入图片描述

信任私有仓库的地址
在这里插入图片描述

二、将镜像上传至私有仓库

# 1、标记镜像为私有仓库的镜像     
docker tag centos:7 私有仓库服务器IP:5000/centos:7

在这里插入图片描述

# 2、上传标记的镜像     
docker push 私有仓 库服务器IP:5000/centos:7

在这里插入图片描述

三、从私有仓库拉取镜像

#拉取镜像 
docker pull 私有仓库服务器ip:5000/centos:7

在这里插入图片描述

Docker与虚拟机的比较

容器相关概念介绍

容器就是将软件打包成标准化单元，以用于开发、交付和部署。

容器镜像是轻量的、可执行的独立软件包，包含软件运行所需的所有内容：代码、运行时环境、系统工具、系统库和设置。

容器化软件在任何环境中都能够始终如一地运行。

容器赋予了软件独立性，使其免受外在环境差异的影响，从而有助于减少团队间在相同基础设施上运行不同软件时的冲突。

在这里插入图片描述

docker容器虚拟化与传统虚拟机比较

Docker 的容器利用了 LXC，管理利用 namespaces 来做权限的控制和隔离，利用cgroups 来进行资源的配置，并且还通过 aufs 来进一步提高文件系统的资源利用率，而这些技术都不是 Docker 独创。

LXC 与虚拟机的不同之处在于，它是一个操作系统级别的虚拟化环境，而不是硬件虚拟化环境。他们都做同样的事情，但 LXC 是操作系统级别的虚拟化环境，虚拟环境有它自己的进程和网络空间，而不是创建一个完整成熟的虚拟机。因此，一个 LXC 虚拟操作系统具有最小的资源需求，并启动只需几秒钟。

相同：

容器和虚拟机具有相似的资源隔离和分配优势

不同：

容器虚拟化的是操作系统，虚拟机虚拟化的是硬件。

传统虚拟机可以运行不同的操作系统，容器只能运行同一类型操作系统

在这里插入图片描述

Docker系列汇总

初始Docker

我们面临的问题

Docker是什么

一句话介绍

基本信息

Docker架构

架构图

镜像（Image）：

容器（Container）：

仓库（Repository）：

安装Docker

安装步骤

Docker命令

Doker服务相关命令

systemctl理解

1.启动docker服务

2.停止docker服务

3.重启docker服务

4.查看docker服务状态

5.开机启动docker服务

Docker镜像相关命令

1.查看镜像

2.搜索镜像

3.拉取镜像

4.删除镜像

Docker 容器相关命令

1查看容器

2.创建容器

参数说明：

例

3.进入容器

例

4.启动容器

5.停止容器

6.删除容器

7.查看容器信息

Docker容器数据卷

思考

Docker 容器删除后，在容器中产生的数据也会随之销毁

Docker 容器和外部机器可以直接交换文件吗？

容器之间想要进行数据交互？

数据卷及其作用介绍

介绍

作用

配置数据卷

举例

注意事项：

多容器进行数据交换

小结

数据卷概念

数据卷作用

数据卷容器

注意

Docker应用部署

1.MySQL部署

具体步骤

1.搜索mysql镜像

2.拉取mysql镜像

3.创建容器

4.操作容器中的mysql

2.Tomcat部署

具体步骤

1.搜索tomcat镜像

2.拉取tomcat镜像

3.创建容器

参数说明：

4.使用外部机器访问tomcat

注意

3.Nginx部署

具体步骤

1.搜索Nginx镜像

2.拉取Nginx镜像

3.创建容器，设置端口映射、目录映射

参数说明：

4.使用外部机器访问nginx

注意事项

1.搜索mysql镜像

2.拉取mysql镜像

3.创建容器

3、使用docker compose编排nginx+springboot项目

4.在./nginx/conf.d目录下编写itheima.conf文件

5.在~/docker-compose 目录下使用docker-compose 启动容器

三、从私有仓库拉取镜像

docker容器虚拟化与传统虚拟机比较