n8n DevOps Automation: CI/CD, Monitoring & Infrastructure Workflows#

1
// Comprehensive CI/CD automation
2
class CICDPipeline {
3
  async executePipeline(trigger) {
4
    const pipeline = {
5
      id: generatePipelineId(),
6
      trigger: trigger,
7
      startTime: new Date(),
8
      stages: []
9
    };
10

11
    try {
12
      // Stage 1: Code Quality
13
      pipeline.stages.push(await this.codeQuality(trigger));
14

15
      // Stage 2: Build
16
      pipeline.stages.push(await this.build(trigger));
17

18
      // Stage 3: Test
19
      pipeline.stages.push(await this.test(trigger));
20

21
      // Stage 4: Security Scan
22
      pipeline.stages.push(await this.securityScan(trigger));
23

24
      // Stage 5: Deploy
25
      pipeline.stages.push(await this.deploy(trigger));
26

27
      // Stage 6: Smoke Tests
28
      pipeline.stages.push(await this.smokeTests(trigger));
29

30
      // Stage 7: Performance Tests
31
      pipeline.stages.push(await this.performanceTests(trigger));
32

33
      pipeline.status = 'success';
34
    } catch (error) {
35
      pipeline.status = 'failed';
36
      pipeline.error = error;
37

38
      // Rollback if deployment failed
39
      if (this.shouldRollback(pipeline)) {
40
        await this.rollback(pipeline);
41
      }
42
    }
43

44
    // Send notifications
45
    await this.notify(pipeline);
46

47
    // Update metrics
48
    await this.updateMetrics(pipeline);
49

50
    return pipeline;
51
  }
52

53
  async codeQuality(trigger) {
54
    const stage = {
55
      name: 'Code Quality',
56
      startTime: new Date()
57
    };
58

59
    // Run linting
60
    const linting = await this.runLinting(trigger.repo);
61

62
    // Run code coverage
63
    const coverage = await this.runCoverage(trigger.repo);
64

65
    // Run complexity analysis
66
    const complexity = await this.analyzeComplexity(trigger.repo);
67

68
    // Check quality gates
69
    const qualityGate = this.checkQualityGates({
70
      linting: linting,
71
      coverage: coverage,
72
      complexity: complexity
73
    });
74

75
    if (!qualityGate.passed) {
76
      throw new Error(`Quality gate failed: ${qualityGate.reason}`);
77
    }
78

79
    stage.endTime = new Date();
80
    stage.status = 'success';
81
    stage.metrics = {
82
      coverage: coverage.percentage,
83
      issues: linting.issues,
84
      complexity: complexity.average
85
    };
86

87
    return stage;
88
  }
89

90
  async build(trigger) {
91
    const stage = {
92
      name: 'Build',
93
      startTime: new Date()
94
    };
95

96
    // Determine build strategy
97
    const strategy = this.determineBuildStrategy(trigger);
98

99
    // Build Docker image
100
    const image = await this.buildDockerImage({
101
      dockerfile: strategy.dockerfile,
102
      context: trigger.repo,
103
      tags: this.generateTags(trigger),
104
      buildArgs: strategy.buildArgs,
105
      cache: strategy.useCache
106
    });
107

108
    // Push to registry
109
    await this.pushToRegistry(image);
110

111
    // Generate SBOM (Software Bill of Materials)
112
    const sbom = await this.generateSBOM(image);
113

114
    stage.endTime = new Date();
115
    stage.status = 'success';
116
    stage.artifacts = {
117
      image: image.id,
118
      tags: image.tags,
119
      sbom: sbom
120
    };
121

122
    return stage;
123
  }
124

125
  async test(trigger) {
126
    const stage = {
127
      name: 'Test',
128
      startTime: new Date()
129
    };
130

131
    // Parallel test execution
132
    const testResults = await Promise.all([
133
      this.runUnitTests(trigger),
134
      this.runIntegrationTests(trigger),
135
      this.runE2ETests(trigger),
136
      this.runContractTests(trigger)
137
    ]);
138

139
    // Aggregate results
140
    const summary = this.aggregateTestResults(testResults);
141

142
    if (summary.failed > 0) {
143
      throw new Error(`${summary.failed} tests failed`);
144
    }
145

146
    stage.endTime = new Date();
147
    stage.status = 'success';
148
    stage.testResults = summary;
149

150
    return stage;
151
  }
152

153
  async securityScan(trigger) {
154
    const stage = {
155
      name: 'Security Scan',
156
      startTime: new Date()
157
    };
158

159
    // Vulnerability scanning
160
    const vulnScan = await this.scanVulnerabilities(trigger.image);
161

162
    // SAST (Static Application Security Testing)
163
    const sast = await this.runSAST(trigger.repo);
164

165
    // DAST (Dynamic Application Security Testing)
166
    const dast = await this.runDAST(trigger.deploymentUrl);
167

168
    // Secret scanning
169
    const secrets = await this.scanSecrets(trigger.repo);
170

171
    // Compliance check
172
    const compliance = await this.checkCompliance(trigger);
173

174
    // Evaluate security posture
175
    const securityScore = this.calculateSecurityScore({
176
      vulnerabilities: vulnScan,
177
      sast: sast,
178
      dast: dast,
179
      secrets: secrets,
180
      compliance: compliance
181
    });
182

183
    if (securityScore < 70) {
184
      throw new Error(`Security score too low: ${securityScore}`);
185
    }
186

187
    stage.endTime = new Date();
188
    stage.status = 'success';
189
    stage.security = {
190
      score: securityScore,
191
      vulnerabilities: vulnScan.critical + vulnScan.high,
192
      compliance: compliance.status
193
    };
194

195
    return stage;
196
  }
197

198
  async deploy(trigger) {
199
    const stage = {
200
      name: 'Deploy',
201
      startTime: new Date()
202
    };
203

204
    // Deployment strategy
205
    const strategy = this.getDeploymentStrategy(trigger);
206

207
    switch(strategy.type) {
208
      case 'blue-green':
209
        await this.blueGreenDeploy(trigger);
210
        break;
211
      case 'canary':
212
        await this.canaryDeploy(trigger);
213
        break;
214
      case 'rolling':
215
        await this.rollingDeploy(trigger);
216
        break;
217
      default:
218
        await this.standardDeploy(trigger);
219
    }
220

221
    // Verify deployment
222
    const verification = await this.verifyDeployment(trigger);
223

224
    if (!verification.healthy) {
225
      throw new Error('Deployment verification failed');
226
    }
227

228
    stage.endTime = new Date();
229
    stage.status = 'success';
230
    stage.deployment = {
231
      strategy: strategy.type,
232
      version: trigger.version,
233
      environment: trigger.environment
234
    };
235

236
    return stage;
237
  }
238
}

1
// Kubernetes automation workflows
2
class KubernetesAutomation {
3
  async deployToKubernetes(config) {
4
    // Generate Kubernetes manifests
5
    const manifests = await this.generateManifests(config);
6

7
    // Apply manifests
8
    await this.applyManifests(manifests);
9

10
    // Wait for rollout
11
    await this.waitForRollout(config.deployment);
12

13
    // Configure networking
14
    await this.configureNetworking(config);
15

16
    // Set up autoscaling
17
    await this.configureAutoscaling(config);
18

19
    // Configure monitoring
20
    await this.configureMonitoring(config);
21

22
    return {
23
      deployment: config.deployment,
24
      status: 'deployed',
25
      endpoints: await this.getEndpoints(config)
26
    };
27
  }
28

29
  async generateManifests(config) {
30
    const manifests = [];
31

32
    // Deployment manifest
33
    manifests.push({
34
      apiVersion: 'apps/v1',
35
      kind: 'Deployment',
36
      metadata: {
37
        name: config.name,
38
        namespace: config.namespace,
39
        labels: config.labels
40
      },
41
      spec: {
42
        replicas: config.replicas,
43
        selector: {
44
          matchLabels: config.labels
45
        },
46
        template: {
47
          metadata: {
48
            labels: config.labels,
49
            annotations: {
50
              'prometheus.io/scrape': 'true',
51
              'prometheus.io/port': '9090'
52
            }
53
          },
54
          spec: {
55
            containers: [{
56
              name: config.name,
57
              image: config.image,
58
              ports: config.ports,
59
              env: config.env,
60
              resources: {
61
                requests: config.resources.requests,
62
                limits: config.resources.limits
63
              },
64
              livenessProbe: {
65
                httpGet: {
66
                  path: '/health',
67
                  port: 8080
68
                },
69
                initialDelaySeconds: 30,
70
                periodSeconds: 10
71
              },
72
              readinessProbe: {
73
                httpGet: {
74
                  path: '/ready',
75
                  port: 8080
76
                },
77
                initialDelaySeconds: 5,
78
                periodSeconds: 5
79
              }
80
            }]
81
          }
82
        }
83
      }
84
    });
85

86
    // Service manifest
87
    manifests.push({
88
      apiVersion: 'v1',
89
      kind: 'Service',
90
      metadata: {
91
        name: config.name,
92
        namespace: config.namespace
93
      },
94
      spec: {
95
        selector: config.labels,
96
        ports: config.ports,
97
        type: config.serviceType || 'ClusterIP'
98
      }
99
    });
100

101
    // HPA manifest
102
    if (config.autoscaling) {
103
      manifests.push({
104
        apiVersion: 'autoscaling/v2',
105
        kind: 'HorizontalPodAutoscaler',
106
        metadata: {
107
          name: config.name,
108
          namespace: config.namespace
109
        },
110
        spec: {
111
          scaleTargetRef: {
112
            apiVersion: 'apps/v1',
113
            kind: 'Deployment',
114
            name: config.name
115
          },
116
          minReplicas: config.autoscaling.min,
117
          maxReplicas: config.autoscaling.max,
118
          metrics: config.autoscaling.metrics
119
        }
120
      });
121
    }
122

123
    return manifests;
124
  }
125

126
  async canaryDeploy(config) {
127
    // Create canary deployment
128
    const canaryDeployment = await this.createCanaryDeployment(config);
129

130
    // Route percentage of traffic
131
    await this.updateTrafficSplit({
132
      stable: 90,
133
      canary: 10
134
    });
135

136
    // Monitor canary metrics
137
    const monitoring = await this.monitorCanary(canaryDeployment, {
138
      duration: config.canaryDuration || 300000, // 5 minutes
139
      metrics: ['error_rate', 'latency', 'success_rate']
140
    });
141

142
    // Analyze results
143
    const analysis = this.analyzeCanaryMetrics(monitoring);
144

145
    if (analysis.healthy) {
146
      // Progressive rollout
147
      for (const percentage of [25, 50, 75, 100]) {
148
        await this.updateTrafficSplit({
149
          stable: 100 - percentage,
150
          canary: percentage
151
        });
152

153
        await this.wait(60000); // 1 minute between increases
154

155
        const health = await this.checkHealth(canaryDeployment);
156
        if (!health.healthy) {
157
          await this.rollbackCanary(canaryDeployment);
158
          throw new Error('Canary deployment failed health check');
159
        }
160
      }
161

162
      // Promote canary to stable
163
      await this.promoteCanary(canaryDeployment);
164
    } else {
165
      // Rollback
166
      await this.rollbackCanary(canaryDeployment);
167
      throw new Error(`Canary failed: ${analysis.reason}`);
168
    }
169
  }
170
}

1
// Infrastructure as Code automation
2
class TerraformAutomation {
3
  async provision(config) {
4
    // Initialize Terraform
5
    await this.terraformInit(config.workingDir);
6

7
    // Plan changes
8
    const plan = await this.terraformPlan(config);
9

10
    // Review plan
11
    const review = await this.reviewPlan(plan);
12

13
    if (review.approved) {
14
      // Apply changes
15
      const result = await this.terraformApply(plan);
16

17
      // Verify infrastructure
18
      await this.verifyInfrastructure(result);
19

20
      // Update inventory
21
      await this.updateInventory(result);
22

23
      return result;
24
    }
25

26
    throw new Error('Plan not approved');
27
  }
28

29
  async terraformPlan(config) {
30
    const planOutput = await this.execute(`terraform plan -out=tfplan`, {
31
      cwd: config.workingDir,
32
      env: config.env
33
    });
34

35
    // Parse plan
36
    const changes = this.parsePlan(planOutput);
37

38
    // Cost estimation
39
    const cost = await this.estimateCost(changes);
40

41
    // Security review
42
    const security = await this.securityReview(changes);
43

44
    return {
45
      changes: changes,
46
      cost: cost,
47
      security: security,
48
      file: 'tfplan'
49
    };
50
  }
51

52
  async driftDetection() {
53
    // Detect configuration drift
54
    const currentState = await this.getCurrentState();
55
    const desiredState = await this.getDesiredState();
56

57
    const drift = this.compareStates(currentState, desiredState);
58

59
    if (drift.length > 0) {
60
      // Generate remediation plan
61
      const remediation = await this.generateRemediation(drift);
62

63
      // Auto-remediate if configured
64
      if (this.config.autoRemediate) {
65
        await this.remediate(remediation);
66
      } else {
67
        // Send alert
68
        await this.alertDrift(drift, remediation);
69
      }
70
    }
71

72
    return drift;
73
  }
74
}
75

76
// CloudFormation automation
77
class CloudFormationAutomation {
78
  async deployStack(config) {
79
    // Validate template
80
    const validation = await this.validateTemplate(config.template);
81

82
    if (!validation.valid) {
83
      throw new Error(`Template validation failed: ${validation.errors}`);
84
    }
85

86
    // Create change set
87
    const changeSet = await this.createChangeSet({
88
      stackName: config.stackName,
89
      template: config.template,
90
      parameters: config.parameters,
91
      capabilities: ['CAPABILITY_IAM']
92
    });
93

94
    // Review changes
95
    const review = await this.reviewChangeSet(changeSet);
96

97
    if (review.approved) {
98
      // Execute change set
99
      await this.executeChangeSet(changeSet);
100

101
      // Wait for completion
102
      await this.waitForStack(config.stackName);
103

104
      // Get outputs
105
      const outputs = await this.getStackOutputs(config.stackName);
106

107
      return {
108
        stackName: config.stackName,
109
        status: 'CREATE_COMPLETE',
110
        outputs: outputs
111
      };
112
    }
113
  }
114
}

1
// Monitoring automation
2
class MonitoringAutomation {
3
  async setupMonitoring(service) {
4
    // Configure metrics collection
5
    await this.configureMetrics(service);
6

7
    // Set up logging
8
    await this.configureLogs(service);
9

10
    // Configure tracing
11
    await this.configureTracing(service);
12

13
    // Create dashboards
14
    await this.createDashboards(service);
15

16
    // Set up alerts
17
    await this.configureAlerts(service);
18

19
    // Configure SLOs
20
    await this.configureSLOs(service);
21

22
    return {
23
      metrics: this.getMetricsEndpoint(service),
24
      logs: this.getLogsEndpoint(service),
25
      traces: this.getTracesEndpoint(service),
26
      dashboards: this.getDashboardUrls(service)
27
    };
28
  }
29

30
  async configureMetrics(service) {
31
    // Prometheus configuration
32
    const prometheusConfig = {
33
      global: {
34
        scrape_interval: '15s',
35
        evaluation_interval: '15s'
36
      },
37
      scrape_configs: [{
38
        job_name: service.name,
39
        kubernetes_sd_configs: [{
40
          role: 'pod',
41
          namespaces: {
42
            names: [service.namespace]
43
          }
44
        }],
45
        relabel_configs: this.generateRelabelConfigs(service)
46
      }]
47
    };
48

49
    // Custom metrics
50
    const customMetrics = await this.defineCustomMetrics(service);
51

52
    // Apply configuration
53
    await this.applyPrometheusConfig(prometheusConfig);
54

55
    // Register custom metrics
56
    await this.registerMetrics(customMetrics);
57
  }
58

59
  async configureLogs(service) {
60
    // Fluentd configuration
61
    const fluentdConfig = `
62
      <source>
63
        @type tail
64
        path /var/log/containers/${service.name}*.log
65
        pos_file /var/log/fluentd-${service.name}.pos
66
        tag kubernetes.${service.name}
67
        <parse>
68
          @type json
69
        </parse>
70
      </source>
71

72
      <filter kubernetes.${service.name}>
73
        @type kubernetes_metadata
74
      </filter>
75

76
      <match kubernetes.${service.name}>
77
        @type elasticsearch
78
        host elasticsearch.monitoring.svc.cluster.local
79
        port 9200
80
        index_name ${service.name}
81
        type_name _doc
82
        include_timestamp true
83
        <buffer>
84
          @type memory
85
          flush_interval 10s
86
        </buffer>
87
      </match>
88
    `;
89

90
    await this.deployFluentdConfig(fluentdConfig);
91
  }
92

93
  async configureAlerts(service) {
94
    const alerts = [];
95

96
    // High error rate alert
97
    alerts.push({
98
      name: `${service.name}_high_error_rate`,
99
      expr: `rate(http_requests_total{service="${service.name}",status=~"5.."}[5m]) > 0.05`,
100
      for: '5m',
101
      labels: {
102
        severity: 'critical',
103
        service: service.name
104
      },
105
      annotations: {
106
        summary: 'High error rate detected',
107
        description: `Error rate is {{ $value | humanizePercentage }} for ${service.name}`
108
      }
109
    });
110

111
    // High latency alert
112
    alerts.push({
113
      name: `${service.name}_high_latency`,
114
      expr: `histogram_quantile(0.95, rate(http_request_duration_seconds_bucket{service="${service.name}"}[5m])) > 0.5`,
115
      for: '5m',
116
      labels: {
117
        severity: 'warning',
118
        service: service.name
119
      },
120
      annotations: {
121
        summary: 'High latency detected',
122
        description: `95th percentile latency is {{ $value }}s for ${service.name}`
123
      }
124
    });
125

126
    // Pod restart alert
127
    alerts.push({
128
      name: `${service.name}_pod_restarts`,
129
      expr: `rate(kube_pod_container_status_restarts_total{namespace="${service.namespace}",pod=~"${service.name}.*"}[15m]) > 0`,
130
      for: '5m',
131
      labels: {
132
        severity: 'warning',
133
        service: service.name
134
      },
135
      annotations: {
136
        summary: 'Pod restarts detected',
137
        description: `Pod {{ $labels.pod }} has restarted {{ $value }} times`
138
      }
139
    });
140

141
    // Apply alert rules
142
    await this.applyAlertRules(alerts);
143

144
    // Configure alert routing
145
    await this.configureAlertRouting(service);
146
  }
147
}

1
// Incident response system
2
class IncidentResponseAutomation {
3
  async handleIncident(alert) {
4
    const incident = {
5
      id: generateIncidentId(),
6
      alert: alert,
7
      startTime: new Date(),
8
      status: 'open',
9
      actions: []
10
    };
11

12
    // Triage incident
13
    incident.severity = await this.triageIncident(alert);
14

15
    // Create incident record
16
    await this.createIncident(incident);
17

18
    // Notify on-call
19
    await this.notifyOnCall(incident);
20

21
    // Automated diagnostics
22
    const diagnostics = await this.runDiagnostics(incident);
23
    incident.diagnostics = diagnostics;
24

25
    // Attempt auto-remediation
26
    if (this.canAutoRemediate(incident)) {
27
      const remediation = await this.autoRemediate(incident);
28
      incident.actions.push(remediation);
29

30
      if (remediation.success) {
31
        incident.status = 'resolved';
32
        incident.resolvedAt = new Date();
33
      }
34
    }
35

36
    // Escalate if needed
37
    if (incident.status === 'open' && incident.severity === 'critical') {
38
      await this.escalate(incident);
39
    }
40

41
    // Create postmortem
42
    if (incident.severity === 'critical') {
43
      await this.schedulePostmortem(incident);
44
    }
45

46
    return incident;
47
  }
48

49
  async runDiagnostics(incident) {
50
    const diagnostics = {
51
      logs: await this.collectLogs(incident),
52
      metrics: await this.collectMetrics(incident),
53
      traces: await this.collectTraces(incident),
54
      events: await this.collectEvents(incident)
55
    };
56

57
    // AI-powered root cause analysis
58
    const rootCause = await this.analyzeRootCause(diagnostics);
59
    diagnostics.rootCause = rootCause;
60

61
    // Generate runbook
62
    const runbook = await this.generateRunbook(incident, rootCause);
63
    diagnostics.runbook = runbook;
64

65
    return diagnostics;
66
  }
67

68
  async autoRemediate(incident) {
69
    const action = {
70
      type: 'auto-remediation',
71
      startTime: new Date()
72
    };
73

74
    try {
75
      switch(incident.alert.type) {
76
        case 'high_memory':
77
          await this.restartPods(incident.service);
78
          action.description = 'Restarted pods due to high memory usage';
79
          break;
80

81
        case 'high_error_rate':
82
          await this.rollback(incident.service);
83
          action.description = 'Rolled back to previous version';
84
          break;
85

86
        case 'disk_full':
87
          await this.cleanupDisk(incident.node);
88
          action.description = 'Cleaned up disk space';
89
          break;
90

91
        case 'scaling_needed':
92
          await this.scaleService(incident.service);
93
          action.description = 'Scaled service to handle load';
94
          break;
95
      }
96

97
      action.success = true;
98
    } catch (error) {
99
      action.success = false;
100
      action.error = error.message;
101
    }
102

103
    action.endTime = new Date();
104
    return action;
105
  }
106
}

1
// Chaos engineering workflows
2
class ChaosEngineering {
3
  async runChaosExperiment(config) {
4
    const experiment = {
5
      id: generateExperimentId(),
6
      hypothesis: config.hypothesis,
7
      startTime: new Date(),
8
      steadyState: await this.measureSteadyState(config)
9
    };
10

11
    try {
12
      // Inject failure
13
      await this.injectChaos(config.chaos);
14

15
      // Monitor system
16
      const monitoring = await this.monitorDuringChaos(config.duration);
17

18
      // Verify steady state
19
      const duringChaos = await this.measureSteadyState(config);
20

21
      // Remove chaos
22
      await this.removeChaos(config.chaos);
23

24
      // Recovery monitoring
25
      const recovery = await this.monitorRecovery(config);
26

27
      // Analyze results
28
      experiment.results = this.analyzeExperiment({
29
        steadyState: experiment.steadyState,
30
        duringChaos: duringChaos,
31
        monitoring: monitoring,
32
        recovery: recovery
33
      });
34

35
    } catch (error) {
36
      // Emergency stop
37
      await this.emergencyStop(config);
38
      experiment.aborted = true;
39
      experiment.error = error;
40
    }
41

42
    experiment.endTime = new Date();
43

44
    // Generate report
45
    experiment.report = await this.generateReport(experiment);
46

47
    return experiment;
48
  }
49

50
  async injectChaos(chaosConfig) {
51
    switch(chaosConfig.type) {
52
      case 'pod-kill':
53
        await this.killRandomPods(chaosConfig);
54
        break;
55

56
      case 'network-delay':
57
        await this.injectNetworkDelay(chaosConfig);
58
        break;
59

60
      case 'cpu-stress':
61
        await this.stressCPU(chaosConfig);
62
        break;
63

64
      case 'disk-failure':
65
        await this.simulateDiskFailure(chaosConfig);
66
        break;
67

68
      case 'dns-chaos':
69
        await this.injectDNSChaos(chaosConfig);
70
        break;
71
    }
72
  }
73
}

1
// GitOps automation
2
class GitOpsAutomation {
3
  async syncGitOps(repo) {
4
    // Pull latest changes
5
    const changes = await this.pullChanges(repo);
6

7
    if (changes.length > 0) {
8
      // Validate changes
9
      const validation = await this.validateChanges(changes);
10

11
      if (validation.valid) {
12
        // Apply changes
13
        await this.applyChanges(changes);
14

15
        // Verify deployment
16
        await this.verifyDeployment(changes);
17

18
        // Update status
19
        await this.updateGitStatus(repo, 'success');
20
      } else {
21
        // Report validation errors
22
        await this.reportErrors(validation.errors);
23
        await this.updateGitStatus(repo, 'failed');
24
      }
25
    }
26
  }
27

28
  async promoteEnvironment(from, to) {
29
    // Get current state
30
    const currentState = await this.getEnvironmentState(from);
31

32
    // Create PR for promotion
33
    const pr = await this.createPromotionPR({
34
      from: from,
35
      to: to,
36
      changes: currentState,
37
      title: `Promote ${from} to ${to}`,
38
      description: this.generatePromotionDescription(currentState)
39
    });
40

41
    // Auto-approve if tests pass
42
    const tests = await this.runPromotionTests(pr);
43

44
    if (tests.passed) {
45
      await this.approvePR(pr);
46
      await this.mergePR(pr);
47
    }
48

49
    return pr;
50
  }
51
}

1
// DevSecOps practices
2
class DevSecOps {
3
  async securityPipeline(code) {
4
    // SAST
5
    const staticAnalysis = await this.runSAST(code);
6

7
    // Dependency scanning
8
    const dependencies = await this.scanDependencies(code);
9

10
    // Container scanning
11
    const containerScan = await this.scanContainer(code);
12

13
    // Compliance checks
14
    const compliance = await this.checkCompliance(code);
15

16
    // Generate security report
17
    return this.generateSecurityReport({
18
      sast: staticAnalysis,
19
      dependencies: dependencies,
20
      container: containerScan,
21
      compliance: compliance
22
    });
23
  }
24
}

1
// Infrastructure cost optimization
2
class CostOptimization {
3
  async optimizeInfrastructure() {
4
    // Identify unused resources
5
    const unused = await this.findUnusedResources();
6

7
    // Right-sizing recommendations
8
    const rightSizing = await this.analyzeRightSizing();
9

10
    // Spot instance opportunities
11
    const spotOpportunities = await this.identifySpotOpportunities();
12

13
    // Reserved instance recommendations
14
    const reservations = await this.recommendReservations();
15

16
    // Apply optimizations
17
    const savings = await this.applyOptimizations({
18
      unused,
19
      rightSizing,
20
      spotOpportunities,
21
      reservations
22
    });
23

24
    return savings;
25
  }
26
}