CI/CD

Ce guide présente les bonnes pratiques pour intégrer lomi. à votre pipeline CI/CD, avec des déploiements fiables et des tests automatisés.

Configuration de l’environnement

Variables d’environnement

# .env.ci
LOMI_API_KEY=lomi_sk_test_... # Clé de test dédiée
LOMI_WEBHOOK_SECRET=whsec_... # Secret webhook de test
LOMI_API_URL=https://sandbox.api.lomi.africa # Bac à sable
LOMI_ENV=test

Gestion des secrets

Chargez les secrets requis de façon sécurisée dans votre CI/CD. Ne commitez jamais de secrets dans le dépôt.

// config/secrets.ts
export function loadSecrets(): void {
  const requiredSecrets = ['LOMI_API_KEY', 'LOMI_WEBHOOK_SECRET'];

  for (const secret of requiredSecrets) {
    if (!process.env[secret]) {
      console.warn(`Avertissement : secret recommandé manquant : ${secret}`);
      // Selon votre configuration, vous pouvez lever une erreur :
      // throw new Error(`Missing required secret: ${secret}`);
    }
  }
}

// Appeler loadSecrets() tôt au démarrage ou dans le setup de tests

GitHub Actions

Workflow de tests

Exécutez vos tests d’intégration contre le bac à sable lomi. sur push et pull requests.

name: Test

on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v3

      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
          node-version: '18'
          cache: 'npm'

      - name: Install dependencies
        run: npm ci

      - name: Run tests
        run: npm test
        env:
          LOMI_API_KEY: ${{ secrets.LOMI_TEST_API_KEY }}
          LOMI_WEBHOOK_SECRET: ${{ secrets.LOMI_TEST_WEBHOOK_SECRET }}
          LOMI_API_URL: 'https://sandbox.api.lomi.africa'
          LOMI_ENV: test

Workflow de déploiement

Déployez avec les clés de production uniquement lors des pushes sur votre branche principale.

name: Deploy

on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    environment: production

    steps:
      - uses: actions/checkout@v3

      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
          node-version: '18'
          cache: 'npm'

      - name: Configure AWS credentials
        uses: aws-actions/configure-aws-credentials@v1
        with:
          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
          aws-region: eu-west-1

      - name: Install, Build, and Deploy
        run: |
          npm ci
          npm run build
          npm run deploy
        env:
          LOMI_API_KEY: ${{ secrets.LOMI_PROD_API_KEY }}
          LOMI_WEBHOOK_SECRET: ${{ secrets.LOMI_PROD_WEBHOOK_SECRET }}
          LOMI_API_URL: 'https://api.lomi.africa'
          LOMI_ENV: production

Tests automatisés

Contrôles pré-déploiement

Avant déploiement, exécutez des vérifications de connectivité et de configuration de base.

// scripts/pre-deploy-check.ts
import { LomiSDK } from '@lomi./sdk';

async function runPreDeploymentChecks(): Promise<void> {
  console.log('Exécution des contrôles pré-déploiement…');
  const apiKey = process.env.LOMI_API_KEY;
  const apiUrl = process.env.LOMI_API_URL;

  if (!apiKey || !apiUrl) {
    throw new Error('LOMI_API_KEY and LOMI_API_URL must be set');
  }

  const lomi = new LomiSDK({
    apiKey: apiKey,
    baseUrl: apiUrl,
  });

  try {
    console.log('Vérification de la connectivité API…');
    const providers = await lomi.providers.listProviders();
    if (!providers || providers.data.length === 0) {
      throw new Error('Failed to fetch providers or no providers available.');
    }
    console.log(`Récupération de ${providers.data.length} prestataires réussie.`);

    // Facultatif : test du point de terminaison webhook si pertinent
    // Le SDK peut ne pas exposer de méthode dédiée ; contrôle personnalisé ou tests d’intégration.

    console.log('Contrôles pré-déploiement réussis !');
  } catch (error) {
    console.error('Échec du contrôle pré-déploiement :', error);
    process.exit(1);
  }
}

runPreDeploymentChecks();

Tests d’intégration

Écrivez des tests qui simulent des parcours utilisateur impliquant lomi..

// tests/integration/payment.test.ts
import { LomiSDK } from '@lomi./sdk';

describe('Payment Integration', () => {
  let lomi: LomiSDK;

  beforeAll(() => {
    if (!process.env.LOMI_TEST_API_KEY || !process.env.TEST_MERCHANT_ID) {
      throw new Error('Missing test environment variables');
    }
    lomi = new LomiSDK({
      apiKey: process.env.LOMI_TEST_API_KEY,
      baseUrl: 'https://sandbox.api.lomi.africa',
    });
  });

  it('should process a test payment end-to-end', async () => {
    const sessionResponse = await lomi.checkoutSessions.create({
      merchant_id: process.env.TEST_MERCHANT_ID!,
      amount: 1000,
      currency_code: 'XOF',
      success_url: 'https://example.com/success',
      cancel_url: 'https://example.com/cancel',
      metadata: { test_order_id: `e2e_${Date.now()}` },
    });
    const sessionId = sessionResponse.data.checkout_session_id;
    expect(sessionId).toBeDefined();

    // Simulation de paiement (helper ou endpoint spécifique)
    // Fortement dépendant des capacités de test lomi.
    // await lomi.testing.simulatePayment(sessionId, 'succeeded');

    // Vérification du succès (délai si nécessaire)
  }, 30000);
});

Stratégies de déploiement

Choisissez une stratégie qui limite le risque lors des mises en production.

Déploiement blue-green

Maintenez deux environnements de production identiques (Bleu et Vert). Déployez sur l’environnement inactif, testez, puis basculez le trafic.

// scripts/deploy-blue-green.ts
async function blueGreenDeploy(newVersion: string): Promise<void> {
  const currentActive = await getActiveEnvironment();
  const inactiveEnv = currentActive === 'blue' ? 'green' : 'blue';

  console.log(`Déploiement de la version ${newVersion} sur ${inactiveEnv}…`);
  await deployToEnvironment(inactiveEnv, newVersion);

  console.log(`Contrôles de santé sur ${inactiveEnv}…`);
  const health = await checkHealth(inactiveEnv);
  if (!health.ok) {
    console.error(
      `Contrôle de santé échoué pour ${inactiveEnv}. Retour arrière du déploiement.`,
    );
    throw new Error('Contrôle de santé échoué sur l’environnement inactif');
  }

  console.log(`Bascule du trafic vers ${inactiveEnv}…`);
  await switchTraffic(inactiveEnv);

  console.log(`Surveillance de ${inactiveEnv}…`);
}

Déploiement canary

Faites tourner la nouvelle version sur une petite fraction du trafic avant généralisation.

// scripts/deploy-canary.ts
async function canaryDeploy(newVersion: string): Promise<void> {
  console.log(`Déploiement canary de la version ${newVersion} avec 10 % du trafic…`);
  await deployCanaryVersion(newVersion, '10%');

  console.log('Surveillance des métriques canary…');
  const metricsOk = await monitorCanaryMetrics({
    duration: '1h',
    errorThreshold: 0.05,
  });

  if (!metricsOk) {
    console.error('Métriques canary insuffisantes. Retour arrière du canary…');
    await rollbackCanary(newVersion);
    throw new Error('Canary deployment failed metrics check');
  }

  console.log('Métriques canary OK. Augmentation progressive du trafic…');
  await scaleCanaryTraffic(newVersion, '50%');
  await monitorCanaryMetrics({ duration: '30m' });
  await scaleCanaryTraffic(newVersion, '100%');

  console.log('Déploiement canary réussi. Mise hors service de l’ancienne version…');
  await decommissionOldVersion();
}

Surveillance

Surveillez en continu la santé de votre intégration.

Bilans de santé

Mettez en place des contrôles automatisés de connectivité API et des fonctions critiques.

// monitoring/healthCheck.ts
import { LomiSDK } from '@lomi./sdk';

export async function checkServiceHealth(): Promise<{
  status: string;
  errors: string[];
}> {
  const errors: string[] = [];
  const lomi = new LomiSDK({
    apiKey: process.env.LOMI_API_KEY!,
    baseUrl: process.env.LOMI_API_URL!,
  });

  try {
    await lomi.providers.listProviders();
  } catch (error: any) {
    errors.push(`lomi. API check failed: ${error.message}`);
  }

  return {
    status: errors.length === 0 ? 'healthy' : 'unhealthy',
    errors: errors,
  };
}

Collecte de métriques

Suivez les métriques liées aux paiements et aux webhooks.

// monitoring/metrics.ts
export function collectMetrics(): Record<string, any> {
  return {
    payments_processed_total: getTotalPayments(),
    payments_succeeded_rate: getSuccessRate(),
    payment_api_latency_ms: getAverageApiLatency(),
    webhooks_received_total: getTotalWebhooksReceived(),
    webhook_verification_failures_total: getWebhookVerificationFailures(),
    webhook_processing_latency_ms: getAverageWebhookProcessingTime(),
  };
}

Procédures de retour arrière

Prévoyez un retour rapide vers une version stable si un déploiement pose problème.

Retour arrière automatisé

Intégrez des étapes de rollback dans le workflow de déploiement.

// scripts/rollback.ts
async function automaticRollback(
  failedDeploymentId: string,
  previousVersion: string,
): Promise<void> {
  console.log(
    `Retour arrière du déploiement ${failedDeploymentId} vers la version ${previousVersion}…`,
  );
  try {
    await deployToEnvironment('production', previousVersion);

    const health = await checkHealth('production');
    if (!health.ok) {
      throw new Error('Rollback verification failed');
    }
    console.log(`Retour arrière vers ${previousVersion} réussi et vérifié.`);
  } catch (error: any) {
    console.error(`Échec du retour arrière automatique : ${error.message}`);
    throw error;
  }
}