Visualiza los registros de detección avanzada de amenazas de DNS Armor con métricas basadas en registros y un panel personalizado

1. Introducción y visión general

DNS Armor, con tecnología de Infoblox, es un servicio completamente administrado que proporciona seguridad a nivel de DNS para tus cargas de trabajo de Google Cloud. Su detector de amenazas avanzado está diseñado para detectar actividad maliciosa en el momento más temprano de la cadena de ataque (la consulta de DNS) sin agregar complejidad operativa ni sobrecarga de rendimiento.

En este codelab, se proporcionan instrucciones paso a paso para configurar y probar el servicio de DNS Armor. Configurarás la infraestructura de red necesaria, crearás el detector de amenazas, probarás el servicio simulando amenazas de DNS y, por último, visualizarás y analizarás los registros de amenazas con un panel personalizado de Cloud Monitoring.

Qué compilarás

En este codelab, aprovisionarás los siguientes recursos:

• Una red de VPC (network-a) con subredes y máquinas virtuales aprovisionadas en las regiones us-east4 y us-central1.
• Un detector de amenazas avanzado de DNS Armor configurado para inspeccionar las consultas de DNS.
• Son métricas basadas en registros de amenazas de DNS.
• Un panel personalizado para visualizar los registros de amenazas de DNS

Qué aprenderás

• Cómo aprovisionar los recursos de redes necesarios, incluidas las VPC y las máquinas virtuales
• Cómo implementar un detector de amenazas avanzado y excluir redes específicas
• Cómo validar la configuración de detección de amenazas con una secuencia de comandos de simulación de amenazas
• Cómo visualizar los registros de amenazas de DNS con métricas basadas en registros y un panel personalizado

Requisitos

• Un proyecto de Google Cloud,
• Acceso a la herramienta de línea de comandos de gcloud

2. Requisitos previos

En esta sección, realizarás las siguientes tareas:

• Verifica que tu proyecto de Google Cloud cumpla con las restricciones necesarias de la política de la organización.
• Confirma que tu cuenta de usuario tenga los roles y permisos de IAM necesarios.
• Habilita las APIs de Google Cloud esenciales para este codelab.
• Asigna el rol de IAM roles/logging.viewer a la cuenta de servicio de Compute Engine.

Restricciones de las políticas de la organización

Para completar este codelab correctamente, verifica las restricciones de la política de la organización que se aplican a tu proyecto. Es posible que algunas políticas dificulten el aprovisionamiento de los recursos necesarios. Las siguientes restricciones podrían afectar la configuración de este codelab:

• constraints/gcp.resourceLocations: Restringe las regiones en las que puedes crear recursos. El codelab requiere us-east4 y us-central1.
• constraints/compute.vmExternalIpAccess: Evita la creación de máquinas virtuales con direcciones IP públicas, lo que podría interferir en la configuración si no sigues el uso de la marca --no-address del codelab .
• constraints/compute.shieldedVm: Aplica la creación de VMs protegidas, que los comandos de creación de VMs del codelab no especifican, lo que podría causar un error.
• constraints/gcp.restrictServiceUsage: Limita las APIs de Google Cloud que se pueden habilitar y podría bloquear el codelab si no permite compute.googleapis.com, networksecurity.googleapis.com, logging.googleapis.com y monitoring.googleapis.com.

Permisos y roles de IAM

Para completar correctamente este codelab, verifica los roles y permisos de IAM otorgados a tu usuario. Se requieren los siguientes roles y permisos de IAM para completar este codelab.

• Administrador de uso del servicio (roles/serviceusage.serviceUsageAdmin): Para habilitar las APIs de Google Cloud necesarias para el codelab.
• Administrador de redes de Compute (roles/compute.networkAdmin): Para crear y administrar redes de VPC, subredes y Cloud NAT.
• Administrador de seguridad de Compute (roles/compute.securityAdmin): Para configurar las reglas de firewall para el acceso SSH a las máquinas virtuales.
• Administrador de instancias de Compute (v1) (roles/compute.instanceAdmin.v1): Para crear y administrar las máquinas virtuales necesarias para el lab.
• Usuario de túnel protegido con IAP (roles/iap.tunnelResourceAccessor): Para conectarse a las máquinas virtuales con SSH a través de Identity-Aware Proxy (IAP).
• Administrador de seguridad de red (roles/networksecurity.admin): Para crear y administrar el detector de amenazas de DNS Armor
• Visor de registros (roles/logging.viewer): Para ver y analizar los registros de amenazas en el Explorador de registros

APIs de Google Cloud

Nota: Ejecuta el comando gcloud config get-value project para asegurarte de que estás en el proyecto correcto.

Si el resultado muestra (unset),

Luego, usa el comando gcloud config set project para configurar el proyecto primero.

Asegúrate de que las APIs de Google Cloud necesarias estén habilitadas en tu proyecto.

1. Habilita las APIs necesarias y ejecuta los siguientes comandos de gcloud en Cloud Shell.

gcloud services enable compute.googleapis.com \
networksecurity.googleapis.com \
logging.googleapis.com \
monitoring.googleapis.com

2. Verifica que las APIs estén habilitadas. Para ello, ejecuta los siguientes comandos de gcloud en Cloud Shell.

gcloud services list --enabled

Cuenta de servicio de Compute Engine

Nota: Ejecuta el comando gcloud config get-value project para asegurarte de que estás en el proyecto correcto.

Si el resultado muestra (unset),

Luego, usa el comando gcloud config set project para configurar el proyecto primero.

La secuencia de comandos de simulación de amenazas requiere permisos para leer los registros de amenazas generados de Cloud Logging y generar informes sobre ellos. Dado que la secuencia de comandos se ejecutará desde una VM que utiliza la cuenta de servicio predeterminada de Compute Engine, se debe asignar el rol de IAM roles/logging.viewer a esta cuenta de servicio.

1. Establece las variables de entorno y ejecuta los siguientes comandos en Cloud Shell.

export PROJECT_ID=$(gcloud config get-value project)

export PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format='value(projectNumber)')

2. Otorga el rol de visualizador de registros a la SA de Compute Engine. Ejecuta los siguientes comandos de gcloud en Cloud Shell.

gcloud projects add-iam-policy-binding $PROJECT_ID \
--member="serviceAccount:${PROJECT_NUMBER}[e-mail]" \
--role="roles/logging.viewer"

3. Aprovisionamiento de recursos de red y procesamiento

En esta sección, realizarás las siguientes tareas:

• Crea una red de VPC network-a con subredes personalizadas.
• Configura Cloud Routers y Cloud NAT para el tráfico de salida a Internet en network-a.
• Crea reglas de firewall para permitir el acceso SSH a las VMs desde el rango de IP de IAP para network-a.
• Aprovisiona máquinas virtuales Linux en network-a sin direcciones IP públicas.

Crea VPCs y subredes

1. Crea network-a y sus subredes en las regiones us-east4 y us-central1. Ejecuta los siguientes comandos gcloud en Cloud Shell.

gcloud compute networks create network-a --subnet-mode=custom

gcloud compute networks subnets create subnet-a-use4 \
--network=network-a \
--range=10.10.0.0/24 \
--region=us-east4

gcloud compute networks subnets create subnet-a-usc1 \
--network=network-a \
--range=10.10.1.0/24 \
--region=us-central1

Configura la salida de Internet

1. Crea Cloud Router y Cloud NAT para network-a para permitir la salida a Internet de las VMs sin IPs públicas.

gcloud compute routers create router-a-use4 \
--network=network-a \
--region=us-east4

gcloud compute routers nats create nat-a-use4 \
--router=router-a-use4 \
--auto-allocate-nat-external-ips \
--nat-all-subnet-ip-ranges \
--region=us-east4

gcloud compute routers create router-a-usc1 \
--network=network-a \
--region=us-central1

gcloud compute routers nats create nat-a-usc1 \
--router=router-a-usc1 \
--auto-allocate-nat-external-ips \
--nat-all-subnet-ip-ranges \
--region=us-central1

Configura las reglas de firewall

1. Crea reglas de firewall para network-a que permitan el acceso SSH desde el rango de IP de IAP. Ejecuta los siguientes comandos gcloud en Cloud Shell.

gcloud compute firewall-rules create allow-ssh-iap-a \
--network=network-a \
--allow=tcp:22 \
--source-ranges=35.235.240.0/20

Crea máquinas virtuales

1. Crea VMs de Linux en network-a.

gcloud compute instances create vm-a-use4 \
--zone=us-east4-c \
--network=network-a \
--subnet=subnet-a-use4 \
--no-address \
--scopes=cloud-platform

gcloud compute instances create vm-a-usc1 \
--zone=us-central1-a \
--network=network-a \
--subnet=subnet-a-usc1 \
--no-address \
--scopes=cloud-platform

4. Crea el detector de amenazas de DNS

En esta sección, realizarás las siguientes tareas:

• Crea el detector de amenazas.
• Enumera el detector de amenazas.

Ahora que se aprovisionaron las VPC, las subredes y las máquinas virtuales, el siguiente paso es crear el detector de amenazas de DNS.

Nota: El detector de amenazas de DNS es un recurso a nivel del proyecto. Usa la marca --excluded-networks para excluir redes de VPC específicas.

1. Crea el detector de amenazas con el comando gcloud beta network-security dns-threat-detectors create.

gcloud beta network-security dns-threat-detectors create my-dns-threat-detector \
--location=global \
--provider=infoblox

2. Haz una lista del detector de amenazas para confirmar la creación.

gcloud beta network-security dns-threat-detectors list --location=global

5. Crea las métricas basadas en registros

En esta sección, realizarás las siguientes tareas:

• Comprende la entrada de registro.
• Crea el archivo config.yaml.
• Crea la métrica basada en registros.

1. Comprende la entrada de registro. Puedes revisar una tabla de todos los campos en los registros de DNS Armor en la documentación de registros de amenazas. En esta sección, se explican los campos específicos que se usarán para crear las métricas basadas en registros.

Se usarán los siguientes campos para crear las métricas basadas en registros:

• vmInstanceId: Es el nombre de la instancia de VM de Compute Engine, aplicable solo a las consultas iniciadas por las VMs de Compute Engine.
• queryName: Es el nombre de la consulta de DNS.
• gravedad: Es la gravedad (alta, media, baja o informativa) asociada con la amenaza detectada. Para obtener más información, consulta la Definición de nivel de gravedad de Infoblox.
• location: Es la región de Google Cloud desde la que se entregó la respuesta.
• threat: Es el nombre de la amenaza detectada.
• threatId: Es el identificador único de la amenaza.

2. Crea el archivo config.yaml. Primero, crea un archivo config.yaml vacío con el comando touch.

touch config.yaml

3. Propaga el archivo config.yaml. En este archivo, se define cómo crear una métrica basada en registros para los registros de amenazas de DNS Armor. Especifica qué entradas de registro se deben filtrar, qué etiquetas se deben extraer de esas entradas y las propiedades de la métrica en sí.

Abre el archivo config.yaml en el editor de texto que prefieras y pega el siguiente contenido.

filter: |
  resource.type="networksecurity.googleapis.com/DnsThreatDetector"
  jsonPayload.dnsQuery.projectNumber="PROJECT_NUMBER"
labelExtractors:
  InstanceId: EXTRACT(jsonPayload.dnsQuery.vmInstanceId)
  QueryName: EXTRACT(jsonPayload.dnsQuery.queryName)
  Severity: EXTRACT(jsonPayload.threatInfo.severity)
  region: EXTRACT(jsonPayload.dnsQuery.location)
  threat: EXTRACT(jsonPayload.threatInfo.threat)
  threatId: EXTRACT(jsonPayload.threatInfo.threatId)
metricDescriptor:
  labels:
  - key: InstanceId
  - key: threat
  - key: Severity
  - key: threatId
  - key: region
  - key: QueryName
  metricKind: DELTA
  unit: '1'
  valueType: INT64

4. Actualiza el número de proyecto. Usa el siguiente comando sed para reemplazar el marcador de posición PROJECT_NUMBER por el valor de tu variable de entorno.

sed -i "s/PROJECT_NUMBER/$PROJECT_NUMBER/g" config.yaml

5. Crea la métrica basada en registros. Por último, ejecuta el siguiente comando de gcloud en Cloud Shell para crear la métrica.

gcloud logging metrics create dns-armor-log-based-metric --config-from-file=config.yaml

6. Crea el panel personalizado

En esta sección, realizarás las siguientes tareas:

• Crea el archivo dashboard.json.
• Crea el panel personalizado

Nota: Para obtener una guía completa sobre cómo crear y administrar paneles personalizados y sus widgets correspondientes con el recurso Dashboard en la API de Cloud Monitoring, consulta la documentación pública.

1. Crea el archivo dashboard.json. Primero, crea un archivo dashboard.json vacío con el comando touch.

touch dashboard.json

2. Propaga el archivo dashboard.json. El archivo dashboard.json configura el panel de supervisión personalizado, define los widgets, las propiedades de visualización y la forma en que se visualizan, agregan y filtran las métricas basadas en registros.

Abre el archivo dashboard.json en el editor de texto que prefieras y pega el siguiente contenido.

{
  "displayName": "DNS Armor - Custom Dashboard",
  "dashboardFilters": [],
  "description": "",
  "labels": {},
  "mosaicLayout": {
    "columns": 48,
    "tiles": [
      {
        "height": 20,
        "width": 24,
        "widget": {
          "title": "Threat Logs",
          "id": "",
          "xyChart": {
            "chartOptions": {
              "displayHorizontal": false,
              "mode": "COLOR",
              "showLegend": false
            },
            "dataSets": [
              {
                "breakdowns": [],
                "dimensions": [],
                "legendTemplate": "",
                "measures": [],
                "minAlignmentPeriod": "60s",
                "plotType": "STACKED_BAR",
                "targetAxis": "Y1",
                "timeSeriesQuery": {
                  "outputFullDuration": false,
                  "timeSeriesFilter": {
                    "aggregation": {
                      "alignmentPeriod": "60s",
                      "crossSeriesReducer": "REDUCE_SUM",
                      "groupByFields": [],
                      "perSeriesAligner": "ALIGN_SUM"
                    },
                    "filter": "metric.type=\"logging.googleapis.com/user/dns-armor-log-based-metric\" resource.type=\"networksecurity.googleapis.com/DnsThreatDetector\""
                  },
                  "unitOverride": ""
                }
              }
            ],
            "thresholds": [],
            "yAxis": {
              "label": "",
              "scale": "LINEAR"
            }
          }
        }
      },
      {
        "xPos": 24,
        "height": 20,
        "width": 24,
        "widget": {
          "title": "Threat Logs per region",
          "id": "",
          "xyChart": {
            "chartOptions": {
              "displayHorizontal": false,
              "mode": "COLOR",
              "showLegend": false
            },
            "dataSets": [
              {
                "breakdowns": [],
                "dimensions": [],
                "legendTemplate": "",
                "measures": [],
                "minAlignmentPeriod": "60s",
                "plotType": "STACKED_BAR",
                "targetAxis": "Y1",
                "timeSeriesQuery": {
                  "outputFullDuration": false,
                  "timeSeriesFilter": {
                    "aggregation": {
                      "alignmentPeriod": "60s",
                      "crossSeriesReducer": "REDUCE_SUM",
                      "groupByFields": [
                        "metric.label.\"region\""
                      ],
                      "perSeriesAligner": "ALIGN_SUM"
                    },
                    "filter": "metric.type=\"logging.googleapis.com/user/dns-armor-log-based-metric\" resource.type=\"networksecurity.googleapis.com/DnsThreatDetector\""
                  },
                  "unitOverride": ""
                }
              }
            ],
            "thresholds": [],
            "yAxis": {
              "label": "",
              "scale": "LINEAR"
            }
          }
        }
      },
      {
        "yPos": 20,
        "height": 20,
        "width": 24,
        "widget": {
          "title": "Group by Threat",
          "id": "",
          "pieChart": {
            "chartType": "DONUT",
            "dataSets": [
              {
                "breakdowns": [],
                "dimensions": [],
                "measures": [],
                "minAlignmentPeriod": "60s",
                "sliceNameTemplate": "",
                "timeSeriesQuery": {
                  "outputFullDuration": true,
                  "timeSeriesFilter": {
                    "aggregation": {
                      "alignmentPeriod": "60s",
                      "crossSeriesReducer": "REDUCE_SUM",
                      "groupByFields": [
                        "metric.label.\"threat\""
                      ],
                      "perSeriesAligner": "ALIGN_SUM"
                    },
                    "filter": "metric.type=\"logging.googleapis.com/user/dns-armor-log-based-metric\" resource.type=\"networksecurity.googleapis.com/DnsThreatDetector\""
                  },
                  "unitOverride": ""
                }
              }
            ],
            "showLabels": false,
            "showTotal": false,
            "sliceAggregatedThreshold": 0
          }
        }
      },
      {
        "yPos": 20,
        "xPos": 24,
        "height": 20,
        "width": 24,
        "widget": {
          "title": "Top List - ThreatID",
          "timeSeriesTable": {
            "columnSettings": [
              {
                "column": "threatId",
                "visible": true
              },
              {
                "column": "threat",
                "visible": true
              },
              {
                "column": "project_id",
                "visible": false
              },
              {
                "column": "value",
                "visible": true
              }
            ],
            "dataSets": [
              {
                "minAlignmentPeriod": "60s",
                "timeSeriesQuery": {
                  "outputFullDuration": true,
                  "timeSeriesFilter": {
                    "aggregation": {
                      "alignmentPeriod": "60s",
                      "crossSeriesReducer": "REDUCE_SUM",
                      "groupByFields": [
                        "metric.label.\"threatId\"",
                        "metric.label.\"threat\""
                      ],
                      "perSeriesAligner": "ALIGN_SUM"
                    },
                    "filter": "metric.type=\"logging.googleapis.com/user/dns-armor-log-based-metric\" resource.type=\"networksecurity.googleapis.com/DnsThreatDetector\"",
                    "pickTimeSeriesFilter": {
                      "direction": "TOP",
                      "numTimeSeries": 30,
                      "rankingMethod": "METHOD_MEAN"
                    }
                  }
                }
              }
            ],
            "metricVisualization": "BAR"
          }
        }
      },
      {
        "yPos": 40,
        "height": 20,
        "width": 24,
        "widget": {
          "title": "Group by Severity",
          "id": "",
          "pieChart": {
            "chartType": "DONUT",
            "dataSets": [
              {
                "breakdowns": [],
                "dimensions": [],
                "measures": [],
                "minAlignmentPeriod": "60s",
                "sliceNameTemplate": "",
                "timeSeriesQuery": {
                  "outputFullDuration": true,
                  "timeSeriesFilter": {
                    "aggregation": {
                      "alignmentPeriod": "60s",
                      "crossSeriesReducer": "REDUCE_SUM",
                      "groupByFields": [
                        "metric.label.\"Severity\""
                      ],
                      "perSeriesAligner": "ALIGN_SUM"
                    },
                    "filter": "metric.type=\"logging.googleapis.com/user/dns-armor-log-based-metric\" resource.type=\"networksecurity.googleapis.com/DnsThreatDetector\""
                  },
                  "unitOverride": ""
                }
              }
            ],
            "showLabels": false,
            "showTotal": false,
            "sliceAggregatedThreshold": 0
          }
        }
      },
      {
        "yPos": 40,
        "xPos": 24,
        "height": 20,
        "width": 24,
        "widget": {
          "title": "Top List - Source",
          "id": "",
          "timeSeriesTable": {
            "columnSettings": [
              {
                "column": "InstanceId",
                "visible": true
              },
              {
                "column": "region",
                "visible": true
              },
              {
                "column": "project_id",
                "visible": true
              },
              {
                "column": "value",
                "visible": true
              }
            ],
            "dataSets": [
              {
                "minAlignmentPeriod": "60s",
                "tableTemplate": "",
                "timeSeriesQuery": {
                  "outputFullDuration": true,
                  "timeSeriesFilter": {
                    "aggregation": {
                      "alignmentPeriod": "60s",
                      "crossSeriesReducer": "REDUCE_SUM",
                      "groupByFields": [
                        "metric.label.\"InstanceId\"",
                        "metric.label.\"region\""
                      ],
                      "perSeriesAligner": "ALIGN_SUM"
                    },
                    "filter": "metric.type=\"logging.googleapis.com/user/dns-armor-log-based-metric\" resource.type=\"networksecurity.googleapis.com/DnsThreatDetector\"",
                    "pickTimeSeriesFilter": {
                      "direction": "TOP",
                      "numTimeSeries": 30,
                      "rankingMethod": "METHOD_MEAN"
                    }
                  },
                  "unitOverride": ""
                }
              }
            ],
            "displayColumnType": false,
            "metricVisualization": "BAR"
          }
        }
      },
      {
        "yPos": 60,
        "height": 20,
        "width": 48,
        "widget": {
          "title": "Group by Domains",
          "id": "",
          "xyChart": {
            "chartOptions": {
              "displayHorizontal": false,
              "mode": "COLOR",
              "showLegend": false
            },
            "dataSets": [
              {
                "breakdowns": [],
                "dimensions": [],
                "legendTemplate": "",
                "measures": [],
                "minAlignmentPeriod": "60s",
                "plotType": "STACKED_BAR",
                "targetAxis": "Y1",
                "timeSeriesQuery": {
                  "outputFullDuration": false,
                  "timeSeriesFilter": {
                    "aggregation": {
                      "alignmentPeriod": "60s",
                      "crossSeriesReducer": "REDUCE_SUM",
                      "groupByFields": [
                        "metric.label.\"QueryName\""
                      ],
                      "perSeriesAligner": "ALIGN_SUM"
                    },
                    "filter": "metric.type=\"logging.googleapis.com/user/dns-armor-log-based-metric\" resource.type=\"networksecurity.googleapis.com/DnsThreatDetector\""
                  },
                  "unitOverride": ""
                }
              }
            ],
            "thresholds": [],
            "yAxis": {
              "label": "",
              "scale": "LINEAR"
            }
          }
        }
      }
    ]
  }
}

2. Crea el panel personalizado. Ejecuta los siguientes comandos gcloud en Cloud Shell.

gcloud monitoring dashboards create --config-from-file=dashboard.json

7. Genera consultas de DNS maliciosas emuladas

En esta sección, realizarás las siguientes tareas:

• Establece una conexión SSH a las VMs.
• Instala Git en las VMs.
• Clona el repositorio del simulador de detección de amenazas de Infoblox.
• Ejecuta el script y analiza el resultado generado.

Valida la configuración generando consultas de DNS maliciosas emuladas desde tus VMs.

Nota: Estas instrucciones son específicas para vm-a-use4. Para generar consultas de DNS maliciosas desde vm-a-usc1, replica todos los pasos que se detallan en esta sección para cada máquina virtual respectiva.

1. Establece una conexión SSH a vm-a-use4. Ejecuta los siguientes comandos gcloud en Cloud Shell.

gcloud compute ssh vm-a-use4 --zone=us-east4-c

2. Instala Git en la VM.

Nota: Este comando se debe ejecutar en la VM, no en Cloud Shell.

sudo apt-get install git -y

3. Clona el repositorio del simulador de detección de amenazas de Infoblox.

Nota: Este comando se debe ejecutar en la VM, no en Cloud Shell.

git clone https://github.com/infobloxopen/ib-threat-detection-simulator

4. Cambia el directorio al directorio del simulador.

Nota: Este comando se debe ejecutar en la VM, no en Cloud Shell.

cd ib-threat-detection-simulator/threat_detection_simulator/

5. Ejecuta la secuencia de comandos y analiza el resultado generado.

Nota: Este script simula varias amenazas basadas en DNS enviando consultas a dominios maliciosos o sospechosos conocidos. Está diseñada solo para fines de prueba y demostración.

• Esta herramienta genera tráfico de consultas de DNS ejecutando comandos dig locales para una lista especificada de dominios. Su objetivo principal es simular actividad de DNS maliciosa.
• En su modo de análisis avanzado predeterminado, replica amenazas en varias categorías, como software malicioso y phishing estándares, así como amenazas avanzadas.
• Estas simulaciones avanzadas incluyen consultas a dominios reales del algoritmo de generación de dominios (DGA) asociados con las familias de malware Mylobot y Suppobox, y también emulan ataques de tunelización de DNS (DNST).

Para obtener más detalles sobre la secuencia de comandos y las amenazas que simula, consulta el repositorio de GitHub.

Nota: Este comando se debe ejecutar en la VM, no en Cloud Shell.

Haz que la secuencia de comandos sea ejecutable.

chmod +x run.sh

Ejecuta la secuencia de comandos.

./run.sh info basic

6. Resultado de muestra

En la siguiente imagen, se muestra una parte del resultado de la secuencia de comandos tal como se ve en una VM dentro de network-a. En este resultado, se detallan las tasas de detección de los diferentes tipos de amenazas de DNS que emuló la secuencia de comandos de prueba.

7. Sal de la sesión de SSH para volver a Cloud Shell.

exit

Nota: Antes de continuar con la siguiente sección, repite los pasos del 1 al 5 para generar consultas de DNS maliciosas desde vm-a-usc1..

8. Cómo ver el panel personalizado

Ver el panel

1. Escribe Dashboards en el campo de búsqueda que se encuentra en la parte superior de la consola de Google Cloud y, luego, haz clic en Paneles en los principales resultados.

2. Busca DNS Armor - Custom Dashboard en el campo de búsqueda y, luego, haz clic en DNS Armor - Custom Dashboard para abrir el panel.

3. Visualiza el panel.

Widgets en el panel

En esta sección, se describen los distintos widgets disponibles en el panel personalizado, y se proporciona una descripción general de sus funcionalidades y los datos que representan.

• Registros de amenazas: Un gráfico de barras apiladas que muestra los registros de amenazas generados para todas las redes incluidas en un proyecto durante un período especificado.
• Registros de amenazas por región: Un gráfico de barras apiladas que ilustra los registros de amenazas, agrupados por región, durante un período definido.
• Agrupar por amenaza: Un gráfico circular que categoriza los registros de amenazas según el tipo de amenaza en un período determinado.
• Lista de principales - ThreatID: Es una lista que muestra los 30 IDs de amenazas principales dentro de un período especificado.
• Agrupar por gravedad: Un gráfico circular que agrupa los registros de amenazas por nivel de gravedad dentro de un período definido.
• Top List - Source: Es una lista que presenta los 30 IDs de instancia principales (VMs de origen) dentro de un período especificado.
• Agrupar por dominios: Es un gráfico de barras apiladas que agrupa los registros de amenazas por los nombres de dominio que se encuentran en las búsquedas.

9. Limpieza

Para evitar cargos futuros, borra los recursos que creaste en este codelab. Asegúrate de salir de la shell de la VM y volver a Cloud Shell cuando ejecutes los comandos de limpieza.

1. Borra el panel personalizado.

Dado que el ID del panel se genera de forma dinámica cuando se crea, primero debes recuperar el nombre del recurso con su nombre visible.

DASHBOARD_NAME=$(gcloud monitoring dashboards list --filter="displayName='DNS Armor - Custom Dashboard'" --format='value(name)')

gcloud monitoring dashboards delete $DASHBOARD_NAME --quiet

2. Borra la métrica basada en registros.

gcloud logging metrics delete dns-armor-log-based-metric --quiet

3. Borra las VMs.

gcloud compute instances delete vm-a-use4 --zone=us-east4-c --quiet

gcloud compute instances delete vm-a-usc1 --zone=us-central1-a --quiet

4. Borra las reglas de firewall.

gcloud compute firewall-rules delete allow-ssh-iap-a --quiet

5. Borra las puertas de enlace de Cloud NAT.

gcloud compute routers nats delete nat-a-use4 --router=router-a-use4 --region=us-east4 --quiet

gcloud compute routers nats delete nat-a-usc1 --router=router-a-usc1 --region=us-central1 --quiet

6. Borra los Cloud Routers.

gcloud compute routers delete router-a-use4 --region=us-east4 --quiet

gcloud compute routers delete router-a-usc1 --region=us-central1 --quiet

7. Borra las subredes.

gcloud compute networks subnets delete subnet-a-use4 --region=us-east4 --quiet

gcloud compute networks subnets delete subnet-a-usc1 --region=us-central1 --quiet

8. Borra el detector de amenazas de DNS.

gcloud beta network-security dns-threat-detectors delete my-dns-threat-detector --location=global --quiet

9. Borra las VPC.

gcloud compute networks delete network-a --quiet

10. Felicitaciones

¡Felicitaciones! Configuraste, implementaste y visualizaste correctamente los registros de detección de amenazas de DNS Armor . Obtuviste experiencia práctica en la protección de tu entorno de Google Cloud contra amenazas basadas en DNS y en la creación de una solución de supervisión personalizada para obtener estadísticas de seguridad.

En este codelab, hiciste lo siguiente:

• Se aprovisionó un entorno de red con VPC, subredes y máquinas virtuales.
• Se configuró la salida a Internet para las VMs privadas con Cloud NAT.
• Se implementó un detector de amenazas de DNS Armor.
• Se simularon amenazas de DNS y se validó la configuración de detección de amenazas.
• Se crearon métricas personalizadas basadas en registros a partir de los registros de amenazas de DNS.
• Se creó un panel personalizado de Cloud Monitoring para visualizar y analizar las amenazas de DNS.

¿Qué sigue?

Documentos de referencia

• Descripción general de la detección avanzada de amenazas | Cloud DNS
• Presentamos DNS Armor para mitigar los riesgos del sistema de nombres de dominio | Blog de Google Cloud
• Crea un detector de amenazas de DNS | Google Cloud