容器 A 的内部世界
├── 进程 1 ↔ /dev/shm（容器A的共享内存） ↔ 进程 2
└── 完全隔离，外部无法访问

容器 B 的内部世界  
├── 进程 3 ↔ /dev/shm（容器B的共享内存） ↔ 进程 4
└── 完全隔离，外部无法访问

# 常见错误信息
"Could not allocate shared memory segment"
"shm_open failed: Cannot allocate memory"
"IPC shared memory creation failed"

version: '3.8'
services:
  postgres:
    image: postgres:14
    shm_size: '1gb'  # 为 PostgreSQL 配置 1GB 共享内存
    environment:
      - POSTGRES_SHARED_BUFFERS=512MB

  python_app:
    image: my-python-app
    shm_size: '512m'  # Python 多进程应用需要 512MB
    command: python data_processor.py

# 不同单位的配置方式
docker run --shm-size=512m myapp           # 512 MB
docker run --shm-size=1g myapp             # 1 GB
docker run --shm-size=2147483648 myapp     # 2 GB（字节单位）

# 重要：Dockerfile 中无法直接设置 shm_size！
# 这个限制必须在运行时指定

FROM python:3.9-slim

# 安装依赖...
RUN pip install numpy pandas

# 提示用户需要在运行时指定共享内存
LABEL description="此镜像需要至少512MB共享内存，运行请使用：docker run --shm-size=512m ..."

COPY app.py .
CMD ["python", "app.py"]

# 验证隔离性
docker run -d --name app1 --shm-size=256m alpine sleep 3600
docker run -d --name app2 --shm-size=512m alpine sleep 3600

docker exec app1 df -h /dev/shm  # 显示 256M
docker exec app2 df -h /dev/shm  # 显示 512M
# 互相无法访问对方的共享内存

# 方法1：共享特定容器的 IPC 命名空间
docker run -d --name source --ipc=shareable --shm-size=1g app1
docker run -d --name consumer --ipc=container:source app2

# 方法2：使用主机 IPC 命名空间（安全风险高！）
docker run --ipc=host myapp

# Docker Compose 中的容器间 IPC 共享
version: '3.8'
services:
  processor:
    image: data-processor
    ipc: "shareable"
    
  analyzer:
    image: data-analyzer
    ipc: "service:processor"  # 共享 processor 的 IPC

# 查看容器内共享内存使用情况
docker exec <container> df -h /dev/shm

# 查看详细的 IPC 状态
docker exec <container> ipcs -m

# 监控实时使用情况
docker stats <container>

# 检查容器配置
docker inspect <container> | grep -i shm

# 安全的微服务架构示例
version: '3.8'
services:
  web:
    image: nginx
    shm_size: '128m'
    # 保持默认隔离，最安全
    
  api:
    image: node:16
    shm_size: '256m'
    # 每个服务有自己的私有共享内存
    
  database:
    image: postgres:14
    shm_size: '1gb'
    # 数据库需要更多，但仍然是隔离的

# docker-compose.yml
version: '3.8'
services:
  postgres:
    image: postgres:14
    shm_size: '2gb'  # 关键配置！
    environment:
      POSTGRES_SHARED_BUFFERS: 1GB
      POSTGRES_EFFECTIVE_CACHE_SIZE: 2GB
    ports:
      - "5432:5432"

# Dockerfile
FROM jupyter/datascience-notebook:latest

# 安装额外库
RUN pip install scikit-learn tensorflow

# 提示需要共享内存
LABEL shm_requirement="建议运行时有 2GB 共享内存"

# docker run --shm-size=2g -p 8888:8888 my-notebook

version: '3.8'
services:
  redis:
    image: redis:6
    shm_size: '128m'  # Redis 持久化可能需要
    
  celery_worker:
    build: .
    shm_size: '512m'  # Celery 多进程任务处理
    depends_on:
      - redis
  
  django_app:
    build: .
    shm_size: '256m'  # Django 应用本身
    ports:
      - "8000:8000"

# 使用 tmpfs 挂载替代 /dev/shm 的部分用途
services:
  myapp:
    image: myapp
    tmpfs:
      - /tmp:size=100m,mode=1777
      - /cache:size=200m
    # 注意：tmpfs 不能替代进程间通信的共享内存

# Kubernetes 中配置共享内存
apiVersion: v1
kind: Pod
spec:
  containers:
  - name: app
    image: myapp
    securityContext:
      # 注意：Kubernetes 方式不同！
    volumeMounts:
    - name: dshm
      mountPath: /dev/shm
  volumes:
  - name: dshm
    emptyDir:
      medium: Memory
      sizeLimit: 512Mi  # 这是关键配置

#!/bin/bash
# test_shm_performance.sh
# 测试不同共享内存大小对应用性能的影响

for size in 64m 128m 256m 512m 1g; do
  echo "测试共享内存大小: $size"
  time docker run --rm --shm-size=$size \
    python:3.9-slim python -c "
import multiprocessing as mp
import numpy as np
import time

def worker(arr):
    return np.sum(arr * arr)

if __name__ == '__main__':
    data = np.random.rand(10000, 10000)
    start = time.time()
    with mp.Pool(4) as pool:
        results = pool.map(worker, [data] * 4)
    print(f'耗时: {time.time()-start:.2f}秒')
"
done