Overview

What You'll Learn

What You'll Need

What You'll Build

Architecture Overview

Clone the Companion Git Repo

git clone https://github.com/Snowflake-Labs/sfguide-build-autonomous-pipelines-for-ai-agents.git
cd sfguide-build-autonomous-pipelines-for-ai-agents

Bootstrap the Account

Note: This step has been already completed in your account as part of the Summit provisioning. Run this only if you intend to run the hands-on lab in your own Snowflake account.

source .env
snow sql -f 1_bootstrap/setup.sql -c <connection-name>

Note: The Openflow deployment provisioning runs asynchronously. You can continue with the next steps while it completes. The deployment must be ready before you configure the Openflow connector in Step 4.

show dcm projects in schema dcm_db.projects;
-- DCM_PROJECT_DEV
show openflow deployments like 'summit_deployment';
-- SUMMIT_DEPLOYMENT
show network rules in schema dcm_db.network;
-- REDPANDA_NETWORK_RULE
show integrations like 'summit_eai';
-- SUMMIT_EAI

SELECT CURRENT_ORGANIZATION_NAME() || '-' || CURRENT_ACCOUNT_NAME() AS account_identifier,
       CURRENT_USER() AS user_name;

Set Up Your Environment

Python Environment

# Verify Python 3.13+ is available
python3 --version  # Must show 3.13 or higher

# If below 3.13, install it first:
#   macOS:  brew install [email protected]
#   Ubuntu: sudo apt install python3.13 python3.13-venv
# Then use the explicit path: /opt/homebrew/bin/python3.13 -m venv .venv

python3 -m venv .venv
source .venv/bin/activate
pip install --upgrade pip
pip install kafka-python-ng python-dotenv snowflake-cli snowflake-connector-python ipykernel
pip install "snowflake-connector-python[pandas]"

Create a Programmatic Access Token (PAT)

ALTER USER ADD PAT summit_admin_pat
  DAYS_TO_EXPIRY = 7
  COMMENT = 'PAT for summit quickstart';

Note: The SUMMIT_ADMIN role must already be granted to your user (the bootstrap section does this). If you haven't bootstrapped yet, go to bootstrap section and configure the foundational roles and access for your account.

Environment Variables

cp .env.template .env

Configure Snowflake CLI

source .env
bash helpers/setup_snow_cli_connection.sh
# if prompted for password or other parameters just hit Enter multiple times

snow connection list
snow sql -q "SELECT CURRENT_ORGANIZATION_NAME() || '-' || CURRENT_ACCOUNT_NAME() AS account_identifier, CURRENT_USER() AS user_name"

Configure Redpanda CLI (rpk)

# Verify rpk cli is available
rpk --version

brew install redpanda-data/tap/redpanda  # macOS

curl -1sLf 'https://dl.redpanda.com/nzc4ZYQK3WRGd9sy/redpanda/cfg/setup/bash.deb.sh' | sudo -E bash && sudo apt install redpanda

source .env
bash helpers/setup_rpk_profile.sh

rpk cluster info

Deploy the DCM Project

Explore the Project Structure

2_dcm_project/
├── manifest.yml                        # Targets and templating config
├── sources/definitions/
│   ├── database.sql                    # Database, schemas, warehouse
│   ├── roles.sql                       # SUMMIT_DEVELOPER_ROLE, SUMMIT_INGEST_ROLE
│   ├── raw_tables.sql                  # 9 raw tables (change-tracking enabled)
│   ├── transform.sql                   # 14 dynamic tables (2 layers)
│   └── analytics.sql                   # 5 analytics views
└── scripts/
    ├── seed_data.sql                   # Reference + sample data
    ├── post_deploy.sql                 # Openflow runtime creation
    └── tear_down.sql                   # Drop all resources

Update the Manifest

targets:
  DCM_DEV:
    account_identifier: MYORG-MY_STAGE_ACCOUNT   # <-- replace with your value
    project_name: DCM_DB.PROJECTS.DCM_PROJECT_DEV
    project_owner: SUMMIT_ADMIN
    templating_config: DEV

Plan the Deployment

snow dcm plan --target DCM_DEV --from 2_dcm_project

Note: you can save the output generated after dcm plan using the "--save-output" parameter.

Deploy

snow dcm deploy --target DCM_DEV --from 2_dcm_project

Post-Deploy: Create the Openflow Runtime

snow sql -f 2_dcm_project/scripts/post_deploy.sql \
  --variable "env_suffix=_DEV" --enable-templating JINJA

Post-Deploy: Seed initial data

snow sql -f 2_dcm_project/scripts/seed_data.sql \
  --variable "env_suffix=_DEV" --enable-templating JINJA

Explore the Data model

USE ROLE SUMMIT_ADMIN;
USE WAREHOUSE SUMMIT_WH;
USE DATABASE SUMMIT_DB_DEV;
USE SCHEMA RAW;

SHOW TABLES;

SELECT * FROM CUSTOMERS ORDER BY 1;
SELECT * FROM ORDERS ORDER BY 1;
SELECT * FROM PAYMENTS ORDER BY 1;
SELECT * FROM PACKAGES ORDER BY 1;
SELECT * FROM TRACKING_EVENTS ORDER BY 1;

┌─────────────────┐       ┌──────────────────────┐
│   CUSTOMERS     │       │  SHIPPING_PRODUCTS   │
│─────────────────│       │──────────────────────│
│ customer_id PK  │       │ product_id PK        │
│ customer_type   │       │ name                 │
│ first_name      │       │ service_type         │
│ last_name       │       │ zone                 │
│ company_name    │       │ base_price           │
│ email           │       │ max_weight/dims      │
│ city, country   │       │ estimated_days       │
└────────┬────────┘       └──────────┬───────────┘
         │ 1:N                       │ 1:N
         ▼                           ▼
┌──────────────────────────────────────────────┐
│                  ORDERS                      │
│──────────────────────────────────────────────│
│ order_id PK                                  │
│ customer_id FK ──► CUSTOMERS                 │
│ origin_location_id FK ──► LOCATIONS          │
│ pickup_address/city/country                  │
│ destination_address/city/country             │
│ total_amount, currency                       │
└───────┬──────────────────────────┬───────────┘
        │ 1:N                      │ 1:1
        ▼                          ▼
┌─────────────────────────┐       ┌─────────────────────────┐
│  ORDER_ITEMS            │       │       PAYMENTS          │
│─────────────────────────│       │─────────────────────────│
│ order_item_id PK        │       │ payment_id PK           │
│ order_id FK ─► ORDERS   │       │ order_id FK ──► ORDERS  │
│ product_id FK ─►        │       │ payment_method          │
│   SHIPPING_PRODUCTS     │       │ card_last_four/brand    │
│ quantity                │       │ card_country            │
│ declared_contents       │       │ billing_addr/city/ctry  │
│ declared_value          │       │ ip_address              │
│ insurance_opted         │       │ device_fingerprint      │
└────────┬────────────────┘       └─────────────────────────┘
         │ 1:1                        ▲ fraud detection
         ▼
┌─────────────────────────┐     ┌────────────────────┐
│     PACKAGES            │     │   LOCATIONS        │
│─────────────────────────│     │────────────────────│
│ package_id PK           │     │ location_id PK     │
│ order_item_id FK ──►    │     │ name               │
│   ORDER_ITEMS           │     │ type (HUB/WH/      │
│ order_id FK ──► ORDERS  │     │   OFFICE/PICKUP)   │
│ tracking_number         │     │ city, country      │
│ actual_weight_kg        │     │ lat, lng           │
│ status                  │     │ capacity           │
└───────┬─────────────────┘     └─────┬──────────────┘
        │ 1:N                         │ 1:N
        ▼                             │
┌──────────────────────┐              │
│  TRACKING_EVENTS     │              │
│──────────────────────│              │
│ event_id PK          │              │
│ package_id FK ─► PKG │              │
│ location_id FK ──────┼──────────────┘
│ event_timestamp      │
│ event_type           │
│ carrier              │
└───────┬──────────────┘
        │ 1:1
        ▼
┌──────────────────────┐
│    DELIVERIES        │
│──────────────────────│
│ delivery_id PK       │
│ package_id FK ─► PKG │
│ driver_name          │
│ actual_delivery_date │
│ signature_collected  │
│ status               │
└──────────────────────┘

Flow: CUSTOMER ─► ORDER ─► ORDER_ITEMS ─► PACKAGES ─► TRACKING_EVENTS ─► DELIVERIES
                    │                                        │
                    └──► PAYMENT                             └──► LOCATIONS

Start streaming from Kafka

Create Kafka Topics

Note: If you're using the provided Kafka cluster for this lab, topics are already created and data is streaming. You can skip topic creation and the producer setup step below. Jump directly to the consumer testing.

source .env
for suffix in orders order-items payments packages tracking-events deliveries; do
  rpk topic create "${KAFKA_TOPIC_PREFIX}-${suffix}"
done

rpk topic list

Test the Producer (Dry Run)

python3 3_generate/tms_producer.py --dry-run --count 1

Note: The Kafka cluster provided for this lab is already producing events — you do not need to run the producer yourself. If you are using your own cluster, run the producer script to generate events and publish them to the Kafka topics.

Run the Producer

python3 3_generate/tms_producer.py --count 5 --delay 1

[1/5] order=ORD-00002 | items=2 | events=12 | msgs=17
[2/5] order=ORD-00003 | items=1 | events=8 | msgs=15
...

Done. Produced 5 orders (82 total messages).

Verify with the Consumer

python3 3_generate/tms_consumer.py --from-beginning

Configure the Openflow Connector

Create a new Flow

Note An error will occur if you try to open the canvas using the ACCOUNTADMIN Role. Make sure that you log out from Openflow, Set your Default Role to SUMMIT_ADMIN in Snowsight and Launch Openflow again.

Configure Flow Parameters

${kafka.topic:substringAfter('tms-'):replace('-', '_'):toUpper()}

Check flow parameters fits the Kafka cluster endpoint

rpk cluster info

USE ROLE SUMMIT_ADMIN;
DESCRIBE INTEGRATION SUMMIT_EAI;
DESCRIBE NETWORK RULE DCM_DB.NETWORK.REDPANDA_NETWORK_RULE;

ALTER NETWORK RULE DCM_DB.NETWORK.REDPANDA_NETWORK_RULE
  SET VALUE_LIST = (
    '<bootstrap-server>:9092',
    '<broker-1>:9092',
    '<broker-2>:9092',
    '<broker-3>:9092'
  );

Tip: The bootstrap server uses the .any. subdomain which load-balances across brokers. The network rule must include both the bootstrap address and all individual broker addresses returned by rpk cluster info.

Start the Flow

(Optionally) Import an existing Flow

Verify Data in Snowflake

USE ROLE SUMMIT_DEVELOPER_ROLE_DEV;
USE WAREHOUSE SUMMIT_WH_DEV;
USE SCHEMA SUMMIT_DB_DEV.RAW;

SELECT 'ORDERS' AS table_name, COUNT(*) AS row_count FROM ORDERS
UNION ALL SELECT 'ORDER_ITEMS', COUNT(*) FROM ORDER_ITEMS
UNION ALL SELECT 'PAYMENTS', COUNT(*) FROM PAYMENTS
UNION ALL SELECT 'PACKAGES', COUNT(*) FROM PACKAGES
UNION ALL SELECT 'TRACKING_EVENTS', COUNT(*) FROM TRACKING_EVENTS
UNION ALL SELECT 'DELIVERIES', COUNT(*) FROM DELIVERIES;

Explore the Dynamic Tables

Layer 1: Clean Tables

-- DT_CLEAN_CUSTOMERS: deduplicates by CUSTOMER_ID, trims strings, normalizes types
SELECT
    CUSTOMER_ID,
    UPPER(TRIM(CUSTOMER_TYPE)) AS CUSTOMER_TYPE,
    TRIM(FIRST_NAME) AS FIRST_NAME,
    TRIM(LAST_NAME) AS LAST_NAME,
    TRIM(COMPANY_NAME) AS COMPANY_NAME,
    TRIM(EMAIL) AS EMAIL,
    TRIM(CITY) AS CITY,
    TRIM(COUNTRY) AS COUNTRY,
    COALESCE(UPPER(TRIM(ACCOUNT_STATUS)), 'ACTIVE') AS ACCOUNT_STATUS,
    CREATED_AT
FROM SUMMIT_DB_DEV.RAW.CUSTOMERS
QUALIFY ROW_NUMBER() OVER (PARTITION BY CUSTOMER_ID ORDER BY CUSTOMER_ID) = 1;

Layer 2: Analytic Tables

USE SCHEMA SUMMIT_DB_DEV.TRANSFORM;

SELECT * 
FROM DT_ORDER_SUMMARY 
ORDER BY ORDER_DATE DESC LIMIT 10;

SELECT PACKAGE_ID, TRACKING_NUMBER, PACKAGE_STATUS, HUBS_VISITED, TRANSIT_HOURS, CARRIER
FROM DT_PACKAGE_TRACKING
ORDER BY FIRST_SCAN DESC LIMIT 10;

SELECT TRACKING_NUMBER, HOP_NUMBER, LOCATION_NAME, LOCATION_CITY, EVENT_TYPE, 
       MINUTES_SINCE_PREV_HOP, CUMULATIVE_MINUTES
FROM DT_PACKAGE_HOPS
WHERE TRACKING_NUMBER = 'TMS-2025-000001'
ORDER BY HOP_NUMBER;

SELECT LOCATION_NAME, LOCATION_TYPE, CITY, ACTIVITY_DATE,
       NUM_PACKAGES, PACKAGES_ARRIVED, PACKAGES_DEPARTED,
       PROCESSING_P75_MINUTES, PROCESSING_P90_MINUTES
FROM DT_LOCATION_ACTIVITY
ORDER BY ACTIVITY_DATE DESC, NUM_PACKAGES DESC
LIMIT 10;

SELECT COUNT(*) AS fraud_results FROM DT_FRAUD_DETECTION;

Check Dynamic Table Health

SHOW DYNAMIC TABLES IN SCHEMA SUMMIT_DB_DEV.TRANSFORM;

Run AI-Powered Fraud Detection

Understanding the Fraud Signals

Run the Fraud Producer

Note: We are generating fraud payments already in the provided Kafka Cluster. Run this only if you are using your own Kafka Cluster.

source .env
python3 3_generate/tms_producer.py --count 50 --delay 0.5 --fraud-rate 0.10

Score Payments Using the Notebook

# If running in Snowsight Workspace, use the block below
session = get_active_session()
conn = session.connection

source .venv/bin/activate

# If running locally, use the block below
conn = snowflake.connector.connect(
    connection_name="summit"
)

What the notebook does

USE ROLE SUMMIT_DEVELOPER_ROLE_DEV;
USE SCHEMA SUMMIT_DB_DEV.TRANSFORM;

SELECT COUNT(*) AS total_scored,
       SUM(CASE WHEN IS_FRAUD THEN 1 ELSE 0 END) AS flagged_fraud,
       ROUND(AVG(FRAUD_SCORE), 3) AS avg_score
FROM FRAUD_DETECTION_RESULTS;

Explore the AI-Enriched Fraud Results

SELECT PAYMENT_ID, FRAUD_SCORE, FRAUD_TYPE, EXPLANATION
FROM FRAUD_DETECTION_RESULTS
WHERE IS_FRAUD = TRUE
ORDER BY FRAUD_SCORE DESC LIMIT 5;

Explore the Fraud Detection Dynamic Table

SELECT CUSTOMER_NAME, CUSTOMER_COUNTRY, PAYMENT_METHOD, CARD_BRAND,
       CARD_COUNTRY, BILLING_COUNTRY, PAYMENT_AMOUNT,
       FRAUD_SCORE, IS_FRAUD, FRAUD_SIGNALS, FRAUD_TYPE, EXPLANATION
FROM SUMMIT_DB_DEV.TRANSFORM.DT_FRAUD_DETECTION
WHERE IS_FRAUD = TRUE
ORDER BY FRAUD_SCORE DESC
LIMIT 10;

Query the Analytics Layer

USE ROLE SUMMIT_DEVELOPER_ROLE_DEV;
USE SCHEMA SUMMIT_DB_DEV.ANALYTICS;

SHOW VIEWS;

Order Summary

SELECT ORDER_ID, CUSTOMER_NAME, ORDER_DATE, ORDER_STATUS,
       DESTINATION_CITY, TOTAL_ITEMS, ORDER_VALUE, DAYS_SINCE_ORDER
FROM ORDER_SUMMARY
WHERE ORDER_STATUS = 'DELIVERED'
ORDER BY ORDER_DATE DESC
LIMIT 20;

Package Tracking

SELECT TRACKING_NUMBER, CUSTOMER_NAME, DESTINATION_CITY,
       PACKAGE_STATUS, HUBS_VISITED, TRANSIT_HOURS, CARRIER
FROM PACKAGE_TRACKING
WHERE PACKAGE_STATUS != 'DELIVERED'
ORDER BY FIRST_SCAN DESC;

Fraud Alerts

SELECT CUSTOMER_NAME, PAYMENT_AMOUNT, FRAUD_SCORE, FRAUD_SIGNALS,
       CARD_COUNTRY, BILLING_COUNTRY, CUSTOMER_COUNTRY
FROM FRAUD_DETECTION
WHERE IS_FRAUD = TRUE
ORDER BY PAYMENT_TIMESTAMP DESC;

Location Performance

SELECT LOCATION_NAME, LOCATION_TYPE, CITY, COUNTRY,
       NUM_PACKAGES, PROCESSING_P90_MINUTES
FROM LOCATION_ACTIVITY
WHERE ACTIVITY_DATE = CURRENT_DATE()
ORDER BY PROCESSING_P90_MINUTES DESC
LIMIT 10;

Create Semantic View using Cortex Code

Important: The semantic view must be created using the SUMMIT_ADMIN role (which owns the ANALYTICS schema). If you're running in a Snowsight worksheet, run USE ROLE SUMMIT_ADMIN; first. The snow sql CLI command already uses this role via your summit connection.

The Prompt

Create a semantic view named SUMMIT_DB_DEV.ANALYTICS.TMS_SEMANTIC_VIEW over the following views
in the ANALYTICS schema of SUMMIT_DB_DEV:

- ORDER_SUMMARY
- PACKAGE_TRACKING
- PACKAGE_HOPS
- LOCATION_ACTIVITY
- FRAUD_DETECTION

Requirements:
1. Add meaningful descriptions to the semantic view itself and to every table, column, dimension,
   and metric so that Cortex Analyst understands the business context of a Transportation
   Management System (TMS) for a pan-European shipping company.
2. Define appropriate relationships (joins) between the tables based on shared keys (ORDER_ID,
   PACKAGE_ID, CUSTOMER_NAME, etc.).
3. Add at least 3 verified queries (examples) that demonstrate how to use the semantic view.

Rules:
Start the SQL file with `USE ROLE SUMMIT_ADMIN;` and `USE WAREHOUSE SUMMIT_WH_DEV;`.
Create only a SQL file and save it locally.
Use the local repository to get information about schema objects.
Do not try to run snowflake statements. Do not run the SQL yet.

The Generated SQL

TABLES (
    order_summary AS SUMMIT_DB_DEV.ANALYTICS.ORDER_SUMMARY
      PRIMARY KEY (ORDER_ID)
      WITH SYNONYMS ('orders', 'shipments', 'order details')
      COMMENT = 'Denormalized order view with customer info, item counts, ...',
    package_tracking AS SUMMIT_DB_DEV.ANALYTICS.PACKAGE_TRACKING
      PRIMARY KEY (PACKAGE_ID) ...,
    package_hops AS SUMMIT_DB_DEV.ANALYTICS.PACKAGE_HOPS ...,
    location_activity AS SUMMIT_DB_DEV.ANALYTICS.LOCATION_ACTIVITY ...,
    fraud_detection AS SUMMIT_DB_DEV.ANALYTICS.FRAUD_DETECTION ...
)

RELATIONSHIPS (
    package_tracking_to_orders AS
      package_tracking (ORDER_ID) REFERENCES order_summary,
    package_hops_to_tracking AS
      package_hops (PACKAGE_ID) REFERENCES package_tracking,
    fraud_to_orders AS
      fraud_detection (ORDER_ID) REFERENCES order_summary
)

Validate semantic view before execution

Validate the semantic view SQL syntax by compiling it against Snowflake before execution

Deploy the Semantic View

snow sql -f 6_cortex-agent/create_semantic_view.sql

USE ROLE SUMMIT_ADMIN;
SHOW SEMANTIC VIEWS IN SCHEMA SUMMIT_DB_DEV.ANALYTICS;

Test the Semantic View

DESCRIBE SEMANTIC VIEW SUMMIT_DB_DEV.ANALYTICS.TMS_SEMANTIC_VIEW;

Test the 3 onboarding queries in TMS_SEMANTIC_VIEW to verify Cortex can resolve dimensions and metrics correctly

Create a Cortex Agent

The Prompt

Create a Cortex Agent named SUMMIT_DB_DEV.ANALYTICS.TMS_AGENT that uses the semantic view SUMMIT_DB_DEV.ANALYTICS.TMS_SEMANTIC_VIEW as its data source.

Requirements:
1. The agent should be able to answer natural language questions about the TMS (Transportation Management System) data: orders, package tracking, logistics hub performance, and fraud detection.
2. Give the agent a clear description and instructions so it understands it serves a pan-European shipping company called EuroShip Logistics.
3. The agent should respond concisely and include relevant data in its answers.

After creating the agent, provide 3 example prompts to demonstrate how to use it:
- "Which packages are currently delayed and where are they stuck?"
- "What is our fraud detection rate this week compared to last week?"
- "Show me the busiest hubs today and their average processing times"

Rules:
Create only a SQL file and save it locally. Do not run the SQL yet.
Use the local repository to get information about schema objects.

Agent Configuration

Deploy the Agent

snow sql -f 6_cortex-agent/create_agent.sql

USE ROLE SUMMIT_ADMIN;
SHOW AGENTS IN SCHEMA SUMMIT_DB_DEV.ANALYTICS;

Chat with the Agent

Work with Snowflake Intelligence

Example Conversations

"How many orders were placed today and what's the total revenue?"
"Show me all fraud alerts from the last 7 days with their explanations"
"What are the top 3 busiest hubs right now by package volume?"
"Which carriers have the longest average transit times?"
"Compare this week's fraud rate to last week"

Build a Streamlit Dashboard with Cortex Code

Prepare the Prompt

Build a Streamlit in Snowflake (SiS) app for the EuroShip Logistics TMS system.

The app should connect to SUMMIT_DB_DEV.ANALYTICS and provide:

1. **Dashboard page** — Key KPIs at the top (total orders, packages in transit, fraud alerts, avg transit hours), followed by charts showing:
   - Orders over time (line chart)
   - Package status distribution (bar chart)
   - Top 10 busiest hubs by package volume (horizontal bar chart)

2. **Package Tracking page** — A searchable table of all packages with filters for status (IN_TRANSIT, DELIVERED, etc.) and carrier. Show tracking number, customer, destination, status, hubs visited, and transit hours.

3. **Fraud Alerts page** — A table of flagged fraudulent payments with fraud score, fraud type, triggered signals, and the AI-generated explanation. Add a filter for minimum fraud score threshold (slider from 0.3 to 1.0).

4. **Location Performance page** — A table and bar chart of hub/warehouse performance metrics: location name, type, city, country, number of packages processed, and P90 processing time in minutes. Add date filter.

Requirements:
- Use the role SUMMIT_ADMIN and warehouse SUMMIT_WH_DEV.
- Query these views: ORDER_SUMMARY, PACKAGE_TRACKING, FRAUD_DETECTION, LOCATION_ACTIVITY.
- Use st.connection("snowflake") for the Snowflake connection.
- Use Streamlit's built-in charting (st.bar_chart, st.line_chart) or st.altair_chart for more control.
- Add a sidebar with page navigation using st.navigation and st.Page.
- Apply clean formatting with st.metric for KPIs.
- The app title should be "EuroShip Logistics — TMS Operations".

Rules:
- Create only the Python app file and save it locally as `7_streamlit/tms_app.py`.
- Do not deploy the app yet.
- Use the local repository to get information about schema objects and column names.

Generate the App with Cortex Code

Run Locally

source .venv/bin/activate
streamlit run 7_streamlit/tms_app.py

Deploy to Snowflake (Optional)

Update the streamlit app to use streamlit snowflake connection

snow streamlit deploy tms_operations_app \
  --replace \
  --database SUMMIT_DB_DEV \
  --role SUMMIT_ADMIN \
  --project 7_streamlit

Iterate with Cortex Code

Bonus: Configure github actions for your DCM project

Multi-Environment Strategy

Cleanup

Stop the Openflow Connector

Drop All Resources

snow sql -f 2_dcm_project/scripts/tear_down.sql \
  --variable "env_suffix=_DEV" --enable-templating JINJA

Drop Bootstrap Resources (Optional)

USE ROLE ACCOUNTADMIN;

ALTER OPENFLOW DEPLOYMENT SUMMIT_DEPLOYMENT TERMINATE;
DROP DATABASE IF EXISTS DCM_DB;
DROP WAREHOUSE IF EXISTS SUMMIT_WH;
DROP ROLE IF EXISTS SUMMIT_ADMIN;

Note: Terminating the Openflow deployment takes a few minutes to complete.

Delete Kafka Topics (Optional)

source .env
for suffix in orders order-items payments packages tracking-events deliveries; do
  rpk topic delete "${KAFKA_TOPIC_PREFIX}-${suffix}"
done

Conclusion and Resources

What You Learned

Related Resources