537 lines
11 KiB
Markdown
537 lines
11 KiB
Markdown
# Production Deployment Guide
|
|
|
|
## Pre-Deployment Checklist
|
|
|
|
- [ ] Environment variables configured in `.env`
|
|
- [ ] PostgreSQL database created and migrated
|
|
- [ ] Redis running and accessible
|
|
- [ ] Telegram credentials verified
|
|
- [ ] SSL certificates prepared (if needed)
|
|
- [ ] Log rotation configured
|
|
- [ ] Monitoring and alerts set up
|
|
- [ ] Backups configured
|
|
- [ ] Health checks tested
|
|
|
|
## Deployment Methods
|
|
|
|
### 1. Docker Compose on VPS
|
|
|
|
#### 1.1 Prepare Server
|
|
|
|
```bash
|
|
# Update system
|
|
sudo apt update && sudo apt upgrade -y
|
|
|
|
# Install Docker
|
|
curl -fsSL https://get.docker.com -o get-docker.sh
|
|
sudo sh get-docker.sh
|
|
|
|
# Install Docker Compose
|
|
sudo curl -L "https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
|
|
sudo chmod +x /usr/local/bin/docker-compose
|
|
|
|
# Create non-root user for Docker
|
|
sudo usermod -aG docker $USER
|
|
newgrp docker
|
|
```
|
|
|
|
#### 1.2 Deploy Application
|
|
|
|
```bash
|
|
# Clone repository
|
|
mkdir -p /home/bot
|
|
cd /home/bot
|
|
git clone https://github.com/yourusername/TG_autoposter.git
|
|
cd TG_autoposter
|
|
|
|
# Create environment file
|
|
nano .env
|
|
# Fill in production values
|
|
|
|
# Start services
|
|
docker-compose -f docker-compose.yml -f docker-compose.prod.yml up -d
|
|
|
|
# Verify services
|
|
docker-compose ps
|
|
```
|
|
|
|
#### 1.3 Database Migrations
|
|
|
|
```bash
|
|
# Run migrations
|
|
docker-compose exec bot alembic upgrade head
|
|
|
|
# Verify
|
|
docker-compose exec bot alembic current
|
|
```
|
|
|
|
#### 1.4 Monitoring
|
|
|
|
```bash
|
|
# View logs
|
|
docker-compose logs -f
|
|
|
|
# Monitor specific service
|
|
docker-compose logs -f bot
|
|
docker-compose logs -f celery_worker_send
|
|
|
|
# Check health
|
|
docker-compose ps
|
|
```
|
|
|
|
### 2. Kubernetes Deployment
|
|
|
|
#### 2.1 Create Kubernetes Manifests
|
|
|
|
```bash
|
|
# Create namespace
|
|
kubectl create namespace telegram-bot
|
|
kubectl config set-context --current --namespace=telegram-bot
|
|
|
|
# Create ConfigMap for environment variables
|
|
kubectl create configmap bot-config --from-env-file=.env.prod
|
|
|
|
# Create Secrets for sensitive data
|
|
kubectl create secret generic bot-secrets \
|
|
--from-literal=telegram-bot-token=$TELEGRAM_BOT_TOKEN \
|
|
--from-literal=db-password=$DB_PASSWORD \
|
|
--from-literal=redis-password=$REDIS_PASSWORD
|
|
```
|
|
|
|
#### 2.2 Deploy Services
|
|
|
|
See `k8s/` directory for manifests:
|
|
- `postgres-deployment.yaml`
|
|
- `redis-deployment.yaml`
|
|
- `bot-deployment.yaml`
|
|
- `celery-worker-deployment.yaml`
|
|
- `celery-beat-deployment.yaml`
|
|
- `flower-deployment.yaml`
|
|
|
|
```bash
|
|
# Apply manifests
|
|
kubectl apply -f k8s/
|
|
|
|
# Monitor deployment
|
|
kubectl get pods
|
|
kubectl logs -f deployment/bot
|
|
```
|
|
|
|
### 3. Using Systemd Service
|
|
|
|
#### 3.1 Create Service File
|
|
|
|
```bash
|
|
sudo tee /etc/systemd/system/tg-autoposter.service > /dev/null <<EOF
|
|
[Unit]
|
|
Description=TG Autoposter Bot
|
|
After=network.target docker.service
|
|
Requires=docker.service
|
|
|
|
[Service]
|
|
Type=simple
|
|
User=bot
|
|
WorkingDirectory=/home/bot/TG_autoposter
|
|
ExecStart=/usr/local/bin/docker-compose up
|
|
ExecStop=/usr/local/bin/docker-compose down
|
|
Restart=always
|
|
RestartSec=10
|
|
|
|
[Install]
|
|
WantedBy=multi-user.target
|
|
EOF
|
|
```
|
|
|
|
#### 3.2 Enable Service
|
|
|
|
```bash
|
|
sudo systemctl daemon-reload
|
|
sudo systemctl enable tg-autoposter
|
|
sudo systemctl start tg-autoposter
|
|
|
|
# Check status
|
|
sudo systemctl status tg-autoposter
|
|
|
|
# View logs
|
|
sudo journalctl -u tg-autoposter -f
|
|
```
|
|
|
|
## Configuration for Production
|
|
|
|
### 1. Environment Variables
|
|
|
|
Create `.env` with production values:
|
|
|
|
```env
|
|
# Core
|
|
TELEGRAM_BOT_TOKEN=your_production_token
|
|
TELEGRAM_API_ID=your_api_id
|
|
TELEGRAM_API_HASH=your_api_hash
|
|
ADMIN_ID=your_admin_id
|
|
|
|
# Database (use managed service like RDS, CloudSQL)
|
|
DB_HOST=db.example.com
|
|
DB_PORT=5432
|
|
DB_USER=bot_user
|
|
DB_PASSWORD=secure_password_here
|
|
DB_NAME=tg_autoposter_prod
|
|
DB_SSL_MODE=require
|
|
|
|
# Redis (use managed service like ElastiCache, Redis Cloud)
|
|
REDIS_HOST=redis.example.com
|
|
REDIS_PORT=6379
|
|
REDIS_DB=0
|
|
REDIS_PASSWORD=secure_redis_password
|
|
|
|
# Logging
|
|
LOG_LEVEL=INFO
|
|
LOG_FILE=/var/log/tg-autoposter/bot.log
|
|
|
|
# Security
|
|
SECRET_KEY=your_secret_key_here
|
|
DEBUG=False
|
|
ALLOWED_HOSTS=yourdomain.com,www.yourdomain.com
|
|
```
|
|
|
|
### 2. Database Configuration
|
|
|
|
```yaml
|
|
# docker-compose.prod.yml
|
|
services:
|
|
postgres:
|
|
image: postgres:15-alpine
|
|
environment:
|
|
POSTGRES_PASSWORD: ${DB_PASSWORD}
|
|
POSTGRES_DB: ${DB_NAME}
|
|
volumes:
|
|
- postgres_data:/var/lib/postgresql/data
|
|
ports:
|
|
- "5432:5432"
|
|
healthcheck:
|
|
test: ["CMD-SHELL", "pg_isready -U ${DB_USER}"]
|
|
interval: 10s
|
|
timeout: 5s
|
|
retries: 5
|
|
```
|
|
|
|
### 3. Redis Configuration
|
|
|
|
```yaml
|
|
# docker-compose.prod.yml
|
|
services:
|
|
redis:
|
|
image: redis:7-alpine
|
|
command: redis-server --requirepass ${REDIS_PASSWORD}
|
|
volumes:
|
|
- redis_data:/data
|
|
ports:
|
|
- "6379:6379"
|
|
healthcheck:
|
|
test: ["CMD", "redis-cli", "--raw", "incr", "ping"]
|
|
interval: 10s
|
|
timeout: 5s
|
|
retries: 5
|
|
```
|
|
|
|
## Scaling Considerations
|
|
|
|
### 1. Horizontal Scaling
|
|
|
|
```yaml
|
|
# docker-compose.prod.yml - Multiple workers
|
|
services:
|
|
celery_worker_send_1:
|
|
# ... worker configuration
|
|
|
|
celery_worker_send_2:
|
|
# ... worker configuration
|
|
|
|
celery_worker_send_3:
|
|
# ... worker configuration
|
|
|
|
# Use load balancer or Docker Swarm for orchestration
|
|
```
|
|
|
|
### 2. Performance Tuning
|
|
|
|
```python
|
|
# app/settings.py
|
|
CELERY_WORKER_PREFETCH_MULTIPLIER = 1
|
|
CELERY_WORKER_MAX_TASKS_PER_CHILD = 1000
|
|
CELERY_TASK_TIME_LIMIT = 30 * 60 # 30 minutes
|
|
CELERY_TASK_SOFT_TIME_LIMIT = 25 * 60 # 25 minutes
|
|
|
|
# Database connection pooling
|
|
DB_POOL_SIZE = 20
|
|
DB_MAX_OVERFLOW = 0
|
|
DB_POOL_TIMEOUT = 30
|
|
DB_POOL_RECYCLE = 3600
|
|
```
|
|
|
|
### 3. Caching Strategy
|
|
|
|
```python
|
|
# Use Redis for caching
|
|
CACHE_TTL = 300 # 5 minutes
|
|
BROADCAST_CACHE_TTL = 3600 # 1 hour
|
|
MEMBERS_CACHE_TTL = 1800 # 30 minutes
|
|
```
|
|
|
|
## Monitoring & Logging
|
|
|
|
### 1. Logging Setup
|
|
|
|
```bash
|
|
# Create log directory
|
|
sudo mkdir -p /var/log/tg-autoposter
|
|
sudo chown bot:bot /var/log/tg-autoposter
|
|
|
|
# Configure log rotation
|
|
sudo tee /etc/logrotate.d/tg-autoposter > /dev/null <<EOF
|
|
/var/log/tg-autoposter/*.log {
|
|
daily
|
|
rotate 14
|
|
compress
|
|
delaycompress
|
|
notifempty
|
|
create 0640 bot bot
|
|
sharedscripts
|
|
postrotate
|
|
systemctl reload tg-autoposter > /dev/null 2>&1 || true
|
|
endscript
|
|
}
|
|
EOF
|
|
```
|
|
|
|
### 2. Prometheus Metrics
|
|
|
|
```python
|
|
# app/metrics.py
|
|
from prometheus_client import Counter, Histogram, Gauge
|
|
|
|
message_sent = Counter('messages_sent_total', 'Total messages sent')
|
|
message_failed = Counter('messages_failed_total', 'Total failed messages')
|
|
send_duration = Histogram('message_send_duration_seconds', 'Message send duration')
|
|
queue_size = Gauge('celery_queue_size', 'Celery queue size')
|
|
```
|
|
|
|
### 3. Monitoring with ELK Stack
|
|
|
|
```yaml
|
|
# docker-compose.prod.yml
|
|
services:
|
|
elasticsearch:
|
|
image: docker.elastic.co/elasticsearch/elasticsearch:8.0.0
|
|
|
|
kibana:
|
|
image: docker.elastic.co/kibana/kibana:8.0.0
|
|
ports:
|
|
- "5601:5601"
|
|
|
|
logstash:
|
|
image: docker.elastic.co/logstash/logstash:8.0.0
|
|
volumes:
|
|
- ./logstash.conf:/usr/share/logstash/pipeline/logstash.conf
|
|
```
|
|
|
|
## Backup & Recovery
|
|
|
|
### 1. Database Backup
|
|
|
|
```bash
|
|
#!/bin/bash
|
|
# backup-db.sh
|
|
BACKUP_DIR="/backups/postgres"
|
|
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
|
|
BACKUP_FILE="$BACKUP_DIR/tg_autoposter_$TIMESTAMP.sql"
|
|
|
|
mkdir -p $BACKUP_DIR
|
|
|
|
# Backup
|
|
docker-compose exec -T postgres pg_dump -U $DB_USER $DB_NAME > $BACKUP_FILE
|
|
|
|
# Compress
|
|
gzip $BACKUP_FILE
|
|
|
|
# Remove old backups (keep 7 days)
|
|
find $BACKUP_DIR -name "*.sql.gz" -mtime +7 -delete
|
|
|
|
echo "Backup completed: $BACKUP_FILE.gz"
|
|
```
|
|
|
|
### 2. Redis Snapshot
|
|
|
|
```bash
|
|
#!/bin/bash
|
|
# backup-redis.sh
|
|
BACKUP_DIR="/backups/redis"
|
|
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
|
|
|
|
mkdir -p $BACKUP_DIR
|
|
|
|
# Create snapshot
|
|
docker-compose exec -T redis redis-cli BGSAVE
|
|
|
|
# Copy snapshot
|
|
docker-compose exec -T redis cp /data/dump.rdb /data/dump_$TIMESTAMP.rdb
|
|
|
|
echo "Redis backup completed"
|
|
```
|
|
|
|
### 3. Restore Database
|
|
|
|
```bash
|
|
# Drop and recreate database
|
|
docker-compose exec -T postgres dropdb -U $DB_USER $DB_NAME
|
|
docker-compose exec -T postgres createdb -U $DB_USER $DB_NAME
|
|
|
|
# Restore from backup
|
|
gunzip < /backups/postgres/tg_autoposter_*.sql.gz | \
|
|
docker-compose exec -T postgres psql -U $DB_USER $DB_NAME
|
|
```
|
|
|
|
## Security Best Practices
|
|
|
|
### 1. Environment Hardening
|
|
|
|
```bash
|
|
# Restrict file permissions
|
|
chmod 600 .env
|
|
chmod 700 /var/log/tg-autoposter
|
|
chmod 700 /backups
|
|
|
|
# Set ownership
|
|
sudo chown bot:bot /home/bot/TG_autoposter -R
|
|
```
|
|
|
|
### 2. Network Security
|
|
|
|
```yaml
|
|
# docker-compose.prod.yml
|
|
services:
|
|
bot:
|
|
networks:
|
|
- backend
|
|
expose:
|
|
- 8000
|
|
|
|
postgres:
|
|
networks:
|
|
- backend
|
|
expose:
|
|
- 5432
|
|
|
|
networks:
|
|
backend:
|
|
driver: bridge
|
|
driver_opts:
|
|
com.docker.network.bridge.name: br_backend
|
|
```
|
|
|
|
### 3. SSL/TLS
|
|
|
|
```bash
|
|
# Generate SSL certificate
|
|
certbot certonly --standalone -d yourdomain.com
|
|
|
|
# Configure in docker-compose.prod.yml
|
|
services:
|
|
nginx:
|
|
image: nginx:latest
|
|
volumes:
|
|
- /etc/letsencrypt:/etc/letsencrypt
|
|
- ./nginx.conf:/etc/nginx/nginx.conf
|
|
ports:
|
|
- "443:443"
|
|
```
|
|
|
|
## Troubleshooting Production Issues
|
|
|
|
### Issue: Memory Leaks
|
|
|
|
```bash
|
|
# Monitor memory usage
|
|
docker stats
|
|
|
|
# Restart worker
|
|
docker-compose restart celery_worker_send
|
|
|
|
# Check logs for errors
|
|
docker-compose logs celery_worker_send | grep -i error
|
|
```
|
|
|
|
### Issue: Database Connection Timeouts
|
|
|
|
```bash
|
|
# Increase pool size in settings
|
|
DB_POOL_SIZE = 30
|
|
|
|
# Check database status
|
|
docker-compose exec postgres psql -U bot -d tg_autoposter -c "SELECT datname, pid FROM pg_stat_activity;"
|
|
|
|
# Restart database
|
|
docker-compose restart postgres
|
|
```
|
|
|
|
### Issue: High CPU Usage
|
|
|
|
```bash
|
|
# Identify problematic tasks
|
|
docker-compose exec flower curl -s http://localhost:5555/api/stats | python -m json.tool
|
|
|
|
# Reduce worker concurrency
|
|
CELERY_WORKER_CONCURRENCY = 2
|
|
```
|
|
|
|
## CI/CD Integration
|
|
|
|
### GitHub Actions Example
|
|
|
|
```yaml
|
|
# .github/workflows/deploy.yml
|
|
name: Deploy to Production
|
|
|
|
on:
|
|
push:
|
|
branches: [main]
|
|
|
|
jobs:
|
|
deploy:
|
|
runs-on: ubuntu-latest
|
|
steps:
|
|
- uses: actions/checkout@v3
|
|
- name: Deploy to VPS
|
|
uses: appleboy/ssh-action@master
|
|
with:
|
|
host: ${{ secrets.VPS_HOST }}
|
|
username: ${{ secrets.VPS_USER }}
|
|
key: ${{ secrets.VPS_SSH_KEY }}
|
|
script: |
|
|
cd /home/bot/TG_autoposter
|
|
git pull origin main
|
|
docker-compose -f docker-compose.yml -f docker-compose.prod.yml up -d
|
|
docker-compose exec bot alembic upgrade head
|
|
```
|
|
|
|
## Support and Monitoring Links
|
|
|
|
- **Flower Dashboard**: http://yourserver.com:5555
|
|
- **PostgreSQL Monitoring**: pgAdmin (if enabled)
|
|
- **Application Logs**: `/var/log/tg-autoposter/`
|
|
- **Health Check Endpoint**: `/health` (if implemented)
|
|
|
|
## Maintenance Schedule
|
|
|
|
- **Daily**: Check logs for errors
|
|
- **Weekly**: Review resource usage
|
|
- **Monthly**: Security updates, dependency updates
|
|
- **Quarterly**: Performance analysis, capacity planning
|
|
|
|
## Contact & Support
|
|
|
|
For issues or questions:
|
|
1. Check logs and error messages
|
|
2. Review GitHub issues
|
|
3. Contact team lead
|
|
4. Escalate to DevOps team if needed
|