Mehrere Snyk-Kubernetes-Controller in einem einzelnen Kubernetes-Cluster installieren

Kubernetes bietet eine Schnittstelle, über die verteilte Systeme reibungslos ausgeführt werden können. Die Plattform kümmert sich um Skalierung und Failover Ihrer Anwendungen, stellt Deployment-Muster bereit und vieles mehr. Bei der Sicherheit müssen die Teams, die Workloads im Kubernetes-Cluster bereitstellen, entscheiden, welche Workloads sie gemäß ihren Anforderungen an die Anwendungssicherheit überwachen möchten.

Was aber, wenn jedes Team selbst festlegen könnte, welche Container-Images und welche konkreten Workloads gescannt werden? Möglicherweise stellen mehrere Teams Workloads in Kubernetes bereit, und jedes hat eigene Anforderungen an die Überwachung. Dieser Anwendungsfall lässt sich am besten lösen, indem jedes Team eine eigene Snyk-Kubernetes-Integration einrichtet und die benötigten Workloads überwacht. Sehen wir uns an, wie das funktioniert.

Überblick über die Snyk-Kubernetes-Integration

Snyk lässt sich in Kubernetes integrieren. So können Sie Ihre laufenden Workloads importieren und kontinuierlich testen, um Schwachstellen in den zugrunde liegenden Images sowie Konfigurationen zu erkennen, die die Sicherheit der Workloads beeinträchtigen könnten. Auch nach dem Deployment überwacht Snyk die Workloads weiterhin und erkennt, wenn sie durch neu entdeckte Schwachstellen oder weitere Sicherheitsprobleme gefährdet sind, etwa wenn neue Container bereitgestellt werden oder sich die Workload-Konfiguration ändert.

Architekturdiagramm der Kubernetes-Integration

Mehrere Snyk-Controller in einem einzelnen Kubernetes-Cluster installieren

Jetzt wird es spannend! Wir führen Sie Schritt für Schritt durch die Einrichtung mehrerer Snyk-Controller in einem einzelnen Kubernetes-Cluster. Dabei gehen wir folgendermaßen vor:

1. Separate Namespaces konfigurieren

2. Für jeden Namespace eine Snyk-Organisation erstellen

3. snyk monitor für den ersten Namespace (Äpfel) installieren und konfigurieren

4. snyk monitor für den zweiten Namespace (Bananen) installieren und konfigurieren

5. Überprüfen, ob bereitgestellte Workloads automatisch über die Policy importiert werden

6. Workloads in „Bananen“ bereitstellen, die über eine Rego-Policy-Datei automatisch importiert werden

Voraussetzungen

1. Für die Kubernetes-Integration benötigen Sie ein Business- oder Enterprise-Konto bei Snyk. Falls Sie noch keines haben, können Sie eine kostenlose Testversion unseres Business-Plans starten. Auch wenn Sie die Schritte nicht selbst ausprobieren möchten, empfehle ich Ihnen, weiterzulesen (und die Codeblöcke zu überspringen), um zu erfahren, wie Sie mehrere Snyk-Controller in einem einzelnen Kubernetes-Cluster installieren und verwalten.

2. Ein Kubernetes-Cluster, z. B. AKS, EKS, GKE, Red Hat OpenShift oder eine andere unterstützte Variante.

Schritt 1: Separate Namespaces konfigurieren

In dieser Demo verwende ich einen Azure-AKS-Dienst für meinen Kubernetes-Cluster. In diesem Cluster installieren wir zwei Snyk-Controller, jeweils in einem eigenen Namespace: einen im Namespace apples und einen im Namespace bananas, wie im folgenden Diagramm dargestellt.

Erstellen Sie nun wie unten gezeigt die Namespaces:

1➜  kubectl create namespace apples
2namespace/apples created
3➜  kubectl create namespace bananas
4namespace/bananas created

Schritt 2: Für jeden Namespace eine Snyk-Organisation erstellen

Mit separaten Snyk-Organisationen können wir das Scannen der Workloads voneinander trennen. So können Feature-Teams eigene Organisationen verwenden und das Scannen ihrer Workloads und Images besser steuern. Sie können für alle Snyk-Controller, die wir bereitstellen, auch dieselbe Organisation verwenden. In diesem Beispiel halten wir sie jedoch getrennt. In beiden Fällen werden die Workloads mit einem Label angezeigt, das wir bei der Installation der Snyk-Controller festlegen.

Unsere neuen Organisationen

Eine für den Namespace apples:

Eine für den Namespace bananas:

Nach der Erstellung sollten in der Snyk-App zwei leere Organisationen angezeigt werden. Wir verwenden sie gleich.

Aktivieren Sie für jede Organisation die Kubernetes-Integration: Wählen Sie dazu den Tab Integrations und anschließend Kubernetes aus. Klicken Sie dann auf Connect. Folgen Sie abschließend der Snyk-Dokumentation zu Kubernetes, um die Einrichtung abzuschließen.

Notieren Sie sich die Integrations-IDs für die Kubernetes-Integration jeder Snyk-Organisation – Sie benötigen sie gleich. Die Kubernetes-Integrations-ID finden Sie über das Symbol Organisationseinstellungen in der oberen Navigationsleiste von Snyk. Navigieren Sie anschließend in der Seitenleiste zu Integrations und wählen Sie die Kubernetes-Integration aus, wie unten dargestellt.

Schritt 3: snyk monitor für den Namespace „Äpfel“ installieren und konfigurieren

Nachdem wir unsere Organisationen und Integrationen eingerichtet und mit unserem Cluster verbunden haben, können wir Snyk Monitor konfigurieren. Dazu verwenden wir ein Terminalfenster.

Wir erstellen eine Datei, um Workload-Ereignisse zu abonnieren, legen die Kriterien für unsere Abonnements fest, installieren das Helm-Chart von Snyk für die Kubernetes-Überwachung und richten den Monitor ein und starten ihn.

Die Registry-Datei erstellen

Erstellen Sie im Terminal ein Verzeichnis für die Organisation „Äpfel“ und wechseln Sie in dieses Verzeichnis:

1➜  mkdir apples
2➜  cd apples

Erstellen Sie eine Datei namens workload-events.rego mit folgendem Inhalt. Ersetzen Sie <APPLES_INTEGRATION_ID> durch die Integrations-ID der Kubernetes-Integration der Organisation „Äpfel“.

Mit der folgenden Rego-Policy weisen wir den Snyk-Controller an, Workloads ausschließlich aus dem Namespace apples zu importieren bzw. zu löschen, sofern der Kubernetes-Workload-Typ weder CronJob noch Service ist. Weitere Informationen zu den verschiedenen Workload-Typen finden Sie in der Snyk-Dokumentation.

workload-events.rego

1package snyk
2orgs := ["<APPLES_INTEGRATION_ID>"]
3default workload_events = false
4workload_events {
5  input.metadata.namespace == "apples"
6  input.kind != "CronJob"
7  input.kind != "Service"
8}

Die Snyk-Helm-Charts zu Ihrem Repository hinzufügen

Greifen Sie auf Ihre Kubernetes-Umgebung zu und führen Sie den folgenden Befehl aus, um das Snyk-Charts-Repository zu Helm hinzuzufügen. Wir benötigen es gleich, wenn wir dieses Helm-Chart installieren.

1➜  helm repo add snyk-charts https://snyk.github.io/kubernetes-monitor --force-update
2"snyk-charts" has been added to your repositories

Die Konfiguration für Snyk Monitor erstellen und das Helm-Chart bereitstellen

Mit einem Kubernetes-Secret können wir den Dienst ausführen, ohne Zugangsdaten im Klartext offenzulegen. In diesen Schritten erstellen und verwenden wir das Secret, während wir die Konfiguration für die Organisation „Äpfel“ bereitstellen.

Erstellen Sie das Secret snyk-monitor für den Namespace „Äpfel“ und ersetzen Sie <APPLES_INTEGRATION_ID> durch die Kubernetes-Integrations-ID der Snyk-App für „Äpfel“. In dieser Demo verwenden wir Docker Hub als öffentliche Container-Registry. Für den Zugriff auf öffentliche Images sind keine Zugangsdaten erforderlich. Weitere Informationen zur Verwendung privater Container-Registries finden Sie in der Snyk-Controller-Dokumentation.

1➜ kubectl create secret generic snyk-monitor -n apples \
2    --from-literal=dockercfg.json={} \
3    --from-literal=integrationId=<APPLES_INTEGRATION_ID>
4secret/snyk-monitor created

Erstellen Sie nun eine ConfigMap, in der die Rego-Policy-Datei gespeichert wird, anhand derer snyk-monitor bestimmt, was im Namespace apples automatisch importiert oder gelöscht werden soll:

1➜ kubectl create configmap snyk-monitor-custom-policies -n apples \       --from-file=./workload-events.rego
2configmap/snyk-monitor-custom-policies created

Installieren Sie als Nächstes snyk-monitor im Namespace apples. Ersetzen Sie im Befehl <APPLES_INTEGRATION_ID> durch die Snyk-App-Integrations-ID für „Äpfel“:

1➜ helm upgrade --install snyk-monitor-apples snyk-charts/snyk-monitor \
2        --namespace apples \
3        --set clusterName="AKS K8s - Apples" \
4        --set policyOrgs=<APPLES_INTEGRATION_ID> \
5        --set workloadPoliciesMap=snyk-monitor-custom-policies
6
7Release "snyk-monitor-apples" does not exist. Installing it now.
8LAST DEPLOYED: Thu Jul 14 19:29:28 2022
9NAMESPACE: apples
10STATUS: deployed
11REVISION: 1
12TEST SUITE: None

Hinweis: Anhand des Labels „AKS K8s - Apples“ finden Sie die importierten Workloads in der Snyk-Benutzeroberfläche, die Sie gleich sehen werden.

Überprüfen Sie abschließend, ob alles läuft. (Dieser Befehl setzt voraus, dass jq installiert ist. Falls nicht, lassen Sie den Teil | jq des Befehls weg.)

1➜ helm ls -A -o json | jq
2[
3  {
4"name": "snyk-monitor-apples",
5"namespace": "apples",
6"revision": "1",
7"updated": "2022-07-14 19:45:56.681028 +1000 AEST",
8"status": "deployed",
9"chart": "snyk-monitor-1.92.10",
10"app_version": ""
11  }
12]
13
14➜ kubectl get pods -n apples
15NAME                             READY   STATUS RESTARTS   AGE
16snyk-monitor-apples-797cd64c-sqvj4   1/1 Running   0      16m

Nun ist im Namespace apples ein Snyk-Controller mit einem eigenen eindeutigen Namen installiert. Später zeigen wir, wie dieser Snyk-Controller Workloads automatisch importiert, wenn sie gemäß unserer Konfiguration im Namespace apples des Kubernetes-Clusters bereitgestellt werden. Wenn Sie jetzt die Projektseite der Organisation „Äpfel“ aktualisieren, sehen Sie möglicherweise, dass Snyk Monitor selbst gescannt wurde. Das liegt daran, dass wir den Controller angewiesen haben, Workloads vom Typ Deployment im Namespace apples zu scannen.

Schritt 4: snyk monitor für den Namespace „Bananen“ installieren und konfigurieren

Erstellen Sie ein Verzeichnis namens „bananas“ und wechseln Sie in dieses Verzeichnis:

1➜ cd ..
2➜ mkdir bananas
3➜ cd bananas

Erstellen Sie nun eine Datei namens workload-events.rego mit folgendem Inhalt. Ersetzen Sie <BANANAS_INTEGRATION_ID> durch die Kubernetes-Integrations-ID der Snyk-App für „Bananen“:

1package snyk
2orgs := ["<BANANAS_INTEGRATION_ID>"]
3default workload_events = false
4workload_events {
5      input.metadata.namespace == "bananas"
6      input.kind != "CronJob"
7      input.kind != "Service"
8}

Erstellen Sie als Nächstes das Secret snyk-monitor für den Namespace „Bananen“ und ersetzen Sie BANANAS_INTEGRATION_ID durch die Kubernetes-Integrations-ID der Snyk-App für „Bananen“:

1➜  ~/snyk/SE/blogs/snyk-multi-namespace-controllers/bananas kubectl create secret generic snyk-monitor -n bananas \
2  --from-literal=dockercfg.json={} \
3  --from-literal=integrationId=BANANAS_INTEGRATION_ID
4secret/snyk-monitor created

Erstellen Sie anschließend eine ConfigMap, in der die Rego-Policy-Datei gespeichert wird, anhand derer snyk-monitor bestimmt, was im Namespace „Bananen“ automatisch importiert oder gelöscht werden soll:

1➜ kubectl create configmap snyk-monitor-custom-policies -n bananas --from-file=./workload-events.rego
2configmap/snyk-monitor-custom-policies created

Installieren Sie snyk-monitor im Namespace „Bananen“ und ersetzen Sie ‰¤BANANAS_INTEGRATION_ID> durch die Kubernetes-Integrations-ID der Snyk-App für „Bananen“:

1➜ helm upgrade --install snyk-monitor-bananas snyk-charts/snyk-monitor \
2      --namespace bananas \
3      --set clusterName="K8s - Bananas" \
4      --set policyOrgs=<BANANAS_INTEGRATION_ID> \
5      --set workloadPoliciesMap=snyk-monitor-custom-policies
6Release "snyk-monitor-bananas" does not exist. Installing it now.
7NAME: snyk-monitor-bananas
8LAST DEPLOYED: Thu Jul 14 20:19:36 2022
9NAMESPACE: bananas
10STATUS: deployed
11REVISION: 1
12TEST SUITE: None

Überprüfen Sie abschließend, ob alles läuft:

1➜ helm ls -A -o json | jq .
2[
3  {
4"name": "snyk-monitor-apples",
5"namespace": "apples",
6"revision": "1",
7"updated": "2022-07-14 19:45:56.681028 +1000 AEST",
8"status": "deployed",
9"chart": "snyk-monitor-1.92.10",
10"app_version": ""
11  },
12  {
13"name": "snyk-monitor-bananas",
14"namespace": "bananas",
15"revision": "1",
16"updated": "2022-07-14 20:19:36.563328 +1000 AEST",
17"status": "deployed",
18"chart": "snyk-monitor-1.92.10",
19"app_version": ""
20  }
21]
22
23➜ kubectl get pods -n bananas
24NAME                                  READY   STATUS   RESTARTS  AGE
25Snyk-monitor-bananas-54b8c4bf89-r6tf2   1/1 Running   0      3m38s

Schritt 5: Überprüfen, ob bereitgestellte Workloads automatisch über die Policy importiert werden

Als Nächstes stellen wir Workloads im Namespace apples bereit, um sicherzustellen, dass sie automatisch importiert werden. Wir beginnen mit einer Spring-Boot-Anwendung, die wir wie unten gezeigt in Kubernetes bereitstellen.

Erstellen Sie eine Datei namens springbootemployee-K8s.yaml mit folgendem Inhalt:

1apiVersion: apps/v1
2kind: Deployment
3metadata:
4  name: springboot-employee-api-apples
5  namespace: apples
6spec:
7  selector:
8matchLabels:
9  app: springboot-employee-api-apples
10  replicas: 1
11  template:
12metadata:
13  labels:
14    app: springboot-employee-api-apples
15spec:
16  containers:
17    - name: springboot-employee-api-apples
18      image: pasapples/springbootemployee:multi-stage-add-layers
19      imagePullPolicy: Always
20      ports:
21        - containerPort: 8080

Stellen Sie sie anschließend bereit:

1➜ kubectl apply -f springbootemployee-K8s.yaml
2deployment.apps/springboot-employee-api-apples created

Überprüfen Sie nach einigen Minuten, ob der Workload gescannt und automatisch in die Snyk-Organisation „Äpfel“ in Snyk importiert wurde. Der Snyk-Controller im Namespace apples sollte dies entsprechend seiner Konfiguration erledigt haben.

Schritt 6: Workloads in „Bananen“ bereitstellen – automatischer Import über eine Rego-Policy-Datei

Erstellen Sie eine Datei namens snyk-boot-web-deployment.yaml mit folgendem Inhalt:

1apiVersion: apps/v1
2kind: Deployment
3metadata:
4  name: snyk-boot-web
5  namespace: bananas
6spec:
7  selector:
8    matchLabels:
9      app: snyk-boot-web
10  replicas: 1
11  template:
12    metadata:
13      labels:
14        app: snyk-boot-web
15    spec:
16      containers:
17        - name: snyk-boot-web
18          image: pasapples/snyk-boot-web:v1
19          imagePullPolicy: Always
20          ports:
21            - containerPort: 5000

Stellen Sie sie wie folgt bereit:

1➜ kubectl apply -f snyk-boot-web-deployment.yaml
2deployment.apps/snyk-boot-web created

Überprüfen Sie nach etwa drei Minuten, ob der Workload gescannt und automatisch in die Snyk-Organisation „Bananen“ in der Snyk-App importiert wurde. Der Snyk-Controller im Namespace „Bananen“ sollte dies entsprechend seiner Konfiguration erledigt haben.

Bonus: Protokolle der Snyk-Controller anzeigen

Kubernetes-Konfigurations- und YAML-Dateien können etwas knifflig sein. Falls bei der Einrichtung Ihrer Monitore Probleme auftreten, kann es hilfreich sein, die Protokolle der einzelnen Snyk-Controller anzusehen, wie in den folgenden Befehlsbeispielen gezeigt:

Snyk-Controller für „Äpfel“

1export APPLES_POD=`kubectl get pods --namespace apples -l "app.kubernetes.io/name=snyk-monitor-apples" -o jsonpath="{.items[0].metadata.name}"`
2
3kubectl logs -n apples $APPLES_POD -f

Snyk-Controller für „Bananen“

1export BANANAS_POD=`kubectl get pods --namespace bananas -l "app.kubernetes.io/name=snyk-monitor-bananas" -o jsonpath="{.items[0].metadata.name}"`
2
3kubectl logs -n bananas $BANANAS_POD -f

Zusammenfassung

In diesem Blogbeitrag haben wir gezeigt, wie Sie mehrere Snyk-Controller in einem einzelnen Kubernetes-Cluster bereitstellen, die jeweils ihren eigenen Namespace überwachen. Die Controller kommunizieren mit der Kubernetes-API, um festzustellen, welche Workloads im Cluster ausgeführt werden (z. B. Deployment, ReplicationController, CronJob usw., wie in der Rego-Policy-Datei definiert). Sie ermitteln die zugehörigen Images und scannen diese direkt im Cluster auf Schwachstellen.

Probieren Sie diese Schritte gerne in Ihrem eigenen Kubernetes-Cluster aus. Starten Sie dazu eine kostenlose Testversion des Snyk-Business-Plans.

Weitere Informationen

Nachdem Sie nun erfahren haben, wie einfach sich die Kubernetes-Integration mit Snyk einrichten lässt, finden Sie hier einige hilfreiche Links für den Einstieg in die Container-Sicherheit.

• Container- und Kubernetes-Sicherheit mit Snyk

• Überblick über die Kubernetes-Integration

• Snyk Container für den automatischen Import bzw. das automatische Löschen von Kubernetes-Workload-Projekten einrichten

• Rego lernen mit dem hervorragenden Tutorial-Kurs von Styra