Gerenciando custos do Cortex AI Functions com uso da conta¶

O Snowflake Cortex AI Functions (AI_COMPLETE, AI_SUMMARIZE, AI_TRANSLATE, AI_SENTIMENT etc.) consome créditos com base no uso de tokens ou de páginas. Sem monitoramento e controles, os custos para o uso dessas funções podem aumentar rapidamente devido a:

Prompts não otimizados que geram tokens excessivos
Consultas de longa duração ou descontroladas
Ausência de limites de gastos por usuário
Visibilidade insuficiente dos padrões de uso

Este tópico sugere estratégias para monitorar, gerenciar e controlar os custos associados ao Snowflake Cortex AI Functions. Ao usar a exibição CORTEX_AI_FUNCTIONS_USAGE_HISTORY, você pode rastrear os padrões de uso e implementar controles de custos automatizados. Essas técnicas podem ajudar você a monitorar o uso, alertar quando os limites de gastos são excedidos, controlar o acesso a funções com base em limites mensais e interromper consultas descontroladas.

Exibição do histórico de uso¶

A exibição SNOWFLAKE.ACCOUNT_USAGE.CORTEX_AI_FUNCTIONS_USAGE_HISTORY fornece uma telemetria detalhada de todas as funções do Cortex AI Functions invocadas por SQL. A exibição tem uma latência máxima de sessenta minutos, embora os dados possam ficar disponíveis em até dez minutos após o início da execução da função. Para obter informações detalhadas sobre essa exibição, consulte Exibição CORTEX_AI_FUNCTIONS_USAGE_HISTORY.

Monitoramento de uso básico¶

As consultas a seguir ajudam você a entender os padrões de uso do AI Functions. Execute-as você mesmo periodicamente ou integre-as aos painéis para obter visibilidade contínua.

Consumo de crédito diário por função e modelo¶

Rastreie as tendências de gastos diários para identificar picos de uso e entender quais funções e modelos consomem mais créditos.

SELECT
    DATE_TRUNC('day', START_TIME) AS usage_date,
    FUNCTION_NAME,
    MODEL_NAME,
    SUM(CREDITS) AS total_credits,
    COUNT(DISTINCT QUERY_ID) AS query_count
FROM SNOWFLAKE.ACCOUNT_USAGE.CORTEX_AI_FUNCTIONS_USAGE_HISTORY
WHERE START_TIME >= DATEADD('day', -30, CURRENT_TIMESTAMP())
GROUP BY 1, 2, 3
ORDER BY usage_date DESC, total_credits DESC;

Copy

Consumo de crédito mensal por usuário¶

Identifique os principais consumidores e rastreie os gastos por usuário ao longo do tempo. Esta consulta trabalha em conjunto com as exibição USERS para fornecer detalhes do usuário, incluindo e-mail e função padrão para facilitar a identificação e o acompanhamento.

SELECT
    DATE_TRUNC('month', h.START_TIME) AS usage_month,
    u.NAME AS user_name,
    u.EMAIL,
    u.DEFAULT_ROLE,
    SUM(h.CREDITS) AS total_credits,
    COUNT(DISTINCT h.QUERY_ID) AS query_count
FROM SNOWFLAKE.ACCOUNT_USAGE.CORTEX_AI_FUNCTIONS_USAGE_HISTORY h
JOIN SNOWFLAKE.ACCOUNT_USAGE.USERS u
    ON h.USER_ID = u.USER_ID
WHERE h.START_TIME >= DATEADD('month', -3, CURRENT_TIMESTAMP())
GROUP BY 1, 2, 3, 4
ORDER BY usage_month DESC, total_credits DESC;

Copy

Controle de custos¶

Defina mecanismos automatizados para detectar gastos excessivos e tomar medidas corretivas. Estas consultas podem ser usadas independentemente umas das outras, ou combinadas para uma governança de custos abrangente.

Alerta de gastos mensais no nível da conta¶

Configure um alerta automatizado que monitore o consumo de crédito total mensal por função de AI em sua conta inteira. Quando os gastos excedem um limite definido, o alerta envia uma notificação por e-mail aos administradores designados. A configuração do alerta requer os seguintes pré-requisitos:

Função ACCOUNTADMIN ou privilégios apropriados para criar integrações de notificação e alertas
Um warehouse para executar a verificação de condição de alerta
Endereços de e-mail verificados dos destinatários do alerta

Primeiro, crie uma integração de notificação, se ainda não existir uma. Este exemplo substitui qualquer integração existente chamada ai_cost_alerts.

CREATE OR REPLACE NOTIFICATION INTEGRATION ai_cost_alerts
    TYPE = EMAIL
    ENABLED = TRUE
    ALLOWED_RECIPIENTS = ('admin@company.com', 'finops@company.com')

Copy

Em seguida, crie uma tabela para rastrear quando os alertas foram enviados em cada mês. Isso é usado para impedir alertas duplicados em um mês.

CREATE TABLE IF NOT EXISTS AI_FUNCTIONS_ALERT_STATE (
    ALERT_NAME VARCHAR NOT NULL,
    ALERT_MONTH DATE NOT NULL,
    SENT_AT TIMESTAMP_LTZ DEFAULT CURRENT_TIMESTAMP(),
    CREDITS_AT_ALERT NUMBER(38,6),
    PRIMARY KEY (ALERT_NAME, ALERT_MONTH)
);

Copy

Agora crie um procedimento armazenado para verificar se um alerta já foi enviado este mês, registre o estado do alerta e envie a notificação por e-mail.

CREATE OR REPLACE PROCEDURE SEND_MONTHLY_SPEND_ALERT(P_THRESHOLD FLOAT)
RETURNS VARCHAR
LANGUAGE JAVASCRIPT
EXECUTE AS CALLER
AS
$$
    // Check if alert already sent this month
    var check_sent = snowflake.execute({
        sqlText: `SELECT COUNT(*) AS cnt FROM AI_FUNCTIONS_ALERT_STATE
                WHERE ALERT_NAME = 'monthly_spend'
                AND ALERT_MONTH = DATE_TRUNC('month', CURRENT_DATE())`
    });
    check_sent.next();
    var already_sent = check_sent.getColumnValue(1);

    if (already_sent > 0) {
        return 'Alert already sent for this month';
    }

    // Get current spend
    var spend_result = snowflake.execute({
        sqlText: `SELECT COALESCE(SUM(CREDITS), 0) AS total
                FROM SNOWFLAKE.ACCOUNT_USAGE.CORTEX_AI_FUNCTIONS_USAGE_HISTORY
                WHERE START_TIME >= DATE_TRUNC('month', CURRENT_TIMESTAMP())`
    });
    spend_result.next();
    var v_credits = spend_result.getColumnValue(1);

    // Check threshold
    if (v_credits <= P_THRESHOLD) {
        return 'Threshold not exceeded. Current: ' + v_credits + ' / ' + P_THRESHOLD;
    }

    // Record alert
    snowflake.execute({
        sqlText: `INSERT INTO AI_FUNCTIONS_ALERT_STATE (ALERT_NAME, ALERT_MONTH, CREDITS_AT_ALERT)
                VALUES ('monthly_spend', DATE_TRUNC('month', CURRENT_DATE()), ?)`,
        binds: [v_credits]
    });

    // Send email - update the recipient email address
    snowflake.execute({
        sqlText: `CALL SYSTEM$SEND_EMAIL(
            'ai_cost_alerts',
            'admin@company.com',
            'AI Functions Monthly Spend Alert',
            'Monthly AI Function credit consumption has exceeded the threshold.\\n\\n' ||
            'Current spend: ' || ${v_credits}::VARCHAR || ' credits\\n' ||
            'Threshold: ' || ${P_THRESHOLD}::VARCHAR || ' credits\\n\\n' ||
            'Please review usage accordingly.'
        )`
    });

    return 'Alert sent. Credits: ' + v_credits;
$$;

Copy

Por fim, crie um alerta que verifique o uso em relação ao limite de gastos a cada hora e chame o procedimento para enviar a notificação, se necessário. Você deve ajustar o limite de 1.000 créditos, que aparece em dois lugares no exemplo abaixo, para o limite desejado.

CREATE OR REPLACE ALERT ai_functions_monthly_spend_alert
    WAREHOUSE = <your_warehouse>
    SCHEDULE = 'USING CRON 0 * * * * UTC'  -- Runs every hour
    IF (EXISTS (
        SELECT 1
        FROM SNOWFLAKE.ACCOUNT_USAGE.CORTEX_AI_FUNCTIONS_USAGE_HISTORY
        WHERE START_TIME >= DATE_TRUNC('month', CURRENT_TIMESTAMP())
        HAVING SUM(CREDITS) > 1000  -- adjust the limit accordingly
    ))
    THEN
        CALL SEND_MONTHLY_SPEND_ALERT(1000);  -- please adjust the limit accordingly

-- enable the alert
ALTER ALERT ai_functions_monthly_spend_alert RESUME;

Copy

Dica

Para fins de teste, primeiro defina o limite como 0 para acionar o alerta imediatamente. Recrie o alerta com o limite desejado após confirmar que ele funciona como esperado.

Depois de testar com um limite de 0, execute o seguinte SQL para permitir que o alerta seja acionado novamente no mês atual.

DELETE FROM AI_FUNCTIONS_ALERT_STATE
WHERE ALERT_NAME = 'monthly_spend'
AND ALERT_MONTH = DATE_TRUNC('month', CURRENT_DATE());

Copy

Para garantir que o alerta esteja funcionando, consulte o histórico de alertas e a tabela de estado do alerta da seguinte maneira:

-- Make sure alert exists
SHOW ALERTS LIKE 'ai_functions_monthly_spend_alert';

-- Check alert history
SELECT *
FROM TABLE(INFORMATION_SCHEMA.ALERT_HISTORY(
    SCHEDULED_TIME_RANGE_START => DATEADD('day', -1, CURRENT_TIMESTAMP()),
    ALERT_NAME => 'ai_functions_monthly_spend_alert'
))
ORDER BY SCHEDULED_TIME DESC;

-- Check which months have had alerts sent
SELECT * FROM AI_FUNCTIONS_ALERT_STATE ORDER BY ALERT_MONTH DESC;

Copy

Limites de gastos mensais por usuário¶

Este exemplo implementa limites de gastos mensais por usuário. Os usuários recebem uma AI_FUNCTIONS_USER_ROLE personalizada dedicada que concede acesso ao Cortex AI Functions. Uma tabela armazena o orçamento mensal de tokens dos usuários individuais. Quando um usuário excede o orçamento do mês, uma tarefa por hora revoga o acesso dele ao AI Functions removendo a AI_FUNCTIONS_USER_ROLE. Uma tarefa mensal restaura a função no início do mês seguinte.

Importante

Por padrão, todos os usuários têm acesso ao AI Functions (e a outros recursos do Snowflake Cortex) porque a função de banco de dados SNOWFLAKE.CORTEX_USER é concedida à função PUBLIC. Para impor limites por usuário, você deve revogar SNOWFLAKE.CORTEX_USER de PUBLIC e concedê-la somente por meio da AI_FUNCTIONS_USER_ROLE. Use o seguinte SQL para revogar a função de PUBLIC:

REVOKE DATABASE ROLE SNOWFLAKE.CORTEX_USER FROM ROLE PUBLIC;

Copy

Certifique-se de que todos os usuários que precisam de acesso aos recursos do Cortex recebam apenas a AI_FUNCTIONS_USER_ROLE. O uso de qualquer outra função que inclua SNOWFLAKE.CORTEX_USER permite que os usuários ignorem os controles de limite de gastos implementados neste exemplo. Em alguns casos, você pode usar uma função mais específica; por exemplo, usuários que precisam ter acesso apenas ao Cortex Analyst podem receber a função SNOWFLAKE.CORTEX_ANALYST_USER em vez da SNOWFLAKE.CORTEX_USER.

Para configurar os limites de gastos por usuário, primeiro crie uma função que controle o acesso ao AI Functions, permitindo que esse acesso seja gerenciado separadamente dos outros privilégios.

-- Create a role specifically for AI Function access
CREATE ROLE IF NOT EXISTS AI_FUNCTIONS_USER_ROLE;

-- Grant necessary privileges to the role
GRANT DATABASE ROLE SNOWFLAKE.CORTEX_USER TO ROLE AI_FUNCTIONS_USER_ROLE;

-- Grant usage on warehouse
GRANT USAGE ON WAREHOUSE AI_FUNCTIONS_WAREHOUSE TO ROLE AI_FUNCTIONS_USER_ROLE;

Copy

Agora configure a tabela de controle de acesso, que rastreia quais usuários têm acesso à função de AI, os limites individuais de gastos e o histórico de revogação deles. Ela serve como a fonte da verdade para os processos automatizados de monitoramento e restauração de acesso.

CREATE TABLE IF NOT EXISTS AI_FUNCTIONS_ACCESS_CONTROL (
    USER_NAME VARCHAR NOT NULL,
    USER_ID NUMBER,
    GRANTED_AT TIMESTAMP_LTZ DEFAULT CURRENT_TIMESTAMP(),
    MONTHLY_CREDIT_LIMIT NUMBER(38,6) DEFAULT 100,  -- adjust the limit accordingly
    IS_ACTIVE BOOLEAN DEFAULT TRUE,
    REVOKED_AT TIMESTAMP_LTZ,
    REVOCATION_REASON VARCHAR,
    PRIMARY KEY (USER_NAME)
);

Copy

Em seguida, crie um procedimento armazenado para conceder acesso à função de AI para um usuário e registre-o na tabela de controle de acesso com o respectivo limite de gastos. O código consulta o ID do usuário na visualização do uso da conta para permitir junções eficientes nas consultas de monitoramento.

CREATE OR REPLACE PROCEDURE GRANT_AI_FUNCTIONS_ACCESS(
    P_USER_NAME VARCHAR,
    P_MONTHLY_LIMIT NUMBER(38,6) DEFAULT 100  -- adjust the limit accordingly
)
RETURNS VARCHAR
LANGUAGE SQL
AS
$$
DECLARE
    v_user_id NUMBER;
BEGIN
    -- Look up USER_ID from account usage
    SELECT USER_ID INTO :v_user_id
    FROM SNOWFLAKE.ACCOUNT_USAGE.USERS
    WHERE NAME = :P_USER_NAME
    LIMIT 1;

    -- Grant the AI Functions role to the user
    EXECUTE IMMEDIATE 'GRANT ROLE AI_FUNCTIONS_USER_ROLE TO USER ' || P_USER_NAME;

    -- Register or update the user in the access control table
    MERGE INTO AI_FUNCTIONS_ACCESS_CONTROL tgt
    USING (SELECT :P_USER_NAME AS USER_NAME) src
    ON tgt.USER_NAME = src.USER_NAME
    WHEN MATCHED THEN
        UPDATE SET
            USER_ID = :v_user_id,
            IS_ACTIVE = TRUE,
            MONTHLY_CREDIT_LIMIT = :P_MONTHLY_LIMIT,
            GRANTED_AT = CURRENT_TIMESTAMP(),
            REVOKED_AT = NULL,
            REVOCATION_REASON = NULL
    WHEN NOT MATCHED THEN
        INSERT (USER_NAME, USER_ID, MONTHLY_CREDIT_LIMIT, IS_ACTIVE)
        VALUES (:P_USER_NAME, :v_user_id, :P_MONTHLY_LIMIT, TRUE);

    RETURN 'Access granted to ' || P_USER_NAME || ' with monthly limit of ' || P_MONTHLY_LIMIT || ' credits';
END;
$$;

Copy

Use esse procedimento armazenado para adicionar usuários e suas cotas de crédito à tabela de controle de acesso.

CALL GRANT_AI_FUNCTIONS_ACCESS('ALICE', 1000);  -- grants access to user ALICE with a monthly limit of 100 credits
CALL GRANT_AI_FUNCTIONS_ACCESS('BOB', 2000);    -- grants access to user BOB with a monthly limit of 200 credits

Copy

Em seguida, crie a tarefa de atualização de acesso mensal. Essa tarefa é executada no primeiro dia de cada mês para restaurar o acesso à função de AI para todos os usuários autorizados. Quando o acesso de um usuário foi revogado devido a ultrapassagem do limite no mês anterior, essa tarefa concede a ele um orçamento zerado para o novo mês.

-- Create a procedure to re-grant access to all entitled users
CREATE OR REPLACE PROCEDURE GRANT_ALL_ENTITLED_USERS()
RETURNS TABLE (USER_NAME VARCHAR, CREDIT_LIMIT NUMBER, ACTION VARCHAR)
LANGUAGE SQL
AS
$$
DECLARE
    result RESULTSET;
BEGIN
    result := (
        SELECT
            USER_NAME,
            MONTHLY_CREDIT_LIMIT AS CREDIT_LIMIT,
            'GRANTED' AS ACTION
        FROM AI_FUNCTIONS_ACCESS_CONTROL
    );

    -- Re-grant access for each entitled user
    FOR rec IN result DO
        CALL GRANT_AI_FUNCTIONS_ACCESS(rec.USER_NAME, rec.CREDIT_LIMIT);
    END FOR;

    RETURN TABLE(result);
END;
$$;

-- Create a task to run on the 1st of each month at midnight UTC
CREATE OR REPLACE TASK MONTHLY_AI_FUNCTIONS_ACCESS_REFRESH
    WAREHOUSE = <your_warehouse>
    SCHEDULE = 'USING CRON 0 0 1 * * UTC'  -- 1st day of each month at 00:00 UTC
AS
    CALL GRANT_ALL_ENTITLED_USERS();

-- Enable the task
ALTER TASK MONTHLY_AI_FUNCTIONS_ACCESS_REFRESH RESUME;

-- Run once initially to populate grantees
CALL GRANT_ALL_ENTITLED_USERS();

-- Verify task status
SHOW TASKS LIKE 'MONTHLY_AI_FUNCTIONS_ACCESS_REFRESH';

Copy

Por fim, crie uma tarefa por hora para monitorar os gastos do usuário e revogar o acesso de qualquer usuário que exceda o limite mensal.

-- Create a procedure to re-grant access to all entitled users
CREATE OR REPLACE PROCEDURE GRANT_ALL_ENTITLED_USERS()
RETURNS TABLE (USER_NAME VARCHAR, CREDIT_LIMIT NUMBER, ACTION VARCHAR)
LANGUAGE SQL
AS
$$
DECLARE
    result RESULTSET;
BEGIN
    result := (
        SELECT
            USER_NAME,
            MONTHLY_CREDIT_LIMIT AS CREDIT_LIMIT,
            'GRANTED' AS ACTION
        FROM AI_FUNCTIONS_ACCESS_CONTROL
    );

    -- Re-grant access for each entitled user
    FOR rec IN result DO
        CALL GRANT_AI_FUNCTIONS_ACCESS(rec.USER_NAME, rec.CREDIT_LIMIT);
    END FOR;

    RETURN TABLE(result);
END;
$$;

-- Create a task to run on the 1st of each month at midnight UTC
CREATE OR REPLACE TASK MONTHLY_AI_FUNCTIONS_ACCESS_REFRESH
    WAREHOUSE = <your_warehouse>
    SCHEDULE = 'USING CRON 0 0 1 * * UTC'  -- 1st day of each month at 00:00 UTC
AS
    CALL GRANT_ALL_ENTITLED_USERS();

-- Enable the task
ALTER TASK MONTHLY_AI_FUNCTIONS_ACCESS_REFRESH RESUME;

-- Run once initially to populate grantees
CALL GRANT_ALL_ENTITLED_USERS();

-- Verify task status
SHOW TASKS LIKE 'MONTHLY_AI_FUNCTIONS_ACCESS_REFRESH';

Copy

Detecção e cancelamento de consultas descontroladas¶

As consultas de função de AI de longa duração podem acumular custos significativos. Este exemplo implementa um sistema automatizado para detectar consultas que excedem um limite de crédito e cancelá-las antes que consumam ainda mais recursos. Um alerta por e-mail é enviado com os detalhes completos da consulta.

Nota

Quando uma consulta é cancelada, o cliente ainda é cobrado por todos os recursos consumidos até o momento do cancelamento. O cancelamento de uma consulta descontrolada impede um maior acúmulo de custos, mas não reembolsa os créditos que já foram gastos.

Este procedimento encontra consultas de função de AI nas últimas 48 horas que excederam o limite de crédito e ainda estão em execução, cancela-as e relata-as a um administrador.

-- Create a procedure to detect and cancel expensive runaway queries
CREATE OR REPLACE PROCEDURE MONITOR_AND_CANCEL_RUNAWAY_QUERIES(
    P_CREDIT_THRESHOLD NUMBER DEFAULT 50  -- adjust the limit accordingly
)
RETURNS TABLE (
    QUERY_ID VARCHAR,
    USER_NAME VARCHAR,
    FUNCTION_NAME VARCHAR,
    MODEL_NAME VARCHAR,
    CREDITS NUMBER,
    START_TIME TIMESTAMP_LTZ,
    ACTION VARCHAR
)
LANGUAGE SQL
AS
$$
DECLARE
    result RESULTSET;
BEGIN
    -- Find queries from the last 48 hours that exceed the threshold and are still running
    result := (
        SELECT
            h.QUERY_ID,
            u.NAME AS USER_NAME,
            h.FUNCTION_NAME,
            h.MODEL_NAME,
            h.CREDITS,
            h.START_TIME,
            h.ROLE_NAMES,
            h.QUERY_TAG,
            h.WAREHOUSE_ID,
            'CANCELLED' AS ACTION
        FROM SNOWFLAKE.ACCOUNT_USAGE.CORTEX_AI_FUNCTIONS_USAGE_HISTORY h
        LEFT JOIN SNOWFLAKE.ACCOUNT_USAGE.USERS u
            ON h.USER_ID = u.USER_ID
        WHERE h.START_TIME >= DATEADD('hour', -48, CURRENT_TIMESTAMP())
        AND h.CREDITS > :P_CREDIT_THRESHOLD
        AND h.IS_COMPLETED = FALSE
    );

    -- Cancel each runaway query and send alert
    FOR rec IN result DO
        -- Attempt to cancel the query
        BEGIN
            EXECUTE IMMEDIATE 'SELECT SYSTEM$CANCEL_QUERY(''' || rec.QUERY_ID || ''')';
        EXCEPTION
            WHEN OTHER THEN
                NULL;  -- Query may have already completed
        END;

        -- Send alert with query details
        CALL SYSTEM$SEND_EMAIL(
            'ai_cost_alerts',
            'admin@company.com',
            'Runaway AI Query Cancelled - ' || rec.QUERY_ID,
            'A runaway AI Function query has been cancelled due to excessive cost.\n\n' ||
            'Query Details:\n' ||
            '- Query ID: ' || rec.QUERY_ID || '\n' ||
            '- User: ' || COALESCE(rec.USER_NAME, 'Unknown') || '\n' ||
            '- Function: ' || rec.FUNCTION_NAME || '\n' ||
            '- Model: ' || rec.MODEL_NAME || '\n' ||
            '- Credits Used: ' || rec.CREDITS::VARCHAR || '\n' ||
            '- Threshold: ' || :P_CREDIT_THRESHOLD::VARCHAR || '\n' ||
            '- Start Time: ' || rec.START_TIME::VARCHAR || '\n' ||
            '- Roles: ' || COALESCE(rec.ROLE_NAMES::VARCHAR, 'N/A') || '\n' ||
            '- Query Tag: ' || COALESCE(rec.QUERY_TAG, 'N/A') || '\n' ||
            '- Warehouse ID: ' || COALESCE(rec.WAREHOUSE_ID::VARCHAR, 'N/A') || '\n\n' ||
            'Please investigate this query and take appropriate action.'
        );
    END FOR;

    RETURN TABLE(result);
END;
$$;

-- Create a task to monitor and cancel runaway queries every hour
CREATE OR REPLACE TASK MONITOR_RUNAWAY_AI_QUERIES
    WAREHOUSE = <your_warehouse>
    SCHEDULE = 'USING CRON 0 * * * * UTC'  -- Every hour
AS
    CALL MONITOR_AND_CANCEL_RUNAWAY_QUERIES(50);  -- adjust the limit accordingly

-- Enable the task
ALTER TASK MONITOR_RUNAWAY_AI_QUERIES RESUME;

-- Verify task status
SHOW TASKS LIKE 'MONITOR_RUNAWAY_AI_QUERIES';

-- Check task execution history
SELECT *
FROM TABLE(INFORMATION_SCHEMA.TASK_HISTORY(
    SCHEDULED_TIME_RANGE_START => DATEADD('day', -1, CURRENT_TIMESTAMP()),
    TASK_NAME => 'MONITOR_RUNAWAY_AI_QUERIES'
))
ORDER BY SCHEDULED_TIME DESC;

Copy

Dica

Talvez você já saiba que algumas de suas consultas serão executadas por muito tempo. Você pode definir uma função especial para essas consultas e excluir essa função da lógica de cancelamento no procedimento. Por exemplo, para criar a função:

CREATE ROLE AI_FUNCTIONS_USER_LONG_RUNNING_ROLE;
GRANT ROLE AI_FUNCTIONS_USER_ROLE TO ROLE AI_FUNCTIONS_USER_LONG_RUNNING_ROLE;
GRANT ROLE AI_FUNCTIONS_USER_LONG_RUNNING_ROLE TO USER LONG_RUNNING_USER;

Copy

Adicione a seguinte condição à cláusula WHERE do procedimento para excluir consultas executadas por usuários com essa função de serem canceladas.

,, code-block:: sqlexample

AND NOT ARRAY_CONTAINS(h.ROLE_NAMES, “AI_FUNCTIONS_USER_LONG_RUNNING_ROLE”)

Agora o usuário pode assumir a função para executar uma consulta de longa duração sem que ela seja cancelada:

USE ROLE AI_FUNCTIONS_USER_LONG_RUNNING_ROLE;
-- then start the long-running query

Copy

Práticas recomendadas¶

Tenha em mente as seguintes práticas recomendadas ao desenvolver uma estratégia de gerenciamento de custos para uso de função de AI:

Comece pelo monitoramento: antes de implementar controles automatizados, estabeleça padrões de uso de linha de base usando as consultas em Monitoramento de uso básico.
Defina limites iniciais conservadores: comece com limites mais baixos e ajuste-os para valores mais altos com base nos padrões de uso reais.
Use tags de consulta: incentive as equipes a usar os parâmetros de sessão QUERY_TAG para permitir a atribuição de custos por projeto ou equipe.
Revise regularmente: revise periodicamente a tabela de controle de acesso e ajuste os limites por usuário com base nas reais necessidades.
Alertas de teste: verifique se as notificações por e-mail funcionam corretamente antes de confiar nelas para alertas críticos.
Considere a latência: a exibição ACCOUNT_USAGE tem até 60 minutos de latência; considere isso em sua estratégia de monitoramento.