Les systèmes de vente flash à haute concurrence représentent un défi majeur en ingénierie logicielle, principalement en raison de la nature imprévisible et intense des pics de trafic. Un aspect critique de ces systèmes est la gestion précise et atomique du stock. Cet article explore comment Redis, combiné à des scripts Lua, peut être efficacement utilisé pour gérer le stock des produits en vente flash, en évitant les problèmes cuorants comme la survente.

Comprendre les Ventes Flash

Une vente flash est une opération promotionnelle où une quantité limitée de produits est proposée à un prix fortement réduit pendant une très courte période. Ces événements, comme les soldes saisonnières ou les lancements de nouveaux produits, se caractérisent par :

• Demande Instantanée Élevée : Le nombre d'acheteurs potentiels dépasse de loin le stock disponible.
• Durée Limitée : L'offre est valable pendant une fenêtre de temps très étroite, souvent quelques minutes.
• Stock Limité : La quantité de produits est restreinte, et les articles sont vendus rapidement.

La principale difficulté réside dans la gestion des requêtes simultanées massives, qui peuvent atteindre des millions en quelques secondes, alors que le stock ne représente qu'une fraction de ces requêtes.

Phases d'une Vente Flash

Typiquement, une vente flash se déroule en trois phases distinctes :

• Phase de Préparation (Pré-chauffage) : Avant le début de l'événement, les données relatives aux produits (description, stock initial) sont pré-chargées dans des caches rapides comme Redis. Les utilisateurs peuvent consulter la page du produit, ce qui permet également de "chauffer" le cache.
• Phase de Vente : C'est la période où la concurrence est maximale. Les requêtes d'achat affluent, et le système doit gérer la décrémentation du stock de manière rapide et fiable.
• Phase de Post-Vente (Règlement) : Une fois la vente terminée ou le stock épuisé, le système gère les transactions finalisées, la consolidation des données et la gestion des cas excetpionnels (annulations, retours en stock).

Utilisation de Redis pour le Stock

Pour la gestion du stock en temps réel, Redis est un choix idéal grâce à sa rapidité et sa capacité à gérer de grandes quantités de données en mémoire. Nous pouvons modéliser le stock d'un produit en vente flash en utilisant une structure de données Hash dans Redis. Cette structure peut contenir les informations clés suivantes :

cle_produit:{
    stockTotal: 200,      -- Quantité totale initialement disponible
    statutActivation: 0,  -- 0: non démarré, 1: actif
    quantiteVendue: 0     -- Quantité de produits déjà vendus
}

• stockTotal : La quantité totale de produits mis en vente. Cette valeur est chargée avant le début de l'événement.
• statutActivation : Un indicateur booléen (0 ou 1) signalant si la vente est active.
• quantiteVendue : Le nombre de produits qui ont déjà été alloués/vendus. Cette valeur est incrémentée lors de chaque achat réussi. Elle ne doit jamais dépasser stockTotal.

Chargement Initial du Stock dans Redis

Pendant la phase de préparation, le stock de chaque produit participant à la vente flash doit être pré-chargé dans Redis. Voici un exemple de code Java illustrant cette opération :

import org.springframework.data.redis.core.RedisTemplate;
import java.util.HashMap;
import java.util.Map;

public class GestionnaireStockFlashSale {

    private static final String PREFIX_CLE_STOCK = "venteflash:stockproduit:";
    private final RedisTemplate<String, Object> redisTemplate;

    public GestionnaireStockFlashSale(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    private String genererCleCache(String identifiantProduit) {
        return PREFIX_CLE_STOCK.concat(identifiantProduit);
    }

    /**
     * Prépare le stock initial d'un produit pour une vente flash.
     * @param identifiantProduit L'ID unique du produit.
     * @param quantiteTotale La quantité totale de ce produit disponible.
     */
    public void initialiserStock(String identifiantProduit, int quantiteTotale) {
        String cleProduit = genererCleCache(identifiantProduit);
        Map<String, Integer> donneesStock = new HashMap<>();
        donneesStock.put("stockTotal", quantiteTotale);
        donneesStock.put("statutActivation", 0); // 0: inactif, 1: actif
        donneesStock.put("quantiteVendue", 0);
        redisTemplate.opsForHash().putAll(cleProduit, donneesStock);
    }
}

Le Problème de la Survente

Lors de la phase de vente, de multiples requêtes tentent de débiter le stock simultanément. Une approche naïve consisterait à :

1. Lire la valeur de quantiteVendue depuis Redis.
2. Vérifier si quantiteVendue + quantité_demandée <= stockTotal.
3. Si c'est le cas, incrémenter quantiteVendue.

Cette séquence d'opérations n'est pas atomique. Dans un environnement distribué à haute concurrence, plusieurs processus ou threads peuvent lire la même valeur de quantiteVendue simultanément, effectuer leur vérification, et tenter d'incrémenter le stock. Cela peut entraîner une situation où le nombre total de produits "vendus" dépasse le stockTotal, c'est ce qu'on apppelle la "survente" (overselling). La survente est un problème grave pour les plateformes e-commerce, car elle conduit à l'incapacité de livrer les produits promus.

Résolution de la Survente avec les Scripts Lua de Redis

Pour garantir l'atomicité des opérations de décrémentation de stock, la solution la plus robuste et performante avec Redis est l'utilisation de scripts Lua. Redis exécute les scripts Lua de manière atomique, garantissant qu'aucune autre commande ne peut être exécutée tant que le script n'est pas terminé.

Script Lua pour la Gestion Atomique du Stock

Voici un exemple de script Lua qui vérifie la disponibilité du stock et l'incrémente (simulant une "vente") de manière atomique :

-- Script Lua pour la décrémentation atomique du stock
-- KEYS[1]: La clé Redis du produit (ex: "venteflash:stockproduit:PROD123")
-- ARGV[1]: La quantité à déduire du stock (nombre de produits à "vendre")

local CODE_ECHEC = "0" -- Indicateur d'échec
local cle_produit = KEYS[1]
local quantite_demande = tonumber(ARGV[1])

-- Récupérer le stock total et la quantité déjà vendue
local info_stock = redis.call("HMGET", cle_produit, "stockTotal", "quantiteVendue")
local stock_disponible_total = tonumber(info_stock[1])
local stock_actuellement_vendu = tonumber(info_stock[2])

-- Vérifier si les informations de stock sont valides
if not stock_disponible_total then
    return CODE_ECHEC
end

-- Vérifier si la quantité demandée peut être satisfaite
-- stock_disponible_total >= stock_actuellement_vendu + quantite_demande
if stock_disponible_total >= (stock_actuellement_vendu + quantite_demande) then
    -- Incrémenter atomiquement la quantité vendue et retourner la nouvelle valeur
    local nouvelle_quantite_vendue = redis.call("HINCRBY", cle_produit, "quantiteVendue", quantite_demande)
    return tostring(nouvelle_quantite_vendue)
end

-- Si la quantité demandée dépasse le stock restant, retourner l'échec
return CODE_ECHEC

Ce script :

1. Récupère simultanément stockTotal et quantiteVendue du Hash Redis.
2. Vérifie si la quantité demandée peut être ajoutée à quantiteVendue sans dépasser stockTotal.
3. Si la condition est remplie, il incrémente atomiquement quantiteVendue en utilisant HINCRBY et retourne la nouvelle valeur.
4. Sinon, il retourne "0", indiquant un échec (stock insuffisant).

Exécution du Script Lua depuis Java

Pour invoquer ce script Lua depuis une application Java, nous utilisons le RedisTemplate de Spring Data Redis :

import org.springframework.core.io.ClassPathResource;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.scripting.support.ResourceScriptSource;
import javax.annotation.PostConstruct;
import java.util.Collections;

public class MoteurVenteFlash {

    private final RedisTemplate<String, Object> redisTemplate;
    private DefaultRedisScript<String> scriptDebitStock;

    private static final String PREFIX_CLE_STOCK = "venteflash:stockproduit:";

    public MoteurVenteFlash(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    @PostConstruct // Initialise le script une fois au démarrage de l'application
    public void init() {
        scriptDebitStock = new DefaultRedisScript<>();
        scriptDebitStock.setScriptSource(new ResourceScriptSource(new ClassPathResource("scripts/debit_stock_flash_sale.lua")));
        scriptDebitStock.setResultType(String.class); // Le script Lua retourne une chaîne de caractères
    }

    private String obtenirCleProduit(String identifiantProduit) {
        return PREFIX_CLE_STOCK.concat(identifiantProduit);
    }

    /**
     * Tente de débiter le stock pour un produit donné en utilisant un script Lua atomique.
     * @param identifiantProduit L'ID du produit.
     * @param quantiteDemandee La quantité de produits à acheter.
     * @return La nouvelle quantité vendue si l'opération réussit, ou 0 en cas d'échec.
     */
    public int tenterAchatProduit(String identifiantProduit, int quantiteDemandee) {
        String cleProduit = obtenirCleProduit(identifiantProduit);
        String resultatScript = redisTemplate.execute(
            scriptDebitStock,
            Collections.singletonList(cleProduit), // Une seule clé pour le script
            String.valueOf(quantiteDemandee)
        );
        return Integer.valueOf(resultatScript);
    }
}

En utilisant cette approche, chaque tentative d'achat exécute le script Lua de manière atomique sur le serveur Redis. Cela élimine la condition de course et assure qu'aucune survente ne se produira, même sous des charges de trafic extrêmes.