---
title: "Connecteur Snowflake"
description: "Guide complet d'intégration Snowflake pour synchroniser analytiques d'entrepôt de données, segments clients et business intelligence avec Brevo via Tajo."
url: https://tajo.io/fr/docs/connectors/custom/snowflake/
markdown: https://tajo.io/fr/docs/connectors/custom/snowflake.md
lang: fr-FR
robots: noindex
---

Demandez un accès anticipé

Indiquez votre prénom et votre adresse e-mail professionnelle. Nous vous enverrons un lien pour confirmer votre demande d’accès à Tajo.

# Connecteur Snowflake

Statut du connecteur: Prévu Pas encore construit. Tajo n'exécute pas ce connecteur aujourd'hui.

| Champ source | Champ de destination | Valeur d’exemple |
| --- | --- | --- |
| `record.id` | `source_id` | `record_1042` |
| `record.updated_at` | `updated_at` | `2026-10-18T08:00:00Z` |
| `record.value` | `value` | `sample_value` |

Connectez Snowflake à Brevo via Tajo pour synchroniser les segments clients depuis votre entrepôt de données, enrichir les profils de contact avec des données analytiques et alimenter des campagnes marketing personnalisées grâce aux insights issus de l’entrepôt.

## Vue d’ensemble

| Propriété | Valeur |
| --- | --- |
| **Plateforme** | Snowflake |
| **Catégorie** | Entrepôt de données (Custom) |
| **Complexité d’installation** | Moyenne |
| **Intégration officielle** | Non |
| **Données synchronisées** | Clients, segments, analytiques, événements |
| **Méthode d’authentification** | Key Pair / OAuth 2.0 |

## Fonctionnalités

- **Reverse ETL**, Poussez les segments clients depuis Snowflake vers les listes de contacts Brevo
- **Synchronisation d’audiences**, Synchronisez les audiences calculées dans l’entrepôt pour des campagnes ciblées
- **Enrichissement analytique**, Enrichissez les contacts Brevo avec des métriques calculées (LTV, scores RFM)
- **Requêtes SQL**, Utilisez l’API REST SQL Snowflake pour exécuter des requêtes programmatiquement
- **Synchronisation planifiée**, Exécutez des pipelines de données automatisés selon des intervalles configurables
- **Prise en charge multi-statements**, Exécutez des transformations de données complexes en un seul appel API

## Prérequis

Avant de commencer, assurez-vous de disposer de :

1. Un compte Snowflake avec le rôle ACCOUNTADMIN ou SYSADMIN
2. Un compte Brevo avec accès API
3. Un compte Tajo avec les permissions connecteur
4. Un warehouse Snowflake dédié aux requêtes d’intégration
5. Une network policy autorisant les adresses IP Tajo

## Authentification

### Authentification par paire de clés (recommandée)

```bash
# Générer une paire de clés RSA
openssl genrsa 2048 | openssl pkcs8 -topk8 -inform PEM -out rsa_key.p8 -nocrypt
openssl rsa -in rsa_key.p8 -pubout -out rsa_key.pub

# Assigner la clé publique à l'utilisateur Snowflake
# Dans Snowflake :
# ALTER USER tajo_integration SET RSA_PUBLIC_KEY='MII...';
```

### Authentification OAuth 2.0

```javascript
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'
    })
  }
);
```

### Authentification SQL API

```bash
# Avec un token JWT sur l'API SQL
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"}'
```

## Configuration

### Configuration de base

```yaml
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 * * *"  # Toutes les 6 heures

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

### Mappage des champs

```yaml
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
```

## Endpoints API

| Endpoint | Méthode | Description |
| --- | --- | --- |
| `/api/v2/statements` | POST | Soumettre des instructions SQL pour exécution |
| `/api/v2/statements/{statementHandle}` | GET | Vérifier le statut d’exécution |
| `/api/v2/statements/{statementHandle}/cancel` | POST | Annuler une instruction en cours |
| `/api/v2/statements/{statementHandle}?partition={id}` | GET | Récupérer les partitions de résultats |

Partitions de l'API SQL

L’API SQL de Snowflake renvoie les grands ensembles de résultats en partitions. Chaque partition contient jusqu’à environ 12 Mo de données. Utilisez le paramètre partition pour itérer sur les résultats.

## Exemples de code

### Initialiser le connecteur

```javascript
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'
});
```

### Synchroniser des segments clients via l’API SQL

```javascript
// Exécuter une requête SQL via l'API REST SQL de Snowflake
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;

// Poller pour obtenir les résultats
let status = result.statementStatusUrl;
while (result.code !== '090001') {
  const check = await fetch(status, {
    headers: { 'Authorization': `Bearer ${jwtToken}` }
  });
  result = await check.json();
}

// Synchroniser vers 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

```javascript
// Pousser les audiences calculées de Snowflake vers les listes Brevo
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'
    }
  }
});
```

## Limites de débit

| Ressource | Limite | Notes |
| --- | --- | --- |
| Requêtes API SQL simultanées | 20 par utilisateur | Par compte Snowflake |
| Taille de résultat API SQL | 12 Mo par partition | Paginez avec les IDs de partition |
| Timeout d’instruction | 172 800 s (48 h) | Configurable par requête |
| Requêtes API | Variable selon le plan | Selon l’édition Snowflake |

Coûts du warehouse

Snowflake facture en fonction du temps de calcul. Utilisez un warehouse dédié de taille appropriée pour les requêtes Tajo et configurez l’auto-suspend pour minimiser les coûts.

## Dépannage

| Problème | Cause | Solution |
| --- | --- | --- |
| Authentification échouée | Token JWT expiré | Régénérez un JWT avec une expiration valide |
| Timeout de requête | Jeu de données volumineux | Ajoutez des filtres ou utilisez une synchronisation incrémentale |
| Erreur réseau | IP non whitelistée | Ajoutez les IPs Tajo à la network policy Snowflake |
| Colonnes manquantes | Changement de schéma | Mettez à jour la configuration de mappage des champs |
| Erreur de partition | Résultat trop volumineux | Traitez les résultats en partitions plus petites |

### Mode debug

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

## Bonnes pratiques

1. **Utilisez un warehouse dédié**, Évitez la contention avec les charges de travail de production
2. **Implémentez une synchronisation incrémentale**, Interrogez uniquement les enregistrements modifiés depuis la dernière synchronisation
3. **Configurez l’auto-suspend**, Paramétrez le warehouse pour qu’il se suspende après 5 minutes d’inactivité
4. **Utilisez l’auth par paire de clés**, Préférez les paires de clés à l’authentification par mot de passe
5. **Optimisez les requêtes**, Filtrez et ne sélectionnez que les colonnes nécessaires pour des syncs plus rapides
6. **Surveillez les crédits**, Suivez la consommation de crédits Snowflake pour les requêtes d’intégration

## Sécurité

- **Authentification par paire de clés**, Chiffrement RSA 2048 bits pour l’accès API
- **OAuth 2.0**, Authentification basée sur tokens avec portée par rôle
- **Network policies**, Allowlist d’IP pour les endpoints de service Tajo
- **Accès basé sur les rôles**, Rôle Snowflake dédié avec privilèges minimum requis
- **Transfert de données chiffré**, TLS 1.2+ pour toutes les communications API
- **Masquage des données**, Utilisez le Dynamic Data Masking de Snowflake pour les champs sensibles

## Ressources associées

- [Connecteur Segment](https://tajo.io/fr/docs/connectors/custom/segment)
- [Connecteur PostHog](https://tajo.io/fr/docs/connectors/custom/posthog)
- [Skill de synchronisation client](https://tajo.io/fr/docs/skills/data-sync/customer-sync)
- [Documentation API SQL Snowflake](https://docs.snowflake.com/en/developer-guide/sql-api/guide)