Architecture micro-services

// crypto-service/src/server.ts : Service crypto centralisé (REST)
import express from 'express'
import { Mafate } from '@mafate/sdk'

const app = express()
const mafate = new Mafate({ apiKey: process.env.MAFATE_API_KEY! })

app.use(express.json())

// Middleware d'authentification inter-services
app.use((req, res, next) => {
  const token = req.headers['x-service-token']
  if (token !== process.env.INTER_SERVICE_SECRET) {
    return res.status(401).json({ error: 'Unauthorized' })
  }
  next()
})

// POST /encrypt
app.post('/encrypt', async (req, res) => {
  const { plaintext, keyId } = req.body
  if (!plaintext || !keyId) {
    return res.status(400).json({ error: 'plaintext et keyId requis' })
  }
  const enc = await mafate.encryptLocal(plaintext, keyId)
  res.json(enc)
})

// POST /decrypt
// ⛔ L'ENVELOPPE EST RELAYEE ENTIERE, ET SOUS SES NOMS EXACTS.
// `keyId` / `keyVersion` n'existent pas : les champs sont en snake_case,
// et il en faut SIX. En omettre un rend la donnee indechiffrable, sans erreur
// visible au moment de l'ecriture.
app.post('/decrypt', async (req, res) => {
  const { ciphertext, wrapped_key, iv, key_id, key_version, envelope_version } = req.body
  const dec = await mafate.decryptLocalToString({
    ciphertext, wrapped_key, iv, key_id, key_version, envelope_version,
  })
  res.json({ plaintext: dec })
})

// POST /encrypt-batch : chiffrer plusieurs champs en un appel
app.post('/encrypt-batch', async (req, res) => {
  const { items } = req.body // [{ plaintext, keyId }]
  const results = await Promise.all(
    items.map(({ plaintext, keyId }) => mafate.encryptLocal(plaintext, keyId))
  )
  res.json({ results })
})

app.listen(9090, () => console.log('Crypto service démarré sur :9090'))

// user-service/src/crypto-client.ts : Client vers le service crypto
import axios from 'axios'

const cryptoClient = axios.create({
  baseURL: process.env.CRYPTO_SERVICE_URL, // http://crypto-svc:9090
  headers: { 'X-Service-Token': process.env.INTER_SERVICE_SECRET },
  timeout: 5000,
})

export async function encrypt(plaintext: string, keyId: string) {
  const { data } = await cryptoClient.post('/encrypt', { plaintext, keyId })
  return data
}

export async function decrypt(enc: object) {
  const { data } = await cryptoClient.post('/decrypt', enc)
  return data.plaintext
}

import { Kafka } from 'kafkajs'
import { Mafate } from '@mafate/sdk'

const mafate = new Mafate({ apiKey: process.env.MAFATE_API_KEY! })
const kafka = new Kafka({ brokers: ['kafka:9092'] })

// PRODUCTEUR : chiffrer avant de publier dans Kafka
const producer = kafka.producer()
await producer.connect()

async function publishUserCreated(user: {
  id: string; email: string; name: string; phone: string
}) {
  // Chiffrer tous les champs PII avant de publier
  const [encEmail, encName, encPhone] = await Promise.all([
    mafate.encryptLocal(user.email, 'key-events-pii'),
    mafate.encryptLocal(user.name,  'key-events-pii'),
    mafate.encryptLocal(user.phone, 'key-events-pii'),
  ])

  const event = {
    type: 'user.created',
    version: '1',
    timestamp: new Date().toISOString(),
    data: {
      id:    user.id,         // non chiffré, identifiant technique
      email: encEmail,        // chiffré
      name:  encName,         // chiffré
      phone: encPhone,        // chiffré
    },
  }

  await producer.send({
    topic: 'user-events',
    messages: [{ key: user.id, value: JSON.stringify(event) }],
  })
  console.log(`Événement user.created publié pour ${user.id}`)
}

// CONSOMMATEUR : déchiffrer après avoir consommé
const consumer = kafka.consumer({ groupId: 'analytics-service' })
await consumer.connect()
await consumer.subscribe({ topic: 'user-events' })

await consumer.run({
  eachMessage: async ({ message }) => {
    const event = JSON.parse(message.value!.toString())
    if (event.type !== 'user.created') return

    // Déchiffrer les champs PII nécessaires au traitement
    const [email, name, phone] = await Promise.all([
      mafate.decryptLocalToString(event.data.email),
      mafate.decryptLocalToString(event.data.name),
      mafate.decryptLocalToString(event.data.phone),
    ])

    // Traitement avec les données en clair
    await analyticsService.trackNewUser({
      id: event.data.id,
      email, name, phone,
    })
  },
})