Cette page fournit des exemples d'interrogation des données Cloud Billing exportées vers et stockées dans BigQuery.
Pour en savoir plus sur l'exportation des données de facturation vers BigQuery, consultez la présentation et les limites.
Générer une requête SQL à partir d'un rapport de facturation
Pour écrire rapidement une requête SQL qui renvoie les résultats équivalents dans BigQuery sous forme de résultats dans un rapport de facturation, vous pouvez utiliser la fonctionnalité Générer une requête dans Rapports de facturation, disponibles dans la console Google Cloud.
Spécifier le nom de la table à utiliser dans vos requêtes
Dans ces exemples, pour interroger vos données Cloud Billing exportées dans BigQuery, vous devez spécifier le chemin d'accès complet au nom de la table dans la clause FROM. Le nom de la table est déterminé à l'aide de trois valeurs séparées par des points :
project-ID.dataset_name.BQ_table_name
- project-ID est l'ID du projet Google Cloud que vous configurez et qui contient votre ensemble de données BigQuery.
- dataset_name est le nom de l'ensemble de données BigQuery que vous avez configuré pour qu'il contienne les tables BigQuery comprenant vos données Cloud Billing.
BQ_table_name est le nom de la table BigQuery qui contient les données Cloud Billing exportées que vous souhaitez interroger.
Un nom est automatiquement attribué aux tables BigQuery contenant les données Cloud Billing exportées en fonction du type d'exportation que vous activez :
Table de coût d'utilisation standard : dans votre ensemble de données BigQuery, cette table est nommée
gcp_billing_export_v1_<BILLING-ACCOUNT-ID>.Table de coût d'utilisation détaillé : dans votre ensemble de données BigQuery, cette table est nommée
gcp_billing_export_resource_v1_<BILLING-ACCOUNT-ID>.Grille tarifaire : dans votre ensemble de données BigQuery, cette table est nommée
cloud_pricing_export.
Par exemple, supposons que vous disposiez d'un compte de facturation Cloud configuré pour exporter les données de coût d'utilisation détaillé et que les composants de la configuration de l'exportation de la facturation soient les suivantes :
- 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: ID du compte de facturation Cloud qui contient les données de facturation que vous exportez. Découvrez comment trouver votre ID de compte de facturation.
En fonction des exemples de valeurs, vous devriez écrire la clause FROM comme suit :
my-billing-project.my_billing_dataset.gcp_billing_export_resource_v1_010101-F0FFF0-10X10X
Exemples de requêtes par type de données Cloud Billing
Cette page fournit des exemples de requêtes pour vos données de coût d'utilisation standard, vos données de coût d'utilisation détaillé, et vos données de tarification.
Si vous avez choisi d'exporter les Données détaillées de coût d'utilisation vous pouvez utiliser les exemples de requête du Coût d'utilisation standard en plus des exemples de requête du Coût d'utilisation détaillé.
Exemples de requêtes de coût d'utilisation standard
Cette section fournit des exemples d'interrogation des données de coût d'utilisation standard de Cloud Billing exportées vers BigQuery.
Ces exemples de requêtes fonctionnent également avec les données de coût d'utilisation détaillé exportées vers BigQuery, bien qu'ils ne soient pas écrits pour récupérer les informations au niveau des ressources fournies avec cette option d'exportation de coût d'utilisation détaillé.
Valeurs courantes utilisées dans les exemples de requêtes de coût standard
Les exemples de requête de cette section utilisent la valeur suivante pour le Nom de la table : project-ID.dataset.gcp_billing_export_v1_XXXXXX-XXXXXX-XXXXXX
Afficher les coûts totaux sur une facture
Les requêtes suivantes illustrent deux méthodes d'affichage des valeurs de coût et de crédit à l'aide de données de facturation exportées.
- Le champ
totaladditionne directement les valeurs de coût et de crédit à virgule flottante, ce qui peut entraîner des erreurs d'arrondi à virgule flottante. - Le champ
total_exactconvertit les coûts et les valeurs de crédit en micro-unités avant de les additionner, puis les reconvertit en dollars après la somme, évitant ainsi les erreurs d'arrondi à virgule flottante.
Exemple 1 : Somme de tous les coûts, par facture
Cette requête affiche le total de la facture pour chaque mois, sous forme de somme des coûts réguliers, des taxes, des ajustements et des erreurs d'arrondi.
SQL standard
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
;
Par exemple, le résultat de la requête précédente peut être celui-ci :
| Ligne | mois | total | total_exact |
|---|---|---|---|
| 1 | 201901 | $1005.004832999999984 | $1005.00 |
| 2 | 201902 | $992.3101739999999717 | $992.31 |
| 3 | 201903 | $1220.761089999999642 | $1220.76 |
Exemple 2 : Renvoyer des détails par type de coût, par mois de facturation
Cette requête affiche les totaux de chaque type de coût cost_type pour chaque mois. Les types de coûts comprennent les coûts réguliers, les taxes, les ajustements et les erreurs d'arrondi.
SQL standard
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
;
Par exemple, le résultat de la requête précédente peut être celui-ci :
| Ligne | mois | cost_type | total | total_exact |
|---|---|---|---|---|
| 1 | 201901 | regular | $1000.501209987994782 | $1000.50 |
| 2 | 201901 | rounding_error | –$0.500489920049387 | –$0.50 |
| 3 | 201901 | tax | $10.000329958477891 | $10.00 |
| 4 | 201901 | adjustment | –$5.002572999387045 | –$5.00 |
Exemples de requêtes avec des libellés
Les exemples suivants illustrent d'autres façons d'exécuter des requêtes sur les données avec des libellés.
En ce qui concerne les exemples de cette section, nous supposons ce qui suit :
- Vous possédez deux applications (presse-agrumes et pilon-à-chocolat).
- Pour chaque application, vous avez deux environnements (développement et production).
- L'environnement de développement dispose d'une petite instance par application.
- L'environnement de production dispose d'une petite instance en Amérique et d'une petite instance en Asie.
- Chaque instance présente un libellé indiquant l'application et l'environnement.
- Vous possédez une instance sans libellé que vous utilisez pour les tests.
Votre facture totale s'élève à 24 $. Voici le détail :
| Instance | Libellés | Coût total |
|---|---|---|
| Petite instance avec un processeur virtuel exécuté en Amérique | Aucun | 4 $ |
| Petite instance avec un processeur virtuel exécuté en Amérique | application : pilon-à-chocolat environnement : dev |
2 $ |
| Petite instance avec un processeur virtuel exécuté en Amérique | application : presse-agrumes environnement : dev |
3 $ |
| Petite instance avec un processeur virtuel exécuté en Amérique | application : pilon-à-chocolat environnement : prod |
3,25 $ |
| Petite instance avec un processeur virtuel exécuté en Asie | application : pilon-à-chocolat environnement : prod |
3,75 $ |
| Petite instance avec un processeur virtuel exécuté en Amérique | application : presse-agrumes environnement : prod |
3,50 $ |
| Petite instance avec un processeur virtuel exécuté en Asie | application : presse-agrumes environnement : prod |
4,50 $ |
Exécuter des requêtes sur chaque ligne sans les grouper
Pour obtenir le rapport le plus détaillé des coûts, vous devez exécuter des requêtes sur chaque ligne sans les grouper. Supposons que tous les champs, sauf les libellés et la description du SKU, sont identiques (projet, service, etc.).
SQL standard
SELECT sku.description, TO_JSON_STRING(labels) as labels, cost as cost FROM `project-ID.dataset.gcp_billing_export_v1_XXXXXX-XXXXXX-XXXXXX`;
Ancien SQL
TO_JSON_STRING not supported.
| Ligne | sku.description | Libellés | Coût |
|---|---|---|---|
| 1 | Petite instance avec un processeur virtuel exécuté en Amérique | [] | 4 $ |
| 2 | Petite instance avec un processeur virtuel exécuté en Amérique | [{"key":"app","value":"chocolate-masher"},{"key":"environment","value":"dev"}] | 2 $ |
| 3 | Petite instance avec un processeur virtuel exécuté en Amérique | [{"key":"app","value":"grapefruit-squeezer"},{"key":"environment","value":"dev"}] | 3 $ |
| 4 | Petite instance avec un processeur virtuel exécuté en Amérique | [{"key":"app","value":"chocolate-masher"},{"key":"environment","value":"prod"}] | 3,25 $ |
| 5 | Petite instance avec un processeur virtuel exécuté en Asie | [{"key":"app","value":"chocolate-masher"},{"key":"environment","value":"prod"}] | 3,75 $ |
| 6 | Petite instance avec un processeur virtuel exécuté en Amérique | [{"key":"app","value":"grapefruit-squeezer"},{"key":"environment","value":"prod"}] | 3,50 $ |
| 7 | Petite instance avec un processeur virtuel exécuté en Asie | [{"key":"app","value":"grapefruit-squeezer"},{"key":"environment","value":"prod"}] | 4,50 $ |
| TOTAL | 24 $ |
Grouper par correspondance de libellés en tant que chaîne JSON
Cette méthode vous permet de rapidement et facilement détailler les coûts pour chaque combinaison de libellés.
SQL standard
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;
Ancien SQL
TO_JSON_STRING not supported.
| Ligne | Libellés | Coût |
|---|---|---|
| 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"}] | 8 $ |
| TOTAL | 24 $ |
Grouper par valeur de libellés pour une clé spécifique
Il est fréquent de détailler les coûts pour les valeurs d'une clé de libellé spécifique. En utilisant la jointure LEFT JOIN et en plaçant le filtre de clé dans la condition JOIN (plutôt que WHERE), vous incluez les coûts qui ne contiennent pas cette clé. Vous obtenez ainsi une vue complète de vos coûts.
SQL standard
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;
Ancien SQL
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;
| Ligne | Environnement | Coût |
|---|---|---|
| 1 | production | 15 $ |
| 2 | développement | 5 $ |
| 3 | vide | 4 $ |
| TOTAL | 24 $ |
Grouper par paires valeur/clé
Soyez prudent lorsque vous interprétez ou exportez ces résultats. Une ligne individuelle affiche ici une somme valide sans que l'utilisation soit comptabilisée deux fois. Toutefois, elle ne doit pas être combinée avec d'autres lignes (sauf si la clé est la même ou si vous êtes certain que les clés ne sont jamais définies sur la même ressource).
SQL standard
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;
Ancien SQL
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;
| Ligne | Clé | Valeur | Coût |
|---|---|---|---|
| 1 | null | vide | 4 $ |
| 2 | application | pilon-à-chocolat | 9 $ |
| 3 | application | presse-agrumes | 11 $ |
| 4 | environnement | développement | 5 $ |
| 5 | environnement | production | 15 $ |
| TOTAL | 44 $ |
Notez que le coût total est supérieur au montant de votre facture.
Requêtes pour la remise sur engagement d'utilisation
Les requêtes suivantes montrent comment afficher les frais et les crédits associés aux remises sur engagement d'utilisation dans les données de facturation exportées. Pour comprendre comment vos frais d'engagement et vos crédits sont appliqués à votre compte et à vos projets Cloud Billing, consultez la section Attribution des remises sur engagement d'utilisation.
Afficher les frais d'engagement
Pour afficher les frais d'engagement pour vos remises sur engagement d'utilisation dans votre exportation de données de facturation, utilisez l'exemple de requête suivant.
SQL standard
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
Afficher les crédits d'engagement
Pour afficher vos crédits de remise sur engagement d'utilisation dans votre exportation de données de facturation, utilisez l'exemple de requête suivant.
SQL standard
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
Utiliser les filtres de hiérarchie des ressources pour examiner l'ascendance
Vous pouvez utiliser les filtres de hiérarchie des ressources pour regrouper les coûts par éléments de hiérarchie, tels que les projets, les dossiers et les organisations. Ces exemples de requêtes montrent des méthodes permettant d'additionner les coûts filtrés en fonction des éléments de la hiérarchie des ressources et d'afficher les ancêtres du projet.
Exemple 1 : Filtrer par nom de ressource
Cet exemple présente des requêtes qui regroupent les coûts par ancêtre de projet et appliquent un filtrage pour ne retenir que les coûts générés sous un élément de hiérarchie spécifié, identifié par le nom de ressource relatif.
Méthode chaîne
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éthode 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
Exemple 2 : Filtrer par nom à afficher
Cet exemple présente des requêtes qui regroupent les coûts par ancêtre de projet et appliquent un filtrage pour ne retenir que les coûts générés sous un élément de hiérarchie spécifié, identifié par le nom à afficher fourni par l'utilisateur.
Méthode de correspondance de chaînes
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éthode 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
Exemples de requêtes avec des tags
Les exemples suivants montrent comment interroger des données avec des tags.
Calculer les coûts par mois de facturation avec des tags
La requête suivante montre comment utiliser les frais de retour par mois de facturation pour le tag 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;
Par exemple, le résultat de la requête précédente peut être celui-ci :
| Ligne | 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 | personalization | 16.08 |
Afficher les coûts des ressources sans tag
Cette requête affiche le total de la facture pour les ressources sans tags, regroupées par mois de facturation.
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;
Par exemple, le résultat de la requête précédente peut être celui-ci :
| Ligne | 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 |
Exemples de requête supplémentaires
Exécuter des requêtes sur les coûts et crédits par projet pour un mois de facturation spécifié
Lorsque vous lui fournissez un mois de facturation spécifique au format AAAAMM (dans l'exemple, le mois de juin 2020), cette requête renvoie les coûts et les crédits regroupés par projet, ainsi que les libellés de projet.
SQL standard
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;
| Ligne | 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 |
Coûts des requêtes pour afficher les corrections ou l'utilisation monétisée tardive pour un mois de facturation spécifié
En spécifiant un mois de facturation spécifique et en filtrant par date à laquelle la date d'utilisation s'est produite avant le mois de facturation, cette requête simplifiée renvoie les coûts totaux pour les corrections ou l'utilisation monétisée tardive (frais qui auraient dû apparaître sur une facture précédente).
SQL standard
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';
Par exemple, le résultat de la requête précédente peut être celui-ci :
| Ligne | total |
|---|---|
| 1 | 3.531752 |
Interroger les détails des coûts pour afficher les corrections ou l'utilisation monétisée tardive par service pour un mois de facturation spécifié
Cet exemple illustre une requête qui renvoie la répartition des coûts par service, pour les frais de facturation, où la date d'utilisation s'est produite avant le mois de facturation. Cette requête renvoie les totaux de coûts et de crédits par service pour les corrections ou l'utilisation monétisée tardive (frais qui auraient dû apparaître sur une facture précédente).
Dans cet exemple de requête, la clause WHERE filtre tous les frais ayant un mois de facturation correspondant à mars 2024 (au format AAAAMM), puis affine les résultats pour ne renvoyer que les frais du mois de facturation dont la date d'utilisation est antérieure au 1er mars 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;
Par exemple, le résultat de la requête précédente peut être celui-ci :
| Ligne | Jour | Description du service | Coût catalogue | Remises négociées | Remises | Promotions et autres | Sous-total |
|---|---|---|---|---|---|---|---|
| 1 | 2024-02-29 | Compute Engine | 4.39916 | 0 | -1.00916 | 0 | 3.39000 |
| 2 | 2024-02-29 | Assistance | 0.131969 | 0 | 0 | 0 | 0.131969 |
| 3 | 2024-02-29 | BigQuery | 0.005502 | 0 | 0 | 0 | 0.005502 |
| 4 | 2024-02-29 | Mise en réseau | 0.010972 | 0 | -0.006691 | 0 | 0.004281 |
Exemples de requêtes de coût d'utilisation détaillé
Cette section fournit des exemples d'interrogation des données de coût d'utilisation détaillé de Cloud Billing exportées vers BigQuery.
Étant donné que le schéma de coût d'utilisation détaillé comprend tous les champs du schéma de coût d'utilisation standard, les exemples de requête fournis pour les données standard exportées vers BigQuery fonctionnent également avec les données détaillées exportées. Notez que les exemples de requêtes standards ne sont pas écrits pour récupérer les informations au niveau des ressources fournies avec l'option d'exportation de coût d'utilisation détaillé. Lorsque vous créez des requêtes pour obtenir les données détaillées, vous pouvez utiliser un exemple de requête standard comme modèle, mettre à jour le Nom de la table et ajouter un ou plusieurs des champs disponibles dans le schéma de coût d'utilisation détaillé.
Pour connaître les autres exigences et limites relatives aux données détaillées exportées, consultez la section Schéma des données de coût d'utilisation détaillé.
Valeurs courantes utilisées dans les exemples de requêtes de coût détaillé
Les exemples de requête de cette section utilisent la valeur suivante pour le Nom de la table : project-ID.dataset.gcp_billing_export_resource_v1_XXXXXX-XXXXXX-XXXXXX
Afficher les coûts au niveau des ressources sur une facture
Les requêtes suivantes illustrent deux méthodes d'affichage des valeurs de coût et de crédit au niveau des ressources sur une facture à l'aide de données de facturation exportées.
- Le champ
totaladditionne directement les valeurs de coût et de crédit à virgule flottante, ce qui peut entraîner des erreurs d'arrondi à virgule flottante. - Le champ
total_exactconvertit les coûts et les valeurs de crédit en micro-unités avant de les additionner, puis les reconvertit en dollars après la somme, évitant ainsi les erreurs d'arrondi à virgule flottante.
Somme des coûts pour chaque ressource, par facture
Cette requête affiche le total de la facture pour chaque resource.name par mois, sous forme de somme des coûts réguliers, des taxes, des ajustements et des erreurs d'arrondi. Les coûts qui ne sont pas associés à un élément au niveau des ressources sont regroupés sous le nom null pour le mois.
SQL standard
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
;
Par exemple, le résultat de la requête précédente peut être celui-ci :
| Ligne | mois | nom | total | total_exact |
|---|---|---|---|---|
| 1 | 201901 | null | $1005.004832999999984 | $1005.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 $ |
Afficher les détails par type de coût pour chaque ressource, par mois de facturation
Cette requête affiche les totaux de chaque cost_type pour chaque resource.name par mois. Les types de coûts comprennent les coûts réguliers, les taxes, les ajustements et les erreurs d'arrondi. Les coûts qui ne sont pas associés à un élément au niveau des ressources sont regroupés sous le nom null pour le mois.
SQL standard
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
;
Par exemple, le résultat de la requête précédente peut être celui-ci :
| Ligne | mois | cost_type | nom | total | total_exact |
|---|---|---|---|---|---|
| 1 | 201901 | regular | null | $1000.501209987994782 | $1000.50 |
| 2 | 201901 | rounding_error | null | –$0.500489920049387 | –$0.50 |
| 3 | 201901 | tax | null | $10.000329958477891 | $10.00 |
| 4 | 201901 | adjustment | null | –$5.002572999387045 | –$5.00 |
| 5 | 201901 | regular | backend1 | $410.998795012082947 | $411.00 |
| 2 | 201901 | rounding_error | backend1 | –$0.2404900489920378 | –$0.24 |
| 3 | 201901 | tax | backend1 | $4.105840329977189 | $4.11 |
Obtenir la répartition des coûts de cluster Google Kubernetes Engine (GKE)
Cette section fournit des exemples de filtrage des coûts de cluster GKE dans vos rapports d'exportation BigQuery. Pour en savoir plus sur les coûts de cluster GKE, consultez la page Afficher la répartition des coûts du cluster.
Filtrer les coûts GKE
Les exemples de requêtes suivants vous montrent comment filtrer et regrouper vos coûts GKE pour les types de ressources compatibles par nom de cluster, espace de noms et libellé.
Coûts liés aux clusters GKE avant crédits
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 ;
Coûts GKE après crédits par espace de noms
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 ;
Coûts GKE par code 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 ;
Exemples de requêtes pour les données de tarification
Cette section fournit différents exemples expliquant comment interroger les données de tarification Cloud Billing exportées vers BigQuery.
Valeurs courantes utilisées dans les exemples de requêtes de tarification
Les exemples de requête de cette section utilisent les valeurs suivantes :
- Nom de la table :
project-ID.dataset.cloud_pricing_export - ID du code SKU :
2DA5-55D3-E679(Cloud Run – Requêtes)
Obtenir les prix catalogue pour un code SKU spécifique
Cet exemple présente une requête simple qui renvoie la valeur list_price pour chaque niveau de tarification d'un code SKU spécifié.
SQL standard
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 est un champ généré automatiquement par BigQuery qui représente la date à laquelle les données appartiennent. Au lieu de _PARTITIONTIME, vous pouvez utiliser un champ généré explicitement par l'exportation Cloud Billing, tel que pricing_as_of_time.
Voici la même requête configurée pour utiliser le champ 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"
;
Résultats de la requête
| Ligne | id | description | 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 | Requêtes | COUNT | COMPTE | MENSUEL | 1000000 | 0 | 0 | 0 |
| 1000000 | 2000000 | 0,4 | 0,4 |
Obtenir les prix catalogue pour un code SKU spécifique et ajouter une description du service
Les deux exemples de cette section illustrent les requêtes qui renvoient la valeur list_price pour chaque niveau de tarification pour un code SKU spécifié et incluent la description du code SKU et la description du service.
- L'exemple 1 renvoie un code SKU par ligne, les niveaux de tarification étant affichés en tant que données imbriquées.
- L'exemple 2 illustre la désimbrication des données pour renvoyer une ligne par code SKU par niveau de tarification.
Exemple 1 : Renvoie des données imbriquées
Cet exemple interroge un seul code SKU pour renvoyer les données list_price. Ce code SKU possède plusieurs niveaux de tarification.
Les valeurs du champ des prix catalogue s'affichent sur des lignes individuelles imbriquées sous la ligne d'ID de code SKU.
SQL standard
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"
;
Résultats de la requête :
| Ligne | 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 | Requêtes | 152E-C115-5142 | Cloud Run | COMPTE | MENSUEL | 1000000 | 0 | 0 | 0 |
| 1000000 | 2000000 | 0,4 | 0,4 |
Exemple 2 : Renvoyer des données non imbriquées associées à la même table
Cet exemple interroge un seul code SKU pour renvoyer la valeur de list price. Ce code SKU possède plusieurs niveaux de tarification.
La requête illustre l'utilisation de l'opérateur UNNEST afin d'aplatir le tableau tiered_rates et de joindre les champs avec la même table, pour obtenir une ligne par niveau de tarification.
SQL standard
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"
;
Résultats de la requête :
| Ligne | sku_id | sku_description | service_id | service_description | pricing_unit_quantity | start_usage_amount | usd_amount | account_currency_amount |
|---|---|---|---|---|---|---|---|---|
| 1 | 2DA5-55D3-E679 | Requêtes | 152E-C115-5142 | Cloud Run | 1000000,0 | 0,0 | 0.0 | 0,0 |
| 2 | 2DA5-55D3-E679 | Requêtes | 152E-C115-5142 | Cloud Run | 1000000,0 | 2000000,0 | 0,4 | 0,4 |
Utiliser la classification des produits et la classification géographique pour interroger les codes SKU
- La classification des produits est une liste de catégories de produits qui s'appliquent aux codes SKU, telles que sans serveur, Cloud Run ou VM à la demande.
- La classification géographique correspond aux métadonnées géographiques qui s'appliquent à un code SKU, constitué de valeurs de type et de région.
Obtenir la classification des produits d'un code SKU
Cet exemple présente une requête qui renvoie la liste product_taxonomy pour un code SKU spécifié, où l'ID du code SKU est égal à 2DA5-55D3-E679 (Cloud Run – Requêtes).
SQL standard
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"
;
Résultats de la requête :
| Ligne | sku_id | sku_description | service_id | service_description | product_taxonomy |
|---|---|---|---|---|---|
| 1 | 2DA5-55D3-E679 | Requêtes | 152E-C115-5142 | Cloud Run | GCP |
| Sans serveur | |||||
| Cloud Run | |||||
| Autre |
Obtenir tous les codes SKU pour une classification de produits spécifique
Cet exemple illustre une requête qui renvoie tous les codes SKU correspondant à un product_taxonomy spécifié.
Dans cette requête, la valeur de product taxonomy est sans serveur.
SQL standard
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
;
Résultats de la requête :
| Ligne | sku_id | sku_description | service_id | service_description | product_taxonomy |
|---|---|---|---|---|---|
| 1 | 0160-BD7B-4C40 | Sortie intra-régionale du réseau Cloud Tasks | F3A6-D7B7-9BDA | Cloud Tasks | GCP |
| Sans serveur | |||||
| Cloud Tasks | |||||
| Autre | |||||
| 2 | FE08-0A74-7AFD | Sortie GOOGLE-API Cloud Tasks | F3A6-D7B7-9BDA | Cloud Tasks | GCP |
| Sans serveur | |||||
| Cloud Tasks | |||||
| Autre | |||||
| 3 | A81A-32A2-B46D | Stockage des files d'attente de tâches Salt Lake City | F17B-412E-CB64 | App Engine | GCP |
| Sans serveur | |||||
| GAE | |||||
| Autre | |||||
| TaskQueue |
Obtenir tous les codes SKU pour une classification géographique et une classification de produits spécifiques
Cet exemple montre une requête qui renvoie tous les codes SKU qui correspondent à une région geo_taxonomy et à un product_taxonomy spécifiés, où region = us-east4 et product_taxonomy = VM à la demande.
SQL standard
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)
;
Résultats de la requête :
| Ligne | sku_id | sku_description | service_id | service_description | geo_taxonomy.type | geo_taxonomy.regions | product_taxonomy |
|---|---|---|---|---|---|---|---|
| 1 | 9174-81EE-425B | Supplément de location unique pour RAM d'instance de location unique s'exécutant en Virginie | 6F81-5844-456A | Compute Engine | RÉGIONAL | us-east4 | GCP |
| Calcul | |||||||
| GCE | |||||||
| VM à la demande | |||||||
| Mémoire : par Go | |||||||
| 2 | C3B9-E891-85ED | RAM d'instance de location unique s'exécutant en Virginie | 6F81-5844-456A | Compute Engine | RÉGIONAL | us-east4 | GCP |
| Calcul | |||||||
| GCE | |||||||
| VM à la demande | |||||||
| Mémoire : par Go | |||||||
| 3 | 6E2A-DCD9-87ED | RAM d'instance prédéfinie N1 s'exécutant en Virginie | 6F81-5844-456A | Compute Engine | RÉGIONAL | us-east4 | GCP |
| Calcul | |||||||
| GCE | |||||||
| VM à la demande | |||||||
| Mémoire : par Go |
Associer les données tarifaires aux données de coût d'utilisation détaillé
Cette requête montre comment associer les exportations de données tarifaires et de coût pour consulter des informations tarifaires détaillées conformes à vos coûts. Vous pouvez configurer cette requête pour extraire les données exportées des données de coût d'utilisation détaillé (comme Exports), puis associer vos données de coût d'utilisation aux données tarifaires exportées (comme Prices).
Utilisez le nom de la table de coût d'utilisation détaillé pour extraire les données Exports : gcp_billing_export_resource_v1_<BILLING_ACCOUNT_ID>
Utilisez le nom de la grille tarifaire pour les données 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
Par exemple, le résultat de la requête précédente peut être celui-ci :
| sku_description | coût | utilisation | pricing_unit_description | account_currency_amount | account_currency_code |
|---|---|---|---|---|---|
| Capacité sur disque persistant avec équilibrage | 0,001345 | { "usage": { "amount": "38654705664000.0", "unit": "byte-seconds", "amount_in_pricing_units": "0.01345895", "pricing_unit": "gibibyte month" } } | gibioctet par mois | 0,1 | USD |
| Capacité sur disque persistant avec équilibrage | 0,001344 | { "usage": { "amount": "38654705664000.0", "unit": "byte-seconds", "amount_in_pricing_units": "0.01345895", "pricing_unit": "gibibyte month" } } | gibioctet par mois | 0,1 | USD |
| Capacité sur disque persistant avec équilibrage | 0,001346 | { "usage": { "amount": "38654705664000.0", "unit": "byte-seconds", "amount_in_pricing_units": "0.01345895", "pricing_unit": "gibibyte month" } } | gibioctet par mois | 0,1 | USD |
Articles associés
Articles liés aux données Cloud Billing exportées
- Configurer l'exportation des données Cloud Billing vers BigQuery
- Comprendre les tables de données Cloud Billing dans BigQuery
- Visualiser les dépenses au fil du temps avec Looker Studio
Rapports sur les coûts et les tarifs disponibles dans Google Cloud Console
- Afficher les rapports Cloud Billing et l'évolution des coûts
- Consulter et télécharger les détails des coûts de votre facture ou relevé
- Afficher et télécharger les tarifs des services Cloud de Google
- Comprendre les économies réalisées grâce aux rapports de répartition des coûts
- Analyser l'efficacité de vos remises sur engagement d'utilisation
- Consulter l'historique des frais et paiements