Docker Compose 编排与 Harbor 私有仓库

前言

实际开发和部署中，一个完整的应用很少只靠单个容器就能跑起来------比如一个网站，得有负责展示页面的 Web 服务、存储数据的数据库、处理缓存的中间件，这些组件各自需要一个容器，还得让它们互相配合工作。另外，企业里的镜像文件往往包含核心代码，不能随便放在公共仓库，需要一个安全的地方存储、管理，还得控制谁能看、谁能改。

这时候就需要两个"神器"：Docker Compose 能帮我们把多个容器"打包"成一个项目，一键启动、停止，不用逐个操作；Harbor 则是企业级的私有镜像仓库，比官方的 Registry 功能强太多，有网页管理界面、能控制权限，还能扫描镜像漏洞。

这篇文章就用最通俗的语言，带你一步步搞定这两个工具，每个步骤都有具体命令，跟着做就能上手。

一、Docker Compose 编排

Docker Compose 是 Docker 官方出的工具，专门用来管理多个容器。简单说，它能把一堆相互依赖的容器（比如 Nginx+Tomcat+MySQL）当成一个"整体项目"来管，不用你手动敲一堆 docker run 命令，一条命令就能搞定所有容器的启动、停止。

1.1 Docker Compose 简介

1.1.1 核心概念

Compose 里有三个关键概念，理解了就好上手：

工程（Project）：就是你存放配置文件的文件夹，里面的 docker-compose.yml 和相关文件合起来叫一个工程，默认用文件夹名当工程名。
服务（Service）：一个工程里的每个组件就是一个服务，比如 Nginx 服务、Tomcat 服务，一个服务可以对应多个容器实例。
容器（Container）：服务跑起来后的实际实例，比如启动 Nginx 服务后，会生成一个 Nginx 容器，这是应用真正运行的载体。

注意：Compose 不管负载均衡，如果需要多个容器分担压力，得配合 Nginx 这类工具。

1.1.2 Compose 的核心价值

简化配置：所有容器的配置都写在一个 docker-compose.yml 文件里，不用记一堆命令。
控制依赖：比如必须先启动数据库，再启动应用，用 depends_on 就能搞定，不会出现"应用启动了，数据库还没好"的问题。
跨平台能用：不管是 Linux、Windows 还是 macOS，只要装了 Docker，就能用 Compose。

1.1.3 核心配置文件

默认配置文件叫 docker-compose.yml，如果想自定义文件名，有两种方式：

用环境变量：export COMPOSE_FILE=我的配置文件.yml
用命令行参数：docker-compose -f 我的配置文件.yml up

1.2 Docker Compose 环境安装

Compose 需要单独安装，下面给两种版本，选一个适合自己的就行：

1.2.1 基础版本安装（1.21.1 版本，多数 Linux 能用）

bash 复制代码

# 1. 下载 Compose 到系统可执行目录
curl -L https://github.com/docker/compose/releases/download/1.21.1/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose

# 2. 给文件加执行权限
chmod +x /usr/local/bin/docker-compose

# 3. 验证是否安装成功，显示版本号就没问题
docker-compose --version

1.2.2 高版本安装（2.26.0 版本，适用于 aarch64 架构，比如 ARM 服务器）

bash 复制代码

# 下载高版本二进制文件
sudo curl -L "https://github.com/docker/compose/releases/download/2.26.0/docker-compose-linux-aarch64" -o /usr/local/bin/docker-compose

# 加执行权限
sudo chmod +x /usr/local/bin/docker-compose

# 验证
docker-compose --version

1.3 YAML 文件格式及编写注意事项

docker-compose.yml 是 Compose 的核心，它用 YAML 格式写的。YAML 很简洁，比 JSON 好读，但有几个严格的规则，必须遵守。

1.3.1 YAML 基本语法（重点）

大小写敏感：image 和 Image 是两个不同的配置项，不能写错。
缩进用空格：不能用 TAB 键，推荐用 2 个空格当一个缩进层级。
列表用 - 开头：比如列出多个语言：- Java - Golang - Python。
字典用 : 连接：键和值之间必须加一个空格，比如 cpu: 2。
注释用 #：# 这是注释，注释内容不会被解析。

语法示例（YAML vs JSON）

YAML 格式（简洁易读）：

yaml 复制代码

languages:  # 列表（对应 JSON 数组）
  - Java
  - Golang
  - Python
resources:  # 字典（对应 JSON 对象）
  cpu: 2
  memory: 1024M
debug: true  # 布尔值

对应的 JSON 格式（对比一下，YAML 更清爽）：

json 复制代码

{
  "languages": ["Java", "Golang", "Python"],
  "resources": {
    "cpu": "2",
    "memory": "1024M"
  },
  "debug": true
}

1.3.2 Docker Compose 常用配置字段

下面是最常用的配置字段，用表格说明，一看就懂：

字段	描述
image	指定用哪个镜像，比如 `nginx:latest`
build	自己构建镜像时用，指定 Dockerfile 所在目录
command	覆盖容器默认执行的命令，比如让 Nginx 前台运行
container_name	给容器起个名字，比如 `web-nginx`
ports	端口映射，格式 `宿主机端口:容器端口`，比如 `8080:80`
volumes	挂载宿主机目录或数据卷，比如把本地文件夹挂到容器里存数据
environment	设置容器内的环境变量，比如 `MYSQL_ROOT_PASSWORD=123456`
depends_on	定义依赖关系，比如 `depends_on: - mysql` 表示先启动 mysql 再启动当前服务
networks	让容器加入指定网络，方便容器之间通信
restart	容器重启策略，比如 `always` 表示容器退出就自动重启

1.3.3 Docker Compose 常用命令

这些命令是日常操作的核心，记下来就行：

命令	描述
docker-compose up -d	创建并启动所有服务，`-d` 表示后台运行
docker-compose down	停止并删除所有容器、网络（加 `-v` 会删除数据卷）
docker-compose ps	查看工程里所有容器的状态
docker-compose logs	查看所有服务的日志（加 `-f` 能实时跟踪）
docker-compose exec 服务名命令	在指定服务的容器里执行命令，比如 `docker-compose exec nginx bash` 进入 Nginx 容器
docker-compose build	重新构建服务的镜像（如果 Dockerfile 改了）
docker-compose start/stop/restart	启动/停止/重启所有服务

1.3.4 典型 Docker Compose 工程文件结构

以"Nginx + Tomcat"为例，推荐这样的目录结构，清晰又好维护：

复制代码

/opt/compose_nginx_tomcat/  # 工程根目录
├── docker-compose.yml      # Compose 核心配置文件
├── nginx                   # Nginx 相关文件
│   ├── Dockerfile          # 构建 Nginx 镜像的文件
│   └── nginx.conf          # Nginx 配置文件（反向代理用）
├── tomcat                  # Tomcat 相关文件
│   ├── Dockerfile          # 构建 Tomcat 镜像的文件
│   └── webapps             # Tomcat 应用目录，放 WAR 包
└── wwwroot                 # 静态资源目录，Nginx 挂载用
    └── index.html          # 静态页面

1.3.5 YAML 配置实操示例（Nginx 服务）

我们先从简单的 Nginx 服务入手，练手熟悉配置：

步骤 1：准备依赖文件

bash 复制代码

# 1. 创建工程目录和子目录
mkdir -p /opt/compose_nginx/nginx /opt/compose_nginx/wwwroot
cd /opt/compose_nginx/nginx

# 2. 下载 Nginx 源码包（可以从官网下，这里假设已经下载好放在当前目录）
# 如果你没有源码包，也可以直接用官方镜像，跳过这步和 Dockerfile 里的编译步骤

# 3. 写一个 Nginx 启动脚本（run.sh）
vim run.sh
# 脚本内容：/usr/local/nginx/sbin/nginx （启动 Nginx）
chmod 755 run.sh  # 给脚本加执行权限

# 4. 写 Dockerfile（构建 Nginx 镜像）
vim Dockerfile
# 文件内容：
FROM centos:7  # 基础镜像用 CentOS 7
MAINTAINER "test <test@example.com>"  # 维护者信息，随便写

# 安装依赖包
RUN rm -rf /etc/yum.repos.d/*
ADD CentOS-Base.repo /etc/yum.repos.d/  # 提前准备好 CentOS 的 YUM 源文件
RUN yum clean all && yum makecache && \
    yum -y install pcre-devel zlib-devel gcc gcc-c++ make && \
    useradd -M -s /sbin/nologin nginx  # 创建 Nginx 专用用户

# 解压并安装 Nginx
ADD nginx-1.20.2.tar.gz /usr/local/src/
WORKDIR /usr/local/src/nginx-1.20.2
RUN ./configure \
--prefix=/usr/local/nginx \
--user=nginx \
--group=nginx && \
make && make install

# 配置环境变量，方便直接执行 nginx 命令
ENV PATH /usr/local/nginx/sbin:$PATH

# 暴露 80 和 443 端口
EXPOSE 80
EXPOSE 443

# 让 Nginx 前台运行（Docker 容器需要前台进程才不会退出）
ENTRYPOINT ["/usr/local/nginx/sbin/nginx", "-g", "daemon off;"]

# 5. 准备一个静态页面
echo "<h1>Hello Docker Compose!</h1>" > /opt/compose_nginx/wwwroot/index.html

步骤 2：编写 docker-compose.yml

bash 复制代码

vim /opt/compose_nginx/docker-compose.yml
# 文件内容：
version: '3'  # Compose 版本，和 Docker 兼容就行
services:
  nginx:  # 服务名，自定义
    container_name: web-nginx  # 容器名
    hostname: nginx-host  # 容器主机名
    build:
      context: ./nginx  # Dockerfile 所在目录
      dockerfile: Dockerfile  # Dockerfile 文件名
    ports:
      - 1216:80  # 宿主机 1216 端口映射到容器 80 端口
    volumes:
      - ./wwwroot:/usr/local/nginx/html  # 把本地 wwwroot 挂到容器的静态资源目录
    networks:
      lnmp:
        ipv4_address: 172.18.0.10  # 给容器分配固定 IP

# 定义自定义网络
networks:
  lnmp:
    driver: bridge
    ipam:
      config:
        - subnet: 172.18.0.0/16  # 子网

步骤 3：启动并验证服务

bash 复制代码

# 进入工程目录
cd /opt/compose_nginx/

# 启动服务（后台运行）
docker-compose up -d

# 查看容器状态，看到 STATUS 是 Up 就成功了
docker-compose ps

# 验证：打开浏览器，输入 http://你的服务器IP:1216，能看到 "Hello Docker Compose!"

1.3.6 编写注意事项

路径是相对的：context 和 volumes 里的路径，都是相对于 docker-compose.yml 文件所在的目录，别写绝对路径，不然换个地方就用不了。
缩进别错了：services 下面的服务要缩进 2 个空格，服务里的字段（比如 build、ports）再缩进 2 个空格，错了会解析失败。
依赖只是启动顺序：depends_on 只能保证"先启动依赖的服务"，不能保证"依赖的服务已经完全就绪"（比如数据库启动后还得初始化），复杂场景可以写个脚本等服务就绪。
端口别冲突：ports 里的宿主机端口如果被其他程序占用，服务会启动失败，换个没被用的端口就行。

1.4 Nginx 反向代理配置（对接 Tomcat）

实际应用中，Nginx 常用来当反向代理，把用户的请求转发给 Tomcat 处理。我们基于上面的工程，新增 Tomcat 服务：

1.4.1 创建工程目录

bash 复制代码

# 复制之前的 Nginx 工程，改成新工程
cp -r /opt/compose_nginx/ /opt/compose_nginx_tomcat
cd /opt/compose_nginx_tomcat/
mkdir tomcat  # 创建 Tomcat 相关目录

1.4.2 编辑 Nginx 配置文件

bash 复制代码

vim /opt/compose_nginx_tomcat/nginx/nginx.conf
# 配置反向代理，添加以下内容：
server {
    listen 80;
    server_name localhost;

    location / {
        # 转发请求到 Tomcat 服务（compose 里服务名能直接解析成 IP）
        proxy_pass http://tomcat:8080;
        # 传递用户真实 IP 和请求头，不然 Tomcat 会以为请求来自 Nginx
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }
}

1.4.3 编写 Tomcat 的 Dockerfile

bash 复制代码

# 1. 把 JDK 和 Tomcat 源码包上传到 /opt/compose_nginx_tomcat/tomcat 目录
# 比如 jdk-8u91-linux-x64.tar.gz 和 apache-tomcat-8.5.35.tar.gz

# 2. 编写 Dockerfile
vim /opt/compose_nginx_tomcat/tomcat/Dockerfile
# 文件内容：
FROM centos:7
MAINTAINER "test <test@example.com>"

# 安装 JDK
ADD jdk-8u91-linux-x64.tar.gz /usr/local/
WORKDIR /usr/local/
RUN mv jdk1.8.0_91 /usr/local/java
# 配置 Java 环境变量
ENV JAVA_HOME /usr/local/java
ENV JRE_HOME ${JAVA_HOME}/jre
ENV CLASSPATH .:${JAVA_HOME}/lib:${JRE_HOME}/lib
ENV PATH $JAVA_HOME/bin:$PATH

# 安装 Tomcat
ADD apache-tomcat-8.5.35.tar.gz /usr/local/
WORKDIR /usr/local/
RUN mv apache-tomcat-8.5.35 /usr/local/tomcat

# 暴露 8080 端口
EXPOSE 8080

# 启动 Tomcat
ENTRYPOINT ["/usr/local/tomcat/bin/catalina.sh", "run"]

1.4.4 编写 Nginx+Tomcat 的 docker-compose.yml

bash 复制代码

vim /opt/compose_nginx_tomcat/docker-compose.yml
# 文件内容：
version: '3'
services:
  # Nginx 服务（反向代理）
  nginx:
    build:
      context: ./nginx
    ports:
      - "8081:80"  # 宿主机 8081 端口映射到 Nginx 80 端口
    volumes:
      - ./wwwroot:/usr/share/nginx/html
      - ./nginx/nginx.conf:/etc/nginx/conf.d/default.conf  # 挂载反向代理配置
    networks:
      - app_network
    depends_on:
      - tomcat  # 先启动 Tomcat

  # Tomcat 服务
  tomcat:
    build:
      context: ./tomcat
    ports:
      - "8080:8080"  # 宿主机 8080 端口映射到 Tomcat 8080 端口
    networks:
      - app_network
    environment:
      # 优化 Java 性能，避免随机数生成阻塞
      - JAVA_OPTS=-Djava.security.egd=file:/dev/./urandom

# 自定义网络，让两个服务能通信
networks:
  app_network:
    driver: bridge

1.4.5 启动 Nginx+Tomcat 服务

bash 复制代码

# 进入工程目录
cd /opt/compose_nginx_tomcat/

# 启动服务
docker-compose up -d

# 查看日志，确认没报错
docker-compose logs -f

# 验证：浏览器访问 http://你的服务器IP:8081，会自动转发到 Tomcat，看到 Tomcat 默认页面

二、Docker-Harbor 私有仓库部署与管理

Docker 官方的 Registry 仓库功能太简单了，没有网页界面，不能控制谁能上传下载，企业用着不方便。Harbor 是 VMware 开源的企业级私有仓库，解决了这些问题，还能扫描镜像漏洞、同步镜像到其他仓库，特别实用。

2.1 搭建基础 Docker Registry 私有仓库

在学 Harbor 之前，先了解下基础的 Registry 仓库，知道私有仓库的基本工作原理：

2.1.1 下载 Registry 镜像

Registry 是 Docker 官方提供的基础仓库镜像，直接下载就行：

bash 复制代码

docker pull registry  # 拉取最新版

2.1.2 配置 Docker 守护进程（支持不安全仓库）

Docker 默认要求仓库用 HTTPS 通信，但基础 Registry 是 HTTP 的，所以得配置 Docker 允许访问"不安全的仓库"：

bash 复制代码

# 编辑 Docker 配置文件
vim /etc/docker/daemon.json

# 添加以下内容（替换成你的服务器 IP）
{
  "insecure-registries": ["192.168.10.14:5000"],  # 允许 HTTP 访问这个仓库
  "registry-mirrors": ["https://ae3f5qei.mirror.aliyuncs.com"]  # 阿里云镜像加速器，下载更快
}

# 重启 Docker 让配置生效
systemctl daemon-reload
systemctl restart docker.service

2.1.3 运行 Registry 容器（持久化存储）

bash 复制代码

docker run -itd \
  -v /data/registry:/var/lib/registry \  # 把镜像数据存在宿主机 /data/registry，容器删了数据也在
  -p 5000:5000 \                        # 宿主机 5000 端口映射到容器 5000 端口
  --restart=always \                    # 容器退出自动重启
  --name registry \                     # 容器名
  registry:latest                       # 用的镜像

2.1.4 Docker 容器重启策略补充

除了 always，还有几种常用的重启策略，根据需求选：

no：默认，容器退出不重启。
on-failure：只有容器非正常退出（比如报错）才重启。
on-failure:3：非正常退出最多重启 3 次。
unless-stopped：除非手动停止容器，否则退出就重启。

2.1.5 镜像标签、上传与下载测试

步骤 1：为本地镜像打标签

上传镜像到私有仓库前，得给镜像贴个"标签"，格式是 仓库地址/镜像名:标签：

bash 复制代码

# 示例：给本地的 centos:7 镜像打标签（替换成你的仓库 IP）
docker tag centos:7 192.168.10.14:5000/centos:v1

步骤 2：上传镜像到私有仓库

bash 复制代码

docker push 192.168.10.14:5000/centos:v1

步骤 3：查看私有仓库中的镜像

用 curl 命令调用仓库 API，查看里面有哪些镜像：

bash 复制代码

curl http://192.168.10.14:5000/v2/_catalog
# 输出类似 {"repositories":["centos"]}，说明有 centos 镜像

步骤 4：查看镜像的所有标签

bash 复制代码

curl http://192.168.10.14:5000/v2/centos/tags/list
# 输出类似 {"name":"centos","tags":["v1"]}，说明 centos 有 v1 标签

步骤 5：从私有仓库拉取镜像

先删除本地的 centos 镜像，再从仓库拉取，验证是否能正常下载：

bash 复制代码

# 删除本地镜像
docker rmi -f centos:7 192.168.10.14:5000/centos:v1

# 从仓库拉取
docker pull 192.168.10.14:5000/centos:v1

# 查看镜像，确认拉取成功
docker images | grep centos

2.2 Harbor 简介

2.2.1 什么是 Harbor

Harbor 是基于 Docker Registry 扩展的企业级私有镜像仓库，所有组件都用容器运行，通过 Compose 一键部署。它解决了官方 Registry 的痛点，比如没有 UI、没有权限控制、没有漏洞扫描等。

2.2.2 Harbor 核心特性

有网页管理界面：不用记命令，打开浏览器就能管理镜像、用户。
能控制权限：可以创建管理员、开发人员、访客等角色，不同人有不同操作权限（比如开发能上传，访客只能下载）。
支持 LDAP/AD 集成：能和企业现有的用户系统对接，不用重新创建用户。
镜像复制：能把一个 Harbor 里的镜像同步到另一个 Harbor，比如北京的镜像同步到上海，方便跨地区部署。
漏洞扫描：自动扫描镜像里的安全漏洞，告诉你哪些镜像有风险。
操作日志：所有操作都有记录，比如谁上传了镜像、谁删除了镜像，方便审计。

2.2.3 Harbor 架构（六大核心组件）

Harbor 由 6 个核心组件组成，各自分工明确，用 Compose 协同工作：

Proxy：反向代理，所有请求都先经过它，再转发到对应的组件。
Registry：存储镜像的核心，负责处理镜像的上传、下载。
Core Services：核心服务，包括网页 UI、权限验证（Token 服务）、镜像状态通知（Webhook）。
Database：存储 Harbor 的配置、用户信息、镜像元数据等。
Job Services：处理异步任务，比如镜像复制、清理过期镜像。
Log Collector：收集所有组件的日志，方便查看和排查问题。

2.2.4 Harbor 数据流向

用户通过浏览器或 Docker 客户端（比如 docker push）发起请求。
Proxy 把请求转发到对应的组件（比如 UI 请求转发到网页服务，镜像请求转发到 Registry）。
Registry 收到请求后，会验证用户的 Token（权限），没 Token 就去 Core Services 申请。
核心服务处理业务逻辑，比如 UI 展示镜像列表，Job Services 同步镜像。
镜像数据存在 Registry，配置和元数据存在 Database。
所有操作日志都被 Log Collector 收集起来。

2.3 部署 Harbor 服务

2.3.1 安装 Docker Compose（前置依赖）

Harbor 用 Compose 部署，所以先确保已经安装了 Compose（参考 1.2 节）。

2.3.2 下载 Harbor 离线安装包

Harbor 提供离线安装包，里面包含所有依赖镜像，没有外网也能安装：

bash 复制代码

# 下载 Harbor 2.4.0 离线包（可以去官网找最新版本）
wget https://github.com/goharbor/harbor/releases/download/v2.4.0/harbor-offline-installer-v2.4.0.tgz

# 解压到 /usr/local/ 目录
tar zxvf harbor-offline-installer-v2.4.0.tgz -C /usr/local/

2.3.3 修改 Harbor 配置文件

bash 复制代码

# 进入 Harbor 目录
cd /usr/local/harbor/

# 复制默认配置文件（备份一下）
cp harbor.yml harbor.yml.bak

# 编辑配置文件
vim harbor.yml

# 修改以下关键参数（根据你的环境改）
hostname: 192.168.10.14  # Harbor 的 IP 或域名，不能用 localhost
harbor_admin_password: Harbor12345  # 管理员初始密码，默认是 admin/Harbor12345
http:
  port: 80  # HTTP 端口，默认 80

配置文件参数说明

必需参数：必须在 harbor.yml 里设置，改了之后要执行 ./prepare 再重启 Harbor 才生效，比如 hostname（Harbor 的地址）、ui_url_protocol（HTTP/HTTPS）。
可选参数：可以默认不变，也能在启动 Harbor 后通过网页 UI 修改，比如 harbor_admin_password（管理员密码，只在第一次启动生效）、self_registration（是否允许用户自行注册）。

2.3.4 启动 Harbor 服务

bash 复制代码

# 1. 生成启动所需的配置文件和证书
./prepare

# 2. 安装并启动 Harbor 所有组件
./install.sh

常见启动错误解决

如果启动时报 iptables: No chain/target/match by that name 错误，重启防火墙就行：

bash 复制代码

systemctl restart firewalld.service
# 重新启动 Harbor
docker-compose up -d

2.3.5 查看 Harbor 启动状态

bash 复制代码

# 进入 Harbor 目录
cd /usr/local/harbor/

# 查看所有组件的状态，都是 Up 就说明启动成功
docker-compose ps

2.3.6 图形化界面创建项目

步骤 1：登录 Harbor Web 界面

打开浏览器，输入 http://你的HarborIP，用默认账号密码登录：

用户名：admin
密码：Harbor12345（或你在配置文件里改的密码）

步骤 2：创建项目

登录后点击右上角"+ 项目"。
填写项目名称（比如 myproject-dev），选择"私有"（只有授权用户能访问）。
点击"确定"，项目就创建好了。

步骤 3：本地测试镜像上传（Harbor 服务器本地）

bash 复制代码

# 1. 登录 Harbor（本地登录用 127.0.0.1，不用配置不安全仓库）
docker login http://127.0.0.1

# 2. 下载一个测试镜像（比如 nginx）
docker pull nginx

# 3. 给镜像打标签，格式：HarborIP/项目名/镜像名:标签
docker tag nginx:latest 127.0.0.1/myproject-dev/nginx:v1

# 4. 上传镜像到 Harbor
docker push 127.0.0.1/myproject-dev/nginx:v1

# 5. 验证：回到 Harbor 网页，进入 myproject-dev 项目，能看到上传的 nginx:v1 镜像

2.4 客户端上传(下载)镜像到 Harbor

其他机器（比如开发机）要上传镜像到 Harbor，需要先配置 Docker 客户端：

2.4.1 配置 Docker 客户端

bash 复制代码

# 1. 编辑 Docker 服务配置文件
vim /usr/lib/systemd/system/docker.service

# 2. 修改 ExecStart 字段，添加 --insecure-registry（替换成你的 Harbor IP）
ExecStart=/usr/bin/dockerd -H fd:// --insecure-registry 192.168.10.14 --containerd=/run/containerd/containerd.sock

# 3. 重启 Docker 服务
systemctl daemon-reload
systemctl restart docker

2.4.2 客户端上传(下载)镜像操作

bash 复制代码

# 1. 登录 Harbor
docker login -u admin -p Harbor12345 http://192.168.10.14

# 2. 下载 Harbor 里的镜像
docker pull 192.168.10.14/myproject-dev/nginx:v1

# 3. 上传自己的镜像
docker pull cirros  # 下载一个测试镜像
docker tag cirros:latest 192.168.10.14/myproject-dev/cirros:v1
docker push 192.168.10.14/myproject-dev/cirros:v1

# 4. 验证：回到 Harbor 网页，能看到新上传的 cirros:v1 镜像

2.5 维护管理 Harbor

2.5.1 通过 Harbor Web 创建项目

和 2.3.6 步骤一样，点击"+ 项目"，填写名称，选择"公共"或"私有"：

公共项目：所有人都能下载镜像，不用登录。
私有项目：只有授权用户才能上传、下载。

2.5.2 创建用户与分配权限

步骤 1：创建用户

登录 Harbor 网页，点击左侧"系统管理"->"用户管理"。
点击"+ 用户"，填写用户名（比如 zhangsan）、邮箱、密码（比如 Abc123456），角色选"普通用户"。
点击"确定"，用户创建成功。

步骤 2：为项目分配用户权限

进入项目（比如 myproject-dev），点击"成员"->"+ 成员"。
搜索刚创建的用户 zhangsan，分配角色为"开发人员"（能上传、下载镜像）。
点击"确定"，权限分配完成。

步骤 3：客户端使用普通用户操作镜像

bash 复制代码

# 1. 退出之前的 admin 登录
docker logout 192.168.10.14

# 2. 用普通用户登录
docker login -u zhangsan -p Abc123456 http://192.168.10.14

# 3. 下载镜像（验证读权限）
docker pull 192.168.10.14/myproject-dev/cirros:v1

# 4. 上传镜像（验证写权限）
docker tag cirros:latest 192.168.10.14/myproject-dev/cirros:v2
docker push 192.168.10.14/myproject-dev/cirros:v2

# 5. 验证：Harbor 网页里能看到 cirros:v2 镜像

2.5.3 查看操作日志

点击左侧"系统管理"->"日志"，能看到所有用户的操作记录，比如谁上传了镜像、谁删除了镜像、谁创建了用户。
可以按时间、操作类型、用户名筛选，方便审计和排查问题。

2.5.4 修改 Harbor 配置（harbor.yml）

如果要修改 Harbor 配置，比如改端口、改管理员密码，按以下步骤来：

bash 复制代码

# 1. 停止 Harbor 服务
cd /usr/local/harbor/
docker-compose down -v

# 2. 修改配置文件
vim harbor.yml

# 3. 重新生成配置
./prepare

# 4. 重启 Harbor
docker-compose up -d

2.5.5 Harbor 数据迁移（保留镜像与配置）

如果要把 Harbor 从一台服务器迁移到另一台，按以下步骤：

步骤 1：停止源服务器 Harbor 服务

bash 复制代码

cd /usr/local/harbor/
docker-compose down -v

步骤 2：打包源服务器数据

Harbor 的镜像数据存在 /data/registry，数据库数据存在 /data/database：

bash 复制代码

# 打包镜像数据
tar zcvf harbor-registry.tar.gz /data/registry/*

# 打包数据库数据（保留用户、项目配置）
tar zcvf harbor-db.tar.gz /data/database/*

步骤 3：将数据包传输到目标服务器

用 scp 命令把打包的文件传到新服务器：

bash 复制代码

scp harbor-registry.tar.gz root@目标服务器IP:/opt/
scp harbor-db.tar.gz root@目标服务器IP:/opt/

步骤 4：目标服务器恢复数据

bash 复制代码

# 1. 在目标服务器部署 Harbor（参考 2.3 节，版本要和源服务器一致）
# 2. 停止目标服务器 Harbor 服务
cd /usr/local/harbor/
docker-compose down -v

# 3. 删除目标服务器的默认数据
rm -rf /data/registry/*
rm -rf /data/database/*

# 4. 解压数据包到对应目录
tar zxvf /opt/harbor-registry.tar.gz -C /data/registry/
tar zxvf /opt/harbor-db.tar.gz -C /data/database/

# 5. 重新初始化并启动 Harbor
./prepare
./install.sh

# 验证：登录目标服务器的 Harbor 网页，能看到源服务器的镜像、用户和项目

总结

Docker Compose 和 Harbor 是 Docker 生态里的"黄金搭档"：

Docker Compose 解决了"多容器协同部署"的问题，把复杂的启动命令写成简单的 YAML 配置，一键就能启动整个应用，大大提升了部署效率。
Harbor 解决了"企业级镜像管理"的问题，有界面、有权限控制、能扫描漏洞，让镜像存储更安全、管理更规范。