Zum Inhalt springen
CI/CD-Guides

CI/CD-Integration Guides

Security & Code Review in der Pipeline automatisieren

Integriere Lurus Code in wenigen Minuten in deine bestehende CI/CD-Infrastruktur. Headless-Ausführung, definierte Exit-Codes, SARIF-Output und native PR-Integration.

🐙 GitHub Actions 🦊 GitLab CI 🔵 Jenkins ⚙️ CircleCI
CLI Reference → Quick Start → CI/CD Guides

Wie die CI/CD-Integration funktioniert

Lurus Code bietet zwei dedizierte CI/CD-Befehle: lurus security-ci für automatisiertes Security Scanning und lurus code-review-ci für KI-gestütztes Code Review. Beide Befehle laufen headless (kein Browser erforderlich), erzeugen maschinenlesbare Ausgaben und geben standardisierte Exit-Codes zurück.

Exit-Codes

0 Erfolgreich – keine blockierenden Findings
1 Findings ab --fail-on-Schwellenwert vorhanden
2 Scan/Review fehlgeschlagen (technischer Fehler)
3 Guthaben aufgebraucht (Teilergebnisse zurückgegeben)

Authentifizierung in CI/CD

Setze LURUS_API_KEY als Umgebungsvariable oder Secret in deinem CI/CD-System. Committe niemals API-Keys in dein Repository.

export LURUS_API_KEY=dein-api-key-hier
🐙
GitHub Actions

GitHub Actions

GitHub Actions wird von Lurus Code nativ unterstützt. Die CLI erkennt automatisch die GITHUB_ACTIONS-Umgebungsvariable und schreibt Ergebnisse in GITHUB_STEP_SUMMARY und GITHUB_OUTPUT.

Automatische Step Summary mit Findings-Tabelle Output-Variablen: total_findings, blocking_findings, passed Inline-PR-Review-Kommentare via --pr-comments Automatisches PR-Verdict (APPROVE / REQUEST_CHANGES) via --verdict SARIF-Upload zu GitHub Code Scanning
1

Security Scan bei Pull Requests

Führe bei jedem PR einen Security Scan durch und poste Findings als Inline-Review-Kommentare.

.github/workflows/lurus-security.yml 
name: Lurus Security Scan

on:
  pull_request:
    branches: [main, develop]

jobs:
  security-scan:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      pull-requests: write   # Erforderlich für PR-Kommentare
      security-events: write # Erforderlich für SARIF-Upload

    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0   # Vollständige History für git diff

      - uses: actions/setup-node@v4
        with:
          node-version: '20'

      - name: Lurus Code CLI installieren
        run: npm install -g @scramble-cloud/lurus-code-cli

      - name: Lurus Security Scan ausführen
        run: lurus security-ci --diff --pr-comments --fail-on high
        env:
          LURUS_API_KEY: ${{ secrets.LURUS_API_KEY }}
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

      - name: SARIF zu GitHub Code Scanning hochladen
        if: always()
        uses: github/codeql-action/upload-sarif@v3
        with:
          sarif_file: lurus-security-results.sarif
2

Code Review mit automatischem Verdict

Führe bei jedem PR ein KI-Code-Review durch und genehmige oder lehne automatisch ab.

.github/workflows/lurus-review.yml 
name: Lurus Code Review

on:
  pull_request:
    branches: [main, develop]

jobs:
  code-review:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      pull-requests: write

    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - uses: actions/setup-node@v4
        with:
          node-version: '20'

      - name: Lurus Code CLI installieren
        run: npm install -g @scramble-cloud/lurus-code-cli

      - name: Lurus Code Review ausführen
        run: lurus code-review-ci --pr-comments --verdict --fail-on high
        env:
          LURUS_API_KEY: ${{ secrets.LURUS_API_KEY }}
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
3

Kombinierte Pipeline (Security + Review)

Führe Security Scan und Code Review parallel aus für maximale Abdeckung.

.github/workflows/lurus-full.yml 
name: Lurus Full CI Check

on:
  pull_request:
    branches: [main, develop]

jobs:
  security-scan:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      pull-requests: write
      security-events: write
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - uses: actions/setup-node@v4
        with:
          node-version: '20'
      - run: npm install -g @scramble-cloud/lurus-code-cli
      - name: Security Scan
        run: lurus security-ci --diff --pr-comments --fail-on high
        env:
          LURUS_API_KEY: ${{ secrets.LURUS_API_KEY }}
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
      - name: SARIF hochladen
        if: always()
        uses: github/codeql-action/upload-sarif@v3
        with:
          sarif_file: lurus-security-results.sarif

  code-review:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      pull-requests: write
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - uses: actions/setup-node@v4
        with:
          node-version: '20'
      - run: npm install -g @scramble-cloud/lurus-code-cli
      - name: Code Review
        run: lurus code-review-ci --pr-comments --verdict --fail-on high
        env:
          LURUS_API_KEY: ${{ secrets.LURUS_API_KEY }}
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
4

Geplanter vollständiger Projekt-Scan

Führe regelmäßig (z. B. nächtlich) einen vollständigen Security Scan der gesamten Codebase durch.

.github/workflows/lurus-nightly.yml 
name: Lurus Nightly Security Scan

on:
  schedule:
    - cron: '0 2 * * *'   # Jede Nacht um 2:00 Uhr UTC
  workflow_dispatch:        # Manueller Trigger

jobs:
  full-security-scan:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      security-events: write

    steps:
      - uses: actions/checkout@v4

      - uses: actions/setup-node@v4
        with:
          node-version: '20'

      - name: Lurus Code CLI installieren
        run: npm install -g @scramble-cloud/lurus-code-cli

      - name: Vollständiger Security Scan
        run: |
          lurus security-ci \
            --format sarif \
            --output lurus-security-results.sarif \
            --fail-on critical
        env:
          LURUS_API_KEY: ${{ secrets.LURUS_API_KEY }}

      - name: SARIF zu GitHub Code Scanning hochladen
        if: always()
        uses: github/codeql-action/upload-sarif@v3
        with:
          sarif_file: lurus-security-results.sarif

security-ci

total_findings Gesamtzahl der Findings
blocking_findings Findings ab --fail-on-Schwellenwert
passed `true` wenn keine blockierenden Findings

code-review-ci

total_findings Gesamtzahl der Review-Findings
blocking_findings Findings ab --fail-on-Schwellenwert
verdict `approve`, `needsChanges` oder `comment`
passed `true` wenn keine blockierenden Findings
🦊
GitLab CI

GitLab CI

Integriere Lurus Code über .gitlab-ci.yml in deine GitLab CI/CD-Pipeline. Nutze GitLab CI/CD-Variablen zur sicheren Verwaltung des API-Keys.

Läuft in jedem Docker-basierten GitLab Runner SARIF-Artefakte für das GitLab Security Dashboard Integration in Merge-Request-Pipelines GitLab CI/CD-Variablen für Secrets-Management Artefakte für HTML-Reports
1

Security Scan bei Merge Requests

Scanne geänderte Dateien bei jedem Merge Request und lasse die Pipeline bei high+-Findings fehlschlagen.

.gitlab-ci.yml 
stages:
  - security

lurus-security-scan:
  stage: security
  image: node:20-alpine
  only:
    - merge_requests
  before_script:
    - npm install -g @scramble-cloud/lurus-code-cli
  script:
    - lurus security-ci
        --diff
        --format sarif
        --output gl-sast-report.sarif
        --fail-on high
  variables:
    LURUS_API_KEY: $LURUS_API_KEY
  artifacts:
    when: always
    reports:
      sast: gl-sast-report.sarif
    paths:
      - gl-sast-report.sarif
    expire_in: 1 Woche
2

Code Review bei Merge Requests

Führe ein KI-Code-Review durch und generiere einen HTML-Report als herunterladbares Artefakt.

.gitlab-ci.yml 
stages:
  - review

lurus-code-review:
  stage: review
  image: node:20-alpine
  only:
    - merge_requests
  before_script:
    - npm install -g @scramble-cloud/lurus-code-cli
  script:
    - lurus code-review-ci
        --format html
        --output code-review-report.html
        --fail-on high
  variables:
    LURUS_API_KEY: $LURUS_API_KEY
  artifacts:
    when: always
    paths:
      - code-review-report.html
    expire_in: 1 Woche
3

Vollständige Pipeline mit beiden Befehlen

Komplette GitLab CI-Konfiguration mit Security Scan und Code Review parallel.

.gitlab-ci.yml 
stages:
  - lurus-checks

variables:
  LURUS_API_KEY: $LURUS_API_KEY

.lurus-base:
  image: node:20-alpine
  only:
    - merge_requests
  before_script:
    - npm install -g @scramble-cloud/lurus-code-cli

lurus-security:
  extends: .lurus-base
  stage: lurus-checks
  script:
    - lurus security-ci --diff --format sarif --fail-on high
  artifacts:
    when: always
    reports:
      sast: lurus-security-results.sarif
    expire_in: 1 Woche

lurus-review:
  extends: .lurus-base
  stage: lurus-checks
  script:
    - lurus code-review-ci --format html --output review.html --fail-on high
  artifacts:
    when: always
    paths:
      - review.html
    expire_in: 1 Woche

ℹ️GitLab CI/CD-Variablen einrichten

  1. 1 Gehe zu deinem Projekt → Settings → CI/CD → Variables
  2. 2 Neue Variable hinzufügen: Key = LURUS_API_KEY, Value = dein API-Key
  3. 3 "Mask variable" aktivieren, um den Wert in Job-Logs zu verstecken
  4. 4 "Protect variable" aktivieren, um sie auf geschützte Branches zu beschränken
🔵
Jenkins

Jenkins

Integriere Lurus Code in Jenkins über eine Declarative Pipeline (Jenkinsfile). Speichere deinen API-Key als Jenkins-Credential.

Declarative Pipeline (Jenkinsfile) Jenkins Credentials für API-Key-Verwaltung HTML Publisher Plugin für Report-Anzeige Parallele Stages für Security + Review Post-Build-Artefakt-Archivierung
1

Security Scan Pipeline

Ein Jenkinsfile, das einen Security Scan auf Pull-Request-Branches ausführt.

Jenkinsfile 
pipeline {
  agent {
    docker {
      image 'node:20-alpine'
    }
  }

  environment {
    LURUS_API_KEY = credentials('lurus-api-key')
  }

  stages {
    stage('Installieren') {
      steps {
        sh 'npm install -g @scramble-cloud/lurus-code-cli'
      }
    }

    stage('Security Scan') {
      steps {
        sh '''
          lurus security-ci \
            --diff \
            --format sarif \
            --output lurus-security-results.sarif \
            --fail-on high
        '''
      }
      post {
        always {
          archiveArtifacts artifacts: 'lurus-security-results.sarif',
                           allowEmptyArchive: true
        }
      }
    }
  }

  post {
    failure {
      echo 'Security Scan fehlgeschlagen – blockierende Findings gefunden'
    }
    success {
      echo 'Security Scan bestanden'
    }
  }
}
2

Code Review Pipeline mit HTML-Report

Führe ein Code Review durch und veröffentliche den HTML-Report in der Jenkins-Oberfläche.

Jenkinsfile 
pipeline {
  agent {
    docker {
      image 'node:20-alpine'
    }
  }

  environment {
    LURUS_API_KEY = credentials('lurus-api-key')
  }

  stages {
    stage('Installieren') {
      steps {
        sh 'npm install -g @scramble-cloud/lurus-code-cli'
      }
    }

    stage('Code Review') {
      steps {
        sh '''
          lurus code-review-ci \
            --format html \
            --output code-review-report.html \
            --fail-on high
        '''
      }
      post {
        always {
          publishHTML(target: [
            allowMissing: true,
            alwaysLinkToLastBuild: true,
            keepAll: true,
            reportDir: '.',
            reportFiles: 'code-review-report.html',
            reportName: 'Lurus Code Review Report'
          ])
        }
      }
    }
  }
}
3

Vollständige Pipeline mit parallelen Stages

Führe Security Scan und Code Review parallel aus für schnelleres Feedback.

Jenkinsfile 
pipeline {
  agent {
    docker {
      image 'node:20-alpine'
    }
  }

  environment {
    LURUS_API_KEY = credentials('lurus-api-key')
  }

  stages {
    stage('Installieren') {
      steps {
        sh 'npm install -g @scramble-cloud/lurus-code-cli'
      }
    }

    stage('Lurus Checks') {
      parallel {
        stage('Security Scan') {
          steps {
            sh 'lurus security-ci --diff --fail-on high'
          }
          post {
            always {
              archiveArtifacts artifacts: 'lurus-security-results.sarif',
                               allowEmptyArchive: true
            }
          }
        }

        stage('Code Review') {
          steps {
            sh 'lurus code-review-ci --format html --output review.html --fail-on high'
          }
          post {
            always {
              publishHTML(target: [
                reportDir: '.',
                reportFiles: 'review.html',
                reportName: 'Code Review Report'
              ])
            }
          }
        }
      }
    }
  }

  post {
    failure {
      echo 'Lurus Checks fehlgeschlagen – Findings prüfen'
    }
  }
}

ℹ️API-Key als Jenkins-Credential hinzufügen

  1. 1 Gehe zu Jenkins → Manage Jenkins → Manage Credentials
  2. 2 Klicke "Add Credentials" → Kind: "Secret text"
  3. 3 ID: lurus-api-key, Secret: dein API-Key
  4. 4 Im Jenkinsfile referenzieren mit credentials('lurus-api-key')
⚙️
CircleCI

CircleCI

Füge Lurus Code über .circleci/config.yml zu deiner CircleCI-Konfiguration hinzu. Speichere deinen API-Key als CircleCI-Umgebungsvariable.

Docker Executor mit Node.js CircleCI Context für Secrets-Management Artefakt-Speicherung für Reports Parallele Workflow-Jobs Branch-basiertes Filtern
1

Security Scan Job

Ein CircleCI-Job, der bei jedem Push auf einen PR-Branch einen Security Scan ausführt.

.circleci/config.yml 
version: 2.1

jobs:
  lurus-security-scan:
    docker:
      - image: cimg/node:20.0
    steps:
      - checkout
      - run:
          name: Lurus Code CLI installieren
          command: npm install -g @scramble-cloud/lurus-code-cli
      - run:
          name: Security Scan ausführen
          command: |
            lurus security-ci \
              --diff \
              --format sarif \
              --output lurus-security-results.sarif \
              --fail-on high
      - store_artifacts:
          path: lurus-security-results.sarif
          destination: security-report

workflows:
  pr-checks:
    jobs:
      - lurus-security-scan:
          filters:
            branches:
              ignore: main
2

Code Review Job

Führe ein KI-Code-Review durch und speichere den HTML-Report als CircleCI-Artefakt.

.circleci/config.yml 
version: 2.1

jobs:
  lurus-code-review:
    docker:
      - image: cimg/node:20.0
    steps:
      - checkout
      - run:
          name: Lurus Code CLI installieren
          command: npm install -g @scramble-cloud/lurus-code-cli
      - run:
          name: Code Review ausführen
          command: |
            lurus code-review-ci \
              --format html \
              --output code-review-report.html \
              --fail-on high
      - store_artifacts:
          path: code-review-report.html
          destination: code-review-report

workflows:
  pr-checks:
    jobs:
      - lurus-code-review:
          filters:
            branches:
              ignore: main
3

Vollständiger Workflow mit parallelen Jobs

Komplette CircleCI-Konfiguration mit Security Scan und Code Review parallel.

.circleci/config.yml 
version: 2.1

executors:
  node-executor:
    docker:
      - image: cimg/node:20.0

commands:
  install-lurus:
    steps:
      - run:
          name: Lurus Code CLI installieren
          command: npm install -g @scramble-cloud/lurus-code-cli

jobs:
  lurus-security:
    executor: node-executor
    steps:
      - checkout
      - install-lurus
      - run:
          name: Security Scan
          command: |
            lurus security-ci \
              --diff \
              --fail-on high \
              --format sarif
      - store_artifacts:
          path: lurus-security-results.sarif

  lurus-review:
    executor: node-executor
    steps:
      - checkout
      - install-lurus
      - run:
          name: Code Review
          command: |
            lurus code-review-ci \
              --fail-on high \
              --format html \
              --output review.html
      - store_artifacts:
          path: review.html

workflows:
  pr-pipeline:
    jobs:
      - lurus-security:
          context: lurus-credentials
          filters:
            branches:
              ignore: main
      - lurus-review:
          context: lurus-credentials
          filters:
            branches:
              ignore: main

ℹ️CircleCI-Umgebungsvariablen einrichten

  1. 1 Gehe zu deinem CircleCI-Projekt → Project Settings → Environment Variables
  2. 2 LURUS_API_KEY mit deinem API-Key als Wert hinzufügen
  3. 3 Alternativ einen CircleCI Context anlegen (Organization Settings → Contexts) für projektübergreifende Nutzung
  4. 4 Context im Workflow referenzieren mit context: dein-context-name
✨

Best Practices

🔑

API-Key sicher speichern

LURUS_API_KEY immer als verschlüsseltes Secret/Credential im CI/CD-System speichern. Niemals in Konfigurationsdateien hardcoden.

⚡

--diff für PR-Pipelines verwenden

In PR-Pipelines --diff nutzen, um nur geänderte Dateien zu scannen. Das ist schneller, günstiger und liefert relevanteren Feedback.

📊

Mit --fail-on critical beginnen

Mit --fail-on critical starten und den Schwellenwert schrittweise senken, während das Team bestehende Issues behebt.

📄

Reports als Artefakte archivieren

SARIF- und HTML-Reports immer als CI-Artefakte archivieren – auch wenn der Job erfolgreich ist.

🔄

Separate Jobs für Security und Review

security-ci und code-review-ci als separate parallele Jobs ausführen für schnelleres Feedback und unabhängige Fehlerzustände.

🌙

Vollständige Scans separat planen

In PR-Pipelines --diff nutzen und vollständige Projekt-Scans (ohne --diff) nächtlich oder wöchentlich einplanen.

🚀
security-ci & code-review-ci
Full command reference with all flags and options
⚡
Quick Start
Install, login, and first session in 5 minutes
✨
Best Practices
Patterns and anti-patterns for CI/CD usage

Bereit, deine Pipeline zu automatisieren?

Hol dir deinen API-Key und integriere Lurus Code noch heute in deinen CI/CD-Workflow.

API-Key holen CLI-Referenz ansehen →