Terug naar alle blogs

Automatiseer back-ups van Celigo-integraties naar GitHub met een shell-script.

Een praktische handleiding voor het exporteren van Celigo-integraties met behulp van de Celigo CLI — het uitpakken van exports in een versiebeheerde Git-repository, het automatisch maskeren van geheimen, en het op verzoek of volgens een schema een schone back-up naar GitHub pushen.

Blog_field_Auteur Nuri Ensing
Categorie Celigo
Blog_field_Datum 15 april 2026

Wie integraties beheert in meerdere Celigo-omgevingen of klantaccounts, krijgt vroeg of laat dezelfde vraag: wanneer is deze flow voor het laatst gewijzigd en hoe zag die er daarvoor uit? Het Celigo-platform bewaart een eigen geschiedenis. Exports met versiebeheer in Git bieden daarnaast inzicht in wijzigingen, een controlespoor en een basis voor herstel buiten het platform.

Deze gids beschrijft een shell-workflow met de Celigo CLI. De scripts exporteren de integraties die voor elk ingesteld CLI-profiel downloadbaar zijn, pakken ze uit in een vaste mapstructuur, maskeren vermoedelijke geheimen en committen alleen wijzigingen naar een privé GitHub-repository.

Ter verduidelijking:  dit is een workflow voor back-ups en versiebeheer. De scripts vormen geen deployment-pijplijn. Celigo beschouwt Git als een aanvullend hulpmiddel voor back-ups, versiegeschiedenis en samenwerking. Het platform blijft de centrale bron voor het bouwen en testen van wijzigingen. Wil je wijzigingen volledig naar andere omgevingen overbrengen, combineer deze aanpak dan met Celigo ILM of een GitHub Actions-pijplijn die de REST API gebruikt.

Wat deze setup doet


  • De twee scripts behandelen de volledige export-naar-commit-cyclus:
  • Maakt gebruik van de Celigo CLI met lokale profielen zodat API-tokens buiten Git blijven
  • Exporteert de integraties die voor elk ingesteld Celigo CLI-profiel downloadbaar zijn en pakt ze uit in een vaste mapstructuur per account, omgeving en integratie
  • Maskeert veelvoorkomende velden die geheimen kunnen bevatten in geëxporteerde JSON-, YAML- en andere bestanden voordat wijzigingen worden klaargezet
  • Committeert alleen wat is gewijzigd en pusht naar jouw privé GitHub-repository

Voordat je begint

Je hebt het volgende nodig op de machine waarop de scripts draaien:

  • Node.js en npm
  • Git
  • jq — voor JSON-verwerking
  • unzip
  • Python 3 voor het maskeren van geheimen
  • Een privé GitHub-repository
  • Een Celigo API-token voor elke omgeving die je wilt back-uppen

Op macOS installeer je de shell-afhankelijkheden met:

Bash
brew install jq unzip

1. Installeer de Celigo CLI

Je kunt het Celigo npm-pakket hier downloaden:https://www.npmjs.com/package/@celigo/celigo-cli

Lukt een globale npm-installatie niet vanwege een rechtenfout, gebruik dan een Node-versiebeheerder zoals nvm in plaats van sudo.

2. Maak Celigo-profielen aan

Maak één profiel per Celigo-omgeving. De scripts verwachten profielen met namen in het formaat account-omgeving — zo wordt de mapstructuur automatisch afgeleid.

Bash
celigo profile add client-prod --api-token YOUR_PROD_TOKEN --api-base-url https://api.eu.integrator.io celigo profile add client-sandbox --api-token YOUR_SANDBOX_TOKEN --api-base-url https://api.eu.integrator.io

Controleer vervolgens of uw profielen geregistreerd zijn:

Bash
celigo profile list

De bovenstaande voorbeelden gebruiken het EU API-endpoint. Voor accounts in Noord-Amerika gebruik je in plaats daarvan de overeenkomende Noord-Amerikaanse basis-URL.

3. Stel de repository in

Kloon je privé GitHub-repository en maak een .gitignore aan om tijdelijke exportbestanden buiten versiebeheer te houden:

Bash
git clone https://github.com/YOUR_ORG/YOUR_REPO.git cd YOUR_REPO
Bash
# .gitignore tmp_celigo_backup/ *.zip .DS_Store *.log

4. Voeg het export-script toe

Sla het volgende op als export_all_integrations.sh in de hoofdmap van je repository. Dit script haalt profielen op, downloadt integraties als ZIP-bestanden, pakt ze uit en voert de maskering van geheimen uit.

Bash
#!/usr/bin/env bash set -Eeuo pipefail BASE_DIR="${BASE_DIR:-./integrations}" TMP_DIR="${TMP_DIR:-./tmp_celigo_backup}" PROFILE_FILTER="${PROFILE_FILTER:-}" REDACT_EXPORTS="${REDACT_EXPORTS:-true}" require_cmd() { command -v "$1" >/dev/null 2>&1 || { echo "Missing required command: $1" >&2 exit 1 } } require_cmd celigo require_cmd jq require_cmd unzip require_cmd awk require_cmd sed require_cmd find require_cmd python3 mkdir -p "$BASE_DIR" "$TMP_DIR" cleanup() { rm -rf "$TMP_DIR" } trap cleanup EXIT sanitize_name() { printf '%s' "$1" \ | tr '[:upper:]' '[:lower:]' \ | sed 's/[[:space:]]\+/_/g' \ | sed 's|[/:]|-|g' \ | tr -cd '[:alnum:]_.-' } matches_filter() { local profile="$1" if [ -z "$PROFILE_FILTER" ]; then return 0 fi case "$profile" in *"$PROFILE_FILTER"*) return 0 ;; *) return 1 ;; esac } redact_file() { local file="$1" python3 - "$file" <<'PY' import json import pathlib import re import sys path = pathlib.Path(sys.argv[1]) text = path.read_text(encoding="utf-8", errors="ignore") SENSITIVE_KEYS = { "apiToken", "api_token", "token", "accessToken", "access_token", "refreshToken", "refresh_token", "clientSecret", "client_secret", "password", "pass", "secret", "consumerSecret", "consumer_secret", "privateKey", "private_key", "authorization", "authHeader", "signedURL", "signedUrl", "awsAccessKeyId", "accessKeyId", "accessKey", "secretAccessKey", "bearerToken", "jwt", "licenseKey" } KEY_PATTERN = re.compile( r'(?i)("?(?:api[_-]?token|token|access[_-]?token|refresh[_-]?token|client[_-]?secret|password|pass|secret|consumer[_-]?secret|private[_-]?key|authorization|auth[_-]?header|signedurl|awsaccesskeyid|access[_-]?key(?:id)?|secretaccesskey|bearer[_-]?token|jwt|license[_-]?key)"?\s*[:=]\s*)(".*?"|\'.*?\'|[^\s,}\]]+)' ) def redact(obj): if isinstance(obj, dict): out = {} for k, v in obj.items(): if k in SENSITIVE_KEYS or k.lower() in {s.lower() for s in SENSITIVE_KEYS}: out[k] = "__REDACTED__" else: out[k] = redact(v) return out if isinstance(obj, list): return [redact(v) for v in obj] return obj updated = text try: parsed = json.loads(text) redacted = redact(parsed) updated = json.dumps(redacted, indent=2, ensure_ascii=False) + " " except Exception: updated = KEY_PATTERN.sub(r'\1"__REDACTED__"', text) if updated != text: path.write_text(updated, encoding="utf-8") PY } redact_directory() { local dir="$1" find "$dir" -type f \( -name '*.json' -o -name '*.js' -o -name '*.ts' -o -name '*.yaml' -o -name '*.yml' \ -o -name '*.txt' -o -name '*.env' -o -name '*.properties' -o -name '*.xml' \) -print0 | while IFS= read -r -d '' file; do redact_file "$file" done find "$dir" -type f \( -name '.env' -o -name '.npmrc' -o -name '*.pem' -o -name '*.key' -o -name '*.p12' -o -name '*.crt' \) -delete } echo "Fetching Celigo profiles..." PROFILE_LINES="$(celigo profile list || true)" if [ -z "$PROFILE_LINES" ]; then echo "No Celigo profiles found." exit 1 fi PROFILE_NAMES=() while IFS= read -r line; do PROFILE_NAME="$(printf '%s' "$line" | awk 'NF {print $1}')" case "$PROFILE_NAME" in ""|NAME|Name|PROFILE|Profile) continue ;; esac if [ -n "$PROFILE_NAME" ] && matches_filter "$PROFILE_NAME"; then PROFILE_NAMES+=("$PROFILE_NAME") fi done <<< "$PROFILE_LINES" if [ ${#PROFILE_NAMES[@]} -eq 0 ]; then echo "No matching Celigo profiles found." exit 1 fi echo "Profiles selected:" for PROFILE_NAME in "${PROFILE_NAMES[@]}"; do echo " - $PROFILE_NAME" done for PROFILE_NAME in "${PROFILE_NAMES[@]}"; do if [[ "$PROFILE_NAME" != *-* ]]; then echo "Skipping '$PROFILE_NAME' — profile name must follow account-environment format." continue fi ACCOUNT_NAME="${PROFILE_NAME%%-*}" ENV_NAME="${PROFILE_NAME#*-}" SAFE_ACCOUNT="$(sanitize_name "$ACCOUNT_NAME")" SAFE_ENV="$(sanitize_name "$ENV_NAME")" ACCOUNT_DIR="$BASE_DIR/$SAFE_ACCOUNT" ENV_DIR="$ACCOUNT_DIR/$SAFE_ENV" TMP_JSON="$TMP_DIR/${SAFE_ACCOUNT}_${SAFE_ENV}_integrations.json" mkdir -p "$ENV_DIR" echo "Fetching integrations for $PROFILE_NAME..." celigo --profile "$PROFILE_NAME" integrations list --format json > "$TMP_JSON" if [ ! -s "$TMP_JSON" ]; then echo "No output returned for $PROFILE_NAME" rm -f "$TMP_JSON" continue fi COUNT="$(jq 'length' "$TMP_JSON")" echo "Found $COUNT integrations in $PROFILE_NAME" if [ "$COUNT" -eq 0 ]; then rm -f "$TMP_JSON" continue fi while IFS= read -r row; do ID="$(printf '%s' "$row" | jq -r '._id')" NAME="$(printf '%s' "$row" | jq -r '.name // .title // ._id')" SAFE_NAME="$(sanitize_name "$NAME")" TARGET_DIR="$ENV_DIR/$SAFE_NAME" ZIP_PATH="$TMP_DIR/${SAFE_ACCOUNT}_${SAFE_ENV}_${SAFE_NAME}.zip" echo " Downloading: $NAME" celigo --profile "$PROFILE_NAME" integrations download "$ID" -o "$ZIP_PATH" rm -rf "$TARGET_DIR" mkdir -p "$TARGET_DIR" unzip -oq "$ZIP_PATH" -d "$TARGET_DIR" rm -f "$ZIP_PATH" if [ "$REDACT_EXPORTS" = "true" ]; then redact_directory "$TARGET_DIR" fi done < <(jq -c '.[]' "$TMP_JSON") rm -f "$TMP_JSON" done echo "" echo "Export complete. Output: $BASE_DIR"

Maak het uitvoerbaar:

Bash
chmod +x export_all_integrations.sh

5. Voeg het Git-push-script toe

Sla dit op als backup_to_git.sh in dezelfde map. Het roept het export-script aan, controleert op wijzigingen en pusht een commit met een tijdstempel naar de repository:

Bash
#!/usr/bin/env bash set -Eeuo pipefail ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" EXPORT_SCRIPT="$ROOT_DIR/export_all_integrations.sh" if [ ! -f "$EXPORT_SCRIPT" ]; then echo "export_all_integrations.sh not found alongside this script." >&2 exit 1 fi if ! git -C "$ROOT_DIR" rev-parse --is-inside-work-tree >/dev/null 2>&1; then echo "Not a Git repository: $ROOT_DIR" >&2 exit 1 fi echo "Running Celigo export from: $ROOT_DIR" "$EXPORT_SCRIPT" cd "$ROOT_DIR" git add integrations/ .gitignore export_all_integrations.sh backup_to_git.sh 2>/dev/null || true COMMIT_MSG="Backup Celigo integrations $(date +%Y-%m-%d_%H-%M)" if git diff --cached --quiet; then echo "No changes since last backup." exit 0 fi git commit -m "$COMMIT_MSG" CURRENT_BRANCH="$(git branch --show-current)" if [ -z "$CURRENT_BRANCH" ]; then CURRENT_BRANCH="main" fi echo "Pushing to GitHub (branch: $CURRENT_BRANCH)..." git push origin "$CURRENT_BRANCH" echo "Backup complete."

Maak het uitvoerbaar:

Bash
chmod +x backup_to_git.sh

6. Voer de back-up uit

Bash
./backup_to_git.sh

De eerste uitvoering legt alle integraties vast in een commit. Volgende uitvoeringen leggen alleen wijzigingen vast. Zo laat de Git-log precies zien wat er tussen twee back-ups is aangepast.

Om te filteren op een specifiek account zonder het script aan te passen, stel de PROFILE_FILTER-variabele in tijdens de uitvoering:

Bash
PROFILE_FILTER=client ./backup_to_git.sh

Resulterende mapstructuur

Na een succesvolle uitvoering ziet jouw repository er als volgt uit:

Text
integrations/ client/ prod/ order-to-cash/ export.json ... inventory-sync/ ... sandbox/ order-to-cash/ ... export_all_integrations.sh backup_to_git.sh .gitignore

Elke integratie krijgt een eigen map. De mapnaam wordt afgeleid van het naamveld van de integratie en omgezet naar kleine letters met underscores. Voeg je een nieuw profiel toe, dan worden bij de volgende uitvoering automatisch de juiste account- en omgevingsmappen aangemaakt.

Beveiligingsoverwegingen

De maskering dekt de meest voorkomende geheimen: API-tokens, client secrets, wachtwoorden, private keys, bearer tokens en ondertekende URL's. Dat gebeurt in bestanden die als JSON kunnen worden verwerkt en, via reguliere expressies, in andere tekstbestanden. Daarnaast blijven de volgende maatregelen nodig:

  • Houd de back-uprepository privé. Ook na het maskeren van geheimen kunnen de geëxporteerde integratiestructuur en flowlogica bedrijfslogica en systeemarchitectuur blootleggen.
  • Sla API-tokens alleen op in lokale CLI-profielen, nooit in omgevingsvariabelen die gelogd kunnen worden of in scripts die gecommit worden.
  • Controleer een diff voordat je een repository openbaar maakt. De maskering is breed, maar niet volledig. Aangepaste veldnamen voor geheimen worden niet automatisch herkend.
  • Certificaat- en sleutelbestanden vallen buiten deze back-up. Het script verwijdert .pem-, .key-, .p12- en .crt-bestanden uit de exportmap. Controleer dat deze bestanden daadwerkelijk zijn verwijderd als ze in je exports voorkomen.


Beperkingen waarmee je rekening moet houden

Deze workflow is geschikt voor back-ups, het beoordelen van wijzigingen en versiegeschiedenis. Hij vervangt geen volledige deployment-pijplijn. Houd rekening met de volgende punten:

  • Deze workflow is bedoeld voor integraties die je Celigo-account en CLI als ZIP-bestanden kunnen downloaden. Integration Apps worden anders afgehandeld en kunnen andere hulpmiddelen of kloonworkflows vereisen.
  • Controleer na het importeren in een andere omgeving zorgvuldig de verbindingen, inloggegevens en omgevingsspecifieke instellingen. Ga er niet van uit dat ze probleemloos worden overgezet. De documentatie van Celigo is op dit punt niet volledig consistent. Een handmatige controle is daarom de veiligste aanpak.
  • Deze workflow vervangt Celigo ILM niet voor gestructureerde omgevingspromotie. Als je integraties verplaatst van sandbox naar productie op een gecontroleerde, herhaalbare manier, is ILM het juiste gereedschap.

Draaien op Windows

Het betreft Bash-scripts — ze maken gebruik van functies zoals here-docs, process substitution en chmod +x die niet native werken in CMD of PowerShell. Op Windows kun je ze uitvoeren via een van deze twee setups:

  • Git Bash — inbegrepen bij Git for Windows, biedt Bash-emulatie die het volledige script ondersteunt.
  • WSL (Windows Subsystem for Linux) biedt een volledige GNU/Linux-omgeving op Windows. Installeer Node, jq en de andere afhankelijkheden binnen de WSL-distributie.

Wil je het script op Windows volgens een schema uitvoeren, gebruik dan Taakplanner om het binnen Git Bash of WSL te starten, in plaats van cron.

Perspectief vanuit de praktijk

De meest voorkomende reden waarom teams dit soort opzet zoeken, is een incident: een flow is gewijzigd, er is iets stuk gegaan, en de vraag is wat er anders was. Het hebben van versiegebonden exports in Git betekent dat die vraag een antwoord heeft — en het antwoord vereist geen duiken in platform-auditlogs of iemand vragen wat ze vorige week denken gewijzigd te hebben.

Uitvoering volgens een cron-schema, bijvoorbeeld dagelijks of na belangrijke wijzigingsmomenten, levert een eenvoudig wijzigingslogboek op. De eigen geschiedenis van het Celigo-platform blijft daarnaast bestaan. Het Git-formaat kun je doorzoeken, vergelijken en aan een ontwikkelaar geven zonder toegang tot het platform te verlenen.

Wil je hulp bij een uitgebreidere aanpak voor Celigo-versiebeheer of deployment, met bijvoorbeeld ILM, GitHub Actions of beheer van meerdere omgevingen? Neem contact op. Als Celigo Advanced Partner kan Teknuro helpen met het ontwerp en de bouw.