Sync Client V2

Le Sync Client peut être utilisé pour transférer toutes les mises à jour des contacts vers une base de données SQL ou un service web.

Activation

Pour utiliser le Sync Client, activez le connecteur correspondant dans les paramètres de la campagne.
Après activation réussie, un jeton (token) s’affiche sous le connecteur – ce jeton est requis pour utiliser le client.
Le jeton n’est visible que par l’utilisateur qui a activé le connecteur.

Comment obtenir le jeton dbsync2

Installation

Télécharger la dernière version du binaire

Télécharger et compiler le code source

Installer Git :

sudo apt-get install git

Installer Google Go :

sudo apt-get install golang-go

Pour les étapes suivantes, assurez-vous que la variable d'environnement GOPATH est définie.
Une description sur la façon de définir GOPATH est disponible ici.

Cloner le dépôt :

go get bitbucket.org/modima/dbsync2

Installer toutes les dépendances :

cd $GOPATH/src/bitbucket.org/modima/dbsync && godep restore

Compiler le code source

  • Plateforme cible Linux :
    cd $GOPATH/src/bitbucket.org/modima/dbsync2/ && go build
  • Plateforme cible Windows :
    cd $GOPATH/src/bitbucket.org/modima/dbsync2/ && GOOS=windows GOARCH=amd64 go build -o dbsync2.exe
  • Plateforme cible Mac :
    cd $GOPATH/src/bitbucket.org/modima/dbsync2/ && GOOS=darwin GOARCH=amd64 go build -o dbsync2_mac

Déploiement avec Docker Compose

Pour les utilisateurs qui préfèrent un déploiement en conteneur, un fichier docker-compose.yml préconfiguré est fourni.
Ce fichier prend en charge tous les modes (PostgreSQL, MySQL/MariaDB, SQL Server et Webhook), ce qui vous permet d’exécuter dbsync2 sans modifier le code source – il vous suffit de mettre à jour un fichier .env.

Prérequis

Configuration

Créez un fichier .env dans le même répertoire que votre docker-compose.yml avec le contenu suivant (ajustez les valeurs au besoin) :

# Paramètres de la campagne
CAMPAIGN_ID=my_campaign_id
CAMPAIGN_TOKEN=my_campaign_token

# Paramètres PostgreSQL
POSTGRES_DB=mydb
POSTGRES_USER=myuser
POSTGRES_PASSWORD=mypassword

# Paramètres MySQL
MYSQL_DB=mydb
MYSQL_USER=myuser
MYSQL_PASSWORD=mypassword
MYSQL_ROOT_PASSWORD=myrootpassword

# Paramètres SQL Server
SA_PASSWORD=YourStrong!Passw0rd
SQLSERVER_DB=mydb

# Paramètres Webhook
WEBHOOK_URL=https://example.com/api/transactions/

docker-compose.yml

Voici un exemple de fichier docker-compose.yml qui utilise notre image Docker Hub (dialfire/dbsync2:latest) et lit toutes les informations de connexion depuis le fichier .env :

version: "3.8"

services:
  #############################
  # Exemple PostgreSQL
  #############################
  postgres:
    image: postgres:16
    container_name: postgres_sync
    restart: unless-stopped
    environment:
      POSTGRES_DB: ${POSTGRES_DB:-mydb}
      POSTGRES_USER: ${POSTGRES_USER:-myuser}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-mypassword}
      PGDATA: /var/lib/postgresql/data/pgdata
    volumes:
      - ./data/postgres:/var/lib/postgresql/data
    ports:
      - "5432:5432"

  dbsync2_postgres:
    image: dialfire/dbsync2:latest
    container_name: dbsync2_postgres
    restart: unless-stopped
    depends_on:
      - postgres
    environment:
      CAMPAIGN_ID: ${CAMPAIGN_ID}
      CAMPAIGN_TOKEN: ${CAMPAIGN_TOKEN}
      POSTGRES_USER: ${POSTGRES_USER:-myuser}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-mypassword}
      POSTGRES_DB: ${POSTGRES_DB:-mydb}
    command: >
      dbsync2 --a db_sync --c ${CAMPAIGN_ID} --ct ${CAMPAIGN_TOKEN} --url postgres://${POSTGRES_USER}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB}?sslmode=disable

  #############################
  # Exemple MySQL/MariaDB
  #############################
  mysql:
    image: mysql:8
    container_name: mysql_sync
    restart: unless-stopped
    environment:
      MYSQL_DATABASE: ${MYSQL_DB:-mydb}
      MYSQL_USER: ${MYSQL_USER:-myuser}
      MYSQL_PASSWORD: ${MYSQL_PASSWORD:-mypassword}
      MYSQL_ROOT_PASSWORD: ${MYSQL_ROOT_PASSWORD:-rootpassword}
    volumes:
      - ./data/mysql:/var/lib/mysql
    ports:
      - "3306:3306"

  dbsync2_mysql:
    image: dialfire/dbsync2:latest
    container_name: dbsync2_mysql
    restart: unless-stopped
    depends_on:
      - mysql
    environment:
      CAMPAIGN_ID: ${CAMPAIGN_ID}
      CAMPAIGN_TOKEN: ${CAMPAIGN_TOKEN}
      MYSQL_USER: ${MYSQL_USER:-myuser}
      MYSQL_PASSWORD: ${MYSQL_PASSWORD:-mypassword}
      MYSQL_DB: ${MYSQL_DB:-mydb}
    command: >
      dbsync2 --a db_sync --c ${CAMPAIGN_ID} --ct ${CAMPAIGN_TOKEN} --url mysql://${MYSQL_USER}:${MYSQL_PASSWORD}@mysql:3306/${MYSQL_DB}?useSSL=false

  #############################
  # Exemple SQL Server
  #############################
  sqlserver:
    image: mcr.microsoft.com/mssql/server:2019-latest
    container_name: sqlserver_sync
    restart: unless-stopped
    environment:
      SA_PASSWORD: ${SA_PASSWORD:-YourStrong!Passw0rd}
      ACCEPT_EULA: "Y"
      MSSQL_PID: "Developer"
    ports:
      - "1433:1433"

  dbsync2_sqlserver:
    image: dialfire/dbsync2:latest
    container_name: dbsync2_sqlserver
    restart: unless-stopped
    depends_on:
      - sqlserver
    environment:
      CAMPAIGN_ID: ${CAMPAIGN_ID}
      CAMPAIGN_TOKEN: ${CAMPAIGN_TOKEN}
      SA_PASSWORD: ${SA_PASSWORD:-YourStrong!Passw0rd}
      SQLSERVER_DB: ${SQLSERVER_DB:-mydb}
    command: >
      dbsync2 --a db_sync --c ${CAMPAIGN_ID} --ct ${CAMPAIGN_TOKEN} --url sqlserver://sa:${SA_PASSWORD}@sqlserver:1433/${SQLSERVER_DB}

  #############################
  # Exemple Webhook
  #############################
  dbsync2_webhook:
    image: dialfire/dbsync2:latest
    container_name: dbsync2_webhook
    restart: unless-stopped
    environment:
      CAMPAIGN_ID: ${CAMPAIGN_ID}
      CAMPAIGN_TOKEN: ${CAMPAIGN_TOKEN}
      WEBHOOK_URL: ${WEBHOOK_URL:-https://example.com/api/transactions/}
    command: >
      dbsync2 --a webhook --c ${CAMPAIGN_ID} --ct ${CAMPAIGN_TOKEN} --url ${WEBHOOK_URL}

networks:
  default: {}

Exécution avec Docker Compose

Une fois que votre fichier .env et docker-compose.yml sont configurés, lancez :

docker-compose up -d

Docker Compose va télécharger l’image préconstruite dialfire/dbsync2:latest et démarrer tous les services selon votre configuration.

Fonctionnement

Toutes les mises à jour des contacts sont récupérées toutes les minutes, puis transférées directement vers le service web ou la base de données SQL configurée (voir Utilisation).

Utilisation

Base de données SQL

Le client prend en charge les systèmes de gestion de base de données suivants :

  • MySQL / MariaDB
  • PostgreSQL
  • Microsoft SQL Server

Avant d’utiliser le client, assurez-vous que la base de données correspondante existe. Le client crée ensuite les tables suivantes dans cette base de données :

  • contacts
    Contient tous les champs $ ainsi que les 100 premiers champs personnalisés de la campagne.
  • transactions
    Contient toutes les transactions avec la clé étrangère contact_id faisant référence au contact correspondant.
  • connections
    Contient toutes les connexions liées aux transactions, avec la clé étrangère transaction_id.
  • recordings
    Contient toutes les enregistrements d’appels associés aux connexions, avec la clé étrangère connection_id.
  • inbound_calls
    Contient tous les appels entrants avec la clé étrangère contact_id.

Structure des tables de la base de données

Schéma de l’URL de connexion à la base de données

MySQL / MariaDB:

mysql://username:password@localhost:3306/database?useSSL=false

PostgreSQL:

postgres://username:password@localhost:5432/database?sslmode=disable

Microsoft SQL Server:

sqlserver://username:password@localhost:1433/instance/database

Exemple

Transférez toutes les transactions depuis le 01 février 2018 pour la campagne MY_CAMPAIGN vers une instance locale de Microsoft SQL Server, en filtrant uniquement les mises à jour commençant par les préfixes 'fc_' ou 'qc_' effectuées par un utilisateur :

dbsync2 --a db_sync --fm hi_updates_only --fp 'fc_,qc_' --c MY_CAMPAIGN_ID --ct MY_CAMPAIGN_TOKEN --s 2018-02-01 --url sqlserver://my_user:my_password@localhost:1433/my_database

Service Web

Alternativement, les transactions peuvent être envoyées à un service web.
Le service web doit accepter les requêtes POST et renvoyer un code de statut entre 200 et 299 en cas de succès (sinon, la transmission sera réessayée jusqu’à 10 fois).

La charge utile est envoyée au format JSON :

{
    "contact": ...,      
    "transaction": ...,  
    "state": ...
}
  • contact : Contient les informations de contact.
  • transaction : Contient la transaction correspondante.
  • state :
    • new pour une nouvelle transaction
    • updated lorsqu’une transaction est mise à jour (par exemple, lorsque des données de connexion sont ajoutées).

Exemple

Transférez toutes les transactions future de la campagne MY_CAMPAIGN vers un service web :

./dbsync2 --a webhook --c MY_CAMPAIGN_ID --ct MY_CAMPAIGN_TOKEN --url 'https://example.com/api/transactions/'

Protocole (Erreur)

  • Tous les messages d’erreur sont affichés directement dans la console (stdout).
  • Tous les messages de log sont écrits dans :
    /var/log/dbsync/{MY_CAMPAIGN_ID}_{MODE}_{TIMESTAMP}.log
  • Si le répertoire /var/log/ n’est pas accessible en écriture, les logs apparaissent sous :
    $HOME/.dbsync/logs/{MY_CAMPAIGN_ID}_{MODE}_{TIMESTAMP}.log

Options de la ligne de commande

Une vue d’ensemble de toutes les options est disponible en exécutant :

dbsync2 --help