Hướng dẫn cài đặt Rocket.Chat với Docker Compose trên Ubuntu

# Cập nhật package lists
sudo apt update && sudo apt upgrade -y

# Cài đặt các package cần thiết
sudo apt install -y \
    curl \
    wget \
    git \
    nano \
    vim \
    htop \
    tree \
    unzip \
    software-properties-common \
    apt-transport-https \
    ca-certificates \
    gnupg \
    lsb-release

# Khởi động lại để áp dụng các updates
sudo reboot

# Gỡ bỏ Docker cũ (nếu có)
sudo apt remove -y docker docker-engine docker.io containerd runc

# Thêm Docker GPG key
sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

# Thêm Docker repository
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# Cập nhật package lists
sudo apt update

# Cài đặt Docker Engine
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

# Thêm user hiện tại vào Docker group
sudo usermod -aG docker $USER

# Khởi động Docker service
sudo systemctl enable docker
sudo systemctl start docker

# Logout và login lại để áp dụng group changes
newgrp docker

# Verify Docker installation
docker --version
docker compose version

# Enable UFW firewall
sudo ufw enable

# Mở các ports cần thiết
sudo ufw allow 22/tcp      # SSH
sudo ufw allow 80/tcp      # HTTP
sudo ufw allow 443/tcp     # HTTPS
sudo ufw allow 3000/tcp    # Rocket.Chat (development)

# Kiểm tra status
sudo ufw status verbose

# Tạo thư mục cho Rocket.Chat
sudo mkdir -p /opt/rocket.chat
sudo chown $USER:$USER /opt/rocket.chat
cd /opt/rocket.chat

# Tạo cấu trúc thư mục
mkdir -p {data,logs,backups,ssl}

# Tải compose file chính thức
curl -L https://go.rocket.chat/i/docker-compose.yml -O

# Hoặc tạo file compose.yml tùy chỉnh
nano compose.yml

version: '3.8'

services:
  rocketchat:
    image: registry.rocket.chat/rocketchat/rocket.chat:${RELEASE:-latest}
    container_name: rocketchat
    restart: unless-stopped
    depends_on:
      - mongodb
    environment:
      - MONGO_URL=${MONGO_URL:-mongodb://mongodb:27017/rocketchat?replicaSet=rs0}
      - MONGO_OPLOG_URL=${MONGO_OPLOG_URL:-mongodb://mongodb:27017/local?replicaSet=rs0}
      - ROOT_URL=${ROOT_URL:-http://localhost:3000}
      - PORT=${PORT:-3000}
      - SITE_URL=${SITE_URL:-http://localhost:3000}
      - ADMIN_USERNAME=${ADMIN_USERNAME:-admin}
      - ADMIN_PASS=${ADMIN_PASS:-admin}
      - ADMIN_EMAIL=${ADMIN_EMAIL:[email protected]}
      - OVERWRITE_SETTING_Show_Setup_Wizard=completed
      - REG_TOKEN=${REG_TOKEN:-}
      - INSTANCE_IP=${INSTANCE_IP:-}
      - DEPLOY_METHOD=docker
      - DEPLOY_PLATFORM=docker-compose
    ports:
      - "${HOST_PORT:-3000}:3000"
    volumes:
      - ./data/rocketchat/uploads:/app/uploads
      - ./data/rocketchat/data:/app/data
      - ./logs/rocketchat:/app/logs
    networks:
      - rocketchat_network
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3000/api/info"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 60s
    logging:
      driver: json-file
      options:
        max-size: "10m"
        max-file: "3"

  mongodb:
    image: mongo:${MONGO_VERSION:-6.0}
    container_name: mongodb
    restart: unless-stopped
    command: >
      mongod 
      --oplogSize 128 
      --replSet rs0 
      --storageEngine wiredTiger 
      --bind_ip_all
    environment:
      - MONGO_INITDB_ROOT_USERNAME=${MONGO_ROOT_USERNAME:-root}
      - MONGO_INITDB_ROOT_PASSWORD=${MONGO_ROOT_PASSWORD:-password}
      - MONGO_INITDB_DATABASE=${MONGO_DB:-rocketchat}
    volumes:
      - ./data/mongodb:/data/db
      - ./data/mongodb/configdb:/data/configdb
      - ./logs/mongodb:/var/log/mongodb
    networks:
      - rocketchat_network
    healthcheck:
      test: ["CMD", "mongo", "--eval", "db.adminCommand('ping')"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 30s
    logging:
      driver: json-file
      options:
        max-size: "10m"
        max-file: "3"

  # MongoDB initialization container
  mongo-init-replica:
    image: mongo:${MONGO_VERSION:-6.0}
    container_name: mongo-init-replica
    depends_on:
      - mongodb
    command: >
      mongosh --host mongodb:27017 --eval 
      "
      var config = {
        '_id': 'rs0',
        'version': 1,
        'members': [
          { '_id': 1, 'host': 'mongodb:27017', 'priority': 1 }
        ]
      };
      rs.initiate(config, { force: true });
      rs.status();
      "
    networks:
      - rocketchat_network
    restart: "no"

  # Redis for caching (optional but recommended)
  redis:
    image: redis:${REDIS_VERSION:-7-alpine}
    container_name: redis
    restart: unless-stopped
    command: redis-server --appendonly yes --maxmemory 512mb --maxmemory-policy allkeys-lru
    volumes:
      - ./data/redis:/data
    networks:
      - rocketchat_network
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 30s
      timeout: 10s
      retries: 3
    logging:
      driver: json-file
      options:
        max-size: "10m"
        max-file: "3"

  # Nginx reverse proxy (optional)
  nginx:
    image: nginx:${NGINX_VERSION:-alpine}
    container_name: nginx
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx/conf.d:/etc/nginx/conf.d
      - ./ssl:/etc/nginx/ssl
      - ./logs/nginx:/var/log/nginx
    depends_on:
      - rocketchat
    networks:
      - rocketchat_network
    logging:
      driver: json-file
      options:
        max-size: "10m"
        max-file: "3"

networks:
  rocketchat_network:
    driver: bridge
    ipam:
      driver: default
      config:
        - subnet: 172.20.0.0/16

volumes:
  mongodb_data:
  redis_data:
  rocketchat_data:

# Tạo file .env
nano .env

# =============================================================================
# ROCKET.CHAT CONFIGURATION
# =============================================================================

# Rocket.Chat Version
RELEASE=latest

# Server Configuration
ROOT_URL=http://localhost:3000
SITE_URL=http://localhost:3000
PORT=3000
HOST_PORT=3000

# Admin Configuration
ADMIN_USERNAME=admin
ADMIN_PASS=SecurePassword123!
[email protected]

# MongoDB Configuration
MONGO_VERSION=6.0
MONGO_URL=mongodb://mongodb:27017/rocketchat?replicaSet=rs0
MONGO_OPLOG_URL=mongodb://mongodb:27017/local?replicaSet=rs0
MONGO_ROOT_USERNAME=root
MONGO_ROOT_PASSWORD=SecureMongoPassword123!
MONGO_DB=rocketchat

# Redis Configuration
REDIS_VERSION=7-alpine

# Nginx Configuration
NGINX_VERSION=alpine

# Registration Token (optional)
REG_TOKEN=

# Instance IP (optional)
INSTANCE_IP=

# SSL Configuration (for production)
SSL_ENABLED=false
SSL_CERT_PATH=/etc/nginx/ssl/cert.pem
SSL_KEY_PATH=/etc/nginx/ssl/key.pem

# Backup Configuration
BACKUP_ENABLED=true
BACKUP_SCHEDULE=0 2 * * *
BACKUP_RETENTION_DAYS=7

# Logging Configuration
LOG_LEVEL=info
LOG_FILE=/app/logs/rocketchat.log

# Performance Configuration
OPTIMIZE_FOR_MEMORY=true
CACHE_DRIVER=redis
CACHE_URL=redis://redis:6379

# Security Configuration
SECURITY_HEADERS=true
TRUSTED_PROXY_COUNT=1

# Tạo thư mục cấu hình Nginx
mkdir -p nginx/conf.d

# Tạo file cấu hình Nginx
nano nginx/conf.d/rocketchat.conf

# Rocket.Chat Nginx Configuration
upstream rocketchat_backend {
    server rocketchat:3000;
}

# HTTP Configuration
server {
    listen 80;
    server_name localhost;

    # Security headers
    add_header X-Frame-Options "SAMEORIGIN" always;
    add_header X-Content-Type-Options "nosniff" always;
    add_header X-XSS-Protection "1; mode=block" always;
    add_header Referrer-Policy "no-referrer-when-downgrade" always;

    # Gzip compression
    gzip on;
    gzip_vary on;
    gzip_min_length 1024;
    gzip_types text/plain text/css text/xml text/javascript application/javascript application/xml+rss application/json;

    # Client max body size
    client_max_body_size 200M;

    # Logging
    access_log /var/log/nginx/rocketchat.access.log;
    error_log /var/log/nginx/rocketchat.error.log;

    # Proxy configuration
    location / {
        proxy_pass http://rocketchat_backend;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        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_set_header X-Nginx-Proxy true;
        proxy_cache_bypass $http_upgrade;
        proxy_redirect off;

        # Timeouts
        proxy_connect_timeout 60s;
        proxy_send_timeout 60s;
        proxy_read_timeout 60s;

        # Buffer settings
        proxy_buffering on;
        proxy_buffer_size 4k;
        proxy_buffers 8 4k;
        proxy_busy_buffers_size 8k;
    }

    # Health check endpoint
    location /api/info {
        proxy_pass http://rocketchat_backend/api/info;
        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;

        # Cache health checks
        proxy_cache_valid 200 30s;
        proxy_cache_valid 404 1m;
    }

    # Static files
    location ~* \.(js|css|png|jpg|jpeg|gif|ico|svg|woff|woff2|ttf|eot)$ {
        proxy_pass http://rocketchat_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;

        # Cache static files
        expires 1y;
        add_header Cache-Control "public, immutable";
        add_header Vary "Accept-Encoding";
    }
}

# Tạo thư mục dữ liệu
mkdir -p data/{mongodb,redis,rocketchat/{uploads,data}} logs/{mongodb,nginx,rocketchat}

# Set permissions
sudo chown -R $USER:$USER data logs

# Khởi chạy MongoDB trước
docker compose up -d mongodb

# Chờ MongoDB khởi động
echo "Waiting for MongoDB to start..."
sleep 30

# Khởi tạo MongoDB replica set
docker compose up mongo-init-replica

# Chờ replica set khởi tạo
echo "Waiting for replica set initialization..."
sleep 30

# Khởi chạy tất cả services
docker compose up -d

# Kiểm tra status
docker compose ps

# Kiểm tra logs
docker compose logs -f rocketchat

# Kiểm tra health check
curl -f http://localhost:3000/api/info

# Kiểm tra MongoDB
docker exec -it mongodb mongosh --eval "rs.status()"

# Kiểm tra services
docker compose ps

# Cài đặt Certbot
sudo apt install -y certbot python3-certbot-nginx

# Tạo SSL certificate
sudo certbot certonly --standalone -d yourdomain.com -d www.yourdomain.com

# Tạo Nginx config cho HTTPS
nano nginx/conf.d/rocketchat-ssl.conf

# HTTPS Configuration
server {
    listen 443 ssl http2;
    server_name yourdomain.com www.yourdomain.com;

    # SSL Configuration
    ssl_certificate /etc/nginx/ssl/fullchain.pem;
    ssl_certificate_key /etc/nginx/ssl/privkey.pem;
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers ECDHE-RSA-AES256-GCM-SHA512:DHE-RSA-AES256-GCM-SHA512:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES256-GCM-SHA384;
    ssl_prefer_server_ciphers off;
    ssl_session_cache shared:SSL:10m;
    ssl_session_timeout 10m;
    ssl_stapling on;
    ssl_stapling_verify on;

    # Security headers
    add_header Strict-Transport-Security "max-age=63072000; includeSubDomains; preload" always;
    add_header X-Frame-Options "SAMEORIGIN" always;
    add_header X-Content-Type-Options "nosniff" always;
    add_header X-XSS-Protection "1; mode=block" always;
    add_header Referrer-Policy "no-referrer-when-downgrade" always;

    # Client max body size
    client_max_body_size 200M;

    # Logging
    access_log /var/log/nginx/rocketchat-ssl.access.log;
    error_log /var/log/nginx/rocketchat-ssl.error.log;

    # Proxy configuration
    location / {
        proxy_pass http://rocketchat_backend;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        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 https;
        proxy_set_header X-Nginx-Proxy true;
        proxy_cache_bypass $http_upgrade;
        proxy_redirect off;

        # Timeouts
        proxy_connect_timeout 60s;
        proxy_send_timeout 60s;
        proxy_read_timeout 60s;
    }
}

# Redirect HTTP to HTTPS
server {
    listen 80;
    server_name yourdomain.com www.yourdomain.com;
    return 301 https://$server_name$request_uri;
}

# Cập nhật file .env
nano .env

# Production Configuration
ROOT_URL=https://yourdomain.com
SITE_URL=https://yourdomain.com
HOST_PORT=80

# SSL Configuration
SSL_ENABLED=true
SSL_CERT_PATH=/etc/nginx/ssl/fullchain.pem
SSL_KEY_PATH=/etc/nginx/ssl/privkey.pem

# Strong passwords
ADMIN_PASS=VerySecurePassword123!@#
MONGO_ROOT_PASSWORD=VerySecureMongoPassword123!@#

# Performance optimization
OPTIMIZE_FOR_MEMORY=true
CACHE_DRIVER=redis
CACHE_URL=redis://redis:6379

# Copy SSL certificates
sudo cp /etc/letsencrypt/live/yourdomain.com/fullchain.pem ssl/
sudo cp /etc/letsencrypt/live/yourdomain.com/privkey.pem ssl/
sudo chown $USER:$USER ssl/*.pem

# Restart services
docker compose down
docker compose up -d

# Kiểm tra HTTPS
curl -I https://yourdomain.com

# Tạo backup script
nano backup-rocketchat.sh

#!/bin/bash

# Rocket.Chat Backup Script
BACKUP_DIR="/opt/rocket.chat/backups"
DATE=$(date +%Y%m%d_%H%M%S)
ROCKETCHAT_DIR="/opt/rocket.chat"
RETENTION_DAYS=7

# Create backup directory
mkdir -p $BACKUP_DIR

echo "Starting Rocket.Chat backup at $(date)"

# Stop Rocket.Chat container
echo "Stopping Rocket.Chat container..."
cd $ROCKETCHAT_DIR
docker compose stop rocketchat

# Backup MongoDB
echo "Backing up MongoDB..."
docker exec mongodb mongodump --archive=/tmp/mongodb_$DATE.archive --gzip
docker cp mongodb:/tmp/mongodb_$DATE.archive $BACKUP_DIR/
docker exec mongodb rm /tmp/mongodb_$DATE.archive

# Backup file uploads
echo "Backing up file uploads..."
tar -czf $BACKUP_DIR/uploads_$DATE.tar.gz -C $ROCKETCHAT_DIR/data/rocketchat uploads/

# Backup configuration
echo "Backing up configuration..."
tar -czf $BACKUP_DIR/config_$DATE.tar.gz -C $ROCKETCHAT_DIR .env compose.yml nginx/

# Create consolidated backup
echo "Creating consolidated backup..."
tar -czf $BACKUP_DIR/rocketchat_full_backup_$DATE.tar.gz -C $BACKUP_DIR mongodb_$DATE.archive uploads_$DATE.tar.gz config_$DATE.tar.gz

# Cleanup individual files
rm -f $BACKUP_DIR/mongodb_$DATE.archive $BACKUP_DIR/uploads_$DATE.tar.gz $BACKUP_DIR/config_$DATE.tar.gz

# Restart Rocket.Chat
echo "Restarting Rocket.Chat..."
docker compose start rocketchat

# Cleanup old backups
echo "Cleaning up old backups..."
find $BACKUP_DIR -name "rocketchat_full_backup_*.tar.gz" -mtime +$RETENTION_DAYS -delete

echo "Backup completed at $(date)"
echo "Backup saved to: $BACKUP_DIR/rocketchat_full_backup_$DATE.tar.gz"

# Upload to cloud storage (optional)
if [ -n "$S3_BUCKET" ]; then
    echo "Uploading to S3..."
    aws s3 cp $BACKUP_DIR/rocketchat_full_backup_$DATE.tar.gz s3://$S3_BUCKET/rocketchat-backups/
fi

# Make executable
chmod +x backup-rocketchat.sh

# Add to crontab
crontab -e
# Add: 0 2 * * * /opt/rocket.chat/backup-rocketchat.sh >> /opt/rocket.chat/backup.log 2>&1

# Tạo restore script
nano restore-rocketchat.sh

#!/bin/bash

# Rocket.Chat Restore Script
BACKUP_FILE=$1
ROCKETCHAT_DIR="/opt/rocket.chat"
TEMP_DIR="/tmp/restore_$(date +%Y%m%d_%H%M%S)"

if [ -z "$BACKUP_FILE" ]; then
    echo "Usage: $0 <backup_file.tar.gz>"
    exit 1
fi

echo "Starting Rocket.Chat restore from $BACKUP_FILE"

# Create temp directory
mkdir -p $TEMP_DIR

# Extract backup
echo "Extracting backup..."
tar -xzf $BACKUP_FILE -C $TEMP_DIR

# Stop services
echo "Stopping services..."
cd $ROCKETCHAT_DIR
docker compose down

# Restore MongoDB
echo "Restoring MongoDB..."
docker compose up -d mongodb
sleep 30
docker exec -i mongodb mongorestore --archive=/tmp/restore.archive --gzip < $TEMP_DIR/mongodb_*.archive

# Restore file uploads
echo "Restoring file uploads..."
rm -rf $ROCKETCHAT_DIR/data/rocketchat/uploads
tar -xzf $TEMP_DIR/uploads_*.tar.gz -C $ROCKETCHAT_DIR/data/rocketchat/

# Restore configuration
echo "Restoring configuration..."
tar -xzf $TEMP_DIR/config_*.tar.gz -C $ROCKETCHAT_DIR/

# Restart services
echo "Restarting services..."
docker compose up -d

# Cleanup
rm -rf $TEMP_DIR

echo "Restore completed at $(date)"

# Make executable
chmod +x restore-rocketchat.sh

# Tạo health check script
nano health-check.sh

#!/bin/bash

# Rocket.Chat Health Check Script
ROCKETCHAT_URL="http://localhost:3000"
ROCKETCHAT_DIR="/opt/rocket.chat"
LOG_FILE="/opt/rocket.chat/health-check.log"

# Colors
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m'

# Function to log messages
log_message() {
    echo -e "$(date '+%Y-%m-%d %H:%M:%S') - $1" | tee -a $LOG_FILE
}

# Check HTTP endpoint
check_http() {
    if curl -f -s $ROCKETCHAT_URL/api/info > /dev/null; then
        log_message "${GREEN}✅ HTTP endpoint is healthy${NC}"
        return 0
    else
        log_message "${RED}❌ HTTP endpoint is not responding${NC}"
        return 1
    fi
}

# Check Docker containers
check_containers() {
    cd $ROCKETCHAT_DIR
    local failed_containers=()

    for container in rocketchat mongodb redis nginx; do
        if docker compose ps | grep -q "$container.*Up"; then
            log_message "${GREEN}✅ $container is running${NC}"
        else
            log_message "${RED}❌ $container is not running${NC}"
            failed_containers+=($container)
        fi
    done

    return ${#failed_containers[@]}
}

# Check disk space
check_disk() {
    local disk_usage=$(df /opt/rocket.chat | tail -1 | awk '{print $5}' | sed 's/%//')

    if [ $disk_usage -gt 80 ]; then
        log_message "${RED}❌ Disk usage is high: ${disk_usage}%${NC}"
        return 1
    else
        log_message "${GREEN}✅ Disk usage is normal: ${disk_usage}%${NC}"
        return 0
    fi
}

# Check memory usage
check_memory() {
    local memory_usage=$(free | grep Mem | awk '{printf "%.0f", $3/$2 * 100.0}')

    if [ $memory_usage -gt 80 ]; then
        log_message "${YELLOW}⚠️ Memory usage is high: ${memory_usage}%${NC}"
        return 1
    else
        log_message "${GREEN}✅ Memory usage is normal: ${memory_usage}%${NC}"
        return 0
    fi
}

# Check MongoDB
check_mongodb() {
    if docker exec mongodb mongosh --eval "db.runCommand('ping')" > /dev/null 2>&1; then
        log_message "${GREEN}✅ MongoDB is healthy${NC}"
        return 0
    else
        log_message "${RED}❌ MongoDB is not responding${NC}"
        return 1
    fi
}

# Check logs for errors
check_logs() {
    local error_count=$(docker compose logs --tail=50 rocketchat 2>/dev/null | grep -i "error\|exception\|failed" | wc -l)

    if [ $error_count -gt 0 ]; then
        log_message "${YELLOW}⚠️ Found $error_count errors in recent logs${NC}"
        return 1
    else
        log_message "${GREEN}✅ No errors in recent logs${NC}"
        return 0
    fi
}

# Main health check
main() {
    log_message "=== Rocket.Chat Health Check Started ==="

    local errors=0

    check_http || ((errors++))
    check_containers || ((errors++))
    check_disk || ((errors++))
    check_memory || ((errors++))
    check_mongodb || ((errors++))
    check_logs || ((errors++))

    if [ $errors -eq 0 ]; then
        log_message "${GREEN}✅ All systems are healthy${NC}"
    else
        log_message "${RED}❌ Found $errors issues${NC}"

        # Send alert (optional)
        if [ -n "$SLACK_WEBHOOK" ]; then
            curl -X POST -H 'Content-type: application/json' \
                --data "{\"text\":\"🚨 Rocket.Chat Health Check: Found $errors issues\"}" \
                $SLACK_WEBHOOK
        fi
    fi

    log_message "=== Health Check Completed ==="
    return $errors
}

# Run health check
main

# Make executable
chmod +x health-check.sh

# Add to crontab
crontab -e
# Add: */5 * * * * /opt/rocket.chat/health-check.sh

# Tạo performance monitoring script
nano performance-monitor.sh

#!/bin/bash

# Rocket.Chat Performance Monitor
METRICS_FILE="/opt/rocket.chat/metrics.log"
ROCKETCHAT_DIR="/opt/rocket.chat"

# Function to collect metrics
collect_metrics() {
    echo "=== Performance Metrics - $(date) ===" >> $METRICS_FILE

    # System metrics
    echo "System Load: $(uptime | awk -F'load average:' '{print $2}')" >> $METRICS_FILE
    echo "Memory Usage: $(free -m | grep Mem | awk '{printf "%.1f%%", $3/$2 * 100.0}')" >> $METRICS_FILE
    echo "Disk Usage: $(df -h /opt/rocket.chat | tail -1 | awk '{print $5}')" >> $METRICS_FILE

    # Docker metrics
    echo "Docker Stats:" >> $METRICS_FILE
    docker stats --no-stream --format "table {{.Container}}\t{{.CPUPerc}}\t{{.MemUsage}}" >> $METRICS_FILE

    # MongoDB metrics
    echo "MongoDB Stats:" >> $METRICS_FILE
    docker exec mongodb mongosh --eval "db.runCommand({serverStatus: 1}).connections" >> $METRICS_FILE 2>/dev/null

    # Rocket.Chat metrics
    echo "Rocket.Chat Response Time:" >> $METRICS_FILE
    response_time=$(curl -o /dev/null -s -w "%{time_total}" http://localhost:3000/api/info)
    echo "API Response Time: ${response_time}s" >> $METRICS_FILE

    echo "=================================" >> $METRICS_FILE
}

# Collect metrics
collect_metrics

# Cleanup old metrics (keep last 30 days)
find /opt/rocket.chat -name "metrics.log" -mtime +30 -delete

# Make executable
chmod +x performance-monitor.sh

# Add to crontab
crontab -e
# Add: */10 * * * * /opt/rocket.chat/performance-monitor.sh

# Kiểm tra MongoDB status
docker exec mongodb mongosh --eval "rs.status()"

# Restart MongoDB
docker compose restart mongodb

# Check MongoDB logs
docker compose logs mongodb

# Check logs
docker compose logs rocketchat

# Check environment variables
docker compose config

# Restart with force recreate
docker compose up -d --force-recreate rocketchat

# Check memory usage
docker stats --no-stream

# Optimize MongoDB
docker exec mongodb mongosh --eval "db.runCommand({planCacheClear: 1})"

# Restart services
docker compose restart

# Check certificate validity
openssl x509 -in ssl/fullchain.pem -text -noout

# Renew certificate
sudo certbot renew

# Update certificate in container
docker compose restart nginx

# Check system resources
htop

# Optimize MongoDB
docker exec mongodb mongosh --eval "db.runCommand({reIndex: 1})"

# Check slow queries
docker exec mongodb mongosh --eval "db.setProfilingLevel(2)"

# View all logs
docker compose logs -f

# View specific service logs
docker compose logs -f rocketchat
docker compose logs -f mongodb
docker compose logs -f nginx

# Check system logs
sudo journalctl -u docker.service -f

# Monitor in real-time
watch -n 1 'docker compose ps'

# Scale Rocket.Chat instances
docker compose up -d --scale rocketchat=3

# Update Nginx config for load balancing
nano nginx/conf.d/rocketchat.conf

upstream rocketchat_backend {
    server rocketchat_1:3000;
    server rocketchat_2:3000;
    server rocketchat_3:3000;
}

# Create MongoDB replica set compose
nano mongodb-replica.yml

version: '3.8'

services:
  mongodb-primary:
    image: mongo:6.0
    container_name: mongodb-primary
    command: mongod --replSet rs0 --bind_ip_all
    ports:
      - "27017:27017"
    volumes:
      - mongodb_primary_data:/data/db
    networks:
      - rocketchat_network

  mongodb-secondary:
    image: mongo:6.0
    container_name: mongodb-secondary
    command: mongod --replSet rs0 --bind_ip_all
    ports:
      - "27018:27017"
    volumes:
      - mongodb_secondary_data:/data/db
    networks:
      - rocketchat_network

  mongodb-arbiter:
    image: mongo:6.0
    container_name: mongodb-arbiter
    command: mongod --replSet rs0 --bind_ip_all
    ports:
      - "27019:27017"
    volumes:
      - mongodb_arbiter_data:/data/db
    networks:
      - rocketchat_network

volumes:
  mongodb_primary_data:
  mongodb_secondary_data:
  mongodb_arbiter_data: