# Example Git workflow for DevOps
# Create feature branch
git checkout -b feature/new-feature

# Make changes and commit
git add .
git commit -m "Add new feature with automated tests"

# Push to remote repository
git push origin feature/new-feature

# Create pull request for code review
# After approval, merge to main branch
git checkout main
git merge feature/new-feature
git push origin main

# Clean up feature branch
git branch -d feature/new-feature

# Example GitHub Actions workflow
name: CI/CD Pipeline
on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  test:
    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: Run security scan
      run: npm run security-check

  deploy:
    needs: test
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/main'
    steps:
    - name: Deploy to production
      run: |
        # Deployment commands here
        echo "Deploying to production..."

# Example GitLab CI configuration
stages:
  - build
  - test
  - deploy

variables:
  NODE_VERSION: "18"

build:
  stage: build
  image: node:$NODE_VERSION
  script:
    - npm ci
    - npm run build
  artifacts:
    paths:
      - dist/
    expire_in: 1 week

test:
  stage: test
  image: node:$NODE_VERSION
  script:
    - npm test
    - npm run security-check
  dependencies:
    - build

deploy:
  stage: deploy
  image: alpine:latest
  script:
    - echo "Deploying application..."
    - # Deployment commands
  environment:
    name: production
  only:
    - main

// Example ESLint configuration for DevOps
{
  "env": {
    "browser": true,
    "es2021": true,
    "node": true
  },
  "extends": [
    "eslint:recommended",
    "@typescript-eslint/recommended"
  ],
  "parser": "@typescript-eslint/parser",
  "parserOptions": {
    "ecmaVersion": 12,
    "sourceType": "module"
  },
  "plugins": [
    "@typescript-eslint"
  ],
  "rules": {
    "indent": ["error", 2],
    "linebreak-style": ["error", "unix"],
    "quotes": ["error", "single"],
    "semi": ["error", "always"]
  }
}

// Example Jenkins pipeline
pipeline {
    agent any
    
    tools {
        maven 'Maven 3.8.6'
        jdk 'JDK 11'
    }
    
    stages {
        stage('Checkout') {
            steps {
                checkout scm
            }
        }
        
        stage('Build') {
            steps {
                sh 'mvn clean compile'
            }
        }
        
        stage('Test') {
            steps {
                sh 'mvn test'
            }
            post {
                always {
                    publishTestResults testResultsPattern: 'target/surefire-reports/*.xml'
                }
            }
        }
        
        stage('Package') {
            steps {
                sh 'mvn package'
            }
        }
        
        stage('Deploy') {
            when {
                branch 'main'
            }
            steps {
                sh './deploy.sh'
            }
        }
    }
    
    post {
        always {
            archiveArtifacts artifacts: 'target/*.jar', fingerprint: true
            junit 'target/surefire-reports/*.xml'
        }
        success {
            echo 'Pipeline completed successfully!'
        }
        failure {
            echo 'Pipeline failed!'
        }
    }
}

# Example CircleCI configuration
version: 2.1

orbs:
  node: circleci/[email protected]

jobs:
  build-and-test:
    docker:
      - image: cimg/node:18.16.0
      - image: cimg/postgres:15.3
        environment:
          POSTGRES_USER: testuser
          POSTGRES_PASSWORD: testpass
          POSTGRES_DB: testdb
    steps:
      - checkout
      - node/install-packages:
          pkg-manager: npm
      - run:
          name: Run tests
          command: npm test
      - run:
          name: Build application
          command: npm run build
      - persist_to_workspace:
          root: .
          paths:
            - dist
            - package.json

  deploy:
    docker:
      - image: cimg/node:18.16.0
    steps:
      - attach_workspace:
          at: .
      - run:
          name: Deploy to production
          command: ./deploy.sh

workflows:
  version: 2
  build-deploy:
    jobs:
      - build-and-test
      - deploy:
          requires:
            - build-and-test
          filters:
            branches:
              only: main

# Example Travis CI configuration
language: node_js
node_js:
  - '18'
  - '16'

cache:
  directories:
    - node_modules

services:
  - postgresql
  - redis-server

before_install:
  - npm install -g npm@latest

install:
  - npm ci

script:
  - npm test
  - npm run security-check

after_success:
  - npm run coverage

deploy:
  provider: heroku
  api_key: $HEROKU_API_KEY
  app: my-app-staging
  on:
    branch: develop

notifications:
  email:
    on_success: change
    on_failure: always

<!-- Example Maven configuration with CI/CD plugins -->
<project xmlns="http://maven.apache.org/POM/4.0.0">
  <modelVersion>4.0.0</modelVersion>
  
  <groupId>com.example</groupId>
  <artifactId>my-app</artifactId>
  <version>1.0.0</version>
  
  <properties>
    <maven.compiler.source>11</maven.compiler.source>
    <maven.compiler.target>11</maven.compiler.target>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>
  
  <dependencies>
    <!-- Dependencies here -->
  </dependencies>
  
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-surefire-plugin</artifactId>
        <version>3.0.0-M9</version>
      </plugin>
      <plugin>
        <groupId>org.jacoco</groupId>
        <artifactId>jacoco-maven-plugin</artifactId>
        <version>0.8.8</version>
        <executions>
          <execution>
            <goals>
              <goal>prepare-agent</goal>
            </goals>
          </execution>
          <execution>
            <id>report</id>
            <phase>test</phase>
            <goals>
              <goal>report</goal>
            </goals>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>
</project>

{
  "name": "my-app",
  "version": "1.0.0",
  "scripts": {
    "build": "webpack --mode production",
    "test": "jest",
    "test:watch": "jest --watch",
    "lint": "eslint src/",
    "security-check": "npm audit --audit-level high",
    "coverage": "jest --coverage",
    "start": "node dist/server.js"
  },
  "devDependencies": {
    "jest": "^29.0.0",
    "eslint": "^8.0.0",
    "webpack": "^5.0.0",
    "@babel/core": "^7.0.0"
  },
  "dependencies": {
    "express": "^4.18.0"
  }
}

# Example multi-stage Dockerfile
# Build stage
FROM node:18-alpine AS builder

WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production

# Production stage
FROM node:18-alpine

WORKDIR /app

# Create non-root user
RUN addgroup -g 1001 -S nodejs && \
    adduser -S nodejs -u 1001

# Copy application files
COPY --from=builder /app/node_modules ./node_modules
COPY . .

# Change ownership to non-root user
RUN chown -R nodejs:nodejs /app
USER nodejs

# Expose port
EXPOSE 3000

# Health check
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
  CMD curl -f http://localhost:3000/health || exit 1

# Start application
CMD ["npm", "start"]

# Example Docker commands for DevOps workflow
# Build image
docker build -t my-app:latest .

# Tag for registry
docker tag my-app:latest my-registry/my-app:latest

# Push to registry
docker push my-registry/my-app:latest

# Run container with health check
docker run -d --name my-app-container \
  -p 3000:3000 \
  --restart unless-stopped \
  my-registry/my-app:latest

# Example Kubernetes deployment
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app-deployment
  labels:
    app: my-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: my-app
        image: my-registry/my-app:latest
        ports:
        - containerPort: 3000
        env:
        - name: NODE_ENV
          value: "production"
        resources:
          requests:
            memory: "256Mi"
            cpu: "250m"
          limits:
            memory: "512Mi"
            cpu: "500m"
        livenessProbe:
          httpGet:
            path: /health
            port: 3000
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /ready
            port: 3000
          initialDelaySeconds: 5
          periodSeconds: 5

---
apiVersion: v1
kind: Service
metadata:
  name: my-app-service
spec:
  selector:
    app: my-app
  ports:
    - protocol: TCP
      port: 80
      targetPort: 3000
  type: LoadBalancer

---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: my-app-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  rules:
  - host: myapp.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: my-app-service
            port:
              number: 80

# Chart.yaml
apiVersion: v2
name: my-app
description: A Helm chart for my application
type: application
version: 0.1.0
appVersion: "1.0.0"

# values.yaml
# Default values for my-app
replicaCount: 3

image:
  repository: my-registry/my-app
  pullPolicy: IfNotPresent
  tag: ""

service:
  type: LoadBalancer
  port: 80

ingress:
  enabled: true
  className: "nginx"
  hosts:
    - host: myapp.example.com
      paths:
        - path: /
          pathType: Prefix

resources:
  limits:
    cpu: 500m
    memory: 512Mi
  requests:
    cpu: 250m
    memory: 256Mi

autoscaling:
  enabled: true
  minReplicas: 3
  maxReplicas: 10
  targetCPUUtilizationPercentage: 80

# templates/deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: {{ include "my-app.fullname" . }}
  labels:
    {{- include "my-app.labels" . | nindent 4 }}
spec:
  {{- if not .Values.autoscaling.enabled }}
  replicas: {{ .Values.replicaCount }}
  {{- end }}
  selector:
    matchLabels:
      {{- include "my-app.selectorLabels" . | nindent 6 }}
  template:
    metadata:
      {{- with .Values.podAnnotations }}
      annotations:
        {{- toYaml . | nindent 8 }}
      {{- end }}
      labels:
        {{- include "my-app.selectorLabels" . | nindent 8 }}
    spec:
      containers:
        - name: {{ .Chart.Name }}
          image: "{{ .Values.image.repository }}:{{ .Values.image.tag | default .Chart.AppVersion }}"
          imagePullPolicy: {{ .Values.image.pullPolicy }}
          ports:
            - name: http
              containerPort: 3000
              protocol: TCP
          livenessProbe:
            httpGet:
              path: /health
              port: http
          readinessProbe:
            httpGet:
              path: /ready
              port: http
          resources:
            {{- toYaml .Values.resources | nindent 12 }}

# main.tf - Main infrastructure configuration
terraform {
  required_version = ">= 1.0"
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
  }

  backend "s3" {
    bucket         = "my-terraform-state"
    key            = "global/networking/terraform.tfstate"
    region         = "us-east-1"
    encrypt        = true
    dynamodb_table = "terraform-locks"
  }
}

provider "aws" {
  region = var.aws_region
}

# VPC Module
module "vpc" {
  source = "./modules/vpc"

  name               = var.environment
  cidr_block         = var.vpc_cidr
  azs                = var.availability_zones
  public_subnets     = var.public_subnets
  private_subnets    = var.private_subnets
  database_subnets   = var.database_subnets
  create_nat_gateway = true
  enable_dns_hostnames = true
  enable_dns_support   = true

  tags = local.common_tags
}

# ECS Cluster Module
module "ecs_cluster" {
  source = "./modules/ecs"

  cluster_name = "${var.environment}-cluster"
  vpc_id       = module.vpc.vpc_id
  subnet_ids   = module.vpc.private_subnets

  tags = local.common_tags
}

# RDS Instance Module
module "rds" {
  source = "./modules/rds"

  identifier          = "${var.environment}-db"
  engine              = "postgres"
  engine_version      = "15.4"
  instance_class      = var.db_instance_class
  allocated_storage   = var.db_allocated_storage
  storage_encrypted   = true
  vpc_security_group_ids = [module.vpc.default_security_group_id]
  db_subnet_group_name = module.vpc.db_subnet_group_name

  tags = local.common_tags
}

# Outputs
output "vpc_id" {
  description = "VPC ID"
  value       = module.vpc.vpc_id
}

output "ecs_cluster_name" {
  description = "ECS Cluster Name"
  value       = module.ecs.cluster_name
}

output "rds_endpoint" {
  description = "RDS Endpoint"
  value       = module.rds.endpoint
}

# variables.tf
variable "aws_region" {
  description = "AWS region"
  type        = string
  default     = "us-east-1"
}

variable "environment" {
  description = "Environment name"
  type        = string
  default     = "dev"
}

variable "vpc_cidr" {
  description = "VPC CIDR block"
  type        = string
  default     = "10.0.0.0/16"
}

variable "availability_zones" {
  description = "List of availability zones"
  type        = list(string)
  default     = ["us-east-1a", "us-east-1b", "us-east-1c"]
}

variable "public_subnets" {
  description = "List of public subnet CIDRs"
  type        = list(string)
  default     = ["10.0.1.0/24", "10.0.2.0/24", "10.0.3.0/24"]
}

variable "private_subnets" {
  description = "List of private subnet CIDRs"
  type        = list(string)
  default     = ["10.0.101.0/24", "10.0.102.0/24", "10.0.103.0/24"]
}

variable "database_subnets" {
  description = "List of database subnet CIDRs"
  type        = list(string)
  default     = ["10.0.201.0/24", "10.0.202.0/24", "10.0.203.0/24"]
}

variable "db_instance_class" {
  description = "Database instance class"
  type        = string
  default     = "db.t3.micro"
}

variable "db_allocated_storage" {
  description = "Allocated storage for DB instance"
  type        = number
  default     = 20
}

# locals.tf
locals {
  common_tags = {
    Environment = var.environment
    ManagedBy   = "Terraform"
    Project     = "MyApp"
  }
}

# playbook.yml
---
- name: Deploy application servers
  hosts: app-servers
  become: yes
  vars:
    app_user: "appuser"
    app_group: "appuser"
    app_home: "/opt/myapp"
    app_version: "1.0.0"
  
  tasks:
    - name: Create application user
      user:
        name: "{{ app_user }}"
        group: "{{ app_group }}"
        home: "{{ app_home }}"
        shell: /bin/bash
        state: present
    
    - name: Install required packages
      apt:
        name:
          - nginx
          - python3
          - python3-pip
          - curl
        state: present
        update_cache: yes
    
    - name: Create application directory
      file:
        path: "{{ app_home }}"
        state: directory
        owner: "{{ app_user }}"
        group: "{{ app_group }}"
        mode: '0755'
    
    - name: Deploy application files
      copy:
        src: "files/app/{{ item.src }}"
        dest: "{{ app_home }}/{{ item.dest }}"
        owner: "{{ app_user }}"
        group: "{{ app_group }}"
        mode: "{{ item.mode }}"
      loop:
        - { src: "app.tar.gz", dest: "app.tar.gz", mode: "0644" }
        - { src: "config.json", dest: "config.json", mode: "0644" }
    
    - name: Extract application
      unarchive:
        src: "{{ app_home }}/app.tar.gz"
        dest: "{{ app_home }}"
        owner: "{{ app_user }}"
        group: "{{ app_group }}"
        remote_src: yes
    
    - name: Install application dependencies
      pip:
        requirements: "{{ app_home }}/requirements.txt"
        virtualenv: "{{ app_home }}/venv"
    
    - name: Create systemd service file
      template:
        src: "templates/myapp.service.j2"
        dest: "/etc/systemd/system/myapp.service"
        mode: "0644"
      notify: restart myapp
    
    - name: Enable and start application service
      systemd:
        name: myapp
        enabled: yes
        state: started
      register: service_result
    
    - name: Configure nginx reverse proxy
      template:
        src: "templates/nginx.conf.j2"
        dest: "/etc/nginx/sites-available/myapp.conf"
        mode: "0644"
      notify: reload nginx
    
    - name: Enable nginx site
      file:
        src: "/etc/nginx/sites-available/myapp.conf"
        dest: "/etc/nginx/sites-enabled/myapp.conf"
        state: link
      notify: reload nginx
    
    - name: Restart nginx
      systemd:
        name: nginx
        state: restarted
    
  handlers:
    - name: restart myapp
      systemd:
        name: myapp
        state: restarted
    
    - name: reload nginx
      systemd:
        name: nginx
        state: reloaded

# inventory.ini
[app-servers]
app-server-01 ansible_host=10.0.1.10
app-server-02 ansible_host=10.0.1.11
app-server-03 ansible_host=10.0.1.12

[app-servers:vars]
ansible_user=ubuntu
ansible_ssh_private_key_file=~/.ssh/id_rsa

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

rule_files:
  - "alert_rules.yml"

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

scrape_configs:
  - job_name: 'prometheus'
    static_configs:
      - targets: ['localhost:9090']
  
  - job_name: 'node-exporter'
    static_configs:
      - targets: ['node-exporter:9100']
  
  - job_name: 'application'
    static_configs:
      - targets: ['my-app:3000']
    metrics_path: /metrics
    scrape_interval: 5s

# alert_rules.yml
groups:
  - name: application_alerts
    rules:
      - alert: HighErrorRate
        expr: rate(http_requests_total{status=~"5.."}[5m]) > 0.05
        for: 2m
        labels:
          severity: critical
        annotations:
          summary: "High error rate detected"
          description: "HTTP error rate is above 5% for more than 2 minutes"
      
      - alert: HighCPUUsage
        expr: 100 - (avg by(instance) (irate(node_cpu_seconds_total{mode="idle"}[5m])) * 100) > 80
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "High CPU usage detected"
          description: "CPU usage is above 80% for more than 5 minutes"

# docker-compose.yml for ELK stack
version: '3.8'

services:
  elasticsearch:
    image: docker.elastic.co/elasticsearch/elasticsearch:8.9.0
    container_name: elasticsearch
    environment:
      - discovery.type=single-node
      - xpack.security.enabled=false
      - "ES_JAVA_OPTS=-Xms512m -Xmx512m"
    ports:
      - "9200:9200"
    volumes:
      - elasticsearch-data:/usr/share/elasticsearch/data
    networks:
      - elk

  logstash:
    image: docker.elastic.co/logstash/logstash:8.9.0
    container_name: logstash
    environment:
      - xpack.monitoring.enabled=false
    ports:
      - "5044:5044"
      - "5000:5000/tcp"
      - "5000:5000/udp"
      - "9600:9600"
    volumes:
      - ./logstash/pipeline:/usr/share/logstash/pipeline
    networks:
      - elk
    depends_on:
      - elasticsearch

  kibana:
    image: docker.elastic.co/kibana/kibana:8.9.0
    container_name: kibana
    ports:
      - "5601:5601"
    environment:
      - ELASTICSEARCH_HOSTS=http://elasticsearch:9200
    networks:
      - elk
    depends_on:
      - elasticsearch

networks:
  elk:
    driver: bridge

volumes:
  elasticsearch-data:

# logstash/pipeline/logstash.conf
input {
  beats {
    port => 5044
  }
  
  file {
    path => "/var/log/myapp/*.log"
    start_position => "beginning"
    codec => json
  }
}

filter {
  if [type] == "application" {
    grok {
      match => { "message" => "%{TIMESTAMP_ISO8601:timestamp} %{LOGLEVEL:loglevel} %{GREEDYDATA:message}" }
    }
    date {
      match => [ "timestamp", "ISO8601" ]
    }
  }
}

output {
  elasticsearch {
    hosts => ["elasticsearch:9200"]
    index => "myapp-%{+YYYY.MM.dd}"
  }
  
  stdout {
    codec => rubydebug
  }
}

{
  "version": "0.2",
  "phases": {
    "install": {
      "runtime-versions": {
        "nodejs": 18
      },
      "commands": [
        "npm install -g aws-cdk"
      ]
    },
    "pre_build": {
      "commands": [
        "npm ci",
        "npm run test",
        "npm run security-check"
      ]
    },
    "build": {
      "commands": [
        "npm run build"
      ]
    },
    "post_build": {
      "commands": [
        "export IMAGE_TAG=$(echo $CODEBUILD_RESOLVED_SOURCE_VERSION | cut -c 1-7)",
        "aws ecr get-login-password --region $AWS_DEFAULT_REGION | docker login --username AWS --password-stdin $ECR_REGISTRY",
        "docker build -t $ECR_REPOSITORY:$IMAGE_TAG .",
        "docker push $ECR_REPOSITORY:$IMAGE_TAG"
      ]
    }
  },
  "artifacts": {
    "files": [
      "**/*"
    ]
  }
}

# appspec.yml for AWS CodeDeploy
version: 0.0
os: linux
files:
  - source: /
    destination: /home/ec2-user/myapp
hooks:
  BeforeInstall:
    - location: scripts/install_dependencies.sh
      timeout: 300
      runas: root
  AfterInstall:
    - location: scripts/start_server.sh
      timeout: 300
      runas: root
  ValidateService:
    - location: scripts/verify_server.sh
      timeout: 300
      runas: root
  ApplicationStop:
    - location: scripts/stop_server.sh
      timeout: 300
      runas: root

# azure-pipelines.yml
trigger:
- main

pool:
  vmImage: 'ubuntu-latest'

variables:
  buildConfiguration: 'Release'
  dotnetVersion: '6.0.x'

steps:
- task: UseDotNet@2
  displayName: 'Use .NET Core SDK'
  inputs:
    version: $(dotnetVersion)

- task: DotNetCoreCLI@2
  displayName: 'Restore NuGet packages'
  inputs:
    command: 'restore'
    projects: '**/*.csproj'

- task: DotNetCoreCLI@2
  displayName: 'Build'
  inputs:
    command: 'build'
    projects: '**/*.csproj'
    arguments: '--configuration $(buildConfiguration) --no-restore'

- task: DotNetCoreCLI@2
  displayName: 'Run unit tests'
  inputs:
    command: 'test'
    projects: '**/*[Tt]ests.csproj'
    arguments: '--configuration $(buildConfiguration) --no-build --collect "Code coverage"'
    publishTestResults: true

- task: DotNetCoreCLI@2
  displayName: 'Publish'
  inputs:
    command: 'publish'
    publishWebProjects: true
    arguments: '--configuration $(buildConfiguration) --output $(Build.ArtifactStagingDirectory)'
    zipAfterPublish: true

- task: PublishBuildArtifacts@1
  displayName: 'Publish artifacts'
  inputs:
    PathtoPublish: '$(Build.ArtifactStagingDirectory)'
    ArtifactName: 'drop'
    publishLocation: 'Container'

# Example event-driven CI/CD pipeline
name: Event-Driven Pipeline
on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]
  schedule:
    - cron: '0 2 * * *'  # Daily at 2 AM

jobs:
  security-scan:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Run security scan
        run: |
          # Security scanning commands
          echo "Running security scan..."
          # Results published to security dashboard
          
  build-and-test:
    needs: security-scan
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Build and test
        run: |
          echo "Building and testing..."
          # Build and test commands
          
  notify-stakeholders:
    needs: [security-scan, build-and-test]
    runs-on: ubuntu-latest
    if: always()  # Always run regardless of previous job outcomes
    steps:
      - name: Send notifications
        run: |
          # Notification logic based on job outcomes
          echo "Sending notifications..."

# Example: Infrastructure validation pipeline
resource "aws_codepipeline" "infrastructure_pipeline" {
  name     = "infrastructure-validation-pipeline"
  role_arn = aws_iam_role.codepipeline_role.arn

  artifact_store {
    location = aws_s3_bucket.pipeline_bucket.bucket
    type     = "S3"
  }

  stage {
    name = "Source"

    action {
      name = "Source"
      category = "Source"
      owner = "ThirdParty"
      provider = "GitHub"
      version = "1"
      output_artifacts = ["SourceArtifact"]

      configuration = {
        Owner = "myorg"
        Repo = "infrastructure-code"
        Branch = "main"
        OAuthToken = "my-github-token"
      }
    }
  }

  stage {
    name = "Plan"

    action {
      name = "TerraformPlan"
      category = "Build"
      owner = "AWS"
      provider = "CodeBuild"
      version = "1"
      input_artifacts = ["SourceArtifact"]
      output_artifacts = ["PlanArtifact"]

      configuration = {
        ProjectName = aws_codebuild_project.terraform_plan.name
      }
    }
  }

  stage {
    name = "Validate"

    action {
      name = "SecurityValidation"
      category = "Test"
      owner = "AWS"
      provider = "CodeBuild"
      version = "1"
      input_artifacts = ["SourceArtifact"]

      configuration = {
        ProjectName = aws_codebuild_project.security_validation.name
      }
    }
  }

  stage {
    name = "Deploy"

    action {
      name = "TerraformApply"
      category = "Deploy"
      owner = "AWS"
      provider = "CodeDeploy"
      version = "1"
      input_artifacts = ["SourceArtifact"]

      configuration = {
        ApplicationName = aws_codedeploy_app.terraform_deploy.application_name
        DeploymentGroupName = aws_codedeploy_deployment_group.staging.name
      }
    }
  }
}