Docker容器退出的多种方法与场景应用指南

# 优雅停止容器（默认等待10秒）
docker stop container_name
 
# 指定等待时间
docker stop -t 30 container_name
 
# 批量停止多个容器
docker stop container1 container2 container3

# app.py - Flask 应用示例
import signal
import sys
import time
from flask import Flask
 
app = Flask(__name__)
 
def graceful_shutdown(signum, frame):
    print(f"收到信号 {signum}，开始优雅关闭...")
    # 保存状态
    save_application_state()
    # 关闭数据库连接
    close_database_connections()
    # 完成正在处理的请求
    finish_pending_requests()
    print("优雅关闭完成")
    sys.exit(0)
 
# 注册信号处理器
signal.signal(signal.SIGTERM, graceful_shutdown)
signal.signal(signal.SIGINT, graceful_shutdown)
 
@app.route('/')
def hello():
    return "Hello, Docker!"
 
def save_application_state():
    # 保存应用状态的逻辑
    time.sleep(2)
    print("应用状态已保存")
 
def close_database_connections():
    # 关闭数据库连接的逻辑
    time.sleep(1)
    print("数据库连接已关闭")
 
def finish_pending_requests():
    # 完成待处理请求的逻辑
    time.sleep(2)
    print("待处理请求已完成")
 
if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

FROM python:3.9-slim
 
WORKDIR /app
 
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
 
COPY app.py .
 
# 使用 exec 形式确保信号正确传递
CMD ["python", "app.py"]

# 发送 SIGKILL 信号（默认）
docker kill container_name
 
# 发送指定信号
docker kill -s SIGTERM container_name
docker kill -s SIGUSR1 container_name
 
# 使用信号编号
docker kill -s 15 container_name  # SIGTERM
docker kill -s 9 container_name   # SIGKILL

# signal_handler.py - 多信号处理示例
import signal
import os
import json
import threading
import time
 
class ApplicationManager:
    def __init__(self):
        self.config = self.load_config()
        self.is_running = True
        self.setup_signal_handlers()
    
    def load_config(self):
        """加载配置文件"""
        try:
            with open('/app/config.json', 'r') as f:
                return json.load(f)
        except FileNotFoundError:
            return {"debug": False, "log_level": "INFO"}
    
    def setup_signal_handlers(self):
        """设置信号处理器"""
        signal.signal(signal.SIGTERM, self.handle_sigterm)
        signal.signal(signal.SIGHUP, self.handle_sighup)
        signal.signal(signal.SIGUSR1, self.handle_sigusr1)
        signal.signal(signal.SIGUSR2, self.handle_sigusr2)
    
    def handle_sigterm(self, signum, frame):
        """处理 SIGTERM - 优雅关闭"""
        print("收到 SIGTERM，开始优雅关闭...")
        self.is_running = False
        self.cleanup()
    
    def handle_sighup(self, signum, frame):
        """处理 SIGHUP - 重新加载配置"""
        print("收到 SIGHUP，重新加载配置...")
        self.config = self.load_config()
        print(f"配置已更新: {self.config}")
    
    def handle_sigusr1(self, signum, frame):
        """处理 SIGUSR1 - 输出状态信息"""
        print("收到 SIGUSR1，输出状态信息...")
        print(f"PID: {os.getpid()}")
        print(f"配置: {self.config}")
        print(f"运行状态: {'运行中' if self.is_running else '停止中'}")
    
    def handle_sigusr2(self, signum, frame):
        """处理 SIGUSR2 - 切换调试模式"""
        print("收到 SIGUSR2，切换调试模式...")
        self.config['debug'] = not self.config.get('debug', False)
        print(f"调试模式: {'开启' if self.config['debug'] else '关闭'}")
    
    def cleanup(self):
        """清理资源"""
        print("正在清理资源...")
        time.sleep(2)
        print("资源清理完成")
    
    def run(self):
        """主运行循环"""
        print(f"应用启动，PID: {os.getpid()}")
        while self.is_running:
            time.sleep(1)
        print("应用已停止")
 
if __name__ == "__main__":
    app = ApplicationManager()
    app.run()

# 启动容器
docker run -d --name signal-app signal-handler
 
# 重新加载配置
docker kill -s SIGHUP signal-app
 
# 查看状态
docker kill -s SIGUSR1 signal-app
 
# 切换调试模式
docker kill -s SIGUSR2 signal-app
 
# 优雅关闭
docker kill -s SIGTERM signal-app

# 方法1：使用 exit 命令
$ docker run -it ubuntu bash
root@container:/# exit
 
# 方法2：使用 Ctrl+D（EOF）
$ docker run -it ubuntu bash
root@container:/# ^D
 
# 方法3：使用 Ctrl+P+Q（分离但不停止）
$ docker run -it ubuntu bash
root@container:/# ^P^Q
# 容器继续在后台运行

# auto_exit.py - 自动退出示例
import sys
import time
import os
 
def main():
    max_runtime = int(os.environ.get('MAX_RUNTIME', '60'))
    start_time = time.time()
    
    while True:
        elapsed = time.time() - start_time
        print(f"运行时间: {elapsed:.1f}秒")
        
        # 检查退出条件
        if elapsed >= max_runtime:
            print(f"达到最大运行时间 {max_runtime}秒，退出")
            sys.exit(0)  # 正常退出
        
        # 检查退出文件
        if os.path.exists('/tmp/exit_flag'):
            print("检测到退出标志文件，退出")
            os.remove('/tmp/exit_flag')
            sys.exit(0)
        
        # 模拟工作
        time.sleep(5)
 
if __name__ == "__main__":
    try:
        main()
    except KeyboardInterrupt:
        print("\n收到中断信号，退出")
        sys.exit(130)  # 128 + 2 (SIGINT)
    except Exception as e:
        print(f"发生错误: {e}")
        sys.exit(1)

version: '3.8'
 
services:
  web:
    image: nginx:alpine
    ports:
      - "80:80"
    stop_grace_period: 30s  # 优雅关闭等待时间
    stop_signal: SIGTERM     # 停止信号
    
  app:
    build: .
    depends_on:
      - db
    environment:
      - SHUTDOWN_TIMEOUT=20
    stop_grace_period: 20s
    
  db:
    image: postgres:13
    environment:
      - POSTGRES_PASSWORD=secret
    volumes:
      - db_data:/var/lib/postgresql/data
    stop_grace_period: 60s  # 数据库需要更长时间
    
  redis:
    image: redis:alpine
    command: redis-server --save 60 1  # 每60秒保存一次
    stop_grace_period: 10s
 
volumes:
  db_data:

# 优雅停止所有服务
docker-compose stop
 
# 停止并移除容器
docker-compose down
 
# 停止特定服务
docker-compose stop web app
 
# 强制停止（立即发送 SIGKILL）
docker-compose kill
 
# 停止并移除所有，包括卷
docker-compose down -v

# coordinator.py - 服务协调器
import signal
import sys
import time
import threading
import requests
 
class ServiceCoordinator:
    def __init__(self):
        self.services = {
            'web': {'url': 'http://web:80/health', 'priority': 3},
            'app': {'url': 'http://app:8000/health', 'priority': 2},
            'cache': {'url': 'http://redis:6379', 'priority': 1}
        }
        self.shutdown_event = threading.Event()
        signal.signal(signal.SIGTERM, self.handle_shutdown)
    
    def handle_shutdown(self, signum, frame):
        """处理关闭信号"""
        print("开始协调服务关闭...")
        self.shutdown_event.set()
        
        # 按优先级顺序关闭服务
        sorted_services = sorted(
            self.services.items(),
            key=lambda x: x[1]['priority']
        )
        
        for service_name, service_info in sorted_services:
            print(f"正在关闭 {service_name}...")
            self.shutdown_service(service_name)
            time.sleep(2)  # 给服务时间完成关闭
        
        print("所有服务已关闭")
        sys.exit(0)
    
    def shutdown_service(self, service_name):
        """关闭单个服务"""
        try:
            # 发送关闭请求到服务
            requests.post(f"http://{service_name}:8000/shutdown", timeout=5)
        except:
            print(f"无法连接到 {service_name}，可能已关闭")
    
    def run(self):
        """主运行循环"""
        print("服务协调器已启动")
        while not self.shutdown_event.is_set():
            # 监控服务健康状态
            for service_name, service_info in self.services.items():
                self.check_service_health(service_name, service_info['url'])
            time.sleep(10)
    
    def check_service_health(self, service_name, url):
        """检查服务健康状态"""
        try:
            response = requests.get(url, timeout=2)
            if response.status_code == 200:
                print(f"✓ {service_name} 正常")
            else:
                print(f"✗ {service_name} 异常: {response.status_code}")
        except:
            print(f"✗ {service_name} 无响应")
 
if __name__ == "__main__":
    coordinator = ServiceCoordinator()
    coordinator.run()

# Dockerfile with healthcheck
FROM node:14-alpine
 
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY . .
 
# 健康检查配置
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
  CMD node healthcheck.js || exit 1
 
CMD ["node", "server.js"]

// healthcheck.js
const http = require('http');
 
const options = {
  hostname: 'localhost',
  port: 3000,
  path: '/health',
  timeout: 2000
};
 
const req = http.request(options, (res) => {
  console.log(`健康检查状态: ${res.statusCode}`);
  if (res.statusCode === 200) {
    process.exit(0);  // 健康
  } else {
    process.exit(1);  // 不健康
  }
});
 
req.on('error', (err) => {
  console.error(`健康检查失败: ${err.message}`);
  process.exit(1);
});
 
req.on('timeout', () => {
  console.error('健康检查超时');
  req.destroy();
  process.exit(1);
});
 
req.end();

# 配置重启策略
docker run -d \
  --name myapp \
  --restart=unless-stopped \
  --health-cmd="curl -f http://localhost/health || exit 1" \
  --health-interval=30s \
  --health-timeout=10s \
  --health-retries=3 \
  myapp:latest

# microservice.py - 微服务优雅退出
import asyncio
import signal
import aiohttp
from aiohttp import web
import logging
 
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
 
class MicroService:
    def __init__(self, name, port):
        self.name = name
        self.port = port
        self.app = web.Application()
        self.runner = None
        self.is_shutting_down = False
        self.active_requests = set()
        self.setup_routes()
        self.setup_middleware()
    
    def setup_routes(self):
        """设置路由"""
        self.app.router.add_get('/health', self.health_check)
        self.app.router.add_post('/shutdown', self.shutdown_endpoint)
        self.app.router.add_get('/api/data', self.get_data)
    
    def setup_middleware(self):
        """设置中间件"""
        @web.middleware
        async def track_requests(request, handler):
            if self.is_shutting_down and request.path != '/health':
                return web.Response(text='Service is shutting down', status=503)
            
            request_id = id(request)
            self.active_requests.add(request_id)
            try:
                response = await handler(request)
                return response
            finally:
                self.active_requests.discard(request_id)
        
        self.app.middlewares.append(track_requests)
    
    async def health_check(self, request):
        """健康检查端点"""
        if self.is_shutting_down:
            return web.Response(text='SHUTTING_DOWN', status=503)
        return web.Response(text='OK', status=200)
    
    async def shutdown_endpoint(self, request):
        """关闭端点"""
        asyncio.create_task(self.graceful_shutdown())
        return web.Response(text='Shutdown initiated', status=202)
    
    async def get_data(self, request):
        """模拟数据处理"""
        await asyncio.sleep(2)  # 模拟处理时间
        return web.json_response({'service': self.name, 'data': 'sample'})
    
    async def graceful_shutdown(self):
        """优雅关闭"""
        logger.info(f"{self.name} 开始优雅关闭...")
        self.is_shutting_down = True
        
        # 等待活跃请求完成（最多30秒）
        max_wait = 30
        waited = 0
        while self.active_requests and waited < max_wait:
            logger.info(f"等待 {len(self.active_requests)} 个请求完成...")
            await asyncio.sleep(1)
            waited += 1
        
        if self.active_requests:
            logger.warning(f"强制关闭 {len(self.active_requests)} 个未完成请求")
        
        # 通知下游服务
        await self.notify_downstream_services()
        
        # 保存状态
        await self.save_state()
        
        # 关闭服务器
        if self.runner:
            await self.runner.cleanup()
        
        logger.info(f"{self.name} 已完全关闭")
    
    async def notify_downstream_services(self):
        """通知下游服务"""
        downstream_services = ['service-b', 'service-c']
        async with aiohttp.ClientSession() as session:
            for service in downstream_services:
                try:
                    url = f"http://{service}:8000/upstream-shutdown"
                    await session.post(url, json={'service': self.name})
                    logger.info(f"已通知 {service}")
                except Exception as e:
                    logger.error(f"通知 {service} 失败: {e}")
    
    async def save_state(self):
        """保存服务状态"""
        # 实际应用中这里会保存到数据库或文件
        logger.info(f"{self.name} 状态已保存")
        await asyncio.sleep(1)  # 模拟保存时间
    
    async def start(self):
        """启动服务"""
        self.runner = web.AppRunner(self.app)
        await self.runner.setup()
        site = web.TCPSite(self.runner, '0.0.0.0', self.port)
        await site.start()
        logger.info(f"{self.name} 运行在端口 {self.port}")
        
        # 设置信号处理
        loop = asyncio.get_event_loop()
        for sig in (signal.SIGTERM, signal.SIGINT):
            loop.add_signal_handler(
                sig,
                lambda: asyncio.create_task(self.graceful_shutdown())
            )
        
        # 保持运行
        while not self.is_shutting_down:
            await asyncio.sleep(1)
 
async def main():
    service = MicroService('service-a', 8000)
    await service.start()
 
if __name__ == '__main__':
    asyncio.run(main())

# db_manager.py - 数据库连接管理
import psycopg2
from psycopg2 import pool
import signal
import threading
import time
import logging
 
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
 
class DatabaseManager:
    def __init__(self, db_config):
        self.db_config = db_config
        self.connection_pool = None
        self.active_connections = []
        self.shutdown_event = threading.Event()
        self.lock = threading.Lock()
        self.init_pool()
        self.setup_signal_handlers()
    
    def init_pool(self):
        """初始化连接池"""
        self.connection_pool = psycopg2.pool.ThreadedConnectionPool(
            minconn=2,
            maxconn=10,
            **self.db_config
        )
        logger.info("数据库连接池已初始化")
    
    def setup_signal_handlers(self):
        """设置信号处理器"""
        signal.signal(signal.SIGTERM, self.handle_shutdown)
        signal.signal(signal.SIGINT, self.handle_shutdown)
    
    def handle_shutdown(self, signum, frame):
        """处理关闭信号"""
        logger.info(f"收到信号 {signum}，开始关闭数据库连接...")
        self.shutdown_event.set()
        threading.Thread(target=self.graceful_shutdown).start()
    
    def get_connection(self):
        """获取数据库连接"""
        if self.shutdown_event.is_set():
            raise Exception("数据库管理器正在关闭")
        
        conn = self.connection_pool.getconn()
        with self.lock:
            self.active_connections.append(conn)
        return conn
    
    def release_connection(self, conn):
        """释放数据库连接"""
        with self.lock:
            if conn in self.active_connections:
                self.active_connections.remove(conn)
        
        if not conn.closed:
            # 回滚未提交的事务
            conn.rollback()
            self.connection_pool.putconn(conn)
    
    def execute_query(self, query, params=None):
        """执行查询"""
        conn = None
        cursor = None
        try:
            conn = self.get_connection()
            cursor = conn.cursor()
            cursor.execute(query, params)
            
            # 如果是写操作，提交事务
            if query.strip().upper().startswith(('INSERT', 'UPDATE', 'DELETE')):
                conn.commit()
                logger.info(f"事务已提交: {query[:50]}...")
            
            # 如果是查询，返回结果
            if query.strip().upper().startswith('SELECT'):
                return cursor.fetchall()
            
            return cursor.rowcount
        
        except Exception as e:
            if conn:
                conn.rollback()
            logger.error(f"查询执行失败: {e}")
            raise
        
        finally:
            if cursor:
                cursor.close()
            if conn:
                self.release_connection(conn)
    
    def graceful_shutdown(self):
        """优雅关闭"""
        logger.info("开始优雅关闭数据库连接...")
        
        # 停止接受新连接
        logger.info("停止接受新的数据库连接")
        
        # 等待活跃连接完成（最多60秒）
        max_wait = 60
        waited = 0
        while self.active_connections and waited < max_wait:
            with self.lock:
                active_count = len(self.active_connections)
            
            if active_count > 0:
                logger.info(f"等待 {active_count} 个活跃连接完成...")
                time.sleep(1)
                waited += 1
            else:
                break
        
        # 强制关闭剩余连接
        with self.lock:
            for conn in self.active_connections:
                try:
                    if not conn.closed:
                        conn.rollback()  # 回滚未提交的事务
                        conn.close()
                        logger.warning(f"强制关闭连接: {id(conn)}")
                except Exception as e:
                    logger.error(f"关闭连接失败: {e}")
        
        # 关闭连接池
        if self.connection_pool:
            self.connection_pool.closeall()
            logger.info("连接池已关闭")
        
        logger.info("数据库管理器已完全关闭")
        exit(0)
    
    def monitor_connections(self):
        """监控连接状态"""
        while not self.shutdown_event.is_set():
            with self.lock:
                active = len(self.active_connections)
            
            logger.info(f"连接池状态 - 活跃: {active}, 空闲: {self.connection_pool.idle}")
            time.sleep(10)
 
# 使用示例
if __name__ == "__main__":
    db_config = {
        'host': 'localhost',
        'database': 'myapp',
        'user': 'postgres',
        'password': 'secret'
    }
    
    manager = DatabaseManager(db_config)
    
    # 启动监控线程
    monitor_thread = threading.Thread(target=manager.monitor_connections)
    monitor_thread.daemon = True
    monitor_thread.start()
    
    # 模拟数据库操作
    try:
        while not manager.shutdown_event.is_set():
            # 执行一些数据库操作
            result = manager.execute_query("SELECT NOW()")
            logger.info(f"当前时间: {result[0][0]}")
            time.sleep(5)
    except KeyboardInterrupt:
        pass

# 查看容器退出码
docker inspect container_name --format='{{.State.ExitCode}}'
 
# 查看容器最后的日志
docker logs --tail 50 container_name
 
# 实时监控容器事件
docker events --filter container=container_name
 
# 查看容器内进程
docker top container_name
 
# 进入运行中的容器调试
docker exec -it container_name sh

# 并行关闭多个资源
import asyncio
 
async def shutdown_resources():
    tasks = [
        close_database(),
        flush_cache(),
        save_state(),
        notify_services()
    ]
    # 并行执行所有关闭任务
    await asyncio.gather(*tasks, return_exceptions=True)

def tiered_shutdown():
    """分级关闭策略"""
    # 第一级：停止接受新请求
    stop_accepting_requests()
    
    # 第二级：完成当前请求
    wait_for_current_requests(timeout=10)
    
    # 第三级：保存关键数据
    save_critical_data()
    
    # 第四级：清理资源
    cleanup_resources()

# docker-compose.yml
services:
  app:
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s