Consultar con la API o la interfaz de usuario de Prometheus

Una vez que hayas implementado Google Cloud Managed Service para Prometheus, podrás consultar los datos enviados al servicio gestionado y mostrar los resultados en gráficos y paneles.

En este documento se describen los ámbitos de las métricas, que determinan los datos que puede consultar, y las siguientes formas basadas en Prometheus de recuperar y usar los datos que ha recogido:

  • API HTTP de Prometheus
  • Interfaz de usuario de Prometheus

Todas las interfaces de consulta de Managed Service para Prometheus están configuradas para recuperar datos de Monarch mediante la API de Cloud Monitoring. Si consultas Monarch en lugar de consultar datos de servidores Prometheus locales, obtendrás una monitorización global a gran escala.

Antes de empezar

Si aún no has desplegado el servicio gestionado, configura la recogida gestionada o la recogida con despliegue automático. Puedes saltarte este paso si solo te interesa consultar métricas de Cloud Monitoring con PromQL.

Configurar el entorno

Para no tener que introducir repetidamente el ID del proyecto o el nombre del clúster, haz la siguiente configuración:

  • Configura las herramientas de línea de comandos de la siguiente manera:

    • Configura gcloud CLI para que haga referencia al ID de tu proyectoGoogle Cloud :

      gcloud config set project PROJECT_ID

    • Configura la CLI de kubectl para que use tu clúster:

      kubectl config set-cluster CLUSTER_NAME

    Para obtener más información sobre estas herramientas, consulta los siguientes artículos:

Configurar un espacio de nombres

Crea el espacio de nombres de Kubernetes NAMESPACE_NAME para los recursos que crees como parte de la aplicación de ejemplo:

kubectl create ns NAMESPACE_NAME

Verificar las credenciales de la cuenta de servicio

Si tu clúster de Kubernetes tiene habilitada la federación de identidades de carga de trabajo para GKE, puedes saltarte esta sección.

Cuando se ejecuta en GKE, Managed Service para Prometheus obtiene automáticamente las credenciales del entorno en función de la cuenta de servicio predeterminada de Compute Engine. La cuenta de servicio predeterminada tiene los permisos necesarios, monitoring.metricWriter y monitoring.viewer, de forma predeterminada. Si no usas Workload Identity Federation para GKE y has quitado alguno de esos roles de la cuenta de servicio de nodo predeterminada, tendrás que volver a añadir los permisos que faltan antes de continuar.

Configurar una cuenta de servicio para Workload Identity Federation for GKE

Si tu clúster de Kubernetes no tiene habilitada la federación de identidades de carga de trabajo para GKE, puedes saltarte esta sección.

Managed Service para Prometheus captura datos de métricas mediante la API de Cloud Monitoring. Si tu clúster usa la federación de Workload Identity para GKE, debes conceder permiso a tu cuenta de servicio de Kubernetes para usar la API Monitoring. En esta sección se describe lo siguiente:

Crear y vincular la cuenta de servicio

Este paso aparece en varios lugares de la documentación de Managed Service para Prometheus. Si ya has completado este paso en una tarea anterior, no tienes que repetirlo. Vaya a la sección Autorizar la cuenta de servicio.

La siguiente secuencia de comandos crea la cuenta de servicio gmp-test-sa y la vincula a la cuenta de servicio predeterminada de Kubernetes en el espacio de nombres NAMESPACE_NAME:

gcloud config set project PROJECT_ID \
&&
gcloud iam service-accounts create gmp-test-sa \
&&
gcloud iam service-accounts add-iam-policy-binding \
  --role roles/iam.workloadIdentityUser \
  --member "serviceAccount:PROJECT_ID.svc.id.goog[NAMESPACE_NAME/default]" \
  gmp-test-sa@PROJECT_ID.iam.gserviceaccount.com \
&&
kubectl annotate serviceaccount \
  --namespace NAMESPACE_NAME \
  default \
  iam.gke.io/gcp-service-account=gmp-test-sa@PROJECT_ID.iam.gserviceaccount.com

Si usas un espacio de nombres o una cuenta de servicio de GKE diferentes, ajusta los comandos según corresponda.

Autorizar la cuenta de servicio

Los grupos de permisos relacionados se recogen en roles, y tú asignas los roles a una entidad principal, en este ejemplo, la Google Cloudcuenta de servicio. Para obtener más información sobre los roles de Monitoring, consulta Control de acceso.

El siguiente comando otorga a la cuenta de servicio Google Cloud gmp-test-sa los roles de la API Monitoring que necesita para leer datos de métricas.

Si ya has concedido un rol específico a la Google Cloud cuenta de servicio como parte de una tarea anterior, no es necesario que lo hagas de nuevo.

Para autorizar tu cuenta de servicio para que lea datos de un ámbito de métricas de varios proyectos, sigue estas instrucciones y, a continuación, consulta la sección Cambiar el proyecto consultado. 

gcloud projects add-iam-policy-binding PROJECT_ID \
  --member=serviceAccount:gmp-test-sa@PROJECT_ID.iam.gserviceaccount.com \
  --role=roles/monitoring.viewer

Depurar la configuración de Workload Identity Federation para GKE

Si tienes problemas para que funcione Workload Identity Federation para GKE, consulta la documentación sobre cómo verificar la configuración de Workload Identity Federation para GKE y la guía para solucionar problemas de Workload Identity Federation para GKE.

Como las erratas y las acciones de copiar y pegar parciales son las fuentes de errores más habituales al configurar la federación de identidades de carga de trabajo para GKE, te recomendamos encarecidamente que uses las variables editables y los iconos de copiar y pegar en los que se puede hacer clic que se incluyen en los ejemplos de código de estas instrucciones.

Workload Identity Federation para GKE en entornos de producción

En el ejemplo que se describe en este documento, se vincula la Google Cloud cuenta de servicio Google Clouda la cuenta de servicio predeterminada de Kubernetes y se le otorgan todos los permisos necesarios para usar la API Monitoring.

En un entorno de producción, puede que quieras usar un enfoque más detallado, con una cuenta de servicio para cada componente, cada una con permisos mínimos. Para obtener más información sobre cómo configurar cuentas de servicio para la gestión de identidades de cargas de trabajo, consulta Usar Workload Identity Federation para GKE.

Permisos de consultas y métricas

Los datos que puedes consultar están determinados por la estructura de Cloud Monitoring ámbito de métricas, independientemente del método que utilices para consultar los datos. Por ejemplo, si usas Grafana para consultar datos de Managed Service para Prometheus, cada ámbito de métricas debe configurarse como una fuente de datos independiente.

Un permiso de métricas de Monitoring es una estructura de solo lectura que te permite consultar datos de métricas de varios proyectos de Google Cloud . Cada ámbito de las métricas está alojado en un Google Cloud proyecto designado, llamado proyecto de ámbito.

De forma predeterminada, un proyecto es el proyecto de ámbito de su propio ámbito de métricas, y el ámbito de métricas contiene las métricas y la configuración de ese proyecto. Un proyecto de ámbito puede tener más de un proyecto monitorizado en su ámbito de métricas, y el proyecto de ámbito puede ver las métricas y las configuraciones de todos los proyectos monitorizados que se incluyan en el ámbito de métricas. Un proyecto monitorizado también puede pertenecer a más de un ámbito de métricas.

Cuando consultas las métricas de un proyecto de ámbito y ese proyecto de ámbito aloja un ámbito de métricas de varios proyectos, puedes recuperar datos de varios proyectos. Si el ámbito de las métricas incluye todos tus proyectos, las consultas y las reglas se evalúan de forma global.

Para obtener más información sobre el ámbito de los proyectos y de las métricas, consulte Ámbitos de las métricas. Para obtener información sobre cómo configurar el ámbito de las métricas de varios proyectos, consulta Ver métricas de varios proyectos.

Datos de Managed Service para Prometheus en Cloud Monitoring

La forma más sencilla de verificar que tus datos de Prometheus se están exportando es usar la página Explorador de métricas de Cloud Monitoring en la Google Cloud consola, que admite PromQL. Para obtener instrucciones, consulta Consultar con PromQL en Cloud Monitoring.

Interfaz de usuario de frontend de Prometheus independiente

Puedes usar la interfaz de usuario de frontend de Prometheus independiente para acceder a los datos ingeridos y visualizarlos. Esta interfaz de usuario ejecuta consultas de PromQL en todos los datos de tuGoogle Cloud proyecto, según el ámbito de las métricas asociado a tu proyecto.

La interfaz de usuario frontend también actúa como proxy de autenticación para acceder a los datos ingeridos. Esta función se puede usar en herramientas de cliente que no admitan OAuth2 para cuentas de servicio, como Grafana o el escalado automático horizontal de pods mediante la biblioteca prometheus-adapter.

Te recomendamos que configures Grafana para visualizar los datos de Managed Service para Prometheus mediante el sincronizador de fuentes de datos. Aquí se incluyen las instrucciones para configurar Grafana mediante la interfaz de usuario independiente de Prometheus como referencia para los usuarios que ya lo hayan configurado con este método.

Desplegar la interfaz de usuario del frontend

Para desplegar la interfaz de usuario de frontend de Prometheus independiente para Managed Service para Prometheus, ejecuta los siguientes comandos:

  1. Despliega el servicio frontend y configúralo para que consulte el proyecto de ámbito de tu ámbito de métricas que elijas:

    curl https://raw.githubusercontent.com/GoogleCloudPlatform/prometheus-engine/e2cd07628f5bf3be5dc794ce8f4d4b9a206447ec/examples/frontend.yaml |
sed 's/\$PROJECT_ID/PROJECT_ID/' |
kubectl apply -n NAMESPACE_NAME -f -

  2. Redirecciona los puertos del servicio frontend a tu máquina local. En el siguiente ejemplo se reenvía el servicio al puerto 9090:

    kubectl -n NAMESPACE_NAME port-forward svc/frontend 9090

    Este comando no devuelve nada y, mientras se ejecuta, informa de los accesos a la URL.

Si quieres seguir usando una implementación de Grafana instalada por kube-prometheus, despliega la interfaz de usuario de frontend de Prometheus independiente en el espacio de nombres monitoring.

Puedes acceder a la interfaz de usuario de frontend de Prometheus independiente en tu navegador a través de la URL http://localhost:9090. Si usas Cloud Shell en este paso, puedes acceder con el botón Vista previa web.

En la siguiente captura de pantalla se muestra una tabla de la interfaz de usuario de frontend independiente de Prometheus que muestra la métrica up:

Ver una métrica en la interfaz de Prometheus.

También puedes configurar la autenticación y la autorización adecuadas en el servicio frontend. Para ello, puedes usar, por ejemplo, Identity-Aware Proxy. Para obtener más información sobre cómo exponer servicios, consulta Exponer aplicaciones mediante servicios.

Cambiar el proyecto consultado para obtener la monitorización de varios proyectos

La implementación de frontend usa el proyecto Google Cloud configurado como proyecto de ámbito. Si este proyecto es el proyecto de ámbito de un ámbito de métricas de varios proyectos, puede leer métricas de todos los proyectos del ámbito de métricas.

Puede especificar un proyecto con un ámbito de métricas de varios proyectos mediante la marca --query.project-id.

Normalmente, se usa un proyecto específico como proyecto de ámbito, y este proyecto no es el mismo en el que se ejecuta la implementación de frontend. Para que la implementación lea un proyecto de destino diferente, debe hacer lo siguiente:

  • Indica a la implementación de frontend qué proyecto es el de destino.

  • Concede a la cuenta de servicio permiso para leer el proyecto de destino. Si has estado usando la cuenta de servicio default de Compute Engine, puedes hacer una de las siguientes acciones:

Para conceder los permisos necesarios para acceder a otro proyecto, Google Cloud haz lo siguiente:

  1. Concede a la cuenta de servicio permiso para leer el proyecto de destino que quieras consultar:

    gcloud projects add-iam-policy-binding SCOPING_PROJECT_ID \
  --member=serviceAccount:gmp-test-sa@PROJECT_ID.iam.gserviceaccount.com \
  --role=roles/monitoring.viewer

  2. Abre la implementación de frontend que has creado anteriormente para editarla:

    kubectl -n NAMESPACE_NAME edit deploy frontend

  3. Especifica el proyecto de destino con la marca --query.project-id:

    apiVersion: apps/v1
kind: Deployment
metadata:
  namespace: NAMESPACE_NAME
  name: frontend
spec:
  template
    containers:
    - name: frontend
      args:
      - --query.project-id=SCOPING_PROJECT_ID
...

    Guarda el archivo y cierra el editor. Una vez aplicado el cambio, los pods del frontend se reinician y consultan el nuevo proyecto de ámbito.

Autenticar la interfaz de usuario frontend

La implementación de frontend admite la autenticación de acceso básica para el acceso autenticado en las versiones 0.5.0 y posteriores. Para habilitar la autenticación, añade las variables de entorno AUTH_USERNAME y AUTH_PASSWORD a la implementación: 

apiVersion: apps/v1
kind: Deployment
metadata:
  namespace: NAMESPACE_NAME
  name: frontend
spec:
  template
    containers:
    - name: frontend
      env:
      - name: AUTH_USERNAME
        value: USERNAME
      - name: AUTH_PASSWORD
        value: PASSWORD
...

Proporcionar credenciales explícitamente

Puedes saltarte esta sección si ejecutas el contenedor frontend en un clúster de Google Kubernetes Engine. Si tienes problemas de autenticación en GKE, consulta Verificar las credenciales de la cuenta de servicio.

Cuando se ejecuta en GKE, el frontend obtiene automáticamente las credenciales del entorno en función de la cuenta de servicio del nodo o de la configuración de Workload Identity Federation para GKE. En los clústeres de Kubernetes que no son de GKE, las credenciales deben proporcionarse explícitamente al frontend mediante marcas o la variable de entorno GOOGLE_APPLICATION_CREDENTIALS.

  1. Define el contexto de tu proyecto de destino:

    gcloud config set project PROJECT_ID

  2. Crea una cuenta de servicio:

    gcloud iam service-accounts create gmp-test-sa

    En este paso se crea la cuenta de servicio que puede que ya hayas creado en las instrucciones de Workload Identity Federation para GKE.

  3. Concede los permisos necesarios a la cuenta de servicio:

    gcloud projects add-iam-policy-binding PROJECT_ID \
  --member=serviceAccount:gmp-test-sa@PROJECT_ID.iam.gserviceaccount.com \
  --role=roles/monitoring.viewer

  4. Crea y descarga una clave para la cuenta de servicio:

    gcloud iam service-accounts keys create gmp-test-sa-key.json \
  --iam-account=gmp-test-sa@PROJECT_ID.iam.gserviceaccount.com

  5. Añade el archivo de claves como secreto a tu clúster que no sea de GKE:

    kubectl -n NAMESPACE_NAME create secret generic gmp-test-sa \
  --from-file=key.json=gmp-test-sa-key.json

  6. Abre el recurso de implementación de frontend para editarlo:

    kubectl -n NAMESPACE_NAME edit deploy frontend

    1. Añade el texto que se muestra en negrita al recurso:

      apiVersion: apps/v1
kind: Deployment
metadata:
  namespace: NAMESPACE_NAME
  name: frontend
spec:
  template
    containers:
    - name: frontend
      args:
      - --query.credentials-file=/gmp/key.json
...
      volumeMounts:
      - name: gmp-sa
        mountPath: /gmp
        readOnly: true
...
    volumes:
    - name: gmp-sa
      secret:
        secretName: gmp-test-sa
...

    2. Guarda el archivo y cierra el editor. Una vez aplicado el cambio, los pods se vuelven a crear y empiezan a autenticarse en el backend de métricas con la cuenta de servicio proporcionada.

    También puedes definir la ruta del archivo de claves mediante la variable de entorno GOOGLE_APPLICATION_CREDENTIALS en lugar de usar las marcas definidas en este ejemplo.

    Usar Grafana a través del proxy frontend

    Managed Service para Prometheus usa la fuente de datos de Prometheus integrada en Grafana, lo que significa que puedes seguir usando cualquier panel de control de Grafana personal o creado por la comunidad sin tener que hacer ningún cambio. También puedes importar tus paneles de Grafana a Cloud Monitoring.

    Autenticación en las APIs Google Cloud

    Google Cloud Todas las APIs requieren autenticación mediante OAuth2. Sin embargo, Grafana no admite la autenticación OAuth2 para las cuentas de servicio que se usan con fuentes de datos de Prometheus. Para usar Grafana con Managed Service para Prometheus, puedes usar la UI de frontend de Prometheus independiente como proxy de autenticación.

    Debes dirigir Grafana al proxy de la interfaz de usuario de frontend independiente para consultar datos de forma global. Si no sigues estos pasos, Grafana solo ejecutará consultas en los datos del servidor Prometheus local.

    Si aún no has desplegado el servicio de interfaz de usuario de Prometheus frontend como proxy, hazlo ahora ejecutando el siguiente comando:

    curl https://raw.githubusercontent.com/GoogleCloudPlatform/prometheus-engine/v0.15.3/examples/frontend.yaml |
sed 's/\$PROJECT_ID/PROJECT_ID/' |
kubectl apply -n NAMESPACE_NAME -f -

    En el caso de los clústeres de Kubernetes que no sean de GKE, como los clústeres de Anthos, consulta también Proporcionar credenciales explícitamente para dar al servicio frontend los permisos necesarios para consultar métricas.

    Consulta cómo cambiar el proyecto consultado para obtener instrucciones sobre cómo configurar el ámbito de las métricas que usa el servicio frontend para consultar varios proyectos.

    Si ya tienes una implementación de Grafana, como una instalada por la biblioteca kube-prometheus o una instalada con un gráfico de Helm, puedes seguir usándola con Managed Service para Prometheus. Si es así, consulte Configurar una fuente de datos para ver los pasos siguientes. De lo contrario, primero debes implementar Grafana.

    Desplegar Grafana

    Si no tienes una implementación de Grafana en ejecución en tu clúster, puedes crear una implementación de prueba efímera para experimentar.

    Para crear una implementación efímera de Grafana, aplica el archivo de manifiesto grafana.yaml de Managed Service para Prometheus a tu clúster y redirige los puertos del servicio grafana a tu máquina local. En el siguiente ejemplo se reenvía el servicio al puerto 3000.

    1. Aplica el manifiesto grafana.yaml:

      kubectl -n NAMESPACE_NAME apply -f  https://raw.githubusercontent.com/GoogleCloudPlatform/prometheus-engine/beb779d32f4dd531a3faad9f2916617b8d9baefd/examples/grafana.yaml

    2. Redirecciona los puertos del servicio grafana a tu máquina local. En este ejemplo, se reenvía el servicio al puerto 3000:

      kubectl -n NAMESPACE_NAME port-forward svc/grafana 3000

      Este comando no devuelve nada y, mientras se ejecuta, informa de los accesos a la URL.

      Puedes acceder a Grafana en tu navegador a través de la URL http://localhost:3000 con el nombre de usuario y la contraseña admin:admin.

    Configura una fuente de datos

    Para consultar Managed Service para Prometheus en Grafana mediante la interfaz de usuario de Prometheus como proxy de autenticación, debes añadir una nueva fuente de datos a Grafana. Para añadir una fuente de datos al servicio gestionado, sigue estos pasos:

    1. Ve a tu implementación de Grafana. Por ejemplo, puedes ir a la URL http://localhost:3000 para acceder a la página de bienvenida de Grafana.

    2. En el menú principal de Grafana, selecciona Configuración y, a continuación, Fuentes de datos.

      Añadir una fuente de datos en Grafana.

    3. Seleccione Añadir fuente de datos y, a continuación, Prometheus como base de datos de series temporales.

      Añadir una fuente de datos de Prometheus.

    4. En el campo URL del panel HTTP, introduce la URL del servicio frontend de Managed Service para Prometheus. Si has configurado la interfaz de usuario de frontend de Prometheus para que se ejecute en el puerto 9090, la URL de servicio de este campo es http://frontend.NAMESPACE_NAME.svc:9090.

      En el campo Tiempo de espera del panel HTTP, asigna el valor 120.

      Si has configurado el proxy de la interfaz de usuario frontend con autenticación básica, activa el interruptor Autenticación básica en el panel Autenticación y rellena el nombre de usuario y la contraseña.

      En el campo Tiempo de espera de la consulta, asigna el valor 2m.

      En el campo Método HTTP, selecciona GET.

      En el campo Tipo de Prometheus, selecciona Prometheus.

      En el campo Versión de Prometheus, selecciona 2.40.x o una versión posterior.

      Si tienes varias fuentes de datos de Prometheus, puedes asignar a esta un nombre como "Managed Prometheus Service". Puedes dejar los demás campos con sus valores predeterminados.

      Configurar una fuente de datos de Managed Service para Prometheus.

    5. Haga clic en Guardar y probar y busque el mensaje "La fuente de datos funciona".

      Probar la fuente de datos de Managed Service para Prometheus.

    Usar la nueva fuente de datos

    Ahora puede crear paneles de Grafana con la nueva fuente de datos. También puedes redirigir los paneles de control que ya tengas a la nueva fuente de datos. En la siguiente captura de pantalla se muestra un gráfico de Grafana que muestra la métrica up:

    Gráfico de Grafana de la métrica up de Managed Service para Prometheus.

    Conectar Managed Service para Prometheus a Thanos

    Puedes federar Managed Service para Prometheus a una pila Thanos autodesplegada mediante el conector de código abierto thanos-promql-connector. Google Cloudno ofrece asistencia para esta integración.

    API HTTP de Prometheus

    Managed Service para Prometheus admite la API HTTP de Prometheus upstream en la URL con el prefijo https://monitoring.googleapis.com/v1/projects/PROJECT_ID/location/global/prometheus/api/v1/. Para obtener información sobre los endpoints admitidos, consulta Compatibilidad con la API.

    Se puede acceder a esta API con cualquier herramienta que pueda interactuar con un servidor Prometheus estándar. Se trata únicamente de un endpoint de API, no de una interfaz de usuario. Como API Google Cloud , la API usa la autenticación OAuth 2.0 y, como parte de la API Cloud Monitoring, el valor de PROJECT_ID es el proyecto de ámbito de un ámbito de métricas, por lo que puedes recuperar datos de cualquier proyecto del ámbito de métricas. Para obtener más información sobre los ámbitos, consulta Ámbitos de las métricas.

    Para usar este endpoint, proporciona una expresión PromQL. Por ejemplo, la siguiente consulta instantánea obtiene todas las series temporales que tienen el nombre de métrica up:

    curl https://monitoring.googleapis.com/v1/projects/PROJECT_ID/location/global/prometheus/api/v1/query \
  -d "query=up" \
  -H "Authorization: Bearer $(gcloud auth print-access-token)"

    Si la solicitud se realiza correctamente, la consulta devuelve un resultado como el siguiente, que se ha formateado para facilitar la lectura:

    {
  "status":"success",
  "data":{
    "resultType":"vector",
    "result":[{
      "metric": {
        "__name__":"up",
        "cluster":"gmp-test",
        "instance":"prom-example-84c6f547f5-g4ljn:web",
        "job":"prometheus",
        "location":"us-central1-a",
        "project_id":"a-gcp-project"
      },
      "value": [1634873239.971,"1"]
    }]
  }
}

    Para obtener información sobre cómo consultar Google Cloud métricas del sistema con PromQL, consulta PromQL para métricas de Cloud Monitoring.

    Compatibilidad con APIs

    Los siguientes endpoints de la API HTTP de Prometheus son compatibles con Managed Service para Prometheus en la URL con el prefijo https://monitoring.googleapis.com/v1/projects/PROJECT_ID/location/global/prometheus/api/v1/.

    Para consultar la documentación completa, consulta la documentación de referencia de la API Cloud Monitoring. Los endpoints HTTP de Prometheus no están disponibles en las bibliotecas de cliente específicas de cada lenguaje de Cloud Monitoring.

    Para obtener información sobre la compatibilidad con PromQL, consulta Compatibilidad con PromQL.

    • Se admiten los siguientes endpoints:

    • El endpoint /api/v1/label/<label_name>/values solo funciona si se proporciona la etiqueta __name__ usándola como valor de <label_name> o si se corresponde exactamente con ella mediante un selector de serie. Por ejemplo, se admiten las siguientes llamadas:

      • /api/v1/label/__name__/values
      • /api/v1/label/__name__/values?match[]={__name__=~".*metricname.*"}
      • /api/v1/label/labelname/values?match[]={__name__="metricname"}

      Esta limitación provoca que las consultas de variables label_values($label) en Grafana fallen. En su lugar, puedes usar label_values($metric, $label). Se recomienda este tipo de consulta porque evita obtener valores de etiquetas de métricas que no son relevantes para el panel de control en cuestión.

    • El endpoint /api/v1/series se admite en las solicitudes GET, pero no en las POST. Si usas el sincronizador de fuentes de datos o el proxy frontend, esta restricción se gestiona automáticamente. También puede configurar sus fuentes de datos de Prometheus en Grafana para que solo emitan solicitudes GET. El parámetro match[] no admite coincidencias de expresiones regulares en la etiqueta __name__.