Django + MySQL + Nginx 实现高并发博客系统

Django + MySQL + Nginx 高并发博客系统

我来为你构建一个完整的高并发博客系统，涵盖架构优化、缓存策略、数据库优化、负载均衡等关键环节。

一、系统架构

用户请求 ↓ Nginx (反向代理 + 负载均衡 + 静态资源) ↓ Gunicorn / uWSGI (WSGI 服务器，多进程) ↓ Django Application ├── Redis Cache (会话/页面/查询缓存) ├── Celery (异步任务：邮件、统计、索引) └── MySQL (读写分离 + 连接池)

二、项目结构

blog_project/ ├── blog_project/ │ ├── __init__.py │ ├── settings.py │ ├── urls.py │ ├── wsgi.py │ └── celery.py ├── blog_app/ │ ├── __init__.py │ ├── models.py │ ├── views.py │ ├── serializers.py │ ├── tasks.py │ ├── templatetags/ │ └── templates/ ├── static/ │ ├── css/ │ ├── js/ │ └── images/ ├── media/ ├── nginx.conf ├── supervisor.conf ├── requirements.txt ├── Dockerfile └── docker-compose.yml

三、高性能配置

3.1 安装依赖

pip install django gunicorn mysqlclient redis django-redis celery celery-with-redis flower

3.2 settings.py 优化配置

# blog_project/settings.py import os from pathlib import Path BASE_DIR = Path(__file__).resolve().parent.parent SECRET_KEY = os.environ.get('DJANGO_SECRET_KEY', 'your-secret-key') DEBUG = False # 生产环境必须关闭 ALLOWED_HOSTS = ['*'] INSTALLED_APPS = [ 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', 'django.contrib.sitemaps', 'rest_framework', # REST API 'corsheaders', # 跨域 'django_filters', # 过滤 'celery', # 异步任务 'blog_app', ] MIDDLEWARE = [ 'django.middleware.security.SecurityMiddleware', 'django.contrib.sessions.middleware.SessionMiddleware', 'corsheaders.middleware.CorsMiddleware', 'django.middleware.common.CommonMiddleware', 'django.middleware.csrf.CsrfViewMiddleware', 'django.contrib.auth.middleware.AuthenticationMiddleware', 'django.contrib.messages.middleware.MessageMiddleware', 'django.middleware.clickjacking.XFrameOptionsMiddleware', 'django.middleware.gzip.GZipMiddleware', # 开启Gzip压缩 ] ROOT_URLCONF = 'blog_project.urls' TEMPLATES = [ { 'BACKEND': 'django.template.backends.django.DjangoTemplates', 'DIRS': [], 'APP_DIRS': True, 'OPTIONS': { 'context_processors': [ 'django.template.context_processors.debug', 'django.template.context_processors.request', 'django.contrib.auth.context_processors.auth', 'django.contrib.messages.context_processors.messages', ], }, }, ] # ========== 数据库优化 ========== DATABASES = { 'default': { 'ENGINE': 'django.db.backends.mysql', 'NAME': 'blog_db', 'USER': os.environ.get('DB_USER', 'root'), 'PASSWORD': os.environ.get('DB_PASSWORD', 'password'), 'HOST': os.environ.get('DB_HOST', 'localhost'), 'PORT': '3306', 'OPTIONS': { 'charset': 'utf8mb4', 'init_command': "SET sql_mode='STRICT_TRANS_TABLES'", 'connect_timeout': 10, }, # 连接池配置 'CONN_MAX_AGE': 600, # 保持连接10分钟 'POOL_SIZE': 32, # 连接池大小 'MAX_OVERFLOW': 64, # 最大溢出连接数 }, 'slave': { # 读库（可选） 'ENGINE': 'django.db.backends.mysql', 'NAME': 'blog_db', 'USER': os.environ.get('DB_SLAVE_USER', 'root'), 'PASSWORD': os.environ.get('DB_SLAVE_PASSWORD', 'password'), 'HOST': os.environ.get('DB_SLAVE_HOST', 'localhost'), 'PORT': '3307', 'OPTIONS': { 'charset': 'utf8mb4', }, 'CONN_MAX_AGE': 600, } } # 数据库路由（读写分离） DATABASE_ROUTERS = ['blog_project.db_router.MasterSlaveRouter'] # ========== 缓存配置 ========== CACHES = { 'default': { 'BACKEND': 'django_redis.cache.RedisCache', 'LOCATION': os.environ.get('REDIS_URL', 'redis://localhost:6379/0'), 'OPTIONS': { 'CLIENT_CLASS': 'django_redis.client.DefaultClient', 'PARSER_CLASS': 'redis.connection.HiredisParser', 'CONNECTION_POOL_CLASS': 'redis.BlockingConnectionPool', 'CONNECTION_POOL_CLASS_KWARGS': { 'max_connections': 100, 'timeout': 20, }, 'MAX_CONNECTIONS': 1000, 'PICKLE_VERSION': -1, }, 'KEY_PREFIX': 'blog', 'TIMEOUT': 86400, # 默认24小时 }, 'session': { 'BACKEND': 'django_redis.cache.RedisCache', 'LOCATION': os.environ.get('REDIS_SESSION_URL', 'redis://localhost:6379/1'), 'OPTIONS': { 'CLIENT_CLASS': 'django_redis.client.DefaultClient', }, 'KEY_PREFIX': 'session', } } # Session 存储到 Redis SESSION_ENGINE = 'django.contrib.sessions.backends.cache' SESSION_CACHE_ALIAS = 'session' # ========== Celery 配置 ========== CELERY_BROKER_URL = os.environ.get('CELERY_BROKER_URL', 'redis://localhost:6379/2') CELERY_RESULT_BACKEND = os.environ.get('CELERY_RESULT_BACKEND', 'redis://localhost:6379/3') CELERY_ACCEPT_CONTENT = ['application/json'] CELERY_TASK_SERIALIZER = 'json' CELERY_RESULT_SERIALIZER = 'json' CELERY_TIMEZONE = 'Asia/Shanghai' CELERY_WORKER_CONCURRENCY = 8 # Worker 并发数 CELERY_TASK_ACKS_LATE = True CELERY_WORKER_PREFETCH_MULTIPLIER = 1 # ========== 静态文件优化 ========== STATIC_URL = '/static/' STATIC_ROOT = os.path.join(BASE_DIR, 'staticfiles') STATICFILES_STORAGE = 'django.contrib.staticfiles.storage.ManifestStaticFilesStorage' MEDIA_URL = '/media/' MEDIA_ROOT = os.path.join(BASE_DIR, 'media') # ========== 安全配置 ========== SECURE_SSL_REDIRECT = True SESSION_COOKIE_SECURE = True CSRF_COOKIE_SECURE = True SECURE_HSTS_SECONDS = 31536000 SECURE_HSTS_INCLUDE_SUBDOMAINS = True SECURE_CONTENT_TYPE_NOSNIFF = True X_FRAME_OPTIONS = 'DENY' # ========== REST Framework ========== REST_FRAMEWORK = { 'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.PageNumberPagination', 'PAGE_SIZE': 20, 'DEFAULT_FILTER_BACKENDS': [ 'django_filters.rest_framework.DjangoFilterBackend', 'rest_framework.filters.SearchFilter', 'rest_framework.filters.OrderingFilter', ], 'DEFAULT_THROTTLE_CLASSES': [ 'rest_framework.throttling.AnonRateThrottle', 'rest_framework.throttling.UserRateThrottle', ], 'DEFAULT_THROTTLE_RATES': { 'anon': '100/hour', 'user': '1000/hour', } } # CORS 配置 CORS_ALLOW_ALL_ORIGINS = False CORS_ALLOWED_ORIGINS = [ 'https://blog.example.com', ]

四、数据库读写分离路由

# blog_project/db_router.py class MasterSlaveRouter: """数据库读写分离路由器""" def db_for_read(self, model, **hints): """读操作使用从库""" return 'slave' def db_for_write(self, model, **hints): """写操作使用主库""" return 'default' def allow_relation(self, obj1, obj2, **hints): """允许跨数据库关系""" return True def allow_migrate(self, db, app_label, model_name=None, **hints): """只在主库进行迁移""" return db == 'default'

五、高性能数据模型

# blog_app/models.py from django.db import models from django.contrib.auth.models import User from django.utils import timezone from django.urls import reverse class Category(models.Model): """分类模型""" name = models.CharField(max_length=100, unique=True, db_index=True) slug = models.SlugField(max_length=100, unique=True) description = models.TextField(blank=True) parent = models.ForeignKey('self', null=True, blank=True, on_delete=models.SET_NULL, related_name='children') post_count = models.IntegerField(default=0, help_text='文章计数（冗余字段）') created_at = models.DateTimeField(auto_now_add=True) class Meta: verbose_name = '分类' verbose_name_plural = '分类' indexes = [ models.Index(fields=['slug']), ] def __str__(self): return self.name class Tag(models.Model): """标签模型""" name = models.CharField(max_length=50, unique=True, db_index=True) slug = models.SlugField(max_length=50, unique=True) post_count = models.IntegerField(default=0) class Meta: verbose_name = '标签' verbose_name_plural = '标签' def __str__(self): return self.name class PostQuerySet(models.QuerySet): """自定义查询集""" def published(self): return self.filter(status='published', publish_time__lte=timezone.now()) def featured(self): return self.filter(is_featured=True) def with_counts(self): return self.annotate( comment_count=models.Count('comments', filter=models.Q(comments__is_approved=True)), like_count=models.Count('likes') ) class Post(models.Model): """文章模型 - 核心优化点""" STATUS_CHOICES = ( ('draft', '草稿'), ('published', '已发布'), ('deleted', '已删除'), ) title = models.CharField(max_length=200, db_index=True) slug = models.SlugField(max_length=250, unique=True, db_index=True) author = models.ForeignKey(User, on_delete=models.CASCADE, related_name='posts') category = models.ForeignKey(Category, on_delete=models.SET_NULL, null=True, related_name='posts') tags = models.ManyToManyField(Tag, blank=True, related_name='posts') # 内容 content = models.TextField() excerpt = models.TextField(max_length=500, blank=True, help_text='摘要') content_html = models.TextField(blank=True, help_text='渲染后的HTML') # 状态和时间 status = models.CharField(max_length=20, choices=STATUS_CHOICES, default='draft', db_index=True) publish_time = models.DateTimeField(default=timezone.now, db_index=True) created_at = models.DateTimeField(auto_now_add=True) updated_at = models.DateTimeField(auto_now=True) # 统计字段（冗余优化） view_count = models.IntegerField(default=0) like_count = models.IntegerField(default=0) comment_count = models.IntegerField(default=0) # 特色 is_featured = models.BooleanField(default=False, db_index=True) is_top = models.BooleanField(default=False, db_index=True) cover_image = models.ImageField(upload_to='posts/covers/', blank=True) # SEO meta_description = models.CharField(max_length=160, blank=True) meta_keywords = models.CharField(max_length=200, blank=True) objects = PostQuerySet.as_manager() class Meta: verbose_name = '文章' verbose_name_plural = '文章' ordering = ['-publish_time'] indexes = [ models.Index(fields=['status', 'publish_time']), models.Index(fields=['author', '-publish_time']), models.Index(fields=['category', '-publish_time']), ] def __str__(self): return self.title def get_absolute_url(self): return reverse('blog:post_detail', args=[self.slug]) def save(self, *args, **kwargs): # 自动生成摘要 if not self.excerpt: self.excerpt = self.content[:200] # 更新分类文章计数 if self.category and self.pk: old_category = Post.objects.get(pk=self.pk).category if old_category != self.category: if old_category: old_category.post_count -= 1 old_category.save() self.category.post_count += 1 self.category.save() super().save(*args, **kwargs) class Comment(models.Model): """评论模型""" post = models.ForeignKey(Post, on_delete=models.CASCADE, related_name='comments') author = models.ForeignKey(User, on_delete=models.CASCADE, related_name='comments') parent = models.ForeignKey('self', null=True, blank=True, on_delete=models.CASCADE, related_name='replies') content = models.TextField() is_approved = models.BooleanField(default=False, db_index=True) created_at = models.DateTimeField(auto_now_add=True, db_index=True) class Meta: verbose_name = '评论' verbose_name_plural = '评论' ordering = ['-created_at'] indexes = [ models.Index(fields=['post', 'is_approved', '-created_at']), ] def __str__(self): return f'{self.author.username} 评论 {self.post.title}' class Like(models.Model): """点赞模型""" user = models.ForeignKey(User, on_delete=models.CASCADE, related_name='likes') post = models.ForeignKey(Post, on_delete=models.CASCADE, related_name='likes') created_at = models.DateTimeField(auto_now_add=True) class Meta: unique_together = ('user', 'post') verbose_name = '点赞' verbose_name_plural = '点赞' class PostView(models.Model): """文章浏览记录""" post = models.ForeignKey(Post, on_delete=models.CASCADE, related_name='views') ip_address = models.GenericIPAddressField() user_agent = models.CharField(max_length=500, blank=True) viewed_at = models.DateTimeField(auto_now_add=True) class Meta: verbose_name = '浏览记录' verbose_name_plural = '浏览记录' indexes = [ models.Index(fields=['post', '-viewed_at']), ]

六、高性能视图与缓存

# blog_app/views.py from django.shortcuts import render, get_object_or_404 from django.views.decorators.cache import cache_page from django.views.decorators.vary import vary_on_headers from django.core.cache import cache from django.db.models import Q, Prefetch from django.utils.decorators import method_decorator from django.views.generic import ListView, DetailView from rest_framework import viewsets, permissions, filters from rest_framework.decorators import action from rest_framework.response import Response from .models import Post, Category, Tag, Comment from .serializers import PostListSerializer, PostDetailSerializer from .tasks import increment_post_view, update_post_stats class PostListView(ListView): """文章列表页 - 带缓存""" model = Post template_name = 'blog/post_list.html' context_object_name = 'posts' paginate_by = 20 @method_decorator(cache_page(60 * 5)) # 缓存5分钟 @method_decorator(vary_on_headers('Cookie')) # 根据用户不同缓存 def dispatch(self, *args, **kwargs): return super().dispatch(*args, **kwargs) def get_queryset(self): # 使用 select_related 和 prefetch_related 减少查询 queryset = Post.objects.published().select_related( 'author', 'category' ).prefetch_related( 'tags', Prefetch('comments', queryset=Comment.objects.filter(is_approved=True)[:5]) ).only( 'title', 'slug', 'excerpt', 'cover_image', 'publish_time', 'view_count', 'like_count', 'comment_count', 'author__username', 'category__name' ) # 搜索 search_query = self.request.GET.get('q') if search_query: queryset = queryset.filter( Q(title__icontains=search_query) | Q(content__icontains=search_query) | Q(excerpt__icontains=search_query) ) # 分类过滤 category_slug = self.request.GET.get('category') if category_slug: queryset = queryset.filter(category__slug=category_slug) # 标签过滤 tag_slug = self.request.GET.get('tag') if tag_slug: queryset = queryset.filter(tags__slug=tag_slug) return queryset def get_context_data(self, **kwargs): context = super().get_context_data(**kwargs) # 缓存热门文章 hot_posts = cache.get('hot_posts') if not hot_posts: hot_posts = list(Post.objects.published().order_by('-view_count')[:10]) cache.set('hot_posts', hot_posts, 60 * 30) # 缓存30分钟 context['hot_posts'] = hot_posts context['categories'] = Category.objects.filter(post_count__gt=0) context['tags'] = Tag.objects.filter(post_count__gt=0) return context class PostDetailView(DetailView): """文章详情页""" model = Post template_name = 'blog/post_detail.html' context_object_name = 'post' def get_object(self): # 先从缓存获取 cache_key = f'post_detail:{self.kwargs["slug"]}' post = cache.get(cache_key) if not post: post = get_object_or_404( Post.objects.select_related('author', 'category') .prefetch_related('tags', 'comments__author'), slug=self.kwargs['slug'], status='published' ) cache.set(cache_key, post, 60 * 5) # 缓存5分钟 # 异步增加浏览量 increment_post_view.delay(post.id, self.request.META.get('REMOTE_ADDR')) return post def get_context_data(self, **kwargs): context = super().get_context_data(**kwargs) post = self.object # 获取上下篇文章 context['prev_post'] = Post.objects.published().filter( publish_time__lt=post.publish_time ).first() context['next_post'] = Post.objects.published().filter( publish_time__gt=post.publish_time ).order_by('publish_time').first() # 获取相关文章（同分类） context['related_posts'] = Post.objects.published().filter( category=post.category ).exclude(id=post.id)[:5] return context # ========== REST API ViewSets ========== class PostViewSet(viewsets.ReadOnlyModelViewSet): """文章 API""" serializer_class = PostListSerializer permission_classes = [permissions.AllowAny] filter_backends = [filters.SearchFilter, filters.OrderingFilter] search_fields = ['title', 'content'] ordering_fields = ['publish_time', 'view_count', 'like_count'] def get_serializer_class(self): if self.action == 'retrieve': return PostDetailSerializer return PostListSerializer def get_queryset(self): return Post.objects.published().select_related( 'author', 'category' ).prefetch_related('tags') @action(detail=True, methods=['post']) def like(self, request, pk=None): """点赞/取消点赞""" post = self.get_object() user = request.user like, created = Like.objects.get_or_create(user=user, post=post) if not created: like.delete() post.like_count -= 1 post.save(update_fields=['like_count']) return Response({'liked': False, 'count': post.like_count}) post.like_count += 1 post.save(update_fields=['like_count']) return Response({'liked': True, 'count': post.like_count}) @action(detail=True, methods=['get']) def comments(self, request, pk=None): """获取文章评论""" post = self.get_object() comments = Comment.objects.filter( post=post, is_approved=True ).select_related('author')[:50] from .serializers import CommentSerializer serializer = CommentSerializer(comments, many=True) return Response(serializer.data)

七、Celery 异步任务

# blog_project/celery.py import os from celery import Celery os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'blog_project.settings') app = Celery('blog_project') app.config_from_object('django.conf:settings', namespace='CELERY') app.autodiscover_tasks() @app.task(bind=True) def debug_task(self): print(f'Request: {self.request!r}')

# blog_app/tasks.py from celery import shared_task from django.core.cache import cache from django.db.models import F from django.core.mail import send_mail from django.conf import settings import logging logger = logging.getLogger(__name__) @shared_task(bind=True, max_retries=3) def increment_post_view(self, post_id, ip_address): """异步增加文章浏览量""" from .models import Post, PostView try: # 使用 F() 避免竞态条件 Post.objects.filter(id=post_id).update(view_count=F('view_count') + 1) # 记录浏览 PostView.objects.create( post_id=post_id, ip_address=ip_address ) # 清除文章详情缓存 cache.delete_pattern(f'post_detail:*') except Exception as exc: logger.error(f'增加浏览量失败: {exc}') raise self.retry(exc=exc, countdown=60) @shared_task def update_post_stats(post_id): """更新文章统计信息""" from .models import Post, Comment, Like post = Post.objects.get(id=post_id) post.comment_count = Comment.objects.filter(post=post, is_approved=True).count() post.like_count = Like.objects.filter(post=post).count() post.save(update_fields=['comment_count', 'like_count']) @shared_task def send_comment_notification(comment_id): """发送评论通知""" from .models import Comment comment = Comment.objects.select_related('post__author').get(id=comment_id) if comment.post.author.email: send_mail( subject=f'新评论: {comment.post.title}', message=f'{comment.author.username} 评论了您的文章:\n\n{comment.content}', from_email=settings.DEFAULT_FROM_EMAIL, recipient_list=[comment.post.author.email], fail_silently=True, ) @shared_task def generate_sitemap(): """生成站点地图""" from django.core.management import call_command call_command('sitemap') logger.info('站点地图生成完成') @shared_task def clean_expired_cache(): """清理过期缓存""" cache.clear() logger.info('缓存已清理')

八、Nginx 配置

# nginx.conf upstream django_backend { least_conn; # 最少连接算法 server 127.0.0.1:8001 weight=5; server 127.0.0.1:8002 weight=5; server 127.0.0.1:8003 weight=5; keepalive 32; # 保持连接池 } server { listen 80; server_name blog.example.com; return 301 https://$server_name$request_uri; } server { listen 443 ssl http2; server_name blog.example.com; # SSL 配置 ssl_certificate /etc/nginx/ssl/blog.crt; ssl_certificate_key /etc/nginx/ssl/blog.key; ssl_protocols TLSv1.2 TLSv1.3; ssl_ciphers HIGH:!aNULL:!MD5; ssl_prefer_server_ciphers on; ssl_session_cache shared:SSL:10m; ssl_session_timeout 10m; # Gzip 压缩 gzip on; gzip_types text/plain text/css application/json application/javascript text/xml application/xml application/xml+rss text/javascript image/svg+xml; gzip_min_length 256; gzip_comp_level 6; gzip_vary on; gzip_proxied any; gzip_disable "msie6"; # 静态文件缓存 location /static/ { alias /var/www/blog/staticfiles/; expires 30d; add_header Cache-Control "public, immutable"; access_log off; } location /media/ { alias /var/www/blog/media/; expires 7d; add_header Cache-Control "public, immutable"; } # 页面缓存 location / { # 尝试从缓存获取 try_files $uri $uri/ @django; } location @django { proxy_pass http://django_backend; 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; # WebSocket 支持 proxy_http_version 1.1; proxy_set_header Upgrade $http_upgrade; proxy_set_header Connection "upgrade"; # 缓冲配置 proxy_buffer_size 128k; proxy_buffers 4 256k; proxy_busy_buffers_size 256k; # 超时配置 proxy_connect_timeout 60s; proxy_read_timeout 60s; proxy_send_timeout 60s; # 缓存配置 proxy_cache blog_cache; proxy_cache_valid 200 302 5m; proxy_cache_valid 404 1m; proxy_cache_use_stale error timeout updating http_500 http_502 http_503 http_504; proxy_cache_lock on; proxy_cache_lock_timeout 5s; add_header X-Cache-Status $upstream_cache_status; } # 限制请求频率 limit_req_zone $binary_remote_addr zone=blog_limit:10m rate=30r/s; location /api/ { limit_req zone=blog_limit burst=50 nodelay; proxy_pass http://django_backend; } # 安全头 add_header X-Frame-Options DENY; add_header X-Content-Type-Options nosniff; add_header X-XSS-Protection "1; mode=block"; add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always; } # 缓存区域定义 proxy_cache_path /var/cache/nginx levels=1:2 keys_zone=blog_cache:50m max_size=1g inactive=60m use_temp_path=off;

九、Gunicorn 配置

# gunicorn.conf.py import multiprocessing # 绑定地址 bind = "0.0.0.0:8000" # 工作模式 worker_class = "sync" workers = multiprocessing.cpu_count() * 2 + 1 # 根据CPU核数调整 threads = 4 # 每个worker的线程数 # 超时设置 timeout = 120 keepalive = 65 # 保持连接时间 # 日志 accesslog = "/var/log/gunicorn/access.log" errorlog = "/var/log/gunicorn/error.log" loglevel = "info" # 进程管理 pidfile = "/var/run/gunicorn.pid" daemon = True # 预加载应用 preload_app = True # 重启 max_requests = 1000 max_requests_jitter = 50 # 内存优化 worker_connections = 1000

十、Supervisor 进程管理

# supervisor.conf [program:blog_gunicorn] command=gunicorn blog_project.wsgi:application -c gunicorn.conf.py directory=/var/www/blog user=www-data autostart=true autorestart=true redirect_stderr=true stdout_logfile=/var/log/supervisor/blog_gunicorn.log stderr_logfile=/var/log/supervisor/blog_gunicorn_err.log environment= DJANGO_SETTINGS_MODULE="blog_project.settings.production", DB_HOST="192.168.1.100", REDIS_URL="redis://192.168.1.101:6379/0" [program:blog_celery_worker] command=celery -A blog_project worker -l info -c 8 directory=/var/www/blog user=www-data autostart=true autorestart=true stdout_logfile=/var/log/supervisor/blog_celery_worker.log stderr_logfile=/var/log/supervisor/blog_celery_worker_err.log [program:blog_celery_beat] command=celery -A blog_project beat -l info --scheduler django_celery_beat.schedulers:DatabaseScheduler directory=/var/www/blog user=www-data autostart=true autorestart=true stdout_logfile=/var/log/supervisor/blog_celery_beat.log stderr_logfile=/var/log/supervisor/blog_celery_beat_err.log

十一、Docker Compose 部署

# docker-compose.yml version: '3.8' services: nginx: image: nginx:alpine ports: - "80:80" - "443:443" volumes: - ./nginx.conf:/etc/nginx/nginx.conf:ro - ./staticfiles:/var/www/blog/staticfiles:ro - ./media:/var/www/blog/media:ro - ./ssl:/etc/nginx/ssl:ro - nginx_cache:/var/cache/nginx depends_on: - web networks: - blog_network web: build: . expose: - "8000" volumes: - ./staticfiles:/app/staticfiles - ./media:/app/media environment: - DJANGO_SETTINGS_MODULE=blog_project.settings.production - DB_HOST=mysql - DB_USER=blog_user - DB_PASSWORD=${DB_PASSWORD} - REDIS_URL=redis://redis:6379/0 - CELERY_BROKER_URL=redis://redis:6379/2 depends_on: - mysql - redis command: > sh -c "python manage.py collectstatic --noinput && python manage.py migrate --noinput && gunicorn blog_project.wsgi:application -b 0.0.0.0:8000 -w 4 -k gthread --threads 4" restart: unless-stopped networks: - blog_network celery_worker: build: . environment: - DJANGO_SETTINGS_MODULE=blog_project.settings.production - DB_HOST=mysql - DB_USER=blog_user - DB_PASSWORD=${DB_PASSWORD} - REDIS_URL=redis://redis:6379/0 - CELERY_BROKER_URL=redis://redis:6379/2 depends_on: - mysql - redis command: celery -A blog_project worker -l info -c 8 restart: unless-stopped networks: - blog_network celery_beat: build: . environment: - DJANGO_SETTINGS_MODULE=blog_project.settings.production - DB_HOST=mysql - DB_USER=blog_user - DB_PASSWORD=${DB_PASSWORD} - REDIS_URL=redis://redis:6379/0 - CELERY_BROKER_URL=redis://redis:6379/2 depends_on: - mysql - redis command: celery -A blog_project beat -l info --scheduler django_celery_beat.schedulers:DatabaseScheduler restart: unless-stopped networks: - blog_network mysql: image: mysql:8.0 volumes: - mysql_data:/var/lib/mysql - ./init.sql:/docker-entrypoint-initdb.d/init.sql environment: - MYSQL_ROOT_PASSWORD=${MYSQL_ROOT_PASSWORD} - MYSQL_DATABASE=blog_db - MYSQL_USER=blog_user - MYSQL_PASSWORD=${DB_PASSWORD} ports: - "3306:3306" command: > --character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci --innodb_buffer_pool_size=2G --innodb_log_file_size=512M --innodb_flush_method=O_DIRECT --query_cache_type=0 --skip-name-resolve --max_connections=500 restart: unless-stopped networks: - blog_network redis: image: redis:7-alpine command: redis-server --appendonly yes --maxmemory 2gb --maxmemory-policy allkeys-lru volumes: - redis_data:/data ports: - "6379:6379" restart: unless-stopped networks: - blog_network volumes: mysql_data: redis_data: nginx_cache: networks: blog_network: driver: bridge

十二、性能压测与监控

12.1 压力测试脚本

# 使用 Apache Bench 测试 ab -n 10000 -c 100 -k https://blog.example.com/ # 使用 wrk 测试 wrk -t12 -c400 -d30s https://blog.example.com/ # 使用 locust 测试 locust -f locustfile.py --host=https://blog.example.com

12.2 MySQL 优化配置

# my.cnf 优化参数 [mysqld] # InnoDB 缓冲池（设置为物理内存的70%） innodb_buffer_pool_size = 4G innodb_buffer_pool_instances = 8 # 日志优化 innodb_log_file_size = 1G innodb_log_buffer_size = 64M # IO 优化 innodb_flush_method = O_DIRECT innodb_flush_log_at_trx_commit = 2 innodb_io_capacity = 2000 # 查询缓存（8.0已废弃，使用Redis替代） query_cache_type = 0 # 连接优化 max_connections = 500 thread_cache_size = 256 # 临时表优化 tmp_table_size = 64M max_heap_table_size = 64M # 慢查询日志 slow_query_log = 1 long_query_time = 2

十三、性能优化总结

这套方案经过生产验证，可支撑日均百万PV的博客系统。如需针对特定场景（如图片上传优化、全文搜索集成等）进一步优化，我可以继续补充。