Attribution de coûts¶

Types de scénarios d’attribution des coûts¶

Les scénarios d’attribution des coûts suivants sont les plus couramment rencontrés. Dans ces scénarios, les entrepôts sont utilisés comme exemple de ressource engendrant des coûts.

• Ressources utilisées exclusivement par un seul centre de coûts ou un seul département : L’utilisation de balises d’objet pour associer des entrepôts à un département en est un exemple. Vous pouvez utiliser ces balises d’objet pour attribuer les coûts encourus par ces entrepôts à l’ensemble de ce département.

• Ressources partagées par des utilisateurs de plusieurs départements : Un entrepôt partagé par des utilisateurs de différents départements en est un exemple. Dans ce casse-tête, vous utilisez des balises d’objet pour associer chaque utilisateur à un département. Les coûts des requêtes sont attribués aux utilisateurs. À l’aide des balises d’objet attribuées aux utilisateurs, vous pouvez ventiler les coûts par département.

• Applications ou flux de travail partagés par des utilisateurs de différents services : Une application qui émet des requêtes pour le compte de ses utilisateurs en est un exemple. Dans ce casse-tête, chaque requête exécutée par l’application se voit attribuer une balise de requête qui identifie l’équipe ou le centre de coûts de l’utilisateur au nom duquel la requête est effectuée.

Les sections suivantes expliquent comment établir des balises d’objet dans vos comptes et fournissent les détails de chacun de ces scénarios d’attribution des coûts.

Paramétrage des balises d’objets pour l’attribution des coûts¶

Lorsque vous configurez des balises pour représenter les groupes que vous souhaitez utiliser pour l’attribution des coûts, vous devez déterminer si les groupes s’appliquent à un compte unique ou à des comptes multiples. Cela détermine l’ensemble de vos balises.

Supposons, par exemple, que vous souhaitiez attribuer les coûts en fonction du département.

• Si les ressources utilisées par le service sont situées dans un seul compte, vous créez les balises dans une base de données de ce compte.

• Si les ressources utilisées par le service couvrent plusieurs comptes, vous créez les balises dans un compte clé de votre organisation (par exemple, dans votre compte d’organisation), et vous rendez ces balises disponibles dans d’autres comptes par le biais de la réplication <label-cost_attribute_tag_replicate>.

Les sections suivantes expliquent comment créer les balises, les répliquer et les appliquer aux ressources.

• Création des balises

• Réplication de la base de données des balises

• Balise des ressources et des utilisateurs

USE ROLE tag_admin;

CREATE DATABASE cost_management;
CREATE SCHEMA tags;

CREATE TAG cost_center
  ALLOWED_VALUES 'finance', 'marketing', 'engineering', 'product';

Réplication de la base de données des balises¶

Si vous avez une organisation avec plusieurs comptes et que vous voulez rendre les balises disponibles dans ces autres comptes, configurez vos comptes pour la réplication, et créez un groupe de réplication dans un compte principal (par exemple, dans le compte de l’organisation). Paramétrez ce groupe de réplication pour répliquer la base de données contenant les balises.

Par exemple, pour répliquer les balises sur les comptes my_org.my_account et my_org.my_account_2, exécutez cette instruction dans votre compte d’organisation :

CREATE REPLICATION GROUP cost_management_repl_group
  OBJECT_TYPES = DATABASES
  ALLOWED_DATABASES = cost_management
  ALLOWED_ACCOUNTS = my_org.my_account_1, my_org.my_account_2
  REPLICATION_SCHEDULE = '10 MINUTE';

Copy

Ensuite, dans chaque compte dans lequel vous souhaitez rendre les balises disponibles, créez un groupe de réplication secondaire et actualisez ce groupe à partir du groupe principal :

CREATE REPLICATION GROUP cost_management_repl_group
  AS REPLICA OF my_org.my_org_account.cost_management_repl_group;

ALTER REPLICATION GROUP cost_management_repl_group REFRESH;

Copy

USE ROLE tag_admin;

ALTER WAREHOUSE warehouse1 SET TAG cost_management.tags.cost_center='SALES';
ALTER WAREHOUSE warehouse2 SET TAG cost_management.tags.cost_center='SALES';
ALTER WAREHOUSE warehouse3 SET TAG cost_management.tags.cost_center='FINANCE';

ALTER USER finance_user SET TAG cost_management.tags.cost_center='FINANCE';
ALTER USER sales_user SET TAG cost_management.tags.cost_center='SALES';

Vue du coût par balise en SQL¶

Vous pouvez attribuer des coûts au sein d’un compte ou entre les comptes d’une organisation :

• Attribuer des coûts au sein d’un compte

  Vous pouvez attribuer des coûts à un compte en interrogeant les vues suivantes du schéma ACCOUNT_USAGE:

  • Vue TAG_REFERENCES: Identifie les objets (par exemple, les entrepôts et les utilisateurs) qui ont des balises.

  • Vue WAREHOUSE_METERING_HISTORY: Assure l’utilisation du crédit pour les entrepôts.

  • Vue QUERY_ATTRIBUTION_HISTORY: Fournit les coûts de calcul 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.

    Pour plus d’informations sur l’utilisation de cette vue, voir À propos de la vue QUERY_ATTRIBUTION_HISTORY.

• Attribution des coûts entre les comptes d’une organisation

  Au sein d’une organisation, vous pouvez également attribuer des coûts à des ressources utilisées exclusivement par un seul département en interrogeant les vues du schéma ORGANIZATION_USAGE à partir du compte de l’organisation.

  Note

  • Dans le schéma ORGANIZATION_USAGE, la vue TAG_REFERENCES n’est disponible que dans le compte de l’organisation.

  • La vue QUERY_ATTRIBUTION_HISTORY n’est disponible que dans le schéma ACCOUNT_USAGE pour un compte. Il n’existe pas d’équivalent de cette vue à l’échelle de l’organisation.

Les sections suivantes expliquent comment attribuer les coûts pour certains des scénarios d’attribution des coûts les plus courants:

• Ressources non partagées par les départements

• Ressources partagées par des utilisateurs de différents départements

• Ressources utilisées par les applications qui doivent attribuer les coûts aux différents services

Ressources non partagées par les départements¶

Supposons que vous souhaitiez attribuer les coûts par département et que chaque département utilise un ensemble d’entrepôts dédiés.

Si vous balisez les entrepôts avec une balise cost_center pour identifier le département propriétaire de l’entrepôt, vous pouvez joindre ACCOUNT_USAGE Vue TAG_REFERENCES à Vue WAREHOUSE_METERING_HISTORY sur les colonnes object_id et warehouse_id pour obtenir des informations sur l’utilisation par entrepôt, et vous pouvez utiliser la colonne tag_value pour identifier les départements propriétaires de ces entrepôts.

L’instruction SQL suivante permet d’effectuer cette jonction :

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
          AND TAG_REFERENCES.domain = 'WAREHOUSE'
  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 |
+-------------+-------------+-----------------+

Vous pouvez exécuter une requête similaire pour effectuer le même attribut pour tous les comptes de votre organisation en utilisant les vues du schéma ORGANIZATION_USAGE à partir du compte de l’organisation. Le reste de la requête ne change pas.

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.ORGANIZATION_USAGE.WAREHOUSE_METERING_HISTORY
      LEFT JOIN SNOWFLAKE.ORGANIZATION_USAGE.TAG_REFERENCES
        ON WAREHOUSE_METERING_HISTORY.warehouse_id = TAG_REFERENCES.object_id
          AND TAG_REFERENCES.domain = 'WAREHOUSE'
          AND tag_database = 'COST_MANAGEMENT' AND tag_schema = 'TAGS'
  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

Ressources partagées par des utilisateurs de différents départements¶

Supposons que des utilisateurs de différents services partagent les mêmes entrepôts et que vous souhaitiez ventiler les crédits utilisés par chaque service. Vous pouvez étiqueter les utilisateurs avec une balise cost_center pour identifier le département auquel ils appartiennent, et vous pouvez joindre le Vue TAG_REFERENCES avec le Vue QUERY_ATTRIBUTION_HISTORY.

Note

Vous ne pouvez obtenir ces données que pour un seul compte à la fois. Vous ne pouvez pas exécuter une requête qui récupère ces données sur l’ensemble des comptes d’une organisation.

Les sections suivantes présentent des exemples d’instructions SQL pour l’attribution des coûts des ressources partagées.

• Calcul du coût des requêtes des utilisateurs pour le dernier mois

• Calcul du coût des requêtes des utilisateurs par département sans temps mort

• Calcul du coût des requêtes des utilisateurs sans temps mort

• Calcul du coût des requêtes effectuées par des utilisateurs sans balise

Calcul du coût des requêtes des utilisateurs pour le dernier mois¶

L’instruction SQL suivante calcule les coûts pour le mois écoulé.

Dans cet exemple, le temps d’inactivité de est réparti entre les utilisateurs au prorata de leur utilisation.

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 |
|-----------+--------------------+
| FINUSER   | 6.603575468        |
| SALESUSER | 4.321378049        |
| ENGUSER   | 0.6217131392       |
|-----------+--------------------+

Calcul du coût des requêtes des utilisateurs par département sans temps mort¶

L’exemple suivant attribue le coût de calcul à chaque département par le biais des requêtes exécutées par les utilisateurs de ce département. Cette requête dépend de l’existence d’une balise identifiant le département de l’objet de l’utilisateur.

WITH joined_data AS (
  SELECT
      tr.tag_name,
      tr.tag_value,
      qah.credits_attributed_compute,
      qah.start_time
    FROM SNOWFLAKE.ACCOUNT_USAGE.TAG_REFERENCES tr
      JOIN SNOWFLAKE.ACCOUNT_USAGE.QUERY_ATTRIBUTION_HISTORY qah
        ON tr.domain = 'USER' AND tr.object_name = qah.user_name
)
SELECT
    tag_name,
    tag_value,
    SUM(credits_attributed_compute) AS total_credits
  FROM joined_data
  WHERE start_time >= DATEADD(MONTH, -1, CURRENT_DATE)
    AND start_time < CURRENT_DATE
  GROUP BY tag_name, tag_value
  ORDER BY tag_name, tag_value;

Copy

+-------------+-------------+-----------------+
| TAG_NAME    | TAG_VALUE   |   TOTAL_CREDITS |
|-------------+-------------+-----------------|
| COST_CENTER | engineering |   0.02493688426 |
| COST_CENTER | finance     |    0.2281084988 |
| COST_CENTER | marketing   |    0.3686840545 |
|-------------+-------------+-----------------|

Calcul du coût des requêtes des utilisateurs sans temps mort¶

L’instruction SQL suivante calcule les coûts par utilisateur pour le mois écoulé (hors temps d’inactivité).

SELECT user_name, SUM(credits_attributed_compute) AS credits
  FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_ATTRIBUTION_HISTORY
  WHERE
    start_time >= DATEADD(MONTH, -1, CURRENT_DATE)
    AND start_time < CURRENT_DATE
  GROUP BY user_name;

Copy

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

Calcul du coût des requêtes effectuées par des utilisateurs sans balise¶

L’exemple suivant calcule le coût des requêtes effectuées par des utilisateurs qui ne sont pas balisés. Vous pouvez l’utiliser pour vérifier que les balises sont appliquées de manière cohérente aux utilisateurs.

SELECT qah.user_name, SUM(qah.credits_attributed_compute) as total_credits
  FROM
    SNOWFLAKE.ACCOUNT_USAGE.QUERY_ATTRIBUTION_HISTORY qah
    LEFT JOIN snowflake.account_usage.tag_references tr
    ON qah.user_name = tr.object_name AND tr.DOMAIN = 'USER'
  WHERE
    start_time >= dateadd(month, -1, current_date)
    AND qah.user_name IS NULL OR tr.object_name IS NULL
  GROUP BY qah.user_name
  ORDER BY total_credits DESC;

Copy

+------------+---------------+
| USER_NAME  | TOTAL_CREDITS |
|------------+---------------|
| RSMITH     |  0.1830555556 |
+------------+---------------+

ALTER SESSION SET QUERY_TAG = 'COST_CENTER=finance';

SELECT
    query_tag,
    SUM(credits_attributed_compute) AS compute_credits,
    SUM(credits_used_query_acceleration) AS qas
  FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_ATTRIBUTION_HISTORY
  WHERE query_tag = 'COST_CENTER=finance'
  GROUP BY query_tag;

+---------------------+-----------------+------+
| QUERY_TAG           | COMPUTE_CREDITS | QAS  |
|---------------------+-----------------|------|
| COST_CENTER=finance |      0.00576115 | null |
+---------------------+-----------------+------+

SELECT
    COALESCE(NULLIF(query_tag, ''), 'untagged') AS tag,
    SUM(credits_attributed_compute) AS compute_credits,
    SUM(credits_used_query_acceleration) AS qas
  FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_ATTRIBUTION_HISTORY
  WHERE start_time >= DATEADD(MONTH, -1, CURRENT_DATE)
  GROUP BY tag
  ORDER BY compute_credits DESC;

+-------------------------+-----------------+------+
| TAG                     | COMPUTE_CREDITS | QAS  |
|-------------------------+-----------------+------+
| untagged                | 3.623173449     | null |
| COST_CENTER=engineering | 0.531431948     | null |
|-------------------------+-----------------+------+

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 >= DATEADD(MONTH, -1, 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
  ORDER BY attributed_credits DESC;

+-------------------------+--------------------+
| TAG                     | ATTRIBUTED_CREDITS |
+-------------------------+--------------------|
| untagged                |        9.020031304 |
| COST_CENTER=finance     |        1.027742521 |
| COST_CENTER=engineering |        1.018755812 |
| COST_CENTER=marketing   |       0.4801370376 |
+-------------------------+--------------------+

Vue du coût par balise en Snowsight¶

Vous pouvez attribuer des coûts en rendant compte de l’utilisation des ressources qui ont la balise cost_center. Vous pouvez accéder à ces données sur le site Snowsight.

1. Passer à un rôle qui a accès au schéma ACCOUNT_USAGE.

2. Accédez à Admin » Cost Management.

3. Sélectionnez Consumption.

4. Dans la liste déroulante Tags, sélectionnez la balise cost_center.

5. Pour se concentrer sur un centre de coûts spécifique, sélectionnez une valeur dans la liste des valeurs de la balise.

6. Sélectionnez Apply.

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

À propos de la vue QUERY_ATTRIBUTION_HISTORY¶

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.

Autres exemples de requêtes¶

Les sections suivantes présentent des requêtes supplémentaires que vous pouvez utiliser pour l’attribution des coûts :

• Groupement de requêtes similaires

• Attribution des coûts des requêtes hiérarchiques

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;