

![在这里插入图片描述](https://developer.qcloudimg.com/http-save/yehe-11458826/cd3e9037f08090dce126ed7de5dc14cf.png)

# 本篇摘要
<font color="#DCF0045" size="4" face="楷体">**本文基于Dockerfile实战搭建Redis集群与C++微服务，详解多阶段构建、镜像优化及Nginx负载均衡配置，并解析虚悬镜像与中间层镜像的核心区别与处理方法。**</font>





# 一.基于`dockerfile`构建`redis`集群

在这里插入图片描述

![在这里插入图片描述](https://developer.qcloudimg.com/http-save/yehe-11458826/f104dd5ae9ee1879de3313d7a6584d08.png)
- 下面通过容器化技术搭建6个redis的集群；然后第七个redis把他们够成集群后退出。



**`搭建过程结构：`**





```mermaid
graph TD
    A[下载配置redis集群] --> B[编写dockerfile制作镜像]
    B --> C[启动容器测试镜像能否正常运行]
    C --> D[编写集群docker-compose.yml]
    D --> E[启动集群]
    E --> F[测试功能-清理资源]
```



首先下载对应源码：

[**Redis源码包**](http://download.redis.io/releases/redis-%207.0.11.tar.gz)


然后本地解压拿到对应的conf文件：


![在这里插入图片描述](https://developer.qcloudimg.com/http-save/yehe-11458826/f90aea3015ffff72fd46bb18a932a00e.png)
- 修改成集群相关配置。


**`修改如下:`**

1.  **安全认证设置**
    *   **`requirepass 123456`**：设置客户端连接密码为 `123456`。
    *   **`masterauth 123456`**：设置主从节点间同步数据的认证密码，与连接密码一致，确保集群内部通信安全。

2.  **网络与连接设置**
    *   **`bind * -::*`**：允许所有 IPv4 和 IPv6 地址连接，这是实现**远程访问**和**集群节点间通信**的关键。
    *   **`port 6379`**：保持默认服务端口。

3.  **集群模式配置**
    *   **`cluster-enabled yes`**：启用集群模式，这是核心开关。
    *   **`cluster-config-file nodes.conf`**：指定集群节点配置文件，由 Redis 自动生成和维护，记录集群状态。
    *   **`cluster-node-timeout 5000`**：设置节点超时时间（5秒），用于判断节点是否故障。

4.  **数据与运行设置**
    *   **`dir /data/redis`**：指定数据持久化文件（如 RDB、AOF）的存储目录。
    *   **`daemonize no`**：配置为**前台运行**，这是为了**适配 Docker 容器**的最佳实践。容器需要一个前台进程来保持运行，否则会立即退出。


![在这里插入图片描述](https://developer.qcloudimg.com/http-save/yehe-11458826/54b4cc26dffdf9c5e354155489f7fc59.png)
- 对应文件拖转进来。


**`对应目录结构：`**

```bash
root@iv-ye1i2elts0wh2yp1ahah:/home/youxing/docker-learn/master_slave/rediscluster# tree
.
├── docker-compose.yml
└── redis
    ├── dockerfile
    ├── redis-7.0.11.tar.gz
    └── redis.conf

1 directory, 4 files

```

下面看下对应的dockerfile文件：

```cpp
# 构建阶段：编译Redis
FROM ubuntu:22.04 as buildstage

# 替换阿里云源并更新
RUN sed -i 's@//.*archive.ubuntu.com@//mirrors.aliyun.com@g' /etc/apt/sources.list && \
    apt-get update

# 安装编译工具
RUN apt-get install -y build-essential

# 添加Redis源码和配置
ADD redis-7.0.11.tar.gz /
ADD redis.conf /redis/

# 编译Redis
WORKDIR /redis-7.0.11
RUN make

# 移动编译好的文件
RUN mv src/redis-server /redis/ && \
    mv src/redis-cli /redis/

# 运行阶段：生产镜像
FROM ubuntu:22.04

# 安装运行时依赖
RUN apt-get update && \
    apt-get install -y --no-install-recommends \
    libc6 && \
    rm -rf /var/lib/apt/lists/*

# 创建目录
RUN mkdir -p /data/redis && \
    mkdir -p /redis

# 从构建阶段复制文件
COPY --from=buildstage /redis /redis

# 暴露端口
EXPOSE 6379

# 设置启动命令
ENTRYPOINT ["/redis/redis-server", "/redis/redis.conf"]
```
- 这里在第一个ubuntu环境进行解压下载编译等；得到可执行程序然后搞到第二个ubuntu里面（由于原先包解压自带对应运行环境，因此第二个容器还需要下对应环境）；实现了多级构建效果；大大减少了对应容器占用空间情况。


**`docker-compose.yml:`**


```cpp

services:
  redis01:
    image: myredis:v1.0
    build: ./redis
    container_name: redis01
    ports:
      - "6379:6379"
    healthcheck:
      test: ["CMD", "/redis/redis-cli", "ping"]
      interval: 10s
      timeout: 5s
      retries: 10

  redis02:
    image: myredis:v1.0
    container_name: redis02
    healthcheck:
      test: ["CMD", "/redis/redis-cli", "ping"]
      interval: 10s
      timeout: 5s
      retries: 10

  redis03:
    image: myredis:v1.0
    container_name: redis03
    healthcheck:
      test: ["CMD", "/redis/redis-cli", "ping"]
      interval: 10s
      timeout: 5s
      retries: 10

  redis04:
    image: myredis:v1.0
    container_name: redis04
    healthcheck:
      test: ["CMD", "/redis/redis-cli", "ping"]
      interval: 10s
      timeout: 5s
      retries: 10

  redis05:
    image: myredis:v1.0
    container_name: redis05
    healthcheck:
      test: ["CMD", "/redis/redis-cli", "ping"]
      interval: 10s
      timeout: 5s
      retries: 10

  redis06:
    image: myredis:v1.0
    container_name: redis06
    healthcheck:
      test: ["CMD", "/redis/redis-cli", "ping"]
      interval: 10s
      timeout: 5s
      retries: 10

  redis07:
    image: myredis:v1.0
    container_name: redis07
    entrypoint: >
      /redis/redis-cli --cluster create
      redis01:6379 redis02:6379 redis03:6379
      redis04:6379 redis05:6379 redis06:6379
      --cluster-replicas 1 -a 123456 --cluster-yes
    depends_on:
      redis01:
        condition: service_healthy
      redis02:
        condition: service_healthy
      redis03:
        condition: service_healthy
      redis04:
        condition: service_healthy
      redis05:
        condition: service_healthy
      redis06:
        condition: service_healthy
```

- 之前build的镜像搞6个redis容器（也可以使用docker compose build直接构建+启动）；然后再让第七个把他们搞成集群服务再退出。


==**演示下效果：**==


![在这里插入图片描述](https://developer.qcloudimg.com/http-save/yehe-11458826/a6ffb8359e19efda17335668da0d12c0.png)

![在这里插入图片描述](https://developer.qcloudimg.com/http-save/yehe-11458826/6a370cde1a953151cc67dfa973dd2997.png)
![在这里插入图片描述](https://developer.qcloudimg.com/http-save/yehe-11458826/61a69b3e28d92699bae5bc334f34ef95.png)

- 可以发现对应先启动123456全部健康后才启动的7。

![在这里插入图片描述](https://developer.qcloudimg.com/http-save/yehe-11458826/d6f9393ae93d2a7a63abd8a3dec4c800.png)
- 镜像构建成功+容器成功启动。

![在这里插入图片描述](https://developer.qcloudimg.com/http-save/yehe-11458826/06cfa81a94b87bc6dfeb10bb966fee1d.png)
- 可以成功插入数据；发现被重定向到对应槽位所在的主节点了。


![在这里插入图片描述](https://developer.qcloudimg.com/http-save/yehe-11458826/1b70f255a1bb5f6521d2463304b4c8ad.png)
- 主从关系也正常。


![在这里插入图片描述](https://developer.qcloudimg.com/http-save/yehe-11458826/9b902a5df4800b6adca8f04971f99e0a.png)
- 停止服务（先停止的7然后剩下的接着）。


# 二.基于dockerfile编写C++微服务

![在这里插入图片描述](https://developer.qcloudimg.com/http-save/yehe-11458826/75523803743efa047c9bc5ff6b38eb51.png)
- 基于nginx容器反向代理对应C++微服务：通过主机port映射到nginx容器的80端口；然后根据nginx的conf反向把对应请求发给对应同一compose网络里的cpp程序容器的8081端口；然后它就接收到请求把对应html发给nginx80端口；最后通过映射发给对应浏览器。


**`步骤如下：`**



```mermaid
graph TD
    A[1. 编写代码] --> B[2. 编写微服务Dockerfile]
    B --> C[3. 配置Nginx负载均衡<br>编写Nginx Dockerfile]
    C --> D[4. 编写docker-compose.yml<br>构建镜像]
    D --> E[5. 启动服务]
    E --> F[6. 测试功能]
```


**对应工程目录：**

```bash
root@iv-ye1i2elts0wh2yp1ahah:/home/youxing/docker-learn/C++_micro_server# tree
.
├── cppweb
│?? ├── dockerfile
│?? ├── main.cpp
│?? └── mycppweb
├── docker-compose.yml
└── nginx
    ├── default.conf
    └── dockerfile

2 directories, 6 files

```

**c++代码：**


```cpp
#include <iostream>
#include <netinet/in.h>
#include <string.h>
#include <assert.h>
#include <unistd.h>
#include <pthread.h>

using namespace std;

struct pthread_data {
    struct sockaddr_in client_addr;
    int sock_fd;
};

void *serverForClient(void *arg);

int main() {
    int socket_fd;
    int conn_fd;
    int res;
    socklen_t len = sizeof(sockaddr_in);

    struct sockaddr_in sever_add;
    memset(&sever_add, 0, sizeof(sever_add));
    sever_add.sin_family = AF_INET;
    sever_add.sin_port = htons(8081);
    sever_add.sin_addr.s_addr = htonl(INADDR_ANY);

    socket_fd = socket(AF_INET, SOCK_STREAM, 0);
    assert(socket_fd > 0);
    
    int option = 1;
    setsockopt(socket_fd, SOL_SOCKET, SO_REUSEADDR, &option, sizeof(option));

    res = bind(socket_fd, (struct sockaddr*)&sever_add, len);
    assert(res != -1);

    res = listen(socket_fd, 5);
    assert(res != -1);
    
    cout << "server init" << endl;

    while(1) {
        struct sockaddr_in client;
        socklen_t client_len = sizeof(client);
        
        conn_fd = accept(socket_fd, (struct sockaddr *)&client, &client_len);
        if (conn_fd < 0) {
            perror("accept");
            continue;
        }

        pthread_data *pdata = new pthread_data;
        pdata->client_addr = client;
        pdata->sock_fd = conn_fd;
        std::cout<<"in "<<conn_fd<<endl;
        pthread_t pt;
        pthread_create(&pt, NULL, serverForClient, (void*)pdata);
        pthread_detach(pt);
    }

    close(socket_fd);
    return 0;
}

void *serverForClient(void *arg) {
    pthread_data *pdata = (pthread_data*)arg;
    int conn_fd = pdata->sock_fd;
std::cout<<"process "<<conn_fd<<endl;
    char request[1024];
    int len = recv(conn_fd, request, sizeof(request)-1, 0);
    if (len <= 0) {
        close(conn_fd);
        delete pdata;
        return nullptr;
    }
    request[len] = '\0';

    const char* http_header = "HTTP/1.1 200 OK\r\n"
                            "Content-Type: text/html\r\n"
                            "Connection: close\r\n\r\n";
    
    send(conn_fd, http_header, strlen(http_header), 0);

    const char* html_content = "<!DOCTYPE html>\n"
                              "<html>\n"
                              "<head>\n"
                              "<title>Welcome to C++ web server!</title>\n"
                              "<style>\n"
                              "  body { width: 35em; margin: 0 auto;\n"
                              "  font-family: Tahoma, Verdana, Arial, sans-serif; }\n"
                              "</style>\n"
                              "</head>\n"
                              "<body>\n"
                              "<h1>Welcome to C++ web server!</h1>\n"
                              "<p>If you see this page, the web server is successfully working.</p>\n"
                              "</body>\n"
                              "</html>";
    
    send(conn_fd, html_content, strlen(html_content), 0);
    close(conn_fd);
    delete pdata;
    return nullptr;
}
```
- 这里绑定默认8081端口（如果容器里进行就绑定容器的8081端口）；然后接受到请求就发送对应html。

**默认nginx的conf：**


```cpp
# Nginx 负载均衡配置
upstream backend {
    server mycppweb:8081 weight=1;
    server mycppweb2:8081 weight=2;
}

server {
    listen 80;
    access_log off;
    
    location / {
        proxy_pass http://backend;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}
```
- 这里默认进行反向代理；当访问到它的80号端口就转向对应的名字为mycppweb的服务对应的容器的8081端口。




总的docker-compose.yml就是启动对应两服务三容器：

```cpp
services:
  web:
    image: mynginx:v3.0
    build:
      context: ./nginx
    ports:
      - "8112:80"
    depends_on:
      mycppweb:
        condition: service_started

  mycppweb:
    build:
      context: ./cppweb
    image: mycppweb:v2.0

  mycppweb2:
    image: mycppweb:v2.0

```

**`对于cpp服务的dockerfile的c++程序编译及运行还是采取多级构建进行只保留exe的容器j镜像构建：`**

```cpp
# 第一阶段：构建阶段（编译环境）
FROM ubuntu:22.04 as buildstage

# 配置国内软件源并更新
RUN sed -i 's@//.*archive.ubuntu.com@//mirrors.ustc.edu.cn@g' /etc/apt/sources.list && apt update

# 安装编译工具链
RUN apt install -y build-essential

# 设置工作目录并复制源码
WORKDIR /src
COPY ./main.cpp .

# 编译程序（链接pthread库）
RUN g++ main.cpp -o mycppweb -lpthread

# 指定运行时命令s
CMD ["/src/mycppweb"]

# 第二阶段：运行阶段（生产环境）
FROM ubuntu:22.04

# 从构建阶段仅复制最终可执行文件
COPY --from=buildstage /src/mycppweb /

# 指定容器启动命令
CMD ["/mycppweb"]
```

**下面启动下：**

![在这里插入图片描述](https://developer.qcloudimg.com/http-save/yehe-11458826/f195d6fce81c6eefcf233b073ef2acc0.png)
- 构建对应的镜像。


![在这里插入图片描述](https://developer.qcloudimg.com/http-save/yehe-11458826/68751284be3493f9e925fbafb467a8b2.png)
- 容器构建成功。

![在这里插入图片描述](https://developer.qcloudimg.com/http-save/yehe-11458826/ddc4fe148b0276f3d69025e9a0434ec1.png)
- 容器正常启动，下面进行访问（打开对应的cpp服务日志监控）。

![在这里插入图片描述](https://developer.qcloudimg.com/http-save/yehe-11458826/68aab33a28e4bf056a6dbcb8a14de162.png)

![在这里插入图片描述](https://developer.qcloudimg.com/http-save/yehe-11458826/27dfeace8b4cd570a49ba8552dc27ce7.png)
![在这里插入图片描述](https://developer.qcloudimg.com/http-save/yehe-11458826/48a5592642f1374780fb4f138c246fa8.png)
- 不停的访问对应网站；因为设置的是nginx根据web1:web2发送率是1:2的权重来进行请求分配；通过观察日志可以发现。



# 三.docker镜像制作常见问题




1.  **`ADD` vs `COPY：`**
    `ADD` 功能更强，能复制本地文件和解压远程URL资源；`COPY` 更安全透明，仅复制本地文件，是推荐做法。

2.  **`CMD` vs `ENTRYPOINT：`**
    `ENTRYPOINT` 定义容器启动后固定的执行命令，`CMD` 提供默认参数。两者组合使用，`ENTRYPOINT` 为命令，`CMD` 为参数，实现灵活与固定的平衡。

3.  **多阶段构建 (Multiple `FROM`)：**
    多个 `FROM` 指令用于多阶段构建。前期阶段（如编译环境）用于准备程序，后期阶段（如运行环境）仅复制所需文件，最终镜像只保留最后阶段内容，极大减小镜像体积。

4.  **Dockerfile 的优势：**
    相比直接制作快照（`docker commit`），Dockerfile 具备可追溯、可重复、可审计、易于自动化的巨大优势，是构建镜像的标准方式（比如commit的方法可能会产生一些无关文件包等放入镜像不进行清除；dockerfile避免了这点）。



5.  **虚悬镜像 (Dangling Images)：**
    
    指仓库名和标签均为 `<none>` 的镜像；主要因镜像更新覆盖旧标签或多次构建同名新镜像导致旧镜像失去名称：

![在这里插入图片描述](https://developer.qcloudimg.com/http-save/yehe-11458826/679b6d6c291666f480a64811662f5a27.png)


   - 此类镜像已无用，可安全删除。使用 `docker image ls -f dangling=true` 查看，并用 `prune` 命令清理。

6.  **中间层镜像 (Intermediate Layer Images)：**
    -   **定义**：是构建其他镜像时所依赖的、无标签的底层镜像；也就是本身整个镜像是`none none`；但是其他镜像构建时候使用了它的某一层的缓存；避免了冗余操作；也就是多个新镜像构建引用了这一层即共用。（`名称和标签也是none；注意与悬空镜像区分`）。
    -   **作用**：用于加速构建过程和复用资源，避免重复下载或编译。
    -   **特性**：不应手动删除，删除会导致上层镜像因依赖丢失而出错。其生命周期自动管理，依赖它的顶层镜像被删除后会自动清理。


==**区别：**==

| 特征 | **虚悬镜像 (Dangling Images)** | **中间层镜像 (Intermediate Layer Images)** |
| :--- | :--- | :--- |
| **状态** | **已废弃的顶层镜像**，是构建过程的“废料”，无任何镜像依赖它。 | **被依赖的底层镜像**，是构建过程的“积木”，有其他镜像依赖它。 |
| **成因** | 被新版本覆盖或重建同名镜像后，旧镜像失去名称。 | 是构建其他镜像时产生的依赖层，本身就没有名字。 |
| **能否删除** | **可以且应该删除**，以释放磁盘空间。 | **绝对不能删除**，删除会导致依赖它的上层镜像损坏。 |
| **查看命令** | `docker image ls -f dangling=true` | `docker image ls -a` （显示所有镜像，包括中间层） |



==**总结：**==

“它们的名称和表情都是`<none>`，但虚悬镜像是没用的垃圾（可删），中间层镜像是有用的基石（不可删）。” 所以，不能仅凭 `REPOSITORY` 和 `TAG` 字段为 `<none>` 就删除镜像，必须先用 `docker image ls -f dangling=true` 确认它是真正的“虚悬镜像”后再进行清理。





# 四.本篇小结
<font color="#DC3545" size="5" face="楷体">**本篇通过完整项目案例掌握Docker生产级应用部署，深入理解镜像分层机制与资源优化策略，提升容器化开发与运维效率。**</font>


本文基于Dockerfile实战搭建Redis集群与C++微服务，详解多阶段构建、镜像优化及Nginx负载均衡配置，并解析虚悬镜像与中间层镜像的核心区别与处理方法。

Docker高阶实战：从Redis集群到C++微服务，全面解析镜像优化与生产环境部署+镜像制作常见问题详解

运维

后端

开发工具

基于Dockerfile实战搭建Redis集群与C++微服务，详解多阶段构建、镜像优化及Nginx负载均衡配置，解析虚悬镜像与中间层镜像区别，提升容器化部署效率。

负载均衡

代码解释

容器

Docker

Redis

Nginx

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

EdgeOne AI 安全实战专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

Docker高阶实战：从Redis集群到C++微服务，全面解析镜像优化与生产环境部署+镜像制作常见问题详解-腾讯云开发者社区-腾讯云

Docker高阶实战：从Redis集群到C++微服务，全面解析镜像优化与生产环境部署+镜像制作常见问题详解

Docker高阶实战：从Redis集群到C++微服务，全面解析镜像优化与生产环境部署+镜像制作常见问题详解

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐