Attribution de coûts¶

Une organisation peut se faire une idée du coût d’utilisation de Snowflake en attribuant ces coûts à des unités logiques au sein de l’organisation (par exemple, des départements, des environnements et des projets). Ce modèle de rétrofacturation (chargeback) ou de récupération des données de facturation (showback) est utile à des fins comptables, mais il permet également à une organisation d’identifier les unités qui dépensent le plus. Ces informations permettent d’identifier les secteurs de l’organisation qui pourraient bénéficier de contrôles et d’optimisations afin de réduire les coûts.

Attribution de coûts de ressources individuelles¶

Note

La balise des objets est disponible à partir de Enterprise Edition.

Le moyen le plus direct et le plus puissant d’attribuer un coût à différents groupes tels que des départements, des environnements ou des projets consiste à baliser des ressources spécifiques à l’aide de la fonction de balisage d’objets. Dans cette stratégie, un administrateur crée une balise (par exemple, cost_center), puis définit une liste de valeurs possibles de la balise (par exemple, sales, finance). Dans cet exemple, chaque centre de coûts reçoit une valeur de balise unique. La combinaison balise/valeur est ensuite affectée aux ressources utilisées par un centre de coûts. Comme ces ressources consomment des crédits, vous pouvez exécuter des rapports groupés par la valeur de la balise. Comme cette valeur de balise correspond directement à un groupement particulier au sein de l’organisation, les coûts peuvent être attribués avec précision.

Le balisage d’objets vous permet d’attribuer un coût en fonction d’un élément aussi général qu’un compte ou aussi spécifique qu’un tableau. Notez que tous les objets qu’il est possible de baliser n’accumulent pas de coût. Du point de vue de la gestion des coûts, le balisage d’un objet n’a de sens que s’il existe une vue du schéma qui contient des données d’utilisation ou de coût liées à cet objet. Pour une liste des vues de l’utilisation et des coûts de Snowflake, voir Exploration du coût global.

Flux de travail d’attribution¶

L’utilisation de balises d’objet pour attribuer un coût consiste en trois tâches de base :

Concevoir une stratégie de balisage et créer les balises appropriées.
Marquer les ressources avec la bonne paire balise/valeur.
Exécuter des rapports basés sur les données d’utilisation et de balisage.

Pour illustrer ce flux de travail, considérons un compte Snowflake qui :

A deux centres de coûts : les ventes et les finances.
Possède trois entrepôts. Les ventes utilisent Entrepôt1 et Entrepôt2, tandis que le service financier utilise Entrepôt3.

Dans cet exemple, l’objectif est d’attribuer les coûts associés à chaque entrepôt au département approprié.

Note

L’exemple suivant suppose que les privilèges appropriés ont été accordés au rôle tag_admin. Une organisation peut utiliser les autorisations de balisage granulaires pour développer une stratégie de balisage sécurisée.

Tâche 1 : concevoir une stratégie de balisage et créer les balises appropriées

Dans cet exemple, un administrateur disposant des privilèges appropriés crée une seule balise appelée cost_center.

USE ROLE tag_admin;
USE SCHEMA my_db.my_schema;
CREATE TAG cost_center;

Copy

Tâche 2 : baliser les objets avec la bonne paire balise/valeur

L’administrateur des balises applique la paire balise/valeur appropriée aux entrepôts. Par exemple, comme le département des ventes utilise à la fois warehouse1 et warehouse2, la même combinaison balise/valeur est appliquée à ces deux ressources.

USE ROLE tag_admin;
ALTER WAREHOUSE warehouse1 SET TAG cost_center='SALES';
ALTER WAREHOUSE warehouse2 SET TAG cost_center='SALES';
ALTER WAREHOUSE warehouse3 SET TAG cost_center='FINANCE';

Copy

Note

Si les administrateurs veulent contrôler les valeurs qui peuvent être définies sur l’objet, ils peuvent utiliser le paramètre facultatif allowed_values lors de la création de la balise. Pour plus de détails, voir CREATE TAG.

Tâche 3 : exécuter des rapports basés sur les données d’utilisation et de balisage.

Vous pouvez attribuer des coûts en rendant compte de l’utilisation des ressources qui ont la balise cost_center. Ces données sont disponibles dans Snowsight, ou en interrogeant le schéma SNOWFLAKE.ACCOUNT_USAGE.

Snowsight:

Passer à un rôle qui a accès au schéma ACCOUNT_USAGE.
Accédez à Admin » Cost Management.
Sélectionnez Consumption.
Dans la liste déroulante Tags, sélectionnez la balise cost_center.
Pour se concentrer sur un centre de coûts spécifique, sélectionnez une valeur dans la liste des valeurs de la balise.
Sélectionnez Apply.

Pour plus de détails sur le filtrage dans Snowsight, voir Filtrage par balise.

SQL:

Le schéma Account Usage contient des données concernant à la fois l’utilisation des ressources et les balises du schéma.

Vous pouvez afficher l’attribution des coûts pour tous les entrepôts d’un mois donné avec leurs balises et leurs valeurs de balises. Cette requête identifie également les entrepôts sans balise :

SELECT tag_references.tag_name,
     COALESCE(tag_references.tag_value, 'untagged') AS tag_value,
     SUM(warehouse_metering_history.credits_used_compute) AS total_credits
FROM snowflake.account_usage.warehouse_metering_history
LEFT JOIN snowflake.account_usage.tag_references
ON warehouse_metering_history.warehouse_id = tag_references.object_id
WHERE warehouse_metering_history.start_time >= DATE_TRUNC('MONTH', DATEADD(MONTH, -1, CURRENT_DATE))
  AND warehouse_metering_history.start_time < DATE_TRUNC('MONTH',  CURRENT_DATE)
GROUP BY tag_references.tag_name, COALESCE(tag_references.tag_value, 'untagged')
ORDER BY total_credits DESC;

Copy

+-------------+-------------+-----------------+
| TAG_NAME    | TAG_VALUE   |   TOTAL_CREDITS |
|-------------+-------------+-----------------|
| NULL        | untagged    |    20.360277159 |
| COST_CENTER | Sales       |    17.173333333 |
| COST_CENTER | Finance     |      8.14444444 |
+-------------+-------------+-----------------+

Pour plus de détails sur l’utilisation des balises d’objet, voir Balisage d’objets.

Coût des attributs pour les requêtes¶

Vous pouvez utiliser Vue QUERY_ATTRIBUTION_HISTORY pour attribuer des coûts en fonction des requêtes. Le coût par requête correspond à l’utilisation du crédit d’entrepôt pour l’exécution de la requête. Ce coût n’inclut pas toute autre utilisation de crédit résultant de l’exécution de la requête. Par exemple, les éléments suivants ne sont pas inclus dans le coût de la requête :

Coûts du transfert des données
Coûts de stockage
Coûts des services Cloud
Coûts des fonctionnalités sans serveur
Coûts des jetons traités par les services AI

Pour les requêtes exécutées simultanément, le coût de l’entrepôt est attribué aux requêtes individuelles en fonction de la moyenne pondérée de leur consommation de ressources au cours d’un intervalle de temps donné.

Le coût par requête n’inclut pas le temps d’inactivité de l’entrepôt. Le temps d’inactivité est une période pendant laquelle aucune requête ne s’exécute dans l’entrepôt et ne peut être mesurée au niveau de l’entrepôt.

Attribution des coûts par balise, utilisateur et requête¶

Vous pouvez attribuer les coûts d’entrepôt et de requête par balise, par utilisateur ou par requête (par exemple, les requêtes récurrentes).

Attribution des coûts d’entrepôt en fonction de la balise de requête¶

Vous pouvez utiliser le paramètre QUERY_TAG pour répartir les coûts sur différentes charges de travail. Une balise de requête peut être attribuée au niveau de la session pour une charge de travail ou un ensemble de requêtes. Pour plus d’informations sur l’attribution basée sur les balises, voir Flux de travail d’attribution.

Pour définir une balise de requête pour une session, procédez comme suit :

Créez une balise. Par exemple, créez une balise pour l’équipe financière :
```
CREATE TAG finance;
```
Copy
Définissez une balise de requête pour la session en cours :
```
ALTER SESSION SET query_tag = finance;
```
Copy
La balise finance est associée à toutes les requêtes exécutées pendant la session.

Pour afficher le coût d’entrepôt de toutes les requêtes balisées pour le mois en cours, exécutez l’instruction suivante. Notez que cette requête répartit l’intégralité du coût de calcul de l’entrepôt entre les balises (y compris le temps d’inactivité) pour le rapprochement :

WITH wh_bill AS (
   SELECT SUM(credits_used_compute) AS compute_credits
     FROM SNOWFLAKE.ACCOUNT_USAGE.WAREHOUSE_METERING_HISTORY
     WHERE start_time >= DATE_TRUNC('MONTH', CURRENT_DATE)
     AND start_time < CURRENT_DATE
),
tag_credits AS (
   SELECT COALESCE(NULLIF(query_tag, ''), 'untagged') AS tag,
          SUM(credits_attributed_compute) AS credits
     FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_ATTRIBUTION_HISTORY
     WHERE start_time >= DATE_TRUNC('MONTH', CURRENT_DATE)
     AND start_time < CURRENT_DATE
     GROUP BY tag
),
total_credit AS (
   SELECT SUM(credits) AS sum_all_credits
     FROM tag_credits
)
SELECT tc.tag,
       tc.credits / t.sum_all_credits * w.compute_credits AS attributed_credits
  FROM tag_credits tc, total_credit t, wh_bill w;

Copy

Attribution des coûts d’entrepôt basée sur l’utilisateur¶

Vous pouvez attribuer le coût de l’entrepôt par utilisateur. Par exemple, pour déterminer le coût total de l’entrepôt attribué à chaque utilisateur pour le mois en cours, exécutez l’instruction suivante :

WITH wh_bill AS (
   SELECT SUM(credits_used_compute) AS compute_credits
     FROM SNOWFLAKE.ACCOUNT_USAGE.WAREHOUSE_METERING_HISTORY
     WHERE start_time >= DATE_TRUNC('MONTH', CURRENT_DATE)
     AND start_time < CURRENT_DATE
),
user_credits AS (
   SELECT user_name, SUM(credits_attributed_compute) AS credits
     FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_ATTRIBUTION_HISTORY
     WHERE start_time >= DATE_TRUNC('MONTH', CURRENT_DATE)
     AND start_time < CURRENT_DATE
     GROUP BY user_name
),
total_credit AS (
   SELECT SUM(credits) AS sum_all_credits
     FROM user_credits
)
SELECT u.user_name,
       u.credits / t.sum_all_credits * w.compute_credits AS attributed_credits
  FROM user_credits u, total_credit t, wh_bill w
  ORDER BY attributed_credits DESC;

Copy

+-----------+--------------------+
| USER_NAME | ATTRIBUTED_CREDITS |
|-----------+--------------------|
| JSMITH    |       17.173333333 |
|-----------+--------------------|
| MJONES    |         8.14444444 |
|-----------+--------------------|
| SYSTEM    |         5.33985393 |
+-----------+--------------------+

Coût des requêtes récurrentes¶

Pour les requêtes récurrentes ou similaires, utilisez query_hash ou query_parameterized_hash pour regrouper les coûts par requête.

Pour trouver les requêtes récurrentes les plus coûteuses pour le mois en cours, exécutez l’instruction suivante :

SELECT query_parameterized_hash,
       COUNT(*) AS query_count,
       SUM(credits_attributed_compute) AS total_credits
  FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_ATTRIBUTION_HISTORY
  WHERE start_time >= DATE_TRUNC('MONTH', CURRENT_DATE)
  AND start_time < CURRENT_DATE
  GROUP BY query_parameterized_hash
  ORDER BY total_credits DESC
  LIMIT 20;

Copy

Pour une requête supplémentaire basée sur l’ID de requête, voir Exemples.

Coût des requêtes hiérarchiques¶

Pour les procédures stockées qui émettent plusieurs requêtes hiérarchiques, vous pouvez calculer les coûts de requête attribués à la procédure en utilisant l’ID de requête racine pour la procédure.

Pour trouver l’ID de requête racine pour une procédure stockée, utilisez Vue ACCESS_HISTORY. Par exemple, pour trouver l’ID de requête racine pour une procédure stockée, définissez query_id et exécutez les instructions suivantes :
```
SET query_id = '<query_id>';

SELECT query_id,
       parent_query_id,
       root_query_id,
       direct_objects_accessed
  FROM SNOWFLAKE.ACCOUNT_USAGE.ACCESS_HISTORY
  WHERE query_id = $query_id;
```
Copy
Pour plus d’informations, voir Exemple : requêtes ancêtres à l’aide de procédures stockées.

Pour additionner les coûts de la requête pour l’ensemble de la procédure, remplacez <id_requête_racine> et exécutez les instructions suivantes :

SET query_id = '<root_query_id>';

SELECT SUM(credits_attributed_compute) AS total_attributed_credits
  FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_ATTRIBUTION_HISTORY
  WHERE (root_query_id = $query_id OR query_id = $query_id);

Copy