Usuwanie Działania w Azure Data Factory i Azure Synapse Analytics

DOTYCZY: Azure Data Factory Azure Synapse Analytics

Wskazówka

Data Factory w usłudze Microsoft Fabric jest następną generacją Azure Data Factory z prostszą architekturą, wbudowaną sztuczną inteligencją i nowymi funkcjami. Jeśli dopiero zaczynasz integrować dane, zacznij od Fabric Data Factory. Istniejące obciążenia ADF można zaktualizować do Fabric, aby uzyskać dostęp do nowych możliwości w zakresie nauki o danych, analiz w czasie rzeczywistym oraz raportowania.

Funkcja usuwania w Azure Data Factory służy do usuwania plików lub folderów z lokalnych magazynów danych lub magazynów danych 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 miękkie usuwanie). 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 aktywności usuwania 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żeli nie jest już wybrane, oraz jego kartę Źródło, aby edytować 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 kartę ustawień rejestrowania dla aktywności 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 Wymagane
zestaw danych Zawiera odwołanie do zestawu danych w celu określenia, które pliki lub foldery mają zostać usunięte Tak
rekurencyjne Wskazuje, czy pliki są usuwane rekursywnie z podfolderów, czy tylko z określonego folderu. Nr. Wartość domyślna to false.
maksymalnaLiczbaJednoczesnychPołączeń Liczba połączeń do jednoczesnego łączenia się z magazynem w celu usunięcia folderu lub plików. Nr. Wartość domyślna to 1.
włącz rejestrowanie Wskazuje, czy należy zarejestrować usunięty folder lub nazwy plików. Jeśli to prawdziwe, musisz dodatkowo podać konto przestrzeni dyskowej do zapisania pliku dziennika, aby można było śledzić zachowanie działania Delete, odczytując plik dziennika. Nie.
ustawienia magazynowania logów 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 Integration Runtime, który jest używany przez proces usuwania do kasowania plików.
Nie.
ścieżka Dotyczy tylko wtedy, gdy enablelogging = true.

Ścieżka do zapisania pliku dziennika na koncie magazynowym. Jeśli nie podasz ścieżki, usługa sama utworzy kontener dla Ciebie.
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 nazwaPliku rekurencyjne 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

Regularnie czyść folder lub pliki podzielone na przedziały czasowe

Możesz utworzyć pipeline, aby okresowo czyścić foldery lub pliki podzielone według 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ładowa rura

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

Możesz utworzyć pipeline do czyszczenia starych lub wygasłych plików, używając filtru atrybutu pliku: "LastModified" w ramach zestawu danych.

Przykładowa rura

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

Przenieś pliki, łącząc działania Kopiowania i Usuwania.

Plik można przenieść, używając aktywności Kopiuj do skopiowania pliku, a następnie aktywności Usuń do 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łania kopiowania + Działania usunięcia, 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 Copy activity 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ładowa rura

{
    "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 usuwania.

{
    "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 przeznaczenia danych używanego przez operację 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 Azure Data Factory i Synapse.