Verwendung des Kubescape-Vulnerabilitäts-Scan-Tools

Tutorials
Kubernetes

Einführung

Kubescape ist ein Open-Source-Tool für Kubernetes, das von Armosec entwickelt wurde und für Risikoanalyse, Sicherheitskonformität, RBAC-Visualisierung und das Scannen von Bildschwachstellen verwendet wird. Darüber hinaus ist Kubescape in der Lage, Kubernetes-Manifeste zu scannen, um potenzielle Konfigurationsprobleme zu erkennen, die Ihre Bereitstellungen einem Angriffsrisiko aussetzen. Es kann auch Helm-Charts scannen, RBAC-Verstöße erkennen, Risikobewertungen durchführen und Risikotrends im Laufe der Zeit anzeigen.

Wichtige Funktionen von Kubescape:

  • Erkennung von Kubernetes-Fehlkonfigurationen und Bereitstellung von Unterstützung zur Fehlerbehebung über das Armosec Cloud Portal.
  • Risikoanalyse und Trendanalyse im Laufe der Zeit über das Armosec Cloud Portal.
  • Enthält mehrere Sicherheitskonformitätsframeworks wie ArmoBest, NSA, MITRE und DevOps Best Practices.
  • Unterstützung für Ausnahmeverwaltung, die es Kubernetes-Administratoren ermöglicht, akzeptable Risikolevels zu kennzeichnen.
  • Integriert sich nahtlos mit verschiedenen Tools wie Jenkins, GitHub-Workflows, Prometheus usw.
  • Bildscannen – Scannen von Bildern auf Schwachstellen und einfaches Anzeigen, Sortieren und Filtern (welche Schwachstelle zuerst behoben werden soll).
  • Vereinfacht die RBAC-Komplexität durch Bereitstellung eines leicht verständlichen visuellen Diagramms, das die RBAC-Konfiguration in Ihrem Cluster zeigt.

Kubescape kann auf verschiedene Arten ausgeführt werden:

  • Über die Befehlszeilenschnittstelle (CLI). Dies ist die bevorzugte Methode, um Skripte und verschiedene Automatisierungen, einschließlich CI/CD-Pipelines, auszuführen. Ergebnisse können zur Analyse in das Armosec Cloud-Portal hochgeladen werden.
  • Als Cronjob innerhalb Ihres Kubernetes-Clusters. In diesem Modus überwacht Kubescape ständig Ihren Kubernetes-Cluster auf Änderungen und lädt Scanergebnisse in das Armosec Cloud-Portal hoch. Diese Funktion funktioniert nur, wenn Sie Armo-Clusterkomponenten in Ihrem DOKS-Cluster bereitstellen.
  • Über die Web-Benutzeroberfläche des Armosec Cloud-Portals. Sie können Konfigurationsscans, Image-Scans auslösen, RBAC-Regeln anzeigen und inspizieren, Frameworks anpassen, usw. Diese Funktion funktioniert nur, wenn Sie Armo-Clusterkomponenten in Ihrem DOKS-Cluster bereitstellen.
  • In Ihrem Visual Studio Code-IDE. Auf diese Weise können Sie Probleme bereits in den frühen Entwicklungsphasen schnell erkennen.

Kubescape verwendet verschiedene Frameworks, um Fehlkonfigurationen zu erkennen, wie:

Ist Kubescape kostenlos?

Ja, das Werkzeug und die Community-Edition sind dauerhaft kostenlos, außer der Implementierung des Cloud-Portal-Backends und möglicherweise einiger anderer erweiterter Funktionen. Es gibt auch eine Begrenzung für die maximale Anzahl von Worker-Nodes, die pro Cluster gescannt werden können (bis zu 10). Die Datenretention für Ihre Scan-Berichte ist auf einen Monat im Armo-Cloud-Portal begrenzt.

Siehe Preispläne für weitere Informationen.

Ist Kubescape Open Source?

Ja, das Werkzeug ist sicherlich Open Source. Sie können die Armo GitHub-Startseite besuchen, um weitere Details zu jeder Komponentenimplementierung zu finden. Die Implementierung des Cloud-Portal-Backends ist nicht Open Source.

In diesem Leitfaden verwenden Sie Kubescape, um eine Risikoanalyse für Ihre Kubernetes-Anwendungs-Lieferkette (Container-Images, Kubernetes-YAML-Manifeste) durchzuführen. Anschließend lernen Sie, wie Sie die geeigneten Maßnahmen ergreifen, um die Situation zu beheben. Schließlich erfahren Sie, wie Sie Kubescape in eine CI/CD-Pipeline integrieren, um in den frühen Entwicklungsphasen nach Sicherheitslücken zu scannen.

Inhaltsverzeichnis

Voraussetzungen

Um alle Schritte aus diesem Leitfaden abzuschließen, benötigen Sie:

  1. A working DOKS cluster running Kubernetes version >=1.21 that you have access to. For additional instructions on configuring a DigitalOcean Kubernetes cluster, see: How to Set Up a DigitalOcean Managed Kubernetes Cluster (DOKS).
  2. A DigitalOcean Docker Registry. A free plan is enough to complete this tutorial. Also, make sure it is integrated with your DOKS cluster as explained here.
  3. Kubectl CLI für die Interaktion mit Kubernetes. Befolgen Sie diese Anweisungen, um sich mit Ihrem Cluster über kubectl und doctl zu verbinden.
  4. Helm, um Kubescape im Kubernetes-Cluster zu installieren.
  5. Kubescape CLI zur Interaktion mit dem Schwachstellen-Scanner Kubescape.
  6. A free Armosec Cloud Portal account used to periodically publish scan results for your Kubernetes cluster to a nice dashboard. Also, the Armosec portal web interface helps you with investigations and risk analysis.
  7. A Slack workspace you own, and a dedicated Slack app to get notified of vulnerability scan issues reported by Kubescape.

Schritt 1 – Kennenlernen der Kubescape CLI

Sie können manuell nach Schwachstellen scannen über die Befehlszeilenschnittstelle kubescape. Die kubescape CLI ist darauf ausgelegt, in verschiedenen Skripten und Automatisierungen verwendet zu werden. Ein praktisches Beispiel ist in einer CI/CD-Pipeline implementiert mit verschiedenen Tools wie Tekton, Jenkins, GitHub Workflows, etc.

Kubescape ist darauf ausgelegt, einen gesamten Kubernetes-Cluster von Grund auf zu scannen (Workloads, Container, etc.). Falls gewünscht, können Scans auch auf einen bestimmten Namespace beschränkt werden. Weitere Funktionen umfassen das Scannen von Hosts (Worker-Nodes), lokale oder entfernte Repository-Scans (z. B. GitHub), das Erkennen von Fehlkonfigurationen in Kubernetes-YAML-Manifesten oder Helm-Charts. Verschiedene Frameworks können über den Befehl framework ausgewählt werden, wie zum Beispiel ArmoBest, NSA, MITRE, etc.

Wenn die kubescape CLI aufgerufen wird, wird sie die bekannte Schwachstellendatenbank auf Ihrem lokalen Rechner herunterladen (oder aktualisieren). Anschließend startet sie den Scan-Vorgang und meldet Probleme in einem bestimmten Format zurück. Standardmäßig wird eine Zusammenfassungstabelle über die Standardausgabe oder die Konsole ausgegeben. Kubescape kann auch Berichte in anderen Formaten generieren, wie z. B. JSON, HTML, SARIF, etc.

Sie können sich entscheiden, die Ergebnisse über die Armosec Cloud-Plattform mithilfe des --submit-Flags zu übermitteln, um die Scan-Ergebnisse später zu speichern und zu visualisieren.

Hinweis: Es ist nicht zwingend erforderlich, Scan-Ergebnisse an das Armosec Cloud-Portal zu übermitteln. Der große Vorteil der Verwendung des Portals liegt in der Sichtbarkeit, da es Ihnen Zugriff auf ein übersichtliches Dashboard bietet, auf dem Sie alle Scan-Berichte und die Gesamtrisikobewertung einsehen können. Es hilft Ihnen auch langfristig bei Untersuchungen und Hinweisen zur Fehlerbehebung.

Einige Beispiele zum Ausprobieren mit der Kubescape CLI:

  • Einen gesamten Kubernetes-Cluster scannen und einen Zusammenfassungsbericht in der Konsole (Standardausgabe) generieren:

    kubescape scan

  • Nur einen bestimmten Namespace für den Scan verwenden:

    kubescape scan --include-namespaces microservices

  • Bestimmte Namespaces vom Scannen ausschließen:

    kubescape scan --exclude-namespaces kube-system,kube-public

  • Einen bestimmten Namespace scannen und die Ergebnisse an das Armosec-Cloud-Portal senden:

    kubescape scan --include-namespaces default --submit

  • Führen Sie einen Cluster-Scan mit einem spezifischen Framework durch (z. B. NSA):

    kubescape scan framework nsa --exclude-namespaces kube-system,kube-public

Kubescape kann Ihre Kubernetes-Clusterhosts (oder Arbeitsknoten) auch auf Betriebssystem-Schwachstellen scannen. Um diese Funktion zu aktivieren, müssen Sie das Flag --enable-host-scan an den kubescape CLI übergeben. Wenn dieses Flag aktiviert ist, implementiert kubescape Sensoren in Ihrem Cluster. Sensoren werden mithilfe von Kubernetes-DaemonSets erstellt, die Pods auf jedem Knoten Ihres Clusters bereitstellen, um bekannte Schwachstellen zu scannen. Nach Abschluss des Scanvorgangs werden die Sensoren aus Ihrem Cluster entfernt (einschließlich der zugehörigen Kubernetes-Ressourcen).

Die Kubescape CLI bietet Hilfeseiten für alle verfügbaren Optionen. Der folgende Befehl kann verwendet werden, um die Haupt-Hilfeseite auszudrucken:

kubescape --help

Die Ausgabe sieht ähnlich aus wie:

Output
Kubescape is a tool for testing Kubernetes security posture. Docs: https://hub.armo.cloud/docs

Usage:
  kubescape [command]

Available Commands:
  completion  Generate autocompletion script
  config      Handle cached configurations
  delete      Delete configurations in Kubescape SaaS version
  download    Download controls-inputs,exceptions,control,framework,artifacts
  help        Help about any command
  list        List frameworks/controls will list the supported frameworks and controls
  scan        Scan the current running cluster or yaml files
  submit      Submit an object to the Kubescape SaaS version
  version     Get current version
...

Jeder kubescape CLI-Befehl (oder Unterbefehl) hat auch eine zugehörige Hilfeseite, auf die über kubescape [Befehl] --help zugegriffen werden kann.

Bitte besuchen Sie die offizielle kubescape CLI-Dokumentationsseite für weitere Beispiele.

Schritt 2 – Kennenlernen des Armosec Cloud-Portals

Armosec bietet ein schönes Cloud-basiertes Portal, auf dem Sie Ihre Kubescape-Scanergebnisse hochladen und Risikoanalysen durchführen können. Dies ist ziemlich nützlich, da Sie jeden Scan-Bericht visualisieren und inspizieren möchten, die entsprechenden Maßnahmen zur Behebung der Situation ergreifen und den Scan dann erneut ausführen möchten, um die Ergebnisse zu überprüfen. Durch eine gute visuelle Darstellung für jeden Bericht und den zugehörigen Risikowert unterstützt Sie dies langfristig bei den Untersuchungen und Iterationen, die erforderlich sind, um die gemeldeten Sicherheitsprobleme zu beheben.

Sie können ein Konto kostenlos erstellen, das auf 10 Worker-Knoten und einer Monatsdatenspeicherung beschränkt ist, was in den meisten Fällen ausreichen sollte (z. B. für Test- oder Entwicklungszwecke). Weitere Informationen zum Erstellen des kubescape-Cloud-Kontos finden Sie auf der offiziellen Dokumentationsseite.

Nachdem Sie das Konto erstellt haben, wird eine eindeutige Benutzer-ID generiert, die Sie verwenden können, um Scanergebnisse für dieses spezifische Konto hochzuladen. Sie haben beispielsweise eine spezifische Automatisierung wie einen CI/CD-Pipeline, in der Sie Scanergebnisse hochladen müssen. Daher ist die zugehörige Benutzer-ID erforderlich, um zwischen mehreren Mandanten zu unterscheiden.

Für jeden hochgeladenen Scan-Bericht in Ihr Armosec-Cloud-Konto wird ein neuer Verlaufseintrag hinzugefügt, der die Liste der gefundenen Probleme und die zugehörige Risikobewertung enthält. Auf diese Weise können Sie Trends und die zugehörigen Diagramme zur Entwicklung der Risikobewertung im Laufe der Zeit erhalten. Außerdem wird auch eine Liste der wichtigsten Sicherheitsprobleme im Hauptdashboard generiert.

Das folgende Bild veranschaulicht diese Funktionen:

Verständnis des Kubescape-Risikobewertungswerts

Bei jedem Scan überprüft Kubescape Ihre Ressourcen auf potenzielle Sicherheitsrisiken mithilfe interner Kontrollen. Eine Kubescape-Steuerung ist ein Konzept, das vom kubescape-Tool verwendet wird, um die unter der Oberfläche verwendeten Tests zur Überprüfung eines bestimmten Aspekts Ihres Clusters (oder der gescannten Ressourcen) zu kennzeichnen. Darüber hinaus ist ein Framework eine Sammlung von Steuerungen oder Tests, die intern verwendet werden, um Ihre bestimmte(n) Ressource(n) auf Probleme zu scannen. Abhängig davon, welches Framework Sie verwenden, werden unterschiedliche Checks durchgeführt (dennoch teilen einige Tests einige Gemeinsamkeiten). Schließlich wird basierend auf dem Risikofaktor, der jedem Test zugeordnet ist, die endgültige Bewertung berechnet.

Der Endwert ist eine positive Zahl im Bereich von 0 bis 100%. Ein niedrigerer Wert deutet auf die beste Bewertung hin, während ein höherer Wert das Gegenteil bedeutet. Wenn Sie also auf der sicheren Seite sein möchten, sollten Sie auf den niedrigstmöglichen Wert abzielen. In der Praxis sollte eine Risikobewertung, die gleich oder niedriger als 30% ist, ein guter Ausgangspunkt sein.

Unterstützte Behebung gemeldeter Sicherheitsprobleme

Eine weitere nützliche Funktion, die das Armosec-Cloud-Portal bietet, ist die Unterstützung bei der Behebung von Sicherheitsproblemen. Das bedeutet, dass Sie Empfehlungen erhalten, wie Sie jedes Sicherheitsproblem beheben können, das vom Kubescape-Scanner gefunden wurde. Dies ist sehr wichtig, da es den Prozess vereinfacht und den Kreislauf für jede Iteration schließt, die Sie durchführen müssen, um jedes gemeldete Sicherheitsproblem zu beheben.

Das folgende Bild veranschaulicht diesen Prozess besser:

Für jedes gemeldete Sicherheitsproblem wird ein Schraubenschlüssel-Symbol angezeigt, auf das Sie klicken können, um Unterstützung bei der Behebung zu erhalten:

Anschließend öffnet sich ein neues Fenster, das Ihnen Details zu jedem betroffenen Kubernetes-Objekt gibt, die in grüner Farbe hervorgehoben sind:

Sie können auf jede Steuerung wie C-0018, C-0030, C-0086 usw. klicken und die hervorgehobenen Probleme untersuchen. Ihnen werden Vorschläge zur Behebung jedes Sicherheitsproblems präsentiert. Es bleibt nur noch, den Hinweisen zu folgen und jedes Sicherheitsproblem zu beheben.

Auslösen von Cluster-Scans über die Web-Benutzeroberfläche

Das Armo-Cloud-Portal bietet die Möglichkeit, Cluster-Scans über die Web-Benutzeroberfläche auszulösen, wenn das Helm-Chart der Armo-Cloud-Komponenten in Ihrem DOKS-Cluster (wie im nächsten Schritt besprochen) bereitgestellt ist. Sowohl die Konfiguration als auch das Bild-Scannen können durch einen einzigen Mausklick im Portal ausgelöst werden. Damit diese Funktion funktioniert, müssen Sie darauf warten, dass die Armo-Cloud-Komponenten Ihren Cluster im Hintergrund gescannt haben und die Ergebnisse hochladen.

Das Auslösen eines Konfigurationsscans erfolgt, indem Sie zur Seite für den Konfigurationsscann navigieren und auf die Schaltfläche „Scan“ klicken. Das untenstehende Bild zeigt, wie diese Aufgabe erledigt wird:

Sie können auch den aktuellen Zeitplan für automatische Scans setzen oder ändern, falls gewünscht, indem Sie auf die Schaltfläche „Zeitplan“ im Popup-Fenster klicken, das nach dem Klicken auf die Schaltfläche „Scan“ erscheint. Mit demselben Fenster können Sie auswählen, welche Kontrollrahmen für das Scannen verwendet werden sollen. Das untenstehende Bild zeigt, wie diese Aufgaben erledigt werden:

Schritt 3 – Konfigurieren von Kubescape Automatische Scans für DOKS

Kubescape kann so konfiguriert werden, dass es automatisch Ihren gesamten Kubernetes-Cluster in bestimmten Zeitintervallen oder jedes Mal, wenn ein neues Anwendungsimage bereitgestellt wird, scannt. Um diese Funktionalität zu erreichen, müssen Sie die Armo-Cluster-Komponenten mithilfe von Helm in Ihrem Kubernetes-Cluster bereitstellen. Ein Armosec Cloud-Portal-Konto ist ebenfalls erforderlich, um die Ergebnisse hochzuladen und zu überprüfen.

Das Armo Helm-Chart installiert Cron-Jobs, die sowohl für den gesamten Kubernetes-Cluster als auch für Container-Images eine Schwachstellenanalyse auslösen. Das Intervall für jeden Cron-Job ist in der Helm-Werte-Datei konfigurierbar.

Bereitstellung von Armo-Cluster-Komponenten für DOKS

Schritte zum Bereitstellen von kubescape in Ihrem Kubernetes-Cluster mithilfe von Helm:

  1. Fügen Sie das Helm-Repository hinzu und listen Sie die verfügbaren Charts auf:
helm repo add armo https://armosec.github.io/armo-helm/
helm repo update armo
helm search repo armo

Die Ausgabe sieht ähnlich wie folgt aus:

Output
NAME                            CHART VERSION   APP VERSION     DESCRIPTION                
armo/armo-cluster-components    1.7.15          v1.7.15         ARMO Vulnerability Scanning

Hinweis: Das relevante Chart ist armo/armo-cluster-components, das Armo-Komponenten in Ihrem Kubernetes-Cluster installiert. Besuchen Sie die Repository-Seite von armo-helm für weitere Details zu diesem Chart.

  1. Holen Sie sich Ihre Armo-Konto-Benutzer-ID mit dem kubescape CLI (benötigt im nächsten Schritt):
kubescape config view

Die Ausgabe sieht ähnlich aus wie:

{
"accountID": "c952b81f-77d5-4afb-80cc-59b59ec2sdfr"
}

Hinweis:
Wenn Sie das kubescape-CLI noch nie verwendet haben, um Scan-Ergebnisse an das Armosec-Cloud-Portal zu senden, funktioniert der obige Befehl nicht. In diesem Fall müssen Sie sich im Portal anmelden und die Kontonummer von dort aus abrufen, wie hier erklärt here.

  1. Installieren Sie die Armo Kubescape-Clusterkomponenten mit Helm – es wird auch ein dedizierter armo-system-Namespace erstellt (stellen Sie sicher, dass Sie die Platzhalter <> entsprechend ersetzen):
ARMO_KUBESCAPE_CHART_VERSION="1.7.15"
helm install armo armo/armo-cluster-components \
--version "$ARMO_KUBESCAPE_CHART_VERSION" \
--namespace armo-system \
--create-namespace \
--set clusterName="$(kubectl config current-context)" \
--set accountGuid=<YOUR_ARMO_ACCOUNT_ID>

–create-namespace \

Hinweis:
Es wird eine bestimmte Version für das Helm-Chart armo-cluster-components verwendet. In diesem Fall wurde 1.7.15 ausgewählt, was der 1.7.15-Version der Armo-Clusterkomponenten entspricht (siehe die Ausgabe von Step 1.). Es ist generell eine gute Praxis, sich auf eine bestimmte Version festzulegen. Dies hilft, vorhersehbare Ergebnisse zu erzielen und eine Versionskontrolle über Git zu ermöglichen.

kubectl get deployments -n armo-system

Überprüfen Sie nun, ob alle Bereitstellungen der Armo-Clusterkomponenten ausgeführt werden:

Output
NAME                        READY   UP-TO-DATE   AVAILABLE   AGE
armo-collector              1/1     1            1           5d6h
armo-kubescape              1/1     1            1           5d6h
armo-notification-service   1/1     1            1           5d6h
armo-vuln-scan              1/1     1            1           5d6h
armo-web-socket             1/1     1            1           5d6h

Die Ausgabe sieht ähnlich aus wie:

Alle Bereitstellungen der Armo-Clusterkomponenten sollten ausgeführt werden.

  • Zuletzt sollten Sie nach einigen Minuten Ihre Cluster-Scan-Berichte im Cloud-Portal sehen können, wie zum Beispiel:
  • Konfigurations-Scan-Ergebnisse:
  • Ergebnisse des Bildscans:

RBAC-Visualisierungsergebnisse:

Für weitere Informationen besuchen Sie bitte die Seite zum Cluster-Schwachstellen-Scan in der offiziellen Dokumentation.

Anpassen von Helm-Werten für das Armo-Cluster-Komponentendiagramm

Sie können das Verhalten des Armo-Cluster-Komponentendiagramms ändern, indem Sie die in diesem Leitfaden bereitgestellte Helm-Werte-Datei bearbeiten.

  • Die folgenden Einstellungen können geändert werden:
  • Scannintervalle über die Werte armoScanScheduler und armoKubescapeScanScheduler.

Neuer Bildscan-Auslöser über den Wert triggerNewImageScan.

Die vollständige Liste der Werte, die an Ihre Bedürfnisse angepasst werden können, finden Sie in der Datei der offiziellen Helm-Chart-Werte. 

ARMO_KUBESCAPE_CHART_VERSION="1.7.15"
helm upgrade armo armo/armo-cluster-components \
  --version "$ARMO_KUBESCAPE_CHART_VERSION" \
  --namespace armo-system \
  --set clusterName="$(kubectl config current-context)" \
  --set accountGuid=<YOUR_ARMO_ACCOUNT_ID> \
  -f <YOUR_CUSTOM_HELM_VALUES_FILE_HERE>

Um Änderungen vorzunehmen, müssen Sie die aktuelle Version der Helm-Chart über (stellen Sie sicher, dass Sie die Platzhalter <> entsprechend ersetzen):

Schritt 4 – Verwenden von Kubescape zum Scannen von Kubernetes-Konfigurationsanfälligkeiten in einer CI/CD-Pipeline

Wie profitieren Sie davon, ein Sicherheits-Compliance-Scanning-Tool in Ihre CI/CD-Pipeline einzubetten und unangenehme Situationen in einer Produktionsumgebung zu vermeiden?

Es beginnt alles auf der Grundlage, wo die Softwareentwicklung beginnt. Im Allgemeinen möchten Sie für jede Phase eine dedizierte Umgebung verwenden. So sollten Sie in den frühen Entwicklungsphasen, wenn sich der Anwendungscode sehr häufig ändert, eine dedizierte Entwicklungsumgebung verwenden (normalerweise als untere Umgebung bezeichnet). Dann wird die Anwendung in der QA-Umgebung immer weiter verfeinert, wo QA-Teams manuelle und/oder automatisierte Tests durchführen. Als nächstes, wenn die Anwendung die Zustimmung des QA-Teams erhält, wird sie in die oberen Umgebungen wie Staging und schließlich in die Produktion befördert. In diesem Prozess, in dem die Anwendung von einer Umgebung in eine andere befördert wird, läuft ein dedizierter Pipeline, der kontinuierlich Anwendungsartefakte scannt und den Sicherheitsrisikoscore berechnet. Wenn der Score einen bestimmten Schwellenwert nicht erreicht, schlägt die Pipeline sofort fehl und die Beförderung der Anwendungsartefakte in die Produktion wird in den frühen Phasen gestoppt.

So fungiert das Sicherheitsscanning-Tool (z. B. kubescape) als Gatekeeper und verhindert unerwünschte Artefakte in Ihrer Produktionsumgebung von den frühen Entwicklungsphasen an. Auf dieselbe Weise verwenden Pipeline-Umgebungen der oberen Ebene kubescape, um zu entscheiden, ob Anwendungsartefakte die endgültige Produktionsphase erreichen dürfen oder nicht.

Implementierung des GitHub Actions CI/CD-Workflows

In diesem Schritt lernen Sie, wie Sie eine Beispiel-CI/CD-Pipeline mit integriertem Schwachstellen-Scannen über GitHub-Workflows erstellen und testen. Um die Grundlagen der Verwendung von GitHub Actions mit DigitalOcean Kubernetes zu erlernen, verweisen Sie auf dieses Tutorial.

Die Pipeline, die im folgenden Abschnitt bereitgestellt wird, erstellt und implementiert die Anwendung game-2048-example aus dem DigitalOcean-Repository kubernetes-sample-apps.

  1. Auf einer Übersichtsebene besteht der beispielhafte CI/CD-Workflow, der im Kubernetes-sample-apps-Repository bereitgestellt wird, aus den folgenden Phasen:
  2. Anwendungsbuild- und Testphase – erstellt Hauptanwendungsartefakte und führt automatisierte Tests aus.
  3. Kubescape-Scanphase – sucht nach bekannten Schwachstellen in den Kubernetes-YAML-Manifesten, die mit der Anwendung verbunden sind. Es fungiert als Tor, und der endgültige Pipeline-Status (bestanden/nicht bestanden) hängt von diesem Schritt ab. Im Falle eines Fehlers wird auch eine Benachrichtigung über Slack gesendet.
  4. Anwendungs-Image-Build- und Push-Phase – erstellt und taggt das Anwendungs-Image mit dem neuesten Git-Commit-SHA. Dann wird das Bild an DOCR übertragen.

Anwendungsimplementierungsphase – implementiert die Anwendung in Kubernetes (DOKS).

Das folgende Diagramm veranschaulicht jeden Job aus der Pipeline und die zugehörigen Schritte mit Aktionen (nur relevante Konfiguration wird angezeigt):

  • Hinweis:
  • Im Fall von Projekten, die auf kustomize basieren, ist es am besten, das endgültige Manifest über den Befehl kubectl kustomize </Pfad/zur/kustomization_/Datei> zu rendern, um alles zu erfassen und zu scannen (einschließlich entfernter Ressourcen). Andererseits kann es schwierig sein zu identifizieren, welche Kubernetes-Ressource gepatcht werden muss. Dies liegt daran, dass die resultierende Manifestdatei aus allen anzuwendenden Ressourcen besteht. So funktioniert Kustomize – es sammelt alle Konfigurationsfragmente aus jedem Overlay und wendet sie über eine Basis an, um das endgültige Compound zu erstellen.

Sie können auch Kubescape anweisen, den gesamten Ordner zu scannen, in dem Sie Ihre customize-Konfigurationen aufbewahren (der aktuelle Leitfaden stützt sich auf diesen Ansatz). Auf diese Weise ist es einfacher zu identifizieren, welche Ressource in Ihrem Repository behoben werden muss. Entfernte Ressourcen, die von Kustomize verwendet werden, müssen stromaufwärts behoben werden. Außerdem werden Kubernetes-Secrets und ConfigMaps, die über kustomize generiert wurden, nicht erfasst.

Wie lassen Sie den Pipeline fehlschlagen, wenn ein bestimmtes Sicherheits-Compliance-Level nicht erfüllt ist?

Die Kubescape CLI bietet hierfür einen Flag namens --fail-threshold an. Diese Flagge korreliert mit dem insgesamt berechneten Risikoscore nach jedem Scan. Sie können den Pipeline basierend auf dem Schwellenwert fehlschlagen oder bestehen lassen und die Bereitstellung der Anwendung stoppen, wenn die Bedingungen nicht erfüllt sind.

Das untenstehende Bild veranschaulicht den Ablauf für den Beispiel-CI/CD-Pipeline, der in diesem Leitfaden verwendet wird:

  1. Bitte befolgen Sie die untenstehenden Schritte, um den kubescape CI/CD GitHub-Workflow im kubernetes-sample-apps-GitHub-Repository zu erstellen und zu testen:
  2. Gabeln Sie das kubernetes-sample-apps-GitHub-Repository.
  3. SLACK_WEBHOOK_URL – enthält Ihre Slack eingehende Webhook-URL, die für Benachrichtigungen über kubescape-Scans verwendet wird.
  4. Wechseln Sie zum Aktionen-Tab Ihres geforkten Repos und wählen Sie das Beispiel für das Kubescape CI/CD-Skript für das Spiel 2048 Workflow aus:

A new entry should appear in below list after clicking the Run Workflow green button. Select the running workflow to observe pipeline progress:

Klicken Sie auf die Schaltfläche Workflow ausführen und lassen Sie die Standardwerte unverändert:

Die Pipeline wird fehlschlagen und gestoppt, wenn der kubescape-nsa-security-check Job ausgeführt wird. Dies ist erwartet, da der Standard-Schwellenwert von 30 für den Gesamtrisikowert niedriger ist als der gewünschte Wert. Sie sollten auch eine Slack-Benachrichtigung mit Details zum Workflow-Lauf erhalten:

Im nächsten Schritt lernen Sie, wie Sie den kubescape-Scanbericht untersuchen, um die Probleme zu beheben, das Risikoscore zu senken und die Pipeline zu bestehen.

Schritt 5 – Untersuchung der Kubescape-Scanergebnisse und Behebung der gemeldeten Probleme

Wenn der Schwellenwert des Risikoscores nicht erreicht wird, schlägt der game-2048 GitHub-Workflow fehl und es wird eine Slack-Benachrichtigung mit zusätzlichen Details gesendet.

Der game-2048-Workflow führt einen Sicherheitscheck durch (lokales Bildscannen wird nicht unterstützt) – Überprüfung auf Konfigurationsfehler in Kubernetes-Manifesten. Der Job kubescape-nsa-security-check wird zu diesem Zweck verwendet. Der entsprechende kubescape-Befehl lautet: kubescape scan framework nsa /pfad/zum/projekt/kubernetes/manife.

- name: Scan Kubernetes YAML files
  run: |
    kubescape scan framework nsa kustomize/ \
      -t ${{ github.event.inputs.kubescape_fail_threshold || env.KUBESCAPE_FAIL_THRESHOLD }} \
      --submit --account=${{ secrets.ARMOSEC_PORTAL_ACCOUNT_ID }}
  working-directory: ${{ env.PROJECT_DIR }}

Im folgenden Ausschnitt wird die Hauptlogik des Jobs kubescape-nsa-security-check dargestellt:

–submit –account=${{ secrets.ARMOSEC_PORTAL_ACCOUNT_ID }}

Die obige Konfiguration gibt dem kubescape CLI an, einen neuen Scan für alle Kubernetes-Manifestdateien im Verzeichnis kustomize/ mithilfe des NSA-Frameworks zu starten. Es gibt auch an, welchen Schwellenwert über das -t-Flag verwendet werden soll, und um die endgültigen Ergebnisse an das Armo-Cloud-Portal zu übermitteln (das –submit-Flag in Verbindung mit –acount).

Das Senken des Risikoscores und das Bestehen des Workflows besteht daher darin, die von der kubescape-nsa-security-check-Aufgabe gemeldeten Probleme zu untersuchen und zu beheben. Als nächstes erfahren Sie, wie Sie Sicherheitsprobleme, die von dieser Aufgabe gemeldet wurden, angehen können.

A new browser window opens showing in detail each control and description. You will also be presented with required actions to remediate the issue (highlighted in green color):

Um den Statusbericht zu überprüfen, können Sie auf den Link zu den kubescape-Scanergebnissen in der erhaltenen Slack-Benachrichtigung klicken. Klicken Sie dann im Armo-Cloud-Portal im linken Menü auf die Schaltfläche REPOSITORIES SCAN. Klicken Sie nun auf den Eintrag kubernetes-sample-apps aus der Liste:

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: game-2048
spec:
  replicas: 1
  selector:
    matchLabels:
      app: game-2048
  strategy:
    type: RollingUpdate
  template:
    metadata:
      labels:
        app: game-2048
    spec:
      containers:
        - name: backend
          Klicken Sie als Nächstes auf den Eintrag deployment.yaml und dann auf das Schraubenschlüssel-Symbol im oberen rechten Bereich:
          image: registry.digitalocean.com/sample-apps/2048-game:latest
          ports:
            - name: http
              containerPort: 8080
          resources:
            requests:
              cpu: 100m
              memory: 50Mi
            limits:
              cpu: 200m
              memory: 100Mi
          securityContext:
            readOnlyRootFilesystem: true
            runAsNonRoot: true
            allowPrivilegeEscalation: false
            capabilities:
              drop:
                - all

Nachdem Sie alle Informationen aus dem Scan-Bericht gesammelt haben, können Sie die Datei deployment.yaml aus Ihrem Repository bearbeiten (die sich im Unterordner game-2048-example/kustomize/resources befindet). Die Fixes sind bereits vorhanden, Sie müssen nur die letzten Zeilen in der Datei auskommentieren. Die endgültige deployment.yaml-Datei sollte wie folgt aussehen:

# Ersetzen Sie die Platzhalter `<>` durch Ihre Docker-Registrierungsinformationen

  • Hinweis :
    Die C-0055-Vorschläge wurden in diesem Beispiel aus Gründen der Einfachheit weggelassen. Weitere Informationen zum sicheren Betriebsmodus in Kubernetes finden Sie hier.
  • Was hat sich geändert? Die folgenden Sicherheitskorrekturen wurden angewendet:
  • readOnlyRootFilesystem – führt das Container-Image schreibgeschützt aus (Dateien können nicht durch kubectl exec im Container geändert werden).
  • runAsNonRoot – führt als nicht root-Benutzer aus, wie im USER-Directive des Dockerfiles des game-2048-Projekts Dockerfile definiert.

allowPrivilegeEscalation – Durch das Festlegen von allowPrivilegeEscalation auf false wird sichergestellt, dass kein Kindprozess eines Containers mehr Berechtigungen als sein Elternprozess erlangen kann.

capabilities.drop – Um Container sicherer zu machen, sollten Sie Containern nur die geringstmöglichen Berechtigungen geben, die sie zum Ausführen benötigen. In der Praxis verwerfen Sie standardmäßig alles und fügen dann Schritt für Schritt erforderliche Berechtigungen hinzu. Weitere Informationen zur Container-Sicherheit finden Sie in diesem Artikel von Armosec.

A few final checks can be performed as well on the Kubernetes side to verify if the reported issues were fixed:

  1. Zum Schluss die Änderungen für die Datei deployment.yaml übernehmen und in den Hauptzweig pushen. Nachdem das Workflows manuell ausgelöst wurde, sollte es diesmal erfolgreich abgeschlossen werden:
  2. Überprüfen Sie, ob das Bereitstellungspaket für das Spiel 2048 ein schreibgeschütztes (unveränderliches) Dateisystem hat, indem Sie die Anwendungsdatei index.html schreiben:

Überprüfen Sie, ob der Container als nicht-root-Benutzer läuft (sollte eine ganze Zahl ungleich Null ausgeben – z.B. 1000):

kubectl exec -it deployment/game-2048 -n game-2048 -- id -u

Überprüfen Sie, ob der Container als nicht-root-Benutzer läuft (sollte eine ganze Zahl ungleich Null ausgeben – z.B. 1000):

Wenn alle Überprüfungen bestehen, haben Sie die erforderlichen Sicherheitsempfehlungen erfolgreich angewendet.

Ausnahmen behandeln

Es gibt Situationen, in denen Sie nicht möchten, dass die endgültige Risikobewertung von einigen gemeldeten Problemen beeinflusst wird, die Ihr Team als sicher zu ignorieren erachtet. Kubescape bietet eine integrierte Funktion zur Verwaltung von Ausnahmen, um diese Situation zu überwinden.

A more efficient approach is where you integrate vulnerability scan tools directly in your favorite IDE (or Integrated Development Environment). This way, you can detect and fix security issues ahead of time in the software development cycle.

Weitere Informationen zu dieser Funktion finden Sie hier.

  1. Kubescape für IDEs
  2. Kubescape bietet Unterstützung für die Integration in IDE über die folgenden Erweiterungen:

Visual Studio Code-Erweiterung.

Kubernetes Lens-Erweiterung.

Die oben genannten Plugins helfen Ihnen, Probleme bereits in den frühen Entwicklungsphasen zu erkennen und zu beheben, was Frustrationen, Kosten und Sicherheitsmängel in Produktionssystemen eliminiert. Außerdem trägt es dazu bei, die Iterationen zu reduzieren und den menschlichen Aufwand langfristig zu verringern. Als Beispiel: Für jedes gemeldete Sicherheitsproblem durch Ihre CI/CD-Automatisierung müssen Sie zurückgehen, das Problem in Ihrem Code beheben, Änderungen bestätigen, auf die CI/CD-Automatisierung warten und im Falle eines Fehlers den Vorgang wiederholen.

Lesen Sie mehr über diese Funktionen, indem Sie zur Seite mit der Kubescape-Dokumentation navigieren und im Abschnitt INTEGRATIONEN suchen.

on:
  push:
    branches: [ master ]
  pull_request:
    branches: [ master ]

Schritt 6 – Auslösen des Kubescape-CI/CD-Workflows automatisch

Sie können den Workflow so einstellen, dass er automatisch bei jedem Commit oder PR gegen den Hauptzweig ausgelöst wird, indem Sie die folgenden Zeilen am Anfang der Datei game-2048-kubescape.yaml auskommentieren:

Nachdem Sie die Datei bearbeitet haben, übernehmen Sie die Änderungen in Ihren Hauptzweig und Sie sollten bereit sein, loszulegen.

Schritt 7 – Aktivieren von Slack-Benachrichtigungen für kontinuierliches Monitoring

Die von Ihnen bisher implementierte Automatisierung für die Schwachstellenprüfung ist ein guter Ausgangspunkt, aber nicht perfekt. Warum?

Ein Problem bei dem aktuellen Ansatz ist, dass Sie nie wissen, wann neue Probleme für die Assets gemeldet werden, die Sie bereits in Ihren Umgebungen bereitgestellt haben. Mit anderen Worten, Sie haben die Sicherheitsrisiken bewertet und Maßnahmen ergriffen, um die Probleme zu einem bestimmten Zeitpunkt zu beheben – wenn Ihre CI/CD-Automatisierung ausgeführt wurde.

Aber was ist, wenn in der Zwischenzeit neue Probleme gemeldet werden und Ihre Anwendung erneut gefährdet ist?

Die Überwachungsfunktion von Kubescape hilft Ihnen dabei, neue Schwachstellen anzugehen, die ständig bekannt gegeben werden. In Kombination mit der Slack-Integration können Sie sofort Maßnahmen ergreifen, um neu bekannt gegebene Probleme zu beheben, die sich auf Ihre Anwendung in einer Produktionsumgebung auswirken könnten.

  1. Das Armo-Cloud-Portal unterstützt die Slack-Integration, um Echtzeitwarnungen nach jedem Cluster-Scan zu senden. Diese Funktion erfordert, dass das Helm-Chart der Armo-Cloud-Komponenten in Ihrem DOKS-Cluster installiert ist, wie in Schritt 3 – Konfigurieren von Kubescape-Automatikscans für DOKS erklärt.
  2. Durch Aktivieren von Slack-Benachrichtigungen erhalten Sie wichtige Benachrichtigungen über erkannte Sicherheitslücken in Ihrem DOKS-Cluster, wie zum Beispiel:
  3. Vulnerabilitäten auf Worker-Knotenebene (Betriebssystemebene).

Vulnerabilitäten von Container-Images.

  • Kubernetes-Fehlkonfigurationen für verschiedene Ressourcen wie Bereitstellungen, Pods usw.
  • Zuerst müssen Sie eine Slack-App erstellen. Dann müssen Sie Ihrem Slack-Bot auf der Seite OAuth & Berechtigungen die folgenden Berechtigungen erteilen:
  • channels:join – Öffentlichen Kanälen in einem Arbeitsbereich beitreten.
  • channels:read – Grundlegende Informationen über öffentliche Kanäle in einem Arbeitsbereich anzeigen.
  • groups:read – Grundlegende Informationen über private Kanäle anzeigen, zu denen Ihre Slack-App hinzugefügt wurde.
  • chat:write – Nachrichten als @< Ihr Slack-App-Name > senden.

im:read – Grundlegende Informationen über Direktnachrichten anzeigen, zu denen Ihre Slack-App hinzugefügt wurde.

mpim:read – Grundlegende Informationen über Direktnachrichten in Gruppen anzeigen, zu denen Ihre Slack-App hinzugefügt wurde.

Als Nächstes navigieren Sie zur Einstellungen-Seite Ihres Armo-Cloud-Portal-Kontos (Symbol oben rechts mit dem Zahnradsymbol). Wählen Sie dann die Seite Integrationen und anschließend Slack aus.

Jetzt fügen Sie Ihren Slack Bot OAuth-Token (zu finden auf der OAuth & Berechtigungen-Seite Ihrer Slack-App) in das Eingabefeld Token einfügen ein. Wählen Sie anschließend aus, wie Sie benachrichtigt werden möchten, und den Slack-Kanal, auf dem Benachrichtigungen gesendet werden sollen. Klicken Sie auf die Schaltfläche Benachrichtigungen festlegen, und Sie sind fertig. Das untenstehende Bild veranschaulicht die Details:

Nach der Konfiguration der Slack-Integration sollten Sie periodische Benachrichtigungen nach jedem Cluster-Scan im festgelegten Kanal erhalten:

Wenn Sie Benachrichtigungen ähnlich wie oben erhalten, haben Sie die Armosec Kubescape Slack-Integration erfolgreich konfiguriert.

Fazit

In diesem Leitfaden haben Sie gelernt, wie Sie eines der beliebtesten Kubernetes-Schwachstellen-Scanning-Tools – Kubescape – verwenden. Sie haben auch gelernt, wie Sie Cluster- und Repository-Scans (YAML-Manifeste) mit dem Kubescape CLI durchführen können. Dann haben Sie gelernt, wie Sie das Schwachstellen-Scanning-Tool in eine traditionelle CI/CD-Pipeline integrieren, die mithilfe von GitHub-Workflows implementiert wurde.

Zuletzt haben Sie gelernt, wie Sie Schwachstellen-Scan-Berichte untersuchen, Fixes anwenden, um die Situation zu beheben, und das Risikoscore durch ein praktisches Beispiel – die game-2048-Anwendung aus dem Repository kubernetes-sample-apps – auf ein Minimum reduzieren.

Source:
https://www.digitalocean.com/community/developer-center/using-the-kubescape-vulnerability-scan-tool