Zuordnen von Kosten¶

Tags erstellen¶

Entscheiden Sie sich bei der Entwicklung der Strategie für die Datenbank und das Schema, in dem Sie die Tags erstellen möchten.

• Sie können eine eigene Datenbank und ein eigenes Schema für die Tags erstellen.

• Wenn Sie Ressourcen in verschiedenen Konten in Ihrem Unternehmen mit Tags versehen möchten, können Sie die Tags in einem Schlüsselkonto in Ihrem Unternehmen erstellen (z. B. in Ihrem Organisationskonto).

Das folgende Beispiel erstellt eine Datenbank namens cost_management und ein Schema namens tags für die Tags, die Sie verwenden möchten:

USE ROLE tag_admin;

CREATE DATABASE cost_management;
CREATE SCHEMA tags;

Wenn Sie cost_management und tags als aktuelle Datenbank und aktuelles Schema ausgewählt haben, erstellen Sie ein Tag mit dem Namen cost_center und setzen die für das Tag zulässigen Werte auf die Namen der Kostenstellen:

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

Tag-Datenbank replizieren¶

Wenn Sie eine Organisation mit mehreren Konten haben und die Tags in diesen anderen Konten verfügbar machen möchten, richten Sie Ihre Konten für die Replikation ein und erstellen Sie eine Replikationsgruppe in einem Hauptkonto (z. B. im Organisationskonto). Richten Sie diese Replikationsgruppe ein, um die Datenbank, die die Tags enthält, zu replizieren.

Um beispielsweise die Tags auf die Konten mit den Namen my_org.my_account und my_org.my_account_2 zu replizieren, führen Sie diese Anweisung in Ihrem Organisationskonto aus:

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';

Erstellen Sie dann in jedem Konto, in dem Sie die Tags verfügbar machen möchten, eine sekundäre Replikationsgruppe und aktualisieren Sie diese Gruppe von der primären Gruppe aus:

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;

Tagging der Ressourcen und Benutzer¶

Nachdem Sie die Bezeichner erstellt und repliziert haben, können Sie diese Bezeichner verwenden, um die Warehouses und Benutzer zu identifizieren, die zu den einzelnen Abteilungen gehören. Da die Verkaufsabteilung zum Beispiel sowohl warehouse1 als auch warehouse2 verwendet, können Sie das Tag cost_center für beide Warehouses auf 'SALES' setzen.

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';

Automating user tags with SCIM¶

If you want to automate the process of tagging users for cost attribution, you can do so by provisioning Snowflake users through a SCIM identity provider such as Microsoft Entra ID or Okta. With SCIM, you can automatically apply cost attribution tags to users when they’re created or updated, eliminating the need to run ALTER USER <user_name> SET TAG manually for each new user and keeping your cost attribution tags consistent as users join or move between departments.

When using SCIM, the snowflakeTags custom attribute accepts a comma-separated list of fully qualified tag references. For example, to assign a user to the finance cost center at provisioning time, include the following value in the SCIM user payload:

{
  "userName": "JSMITH",
  "displayName": "Jane Smith",
  "urn:ietf:params:scim:schemas:extension:enterprise:2.0:User": {
    "snowflakeUserName": "JSMITH",
    "snowflakeTags": "[cost_management.tags.cost_center:finance]"
  }
}

Tags set through SCIM appear in the same TAG_REFERENCES views and work with Snowsight tag filters (see Kosten nach Tag anzeigen in Snowsight), so your existing cost attribution queries and dashboards work without changes.

To get started with this approach, you need to:

• Create the tags in Snowflake, as described in Creating the tags above.

• Grant the SCIM provisioner role USAGE on the tag schema and APPLY on each tag.

For the complete setup steps, prerequisite grants, and API examples, see the „Populating Snowflake tags with SCIM integrations“ section in:

• SCIM with Microsoft Entra ID

• SCIM with Okta

• SCIM with a custom identity provider

Ressourcen, die nicht von Abteilungen geteilt werden¶

Angenommen, Sie möchten die Kosten nach Abteilungen zuordnen und jede Abteilung nutzt eine Reihe von speziellen Warehouses.

Wenn Sie Warehouses mit einem cost_center-Tag versehen, um die Abteilung zu identifizieren, der das Warehouse gehört, können Sie ACCOUNT_USAGE Ansicht TAG_REFERENCES mit Ansicht WAREHOUSE_METERING_HISTORY in den Spalten object_id und warehouse_id verbinden, um Nutzungsinformationen nach Warehouse zu erhalten, und Sie können die Spalte tag_value verwenden, um die Abteilungen zu identifizieren, denen diese Warehouses gehören.

Die folgende SQL-Anweisung führt diese Verknüpfung durch:

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;

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

Sie können eine ähnliche Abfrage durchführen, um dieselbe Zuordnung für alle Konten in Ihrer Organization vorzunehmen, indem Sie die Ansichten im Schema ORGANIZATION_USAGE aus dem Organisationskonto verwenden. Der Rest der Abfrage ändert sich nicht.

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;

Von Benutzern aus verschiedenen Abteilungen gemeinsam genutzte Ressourcen¶

Nehmen wir an, dass Benutzer in verschiedenen Abteilungen dieselben Warehouses nutzen und Sie die von den einzelnen Abteilungen genutzten Credits aufschlüsseln möchten. Sie können die Benutzer mit einem cost_center-Tag versehen, um die Abteilung zu identifizieren, zu der sie gehören, und Sie können Ansicht TAG_REFERENCES mit Ansicht QUERY_ATTRIBUTION_HISTORY verbinden.

In den nächsten Abschnitten finden Sie Beispiele von SQL-Anweisungen für die Zuordnung von Kosten für gemeinsam genutzte Ressourcen.

• Berechnung der Kosten von Benutzerabfragen für den letzten Monat

• Berechnung der Kosten von Benutzerabfragen nach Abteilung ohne Leerlaufzeit

• Berechnung der Kosten für Abfragen von Benutzern ohne Leerlaufzeit

• Berechnung der Kosten für Abfragen von Benutzern ohne Tags

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;

+-----------+--------------------+
| USER_NAME | ATTRIBUTED_CREDITS |
|-----------+--------------------+
| FINUSER   | 6.603575468        |
| SALESUSER | 4.321378049        |
| ENGUSER   | 0.6217131392       |
|-----------+--------------------+

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;

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

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;

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

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;

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

Ressourcen, die von Anwendungen verwendet werden, die die Kosten verschiedenen Abteilungen zuordnen müssen¶

Die Beispiele in diesem Abschnitt berechnen die Kosten für eine oder mehrere Anwendungen, die von Snowflake betrieben werden.

Die Beispiele gehen davon aus, dass diese Anwendungen Abfrage-Tags setzen, die die Anwendung für alle ausgeführten Abfragen identifizieren. Um das Abfrage-Tag für Abfragen in einer Sitzung festzulegen, führen Sie den Befehl ALTER SESSION aus. Beispiel:

ALTER SESSION SET QUERY_TAG = 'COST_CENTER=finance';

Dadurch wird das Tag COST_CENTER=finance mit allen nachfolgenden Abfragen verknüpft, die während der Sitzung ausgeführt werden.

Sie können dann das Abfrage-Tag verwenden, um die durch diese Abfragen entstandenen Kosten auf die entsprechenden Abteilungen zurückzuführen.

In den nächsten Abschnitten finden Sie Beispiele für die Anwendung dieses Ansatzes.

• Berechnung der Kosten für Abfragen nach Abteilung

• Berechnung der Kosten von Abfragen (ohne Leerlaufzeit) nach Abfrage-Tag

• Berechnung der Kosten von Abfragen (einschließlich Leerlaufzeit) nach Abfrage-Tag

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 |
+-------------------------+--------------------+

Gruppieren ähnlicher Abfragen¶

Für wiederkehrende oder ähnliche Abfragen verwenden Sie query_hash oder query_parameterized_hash, um die Kosten nach Abfrage zu gruppieren.

Um die teuersten wiederkehrenden Abfragen für den aktuellen Monat zu finden, führen Sie die folgende Anweisung aus:

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;

Eine weitere Abfrage, die auf der Abfrage-ID basiert, finden Sie unter Beispiele.

Zuordnung der Kosten von hierarchischen Abfragen¶

Bei gespeicherten Prozeduren, die mehrere hierarchische Abfragen durchführen, können Sie die zugewiesenen Abfragekosten der Prozedur berechnen, indem Sie die Stammabfrage ID für die Prozedur verwenden.

1. Um die Stammabfrage-ID für eine gespeicherte Prozedur zu finden, verwenden Sie die Ansicht ACCESS_HISTORY. Um zum Beispiel die Stammabfrage-ID für eine gespeicherte Prozedur zu finden, stellen Sie query_id ein und führen Sie die folgenden Anweisungen aus:

   CopyExpand

   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;
   

   Show lessSee more

   Scroll to top

   Weitere Informationen dazu finden Sie unter Vorgängerabfragen mit gespeicherten Prozeduren.

2. Um die Summe der Abfragekosten für die gesamte Prozedur zu summieren, ersetzen Sie <root_query_id> und führen Sie die folgenden Anweisungen aus:

   CopyExpand

   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);
   

   Show lessSee more

   Scroll to top