RedHat OpenShift

Bereitstellen Sie getrennte SUSE® Security-Komponenten mit RedHat OpenShift

SUSE® Security ist kompatibel mit Standard-ovs-SDN-Plugins sowie mit anderen wie Flannel, Weave oder Calico. Die folgenden Beispiele gehen davon aus, dass ein Standard-ovs-Plugin verwendet wird. Dies geht auch davon aus, dass ein lokales Docker-Registry verwendet wird (siehe Anweisungen am Ende zur Erstellung des Secrets für das dynamische Abrufen von neuvector oder Docker Hub).

SUSE® Security unterstützt die Helm-basierte Bereitstellung mit einem Helm-Chart bei https://github.com/neuvector/neuvector-helm.. Der SUSE® Security Operator kann ebenfalls zur Bereitstellung verwendet werden und basiert auf dem Helm-Chart. Um die neuesten SUSE® Security Container-Versionen mit einem Operator bereitzustellen, verwenden Sie bitte entweder den von Red Hat zertifizierten Operator aus dem Operator Hub oder den Community-Operator, wie im Operator-Bereich beschrieben.

Um manuell bereitzustellen, ziehen Sie zuerst die entsprechenden SUSE® Security Container aus dem SUSE® Security-Registry in das lokale Registry. Hinweis: Das Scanner-Image sollte regelmäßig für CVE-Datenbank-Updates von SUSE® Security abgerufen werden.

SUSE® Security Images auf Docker Hub

Die Images befinden sich in der SUSE® Security Docker Hub-Registry. Verwenden Sie das entsprechende Versions-Tag für den Manager, Controller, Enforcer, und lassen Sie die Version für Scanner und Updater als 'latest'. Beispiel:

  • neuvector/manager:5.4.3

  • neuvector/controller:5.4.3

  • neuvector/enforcer:5.4.3

  • neuvector/scanner:latest

  • neuvector/updater:latest

Bitte stellen Sie sicher, dass Sie die Bildreferenzen in den entsprechenden YAML-Dateien aktualisieren.

Wenn Sie mit dem aktuellen SUSE® Security Helm-Chart (v1.8.9+) bereitstellen, sollten die folgenden Änderungen an values.yml vorgenommen werden:

  • Aktualisieren Sie die Registry auf docker.io

  • Aktualisieren Sie die Bildnamen/-tags auf die aktuelle Version im Docker Hub, wie oben gezeigt

  • Lassen Sie die imagePullSecrets leer

Bereitstellung auf OpenShift

docker login docker.io
docker pull docker.io/neuvector/manager:<version>
docker pull docker.io/neuvector/controller:<version>
docker pull docker.io/neuvector/enforcer:<version>
docker pull docker.io/neuvector/scanner
docker pull docker.io/neuvector/updater
docker logout docker.io

Die folgende Beispieldatei wird einen Manager, 3 Controller und 2 Scanner-Pods bereitstellen. Es wird einen Enforcer auf jedem Knoten als DaemonSet bereitstellen, einschließlich auf dem Master-Knoten (sofern planbar). Siehe den unteren Abschnitt für die Angabe von dedizierten Manager- oder Controller-Knoten mithilfe von Knoten-Labels. Hinweis: Es wird nicht empfohlen, mehr als einen Manager hinter einem Load Balancer bereitzustellen (skalieren), da dies zu potenziellen Problemen mit dem Sitzungsstatus führen kann. Wenn Sie planen, einen PersistentVolumeClaim zu verwenden, um die Sicherung der SUSE® Security Konfigurationsdateien zu speichern, lesen Sie bitte den allgemeinen Abschnitt Backup/Persistent Data im Production Deployment Überblick.

Setzen Sie als Nächstes die Route und erlauben Sie privilegierte SUSE® Security Container mit den folgenden Anweisungen. Standardmäßig erlaubt OpenShift keine privilegierten Container. Außerdem plant OpenShift standardmäßig keine Pods auf dem Master-Knoten. Siehe die Anweisungen am Ende, um dies zu aktivieren/deaktivieren.

Bitte sehen Sie den Abschnitt zur Unternehmensintegration für Details zur Integration mit OpenShift rollenbasierter Zugriffskontrolle (RBAC).

  1. Melden Sie sich als normaler Benutzer an

    oc login -u <user_name>

  2. Erstellen Sie ein neues Projekt.

    Wenn das — node-selector-Argument beim Erstellen eines Projekts verwendet wird, wird die Platzierung von Pods, wie für den SUSE® Security Enforcer, auf bestimmte Knoten beschränkt.

    		 
    oc new-project neuvector

  3. Pushen Sie SUSE® Security-Bilder in die OpenShift-Docker-Registry.

    Für OpenShift 4.6+ ändern Sie docker-registry.default.svc unten in image-registry.openshift-image-registry.svc in den folgenden Befehlen.

    		 
    docker login -u <user_name> -p `oc whoami -t` docker-registry.default.svc:5000
docker tag docker.io/neuvector/enforcer:<version> docker-registry.default.svc:5000/neuvector/enforcer:<version>
docker tag docker.io/neuvector/controller:<version> docker-registry.default.svc:5000/neuvector/controller:<version>
docker tag docker.io/neuvector/manager:<version> docker-registry.default.svc:5000/neuvector/manager:<version>
docker tag docker.io/neuvector/scanner docker-registry.default.svc:5000/neuvector/scanner
docker tag docker.io/neuvector/updater docker-registry.default.svc:5000/neuvector/updater
docker push docker-registry.default.svc:5000/neuvector/enforcer:<version>
docker push docker-registry.default.svc:5000/neuvector/controller:<version>
docker push docker-registry.default.svc:5000/neuvector/manager:<version>
docker push docker-registry.default.svc:5000/neuvector/scanner
docker push docker-registry.default.svc:5000/neuvector/updater
docker logout docker-registry.default.svc:5000

    Bitte sehen Sie den Abschnitt Aktualisierung der CVE-Datenbank unten für Empfehlungen zur Aktualisierung des neuesten Scanner-Bildes in Ihrer Registry.

  4. Melden Sie sich als system:admin an.

    oc login -u system:admin

  5. Erstellen Sie Dienstkonten und gewähren Sie Zugriff auf den privilegierten SCC

    oc create sa controller -n neuvector
oc create sa enforcer -n neuvector
oc create sa basic -n neuvector
oc create sa updater -n neuvector
oc create sa scanner -n neuvector
oc create sa registry-adapter -n neuvector
oc create sa cert-upgrader -n neuvector
oc -n neuvector adm policy add-scc-to-user privileged -z enforcer

    Die folgenden Informationen werden im privilegierten SCC hinzugefügt:

    - system:serviceaccount:neuvector:enforcer

    Fügen Sie einen neuen neuvector-scc-controller SCC für das Dienstkonto des Controllers in OpenShift hinzu, indem Sie eine Datei mit folgendem Inhalt erstellen:

    allowHostDirVolumePlugin: false
allowHostIPC: false
allowHostNetwork: false
allowHostPID: false
allowHostPorts: false
allowPrivilegeEscalation: false
allowPrivilegedContainer: false
allowedCapabilities: null
apiVersion: security.openshift.io/v1
defaultAddCapabilities: null
fsGroup:
  type: RunAsAny
groups: []
kind: SecurityContextConstraints
metadata:
  name: neuvector-scc-controller
priority: null
readOnlyRootFilesystem: false
requiredDropCapabilities:
- ALL
runAsUser:
  type: RunAsAny
seLinuxContext:
  type: RunAsAny
supplementalGroups:
  type: RunAsAny
users: []
volumes:
- configMap
- downwardAPI
- emptyDir
- persistentVolumeClaim
- azureFile
- projected
- secret

    Wenden Sie dies dann an.

    oc apply -f (filename)

    Führen Sie dann den folgenden Befehl aus, um das Dienstkonto des Controllers an den neuvector-scc-controller SCC zu binden.

    oc -n neuvector adm policy add-scc-to-user neuvector-scc-controller -z controller

    Verwenden Sie in OpenShift 4.6+ Folgendes, um zu überprüfen:

    oc get rolebinding system:openshift:scc:privileged -n neuvector -o wide
    NAME                              ROLE                                          AGE     USERS   GROUPS   SERVICEACCOUNTS
system:openshift:scc:privileged   ClusterRole/system:openshift:scc:privileged   9m22s                    neuvector/enforcer

    Führen Sie diesen Befehl aus, um den SUSE® Security Dienst für den Controller zu überprüfen.

    oc get rolebinding system:openshift:scc:neuvector-scc-controller -n neuvector -o wide

    Die Ausgabe wird wie folgt aussehen

    NAME                                            ROLE                                                        AGE     USERS   GROUPS   SERVICEACCOUNTS
System:openshift:scc:neuvector-scc-controller   ClusterRole/system:openshift:scc:neuvector-scc-controller   9m22s                    neuvector/controller

  6. Erstellen Sie die benutzerdefinierten Ressourcen (CRD) für die SUSE® Security Sicherheitsregeln. Für OpenShift 4.6+ (Kubernetes 1.19+):

    oc apply -f https://raw.githubusercontent.com/neuvector/manifests/main/kubernetes/5.4.0/crd-k8s-1.19.yaml
oc apply -f https://raw.githubusercontent.com/neuvector/manifests/main/kubernetes/5.4.0/waf-crd-k8s-1.19.yaml
oc apply -f https://raw.githubusercontent.com/neuvector/manifests/main/kubernetes/5.4.0/dlp-crd-k8s-1.19.yaml
oc apply -f https://raw.githubusercontent.com/neuvector/manifests/main/kubernetes/5.4.0/com-crd-k8s-1.19.yaml
oc apply -f https://raw.githubusercontent.com/neuvector/manifests/main/kubernetes/5.4.0/vul-crd-k8s-1.19.yaml
oc apply -f https://raw.githubusercontent.com/neuvector/manifests/main/kubernetes/5.4.0/admission-crd-k8s-1.19.yaml
oc apply -f https://raw.githubusercontent.com/neuvector/manifests/main/kubernetes/5.4.0/5.4.3_group-definition-k8s.yaml

  7. Fügen Sie Leseberechtigungen zum Zugriff auf die Kubernetes-API und OpenShift RBAC hinzu.

    Die Standardbereitstellung SUSE® Security 5.2+ verwendet Dienstkonten mit minimalen Berechtigungen anstelle der Standardkonten. Siehe unten, wenn Sie von einer Version vor 5.2 auf 5.2+ aktualisieren.

    Wenn Sie auf 5.3.0+ aktualisieren, führen Sie die folgenden Befehle basierend auf Ihrer aktuellen Version aus:

    • Version 5.2.0

    • Versionen vor 5.2.0

    oc delete clusterrole neuvector-binding-nvsecurityrules neuvector-binding-nvadmissioncontrolsecurityrules neuvector-binding-nvdlpsecurityrules neuvector-binding-nvwafsecurityrules
    oc delete clusterrolebinding neuvector-binding-app neuvector-binding-rbac neuvector-binding-admission neuvector-binding-customresourcedefinition neuvector-binding-nvsecurityrules neuvector-binding-view neuvector-binding-nvwafsecurityrules neuvector-binding-nvadmissioncontrolsecurityrules neuvector-binding-nvdlpsecurityrules neuvector-binding-co oc delete rolebinding neuvector-admin -n neuvector
    		 
    oc create clusterrole neuvector-binding-app --verb=get,list,watch,update --resource=nodes,pods,services,namespaces
oc create clusterrole neuvector-binding-rbac --verb=get,list,watch --resource=rolebindings.rbac.authorization.k8s.io,roles.rbac.authorization.k8s.io,clusterrolebindings.rbac.authorization.k8s.io,clusterroles.rbac.authorization.k8s.io,imagestreams.image.openshift.io
oc adm policy add-cluster-role-to-user neuvector-binding-app system:serviceaccount:neuvector:controller
oc adm policy add-cluster-role-to-user neuvector-binding-rbac system:serviceaccount:neuvector:controller
oc create clusterrole neuvector-binding-admission --verb=get,list,watch,create,update,delete --resource=validatingwebhookconfigurations,mutatingwebhookconfigurations
oc adm policy add-cluster-role-to-user neuvector-binding-admission system:serviceaccount:neuvector:controller
oc create clusterrole neuvector-binding-customresourcedefinition --verb=watch,create,get,update --resource=customresourcedefinitions
oc adm policy add-cluster-role-to-user neuvector-binding-customresourcedefinition system:serviceaccount:neuvector:controller
oc create clusterrole neuvector-binding-nvsecurityrules --verb=get,list,delete --resource=nvsecurityrules,nvclustersecurityrules
oc create clusterrole neuvector-binding-nvadmissioncontrolsecurityrules --verb=get,list,delete --resource=nvadmissioncontrolsecurityrules
oc create clusterrole neuvector-binding-nvdlpsecurityrules --verb=get,list,delete --resource=nvdlpsecurityrules
oc create clusterrole neuvector-binding-nvwafsecurityrules --verb=get,list,delete --resource=nvwafsecurityrules
oc adm policy add-cluster-role-to-user neuvector-binding-nvsecurityrules system:serviceaccount:neuvector:controller
oc adm policy add-cluster-role-to-user view system:serviceaccount:neuvector:controller --rolebinding-name=neuvector-binding-view
oc adm policy add-cluster-role-to-user neuvector-binding-nvwafsecurityrules system:serviceaccount:neuvector:controller
oc adm policy add-cluster-role-to-user neuvector-binding-nvadmissioncontrolsecurityrules system:serviceaccount:neuvector:controller
oc adm policy add-cluster-role-to-user neuvector-binding-nvdlpsecurityrules system:serviceaccount:neuvector:controller
oc create role neuvector-binding-scanner --verb=get,patch,update,watch --resource=deployments -n neuvector
oc adm policy add-role-to-user neuvector-binding-scanner system:serviceaccount:neuvector:updater system:serviceaccount:neuvector:controller -n neuvector --role-namespace neuvector
oc create clusterrole neuvector-binding-co --verb=get,list --resource=clusteroperators
oc adm policy add-cluster-role-to-user neuvector-binding-co system:serviceaccount:neuvector:enforcer system:serviceaccount:neuvector:controller
oc create role neuvector-binding-secret --verb=get,list,watch --resource=secrets -n neuvector
oc adm policy add-role-to-user neuvector-binding-secret system:serviceaccount:neuvector:controller system:serviceaccount:neuvector:enforcer system:serviceaccount:neuvector:scanner system:serviceaccount:neuvector:registry-adapter -n neuvector --role-namespace neuvector
oc create clusterrole neuvector-binding-nvcomplianceprofiles --verb=get,list,delete --resource=nvcomplianceprofiles
oc create clusterrolebinding neuvector-binding-nvcomplianceprofiles --clusterrole=neuvector-binding-nvcomplianceprofiles --serviceaccount=neuvector:controller
oc create clusterrole neuvector-binding-nvvulnerabilityprofiles --verb=get,list,delete --resource=nvvulnerabilityprofiles
oc create clusterrolebinding neuvector-binding-nvvulnerabilityprofiles --clusterrole=neuvector-binding-nvvulnerabilityprofiles --serviceaccount=neuvector:controller
oc apply -f https://raw.githubusercontent.com/neuvector/manifests/main/kubernetes/5.4.0/neuvector-roles-k8s.yaml
oc create role neuvector-binding-lease --verb=create,get,update --resource=leases -n neuvector
oc adm policy add-role-to-user neuvector-binding-cert-upgrader system:serviceaccount:neuvector:cert-upgrader -n neuvector --role-namespace neuvector
oc adm policy add-role-to-user neuvector-binding-job-creation system:serviceaccount:neuvector:cert-upgrader -n neuvector --role-namespace neuvector
oc adm policy add-role-to-user neuvector-binding-lease system:serviceaccount:neuvector:controller system:serviceaccount:neuvector:cert-upgrader -n neuvector --role-namespace neuvector
oc create clusterrole neuvector-binding-nvgroupdefinitions --verb=get,list,delete --resource=nvgroupdefinitions
oc create clusterrolebinding neuvector-binding-nvgroupdefinitions --clusterrole=neuvector-binding-nvgroupdefinitions --serviceaccount=neuvector:controller

  8. Führen Sie den folgenden Befehl aus, um zu überprüfen, ob die Dienstkonten neuvector/controller, neuvector/enforcer und neuvector/updater erfolgreich hinzugefügt wurden.

    oc get ClusterRoleBinding neuvector-binding-app neuvector-binding-rbac neuvector-binding-admission neuvector-binding-customresourcedefinition neuvector-binding-nvsecurityrules neuvector-binding-view neuvector-binding-nvwafsecurityrules neuvector-binding-nvadmissioncontrolsecurityrules neuvector-binding-nvdlpsecurityrules neuvector-binding-co -o wide

    Beispielausgabe:

    NAME                                                ROLE                                                            AGE   USERS   GROUPS   SERVICEACCOUNTS
neuvector-binding-app                               ClusterRole/neuvector-binding-app                               56d                    neuvector/controller
neuvector-binding-rbac                              ClusterRole/neuvector-binding-rbac                              34d                    neuvector/controller
neuvector-binding-admission                         ClusterRole/neuvector-binding-admission                         72d                    neuvector/controller
neuvector-binding-customresourcedefinition          ClusterRole/neuvector-binding-customresourcedefinition          72d                    neuvector/controller
neuvector-binding-nvsecurityrules                   ClusterRole/neuvector-binding-nvsecurityrules                   72d                    neuvector/controller
neuvector-binding-view                              ClusterRole/view                                                72d                    neuvector/controller
neuvector-binding-nvwafsecurityrules                ClusterRole/neuvector-binding-nvwafsecurityrules                72d                    neuvector/controller
neuvector-binding-nvadmissioncontrolsecurityrules   ClusterRole/neuvector-binding-nvadmissioncontrolsecurityrules   72d                    neuvector/controller
neuvector-binding-nvdlpsecurityrules                ClusterRole/neuvector-binding-nvdlpsecurityrules                72d                    neuvector/controller
neuvector-binding-co                                ClusterRole/neuvector-binding-co                                72d                    neuvector/enforcer, neuvector/controller

    Und dieser Befehl:

    oc get RoleBinding neuvector-binding-scanner neuvector-binding-cert-upgrader neuvector-binding-job-creation neuvector-binding-lease neuvector-binding-secret -n neuvector -o wide

    Beispielausgabe:

    NAME                              ROLE                                   AGE   USERS   GROUPS   SERVICEACCOUNTS
neuvector-binding-scanner         Role/neuvector-binding-scanner         56m                    neuvector/controller, neuvector/updater
neuvector-binding-cert-upgrader   Role/neuvector-binding-cert-upgrader   56m                    neuvector/cert-upgrader
neuvector-binding-job-creation    Role/neuvector-binding-job-creation    56m                    neuvector/controller
neuvector-binding-lease           Role/neuvector-binding-lease           56m                    neuvector/controller, neuvector/cert-upgrader
neuvector-binding-secret          Role/neuvector-binding-secret          56m                    neuvector/controller, neuvector/enforcer, neuvector/scanner, neuvector/registry-adapter

  9. (Optional) Erstellen Sie den Federation Master und/oder die Remote Multi-Cluster Management-Dienste. Wenn Sie die Multi-Cluster-Management-Funktionen in SUSE® Security verwenden möchten, muss ein Cluster den Federation Master-Dienst bereitgestellt haben, und jeder Remote-Cluster muss den Federation Worker-Dienst haben. Zur Flexibilität können Sie wählen, sowohl Master- als auch Worker-Dienste auf jedem Cluster bereitzustellen, sodass jedes Cluster ein Master- oder Remote-Cluster sein kann.

    Föderierte Management-Services

    apiVersion: v1
kind: Service
metadata:
  name: neuvector-service-controller-fed-master
  namespace: neuvector
spec:
  ports:
  - port: 11443
    name: fed
    protocol: TCP
  type: NodePort
  selector:
    app: neuvector-controller-pod

---

apiVersion: v1
kind: Service
metadata:
  name: neuvector-service-controller-fed-worker
  namespace: neuvector
spec:
  ports:
  - port: 10443
    name: fed
    protocol: TCP
  type: NodePort
  selector:
    app: neuvector-controller-pod

    Erstellen Sie dann die entsprechenden Dienste:

    oc create -f nv_master_worker.yaml

  10. Erstellen Sie die Neuvector-Dienste und Pods basierend auf den untenstehenden Beispiel-YAMLs.

    Ersetzen Sie die <version>-Tags für die Manager-, Controller- und Enforcer-Image-Referenzen in der YAML-Datei. Nehmen Sie auch alle anderen erforderlichen Änderungen für Ihre Bereitstellungsumgebung vor.

    		 
    oc create -f <compose file>

Fertig. Sie sollten in der Lage sein, sich mit der SUSE® Security-Konsole zu verbinden und sich mit admin:admin anzumelden, z. B. https://<public-ip>:8443

Um zu sehen, wie Sie auf die Konsole für den neuvector-webui-Dienst zugreifen können:

oc get services -n neuvector

Wenn Sie Ihren eigenen Namespace erstellt haben, anstatt “neuvector” zu verwenden, ersetzen Sie alle Instanzen von “namespace: neuvector” und anderen Namespace-Referenzen in den untenstehenden Beispiel-YAML-Dateien durch Ihren Namespace.

OpenShift 4.6+ mit CRI-O-Laufzeit

Der Name Ihrer Standard-OpenShift-Registry könnte sich von docker-registry in openshift-image-registry geändert haben. Möglicherweise müssen Sie die Image-Registry für den Manager, Controller und Enforcer in der Beispiel-YAML ändern.

Der Typ NodePort wird für die fed-master und fed-worker Dienste anstelle von LoadBalancer verwendet. Möglicherweise müssen Sie Anpassungen für Ihre Bereitstellung vornehmen.

Wenn Sie die CRI-O-Laufzeit verwenden, siehe dieses CRI-O-Beispiel.

Master Node Taints und Tolerations

Alle Taint-Informationen müssen übereinstimmen, um Enforcer auf Knoten zu planen. Um die Taint-Informationen auf einem Knoten (z.B. Master) zu überprüfen:

$ oc get node taintnodename -o yaml

Beispielausgabe:

spec:
  taints:
  - effect: NoSchedule
    key: node-role.kubernetes.io/master
  # there may be an extra info for taint as below
  - effect: NoSchedule
    key: mykey
    value: myvalue

Wenn es zusätzliche Taints wie oben gibt, fügen Sie diese dem Abschnitt Tolerations in der Beispiel-YAML hinzu:

spec:
  template:
    spec:
      tolerations:
        - effect: NoSchedule
          key: node-role.kubernetes.io/master
        - effect: NoSchedule
          key: node-role.kubernetes.io/control-plane
        # if there is an extra info for taints as above, please add it here. This is required to match all the taint info defined on the taint node. Otherwise, the Enforcer won't deploy on the taint node
        - effect: NoSchedule
          key: mykey
          value: myvalue

Verwendung von Knoten-Labels für Manager- und Controller-Knoten

Um zu steuern, auf welchen Knoten der Manager und der Controller bereitgestellt werden, beschriften Sie jeden Knoten. Ersetzen Sie <nodename> durch den entsprechenden Knotennamen.

oc label nodes <nodename> nvcontroller=true

Fügen Sie dann einen nodeSelector zur YAML-Datei für die Bereitstellung des Managers und Controllers hinzu. Beispiel:

          - mountPath: /host/cgroup
              name: cgroup-vol
              readOnly: true
      nodeSelector:
        nvcontroller: "true"
      restartPolicy: Always

Um zu verhindern, dass der Enforcer auf einem Controller-Knoten bereitgestellt wird, wenn es sich um einen dedizierten Management-Knoten handelt (ohne zu überwachende Anwendungscontainer), fügen Sie eine nodeAffinity zum YAML-Abschnitt des Enforcers hinzu. Beispiel:

app: neuvector-enforcer-pod
    spec:
      affinity:
        nodeAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            nodeSelectorTerms:
              - matchExpressions:
                - key: nvcontroller
                  operator: NotIn
                  values: ["true"]
      imagePullSecrets:

Aktualisierung der CVE-Datenbank bei OpenShift-Bereitstellungen

Das neueste Scanner-Image enthält immer das aktuellste Update der CVE-Datenbank von SUSE® Security. Aus diesem Grund wird empfohlen, beim Abrufen des Images kein Versionstag zu verwenden. Die Aktualisierung der CVE-Datenbank erfordert jedoch regelmäßiges Abrufen des neuesten Scanner-Images, damit der Aktualisierungs-Cron-Daemon die Scanner neu bereitstellen kann. Die obigen Beispiele gehen davon aus, dass SUSE® Security Images abgerufen, getaggt und in eine lokale OpenShift-Registry hochgeladen werden. Die Bereitstellung erfolgt dann aus dieser Registry anstelle von direkt von neuvector (oder der Legacy SUSE® Security Registry auf Docker Hub).

Um die CVE-Datenbank regelmäßig zu aktualisieren, empfehlen wir, ein Skript/Cron-Daemon zu erstellen, um das neueste SUSE® Security Scanner-Image abzurufen und die Schritte zum Taggen und Hochladen in die lokale Registry durchzuführen. Dies stellt sicher, dass die CVE-Datenbank regelmäßig aktualisiert wird und Images sowie Container auf neue Schwachstellen gescannt werden.

Rolling Updates

Orchestrierungstools wie Kubernetes, RedHat OpenShift und Rancher unterstützen Rolling Updates mit konfigurierbaren Richtlinien. Sie können diese Funktion nutzen, um die SUSE® Security Container zu aktualisieren. Am wichtigsten ist, dass sichergestellt wird, dass mindestens ein Allinone/Controller läuft, damit Richtlinien, Protokolle und Verbindungsdaten nicht verloren gehen. Stellen Sie sicher, dass zwischen den Container-Updates mindestens 30 Sekunden liegen, damit ein neuer Leader gewählt werden kann und die Daten zwischen den Controllern synchronisiert werden.

Bevor Sie mit den Rolling Updates beginnen, laden Sie bitte die SUSE® Security Container herunter und versehen Sie sie wie zu Beginn dieser Seite mit einem Tag. Sie können das Neueste ohne Versionsnummer abrufen, aber um das Rolling Update auszulösen, müssen Sie das Image mit einer Version taggen.

Zum Beispiel für den Controller (neueste):

docker pull neuvector/controller

Dann zum Taggen/Pushen, wenn die neueste Version 2.0.1 ist, dasselbe wie Schritt 3 oben auf dieser Seite:

docker login -u <user_name> -p `oc whoami -t` docker-registry.default.svc:5000
docker tag neuvector/controller docker-registry.default.svc:5000/neuvector/controller:2.0.1
docker push docker-registry.default.svc:5000/neuvector/controller:2.0.1

Sie können jetzt Ihre YAML-Datei mit diesen neuen Versionen und ‘apply’ aktualisieren oder den ‘oc set image …​’ Befehl verwenden, um das Rolling Update auszulösen. Bitte sehen Sie sich die Beispiele für Rolling Updates in Kubernetes in diesem Produktionsabschnitt an, um zu erfahren, wie man Rolling Updates der SUSE® Security Container startet und überwacht.

Die bereitgestellten Beispiel-Implementierungs-YAMLs konfigurieren bereits die Rolling Update-Richtlinie. Wenn Sie über das SUSE® Security Helm-Chart aktualisieren, ziehen Sie bitte das neueste Chart, um neue Funktionen wie Admission Control richtig zu konfigurieren, und löschen Sie die alte Cluster-Rolle und die Cluster-Rollenbindung für SUSE® Security.

Aktivierung der REST-API

Um die REST-API zu aktivieren, muss der Port 10443 wie folgt konfiguriert werden:

apiVersion: v1
kind: Service
metadata:
  name: neuvector-service-controller
  namespace: neuvector
spec:
  ports:
    - port: 10443
      name: controller
      protocol: TCP
  type: NodePort
  selector:
    app: neuvector-controller-pod

Aktivieren/Deaktivieren der Planung auf dem Master-Knoten

Die folgenden Befehle können verwendet werden, um die Planung auf dem Master-Knoten zu aktivieren/deaktivieren.

oc adm manage-node nodename --schedulable
oc adm manage-node nodename --schedulable=false

OpenShift-Implementierung im nicht privilegierten Modus

Die folgenden Anweisungen können verwendet werden, um SUSE® Security ohne Verwendung von privilegierten Modus-Containern bereitzustellen. Der Controller befindet sich bereits im nicht privilegierten Modus und die Implementierung des Enforcers sollte geändert werden, was in den unten aufgeführten Auszügen gezeigt wird.

Enforcer:

spec:
  template:
    metadata:
      annotations:
        container.apparmor.security.beta.kubernetes.io/neuvector-enforcer-pod: unconfined
      # this line below is required to be added if k8s version is pre-v1.19
      # container.seccomp.security.alpha.kubernetes.io/neuvector-enforcer-pod: unconfined
    spec:
      containers:
          securityContext:
            # openshift
            seLinuxOptions:
              type: unconfined_t
            # the following two lines are required for k8s v1.19+. pls comment out both lines if version is pre-1.19. Otherwise, a validating data error message will show
            seccompProfile:
              type: Unconfined
            capabilities:
              add:
              - SYS_ADMIN
              - NET_ADMIN
              - SYS_PTRACE
              - IPC_LOCK
              - NET_RAW
              - SYS_CHROOT
              - MKNOD
              - AUDIT_WRITE
              - SETFCAP

Das folgende Beispiel ist eine vollständige Implementierungsreferenz unter Verwendung der cri-o-Laufzeitumgebung. Für andere Laufzeiten bitte die entsprechenden Änderungen an den Volumes/Volume-Mounts für die crio.sock vornehmen.

Klicken Sie hier für Details 
apiVersion: v1
kind: Service
metadata:
  name: neuvector-svc-crd-webhook
  namespace: neuvector
spec:
  ports:
  - port: 443
    targetPort: 30443
    protocol: TCP
    name: crd-webhook
  type: ClusterIP
  selector:
    app: neuvector-controller-pod

---

apiVersion: v1
kind: Service
metadata:
  name: neuvector-svc-admission-webhook
  namespace: neuvector
spec:
  ports:
  - port: 443
    targetPort: 20443
    protocol: TCP
    name: admission-webhook
  type: ClusterIP
  selector:
    app: neuvector-controller-pod

---

apiVersion: v1
kind: Service
metadata:
  name: neuvector-service-webui
  namespace: neuvector
spec:
  ports:
    - port: 8443
      name: manager
      protocol: TCP
  type: ClusterIP
  selector:
    app: neuvector-manager-pod

---

apiVersion: v1
kind: Service
metadata:
  name: neuvector-svc-controller
  namespace: neuvector
spec:
  ports:
  - port: 18300
    protocol: "TCP"
    name: "cluster-tcp-18300"
  - port: 18301
    protocol: "TCP"
    name: "cluster-tcp-18301"
  - port: 18301
    protocol: "UDP"
    name: "cluster-udp-18301"
  clusterIP: None
  selector:
    app: neuvector-controller-pod

---

apiVersion: route.openshift.io/v1
kind: Route
metadata:
  name: neuvector-route-webui
  namespace: neuvector
spec:
  to:
    kind: Service
    name: neuvector-service-webui
  port:
    targetPort: manager
  tls:
    termination: passthrough

---

apiVersion: apps/v1
kind: Deployment
metadata:
  name: neuvector-manager-pod
  namespace: neuvector
spec:
  selector:
    matchLabels:
      app: neuvector-manager-pod
  replicas: 1
  template:
    metadata:
      labels:
        app: neuvector-manager-pod
    spec:
      serviceAccountName: basic
      serviceAccount: basic
      containers:
        - name: neuvector-manager-pod
          image: image-registry.openshift-image-registry.svc:5000/neuvector/manager:<version>
          env:
            - name: CTRL_SERVER_IP
              value: neuvector-svc-controller.neuvector
      restartPolicy: Always

---

apiVersion: apps/v1
kind: Deployment
metadata:
  name: neuvector-controller-pod
  namespace: neuvector
spec:
  selector:
    matchLabels:
      app: neuvector-controller-pod
  minReadySeconds: 60
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 0
  replicas: 3
  template:
    metadata:
      labels:
        app: neuvector-controller-pod
    spec:
      affinity:
        podAntiAffinity:
          preferredDuringSchedulingIgnoredDuringExecution:
          - weight: 100
            podAffinityTerm:
              labelSelector:
                matchExpressions:
                - key: app
                  operator: In
                  values:
                  - neuvector-controller-pod
              topologyKey: "kubernetes.io/hostname"
      serviceAccountName: controller
      serviceAccount: controller
      containers:
        - name: neuvector-controller-pod
          image: image-registry.openshift-image-registry.svc:5000/neuvector/controller:<version>
          securityContext:
            runAsUser: 0
          readinessProbe:
            exec:
              command:
              - cat
              - /tmp/ready
            initialDelaySeconds: 5
            periodSeconds: 5
          env:
            - name: CLUSTER_JOIN_ADDR
              value: neuvector-svc-controller.neuvector
            - name: CLUSTER_ADVERTISED_ADDR
              valueFrom:
                fieldRef:
                  fieldPath: status.podIP
            - name: CLUSTER_BIND_ADDR
              valueFrom:
                fieldRef:
                  fieldPath: status.podIP
            # - name: CTRL_PERSIST_CONFIG
            #   value: "1"
          volumeMounts:
            # - mountPath: /var/neuvector
            #   name: nv-share
            #   readOnly: false
            - mountPath: /etc/config
              name: config-volume
              readOnly: true
      terminationGracePeriodSeconds: 300
      restartPolicy: Always
      volumes:
        # - name: nv-share
        #   persistentVolumeClaim:
        #     claimName: neuvector-data
        - name: config-volume
          projected:
            sources:
              - configMap:
                  name: neuvector-init
                  optional: true
              - secret:
                  name: neuvector-init
                  optional: true
              - secret:
                  name: neuvector-secret
                  optional: true

---

apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: neuvector-enforcer-pod
  namespace: neuvector
spec:
  selector:
    matchLabels:
      app: neuvector-enforcer-pod
  updateStrategy:
    type: RollingUpdate
  template:
    metadata:
      labels:
        app: neuvector-enforcer-pod
      annotations:
        container.apparmor.security.beta.kubernetes.io/neuvector-enforcer-pod: unconfined
      # Add the following for pre-v1.19
      # container.seccomp.security.alpha.kubernetes.io/neuvector-enforcer-pod: unconfined
    spec:
      tolerations:
        - effect: NoSchedule
          key: node-role.kubernetes.io/master
        - effect: NoSchedule
          key: node-role.kubernetes.io/control-plane
      hostPID: true
      serviceAccountName: enforcer
      serviceAccount: enforcer
      containers:
        - name: neuvector-enforcer-pod
          image: image-registry.openshift-image-registry.svc:5000/neuvector/enforcer:<version>
          securityContext:
            # openshift
            seLinuxOptions:
              type: unconfined_t
            # the following two lines are required for k8s v1.19+. pls comment out both lines if version is pre-1.19. Otherwise, a validating data error message will show
            seccompProfile:
              type: Unconfined
            capabilities:
              add:
              - SYS_ADMIN
              - NET_ADMIN
              - SYS_PTRACE
              - IPC_LOCK
              - NET_RAW
              - SYS_CHROOT
              - MKNOD
              - AUDIT_WRITE
              - SETFCAP
          env:
            - name: CLUSTER_JOIN_ADDR
              value: neuvector-svc-controller.neuvector
            - name: CLUSTER_ADVERTISED_ADDR
              valueFrom:
                fieldRef:
                  fieldPath: status.podIP
            - name: CLUSTER_BIND_ADDR
              valueFrom:
                fieldRef:
                  fieldPath: status.podIP
          volumeMounts:
            - mountPath: /lib/modules
              name: modules-vol
              readOnly: true
            # - mountPath: /run/runtime.sock
            #   name: runtime-sock
            #   readOnly: true
            # - mountPath: /host/proc
            #   name: proc-vol
            #   readOnly: true
            # - mountPath: /host/cgroup
            #   name: cgroup-vol
            #   readOnly: true
            - mountPath: /var/nv_debug
              name: nv-debug
              readOnly: false
      terminationGracePeriodSeconds: 1200
      restartPolicy: Always
      volumes:
        - name: modules-vol
          hostPath:
            path: /lib/modules
        # - name: runtime-sock
        #   hostPath:
        #     path: /var/run/crio/crio.sock
        # - name: proc-vol
        #   hostPath:
        #     path: /proc
        # - name: cgroup-vol
        #   hostPath:
        #     path: /sys/fs/cgroup
        - name: nv-debug
          hostPath:
            path: /var/nv_debug

---

apiVersion: apps/v1
kind: Deployment
metadata:
  name: neuvector-scanner-pod
  namespace: neuvector
spec:
  selector:
    matchLabels:
      app: neuvector-scanner-pod
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 0
  replicas: 2
  template:
    metadata:
      labels:
        app: neuvector-scanner-pod
    spec:
      serviceAccountName: scanner
      serviceAccount: scanner
      containers:
        - name: neuvector-scanner-pod
          image: image-registry.openshift-image-registry.svc:5000/neuvector/scanner:<version>
          imagePullPolicy: Always
          env:
            - name: CLUSTER_JOIN_ADDR
              value: neuvector-svc-controller.neuvector
      restartPolicy: Always

---

apiVersion: batch/v1
kind: CronJob
metadata:
  name: neuvector-updater-pod
  namespace: neuvector
spec:
  schedule: "0 0 * * *"
  jobTemplate:
    spec:
      template:
        metadata:
          labels:
            app: neuvector-updater-pod
        spec:
          serviceAccountName: updater
          serviceAccount: updater
          containers:
          - name: neuvector-updater-pod
            image: image-registry.openshift-image-registry.svc:5000/neuvector/updater:<version>
            imagePullPolicy: Always
            command:
            - /bin/sh
            - -c
            - TOKEN=`cat /var/run/secrets/kubernetes.io/serviceaccount/token`; /usr/bin/curl -kv -X PATCH -H "Authorization:Bearer $TOKEN" -H "Content-Type:application/strategic-merge-patch+json" -d '{"spec":{"template":{"metadata":{"annotations":{"kubectl.kubernetes.io/restartedAt":"'`date +%Y-%m-%dT%H:%M:%S%z`'"}}}}}' 'https://kubernetes.default/apis/apps/v1/namespaces/neuvector/deployments/neuvector-scanner-pod'
          restartPolicy: Never