Mit Pulumi die Snyk-Kubernetes-Integration für Container automatisieren

Der Begriff Infrastructure as Code (IaC) ist uns allen bekannt. Doch Code bedeutet in diesem Zusammenhang nicht wirklich Code im Sinne einer Programmiersprache. IaC bezeichnet in der Regel die Konfiguration von Infrastruktur mithilfe von Tools wie Terraform, CloudFormation, Kubernetes-YAML oder Azure Resource Manager-Vorlagen. Dabei wird festgelegt, wie die Infrastruktur erstellt wird. Diese Konfigurationen bieten nicht die Flexibilität und Leistungsfähigkeit moderner Programmiersprachen. IaC ist also Code, aber normalerweise nicht diese Art von Code.

In diesem Blogbeitrag zeigen wir Ihnen Schritt für Schritt, wie Sie mit Pulumi, einem neuen Open-Source-Tool, mit dem Entwickler Code in mehreren Sprachen wie JavaScript, Typescript, Python und Go erstellen können, alles Notwendige für die Konfiguration der Kubernetes-Integration in Snyk Container einrichten.

Überblick über die Snyk-Kubernetes-Integration

Snyk lässt sich in Kubernetes integrieren. So können Sie Ihre laufenden Workloads importieren und testen sowie Schwachstellen in den zugehörigen Images und Konfigurationen erkennen, die die Sicherheit dieser Workloads beeinträchtigen könnten. Nach dem Import überwacht Snyk diese Workloads weiterhin und erkennt zusätzliche Sicherheitsprobleme, wenn neue Images bereitgestellt werden oder sich die Workload-Konfiguration ändert.

Was ist Pulumi?

Pulumi ist ein Open-Source-IaC-Tool, das die beliebtesten Programmiersprachen nutzt, um die Bereitstellung und Verwaltung von Cloud-Ressourcen zu vereinfachen.

Pulumi wurde 2017 gegründet und hat grundlegend verändert, wie DevOps-Teams das Konzept von Infrastructure as Code angehen. Anstatt auf domänenspezifische Sprachen zu setzen, können Unternehmen mit Pulumi echte Programmiersprachen verwenden, um Cloud-native Infrastruktur bereitzustellen und wieder abzubauen.

Pulumi unterstützt die folgenden Programmiersprachen:

• Python

• JavaScript

• Go

• TypeScript

• .NET-Sprachen (C#, F# und VB)

So installieren Sie die Snyk-Kubernetes-Integration mit Pulumi

Jetzt wird es spannend! Wir gehen Schritt für Schritt durch die Einrichtung von Pulumi und starten unsere Automatisierungen. Dabei gehen wir wie folgt vor:

1. Richten Sie in der Snyk-App eine Kubernetes-Integrations-ID ein

2. Klonen Sie das Beispiel-Repository

3. Authentifizieren Sie sich bei Google Cloud

4. Erstellen Sie einen neuen Pulumi-Stack

5. Legen Sie die erforderlichen Pulumi-Konfigurationsvariablen fest

6. Stellen Sie alles mit pulumi up bereit

7. Rufen Sie die Kubernetes-Konfiguration ab

8. Entfernen Sie die gesamte Einrichtung

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 sich für eine kostenlose 14-tägige Business-Testversion anmelden.

2. Wir stellen die Ressourcen in Google Cloud bereit, daher benötigen Sie ein Konto. Falls Sie noch kein Konto haben, melden Sie sich hier kostenlos an. Folgen Sie anschließend in jedem Fall diesen Anweisungen, um Pulumi mit Ihrem Google-Cloud-Konto zu verbinden.

3. In diesem Beispiel wird vorausgesetzt, dass sich die gcloud-CLI in Ihrem Pfad befindet. Sie wird als Teil des Google Cloud SDK installiert.

4. Stellen Sie sicher, dass Sie über Python 3, ein Pulumi-Konto und die Pulumi-CLI verfügen.

5. Beachten Sie, dass Pulumi voraussetzt, dass Python 3 in Ihrer Umgebung die Standardversion ist. Falls neben Python 3 auch Python 2 installiert ist, müssen Sie möglicherweise einen Alias erstellen. Führen Sie den folgenden Befehl aus, um dies zu überprüfen und sicherzustellen, dass Sie die neueste Version von 3.x verwenden:

1❯ python --version
2Python 3.9.9

Schritt 1: Richten Sie in der Snyk-App eine Kubernetes-Integrations-ID ein

Melden Sie sich bei Snyk an und wählen Sie die Organisation aus, in der Sie die Kubernetes-Integration automatisch einrichten möchten. Sie können eine leere Organisation oder eine bestehende Organisation mit Projekten verwenden. Stellen Sie für dieses Beispiel sicher, dass die Kubernetes-Integration in der ausgewählten Organisation noch nicht konfiguriert ist.

Klicken Sie anschließend auf Integrationen > Kubernetes > Verbinden. Wenn Sie kein Snyk-Business- oder Enterprise-Konto haben, können Sie diesen Schritt nicht ausführen.

Notieren Sie sich die Integrations-ID, da wir sie gleich benötigen.

Das war’s! Jetzt können Sie unsere Snyk-Kubernetes-Integrationsdemo mit Pulumi Infrastructure as Code einrichten. Pulumi erledigt Folgendes:

• Einen GKE-Cluster erstellen

• Den Snyk-Controller im Cluster bereitstellen0

• Die Snyk-Kubernetes-Integration für den automatischen Import von K8s-Workloads in Snyk einrichten

• Einen Beispiel-Workload gemäß unserer Rego-Richtliniendatei im Namespace apples bereitstellen

Schritt 2: Klonen Sie das Beispiel-Repository

Klonen Sie das folgende GitHub-Demo-Repository wie unten gezeigt:

1$ git clone https://github.com/papicella/snyk-kubernetes-integration
2Cloning into 'snyk-kubernetes-integration'...
3remote: Enumerating objects: 18, done.
4remote: Counting objects: 100% (18/18), done.
5remote: Compressing objects: 100% (14/14), done.
6remote: Total 18 (delta 8), reused 14 (delta 4), pack-reused 0
7Receiving objects: 100% (18/18), 8.76 KiB | 4.38 MiB/s, done.
8Resolving deltas: 100% (8/8), done.

Wechseln Sie nach dem Klonen dieses Repositorys mit cd in das Verzeichnis und führen Sie die nächsten Befehle aus …

Schritt 3: Authentifizieren Sie sich bei Google Cloud

Authentifizieren Sie sich mit der lokalen Authentifizierung bei Google Cloud, um diese Demo bereitzustellen. Es gibt weitere Möglichkeiten, Pulumi mit Google Cloud zu konfigurieren, aber für diese Demo ist dies der einfachste Weg:

1$ gcloud auth login

Schritt 4: Erstellen Sie einen neuen Pulumi-Stack

Erstellen Sie einen neuen Stack, der für dieses Beispiel als isoliertes Bereitstellungsziel dient. Verwenden Sie als Beispiel dev:

1$ pulumi stack init dev

Schritt 5: Legen Sie die erforderlichen Pulumi-Konfigurationsvariablen fest

Häufig benötigen verschiedene Stacks innerhalb eines Projekts unterschiedliche Werte. Beispielsweise möchten Sie möglicherweise für Ihre Google-Cloud-Compute-Instanz eine andere Größe oder für Ihren Kubernetes-Cluster in Entwicklungs- und Produktions-Stacks eine andere Anzahl von Servern verwenden.

Die Schlüssel-Wert-Paare eines Stacks werden in der Stack-Einstellungsdatei Ihres Projekts gespeichert. Ihr Name lautet automatisch Pulumi.<stack-name>.yaml. In der Regel können Sie diese Datei ignorieren. Möglicherweise möchten Sie sie jedoch einchecken und zusammen mit dem Quellcode Ihres Projekts versionieren.

Fügen Sie Ihrem Stack die folgenden Konfigurationsvariablen hinzu, wie unten gezeigt:

1$ pulumi config set gcp:project [your-gcp-project-here] # Eg: snyk-cx-se-demo
2$ pulumi config set gcp:zone us-central1-c # any valid GCP zone here
3$ pulumi config set password --secret [your-cluster-password-here] # password for the cluster
4$ pulumi config set master_version 1.21.6-gke.1500 # any valid K8s master version on GKE

Standardmäßig hat Ihr Cluster 3 Knoten vom Typ n1-standard-1. Diese Einstellung lässt sich ändern. Wenn Sie beispielsweise 5 Knoten vom Typ n1-standard-2 auswählen möchten, können Sie folgende Befehle ausführen:

1$ pulumi config set node_count 5
2$ pulumi config set node_machine_type n1-standard-2

Abschließend müssen wir die erforderlichen Einstellungen für die Snyk-Kubernetes-Integration konfigurieren, damit die Integration automatisch in unserem Cluster eingerichtet wird. Dazu benötigen wir die ID unserer Kubernetes-Integration und die ID unserer Snyk-Organisation. In diesem Beispiel sind beide identisch:

1$ pulumi config set snyk_K8s_integration_id K8S_INTEGRATION_ID #same as ORG_ID at the moment
2$ pulumi config set snyk_org_id ORG_ID # your Snyk ORG ID under settings

Dieses Beispiel zeigt, wie Sie Stacks sinnvoll konfigurieren können. Sie können diese Einstellungen sogar nach der Bereitstellung ändern.

Anschließend enthält die Datei Pulumi.dev.yaml Folgendes:

1config:
2gcp-K8s-integration-demo:master_version: 1.21.5-gke.1302
3gcp-K8s-integration-demo:node_count: "3"
4gcp-K8s-integration-demo:node_machine_type: n1-standard-2
5gcp-K8s-integration-demo:password:
6    secure: AAABsomesecret+EnF1p4w==
7gcp-K8s-integration-demo:snyk_K8s_integration_id: yyyy1234
8gcp-K8s-integration-demo:snyk_org_id: yyyy1234
9gcp:project: snyk-cx-se-demo
10gcp:zone: us-central1-c

Schritt 6: Stellen Sie alles mit pulumi up bereit

Mit dem Befehl pulumi up werden alle für die Kubernetes-Integration mit Snyk erforderlichen Google-Cloud-Ressourcen bereitgestellt, darunter der GKE-Cluster selbst und das Helm-Chart des Snyk-Controllers. Anschließend wird ein Kubernetes-Deployment mit einer Spring-Boot-Anwendung bereitgestellt:

1$ pulumi up

Daraufhin wird eine Vorschau angezeigt und Sie werden um Bestätigung gebeten. Anschließend beginnt die Bereitstellung der Snyk-Kubernetes-Integrationsdemo:

1$ pulumi up
2Previewing update (dev)
3
4View Live: https://app.pulumi.com/papicella/gcp-K8s-integration-demo/dev/previews/1db6492c-ae23-4e87-abf0-41e09fb62177
5
6    Type                                                              Name                          Plan
7+   pulumi:pulumi:Stack                                               gcp-K8s-integration-demo-dev  create
8+   ├─ kubernetes:helm.sh/v3:Chart                                    snyk-monitor                  create
9+   │  ├─ kubernetes:core/v1:ServiceAccount                           snyk-monitor/snyk-monitor     create
10+   │  ├─ kubernetes:networking.k8s.io/v1:NetworkPolicy               snyk-monitor/snyk-monitor     create
11+   │  ├─ kubernetes:rbac.authorization.k8s.io/v1:ClusterRole         snyk-monitor                  create
12+   │  ├─ kubernetes:rbac.authorization.k8s.io/v1:ClusterRoleBinding  snyk-monitor                  create
13+   │  └─ kubernetes:apps/v1:Deployment                               snyk-monitor/snyk-monitor     create
14+   ├─ gcp:container:Cluster                                          pulumi-gke-cluster            create
15+   ├─ pulumi:providers:kubernetes                                    gke_k8s                       create
16+   ├─ kubernetes:core/v1:Namespace                                   snyk-monitor                  create
17+   ├─ kubernetes:core/v1:Namespace                                   apples                        create
18+   ├─ kubernetes:core/v1:ConfigMap                                   snyk-monitor-custom-policies  create
19+   ├─ kubernetes:core/v1:Service                                     springboot-employee-api       create
20+   ├─ kubernetes:core/v1:Secret                                      snyk-monitor                  create
21+   └─ kubernetes:apps/v1:Deployment                                  springboot-employee-api       create
22
23Resources:
24    + 15 to create

Nach etwa fünf Minuten ist Ihr Cluster bereit. Der Snyk-Controller ist installiert und ein Beispiel-Workload-Deployment wurde automatisch in Ihre Snyk-Organisation importiert:

1Do you want to perform this update? yes
2Updating (dev)
3
4View Live: https://app.pulumi.com/papicella/gcp-K8s-integration-demo/dev/updates/1
5
6    Type                                                              Name                          Status
7+   pulumi:pulumi:Stack                                               gcp-K8s-integration-demo-dev  created
8+   ├─ kubernetes:helm.sh/v3:Chart                                    snyk-monitor                  created
9+   │  ├─ kubernetes:core/v1:ServiceAccount                           snyk-monitor/snyk-monitor     created
10+   │  ├─ kubernetes:networking.k8s.io/v1:NetworkPolicy               snyk-monitor/snyk-monitor     created
11+   │  ├─ kubernetes:rbac.authorization.k8s.io/v1:ClusterRole         snyk-monitor                  created
12+   │  ├─ kubernetes:rbac.authorization.k8s.io/v1:ClusterRoleBinding  snyk-monitor                  created
13+   │  └─ kubernetes:apps/v1:Deployment                               snyk-monitor/snyk-monitor     created
14+   ├─ gcp:container:Cluster                                          pulumi-gke-cluster            created
15+   ├─ pulumi:providers:kubernetes                                    gke_k8s                       created
16+   ├─ kubernetes:core/v1:Namespace                                   snyk-monitor                  created
17+   ├─ kubernetes:core/v1:Namespace                                   apples                        created
18+   ├─ kubernetes:core/v1:Service                                     springboot-employee-api       created
19+   ├─ kubernetes:core/v1:ConfigMap                                   snyk-monitor-custom-policies  created
20+   ├─ kubernetes:core/v1:Secret                                      snyk-monitor                  created
21+   └─ kubernetes:apps/v1:Deployment                                  springboot-employee-api       created
22
23Outputs:
24    kubeconfig: "[secret]"
25
26Resources:
27    + 15 created
28
29Duration: 6m28s

Die folgenden Screenshots zeigen, dass alles wie erwartet erstellt wurde.

Der in Google Cloud erstellte GKE-Cluster:

Die automatisch konfigurierte Snyk-Kubernetes-Integration:

Der automatisch aus dem Namespace apples importierte Beispiel-Workload:

Konfiguration im Detail

Sehen wir uns die Python-Datei __main__.py genauer an und erfahren wir, wie die Snyk-Kubernetes-Integration für uns installiert und konfiguriert wurde.

Die vom Snyk-Controller verwendete Rego-Richtliniendatei ist derzeit fest so eingestellt, dass nur Workloads aus dem Namespace apples importiert werden, sofern sie nicht vom Typ CronJob oder Service sind. Sie können dies in __main__.py ändern und die Richtliniendatei extern statt als fest codierten Bestandteil des Python-Codes verwenden:

1snyk_monitor_custom_policies_str = """package snyk
2orgs := ["%s"]
3default workload_events = false
4workload_events {
5input.metadata.namespace == "apples"
6    input.kind != "CronJob"
7    input.kind != "Service"
8}""" % (SNYK_ORG_ID)

Hier sehen Sie den Python-Code, mit dem der Snyk-Controller über sein Helm-Chart installiert wird. Beachten Sie, dass wir das Repository zum Abrufen des Helm-Charts angegeben und sowohl die Snyk-Organisations-ID als auch die oben beschriebene benutzerdefinierte Richtliniendatei bereitgestellt haben. All dies ist erforderlich, um den Snyk-Controller im GKE-Cluster zu installieren und in Snyk zu integrieren.

1# Deploy the snyk controller using it's helm chart
2snyk_monitor_chart = Chart(
3    "snyk-monitor",
4    ChartOpts(
5        chart="snyk-monitor",
6        version="1.79.0",
7        namespace="snyk-monitor",
8        fetch_opts=FetchOpts(
9            repo="https://snyk.github.io/kubernetes-monitor",
10        ),
11        values={
12          "clusterName": "K8s-integration-demo-cluster",
13          "policyOrgs": "{%s}" % (SNYK_ORG_ID),
14          "workloadPoliciesMap": "snyk-monitor-custom-policies"
15        }
16    ),
17    opts=ResourceOptions(provider=k8s_provider)
18)

Mit dem Python-Code wurde außerdem eine Spring-Boot-Beispielanwendung im Namespace apples bereitgestellt. Diese wurde vom Snyk-Controller automatisch in die Snyk-App importiert. Der Python-Code für dieses Deployment lautet:

1# deploy spring boot employee app
2
3"""springboot employee api container, replicated 1 time."""
4app_name = "springboot-employee-api"
5app_labels = { "app": app_name }
6
7springboot_employee_api = k8s.apps.v1.Deployment(
8            app_name,
9            metadata={
10              "namespace": "apples",
11            },
12            spec=k8s.apps.v1.DeploymentSpecArgs(
13                replicas=1,
14                selector=k8s.meta.v1.LabelSelectorArgs(match_labels=app_labels),
15                template=k8s.core.v1.PodTemplateSpecArgs(
16                    metadata=k8s.meta.v1.ObjectMetaArgs(labels=app_labels),
17                    spec=k8s.core.v1.PodSpecArgs(
18                        containers=[
19                            k8s.core.v1.ContainerArgs(
20                                name=app_name,
21                                image="pasapples/springbootemployee:cnb",
22                                ports=[k8s.core.v1.ContainerPortArgs(
23                                  container_port=8080
24                                )]
25                            )
26                        ]
27                    ),
28                ),
29            ),
30            opts=ResourceOptions(provider=k8s_provider)
31)

Schritt 7: Rufen Sie die Kubernetes-Konfiguration ab

Sie können diese Konfiguration nun entweder in Ihrer Datei ~/.kube/config verwenden oder lokal speichern und in die Umgebungsvariable KUBECONFIG eintragen. Natürlich funktionieren auch alle Ihre gewohnten Google-Cloud-Befehle.

Zum Beispiel:

1$ pulumi stack output kubeconfig --show-secrets > kubeconfig.yaml
2$ KUBECONFIG=./kubeconfig.yaml kubectl get po -n apples
3NAME                                                READY   STATUS    RESTARTS   AGE
4springboot-employee-api-fyrj9hr2-66d8456f5f-hqqhx   1/1     Running   0          17m

Der im Namespace snyk-monitor installierte Snyk-Controller sowie die jetzt von Pulumi verwaltete ConfigMap und das Secret, angezeigt mit einigen kubectl-Befehlen:

1$ kubectl get all -n snyk-monitor
2NAME                              READY   STATUS    RESTARTS   AGE
3pod/snyk-monitor-db67744d-szl79   1/1     Running   0          8m52s
4
5NAME                           READY   UP-TO-DATE   AVAILABLE   AGE
6deployment.apps/snyk-monitor   1/1     1            1           8m53s
7
8NAME                                    DESIRED   CURRENT   READY   AGE
9replicaset.apps/snyk-monitor-db67744d   1         1         1       8m53s
10
11$ kubectl get secret -n snyk-monitor -l app.kubernetes.io/managed-by=pulumi
12NAME           TYPE     DATA   AGE
13snyk-monitor   Opaque   2      42m
14
15$ kubectl get configmap -n snyk-monitor -l app.kubernetes.io/managed-by=pulumi
16NAME                           DATA   AGE
17snyk-monitor-custom-policies   1      42m

Schritt 8: Entfernen Sie die gesamte Einrichtung

Wenn Sie fertig sind, können Sie alle Ressourcen und den Stack entfernen:

1$ pulumi destroy
2$ pulumi stack rm

Zusammenfassend haben Sie erfahren, wie Sie mit Pulumi die Snyk-Kubernetes-Integration installieren und konfigurieren können. Damit können Sie Ihre laufenden Workloads importieren und testen sowie Schwachstellen in den zugehörigen Images und Konfigurationen erkennen, die die Sicherheit dieser Workloads beeinträchtigen könnten.

Weitere Ressourcen

Sie wissen nun, wie einfach sich die Kubernetes-Integration mit Snyk mithilfe der Programmiersprache Python und Pulumi einrichten lässt. Die folgenden Links helfen Ihnen bei den ersten Schritten auf Ihrem Weg zur Container-Sicherheit.

• Snyk Container

• Dokumentation zum Überblick über die Kubernetes-Integration

• Dokumentation zum automatischen Import und Löschen von Kubernetes-Workload-Projekten

• Lernen Sie Rego mit dem hervorragenden Tutorial-Kurs von Styra