Docker 扛高并发实战：从镜像优化到 Nginx 负载均衡的完整部署命令

发布人：慈云数据-客服中心发布时间：11小时前阅读量：3

Docker 高并发解决方案｜附完整命令

在互联网业务中，“高并发”通常意味着系统需要在同一时间处理大量用户请求，例如秒杀活动、直播间互动、在线教育抢课、支付回调、API 网关转发等场景。Docker 作为当前主流的容器化技术，能够帮助我们快速部署、弹性扩容、隔离运行环境，但如果只是简单地把应用放进容器，并不能天然解决高并发问题。

真正的 Docker 高并发解决方案，需要从 镜像构建、容器资源限制、应用参数调优、反向代理、负载均衡、网络优化、日志治理、监控告警、横向扩容 等多个方面综合设计。

本文将以一个典型 Web 服务为例，系统讲解如何基于 Docker 构建高并发部署方案，并附上完整可执行命令，方便你直接实践。

一、高并发场景下 Docker 的核心思路

Docker 在高并发系统中的价值主要体现在以下几个方面：

环境一致性
- 本地、测试、生产环境保持一致；
- 避免“在我电脑上可以运行”的问题。
快速部署
- 应用打包成镜像后，可快速启动多个容器实例；
- 支持秒级扩容。
资源隔离
- 每个容器拥有独立的进程、文件系统和网络空间；
- 可以通过 CPU、内存限制避免单个服务拖垮宿主机。
横向扩容
- 通过启动多个容器副本提升并发处理能力；
- 配合 Nginx、Docker Compose、Swarm 或 Kubernetes 实现负载均衡。
易于回滚
- 镜像版本可控；
- 出现问题可以快速切换到旧版本。

不过，需要明确一点：

Docker 不是高并发的万能药。
Docker 解决的是部署、隔离和扩容问题，真正的并发能力仍然取决于应用架构、数据库、缓存、网络、系统参数以及负载均衡设计。

二、整体架构设计

一个较为常见的 Docker 高并发架构如下：

用户请求
   ↓
Nginx / OpenResty 反向代理
   ↓
多个应用容器实例
   ↓
Redis 缓存 / 消息队列
   ↓
数据库 MySQL / PostgreSQL
   ↓
监控、日志、告警系统

在这个架构中：

Nginx 负责接收请求、负载均衡、限流、连接复用；
应用容器 负责处理业务逻辑；
Redis 用于缓存热点数据、分布式锁、限流计数；
数据库 负责最终数据持久化；
监控系统 用于观察 CPU、内存、QPS、响应时间、错误率。

本文重点围绕 Docker 和 Nginx 展开，给出一个可以落地的高并发部署方案。

三、准备示例应用

为了方便演示，我们假设有一个简单的 Node.js Web 服务。当然，你也可以替换成 Java、Go、Python、PHP 等应用。

1. 创建项目目录

mkdir docker-high-concurrency
cd docker-high-concurrency

2. 创建应用文件

mkdir app
cd app

创建 package.json：

cat > package.json <<'EOF'
{
  "name": "docker-high-concurrency-demo",
  "version": "1.0.0",
  "description": "Docker high concurrency demo",
  "main": "server.js",
  "scripts": {
    "start": "node server.js"
  },
  "dependencies": {
    "express": "^4.18.3"
  }
}
EOF

创建 server.js：

cat > server.js <<'EOF'
const express = require('express');
const os = require('os');

const app = express();
const port = process.env.PORT || 3000;

app.get('/', (req, res) => {
  res.json({
    message: 'Hello Docker High Concurrency',
    hostname: os.hostname(),
    time: new Date().toISOString()
  });
});

app.get('/health', (req, res) => {
  res.status(200).send('OK');
});

app.listen(port, () => {
  console.log(`Server running on port ${port}`);
});
EOF

四、编写高质量 Dockerfile

一个高并发场景下的 Dockerfile，应该尽量做到：

镜像体积小；
构建过程可缓存；
不使用 root 用户运行；
暴露健康检查接口；
合理设置启动命令；
避免把无关文件复制进镜像。

1. 创建 Dockerfile

cat > Dockerfile <<'EOF'
FROM node:20-alpine

WORKDIR /app

COPY package*.json ./

RUN npm install --production

COPY server.js ./

RUN addgroup -S appgroup && adduser -S appuser -G appgroup

USER appuser

EXPOSE 3000

HEALTHCHECK --interval=10s --timeout=3s --start-period=10s --retries=3 \
  CMD wget -qO- http://127.0.0.1:3000/health || exit 1

CMD ["node", "server.js"]
EOF

2. 创建 `.dockerignore`

cat > .dockerignore <<'EOF'
node_modules
npm-debug.log
Dockerfile
.dockerignore
.git
.gitignore
README.md
EOF

3. 构建镜像

docker build -t high-concurrency-app:1.0 .

4. 测试运行单个容器

docker run -d \
  --name app-test \
  -p 3000:3000 \
  high-concurrency-app:1.0

测试访问：

curl http://127.0.0.1:3000/

查看健康状态：

docker ps

删除测试容器：

docker rm -f app-test

五、容器资源限制与高并发保护

在高并发场景下，不能让容器无限制地使用宿主机资源。否则一旦某个应用出现内存泄漏或 CPU 飙升，可能导致整台机器不可用。

Docker 可以通过参数限制 CPU、内存和进程数量。

1. 限制 CPU 和内存

docker run -d \
  --name app-limited \
  -p 3000:3000 \
  --cpus="1.5" \
  --memory="512m" \
  --memory-swap="512m" \
  high-concurrency-app:1.0

参数说明：

参数	含义
`--cpus="1.5"`	最多使用 1.5 个 CPU 核心
`--memory="512m"`	最大使用 512MB 内存
`--memory-swap="512m"`	禁止额外使用 swap
`--name`	容器名称

删除容器：

docker rm -f app-limited

2. 限制进程数

docker run -d \
  --name app-pids \
  -p 3000:3000 \
  --pids-limit=256 \
  high-concurrency-app:1.0

进程数限制可以防止应用异常 fork 大量进程，导致宿主机资源耗尽。

docker rm -f app-pids

3. 设置自动重启

生产环境中建议设置容器异常退出后自动重启：

docker run -d \
  --name app-restart \
  -p 3000:3000 \
  --restart=always \
  --cpus="1" \
  --memory="512m" \
  high-concurrency-app:1.0

六、使用 Docker Compose 部署多实例

单个容器的并发能力有限，高并发系统通常通过多个应用实例横向扩展。

这里使用 Docker Compose 启动：

3 个应用容器；
1 个 Nginx 负载均衡容器；
统一网络；
健康检查；
资源限制。

回到项目根目录：

cd ..

项目结构如下：

docker-high-concurrency/
├── app/
│   ├── Dockerfile
│   ├── package.json
│   ├── server.js
│   └── .dockerignore
├── nginx/
│   └── nginx.conf
└── docker-compose.yml

创建 Nginx 配置目录：

mkdir nginx

七、配置 Nginx 负载均衡

Nginx 是高并发架构中非常重要的一层。它可以：

反向代理；
负载均衡；
连接复用；
gzip 压缩；
限流；
超时控制；
静态资源缓存；
隐藏后端服务细节。

创建 nginx/nginx.conf：

cat > nginx/nginx.conf <<'EOF'
worker_processes auto;

events {
    worker_connections 65535;
    use epoll;
    multi_accept on;
}

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

    access_log off;
    error_log /var/log/nginx/error.log warn;

    sendfile on;
    tcp_nopush on;
    tcp_nodelay on;
    keepalive_timeout 65;
    keepalive_requests 10000;

    client_header_timeout 10s;
    client_body_timeout 10s;
    send_timeout 10s;

    gzip on;
    gzip_comp_level 5;
    gzip_min_length 1k;
    gzip_types text/plain application/json application/javascript text/css text/xml;

    upstream app_cluster {
        least_conn;
        server app1:3000 max_fails=3 fail_timeout=10s;
        server app2:3000 max_fails=3 fail_timeout=10s;
        server app3:3000 max_fails=3 fail_timeout=10s;
        keepalive 128;
    }

    limit_req_zone $binary_remote_addr zone=req_limit_per_ip:10m rate=20r/s;
    limit_conn_zone $binary_remote_addr zone=conn_limit_per_ip:10m;

    server {
        listen 80 reuseport;
        server_name _;

        limit_conn conn_limit_per_ip 50;

        location / {
            limit_req zone=req_limit_per_ip burst=100 nodelay;

            proxy_pass http://app_cluster;
            proxy_http_version 1.1;

            proxy_set_header Connection "";
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto $scheme;

            proxy_connect_timeout 3s;
            proxy_send_timeout 10s;
            proxy_read_timeout 10s;
        }

        location /health {
            return 200 "OK\n";
        }
    }
}
EOF

关键配置说明

配置	作用
`worker_processes auto`	根据 CPU 核心自动设置 worker 数
`worker_connections 65535`	每个 worker 最大连接数
`use epoll`	Linux 下高性能 I/O 模型
`multi_accept on`	尽可能一次接受多个连接
`least_conn`	请求分发给连接数较少的后端
`keepalive 128`	Nginx 与后端保持长连接
`limit_req_zone`	按 IP 限制请求速率
`limit_conn_zone`	按 IP 限制连接数
`reuseport`	多 worker 监听同端口，提高性能

八、编写 docker-compose.yml

创建 docker-compose.yml：

cat > docker-compose.yml <<'EOF'
services:
  app1:
    build:
      context: ./app
    image: high-concurrency-app:1.0
    container_name: app1
    restart: always
    environment:
      - PORT=3000
    expose:
      - "3000"
    deploy:
      resources:
        limits:
          cpus: "1.0"
          memory: 512M
    healthcheck:
      test: ["CMD", "wget", "-qO-", "http://127.0.0.1:3000/health"]
      interval: 10s
      timeout: 3s
      retries: 3
      start_period: 10s
    networks:
      - high_net

  app2:
    image: high-concurrency-app:1.0
    container_name: app2
    restart: always
    environment:
      - PORT=3000
    expose:
      - "3000"
    deploy:
      resources:
        limits:
          cpus: "1.0"
          memory: 512M
    healthcheck:
      test: ["CMD", "wget", "-qO-", "http://127.0.0.1:3000/health"]
      interval: 10s
      timeout: 3s
      retries: 3
      start_period: 10s
    networks:
      - high_net

  app3:
    image: high-concurrency-app:1.0
    container_name: app3
    restart: always
    environment:
      - PORT=3000
    expose:
      - "3000"
    deploy:
      resources:
        limits:
          cpus: "1.0"
          memory: 512M
    healthcheck:
      test: ["CMD", "wget", "-qO-", "http://127.0.0.1:3000/health"]
      interval: 10s
      timeout: 3s
      retries: 3
      start_period: 10s
    networks:
      - high_net

  nginx:
    image: nginx:1.25-alpine
    container_name: nginx-lb
    restart: always
    depends_on:
      - app1
      - app2
      - app3
    ports:
      - "80:80"
    volumes:
      - ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro
    ulimits:
      nofile:
        soft: 65535
        hard: 65535
    networks:
      - high_net

networks:
  high_net:
    driver: bridge
EOF

注意：deploy.resources 在普通 docker compose up 中不一定完全生效，它主要用于 Swarm 模式。如果需要在 Compose 单机模式中严格限制资源，可以使用 docker run 参数，或根据 Docker Compose 版本使用 mem_limit、cpus 等字段。

启动服务：

docker compose up -d --build

查看容器：

docker compose ps

测试访问：

curl http://127.0.0.1/

多次执行可以看到返回的 hostname 不同，说明请求被分发到了不同容器。

查看日志：

docker compose logs -f nginx

停止服务：

docker compose down

九、使用 Compose 快速横向扩容

如果你不想在配置文件里手动写 app1、app2、app3，也可以使用 Compose 的扩容方式。不过需要注意：如果服务指定了固定 container_name，就不能直接扩容。

下面给出更适合扩容的配置方式。

创建一个简化版 docker-compose.scale.yml：

cat > docker-compose.scale.yml <<'EOF'
services:
  app:
    build:
      context: ./app
    image: high-concurrency-app:1.0
    restart: always
    environment:
      - PORT=3000
    expose:
      - "3000"
    networks:
      - high_net

  nginx:
    image: nginx:1.25-alpine
    restart: always
    depends_on:
      - app
    ports:
      - "80:80"
    volumes:
      - ./nginx/nginx-scale.conf:/etc/nginx/nginx.conf:ro
    ulimits:
      nofile:
        soft: 65535
        hard: 65535
    networks:
      - high_net

networks:
  high_net:
    driver: bridge
EOF

创建支持动态 DNS 的 Nginx 配置：

cat > nginx/nginx-scale.conf <<'EOF'
worker_processes auto;

events {
    worker_connections 65535;
    use epoll;
    multi_accept on;
}

http {
    resolver 127.0.0.11 valid=10s ipv6=off;

    access_log off;
    error_log /var/log/nginx/error.log warn;

    upstream app_cluster {
        least_conn;
        server app:3000 resolve;
        keepalive 128;
    }

    server {
        listen 80 reuseport;

        location / {
            proxy_pass http://app_cluster;
            proxy_http_version 1.1;
            proxy_set_header Connection "";
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;

            proxy_connect_timeout 3s;
            proxy_send_timeout 10s;
            proxy_read_timeout 10s;
        }
    }
}
EOF

启动 5 个应用实例：

docker compose -f docker-compose.scale.yml up -d --build --scale app=5

查看容器：

docker compose -f docker-compose.scale.yml ps

测试访问：

for i in {1..10}; do curl -s http://127.0.0.1/; echo; done

扩容到 10 个实例：

docker compose -f docker-compose.scale.yml up -d --scale app=10

缩容到 3 个实例：

docker compose -f docker-compose.scale.yml up -d --scale app=3

停止并清理：

docker compose -f docker-compose.scale.yml down

十、宿主机内核参数优化

高并发不仅是 Docker 的问题，宿主机 Linux 内核参数也很关键。如果文件描述符、连接队列、端口范围过小，系统很容易出现连接失败、请求超时等问题。

1. 查看当前限制

ulimit -n

查看系统最大文件句柄数：

cat /proc/sys/fs/file-max

查看 TCP 参数：

sysctl net.core.somaxconn
sysctl net.ipv4.ip_local_port_range
sysctl net.ipv4.tcp_tw_reuse

2. 临时调整参数

sudo sysctl -w net.core.somaxconn=65535
sudo sysctl -w net.core.netdev_max_backlog=250000
sudo sysctl -w net.ipv4.tcp_max_syn_backlog=65535
sudo sysctl -w net.ipv4.ip_local_port_range="1024 65535"
sudo sysctl -w net.ipv4.tcp_tw_reuse=1
sudo sysctl -w fs.file-max=1000000

3. 永久写入配置

sudo tee /etc/sysctl.d/99-high-concurrency.conf > /dev/null <<'EOF'
fs.file-max = 1000000

net.core.somaxconn = 65535
net.core.netdev_max_backlog = 250000

net.ipv4.tcp_max_syn_backlog = 65535
net.ipv4.ip_local_port_range = 1024 65535
net.ipv4.tcp_tw_reuse = 1
net.ipv4.tcp_fin_timeout = 15

net.ipv4.tcp_keepalive_time = 600
net.ipv4.tcp_keepalive_intvl = 30
net.ipv4.tcp_keepalive_probes = 5
EOF

使配置生效：

sudo sysctl --system

4. 调整用户文件描述符

sudo tee -a /etc/security/limits.conf > /dev/null <<'EOF'
* soft nofile 65535
* hard nofile 65535
root soft nofile 65535
root hard nofile 65535
EOF

如果使用 systemd 管理 Docker，还需要调整 Docker 服务限制：

sudo mkdir -p /etc/systemd/system/docker.service.d
sudo tee /etc/systemd/system/docker.service.d/override.conf > /dev/null <<'EOF'
[Service]
LimitNOFILE=1048576
LimitNPROC=1048576
EOF

重载并重启 Docker：

sudo systemctl daemon-reload
sudo systemctl restart docker

确认 Docker 进程限制：

cat /proc/$(pidof dockerd)/limits | grep "open files"

十一、日志优化：避免高并发下磁盘被打爆

高并发场景下，请求日志量非常大。如果不做限制，Docker 默认日志文件可能快速占满磁盘，导致服务异常。

1. 单容器日志限制

docker run -d \
  --name app-log-limit \
  --log-driver=json-file \
  --log-opt max-size=100m \
  --log-opt max-file=3 \
  -p 3000:3000 \
  high-concurrency-app:1.0

2. Docker 全局日志配置

创建或修改 /etc/docker/daemon.json：

sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json > /dev/null <<'EOF'
{
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "100m",
    "max-file": "3"
  }
}
EOF

重启 Docker：

sudo systemctl restart docker

查看配置是否生效：

docker info | grep -A 5 "Logging Driver"

十二、压测验证方案

部署完成后，需要通过压测工具验证系统承载能力。常用工具包括：

ab
wrk
hey
k6
JMeter

这里推荐使用 wrk，它适合做 HTTP 高并发压测。

1. 安装 wrk

Ubuntu / Debian：

sudo apt update
sudo apt install -y build-essential git
git clone https://github.com/wg/wrk.git
cd wrk
make
sudo cp wrk /usr/local/bin/
wrk -v

CentOS / Rocky Linux：

sudo yum groupinstall -y "Development Tools"
sudo yum install -y git openssl-devel
git clone https://github.com/wg/wrk.git
cd wrk
make
sudo cp wrk /usr/local/bin/
wrk -v

2. 执行压测

wrk -t4 -c100 -d30s http://127.0.0.1/

参数说明：

参数	含义
`-t4`	使用 4 个线程
`-c100`	保持 100 个并发连接
`-d30s`	持续压测 30 秒

提高并发：

wrk -t8 -c1000 -d60s http://127.0.0.1/

如果要压测接口响应延迟分布：

wrk -t8 -c1000 -d60s --latency http://127.0.0.1/

压测时观察容器资源：

docker stats

观察 Nginx 日志：

docker logs -f nginx-lb

十三、监控容器性能

高并发系统不能只看“能不能跑”，还要持续观察。

1. 使用 docker stats

docker stats

查看指定容器：

docker stats nginx-lb app1 app2 app3

你需要重点关注：

CPU 使用率；
内存使用率；
网络收发；
Block I/O；
容器是否频繁重启。

2. 查看容器健康状态

docker inspect app1 --format='{{json .State.Health}}'

格式化输出：

docker inspect app1 --format='{{range .State.Health.Log}}{{.Output}}{{end}}'

3. 查看容器重启次数

docker inspect app1 --format='{{.RestartCount}}'

十四、应用层也必须调优

如果应用本身性能差，仅仅增加容器数量并不能解决根本问题。高并发场景下，应用层应该注意：

1. 使用连接池

数据库、Redis、HTTP Client 都应该使用连接池，避免每个请求都创建新连接。

例如：

MySQL 连接池；
Redis 连接池；
HTTP Keep-Alive；
gRPC 长连接。

2. 减少同步阻塞

高并发接口中应避免：

大文件同步读写；
复杂 CPU 计算；
慢 SQL；
调用不稳定第三方服务；
大事务。

3. 使用缓存

热点数据应优先从 Redis 或本地缓存读取，避免所有请求打到数据库。

常见缓存策略：

Cache Aside；
设置合理 TTL；
热点 Key 预热；
防止缓存穿透；
防止缓存击穿；
防止缓存雪崩。

4. 使用消息队列削峰

对于非实时任务，可以异步化处理，例如：

发送短信；
发送邮件；
写操作日志；
订单后置处理；
数据同步。

常见消息队列：

RabbitMQ；
Kafka；
RocketMQ；
Redis Stream。

十五、常见瓶颈与解决方案

瓶颈	表现	解决方案
CPU 不足	响应变慢，CPU 长期 90%+	增加实例、优化代码、拆分 CPU 密集任务
内存不足	OOM、容器重启	增加内存、排查泄漏、限制缓存大小
文件句柄不足	Too many open files	调整 `ulimit` 和 systemd 限制
连接队列过小	大量连接失败	调整 `somaxconn`、Nginx backlog
数据库慢	P99 延迟升高	索引优化、读写分离、缓存、分库分表
日志过多	磁盘占满、I/O 高	日志限流、异步日志、日志轮转
单机瓶颈	扩容无效	多宿主机部署、Swarm、Kubernetes
突发流量	请求瞬间打爆后端	Nginx 限流、Redis 限流、队列削峰

十六、生产环境建议

如果只是单机部署，Docker Compose 已经可以满足中小规模应用。但如果业务并发持续增长，建议升级为更完整的容器编排方案。

1. 单机高并发

适合：

中小型业务；
内部系统；
单机多实例；
流量较稳定的服务。

推荐方案：

Docker Compose + Nginx + Redis + MySQL + 日志限制 + 宿主机调优

2. 多机高并发

适合：

多节点部署；
弹性扩缩容；
服务自动发现；
灰度发布；
自动故障转移。

推荐方案：

Kubernetes + Ingress Nginx + HPA + Prometheus + Grafana + ELK/Loki

3. 镜像版本管理

生产镜像不要长期使用 latest，建议使用明确版本号：

docker build -t registry.example.com/app/high-concurrency-app:1.0.0 ./app
docker push registry.example.com/app/high-concurrency-app:1.0.0

拉取指定版本：

docker pull registry.example.com/app/high-concurrency-app:1.0.0

回滚版本：

docker stop app
docker rm app
docker run -d \
  --name app \
  -p 3000:3000 \
  registry.example.com/app/high-concurrency-app:0.9.0

十七、一键部署命令汇总

下面给出从零创建项目到启动服务的完整命令，适合快速复制执行。

mkdir -p docker-high-concurrency/app docker-high-concurrency/nginx
cd docker-high-concurrency/app

cat > package.json <<'EOF'
{
  "name": "docker-high-concurrency-demo",
  "version": "1.0.0",
  "main": "server.js",
  "scripts": {
    "start": "node server.js"
  },
  "dependencies": {
    "express": "^4.18.3"
  }
}
EOF

cat > server.js <<'EOF'
const express = require('express');
const os = require('os');

const app = express();
const port = process.env.PORT || 3000;

app.get('/', (req, res) => {
  res.json({
    message: 'Hello Docker High Concurrency',
    hostname: os.hostname(),
    time: new Date().toISOString()
  });
});

app.get('/health', (req, res) => {
  res.status(200).send('OK');
});

app.listen(port, () => {
  console.log(`Server running on port ${port}`);
});
EOF

cat > Dockerfile <<'EOF'
FROM node:20-alpine

WORKDIR /app

COPY package*.json ./

RUN npm install --production

COPY server.js ./

RUN addgroup -S appgroup && adduser -S appuser -G appgroup

USER appuser

EXPOSE 3000

HEALTHCHECK --interval=10s --timeout=3s --start-period=10s --retries=3 \
  CMD wget -qO- http://127.0.0.1:3000/health || exit 1

CMD ["node", "server.js"]
EOF

cat > .dockerignore <<'EOF'
node_modules
npm-debug.log
Dockerfile
.dockerignore
.git
.gitignore
README.md
EOF

cd ../nginx

cat > nginx.conf <<'EOF'
worker_processes auto;

events {
    worker_connections 65535;
    use epoll;
    multi_accept on;
}

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

    access_log off;
    error_log /var/log/nginx/error.log warn;

    sendfile on;
    tcp_nopush on;
    tcp_nodelay on;
    keepalive_timeout 65;
    keepalive_requests 10000;

    upstream app_cluster {
        least_conn;
        server app1:3000 max_fails=3 fail_timeout=10s;
        server app2:3000 max_fails=3 fail_timeout=10s;
        server app3:3000 max_fails=3 fail_timeout=10s;
        keepalive 128;
    }

    limit_req_zone $binary_remote_addr zone=req_limit_per_ip:10m rate=20r/s;
    limit_conn_zone $binary_remote_addr zone=conn_limit_per_ip:10m;

    server {
        listen 80 reuseport;
        server_name _;

        limit_conn conn_limit_per_ip 50;

        location / {
            limit_req zone=req_limit_per_ip burst=100 nodelay;

            proxy_pass http://app_cluster;
            proxy_http_version 1.1;
            proxy_set_header Connection "";
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;

            proxy_connect_timeout 3s;
            proxy_send_timeout 10s;
            proxy_read_timeout 10s;
        }

        location /health {
            return 200 "OK\n";
        }
    }
}
EOF

cd ..

cat > docker-compose.yml <<'EOF'
services:
  app1:
    build:
      context: ./app
    image: high-concurrency-app:1.0
    container_name: app1
    restart: always
    expose:
      - "3000"
    networks:
      - high_net

  app2:
    image: high-concurrency-app:1.0
    container_name: app2
    restart: always
    expose:
      - "3000"
    networks:
      - high_net

  app3:
    image: high-concurrency-app:1.0
    container_name: app3
    restart: always
    expose:
      - "3000"
    networks:
      - high_net

  nginx:
    image: nginx:1.25-alpine
    container_name: nginx-lb
    restart: always
    depends_on:
      - app1
      - app2
      - app3
    ports:
      - "80:80"
    volumes:
      - ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro
    ulimits:
      nofile:
        soft: 65535
        hard: 65535
    networks:
      - high_net

networks:
  high_net:
    driver: bridge
EOF

docker compose up -d --build
docker compose ps
curl http://127.0.0.1/