Présentation de la mise en cache d'écriture directe et d'écriture derrière
NCache prend en charge la mise en cache Write Through, qui permet les opérations d'écriture directement sur la source de données via le cache. De cette façon, vous pouvez synchroniser votre cache et la source de données. Dans la mise en cache Write-Through, NCache met d'abord à jour le magasin de cache, puis applique cette opération à la source de données. Par exemple, si une application cliente met à jour une entrée dans le cache, alors NCache mettra également à jour la source de données (si Write-Through est activé).
Notes
Cette fonctionnalité est uniquement disponible dans NCache Enterprise Édition.
Pour utiliser Write-Through Caching dans votre application, vous devez d'abord implémenter le IWriteThruProvider
interface. NCache utilisera en interne ce fournisseur personnalisé pour effectuer des opérations d'écriture sur la source de données. NCache appellera votre fournisseur derrière les opérations d'écriture (Ajouter, Insérer, Supprimer/Supprimer) les appels API avec Write-Through.
Lecture NCache fournit deux modes pour la mise en cache en écriture ci-dessous :
- Write-Through (met à jour la source de données de manière synchrone)
- Write-Behind (met à jour la source de données de manière asynchrone)
Notes
NCache fournit un compteur de performances Write-thru/sec
pour les opérations d'écriture immédiate.
Écrire via
Dans la mise en cache en écriture immédiate, une opération est d'abord appliquée sur le magasin de cache, puis mise à jour de manière synchrone sur la source de données configurée. En utilisant Write-Through, les opérations seront terminées après NCache applique cette opération sur la source de données. Vous pouvez utiliser la mise en cache en écriture immédiate si les mises à jour immédiates de la source de données sont essentielles et que vous devez mettre à jour la source de données dès que le cache est mis à jour.
Écriture derrière
Dans Write-Through, en raison d'opérations synchrones sur la source de données, le taux d'opérations sera le même que le taux d'opérations de l'utilisateur sur le cache. Pour les applications avec un trafic utilisateur élevé, le taux d'opérations utilisateur sur le cache peut être très élevé, ce qui peut submerger votre source de données. Les opérations de source de données synchrones peuvent également affecter le temps de réponse d'une opération utilisateur.
Pour surmonter ces problèmes, Write-Behind peut être utilisé à la place de Write-Through. Dans Write-Behind, les opérations de source de données sont effectuées de manière asynchrone après NCache effectue des opérations sur le magasin de cache. Après la mise à jour du magasin de cache, ces opérations sont mises en file d'attente et appliquées ultérieurement aux sources de données configurées de manière asynchrone. Ainsi, l'utilisation de Write-Behind améliorera le temps de réponse des opérations de cache.
NCache fournit différents paramètres de configuration dans Write-Behind pour contrôler le flux d'opérations sur la source de données. Par exemple, vous pouvez spécifier le taux auquel NCache appliquera les opérations Write-Behind sur la source de données via Throttling.
Étranglement
Indique le nombre d'opérations appliquées sur la source de données par seconde. La valeur par défaut pour la limitation est de 500 ops/sec. Vous pouvez modifier cette valeur via les paramètres de la source de sauvegarde dans le NCache Gérante.
Notes
NCache fournit un compteur de performances Write-behind/sec
pour les opérations Write-Behind.
Modes d'écriture différée
NCache vous permet d'appliquer des opérations Write-Behind individuellement ou par lot. Une file d'attente Write-Behind est maintenue pour les opérations Write-Behind. Toutes les opérations Write-Behind seront mises en file d'attente dans cette file d'attente et appliquées ultérieurement à la source de données en fonction du mode batch ou non batch configuré expliqué ci-dessous.
Mode non batch
Par défaut, le mode non batch sera configuré pour les opérations Write-Behind. Dans ce mode, les opérations dans la file d'attente Write-Behind seront appliquées une par une sur la source de données en fonction du taux de limitation configuré. Par exemple, si le taux de limitation est de 500 opérations par seconde, NCache appliquera les opérations Write-Behind une à la fois à la source de données et ne dépassera pas 500 opérations par seconde.
Temps différé
En mode batch, un lot/bloc d'opérations est sélectionné en fonction de leur operation delay
. Vous pouvez configurer operation delay
pour les opérations Write-Behind, qui indique le temps en millisecondes pendant lequel chaque opération doit attendre dans la file d'attente Write-Behind avant d'être appliquée à la source de données. Par défaut, sa valeur est zéro.
L'intervalle de lot est l'intervalle configurable selon lequel NCache vérifie périodiquement les opérations dont le délai d'attente a expiré dans la file d'attente Write-Behind. Par exemple, si le délai de fonctionnement est configuré sur 1000 5 ms et l'intervalle de lot sur XNUMX s, NCache vérifie les opérations dans la file d'attente Write-Behind toutes les 5 secondes et sélectionne toutes les opérations dont les délais d'opération ont expiré (toutes les opérations qui sont en file d'attente depuis les 1000 dernières millisecondes).
Après sélection des opérations en bloc, elles sont appliquées à la source de données en fonction du taux de limitation configuré. Supposons qu'un groupe de 1000 500 opérations soient sélectionnées dans la file d'attente Write-Behind, qui sont ensuite appliquées à la source de données dans un lot de 500 opérations (si le taux de limitation est de XNUMX ops/sec) en tant qu'opération maximale appliquée à la source de données par seconde. ne peut pas dépasser la valeur de limitation configurée.
Vous pouvez spécifier un délai de fonctionnement allant de quelques secondes à des jours et des mois. De cette manière, vous pouvez suspendre vos opérations sur la source de données dans un délai configurable. NCache fournit également des compteurs de performances pour la file d'attente en écriture différée, le nombre d'opérations et le nombre d'opérations par lots en cours. Pour Write-Behind, si le traitement par lots est activé, les opérations prêtes à être exécutées sur la source de données sont retirées de la file d'attente Write-Behind.
Notes
Le nombre d'opérations retirées de la file d'attente dans l'intervalle de lot actuel sera affiché par le compteur de nombre d'opérations par lots en cours.
Prise en charge de l'application à chaud pour la configuration en écriture différée
NCache prend en charge les paramètres Write-Behind applicables à chaud qui vous permettent de modifier les configurations Write-Behind au moment de l'exécution, sans arrêter le cache. Vous pouvez modifier les attributs configurables Write-Behind via le NCache Gestionnaire et NCache intégrera ces modifications de manière dynamique.
Dans la prise en charge de l'application à chaud, vous pouvez modifier le mode Write-Behind de batch à non batch et vice versa. Par exemple, si vous avez changé le mode batch en non-batch, alors NCache ignorera la valeur du délai d'opération et commencera à exécuter les opérations individuellement. En outre, vous pouvez modifier le taux de limitation au moment de l'exécution en fonction de vos besoins. De même, le délai d'opération, l'intervalle de lot, la limite de file d'attente des opérations ayant échoué et le taux d'éviction des opérations ayant échoué peuvent également changer au moment de l'exécution.
Vous pouvez uniquement augmenter la valeur de la limite de la file d'attente des opérations ayant échoué ; sinon, NCache utilisera sa valeur par défaut pour les opérations ultérieures.
Écriture différée dans un environnement en cluster
Comme une file d'attente Write-Behind est maintenue pour les opérations Write-Behind, un moniteur de thread dédié distinct exécute son opération. Les détails du niveau de topologie pour Write-Behind sont mentionnés ci-dessous :
Topologie répliquée : La file d'attente Write-Behind est maintenue sur tous les nœuds, mais le processeur asynchrone Write-Behind est présent uniquement sur le nœud coordinateur. Cela signifie que toutes les opérations Write-Behind sont effectuées via ce nœud et répliquées sur d'autres files d'attente de nœuds à l'échelle du cluster. De cette manière, si un nœud est en panne, le nœud coordinateur suivant exécute toutes les opérations d'écriture différée restantes.
Topologie partitionnée-répliquée : La file d'attente Write-Behind est maintenue sur chaque nœud actif et également répliquée sur ses répliques correspondantes. Chaque nœud est responsable de son opération Write-Behind sur la source de données.
Topologie en miroir : La file d'attente Write-Behind est maintenue sur les nœuds actifs et passifs, mais seul le nœud actif est chargé d'effectuer les opérations Write-Behind. De même, si le nœud actif est en panne, le nœud passif devient actif et effectue les opérations Write-Behind restantes.
Topologie partitionnée : La file d'attente Write-Behind est maintenue sur chaque partition et chaque nœud est responsable de ses opérations Write-Behind sur la source de données.
Mise en cache du résultat de l'opération
NCache vous offre la possibilité de synchroniser les opérations d'écriture immédiate dans le cache en fonction du résultat de leur opération. Après avoir appliqué une opération (Ajouter/Insérer) sur la source de données, vous pouvez spécifier le statut de l'opération sur la base duquel NCache synchronisera le magasin de cache. Par exemple, en cas d'échec de l'opération de la source de données, vous pouvez décider de supprimer ces données du cache ou de les conserver. Vous pouvez également réessayer cette opération sur la source de données. Pour cela, vous devez spécifier Success
/Failure
/FailureRetry
/FailureDontRemove
as
OperationResult.Status
of OperationResult
. Ceci est fourni dans la mise en cache Write-Through et Write-Behind.
État de l'opération de la source de données et actions correspondantes par NCache sont décrits ci-dessous :
en ligne: Cela signifie que l'opération de source de données a réussi et que l'élément a été ajouté à la source de données afin NCache le conservera également dans le cache.
Échec: Cela signifie que l'opération de source de données a échoué et que l'élément n'a pas pu être ajouté à la source de données. NCache le supprimera également du cache.
ÉchecNe pas supprimer: Cela signifie que l'opération de source de données a échoué et que l'élément n'a pas pu être ajouté à la source de données, mais NCache le gardera dans le cache.
ÉchecRéessayer: Cela signifie que l'opération de source de données a échoué et que l'élément n'a pas pu être ajouté à la source de données. NCache conservera l'élément dans le cache et réessayera. Les tentatives seront effectuées en tant qu'opérations Write-Behind.
Nouvelle tentative d'opérations ayant échoué
NCache vous permet de réessayer les opérations dans Write-Through/Write-Behind en cas d'échec sur la source de données. A cet effet, si vous activez la nouvelle tentative d'opération, alors NCache va réessayer cette opération sur la source de données. En cas d'écriture immédiate ou d'écriture différée, toutes les opérations de nouvelle tentative seront remises en file d'attente dans la file d'attente d'écriture différée, ce qui signifie qu'une opération de nouvelle tentative d'écriture immédiate sera réessayée de manière asynchrone en tant qu'opération d'écriture différée.
Notes
NCache fournit également un compteur de performances pour Datasource failed operations/sec
. Opérations d'écriture effectuées sur la source de données renvoyant Failure
/FailureRetry
/FailureDontRemove
as OperationResult.Status
of
OperationResult
sont comptés par seconde par ce compteur.
NCache vous permet de limiter le nombre d'opérations ayant échoué à retenter. Dans une telle situation, vous mentionnerez la limite de la file d'attente des opérations ayant échoué via le
NCache Manager et si cette limite est dépassée, vous pouvez expulser les opérations ayant échoué grâce à un taux d'expulsion configurable. Ici, NCache expulsera la plupart des opérations retentées lorsque la file d'attente retentée est pleine. Chaque opération a un RetryCount
propriété qui lui est associée, qui est incrémentée à chaque opération retentée sur la source de données.
Pour ça, NCache fournit un compteur de performances pour
Write-behind failure retry count
ainsi que le Write-behind evictions/sec
L’ Write-behind failure retry count
affiche le nombre d'opérations remises en file d'attente pour une nouvelle tentative. Opérations d'écriture de source de données renvoyées FailureRetry
as Status
in OperationResult
sera remis en file d'attente pour une nouvelle tentative. Alors que, Write-behind evictions/sec
compteur affiche le nombre d'opérations de relance expulsées par seconde.
Mise à jour du cache après l'opération de source de données
Comme indiqué précédemment, dans la mise en cache en écriture immédiate, l'opération est d'abord effectuée sur le magasin de cache, puis sur la source de données. Il peut exister des scénarios dans lesquels après avoir effectué des opérations sur la source de données, les données sont modifiées, par exemple dans le cas de colonnes d'identité, sa valeur peut être modifiée par l'opération de la source de données. Dans une telle situation, les données peuvent devenir incohérentes dans le cache et la source de données. Pour gérer cela, NCache vous permet de spécifier s'il faut ou non mettre à jour les données dans le cache après les opérations de source de données. Vous pouvez activer UpdateInNCache
pour effectuer à nouveau l'opération (Ajouter/Insérer) sur le magasin de cache pour le synchroniser avec la source de données, par conséquent, mettre à jour les opérations dans le magasin de cache de manière synchrone via Write-Through ou de manière asynchrone via la mise en cache Write-Behind.
Notes
NCache fournit également un compteur de performances Datasource updates/sec
qui affiche le nombre d'opérations de mise à jour par seconde dans le cache après les opérations d'écriture de la source de données.
Dans cette section
Configurer le fournisseur d'écriture directe
Explique l'interface du fournisseur d'écriture immédiate et fournit un exemple d'implémentation de l'interface.
Écriture immédiate avec opérations de cache
Fournit des exemples pour utiliser Write-Through avec des opérations de base dans NCache.
Write-Behind avec les opérations de cache
Fournit des exemples pour utiliser Write-Behind avec des opérations de base dans NCache.
Surveiller les compteurs d'écriture directe
Décrit les compteurs de performance fournis par NCache pour surveiller la mise en cache d'écriture immédiate.