docker 介绍

什么是docker

• Docker 是一个Go语言开发实现的开源应用容器引擎
• 分为 CE（Community Edition: 社区版） 和 EE（Enterprise Edition: 企业版）
• Docker 和传统虚拟化方式的不同之处。传统虚拟机技术是虚拟出一套硬件后，在其上运行一个完整操作系统，在该系统上再运行所需应用进程；而容器内的应用进程直接运行于宿主的内核，容器内没有自己的内核，而且也没有进行硬件虚拟。因此容器要比传统虚拟机更为轻便

为什么需要使用docker

更高效的利用系统资源

• 由于容器不需要进行硬件虚拟以及运行完整操作系统等额外开销，Docker 对系统资源的利用率更高。无论是应用执行速度、内存损耗或者文件存储速度，都要比传统虚拟机技术更高效。因此，相比虚拟机技术，一个相同配置的主机，往往可以运行更多数量的应用

更快速的启动时间

• 传统的虚拟机技术启动应用服务往往需要数分钟，而 Docker 容器应用，由于直接运行于宿主内核，无需启动完整的操作系统，因此可以做到秒级、甚至毫秒级的启动时间。大大的节约了开发、测试、部署的时间。

一致的运行环境

• 开发过程中一个常见的问题是环境一致性问题。由于开发环境、测试环境、生产环境不一致，导致有些 bug 并未在开发过程中被发现。而 Docker 的镜像提供了除内核外完整的运行时环境，确保了应用运行环境一致性，从而不会再出现 「这段代码在我机器上没问题啊」 这类问题。

持续交付和部署

• 对开发和运维（DevOps）人员来说，最希望的就是一次创建或配置，可以在任意地方正常运行。
• 使用 Docker 可以通过定制应用镜像来实现持续集成、持续交付、部署。开发人员可以通过 Dockerfile 来进行镜像构建，并结合 持续集成(Continuous Integration) 系统进行集成测试，而运维人员则可以直接在生产环境中快速部署该镜像，甚至结合 持续部署(Continuous Delivery/Deployment) 系统进行自动部署

更轻松的迁移

• 由于 Docker 确保了执行环境的一致性，使得应用的迁移更加容易。Docker 可以在很多平台上运行，无论是物理机、虚拟机、公有云、私有云，甚至是笔记本，其运行结果是一致的。因此用户可以很轻易的将在一个平台上运行的应用，迁移到另一个平台上，而不用担心运行环境的变化导致应用无法正常运行的情况。

更轻松的维护和扩展

• Docker 使用的分层存储以及镜像的技术，使得应用重复部分的复用更为容易，也使得应用的维护更新更加简单，基于基础镜像进一步扩展镜像也变得非常简单。此外，Docker 团队同各个开源项目团队一起维护了一大批高质量的 官方镜像，既可以直接在生产环境使用，又可以作为基础进一步定制，大大的降低了应用服务的镜像制作成本。

对比传统虚拟机总结

特性	容器	虚拟机
启动	秒级	分钟级
硬盘使用	一般为 MB	一般为 GB
性能	接近原生	弱于
系统支持量	单机支持上千个容器	一般几十个

docker的架构

Docker 使用客户端-服务器 (C/S) 架构模式，使用远程 API 来管理和创建 Docker 容器。

Docker 容器通过 Docker 镜像来创建。

容器与镜像的关系类似于面向对象编程中的对象与类。

Docker	面向对象
容器	对象
镜像	类

• 架构中的名词说明

名词	说明
镜像(Images)	Docker 镜像是用于创建 Docker 容器的模板。
容器(Container)	容器是独立运行的一个或一组应用。
客户端(Client)	Docker 客户端通过命令行或者其他工具使用 Docker API (docs.docker.com/reference/a…) 与 Docker 的守护进程通信。
主机(Host)	一个物理或者虚拟的机器用于执行 Docker 守护进程和容器。
仓库(Registry)	Docker 仓库用来保存镜像，可以理解为代码控制中的代码仓库。Docker Hub(hub.docker.com) 提供了庞大的镜像集合供使用。
Docker Machine	Docker Machine是一个简化Docker安装的命令行工具，通过一个简单的命令行即可在相应的平台上安装Docker，比如VirtualBox、 Digital Ocean、Microsoft Azure。

docker的安装

使用脚本的方式安装

执行安装脚本

$ curl -fsSL https://get.docker.com -o get-docker.sh
$ sudo sh get-docker.sh

启动 docker 进程

sudo systemctl enable docker
sudo systemctl start docker 

为docker配置镜像加速器

• 在 /etc/docker/daemon.json 中写入如下内容（如果文件不存在请新建该文件）

{
  "registry-mirrors": [
    "https://registry.docker-cn.com"
  ]
}

• 重新启动服务

$ sudo systemctl daemon-reload
$ sudo systemctl restart docker

• 检查加速器是否生效 配置加速器之后，如果拉取镜像仍然十分缓慢，请手动检查加速器配置是否生效，在命令行执行 docker info，如果从结果中看到了如下内容，说明配置成功。

Registry Mirrors:
 https://registry.docker-cn.com/

docker的卸载

• 先查询安装过的包

yum list installed | grep docker

• 移除docker相关的包

yum -y remove 上面列出来的包

镜像的使用

获取镜像

之前提到过，Docker Hub 上有大量的高质量的镜像可以用，这里我们就说一下怎么获取这些镜像。

从 Docker 镜像仓库获取镜像的命令是 docker pull。其命令格式为：

docker pull [选项] [Docker Registry 地址[:端口号]/]仓库名[:标签]

具体的选项可以通过 docker pull --help 命令看到，这里我们说一下镜像名称的格式。

• Docker 镜像仓库地址：地址的格式一般是 <域名/IP>[:端口号]。默认地址是 Docker Hub。
• 仓库名：如之前所说，这里的仓库名是两段式名称，即 <用户名>/<软件名>。对于 Docker Hub，如果不给出用户名，则默认为 library，也就是官方镜像。

docker pull ubuntu:16.04
16.04: Pulling from library/ubuntu
bf5d46315322: Pull complete
9f13e0ac480c: Pull complete
e8988b5b3097: Pull complete
40af181810e7: Pull complete
e6f7c7e5c03e: Pull complete
Digest: sha256:147913621d9cdea08853f6ba9116c2e27a3ceffecf3b492983ae97c3d643fbbe
Status: Downloaded newer image for ubuntu:16.04

上面的命令中没有给出 Docker 镜像仓库地址，因此将会从 Docker Hub 获取镜像。而镜像名称是 ubuntu:16.04，因此将会获取官方镜像 library/ubuntu 仓库中标签为 16.04 的镜像。

从下载过程中可以看到我们之前提及的分层存储的概念，镜像是由多层存储所构成。下载也是一层层的去下载，并非单一文件。下载过程中给出了每一层的 ID 的前 12 位。并且下载结束后，给出该镜像完整的 sha256 的摘要，以确保下载一致性。

在使用上面命令的时候，你可能会发现，你所看到的层 ID 以及 sha256 的摘要和这里的不一样。这是因为官方镜像是一直在维护的，有任何新的 bug，或者版本更新，都会进行修复再以原来的标签发布，这样可以确保任何使用这个标签的用户可以获得更安全、更稳定的镜像。

列出镜像

镜像列表

要想列出已经下载下来的镜像，有两个命令。

docker images

或者

docker image ls

结果如下

REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
ubuntu              16.04               2a697363a870        38 hours ago        119MB
tomcat              latest              27600aa3d7f1        8 days ago          463MB
ubuntu              <none>              a3551444fc85        2 weeks ago         119MB

列表包含了 仓库名、标签、镜像 ID、创建时间 以及 所占用的空间。

镜像体积

如果仔细观察，会注意到，这里标识的所占用空间和在 Docker Hub 上看到的镜像大小不同。比如，ubuntu:16.04 镜像大小，在这里是 127 MB，但是在 Docker Hub 显示的却是 50 MB。这是因为 Docker Hub 中显示的体积是压缩后的体积。在镜像下载和上传过程中镜像是保持着压缩状态的，因此 Docker Hub 所显示的大小是网络传输中更关心的流量大小。而 docker image ls 显示的是镜像下载到本地后，展开的大小，准确说，是展开后的各层所占空间的总和，因为镜像到本地后，查看空间的时候，更关心的是本地磁盘空间占用的大小。

另外一个需要注意的问题是，docker image ls 列表中的镜像体积总和并非是所有镜像实际硬盘消耗。由于 Docker 镜像是多层存储结构，并且可以继承、复用，因此不同镜像可能会因为使用相同的基础镜像，从而拥有共同的层。由于 Docker 使用 Union FS，相同的层只需要保存一份即可，因此实际镜像硬盘占用空间很可能要比这个列表镜像大小的总和要小的多。

你可以通过以下命令来便捷的查看镜像、容器、数据卷所占用的空间。

docker system df
TYPE                TOTAL               ACTIVE              SIZE                RECLAIMABLE
Images              3                   1                   700.2MB             237.5MB (33%)
Containers          2                   0                   65.95kB             65.95kB (100%)
Local Volumes       0                   0                   0B                  0B
Build Cache         0                   0                   0B                  0B

虚悬镜像

上面的镜像列表中，还可以看到一个特殊的镜像，这个镜像标签为 none

ubuntu              <none>              a3551444fc85        2 weeks ago         119MB

这个镜像原本是有镜像名和标签的, 镜像发布新版本后，重新docker pull的时候， 这个镜像名被转移到了新下载的镜像身上， 而旧的镜像上的这个名称则被取消，从而成为了 。除了 docker pull 可能导致这种情况，docker build 也同样可以导致这种现象。由于新旧镜像同名，旧镜像名称被取消，从而出现仓库名、标签均为 的镜像。这类无标签镜像也被称为 虚悬镜像(dangling image) ，可以用下面的命令专门显示这类镜像：

docker images -f dangling=true

中间层镜像

为了加速镜像构建、重复利用资源，Docker 会利用 中间层镜像。所以在使用一段时间后，可能会看到一些依赖的中间层镜像。默认的 docker image ls 列表中只会显示顶层镜像，如果希望显示包括中间层镜像在内的所有镜像的话，需要加 -a 参数。

docker images -a

列出部分镜像

不加任何参数的情况下，docker images 会列出所有顶级镜像，但是有时候我们只希望列出部分镜像。docker image ls 有好几个参数可以帮助做到这个事情。

• 根据仓库名列出镜像

docker images ubuntu
ubuntu              16.04               2a697363a870        38 hours ago        119MB
ubuntu              <none>              a3551444fc85        2 weeks ago         119MB

• 列出特定的某个镜像，也就是说指定仓库名和标签

docker images ubuntu:16.04
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
ubuntu              16.04               2a697363a870        38 hours ago        119MB

删除镜像

如果要删除本地的一个镜像，可以使用 docker image rm 命令，其格式为：

• 删除一个镜像

docker image rm [选项] <镜像1> [<镜像2> ...]

或者

docker rmi [选项] <镜像1> [<镜像2> ...]

• 删除全部镜像

docker image prune

其中，<镜像> 可以是 镜像短 ID、镜像长 ID、镜像名 或者 镜像摘要。<> 代表必须参数，[] 代表可选参数

定制镜像

dockerfile定制镜像

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

这里以定制 tomcat 镜像为例，我们使用 Dockerfile 来定制自己的tomcat

• 运行一个tomcat容器出来

docker run -p 8080:8080 tomcat 

• 新开xshell窗口，以交互的方式进入刚刚启动的容器

 docker exec -it f208e826caf2 bash

• 更改/webapps/Root 目录中的 index.jsp，再后面追加一段内容

cd webapps/ROOT
echo "hello docker tomcat" >> index.jsp

以上我们对原来的tomcat容器做了修改，但没有更改镜像，导致每次启动一个容器，都要进入容器进行修改。如果直接修改镜像，那么只会跑起来的容器都不在需要一一修改。

现在创建一个Dockerfile 文件来构建我们自己的镜像

cd /usr/local

mkdir -p docker/mytomcat

cd docker/mytomcat

• 编写Dockerfile 脚本构建镜像

vi Dockerfile

• 写入脚本

FROM tomcat

WORKDIR /usr/local/tomcat/webapps/ROOT/
RUN rm -rf *
RUN echo "hello docker tomcat" > /usr/local/tomcat/webapps/ROOT/index.html

FROM tomcat: 选定基础镜像为tomcat WORKDIR /usr/local/tomcat/webapps/ROOT/：指定工作目录，进入到这个目录 RUN rm -rf * ： 删除当前目录所有文件 RUN echo "hello docker tomcat" > /usr/local/tomcat/webapps/ROOT/index.html： 写入一个index.html文件到当前目录

• 构建镜像 进入到Dockerfile 所在目录

docker build -t mytomcat .

mytomcat为你要构建的镜像的标签名 . 表示当前目录。

好了，现在已经构建好我们自己的tomcat镜像了。运行起来

• 运行定制镜像

docker run -p 8080:8080 mytomcat

Dockerfile 命令详解

FROM

• 功能为指定基础镜像，并且必须是第一条指令。，那么写法为：FROM scratch。同时意味着接下来所写的指令将作为镜像的第一层开始

RUN

功能为运行指定的命令

RUN命令有两种格式

1. RUN
2. RUN ["executable", "param1", "param2"] 第一种后边直接跟shell命令

在linux操作系统上默认 /bin/sh -c

在windows操作系统上默认 cmd /S /C

第二种是类似于函数调用。

可将executable理解成为可执行文件，后面就是两个参数。

两种写法比对：

RUN /bin/bash -c 'source HOME RUN ["/bin/bash", "-c", "echo hello"] 注意：多行命令不要写多个RUN，原因是Dockerfile中每一个指令都会建立一层.

多少个RUN就构建了多少层镜像，会造成镜像的臃肿、多层，不仅仅增加了构件部署的时间，还容易出错。

RUN书写时的换行符是\

COPY

看这个名字就知道，又是一个复制命令

语法如下：

1. COPY ...
2. COPY ["",... ""] 与ADD的区别

COPY的只能是本地文件，其他用法一致

ADD

一个复制命令，把文件复制到景象中。

如果把虚拟机与容器想象成两台linux服务器的话，那么这个命令就类似于scp，只是scp需要加用户名和密码的权限验证，而ADD不用。

语法如下：

1. ADD ...
2. ADD ["",... ""]

路径的填写可以是容器内的绝对路径，也可以是相对于工作目录的相对路径

可以是一个本地文件或者是一个本地压缩文件，还可以是一个url

如果把写成一个url，那么ADD就类似于wget命令

如果把的文件是个tar.gz包， 发送之后就会自动解压缩。

容器的使用

启动容器

简单启动

docker run -p 8081:8080 tomcat 

• run:启动一个容器，启动一个容器即启动了一个进程

• -p: 指定端口， 第一个参数为宿主机的端口，第二个参数为docker容器的端口。意思是把宿主机8081端口映射到容器中的8080端口上， 我们直接访问宿主机的8081端口就能直接访问到8080

• tomcat:镜像名

守护态启动

也就是后台运行，不占用主线程，不会被日志卡住在主线程。

docker run -d -p 8080:8080 tomcat

• -d:以守护态启动容器

这种方式启动后， 只会返回一个完整的容器Id， 要查看启动时输出的日志使用以下命令查看:

docker container logs 容器Id

进入已经启动的容器

docker exec -it 容器Id bash

• exec:进入
• -it: 交互模式
• bash:命令行

进入容器后， 有些linux 命令会不能使用，比如ll、vi,因为tomcat这个镜像是基于最简单的linux构建的。

列出容器

docker container ls -a

或者

docker ps -a

终止容器

docker container stop

删除容器

docker container rm 容器Id

或者

docker container prune 

删除所有处于终止状态的容器

docker container prune

容器数据持久化

一个容器销毁后， 容器里面的数据也就丢失了。 如何把容器中的数据和宿主机之间做读取，做到容器中的数据持久化呢， 这就是容器数据的持久化，需要使用到docker的数据卷。

数据卷是一个可供一个或多个容器使用的特殊目录，它绕过 UFS，可以提供很多有用的特性：

• 数据卷 可以在容器之间共享和重用
• 对 数据卷 的修改会立马生效
• 对 数据卷 的更新，不会影响镜像
• 数据卷 默认会一直存在，即使容器被删除

下面运行一个tomcat容器， 把ROOT 目录指定为宿主机上的目录

• 在宿主机的root目录下新建一个目录ROOT

mkdir ROOT

• 在ROOT目录中创建一个index.html文件

cd /ROOT 

vi index.html

内容为 hello I am domain , this is index.html in volume

• 启动一个挂载数据卷的容器

docker run -d -p 8081:8080 -v /root/ROOT:/usr/local/tomcat/webapps/ROOT tomcat 

-v： 第一个参数表示宿主机的目录，第二个参数表示容器中的目录，意思是把容器中的ROOT 目录替换为宿主机中ROOT目录

浏览器中访问 8081 端口就能看到 刚刚宿主机中index.html中的内容了。

可以查看容器中数据卷的信息:

docker inspect 容器Id

数据卷 信息在 "Mounts" Key 下面

容器部署mysql数据库

• 拉取mysql镜像

不指定标签，默认从官网拉取最新的mysql镜像

docker pull mysql

• 启动容器

带数据卷启动容器

docker run -p 3306:3306 --name mysql \
-v /usr/local/docker/mysql/logs:/var/log/mysql \
-v /usr/local/docker/mysql/data:/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=123456 \
-d mysql

下面是每行参数的意思
-v /usr/local/docker/mysql/logs:/var/log/mysql: 挂载日志文件，左边宿主机目录， 右边容器目录。
-v /usr/local/docker/mysql/data:/var/lib/mysql:挂载 数据文件。
-e MYSQL_ROOT_PASSWORD=123456：通过环境变量设置root用户的密码

docker-compose

Compose 项目是 Docker 官方的开源项目，负责实现对 Docker 容器集群的快速编排。

Compose 中有两个重要的概念：

服务 (service)：一个应用的容器，实际上可以包括若干运行相同镜像的容器实例。
项目 (project)：由一组关联的应用容器组成的一个完整业务单元，在 docker-compose.yml 文件中定义。

Compose 的默认管理对象是项目，通过子命令对项目中的一组容器进行便捷地生命周期管理。

docker-compose 的安装卸载

这里使用二进制包的方式来安装和卸载

安装

从github上面下载安装并给docker-compose命令执行权限

curl -L https://github.com/docker/compose/releases/download/1.17.1/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose
chmod +x /usr/local/bin/docker-compose

卸载

删除二进制文件即可。

rm /usr/local/bin/docker-compose

docker-compose 使用

docker-compose 部署项目

这里通过docker-compose来启动一个项目，启动项目需要启动两个容器， 一个tomcat,一个mysql。 这就是前面说的服务组成项目。

docker-compose是通过docker-compose.yml 文件来构建的 .

• 在部署目录 创建编写一个docker-compose.yml文件

cd /usr/local/docker

mkdir myshop

cd myshop

vi docker-compose.yml


version: '3'
services: 
  tomcat:
    restart: always
    image: 'tomcat'
    container_name: tomcat
    ports:
      - 8080:8080
    volumes:
      - /usr/local/docker/myshop/ROOT:/usr/local/tomcat/webapps/ROOT

  mysql:
    restart: always
    image: mysql
    container_name: mysql
    ports:
      - 3306:3306
    environment:
      TZ: Asia/Shanghai
      MYSQL_ROOT_PASSWORD: 123456
    command:
      --character-set-server=utf8mb4
      --collation-server=utf8mb4_general_ci
      --explicit_defaults_for_timestamp=true
      --lower_case_table_names=1
      --max_allowed_packet=128M
    volumes:
      - mysql-data:/var/lib/mysql

volumes:
  mysql-data:

这里配置了两个服务， 两个服务都使用了数据卷, tomcat中的使用数据卷是常见的格式: 宿主机目录:容器目录,mysql中使用的是 统一管理数据卷的方式, 使用docker分配的宿主机目录，而不是自己指定。下面是配置中的意思:

- mysql-data:/var/lib/mysql: 左边宿主机目录名，右边是容器目录，然后在下面volumes节点下声明这个宿主机目录

volumes:
  mysql-data:

• docker-compose 启动项目 在当前docker-compose.yml文件所在目录，执行启动命令

docker-compose up -d

-d 表示以守护态运行，不占用操作系统主线程,不在主线程输出日志。

• docker-compose 停止项目 在当前docker-compose.yml文件所在目录，执行启动命令

docker-compose down

• docker-compose 查看日志

那么以守护态运行后，怎么查看日志？通过以下命令:

docker-compose logs

docker-compose 部署mysql

version: '3.1'
services:
  db:
    image: mysql
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: 123456
    command:
      --default-authentication-plugin=mysql_native_password
      --character-set-server=utf8mb4
      --collation-server=utf8mb4_general_ci
      --explicit_defaults_for_timestamp=true
      --lower_case_table_names=1
    ports:
      - 3306:3306
    volumes:
      - ./data:/var/lib/mysql

  adminer:
    image: adminer
    restart: always
    ports:
      - 8080:8080

docker-compose 安装 GitLab

通过docker-compos 来部署一个 git 托管平台，非常的方便。

在/usr/local/docker/gitlab 目录下创建一个docker-compose.yml配置文件，内容如下:

version: '3'
services:
    web:
      image: 'twang2218/gitlab-ce-zh'
      restart: always
      hostname: '192.168.65.130'
      environment:
        TZ: 'Asia/Shanghai'
        GITLAB_OMNIBUS_CONFIG: |
          external_url 'http://192.168.65.130:8080'
          gitlab_rails['gitlab_shell_ssh_port'] = 2222
          unicorn['port'] = 8888
          nginx['listen_port'] = 8080
      ports:
        - '8080:8080'
        - '8443:443'
        - '2222:22'
      volumes:
        - /usr/local/docker/gitlab/config:/etc/gitlab
        - /usr/local/docker/gitlab/data:/var/opt/gitlab
        - /usr/local/docker/gitlab/logs:/var/log/gitlab

下面是每个节点属性的意思:

• restart:每次启动都重启容器
• hostname:主机名，就是当前宿主机的ip
• environment:环境变量，用来设置一些初始化的数据
• TZ:时区
• GITLAB_OMNIBUS_CONFIG:gitlab的一些配置
• external_url:外部访问地址
• gitlab_rails：git ssh 端口
• unicorn：内部端口
• nginx：nginx 监听端口，需要和上面的外部访问端口一致
• ports:宿主机和容器之间的映射端口， 左边宿主机端口，右边容器端口
• volumes:数据卷目录， 左边宿主机目录，右边容器目录

去到官网搜索镜像gitlab-ce-zh,拉取镜像:

docker pull twang2218/gitlab-ce-zh

在docker-compose.yml文件所在目录， 执行启动命令:

docker-compose up 

容器很大， 启动时间较长， 需要等待一段时间。启动成功后，提示修改密码，这里修改的是root的密码。 修改完后就可以使用 root 账号和刚刚修改的密码登录啦。

docker-compose 搭建私服

Nexus 是一个强大的仓库管理器,部署后，可以把自己的sdk上传这里。 配置后即可拉取使用

• 在/usr/local/docker/nexus3目录下，创建docker-compose.yml配置文件,内容如下:

version: '3.1'
services:
  nexus:
    restart: always
    image: sonatype/nexus3
    container_name: nexus
    ports:
      - 8081:8081
    volumes:
      - /usr/local/docker/nexus3/data:/nexus-data

• 启动 在当前目录 启动 nexus3 容器:

docker-compose up

启动报错， 没有IO权限，通过更改当前目录的data目录权限解决:

chmod 777 data

把之前的容器关闭，再重新启动:

docker-compose down
docker-compose up

在项目中使用私服

• 在 Maven settings.xml 中添加 Nexus 认证信息(servers 节点下)：

<server>
  <id>nexus-releases</id>
  <username>admin</username>
  <password>admin123</password>
</server>

<server>
  <id>nexus-snapshots</id>
  <username>admin</username>
  <password>admin123</password>
</server>

• 配置自动化部署

在 pom.xml 中添加如下代码：

<distributionManagement>  
  <repository>  
    <id>nexus-releases</id>  
    <name>Nexus Release Repository</name>  
    <url>http://192.168.65.130:8081/repository/maven-releases/</url>  
  </repository>  
  <snapshotRepository>  
    <id>nexus-snapshots</id>  
    <name>Nexus Snapshot Repository</name>  
    <url>http://192.168.65.130:8081/repository/maven-snapshots/</url>  
  </snapshotRepository>  
</distributionManagement> 

这里的id需和上面节点中定义的id一致,url为nexus中browse拷贝对应版本的url

• 部署到仓库

mvn deploy

• 上传第三方 JAR 包 Nexus 3.0 不支持页面上传，可使用 maven 命令：

# 如第三方JAR包：aliyun-sdk-oss-2.2.3.jar
mvn deploy:deploy-file 
  -DgroupId=com.aliyun.oss 
  -DartifactId=aliyun-sdk-oss 
  -Dversion=2.2.3 
  -Dpackaging=jar 
  -Dfile=D:\aliyun-sdk-oss-2.2.3.jar 
  -Durl=http://127.0.0.1:8081/repository/maven-3rd/ 
  -DrepositoryId=nexus-releases

注意事项：

• 建议在上传第三方 JAR 包时，创建单独的第三方 JAR 包管理仓库，便于管理有维护（maven-3rd）。
• -DrepositoryId=nexus-releases 对应的是 settings.xml 中 Servers 配置的 ID 名称。（授权）
• 项目拉取依赖的顺序为: 本地->私服->官服

仓库的使用

综合实战