Snowflake-Alerts an MS Teams senden

Schritt 1: Webhook in Teams anlegen

Legen Sie in Teams einen neuen Kanal an oder wechseln Sie in den Kanal, in dem die Alerts erscheinen sollen.

Klicken Sie oben rechts im Kanal auf die drei Punkte und dann auf "Kanal verwalten".

Wechseln Sie auf den Reiter "Einstellungen", dann in den Bereich "Connectors" und klicken Sie auf "Bearbeiten".

Sie sehen eine Liste verfügbarer Connectors. Suchen Sie nach "Webhook" und klicken Sie auf "Hinzufügen".

Im nächsten Schritt können Sie ein Bild für den Webhook hochladen. Ich nehme dafür ein passendes Snowflake-Logo. Vergeben Sie unbedingt einen Namen und klicken Sie dann auf "Erstellen".

Nach dem Klick auf "Erstellen" erhalten Sie die Webhook-URL. Die URL enthält Ihr Secret – gehen Sie also sorgfältig damit um. Kopieren Sie die URL zunächst und legen Sie sie in einem Notizblock ab.

Webhook testen

Mit folgendem CURL-Befehl testen Sie den Webhook. Unter Windows verwenden Sie dafür Git Bash.

curl -X POST https://paste-your-url-with-secret-here \
-H "Content-Type: application/json" \
-d '{"text": "Hello, world"}'

Die Nachricht "Hello, world" sollte sofort in Ihrem Teams-Kanal auftauchen.

Glückwunsch – Ihr neuer Webhook läuft!

Schritt 2: Snowflake-Secret anlegen

Die Webhook-URL enthält ein Secret. Ersetzen Sie den Secret-String unten durch Ihren eigenen und führen Sie diesen Befehl in Snowflake aus.

Hinweis: Secrets sind Objekte auf Schema-Ebene. Achten Sie auf den richtigen Datenbank- und Schema-Kontext Ihres Worksheets oder verwenden Sie voll qualifizierte Namen.

In meinem Fall habe ich ein Secret namens gmds_teams_secret im Schema public der Datenbank analytics angelegt.

use schmea <database>.<schema>;

CREATE OR REPLACE SECRET gmds_teams_secret
  TYPE = GENERIC_STRING
  SECRET_STRING = 'this-is-the-secret';

Zur Klarstellung: Das Secret ist der letzte Teil der hier gezeigten URI: https://org-name.webhook.office.com/webhookb2/webhook-id/IncomingWebhook/this-is-the-secret

Schritt 3: Webhook Notification Integration erstellen

Da das Secret nun angelegt ist, erstellen wir die Notification Integration:

CREATE OR REPLACE NOTIFICATION INTEGRATION gmds_teams_webhook_integration
  TYPE=WEBHOOK
  ENABLED=TRUE
  WEBHOOK_URL='https://org-name/webhook.office.com/webhookb2/webhook-id/IncomingWebhook/SNOWFLAKE_WEBHOOK_SECRET'
  WEBHOOK_SECRET=analytics.public.gmds_teams_secret
  WEBHOOK_BODY_TEMPLATE='{"text": "SNOWFLAKE_WEBHOOK_MESSAGE"}'
  WEBHOOK_HEADERS=('Content-Type'='application/json');

Schritt 4: Benachrichtigung senden

Zum Versand einer Benachrichtigung nutzen wir die integrierte Stored Procedure SYSTEM$SEND_SNOWFLAKE_NOTIFICATION. Dabei übergeben wir der Procedure die Funktion SANITIZE_WEBHOOK_CONTENT, um Platzhalter (z. B. SNOWFLAKE_WEBHOOK_SECRET) aus der Nachricht zu entfernen.

So sah der Code aus, den ich in meinem Account ausgeführt habe:

CALL SYSTEM$SEND_SNOWFLAKE_NOTIFICATION(
  SNOWFLAKE.NOTIFICATION.TEXT_PLAIN(
    SNOWFLAKE.NOTIFICATION.SANITIZE_WEBHOOK_CONTENT('This is a test Teams Alert from my Snowflake Account')
  ),
  SNOWFLAKE.NOTIFICATION.INTEGRATION('gmds_teams_webhook_integration')
);

Die Benachrichtigung kam umgehend in Microsoft Teams an!

Mit diesen Grundbausteinen in der Hand widmen wir uns nun einem realen Beispiel.

SQL-Query für Warehouse-Spikes schreiben und in einen Serverless Task verpacken

Die folgende Query vergleicht die aktuelle Nutzung (letzte abgeschlossene Stunde) mit der durchschnittlichen Stundennutzung jedes Warehouses im vergangenen Monat. Markiert werden Warehouses mit einer Nutzungssteigerung von 50 %.

Wir setzen auf einen Serverless Task – das spart Kosten. Lassen Sie einfach den Warehouse-Namen weg, damit der Task serverless läuft.

Zu Demonstrationszwecken hänge ich per UNION einen Dummy-Datensatz an, damit jede Ausführung des Tasks eine Zeile und damit einen Alert erzeugt.

CREATE OR REPLACE TASK monitor_warehouse_spikes
SCHEDULE = 'USING CRON 2 * * * * America/New_York'
SERVERLESS_TASK_MIN_STATEMENT_SIZE = 'XSMALL'
SERVERLESS_TASK_MAX_STATEMENT_SIZE = 'XSMALL'
as
insert into usage_spike_alerts (warehouse_name,last_hour_credits,avg_monthly_credits,credit_diff,percent_increase)
WITH last_hour_usage AS (
    SELECT
        warehouse_name,
        sum(credits_used) AS last_hour_credits
    FROM
        snowflake.account_usage.warehouse_metering_history
    WHERE
        start_time >= DATEADD(hour, -2, CURRENT_TIMESTAMP)
        AND end_time <= CURRENT_TIMESTAMP

Code ausklappen

SCHEDULE = 'USING CRON 2 * * * * America/New_York' heißt: 2 Minuten nach jeder vollen Stunde, an jedem Tag.

Tabelle für die Query-Ergebnisse anlegen

CREATE or replace TABLE usage_spike_alerts (
    alert_id INT AUTOINCREMENT PRIMARY KEY,
    warehouse_name STRING NOT NULL,
    last_hour_credits FLOAT NOT NULL,
    avg_monthly_credits FLOAT NOT NULL,
    credit_diff FLOAT NOT NULL,
    percent_increase FLOAT NOT NULL,
    inserted_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    alert_sent boolean default false
);

Beachten Sie: Diese Tabelle enthält einige Hilfsspalten mit Default-Werten, die nicht aus dem Query-Ergebnis stammen:

• alert_id: Primärschlüssel
• inserted_at: zeigt, wann der Task den Datensatz eingefügt hat.
• alert_sent: zunächst false, wird nach dem Versand des Alerts auf true gesetzt.

Task testen und Ergebnisse prüfen

execute task monitor_warehouse_spikes;
select * from usage_spike_alerts where not alert_sent;

Procedure für den Alert-Versand bei einem Spike anlegen

Wir wollen Folgendes erreichen:

• Die Tabelle usage_spike_alerts auf noch nicht versendete Datensätze prüfen: alert_sent==false
• Sind ungesendete Datensätze vorhanden, an Microsoft Teams schicken.
• Den Datensatz als gesendet kennzeichnen.
• Die Anzahl versendeter Alerts in der SQL-Konsole ausgeben.

CREATE OR REPLACE PROCEDURE send_usage_spike_alerts()
RETURNS STRING
LANGUAGE PYTHON
RUNTIME_VERSION = '3.8'
PACKAGES = ('snowflake-snowpark-python')
HANDLER = 'send_alerts'
AS $$
import snowflake.snowpark as snowpark

def send_alerts(session):
    query = """
        SELECT warehouse_name, last_hour_credits, avg_monthly_credits, credit_diff, percent_increase
        FROM usage_spike_alerts
        WHERE alert_sent = FALSE
    """

Code ausklappen

Procedure manuell testen

Wir haben bereits einen Testdatensatz in die "Spikes"-Tabelle eingefügt. Führen wir nun die Stored Procedure aus und prüfen:

• Werden die Datensätze auf alert_sent==true aktualisiert?
• Kommt die Nachricht in Microsoft Teams an?

execute task monitor_warehouse_spikes;  -- falls noch nicht geschehen ...
select * from usage_spike_alerts where not alert_sent; -- prüfen, sent = false
CALL send_usage_spike_alerts(); -- Alert senden
-- auf den Alert warten
select * from usage_spike_alerts where not alert_sent; -- 0 Zeilen

Sie sollten jetzt einen Alert in Teams erhalten haben!

Die Formatierung des Alerts kann etwas knifflig sein. Experimentieren Sie ruhig mit dem Python-Code, um den Alert in einem ansprechenderen Format zu versenden – und erzählen Sie uns, wie Sie es gelöst haben!

Task und Procedure miteinander verketten

Der stündliche Zeitplan des Tasks monitor_warehouse_spikes soll den End-to-End-Prozess abdecken. Sorgen wir also dafür, dass nach Ausführung des Tasks monitor_warehouse_spikes auch die Procedure für den Alert-Versand läuft.

Zuerst verpacken wir die Procedure in einen Serverless Task und aktivieren ihn:

CREATE TASK send_usage_spike_alerts_task
AS
CALL send_usage_spike_alerts();

alter task send_usage_spike_alerts_task resume;

Anschließend verketten wir die Tasks:

ALTER TASK send_usage_spike_alerts_task
ADD AFTER monitor_warehouse_spikes;

Test:

1execute task monitor_warehouse_spikes;

Dieser Task sollte nun die neuen Datensätze in die Tabelle einfügen und die Alerts an Teams schicken!

Beim direkten Aufruf der Procedure send_usage_spike_alerts() erscheint die Nachricht sofort in Microsoft Teams. Beim Verketten von send_usage_spike_alerts_task mit monitor_warehouse_spikes dauert es bis zu 3 Minuten, bis der Alert ankommt.

Snowflake-Alerts an Microsoft Teams zu schicken, ist enorm hilfreich. Die Anwendungsfälle für diese Art von Benachrichtigung sind nahezu grenzenlos!

Dieser Artikel gibt Ihnen das Rüstzeug für:

• das Anlegen eines Webhooks in Microsoft Teams.
• das Erstellen eines Secrets in Snowflake.
• das Einrichten einer Webhook-Integration in Snowflake.
• das Anlegen eines Tasks zur Protokollierung von Warehouse-Nutzungsspitzen.
• das Erstellen einer Procedure, die Alerts auf Basis einer Bedingung versendet – in diesem Fall, ob die Query Zeilen liefert.
• das Verpacken einer Procedure in einen Task.
• das Verketten mehrerer Tasks.

Ich bin gespannt auf Ihre Anwendungsfälle! 🥂

Jeff ist Data- und Analytics-Consultant mit über 15 Jahren Erfahrung in der Automatisierung von Insights und der datenbasierten Steuerung von Geschäftsprozessen. Technologisch ist er auf Snowflake + dbt + Tableau spezialisiert. Inhaltlich bringt er Erfahrung aus den Branchen öffentliche Versorgung, klinische Studien, Verlagswesen, CPG und Fertigung mit. Melden Sie sich jederzeit: [email protected].