Estrutura do Workflow

Configuração JSON

{
  "nodes": [
    {
      "name": "Cron Trigger",
      "type": "n8n-nodes-base.cron",
      "parameters": {
        "rule": {
          "hour": 2,
          "minute": 0
        }
      }
    },
    {
      "name": "MySQL Backup",
      "type": "n8n-nodes-base.mysql",
      "parameters": {
        "operation": "executeQuery",
        "query": "SELECT * FROM users",
        "options": {
          "largeNumbersOutput": "text"
        }
      }
    },
    {
      "name": "Google Drive Upload",
      "type": "n8n-nodes-base.googleDrive",
      "parameters": {
        "operation": "upload",
        "name": "backup_{{ $now.format('YYYY-MM-DD') }}.json",
        "driveId": "backup-folder",
        "binaryData": true
      }
    }
  ],
  "connections": {
    "Cron Trigger": {
      "main": [[{"node": "MySQL Backup", "type": "main", "index": 0}]]
    },
    "MySQL Backup": {
      "main": [[{"node": "Google Drive Upload", "type": "main", "index": 0}]]
    }
  }
}

Fluxo do Workflow

Código do Workflow

{
  "nodes": [
    {
      "name": "Every 5 minutes",
      "type": "n8n-nodes-base.interval",
      "parameters": {
        "interval": 5,
        "unit": "minutes"
      }
    },
    {
      "name": "Check Website",
      "type": "n8n-nodes-base.httpRequest",
      "parameters": {
        "url": "https://meusite.com",
        "options": {
          "timeout": 10000,
          "followRedirect": false
        }
      }
    },
    {
      "name": "Is Site Down?",
      "type": "n8n-nodes-base.if",
      "parameters": {
        "conditions": {
          "number": [
            {
              "value1": "={{ $json.statusCode }}",
              "operation": "notEqual",
              "value2": 200
            }
          ]
        }
      }
    },
    {
      "name": "Send Alert",
      "type": "n8n-nodes-base.slack",
      "parameters": {
        "channel": "#alerts",
        "text": "🚨 WEBSITE DOWN!\nURL: {{ $('Check Website').first().json.url }}\nStatus: {{ $('Check Website').first().json.statusCode }}\nTime: {{ $now.format('DD/MM/YYYY HH:mm:ss') }}"
      }
    }
  ]
}

Estrutura Completa

Configuração Detalhada

{
  "name": "Form Processor",
  "nodes": [
    {
      "name": "Form Webhook",
      "type": "n8n-nodes-base.webhook",
      "parameters": {
        "httpMethod": "POST",
        "path": "contact-form",
        "options": {
          "rawBody": false
        }
      }
    },
    {
      "name": "Validate Data",
      "type": "n8n-nodes-base.function",
      "parameters": {
        "functionCode": "const data = items[0].json;\n\n// Validações\nconst errors = [];\n\nif (!data.name || data.name.length < 2) {\n  errors.push('Nome é obrigatório');\n}\n\nif (!data.email || !data.email.includes('@')) {\n  errors.push('Email inválido');\n}\n\nif (!data.message || data.message.length < 10) {\n  errors.push('Mensagem muito curta');\n}\n\nif (errors.length > 0) {\n  throw new Error('Validation failed: ' + errors.join(', '));\n}\n\n// Sanitização\ndata.name = data.name.trim();\ndata.email = data.email.toLowerCase().trim();\ndata.message = data.message.trim();\ndata.created_at = new Date().toISOString();\n\nreturn [{ json: data }];"
      }
    },
    {
      "name": "Save to Sheets",
      "type": "n8n-nodes-base.googleSheets",
      "parameters": {
        "operation": "append",
        "sheetId": "1ABC123DEF456...",
        "range": "A:E",
        "options": {
          "valueInputOption": "USER_ENTERED"
        },
        "values": [
          [
            "={{ $json.name }}",
            "={{ $json.email }}",
            "={{ $json.message }}",
            "={{ $json.created_at }}",
            "pending"
          ]
        ]
      }
    },
    {
      "name": "Send Confirmation",
      "type": "n8n-nodes-base.emailSend",
      "parameters": {
        "fromEmail": "noreply@empresa.com",
        "toEmail": "={{ $json.email }}",
        "subject": "Confirmação - Recebemos sua mensagem",
        "text": "Olá {{ $json.name }},\n\nRecebemos sua mensagem e entraremos em contato em breve.\n\nObrigado!"
      }
    }
  ]
}

Cenário: Lead Management

Quando um novo lead é capturado em um formulário web, automaticamente:

Código do Workflow

{
  "name": "Lead Sync Multi-Platform",
  "nodes": [
    {
      "name": "Webhook Lead Capture",
      "type": "n8n-nodes-base.webhook",
      "parameters": {
        "httpMethod": "POST",
        "path": "new-lead"
      }
    },
    {
      "name": "Process Lead Data",
      "type": "n8n-nodes-base.function",
      "parameters": {
        "functionCode": "// Standardize lead data\nconst lead = items[0].json;\n\nconst standardizedLead = {\n  firstName: lead.first_name || lead.name?.split(' ')[0],\n  lastName: lead.last_name || lead.name?.split(' ').slice(1).join(' '),\n  email: lead.email?.toLowerCase(),\n  phone: lead.phone,\n  company: lead.company,\n  source: lead.utm_source || 'website',\n  createdAt: new Date().toISOString()\n};\n\nreturn [{ json: standardizedLead }];"
      }
    },
    {
      "name": "Save to HubSpot",
      "type": "n8n-nodes-base.hubspot",
      "parameters": {
        "resource": "contact",
        "operation": "create",
        "properties": {
          "firstname": "={{ $json.firstName }}",
          "lastname": "={{ $json.lastName }}",
          "email": "={{ $json.email }}",
          "phone": "={{ $json.phone }}",
          "company": "={{ $json.company }}"
        }
      }
    },
    {
      "name": "Add to MailChimp",
      "type": "n8n-nodes-base.mailchimp",
      "parameters": {
        "operation": "subscribe",
        "list": "main-list",
        "email": "={{ $json.email }}",
        "mergeFields": {
          "FNAME": "={{ $json.firstName }}",
          "LNAME": "={{ $json.lastName }}"
        }
      }
    },
    {
      "name": "Notify Slack",
      "type": "n8n-nodes-base.slack",
      "parameters": {
        "channel": "#sales",
        "text": "🎉 Novo Lead!\n👤 {{ $json.firstName }} {{ $json.lastName }}\n📧 {{ $json.email }}\n🏢 {{ $json.company }}\n🔗 Fonte: {{ $json.source }}"
      }
    },
    {
      "name": "Log to Sheets",
      "type": "n8n-nodes-base.googleSheets",
      "parameters": {
        "operation": "append",
        "values": [
          [
            "={{ $json.firstName }}",
            "={{ $json.lastName }}",
            "={{ $json.email }}",
            "={{ $json.phone }}",
            "={{ $json.company }}",
            "={{ $json.source }}",
            "={{ $json.createdAt }}"
          ]
        ]
      }
    }
  ]
}

Fluxo Inteligente

Implementação com AI

{
  "name": "AI Content Pipeline",
  "nodes": [
    {
      "name": "RSS Feed Monitor",
      "type": "n8n-nodes-base.rssFeedRead",
      "parameters": {
        "url": "https://feeds.example.com/tech-news"
      }
    },
    {
      "name": "OpenAI Summarizer", 
      "type": "n8n-nodes-base.openAi",
      "parameters": {
        "model": "gpt-4",
        "prompt": "Resuma este artigo em 280 caracteres para Twitter, mantendo as informações mais importantes:\n\n{{ $json.content }}",
        "maxTokens": 150,
        "temperature": 0.7
      }
    },
    {
      "name": "Generate Image",
      "type": "n8n-nodes-base.openAi",
      "parameters": {
        "model": "dall-e-3",
        "prompt": "Create a modern, minimalist illustration representing: {{ $json.title }}",
        "size": "1024x1024",
        "quality": "standard"
      }
    },
    {
      "name": "Sentiment Analysis",
      "type": "n8n-nodes-base.function",
      "parameters": {
        "functionCode": "// Análise de sentimento simples\nconst text = items[0].json.summary.toLowerCase();\n\nconst positiveWords = ['good', 'great', 'excellent', 'amazing', 'breakthrough'];\nconst negativeWords = ['bad', 'terrible', 'awful', 'disaster', 'crisis'];\n\nlet sentiment = 'neutral';\nlet score = 0;\n\npositiveWords.forEach(word => {\n  if (text.includes(word)) score += 1;\n});\n\nnegativeWords.forEach(word => {\n  if (text.includes(word)) score -= 1;\n});\n\nif (score > 0) sentiment = 'positive';\nif (score < 0) sentiment = 'negative';\n\nreturn [{\n  json: {\n    ...items[0].json,\n    sentiment: sentiment,\n    sentimentScore: score\n  }\n}];"
      }
    },
    {
      "name": "Post to Twitter",
      "type": "n8n-nodes-base.twitter",
      "parameters": {
        "text": "{{ $('OpenAI Summarizer').first().json.choices[0].message.content }}\n\n#TechNews #AI",
        "additionalFields": {
          "media": "{{ $('Generate Image').first().json.data[0].url }}"
        }
      }
    }
  ]
}

ETL Avançado

Processa grandes volumes de dados com transformações complexas:

Data Processing Function

{
  "name": "Advanced Data Processor",
  "type": "n8n-nodes-base.function",
  "parameters": {
    "functionCode": "// Processamento avançado de dados\nconst _ = require('lodash');\nconst moment = require('moment');\n\n// Dados de entrada\nconst rawData = items[0].json.records;\n\n// Validação e limpeza\nconst cleanData = rawData\n  .filter(record => {\n    // Remove registros inválidos\n    return record.email && \n           record.email.includes('@') &&\n           record.amount && \n           record.amount > 0;\n  })\n  .map(record => {\n    // Normalização\n    return {\n      id: record.id,\n      email: record.email.toLowerCase().trim(),\n      amount: parseFloat(record.amount),\n      currency: record.currency || 'USD',\n      date: moment(record.date).format('YYYY-MM-DD'),\n      category: record.category?.toLowerCase(),\n      // Campos calculados\n      quarter: moment(record.date).quarter(),\n      year: moment(record.date).year(),\n      month: moment(record.date).month() + 1\n    };\n  });\n\n// Agregações\nconst analytics = {\n  totalRecords: cleanData.length,\n  totalAmount: _.sumBy(cleanData, 'amount'),\n  avgAmount: _.meanBy(cleanData, 'amount'),\n  byCategory: _.groupBy(cleanData, 'category'),\n  byMonth: _.groupBy(cleanData, 'month'),\n  topCustomers: _.chain(cleanData)\n    .groupBy('email')\n    .map((orders, email) => ({\n      email,\n      totalAmount: _.sumBy(orders, 'amount'),\n      orderCount: orders.length\n    }))\n    .orderBy('totalAmount', 'desc')\n    .take(10)\n    .value()\n};\n\nreturn [\n  { json: { processedData: cleanData } },\n  { json: { analytics: analytics } }\n];"
  }
}

Estratégias de Recuperação

Error Handler Implementation

{
  "name": "Robust Error Handler",
  "type": "n8n-nodes-base.function",
  "parameters": {
    "functionCode": "// Sistema robusto de tratamento de erros\nconst maxRetries = 3;\nconst baseDelay = 1000; // 1 segundo\n\nasync function executeWithRetry(operation, data, attempt = 1) {\n  try {\n    // Simula operação que pode falhar\n    const result = await operation(data);\n    return { success: true, data: result };\n    \n  } catch (error) {\n    console.error(`Attempt ${attempt} failed:`, error.message);\n    \n    if (attempt >= maxRetries) {\n      // Máximo de tentativas atingido\n      return {\n        success: false,\n        error: error.message,\n        attempts: attempt,\n        timestamp: new Date().toISOString(),\n        originalData: data\n      };\n    }\n    \n    // Calcula delay exponencial\n    const delay = baseDelay * Math.pow(2, attempt - 1);\n    console.log(`Retrying in ${delay}ms...`);\n    \n    // Aguarda antes da próxima tentativa\n    await new Promise(resolve => setTimeout(resolve, delay));\n    \n    // Recursão para nova tentativa\n    return executeWithRetry(operation, data, attempt + 1);\n  }\n}\n\n// Exemplo de uso\nconst apiCall = async (data) => {\n  // Simula chamada de API que pode falhar\n  if (Math.random() < 0.7) {\n    throw new Error('API temporarily unavailable');\n  }\n  return { processed: true, id: data.id };\n};\n\n// Processa cada item com retry\nconst results = [];\nfor (const item of items) {\n  const result = await executeWithRetry(apiCall, item.json);\n  results.push({ json: result });\n}\n\nreturn results;"
  }
}

Jornada Completa do Cliente

Workflow Implementation

{
  "name": "Customer Onboarding",
  "nodes": [
    {
      "name": "New Customer Trigger",
      "type": "n8n-nodes-base.webhook",
      "parameters": {
        "path": "new-customer"
      }
    },
    {
      "name": "Customer Data Enrichment",
      "type": "n8n-nodes-base.function",
      "parameters": {
        "functionCode": "const customer = items[0].json;\n\n// Enriquece dados do cliente\nconst enrichedData = {\n  ...customer,\n  onboardingId: `OB_${Date.now()}`,\n  customerTier: customer.contractValue > 10000 ? 'Enterprise' : 'Standard',\n  assignedCSM: customer.contractValue > 50000 ? 'senior-csm' : 'standard-csm',\n  onboardingTrack: customer.industry === 'finance' ? 'compliance-focused' : 'standard',\n  timeZone: customer.timeZone || 'UTC',\n  language: customer.language || 'en'\n};\n\nreturn [{ json: enrichedData }];"
      }
    },
    {
      "name": "Create HubSpot Contact",
      "type": "n8n-nodes-base.hubspot",
      "parameters": {
        "resource": "contact",
        "operation": "create",
        "properties": {
          "email": "={{ $json.email }}",
          "firstname": "={{ $json.firstName }}",
          "lastname": "={{ $json.lastName }}",
          "company": "={{ $json.company }}",
          "phone": "={{ $json.phone }}",
          "lifecyclestage": "customer",
          "customer_tier": "={{ $json.customerTier }}",
          "onboarding_id": "={{ $json.onboardingId }}"
        }
      }
    },
    {
      "name": "Send Welcome Email",
      "type": "n8n-nodes-base.emailSend",
      "parameters": {
        "fromEmail": "welcome@empresa.com",
        "toEmail": "={{ $json.email }}",
        "subject": "🎉 Bem-vindo à [Empresa], {{ $json.firstName }}!",
        "htmlBody": "
Olá {{ $json.firstName }},
Bem-vindo à nossa plataforma! Estamos muito animados para trabalhar com você.
Seus próximos passos:
Acesse seu portal: portal.empresa.com
Agende sua call de onboarding
Explore nossos recursos
Seu representante: {{ $json.assignedCSM }}
ID do Onboarding: {{ $json.onboardingId }}
"
      }
    },
    {
      "name": "Schedule Follow-ups",
      "type": "n8n-nodes-base.function",
      "parameters": {
        "functionCode": "// Agenda follow-ups automáticos\nconst customer = items[0].json;\nconst followUps = [];\n\n// Day 1 follow-up\nfollowUps.push({\n  type: 'email',\n  scheduleFor: new Date(Date.now() + 24 * 60 * 60 * 1000).toISOString(),\n  template: 'day1_setup_guide',\n  customerId: customer.onboardingId\n});\n\n// Day 3 check-in call\nfollowUps.push({\n  type: 'calendar_invite',\n  scheduleFor: new Date(Date.now() + 3 * 24 * 60 * 60 * 1000).toISOString(),\n  duration: 30,\n  subject: 'Onboarding Check-in Call',\n  customerId: customer.onboardingId\n});\n\n// Day 7 satisfaction survey\nfollowUps.push({\n  type: 'survey',\n  scheduleFor: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString(),\n  surveyId: 'onboarding_satisfaction',\n  customerId: customer.onboardingId\n});\n\nreturn followUps.map(followUp => ({ json: followUp }));"
      }
    },
    {
      "name": "Notify Sales Team",
      "type": "n8n-nodes-base.slack",
      "parameters": {
        "channel": "#sales-notifications",
        "text": "🎉 Novo cliente onboarded!\n👤 {{ $json.firstName }} {{ $json.lastName }}\n🏢 {{ $json.company }}\n💰 Tier: {{ $json.customerTier }}\n🆔 Onboarding ID: {{ $json.onboardingId }}\n👨‍💼 CSM: {{ $json.assignedCSM }}"
      }
    }
  ]
}

Processo de Faturamento

Billing Automation

{
  "name": "Automated Billing",
  "schedule": "0 9 1 * *", // 1st day of month at 9 AM
  "nodes": [
    {
      "name": "Monthly Billing Trigger",
      "type": "n8n-nodes-base.cron"
    },
    {
      "name": "Get Active Contracts",
      "type": "n8n-nodes-base.mysql",
      "parameters": {
        "query": "SELECT c.*, cu.email, cu.name, cu.billing_address FROM contracts c JOIN customers cu ON c.customer_id = cu.id WHERE c.status = 'active' AND c.billing_day <= DAY(NOW())"
      }
    },
    {
      "name": "Generate Invoice Data",
      "type": "n8n-nodes-base.function",
      "parameters": {
        "functionCode": "const contracts = items[0].json;\nconst invoices = [];\n\nfor (const contract of contracts) {\n  // Calculate billing period\n  const today = new Date();\n  const billingStart = new Date(today.getFullYear(), today.getMonth(), 1);\n  const billingEnd = new Date(today.getFullYear(), today.getMonth() + 1, 0);\n  \n  // Calculate amount based on usage or fixed\n  let amount = contract.monthly_amount;\n  \n  if (contract.billing_type === 'usage') {\n    // Get usage data (simplified)\n    amount = contract.base_amount + (contract.usage_units * contract.unit_price);\n  }\n  \n  // Apply taxes\n  const taxRate = contract.tax_rate || 0.08;\n  const taxAmount = amount * taxRate;\n  const totalAmount = amount + taxAmount;\n  \n  invoices.push({\n    contractId: contract.id,\n    customerId: contract.customer_id,\n    customerName: contract.name,\n    customerEmail: contract.email,\n    invoiceNumber: `INV-${today.getFullYear()}-${String(today.getMonth() + 1).padStart(2, '0')}-${String(contract.id).padStart(4, '0')}`,\n    billingPeriodStart: billingStart.toISOString().split('T')[0],\n    billingPeriodEnd: billingEnd.toISOString().split('T')[0],\n    subtotal: amount,\n    taxAmount: taxAmount,\n    totalAmount: totalAmount,\n    currency: contract.currency || 'USD',\n    dueDate: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000).toISOString().split('T')[0], // 30 days\n    status: 'pending',\n    createdAt: new Date().toISOString()\n  });\n}\n\nreturn invoices.map(invoice => ({ json: invoice }));"
      }
    },
    {
      "name": "Save to Database",
      "type": "n8n-nodes-base.mysql",
      "parameters": {
        "query": "INSERT INTO invoices (contract_id, customer_id, invoice_number, billing_period_start, billing_period_end, subtotal, tax_amount, total_amount, currency, due_date, status, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
        "values": [
          "={{ $json.contractId }}",
          "={{ $json.customerId }}",
          "={{ $json.invoiceNumber }}",
          "={{ $json.billingPeriodStart }}",
          "={{ $json.billingPeriodEnd }}",
          "={{ $json.subtotal }}",
          "={{ $json.taxAmount }}",
          "={{ $json.totalAmount }}",
          "={{ $json.currency }}",
          "={{ $json.dueDate }}",
          "{{ $json.status }}",
          "={{ $json.createdAt }}"
        ]
      }
    },
    {
      "name": "Generate PDF Invoice",
      "type": "n8n-nodes-base.httpRequest",
      "parameters": {
        "method": "POST",
        "url": "https://api.pdf-generator.com/v1/invoices",
        "body": {
          "template": "professional_invoice",
          "data": {
            "invoice_number": "={{ $json.invoiceNumber }}",
            "customer_name": "={{ $json.customerName }}",
            "billing_period": "{{ $json.billingPeriodStart }} - {{ $json.billingPeriodEnd }}",
            "subtotal": "={{ $json.subtotal }}",
            "tax": "={{ $json.taxAmount }}",
            "total": "={{ $json.totalAmount }}",
            "due_date": "={{ $json.dueDate }}"
          }
        }
      }
    },
    {
      "name": "Send Invoice Email",
      "type": "n8n-nodes-base.emailSend",
      "parameters": {
        "fromEmail": "billing@empresa.com",
        "toEmail": "={{ $json.customerEmail }}",
        "subject": "Fatura {{ $json.invoiceNumber }} - {{ $json.customerName }}",
        "htmlBody": "Segue em anexo sua fatura referente ao período {{ $json.billingPeriodStart }} - {{ $json.billingPeriodEnd }}.",
        "attachments": "invoice_{{ $json.invoiceNumber }}.pdf"
      }
    }
  ]
}

Prometheus Configuration

# prometheus.yml
global:
  scrape_interval: 15s
  evaluation_interval: 15s

rule_files:
  - "n8n_rules.yml"

alerting:
  alertmanagers:
    - static_configs:
        - targets:
          - alertmanager:9093

scrape_configs:
  - job_name: 'n8n'
    static_configs:
      - targets: ['n8n:5678']
    metrics_path: '/metrics'
    scrape_interval: 30s
    scrape_timeout: 10s

  - job_name: 'postgres'
    static_configs:
      - targets: ['postgres:5432']
    
  - job_name: 'redis'
    static_configs:
      - targets: ['redis:6379']
    
  - job_name: 'nginx'
    static_configs:
      - targets: ['nginx:80']
    metrics_path: '/metrics'

Alert Rules

# n8n_rules.yml
groups:
  - name: n8n_alerts
    rules:
    - alert: N8NHighErrorRate
      expr: rate(n8n_workflow_executions_failed_total[5m]) > 0.1
      for: 5m
      labels:
        severity: warning
      annotations:
        summary: "High workflow failure rate"
        description: "N8N workflow failure rate is {{ $value }}% over the last 5 minutes"

    - alert: N8NHighMemoryUsage
      expr: process_resident_memory_bytes / 1024 / 1024 > 1000
      for: 10m
      labels:
        severity: warning
      annotations:
        summary: "N8N high memory usage"
        description: "N8N is using {{ $value }}MB of memory"

    - alert: PostgresDown
      expr: up{job="postgres"} == 0
      for: 1m
      labels:
        severity: critical
      annotations:
        summary: "PostgreSQL is down"
        description: "PostgreSQL database is not responding"

    - alert: RedisDown
      expr: up{job="redis"} == 0
      for: 1m
      labels:
        severity: warning
      annotations:
        summary: "Redis is down"
        description: "Redis cache is not responding"

Automated Backup Script

#!/bin/bash
# backup.sh - Automated backup script

set -e

# Configuration
BACKUP_DIR="/backups"
DATE=$(date +%Y%m%d_%H%M%S)
RETENTION_DAYS=30

# Database backup
echo "Starting PostgreSQL backup..."
pg_dump -h postgres -U n8n_user -d n8n_prod > "${BACKUP_DIR}/n8n_db_${DATE}.sql"

# Compress database backup
gzip "${BACKUP_DIR}/n8n_db_${DATE}.sql"

# N8N data backup
echo "Backing up n8n data..."
tar -czf "${BACKUP_DIR}/n8n_data_${DATE}.tar.gz" -C /home/node/.n8n .

# Workflow export
echo "Exporting workflows..."
curl -u "${N8N_ADMIN_USER}:${N8N_ADMIN_PASSWORD}" \
     "http://n8n:5678/api/v1/workflows" \
     > "${BACKUP_DIR}/workflows_${DATE}.json"

# Upload to cloud storage (example with AWS S3)
if [ "${AWS_S3_BUCKET}" ]; then
    echo "Uploading to S3..."
    aws s3 cp "${BACKUP_DIR}/n8n_db_${DATE}.sql.gz" \
        "s3://${AWS_S3_BUCKET}/backups/database/"
    aws s3 cp "${BACKUP_DIR}/n8n_data_${DATE}.tar.gz" \
        "s3://${AWS_S3_BUCKET}/backups/data/"
    aws s3 cp "${BACKUP_DIR}/workflows_${DATE}.json" \
        "s3://${AWS_S3_BUCKET}/backups/workflows/"
fi

# Clean old backups
echo "Cleaning old backups..."
find "${BACKUP_DIR}" -name "n8n_db_*.sql.gz" -mtime +${RETENTION_DAYS} -delete
find "${BACKUP_DIR}" -name "n8n_data_*.tar.gz" -mtime +${RETENTION_DAYS} -delete
find "${BACKUP_DIR}" -name "workflows_*.json" -mtime +${RETENTION_DAYS} -delete

echo "Backup completed successfully!"

# Send notification
curl -X POST \
     -H 'Content-type: application/json' \
     --data "{\"text\":\"✅ N8N backup completed successfully - ${DATE}\"}" \
     "${SLACK_WEBHOOK_URL}"

Recovery Script

#!/bin/bash
# restore.sh - Recovery script

set -e

if [ $# -eq 0 ]; then
    echo "Usage: $0 "
    echo "Example: $0 20240115_143022"
    exit 1
fi

BACKUP_DATE=$1
BACKUP_DIR="/backups"

echo "Starting recovery for backup: ${BACKUP_DATE}"

# Stop n8n service
echo "Stopping n8n service..."
docker-compose stop n8n

# Restore database
echo "Restoring database..."
if [ -f "${BACKUP_DIR}/n8n_db_${BACKUP_DATE}.sql.gz" ]; then
    # Drop existing database
    docker-compose exec postgres psql -U n8n_user -c "DROP DATABASE IF EXISTS n8n_prod;"
    docker-compose exec postgres psql -U n8n_user -c "CREATE DATABASE n8n_prod;"
    
    # Restore from backup
    gunzip -c "${BACKUP_DIR}/n8n_db_${BACKUP_DATE}.sql.gz" | \
        docker-compose exec -T postgres psql -U n8n_user -d n8n_prod
    
    echo "Database restored successfully"
else
    echo "Database backup file not found!"
    exit 1
fi

# Restore n8n data
echo "Restoring n8n data..."
if [ -f "${BACKUP_DIR}/n8n_data_${BACKUP_DATE}.tar.gz" ]; then
    # Backup current data
    docker run --rm -v n8n_data:/data -v $(pwd):/backup \
        alpine tar czf /backup/n8n_data_current_backup.tar.gz -C /data .
    
    # Clear current data
    docker run --rm -v n8n_data:/data alpine rm -rf /data/*
    
    # Restore from backup
    docker run --rm -v n8n_data:/data -v "${BACKUP_DIR}":/backup \
        alpine tar xzf "/backup/n8n_data_${BACKUP_DATE}.tar.gz" -C /data
    
    echo "N8N data restored successfully"
else
    echo "N8N data backup file not found!"
    exit 1
fi

# Start services
echo "Starting services..."
docker-compose up -d

# Wait for services to be ready
echo "Waiting for services to start..."
sleep 30

# Verify restoration
echo "Verifying restoration..."
RESPONSE=$(curl -s -o /dev/null -w "%{http_code}" http://localhost:5678/healthz)
if [ "$RESPONSE" = "200" ]; then
    echo "✅ Recovery completed successfully!"
    
    # Send notification
    curl -X POST \
         -H 'Content-type: application/json' \
         --data "{\"text\":\"✅ N8N recovery completed successfully - ${BACKUP_DATE}\"}" \
         "${SLACK_WEBHOOK_URL}"
else
    echo "❌ Recovery verification failed!"
    exit 1
fi