Simple Log Service prend en charge les mises à jour et suppressions au niveau des lignes pour les données déjà écrites dans un Logstore. Activez cette fonctionnalité lors de la création d'un Logstore, puis utilisez l'OpenAPI ou le SDK Python pour modifier et supprimer des données de journal par RowID ou par requête.
Vue d'ensemble
Par défaut, un Logstore suit un modèle immuable en ajout seul (append-only). Une fois les données écrites dans un Logstore, elles ne peuvent pas être modifiées ni supprimées sur place.
Certains scénarios nécessitent de modifier ou de supprimer des données existantes dans un Logstore :
Correction rétroactive des champs : mettez à jour des champs métier tels que le statut d'une commande, les étiquettes de risque ou les résultats de scoring après l'écriture du journal d'origine.
Nettoyage des données de test : supprimez les enregistrements de test ou de canari d'un Logstore de production.
Réparation d'enregistrement unique : corrigez une entrée de journal spécifique lors d'un workflow de rejeu ou de rapprochement métier.
Simple Log Service fournit des capacités de mise à jour et de suppression au niveau des lignes pour chaque Logstore. Modifiez ou supprimez des enregistrements individuels via RowID, ou effectuez des modifications et suppressions par lot par requête.
Prenez note des points suivants avant d'utiliser cette fonctionnalité :
Cette fonctionnalité est disponible uniquement pour les nouveaux Logstores. Définissez
enableModifysurtruelors de la création du Logstore. Vous ne pouvez pas activer cette fonctionnalité pour un Logstore existant.Une fois activée, la fonctionnalité ne peut pas être désactivée. Planifiez en conséquence avant de créer le Logstore.
Toutes les opérations de modification et de suppression sont irréversibles. Il n'existe aucun mécanisme de restauration intégré.
Les consommateurs en temps réel (LogHub) et les tâches de livraison ne sont pas notifiés des modifications ou des suppressions. Seuls les chemins de lecture basés sur des requêtes (Search, SQL, SPL) renvoient les dernières données.
Concepts clés
RowID
RowID est un identifiant logique attribué par Simple Log Service à chaque entrée de journal dans un Logstore où la mise à jour et la suppression au niveau des lignes sont activées. Toutes les opérations de modification et de suppression utilisent RowID pour localiser l'enregistrement cible.
Format : RowID est généré au moment de l'écriture et ne peut pas être personnalisé. Traitez-le comme un identifiant opaque.
Stabilité : Un RowID reste inchangé tout au long du cycle de vie d'un enregistrement de journal, même après sa modification.
Visibilité : Les résultats de requête incluent automatiquement le champ intégré
__rowid__. Ce nom de champ est réservé et ne peut pas être utilisé dans les configurations d'index.
AffectedRows
Chaque demande de modification ou de suppression réussie renvoie AffectedRows, qui correspond au nombre d'enregistrements de journal réellement affectés. Utilisez cette valeur pour vérifier que l'opération s'est déroulée comme prévu.
AffectedRows est renvoyé dans le corps de la réponse HTTP x-log-affectedrows. Dans le SDK Python, lisez-le via resp.affected_rows.
Prérequis
Assurez-vous que les conditions suivantes sont remplies :
Un projet Simple Log Service. Pour plus d'informations, consultez Créer un projet.
Un Logstore avec le paramètre
enableModifydéfini surtrue. Consultez Activer la fonctionnalité dans cette rubrique.Les autorisations RAM
log:UpdateLogStoreLogsetlog:DeleteLogStoreLogsaccordées à l'appelant. Consultez Autorisations RAM requises dans cette rubrique.(Conditionnel) Si vous utilisez des opérations basées sur des requêtes, les champs référencés dans la requête doivent avoir des index configurés.
Activer la fonctionnalité
Pour utiliser la mise à jour et la suppression au niveau des lignes, définissez le paramètre enableModify sur true lorsque vous appelez l'API CreateLogStore.
Vous ne pouvez définir
enableModifyque lors de la création d'un nouveau Logstore. Vous ne pouvez pas activer cette fonctionnalité pour un Logstore existant.Après avoir défini
enableModifysurtrue, vous ne pouvez pas le désactiver.Cette fonctionnalité ne peut être activée que via l'OpenAPI ou le SDK. La console Simple Log Service ne prend pas en charge cette fonctionnalité.
Activer via l'OpenAPI
Appelez l'API CreateLogStore et définissez enableModify sur true dans le corps de la requête :
POST /logstores HTTP/1.1
Host: <project>.<endpoint>
Content-Type: application/json
{
"logstoreName": "my-logstore",
"ttl": 30,
"shardCount": 1,
"enableModify": true
}
Une fois le Logstore créé, appelez l'API GetLogStore pour vérifier. Si la réponse contient "enableModify": true, la fonctionnalité est activée.
Activer via le SDK Python
from aliyun.log import LogClient
# Obtain AccessKey credentials from environment variables.
client = LogClient(endpoint, access_key_id, access_key)
client.create_logstore(
project_name="my-project",
logstore_name="my-logstore",
ttl=30,
shard_count=1,
enable_modify=True,
)
Modifier et supprimer des données
Deux méthodes sont disponibles pour modifier et supprimer des données de journal :
|
Méthode |
Scénario |
Nombre maximal de lignes par requête |
|
Par RowID |
Vous connaissez le RowID exact de l'enregistrement cible et souhaitez le modifier ou le supprimer avec précision. |
1 |
|
Par requête |
Vous souhaitez modifier ou supprimer par lot tous les enregistrements correspondant à une condition de requête. |
10 000 |
Méthode 1 : Modifier et supprimer par RowID
Utilisez cette méthode lorsque vous disposez déjà du RowID d'un enregistrement spécifique, généralement obtenu à partir d'un résultat de requête précédent.
Modifier un enregistrement unique
Spécifiez uniquement les champs que vous souhaitez modifier. Les champs que vous n'incluez pas restent inchangés.
from aliyun.log import LogClient, LogItem
client = LogClient(endpoint, access_key_id, access_key)
# Specify only the fields to update. Unspecified fields keep their original values.
new_item = LogItem(
contents=[("status", "REFUNDED")],
)
resp = client.update_logs(
project="my-project",
logstore="my-logstore",
rowid=rowid,
log_item=new_item,
)
print(f"Affected rows: {resp.affected_rows}")
Supprimer un enregistrement unique
resp = client.delete_logs_v2(
project="my-project",
logstore="my-logstore",
rowid=rowid,
)
print(f"Affected rows: {resp.affected_rows}")
La suppression multiple du même enregistrement est idempotente. L'opération ne renvoie pas d'erreur, mais
affected_rowsrenvoie0.Utilisez
delete_logs_v2pour une suppression synchrone. L'ancienne méthodedelete_logseffectue une suppression douce asynchrone, qui n'est pas prise en charge pour les Logstores avecenableModifyactivé.
Méthode 2 : Modifier et supprimer par requête
Utilisez cette méthode pour modifier ou supprimer par lot les enregistrements correspondant à une condition de requête. La requête s'exécute côté serveur et la modification ou la suppression est appliquée à tous les enregistrements correspondants.
Cette opération est irréversible.
Si l'opération échoue partiellement, les lignes déjà modifiées ou déjà supprimées ne sont pas restaurées. La réponse renvoie uniquement le nombre de lignes réellement affectées.
Avant l'exécution, utilisez Search ou SQL pour prévisualiser les enregistrements correspondant à votre condition de requête et vérifier l'étendue.
Les opérations par lot basées sur des requêtes consomment beaucoup de ressources. Réduisez la plage horaire ou affinez la condition de requête pour rester dans la limite de 10 000 lignes par requête.
Les champs référencés dans la requête doivent avoir des index configurés. Sinon, la requête ne renvoie aucun résultat.
Supprimer par requête
resp = client.delete_logs_v2(
project="my-project",
logstore="my-logstore",
from_time=1716537600,
to_time=1716624000,
query='level: DEBUG',
)
print(f"Deleted rows: {resp.affected_rows}")
Modifier par requête
Spécifiez à la fois la condition de requête et les valeurs de champ à mettre à jour. Tous les enregistrements correspondants sont mis à jour avec les mêmes valeurs de champ.
resp = client.update_logs(
project="my-project",
logstore="my-logstore",
from_time=1716537600,
to_time=1716624000,
query='order_id: 12345 and status: "PENDING"',
update_fields={"status": "REFUNDED", "refund_at": "2026-05-25T10:00:00Z"},
)
print(f"Modified rows: {resp.affected_rows}")
Si vous transmettez à la fois
rowidetquerydans la même requête,rowidest prioritaire et le paramètrequeryest ignoré.Les opérations basées sur des requêtes nécessitent que les données soient visibles pour la requête. Il peut y avoir un délai de quelques secondes entre l'ingestion des données et leur disponibilité pour la requête.
Vérifier les résultats
Vérifiez le résultat après chaque opération de modification ou de suppression pour confirmer qu'elle a réussi comme prévu.
-
Vérifiez AffectedRows : chaque requête renvoie
AffectedRowsdans la réponse (en-tête HTTPx-log-affectedrowsouresp.affected_rowsdans le SDK Python). Comparez cette valeur au nombre attendu d'enregistrements :AffectedRows > 0et correspond à l'attente : l'opération a réussi.AffectedRows = 0: aucun enregistrement ne correspondait à la condition, ou l'enregistrement avait déjà été supprimé. Revérifiez votre requête ou RowID.AffectedRowsest inférieur aux attentes : une défaillance partielle peut s'être produite. Réexécutez l'opération pour les enregistrements restants.
Exécutez une requête de suivi : pour les opérations par lot, exécutez une requête Search ou SQL après l'opération pour confirmer que les données reflètent l'état attendu. Cela est particulièrement important lorsque
AffectedRowsest inférieur aux attentes.
Cohérence des données
Les opérations de modification et de suppression prennent effet de manière synchrone. Après la réussite d'une requête, les requêtes suivantes (Search, SQL et SPL) renvoient les résultats mis à jour.
Gardez à l'esprit les comportements suivants :
La consommation en temps réel n'est pas affectée : les consommateurs LogHub et les tâches de livraison (telles que la livraison vers OSS ou MaxCompute) fonctionnent sur le flux d'écriture d'origine. Ils ne reflètent pas les modifications ou les suppressions. Seuls les chemins de lecture basés sur des requêtes renvoient les dernières données.
Les opérations basées sur des requêtes ne sont pas atomiques : le serveur traite chaque enregistrement correspondant individuellement. En cas d'échec partiel, les enregistrements déjà traités ne sont pas restaurés. La réponse renvoie le nombre de lignes réellement affectées.
Autorisations RAM requises
L'utilisateur ou le rôle RAM qui appelle l'API de modification ou de suppression doit disposer des autorisations suivantes :
|
Action |
Description |
|
|
Modifiez les données de journal par RowID ou par requête. |
|
|
Supprimez les données de journal par RowID ou par requête. |
Format ARN de la ressource :
acs:log:<region>:<account-id>:project/<project-name>/logstore/<logstore-name>
Nous vous recommandons de créer un utilisateur ou un rôle RAM dédié pour les opérations de modification et de suppression, en particulier pour les suppressions par lot basées sur des requêtes. Utilisez ActionTrail pour auditer ces opérations.
Limites d'utilisation
|
Élément |
Description |
|
Nouveau Logstore uniquement |
Vous devez définir |
|
Ne peut pas être désactivé |
Après avoir activé cette fonctionnalité, vous ne pouvez pas la désactiver. |
|
Nombre maximal de lignes par opération basée sur une requête |
10 000 lignes par requête. Si la requête correspond à plus de 10 000 enregistrements, la requête est rejetée. Réduisez la plage horaire ou affinez la condition de requête. |
|
Exigence d'index |
Les champs utilisés comme conditions de requête doivent avoir des index configurés. Les opérations par RowID ne nécessitent pas d'index de champ métier. |
|
Aucune reconstruction d'index |
Après avoir activé cette fonctionnalité, le Logstore ne prend pas en charge les reconstructions d'index. |
|
Aucune suppression douce |
Après avoir activé cette fonctionnalité, la suppression douce asynchrone n'est pas prise en charge. Utilisez l'interface de suppression synchrone ( |
|
|
Vous ne pouvez pas utiliser |
|
Consommateurs en temps réel non notifiés |
Les consommateurs LogHub et les tâches de livraison (telles que la livraison vers OSS ou MaxCompute) ne sont pas notifiés des modifications ou des suppressions. Seuls les chemins de lecture basés sur des requêtes (Search, SQL, SPL) renvoient les dernières données. |
Facturation
Opérations de modification : les opérations de modification ne sont actuellement pas facturées. À l'avenir, les frais seront basés sur l'espace de stockage généré par les données modifiées.
Opérations de suppression : les opérations de suppression n'entraînent pas de frais supplémentaires.
FAQ
Puis-je activer cette fonctionnalité pour un Logstore existant ?
Non. Cette fonctionnalité nécessite un format de stockage disponible uniquement au moment de la création du Logstore. Créez un nouveau Logstore avec enableModify=true et migrez les données historiques via la transformation de données ou le SDK.
Les opérations de modification et de suppression affectent-elles les consommateurs en temps réel ?
Non. Les consommateurs LogHub et les tâches de livraison fonctionnent sur le flux d'écriture d'origine et ne reflètent pas les modifications ou les suppressions. Seuls les chemins de lecture basés sur des requêtes (Search, SQL et SPL) renvoient les dernières données.
Les modifications et suppressions sont-elles immédiatement visibles ?
Oui. Après la réussite d'une requête, les requêtes suivantes renvoient les données mises à jour. La valeur AffectedRows dans la réponse indique combien d'enregistrements ont été réellement modifiés ou supprimés.
Puis-je annuler une modification ou une suppression accidentelle ?
Non. Il n'existe aucun mécanisme de restauration intégré. Prévisualisez les enregistrements correspondants avec Search ou SQL avant d'exécuter une opération de modification ou de suppression. Nous vous recommandons d'utiliser des utilisateurs RAM dédiés avec des autorisations restreintes et d'activer ActionTrail pour l'audit.
La suppression libère-t-elle immédiatement de l'espace de stockage ?
La suppression est une opération logique. Le stockage sous-jacent est conservé jusqu'à l'expiration du TTL du Logstore ou jusqu'à l'exécution d'une compactation en arrière-plan. Tous les chemins de requête filtrent les enregistrements supprimés, de sorte que les données supprimées sont invisibles pour les utilisateurs.