Configuración de Universal Service Monitoring

Este producto no es compatible con el sitio Datadog seleccionado. ().

Versiones admitidas y compatibilidad

Versión requerida del Agent
Universal Service Monitoring requiere que el Datadog Agent instalado junto a tu servicio en contenedores sea al menos la versión 6.40 o 7.40. Como se indica más adelante, algunas funciones en Vista previa requieren versiones posteriores.
Plataformas Linux compatibles
Kernel Linux 4.14 y posterior
CentOS o RHEL 8.0 y posterior
Plataformas compatibles de Windows
Windows 2012 R2 y posterior
Protocolos de capa de aplicación admitidos
HTTP
HTTPS (OpenSSL)
Limitaciones conocidas
Universal Service Monitoring requiere el uso de system-probe de Datadog, que no es compatible con Google Kubernetes Engine (GKE) Autopilot.
Otros protocolos y métodos de cifrado de tráfico están en fase de vista previa. Si quieres saber qué plataformas y protocolos te gustaría que fueran compatibles, ponte en contacto con el servicio de asistencia.

Requisitos previos

  • En Linux:
    • Tu servicio se ejecuta en un contenedor.
    • En vista previa: para servicios fuera de contenedores, consulta las instrucciones aquí.
  • Si estás en Windows:
    • Tu servicio se ejecuta en una máquina virtual.
  • Datadog Agent se instala junto con tu servicio. No es necesario instalar una biblioteca de rastreo.
  • La etiqueta env para el etiquetado de servicios unificado se ha aplicado a tu despliegue. Las etiquetas service y version son opcionales.

Activación de Universal Service Monitoring

Activa Universal Service Monitoring en tu Agent utilizando uno de los siguientes métodos según cómo esté desplegado tu servicio y configurado tu Agent:

Si utilizas la tabla de Datadog en una versión >= 2.26.2, añade lo siguiente a tu archivo de valores:

datadog:
  ...
  serviceMonitoring:
    enabled: true

Si tu clúster está ejecutando Google Container-Optimized OS (COS), añade también lo siguiente a tu archivo de valores:

providers:
  gke:
    cos: true

Si tu clúster utiliza la distribución Bottlerocket Linux para sus nodos, añade lo siguiente a tu archivo de valores:

agents:
  containers:
    systemProbe:
      securityContext:
        seLinuxOptions:
          user: "system_u"
          role: "system_r"
          type: "spc_t"
          level: "s0"

Se requiere Datadog Operator v1.0.0 o posterior.

Para habilitar Universal Service Monitoring con el Datadog Operator, actualiza tu manifiesto datadog-agent.yaml. En el recurso DatadogAgent, establece spec.features.usm.enabled en true:

apiVersion: datadoghq.com/v2alpha1
kind: DatadogAgent
metadata:
  name: datadog
spec:
  global:
    credentials:
     apiSecret:
        secretName: datadog-secret
        keyName: api-key
     appSecret:
      secretName: datadog-secret
      keyName: app-key
  features:
    usm:
      enabled: true
  1. Añade la anotación container.apparmor.security.beta.kubernetes.io/system-probe: unconfined en la plantilla datadog-agent:

    spec:
      selector:
        matchLabels:
          app: datadog-agent
      template:
        metadata:
          labels:
            app: datadog-agent
          name: datadog-agent
          annotations:
            container.apparmor.security.beta.kubernetes.io/system-probe: unconfined
    
  2. Habilita Universal Service Monitoring con las siguientes variables de entorno en el daemonset del Agent. Si estás ejecutando un contenedor por proceso de Agent, añade las siguientes variables de entorno al contenedor process-agent. De lo contrario, añádelas al contenedor agent.

    ...
      env:
        ...
        - name: DD_SYSTEM_PROBE_SERVICE_MONITORING_ENABLED
          value: 'true'
        - name: DD_SYSTEM_PROBE_EXTERNAL
          value: 'true'
        - name: DD_SYSPROBE_SOCKET
          value: /var/run/sysprobe/sysprobe.sock
    
  3. Monta los siguientes volúmenes adicionales en el contenedor datadog-agent:

    ...
    spec:
      serviceAccountName: datadog-agent
      containers:
        - name: datadog-agent
          image: 'gcr.io/datadoghq/agent:latest'
          ...
      volumeMounts:
        ...
        - name: sysprobe-socket-dir
        mountPath: /var/run/sysprobe
    
  4. Añade un nuevo contenedor system-probe como complemento del Agent:

    ...
    spec:
      serviceAccountName: datadog-agent
      containers:
        - name: datadog-agent
          image: 'gcr.io/datadoghq/agent:latest'
          ...
        - name: system-probe
          image: 'gcr.io/datadoghq/agent:latest'
          imagePullPolicy: Always
          securityContext:
            capabilities:
              add:
                - SYS_ADMIN
                - SYS_RESOURCE
                - SYS_PTRACE
                - NET_ADMIN
                - NET_BROADCAST
                - NET_RAW
                - IPC_LOCK
                - CHOWN
          command:
            - /opt/datadog-agent/embedded/bin/system-probe
          env:
            - name: DD_SYSTEM_PROBE_SERVICE_MONITORING_ENABLED
              value: 'true'
            - name: DD_SYSPROBE_SOCKET
              value: /var/run/sysprobe/sysprobe.sock
          resources: {}
          volumeMounts:
            - name: procdir
              mountPath: /host/proc
              readOnly: true
            - name: cgroups
              mountPath: /host/sys/fs/cgroup
              readOnly: true
            - name: debugfs
              mountPath: /sys/kernel/debug
            - name: sysprobe-socket-dir
              mountPath: /var/run/sysprobe
            - name: modules
              mountPath: /lib/modules
              readOnly: true
            - name: src
              mountPath: /usr/src
              readOnly: true
            - name: runtime-compiler-output-dir
              mountPath: /var/tmp/datadog-agent/system-probe/build
            - name: kernel-headers-download-dir
              mountPath: /var/tmp/datadog-agent/system-probe/kernel-headers
              readOnly: false
            - name: apt-config-dir
              mountPath: /host/etc/apt
              readOnly: true
            - name: yum-repos-dir
              mountPath: /host/etc/yum.repos.d
              readOnly: true
            - name: opensuse-repos-dir
              mountPath: /host/etc/zypp
              readOnly: true
            - name: public-key-dir
              mountPath: /host/etc/pki
              readOnly: true
            - name: yum-vars-dir
              mountPath: /host/etc/yum/vars
              readOnly: true
            - name: dnf-vars-dir
              mountPath: /host/etc/dnf/vars
              readOnly: true
            - name: rhel-subscription-dir
              mountPath: /host/etc/rhsm
              readOnly: true
    
  5. Añade los siguientes volúmenes a tu manifiesto:

    volumes:
      - name: sysprobe-socket-dir
        emptyDir: {}
      - name: procdir
        hostPath:
          path: /proc
      - name: debugfs
        hostPath:
          path: /sys/kernel/debug
      - hostPath:
          path: /lib/modules
        name: modules
      - hostPath:
          path: /usr/src
        name: src
      - hostPath:
          path: /var/tmp/datadog-agent/system-probe/build
        name: runtime-compiler-output-dir
      - hostPath:
          path: /var/tmp/datadog-agent/system-probe/kernel-headers
        name: kernel-headers-download-dir
      - hostPath:
          path: /etc/apt
        name: apt-config-dir
      - hostPath:
          path: /etc/yum.repos.d
        name: yum-repos-dir
      - hostPath:
          path: /etc/zypp
        name: opensuse-repos-dir
      - hostPath:
          path: /etc/pki
        name: public-key-dir
      - hostPath:
          path: /etc/yum/vars
        name: yum-vars-dir
      - hostPath:
          path: /etc/dnf/vars
        name: dnf-vars-dir
      - hostPath:
          path: /etc/rhsm
        name: rhel-subscription-dir
    

    Nota: Si tu clúster se ejecuta en Google Container-Optimized OS (COS), elimina el montaje src al eliminar lo siguiente de tu definición de contenedor:

     - name: src
       mountPath: /usr/src
       readOnly: true
    

    Y eliminar lo siguiente de tu manifiesto:

     - hostPath:
         path: /usr/src
       name: src
    
  6. Para una compatibilidad de HTTPS opcional, añade lo siguiente al contenedor system-probe:

    env:
      - name: HOST_ROOT
        value: /host/root
    volumeMounts:
      - name: hostroot
        mountPath: /host/root
        readOnly: true
    

    Y añade los siguientes volúmenes a tu manifiesto:

    volumes:
      - name: hostroot
        hostPath:
        path: /
    

Añade lo siguiente a tu comando docker run:

docker run --cgroupns host \
--pid host \
-e DD_API_KEY="<DATADOG_API_KEY>" \
-e DD_SYSTEM_PROBE_SERVICE_MONITORING_ENABLED=true \
-v /var/run/docker.sock:/var/run/docker.sock:ro \
-v /proc/:/host/proc/:ro \
-v /sys/fs/cgroup/:/host/sys/fs/cgroup:ro \
-v /sys/kernel/debug:/sys/kernel/debug \
-v /lib/modules:/lib/modules:ro \
-v /usr/src:/usr/src:ro \
-v /var/tmp/datadog-agent/system-probe/build:/var/tmp/datadog-agent/system-probe/build \
-v /var/tmp/datadog-agent/system-probe/kernel-headers:/var/tmp/datadog-agent/system-probe/kernel-headers \
-v /etc/apt:/host/etc/apt:ro \
-v /etc/yum.repos.d:/host/etc/yum.repos.d:ro \
-v /etc/zypp:/host/etc/zypp:ro \
-v /etc/pki:/host/etc/pki:ro \
-v /etc/yum/vars:/host/etc/yum/vars:ro \
-v /etc/dnf/vars:/host/etc/dnf/vars:ro \
-v /etc/rhsm:/host/etc/rhsm:ro \
-e HOST_ROOT=/host/root \
--security-opt apparmor:unconfined \
--cap-add=SYS_ADMIN \
--cap-add=SYS_RESOURCE \
--cap-add=SYS_PTRACE \
--cap-add=NET_ADMIN \
--cap-add=NET_BROADCAST \
--cap-add=NET_RAW \
--cap-add=IPC_LOCK \
--cap-add=CHOWN \
gcr.io/datadoghq/agent:latest

Añade lo siguiente a tu archivo docker-compose.yml:

services:
  ...
  datadog:
    ...
    environment:
     - DD_SYSTEM_PROBE_SERVICE_MONITORING_ENABLED='true'
    volumes:
     - /var/run/docker.sock:/var/run/docker.sock:ro
     - /proc/:/host/proc/:ro
     - /sys/fs/cgroup/:/host/sys/fs/cgroup:ro
     - /sys/kernel/debug:/sys/kernel/debug
     - /lib/modules:/lib/modules
     - /usr/src:/usr/src
     - /var/tmp/datadog-agent/system-probe/build:/var/tmp/datadog-agent/system-probe/build
     - /var/tmp/datadog-agent/system-probe/kernel-headers:/var/tmp/datadog-agent/system-probe/kernel-headers
     - /etc/apt:/host/etc/apt
     - /etc/yum.repos.d:/host/etc/yum.repos.d
     - /etc/zypp:/host/etc/zypp
     - /etc/pki:/host/etc/pki
     - /etc/yum/vars:/host/etc/yum/vars
     - /etc/dnf/vars:/host/etc/dnf/vars
     - /etc/rhsm:/host/etc/rhsm
    cap_add:
     - SYS_ADMIN
     - SYS_RESOURCE
     - SYS_PTRACE
     - NET_ADMIN
     - NET_BROADCAST
     - NET_RAW
     - IPC_LOCK
     - CHOWN
    security_opt:
     - apparmor:unconfined

Para una compatibilidad HTTPS opcional, también añade:

services:
  ...
  datadog:
    ...
    environment:
     - HOST_ROOT: '/host/root'
    volumes:
     - /:/host/root:ro

Como Docker Swarm todavía no admite el cambio de security_opt, el sistema operativo no debe tener una instancia de apparmor en ejecución.

Si el sistema operativo no dispone de una instancia apparmor en ejecución, utiliza el mismo archivo docker-compose.yml de la sección Docker-Compose junto al campo security_opt.

Si no estás utilizando Helm Charts o variables de entorno, establece lo siguiente en tu archivo system-probe.yaml:

service_monitoring_config:
  enabled: true

Si configuras el system-probe con variables de entorno, como es común con Docker y las instalaciones de ECS, pasa la siguiente variable de entorno a ambas variables: el process-agent y system-probe:

DD_SYSTEM_PROBE_SERVICE_MONITORING_ENABLED=true

Establece los siguientes atributos en tus nodos:

node["datadog"]["system_probe"]["service_monitoring_enabled"] = true

Establece service_monitoring_enabled:

class { 'datadog_agent::system_probe':
    service_monitoring_enabled => true,
}

Añade los siguientes atributos a tu cuaderno de estrategias:

service_monitoring_config:
  enabled: true

Para ECS, activa USM y System Probe con la siguiente definición de tarea JSON. Despliega la definición de tarea como servicio daemon.

{
  "containerDefinitions": [
    {
      "name": "datadog-agent",
      "image": "public.ecr.aws/datadog/agent:7",
      "cpu": 500,
      "memory": 1024,
      "essential": true,
      "mountPoints": [
        ...
        {
          "containerPath": "/sys/kernel/debug",
          "sourceVolume": "sys_kernel_debug"
        },
        {
          "containerPath": "/host/proc",
          "sourceVolume": "proc"
        },
        {
          "containerPath": "/var/run/docker.sock",
          "sourceVolume": "var_run_docker_sock"
        },
        {
          "containerPath": "/host/sys/fs/cgroup",
          "sourceVolume": "sys_fs_cgroup"
        },
        {
          "readOnly": true,
          "containerPath": "/var/lib/docker/containers",
          "sourceVolume": "var_lib_docker_containers"
        },
        {
          "containerPath": "/lib/modules",
          "sourceVolume": "lib_modules"
        },
        {
          "containerPath": "/usr/src",
          "sourceVolume": "usr_src"
        },
        {
          "containerPath": "/var/tmp/datadog-agent/system-probe/build",
          "sourceVolume": "var_tmp_datadog_agent_system_probe_build"
        },
        {
          "containerPath": "/var/tmp/datadog-agent/system-probe/kernel-headers",
          "sourceVolume": "var_tmp_datadog_agent_system_probe_kernel_headers"
        },
        {
          "containerPath": "/host/etc/apt",
          "sourceVolume": "etc_apt"
        },
        {
          "containerPath": "/host/etc/yum.repos.d",
          "sourceVolume": "etc_yum_repos_d"
        },
        {
          "containerPath": "/host/etc/zypp",
          "sourceVolume": "etc_zypp"
        },
        {
          "containerPath": "/host/etc/pki",
          "sourceVolume": "etc_pki"
        },
        {
          "containerPath": "/host/etc/yum/vars",
          "sourceVolume": "etc_yum_vars"
        },
        {
          "containerPath": "/host/etc/dnf/vars",
          "sourceVolume": "etc_dnf_vars"
        },
        {
          "containerPath": "/host/etc/rhsm",
          "sourceVolume": "etc_rhsm"
        }
      ],
      "environment": [
        {
          "name": "DD_API_KEY",
          "value": "<YOUR_DATADOG_API_KEY>"
        },
        ...
        {
          "name": "DD_SYSTEM_PROBE_SERVICE_MONITORING_ENABLED",
          "value": "true"
        }
      ],
      "linuxParameters": {
        "capabilities": {
          "add": [
            "SYS_ADMIN",
            "SYS_RESOURCE",
            "SYS_PTRACE",
            "NET_ADMIN",
            "NET_BROADCAST",
            "NET_RAW",
            "IPC_LOCK",
            "CHOWN"
          ]
        }
      }
    }
  ],
  "requiresCompatibilities": [
    "EC2"
  ],
  "volumes": [
    ...
    {
      "host": {
        "sourcePath": "/sys/kernel/debug"
      },
      "name": "sys_kernel_debug"
    },
    {
      "host": {
        "sourcePath": "/proc/"
      },
      "name": "proc"
    },
    {
      "host": {
        "sourcePath": "/var/run/docker.sock"
      },
      "name": "var_run_docker_sock"
    },
    {
      "host": {
        "sourcePath": "/sys/fs/cgroup/"
      },
      "name": "sys_fs_cgroup"
    },
    {
      "host": {
        "sourcePath": "/var/lib/docker/containers/"
      },
      "name": "var_lib_docker_containers"
    },
    {
      "host": {
        "sourcePath": "/lib/modules"
      },
      "name": "lib_modules"
    },
    {
      "host": {
        "sourcePath": "/usr/src"
      },
      "name": "usr_src"
    },
    {
      "host": {
        "sourcePath": "/var/tmp/datadog-agent/system-probe/build"
      },
      "name": "var_tmp_datadog_agent_system_probe_build"
    },
    {
      "host": {
        "sourcePath": "/var/tmp/datadog-agent/system-probe/kernel-headers"
      },
      "name": "var_tmp_datadog_agent_system_probe_kernel_headers"
    },
    {
      "host": {
        "sourcePath": "/etc/apt"
      },
      "name": "etc_apt"
    },
    {
      "host": {
        "sourcePath": "/etc/yum.repos.d"
      },
      "name": "etc_yum_repos_d"
    },
    {
      "host": {
        "sourcePath": "/etc/zypp"
      },
      "name": "etc_zypp"
    },
    {
      "host": {
        "sourcePath": "/etc/pki"
      },
      "name": "etc_pki"
    },
    {
      "host": {
        "sourcePath": "/etc/yum/vars"
      },
      "name": "etc_yum_vars"
    },
    {
      "host": {
        "sourcePath": "/etc/dnf/vars"
      },
      "name": "etc_dnf_vars"
    },
    {
      "host": {
        "sourcePath": "/etc/rhsm"
      },
      "name": "etc_rhsm"
    }
  ],
  "family": "datadog-agent-task"
}

Si la imagen del sistema operativo es Ubuntu o Debian, añade lo siguiente después de environment:

"dockerSecurityOptions": [
  "apparmor:unconfined"
]

Para una compatibilidad HTTPS opcional, también añade:

"mountPoints": [
  ...
  {
    "containerPath": "/host/root",
    "sourceVolume": "host_root"
  },
  ...
]
...
"volumes": [
  ...
  {
    "host": {
      "sourcePath": "/"
    },
    "name": "host_root"
  },
  ...
]

Si utilizas equilibradores de carga con tus servicios, habilita las integraciones de nube adicionales para permitir que Universal Service Monitoring descubra entidades gestionadas por la nube:

  1. Instala la integración de AWS para obtener visibilidad en AWS Load Balancer.
  2. Activa la recopilación de métricas de ENI y EC2.
  3. Añade las siguientes etiquetas a cada equilibrador de carga:
    ENV=<env>
    SERVICE=<service>
    

Para servicios que se ejecutan en IIS:

  1. Instala Datadog Agent (versión 6.41 o 7.41 y posteriores) con el componente del controlador de dispositivos de kernel de red activado. Para el Agent versión 7.44 o anterior, debes pasar ADDLOCAL="MainApplication,NPM" al comando msiexec durante la instalación, o seleccionar Cloud Network Monitoring al ejecutar la instalación del Agent a través de la GUI.

  2. Edita C:\ProgramData\Datadog\system-probe.yaml para definir el indicador habilitado como true:

    service_monitoring_config:
      enabled: true
    

Para los que no son servicios de IIS:

La detección de servicios que no son IIS está activada por defecto a partir del Agent versión 7.57. Las versiones anteriores del Agent pueden requerir el siguiente cambio de configuración a system-probe.yaml:

service_monitoring_config:
  enabled: true
  process_service_inference:
    enabled: true

Configuración adicional

Los siguientes sistemas o servicios requieren una configuración adicional:

Universal Service Monitoring está disponible para monitorizar servicios que se ejecutan en bare-metal o en máquinas virtuales de Linux.
Requiere Agent versión 7.42 o posterior.

Añade la siguiente configuración a system-probe.yaml:

service_monitoring_config:
  enabled: true
  process_service_inference:
    enabled: true
DD_SYSTEM_PROBE_PROCESS_SERVICE_INFERENCE_ENABLED=true
Universal Service Monitoring está en Vista previa para monitorizar el tráfico cifrado con TLS desde servicios implementados en Golang.
Nota:
  • Los servidores Go HTTPS pueden actualizar el protocolo HTTP1.1 a HTTP/2, que es compatible con la Vista previa. Contacta a tu gestor de cuenta para obtener más detalles.
  • Requiere el Agent versión 7.51 or posterior.

Añade la siguiente configuración a system-probe.yaml:

service_monitoring_config:
  enabled: true
  tls:
    go:
      enabled: true
DD_SERVICE_MONITORING_CONFIG_TLS_GO_ENABLED=true
agents:
  containers:
    systemProbe:
      env:
        - name: DD_SERVICE_MONITORING_CONFIG_TLS_GO_ENABLED
          value: "true"
Universal Service Monitoring está en Vista previa para monitorizar solicitudes HTTP, HTTP/2 y gRPC de servicios implementados en Node.js.
Requiere Agent versión 7.54 o posterior.

Añade la siguiente configuración a system-probe.yaml:

service_monitoring_config:
  enabled: true
  tls:
    nodejs:
      enabled: true
DD_SERVICE_MONITORING_CONFIG_TLS_NODEJS_ENABLED=true
agents:
  containers:
    systemProbe:
      env:
        - name: DD_SERVICE_MONITORING_CONFIG_TLS_NODEJS_ENABLED
          value: "true"
Universal Service Monitoring está disponible para monitorizar servicios en Istio mTLS y capturar tráfico de HTTPs, HTTP/2 y gRPC cifrado. Requiere Agent versión 7.50 o posterior.

Añade la siguiente configuración a system-probe.yaml:

service_monitoring_config:
  enabled: true
  tls:
    istio:
      enabled: true
DD_SERVICE_MONITORING_CONFIG_TLS_ISTIO_ENABLED=true
agents:
  containers:
    systemProbe:
      env:
        - name: DD_SERVICE_MONITORING_CONFIG_TLS_ISTIO_ENABLED
          value: "true"
Universal Service Monitoring puede capturar tráfico HTTP/2 y gRPC. Nota:
  • Requiere Linux Kernel versión 5.2 o posterior.
  • Requiere Agent versión 7.53 o posterior.

Añade la siguiente configuración a system-probe.yaml:

service_monitoring_config:
  enable_http2_monitoring: true
DD_SERVICE_MONITORING_CONFIG_ENABLE_HTTP2_MONITORING=true
agents:
  containers:
    systemProbe:
      env:
        - name: DD_SERVICE_MONITORING_CONFIG_ENABLE_HTTP2_MONITORING
          value: "true"
La monitorización de Kafka está disponible en la Vista previa.
Nota:
  • Los productores y consumidores requieren la versión 5.2 o posterior del Linux Kernel.
  • Los productores y consumidores deben interactuar con Kafka sin TLS.
  • Requiere Agent versión 7.53 o posterior.

Añade la siguiente configuración a system-probe.yaml:

service_monitoring_config:
  enabled: true
  enable_kafka_monitoring: true
DD_SERVICE_MONITORING_CONFIG_ENABLE_KAFKA_MONITORING=true
datadog:
  ...
  serviceMonitoring:
    enabled: true

agents:
  ...
  containers:
    systemProbe:
      env:
        - name: DD_SERVICE_MONITORING_CONFIG_ENABLE_KAFKA_MONITORING
          value: "true"

Exclusión y sustitución de rutas

Utiliza http_replace_rules o DD_SYSTEM_PROBE_NETWORK_HTTP_REPLACE_RULES para configurar el Agent para eliminar los endpoints HTTP que coincidan con una expresión regular, o para convertir los endpoints coincidentes a un formato diferente.

Añade la siguiente configuración a system-probe:

network_config:
  http_replace_rules:
    - pattern: "<exclusion rule>"
      repl: ""
    - pattern: "<replacement rule>"
      repl: "<new format>"

Por ejemplo, la siguiente configuración elimina los endpoints que empiezan por /api/, como /api/v1/users. Sin embargo, no elimina /api ni /users/api:

network_config:
  http_replace_rules:
    - pattern: "/api/.*"
      repl: ""

La siguiente configuración sustituye un endpoint /api/users para que coincida con un nuevo formato de /api/v1/users:

network_config:
  http_replace_rules:
    - pattern: "/api/users"
      repl: "/api/v1/users"

Añade la siguiente entrada:

DD_SYSTEM_PROBE_NETWORK_HTTP_REPLACE_RULES=[{"pattern":"<drop regex>","repl":""},{"pattern":"<replace regex>","repl":"<replace pattern>"}]

El siguiente ejemplo elimina el endpoint /my-api y sustituye /my-api-2 por /new-version.

agents:
  containers:
    systemProbe:
      env:
        - name: DD_SYSTEM_PROBE_NETWORK_HTTP_REPLACE_RULES
          value: '[{"pattern":"/my-api","repl":""},{"pattern":"/my-api-2","repl":"/new-version"}]'
Compatibilidad con protocolos y métodos de cifrado adicionales

USM está en la fase de vista previa para descubrir los servicios en la nube y decodificar protocolos y métodos de cifrado de tráfico adicionales. Para obtener más información y solicitar acceso a la vista previa, consulta Detección de servicios en la nube y protocolos adicionales.

Referencias adicionales