En esta página, se proporcionan algunos ejemplos de cómo consultar los datos de la Facturación de Cloud exportados y almacenados en BigQuery.
Para obtener más información sobre la exportación de tus datos de facturación a BigQuery, consulta la descripción general y las limitaciones.
Genera una consulta en SQL a partir de un informe de facturación
Para escribir con rapidez una consulta de SQL que muestre los resultados equivalentes en BigQuery como los resultados de un informe de facturación, puedes usar la función Generar consulta en Informes de facturación, disponibles en la consola de Google Cloud.
Especifica el nombre de tabla que se usará en tus consultas
En estos ejemplos, para consultar los datos exportados de la Facturación de Cloud en BigQuery, debes especificar la ruta de acceso completa al nombre de la tabla en la cláusula FROM. El nombre de la tabla se determina mediante tres valores separados por puntos:
project-ID.dataset_name.BQ_table_name
- project-ID es el ID del proyecto de Google Cloud que configuraste que contiene tu conjunto de datos de BigQuery.
- dataset_name es el nombre del conjunto de datos de BigQuery que configuraste para contener las tablas de BigQuery con tus datos de la Facturación de Cloud.
BQ_table_name es el nombre de la tabla de BigQuery que contiene los datos exportados de la Facturación de Cloud que deseas consultar.
A las tablas de BigQuery que contienen los datos exportados de la Facturación de Cloud se les asigna un nombre de forma automática, según el tipo de exportación que habilites:
Tabla de costos de uso estándar: En tu conjunto de datos de BigQuery, esta tabla se llama
gcp_billing_export_v1_<BILLING-ACCOUNT-ID>.Tabla de costos de uso detallados: En tu conjunto de datos de BigQuery, esta tabla se llama
gcp_billing_export_resource_v1_<BILLING-ACCOUNT-ID>.Tabla de precios: En tu conjunto de datos de BigQuery, esta tabla se llama
cloud_pricing_export.
Por ejemplo, supongamos que tienes una cuenta de Facturación de Cloud configurada para exportar datos de costos de uso detallados y los componentes de la configuración de exportación de facturación son las siguientes:
- project-ID:
my-billing-project - dataset_name:
my_billing_dataset - BQ_table_name:
gcp_billing_export_resource_v1_<BILLING-ACCOUNT-ID> - BILLING-ACCOUNT-ID:
010101-F0FFF0-10X10X: Es el ID de la cuenta de Facturación de Cloud que contiene los datos de facturación que deseas exportar. Obtén información para encontrar el ID de tu cuenta de facturación.
Según los valores de ejemplo, deberías escribir la cláusula FROM de la siguiente manera:
my-billing-project.my_billing_dataset.gcp_billing_export_resource_v1_010101-F0FFF0-10X10X
Ejemplos de consultas por tipo de datos de Facturación de Cloud
En esta página, se proporcionan ejemplos de consultas para tus datos de costos de uso estándar ,datos de los costos de uso detallados y datos de precios.
Si elegiste exportar datos de costos de uso detallados entonces puedes usar los ejemplos de consultas de costo de uso estándar, además de los ejemplos de consultas de costo de uso detallado.
Ejemplos de consultas de costos de uso estándar
En esta sección, se proporcionan ejemplos de cómo consultar los datos de costos de uso estándar de Facturación de Cloud exportados a BigQuery.
Estos ejemplos de consultas también funcionan con los datos detallados de costos exportados a BigQuery, pese a que no se escriben para recuperar información de nivel de recurso que se proporcione con la opción de exportación de costos de uso detallados.
Valores comunes usados en las consultas de costo estándar de ejemplo
En los ejemplos de consulta de esta sección, se usa el siguiente valor para nombre de tabla: project-ID.dataset.gcp_billing_export_v1_XXXXXX-XXXXXX-XXXXXX
Muestra los costos totales en una factura
En las siguientes consultas, se demuestran dos formas de ver los costos y los valores de crédito mediante datos de facturación exportados.
- El campo
totalsuma directamente el costo de punto flotante y los valores de crédito, lo que puede generar errores de redondeo de punto flotante. - El campo
total_exactconvierte los costos y los valores de crédito en micros antes de sumar; luego, los vuelve a convertir a dólares después de la suma y así evita el error de redondeo de punto flotante.
Ejemplo 1: suma de todos los costos, por factura
Esta consulta muestra el total de la factura de cada mes como una suma de costos regulares, impuestos, ajustes y errores de redondeo.
SQL estándar
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 `project-ID.dataset.gcp_billing_export_v1_XXXXXX-XXXXXX-XXXXXX`
GROUP BY 1
ORDER BY 1 ASC
;
Por ejemplo, el resultado de la consulta anterior podría ser el siguiente:
| Fila | mes | total | total_exact |
|---|---|---|---|
| 1 | 201901 | $1,005.004832999999984 | $1,005.00 |
| 2 | 201902 | $992.3101739999999717 | $992.31 |
| 3 | 201903 | $1,220.761089999999642 | $1,220.76 |
Ejemplo 2: visualiza detalles por tipo de costo, por factura mensual
En esta consulta, se muestran los totales de cada cost_type de cada mes. Los tipos de costos incluyen costos regulares, impuestos, ajustes y errores de redondeo.
SQL estándar
SELECT
invoice.month,
cost_type,
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 `project-ID.dataset.gcp_billing_export_v1_XXXXXX-XXXXXX-XXXXXX`
GROUP BY 1, 2
ORDER BY 1 ASC, 2 ASC
;
Por ejemplo, el resultado de la consulta anterior podría ser el siguiente:
| Fila | mes | cost_type | total | total_exact |
|---|---|---|---|---|
| 1 | 201901 | regular | $1,000.501209987994782 | $1,000.50 |
| 2 | 201901 | rounding_error | –$0.500489920049387 | –$0.50 |
| 3 | 201901 | impuesto | $10.000329958477891 | $10.00 |
| 4 | 201901 | ajuste | –$5.002572999387045 | –$5.00 |
Ejemplos de consultas con etiquetas
En los siguientes ejemplos, se muestran otras maneras de consultar tus datos con etiquetas.
Para los ejemplos de esta sección, supongamos lo siguiente:
- Tienes 2 apps (grapefruit-squeezer y chocolate-masher).
- Para cada app, tienes 2 entornos (dev y prod).
- El entorno dev tiene 1 instancia pequeña por app.
- El entorno prod tiene 1 instancia pequeña en América y 1 instancia pequeña en Asia.
- Cada instancia tiene la etiqueta de la app y el entorno.
- Tienes 1 instancia sin etiqueta que usas para experimentar.
La factura total es de $24 con el siguiente desglose:
| Instancia | Etiquetas | Costo total |
|---|---|---|
| Instancia pequeña con 1 CPU virtual en ejecución en América | Ninguna | $4 |
| Instancia pequeña con 1 CPU virtual en ejecución en América | app: chocolate-masher entorno: desarrollo |
$2 |
| Instancia pequeña con 1 CPU virtual en ejecución en América | app: grapefruit-squeezer entorno: desarrollo |
$3 |
| Instancia pequeña con 1 CPU virtual en ejecución en América | app: chocolate-masher entorno: producción |
$3.25 |
| Instancia pequeña con 1 CPU virtual en ejecución en Asia | app: chocolate-masher entorno: producción |
$3.75 |
| Instancia pequeña con 1 CPU virtual en ejecución en América | app: grapefruit-squeezer entorno: producción |
$3.50 |
| Instancia pequeña con 1 CPU virtual en ejecución en Asia | app: grapefruit-squeezer entorno: producción |
$4.50 |
Consulta cada fila sin agrupar
La manera más detallada de ver estos costos sería consultar cada fila sin agrupar. Supongamos que todos los campos, excepto las etiquetas y la descripción de SKU, son iguales (proyecto, servicio y otros).
SQL estándar
SELECT sku.description, TO_JSON_STRING(labels) as labels, cost as cost FROM `project-ID.dataset.gcp_billing_export_v1_XXXXXX-XXXXXX-XXXXXX`;
SQL heredado
TO_JSON_STRING not supported.
| Fila | sku.description | etiquetas | costo |
|---|---|---|---|
| 1 | Instancia pequeña con 1 CPU virtual en ejecución en América | [] | $4 |
| 2 | Instancia pequeña con 1 CPU virtual en ejecución en América | [{"key":"app","value":"chocolate-masher"},{"key":"environment","value":"dev"}] | $2 |
| 3 | Instancia pequeña con 1 CPU virtual en ejecución en América | [{"key":"app","value":"grapefruit-squeezer"},{"key":"environment","value":"dev"}] | $3 |
| 4 | Instancia pequeña con 1 CPU virtual en ejecución en América | [{"key":"app","value":"chocolate-masher"},{"key":"environment","value":"prod"}] | $3.25 |
| 5 | Instancia pequeña con 1 CPU virtual en ejecución en Asia | [{"key":"app","value":"chocolate-masher"},{"key":"environment","value":"prod"}] | $3.75 |
| 6 | Instancia pequeña con 1 CPU virtual en ejecución en América | [{"key":"app","value":"grapefruit-squeezer"},{"key":"environment","value":"prod"}] | $3.50 |
| 7 | Instancia pequeña con 1 CPU virtual en ejecución en Asia | [{"key":"app","value":"grapefruit-squeezer"},{"key":"environment","value":"prod"}] | $4.50 |
| TOTAL | $24 |
Agrupar por mapa de etiquetas como un Cadena JSON
Esta es una manera rápida y básica de desglosar los costos por cada combinación de etiquetas.
SQL estándar
SELECT TO_JSON_STRING(labels) as labels, sum(cost) as cost FROM `project-ID.dataset.gcp_billing_export_v1_XXXXXX-XXXXXX-XXXXXX` GROUP BY labels;
SQL heredado
TO_JSON_STRING not supported.
| Fila | etiquetas | costo |
|---|---|---|
| 1 | [] | $4 |
| 2 | [{"key":"app","value":"chocolate-masher"},{"key":"environment","value":"dev"}] | $2 |
| 3 | [{"key":"app","value":"grapefruit-squeezer"},{"key":"environment","value":"dev"}] | $3 |
| 4 | [{"key":"app","value":"chocolate-masher"},{"key":"environment","value":"prod"}] | $7 |
| 5 | [{"key":"app","value":"grapefruit-squeezer"},{"key":"environment","value":"prod"}] | USD 8 |
| TOTAL | $24 |
Agrupar por el valor de las etiquetas para una clave específica
Desglosar los costos por valores de una clave de etiqueta específica es un caso práctico común. Si usas LEFT JOIN y pones el filtro de clave en la condición JOIN (en lugar de WHERE), incluyes el costo que no contiene esta clave, por lo que recibes una vista completa de tus costos.
SQL estándar
SELECT labels.value as environment, SUM(cost) as cost FROM `project-ID.dataset.gcp_billing_export_v1_XXXXXX-XXXXXX-XXXXXX` LEFT JOIN UNNEST(labels) as labels ON labels.key = "environment" GROUP BY environment;
SQL heredado
SELECT labels.value as environment, SUM(cost) as cost FROM [project-ID:dataset.gcp_billing_export_v1_XXXXXX-XXXXXX-XXXXXX] WHERE labels.key = "environment" OR labels.key IS NULL GROUP BY environment;
| Fila | entorno | costo |
|---|---|---|
| 1 | prod | $15 |
| 2 | dev | $5 |
| 3 | null | $4 |
| TOTAL | $24 |
Agrupar por pares clave-valor
Ten cuidado cuando interpretes o exportes estos resultados. Cada una de estas filas muestra una suma válida sin conteos duplicados, pero no se debería combinar con otras filas (excepto si la clave es la misma o si tienes certeza de que las claves nunca se configuran en el mismo recurso).
SQL estándar
SELECT labels.key as key, labels.value as value, SUM(cost) as cost FROM `project-ID.dataset.gcp_billing_export_v1_XXXXXX-XXXXXX-XXXXXX` LEFT JOIN UNNEST(labels) as labels GROUP BY key, value;
SQL heredado
SELECT labels.key as key, labels.value as value, SUM(cost) FROM [project-ID:dataset.gcp_billing_export_v1_XXXXXX-XXXXXX-XXXXXX] GROUP BY key, value;
| Fila | clave | valor | costo |
|---|---|---|---|
| 1 | null | null | $4 |
| 2 | app | chocolate-masher | $9 |
| 3 | app | grapefruit-squeezer | $11 |
| 4 | entorno | dev | $5 |
| 5 | entorno | prod | $15 |
| TOTAL | $44 |
Ten en cuenta que la suma total es mayor que la de tu factura.
Consultas sobre los descuentos por compromiso de uso
En las siguientes consultas, se demuestran formas de ver las tarifas y los créditos asociados con los descuentos por compromiso de uso en los datos de facturación exportados. Para comprender cómo se atribuyen las tarifas y los créditos de compromiso a la cuenta y los proyectos de Facturación de Cloud, consulta Atribución de descuentos por compromiso de uso.
Visualiza las tarifas de compromiso
Para ver las tarifas por compromiso de los descuentos por compromiso de uso en la exportación de datos de facturación, usa la siguiente consulta de muestra:
SQL estándar
SELECT
invoice.month AS invoice_month,
SUM(cost) as commitment_fees
FROM `project-ID.dataset.gcp_billing_export_v1_XXXXXX-XXXXXX-XXXXXX`
WHERE LOWER(sku.description) LIKE "commitment%"
GROUP BY 1
Visualiza los créditos de compromiso
Para ver los créditos de descuento por compromiso de uso en la exportación de datos de facturación, usa la siguiente consulta de muestra.
SQL estándar
SELECT
invoice.month AS invoice_month,
SUM(credits.amount) as CUD_credits
FROM `project-ID.dataset.gcp_billing_export_v1_XXXXXX-XXXXXX-XXXXXX`
LEFT JOIN UNNEST(credits) AS credits
WHERE credits.type = "COMMITTED_USAGE_DISCOUNT"
GROUP BY 1
Usa los filtros de la jerarquía de recursos para revisar el principal
Puedes usar filtros de jerarquía de recursos para agregar costos por elementos jerárquicos, como proyectos, carpetas y organizaciones. En estos ejemplos de consulta, se muestran métodos para sumar costos filtrados por elementos de jerarquía de recursos y mostrar los registros del proyecto.
Ejemplo 1: Filtra por nombre de recurso
En este ejemplo, se muestran las consultas que agrupan los costos por principal del proyecto y filtran solo los costos generados en un elemento de jerarquía especificado, identificado por el nombre de recurso relativo.
Método Cadena
SELECT
invoice.month AS invoice_month,
TO_JSON_STRING(project.ancestors) as ancestors,
SUM(cost)
+ SUM(IFNULL((SELECT SUM(c.amount) FROM UNNEST(credits) c), 0))
AS net_cost
FROM `project-ID.dataset.gcp_billing_export_v1_XXXXXX-XXXXXX-XXXXXX` as bq
WHERE TO_JSON_STRING(project.ancestors) like "%resource_name\":\"folders/1234"
GROUP BY invoice_month, ancestors
ORDER BY invoice_month, ancestors
Método UNNEST
SELECT
invoice.month AS invoice_month,
TO_JSON_STRING(project.ancestors) as ancestors,
SUM(cost)
+ SUM(IFNULL((SELECT SUM(c.amount) FROM UNNEST(credits) c), 0))
AS net_cost
FROM `project-ID.dataset.gcp_billing_export_v1_XXXXXX-XXXXXX-XXXXXX` as bq, UNNEST(project.ancestors) as ancestor
WHERE ancestor.resource_name = "folders/1234"
GROUP BY invoice_month, ancestors
ORDER BY invoice_month, ancestors
Ejemplo 2: Filtra por nombre visible
En este ejemplo, se muestran las consultas que agrupan los costos por principal del proyecto y filtran solo los costos generados en un elemento de jerarquía especificado, identificado por el nombre visible proporcionado por el usuario.
Método de coincidencia de Cadena
SELECT
invoice.month AS invoice_month,
TO_JSON_STRING(project.ancestors) as ancestors,
SUM(cost)
+ SUM(IFNULL((SELECT SUM(c.amount) FROM UNNEST(credits) c), 0))
AS net_cost
FROM `project-ID.dataset.gcp_billing_export_v1_XXXXXX-XXXXXX-XXXXXX` as bq
WHERE TO_JSON_STRING(project.ancestors) like "%display_name\":\"MyFolderName%"
GROUP BY invoice_month, ancestors
ORDER BY invoice_month, ancestors
Método UNNEST
SELECT
invoice.month AS invoice_month,
TO_JSON_STRING(project.ancestors) as ancestors,
SUM(cost)
+ SUM(IFNULL((SELECT SUM(c.amount) FROM UNNEST(credits) c), 0))
AS net_cost
FROM `project-ID.dataset.gcp_billing_export_v1_XXXXXX-XXXXXX-XXXXXX` as bq, UNNEST(project.ancestors) as ancestor
WHERE ancestor.display_name = "MyFolderName"
GROUP BY invoice_month, ancestors
ORDER BY invoice_month, ancestors
Ejemplos de consultas con etiquetas de política
En los siguientes ejemplos, se ilustran las maneras de consultar tus datos con etiquetas de política.
Calcula los costos por mes de facturación con etiquetas de política
En la siguiente consulta, se demuestra cómo puedes usar los costos de devolución por mes de facturación para la etiqueta de política cost_center.
SELECT
invoice.month AS invoice_month,
tag.value AS cost_center,
ROUND((SUM(CAST(cost AS NUMERIC))
+ SUM(IFNULL((SELECT SUM (CAST(c.amount AS NUMERIC))
FROM UNNEST(credits) AS c), 0))), 2)
AS net_cost
FROM `project-ID.dataset.gcp_billing_export_resource_v1_XXXXXX-XXXXXX-XXXXXX`, UNNEST(tags) AS tag
WHERE tag.key = "cost_center" AND tag.namespace = "821092389413"
GROUP BY invoice.month, tag.value
ORDER BY invoice.month, tag.value;
Por ejemplo, el resultado de la consulta anterior podría ser el siguiente:
| Fila | invoice_month | cost_center | net_cost |
|---|---|---|---|
| 1 | 202208 | android_mobile_apps | 9.93 |
| 2 | 202208 | ios_mobile_apps | 9.93 |
| 3 | 202209 | android_mobile_apps | 25.42 |
| 4 | 202209 | ios_mobile_apps | 25.4 |
| 5 | 202209 | personalización | 16.08 |
Visualiza los costos de los recursos sin etiquetar
En esta consulta se muestra el total de la factura de los recursos sin etiquetar, agrupados por mes de facturación.
SELECT
invoice.month AS invoice_month,
ROUND((SUM(CAST(cost AS NUMERIC))
+ SUM(IFNULL((SELECT SUM(CAST(c.amount AS NUMERIC))
FROM UNNEST(credits) AS c), 0))), 2)
AS net_cost
FROM
`project-ID.dataset.gcp_billing_export_v1_XXXXXX-XXXXXX-XXXXXX`
WHERE "color" NOT IN (SELECT key FROM UNNEST(tags))
GROUP BY invoice_month
ORDER BY invoice_month;
Por ejemplo, el resultado de la consulta anterior podría ser el siguiente:
| Fila | invoice_month | net_cost |
|---|---|---|
| 1 | 202202 | 0 |
| 2 | 202203 | 16.81 |
| 3 | 202204 | 54.09 |
| 4 | 202205 | 55.82 |
| 5 | 202206 | 54.09 |
| 6 | 202207 | 55.83 |
| 7 | 202208 | 31.49 |
Ejemplos de consulta adicionales
Consulta los costos y créditos por proyecto para un mes de facturación especificado
Si proporcionas junio de 2020 como el mes de facturación específico (en el formato AAAAMM), esta consulta mostrará una vista de los costos y créditos agrupados por proyecto junto con las etiquetas de proyecto.
SQL estándar
SELECT project.name, TO_JSON_STRING(project.labels) as project_labels, sum(cost) as total_cost, SUM(IFNULL((SELECT SUM(c.amount) FROM UNNEST(credits) c), 0)) as total_credits FROM `project-ID.dataset.gcp_billing_export_v1_XXXXXX-XXXXXX-XXXXXX` WHERE invoice.month = "202006" GROUP BY 1, 2 ORDER BY 1;
| Fila | name | project_labels | total_cost | total_credits |
|---|---|---|---|---|
| 1 | CTG - Dev | [{"key":"ctg_p_env","value":"dev"}] | 79.140979 | -4.763796 |
| 2 | CTG - Prod | [{"key":"ctg_p_env","value":"prod"},{"key":"ctg_team","value":"eng"}] | 32.466272 | -3.073356 |
| 3 | CTG - Sandbox | [{"key":"ctg_p_env","value":"dev"}] | 0 | 0 |
| 4 | CTG - Storage | [{"key":"ctg_p_env","value":"prod"},{"key":"ctg_team","value":"data"}] | 7.645793 | -0.003761 |
Consulta los costos para ver las correcciones o el uso de monetización tardía de un mes de facturación específico
Cuando proporcionas un mes de facturación específico y filtras por fecha en la que la fecha de uso se produjo antes del mes de facturación, esta consulta simplificada muestra los totales de costos de las correcciones o retrasados. uso de monetización (cargos que deberían haberse en una factura anterior).
SQL estándar
SELECT
SUM(cost)
+ SUM(IFNULL((SELECT SUM(c.amount)
FROM UNNEST(credits) c), 0))
AS total
FROM `project-ID.dataset.gcp_billing_export_v1_XXXXXX-XXXXXX-XXXXXX`
WHERE
invoice.month = '202403' AND
DATE(TIMESTAMP_TRUNC(usage_start_time, Day, 'US/Pacific')) < '2024-03-01';
Por ejemplo, el resultado de la consulta anterior podría ser el siguiente:
| Fila | total |
|---|---|
| 1 | 3.531752 |
Consulta los detalles de los costos para ver las correcciones o el uso de monetización tardía por servicio para un mes de facturación específico
Este ejemplo demuestra una consulta que muestra un desglose de costos por servicio, para cargos de factura, en los que la fecha de uso ocurrió antes del mes de facturación. Esta consulta muestra los totales de costos y créditos por servicio para correcciones o uso de monetización tardía (cargos que deberían haberse en una factura anterior).
En este ejemplo de consulta, la cláusula WHERE filtra todos los cargos con un mes de facturación de marzo de 2024 (en el formato AAAAMM) y, luego, define mejor los resultados para que solo se muestren los cargos de mes de facturación que tienen una fecha de uso anterior al 1 de marzo de 2024.
SELECT
DATE(TIMESTAMP_TRUNC(usage_start_time, Day, 'US/Pacific')) AS `Day`,
service.description AS `Service Description`,
SUM(CAST(cost_at_list AS NUMERIC)) AS `List cost`,
SUM(CAST(cost AS NUMERIC)) - SUM(CAST(cost_at_list AS NUMERIC)) AS `Negotiated savings`,
SUM(IFNULL((SELECT SUM(CAST(c.amount AS numeric)) FROM UNNEST(credits) c WHERE c.type IN ('SUSTAINED_USAGE_DISCOUNT', 'DISCOUNT', 'SPENDING_BASED_DISCOUNT', 'COMMITTED_USAGE_DISCOUNT', 'FREE_TIER', 'COMMITTED_USAGE_DISCOUNT_DOLLAR_BASE', 'SUBSCRIPTION_BENEFIT', 'RESELLER_MARGIN')), 0)) AS `Discounts`,
SUM(IFNULL((SELECT SUM(CAST(c.amount AS numeric)) FROM UNNEST(credits) c WHERE c.type IN ('CREDIT_TYPE_UNSPECIFIED', 'PROMOTION')), 0)) AS `Promotions and others`,
SUM(CAST(cost_at_list AS NUMERIC)) + SUM(IFNULL((SELECT SUM(CAST(c.amount AS numeric)) FROM UNNEST(credits) c WHERE c.type IN ('SUSTAINED_USAGE_DISCOUNT', 'DISCOUNT', 'SPENDING_BASED_DISCOUNT', 'COMMITTED_USAGE_DISCOUNT', 'FREE_TIER', 'COMMITTED_USAGE_DISCOUNT_DOLLAR_BASE', 'SUBSCRIPTION_BENEFIT', 'RESELLER_MARGIN')), 0)) + SUM(CAST(cost AS NUMERIC)) - SUM(CAST(cost_at_list AS NUMERIC))+ SUM(IFNULL((SELECT SUM(CAST(c.amount AS numeric)) FROM UNNEST(credits) c WHERE c.type IN ('CREDIT_TYPE_UNSPECIFIED', 'PROMOTION')), 0)) AS `Subtotal`
FROM
`project-ID.dataset.gcp_billing_export_v1_XXXXXX-XXXXXX-XXXXXX`
WHERE
invoice.month = '202403' AND
DATE(TIMESTAMP_TRUNC(usage_start_time, Day, 'US/Pacific')) < '2024-03-01'
GROUP BY
Day,
service.description
ORDER BY
Day DESC,
Subtotal DESC;
Por ejemplo, el resultado de la consulta anterior podría ser el siguiente:
| Fila | Día | Descripción del servicio | Costo de lista | Ahorros negociados | Descuentos | Promociones y otros créditos | Subtotal |
|---|---|---|---|---|---|---|---|
| 1 | 2024-02-29 | Compute Engine | 4.39916 | 0 | -1.00916 | 0 | 3.39000 |
| 2 | 2024-02-29 | Asistencia | 0.131969 | 0 | 0 | 0 | 0.131969 |
| 3 | 2024-02-29 | BigQuery | 0.005502 | 0 | 0 | 0 | 0.005502 |
| 4 | 2024-02-29 | Herramientas de redes | 0.010972 | 0 | -0.006691 | 0 | 0.004281 |
Ejemplos de consultas de costos de uso detallados
En esta sección, se proporcionan ejemplos de cómo consultar los datos de costos de uso detallados de Facturación de Cloud exportados a BigQuery.
Debido a que el esquema de costos de uso detallados incluye todos los campos del esquema de costos de uso estándar, los ejemplos de consulta proporcionados para los datos estándar exportados a BigQuery también funciona con los datos detallados que se exportan. Ten en cuenta que los ejemplos de consultas estándar no se escriben para recuperar información de nivel de recurso que se proporcione con la opción de exportación de costos de uso detallados. Cuando creas consultas para los datos detallados puedes usar un ejemplo de consulta estándar como una plantilla, actualizar el nombre de la tabla y agregar cualquiera de los campos que están disponibles en el esquema de costos de uso detallados.
Para conocer más requisitos y limitaciones de los datos detallados exportados, consultaEsquema de los datos de costos de uso detallados.
Valores comunes usados en las consultas de costos detalladas de ejemplo
En los ejemplos de consulta de esta sección, se usa el siguiente valor para nombre de tabla: project-ID.dataset.gcp_billing_export_resource_v1_XXXXXX-XXXXXX-XXXXXX
Muestra los costos a nivel de recurso en una factura
En las siguientes consultas, se demuestran dos formas de ver los costos y los valores de crédito a nivel de recurso en una factura mediante el uso de los datos de facturación exportados.
- El campo
totalsuma directamente el costo de punto flotante y los valores de crédito, lo que puede generar errores de redondeo de punto flotante. - El campo
total_exactconvierte los costos y los valores de crédito en micros antes de sumar; luego, los vuelve a convertir a dólares después de la suma y así evita el error de redondeo de punto flotante.
Suma de costos por cada recurso por factura
Esta consulta muestra el total de la factura de resource.name cada mes como una suma de costos regulares, impuestos, ajustes y errores de redondeo. Cualquier costo no asociado con un elemento a nivel de recurso se agrega en el nombre null del mes.
SQL estándar
SELECT
invoice.month,
resource.name,
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 `project-ID.dataset.gcp_billing_export_resource_v1_XXXXXX-XXXXXX-XXXXXX`
GROUP BY 1, 2
ORDER BY 1 ASC, 2 ASC
;
Por ejemplo, el resultado de la consulta anterior podría ser el siguiente:
| Fila | mes | nombre | total | total_exact |
|---|---|---|---|---|
| 1 | 201901 | null | $1,005.004832999999984 | $1,005.00 |
| 2 | 201901 | backend1 | $781.8499760000028 | $781.85 |
| 3 | 201902 | null | $953.0034923645475983 | $953.03 |
| 4 | 201902 | backend1 | $992.3101739999999717 | $992.31 |
| 5 | 201902 | bitnami-launchpad-wordpress-1-wordpress | $1.2817819999999998 | $1.28 |
Muestra detalles por tipo de costo para cada recurso, por factura mensual
En esta consulta, se muestran los totales de cada cost_type para cada resource.name por mes. Los tipos de costos incluyen costos regulares, impuestos, ajustes y errores de redondeo. Cualquier costo no asociado con un elemento a nivel de recurso se agrega en el nombre null del mes.
SQL estándar
SELECT
invoice.month,
cost_type,
resource.name,
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 `project-ID.dataset.gcp_billing_export_resource_v1_XXXXXX-XXXXXX-XXXXXX`
GROUP BY 1, 2, 3
ORDER BY 1 ASC, 2 ASC, 3 ASC
;
Por ejemplo, el resultado de la consulta anterior podría ser el siguiente:
| Fila | mes | cost_type | nombre | total | total_exact |
|---|---|---|---|---|---|
| 1 | 201901 | regular | null | $1,000.501209987994782 | $1,000.50 |
| 2 | 201901 | rounding_error | null | –$0.500489920049387 | –$0.50 |
| 3 | 201901 | impuesto | null | $10.000329958477891 | $10.00 |
| 4 | 201901 | ajuste | null | –$5.002572999387045 | –$5.00 |
| 5 | 201901 | regular | backend1 | $410.998795012082947 | $411.00 |
| 2 | 201901 | rounding_error | backend1 | –$0.2404900489920378 | –$0.24 |
| 3 | 201901 | impuesto | backend1 | $4.105840329977189 | $4.11 |
Obtén un desglose de costos de los clústeres de Google Kubernetes Engine (GKE)
En esta sección, se proporcionan ejemplos de filtrado de costos de clústeres de GKE en tus informes de exportación de BigQuery. Para obtener más información sobre los costos de los clústeres de GKE, consulta Ve el desglose de los costos de los clústeres.
Filtra los costos de GKE
Las siguientes consultas de ejemplo muestran cómo filtrar y agrupar los costos de GKE para los tipos de recursos admitidos por nombre de clúster, espacio de nombres y etiqueta.
Costos de los clústeres de GKE antes de los créditos
SELECT SUM(cost) AS cost_before_credits, labels.value AS cluster_name FROM `project-ID.dataset.gcp_billing_export_resource_v1_XXXXXX-XXXXXX-XXXXXX` LEFT JOIN UNNEST(labels) as labels ON labels.key = "goog-k8s-cluster-name" GROUP BY labels.value ;
Costos de GKE después los de créditos por espacio de nombres
SELECT labels.value as namespace, SUM(cost) + SUM(IFNULL((SELECT SUM(c.amount) FROM UNNEST(credits) c), 0)) AS cost_after_credits, FROM `project-ID.dataset.gcp_billing_export_resource_v1_XXXXXX-XXXXXX-XXXXXX` LEFT JOIN UNNEST(labels) as labels ON labels.key = "k8s-namespace" GROUP BY namespace ;
Costos de GKE por SKU
SELECT project.id AS project_id, labels.value AS cluster_name, sku.id AS sku_id, sku.description AS sku_description, SUM(cost) AS cost FROM `project-ID.dataset.gcp_billing_export_resource_v1_XXXXXX-XXXXXX-XXXXXX` JOIN UNNEST(labels) AS labels ON labels.key = "goog-k8s-cluster-name" GROUP BY cluster_name, project_id, sku_description, sku_id ;
Ejemplos de consultas de datos de precios
En esta sección, se proporcionan ejemplos diferentes de cómo consultar los datos de precios de la Facturación de Cloud exportados a BigQuery.
Valores comunes que se usan en las consultas de precios de ejemplo
En los ejemplos de consultas de esta sección, se usan los siguientes valores:
- Nombre de la tabla:
project-ID.dataset.cloud_pricing_export - ID de SKU:
2DA5-55D3-E679(Cloud Run: Solicitudes)
Obtén precios de listas para un SKU específico
En este ejemplo, se muestra una consulta básica que muestra el objeto list_price para cada nivel de precios de un SKU especificado.
SQL estándar
SELECT sku.id, sku.description, list_price.*
FROM `project-ID.dataset.cloud_pricing_export`
WHERE DATE(_PARTITIONTIME) = "2020-07-20"
AND sku.id = "2DA5-55D3-E679"
;
_PARTITIONTIME es un campo que BigQuery genera de forma automática y representa la fecha a la que pertenecen los datos. En lugar de _PARTITIONTIME, puedes usar un campo que la exportación de Facturación de Cloud genera de forma explícita, como pricing_as_of_time.
Esta es la misma consulta configurada para usar el campo pricing_as_of_time:
SELECT sku.id, sku.description, list_price.*
FROM `project-ID.dataset.cloud_pricing_export`
WHERE DATE(pricing_as_of_time) = "2020-07-20"
AND sku.id = "2DA5-55D3-E679"
;
Resultados de la consulta
| Fila | id | descripción | pricing_unit | aggregation_info. aggregation_level |
aggregation_info. aggregation_interval |
tiered_rates. pricing_unit_quantity |
tiered_rates. start_usage_amount |
tiered_rates. usd_amount |
tiered_rates. account_currency_amount |
|---|---|---|---|---|---|---|---|---|---|
| 1 | 2DA5-55D3-E679 | Solicitudes | COUNT | CUENTA | MENSUAL | 1000000 | 0 | 0 | 0 |
| 1000000 | 2000000 | 0.4 | 0.4 |
Obtén precios de lista para un SKU específico e incluye la descripción del servicio
En los dos ejemplos de esta sección, se exponen consultas que muestran el list_price para cada nivel de precios de un SKU especificado, y, además, incluye la descripción del SKU y la descripción del servicio.
- En el ejemplo 1, se muestra un SKU por fila, con los niveles de precios que se muestran como datos anidados.
- En el ejemplo 2, se muestra cómo desanidar los datos para mostrar una fila por SKU por nivel de precios.
Ejemplo 1: Muestra datos anidados
En este ejemplo, se consulta un solo SKU para que se muestren los datos de list_price. Este SKU tiene varios niveles de precios.
Los valores del campo de precio de lista se muestran en filas individuales anidadas en la fila de ID del SKU.
SQL estándar
SELECT sku.id AS sku_id,
sku.description AS sku_description,
service.id AS service_id,
service.description as service_description,
list_price.*
FROM project-ID.dataset.cloud_pricing_export
WHERE DATE(_PARTITIONTIME) = "2020-07-20"
AND sku.id = "2DA5-55D3-E679"
;
Resultados de la consulta:
| Fila | sku_id | sku_description | service_id | service_description | aggregation_info. aggregation_level |
aggregation_info. aggregation_interval |
tiered_rates. pricing_unit_quantity |
tiered_rates. start_usage_amount |
tiered_rates. usd_amount |
tiered_rates. account_currency_amount |
|---|---|---|---|---|---|---|---|---|---|---|
| 1 | 2DA5-55D3-E679 | Solicitudes | 152E-C115-5142 | Cloud Run | CUENTA | MENSUAL | 1000000 | 0 | 0 | 0 |
| 1000000 | 2000000 | 0.4 | 0.4 |
Ejemplo 2: Muestra datos no anidados con la misma tabla
En este ejemplo, se consulta un solo SKU para que se muestre list price. El SKU tiene varios niveles de precios.
En la consulta, se muestra el uso del operador UNNEST para compactar el arreglo tiered_rates y unir los campos con la misma tabla, lo que genera una fila por nivel de precios.
SQL estándar
SELECT sku.id AS sku_id,
sku.description AS sku_description,
service.id AS service_id,
service.description as service_description,
tier.*
FROM `project-ID.dataset.cloud_pricing_export` as sku_pricing, UNNEST (sku_pricing.list_price.tiered_rates) as tier
WHERE DATE(_PARTITIONTIME) = "2020-07-20"
AND sku.id = "2DA5-55D3-E679"
;
Resultados de la consulta:
| Fila | sku_id | sku_description | service_id | service_description | pricing_unit_quantity | start_usage_amount | usd_amount | account_currency_amount |
|---|---|---|---|---|---|---|---|---|
| 1 | 2DA5-55D3-E679 | Solicitudes | 152E-C115-5142 | Cloud Run | 1000000.0 | 0.0 | 0.0 | 0.0 |
| 2 | 2DA5-55D3-E679 | Solicitudes | 152E-C115-5142 | Cloud Run | 1000000.0 | 2000000.0 | 0.4 | 0.4 |
Usar la taxonomía de productos y la taxonomía geográfica para consultar los SKU
- La taxonomía de productos es una lista de categorías de productos que se aplican al SKU, como sin servidores, Cloud Run o VMs a pedido.
- La taxonomía geográfica son los metadatos geográficos que se aplican a un SKU y consisten en valores de tipo y región.
Obtén la taxonomía de producto de un SKU
En este ejemplo, se observa una consulta que muestra la lista product_taxonomy para un SKU especificado, en el que el ID de SKU = 2DA5-55D3-E679 (Cloud Run: Solicitudes).
SQL estándar
SELECT sku.id AS sku_id,
sku.description AS sku_description,
service.id AS service_id,
service.description as service_description,
product_taxonomy
FROM `project-ID.dataset.cloud_pricing_export`
WHERE DATE(_PARTITIONTIME) = "2020-07-20"
AND sku.id = "2DA5-55D3-E679"
;
Resultados de la consulta:
| Fila | sku_id | sku_description | service_id | service_description | product_taxonomy |
|---|---|---|---|---|---|
| 1 | 2DA5-55D3-E679 | Solicitudes | 152E-C115-5142 | Cloud Run | GCP |
| Sin servidores | |||||
| Cloud Run | |||||
| Otro |
Obtén todos los SKU de una taxonomía de productos específica
En este ejemplo, se observa una consulta que muestra todos los SKU que coinciden con un product_taxonomy especificado.
En esta consulta, especificamos sin servidores como el valor product taxonomy.
SQL estándar
SELECT sku.id AS sku_id,
sku.description AS sku_description,
service.id AS service_id,
service.description as service_description,
product_taxonomy
FROM `project-ID.dataset.cloud_pricing_export`
WHERE DATE(_PARTITIONTIME) = "2020-07-20"
AND "Serverless" in UNNEST(product_taxonomy)
LIMIT 10
;
Resultados de la consulta:
| Fila | sku_id | sku_description | service_id | service_description | product_taxonomy |
|---|---|---|---|---|---|
| 1 | 0160-BD7B-4C40 | Salida de red de Cloud Tasks dentro de la región | F3A6-D7B7-9BDA | Cloud Tasks | GCP |
| Sin servidores | |||||
| Cloud Tasks | |||||
| Otro | |||||
| 2 | FE08-0A74-7AFD | Salida de GOOGLE-API de Cloud Tasks | F3A6-D7B7-9BDA | Cloud Tasks | GCP |
| Sin servidores | |||||
| Cloud Tasks | |||||
| Otro | |||||
| 3 | A81A-32A2-B46D | Almacenamiento de lista de tareas en cola de Salt Lake City | F17B-412E-CB64 | App Engine | GCP |
| Sin servidores | |||||
| GAE | |||||
| Otro | |||||
| TaskQueue |
Obtén todos los SKU para una taxonomía geográfica y una taxonomía de productos específicas
En este ejemplo, se observa una consulta que muestra todos los SKU que coinciden con una región geo_taxonomy y una product_taxonomy especificadas, en las que region = us-east4 y product_taxonomy = VM a pedido.
SQL estándar
SELECT sku.id AS sku_id,
sku.description AS sku_description,
service.id AS service_id,
service.description as service_description,
geo_taxonomy,
product_taxonomy
FROM `project-ID.dataset.cloud_pricing_export`
WHERE DATE(_PARTITIONTIME) = "2020-07-20"
AND "VMs On Demand" in UNNEST(product_taxonomy)
AND geo_taxonomy.type = "REGIONAL"
AND "us-east4" in UNNEST (geo_taxonomy.regions)
;
Resultados de la consulta:
| Fila | sku_id | sku_description | service_id | service_description | geo_taxonomy.type | geo_taxonomy.regions | product_taxonomy |
|---|---|---|---|---|---|---|---|
| 1 | 9174-81EE-425B | Usuario único Premium para RAM de instancia de usuario único que se ejecuta en Virginia | 6F81-5844-456A | Compute Engine | REGIONAL | us-east4 | GCP |
| Procesamiento | |||||||
| GCE | |||||||
| VM a pedido | |||||||
| Memoria: por GB | |||||||
| 2 | C3B9-E891-85ED | RAM de instancia de usuario única que se ejecuta en Virginia | 6F81-5844-456A | Compute Engine | REGIONAL | us-east4 | GCP |
| Procesamiento | |||||||
| GCE | |||||||
| VM a pedido | |||||||
| Memoria: por GB | |||||||
| 3 | 6E2A-DCD9-87ED | RAM de instancia predefinida N1 que se ejecuta en Virginia | 6F81-5844-456A | Compute Engine | REGIONAL | us-east4 | GCP |
| Procesamiento | |||||||
| GCE | |||||||
| VM a pedido | |||||||
| Memoria: por GB |
Une datos de precios con datos detallados de costos de uso
En esta consulta, se muestra cómo unir las exportaciones de datos de precios y costos para ver la información de precios detallada en línea con tus costos. Puedes configurar esta consulta para extraer datos exportados de tus datos detallados de costos de uso (como Exports) y unir los datos de costos de uso con tus datos de precios exportados (como Prices).
Usa el nombre de la tabla de costos de uso detallados para extraer los datos de Exports: gcp_billing_export_resource_v1_<BILLING_ACCOUNT_ID>
Usa el nombre de la tabla de precios para los datos de Prices: project-ID.dataset.cloud_pricing_export
WITH
Exports AS (
SELECT *
FROM `project-ID.dataset.gcp_billing_export_resource_v1_XXXXXX-XXXXXX-XXXXXX`
),
Prices AS (
SELECT *
FROM `project-ID.dataset.cloud_pricing_export`
)
SELECT
Exports.sku.description AS sku_description,
Exports.cost,
Exports.usage,
FlattenedPrices.pricing_unit_description,
FlattenedPrices.account_currency_amount,
FlattenedPrices.account_currency_code,
FROM Exports
JOIN (SELECT * FROM Prices CROSS JOIN UNNEST(Prices.list_price.tiered_rates)) AS FlattenedPrices
ON
Exports.sku.id = FlattenedPrices.sku.id
AND Exports.price.tier_start_amount = FlattenedPrices.start_usage_amount
WHERE
DATE(Exports.export_time) = '2023-06-30'
AND DATE(FlattenedPrices.export_time) = '2023-06-30'
AND cost > 0
LIMIT 1000
Por ejemplo, el resultado de la consulta anterior podría ser el siguiente:
| sku_description | costo | uso | pricing_unit_description | account_currency_amount | account_currency_code |
|---|---|---|---|---|---|
| Capacidad de PD equilibrada | 0.001345 | { "usage": { "amount": "38654705664000.0", "unit": "byte-seconds", "amount_in_pricing_units": "0.01345895", "pricing_unit": "gibibyte month" } } | gibibyte por mes | 0.1 | USD |
| Capacidad de PD equilibrada | 0.001344 | { "usage": { "amount": "38654705664000.0", "unit": "byte-seconds", "amount_in_pricing_units": "0.01345895", "pricing_unit": "gibibyte month" } } | gibibyte por mes | 0.1 | USD |
| Capacidad de PD equilibrada | 0.001346 | { "usage": { "amount": "38654705664000.0", "unit": "byte-seconds", "amount_in_pricing_units": "0.01345895", "pricing_unit": "gibibyte month" } } | gibibyte por mes | 0.1 | USD |
Temas relacionados
Temas relacionados con los datos exportados de la Facturación de Cloud
- Configura la exportación de datos de la Facturación de Cloud a BigQuery
- Comprende las tablas de datos de la Facturación de Cloud en BigQuery
- Visualiza el gasto en el tiempo con Looker Studio
Informes de costos y precios disponibles en la consola de Google Cloud
- Visualiza los informes de Facturación de Cloud y las tendencias de costos.
- Visualiza y descarga los detalles del costo de tu factura o extracto
- Visualiza y descarga los precios de los servicios en la nube de Google
- Obtén información sobre los ahorros con informes de desglose de costos
- Analizar la efectividad de los descuentos por compromiso de uso
- Visualiza el historial de costos y pagos.