Sichern Sie Ihre Anwendung von Argo CD bis Kubernetes

GitOps ist ein beliebtes Framework zur Verwaltung und Absicherung der Anwendungspipeline. Wer sich auf den Weg zu GitOps gemacht hat, stellt sich häufig die Frage: „Wie kann ich meine Pipeline absichern, wenn alles automatisiert ist?“

Das GitOps-Framework basiert auf dem Konzept, dass alle Code-Commits und Änderungen über Git erfolgen. Dadurch wird eine automatisierte Pipeline ausgelöst, die Anwendungen erstellt und auf Kubernetes bereitstellt. Da Entwicklungs- und Sicherheitsteams nur wenige Berührungspunkte innerhalb der Pipeline haben, muss die Sicherheit verbindlich vorgeschrieben werden. So wird sichergestellt, dass die bereitgestellten Anwendungen möglichst wenige Schwachstellen aufweisen.

In diesem Blog erfahren Sie, wie Snyk Anwendungssicherheit in GitOps ermöglicht – mit Fokus auf das beliebte Tool Argo CD. In diesem Szenario führt Snyk einen IaC-Scan durch, um sicherzustellen, dass die bereitzustellende Anwendung sicher ist, bevor sie bereitgestellt wird, und stoppt den Build, falls dies nicht der Fall ist. Außerdem kann Snyk bereitgestellte Anwendungen automatisiert in verschiedenen Namespaces auf Kubernetes überwachen.

Was ist Argo CD?

Argo CD ist ein deklaratives, Kubernetes-natives Continuous-Delivery-Tool (CD), das ein Repository verfolgt und Änderungen oder „Drift“ erkennt. Anschließend nimmt es die erforderlichen Änderungen an der Kubernetes-Clusterkonfiguration vor.

Argo CD für die Zusammenarbeit mit Snyk einrichten

Diese Demo zeigt, wie Sie Ihren GitOps-Prozess mit Argo CD starten und Snyk einsetzen, um Anwendungen abzusichern und Kubernetes-Workloads zu überwachen. Führen Sie dazu die folgenden Schritte aus:

1. Git-Repository klonen

2. Argo CD konfigurieren

3. Anwendung mit Argo CD bereitstellen

4. Kubernetes-Secret-Objekt für Ihr Snyk-Token erstellen

5. Argo-CD-PreSync-Ressourcen-Hook erstellen

6. Warten, bis Argo CD die Konfigurationsdrift erkennt

7. Mit Kubernetes integrieren

Voraussetzungen

1. Für Snyk-Tests in Argo CD und den automatischen Import von Kubernetes-Workloads in Snyk benötigen Sie ein Snyk-Konto mit einem Business- oder Enterprise-Plan. Falls Sie noch kein Snyk-Konto haben, können Sie eine kostenlose Testversion unseres Business-Plans starten.

2. Eine laufende Argo-CD-Instanz in Ihrem Kubernetes-Cluster. Einzelheiten zur Einrichtung finden Sie in der Argo-CD-Dokumentation.

3. Ein laufender Kubernetes-Cluster (z. B. EKS, AKS, GKE, Red Hat OpenShift oder eine beliebige unterstützte Variante).

Schritt 1: Git-Repository klonen

In dieser Demo kommt eine Flask-Polling-Anwendung zum Einsatz, deren Quellcode unter https://github.com/jiajunngjj/flask-polling-app gehostet wird. Klonen Sie das Repository in Ihre eigene Umgebung.

žœ  git clone https://github.com/jiajunngjj/flask-polling-app.git

Schritt 2: Argo CD konfigurieren

Fügen Sie Ihren Kubernetes-Cluster zu Argo CD hinzu:

žœ argocd cluster add CONTEXTNAME

In dieser Demo läuft Argo CD innerhalb dieses Kubernetes-Clusters und ist daher automatisch über den internen K8s-Hostnamen (kubernetes.default.svc) verbunden:

Fügen Sie anschließend auch das zuvor erwähnte Repository zu Argo CD hinzu:

Nach dem erfolgreichen Hinzufügen des Repositorys sollte etwa Folgendes angezeigt werden:

Schritt 3: Anwendung mit Argo CD bereitstellen

Erstellen Sie einen Kubernetes-Namespace, in dem die Anwendung bereitgestellt wird. In diesem Beispiel erstellen wir den Namespace argocd-demo, um die Anwendung flask-polling-app auszuführen:

žœ kubectl create ns argocd-demo

Erstellen Sie die Anwendung über die Argo-CD-Befehlszeile (oder über die Argo-CD-Benutzeroberfläche, nachdem Sie das Repository hinzugefügt haben):

žœ argocd app create snyk-demo  \  --repo https://github.com/jiajunngjj/flask-polling-app.git \  --path argocd \  --dest-server https://kubernetes.default.svc \  --dest-namespace argocd-demo

Eine Erläuterung der Befehlsparameter:

• repo — Repository für die Quellcodeverwaltung (SCM)

• path — Verzeichnis mit dem Kubernetes-Manifest

• dest-server — Kubernetes-Cluster

• dest-namespace — Kubernetes-Namespace, in dem die Anwendung bereitgestellt wird

Nach dem Erstellen der Anwendung in Argo CD wird in der Benutzeroberfläche der Status OutOfSync angezeigt:

Führen Sie als Nächstes den Argo-CD-Befehl sync aus, um die Anwendung bereitzustellen:

žœ argocd app sync snyk-demo

Anschließend sollte die Anwendung in der Argo-CD-Benutzeroberfläche zu sehen sein:

Sie sollten außerdem sehen, dass die Anwendung im Kubernetes-Namespace argocd-demo bereitgestellt wird:

1➜ kubectl get pods -n argocd-demoNAME READY STATUS RESTARTS AGEpolling-app-6f5978849c-pp8f4 1/1 Running 0 33spolling-app-6f5978849c-tqpd2 1/1 Running 0 33s

Schritt 4: Kubernetes-Secret-Objekt für Ihr Snyk-Token erstellen

Nachdem die Anwendung erfolgreich zu Argo CD hinzugefügt wurde, können Sie den Snyk-IaC-Test in die Argo-CD-Pipeline integrieren. Rufen Sie Ihr Snyk-Token in der Snyk-App ab und erstellen Sie ein Secret-Objekt im Namespace argocd-demo:

1➜ kubectl create secret generic snyk-token \ --from-literal=token=<XXXX-XXXXXX-XXXXXXXX> \ -n argocd-demo

Schritt 5: Argo-CD-PreSync-Ressourcen-Hook erstellen

Erstellen Sie im selben Verzeichnis wie die Deployment-YAML-Dateien (argocd) eine Datei mit dem Namen snyk-scan.yaml, die folgenden Inhalt enthält:

1apiVersion: batch/v1
2kind: Job
3metadata:
4  name: snyk-iac-scan
5  annotations:
6    argocd.argoproj.io/hook: PreSync
7spec:
8  ttlSecondsAfterFinished: 600
9  template:
10    spec:
11      containers:
12      - name: snyk-cli
13        image: snyk/snyk-cli:npm
14        command: ["/bin/sh","-c"]
15        args:
16          - git clone https://github.com/jiajunngjj/flask-polling-app.git;
17            snyk auth $SNYK_TOKEN;
18            snyk iac test flask-polling-app/argocd/polling-app.yaml || true;
19        env:
20          - name: SNYK_TOKEN
21            valueFrom:
22              secretKeyRef:
23                name: snyk-token
24                key: token
25      restartPolicy: Never
26  backoffLimit: 0

Bearbeiten Sie die Datei polling-app.yaml, um die Erkennung von Konfigurationsdrift auszulösen (in diesem Beispiel wird die Anzahl der Replikate auf „1“ geändert):

1---
2apiVersion: v1
3kind: Service
4metadata:
5  name: polling-app
6spec:
7  ports:
8  - name: 8080-tcp
9    port: 8080
10    protocol: TCP
11    targetPort: 8080
12  selector:
13    app: polling-app
14  type: LoadBalancer
15
16---
17apiVersion: apps/v1
18kind: Deployment
19metadata:
20  name: polling-app
21spec:
22  replicas: 1
23  selector:
24  matchLabels:
25    app: polling-app
26  template:
27    metadata:
28      labels:
29        app: polling-app
30    spec:
31      containers:
32      - image: jiajunngjj/polling-app
33        name: polling-app
34        ports:
35        - containerPort: 8080
36      restartPolicy: "Always"

Führen Sie Git-Befehle aus, um die Datei an das Repository zu übertragen:

1➜ git add argocd/snyk-scan.yaml argocd/polling-app.yaml➜ git commit -m "added snyk-scan.yaml and edited polling-app.yaml"➜ git push

Schritt 6: Warten, bis Argo CD die Konfigurationsdrift erkennt

Wenn Argo CD die Konfigurationsdrift erkennt, beginnt die Synchronisierung, um den gewünschten neuen Zustand herzustellen. Sie sehen, dass der Snyk-IaC-Scan vor der Bereitstellung der Anwendung gestartet wird:

Sie sehen auch, dass snyk-iac-scan als Pod ausgeführt wird:

1➜ kubectl get pods -n argocd-demoNAME READY STATUS RESTARTS AGEpolling-app-6f5978849c-pp8f4 1/1 Running 0 16msnyk-iac-scan-9x8gz 0/1 Completed 0 2m32s

Schließlich sehen Sie in der Argo-CD-Benutzeroberfläche den Job snyk-iac-scan:

Schritt 7: Mit Kubernetes integrieren

Snyk lässt sich in Kubernetes integrieren. So können Sie laufende Workloads importieren und testen, um Schwachstellen in den zugehörigen Images sowie Konfigurationen zu erkennen, die die Sicherheit dieser Workloads beeinträchtigen könnten. Nach dem Import überwacht Snyk die Workloads kontinuierlich und erkennt und priorisiert Sicherheitsprobleme, wenn neue Images bereitgestellt und Workload-Konfigurationen geändert werden.

Ein Vorteil: Sie müssen Ihre Deployment-YAML-Dateien nicht aktualisieren, da dies automatisch über den Snyk Controller erfolgt, wenn Sie den automatischen Import aktivieren (wie in der Snyk-Dokumentation erläutert). Snyk unterstützt die folgenden Workloads:

• Deployments

• ReplicaSets

• DaemonSets

• StatefulSets

• Jobs

• CronJobs

• ReplicationControllers

• Pods

Weitere Snyk-Blogbeiträge zeigen, wie Sie mehrere Snyk-Kubernetes-Cluster in einem einzelnen Cluster installieren und Pulumi zur Automatisierung der Snyk-Kubernetes-Integration einsetzen können.

Sobald Argo CD Ihre Anwendung bereitgestellt hat, importiert die Kubernetes-Integration von Snyk den Scan dieses Workloads ohne manuelles Eingreifen in die Plattform:

Zusammenfassung

In dieser Demo wird über den Ressourcen-Hook von Argo CD bei jeder erkannten Konfigurationsänderung ein Snyk-IaC-Scan gestartet. So lässt sich ein GitOps-Workflow verbindlich mit Sicherheitsprüfungen versehen: Snyk erkennt Schwachstellen und hält den Workflow an, wenn eine erkannte Schwachstelle den festgelegten Schweregrad erreicht. Dadurch gelangt niemals anfälliger Code in die Produktionsumgebung.

Weitere Informationen

Nachdem Sie nun wissen, wie Sie einen Snyk-IaC-Test mit Argo CD einrichten und Workloads auf Kubernetes überwachen, finden Sie in diesen Ressourcen weitere Informationen dazu, wie Sie Ihren Softwareentwicklungslebenszyklus zusätzlich absichern:

• Snyk-CI/CD-Integrationen

• Eigene benutzerdefinierte Regeln erstellen

• Drift und manuell erstellte Ressourcen erkennen