gh-nibzard-steel-marketplace-steel-forge/commands/steel-deploy.md

description

description
Help deploy Steel automation to production environments

Steel Deployment Assistant

Help the user deploy Steel automation to production with best practices and configurations.

Deployment Options

1. Docker Deployment

Create Dockerfile:

FROM node:18-alpine

WORKDIR /app

# Install dependencies
COPY package*.json ./
RUN npm ci --only=production

# Copy source
COPY . .

# Build if using TypeScript
RUN npm run build

# Run the automation
CMD ["node", "dist/index.js"]

Docker Compose with Steel:

version: '3.8'
services:
  steel-automation:
    build: .
    environment:
      - STEEL_API_KEY=${STEEL_API_KEY}
      - NODE_ENV=production
    restart: unless-stopped

2. Serverless Deployment (AWS Lambda, etc.)

Key Considerations:

• Steel handles the browser, your function just needs to call the API
• Set appropriate timeouts (Lambda: 15 min max)
• Use environment variables for API keys

Lambda Handler Example:

import { Steel } from 'steel-sdk';

export const handler = async (event: any) => {
  const client = new Steel({ 
    steelAPIKey: process.env.STEEL_API_KEY! 
  });
  
  const session = await client.sessions.create();
  
  try {
    // Your automation logic
    const result = await runAutomation(session);
    return { statusCode: 200, body: JSON.stringify(result) };
  } finally {
    await client.sessions.release(session.id);
  }
};

3. Scheduled Jobs (Cron, GitHub Actions)

GitHub Actions Example:

name: Daily Steel Scraping

on:
  schedule:
    - cron: '0 9 * * *'  # Daily at 9 AM UTC
  workflow_dispatch:

jobs:
  scrape:
    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 Steel automation
        env:
          STEEL_API_KEY: ${{ secrets.STEEL_API_KEY }}
        run: npm start

4. Kubernetes Deployment

Deployment YAML:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: steel-automation
spec:
  replicas: 3
  template:
    spec:
      containers:
      - name: automation
        image: your-registry/steel-automation:latest
        env:
        - name: STEEL_API_KEY
          valueFrom:
            secretKeyRef:
              name: steel-secrets
              key: api-key
        resources:
          limits:
            memory: "512Mi"
            cpu: "500m"

Production Best Practices

Environment Configuration

const config = {
  steel: {
    apiKey: process.env.STEEL_API_KEY,
    sessionTimeout: parseInt(process.env.STEEL_TIMEOUT || '60000'),
    retries: parseInt(process.env.STEEL_RETRIES || '3')
  },
  // Other config...
};

Error Handling & Retries

async function runWithRetry(fn: () => Promise<any>, retries = 3) {
  for (let i = 0; i < retries; i++) {
    try {
      return await fn();
    } catch (error) {
      console.error(`Attempt ${i + 1} failed:`, error);
      if (i === retries - 1) throw error;
      await new Promise(r => setTimeout(r, 1000 * (i + 1))); // Backoff
    }
  }
}

Session Management

// Always clean up sessions
const session = await client.sessions.create();
try {
  await runAutomation(session);
} catch (error) {
  console.error('Automation failed:', error);
  console.error('Session viewer:', session.sessionViewerUrl);
  throw error;
} finally {
  await client.sessions.release(session.id);
}

Logging & Monitoring

// Structured logging
console.log(JSON.stringify({
  timestamp: new Date().toISOString(),
  level: 'info',
  message: 'Session created',
  sessionId: session.id,
  viewerUrl: session.sessionViewerUrl
}));

// Track metrics
const startTime = Date.now();
await runAutomation(session);
const duration = Date.now() - startTime;
console.log(JSON.stringify({
  metric: 'automation_duration_ms',
  value: duration
}));

Security Checklist

• ✅ Store API keys in environment variables or secrets management
• ✅ Never commit .env files with real keys
• ✅ Use least-privilege API keys when possible
• ✅ Enable rate limiting in your application
• ✅ Monitor for unusual usage patterns
• ✅ Set session timeouts to prevent runaway sessions

Cost Optimization

// Reuse sessions when possible
const sessionPool = new SessionPool(client, { maxSize: 5 });

// Use appropriate dimensions
const session = await client.sessions.create({
  dimensions: { width: 1280, height: 800 } // Smaller = faster
});

// Block unnecessary resources
const session = await client.sessions.create({
  blockAds: true // Faster and cheaper
});

Deployment Checklist

Before deploying, verify:

1. Environment Variables Set:

   • STEEL_API_KEY configured
   • Other necessary config variables

2. Error Handling:

   • Try-catch blocks around Steel operations
   • Proper session cleanup in finally blocks
   • Retry logic for transient failures

3. Resource Limits:

   • Appropriate timeouts configured
   • Memory limits set (if containerized)
   • Concurrent session limits considered

4. Monitoring:

   • Logging configured
   • Error tracking (Sentry, etc.) set up
   • Metrics collection enabled

5. Testing:

   • Tested in staging environment
   • Load tested if expecting high volume
   • Verified session cleanup works

Common Deployment Issues

Issue: API Key Not Found

if (!process.env.STEEL_API_KEY) {
  throw new Error('STEEL_API_KEY environment variable not set');
}

Issue: Timeouts in Production

const session = await client.sessions.create({
  sessionTimeout: 120000 // 2 minutes for production
});

Issue: Too Many Concurrent Sessions

// Implement session pooling or queuing
const queue = new PQueue({ concurrency: 5 });
await queue.add(() => runAutomation());

Guide users through their specific deployment scenario with practical, working configurations.