Deployment Guide

# Clone the deployment repository
git clone https://github.com/synthera/deployment-aws.git
cd deployment-aws

# Configure Terraform variables
cp terraform.tfvars.example terraform.tfvars
# Edit terraform.tfvars with your settings

# Initialize and apply Terraform
terraform init
terraform plan
terraform apply

# This creates:
# - VPC with public/private subnets
# - EKS cluster with managed node groups
# - RDS PostgreSQL instance
# - ElastiCache Redis cluster
# - Application Load Balancer
# - S3 buckets for storage
# - IAM roles and policies

# Configure kubectl for EKS
aws eks update-kubeconfig --region us-west-2 --name synthera-cluster

# Install necessary operators
kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/main/deploy/static/provider/aws/deploy.yaml

# Deploy SynThera using Helm
helm repo add synthera https://charts.synthera.health
helm repo update

# Create namespace and secrets
kubectl create namespace synthera
kubectl create secret generic synthera-secrets \
  --from-literal=database-url="postgresql://user:pass@rds-endpoint:5432/synthera" \
  --from-literal=redis-url="redis://elasticache-endpoint:6379" \
  --from-literal=jwt-secret="your-secure-jwt-secret"

# Deploy with Helm
helm install synthera synthera/synthera \
  --namespace synthera \
  --values values-aws.yaml \
  --set image.tag=v2024.1.0

# Download the installation package
curl -O https://releases.synthera.health/v2024.1.0/synthera-enterprise.tar.gz
tar -xzf synthera-enterprise.tar.gz
cd synthera-enterprise

# Configure environment
cp .env.example .env
# Edit .env with your configuration

# Generate certificates (or use your own)
./scripts/generate-certs.sh

# Start services
docker-compose up -d

# Initialize database
docker-compose exec app python manage.py migrate
docker-compose exec app python manage.py createsuperuser

# Load initial data
docker-compose exec app python manage.py loaddata initial_specialties.json

# Generate SSL certificate with Let's Encrypt
certbot certonly --standalone \
  -d synthera.health \
  -d api.synthera.health \
  -d app.synthera.health \
  --email admin@synthera.health \
  --agree-tos

# Nginx SSL configuration
server {
    listen 443 ssl http2;
    server_name synthera.health;
    
    ssl_certificate /etc/letsencrypt/live/synthera.health/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/synthera.health/privkey.pem;
    
    # Modern SSL configuration
    ssl_protocols TLSv1.3 TLSv1.2;
    ssl_ciphers ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384;
    ssl_prefer_server_ciphers off;
    
    # Security headers
    add_header Strict-Transport-Security "max-age=63072000" always;
    add_header X-Frame-Options DENY always;
    add_header X-Content-Type-Options nosniff always;
    add_header Referrer-Policy "strict-origin-when-cross-origin" always;
    add_header Content-Security-Policy "default-src 'self'" always;
    
    location / {
        proxy_pass http://app:8080;
        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;
    }
}

# Application health check
curl -f http://localhost:8080/health
# Expected response: {"status": "healthy", "version": "v2024.1.0"}

# Database connectivity
curl -f http://localhost:8080/health/db
# Expected response: {"database": "connected", "latency": "2ms"}

# AI models status
curl -f http://localhost:8080/health/ai
# Expected response: {"models": {"clinical": "loaded", "voice": "loaded"}}

# System resources
curl -f http://localhost:8080/health/system
# Expected response: {"cpu": "45%", "memory": "6.2GB/16GB", "disk": "120GB/1TB"}

# Application logs
docker-compose logs -f app

# Filter error logs
docker-compose logs app | grep ERROR

# Database query logs
docker-compose logs postgres | grep "slow query"

# Audit logs for compliance
tail -f /var/log/synthera/audit.log

# Performance metrics
curl -s http://localhost:8080/metrics | grep synthera_request_duration

#!/bin/bash
# Database backup script

BACKUP_DIR="/backups"
DATE=$(date +%Y%m%d_%H%M%S)
DB_NAME="synthera"

# Create backup
pg_dump -h postgres -U synthera $DB_NAME | gzip > $BACKUP_DIR/db_backup_$DATE.sql.gz

# Upload to S3 (if using cloud backup)
aws s3 cp $BACKUP_DIR/db_backup_$DATE.sql.gz s3://synthera-backups/database/

# Cleanup old backups (keep 30 days)
find $BACKUP_DIR -name "db_backup_*.sql.gz" -mtime +30 -delete

# Verify backup integrity
gunzip -t $BACKUP_DIR/db_backup_$DATE.sql.gz
if [ $? -eq 0 ]; then
    echo "Backup completed successfully: db_backup_$DATE.sql.gz"
else
    echo "Backup verification failed!" >&2
    exit 1
fi

# Database recovery from backup
# 1. Stop the application
docker-compose stop app

# 2. Create new database (if needed)
docker-compose exec postgres createdb -U synthera synthera_restored

# 3. Restore from backup
gunzip -c /backups/db_backup_20240125_120000.sql.gz | \
  docker-compose exec -T postgres psql -U synthera -d synthera_restored

# 4. Update database configuration
# Edit .env to point to restored database

# 5. Start application
docker-compose start app

# Point-in-time recovery (if using WAL archiving)
# Stop PostgreSQL
docker-compose stop postgres

# Restore base backup
tar -xzf /backups/base_backup_20240125.tar.gz -C /var/lib/postgresql/data

# Create recovery.conf
echo "restore_command = 'cp /backups/wal/%f %p'" > /var/lib/postgresql/data/recovery.conf
echo "recovery_target_time = '2024-01-25 14:30:00'" >> /var/lib/postgresql/data/recovery.conf

# Start PostgreSQL in recovery mode
docker-compose start postgres