Blog AI/ML Entwicklung von GitLab Duo: Sicheres und gründliches Testen von KI-generiertem Code
Veröffentlicht am: May 30, 2024
7 Minuten Lesezeit

Entwicklung von GitLab Duo: Sicheres und gründliches Testen von KI-generiertem Code

Erfahre Schritt für Schritt, wie du die Zuverlässigkeit und Sicherheit von KI-generiertem Code mithilfe von GitLab Duo und GitLab Pages (einschließlich Codebeispielen und Prompts) verbessern kannst.

gitlab duo - new cover

Generative KI bedeutet einen monumentalen Wandel in der Softwareentwicklungsbranche, da sie die Entwicklung, die Sicherheit und den Betrieb von Software vereinfacht. Unsere neue Blog-Reihe von unseren Produkt- und Entwicklungsteams gibt einen Einblick darin, wie wir die KI-Funktionen erstellen, testen und bereitstellen, die in deinem Unternehmen benötigt werden. Lerne neue Funktionen innerhalb von GitLab Duo kennen und erfahre, wie diese DevSecOps-Teams dabei helfen werden, bessere Ergebnisse für Kund(inn)en zu erzielen.

Da KI zunehmend Bestandteil der Softwareentwicklung wird, ist die Gewährleistung der Sicherheit und das gründliche Testen von KI-generiertem Code von größter Bedeutung. Dieser Artikel ist eine Schritt-für-Schritt-Anleitung zur Kombination von GitLab Duo, unserer Suite von KI-Funktionen zur Unterstützung des DevSecOps-Workflows, und GitLab Pages, um KI-generierten Code zu sichern und gründlich zu testen. Du erfährst, wie du typische Risiken minimieren kannst und wie du automatisch Tests generierst, Code testest und Testberichte erstellst, um die Zuverlässigkeit deines KI-generierten Codes zu verbessern.

Herausforderungen bei der Verwendung von KI-generiertem Code

KI-generierter Code steht häufig vor folgenden Problemen:

  • Nicht übereinstimmende Algorithmen: Es können falsche oder suboptimale Algorithmen generiert werden.
  • Probleme mit Abhängigkeiten: KI-generierter Code kann Abhängigkeiten enthalten, die veraltet oder inkompatibel sind.
  • Sicherheitslücken: KI kann Code mit potenziellen Sicherheitsschwachstellen generieren.

KI-generierter Code hat oft mit Problemen wie nicht übereinstimmenden Algorithmen, Abhängigkeitsproblemen und Sicherheitslücken zu kämpfen. Eine kürzlich von der Association of Computing Machinery veröffentlichte Studie zu den Antworten von ChatGPT auf Programmierfragen ergab, dass 52 % der Antworten falsche Informationen enthielten und 77 % zu ausführlich waren. Trotz dieser Mängel bevorzugten die Benutzer(innen) in 35 % der Fälle die umfassenden und gut formulierten Antworten von ChatGPT, wobei sie in 39 % der Fälle sogar Fehlinformationen übersahen. Die Bewältigung dieser Herausforderungen erfordert den Einsatz fortschrittlicher Tools und Frameworks.

Der Ansatz von GitLab für die Sicherheit und das Testen von KI

GitLab hat eine umfassende Inhaltsstrategie, die sich auf die Integration von Sicherheitsmaßnahmen in den Entwicklungsworkflow konzentriert. Durch die Nutzung von GitLab Duo für die KI-gestützte Codegenerierung und GitLab Pages für die Einbettung von Testberichten können Entwickler(innen) sicherstellen, dass ihr KI-generierter Code sowohl sicher als auch zuverlässig ist.

Hier ist eine Schritt-für-Schritt-Anleitung für die Kombination von GitLab Duo und GitLab Pages, um durch die Implementierung eines Flask-Webservers sicheren und gründlich getesteten KI-generierten Code zu gewährleisten.

1. Ein neues Projekt auf GitLab.com erstellen

  • Gehe zu GitLab.com.
  • Klicke auf die Schaltfläche „Neues Projekt“.
  • Wähle „Leeres Projekt erstellen“ aus.
  • Gib einen Projektnamen ein (z. B. AI_Code_Security).
  • Lege die Sichtbarkeitsebene fest (öffentlich, intern oder privat).
  • Klicke auf „Projekt erstellen“.

2. GitLab Duo-Codevorschläge aktivieren

  • Navigiere zu deinem Projekt.
  • Klicke auf die Schaltfläche „Web IDE“, um die Web IDE zu öffnen.
  • Stelle sicher, dass GitLab Duo-Funktionen wie Codevorschläge und Duo-Chat aktiviert sind.
  • Beginne mit der Programmierung in der Web IDE. Während du tippst, liefert GitLab Duo Codevorschläge, die dir helfen, effizienter zu programmieren.

3. Einen Flask Webserver erstellen

Du kannst mithilfe des Kommentars im Screenshot unten (grün hervorgehoben) einen Flask Webserver erstellen.

DGD-Testing – Bild 1

4. Tests mit GitLab Duo generieren

Unit-Tests sind für die Validierung der Funktionalität des generierten Codes unerlässlich. Verwende den Befehl /tests von GitLab Duo, um Testvorschläge direkt in der Web IDE zu generieren. Dieser Befehl kann mit zusätzlichen Anweisungen angepasst werden, um einen Fokus auf bestimmte Aspekte wie Leistung, Regression oder die Verwendung bestimmter Frameworks zu erreichen.

Beispiel für die Verwendung in Web IDE:

  • Wähle den Code aus, für den du Tests generieren möchtest.
  • Verwende den Befehl /tests und füge bei Bedarf zusätzliche Anweisungen hinzu.

DGD-Testing – Bild 2

5. Probleme mit KI-generiertem Code mithilfe von GitLab Duo Chat identifizieren

Verwende GitLab Duo Chat, um KI-generierten Code zu überprüfen und zu optimieren. Wir können zum Beispiel den Code für unseren Flask Webserver auf Sicherheitslücken überprüfen:

Prompt: Überprüfe diesen Code auf potenzielle Sicherheitslücken und Abhängigkeitsprobleme.

DGD-Testing – Bild 3

GitLab Duo Chat kann helfen, die Sicherheitslücken im oben gezeigten Code zu identifizieren.

6. Testberichte erstellen

Nachdem du deine Tests durchgeführt hast, erstellst du einen Testbericht, der mit GitLab Pages bereitgestellt wird.


Prompt: Schreibe mir ein Python-Skript, das einen Testbericht erstellt, der mit GitLab Pages bereitgestellt wird.

DGD-Testing – Bild 4

Was passiert hier?

  • Das Skript stellt sicher, dass das Verzeichnis test_reports existiert.
  • Es führt die Datei test_server.py mit subprocess.run() aus und erfasst die Ausgabe.
  • Die Rohausgabe wird in test_reports/test_output.txt gespeichert. Es wird ein HTML-Bericht erstellt, der die Testausgabe aus Gründen der Lesbarkeit in die <pre>-Tags einbettet und als test_reports/index.html gespeichert wird.

7. Den Testbericht mit GitLab Pages bereitstellen

Verwende GitLab Pages, um den Testbericht zu hosten und anzuzeigen. Hier ist die Konfiguration für unsere Datei .gitlab-ci.yml, um den Testbericht bereitzustellen.


stages:
  - test
  - deploy
test_job:
  stage: test
  script:
    - python generate_test_report.py
  artifacts:
    paths:
      - test_reports/
pages:
  stage: deploy
  script:
    - mv test_reports public
  artifacts:
    paths:
      - public

Bei dieser Konfiguration führt die Phase test_job das Python-Skript aus, um den Testbericht zu erstellen. Die Phase pages verschiebt das Verzeichnis test_reports in den Pfad public, wo GitLab Pages den Inhalt bereitstellt.

8. Testberichte in MR-Widgets einbetten

Die Einbettung der Testberichte in MR-Widgets bietet einen sofortigen Einblick in die Testergebnisse und gewährleistet Transparenz und Zuverlässigkeit. Dazu kannst du den Testbericht als Artefakt in die Konfiguration deiner CI/CD-Pipeline aufnehmen:


stages:
  - build
  - test
  - deploy

build_job:
  stage: build
  script:
    - echo "Building the project..."
    - # Your build commands here

test_job:
  stage: test
  script:
    - mkdir -p test-reports
    - python test_server.py > test-reports/results.xml
  artifacts:
    when: always
    reports:
      junit: test-reports/results.xml
    paths:
      - test-reports/results.xml

pages:
  stage: deploy
  script:
    - mkdir .public
    - mv test-reports .public/
  artifacts:
    paths:
      - .public

Indem du den Testbericht als Artefakt einfügst und ihn im Abschnitt „reports“ angibst, zeigt GitLab die Testergebnisse automatisch in den MR-Widgets an, was einen sofortigen Einblick in die Testergebnisse ermöglicht und die Transparenz und Zuverlässigkeit erhöht.

Fallstudie: Zuverlässigkeit von KI mit Sicherheitsrichtlinien und Scannern

Stell dir ein Szenario vor, in dem ein KI-generierter Codeschnipsel eine Abhängigkeit verwendet, die bekannte Sicherheitslücken aufweist. Durch die Verwendung von GitLab Duo und den integrierten Sicherheitsrichtlinien würde diese Abhängigkeit bei der Codeerstellung gekennzeichnet. Das folgende Beispiel wurde von der KI erstellt:


import os
from flask import Flask, request

app = Flask(__name__)

@app.route('/search')
def search():
    query = request.args.get('query')
    execute_os_command(query)
    return 'You searched for: ' + query

def execute_os_command(command):
    os.system(command)

if __name__ == '__main__':
    app.run()

Der Suchendpunkt in diesem Beispiel ist anfällig für OS Command Injection. Durch den Einsatz der GitLab-Komponente Statische Anwendungssicherheitstests (SAST) würde diese Sicherheitslücke bereits in der CI/CD-Pipeline entdeckt werden.

SAST-Scans integrieren, um Sicherheitslücken zu erkennen

GitLab SAST analysiert deinen Code automatisch auf Sicherheitslücken. So kannst du es in deine .gitlab-ci.yml-Datei integrieren, um nach Problemen zu suchen:


stages:
  - build
  - test
  - sast
  - deploy

build_job:
  stage: build
  script:
    - echo "Building the project..."
    - # Your build commands here

test_job:
  stage: test
  script:
    - python test_server.py > test-reports/results.xml
  artifacts:
    when: always
    reports:
      junit: test-reports/results.xml
    paths:
      - test-reports/results.xml

sast_job:
  stage: sast
  script:
    - echo "Running SAST..."
  artifacts:
    reports:
      sast: gl-sast-report.json
  only:
    - branches

pages:
  stage: deploy
  script:
    - mv test-reports public
  artifacts:
    paths:
      - public

In dieser Konfiguration wird SAST in der Phase sast_job ausgeführt, um Sicherheitslücken im Code zu erkennen, und einen Bericht (gl-sast-report.json) zu erstellen, der in die Pipeline-Artefakte aufgenommen wird. Durch die Integration von Sicherheitsrichtlinien und robusten Test-Frameworks hilft GitLab Duo Kund(inn)en dabei, sicherzustellen, dass ihr KI-generierter Code sowohl effizient als auch sicher ist.

Lege noch heute los

Die Integration von KI in die Softwareentwicklung bringt erhebliche Vorteile, aber auch neue Herausforderungen mit sich. Durch die Verwendung von Tools wie GitLab Duo und GitLab Pages können Entwickler(innen) sicherstellen, dass ihr KI-generierter Code sicher, gut getestet und zuverlässig ist. Erkunde diese Tools noch heute und beteilige dich an der Diskussion über die Verbesserung der Sicherheit und des Testens von KI.

Starte noch heute eine 30-tägige Testversion von GitLab Ultimate, um GitLab Duo und GitLab Pages auszuprobieren.

Lies mehr über die Reihe „Entwicklung von GitLab Duo“

Wir möchten gern von dir hören

Hat dir dieser Blogbeitrag gefallen oder hast du Fragen oder Feedback? Erstelle ein neues Diskussionsthema im GitLab Community-Forum und tausche deine Eindrücke aus. Teile dein Feedback

Kann es losgehen?

Sieh dir an, was dein Team mit einer einheitlichen DevSecOps-Plattform erreichen könnte.

Kostenlos testen

Finde heraus, welcher Tarif für dein Team am besten geeignet ist

Erfahre mehr über die Preise

Erfahre mehr darüber, was GitLab für dein Team tun kann

Sprich mit einem Experten/einer Expertin