Docker基础操作

拼搏现实的明天。 2024-03-26 08:13 29阅读 0赞

### 关于Docker（[https://hub.docker.com/][https_hub.docker.com]） ###

微服务虽然具备各种各样的优势，但服务的拆分通用给部署带来了很大的麻烦。分布式系统中，依赖的组件非常多，不同组件之间部署时往往会产生一些冲突。在数百上千台服务中重复部署，环境不一定一致，会遇到各种问题。例如一个项目中，部署时需要依赖于Redis、RabbitMQ、MySQL等，这些服务部署时所需要的函数库、依赖项各不相同，甚至会有冲突。给部署带来了极大的困难。

**Docker**为了解决依赖的兼容问题的，采用了两个手段：将应用的Libs（函数库）、Deps（依赖）、配置与应用一起打包；将每个应用放到一个隔离**容器**去运行，避免互相干扰。

虽然解决了不同应用的兼容问题，但是开发、测试等环境会存在差异，操作系统版本也会有差异，例如Ubuntu和CentOS都是基于Linux内核，无非是系统应用不同，提供的函数库有差异，但是如果将一个Ubuntu版本的MySQL应用安装到CentOS系统，MySQL在调用Ubuntu函数库时，会发现找不到或者不匹配，就会报错了。

**Docker**将用户程序与所需要调用的系统(比如Ubuntu)函数库一起打包，Docker运行到不同操作系统时，直接基于打包的函数库，借助于操作系统的Linux内核来运行。

Docker如何解决大型项目依赖关系复杂，不同组件依赖的兼容性问题？

Docker允许开发中将应用、依赖、函数库、配置一起**打包**，形成可移植镜像；Docker应用运行在容器中，使用沙箱机制，相互**隔离**

Docker如何解决开发、测试、生产环境有差异的问题？

Docker镜像中包含完整运行环境，包括系统函数库，仅依赖系统的Linux内核，因此可以在任意Linux操作系统上运行。

Docker是一个快速交付应用、运行应用的技术，具备下列优势：

可以将程序及其依赖、运行环境一起打包为一个镜像，可以迁移到任意Linux操作系统；运行时利用沙箱机制形成隔离容器，各个应用互不干扰；启动、移除都可以通过一行命令完成，方便快捷。

#### Docker与虚拟机的区别 ####

Docker可以让一个应用在任何操作系统中非常方便的运行。而以前我们接触的虚拟机，也能在一个操作系统中，运行另外一个操作系统，保护系统中的任何应用。

**虚拟机**virtual machine）是在操作系统中**模拟**硬件设备，然后运行另一个操作系统，比如在 Windows 系统里面运行 Ubuntu 系统，这样就可以运行任意的Ubuntu应用了。而**Docker**仅仅是封装函数库，并没有模拟完整的操作系统。

Docker和虚拟机的差异体现在：docker是一个系统进程，而虚拟机是在操作系统中的操作系统；docker体积小、启动速度快、性能好；虚拟机体积大、启动速度慢、性能一般。

#### 镜像和容器 ####

**镜像（Image）**：Docker将应用程序及其所需的依赖、函数库、环境、配置等文件打包在一起，称为镜像。

**容器（Container）**：镜像中的应用程序运行后形成的进程就是容器，只是Docker会给容器做隔离，对外不可见。

**镜像**，就是把一个应用在硬盘上的文件、及其运行环境、部分系统函数库文件一起打包形成的文件包。这个文件包是只读的。**容器**就是将这些文件中编写的程序、函数加载到内存中运行，形成进程，只不过要隔离起来。因此一个镜像可以启动多次，形成多个容器进程。

#### **DockerHub** ####

DockerHub是一个官方的Docker镜像的托管平台。这样的平台称为Docker Registry。国内也有类似于DockerHub 的公开服务，比如 [网易云镜像服务][Link 1]、[阿里云镜像库][Link 2]等。我们不仅可以将自己的镜像共享到DockerHub，也可以从DockerHub拉取镜像。

#### **Docker架构** ####

Docker是一个CS架构的程序，由两部分组成：

服务端(server)：Docker守护进程，负责处理Docker指令，管理镜像、容器等

客户端(client)：通过命令向Docker服务端发送指令。可以在本地或远程向服务端发送指令。

### **Docker的基本操作** ###

#### **镜像名称** ####

镜像名称一般分两部分组成：\[repository\]:\[tag\]。在没有指定tag时，默认是latest，代表最新版本的镜像。例如：**mysql:5.7，**mysql就是repository，5.7就是tag，合一起就是镜像名称，代表5.7版本的MySQL镜像。

#### **镜像命令** ####

拉取镜像：docker pull xxx(镜像名称

查看拉取到的镜像：docker images

![2af8da0136864ba48a873636bb5bf2b1.png][]

**善于查看帮助文档：**

**查看docker帮助文档**：docker --helper

**查看xxx命令用法**，可以输入命令：docker xxx --help

例如，查看save命令用法，可以输入命令：

docker save --help

![af9558419cc54d29beac42dbdf4c8a71.png][]

命令格式：

docker save -o \[保存的目标文件名称\] \[镜像名称\]

使用docker save**导出镜像到磁盘** ：（举例）

docker save -o nginx.tar nginx:latest

**加载本地文件**：

docker load -i 文件名称

**删除本地的镜像**：

docker rmi 镜像名称

**进入容器执行命令**docker exec

**查看容器运行日志**docker logs

**查看所有运行的容器及状态**docker ps

docker run：创建并运行一个容器，处于运行状态

docker pause：让一个运行的容器暂停

docker unpause：让一个容器从暂停状态恢复运行

docker stop：停止一个运行的容器

docker start：让一个停止的容器再次运行

docker rm：删除一个容器

**举例1：**

创建并运行nginx容器的命令：

docker run --name mn -p 80:80 -d nginx

docker run ：创建并运行一个容器

\--name : 给容器起一个名字，比如叫做mn

\-p ：将宿主机端口与容器端口映射，冒号左侧是宿主机端口，右侧是容器端口。默认情况下，容器是隔离环境，我们直接访问宿主机的80端口，肯定访问不到容器中的nginx。现在，将容器的80与宿主机的80关联起来，当我们访问宿主机的80端口时，就会被映射到容器的80，这样就能访问到nginx了：

\-d：后台运行容器

nginx：镜像名称，例如nginx

**举例2：**

进入刚刚创建的nginx容器的命令为：

docker exec -it mn bash

docker exec ：进入容器内部，执行一个命令

\-it : 给当前进入的容器创建一个标准输入、输出终端，允许我们与容器交互

mn ：要进入的容器的名称

bash：进入容器后执行的命令，bash是一个linux终端交互命令

**docker run命令的常见参数:**

*  \--name：指定容器名称

*  \-p：指定端口映射

*  \-d：让容器后台运行

**查看容器日志的命令：**

*  docker logs

*  添加 -f 参数可以持续查看日志

**查看容器状态：**

*  docker ps

*  docker ps -a 查看所有容器，包括已经停止的

**删除容器：**

docker rm

不能删除运行中的容器，除非添加 -f 参数

### **数据卷（容器数据管理）** ###

#### **创建和查看数据卷** ####

**数据卷（volume）**是一个虚拟目录，指向宿主机文件系统中的某个目录。一旦完成数据卷挂载，对容器的一切操作都会作用在数据卷对应的宿主机目录了。

数据卷操作的基本语法如下：

docker volume \[COMMAND\]

docker volume命令是数据卷操作，根据命令后跟随的command来确定下一步的操作：

create 创建一个volume

inspect 显示一个或多个volume的信息

ls 列出所有的volume

prune 删除未使用的volume

rm 删除一个或多个指定的volume

**示例：**

1.创建数据卷

docker volume create html

2.查看所有数据

docker volume ls

3.查看数据卷详细信息卷

docker volume inspect html

![Image 1][]

可以看到，我们创建的html这个数据卷关联的宿主机目录为/var/lib/docker/volumes/html/\_data目录。

#### **挂载数据卷** ####

示例1：在创建容器时，可以通过 -v 参数来挂载一个数据卷到某个容器内目录，命令格式如下：

docker run \
      --name mn \
      -v html:/root/html \
      -p 8080:80
      nginx \

\-v html:/root/htm：把html数据卷挂载到容器内的/root/html这个目录中

示例2：**给nginx挂载数据卷**

创建容器并挂载数据卷到容器内的HTML目录：

docker run --name mn -v html:/usr/share/nginx/html -p 80:80 -d nginx

示例3：

容器不仅仅可以挂载数据卷，也可以直接挂载到宿主机目录上。关联关系如下：

带数据卷模式：宿主机目录 --> 数据卷 ---> 容器内目录

直接挂载模式：宿主机目录 ---> 容器内目录

目录挂载与数据卷挂载的语法是类似的：

\-v \[宿主机目录\]:\[容器内目录\]

\-v \[宿主机文件\]:\[容器内文件\]

docker run \
      --name mysql_xy \
      -e MYSQL_ROOT_PASSWORD=1234 \
      -p 3306:3306 \
      -v /tmp/mysql/conf/hmy.cnf:/etc/mysql/conf.d/hmy.cnf \
      -v /tmp/mysql/data:/var/lib/mysql \
      -d  \
      mysql:5.7.25

### **Dockerfile自定义镜像** ###

常见的镜像在DockerHub就能找到，但是我们自己写的项目就必须自己构建镜像了。

更多信息请移步到官网： [https://docs.docker.com/engine/reference/builder][https_docs.docker.com_engine_reference_builder]

构建自定义的镜像时，并不需要一个个文件去拷贝，打包。只需要告诉Docker，我们的镜像的组成，需要哪些BaseImage、需要拷贝什么文件、需要安装什么依赖、启动脚本是什么，将来Docker会帮助我们构建镜像。而描述上述信息的文件就是**Dockerfile文件**。

**Dockerfile**就是一个文本文件，其中包含一个个的**指令(Instruction)**，用指令来说明要执行什么操作来构建镜像。**每一个指令都会形成一层Layer**。

示例：**基于java8构建Java项目**

1.新建一个空的目录，然后在目录中新建一个文件，命名为Dockerfile

2.拷贝项目jar包到这个目录中

3. 编写Dockerfile文件：

a ）基于java:8-alpine作为基础镜像

b ）将app.jar拷贝到镜像中

c ）暴露端口

d ）编写入口ENTRYPOINT

FROM java:8-alpine
    COPY ./app.jar /tmp/app.jar
    EXPOSE 8090
    ENTRYPOINT java -jar /tmp/app.jar

4.使用docker build命令构建镜像

5.使用docker run创建容器并运行

小结：Dockerfile的本质是一个文件，通过指令描述镜像的构建过程；Dockerfile的第一行必须是FROM，从一个基础镜像来构建，基础镜像可以是基本操作系统，如Ubuntu。也可以是其他人制作好的镜像，例如：java:8-alpine

### **Docker-Compose** ###

![207123e0dbdc4d4ea6b5af5c2a4c618d.png][]

Docker Compose可以基于Compose文件帮我们快速的部署分布式应用，而无需手动一个个创建和运行容器。

#### **DockerCompose** ####

Compose文件是一个文本文件，通过指令定义集群中的每个容器如何运行。

示例：

version: "3.8"
     services:
      mysql:
        image: mysql:5.7.25
        environment:
         MYSQL_ROOT_PASSWORD: 123 
        volumes:
         - "/tmp/mysql/data:/var/lib/mysql"
         - "/tmp/mysql/conf/hmy.cnf:/etc/mysql/conf.d/hmy.cnf"
      web:
        build: .
        ports:
         - "8090:8090"

上面的Compose文件就描述了一个项目，其中包含两个容器：

mysql：一个基于mysql:5.7.25镜像构建的容器，并且挂载了两个目录

web：一个基于docker build临时构建的镜像容器，映射端口时8090

DockerCompose的详细语法参考官网：[https://docs.docker.com/compose/compose-file/][https_docs.docker.com_compose_compose-file]

其实DockerCompose文件可以看做是将多个docker run命令写到一个文件中的。

#### **安装DockerCompose** ####

1.Linux下需要通过命令下载：（下载速度较慢），或者也可以找别人下载好的直接上传到/usr/local/bin/目录也可以。

# 安装
    curl -L https://github.com/docker/compose/releases/download/1.23.1/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose

2.修改文件权限：

# 修改权限
    chmod +x /usr/local/bin/docker-compose

3.Base自动补全命令：

# 补全命令
    curl -L https://raw.githubusercontent.com/docker/compose/1.29.1/contrib/completion/bash/docker-compose > /etc/bash_completion.d/docker-compose
    
    # 如果出现错误，需要修改自己的hosts文件
    echo "199.232.68.133 raw.githubusercontent.com" >> /etc/hosts

#### **Docker镜像仓库** ####

搭建镜像仓库可以基于Docker官方提供的DockerRegistry来实现。

官网地址：[https://hub.docker.com/\_/registry][https_hub.docker.com_registry]

我们的私服采用的是http协议，默认不被Docker信任，所以需要做一个配置：

# 打开要修改的文件
    vi /etc/docker/daemon.json
    # 添加内容：
    "insecure-registries":["http://101.42.252.223:8080"]
    # 重加载
    systemctl daemon-reload
    # 重启docker
    systemctl restart docker

使用DockerCompose部署带有图象界面的DockerRegistry，命令如下：

version: '3.0'
    services:
      registry:
        image: registry
        volumes:
          - ./registry-data:/var/lib/registry
      ui:
        image: joxit/docker-registry-ui:static
        ports:
          - 8080:80
        environment:
          - REGISTRY_TITLE=我的私有仓库
          - REGISTRY_URL=http://registry:5000
        depends_on:
          - registry

### **部署微服务集群** ###

示例：

一、创建文件夹，里面每一个微服务都要单独创建一个目录，同级目录编写docker-compose文件

version: "3.2"
    
    services:
      nacos:
        image: nacos/nacos-server
        environment:
          MODE: standalone
        ports:
          - "8848:8848"
      mysql:
        image: mysql:5.7.25
        environment:
          MYSQL_ROOT_PASSWORD: 123
        volumes:
          - "$PWD/mysql/data:/var/lib/mysql"
          - "$PWD/mysql/conf:/etc/mysql/conf.d/"
      userservice:
        build: ./user-service
      orderservice:
        build: ./order-service
      gateway:
        build: ./gateway
        ports:
          - "10010:10010"

可以看到，其中包含5个service服务：

nacos：作为注册中心和配置中心

image: nacos/nacos-server： 基于nacos/nacos-server镜像构建

environment：环境变量

MODE: standalone：单点模式启动

ports：端口映射，这里暴露了8848端口

mysql：数据库

image: mysql:5.7.25：镜像版本是mysql:5.7.25

environment：环境变量

MYSQL\_ROOT\_PASSWORD: 1234：设置数据库root账户的密码为1234

volumes：数据卷挂载，这里挂载了mysql的data、conf目录。

userservice、orderservice、gateway：都是基于Dockerfile临时构建的

二、修改自己的项目，将数据库、nacos地址都命名为docker-compose中的服务名

三、使用maven打包工具，将项目中的每个微服务都打包为app.jar

四、将打包好的app.jar拷贝到每一个对应的子目录中

五、将项目上传至虚拟机，利用 docker-compose up -d 来部署

### **关于搭建私有镜像仓库的**推送、拉取镜像 ###

推送镜像到私有镜像服务必须先tag，步骤如下：

一、重新tag本地镜像，名称前缀为私有仓库的地址：192.xxx.xxx.xxx:8080/

docker tag nginx:latest 192.xxx.xxx.xxx:8080/nginx:1.0

二、推送镜像

docker push 192.xxx.xxx.xxx:8080/nginx:1.0

三、拉取镜像

docker pull 192.xxx.xxx.xxx:8080/nginx:1.0

[https_hub.docker.com]: https://hub.docker.com/
[Link 1]: https://c.163yun.com/hub
[Link 2]: https://cr.console.aliyun.com/
[2af8da0136864ba48a873636bb5bf2b1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/091e757641b54ed1b4c597581a0c2974.png
[af9558419cc54d29beac42dbdf4c8a71.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/294305f5c459470bae7d07c09124bfb2.png
[Image 1]: 
[https_docs.docker.com_engine_reference_builder]: https://docs.docker.com/engine/reference/builder
[207123e0dbdc4d4ea6b5af5c2a4c618d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/9139e6a899a94f838c6aaa7641e9a68a.png
[https_docs.docker.com_compose_compose-file]: https://docs.docker.com/compose/compose-file/
[https_hub.docker.com_registry]: https://hub.docker.com/_/registry