Deployment Guide

# Install the CLI
npm install -g @globio/cli
 
# Login to your account
globio login
 
# Initialize your project
globio init my-game --template unity
 
# Deploy to production
globio deploy --env production

// globio.config.js
export default {
  environments: {
    development: {
      apiEndpoint: 'https://dev-api.globio.dev',
      region: 'us-east-1',
      debug: true
    },
    staging: {
      apiEndpoint: 'https://staging-api.globio.dev',
      region: 'us-east-1',
      debug: false
    },
    production: {
      apiEndpoint: 'https://api.globio.dev',
      region: 'auto', // Auto-select closest region
      debug: false,
      monitoring: true
    }
  },
  
  services: {
    globaldoc: {
      enabled: true,
      backup: true,
      replication: 'multi-region'
    },
    globalsync: {
      enabled: true,
      regions: ['us-east-1', 'eu-west-1', 'ap-southeast-1']
    },
    globalcode: {
      enabled: true,
      memory: '256MB',
      timeout: '30s'
    }
  }
}

# Deploy to multiple regions
globio deploy --regions us-east-1,eu-west-1,ap-southeast-1
 
# Check deployment status
globio status --global
 
# Monitor performance across regions
globio metrics --region all

// Configure region-specific settings
const regionConfig = {
  'us-east-1': {
    primary: true,
    services: ['globaldoc', 'globalsync', 'globalcode'],
    capacity: 'high'
  },
  'eu-west-1': {
    services: ['globaldoc', 'globalsync'],
    capacity: 'medium',
    dataResidency: 'eu-only'
  },
  'ap-southeast-1': {
    services: ['globaldoc', 'globalsync'],
    capacity: 'medium'
  }
}

# main.tf
provider "globio" {
  api_key = var.globio_api_key
  region  = "us-east-1"
}
 
resource "globio_project" "game" {
  name        = "my-awesome-game"
  description = "Epic multiplayer adventure game"
  
  services = {
    globaldoc = {
      enabled = true
      tier    = "pro"
    }
    
    globalsync = {
      enabled     = true
      max_rooms   = 1000
      regions     = ["us-east-1", "eu-west-1"]
    }
    
    globalcode = {
      enabled = true
      runtime = "nodejs18"
      memory  = "512MB"
    }
  }
}
 
resource "globio_database" "game_data" {
  project_id = globio_project.game.id
  name       = "game-database"
  
  backup_schedule = "daily"
  retention_days  = 30
}

# globio-stack.yaml
AWSTemplateFormatVersion: '2010-09-09'
Description: 'Globio Game Infrastructure'
 
Parameters:
  GlobioApiKey:
    Type: String
    NoEcho: true
    Description: 'Globio API Key'
 
Resources:
  GlobioProject:
    Type: 'Custom::GlobioProject'
    Properties:
      ServiceToken: !GetAtt GlobioProvider.Arn
      ProjectName: 'my-game'
      Services:
        - globaldoc
        - globalsync
        - globalcode
      Region: 'us-east-1'

// Health monitoring setup
const monitoring = {
  healthChecks: [
    {
      name: 'api-health',
      endpoint: '/health',
      interval: '30s',
      timeout: '5s',
      retries: 3
    },
    {
      name: 'database-health',
      type: 'globaldoc',
      query: 'SELECT 1',
      interval: '60s'
    },
    {
      name: 'multiplayer-health',
      type: 'globalsync',
      metric: 'active_rooms',
      threshold: 1000
    }
  ],
  
  alerts: [
    {
      name: 'high-error-rate',
      condition: 'error_rate > 5%',
      duration: '5m',
      channels: ['slack', 'email']
    },
    {
      name: 'high-latency',
      condition: 'p95_latency > 500ms',
      duration: '2m',
      channels: ['pagerduty']
    }
  ]
}

# Monitor key metrics
globio metrics --service globaldoc --metric latency
globio metrics --service globalsync --metric concurrent_players
globio metrics --service globalcode --metric invocations
 
# Set up alerts
globio alerts create --name "high-latency" \
  --condition "p95_latency > 500ms" \
  --duration "5m" \
  --channel slack
 
# View logs
globio logs --service globalcode --function calculateScore --tail

// Security settings
const securityConfig = {
  authentication: {
    required: true,
    providers: ['google', 'apple', 'discord'],
    sessionTimeout: '24h'
  },
  
  encryption: {
    atRest: true,
    inTransit: true,
    keyRotation: 'monthly'
  },
  
  accessControl: {
    rbac: true,
    apiRateLimit: '1000/hour',
    ipWhitelist: ['10.0.0.0/8']
  },
  
  compliance: {
    gdpr: true,
    coppa: true,
    dataRetention: '2years'
  }
}

# Configure custom domain with SSL
globio domains add game.example.com --ssl auto
 
# Upload custom certificate
globio ssl upload --domain game.example.com \
  --cert cert.pem --key private.key
 
# Enable HSTS
globio security enable-hsts --domain game.example.com

# .github/workflows/deploy.yml
name: Deploy to Globio
 
on:
  push:
    branches: [main]
 
jobs:
  deploy:
    runs-on: ubuntu-latest
    
    steps:
    - uses: actions/checkout@v3
    
    - name: Setup Node.js
      uses: actions/setup-node@v3
      with:
        node-version: '18'
    
    - name: Install dependencies
      run: npm ci
    
    - name: Run tests
      run: npm test
    
    - name: Install Globio CLI
      run: npm install -g @globio/cli
    
    - name: Deploy to Globio
      env:
        GLOBIO_API_KEY: ${{ secrets.GLOBIO_API_KEY }}
      run: |
        globio login --api-key $GLOBIO_API_KEY
        globio deploy --env production

# .gitlab-ci.yml
stages:
  - test
  - deploy
 
variables:
  NODE_VERSION: "18"
 
test:
  stage: test
  image: node:$NODE_VERSION
  script:
    - npm ci
    - npm test
 
deploy:
  stage: deploy
  image: node:$NODE_VERSION
  script:
    - npm install -g @globio/cli
    - globio login --api-key $GLOBIO_API_KEY
    - globio deploy --env production
  only:
    - main

// Auto-scaling rules
const scalingConfig = {
  globaldoc: {
    minCapacity: 2,
    maxCapacity: 100,
    targetUtilization: 70,
    scaleUpCooldown: '5m',
    scaleDownCooldown: '10m'
  },
  
  globalsync: {
    minRooms: 10,
    maxRooms: 10000,
    playersPerRoom: 100,
    autoScale: true
  },
  
  globalcode: {
    concurrency: 1000,
    timeout: '30s',
    memory: '256MB',
    provisioned: 50 // Always warm instances
  }
}

# Enable caching
globio cache enable --service globaldoc --ttl 300s
 
# Configure CDN
globio cdn enable --regions global --cache-policy aggressive
 
# Optimize database
globio db optimize --analyze-queries --suggest-indexes
 
# Monitor performance
globio performance report --timerange 24h

// Backup strategy
const backupConfig = {
  globaldoc: {
    frequency: 'hourly',
    retention: '30d',
    crossRegion: true,
    encryption: true
  },
  
  globalvault: {
    frequency: 'daily',
    retention: '90d',
    versioning: true
  },
  
  configuration: {
    frequency: 'on-change',
    retention: '1y',
    gitBackup: true
  }
}

# Create disaster recovery plan
globio dr create-plan --rto 1h --rpo 15m
 
# Test disaster recovery
globio dr test --scenario region-failure
 
# Restore from backup
globio restore --backup-id backup_123 --target-env staging
 
# Failover to secondary region
globio failover --from us-east-1 --to eu-west-1

## Pre-Deployment
- [ ] Run all tests
- [ ] Update version numbers
- [ ] Review security settings
- [ ] Check resource limits
- [ ] Validate configuration
 
## Deployment
- [ ] Deploy to staging first
- [ ] Run smoke tests
- [ ] Monitor key metrics
- [ ] Verify all services
- [ ] Test critical paths
 
## Post-Deployment
- [ ] Monitor error rates
- [ ] Check performance metrics
- [ ] Verify user experience
- [ ] Update documentation
- [ ] Notify stakeholders

# Promote from staging to production
globio promote --from staging --to production
 
# Rollback if issues occur
globio rollback --to previous-version
 
# Blue-green deployment
globio deploy --strategy blue-green --health-check-url /health
 
# Canary deployment
globio deploy --strategy canary --traffic-split 10%