Udostępnij za pośrednictwem


Działanie usuwania w usłudze Azure Data Factory i usłudze Azure Synapse Analytics

DOTYCZY: Azure Data Factory Azure Synapse Analytics

Napiwek

Wypróbuj usługę Data Factory w usłudze Microsoft Fabric — rozwiązanie analityczne typu all-in-one dla przedsiębiorstw. Usługa Microsoft Fabric obejmuje wszystko, od przenoszenia danych do nauki o danych, analizy w czasie rzeczywistym, analizy biznesowej i raportowania. Dowiedz się, jak bezpłatnie rozpocząć nową wersję próbną !

Działanie usuwania w usłudze Azure Data Factory umożliwia usuwanie plików lub folderów z lokalnych magazynów magazynu lub magazynów w chmurze. Użyj tego działania, aby wyczyścić lub zarchiwizować pliki, gdy nie są już potrzebne.

Ostrzeżenie

Nie można przywrócić usuniętych plików lub folderów (chyba że magazyn ma włączone usuwanie nietrwałe). Należy zachować ostrożność przy usuwaniu plików lub folderów za pomocą działania usuwania.

Najlepsze rozwiązania

Poniżej przedstawiono kilka zaleceń dotyczących korzystania z działania Usuń:

  • Przed usunięciem plików należy utworzyć kopię zapasową za pomocą działania Usuń, jeśli trzeba je przywrócić w przyszłości.

  • Upewnij się, że usługa ma uprawnienia do zapisu, aby usunąć foldery lub pliki z magazynu.

  • Upewnij się, że nie usuwasz plików, które są zapisywane w tym samym czasie.

  • Jeśli chcesz usunąć pliki lub foldery z systemu lokalnego, upewnij się, że używasz własnego środowiska Integration Runtime w wersji nowszej niż 3.14.

Obsługiwane magazyny danych

Tworzenie działania Usuwanie za pomocą interfejsu użytkownika

Aby użyć działania Usuń w potoku, wykonaj następujące kroki:

  1. Wyszukaj ciąg Usuń w okienku Działania potoku i przeciągnij działanie Usuń na kanwę potoku.

  2. Wybierz nowe działanie Usuń na kanwie, jeśli nie zostało jeszcze wybrane, a karta Źródło , aby edytować jego szczegóły.

    Pokazuje interfejs użytkownika dla działania Usuwania.

  3. Wybierz istniejący lub utwórz nowy zestaw danych określający pliki do usunięcia. Jeśli wybrano wiele plików, opcjonalnie włącz rekursywne usuwanie, które również usuwa dane w dowolnych folderach podrzędnych. Można również określić maksymalną liczbę połączeń współbieżnych dla operacji.

  4. Opcjonalnie skonfiguruj rejestrowanie, wybierając kartę Ustawienia rejestrowania i wybierając istniejącą lub tworząc nową lokalizację połączonego konta rejestrowania w celu rejestrowania wyników wykonanych operacji usuwania.

    Pokazuje & Ustawienia rejestrowania & karta działania Usuń.

Składnia

{
    "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>"
        }
    }
}

Właściwości typu

Właściwości Opis Wymagania
zestaw danych Zawiera odwołanie do zestawu danych w celu określenia, które pliki lub foldery mają zostać usunięte Tak
Cykliczne Wskazuje, czy pliki są usuwane rekursywnie z podfolderów, czy tylko z określonego folderu. L.p. Wartość domyślna to false.
maxConcurrentConnections Liczba połączeń łączących się z magazynem magazynu współbieżnie w celu usunięcia folderu lub plików. L.p. Wartość domyślna to 1.
włączanie rejestrowania Wskazuje, czy należy zarejestrować usunięty folder lub nazwy plików. Jeśli to prawda, musisz dodatkowo podać konto magazynu, aby zapisać plik dziennika, aby można było śledzić zachowania działania Usuń, odczytując plik dziennika. Nie.
logStorageSettings Dotyczy tylko wtedy, gdy enablelogging = true.

Grupa właściwości magazynu, które można określić, gdzie chcesz zapisać plik dziennika zawierający folder lub nazwy plików usunięte przez działanie Usuń.
Nie.
linkedServiceName Dotyczy tylko wtedy, gdy enablelogging = true.

Połączona usługa Azure Storage, Azure Data Lake Storage Gen1 lub Azure Data Lake Storage Gen2 do przechowywania pliku dziennika zawierającego nazwy folderów lub plików usuniętych przez działanie Usuń. Należy pamiętać, że musi być skonfigurowany z tym samym typem środowiska Integration Runtime z tego, który jest używany przez działanie usuwania do usuwania plików.
Nie.
path Dotyczy tylko wtedy, gdy enablelogging = true.

Ścieżka do zapisania pliku dziennika na koncie magazynu. Jeśli nie podasz ścieżki, usługa utworzy kontener.
Nie.

Monitorowanie

Istnieją dwa miejsca, w których można wyświetlać i monitorować wyniki działania Usuń:

  • Z danych wyjściowych działania Usuń.
  • Z pliku dziennika.

Przykładowe dane wyjściowe działania Usuń

{ 
  "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
}

Przykładowy plik dziennika działania Usuń

Nazwisko Kategoria Stan Błąd
test1/yyy.json Plik Usunięte
test2/hello789.txt Plik Usunięte
test2/test3/hello000.txt Plik Usunięte
test2/test3/zzz.json Plik Usunięte

Przykłady użycia działania Usuń

Usuwanie określonych folderów lub plików

Magazyn ma następującą strukturę folderów:

Korzeń/
    Folder_A_1/
        1.txt
        2.txt
        3.csv
    Folder_A_2/
        4.txt
        5.csv
        Folder_B_1/
            6.txt
            7.csv
        Folder_B_2/
            8.txt

Teraz używasz działania Usuń, aby usunąć folder lub pliki według kombinacji innej wartości właściwości z zestawu danych i działania Usuń:

folderPath fileName Cykliczne Wyjście
Katalog główny/Folder_A_2 NULL Fałsz Korzeń/
    Folder_A_1/
        1.txt
        2.txt
        3.csv
    Folder_A_2/
        4.txt
        5.csv
        Folder_B_1/
            6.txt
            7.csv
        Folder_B_2/
            8.txt
Katalog główny/Folder_A_2 NULL Prawda Korzeń/
    Folder_A_1/
        1.txt
        2.txt
        3.csv
    Folder_A_2/
        4.txt
        5.csv
        Folder_B_1/
            6.txt
            7.csv
        Folder_B_2/
            8.txt
Katalog główny/Folder_A_2 *.Txt Fałsz Korzeń/
    Folder_A_1/
        1.txt
        2.txt
        3.csv
    Folder_A_2/
        4.txt
        5.csv
        Folder_B_1/
            6.txt
            7.csv
        Folder_B_2/
            8.txt
Katalog główny/Folder_A_2 *.Txt Prawda Korzeń/
    Folder_A_1/
        1.txt
        2.txt
        3.csv
    Folder_A_2/
        4.txt
        5.csv
        Folder_B_1/
            6.txt
            7.csv
        Folder_B_2/
            8.txt

Okresowo czyścić folder lub pliki partycjonowane w czasie

Potok można utworzyć w celu okresowego czyszczenia folderu lub plików podzielonych na partycje czasu. Na przykład struktura folderów jest podobna do: /mycontainer/2018/12/14/*.csv. Możesz użyć zmiennej systemowej usługi z wyzwalacza harmonogramu, aby zidentyfikować folder lub pliki, które powinny zostać usunięte w każdym przebiegu potoku.

Przykładowy potok

{
    "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":[

        ]
    }
}

Przykładowy zestaw danych

{
    "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"
                }
            }
        }
    }
}

Przykładowy wyzwalacz

{
    "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
                    ]
                }
            }
        }
    }
}

Wyczyść wygasłe pliki, które zostały ostatnio zmodyfikowane przed 2018.1.1

Potok można utworzyć, aby wyczyścić stare lub wygasłe pliki przy użyciu filtru atrybutów pliku: "LastModified" w zestawie danych.

Przykładowy potok

{
    "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":[

        ]
    }
}

Przykładowy zestaw danych

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

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

Przenoszenie plików przez łączenie działanie Kopiuj i działanie Usuwanie

Plik można przenieść przy użyciu działanie Kopiuj, aby skopiować plik, a następnie działanie Usuń w celu usunięcia pliku w potoku. Jeśli chcesz przenieść wiele plików, możesz użyć działania GetMetadata + Działania filtru + Działania foreach + działanie Kopiuj + Usuń, jak w poniższym przykładzie.

Uwaga

Jeśli chcesz przenieść cały folder, definiując tylko zestaw danych zawierający ścieżkę folderu, a następnie używając działanie Kopiuj i działania Usuń, aby odwołać się do tego samego zestawu danych reprezentującego folder, należy zachować ostrożność. Należy się upewnić, że nie będzie żadnych nowych plików przychodzących do folderu między operacją kopiowania a operacją usuwania. Jeśli nowe pliki docierają do folderu w momencie, gdy działanie kopiowania właśnie zakończyło zadanie kopiowania, ale działanie Usuń nie zostało uruchomione, działanie Usuń może usunąć nowo przybywający plik, który nie został jeszcze skopiowany do miejsca docelowego, usuwając cały folder.

Przykładowy potok

{
    "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":[

        ]
    }
}

Przykładowe zestawy danych

Zestaw danych używany przez działanie GetMetadata do wyliczania listy plików.

{
    "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"
                }
            }
        }
    }
}

Zestaw danych dla źródła danych używanego przez działanie kopiowania i działanie Usuwanie.

{
    "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"
                }
            }
        }
    }
}

Zestaw danych dla miejsca docelowego danych używanego przez działanie kopiowania.

{
    "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"
                }
            }
        }
    }
}

Szablon można również pobrać, aby przenieść pliki z tego miejsca.

Znane ograniczenia

  • Działanie usuwania nie obsługuje usuwania listy folderów opisanych za pomocą symboli wieloznacznych.

  • W przypadku używania filtru atrybutów pliku w działaniu usuwania: modifiedDatetimeStart i modifiedDatetimeEnd w celu wybrania plików do usunięcia, upewnij się, że ustawiono również wartość "wildcardFileName": "*" w działaniu usuwania.

Dowiedz się więcej na temat przenoszenia plików w potokach usługi Azure Data Factory i Synapse.