33. Implementa componentes de Nessus

Tiempo estimado para completar la actividad: 1 día

Propietario del componente operable: VULN

Perfil de habilidad: ingeniero de Deployment

Última actualización: 18 de agosto de 2025

Nessus es un analizador de seguridad para los sistemas de asistencia y operación de Google Distributed Cloud (GDC) aislado. Ayuda al equipo del centro de operaciones a supervisar y responder a las vulnerabilidades de seguridad en el hardware y el software.

En este documento, se presentan los pasos para implementar Nessus y se supone que el operador que lo sigue realiza los pasos desde una estación de trabajo de OC con PowerShell y WSL disponibles.

33.1. Antes de comenzar

• Se requiere acceso

  • Sigue IAM-R0005:
    • Obtén el rol de clúster clusterrole/tenable-nessus-admin-root en el clúster de administrador raíz.
    • Obtén el rol role/system-artifact-management-admin en el espacio de nombres gpc-system del clúster de administrador raíz.

• Herramientas necesarias

  • kubectl
  • gdcloud
  • helm
  • yq
  • docker

• Licencias

  • Una licencia de Nessus
    • Sigue NES-G0004: Cómo realizar la preactivación de la licencia de Nessus para preparar el paquete de preactivación "GDCH 1".

Nota: Es posible que gdcloud no se resuelva de forma predeterminada. De lo contrario, corrige la ruta con PATH=/root/release:${PATH:?} y vuelve a intentarlo.

33.1.1. Prácticas recomendadas

33.1.1.1. Actualizaciones

Para las actualizaciones desde versiones anteriores a la 1.14, sigue la opción "Opcional: Desinstalar" de cada sección principal de esta guía antes de realizar cualquier instalación.

En caso de reinstalaciones, sigue la parte "Opcional: Desinstalación" de cada sección principal de esta guía.

33.1.1.2. Cómo controlar la desviación de versiones entre organizaciones y zonas

No debería haber problemas debido a la desviación de versiones entre organizaciones y zonas. Sigue los pasos específicos de la organización teniendo en cuenta la versión de la organización. Luego, cada implementación será independiente por zona.

33.1.2. Licencia de Tenablesc

Tenable.sc es un software de terceros con licencia que requiere un archivo de licencia para funcionar. Antes de continuar, se debe obtener una licencia de Tenable según la SBOM. En casos especiales, es posible que podamos proporcionar una licencia.

El archivo de licencia debe tener un nombre como SecurityCenter-<version>-1000IPs-<uid>.key. Ubica este archivo y toma nota de él para más adelante, ya que deberás subirlo directamente a la IU de Tenablesc.

Requisitos:

• Un archivo de licencia de Tenablesc con un límite de al menos 1,000 IPs y el nombre de host tenablesc-as1

33.2. Ubica los archivos de implementación de Nessus

Antes de implementar Nessus, sigue estos pasos con Windows PowerShell para ubicar los archivos de instalación de Nessus:

1. Accede a los gráficos de Helm de Nessus y a la imagen de la máquina virtual (VM):

   Dentro del OC, se puede acceder a estos elementos en \\<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. Mueve estos archivos a tu estación de trabajo local para usarlos más adelante:

   # 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. Ubica el paquete de preactivación de Nessus

Importante: Este paso no es obligatorio para las actualizaciones.

El paquete de preactivación de Nessus es específico para cada instalación de Nessus y, por lo tanto, no se puede incluir en el paquete del centro de operaciones. Sigue la guía de Nessus NES-G0004: Cómo realizar la preactivación de la licencia de Nessus para preparar el paquete de preactivación "GDCH 1" antes de continuar.

1. En una máquina conectada a Internet, obtén nessus-preact-gdch1.tar.gz por tu cuenta o a través de un PDC de Ingeniería de Google.

2. Transfiere este archivo a tu estación de trabajo y colócalo en $env:USERPROFILE\tenable-nessus.

3. El directorio $env:USERPROFILE\tenable-nessus debe contener el paquete de preactivación:

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

33.4. Cómo abrir WSL

En los pasos restantes de la página, se requiere WSL para todos los comandos, a menos que se indique lo contrario.

1. Opcional: Se requiere sudo. Si no conoces la contraseña del usuario sudo, ejecuta el siguiente comando para establecer la contraseña de oc-it del usuario sudo de WSL:

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

33.5. Configure las variables de entorno

Sigue estos pasos para establecer las variables de entorno requeridas:

1. Define la variable de entorno ROOT_ADMIN_CLUSTER_KUBECONFIG para usarla más adelante en la terminal actual. Debe ser una ruta absoluta al kubeconfig del clúster de administrador generado como requisito previo:

   ROOT_ADMIN_CLUSTER_KUBECONFIG=
   

2. Define un alias para el comando kubectl del clúster de administrador seleccionado en la terminal actual:

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

3. Configura la variable USERPROFILE:

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

   $USERPROFILE ahora apunta a la misma ubicación que $env:USERPROFILE.

33.5.1. Configura variables de entorno para la organización de la versión 1

1. Define la variable de entorno ORG_ADMIN_KUBECONFIG para usarla más adelante en la terminal actual. Debe ser una ruta de acceso absoluta al kubeconfig del clúster de administrador de la organización seleccionado que se generó como requisito previo:

   ORG_ADMIN_KUBECONFIG=
   

2. Define un alias para el comando kubectl del clúster de administrador de la organización seleccionado en la terminal actual:

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

3. Define la variable de entorno ORG_SYSTEM_KUBECONFIG para usarla más adelante en la terminal actual. Debe ser una ruta de acceso absoluta al kubeconfig del clúster del sistema seleccionado que se generó como requisito previo:

   ORG_SYSTEM_KUBECONFIG=
   

4. Define un alias para el comando kubectl del clúster del sistema seleccionado en la terminal actual:

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

33.5.2. Configura variables de entorno para la organización de la versión 2

1. Define la variable de entorno ORG_MGMT_KUBECONFIG para usarla más adelante en la terminal actual. Debe ser una ruta absoluta al archivo kubeconfig del servidor de la API del plano de administración de la organización de la versión 2 seleccionada que se generó como requisito previo:

   ORG_MGMT_KUBECONFIG=
   

2. Define un alias para el comando kubectl del clúster de administrador de la organización seleccionado en la terminal actual:

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

3. Define la variable de entorno ORG_INFRA_KUBECONFIG para usarla más adelante en la terminal actual. Debe ser una ruta absoluta al kubeconfig del servidor de la API del plano de control de la organización de la versión 2 seleccionada que se generó como requisito previo:

   ORG_INFRA_KUBECONFIG=
   

4. Define un alias para el comando kubectl del clúster del sistema seleccionado en la terminal actual:

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

33.6. Sube el paquete de preactivación

Importante: Este paso no es obligatorio para las actualizaciones.

Sigue los pasos que se indican a continuación para subir el registro de artefactos de Harbor.

1. Convierte el paquete al formato OCI con los metadatos adecuados:

   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. Instala el certificado de CA de 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"
   

   Para encontrar el sistema operativo, haz lo siguiente:

   sudo sh -c "hostnamectl"
   

   Para Rocky Linux como sistema operativo, ejecuta lo siguiente:

   sudo update-ca-trust extract
   

   Si usas Ubuntu como sistema operativo, ejecuta el siguiente comando:

   sudo update-ca-certificates
   

3. Sube el paquete de preactivación a Harbor:

   • Método ideal: Autentícate con 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
     

   • Método de copia de seguridad: Se usa 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. Instala Nessus

Advertencia: Para las actualizaciones desde versiones anteriores a la 1.14, sigue la sección "Opcional: Desinstalar" antes de continuar con la instalación.

1. Activa la instalación de 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. Espera alrededor de 1.5 horas para que finalice la instalación.

33.7.1. Opcional: Desinstala Nessus

En esta sección, se incluyen los comandos para quitar la implementación de Nessus de todos los clústeres requeridos.

Advertencia: Desinstala tu implementación existente de Nessus solo si vas a reinstalar o actualizar el software. De lo contrario, omite esta sección.

1. Desinstala Nessus del clúster de administrador raíz:

   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. Para la arquitectura de la organización v1:

   1. Desinstala Nessus del clúster de administrador de la organización:

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

   2. Desinstala Nessus del clúster del sistema de la organización:

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

3. Para la arquitectura de la organización v2:

   1. Desinstala Nessus del clúster de administración de la organización:

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

   2. Desinstala Nessus del clúster de infraestructura de la organización:

      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. Verifica Nessus en el clúster de administrador raíz

1. Verifica que se hayan publicado las claves y los certificados:

   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 que el Nessus Manager principal esté en buen estado:

   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. Si se informa que el Nessus Manager principal no está en buen estado, por ejemplo, si el resultado de cualquiera de los comandos anteriores es falso, reinicia el Nessus Manager principal con los siguientes comandos:

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

4. Espera alrededor de 1.5 horas y, luego, vuelve a verificar el estado.

5. Si el Nessus Manager principal sigue apareciendo como no saludable después de 1.5 horas, deriva el problema al equipo de guardia.

   1. Incluye la siguiente información después de ejecutar la consulta proporcionada desde la IU de Grafana:

      {pod="<pod_name>"}
      

   2. Incluye la configuración del Nessus Manager principal:

      kra get pnm -A -o yaml
      

6. Verifica que el Nessus Manager secundario esté en buen estado:

   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. Si se informa que el Nessus Manager secundario no está en buen estado, reinícialo con los siguientes comandos, espera 20 minutos y, luego, vuelve a verificar el estado:

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

8. Si, después de 20 minutos, el administrador de Nessus secundario sigue apareciendo como no apto, deriva el problema y, después de ejecutar la consulta proporcionada desde la IU de Grafana, incluye la siguiente información.

   1. Incluye la siguiente información después de ejecutar la consulta proporcionada desde la IU de Grafana:

      {pod="<pod_name>"}
      

   2. Incluye la configuración del Nessus Manager secundario:

      kra get cnm -A -o yaml
      

9. Verifica que no haya agentes en mal estado:

   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. Para todos los agentes que aparecen en la lista de agentes en mal estado, configura la variable NESSUS_AGENT_NAME y ejecuta el siguiente comando para todos:

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

11. Si después de 20 minutos los agentes en mal estado siguen apareciendo en la lista, haz lo siguiente para cada agente:

    • Verifica los registros del pod install-<node_name> en Grafana y, si hay un registro de error ansible-playbook error: one or more host failed, establece una conexión SSH con el nodo de metal desnudo usando PLATAUTH-G0001.

    • Después de establecer una conexión SSH con el nodo de metal desnudo, mueve /etc/yum.repos.d a /etc/ yum.repos.d.back (para borrar de forma efectiva la configuración de los repositorios de yum).

12. Si, después de 20 minutos, los agentes en mal estado siguen apareciendo en la lista, deriva el problema y, después de ejecutar la consulta proporcionada desde la IU de Grafana, incluye la siguiente información.

    1. Incluye la siguiente información después de ejecutar la consulta proporcionada desde la IU de Grafana.

       {pod="<pod_name>"}
       

    2. Incluye el estado del agente de Nessus:

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

    3. Incluye la configuración del agente de Nessus:

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

33.8. Nessus Manager: Verificación de la organización

En esta sección, se describen los pasos necesarios para verificar Nessus en una organización de Distributed Cloud.

Para garantizar una verificación de Nessus exitosa y completa, ejecuta este procedimiento para cada clúster de organización de Distributed Cloud, incluido el clúster de organización de TI del Centro de operaciones.

Enumera las organizaciones disponibles:

kra get -n gpc-system organization

Sigue los pasos que se indican a continuación para cada organización, excepto la organización root, que ya se abordó.

33.8.1. Requisitos previos

• Acceso requerido para las organizaciones de la versión 1

  • Sigue IAM-R0005:
    • Obtén el rol de clúster clusterrole/tenable-nessus-admin-root en el clúster de administrador raíz.

  • Sigue IAM-R0004:

    • Genera el archivo KUBECONFIG para el clúster de administrador raíz.

  • Sigue IAM-R0005:

    • Obtén el rol de clúster clusterrole/tenable-nessus-admin-org-legacy en el clúster de administrador de la organización de destino.

  • Sigue IAM-R0004:

    • Genera el archivo KUBECONFIG para el clúster de administrador de la organización de destino.

  • Sigue IAM-R0005:

    • Obtén el rol de clúster clusterrole/tenable-nessus-admin-system-legacy en el clúster del sistema de destino.

  • Sigue IAM-R0004:

    • Genera el archivo KUBECONFIG para el clúster del sistema de destino.

• Acceso requerido para las organizaciones de la versión 2

  • Sigue IAM-R0005:
    • Obtén el rol de clúster clusterrole/tenable-nessus-admin-root en el clúster de administrador raíz.
  • Sigue IAM-R0004:
    • Genera el archivo KUBECONFIG para el clúster de administrador raíz.
  • Sigue IAM-R0005:
    • Obtén el rol de clúster clusterrole/tenable-nessus-admin-infra-mp en el clúster de destino.
  • Sigue IAM-R0004:
    • Genera el archivo KUBECONFIG de mp para el clúster de infraestructura de destino.
  • Sigue IAM-R0005:
    • Obtén el rol de clúster clusterrole/tenable-nessus-admin-infra-cp en el servidor de la API de kube del plano de control de la infraestructura de destino.
  • Sigue IAM-R0004:
    • Genera el archivo KUBECONFIG de cp para el clúster de infraestructura.

Sigue los pasos de Configura variables de entorno para configurar el acceso a los clústeres de la organización y definir los alias de línea de comandos kna y knu.

33.8.2. Verifica Nessus en el clúster de administrador de la organización en organizaciones de la versión 1 y el servidor de la API de kube del plano de administración de la infraestructura en organizaciones de la versión 2.

1. Verifica que no haya agentes en mal estado:

   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. Para todos los agentes que aparecen en la lista de agentes en mal estado, configura la variable NESSUS_AGENT_NAME y ejecuta el siguiente comando para todos:

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

3. Si después de 20 minutos los agentes en mal estado siguen apareciendo en la lista, haz lo siguiente para cada agente:

   • Verifica los registros del pod install-<node_name> en Grafana y, si hay un registro de error ansible-playbook error: one or more host failed, establece una conexión SSH con el nodo de metal desnudo usando PLATAUTH-G0001.

   • Después de establecer una conexión SSH con el nodo de metal desnudo, mueve /etc/yum.repos.d a /etc/ yum.repos.d.back (para borrar de forma efectiva la configuración de los repositorios de yum).

4. Si, después de 20 minutos, los agentes en mal estado siguen apareciendo en la lista, deriva el problema y, después de ejecutar la consulta proporcionada desde la IU de Grafana, incluye la siguiente información.

   {pod="<pod_name>"}
   

33.8.3. Verifica Nessus en el clúster del sistema en organizaciones de la versión 1 y el servidor de la API de kube del plano de control de la infraestructura en organizaciones de la versión 2

1. Verifica que el Nessus Manager secundario esté en buen estado:

   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. Si se informa que el Nessus Manager secundario no está en buen estado, reinícialo con los siguientes comandos, espera 20 minutos y, luego, vuelve a verificar el estado:

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

3. Si, después de 20 minutos, el administrador de Nessus secundario sigue apareciendo como no apto, deriva el problema y, después de ejecutar la consulta proporcionada desde la IU de Grafana, incluye la siguiente información.

   1. Incluye la siguiente información después de ejecutar la consulta proporcionada desde la IU de Grafana.

      {pod="<pod_name>"}
      

   2. Incluye la configuración del Nessus Manager secundario.

      knu get cnm -A -o yaml
      

4. Verifica que no haya agentes en mal estado:

   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. Para todos los agentes que aparecen en la lista de agentes en mal estado, configura la variable NESSUS_AGENT_NAME y ejecuta el siguiente comando para todos:

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

6. Si después de 20 minutos los agentes en mal estado siguen apareciendo en la lista, haz lo siguiente para cada agente:

   • Verifica los registros del pod install-<node_name> en Grafana y, si hay un registro de error ansible-playbook error: one or more host failed, establece una conexión SSH con el nodo de metal desnudo usando PLATAUTH-G0001.

   • Después de establecer una conexión SSH con el nodo de metal desnudo, mueve /etc/yum.repos.d a /etc/ yum.repos.d.back (para borrar de forma efectiva la configuración de los repositorios de yum).

7. Si, después de 20 minutos, los agentes en mal estado siguen apareciendo en la lista, deriva el problema y, después de ejecutar la consulta proporcionada desde la IU de Grafana, incluye la siguiente información.

   1. Incluye la siguiente información después de ejecutar la consulta proporcionada desde la IU de Grafana:

      {pod="<pod_name>"}
      

   2. Incluye el estado del agente de Nessus:

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

   3. Incluye la configuración del agente de Nessus:

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

33.9. Instala Tenable.sc

En esta sección, se incluyen los pasos para instalar o actualizar una VM existente de Tenable.sc dentro de la organización de TI del Centro de operaciones.

33.9.1. Requisitos previos

• Se requiere acceso

  • Para la arquitectura de la organización v1:
    • Sigue IAM-R0005:
      • Obtén el rol de clúster clusterrole/tenable-nessus-admin-root en el clúster de administrador raíz.
    • Sigue IAM-R0004:
      • Genera el archivo KUBECONFIG para el clúster de administrador raíz.
    • Sigue IAM-R0005:
      • Obtén el rol de clúster clusterrole/tenable-nessus-admin-org-legacy en el clúster de administrador de gdchservices.
    • Sigue IAM-R0004:
      • Genera el archivo KUBECONFIG para el clúster de administrador de gdchservices.
    • Sigue IAM-R0005:
      • Obtén el rol de clúster clusterrole/tenable-nessus-admin-system-legacy en el clúster del sistema gdchservices.
    • Sigue IAM-R0004:
      • Genera el archivo KUBECONFIG para el clúster del sistema gdchservices.
  • Para la arquitectura de la organización v2:
    • Sigue IAM-R0005:
      • Obtén el rol de clúster clusterrole/tenable-nessus-admin-root en el clúster de administrador raíz.
    • Sigue IAM-R0004:
      • Genera el archivo KUBECONFIG para el clúster de administrador raíz.
    • Sigue IAM-R0005:
      • Obtén el rol de clúster clusterrole/tenable-nessus-admin-infra-mp en el clúster gdchservices-management.
    • Sigue IAM-R0004:
      • Genera el archivo KUBECONFIG para el clúster gdchservices-management.
    • Sigue IAM-R0005:
      • Obtén el rol de clúster clusterrole/tenable-nessus-admin-infra-cp en el clúster gdchservices-infra.
    • Sigue IAM-R0004:
      • Genera el archivo KUBECONFIG para el clúster gdchservices-infra.

33.9.2. Configure las variables de entorno

Sigue estos pasos para establecer las variables de entorno requeridas:

1. Define la variable de entorno ROOT_ADMIN_CLUSTER_KUBECONFIG para usarla más adelante en la terminal actual. Debe ser una ruta absoluta al kubeconfig del clúster de administrador generado como requisito previo:

   ROOT_ADMIN_CLUSTER_KUBECONFIG=
   

2. Define un alias para el comando kubectl del clúster de administrador raíz en la terminal actual:

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

3. Define la variable de entorno para el kubeconfig del plano de administración de la organización de gdchservices:

   • Para la arquitectura de la organización v1: Define la variable de entorno ORG_ADMIN_KUBECONFIG para usarla más adelante en la terminal actual. Debe ser una ruta de acceso absoluta al archivo kubeconfig del clúster de administrador de gdchservices generado como requisito previo:

     ORG_ADMIN_KUBECONFIG=
     

   • Para la arquitectura de la organización v2: Define la variable de entorno ORG_MGMT_KUBECONFIG para usarla más adelante en la terminal actual. Esta debe ser una ruta de acceso absoluta al kubeconfig del clúster de administración de gdchservices que se generó como requisito previo:

     ORG_MGMT_KUBECONFIG=
     

4. Crea un alias para el comando kubectl con el kubeconfig anterior:

   • Para la arquitectura de la organización v1: Define un alias para el comando kubectl del clúster de administrador de gdchservices en la terminal actual:

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

   • Para la arquitectura de la organización v2: Define un alias para el comando kubectl del clúster de administrador de gdchservices en la terminal actual:

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

5. Define la variable de entorno para el kubeconfig del plano de control de la organización de gdchservices:

   • Para la arquitectura de la organización v1: Define la variable de entorno ORG_SYSTEM_KUBECONFIG para usarla más adelante en la terminal actual. Esta debe ser una ruta de acceso absoluta al archivo kubeconfig del clúster del sistema de gdchservices que se generó como requisito previo:

     ORG_SYSTEM_KUBECONFIG=
     

   • Para la arquitectura de la organización v2: Define la variable de entorno ORG_INFRA_KUBECONFIG para usarla más adelante en la terminal actual. Esta debe ser una ruta de acceso absoluta al archivo kubeconfig del clúster de infraestructura de gdchservices que se generó como requisito previo:

     ORG_INFRA_KUBECONFIG=
     

6. Crea un alias para el comando kubectl con el kubeconfig anterior:

   • Para la arquitectura de la organización v1: Define un alias para el comando kubectl del clúster del sistema gdchservices en la terminal actual:

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

   • Para la arquitectura de la organización v2: Define un alias para el comando kubectl del clúster de infraestructura de gdchservices en la terminal actual:

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

7. Configura la variable USERPROFILE:

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

   $USERPROFILE ahora apunta a la misma ubicación que $env:USERPROFILE.

8. Define el nombre de la organización en la que se implementa Tenable.sc:

   ORG=gdchservices
   

33.9.3. Prepararse para la instalación

Sigue estos pasos para preparar la organización.

1. Crea el proyecto 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. Después de dos minutos, verifica que los espacios de nombres existan en los clústeres del administrador de la organización y del sistema.

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

   Ten en cuenta que la etiqueta del proyecto resourcemanager.gdc.goog/attach-all-user-clusters: "true" hace que el espacio de nombres también se cree en todos los clústeres de usuario de la organización.

3. Genera y guarda las credenciales de usuario de administrador y administrador de Tenablesc como un secreto de 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. Instala el gráfico de administrador

1. Establece las siguientes variables de entorno para preparar la instalación:

   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. Aplica el gráfico de Helm del administrador.

   • Para la arquitectura de la organización 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:?}
     

   • Para la arquitectura de la organización v2:

     Establece OCIT_NESSUS_MANAGER_PREFIXES como una lista separada por comas, como "{dc1-nessus1,dc1-nessus2}", que indica el prefijo de la VM de OCIT.

     Establece OCIT_NESSUS_URL_SUFFIX, que indica el sufijo de la VM de OCIT.

     Aplica actualizaciones de Helm para el plano de administración:

     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:?}
     

     Aplica las actualizaciones de Helm para el plano de infraestructura:

     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:?}
     

     Aplica la política de autorización de 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 la entrada de servicio:

     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 el registro de 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
     

     Almacena el FQDN en una variable de entorno después de esperar cinco minutos:

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

     Aplica un parche al servicio virtual y a la puerta de enlace para agregar el FQDN interno de 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:?}"'"}]'
     

     Aplica un parche al recurso de verificador para sondear el extremo correcto:

     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 la implementación.

   Revisa el resultado del siguiente comando para confirmar que la implementación de tenablesc-admin se realizó correctamente:

   • Para la arquitectura de la organización v1:

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

   • Para la arquitectura de la organización v2:

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

4. Verifica que exista el servicio virtual.

   • Para la arquitectura de la organización v1:

     kna get virtualservice -n tenablesc-system
     

   • Para la arquitectura de la organización v2:

     knu get virtualservice -n tenablesc-system
     

5. Verifica que la entrada DNS exista.

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

6. Verifica que AuditLoggingTarget esté listo, lo que debería tardar varios minutos.

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

   • Es posible que se produzca el siguiente error:

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

     Si es así, se debe crear el espacio de nombres tenablesc-system en el clúster especificado. Para continuar, crea el espacio de nombres y, luego, abre un error de nivel superior para iniciar una investigación sobre el motivo de este error. Incluye el resultado de la descripción del proyecto tenablesc-system en el ticket.

     kna describe project tenablesc-system
     

   • Es posible que se produzca el siguiente error:

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

     Si es así, crea el AuditLoggingTarget faltante de forma manual:

     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
     

     Después de cinco minutos, se espera que el resultado sea similar al siguiente:

     {
         "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
     }
     

     Después de 10 minutos, si el resultado del estado sigue pareciendo incorrecto, es posible que la plataforma de Observabilidad no esté en buen estado. Abre un error principal con la información de estado disponible para ayudar con la depuración.

33.9.5. Gráfico de VMs instaladas

1. Establece las siguientes variables de entorno para preparar la instalación:

   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
   

   • Para la arquitectura de la organización 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 }')
     

   • Para la arquitectura de la organización 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. Establece el tipo de máquina virtual:

   1. Obtén los nombres de todos los tipos de máquinas virtuales:

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

   2. Selecciona el tipo de máquinas virtuales con el campo Supported como true y almacénalo en la variable de entorno. Preferidos: n2-standard-4-gdc y n3-standard-4-gdc.

      VIRTUAL_MACHINE_TYPE=
      

3. Se requiere un ProjectNetworkPolicy para que los registros de Tenable.sc se entreguen a la instancia de infra-obs Loki.

   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. Aplica el gráfico de Helm de las VMs.

   • Para la arquitectura de la organización 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:?}
     

   • Para la arquitectura de la organización 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:?}
     

   Cuando apliques el gráfico de Helm, es posible que surjan los siguientes problemas:

   • Error en el webhook: 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
     

     Solución: Vuelve a ejecutar el comando helm upgrade.

5. Verifica la implementación. Revisa el resultado del siguiente comando para confirmar que la implementación de tenablesc-vm se realizó correctamente:

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

6. Espera a que Tenablesc comience a ejecutarse.

   Verifica el estado de la máquina virtual:

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

   Ejemplo de resultado que indica que la VM aún se está aprovisionando:

   NAME            STATUS    AGE
   tenablesc-as1   Pending   55s
   

   Ejemplo de resultado que indica que la VM se está ejecutando:

   NAME            STATUS    AGE
   tenablesc-as1   Running   8m25s
   

   Si la VM no se ejecuta después de 60 minutos, revisa los eventos del espacio de nombres para detectar errores destacados.

   knu get -n tenablesc-system events -o wide
   

   Recopila las advertencias y los errores notables, y regístralos con un metabug.

7. Se requiere un VirtualService y un DestinationRule para acceder a la IU de Tenable.sc.

   • Para la arquitectura de la organización v1: No se requiere ningún cambio.

   • Para la arquitectura de la organización v2:

     • Configura el nombre del servicio como una variable de entorno para usarla más adelante:

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

     • Edita la CR de VirtualService y 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 que el DNS se resuelva en una 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 que el servicio se resuelva a través del DNS.

   Nota: Si usas instaladores proporcionados por ti mismo, omite este paso.

   El resultado esperado es un código de respuesta 200 y un resultado en HTML.

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

33.9.6. Prepara las credenciales SSH de la VM de Tenablesc

Sigue estos pasos para preparar SSH y acceder a la VM de Tenable.

1. Genera una clave SSH.

   Esta clave SSH solo se usará de forma temporal para acceder a la VM.

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

2. Configura las siguientes variables de entorno:

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

3. Crea un VirtualMachineRequest temporal (24 h).

   VirtualMachineRequest se usa para instalar el certificado SSH generado en la 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. Exporta la IP de SSH de la VM como una variable de entorno local.

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

5. Prueba que la conexión SSH funcione:

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

   El resultado esperado es alice, que es el nombre de usuario de SSH.

   Si se agota el tiempo de espera de la conexión SSH, significa que falta la política de entrada. Crea la política de entrada con el siguiente comando y vuelve a intentarlo.

6. Crea la política de entrada:

   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. Aprovisiona un Pod de iotools en el espacio de nombres 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. Transfiere la clave privada al pod iotools:

9. Transfiere la clave privada al pod iotools:

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

33.9.7. Instala certificados de servicio web

Sigue estos pasos para instalar los certificados del servicio web de Tenablesc.

1. Exporta la dirección IP de SSH de la VM como una variable de entorno local:

   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 los certificados y las claves del servidor web.

   Los siguientes comandos instalarán los certificados y las claves de TLS que se usarán para entregar la IU de Tenable.

   1. Cómo configurar el nombre del certificado TLS

      TLS_SECRET_NAME=nessus-tls
      

   2. Guarda el certificado nessus-tls de forma local:

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

   3. Copia el certificado nessus-tls en el pod iotools:

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

   4. Prepara el certificado 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 clave privada de 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. Prepara el certificado de CA de 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 la secuencia de comandos de instalación del certificado.

   Guarda el siguiente código en /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 el script en el pod iotools:

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

5. Instala los certificados y las claves del servidor web.

   Ejecuta install-web-tls.sh en la VM de 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"
   

   El servicio Tenablesc ahora usa los certificados y las claves de TLS adecuados.

33.9.8. Habilita el reenvío de registros en Tenable.sc

1. Sigue NES-R0002 para acceder a la IU de Tenablesc.

2. En la barra de navegación, ve a System > Configurations.

3. En la página Configuraciones, haz clic en Varios.

4. Ve a la sección Syslog:

   1. Activa Habilitar el reenvío.
   2. Establece la Instalación en usuario.
   3. En Gravedad, selecciona Seleccionar todo.

5. Haz clic en Enviar para guardar la configuración.

   33.9.9. Habilita la conectividad de red de OIC a GDC

Completa los siguientes pasos para las VMs nessus1 y nessus2:

1. Configura las siguientes variables de entorno:

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

2. Publica las configuraciones en el plano de administración de servicios de 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. Publica las configuraciones en el plano de control de 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. Limpia

Borra el directorio temporal de Nessus.

rm -rf /tmp/nessus

33.9.11. Activación de licencias

En esta sección, se proporcionan detalles sobre cómo aplicar la licencia de Tenablesc.

1. Abre la IU web de Tenablesc con la siguiente 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. Antes de que se aplique la licencia, la IU muestra el asistente de configuración.

   Si la IU muestra un mensaje de acceso, significa que ya se aplicó la licencia y se deben omitir los pasos restantes de esta sección.

3. Haz clic en Siguiente.

4. Sube el archivo de licencia de Tenablesc SecurityCenter-<version>-<number>IPs-<uid>.key.

   Posibles problemas:

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

     Este error significa que el archivo de licencia proporcionado no es válido. Analiza las siguientes posibles causas:

     1. Nombre de host incorrecto

        El nombre de host incorrecto está configurado en la página del producto de Tenabe.com para esta licencia. Verifica que el nombre de host de la licencia en la página del producto de Tenable.com sea tenablesc-as1. Si el nombre de host no coincide, configúralo como tenablesc-as1, descarga la nueva licencia y usa el nuevo archivo de licencia.

     2. Archivo con errores de formato

        Es posible que el archivo de licencia se haya modificado durante la transferencia: Al igual que el archivo de preactivación de Nessus, este archivo de licencia no se puede modificar durante la transferencia. El archivo exacto que se descargó de la página de productos de Tenable.com se debe subir a la IU de Tenable. Puedes verificar si se modificó el archivo comparando el SHA del archivo antes y después de la transferencia.

     3. El archivo de licencia es incorrecto

        Asegúrate de usar un archivo de licencia Tenable.sc que se haya obtenido de la página de productos de Tenable.com. El contenido del archivo debe ser similar a una clave PEM.

     Si la licencia sigue sin funcionar, abre un metabug con el equipo de VULN y agrega los pasos para solucionar problemas que intentaste hasta el momento.

5. Actualiza la página. Si aparece una pantalla de acceso, significa que la licencia se aplicó correctamente.

Tenable.sc ya está completamente inicializado. En el manual del operador, se indican los pasos adicionales para configurar y usar Tenablesc, que se deben completar más adelante después del arranque.

33.9.12. Opcional: Desinstala

En esta sección, se incluyen los comandos para quitar la implementación de Tenable.sc.

Advertencia: Si desinstalas los gráficos de Helm de Tenable.sc, se quitarán los volúmenes persistentes y se borrarán los datos de la aplicación.

Sigue estos pasos para desinstalar los gráficos de Helm de los clústeres:

1. Desinstala el gráfico de Helm del clúster de infraestructura de la organización:

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

2. Desinstala el gráfico de Helm del servidor de la API de administración:

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

3. Desinstala el gráfico de Helm para la VM de Tenable SC del servidor de la API de administración:

   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. Configuración de Tenable.SC

Sigue NES-G0001: Configura Tenable.sc para configurar Tenable.sc.

33.10. Valida la implementación de Nessus

En esta sección, se detallan los pasos para validar que los administradores y agentes de Nessus se ejecuten y vinculen según lo previsto, y se proporcionan pasos para corregir posibles problemas conocidos.

Esta sección está diseñada para ejecutarse al final de la instalación, pero también se recomienda realizar estos pasos de validación antes de realizar análisis. Los pasos para realizar análisis se explican en el manual del operador.

Antes de comenzar, sigue los pasos de Cómo establecer variables de entorno para configurar el acceso al clúster de administrador raíz y definir el alias de línea de comandos kra.

33.10.1. Valida el agrupamiento en clústeres

La forma principal de validar que los agentes y administradores de Nessus estén vinculados es a través de la IU del administrador principal de Nessus. En la IU, los elementos secundarios de Nessus deben aparecer en el grupo de clústeres predeterminado de la agrupación de agentes, y todos los agentes de Nessus deben aparecer en el grupo de agentes predeterminado.

Nota: El vínculo entre el Nessus Manager principal y todos los secundarios se rompe si se reinicia el Nessus Manager principal después de la instalación inicial. Esto puede ocurrir como consecuencia natural de la implementación en Kubernetes.

1. Obtén el DNS de la IU principal de Nessus Manager:

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

2. Abre un navegador de Internet y dirígete al vínculo de los pasos anteriores. Esto te llevará a la IU principal de Nessus Manager.

3. Accede a la IU de Nessus Manager con el nombre de usuario admin y la contraseña predeterminada admin.

   En caso de que haya problemas de autenticación durante el acceso, sigue NES-T0004 para rotar las credenciales de Nessus y volver a intentar acceder.

4. Haz clic en Configuración en la parte superior de la página.

   En la página Configuración, revisa la información de los complementos. Si no se define el valor de Plugin Set, sigue NES-T0001 para volver a aplicar el conjunto de complementos más reciente al Nessus Manager principal.

5. Haz clic en Sensores en la parte superior de la página y, luego, en Agrupación de agentes.

6. Haz clic en Default Agent Group para ver todos los nodos registrados.

   Si el grupo está vacío o falta el nodo (instancia secundaria de Nessus) para alguna organización, se debe volver a registrar la instancia secundaria de Nessus.

Nota: Puede haber casos en los que los agentes de Nessus de una organización se vinculen a un Nessus Manager secundario de otra organización debido a la distribución de un nodo principal a los nodos secundarios a los que pueden acceder los agentes.