33. Esegui il deployment dei componenti Nessus

Tempo stimato per il completamento: 1 giorno

Proprietario del componente utilizzabile: VULN

Profilo delle competenze: Deployment Engineer

Ultimo aggiornamento: 18 agosto 2025

Nessus è uno scanner di sicurezza per i sistemi di supporto e operativi di Google Distributed Cloud (GDC) air-gapped. Aiuta il team del centro operativo a monitorare e rispondere alle vulnerabilità di sicurezza di hardware e software.

Questo documento presenta i passaggi per il deployment di Nessus e presuppone che l'operatore che lo segue esegua i passaggi da una workstation OC con PowerShell e WSL disponibili.

33.1. Prima di iniziare

• Accesso richiesto

  • Segui IAM-R0005:
    • Ottieni il ruolo cluster clusterrole/tenable-nessus-admin-root nel cluster di amministrazione principale.
    • Ottieni il ruolo role/system-artifact-management-admin nello spazio dei nomi gpc-system del cluster di amministrazione principale.

• Strumenti necessari

  • kubectl
  • gdcloud
  • helm
  • yq
  • docker

• Licenze

  • Una licenza Nessus
    • Segui le istruzioni riportate in NES-G0004 - How to perform Nessus license preactivation per preparare il bundle di preattivazione "GDCH 1".

Nota: gdcloud potrebbe non essere risolto per impostazione predefinita. In caso contrario, modifica il percorso con PATH=/root/release:${PATH:?} e riprova.

33.1.1. Best practice

33.1.1.1. Upgrade

Per gli upgrade dalle versioni precedenti alla 1.14, segui la sezione "Facoltativo: disinstallazione" di ogni sezione principale di questa guida prima di eseguire qualsiasi installazione.

In caso di reinstallazioni, segui la parte "Facoltativo: disinstallazione" di ogni sezione principale di questa guida.

33.1.1.2. Gestione della differenza di versione tra organizzazioni e zone

Non dovrebbero esserci problemi dovuti alla variazione della versione tra organizzazioni e zone. Segui i passaggi specifici dell'organizzazione tenendo presente la versione dell'organizzazione. Ogni deployment sarà quindi indipendente per zona.

33.1.2. Licenza Tenablesc

Tenablesc è un software di terze parti con licenza che richiede un file di licenza per funzionare. Prima di continuare, devi ottenere una licenza Tenable in base alla SBOM. In casi speciali, potremmo essere in grado di fornire una licenza.

Il file di licenza deve avere un nome come SecurityCenter-<version>-1000IPs-<uid>.key. Individua questo file e prendine nota per dopo, perché dovrà essere caricato direttamente nell'interfaccia utente di Tenablesc.

Requisiti:

• Un file di licenza Tenablesc con un limite di almeno 1000 IP e un nome host tenablesc-as1

33.2. Individuare i file di deployment di Nessus

Prima di eseguire il deployment di Nessus, segui questi passaggi utilizzando Windows PowerShell per individuare i file di installazione di Nessus:

1. Accedi ai grafici Helm e all'immagine della macchina virtuale (VM) Nessus:

   All'interno dell'OC, questi sono accessibili in \\<dc-prefix>-hyperv1\OpsCenter\tenable-nessus

   ./operations_center/tenable-nessus/
   ├── rhel-8.6-x86_64-kvm-tenablesc.qcow2    # Tenable.sc server image
   ├── tenablesc-automation-bundle-v6n.tar    # Tenable.sc automation bundle
   ├── tenablesc-admin.tgz                    # Ops admin Tenable.sc Helm chart
   └── tenablesc-vms.tgz                      # Ops admin Tenable.sc Helm chart for VM
   

2. Sposta questi file sulla workstation locale per utilizzarli in un secondo momento:

   # Eg "\\dc1-hyperv1\OpsCenter\tenable-nessus\*"
   $OPS_TENABLE_RESOURCES = ""
   
   mkdir $env:USERPROFILE\tenable-nessus
   Copy-Item ${OPS_TENABLE_RESOURCES} $env:USERPROFILE\tenable-nessus
   

33.3. Individuare il bundle di preattivazione di Nessus

Importante: questo passaggio non è obbligatorio per gli upgrade.

Il pacchetto di preattivazione di Nessus è specifico per ogni installazione di Nessus e pertanto non può essere incluso nel pacchetto del centro operativo. Segui la guida di Nessus NES-G0004 - How to perform Nessus license preactivation per preparare il pacchetto di preattivazione "GDCH 1" prima di continuare.

1. Su una macchina connessa a internet, ottieni nessus-preact-gdch1.tar.gz personalmente o tramite un punto di contatto di Google Engineering.

2. Trasferisci questo file sulla tua workstation e inseriscilo in $env:USERPROFILE\tenable-nessus

3. La directory $env:USERPROFILE\tenable-nessus deve contenere il bundle di preattivazione:

   $env:USERPROFILE\tenable-nessus
   ├── nessus-preact-gdch1.tar.gz             # GDCH Nessus Preactivation File
   

33.4. Apri WSL

I passaggi rimanenti nella pagina richiedono WSL per tutti i comandi, se non diversamente indicato.

1. (Facoltativo) È necessario sudo. Se non conosci la password dell'utente sudo, esegui questo comando per impostare la password dell'utente sudo WSL oc-it:

   /mnt/c/Windows/System32/wsl.exe --distribution "${WSL_DISTRO_NAME}" --user root --exec passwd oc-it
   

33.5. Imposta le variabili di ambiente

Segui questi passaggi per impostare le variabili di ambiente richieste:

1. Definisci la variabile di ambiente ROOT_ADMIN_CLUSTER_KUBECONFIG per un utilizzo successivo nel terminale corrente. Deve essere un percorso assoluto al file kubeconfig del cluster di amministrazione generato come prerequisito:

   ROOT_ADMIN_CLUSTER_KUBECONFIG=
   

2. Definisci un alias per il comando kubectl del cluster di amministrazione selezionato nel terminale corrente:

   alias kra='kubectl --kubeconfig ${ROOT_ADMIN_CLUSTER_KUBECONFIG:?}'
   

3. Imposta la variabile USERPROFILE:

   export USERPROFILE=$(wslpath $(cmd.exe /c "<nul set /p=%UserProfile%" 2>/dev/null))
   

   Ora $USERPROFILE punta alla stessa posizione di $env:USERPROFILE.

33.5.1. Imposta le variabili di ambiente per l'organizzazione v1

1. Definisci la variabile di ambiente ORG_ADMIN_KUBECONFIG per un utilizzo successivo nel terminale corrente. Deve essere un percorso assoluto al file kubeconfig del cluster di amministrazione dell'organizzazione selezionato generato come prerequisito:

   ORG_ADMIN_KUBECONFIG=
   

2. Definisci un alias per il comando kubectl del cluster di amministrazione dell'organizzazione selezionato nel terminale corrente:

   alias kna='kubectl --kubeconfig ${ORG_ADMIN_KUBECONFIG:?}'
   

3. Definisci la variabile di ambiente ORG_SYSTEM_KUBECONFIG per un utilizzo successivo nel terminale corrente. Deve essere un percorso assoluto al file kubeconfig del cluster di sistema selezionato generato come prerequisito:

   ORG_SYSTEM_KUBECONFIG=
   

4. Definisci un alias per il comando kubectl del cluster di sistema selezionato nel terminale corrente:

   alias knu='kubectl --kubeconfig ${ORG_SYSTEM_KUBECONFIG:?}'
   

33.5.2. Imposta le variabili di ambiente per l'organizzazione v2

1. Definisci la variabile di ambiente ORG_MGMT_KUBECONFIG per un utilizzo successivo nel terminale corrente. Deve essere un percorso assoluto al kubeconfig del server API del piano di gestione dell'organizzazione v2 selezionata generato come prerequisito:

   ORG_MGMT_KUBECONFIG=
   

2. Definisci un alias per il comando kubectl del cluster di amministrazione dell'organizzazione selezionato nel terminale corrente:

   alias kna='kubectl --kubeconfig ${ORG_MGMT_KUBECONFIG:?}'
   

3. Definisci la variabile di ambiente ORG_INFRA_KUBECONFIG per un utilizzo successivo nel terminale corrente. Deve essere un percorso assoluto al file kubeconfig del server API del piano di controllo dell'organizzazione v2 selezionata generato come prerequisito:

   ORG_INFRA_KUBECONFIG=
   

4. Definisci un alias per il comando kubectl del cluster di sistema selezionato nel terminale corrente:

   alias knu='kubectl --kubeconfig ${ORG_INFRA_KUBECONFIG:?}'
   

33.6. Carica bundle di preattivazione

Importante: questo passaggio non è obbligatorio per gli upgrade.

Segui questi passaggi per caricare il registro degli artefatti Harbor.

1. Converti il bundle nel formato OCI con i metadati appropriati:

   BUNDLE_PATH=${USERPROFILE:?}/tenable-nessus/nessus-preact-gdch1.tar.gz
   BUNDLE_OCI_PATH=${USERPROFILE:?}/tenable-nessus/nessus-preact-gdch1-oci
   BUNDLE_TAG=$(date '+%Y%m%d%H%M%S')
   gdcloud artifacts oci build-from-tar ${BUNDLE_PATH:?} ${BUNDLE_OCI_PATH:?} \
       --version "${BUNDLE_TAG:?}" \
       --index-annotations "org.google.gpc.harbor.tag=${BUNDLE_TAG:?},com.gpc.oci.image.flat=true" \
       --manifest-annotations "org.google.gpc.harbor.project=gpc-system-nessus-updates,org.google.gpc.harbor.repo=nessus-preactivation,com.gpc.oci.image.flat=true" \
       --layer-media-type="application/vnd.unknown.layer.v1.tar"
   

2. Installa il certificato CA di Harbor:

   HARBOR_URL=$(kra get harborcluster harbor -n harbor-system -o=jsonpath='{.spec.externalURL}')
   
   HARBOR_IP=${HARBOR_URL#https://}
   
   sudo mkdir -p /etc/docker/certs.d/${HARBOR_IP:?}
   CA_CRT=$(kra get secret trust-store-internal-only -n anthos-creds -o jsonpath='{.data.ca\.crt}')
   
   sudo sh -c "echo ${CA_CRT} | openssl base64 -A -d > /etc/docker/certs.d/${HARBOR_IP:?}/ca.crt"
   

   Trova il sistema operativo:

   sudo sh -c "hostnamectl"
   

   Per Rocky Linux come sistema operativo, esegui:

   sudo update-ca-trust extract
   

   Per Ubuntu come sistema operativo, esegui:

   sudo update-ca-certificates
   

3. Carica il bundle di preattivazione su Harbor:

   • Metodo ideale: esegui l'autenticazione utilizzando gdcloud auth login.

     INFRA_CONSOLE_URL="https://$(kra get dnsregistrations.network.private.gdc.goog -n gpc-system infra-console -o jsonpath='{.status.fqdn}')"
     
     gdcloud config set core/organization_console_url ${INFRA_CONSOLE_URL:?}
     gdcloud auth login
     gdcloud auth configure-docker
     
     gdcloud system container-registry load-oci ${BUNDLE_OCI_PATH:?} --create-release-metadata=false --skip-failover-registry
     

   • Metodo di backup: utilizzo di kubeconfig.

     gdcloud system container-registry load-oci ${BUNDLE_OCI_PATH:?} --create-release-metadata=false --use-ip-port=true  --skip-failover-registry --kubeconfig=${ROOT_ADMIN_CLUSTER_KUBECONFIG:?}
     

33.7. Installa Nessus

Avviso: per gli upgrade dalle versioni precedenti alla 1.14, segui la sezione "Facoltativo: disinstallazione" prima di procedere con l'installazione.

1. Attiva l'installazione di Nessus:

   cat <<EOF | kra apply -f -
   apiVersion: vulnerabilitymanagement.private.gdc.goog/v1alpha1
   kind: ParentNessusManagerConfig
   metadata:
       name: parent-nessus-manager-config
       namespace: tenable-nessus-system
   spec:
       preactivationUrlBundleTag: "${BUNDLE_TAG:?}"
       installedAt: "$(date -u +"%Y-%m-%dT%H:%M:%SZ")"
   EOF
   

2. Attendi circa 1 ora e mezza per il completamento dell'installazione.

33.7.1. (Facoltativo) Disinstalla Nessus

Questa sezione contiene i comandi per rimuovere il deployment di Nessus da tutti i cluster richiesti.

Avviso: disinstalla la tua implementazione Nessus esistente solo se stai eseguendo una reinstallazione o un upgrade. In caso contrario, salta questa sezione.

1. Disinstalla Nessus dal cluster di amministrazione root:

   helm list -n tenable-nessus-system -q --kubeconfig ${ROOT_ADMIN_CLUSTER_KUBECONFIG:?} | xargs helm uninstall -n tenable-nessus-system --kubeconfig ${ROOT_ADMIN_CLUSTER_KUBECONFIG:?}
   

2. Per l'architettura dell'organizzazione v1:

   1. Disinstalla Nessus dal cluster di amministrazione dell'organizzazione:

      helm list -n tenable-nessus-system -q --kubeconfig ${ORG_ADMIN_KUBECONFIG:?} | xargs helm uninstall -n tenable-nessus-system --kubeconfig ${ORG_ADMIN_KUBECONFIG:?}
      

   2. Disinstalla Nessus dal cluster di sistema dell'organizzazione:

      helm list -n tenable-nessus-system -q --kubeconfig ${ORG_SYSTEM_KUBECONFIG:?} | xargs helm uninstall -n tenable-nessus-system --kubeconfig ${ORG_SYSTEM_KUBECONFIG:?}
      

3. Per l'architettura dell'organizzazione v2:

   1. Disinstalla Nessus dal cluster di gestione dell'organizzazione:

      helm list -n tenable-nessus-system -q --kubeconfig ${ORG_MGMT_KUBECONFIG:?} | xargs helm uninstall -n tenable-nessus-system --kubeconfig ${ORG_MGMT_KUBECONFIG:?}
      

   2. Disinstalla Nessus dal cluster dell'infrastruttura dell'organizzazione:

      helm list -n tenable-nessus-system -q --kubeconfig ${ORG_INFRA_KUBECONFIG:?} | xargs helm uninstall -n tenable-nessus-system --kubeconfig ${ORG_INFRA_KUBECONFIG:?}
      

33.7.2. Verificare Nessus nel cluster di amministrazione root

1. Verifica che le chiavi e i certificati siano pubblicati:

   echo "Child linking key published: $(kra get pnm -A -o yaml | yq e '.items[0].status.conditions[] | select(.type == "ChildLinkingKeyPublished") | .status')"
   
   echo "Agent linking key published: $(kra get pnm -A -o yaml | yq e '.items[0].status.conditions[] | select(.type == "AgentLinkingKeyPublished") | .status')"
   
   echo "Nessus TLS Crt published: $(kra get pnm -A -o yaml | yq e '.items[0].status.conditions[] | select(.type == "NessusTlsCrtPublished") | .status')"
   

2. Verifica che Nessus Manager genitore sia in stato integro:

   POD_NAME=$(kra get pod -n tenable-nessus-system | grep vuln-parent-nessus-backend-app | awk '{print $1}')
   
   if kra exec -n tenable-nessus-system -c manager ${POD_NAME:?} -- /bin/bash -c "/opt/nessus/sbin/nessuscli node status" | grep -Fq "Agents linked"; then
       echo "Manager node is healthy"
   else
       echo "Manager node is unhealthy"
   fi
   

3. Se Nessus Manager principale viene segnalato come non integro, ad esempio l'output di uno dei comandi precedenti è false, riavvia Nessus Manager principale con i seguenti comandi:

   kra rollout restart deployment vuln-parent-nessus-backend-app -n tenable-nessus-system
   

4. Attendi circa 1 ora e mezza e poi controlla di nuovo lo stato.

5. Se il Nessus Manager principale risulta ancora non integro dopo 1 ora e mezza, riassegna il problema al team di reperibilità.

   1. Includi le seguenti informazioni dopo aver eseguito la query specificata dalla UI di Grafana:

      {pod="<pod_name>"}
      

   2. Includi la configurazione di Nessus Manager principale:

      kra get pnm -A -o yaml
      

6. Verifica che Nessus Manager secondario sia in stato integro:

   POD_NAME=$(kra get pod -n tenable-nessus-system | grep vuln-managed-nessus-backend-app | awk '{print $1}')
   
   if kra exec -n tenable-nessus-system -c manager ${POD_NAME:?} -- /bin/bash -c "/opt/nessus/sbin/nessuscli node status" | grep -Fq "Agents linked"; then
       echo "Manager node is healthy"
   else
       echo "Manager node is unhealthy"
   fi
   

7. Se Nessus Manager secondario viene segnalato come non integro, riavvialo con i seguenti comandi, attendi 20 minuti e controlla di nuovo lo stato:

   kra rollout restart deployment vuln-managed-nessus-backend-app -n tenable-nessus-system
   

8. Se dopo 20 minuti il gestore Nessus secondario risulta ancora non integro, riassegna il problema e includi le seguenti informazioni dopo aver eseguito la query specificata dall'interfaccia utente di Grafana.

   1. Includi le seguenti informazioni dopo aver eseguito la query specificata dalla UI di Grafana:

      {pod="<pod_name>"}
      

   2. Includi la configurazione di Nessus Manager figlio:

      kra get cnm -A -o yaml
      

9. Verifica che non siano presenti agenti non integri:

   echo "Nodes with unhealthy agents:"\
   $(kra get nessusagent -A -o yaml | yq '.items[] | select(.status.conditions[] | select(.type == "Heartbeat" and .status == "False")) | .spec.nodeRef')
   

10. Per tutti gli agenti elencati nell'elenco non integro, imposta la variabile NESSUS_AGENT_NAME ed esegui il seguente comando per tutti:

    NESSUS_AGENT_NAME=
    kra delete nessusagent ${NESSUS_AGENT_NAME} -n tenable-nessus-system
    

11. Se dopo 20 minuti gli agenti non integri sono ancora segnalati nell'elenco, procedi nel seguente modo per ciascun agente:

    • Controlla i log del pod install-<node_name> in Grafana e, se è presente un log di errori ansible-playbook error: one or more host failed, stabilisci una connessione SSH al nodo bare metal utilizzando PLATAUTH-G0001.

    • Dopo aver stabilito una connessione SSH al nodo bare metal, sposta /etc/yum.repos.d in /etc/ yum.repos.d.back (per eliminare in modo efficace yum repos conf).

12. Se dopo 20 minuti gli agenti non integri sono ancora segnalati nell'elenco, riassegna il problema e includi le seguenti informazioni dopo aver eseguito la query specificata dall'interfaccia utente di Grafana.

    1. Includi le seguenti informazioni dopo aver eseguito la query specificata dalla UI di Grafana.

       {pod="<pod_name>"}
       

    2. Includi lo stato dell'agente Nessus:

       kra get nessusagent/${NESSUS_AGENT_NAME} -n tenable-nessus-system -o yaml
       

    3. Includi la configurazione dell'agente Nessus:

       kra get nessusagentconfig/nessus-agent-config -n tenable-nessus-system -o yaml
       

33.8. Nessus Manager - verifica dell'organizzazione

Questa sezione descrive i passaggi necessari per verificare Nessus all'interno di un'organizzazione Distributed Cloud.

Per garantire una verifica Nessus efficace e completa, esegui questa procedura per ogni cluster dell'organizzazione di Distributed Cloud, incluso il cluster dell'organizzazione IT del Centro operazioni.

Elenca le organizzazioni disponibili:

kra get -n gpc-system organization

Segui i passaggi riportati di seguito per ogni organizzazione, ad eccezione dell'organizzazione root, che è già stata trattata.

33.8.1. Prerequisiti

• Accesso richiesto per le organizzazioni v1

  • Segui IAM-R0005:
    • Ottieni il ruolo cluster clusterrole/tenable-nessus-admin-root nel cluster di amministrazione principale.

  • Segui IAM-R0004:

    • Genera il file KUBECONFIG per il cluster di amministrazione principale.

  • Segui IAM-R0005:

    • Ottieni il ruolo cluster clusterrole/tenable-nessus-admin-org-legacy nel cluster di amministrazione dell'organizzazione di destinazione.

  • Segui IAM-R0004:

    • Genera il file KUBECONFIG per il cluster di amministrazione dell'organizzazione di destinazione.

  • Segui IAM-R0005:

    • Ottieni il ruolo cluster clusterrole/tenable-nessus-admin-system-legacy nel cluster di sistema di destinazione.

  • Segui IAM-R0004:

    • Genera il file KUBECONFIG per il cluster di sistema di destinazione.

• Accesso richiesto per le organizzazioni v2

  • Segui IAM-R0005:
    • Ottieni il ruolo cluster clusterrole/tenable-nessus-admin-root nel cluster di amministrazione principale.
  • Segui IAM-R0004:
    • Genera il file KUBECONFIG per il cluster di amministrazione principale.
  • Segui IAM-R0005:
    • Ottieni il ruolo del cluster clusterrole/tenable-nessus-admin-infra-mp nel cluster di destinazione.
  • Segui IAM-R0004:
    • Genera il file KUBECONFIG di mp per il cluster di infrastruttura di destinazione.
  • Segui IAM-R0005:
    • Ottieni il ruolo cluster clusterrole/tenable-nessus-admin-infra-cp nel server API Kube del control plane dell'infrastruttura di destinazione.
  • Segui IAM-R0004:
    • Genera il file KUBECONFIG cp per il cluster di infrastruttura.

Segui la procedura descritta in Impostare le variabili di ambiente per configurare l'accesso ai cluster dell'organizzazione e definire gli alias della riga di comando kna e knu.

33.8.2. Verifica Nessus nel cluster di amministrazione dell'organizzazione nelle organizzazioni v1 e nel server API kube del control plane di gestione dell'infrastruttura nelle organizzazioni v2

1. Verifica che non siano presenti agenti non integri:

   echo "Nodes with unhealthy agents:"\
   $(kna get nessusagent -A -o yaml | yq '.items[] | select(.status.conditions[] | select(.type == "Heartbeat" and .status == "False")) | .spec.nodeRef')
   

2. Per tutti gli agenti elencati nell'elenco non integro, imposta la variabile NESSUS_AGENT_NAME ed esegui il seguente comando per tutti:

   NESSUS_AGENT_NAME=
   kna delete nessusagent ${NESSUS_AGENT_NAME} -n tenable-nessus-system
   

3. Se dopo 20 minuti gli agenti non integri sono ancora segnalati nell'elenco, procedi nel seguente modo per ciascun agente:

   • Controlla i log del pod install-<node_name> in Grafana e, se è presente un log di errori ansible-playbook error: one or more host failed, stabilisci una connessione SSH al nodo bare metal utilizzando PLATAUTH-G0001.

   • Dopo aver stabilito una connessione SSH al nodo bare metal, sposta /etc/yum.repos.d in /etc/ yum.repos.d.back (per eliminare in modo efficace yum repos conf).

4. Se dopo 20 minuti gli agenti non integri vengono ancora segnalati nell'elenco, riassegna il problema e includi le seguenti informazioni dopo aver eseguito la query specificata dall'interfaccia utente di Grafana.

   {pod="<pod_name>"}
   

33.8.3. Verifica Nessus nel cluster di sistema nelle organizzazioni v1 e il server API kube del control plane dell'infrastruttura nelle organizzazioni v2

1. Verifica che Nessus Manager secondario sia in stato integro:

   POD_NAME=$(knu get pod -n tenable-nessus-system | grep vuln-managed-nessus-backend-app | awk '{print $1}')
   
   if knu exec -n tenable-nessus-system -c manager ${POD_NAME:?} -- /bin/bash -c "/opt/nessus/sbin/nessuscli node status" | grep -Fq "Agents linked"; then
       echo "Manager node is healthy"
   else
       echo "Manager node is unhealthy"
   fi
   

2. Se Nessus Manager secondario viene segnalato come non integro, riavvialo con i seguenti comandi, attendi 20 minuti e controlla di nuovo lo stato:

   knu rollout restart deployment vuln-managed-nessus-backend-app -n tenable-nessus-system
   

3. Se dopo 20 minuti il gestore Nessus secondario risulta ancora non integro, riassegna il problema e includi le seguenti informazioni dopo aver eseguito la query specificata dall'interfaccia utente di Grafana.

   1. Includi le seguenti informazioni dopo aver eseguito la query specificata dalla UI di Grafana.

      {pod="<pod_name>"}
      

   2. Includi la configurazione di Nessus Manager secondario.

      knu get cnm -A -o yaml
      

4. Verifica che non siano presenti agenti non integri:

   echo "Nodes with unhealthy agents:"\
   $(knu get nessusagent -A -o yaml | yq '.items[] | select(.status.conditions[] | select(.type == "Heartbeat" and .status == "False")) | .spec.nodeRef')
   

5. Per tutti gli agenti elencati nell'elenco non integro, imposta la variabile NESSUS_AGENT_NAME ed esegui il seguente comando per tutti:

   NESSUS_AGENT_NAME=
   knu delete nessusagent ${NESSUS_AGENT_NAME} -n tenable-nessus-system
   

6. Se dopo 20 minuti gli agenti non integri sono ancora segnalati nell'elenco, procedi nel seguente modo per ciascun agente:

   • Controlla i log del pod install-<node_name> in Grafana e, se è presente un log di errori ansible-playbook error: one or more host failed, stabilisci una connessione SSH al nodo bare metal utilizzando PLATAUTH-G0001.

   • Dopo aver stabilito una connessione SSH al nodo bare metal, sposta /etc/yum.repos.d in /etc/ yum.repos.d.back (per eliminare in modo efficace yum repos conf).

7. Se dopo 20 minuti gli agenti non integri sono ancora segnalati nell'elenco, riassegna il problema e includi le seguenti informazioni dopo aver eseguito la query specificata dall'interfaccia utente di Grafana.

   1. Includi le seguenti informazioni dopo aver eseguito la query specificata dalla UI di Grafana:

      {pod="<pod_name>"}
      

   2. Includi lo stato dell'agente Nessus:

      knu get nessusagent/${NESSUS_AGENT_NAME} -n tenable-nessus-system -o yaml
      

   3. Includi la configurazione dell'agente Nessus:

      knu get nessusagentconfig/nessus-agent-config -n tenable-nessus-system -o yaml
      

33.9. Installa Tenable.sc

Questa sezione contiene i passaggi per installare o eseguire l'upgrade di una VM esistente di Tenable.sc all'interno dell'organizzazione IT Operations Center.

33.9.1. Prerequisiti

• Accesso richiesto

  • Per l'architettura dell'organizzazione v1:
    • Segui IAM-R0005:
      • Ottieni il ruolo cluster clusterrole/tenable-nessus-admin-root nel cluster di amministrazione principale.
    • Segui IAM-R0004:
      • Genera il file KUBECONFIG per il cluster di amministrazione principale.
    • Segui IAM-R0005:
      • Ottieni il ruolo cluster clusterrole/tenable-nessus-admin-org-legacy nel cluster di amministrazione gdchservices.
    • Segui IAM-R0004:
      • Genera il file KUBECONFIG per il cluster di amministrazione gdchservices.
    • Segui IAM-R0005:
      • Ottieni il ruolo cluster clusterrole/tenable-nessus-admin-system-legacy nel cluster di sistema gdchservices.
    • Segui IAM-R0004:
      • Genera il file KUBECONFIG per il cluster di sistema gdchservices.
  • Per l'architettura dell'organizzazione v2:
    • Segui IAM-R0005:
      • Ottieni il ruolo cluster clusterrole/tenable-nessus-admin-root nel cluster di amministrazione principale.
    • Segui IAM-R0004:
      • Genera il file KUBECONFIG per il cluster di amministrazione principale.
    • Segui IAM-R0005:
      • Ottieni il ruolo cluster clusterrole/tenable-nessus-admin-infra-mp nel cluster gdchservices-management.
    • Segui IAM-R0004:
      • Genera il file KUBECONFIG per il cluster gdchservices-management.
    • Segui IAM-R0005:
      • Ottieni il ruolo cluster clusterrole/tenable-nessus-admin-infra-cp nel cluster gdchservices-infra.
    • Segui IAM-R0004:
      • Genera il file KUBECONFIG per il cluster gdchservices-infra.

33.9.2. Imposta le variabili di ambiente

Segui questi passaggi per impostare le variabili di ambiente richieste:

1. Definisci la variabile di ambiente ROOT_ADMIN_CLUSTER_KUBECONFIG per un utilizzo successivo nel terminale corrente. Deve essere un percorso assoluto al file kubeconfig del cluster di amministrazione generato come prerequisito:

   ROOT_ADMIN_CLUSTER_KUBECONFIG=
   

2. Definisci un alias per il comando kubectl del cluster di amministrazione principale nel terminale corrente:

   alias kra='kubectl --kubeconfig ${ROOT_ADMIN_CLUSTER_KUBECONFIG:?}'
   

3. Definisci la variabile di ambiente per il file kubeconfig del management plane dell'organizzazione gdchservices:

   • Per l'architettura dell'organizzazione v1: Definisci la variabile di ambiente ORG_ADMIN_KUBECONFIG per un utilizzo successivo nel terminale corrente. Deve essere un percorso assoluto al file kubeconfig del cluster di amministrazione gdchservices generato come prerequisito:

     ORG_ADMIN_KUBECONFIG=
     

   • Per l'architettura dell'organizzazione v2: Definisci la variabile di ambiente ORG_MGMT_KUBECONFIG per un utilizzo successivo nel terminale corrente. Deve essere un percorso assoluto al file kubeconfig del cluster di gestione gdchservices generato come prerequisito:

     ORG_MGMT_KUBECONFIG=
     

4. Crea un alias per il comando kubectl utilizzando il file kubeconfig precedente:

   • Per l'architettura dell'organizzazione v1: Definisci un alias per il comando kubectl del cluster di amministrazione gdchservices nel terminale corrente:

     alias kna='kubectl --kubeconfig ${ORG_ADMIN_KUBECONFIG:?}'
     

   • Per l'architettura dell'organizzazione v2: Definisci un alias per il comando kubectl del cluster di amministrazione gdchservices nel terminale corrente:

     alias kna='kubectl --kubeconfig ${ORG_MGMT_KUBECONFIG:?}'
     

5. Definisci la variabile di ambiente per il file kubeconfig del control plane dell'organizzazione gdchservices:

   • Per l'architettura dell'organizzazione v1: Definisci la variabile di ambiente ORG_SYSTEM_KUBECONFIG per un utilizzo successivo nel terminale corrente. Deve essere un percorso assoluto al file kubeconfig del cluster di sistema gdchservices generato come prerequisito:

     ORG_SYSTEM_KUBECONFIG=
     

   • Per l'architettura dell'organizzazione v2: Definisci la variabile di ambiente ORG_INFRA_KUBECONFIG per un utilizzo successivo nel terminale corrente. Deve essere un percorso assoluto al file kubeconfig del cluster di infrastruttura gdchservices generato come prerequisito:

     ORG_INFRA_KUBECONFIG=
     

6. Crea un alias per il comando kubectl utilizzando il file kubeconfig precedente:

   • Per l'architettura dell'organizzazione v1: Definisci un alias per il comando kubectl del cluster di sistema gdchservices nel terminale corrente:

     alias knu='kubectl --kubeconfig ${ORG_SYSTEM_KUBECONFIG:?}'
     

   • Per l'architettura dell'organizzazione v2: Definisci un alias per il comando kubectl del cluster di infrastruttura gdchservices nel terminale corrente:

     alias knu='kubectl --kubeconfig ${ORG_INFRA_KUBECONFIG:?}'
     

7. Imposta la variabile USERPROFILE:

   export USERPROFILE=$(wslpath $(cmd.exe /c "<nul set /p=%UserProfile%" 2>/dev/null))
   

   Ora $USERPROFILE punta alla stessa posizione di $env:USERPROFILE.

8. Definisci il nome dell'organizzazione in cui è stato implementato Tenablesc:

   ORG=gdchservices
   

33.9.3. Prepararsi all'installazione

Segui questi passaggi per preparare l'organizzazione.

1. Crea il progetto tenablesc-system.

   cat <<EOF | kna apply -n gpc-system -f -
   apiVersion: resourcemanager.gdc.goog/v1
   kind: Project
   metadata:
     name: tenablesc-system
     labels:
       istio.io/rev: default
       networking.gdc.goog/enable-default-egress-allow-to-outside-the-org: "true"
       resourcemanager.gdc.goog/attach-all-user-clusters: "true"
   EOF
   

2. Dopo due minuti, verifica che gli spazi dei nomi esistano sia nel cluster di amministrazione dell'organizzazione sia in quello di sistema.

   kna get namespace tenablesc-system -o yaml
   
   knu get namespace tenablesc-system -o yaml
   

   Tieni presente che l'etichetta del progetto resourcemanager.gdc.goog/attach-all-user-clusters: "true" fa sì che lo spazio dei nomi venga creato anche in tutti i cluster utente dell'organizzazione.

3. Genera e salva le credenziali utente di amministratore e gestore di Tenablesc come secret Kubernetes.

   cat <<EOF | knu apply -n tenablesc-system  -f -
   apiVersion: v1
   kind: Secret
   type: Opaque
   metadata:
       name: users
   data:
       adminpw: $(</dev/urandom tr -dc 'A-Za-z0-9~!@#$%^*+?' | head -c 25 | base64)
       managerpw: $(</dev/urandom tr -dc 'A-Za-z0-9~!@#$%^*+?' | head -c 25 | base64)
   EOF
   

33.9.4. Grafico Installazioni amministrative

1. Imposta le seguenti variabili di ambiente per prepararti all'installazione:

   URL_SUFFIX=$(kna get configmap dnssuffix -n gpc-system -o jsonpath='{.data.dnsSuffix}')
   
   ROOT_URL_SUFFIX=$(kra get configmap dnssuffix -n gpc-system -o jsonpath='{.data.dnsSuffix}')
   
   DEPLOY_NAME=tenablesc
   

2. Applica il grafico Helm dell'amministratore.

   • Per l'architettura dell'organizzazione v1:

     helm upgrade --install \
       tenablesc-admin ${USERPROFILE:?}/tenable-nessus/tenablesc-admin.tgz \
       --namespace tenablesc-system \
       --set urlSuffix=${URL_SUFFIX:?} \
       --set deployName=${DEPLOY_NAME:?} \
       --kubeconfig ${ORG_ADMIN_KUBECONFIG:?}
     

   • Per l'architettura dell'organizzazione v2:

     Imposta OCIT_NESSUS_MANAGER_PREFIXES come elenco separato da virgole, ad esempio "{dc1-nessus1,dc1-nessus2}", che indica il prefisso della VM OCIT.

     Imposta OCIT_NESSUS_URL_SUFFIX indicando il suffisso della VM OCIT.

     Applica gli aggiornamenti di Helm per il piano di gestione:

     helm upgrade --install \
       tenablesc-admin ${USERPROFILE:?}/tenable-nessus/tenablesc-infra-mp.tgz \
       --namespace tenablesc-system \
       --set urlSuffix=${URL_SUFFIX:?} \
       --set ocitNessusManagerPrefixes=${OCIT_NESSUS_MANAGER_PREFIXES:?} \
       --set deployName=${DEPLOY_NAME:?} \
       --kubeconfig ${ORG_MGMT_KUBECONFIG:?}
     

     Applica gli aggiornamenti di Helm per il piano dell'infrastruttura:

     helm upgrade --install \
       tenablesc-admin ${USERPROFILE:?}/tenable-nessus/tenablesc-infra-cp.tgz \
       --namespace tenablesc-system \
       --set urlSuffix=${URL_SUFFIX:?} \
       --set rootUrlSuffix=${ROOT_URL_SUFFIX:?} \
       --set ocitUrlSuffix=${OCIT_NESSUS_URL_SUFFIX:?} \
       --set ocitNessusManagerPrefixes=${OCIT_NESSUS_MANAGER_PREFIXES:?} \
       --set deployName=${DEPLOY_NAME:?} \
       --kubeconfig ${ORG_INFRA_KUBECONFIG:?}
     

     Applica il criterio di autorizzazione Istio:

     cat <<EOF | knu apply -f -
     apiVersion: security.istio.io/v1
     kind: AuthorizationPolicy
     metadata:
       name: allow-nessus-terminated-traffic
       namespace: istio-system
     spec:
       rules:
       - from:
         - source:
             ipBlocks:
             - 0.0.0.0/0
         to:
         - operation:
             hosts:
             - nessus-terminated.${URL_SUFFIX:?}
       selector:
         matchLabels:
           istio: management-ingress-gateway
     EOF
     

     Crea voce di servizio:

     cat <<EOF | knu apply -f -
     apiVersion: networking.istio.io/v1beta1
     kind: ServiceEntry
     metadata:
       name: nessus-svc-entry
       namespace: istio-system
     spec:
       hosts:
       - nessus.${ROOT_URL_SUFFIX:?}
       location: MESH_EXTERNAL
       ports:
       - name: https-port
         number: 443
         protocol: TLS
       resolution: DNS
     EOF
     

     Crea registrazione DNS:

     cat <<EOF | kna apply -n tenablesc-system -f -
     apiVersion: network.private.gdc.goog/v1alpha1
     kind: DNSRegistration
     metadata:
       name: tenablesc-internal
       namespace: tenablesc-system
     spec:
       resolutionConfig:
         exposeToNetwork: VPC
         resolveTo:
           useDefaultIstioGateway:
             owningCluster: InfraCluster
             ingressLabel: infra
         vpcIdentifier: infra
     EOF
     

     Archivia l'FQDN in una variabile di ambiente dopo aver atteso cinque minuti:

     TENABLE_SC_INTERNAL_FQDN=$(kna get dnsregistrations.network.private.gdc.goog -n tenablesc-system tenablesc-internal -o jsonpath='{.status.fqdn}')
     

     Applica una patch al servizio virtuale e al gateway per aggiungere il nome di dominio completo interno di Tenable SC:

     knu patch gateway tenablesc-gateway -n istio-system --type='json' \
     -p='[{"op": "add", "path": "/spec/servers/0/hosts/0", "value": "'"${TENABLE_SC_INTERNAL_FQDN:?}"'"}]'
     

     knu patch virtualservice tenablesc-https-ingress-virtualsvc -n tenablesc-system --type='json' \
     -p='[{"op": "add", "path": "/spec/hosts/0", "value": "'"${TENABLE_SC_INTERNAL_FQDN:?}"'"}]'
     

     Applica una patch alla risorsa prober per eseguire il probe dell'endpoint corretto:

     kna patch probe tenablesc-probe -n tenablesc-system --type='json' \
     -p='[{"op": "replace", "path": "/spec/probeJobs/0/targets/0", "value": "https://'"${TENABLE_SC_INTERNAL_FQDN:?}"'"}]'
     

3. Verifica il deployment.

   Esamina l'output del seguente comando per verificare che il deployment di tenablesc-admin sia andato a buon fine:

   • Per l'architettura dell'organizzazione v1:

     helm ls --namespace tenablesc-system --kubeconfig ${ORG_ADMIN_KUBECONFIG:?}
     

   • Per l'architettura dell'organizzazione v2:

     helm ls --namespace tenablesc-system --kubeconfig ${ORG_MGMT_KUBECONFIG:?}
     

4. Verifica che il servizio virtuale esista.

   • Per l'architettura dell'organizzazione v1:

     kna get virtualservice -n tenablesc-system
     

   • Per l'architettura dell'organizzazione v2:

     knu get virtualservice -n tenablesc-system
     

5. Verifica che la voce DNS esista.

   echo $(kna get dnsregistrations.network.private.gdc.goog -n tenablesc-system tenablesc -o jsonpath='{.status.fqdn}')
   

6. Verifica che AuditLoggingTarget sia pronto, operazione che dovrebbe richiedere diversi minuti.

   kna get auditloggingtarget/tenablesc-audit-logging-target -n tenablesc-system -o jsonpath='{ .status }' |  jq
   

   • Potrebbe verificarsi il seguente errore:

     Error: failed to copy secret to project: namespace "tenablesc-system" not found in cluster <user_cluster>

     In questo caso, lo spazio dei nomi tenablesc-system deve essere creato nel cluster specificato. Per continuare, crea lo spazio dei nomi e poi apri un meta bug per avviare un'indagine sul motivo per cui si verifica questo errore. Includi l'output di tenablesc-system Project describe nel ticket.

     kna describe project tenablesc-system
     

   • Potrebbe verificarsi il seguente errore:

     Error from server (NotFound): auditloggingtargets.logging.private.gdc.goog "tenablesc-audit-logging-target" not found

     In questo caso, crea manualmente il AuditLoggingTarget mancante:

     cat <<EOF | kna apply -n tenablesc-system -f -
     apiVersion: logging.private.gdc.goog/v1alpha1
     kind: AuditLoggingTarget
     metadata:
         name: "${DEPLOY_NAME:?}-audit-logging-target"
     spec:
         appNameLabel: "${DEPLOY_NAME:?}"
         hostNameLabel: host
         ingressGatewayPort: 0
         logAccessLevel: io
         serviceName: "${DEPLOY_NAME:?}"
         timestampKey: time
         timestampkeyFormat: '%Y-%m-%dT%H:%M:%S'
     EOF
     

     Dopo cinque minuti, l'output dovrebbe essere simile al seguente:

     {
         "certSecretName": "tenablesc-alog-client-tls",
         "conditions": [
             {
                 "lastTransitionTime": "2023-07-11T15:13:50Z",
                 "message": "",
                 "observedGeneration": 1,
                 "reason": "ReconciliationCompleted",
                 "status": "True",
                 "type": "Ready"
             }
         ],
         "serverCertSecretName": "tenablesc-alog-server-tls",
         "syslogServerName": "tenablesc-alog-system.gdchservices.bert.sesame.street",
         "syslogServerPortNumber": 5140
     }
     

     Dopo 10 minuti, se l'output dello stato sembra ancora errato, la piattaforma di osservabilità potrebbe non essere in buono stato. Apri un meta bug con le informazioni sullo stato disponibili per facilitare il debug.

33.9.5. Grafico Installazioni di VM

1. Imposta le seguenti variabili di ambiente per prepararti all'installazione:

   TENABLESC_IMAGE_URL=$(kna get virtualmachineimages.virtualmachine.gdc.goog -n vm-system -o custom-columns=NAME:.metadata.name | grep nessus-tenable-sc | sort -r -k 1 | head -1)
   TENABLESC_BOOT_SIZE=50G
   

   • Per l'architettura dell'organizzazione v1:

     ALT_NAME=tenablesc-audit-logging-target
     
     ALT_NS=tenablesc-system
     
     ALT_HOSTNAME=$(kna get auditloggingtarget/${ALT_NAME:?} -n ${ALT_NS:?} -o jsonpath='{ .status.syslogServerName }')
     
     ALT_PORT=$(kna get auditloggingtarget/${ALT_NAME:?} -n ${ALT_NS:?} -o jsonpath='{ .status.syslogServerPortNumber }')
     
     ALT_CERT_SECRET=$(kna get auditloggingtarget/${ALT_NAME:?} -n ${ALT_NS:?} -o jsonpath='{ .status.certSecretName }')
     
     ALT_CACERT=$(kna get secret/${ALT_CERT_SECRET:?} -n ${ALT_NS:?} -o jsonpath='{ .data.ca\.crt }')
     
     ALT_CERTFILE=$(kna get secret/${ALT_CERT_SECRET:?} -n ${ALT_NS:?} -o jsonpath='{ .data.tls\.crt }')
     
     ALT_KEYFILE=$(kna get secret/${ALT_CERT_SECRET:?} -n ${ALT_NS:?} -o jsonpath='{ .data.tls\.key }')
     

   • Per l'architettura dell'organizzazione v2:

     ALT_NAME=tenablesc-audit-logging-target
     
     ALT_NS=tenablesc-system
     
     ALT_HOSTNAME=$(kna get auditloggingtarget/${ALT_NAME:?} -n ${ALT_NS:?} -o jsonpath='{ .status.syslogServerName }')
     
     ALT_PORT=$(kna get auditloggingtarget/${ALT_NAME:?} -n ${ALT_NS:?} -o jsonpath='{ .status.syslogServerPortNumber }')
     
     ALT_CERT_SECRET=$(kna get auditloggingtarget/${ALT_NAME:?} -n ${ALT_NS:?} -o jsonpath='{ .status.certSecretName }')
     
     ALT_CACERT=$(knu get secret/${ALT_CERT_SECRET:?} -n ${ALT_NS:?} -o jsonpath='{ .data.ca\.crt }')
     
     ALT_CERTFILE=$(knu get secret/${ALT_CERT_SECRET:?} -n ${ALT_NS:?} -o jsonpath='{ .data.tls\.crt }')
     
     ALT_KEYFILE=$(knu get secret/${ALT_CERT_SECRET:?} -n ${ALT_NS:?} -o jsonpath='{ .data.tls\.key }')
     

2. Imposta il tipo di macchina virtuale:

   1. Recupera i nomi di tutti i tipi di macchine virtuali:

      kna get virtualmachinetypes.virtualmachine.gdc.goog -n vm-system
      

   2. Seleziona il tipo di macchine virtuali con il campo Supported come true e archivialo nella variabile di ambiente. Preferiti: n2-standard-4-gdc e n3-standard-4-gdc.

      VIRTUAL_MACHINE_TYPE=
      

3. È necessario un ProjectNetworkPolicy per la distribuzione dei log di Tenable.sc all'istanza Loki infra-obs.

   cat <<EOF | kna apply -f -
   apiVersion: networking.gdc.goog/v1
   kind: ProjectNetworkPolicy
   metadata:
     name: allow-tenablesc-system-ingress-traffic
     namespace: obs-system
   spec:
     ingress:
     - from:
       - projects:
           matchNames:
           - tenablesc-system
     policyType: Ingress
     subject:
       subjectType: UserWorkload
   EOF
   

4. Applica il grafico Helm delle VM.

   • Per l'architettura dell'organizzazione v1:

     helm upgrade --install \
       tenablesc-vms ${USERPROFILE:?}/tenable-nessus/tenablesc-vms.tgz \
       --namespace tenablesc-system  \
       --set urlSuffix=${URL_SUFFIX:?} \
       --set applicationServer.image=${TENABLESC_IMAGE_URL:?} \
       --set applicationServer.bootSize=${TENABLESC_BOOT_SIZE:?} \
       --set applicationServer.virtualMachineType=${VIRTUAL_MACHINE_TYPE:?} \
       --set syslogaudit.host=${ALT_HOSTNAME:?} \
       --set syslogaudit.port=${ALT_PORT:?} \
       --set syslogaudit.caCert=${ALT_CACERT} \
       --set syslogaudit.certFile=${ALT_CERTFILE} \
       --set syslogaudit.keyFile=${ALT_KEYFILE} \
       --kubeconfig ${ORG_ADMIN_KUBECONFIG:?}
     

   • Per l'architettura dell'organizzazione v2:

     helm upgrade --install \
       tenablesc-vms ${USERPROFILE:?}/tenable-nessus/tenablesc-vms.tgz \
       --namespace tenablesc-system  \
       --set urlSuffix=${URL_SUFFIX:?} \
       --set applicationServer.image=${TENABLESC_IMAGE_URL:?} \
       --set applicationServer.bootSize=${TENABLESC_BOOT_SIZE:?} \
       --set applicationServer.virtualMachineType=${VIRTUAL_MACHINE_TYPE:?} \
       --set syslogaudit.host=${ALT_HOSTNAME:?} \
       --set syslogaudit.port=${ALT_PORT:?} \
       --set syslogaudit.caCert=${ALT_CACERT} \
       --set syslogaudit.certFile=${ALT_CERTFILE} \
       --set syslogaudit.keyFile=${ALT_KEYFILE} \
       --kubeconfig ${ORG_MGMT_KUBECONFIG:?}
     

   Quando applichi il grafico Helm, potresti riscontrare i seguenti problemi:

   • Webhook non riuscito: connect: connection refused

     Error: Internal error occurred: failed calling webhook "mvirtualmachines.vm.cluster.gke.io": failed to call webhook: Post "https://vm-manager-webhook.gpc-system.svc:443/mutate-vm-cluster-gke-io-v1alpha1-virtualmachine?timeout=10s": dial tcp 10.1.118.145:443: connect: connection refused
     

     Correzione: esegui di nuovo il comando helm upgrade.

5. Verifica il deployment. Esamina l'output del seguente comando per verificare che il deployment di tenablesc-vm sia andato a buon fine:

   helm ls --namespace tenablesc-system --kubeconfig ${ORG_ADMIN_KUBECONFIG:?}
   

6. Attendi l'avvio di Tenablesc.

   Controlla lo stato della macchina virtuale:

   kna get virtualmachines.virtualmachine.gdc.goog -n tenablesc-system
   

   Output di esempio che indica che il provisioning della VM è ancora in corso:

   NAME            STATUS    AGE
   tenablesc-as1   Pending   55s
   

   Output di esempio che indica che la VM è in esecuzione:

   NAME            STATUS    AGE
   tenablesc-as1   Running   8m25s
   

   Se la VM non è in esecuzione dopo 60 minuti, esamina gli eventi dello spazio dei nomi per individuare eventuali errori.

   knu get -n tenablesc-system events -o wide
   

   Raccogli eventuali avvisi ed errori degni di nota e segnalali con un metabug.

7. Per accedere alla UI di Tenable.sc sono necessari un VirtualService e un DestinationRule.

   • Per l'architettura dell'organizzazione v1: Non è richiesta alcuna modifica.

   • Per l'architettura dell'organizzazione v2:

     • Imposta il nome del servizio come variabile di ambiente per un utilizzo successivo:

       TENABLE_SC_SERVICE=$(knu get service -n tenablesc-system | awk '($1 ~ /^g-svc-/) && ($0 ~ /443/) {print $1}'s)
       

     • Modifica il CR VirtualService e DestinationRule:

       knu patch virtualservice tenablesc-https-ingress-virtualsvc -n tenablesc-system --type merge --patch '{"spec": {"http": [{"route": [{"destination": {"host":"'"${TENABLE_SC_SERVICE:?}"'.tenablesc-system.svc.cluster.local"}}]}]}}'
       knu patch destinationrule tls-encrypt-tenablesc-https-ingress -n tenablesc-system --type merge --patch '{"spec":{"host":"'"${TENABLE_SC_SERVICE:?}"'.tenablesc-system.svc.cluster.local"}}'
       

8. Verifica che il DNS venga risolto in un IP.

   TENABLE_SC_HOST=$(kna get dnsregistrations.network.private.gdc.goog -n tenablesc-system tenablesc -o jsonpath='{.status.fqdn}')
   
   dig +noall +answer ${TENABLE_SC_HOST:?}
   

9. Verifica che il servizio venga risolto tramite DNS.

   Nota: se utilizzi programmi di installazione forniti autonomamente, salta questo passaggio.

   Il risultato previsto è un codice di risposta 200 e un output HTML.

   curl -kv https://${TENABLE_SC_HOST:?}
   

33.9.6. Prepara le credenziali SSH della VM Tenablesc

Segui questi passaggi per preparare SSH per l'accesso alla VM Tenable.

1. Genera una chiave SSH.

   Questa chiave SSH verrà utilizzata solo temporaneamente per accedere alla VM.

   rm /tmp/tenablesc
   ssh-keygen -t rsa -b 4096 -f /tmp/tenablesc -N ""
   

2. Imposta le seguenti variabili di ambiente.

   export VM_PUBLIC_KEY=$(cat /tmp/tenablesc.pub)
   
   export VM_NAME=tenablesc-as1
   

3. Crea un VirtualMachineRequest temporaneo (24 ore).

   VirtualMachineRequest viene utilizzato per installare il certificato SSH generato sulla VM.

   kna delete VirtualMachineAccessRequest ${VM_NAME:?}-ar -n tenablesc-system --ignore-not-found=true
   cat <<EOF | kna apply -n tenablesc-system -f -
   apiVersion: virtualmachine.gdc.goog/v1
   kind: VirtualMachineAccessRequest
   metadata:
     name: ${VM_NAME:?}-ar
   spec:
     ssh:
       key: |
         ${VM_PUBLIC_KEY:?}
       ttl: 24h
     user: alice
     vm: ${VM_NAME:?}
   EOF
   

4. Esporta l'IP SSH della VM come variabile di ambiente locale.

   INGRESS_IP=$(kna get vmexternalaccess tenablesc-as1 -n tenablesc-system -o jsonpath='{.status.ingressIP}')
   
   echo "VM SSH IP: ${INGRESS_IP:?}"
   

5. Verifica che la connessione SSH funzioni:

   ssh -i /tmp/tenablesc -o "StrictHostKeyChecking no" alice@${INGRESS_IP:?} whoami
   

   L'output previsto è alice, ovvero il nome utente SSH.

   Se la connessione SSH va in timeout, significa che la policy in entrata non è presente. Crea il criterio in entrata con il seguente comando e riprova.

6. Crea il criterio in entrata:

   kna create -f - <<EOF
   apiVersion: networking.gdc.goog/v1
   kind: ProjectNetworkPolicy
   metadata:
       name: allow-external-traffic-vm
       namespace: tenablesc-system
   spec:
       ingress:
       - from:
           - ipBlock:
               cidr: 0.0.0.0/0
       policyType: Ingress
       subject:
           subjectType: UserWorkload
   EOF
   

7. Esegui il provisioning di un pod iotools nello spazio dei nomi tenablesc-system:

   cat << EOF | knu apply -n tenablesc-system -f -
   apiVersion: v1
   kind: Pod
   metadata:
     name: iotools
     namespace: tenablesc-system
   spec:
     containers:
     - name: iotools
       image: gcr.io/private-cloud-staging/operation-tools:latest
       command: ["sleep","infinity"]
       volumeMounts:
       - name: log-volume
         mountPath: /var/log
     volumes:
     - name: log-volume
       emptyDir: {}
   EOF
   

8. Trasferisci la chiave privata al pod iotools:

9. Trasferisci la chiave privata al pod iotools:

   knu -n tenablesc-system cp /tmp/tenablesc iotools:/tmp/tenablesc
   

33.9.7. Installare i certificati del servizio web

Segui questi passaggi per installare i certificati del servizio web Tenablesc.

1. Esporta l'indirizzo IP SSH della VM come variabile di ambiente locale:

   INGRESS_IP=$(knu get virtualmachine tenablesc-as1 -n tenablesc-system -o json | jq -r '.status.network.interfaces[0].ipAddresses[0] | split("/")[0]')
   
   echo "VM SSH IP: ${INGRESS_IP:?}"
   

2. Prepara i certificati e le chiavi del server web.

   I seguenti comandi installeranno i certificati e le chiavi TLS che verranno utilizzati per pubblicare la UI di Tenable.

   1. Imposta il nome del certificato TLS

      TLS_SECRET_NAME=nessus-tls
      

   2. Salva il certificato nessus-tls localmente:

      knu get secret ${TLS_SECRET_NAME:?} -n tenable-nessus-system -o yaml > nessus-tls.yaml
      

   3. Copia il certificato nessus-tls nel pod iotools:

      knu -n tenablesc-system cp nessus-tls.yaml iotools:/tmp/nessus-tls.yaml
      

   4. Organizza il certificato TLS.

      knu get -n tenable-nessus-system secret ${TLS_SECRET_NAME:?} -o jsonpath='{ .data.tls\.crt }' | base64 -d | knu -n tenablesc-system exec -i iotools -- /bin/bash -c "ssh -i /tmp/tenablesc -o \"StrictHostKeyChecking no\" \"alice@${INGRESS_IP}\" \"cat - > ~/SecurityCenter.crt\""
      

   5. Prepara la chiave privata TLS.

      knu get -n tenable-nessus-system secret ${TLS_SECRET_NAME:?} -o jsonpath='{ .data.tls\.key }' | base64 -d | knu -n tenablesc-system exec -i iotools -- /bin/bash -c "ssh -i /tmp/tenablesc -o \"StrictHostKeyChecking no\" \"alice@${INGRESS_IP}\" \"cat - > ~/SecurityCenter.key\""
      

   6. Esegui lo staging del certificato CA TLS.

      knu get -n tenable-nessus-system secret ${TLS_SECRET_NAME:?} -o jsonpath='{ .data.ca\.crt }' | base64 -d | knu -n tenablesc-system exec -i iotools -- /bin/bash -c "ssh -i /tmp/tenablesc -o \"StrictHostKeyChecking no\" \"alice@${INGRESS_IP}\" \"cat - > ~/SecurityCenterCA.crt\""
      

3. Prepara lo script di installazione del certificato.

   Salva il seguente codice in /tmp/tenable-sc-install-web-tls.sh.

   cat >> /tmp/tenable-sc-install-web-tls.sh << EOF
   #!/bin/bash
   # Install server cert
   sudo mv ~/SecurityCenter.crt /opt/sc/support/conf/SecurityCenter.crt
   sudo mv ~/SecurityCenter.key /opt/sc/support/conf/SecurityCenter.key
   sudo chown tns:tns /opt/sc/support/conf/SecurityCenter.crt
   sudo chown tns:tns /opt/sc/support/conf/SecurityCenter.key
   sudo chmod 640 /opt/sc/support/conf/SecurityCenter.crt
   sudo chmod 640 /opt/sc/support/conf/SecurityCenter.key
   
   # Install custom CA cert
   sudo /opt/sc/support/bin/php /opt/sc/src/tools/installCA.php ~/SecurityCenterCA.crt
   
   # append root ext ca to sys log ca
   cat ~/SecurityCenterCA.crt | sudo tee -a /etc/fluent-bit/syslog-ca.crt
   
   # Restart Tenable.sc
   sudo systemctl restart SecurityCenter
   # Restart fluent-bit
   sudo systemctl restart fluent-bit
   EOF
   

4. Copia lo script nel pod iotools:

   knu -n tenablesc-system cp /tmp/tenable-sc-install-web-tls.sh iotools:/tmp/tenable-sc-install-web-tls.sh
   

5. Installa i certificati e le chiavi del server web.

   Esegui install-web-tls.sh sulla VM Tenable.sc.

   knu -n tenablesc-system exec -i iotools -- /bin/bash -c "ssh -i /tmp/tenablesc alice@${INGRESS_IP:?} 'bash -s' < /tmp/tenable-sc-install-web-tls.sh"
   

   Il servizio Tenablesc ora utilizza i certificati e le chiavi TLS appropriati.

33.9.8. Abilita l'inoltro dei log in Tenablesc

1. Segui NES-R0002 per accedere alla UI di Tenablesc.

2. Nella barra di navigazione, vai a Sistema > Configurazioni.

3. Nella pagina Configurazioni, fai clic su Varie.

4. Vai alla sezione Syslog:

   1. Attiva l'opzione Attiva inoltro.
   2. Imposta Struttura su utente.
   3. In Gravità, seleziona Seleziona tutto.

5. Fai clic su Invia per salvare la configurazione.

   33.9.9. Attivare la connettività di rete OIC a GDC

Completa i seguenti passaggi per le VM nessus1 e nessus2:

1. Imposta le seguenti variabili di ambiente:

   SITE_ID=
   OIC_DNS_SUFFIX=
   NESSUS_SUFFIX=
   GDC_SERVICES_ORG_URL_SUFFIX=$(kna get configmap dnssuffix -n gpc-system -o jsonpath='{.data.dnsSuffix}')
   

2. Pubblica le configurazioni nel piano di gestione dei servizi GDC:

   cat <<EOF | kubectl --kubeconfig ${ORG_INFRA_KUBECONFIG:?} apply -f -
   apiVersion: networking.istio.io/v1beta1
   kind: DestinationRule
   metadata:
     name: root-infra-ingress-gateway-https-dr-${SITE_ID:?}-${NESSUS_SUFFIX:?}
     namespace: istio-system
   spec:
     host: ${SITE_ID:?}-${NESSUS_SUFFIX:?}.${OIC_DNS_SUFFIX:?}
     trafficPolicy:
       portLevelSettings:
       - port:
           number: 8834
         tls:
           mode: SIMPLE
           sni: ${SITE_ID:?}-${NESSUS_SUFFIX:?}.${OIC_DNS_SUFFIX:?}
   ---
   apiVersion: networking.istio.io/v1beta1
   kind: DestinationRule
   metadata:
     name: infra-egress-gateway-nessus-dr-${SITE_ID:?}-${NESSUS_SUFFIX:?}
     namespace: istio-system
   spec:
     host: infra-egress-gateway.istio-system.svc.cluster.local
     subsets:
     - name: nessus-egress-${SITE_ID:?}-${NESSUS_SUFFIX:?}
       trafficPolicy:
         loadBalancer:
           simple: ROUND_ROBIN
         portLevelSettings:
         - port:
             number: 443
           tls:
             credentialName: nessus-tls
             mode: SIMPLE
             sni: ${SITE_ID:?}-${NESSUS_SUFFIX:?}.${OIC_DNS_SUFFIX:?}
   ---
   apiVersion: networking.istio.io/v1beta1
   kind: Gateway
   metadata:
     name: nessus-egress-gateway-${SITE_ID:?}-${NESSUS_SUFFIX:?}
     namespace: istio-system
   spec:
     selector:
       istio: infra-egress-gateway
     servers:
     - hosts:
       - ${SITE_ID:?}-${NESSUS_SUFFIX:?}.${OIC_DNS_SUFFIX:?}
       port:
         name: https-port
         number: 443
         protocol: HTTPS
       tls:
         cipherSuites:
         - ECDHE-ECDSA-AES256-GCM-SHA384
         - ECDHE-RSA-AES256-GCM-SHA384
         credentialName: nessus-tls
         mode: SIMPLE
   ---
   apiVersion: networking.istio.io/v1beta1
   kind: Gateway
   metadata:
     name: nessus-terminated-gateway-${SITE_ID:?}-${NESSUS_SUFFIX:?}
     namespace: istio-system
   spec:
     selector:
       istio: management-ingress-gateway
     servers:
     - hosts:
       - ${SITE_ID:?}-${NESSUS_SUFFIX:?}.${GDC_SERVICES_ORG_URL_SUFFIX:?}
       port:
         name: https-port
         number: 443
         protocol: HTTPS
       tls:
         cipherSuites:
         - ECDHE-ECDSA-AES256-GCM-SHA384
         - ECDHE-RSA-AES256-GCM-SHA384
         credentialName: nessus-tls
         mode: SIMPLE
   ---
   apiVersion: networking.istio.io/v1beta1
   kind: ServiceEntry
   metadata:
     name: nessus-svc-entry-${SITE_ID:?}-${NESSUS_SUFFIX:?}
     namespace: istio-system
   spec:
     hosts:
     - ${SITE_ID:?}-${NESSUS_SUFFIX:?}.${OIC_DNS_SUFFIX:?}
     location: MESH_EXTERNAL
     ports:
     - name: https-port
       number: 8834
       protocol: TLS
     resolution: DNS
   ---
   apiVersion: networking.istio.io/v1beta1
   kind: VirtualService
   metadata:
     name: nessus-admin-virtual-service-${SITE_ID:?}-${NESSUS_SUFFIX:?}
     namespace: istio-system
   spec:
     gateways:
     - istio-system/nessus-terminated-gateway-${SITE_ID:?}-${NESSUS_SUFFIX:?}
     hosts:
     - ${SITE_ID:?}-${NESSUS_SUFFIX:?}.${GDC_SERVICES_ORG_URL_SUFFIX:?}
     http:
     - rewrite:
         authority: ${SITE_ID:?}-${NESSUS_SUFFIX:?}.${OIC_DNS_SUFFIX:?}
       route:
       - destination:
           host: infra-egress-gateway.istio-system.svc.cluster.local
           port:
             number: 443
           subset: nessus-egress-${SITE_ID:?}-${NESSUS_SUFFIX:?}
   ---
   apiVersion: networking.istio.io/v1beta1
   kind: VirtualService
   metadata:
     name: nessus-egress-virtual-service-${SITE_ID:?}-${NESSUS_SUFFIX:?}
     namespace: istio-system
   spec:
     gateways:
     - istio-system/nessus-egress-gateway-${SITE_ID:?}-${NESSUS_SUFFIX:?}
     hosts:
     - ${SITE_ID:?}-${NESSUS_SUFFIX:?}.${OIC_DNS_SUFFIX:?}
     http:
     - match:
       - uri:
           prefix: /
       route:
       - destination:
           host: ${SITE_ID:?}-${NESSUS_SUFFIX:?}.${OIC_DNS_SUFFIX:?}
           port:
             number: 8834
   ---
   apiVersion: security.istio.io/v1
   kind: AuthorizationPolicy
   metadata:
     name: mgmt-infra-egress-access-${SITE_ID:?}-${NESSUS_SUFFIX:?}
     namespace: istio-system
   spec:
     rules:
     - from:
       - source:
           ipBlocks:
           - 0.0.0.0/0
       to:
       - operation:
           hosts:
           - ${SITE_ID:?}-${NESSUS_SUFFIX:?}.${GDC_SERVICES_ORG_URL_SUFFIX:?}
     selector:
       matchLabels:
         istio: management-ingress-gateway
   EOF
   

3. Pubblica le configurazioni nel control plane GDC:

   cat <<EOF | kubectl --kubeconfig ${ORG_MGMT_KUBECONFIG:?} apply -f -
   apiVersion: network.private.gdc.goog/v1alpha1
   kind: DNSRegistration
   metadata:
     name: ${SITE_ID:?}-${NESSUS_SUFFIX:?}-customer-internal
     namespace: tenablesc-system
   spec:
     fqdnPrefix: ${SITE_ID:?}-${NESSUS_SUFFIX:?}
     resolutionConfig:
       exposeToNetwork: VPC
       resolveTo:
         useDefaultIstioGateway:
           ingressLabel: admin
           owningCluster: InfraCluster
       vpcIdentifier: default
   EOF
   

33.9.10. Esegui la pulizia

Elimina la directory temporanea di Nessus.

rm -rf /tmp/nessus

33.9.11. Attivazione della licenza

Questa sezione fornisce i dettagli su come applicare la licenza Tenablesc.

1. Apri l'interfaccia utente web di Tenablesc utilizzando il seguente URL:

   TENABLE_SC_HOST=$(kna get dnsregistrations.network.private.gdc.goog -n tenablesc-system tenablesc -o jsonpath='{.status.fqdn}')
   
   echo "Navigate to https://${TENABLE_SC_HOST:?}"
   

2. Prima dell'applicazione della licenza, l'interfaccia utente mostra la procedura guidata di configurazione.

   Se l'interfaccia utente mostra una richiesta di accesso, la licenza è già stata applicata e i passaggi rimanenti di questa sezione devono essere saltati.

3. Fai clic su Avanti.

4. Carica il file della licenza Tenablesc SecurityCenter-<version>-<number>IPs-<uid>.key.

   Potenziali problemi:

   • Error Activating License File. License Is Invalid. No Valid License Found.:

     Questo errore indica che il file di licenza fornito non è valido. Esamina le seguenti possibili cause:

     1. Nome host errato

        Nella pagina del prodotto Tenabe.com per questa licenza è impostato il nome host errato. Verifica che il nome host della licenza nella pagina del prodotto Tenable.com sia tenablesc-as1. Se il nome host non corrisponde: impostalo su tenablesc-as1, scarica la nuova licenza e utilizza il nuovo file di licenza.

     2. File non valido

        Il file di licenza potrebbe essere stato modificato durante il trasferimento: in modo simile al file di preattivazione di Nessus, questo file di licenza non può essere modificato durante il trasferimento. Il file esatto scaricato dalla pagina del prodotto Tenable.com deve essere caricato nell'interfaccia utente di Tenable. Puoi verificare se il file è stato modificato confrontando l'SHA del file prima e dopo il trasferimento.

     3. File di licenza errato

        Assicurati di utilizzare un file di licenza Tenable.sc ottenuto dalla pagina del prodotto Tenable.com. Il contenuto del file deve essere simile a una chiave PEM.

     Se la licenza continua a non funzionare, apri un metabug con il team VULN e includi tutti i passaggi per la risoluzione dei problemi tentati finora.

5. Aggiorna la pagina. Se viene visualizzata una schermata di accesso, la licenza è stata applicata correttamente.

Tenablesc è ora completamente avviato. Ulteriori passaggi per configurare e utilizzare Tenablesc sono disponibili nel manuale dell'operatore, che devono essere completati in un secondo momento dopo il bootstrap.

33.9.12. (Facoltativo) Disinstalla

Questa sezione contiene i comandi per rimuovere il deployment di Tenable.sc.

Avviso: la disinstallazione dei grafici Helm di Tenable.sc rimuove tutti i volumi permanenti ed elimina i dati dell'applicazione.

Segui questi passaggi per disinstallare i grafici Helm dai cluster:

1. Disinstalla il grafico Helm dal cluster di infrastruttura dell'organizzazione:

   helm uninstall --namespace tenablesc-system tenablesc-system --kubeconfig ${ORG_INFRA_KUBECONFIG:?}
   

2. Disinstalla il grafico Helm dal server API di gestione:

   helm uninstall --namespace tenablesc-system tenablesc-admin --kubeconfig ${ORG_MGMT_KUBECONFIG:?}
   

3. Disinstalla il grafico Helm per la VM Tenable SC dal server API di gestione:

   VIRTUAL_MACHINE_NAME=$(knu get virtualmachine -n tenablesc-system -o custom-columns=NAME:.metadata.name | sort -r -k 1 | head -1)
   kna patch virtualmachines.virtualmachine.gdc.goog ${VIRTUAL_MACHINE_NAME:?} -n tenablesc-system --type merge --patch '{"spec":{"runningState":"Stopped"}}'
   helm uninstall tenablesc-vms -n tenablesc-system --kubeconfig ${ORG_MGMT_KUBECONFIG:?}
   

33.9.13. Configurazione di Tenable.SC

Segui NES-G0001 - set up Tenable.SC per configurare Tenable.sc.

33.10. Convalida il deployment di Nessus

Questa sezione descrive in dettaglio i passaggi per verificare che i gestori e gli agenti Nessus siano in esecuzione e collegati tra loro come previsto e fornisce i passaggi per risolvere potenziali problemi noti.

Questa sezione deve essere eseguita alla fine dell'installazione, ma è anche consigliabile eseguire questi passaggi di convalida prima di eseguire le scansioni. La procedura per eseguire le scansioni è descritta nel manuale dell'operatore.

Prima di iniziare, segui la procedura descritta in Impostare le variabili di ambiente per configurare l'accesso al cluster di amministrazione principale e definire l'alias della riga di comando kra.

33.10.1. Convalida del clustering

Il modo principale per verificare che Nessus Manager e gli agenti siano collegati è tramite l'interfaccia utente di Nessus Manager principale. Nell'interfaccia utente, gli elementi secondari di Nessus devono essere elencati nel gruppo di cluster predefinito del clustering degli agenti e tutti gli agenti Nessus devono essere elencati nel gruppo di agenti predefinito.

Nota :il collegamento tra Nessus Manager principale e tutti i secondari viene interrotto se Nessus Manager principale viene riavviato dopo l'installazione iniziale. Ciò potrebbe accadere come conseguenza naturale del deployment su Kubernetes.

1. Ottieni il DNS per l'interfaccia utente principale di Nessus Manager:

   echo Nessus Manager UI: https://$(kra get dnsregistration \
       -n tenable-nessus-system nessus -o jsonpath='{.status.fqdn}')
   

2. Apri un browser internet e vai al link dei passaggi precedenti. Viene visualizzata l'interfaccia utente principale di Nessus Manager.

3. Accedi alla UI di Nessus Manager con il nome utente admin e la password predefinita admin.

   In caso di problemi di autenticazione durante l'accesso, segui la procedura NES-T0004 per ruotare le credenziali Nessus e riprovare ad accedere.

4. Fai clic su Impostazioni nella parte superiore della pagina.

   Nella pagina Impostazioni, rivedi le informazioni sui plug-in. Se il valore di Plugin Set non è definito, segui NES-T0001 per riapplicare l'ultimo set di plugin a Nessus Manager principale.

5. Fai clic su Sensori nella parte superiore della pagina, poi su Clustering agenti.

6. Fai clic su Default Agent Group per visualizzare tutti i nodi registrati.

   Se il gruppo è vuoto o il nodo (istanza Nessus secondaria) per qualsiasi organizzazione è mancante, l'istanza Nessus secondaria deve essere registrata di nuovo.

Nota: possono verificarsi casi in cui gli agenti Nessus di un'organizzazione vengono collegati a un Nessus Manager secondario di un'altra organizzazione a causa della distribuzione da parte di un nodo principale ai nodi secondari raggiungibili dagli agenti.