Was ist GitLab Container Scanning?

Steigern Sie die Sicherheit und Compliance Ihres Unternehmens mit GitLab Container Scanning, das Schwachstellen und Malware in Ihren Container-Images vor der Bereitstellung erkennt. Automatisieren Sie das Scannen, reduzieren Sie Risiken und sorgen Sie mit diesem leistungsstarken Tool für eine sichere Lieferkette.

GitLab Container Scanning ist ein unverzichtbares Tool für die Aufrechterhaltung der Sicherheit und Integrität von containerisierten Anwendungen. Die Kenntnis und der Einsatz dieser Technik werden umso wichtiger, je mehr Unternehmen zur Containerisierung für die Softwarebereitstellung übergehen.

Dieser Artikel behandelt GitLab Container Scanning , seine Funktionsweise, unterstützte Containerformate und wie Best Practices und Beispiele aus der Praxis die Einrichtung für Projekte erleichtern können. Mit durchgängig hervorgehobenen Best Practices bietet dieser Leitfaden ein Verständnis von GitLab Container Scanning, das sichere Entwicklungsprozesse mit reibungslosen Arbeitsabläufen gewährleistet.

GitLab Container Scanning verstehen

Das Verständnis von GitLab Container Scanning ist entscheidend für alle, die containerisierte Anwendungen mit GitLab oder anderen Containerisierung Plattformen wie Docker. GitLab Container Scanning dient als Sicherheitscheck, bei dem jede Komponente Ihrer Software auf Schwachstellen überprüft wird, die Angreifer ausnutzen könnten – ähnlich wie bei einer Antivirenprüfung der einzelnen Bausteine!

Die Inspektion umfasst eine genaue Überprüfung der in Containern enthaltenen Software, um etwaige Probleme oder potenzielle Risiken zu erkennen. Dieser Schritt ist bei der Entwicklung moderner Software von entscheidender Bedeutung. Container bestehen in der Regel aus unterschiedlichen Komponenten aus verschiedenen Quellen, die alle Sicherheitsstandards einhalten müssen, um die Integrität Ihrer Anwendung zu gewährleisten.

GitLab Container Scanning kann für die Softwareentwicklung von unschätzbarem Wert sein und bietet wichtigen Schutz für containerisierte Softwareanwendungen. Die frühzeitige Erkennung von Schwachstellen trägt zur Aufrechterhaltung sicherer Systeme bei und gibt Entwicklern und Stakeholdern gleichermaßen Sicherheit.

Wie funktioniert GitLab Container Scanning?

GitLab Container Scanning kann Schwachstellen in Container-Images automatisch identifizieren und beheben, sodass Sie sicher sein können, dass alle Schwachstellen in diesen Images schnell und zuverlässig behoben werden. Hier eine Übersicht über die Funktionsweise:

GitLab Container Scanning lässt sich problemlos in die Continuous Integration/Continuous Deployment (CI/CD)-Pipeline integriert werden, sodass der Scan-Prozess zu einem integralen Bestandteil jedes Builds und Pushs wird und nicht nur ein isoliertes Ereignis ist. Dadurch wird sichergestellt, dass Sicherheitsüberprüfungen zu einem fortlaufenden Bestandteil der Entwicklung werden und nicht nur einmalig durchgeführt werden.

Nutzung von Schwachstellendatenbanken

Dieses Tool gleicht Komponenten mit bekannten Schwachstellendatenbanken ab, um bekannte Schwachstellen in Softwarepaketen oder Bibliotheken zu erkennen, die in Containern verwendet werden. Auf diese Weise lassen sich bekannte Bedrohungen, die darin vorhanden sein könnten, leicht identifizieren.

Erstellen eines Berichts

GitLab Container Scanning erstellt nach Abschluss einen umfassenden Bericht, in dem alle entdeckten Schwachstellen und deren Schweregrad aufgeführt sind und bei Bedarf Korrekturen oder Strategien zur Risikominderung vorgeschlagen werden.

Automatisierung von Reaktionen

Mit GitLab Container Scanning können Benutzer automatische Reaktionen festlegen, die auf der Konfiguration basieren. Dazu gehören beispielsweise das Erstellen von Issues für Entwicklungsteams oder sogar das Anhalten der CI/CD-Pipeline, um sicherzustellen, dass kein unsicherer Code jemals in die Produktion gelangt.

Behebung und kontinuierliche Überwachung

Unser Tool zur kontinuierlichen Überwachung unterstützt die fortlaufende Behebung, indem es Container-Updates kontinuierlich scannt, sobald diese verfügbar sind, automatisch auf Schwachstellen überprüft, die bei der Implementierung von Änderungen auftreten können, und einen kontinuierlichen Schutz vor neuen Schwachstellen gewährleistet, die im Laufe der Zeit auftreten.

Unterstützte Containerformate für GitLab

Wenn wir von der Unterstützung bestimmter Containerformate durch GitLab’s Container Scanning sprechen, meinen wir damit die Untersuchung ihrer spezifischen Struktur und der Anordnung der darin enthaltenen Daten. Die Scan-Tools Trivy und Grype bieten umfassende Unterstützung für verschiedene Linux-Distributionen, sodass Schwachstellen in verschiedenen Umgebungen schnell identifiziert werden können.

Open-Source-Scan-Tools:

• Trivy (ein Open-Source-Scanner für Schwachstellen in Containern und Betriebssystemen): Trivy ist ein etablierter Open-Source-Scanner für Schwachstellen, der speziell auf Container und Betriebssysteme zugeschnitten ist und leichte, aber gründliche Scan-Funktionen bietet, um Schwachstellen in vielen Linux-Distributionen zu identifizieren.

• Grype: Grype liefert genaue Schwachstellendaten zu Container-Images. Als Analyse-Tool ergänzt Grype Trivy, indem es Sicherheitsbedrohungen mit präzisen und dennoch umsetzbaren Schwachstellendaten gründlich untersucht.

Unterstützte Linux-Distributionen

Es ist äußerst wichtig, den Unterschied zwischen Containerformat und Distributionen zu verstehen. Container speichern Daten innerhalb von Containern, während Distributionen verschiedene Varianten des Linux-Betriebssystems bezeichnen, die von den GitLab-Diensten Trivy und Grype unterstützt werden. GitLab unterstützt eine beeindruckende Liste von Distributionen. Hier eine kurze Übersicht:

• Alma Linux: Mit Trivy gescannt
• Alpine Linux: Wird sowohl von Grype als auch von Trivy unterstützt
• Amazon Linux: Wird sowohl von Grype als auch von Trivy unterstützt
• BusyBox: Mit Grype gescannt
• CentOS: Wird sowohl von Grype als auch von Trivy unterstützt
• CBL-Mariner: Mit Trivy gescannt
• Debian: Wird sowohl von Grype als auch von Trivy unterstützt
• Distroless: Wird sowohl von Grype als auch von Trivy unterstützt
• Oracle Linux: Wird sowohl von Grype als auch von Trivy unterstützt
• Photon OS: Gescannt von Trivy
• Red Hat (RHEL): Wird sowohl von Grype als auch von Trivy unterstützt
• Rocky Linux: Mit Trivy gescannt
• SUSE: Von Trivy gescannt
• Ubuntu: Wird sowohl von Grype als auch von Trivy unterstützt

Die Bedeutung einer breiten Distributionsunterstützung

Wir bei GitLab Container Scanning wissen, dass eine breite Distributionsunterstützung immer wichtiger wird, da containerisierte Anwendungen bei Entwicklern immer beliebter werden, die oft verschiedene Linux-Distributionen aufgrund von Leistung, Sicherheit, Kompatibilität oder persönlichen Vorlieben auswählen. Durch die gleichzeitige Unterstützung mehrerer Distributionen stellt GitLab Container Scanning sicher, dass Entwickler die Anwendungssicherheit unabhängig von der gewählten Umgebung aufrechterhalten können – und untermauert damit unser Engagement für ganzheitliche Sicherheit für containerisierte Workloads.

Wie richtet man GitLab für Container Scanning ein?

Die Implementierung von GitLab für Container Scanning ist ein effizienter Prozess, der das automatische Scannen Ihrer containerisierten Anwendungen auf Schwachstellen erleichtert. Hier finden Sie eine allgemeine Übersicht darüber, wie Sie dies erreichen können:

1. Container-Scans durch automatische Merge-Anfragen aktivieren

Mit GitLab 14.9 lassen sich Container-Scans einfach und schnell durch automatische Merge-Anfragen aktivieren. So geht's:

• Navigieren Sie zum gewünschten Projekt.
• Gehen Sie zu "Sicherheit" > "Sicherheitskonfiguration".
• Wählen Sie in der Zeile "Container-Scanning" die Option "Mit Merge-Anfrage konfigurieren".

Nach der Aktivierung generiert dieser Prozess eine automatische Merge-Anfrage, die alle Änderungen enthält, die zur Aktivierung des Container-Scannings erforderlich sind. Überprüfen Sie diese einfach vor dem Mergen, um die Konfiguration des Container-Scannings abzuschließen.

2. Konfiguration über die Datei .gitlab-ci.yml:

Für die manuelle Konfiguration des Container-Scannings müssen Sie die entsprechende Vorlage zu Ihrer Datei .gitlab-ci.yml hinzufügen:

include:   - template: Security/Container-Scanning.gitlab-ci.yml

Diese Vorlage fügt Ihrer CI/CD-Pipeline einen container_scanning-Job hinzu, der Docker-Images auf Schwachstellen scannt und die Ergebnisse als Container-Scanning-Bericht speichert.

Ein Beispiel für eine .gitlab-ci.yml-Datei, die Docker-Images erstellt und scannt, könnte wie folgt aussehen.

include:   - template: Jobs/Build.gitlab-ci.yml   - template: Security/Container-Scanning.gitlab-ci.yml container_scanning:   variables:     CS_DEFAULT_BRANCH_IMAGE: $CI_REGISTRY_IMAGE/$CI_DEFAULT_BRANCH:$CI_COMMIT_SHA

3. Anpassen der Einstellungen für das Scannen von Containern

Mit GitLab können Sie die Art und Weise, wie Container gescannt werden, an Ihre spezifischen Anforderungen anpassen, von einer verbesserten Ausgabe und Authentifizierung mit der spezifischen Registry bis hin zu detaillierteren Ergebnissen.

Um beispielsweise eine ausführliche Ausgabe zu aktivieren, bearbeiten Sie Ihre .gitlab-ci.yml entsprechend:

include:   - template: Security/Container-Scanning.gitlab-ci.yml variables:     SECURE_LOG_LEVEL: 'debug'

4. Scannen eines Images in einer Remote-Registry:

Sie können auch Images scannen, die sich in einer anderen Registry als den Projekten befinden, indem Sie die folgende Konfiguration verwenden:

include:   - template: Security/Container-Scanning.gitlab-ci.yml container_scanning:   variables:     CS_IMAGE: example.com/user/image:tag

Die Einrichtung von GitLab Container Scanning ist intuitiv und benutzerfreundlich, von automatisierten Merge-Anfragen bis hin zur manuellen Konfiguration. GitLab integriert Sicherheitsüberprüfungen mit seinen leistungsstarken Scan-Tools in den Entwicklungs-Workflow von Entwicklern und macht GitLab damit zu einem unverzichtbaren Bestandteil der modernen, sicheren Softwareentwicklung.

Bewährte Verfahren für das GitLab-Container-Scanning

1. Scanning-Tools regelmäßig aktualisieren

Es ist wichtig, dass Scanning-Tools wie Trivy und Grype auf dem neuesten Stand bleiben, damit sie neue Schwachstellen sofort erkennen können, sobald sie auftreten, und gleichzeitig mit allen Änderungen kompatibel bleiben, die von den unterstützten Distributionen vorgenommen werden. Regelmäßige Updates stellen dies sicher.

2. Integrieren Sie das Scannen frühzeitig in die Entwicklung

Je früher das Scannen von Containern Teil Ihres Entwicklungszyklus wird, desto schneller können Schwachstellen identifiziert und behoben werden. Durch die Einbindung von GitLab Container Scanning in Ihre kontinuierliche Integration (CI)-Pipeline von GitLab in Ihre kontinuierliche Integration ein, wird sichergestellt, dass bei jedem Code-Push automatisch Scans durchgeführt werden – diese werden so Teil Ihres Entwicklungs-Workflows und tragen zu einer schnelleren Identifizierung und Behebung von Schwachstellen bei.

3. Passen Sie die Scans an Ihre Bedürfnisse an

Nicht jedes Projekt erfordert identische Scans. Durch die Anpassung an Ihre Projektanforderungen – hinsichtlich Ausführlichkeitsgrad, Ausrichtung auf bestimmte Registrierungen oder Festlegung von Variablen – können Scans wesentlich schneller und effizienter durchgeführt werden. Nutzen Sie die Anpassungsfunktionen in der Datei .gitlab-ci.yml, um Scans präzise zu optimieren.

4. Überprüfen Sie die Scan-Berichte regelmäßig und ergreifen Sie entsprechende Maßnahmen

Es reicht nicht aus, nur Scans durchzuführen – die Ergebnisse müssen auch überprüft und umgehend behoben werden. Die regelmäßige Überprüfung der Container-Scan-Berichte in Verbindung mit systematischen Korrekturmaßnahmen stellt sicher, dass Schwachstellen schnell identifiziert und entsprechend behoben werden. Die Integration des Korrektur-Workflows in bestehende Entwicklungsprozesse kann bei dieser wichtigen Korrekturaufgabe hilfreich sein.

Behebungsworkflow mit GitLab Container Scanning

Der Behebungsworkflow von GitLab Container Scanning umfasst mehrere Schritte, mit denen Schwachstellen in Container-Images identifiziert und effizient und systematisch behoben werden können. Ein typischer Workflow könnte etwa wie folgt aussehen:

1. Sicherheitslücken ermitteln: GitLab bietet die Container-Scan-Funktion und Sicherheitsscans mit Trivy oder Grype. Sobald Sicherheitslücken entdeckt wurden, wird im Rahmen dieses Schritts ein ausführlicher Bericht erstellt, in dem alle Sicherheitslücken detailliert aufgeführt sind.
2. Analyse der Ergebnisse: In diesem Schritt müssen die Ergebnisse der Container-Scan-Berichte eingehend geprüft werden, um Details zu Schweregrad, Art und Quelle der Schwachstellen zu erhalten, die sofortige Aufmerksamkeit erfordern. Dabei sollten Probleme, die sofort behoben werden müssen, priorisiert werden.
3. Priorisierung der Behebung: Auf der Grundlage dieser Bewertung sollten die Probleme entsprechend priorisiert werden. Bei Problemen mit hoher Priorität liegt der Schwerpunkt in der Regel auf Schwachstellen, die eine unmittelbare Gefahr für Anwendungen darstellen, wobei Faktoren wie die Auswirkungen und die Leichtigkeit der Ausnutzung eine Rolle spielen können.
4. Erstellen eines Plans zur Behebung: Nach der Priorisierung der Schwachstellen muss ein wirksamer Plan zur Behebung erstellt werden, um jede einzelne Schwachstelle zu beheben. Dieser Plan umfasst Maßnahmen, die zur wirksamen Minderung jeder Schwachstelle erforderlich sind – dazu können die Installation von Updates, Änderungen oder Modifikationen oder die direkte Änderung von Teilen des Codes gehören.
5. Implementieren Sie Korrekturen: Mit einem Plan in der Hand sollten Abhilfemaßnahmen mithilfe von GitLab-Merge-Anfragen durchgeführt werden, die den Code, die Konfigurationseinstellungen oder die Abhängigkeiten ändern, die sich auf die betroffenen Codebasen auswirken. Die Zusammenarbeit zwischen Entwicklern, Sicherheitsteams und anderen wichtigen Akteuren erweist sich oft als unerlässlich, um diesen Prozess erfolgreich durchzuführen.
6. Testen der Korrekturen: Nach der Anwendung der Korrekturen ist es wichtig, zusätzliche Überprüfungen durchzuführen, um sicherzustellen, dass sie die Schwachstellen erfolgreich beheben, ohne neue Probleme zu verursachen. Das erneute Scannen von Container-Images oder die Durchführung zusätzlicher Tests kann dabei helfen, zu überprüfen, ob die Korrekturmaßnahmen die Schwachstellen erfolgreich beseitigt und keine neuen Sicherheitslücken geschaffen haben.
7. Überwachung und kontinuierliche Verbesserung: Behebungsworkflows lassen sich nicht über Nacht umsetzen. Kontinuierliche Überwachung, Scans und Überarbeitungen gewährleisten die langfristige Wirksamkeit. Ein iterativer Ansatz gewährleistet die langfristige Funktionsfähigkeit.

Beispiele und Anwendungsfälle aus der Praxis

1. Bankwesen

Sicherheit in Bankanwendungen ist von größter Bedeutung. Herkömmliche Methoden zur Erkennung von Schwachstellen sind oft nicht in der Lage, diese rechtzeitig zu erkennen. Durch die Einbindung von GitLab Container Scanning in die Continuous Integration/Continuous Deployment-Pipeline für Bankanwendungen werden Echtzeit-Überprüfungen und -Korrekturen möglich, was eine wesentlich robustere Lösung ermöglicht, die nicht nur die allgemeine Sicherheit stärkt, sondern auch das Vertrauen und die Compliance in der gesamten Branche fördert.

2. Gesundheitswesen

Gesundheitssysteme verarbeiten sensible Daten, die gemäß strengen gesetzlichen Vorschriften geschützt werden müssen, doch manuelle Überprüfungen sind oft mühsam und fehleranfällig. Durch den Einsatz von GitLab Container Scanning für Schwachstellenanalysen und als Teil kontinuierlicher Compliance-Berichtsprozesse können Gesundheitsorganisationen GitLab Container Scanning optimieren, um sich vor Sicherheitsverletzungen zu schützen und gleichzeitig den Berichtsprozess wesentlich weniger komplex als zuvor zu gestalten.

3. Tech-Start-ups

Tech-Start-ups haben oft Schwierigkeiten, ein Gleichgewicht zwischen schneller Entwicklung und der Einhaltung von Sicherheitsstandards zu finden. GitLab Container Scanning kann Unternehmen dabei helfen, beide Prozesse aufeinander abzustimmen. Die kontinuierliche Schwachstellenüberprüfung von containerisierten Anwendungen ermöglicht schnellere Entwicklungszyklen und schützt gleichzeitig die Sicherheit – so erhalten Start-ups die nötige Agilität für Innovationen und können gleichzeitig strenge Sicherheitsstandards einhalten.

Fazit

GitLab Container Scanning ist zu einem unverzichtbaren Bestandteil der modernen Entwicklungslandschaft geworden und bietet Unternehmen eine einfache Möglichkeit, Schwachstellen in containerisierten Anwendungen schnell und zuverlässig zu erkennen. Durch die nahtlose Integration in ihre Entwicklungspipelines und die frühzeitige Sichtbarkeit von Schwachstellen in den Entwicklungsprozessen sind Unternehmen in der Lage, Sicherheit in ihren Entwicklungsprozess zu integrieren, Risiken zu minimieren und gleichzeitig die allgemeine Sicherheitslage zu verbessern.

GitLab Container Scanning ist ein integraler Bestandteil einer effektiven DevSecOps-Strategie und fördert eine Umgebung der kontinuierlichen Sicherheitsverbesserung. Dieses wertvolle Asset stellt sicher, dass Sicherheit bei Innovationen an erster Stelle steht, von der Einhaltung von Vorschriften oder dem Schutz von Kundendaten bis hin zur Aufrechterhaltung agiler Entwicklungszyklen und der Erfüllung vielfältiger Sicherheitsanforderungen in verschiedenen Branchen oder Anwendungsfällen.

"

Häufig gestellte Fragen zum Scannen von GitLab-Containern

Was ist GitLab Container Scanning?

GitLab Container Scanning führt während CI/CD eine Schwachstellenprüfung Ihrer Container-Images durch. Es verwendet Scanner wie Trivy, um jede Ebene – von Basis-OS-Paketen bis hin zu Anwendungsabhängigkeiten – zu überprüfen, bevor die Images in die Produktion gelangen. Sie aktivieren es, indem Sie die CI-Vorlage "Container-Scanning" von GitLab einbinden oder über eine One-Click-Merge-Anfrage.

Die Ergebnisse werden als JSON-Artefakte und auf der Registerkarte "Sicherheit" Ihrer Pipeline angezeigt, wobei riskante CVEs und abgelaufene Betriebssystemversionen gekennzeichnet werden.

Welche Arten von Schwachstellen erkennt GitLab Container Scanning?

Es erkennt bekannte CVEs in Ihrem Basisimage und Ihren Betriebssystempaketen sowie, falls aktiviert, sprachspezifische Bibliotheksfehler (z. B. Java- oder Python-Pakete). Außerdem kennzeichnet es Betriebssysteme, die nicht mehr unterstützt werden und keine Sicherheitsupdates mehr erhalten. Der zugrunde liegende Trivy-Scanner nutzt Beratungsquellen wie NVD, Distro-Sicherheitstracker und die eigene Beratungsdatenbank von GitLab, um Schwachstellen anhand des CVSS-Scores und der Ausnutzbarkeit zu identifizieren und zu kategorisieren.

Wie aktiviere ich das Scannen von Containern in einer GitLab-Pipeline?

Fügen Sie die integrierte Vorlage von GitLab zu Ihrer .gitlab-ci.yml hinzu.

include:

- template: Jobs/Container-Scanning.gitlab-ci.yml

Alternativ können Sie in Ihrem Projekt zu "Sicherheit" > "Sicherheitskonfiguration" gehen, auf "Mit Merge-Anfrage konfigurieren" klicken und die Merge durchführen. Dadurch werden die erforderlichen Jobs in Ihre Pipeline eingefügt. Es sind keine zusätzlichen Skripte erforderlich, wenn Sie Ihr Docker-Image bereits erstellen und in die Projektregistrierung übertragen haben

Wo werden die Ergebnisse der Containerscans in GitLab angezeigt?

Öffnen Sie nach dem Ausführen Ihrer Pipeline "Build > Pipelines", wählen Sie den Lauf aus und klicken Sie auf die Registerkarte "Sicherheit". Dort sehen Sie den Schweregrad jeder Feststellung, den CVSS-Score, die Ausnutzungswahrscheinlichkeit (EPSS) und Hinweise zur Behebung. Der Rohscanbericht (gl-container-scanning-report.json) sowie ein CycloneDX SBOM (gl-sbom-report.cdx.json) sind unter "Job-Artefakte" verfügbar.

In der Ultimate-Stufe sehen Sie auch Inline-Ergebnisse in Merge-Anfragen und einen konsolidierten Schwachstellenbericht im Standardzweig.

Schlägt GitLab Abhilfemaßnahmen für erkannte Schwachstellen vor?

Ja. Jeder Schwachstelleintrag enthält eine Beschreibung des Problems, seiner Auswirkungen und empfohlener Abhilfemaßnahmen, wie z. B. Paket-Upgrades oder Konfigurationsänderungen. In der Ultimate-Stufe kann GitLab sogar automatische Korrekturpatches generieren – Merge-Anfragen, die Ihre Dockerfile oder Ihr Paketmanifest für Sie auf feste Versionen aktualisieren.

Wie gehe ich mit Fehlalarmen in GitLab Container Scanning um?

Erstellen Sie eine Datei "vulnerability-allowlist.yml" im Stammverzeichnis Ihres Repositorys. Listen Sie CVE-IDs (global oder pro Image) auf, die Sie als False Positives bestätigt haben. GitLab schließt diese CVEs dann aus zukünftigen Scan-Berichten aus und markiert sie im Job-Protokoll als "Genehmigt". Auf diese Weise konzentriert sich Ihre Registerkarte "Sicherheit" auf echte Risiken, ohne echte Probleme zu verbergen.