RedHat OpenShift

Implantar Componentes SUSE® Security Separados com RedHat OpenShift

SUSE® Security é compatível com plug-ins SDN ovs padrão, bem como outros como flannel, weave ou calico. Os exemplos abaixo assumem que um plug-in ovs padrão está sendo usado. Isso também assume que um registro docker local será usado (veja as instruções no final para criar o segredo para puxar dinamicamente do neuvector ou Docker Hub).

SUSE® Security suporta implantação baseada em Helm com um gráfico Helm em https://github.com/neuvector/neuvector-helm.. O Operador SUSE® Security também pode ser usado para implantar e é baseado no gráfico Helm. Para implantar as versões mais recentes do contêiner SUSE® Security usando um Operador, use o Operador Certificado da Red Hat do Operator Hub ou o operador da comunidade, conforme detalhado na seção do Operador.

Para implantar manualmente, primeiro puxe os contêineres SUSE® Security apropriados do registro SUSE® Security para o seu registro local. Nota: a imagem do scanner deve ser puxada regularmente para atualizações do banco de dados CVE de SUSE® Security.

SUSE® Security Imagens no Docker Hub

As imagens estão no SUSE® Security registro Docker Hub. Use a tag de versão apropriada para o manager, controller e enforcer, e deixe a versão como 'latest' para scanner e updater. Por exemplo:

  • neuvector/manager:5.4.3

  • neuvector/controller:5.4.3

  • neuvector/enforcer:5.4.3

  • neuvector/scanner:latest

  • neuvector/updater:latest

Por favor, certifique-se de atualizar as referências de imagem nos arquivos yaml apropriados.

Se implantando com o SUSE® Security gráfico Helm atual (v1.8.9+), as seguintes alterações devem ser feitas em values.yml:

  • Atualize o registro para docker.io

  • Atualize os nomes/tags das imagens para a versão atual no Docker Hub, conforme mostrado acima.

  • Deixe o imagePullSecrets vazio

Implante no 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

O arquivo de amostra abaixo implantará um manager, 3 controller e 2 pods de scanner. Ele implantará um enforcer em cada nó como um DaemonSet, incluindo no nó mestre (se agendável). Veja a seção inferior para especificar nós dedicados de manager ou controller usando rótulos de nó. Nota: Não é recomendado implantar (escalar) mais de um manager atrás de um balanceador de carga devido a possíveis problemas de estado de sessão. Se você planeja usar uma reivindicação de PersistentVolume para armazenar o backup dos arquivos de configuração de SUSE® Security, consulte a seção geral de Backup/Dados Persistentes na visão geral de Implantação em Produção.

Em seguida, defina a rota e permita contêineres privilegiados SUSE® Security usando as instruções abaixo. Por padrão, o OpenShift não permite contêineres privilegiados. Além disso, por padrão, o OpenShift não agenda pods no nó mestre. Veja as instruções no final para habilitar/desabilitar isso.

Consulte a seção de Integração Empresarial para detalhes sobre a integração com os controles de acesso com base em função (RBACs) do OpenShift.

  1. Faça login como um usuário normal

    oc login -u <user_name>

  2. Criar um novo projeto.

    Se o argumento --node-selector for usado ao criar um projeto, isso restringirá a colocação de pods, como para o SUSE® Security enforcer, a nós específicos.

    		 
    oc new-project neuvector

  3. Envie SUSE® Security imagens para o registro docker do OpenShift.

    Para OpenShift 4.6+, mude docker-registry.default.svc abaixo para image-registry.openshift-image-registry.svc nos comandos abaixo

    		 
    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

    Consulte a seção Atualizando o Banco de Dados CVE abaixo para recomendações sobre como manter a imagem do scanner mais recente atualizada em seu registro.

  4. Faça login como conta system:admin

    oc login -u system:admin

  5. Crie contas de serviço e conceda acesso ao SCC privilegiado

    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

    As seguintes informações serão adicionadas aos usuários do SCC privilegiado:

    - system:serviceaccount:neuvector:enforcer

    Adicione um novo scc neuvector-scc-controller para a conta de serviço do controller no OpenShift, criando um arquivo com:

    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

    Em seguida, aplique

    oc apply -f (filename)

    Em seguida, execute o seguinte comando para vincular a conta de serviço do controller ao scc neuvector-scc-controller.

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

    No OpenShift 4.6+, use o seguinte para verificar:

    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

    Execute este comando para verificar o SUSE® Security serviço para o Controller:

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

    A saída será parecida com

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

  6. Crie os recursos personalizados (CRD) para SUSE® Security as regras de segurança. Para 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. Adicione permissão de leitura para acessar a API do kubernetes e os RBACs do OpenShift.

    A implantação padrão SUSE® Security 5.2+ usa contas de serviço com privilégios mínimos em vez da conta padrão. Veja abaixo se estiver atualizando para 5.2+ a partir de uma versão anterior a 5.2.

    Se você estiver atualizando para 5.3.0+, execute os seguintes comandos com base na sua versão atual:

    • Versão 5.2.0

    • Versões anteriores a 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. Execute o seguinte comando para verificar se as contas de serviço neuvector/controller, neuvector/enforcer e neuvector/updater foram adicionadas com sucesso.

    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

    Saída de exemplo:

    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

    E este comando:

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

    Saída de exemplo:

    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. (Opcional) Crie o Master da Federação e/ou Serviços de Gerenciamento Multi-Cluster Remoto. Se você planeja usar as funções de gerenciamento de múltiplos clusters em SUSE® Security, um cluster deve ter o serviço Federation Master implantado, e cada cluster remoto deve ter o serviço Federation Worker implantado. Para flexibilidade, você pode optar por implantar tanto os serviços Master quanto Worker em cada cluster, para que qualquer cluster possa ser um master ou remoto.

    Serviços de Gerenciamento Federado

    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

    Em seguida, crie o(s) serviço(s) apropriado(s):

    oc create -f nv_master_worker.yaml

  10. Crie os serviços e pods do neuvector com base nos exemplos de yamls abaixo.

    Substitua as tags <version> para as referências de imagem do manager, controller e enforcer no arquivo yaml. Além disso, faça quaisquer outras modificações necessárias para o seu ambiente de implantação.

    		 
    oc create -f <compose file>

É isso aí! Você deve ser capaz de se conectar ao SUSE® Security console e fazer login com admin:admin, por exemplo, https://<public-ip>:8443.

Para ver como acessar o console do serviço neuvector-webui:

oc get services -n neuvector

Se você criou seu próprio namespace em vez de usar “neuvector”, substitua todas as instâncias de “namespace: neuvector” e outras referências de namespace pelo seu namespace nos arquivos yaml de exemplo abaixo.

OpenShift 4.6+ com runtime CRI-O

O nome do seu registro OpenShift padrão pode ter mudado de docker-registry para openshift-image-registry. Você pode precisar alterar o registro de imagem para o manager, controller e enforcer no yaml de exemplo.

O tipo NodePort é usado para os serviços fed-master e fed-worker em vez de LoadBalancer. Você pode precisar ajustar para sua implantação.

Se estiver usando o runtime CRI-O, veja este exemplo CRI-O.

Taints e Tolerâncias do Nó Master

Todas as informações de taint devem corresponder para agendar os enforcers nos nós. Para verificar as informações de taint em um nó (por exemplo, Master):

$ oc get node taintnodename -o yaml

Saída de exemplo:

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

Se houver taints adicionais como acima, adicione estes à seção de tolerâncias do yaml de exemplo:

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

Usando Rótulos de Nó para Nós de Manager e Controller

Para controlar em quais nós o manager e o controller são implantados, rotule cada nó. Substitua <nodename> pelo nome apropriado do nó.

oc label nodes <nodename> nvcontroller=true

Em seguida, adicione um nodeSelector ao arquivo yaml para as seções de implantação do manager e do controller. Por exemplo:

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

Para evitar que o enforcer seja implantado em um nó controller, se for um nó de gerenciamento dedicado (sem contêineres de aplicativo a serem monitorados), adicione um nodeAffinity à seção yaml do enforcer. Por exemplo:

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

Atualizando o Banco de Dados CVE em Implantações OpenShift

A imagem do scanner mais recente sempre contém a atualização mais recente do banco de dados CVE de SUSE® Security. Por esta razão, uma tag de versão não é recomendada ao puxar a imagem. No entanto, atualizar o banco de dados CVE requer que a imagem do scanner mais recente seja puxada regularmente, para que o trabalho cron do atualizador possa reimplantar o(s) scanner(s). Os exemplos acima assumem que as SUSE® Security imagens são puxadas, marcadas e enviadas para um registro local do OpenShift. A implantação é então a partir deste registro em vez de diretamente do neuvector (ou do SUSE® Security registro legado no Docker Hub).

Para atualizar regularmente o banco de dados CVE, recomendamos que um script/trabalho cron seja criado para puxar a SUSE® Security imagem do scanner mais recente e realizar as etapas de marcação e envio para o registro local. Isso garantirá que o banco de dados CVE esteja sendo atualizado regularmente e que imagens e contêineres estejam sendo verificados em busca de novas vulnerabilidades.

Atualizações Contínuas

Ferramentas de orquestração como Kubernetes, RedHat OpenShift e Rancher suportam atualizações contínuas com políticas configuráveis. Você pode usar esse recurso para atualizar os SUSE® Security contêineres. O mais importante será garantir que haja pelo menos um Allinone/controller em execução para que políticas, logs e dados de conexão não sejam perdidos. Certifique-se de que haja, no mínimo, 30 segundos entre as atualizações dos contêineres para que um novo líder possa ser eleito e os dados sincronizados entre os controladores.

Antes de iniciar as atualizações contínuas, por favor, faça o pull e marque os contêineres SUSE® Security da mesma forma que no início desta página. Você pode fazer o pull da versão mais recente sem um número de versão, mas para acionar a atualização contínua, será necessário marcar a imagem com uma versão.

Por exemplo, para o controlador (mais recente):

docker pull neuvector/controller

Então, para marcar/push, se a versão mais recente for 2.0.1, o mesmo que o passo 3 no topo desta página:

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

Agora você pode atualizar seu arquivo YAML com essas novas versões e ‘apply’, ou usar o comando ‘oc set image …​’ para acionar a atualização contínua. Por favor, veja os exemplos de atualizações contínuas do Kubernetes nesta seção de Produção para saber como lançar e monitorar as atualizações dos contêineres SUSE® Security.

Os arquivos YAML de implantação fornecidos como exemplo já configuram a política de atualização contínua. Se você estiver atualizando via o SUSE® Security Helm chart, por favor, faça o pull do chart mais recente para configurar corretamente novos recursos, como controle de admissão, e exclua a antiga função de cluster e a vinculação de função de cluster para SUSE® Security.

Habilitando a API REST

Para habilitar a API REST, a porta 10443 deve ser configurada da seguinte forma:

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

Habilitar/Desabilitar Agendamento no Nó Mestre

Os seguintes comandos podem ser usados para habilitar/desabilitar o agendamento no nó mestre.

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

Implantação do OpenShift em Modo Não Privilegiado

As seguintes instruções podem ser usadas para implantar SUSE® Security sem usar contêineres em modo privilegiado. O controlador já está em modo não privilegiado e a implantação do enforcer deve ser alterada, como mostrado nos trechos abaixo.

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

O exemplo a seguir é uma referência completa de implantação usando o tempo de execução cri-o. Para outros tempos de execução, por favor, faça as alterações apropriadas nos volumes/montagens de volume para o crio.sock.

Clique aqui para ver os detalhes 
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