Activité Delete dans Azure Data Factory et Azure Synapse Analytics

S’APPLIQUE À : Azure Data Factory Azure Synapse Analytics

Conseil

Essayez Data Factory dans Microsoft Fabric, une solution d’analyse tout-en-un pour les entreprises. Microsoft Fabric couvre tous les aspects, du déplacement des données à la science des données, en passant par l’analyse en temps réel, l’aide à la décision et la création de rapports. Découvrez comment démarrer un nouvel essai gratuitement !

L’activité Delete dans Azure Data Factory vous permet de supprimer des fichiers ou dossiers de magasins de stockage au niveau local ou dans le cloud. Utilisez cette activité pour propre ou archiver des fichiers lorsqu’ils ne sont plus nécessaires.

Avertissement

Les fichiers ou dossiers supprimés ne peuvent pas être restaurés (sauf si la suppression réversible est activée pour le stockage). Soyez donc prudent quand vous supprimez des fichiers ou dossiers à l’aide de l’activité Delete.

Meilleures pratiques

Voici quelques recommandations relatives à l’utilisation de l’activité Delete :

  • Sauvegardez vos fichiers avant de les supprimer avec l’activité Delete au cas où vous souhaiteriez les restaurer par la suite.

  • Vérifiez que le service dispose d’autorisations en écriture pour supprimer des dossiers ou fichiers du magasin de stockage.

  • Veillez à ne pas supprimer les fichiers qui sont écrits en même temps.

  • Si vous souhaitez supprimer des fichiers ou des dossiers d’un système local, vérifiez que vous utilisez un runtime d’intégration auto-hébergé avec une version supérieure à 3.14.

Magasins de données pris en charge

Créer une activité de suppression avec l’interface utilisateur

Pour utiliser une activité Delete dans un pipeline, effectuez les étapes suivantes :

  1. Recherchez Delete dans le volet Activités de pipeline, puis faites glisser une activité Delete vers le canevas du pipeline.

  2. Sélectionnez la nouvelle activité Supprimer sur le canevas si elle n’est pas déjà sélectionnée, et son onglet Source , pour modifier ses détails.

    Shows the UI for a Delete activity.

  3. Sélectionnez un jeu de données existant ou créez-en un nouveau, en spécifiant les fichiers à supprimer. Si plusieurs fichiers sont sélectionnés, activez éventuellement la suppression récursive, qui supprime également les données dans les dossiers enfants. Vous pouvez également spécifier un nombre maximal de connexions simultanées pour l’opération.

  4. Si vous le souhaitez, vous pouvez configurer la journalisation en sélectionnant l’onglet Paramètres de journalisation et en sélectionnant un emplacement existant ou en créant un nouvel emplacement de service lié de compte de journalisation pour enregistrer les résultats des opérations de suppression effectuées.

    Shows the  Logging settings  tab for a Delete activity.

Syntaxe

{
    "name": "DeleteActivity",
    "type": "Delete",
    "typeProperties": {
        "dataset": {
            "referenceName": "<dataset name>",
            "type": "DatasetReference"
        },
        "storeSettings": {
            "type": "<source type>",
            "recursive": true/false,
            "maxConcurrentConnections": <number>
        },
        "enableLogging": true/false,
        "logStorageSettings": {
            "linkedServiceName": {
                "referenceName": "<name of linked service>",
                "type": "LinkedServiceReference"
            },
            "path": "<path to save log file>"
        }
    }
}

Propriétés type

Propriété Description Obligatoire
dataset Fournit la référence au jeu de données pour déterminer les fichiers ou le dossier à supprimer. Oui
recursive Indique si les fichiers sont supprimés de manière récursive des sous-dossiers ou uniquement du dossier spécifié. Non. Par défaut, il s’agit de false.
maxConcurrentConnections Nombre de connexions simultanées au magasin de stockage pour supprimer un dossier ou des fichiers. Non. Par défaut, il s’agit de 1.
Activer la journalisation Indique si vous devez enregistrer le dossier ou les noms de fichiers supprimés. Si la valeur est true, vous devez fournir un compte de stockage pour enregistrer le fichier journal dans lequel vous pouvez suivre les comportements de l’activité Delete. Non
logStorageSettings S’applique seulement quand enablelogging = true.

Groupe de propriétés de stockage qui peuvent être spécifiées à l’endroit où vous souhaitez enregistrer le fichier journal contenant le dossier ou les noms de fichiers supprimés par l’activité Supprimer.
Non
linkedServiceName S’applique seulement quand enablelogging = true.

Service lié de Stockage Azure, d’Azure Data Lake Stockage Gen1 ou d’Azure Data Lake Stockage Gen2 pour stocker le fichier journal qui contient le dossier ou les noms de fichiers supprimés par l’activité Supprimer. N’oubliez pas qu’il doit être configuré avec le même type d’Integration Runtime que celui utilisé par l’activité de suppression pour supprimer des fichiers.
Non
path S’applique seulement quand enablelogging = true.

Chemin utilisé pour enregistrer le fichier journal dans votre compte de stockage. Si vous ne fournissez pas de chemin d’accès, le service crée un conteneur pour vous.
Non

Surveillance

Vous pouvez voir et superviser les résultats de l’activité Delete dans deux emplacements :

  • Sortie de l’activité Delete
  • Fichier journal

Exemple de sortie de l’activité Delete

{ 
  "datasetName": "AmazonS3",
  "type": "AmazonS3Object",
  "prefix": "test",
  "bucketName": "adf",
  "recursive": true,
  "isWildcardUsed": false,
  "maxConcurrentConnections": 2,  
  "filesDeleted": 4,
  "logPath": "https://sample.blob.core.windows.net/mycontainer/5c698705-a6e2-40bf-911e-e0a927de3f07",
  "effectiveIntegrationRuntime": "MyAzureIR (West Central US)",
  "executionDuration": 650
}

Exemple de fichier journal de l’activité Delete

Nom Category Statut Error
test1/yyy.json Fichier Deleted
test2/hello789.txt Fichier Deleted
test2/test3/hello000.txt Fichier Deleted
test2/test3/zzz.json Fichier Deleted

Exemples d’utilisation de l’activité Delete

Supprimer des dossiers ou fichiers spécifiques

Le magasin a la structure de dossiers suivante :

Racine/
    Dossier_A_1/
        1.txt
        2.txt
        3.csv
    Folder_A_2/
        4.txt
        5.csv
        Dossier_B_1/
            6.txt
            7.csv
        Dossier_B_2/
            8.txt

Vous utilisez maintenant l’activité Supprimer pour supprimer des dossiers ou des fichiers en combinant différentes valeurs de propriété du jeu de données et de l’activité Supprimer :

folderPath fileName recursive Output
Racine/ Dossier_A_2 NULL False Racine/
    Dossier_A_1/
        1.txt
        2.txt
        3.csv
    Folder_A_2/
        4.txt
        5.csv
        Dossier_B_1/
            6.txt
            7.csv
        Dossier_B_2/
            8.txt
Racine/ Dossier_A_2 NULL True Racine/
    Dossier_A_1/
        1.txt
        2.txt
        3.csv
    Folder_A_2/
        4.txt
        5.csv
        Dossier_B_1/
            6.txt
            7.csv
        Dossier_B_2/
            8.txt
Racine/ Dossier_A_2 *.txt False Racine/
    Dossier_A_1/
        1.txt
        2.txt
        3.csv
    Folder_A_2/
        4.txt
        5.csv
        Dossier_B_1/
            6.txt
            7.csv
        Dossier_B_2/
            8.txt
Racine/ Dossier_A_2 *.txt True Racine/
    Dossier_A_1/
        1.txt
        2.txt
        3.csv
    Folder_A_2/
        4.txt
        5.csv
        Dossier_B_1/
            6.txt
            7.csv
        Dossier_B_2/
            8.txt

Nettoyer périodiquement le dossier ou les fichiers partitionnés dans le temps

Vous pouvez créer un pipeline pour nettoyer périodiquement le dossier ou les fichiers partitionnés dans le temps. Voici un exemple de structure de dossiers : /mycontainer/2018/12/14/*.csv. Vous pouvez utiliser la variable de système de service à partir du déclencheur de planification pour identifier le dossier ou les fichiers à supprimer dans chaque exécution du pipeline.

Exemple de pipeline

{
    "name":"cleanup_time_partitioned_folder",
    "properties":{
        "activities":[
            {
                "name":"DeleteOneFolder",
                "type":"Delete",
                "dependsOn":[

                ],
                "policy":{
                    "timeout":"7.00:00:00",
                    "retry":0,
                    "retryIntervalInSeconds":30,
                    "secureOutput":false,
                    "secureInput":false
                },
                "userProperties":[

                ],
                "typeProperties":{
                    "dataset":{
                        "referenceName":"PartitionedFolder",
                        "type":"DatasetReference",
                        "parameters":{
                            "TriggerTime":{
                                "value":"@formatDateTime(pipeline().parameters.TriggerTime, 'yyyy/MM/dd')",
                                "type":"Expression"
                            }
                        }
                    },
                    "logStorageSettings":{
                        "linkedServiceName":{
                            "referenceName":"BloblinkedService",
                            "type":"LinkedServiceReference"
                        },
                        "path":"mycontainer/log"
                    },
                    "enableLogging":true,
                    "storeSettings":{
                        "type":"AzureBlobStorageReadSettings",
                        "recursive":true
                    }
                }
            }
        ],
        "parameters":{
            "TriggerTime":{
                "type":"string"
            }
        },
        "annotations":[

        ]
    }
}

Exemple de jeu de données

{
    "name":"PartitionedFolder",
    "properties":{
        "linkedServiceName":{
            "referenceName":"BloblinkedService",
            "type":"LinkedServiceReference"
        },
        "parameters":{
            "TriggerTime":{
                "type":"string"
            }
        },
        "annotations":[

        ],
        "type":"Binary",
        "typeProperties":{
            "location":{
                "type":"AzureBlobStorageLocation",
                "folderPath":{
                    "value":"@dataset().TriggerTime",
                    "type":"Expression"
                },
                "container":{
                    "value":"mycontainer",
                    "type":"Expression"
                }
            }
        }
    }
}

Exemple de déclencheur

{
    "name": "DailyTrigger",
    "properties": {
        "runtimeState": "Started",
        "pipelines": [
            {
                "pipelineReference": {
                    "referenceName": "cleanup_time_partitioned_folder",
                    "type": "PipelineReference"
                },
                "parameters": {
                    "TriggerTime": "@trigger().scheduledTime"
                }
            }
        ],
        "type": "ScheduleTrigger",
        "typeProperties": {
            "recurrence": {
                "frequency": "Day",
                "interval": 1,
                "startTime": "2018-12-13T00:00:00.000Z",
                "timeZone": "UTC",
                "schedule": {
                    "minutes": [
                        59
                    ],
                    "hours": [
                        23
                    ]
                }
            }
        }
    }
}

Nettoyer les fichiers ayant expiré dont la dernière modification est antérieure au 1/1/2018

Vous pouvez créer un pipeline pour propre les fichiers anciens ou expirés à l’aide du filtre d’attribut de fichier : « LastModified » dans le jeu de données.

Exemple de pipeline

{
    "name":"CleanupExpiredFiles",
    "properties":{
        "activities":[
            {
                "name":"DeleteFilebyLastModified",
                "type":"Delete",
                "dependsOn":[

                ],
                "policy":{
                    "timeout":"7.00:00:00",
                    "retry":0,
                    "retryIntervalInSeconds":30,
                    "secureOutput":false,
                    "secureInput":false
                },
                "userProperties":[

                ],
                "typeProperties":{
                    "dataset":{
                        "referenceName":"BlobFilesLastModifiedBefore201811",
                        "type":"DatasetReference"
                    },
                    "logStorageSettings":{
                        "linkedServiceName":{
                            "referenceName":"BloblinkedService",
                            "type":"LinkedServiceReference"
                        },
                        "path":"mycontainer/log"
                    },
                    "enableLogging":true,
                    "storeSettings":{
                        "type":"AzureBlobStorageReadSettings",
                        "recursive":true,
                        "modifiedDatetimeEnd":"2018-01-01T00:00:00.000Z"
                    }
                }
            }
        ],
        "annotations":[

        ]
    }
}

Exemple de jeu de données

{
    "name":"BlobFilesLastModifiedBefore201811",
    "properties":{
        "linkedServiceName":{
            "referenceName":"BloblinkedService",
            "type":"LinkedServiceReference"
        },
        "annotations":[

        ],
        "type":"Binary",
        "typeProperties":{
            "location":{
                "type":"AzureBlobStorageLocation",
                "fileName":"*",
                "folderPath":"mydirectory",
                "container":"mycontainer"
            }
        }
    }
}

Déplacer des fichiers par chaînage des activités Copy et Delete

Vous pouvez déplacer un fichier en utilisant une activité Copy pour copier un fichier, puis une activité Delete pour supprimer un fichier d’un pipeline. Pour déplacer plusieurs fichiers, vous pouvez utiliser les activités GetMetadata, Filter, Foreach, Copy et Delete comme dans l’exemple suivant.

Notes

Soyez très prudent si, pour déplacer la totalité d’un dossier, vous définissez un jeu de données contenant un chemin de dossier uniquement, puis utilisez une activité Copy et une activité Delete pour faire référence au même jeu de données représentant un dossier. Vous devez vous assurer qu’aucun nouveau fichier n’arrive dans le dossier entre l’opération de copie et l’opération de suppression. Si de nouveaux fichiers arrivent dans le dossier au moment où votre activité Copy vient juste d’achever la copie, mais avant le démarrage de l’activité Delete, cette dernière, en supprimant la totalité du dossier, risque de supprimer le nouveau fichier qui n’a pas encore été copié dans la destination.

Exemple de pipeline

{
    "name":"MoveFiles",
    "properties":{
        "activities":[
            {
                "name":"GetFileList",
                "type":"GetMetadata",
                "dependsOn":[

                ],
                "policy":{
                    "timeout":"7.00:00:00",
                    "retry":0,
                    "retryIntervalInSeconds":30,
                    "secureOutput":false,
                    "secureInput":false
                },
                "userProperties":[

                ],
                "typeProperties":{
                    "dataset":{
                        "referenceName":"OneSourceFolder",
                        "type":"DatasetReference",
                        "parameters":{
                            "Container":{
                                "value":"@pipeline().parameters.SourceStore_Location",
                                "type":"Expression"
                            },
                            "Directory":{
                                "value":"@pipeline().parameters.SourceStore_Directory",
                                "type":"Expression"
                            }
                        }
                    },
                    "fieldList":[
                        "childItems"
                    ],
                    "storeSettings":{
                        "type":"AzureBlobStorageReadSettings",
                        "recursive":true
                    },
                    "formatSettings":{
                        "type":"BinaryReadSettings"
                    }
                }
            },
            {
                "name":"FilterFiles",
                "type":"Filter",
                "dependsOn":[
                    {
                        "activity":"GetFileList",
                        "dependencyConditions":[
                            "Succeeded"
                        ]
                    }
                ],
                "userProperties":[

                ],
                "typeProperties":{
                    "items":{
                        "value":"@activity('GetFileList').output.childItems",
                        "type":"Expression"
                    },
                    "condition":{
                        "value":"@equals(item().type, 'File')",
                        "type":"Expression"
                    }
                }
            },
            {
                "name":"ForEachFile",
                "type":"ForEach",
                "dependsOn":[
                    {
                        "activity":"FilterFiles",
                        "dependencyConditions":[
                            "Succeeded"
                        ]
                    }
                ],
                "userProperties":[

                ],
                "typeProperties":{
                    "items":{
                        "value":"@activity('FilterFiles').output.value",
                        "type":"Expression"
                    },
                    "batchCount":20,
                    "activities":[
                        {
                            "name":"CopyAFile",
                            "type":"Copy",
                            "dependsOn":[

                            ],
                            "policy":{
                                "timeout":"7.00:00:00",
                                "retry":0,
                                "retryIntervalInSeconds":30,
                                "secureOutput":false,
                                "secureInput":false
                            },
                            "userProperties":[

                            ],
                            "typeProperties":{
                                "source":{
                                    "type":"BinarySource",
                                    "storeSettings":{
                                        "type":"AzureBlobStorageReadSettings",
                                        "recursive":false,
                                        "deleteFilesAfterCompletion":false
                                    },
                                    "formatSettings":{
                                        "type":"BinaryReadSettings"
                                    },
                                    "recursive":false
                                },
                                "sink":{
                                    "type":"BinarySink",
                                    "storeSettings":{
                                        "type":"AzureBlobStorageWriteSettings"
                                    }
                                },
                                "enableStaging":false,
                                "dataIntegrationUnits":0
                            },
                            "inputs":[
                                {
                                    "referenceName":"OneSourceFile",
                                    "type":"DatasetReference",
                                    "parameters":{
                                        "Container":{
                                            "value":"@pipeline().parameters.SourceStore_Location",
                                            "type":"Expression"
                                        },
                                        "Directory":{
                                            "value":"@pipeline().parameters.SourceStore_Directory",
                                            "type":"Expression"
                                        },
                                        "filename":{
                                            "value":"@item().name",
                                            "type":"Expression"
                                        }
                                    }
                                }
                            ],
                            "outputs":[
                                {
                                    "referenceName":"OneDestinationFile",
                                    "type":"DatasetReference",
                                    "parameters":{
                                        "Container":{
                                            "value":"@pipeline().parameters.DestinationStore_Location",
                                            "type":"Expression"
                                        },
                                        "Directory":{
                                            "value":"@pipeline().parameters.DestinationStore_Directory",
                                            "type":"Expression"
                                        },
                                        "filename":{
                                            "value":"@item().name",
                                            "type":"Expression"
                                        }
                                    }
                                }
                            ]
                        },
                        {
                            "name":"DeleteAFile",
                            "type":"Delete",
                            "dependsOn":[
                                {
                                    "activity":"CopyAFile",
                                    "dependencyConditions":[
                                        "Succeeded"
                                    ]
                                }
                            ],
                            "policy":{
                                "timeout":"7.00:00:00",
                                "retry":0,
                                "retryIntervalInSeconds":30,
                                "secureOutput":false,
                                "secureInput":false
                            },
                            "userProperties":[

                            ],
                            "typeProperties":{
                                "dataset":{
                                    "referenceName":"OneSourceFile",
                                    "type":"DatasetReference",
                                    "parameters":{
                                        "Container":{
                                            "value":"@pipeline().parameters.SourceStore_Location",
                                            "type":"Expression"
                                        },
                                        "Directory":{
                                            "value":"@pipeline().parameters.SourceStore_Directory",
                                            "type":"Expression"
                                        },
                                        "filename":{
                                            "value":"@item().name",
                                            "type":"Expression"
                                        }
                                    }
                                },
                                "logStorageSettings":{
                                    "linkedServiceName":{
                                        "referenceName":"BloblinkedService",
                                        "type":"LinkedServiceReference"
                                    },
                                    "path":"container/log"
                                },
                                "enableLogging":true,
                                "storeSettings":{
                                    "type":"AzureBlobStorageReadSettings",
                                    "recursive":true
                                }
                            }
                        }
                    ]
                }
            }
        ],
        "parameters":{
            "SourceStore_Location":{
                "type":"String"
            },
            "SourceStore_Directory":{
                "type":"String"
            },
            "DestinationStore_Location":{
                "type":"String"
            },
            "DestinationStore_Directory":{
                "type":"String"
            }
        },
        "annotations":[

        ]
    }
}

Exemples de jeux de données

Jeu de données utilisé par l’activité GetMetadata pour énumérer la liste de fichiers.

{
    "name":"OneSourceFolder",
    "properties":{
        "linkedServiceName":{
            "referenceName":"AzureStorageLinkedService",
            "type":"LinkedServiceReference"
        },
        "parameters":{
            "Container":{
                "type":"String"
            },
            "Directory":{
                "type":"String"
            }
        },
        "annotations":[

        ],
        "type":"Binary",
        "typeProperties":{
            "location":{
                "type":"AzureBlobStorageLocation",
                "folderPath":{
                    "value":"@{dataset().Directory}",
                    "type":"Expression"
                },
                "container":{
                    "value":"@{dataset().Container}",
                    "type":"Expression"
                }
            }
        }
    }
}

Jeu de données utilisé comme source de données par les activités Copy et Delete.

{
    "name":"OneSourceFile",
    "properties":{
        "linkedServiceName":{
            "referenceName":"AzureStorageLinkedService",
            "type":"LinkedServiceReference"
        },
        "parameters":{
            "Container":{
                "type":"String"
            },
            "Directory":{
                "type":"String"
            },
            "filename":{
                "type":"string"
            }
        },
        "annotations":[

        ],
        "type":"Binary",
        "typeProperties":{
            "location":{
                "type":"AzureBlobStorageLocation",
                "fileName":{
                    "value":"@dataset().filename",
                    "type":"Expression"
                },
                "folderPath":{
                    "value":"@{dataset().Directory}",
                    "type":"Expression"
                },
                "container":{
                    "value":"@{dataset().Container}",
                    "type":"Expression"
                }
            }
        }
    }
}

Jeu de données utilisé comme destination de données par l’activité Copy.

{
    "name":"OneDestinationFile",
    "properties":{
        "linkedServiceName":{
            "referenceName":"AzureStorageLinkedService",
            "type":"LinkedServiceReference"
        },
        "parameters":{
            "Container":{
                "type":"String"
            },
            "Directory":{
                "type":"String"
            },
            "filename":{
                "type":"string"
            }
        },
        "annotations":[

        ],
        "type":"Binary",
        "typeProperties":{
            "location":{
                "type":"AzureBlobStorageLocation",
                "fileName":{
                    "value":"@dataset().filename",
                    "type":"Expression"
                },
                "folderPath":{
                    "value":"@{dataset().Directory}",
                    "type":"Expression"
                },
                "container":{
                    "value":"@{dataset().Container}",
                    "type":"Expression"
                }
            }
        }
    }
}

Vous pouvez également faire en sorte que le modèle déplace les fichiers à partir d’ici.

Limitations connues

  • L’activité De suppression ne prend pas en charge la suppression de la liste des dossiers décrits par wild carte.

  • Lorsque vous utilisez le filtre d'attribut de fichier dans l'activité de suppression : modifiedDatetimeStart et modifiedDatetimeEnd pour sélectionner les fichiers à supprimer, veillez à définir également "wildcardFileName": "*" dans l'activité de suppression.

Apprenez-en davantage sur le déplacement de fichiers dans les pipelines Azure Data Factory et Synapse.