Ajukan akses awal

Masukkan nama depan serta email atau nomor telepon Anda. Kami akan menghubungi Anda dengan detail akses Tajo.

Konektor Snowflake

Hubungkan Snowflake ke Brevo melalui Tajo untuk menyinkronkan segmen pelanggan dari data warehouse Anda, memperkaya profil kontak dengan data analitik, dan menjalankan kampanye pemasaran personal berbekal wawasan dari warehouse.

Ikhtisar

Properti	Nilai
Platform	Snowflake
Kategori	Data Warehouse (Custom)
Kompleksitas penyiapan	Sedang
Integrasi resmi	Tidak
Data tersinkron	Pelanggan, segmen, analitik, event
Metode autentikasi	Key Pair / OAuth 2.0

Fitur

Reverse ETL - Kirim segmen pelanggan dari Snowflake ke list kontak Brevo
Sinkronisasi audiens - Sinkronkan audiens hasil perhitungan warehouse untuk kampanye tertarget
Pengayaan analitik - Perkaya kontak Brevo dengan metrik terhitung (LTV, skor RFM)
Kueri berbasis SQL - Gunakan Snowflake SQL REST API untuk menjalankan kueri secara terprogram
Sinkronisasi terjadwal - Jalankan pipeline data otomatis pada interval yang dapat dikonfigurasi
Dukungan multi-statement - Jalankan transformasi data kompleks dalam satu panggilan API

Prasyarat

Sebelum memulai, pastikan Anda memiliki:

Akun Snowflake dengan role ACCOUNTADMIN atau SYSADMIN
Akun Brevo dengan akses API
Akun Tajo dengan izin konektor
Warehouse Snowflake khusus untuk kueri integrasi
Network policy yang mengizinkan alamat IP Tajo

Autentikasi

Autentikasi key pair (disarankan)

# Generate RSA key pair
openssl genrsa 2048 | openssl pkcs8 -topk8 -inform PEM -out rsa_key.p8 -nocrypt
openssl rsa -in rsa_key.p8 -pubout -out rsa_key.pub

# Assign public key to Snowflake user
# In Snowflake:
# ALTER USER tajo_integration SET RSA_PUBLIC_KEY='MII...';

Autentikasi OAuth 2.0

const tokenResponse = await fetch(
  'https://<account>.snowflakecomputing.com/oauth/token-request',
  {
    method: 'POST',
    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
    body: new URLSearchParams({
      grant_type: 'client_credentials',
      client_id: process.env.SNOWFLAKE_CLIENT_ID,
      client_secret: process.env.SNOWFLAKE_CLIENT_SECRET,
      scope: 'session:role:TAJO_ROLE'
    })
  }
);

Autentikasi SQL API

# Using JWT token with the SQL API
curl -X POST \
  'https://<account>.snowflakecomputing.com/api/v2/statements' \
  -H 'Authorization: Bearer <jwt_token>' \
  -H 'Content-Type: application/json' \
  -H 'X-Snowflake-Authorization-Token-Type: KEYPAIR_JWT' \
  -d '{"statement": "SELECT * FROM customers LIMIT 10", "warehouse": "TAJO_WH"}'

Konfigurasi

Penyiapan dasar

connectors:
  snowflake:
    enabled: true
    account: "your-account.snowflakecomputing.com"
    warehouse: "TAJO_WH"
    database: "MARKETING_DB"
    schema: "PUBLIC"
    role: "TAJO_ROLE"

    sync:
      customers: true
      segments: true
      analytics: true
      schedule: "0 */6 * * *"  # Every 6 hours

    queries:
      customer_segments: |
        SELECT email, segment_name, ltv_score, rfm_class
        FROM customer_segments
        WHERE updated_at > :last_sync

Pemetaan field

field_mapping:
  email: email
  first_name: FIRSTNAME
  last_name: LASTNAME
  ltv_score: LTV_SCORE
  rfm_class: RFM_SEGMENT
  total_orders: ORDER_COUNT
  last_purchase_date: LAST_ORDER_DATE
  predicted_churn: CHURN_RISK
  customer_segment: SEGMENT_NAME

Endpoint API

Endpoint	Metode	Deskripsi
`/api/v2/statements`	POST	Mengirim statement SQL untuk dijalankan
`/api/v2/statements/{statementHandle}`	GET	Memeriksa status eksekusi
`/api/v2/statements/{statementHandle}/cancel`	POST	Membatalkan statement yang sedang berjalan
`/api/v2/statements/{statementHandle}?partition={id}`	GET	Mengambil partisi hasil

Partisi SQL API

Snowflake SQL API mengembalikan hasil berukuran besar dalam bentuk partisi. Setiap partisi memuat data hingga sekitar 12MB. Gunakan parameter partition untuk menelusuri seluruh hasil.

Contoh kode

Inisialisasi konektor

import { TajoClient } from '@tajo/sdk';

const tajo = new TajoClient({
  apiKey: process.env.TAJO_API_KEY,
  brevoApiKey: process.env.BREVO_API_KEY
});

await tajo.connectors.connect('snowflake', {
  account: process.env.SNOWFLAKE_ACCOUNT,
  privateKey: process.env.SNOWFLAKE_PRIVATE_KEY,
  warehouse: 'TAJO_WH',
  database: 'MARKETING_DB',
  schema: 'PUBLIC'
});

Sinkronkan segmen pelanggan melalui SQL API

// Execute a SQL query via Snowflake SQL REST API
const response = await fetch(
  `https://${account}.snowflakecomputing.com/api/v2/statements`,
  {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${jwtToken}`,
      'Content-Type': 'application/json',
      'X-Snowflake-Authorization-Token-Type': 'KEYPAIR_JWT'
    },
    body: JSON.stringify({
      statement: `SELECT email, segment, ltv FROM customer_segments
                  WHERE updated_at > '${lastSync}'`,
      warehouse: 'TAJO_WH',
      database: 'MARKETING_DB',
      schema: 'PUBLIC',
      timeout: 120
    })
  }
);

const result = await response.json();
const statementHandle = result.statementHandle;

// Poll for results
let status = result.statementStatusUrl;
while (result.code !== '090001') {
  const check = await fetch(status, {
    headers: { 'Authorization': `Bearer ${jwtToken}` }
  });
  result = await check.json();
}

// Sync to Brevo via Tajo
for (const row of result.data) {
  await tajo.contacts.sync({
    email: row[0],
    attributes: { SEGMENT: row[1], LTV: row[2] }
  });
}

Pipeline Reverse ETL

// Push computed audiences from Snowflake to Brevo lists
await tajo.connectors.sync('snowflake', {
  type: 'reverse-etl',
  query: `
    SELECT email, first_name, last_name, predicted_ltv, churn_score
    FROM ml_predictions.customer_scores
    WHERE score_date = CURRENT_DATE()
  `,
  destination: {
    list_id: 42,
    attribute_mapping: {
      predicted_ltv: 'PREDICTED_LTV',
      churn_score: 'CHURN_SCORE'
    }
  }
});

Batas rate

Sumber daya	Batas	Catatan
Kueri serentak SQL API	20 per pengguna	Per akun Snowflake
Ukuran hasil SQL API	12MB per partisi	Gunakan paginasi dengan ID partisi
Timeout statement	172.800 detik (48 jam)	Dapat dikonfigurasi per kueri
Permintaan API	Bergantung pada paket	Mengikuti edisi Snowflake

Biaya warehouse

Snowflake menagih berdasarkan waktu komputasi. Gunakan warehouse khusus dengan ukuran yang sesuai untuk kueri Tajo dan setel auto-suspend agar biaya tetap minimal.

Pemecahan masalah

Masalah	Penyebab	Solusi
Autentikasi gagal	Token JWT kedaluwarsa	Buat ulang JWT dengan masa berlaku yang valid
Kueri timeout	Dataset terlalu besar	Tambahkan filter atau gunakan sinkronisasi inkremental
Galat jaringan	IP belum masuk allowlist	Tambahkan IP Tajo ke network policy Snowflake
Kolom tidak ditemukan	Perubahan skema	Perbarui konfigurasi pemetaan field
Galat partisi	Hasil terlalu besar	Proses hasil dalam partisi yang lebih kecil

Mode debug

connectors:
  snowflake:
    debug: true
    log_level: verbose
    log_queries: true

Praktik terbaik

Gunakan warehouse khusus - Hindari rebutan sumber daya dengan beban kerja produksi
Terapkan sinkronisasi inkremental - Kueri hanya record yang berubah sejak sinkronisasi terakhir
Setel auto-suspend - Konfigurasikan warehouse agar berhenti setelah 5 menit tanpa aktivitas
Gunakan autentikasi key pair - Utamakan key pair dibanding autentikasi kata sandi
Optimalkan kueri - Saring dan ambil hanya kolom yang diperlukan agar sinkronisasi lebih cepat
Pantau kredit - Awasi konsumsi kredit Snowflake untuk kueri integrasi

Keamanan

Autentikasi key pair - Enkripsi RSA 2048-bit untuk akses API
OAuth 2.0 - Autentikasi berbasis token dengan pembatasan role
Network policy - Allowlist IP untuk endpoint layanan Tajo
Akses berbasis role - Role Snowflake khusus dengan hak akses seminimal mungkin
Transfer data terenkripsi - TLS 1.2+ untuk seluruh komunikasi API
Penyamaran data - Gunakan dynamic data masking Snowflake untuk field sensitif