Control de presupuesto Cloud: crear una tabla de costes en BigQuery, y visualizarlas

Fecha de publicación: 15/07/2025
Tiempo de lectura: 6 minutos

Uno de los pilares de una buena estrategia en la nube es controlar el gasto de forma proactiva. Google Cloud Platform (GCP) ofrece herramientas para exportar el coste detallado de todos tus servicios, y con BigQuery puedes transformar esa información en dashboards claros y útiles.

Veamos paso a paso cómo crear una tabla de costes en BigQuery, y cómo visualizar esos datos con Looker Studio. También puedes conectarte a esta tabla con otra herramienta como PowerBI a traves de su conector de BigQuery.

Tenemos dos métodos para calcular los costes:

El método I a través de la exportación desde GCP, y el método II realizando los cálculos con consultas SQL.

Método I: exportación de facturación en GCP

Activamos la exportación de costes a BigQuery

Para tener los datos de costes disponibles en BigQuery, debes habilitar la exportación desde tu cuenta de facturación:

Ve a https://console.cloud.google.com/billing.
Selecciona tu cuenta de facturación.
En el menú lateral, haz clic en Exportación de la facturación.

Selecciona el proyecto y dataset donde quieres que se exporten los datos.

Google comenzará a volcar automáticamente los costes de uso, desglosados por servicio, proyecto, SKU, etc.

Se crean dos tablas por defecto:

gcp_billing_export_v1_XXXXXX: exportación detallada con la facturación real.
gcp_billing_export_resources_XXXXXX: recursos asociados.

Consultar los datos desde BigQuery

Una vez habilitada la exportación, puedes comenzar a consultar tus datos con SQL.

Imaginemos, que queremos saber la facturación total mensual,

SELECT
  invoice.month,
  SUM(cost)
    + SUM(IFNULL((SELECT SUM(c.amount)
                  FROM UNNEST(credits) c), 0))
    AS total,
  (SUM(CAST(cost AS NUMERIC))
    + SUM(IFNULL((SELECT SUM(CAST(c.amount AS NUMERIC))
                  FROM UNNEST(credits) AS c), 0)))
    AS total_exact
FROM `joseangelpexxx.analytics_38xxxxx9.gcp_billing_export_v1_xxxxxx`
GROUP BY 1
ORDER BY 1 ASC
;


SELECT
  invoice.month,
  SUM(cost)
    + SUM(((SELECT SUM(c.amount)
                  FROM UNNEST(credits) c), 0))
    AS total,
  (SUM(CAST(cost AS NUMERIC))
    + SUM(IFNULL((SELECT SUM(CAST(c.amount AS NUMERIC))
                  FROM UNNEST(credits) AS c), 0)))
    AS total_exact
FROM `joseangelpexxx.analytics_38xxxxx9.gcp_billing_export_v1_xxxxxx`
GROUP BY 1
ORDER BY 1 ASC
;

ℹ️ Tienes más consultas detalladas en la documentación de Google Cloud

Crear un dashboard para visualizar los costes

Una vez que tienes la tabla actualizada diariamente con datos de costes, podremos conectarnos directamente desde LookerStudio utilizando _PARTITIONTIME como dimensión de periodo.

Ejemplos de tablas de costes

Podremos crear algunas tablas como estas para realizar seguimiento:

La opción más recomendada es utilizar LookerStudio por la integración directa que tiene con BigQuery, aunque hay otras opciones como PowerBI, Grafana o Google Sheets incluso.

Método II: cálculo a través de consultas SQL

Tenemos otra alternativa al cálculo del coste de nuestro servicio de almacenamiento, aunque solo tendremos el cálculo de consultas y almacenamiento BigQuery.

Tabla de almacenamiento

Con la siguiente consulta, crearemos una tabla de costes de almacenamiento llamada storage, en la que diferenciaremos por project_id para identificar los almacenamientos. Aplicaremos el coste por cada GB lógico, físico, corto y largo plazo.

El almacenamiento de largo plazo es aquel que no es modificado en los últimos 90 días. Si una tabla permanece sin cambios durante 90 días, Google la considera almacenamiento de largo plazo y reduce el precio por GB almacenado.

En el resultado, también podemos observar la compresión que aplica Google Cloud Platform (GCP), comparando el espacio lógico (sin comprimir, visible para el usuario) con el espacio físico (comprimido, realmente almacenado en disco).

La facturación de BigQuery se basa principalmente en el almacenamiento lógico, no en el físico, por lo que es importante entender ambas métricas.

CREATE OR REPLACE TABLE `joseanxxxxx.analytics_387xxxxx.storage` AS (
  SELECT
    project_id,

    CASE
      WHEN project_id = «joseanxxxx» THEN «Cloud Jose Angel»
      WHEN project_id = «perezxxxx» THEN «Cloud Perez Garcia»
      WHEN project_id = «searchxxxx» THEN «Search Console»
      ELSE «Otro»
    END AS proyecto,

    table_schema,
    
    CASE
      WHEN table_schema = «analytics_387xxxx» THEN «GA4 PRO»
      WHEN table_schema = «analytics_416xxxx» THEN «GA4 PRE»
      WHEN table_schema = «analytics_4710xxxx» THEN «GA4 Server side»
      ELSE «Otro»
    END AS datasheet,

    table_name,

    CASE
      WHEN STARTS_WITH(table_name, «events_») THEN «Eventos»
      WHEN STARTS_WITH(table_name, «events_intraday») THEN «Eventos en tiempo real»
      WHEN STARTS_WITH(table_name, «pseudonymous_users_») THEN «Usuarios»
      WHEN STARTS_WITH(table_name, «users_») THEN «Usuarios»
      ELSE «Otro»
    END AS tabla,

    SUM(active_logical_bytes) AS bytes_logicos_activos,
    SUM(long_term_logical_bytes) AS bytes_logicos_largo_plazo,
    SUM(active_physical_bytes) AS bytes_fisicos_activos,
    SUM(long_term_physical_bytes) AS bytes_fisicos_largo_plazo,

    — GiB
    SUM(active_logical_bytes) / POW(2,30) AS gib_logicos_activos,
    SUM(long_term_logical_bytes) / POW(2,30) AS gib_logicos_largo_plazo,
    SUM(active_physical_bytes) / POW(2,30) AS gib_fisicos_activos,
    SUM(long_term_physical_bytes) / POW(2,30) AS gib_fisicos_largo_plazo,

    — EUR estimado
    SUM(active_logical_bytes) / POW(2,30) * 0.02 AS eur_logicos_activos,
    SUM(long_term_logical_bytes) / POW(2,30) * 0.01 AS eur_logicos_largo_plazo,
    SUM(active_physical_bytes) / POW(2,30) * 0.04 AS eur_fisicos_activos,
    SUM(long_term_physical_bytes) / POW(2,30) * 0.02 AS eur_fisicos_largo_plazo

  FROM `region-us`.INFORMATION_SCHEMA.TABLE_STORAGE
  GROUP BY project_id, table_schema, table_name, datasheet, tabla
)


CREATE OR REPLACE TABLE `joseanxxxxx.analytics_387xxxxx.storage` AS (
  SELECT
    project_id,
- - Aplicamos función case a los proyectos para tenerlos más identificados
    CASE
      WHEN project_id = "joseanxxxx" THEN "Cloud Jose Angel"
      WHEN project_id = "perezxxxx" THEN "Cloud Perez Garcia"
      WHEN project_id = "searchxxxx" THEN "Search Console"
      ELSE "Otro"
    END AS proyecto,
    table_schema,
- - Para identificar el datasheet concreto, aplicamos función case a las tablas
    
    CASE
      WHEN table_schema = "analytics_387xxxx" THEN "GA4 PRO"
      WHEN table_schema = "analytics_416xxxx" THEN "GA4 PRE"
      WHEN table_schema = "analytics_4710xxxx" THEN "GA4 Server side"
      ELSE "Otro"
    END AS datasheet,
    table_name,
- - Nos traemos el nombre de las tablas y aplicamos función case para tener un output más claro
    CASE
      WHEN STARTS_WITH(table_name, "events_") THEN "Eventos"
      WHEN STARTS_WITH(table_name, "events_intraday") THEN "Eventos en tiempo real"
      WHEN STARTS_WITH(table_name, "pseudonymous_users_") THEN "Usuarios"
      WHEN STARTS_WITH(table_name, "users_") THEN "Usuarios"
      ELSE "Otro"
    END AS tabla,
    SUM(active_logical_bytes) AS bytes_logicos_activos,
    SUM(long_term_logical_bytes) AS bytes_logicos_largo_plazo,
    SUM(active_physical_bytes) AS bytes_fisicos_activos,
    SUM(long_term_physical_bytes) AS bytes_fisicos_largo_plazo,
    -- GiB
    SUM(active_logical_bytes) / POW(2,30) AS gib_logicos_activos,
    SUM(long_term_logical_bytes) / POW(2,30) AS gib_logicos_largo_plazo,
    SUM(active_physical_bytes) / POW(2,30) AS gib_fisicos_activos,
    SUM(long_term_physical_bytes) / POW(2,30) AS gib_fisicos_largo_plazo,
    -- EUR estimado
    SUM(active_logical_bytes) / POW(2,30) * 0.02 AS eur_logicos_activos,
    SUM(long_term_logical_bytes) / POW(2,30) * 0.01 AS eur_logicos_largo_plazo,
    SUM(active_physical_bytes) / POW(2,30) * 0.04 AS eur_fisicos_activos,
    SUM(long_term_physical_bytes) / POW(2,30) * 0.02 AS eur_fisicos_largo_plazo
- - Indicamos la reción. region-us en mi caso
  FROM `region-us`.INFORMATION_SCHEMA.TABLE_STORAGE
  GROUP BY project_id, table_schema, table_name, datasheet, tabla
)

El resultado será una tabla permanente, que podremos llevarnos a nuestra herramienta de visualización con resultado similar al siguiente:

Tabla de consultas

Esta query crea una tabla llamada jobs en BigQuery, particionada por fecha, que registra información detallada sobre los trabajos ejecutados en el proyecto.

Para cada job, extrae campos clave como: fecha de creación, usuario que lo ejecutó, tipo de job, tipo de sentencia SQL (statement_type), y el número de bytes facturados. También incluye una estimación del coste en euros en base al volumen de datos procesados (conversión de bytes a TiB y precio por TiB ajustado a euros).

Además, clasifica el origen del job: si está programado automáticamente (scheduled), si lo lanza Looker Studio o si es un job manual desde BigQuery.

También identifica dashboards específicos usando el ID (dashboard_id) incluido en las etiquetas del job. Por ejemplo, en mi caso, si el ID coincide con uno concreto, se muestra Looker de Costes o Dashboard de GA4 Server Side. Si no tiene dashboard asociado, se indica que el job proviene de BigQuery directamente.

CREATE or replace TABLE `joseanxxxxx.analytics_3876xxxxxx.jobs`
PARTITION BY date
AS
SELECT
  DATE(creation_time) AS date,
  project_id,
  CASE
    WHEN project_id = «joseanxxxxx» THEN «Cloud Jose Angel»
    WHEN project_id = «perezxxxxxx» THEN «Cloud Perez Garcia»
    WHEN project_id = «searchconsole» THEN «Search Console»
    ELSE «Otro»
  END AS proyecto,
  
– – Identificamos qué usuario ha realizado los trabajos, así como el coste de estos
  user_email AS `Email de usuario`,

  CASE
    WHEN job_id LIKE ‘%scheduled%’ THEN ‘Programadas’
    WHEN (SELECT value FROM UNNEST(labels) WHERE key = ‘requestor’) = ‘looker_studio’ THEN ‘Looker Studio’
    ELSE ‘BigQuery’
  END AS job_class,

  job_type,
  statement_type,

– – Identificamos qué dashboard es el que está generando los costes. El valor corresponde a la parte final de la URL cuando visualizamos un dashboard en LookerStudio

  CASE
    WHEN (SELECT value FROM UNNEST(labels) WHERE key = ‘looker_studio_report_id’) IS NULL THEN ‘BigQuery’
    WHEN (SELECT value FROM UNNEST(labels) WHERE key = ‘looker_studio_report_id’) = ‘5b519600-xxxxxxx’ THEN ‘Looker de Costes’
    WHEN STARTS_WITH((SELECT value FROM UNNEST(labels) WHERE key = ‘looker_studio_report_id’), ‘e2a’) THEN ‘Dashboard de GA4 Server Side’
    ELSE (SELECT value FROM UNNEST(labels) WHERE key = ‘looker_studio_report_id’)
  END AS dashboard_id,

  total_bytes_billed,
  total_bytes_billed / POW(10, 9) AS billed_gb,
  total_bytes_billed / POW(2, 30) AS billed_gib,
  total_bytes_billed / POW(2, 40) * 6.25 * 0.93 AS estimated_cost_euros

FROM `region-us`.INFORMATION_SCHEMA.JOBS
WHERE total_bytes_billed > 0;

CREATE or replace TABLE `joseanxxxxx.analytics_3876xxxxxx.jobs`
PARTITION BY date
AS
SELECT
  DATE(creation_time) AS date,
  project_id,
  CASE
    WHEN project_id = "joseanxxxxx" THEN "Cloud Jose Angel"
    WHEN project_id = "perezxxxxxx" THEN "Cloud Perez Garcia"
    WHEN project_id = "searchconsole" THEN "Search Console"
    ELSE "Otro"
  END AS proyecto,
  
- - Identificamos qué usuario ha realizado los trabajos, así como el coste de estos
  user_email AS `Email de usuario`,
  CASE
    WHEN job_id LIKE '%scheduled%' THEN 'Programadas'
    WHEN (SELECT value FROM UNNEST(labels) WHERE key = 'requestor') = 'looker_studio' THEN 'Looker Studio'
    ELSE 'BigQuery'
  END AS job_class,
  job_type,
  statement_type,
- - Identificamos qué dashboard es el que está generando los costes. El valor corresponde a la parte final de la URL cuando visualizamos un dashboard en LookerStudio
  CASE
    WHEN (SELECT value FROM UNNEST(labels) WHERE key = 'looker_studio_report_id') IS NULL THEN 'BigQuery'
    WHEN (SELECT value FROM UNNEST(labels) WHERE key = 'looker_studio_report_id') = '5b519600-xxxxxxx' THEN 'Looker de Costes'
    WHEN STARTS_WITH((SELECT value FROM UNNEST(labels) WHERE key = 'looker_studio_report_id'), 'e2a') THEN 'Dashboard de GA4 Server Side'
    ELSE (SELECT value FROM UNNEST(labels) WHERE key = 'looker_studio_report_id')
  END AS dashboard_id,
  total_bytes_billed,
  total_bytes_billed / POW(10, 9) AS billed_gb,
  total_bytes_billed / POW(2, 30) AS billed_gib,
  total_bytes_billed / POW(2, 40) * 6.25 * 0.93 AS estimated_cost_euros
FROM `region-us`.INFORMATION_SCHEMA.JOBS
WHERE total_bytes_billed > 0;

Bonus: controla el gasto en Google Cloud: cómo crear alertas de presupuesto

Controlar el gasto en Google Cloud no tiene por qué ser complicado. Exportar los datos a BigQuery te permite tener total visibilidad y flexibilidad para analizarlos como tú quieras. Y con un dashboard bien diseñado, puedes anticiparte a desvíos y tomar decisiones rápidas.

🔗 Te dejo por aquí un enlace a otro artículo en el que cuento cómo crear alertas presupuestarias en GCP: Controla el gasto en Google Cloud: cómo crear alertas de presupuesto

Otros artículos

Datos revelando secretos militares

# Truco o dato

En un mundo hiperconectado, donde millones de datos se generan y comparten a diario, la información abierta se ha convertido en una herramienta poderosa —y peligrosa—. La inteligencia de fuentes

Controla el gasto en Google Cloud: cómo crear alertas de presupuesto

# Google Cloud

A medida que escalas tus proyectos en la nube, es fácil perder el control de los costes. GCP ofrece herramientas nativas para establecer presupuestos mensuales y alertas automatizadas que te avisan cuando alcanzas ciertos

Cómo identificar tráfico IA en Google Analytics

# Analítica

Situación actual El tráfico generado por herramientas de IA como ChatGPT, Claude, Perplexity, Gemini o incluso los AI Overviews de Google no deja de crecer. Este nuevo tipo de tráfico, aunque aún incipiente en muchos sectores, está

Jose Angel Perez