33. Implemente componentes do Nessus

Tempo estimado até à conclusão: 1 dia

Operable component owner: VULN

Perfil de competências: engenheiro de implementação

Última atualização: 18 de agosto de 2025

O Nessus é um scanner de segurança para os sistemas de apoio técnico e de funcionamento do Google Distributed Cloud (GDC) isolado. Ajuda a equipa do centro de operações a monitorizar e responder a vulnerabilidades de segurança no hardware e software.

Este documento apresenta os passos para implementar o Nessus e pressupõe que o operador que o segue está a executar passos a partir de uma estação de trabalho do OC com o PowerShell e o WSL disponíveis.

33.1. Antes de começar

• Acesso necessário

  • Siga as instruções do erro IAM-R0005:
    • Obtenha a função de cluster clusterrole/tenable-nessus-admin-root no cluster de administrador raiz.
    • Obter a função role/system-artifact-management-admin no espaço de nomes gpc-system do cluster de administrador raiz.

• Ferramentas necessárias

  • kubectl
  • gdcloud
  • leme
  • yq
  • docker

• Licenciamento

  • Uma licença do Nessus
    • Siga o artigo NES-G0004 – Como realizar a pré-ativação da licença do Nessus para preparar o pacote de pré-ativação "GDCH 1"

Nota: o problema gdcloud pode não ser resolvido por predefinição. Caso contrário, corrija o caminho com PATH=/root/release:${PATH:?} e tente novamente.

33.1.1. Práticas recomendadas

33.1.1.1. Atualizações

Para atualizações de versões anteriores à 1.14, siga a secção "Opcional: desinstalar" de cada secção principal deste guia antes de realizar quaisquer instalações.

Em caso de reinstalações, siga a parte "Opcional: desinstalar" de cada secção principal deste guia.

33.1.1.2. Processamento da variação da versão entre organizações e zonas

Não deve haver problemas devido à variação da versão entre organizações e zonas. Siga os passos específicos da organização tendo em atenção a versão da organização. Em seguida, cada implementação é independente por zona.

33.1.2. Licença do Tenablesc

O Tenablesc é um software de terceiros licenciado que requer um ficheiro de licença para funcionar. Tem de obter uma licença da Tenable de acordo com a SBOM antes de continuar. Em casos especiais, podemos fornecer uma licença.

O ficheiro de licença deve ter um nome como SecurityCenter-<version>-1000IPs-<uid>.key. Localize este ficheiro e tome nota dele para mais tarde, uma vez que tem de ser carregado diretamente para a IU do Tenablesc.

Requisitos:

• Um ficheiro de licença do Tenablesc com, pelo menos, um limite de 1000 IPs e o nome do anfitrião tenablesc-as1

33.2. Localize ficheiros de implementação do Nessus

Antes de implementar o Nessus, siga os passos abaixo com o Windows PowerShell para localizar os ficheiros de instalação do Nessus:

1. Aceda aos gráficos Helm do Nessus e à imagem da máquina virtual (VM):

   Dentro do OC, estes estão acessíveis em \\<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. Mova estes ficheiros para a sua estação de trabalho local para utilização posterior:

   # 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. Localize o pacote de pré-ativação do Nessus

Importante: este passo não é necessário para atualizações.

O pacote de pré-ativação do Nessus é específico de cada instalação do Nessus e, por isso, não pode ser incluído no pacote do centro de operações. Siga o guia do Nessus NES-G0004 – Como pré-ativar a licença do Nessus para preparar o pacote de pré-ativação "GDCH 1" antes de continuar.

1. Num computador com ligação à Internet, obtenha nessus-preact-gdch1.tar.gz por si ou através de um POC de engenharia da Google.

2. Transfira este ficheiro para a sua estação de trabalho e coloque-o em $env:USERPROFILE\tenable-nessus

3. O diretório $env:USERPROFILE\tenable-nessus tem de conter o pacote de pré-ativação:

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

33.4. Abra o WSL

Os passos restantes na página requerem o WSL para todos os comandos, salvo indicação em contrário.

1. Opcional: é necessário o comando sudo. Se não souber a palavra-passe do utilizador sudo, execute o seguinte comando para definir a palavra-passe do utilizador sudo do WSL oc-it:

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

33.5. Defina variáveis de ambiente

Siga os passos abaixo para definir as variáveis de ambiente necessárias:

1. Defina a variável de ambiente ROOT_ADMIN_CLUSTER_KUBECONFIG para utilização posterior no terminal atual. Tem de ser um caminho absoluto para o kubeconfig do cluster de administrador gerado como pré-requisito:

   ROOT_ADMIN_CLUSTER_KUBECONFIG=
   

2. Defina um alias para o comando kubectl do cluster de administrador selecionado no terminal atual:

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

3. Defina a variável USERPROFILE:

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

   $USERPROFILE aponta agora para a mesma localização que $env:USERPROFILE.

33.5.1. Defina variáveis de ambiente para a organização v1

1. Defina a variável de ambiente ORG_ADMIN_KUBECONFIG para utilização posterior no terminal atual. Este tem de ser um caminho absoluto para o kubeconfig do cluster de administrador da organização selecionado gerado como pré-requisito:

   ORG_ADMIN_KUBECONFIG=
   

2. Defina um alias para o comando kubectl do cluster de administrador da organização selecionado no terminal atual:

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

3. Defina a variável de ambiente ORG_SYSTEM_KUBECONFIG para utilização posterior no terminal atual. Este tem de ser um caminho absoluto para o kubeconfig do cluster do sistema selecionado gerado como pré-requisito:

   ORG_SYSTEM_KUBECONFIG=
   

4. Defina um alias para o comando kubectl do cluster do sistema selecionado no terminal atual:

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

33.5.2. Defina variáveis de ambiente para a organização v2

1. Defina a variável de ambiente ORG_MGMT_KUBECONFIG para utilização posterior no terminal atual. Este tem de ser um caminho absoluto para o kubeconfig do servidor da API do plano de gestão da organização v2 selecionada gerado como pré-requisito:

   ORG_MGMT_KUBECONFIG=
   

2. Defina um alias para o comando kubectl do cluster de administrador da organização selecionado no terminal atual:

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

3. Defina a variável de ambiente ORG_INFRA_KUBECONFIG para utilização posterior no terminal atual. Este tem de ser um caminho absoluto para o kubeconfig do servidor da API do plano de controlo da organização v2 selecionada gerado como pré-requisito:

   ORG_INFRA_KUBECONFIG=
   

4. Defina um alias para o comando kubectl do cluster do sistema selecionado no terminal atual:

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

33.6. Carregue o pacote de pré-ativação

Importante: este passo não é necessário para atualizações.

Siga os passos abaixo para carregar o registo do artefacto do Harbor.

1. Converta o pacote para o formato OCI com os metadados adequados:

   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. Instale o certificado da AC do 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"
   

   Encontre o sistema operativo:

   sudo sh -c "hostnamectl"
   

   Para o Rocky Linux como sistema operativo, execute:

   sudo update-ca-trust extract
   

   Para o Ubuntu como sistema operativo, execute:

   sudo update-ca-certificates
   

3. Carregue o pacote de pré-ativação para o Harbor:

   • Método ideal: autentique com 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 cópia de segurança: a usar 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. Instale o Nessus

Aviso: para atualizações de versões anteriores à 1.14, siga a secção "Opcional: desinstalar" antes de prosseguir com a instalação.

1. Acione a instalação do 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. Aguarde cerca de 1,5 horas até que a instalação esteja concluída.

33.7.1. Opcional: desinstale o Nessus

Esta secção contém os comandos para remover a implementação do Nessus de todos os clusters necessários.

Aviso: só desinstale a implementação do Nessus existente se estiver a fazer uma reinstalação ou uma atualização. Caso contrário, ignore esta secção.

1. Desinstale o Nessus do cluster de administrador raiz:

   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 a arquitetura organizacional v1:

   1. Desinstale o Nessus do cluster de administrador da organização:

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

   2. Desinstale o Nessus do cluster do sistema da organização:

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

3. Para a arquitetura de organização v2:

   1. Desinstale o Nessus do cluster de gestão da organização:

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

   2. Desinstale o Nessus do cluster de infraestrutura da organização:

      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. Valide o Nessus no cluster de administrador raiz

1. Valide se as chaves e os certificados estão publicados:

   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. Verifique se o Nessus Manager principal está em bom 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. Se o Nessus Manager principal for comunicado como não estando em bom estado, como a saída de qualquer um dos comandos anteriores for falsa, reinicie o Nessus Manager principal com os seguintes comandos:

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

4. Aguarde cerca de 1,5 horas e, em seguida, verifique novamente o estado.

5. Se o Nessus Manager principal continuar a ser comunicado como não saudável após 1,5 horas, encaminhe o problema para o técnico de serviço de piquete.

   1. Inclua as seguintes informações depois de executar a consulta fornecida na IU do Grafana:

      {pod="<pod_name>"}
      

   2. Inclua a configuração do Nessus Manager principal:

      kra get pnm -A -o yaml
      

6. Verifique se o Nessus Manager secundário está em bom 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. Se o Nessus Manager secundário for comunicado como não estando em bom estado, reinicie o Nessus Manager secundário com os seguintes comandos, aguarde 20 minutos e, em seguida, verifique novamente o estado:

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

8. Se, após 20 minutos, o gestor do Nessus secundário continuar a ser comunicado como não saudável, encaminhe o problema e inclua as seguintes informações após executar a consulta fornecida na IU do Grafana.

   1. Inclua as seguintes informações depois de executar a consulta fornecida na IU do Grafana:

      {pod="<pod_name>"}
      

   2. Inclua a configuração do Nessus Manager da criança:

      kra get cnm -A -o yaml
      

9. Verifique se existem agentes em mau 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 os agentes apresentados na lista com problemas, defina a variável NESSUS_AGENT_NAME e execute o seguinte comando para todos:

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

11. Se, após 20 minutos, os agentes não íntegros continuarem a ser comunicados na lista, faça o seguinte para cada agente:

    • Verifique os registos do pod install-<node_name> no grafana e, se existir um registo de erros ansible-playbook error: one or more host failed, estabeleça uma ligação SSH ao nó bare metal através de PLATAUTH-G0001.

    • Depois de estabelecer uma ligação SSH ao nó bare metal, mova o ficheiro /etc/yum.repos.d para /etc/ yum.repos.d.back (para eliminar efetivamente o ficheiro yum repos conf).

12. Se, após 20 minutos, os agentes não íntegros continuarem a ser comunicados na lista, encaminhe o problema e inclua as seguintes informações após executar a consulta fornecida na IU do Grafana.

    1. Inclua as seguintes informações depois de executar a consulta fornecida na IU do Grafana.

       {pod="<pod_name>"}
       

    2. Inclua o estado do agente do Nessus:

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

    3. Inclua a configuração do agente do Nessus:

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

33.8. Nessus Manager – Validação da organização

Esta secção aborda os passos necessários para validar o Nessus numa organização da Distributed Cloud.

Para garantir uma validação do Nessus bem-sucedida e completa, execute este procedimento para cada cluster de organização da Distributed Cloud, incluindo o cluster de organização de TI do centro de operações.

Indique as organizações disponíveis:

kra get -n gpc-system organization

Siga os passos seguintes para cada organização, exceto a organização root, que já foi abordada.

33.8.1. Pré-requisitos

• Acesso necessário para organizações da versão 1

  • Siga as instruções do erro IAM-R0005:
    • Obtenha a função de cluster clusterrole/tenable-nessus-admin-root no cluster de administrador raiz.

  • Siga IAM-R0004:

    • Gere o KUBECONFIG para o cluster de administrador raiz.

  • Siga IAM-R0005:

    • Obtenha a função de cluster clusterrole/tenable-nessus-admin-org-legacy no cluster de administrador da organização de destino.

  • Siga IAM-R0004:

    • Gere o KUBECONFIG para o cluster de administrador da organização de destino.

  • Siga IAM-R0005:

    • Obtenha a função de cluster clusterrole/tenable-nessus-admin-system-legacy no cluster do sistema de destino.

  • Siga IAM-R0004:

    • Gere o KUBECONFIG para o cluster do sistema de destino.

• Acesso necessário para organizações da versão 2

  • Siga as instruções do erro IAM-R0005:
    • Obtenha a função de cluster clusterrole/tenable-nessus-admin-root no cluster de administrador raiz.
  • Siga as instruções em IAM-R0004:
    • Gere o KUBECONFIG para o cluster de administrador raiz.
  • Siga as instruções do erro IAM-R0005:
    • Obtenha a função de cluster clusterrole/tenable-nessus-admin-infra-mp no cluster de destino.
  • Siga as instruções em IAM-R0004:
    • Gere o KUBECONFIG do MP para o cluster de infraestrutura de destino.
  • Siga as instruções do erro IAM-R0005:
    • Obtenha a função de cluster clusterrole/tenable-nessus-admin-infra-cp no servidor da API kube do plano de controlo da infraestrutura de destino.
  • Siga as instruções em IAM-R0004:
    • Gere o cp KUBECONFIG para o cluster de infraestrutura.

Siga as instruções em Definir variáveis de ambiente para configurar o acesso aos clusters da organização e definir os alias da linha de comandos kna e knu.

33.8.2. Valide o Nessus no cluster de administrador da organização em organizações v1 e no servidor da API kube do plano de gestão de infraestrutura em organizações v2

1. Verifique se existem agentes em mau 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 os agentes apresentados na lista com problemas, defina a variável NESSUS_AGENT_NAME e execute o seguinte comando para todos:

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

3. Se, após 20 minutos, os agentes não íntegros continuarem a ser comunicados na lista, faça o seguinte para cada agente:

   • Verifique os registos do pod install-<node_name> no grafana e, se existir um registo de erros ansible-playbook error: one or more host failed, estabeleça uma ligação SSH ao nó bare metal através de PLATAUTH-G0001.

   • Depois de estabelecer uma ligação SSH ao nó bare metal, mova o ficheiro /etc/yum.repos.d para /etc/ yum.repos.d.back (para eliminar efetivamente o ficheiro yum repos conf).

4. Se, após 20 minutos, os agentes não íntegros continuarem a ser comunicados na lista, encaminhe o problema e inclua as seguintes informações após executar a consulta fornecida na IU do Grafana.

   {pod="<pod_name>"}
   

33.8.3. Valide o Nessus no cluster do sistema em organizações v1 e o servidor da API kube do plano de controlo de infraestrutura em organizações v2

1. Verifique se o Nessus Manager secundário está em bom 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. Se o Nessus Manager secundário for comunicado como não estando em bom estado, reinicie o Nessus Manager secundário com os seguintes comandos, aguarde 20 minutos e, em seguida, verifique novamente o estado:

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

3. Se, após 20 minutos, o gestor do Nessus secundário continuar a ser considerado não saudável, encaminhe o problema e inclua as seguintes informações depois de executar a consulta fornecida na IU do Grafana.

   1. Inclua as seguintes informações depois de executar a consulta fornecida na IU do Grafana.

      {pod="<pod_name>"}
      

   2. Inclua a configuração do Nessus Manager da criança.

      knu get cnm -A -o yaml
      

4. Verifique se existem agentes em mau 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 os agentes apresentados na lista com problemas, defina a variável NESSUS_AGENT_NAME e execute o seguinte comando para todos:

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

6. Se, após 20 minutos, os agentes não íntegros continuarem a ser comunicados na lista, faça o seguinte para cada agente:

   • Verifique os registos do pod install-<node_name> no grafana e, se existir um registo de erros ansible-playbook error: one or more host failed, estabeleça uma ligação SSH ao nó bare metal através de PLATAUTH-G0001.

   • Depois de estabelecer uma ligação SSH ao nó bare metal, mova o ficheiro /etc/yum.repos.d para /etc/ yum.repos.d.back (para eliminar efetivamente o ficheiro yum repos conf).

7. Se, após 20 minutos, os agentes não íntegros continuarem a ser comunicados na lista, encaminhe o problema e inclua as seguintes informações após executar a consulta fornecida na IU do Grafana.

   1. Inclua as seguintes informações depois de executar a consulta fornecida na IU do Grafana:

      {pod="<pod_name>"}
      

   2. Inclua o estado do agente do Nessus:

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

   3. Inclua a configuração do agente do Nessus:

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

33.9. Instale o Tenable.sc

Esta secção contém passos para instalar ou atualizar uma VM existente do Tenable.sc na organização de TI do Operations Center.

33.9.1. Pré-requisitos

• Acesso necessário

  • Para a arquitetura organizacional v1:
    • Siga as instruções do erro IAM-R0005:
      • Obtenha a função de cluster clusterrole/tenable-nessus-admin-root no cluster de administrador raiz.
    • Siga as instruções em IAM-R0004:
      • Gere o KUBECONFIG para o cluster de administrador raiz.
    • Siga as instruções do erro IAM-R0005:
      • Obtenha a função de cluster clusterrole/tenable-nessus-admin-org-legacy no cluster de administrador gdchservices.
    • Siga as instruções em IAM-R0004:
      • Gere o KUBECONFIG para o cluster de administrador gdchservices.
    • Siga as instruções do erro IAM-R0005:
      • Obtenha a função de cluster clusterrole/tenable-nessus-admin-system-legacy no cluster do sistema gdchservices.
    • Siga as instruções em IAM-R0004:
      • Gere o KUBECONFIG para o cluster do sistema gdchservices.
  • Para a arquitetura de organização v2:
    • Siga as instruções do erro IAM-R0005:
      • Obtenha a função de cluster clusterrole/tenable-nessus-admin-root no cluster de administrador raiz.
    • Siga as instruções em IAM-R0004:
      • Gere o KUBECONFIG para o cluster de administrador raiz.
    • Siga as instruções do erro IAM-R0005:
      • Obtenha a função de cluster clusterrole/tenable-nessus-admin-infra-mp no cluster gdchservices-management.
    • Siga as instruções em IAM-R0004:
      • Gere o KUBECONFIG para o cluster gdchservices-management.
    • Siga as instruções do erro IAM-R0005:
      • Obtenha a função de cluster clusterrole/tenable-nessus-admin-infra-cp no cluster gdchservices-infra.
    • Siga as instruções em IAM-R0004:
      • Gere o KUBECONFIG para o cluster gdchservices-infra.

33.9.2. Defina variáveis de ambiente

Siga os passos abaixo para definir as variáveis de ambiente necessárias:

1. Defina a variável de ambiente ROOT_ADMIN_CLUSTER_KUBECONFIG para utilização posterior no terminal atual. Tem de ser um caminho absoluto para o kubeconfig do cluster de administrador gerado como pré-requisito:

   ROOT_ADMIN_CLUSTER_KUBECONFIG=
   

2. Defina um alias para o comando kubectl do cluster de administrador principal no terminal atual:

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

3. Defina a variável de ambiente para o kubeconfig do plano de gestão da organização gdchservices:

   • Para a arquitetura org v1: defina a variável de ambiente ORG_ADMIN_KUBECONFIG para utilização posterior no terminal atual. Tem de ser um caminho absoluto para o kubeconfig do cluster de administração do gdchservices gerado como pré-requisito:

     ORG_ADMIN_KUBECONFIG=
     

   • Para a arquitetura org v2: defina a variável de ambiente ORG_MGMT_KUBECONFIG para utilização posterior no terminal atual. Tem de ser um caminho absoluto para o kubeconfig do cluster de gestão gdchservices gerado como pré-requisito:

     ORG_MGMT_KUBECONFIG=
     

4. Crie um alias para o comando kubectl usando o kubeconfig acima:

   • Para a arquitetura da organização v1: Defina um alias para o comando kubectl do cluster de administrador gdchservices no terminal atual:

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

   • Para a arquitetura da organização v2: defina um alias para o comando kubectl do cluster de administrador gdchservices no terminal atual:

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

5. Defina a variável de ambiente para o kubeconfig do plano de controlo da organização gdchservices:

   • Para a arquitetura org v1: defina a variável de ambiente ORG_SYSTEM_KUBECONFIG para utilização posterior no terminal atual. Este tem de ser um caminho absoluto para o kubeconfig do cluster do sistema gdchservices gerado como pré-requisito:

     ORG_SYSTEM_KUBECONFIG=
     

   • Para a arquitetura org v2: defina a variável de ambiente ORG_INFRA_KUBECONFIG para utilização posterior no terminal atual. Tem de ser um caminho absoluto para o kubeconfig do cluster de infraestrutura gdchservices gerado como pré-requisito:

     ORG_INFRA_KUBECONFIG=
     

6. Crie um alias para o comando kubectl usando o kubeconfig acima:

   • Para a arquitetura org v1: Defina um alias para o comando kubectl do cluster do sistema gdchservices no terminal atual:

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

   • Para a arquitetura org v2: Defina um alias para o comando kubectl do cluster de infraestrutura gdchservices no terminal atual:

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

7. Defina a variável USERPROFILE:

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

   $USERPROFILE aponta agora para a mesma localização que $env:USERPROFILE.

8. Defina o nome da organização na qual o Tenablesc está implementado:

   ORG=gdchservices
   

33.9.3. Prepare-se para a instalação

Siga os passos abaixo para preparar a organização.

1. Crie o projeto 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. Após dois minutos, verifique se existem espaços de nomes nos clusters de administrador da organização e do sistema.

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

   Tenha em atenção que a etiqueta do projeto resourcemanager.gdc.goog/attach-all-user-clusters: "true" faz com que o espaço de nomes também seja criado em todos os clusters de utilizadores da organização.

3. Gere e guarde a credencial de utilizador administrador e gestor do Tenablesc como um segredo do 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. Gráfico de instalação de administradores

1. Defina as seguintes variáveis de ambiente para se preparar para a instalação:

   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. Aplique o gráfico Helm de administrador.

   • Para a arquitetura organizacional 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 a arquitetura de organização v2:

     Defina OCIT_NESSUS_MANAGER_PREFIXES como uma lista separada por vírgulas, como "{dc1-nessus1,dc1-nessus2}", que indica o prefixo da VM do OCIT.

     Defina OCIT_NESSUS_URL_SUFFIX, que indica o sufixo da VM do OCIT.

     Aplique atualizações do Helm para o plano de gestão:

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

     Aplique atualizações do Helm para o plano de infraestrutura:

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

     Aplique a política de autorização do 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
     

     Criar entrada de serviço:

     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
     

     Crie um registo 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
     

     Armazene o FQDN numa variável de ambiente após aguardar cinco minutos:

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

     Aplique uma correção ao serviço virtual e ao gateway para adicionar o FQDN interno do 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:?}"'"}]'
     

     Corrija o recurso do verificador para verificar o ponto final correto:

     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. Valide a implementação.

   Reveja o resultado do seguinte comando para confirmar que a implementação do tenablesc-admin foi bem-sucedida:

   • Para a arquitetura organizacional v1:

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

   • Para a arquitetura de organização v2:

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

4. Verifique se o serviço virtual existe.

   • Para a arquitetura organizacional v1:

     kna get virtualservice -n tenablesc-system
     

   • Para a arquitetura de organização v2:

     knu get virtualservice -n tenablesc-system
     

5. Verifique se a entrada DNS existe.

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

6. Verifique se o AuditLoggingTarget está pronto, o que deverá demorar vários minutos.

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

   • Pode ocorrer o seguinte erro:

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

     Se for o caso, o espaço de nomes tenablesc-system tem de ser criado no cluster especificado. Para continuar, crie o espaço de nomes e, em seguida, abra um erro meta para acionar uma investigação sobre o motivo da ocorrência deste erro. Inclua o resultado do comando tenablesc-system Project describe no pedido.

     kna describe project tenablesc-system
     

   • Pode ocorrer o seguinte erro:

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

     Se for o caso, crie o AuditLoggingTarget em falta manualmente:

     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
     

     Após cinco minutos, o resultado deverá ser semelhante ao seguinte:

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

     Após 10 minutos, se o resultado do estado ainda parecer incorreto, a plataforma de observabilidade pode não estar em bom estado. Abra um erro meta com as informações de estado disponíveis para ajudar na depuração.

33.9.5. Gráfico de VMs instaladas

1. Defina as seguintes variáveis de ambiente para se preparar para a instalação:

   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 a arquitetura organizacional 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 a arquitetura de organização 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. Defina o tipo de máquina virtual:

   1. Obter os nomes de todos os tipos de máquinas virtuais:

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

   2. Selecione o tipo de máquinas virtuais com o campo Supported como true e armazene-o na variável de ambiente. Preferencial: n2-standard-4-gdc e n3-standard-4-gdc.

      VIRTUAL_MACHINE_TYPE=
      

3. É necessário um ProjectNetworkPolicy para que os registos do Tenable.sc sejam enviados para a instância do 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. Aplique o gráfico Helm das VMs.

   • Para a arquitetura organizacional 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 a arquitetura de organização 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 aplica o gráfico Helm, pode deparar-se com os seguintes problemas:

   • Falha no 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
     

     Correção: execute novamente o comando helm upgrade.

5. Valide a implementação. Reveja o resultado do seguinte comando para confirmar que a implementação do tenablesc-vm foi bem-sucedida:

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

6. Aguarde até que o Tenablesc comece a ser executado.

   Verifique o estado da máquina virtual:

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

   Exemplo de saída que indica que a VM ainda está a ser aprovisionada:

   NAME            STATUS    AGE
   tenablesc-as1   Pending   55s
   

   Exemplo de resultado que indica que a VM está em execução:

   NAME            STATUS    AGE
   tenablesc-as1   Running   8m25s
   

   Se a VM não estiver em execução após 60 minutos, reveja os eventos do espaço de nomes para ver se existem erros proeminentes.

   knu get -n tenablesc-system events -o wide
   

   Recolha todos os avisos e erros notáveis e comunique-os com um metabug.

7. É necessário um VirtualService e um DestinationRule para aceder à IU do Tenable.sc.

   • Para a arquitetura organizacional v1: não é necessária nenhuma alteração.

   • Para a arquitetura de organização v2:

     • Defina o nome do serviço como uma variável de ambiente para utilização posterior:

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

     • Edite a VirtualService e a DestinationRule CR:

       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. Verifique se o DNS resolve para um 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. Verifique se o serviço é resolvido através de DNS.

   Nota: se estiver a usar instaladores fornecidos por si, ignore este passo.

   O resultado esperado é um código de resposta 200 e algum resultado HTML.

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

33.9.6. Prepare as credenciais de SSH da VM do Tenablesc

Siga os passos abaixo para preparar o SSH para aceder à VM do Tenable.

1. Gere uma chave SSH.

   Esta chave SSH só é usada temporariamente para aceder à VM.

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

2. Defina as seguintes variáveis de ambiente.

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

3. Crie um grupo temporário (24 horas) VirtualMachineRequest.

   VirtualMachineRequest é usado para instalar o certificado SSH gerado na 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. Exporte o IP SSH da VM como uma variável de ambiente local.

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

5. Teste se a ligação SSH está a funcionar:

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

   O resultado esperado é alice, que é o nome de utilizador do SSH.

   Se a ligação SSH estiver a exceder o tempo limite, significa que a política de entrada está em falta. Crie a política de entrada com o seguinte comando e tente novamente.

6. Crie a 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. Aprovisione um agrupamento iotools no espaço de nomes 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. Transfira a chave privada para o pod iotools:

9. Transfira a chave privada para o pod iotools:

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

33.9.7. Instale certificados de serviços Web

Siga os passos abaixo para instalar os certificados de serviço Web da Tenablesc.

1. Exporte o endereço IP SSH da VM como uma variável de ambiente 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. Prepare os certificados e as chaves do servidor Web.

   Os seguintes comandos instalam certificados e chaves TLS que vão ser usados para publicar a IU do Tenable.

   1. Defina o nome do certificado TLS

      TLS_SECRET_NAME=nessus-tls
      

   2. Guarde o certificado nessus-tls localmente:

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

   3. Copie o certificado nessus-tls para o pod iotools:

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

   4. Prepare o 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. Prepare a chave privada 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. Prepare o certificado da AC 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. Prepare o script de instalação do certificado.

   Guarde o seguinte código em /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. Copie o script para o pod iotools:

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

5. Instale os certificados e as chaves do servidor Web.

   Execute install-web-tls.sh na VM do 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"
   

   O serviço Tenablesc está agora a usar os certificados e as chaves TLS adequados.

33.9.8. Ative o encaminhamento de registos no Tenable.sc

1. Siga as instruções em NES-R0002 para iniciar sessão na IU do Tenablesc.

2. Na barra de navegação, aceda a Sistema > Configurações.

3. Na página Configurações, clique em Diversos.

4. Aceda à secção Syslog:

   1. Ative a opção Ativar encaminhamento.
   2. Defina a Instalação como user.
   3. Em Gravidade, selecione Selecionar tudo.

5. Clique em Enviar para guardar a configuração.

   33.9.9. Ative a conetividade de rede do OIC para o GDC

Conclua os seguintes passos para as VMs nessus1 e nessus2:

1. Configure as seguintes variáveis de 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. Publique as configurações no plano de gestão dos serviços 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. Publique as configurações no plano de controlo do 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. Limpar

Elimine o diretório temporário do Nessus.

rm -rf /tmp/nessus

33.9.11. Ativação de licenças

Esta secção fornece detalhes sobre como aplicar a licença do Tenablesc.

1. Abra a IU da Web do Tenablesc através do seguinte 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 a licença ser aplicada, a IU mostra o assistente de configuração.

   Se a IU estiver a apresentar um pedido de início de sessão, significa que a licença já foi aplicada e deve ignorar os passos restantes nesta secção.

3. Clicar em Seguinte.

4. Carregue o ficheiro de licença do Tenablesc SecurityCenter-<version>-<number>IPs-<uid>.key.

   Potenciais problemas:

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

     Este erro significa que o ficheiro de licença fornecido é inválido. Analise as seguintes potenciais causas:

     1. Nome do anfitrião incorreto

        O nome do anfitrião incorreto está definido na página do produto Tenabe.com para esta licença. Verifique se o nome de anfitrião da licença na página do produto Tenable.com é tenablesc-as1. Se o nome do anfitrião não corresponder: defina-o como tenablesc-as1, transfira a nova licença e use o novo ficheiro de licença.

     2. Ficheiro com formato incorreto

        O ficheiro de licença pode ter sido modificado durante a transferência: tal como o ficheiro de pré-ativação do Nessus, este ficheiro de licença não pode ser modificado em trânsito. O ficheiro exato transferido da página do produto Tenable.com tem de ser carregado na IU do Tenable. Pode verificar se o ficheiro foi modificado comparando o SHA do ficheiro antes e depois da transferência.

     3. Ficheiro de licença incorreto

        Certifique-se de que está a usar um Tenable.scficheiro de licença obtido na página do produto Tenable.com. O conteúdo do ficheiro deve ser semelhante a uma chave PEM.

     Se a licença continuar a não funcionar, abra um metabug com a equipa de VULN e inclua todos os passos de resolução de problemas tentados até agora.

5. Atualize a página. Se for apresentado um ecrã de início de sessão, significa que a licença foi aplicada com êxito.

O Tenablesc está agora totalmente inicializado. Estão disponíveis mais passos para configurar e usar o Tenablesc no manual do operador, que se espera que sejam concluídos mais tarde após o arranque.

33.9.12. Opcional: desinstale

Esta secção contém os comandos para remover a implementação do Tenable.sc.

Aviso: a desinstalação dos gráficos Helm do Tenable.sc remove todos os volumes persistentes e elimina os dados da aplicação.

Siga os passos seguintes para desinstalar os gráficos Helm dos clusters:

1. Desinstale o gráfico Helm do cluster de infraestrutura da organização:

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

2. Desinstale o gráfico Helm do servidor da API de gestão:

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

3. Desinstale o gráfico Helm para a VM do Tenable SC do servidor da API de gestão:

   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. Configuração do Tenable.SC

Siga o guia NES-G0001: configurar o Tenable.SC para configurar o Tenable.sc.

33.10. Valide a implementação do Nessus

Estas secções detalham os passos para validar se os gestores e os agentes do Nessus estão a ser executados e associados conforme esperado, e fornecem passos para corrigir potenciais problemas conhecidos.

Esta secção destina-se a ser executada no final da instalação, mas também é recomendado seguir estes passos de validação antes de realizar análises. Os passos para realizar as procuras estão descritos no manual do operador.

Antes de começar, siga as instruções em Definir variáveis de ambiente para configurar o acesso ao cluster de administrador raiz e definir o alias da linha de comandos kra.

33.10.1. Valide o agrupamento

A principal forma de validar se os gestores e os agentes do Nessus estão associados é através da IU do gestor do Nessus principal. Na IU, os filhos do Nessus têm de ser apresentados no grupo de clusters predefinido de agrupamento de agentes e todos os agentes do Nessus têm de ser apresentados no grupo de agentes predefinido.

Nota: a associação entre o Nessus Manager principal e todos os elementos secundários é interrompida se o Nessus Manager principal for reiniciado após a instalação inicial. Isto pode acontecer como consequência natural da implementação no Kubernetes.

1. Obtenha o DNS da IU do Nessus Manager principal:

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

2. Abra um navegador de Internet e navegue para o link dos passos anteriores. Esta ação navega para a IU principal do Nessus Manager.

3. Inicie sessão na IU do Nessus Manager com o nome de utilizador admin e a palavra-passe predefinida admin.

   Em caso de problemas de autenticação durante o início de sessão, siga o procedimento NES-T0004 para rodar as credenciais do Nessus e tentar iniciar sessão novamente.

4. Clique em Definições na parte superior da página.

   Na página Definições, reveja as informações dos Plug-ins. Se o valor de Plugin Set não estiver definido, siga NES-T0001 para aplicar novamente o conjunto de plugins mais recente ao Nessus Manager principal.

5. Clique em Sensores na parte superior da página e, de seguida, clique em Agrupamento de agentes.

6. Clique em Grupo de agentes predefinido para ver todos os nós registados.

   Se o grupo estiver vazio ou o nó (instância secundária do Nessus) de qualquer organização estiver em falta, a instância secundária do Nessus tem de ser registada novamente.

Nota: podem existir instâncias em que os agentes do Nessus numa organização são associados a um Nessus Manager secundário de outra organização devido à distribuição por um nó principal aos nós secundários acessíveis pelos agentes.