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.
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
/testsund füge bei Bedarf zusätzliche Anweisungen hinzu.
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.
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.
Was passiert hier?
- Das Skript stellt sicher, dass das Verzeichnis test_reports existiert.
- Es führt die Datei
test_server.pymitsubprocess.run()aus und erfasst die Ausgabe. - Die Rohausgabe wird in
test_reports/test_output.txtgespeichert. Es wird ein HTML-Bericht erstellt, der die Testausgabe aus Gründen der Lesbarkeit in die<pre>-Tags einbettet und alstest_reports/index.htmlgespeichert 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.
