Planification et exécution avec Data FactoryData Factory scheduling and execution

Notes

Cet article s’applique à la version 1 de Data Factory.This article applies to version 1 of Data Factory. Si vous utilisez la version actuelle du service Data Factory, consultez l’article Exécution et déclencheurs du pipeline dans Azure Data Factory.If you are using the current version of the Data Factory service, see pipeline execution and triggers article.

Cet article explique les aspects de la planification et de l’exécution du modèle d’application Azure Data Factory.This article explains the scheduling and execution aspects of the Azure Data Factory application model. Cet article suppose que vous avez des notions de base sur les concepts de modèle de données Data Factory, dont l’activité, les pipelines, les services connexes et les groupes de données.This article assumes that you understand basics of Data Factory application model concepts, including activity, pipelines, linked services, and datasets. Pour les concepts de base d’Azure Data Factory, consultez les articles suivants :For basic concepts of Azure Data Factory, see the following articles:

Heures de début et de fin de pipelineStart and end times of pipeline

Un pipeline est actif uniquement entre son heure de début et son heure de fin.A pipeline is active only between its start time and end time. Il n'est pas exécuté avant l'heure de début, ni après l'heure de fin.It is not executed before the start time or after the end time. Lorsque le pipeline est suspendu, il n’est pas exécuté, quelle que soit son heure de début et de fin.If the pipeline is paused, it is not executed irrespective of its start and end time. Pour qu'un pipeline soit exécuté, il ne doit pas être suspendu.For a pipeline to run, it should not be paused. Vous trouvez ces paramètres (début, fin, suspendu) dans la définition du pipeline :You find these settings (start, end, paused) in the pipeline definition:

"start": "2017-04-01T08:00:00Z",
"end": "2017-04-01T11:00:00Z"
"isPaused": false

Pour plus d’informations sur ces propriétés, consultez l’article Créer des pipelines.For more information these properties, see create pipelines article.

Spécifier la planification d’une activitéSpecify schedule for an activity

Ce n’est pas le pipeline qui est exécuté.It is not the pipeline that is executed. Ce sont les activités dans le pipeline qui sont exécutées dans le contexte global du pipeline.It is the activities in the pipeline that are executed in the overall context of the pipeline. Vous pouvez planifier l’activité pour qu’elle s’exécute de façon récurrente grâce à la section scheduler (planificateur) de l’activité JSON.You can specify a recurring schedule for an activity by using the scheduler section of activity JSON. Par exemple, vous pouvez planifier l’exécution d’une activité toutes les heures comme suit :For example, you can schedule an activity to run hourly as follows:

"scheduler": {
    "frequency": "Hour",
    "interval": 1
},

Comme illustré dans le diagramme suivant, la définition d’une planification pour une activité crée une série de fenêtres récurrentes dans les heures de début et de fin du pipeline.As shown in the following diagram, specifying a schedule for an activity creates a series of tumbling windows with in the pipeline start and end times. Les fenêtres récurrentes sont une série d’intervalles de temps fixes contigus, qui ne se chevauchent pas.Tumbling windows are a series of fixed-size non-overlapping, contiguous time intervals. Ces fenêtres récurrentes logiques pour une activité sont appelées des fenêtres d’activité.These logical tumbling windows for an activity are called activity windows.

Exemple de planificateur d’activité

La propriété scheduler (planificateur) d’une activité est facultative.The scheduler property for an activity is optional. Si vous définissez cette propriété, elle doit correspondre à la cadence que vous spécifiez dans la définition du jeu de données de sortie pour l’activité.If you do specify this property, it must match the cadence you specify in the definition of output dataset for the activity. Le jeu de données de sortie pilote actuellement la planification.Currently, output dataset is what drives the schedule. Vous devez donc créer un jeu de données de sortie même si l’activité ne génère aucune sortie.Therefore, you must create an output dataset even if the activity does not produce any output.

Spécifier la planification d’un jeu de donnéesSpecify schedule for a dataset

Une activité dans un pipeline Data Factory peut inclure zéro ou plusieurs jeux de données d’entrée et produire un ou plusieurs jeux de données de sortie.An activity in a Data Factory pipeline can take zero or more input datasets and produce one or more output datasets. Pour une activité, vous pouvez spécifier la cadence à laquelle les données d’entrée sont disponibles ou les données de sortie sont produites à l’aide de la section availability (disponibilité) dans les définitions de jeu de données.For an activity, you can specify the cadence at which the input data is available or the output data is produced by using the availability section in the dataset definitions.

La Fréquence dans la section availability (disponibilité) spécifie l’unité de temps.Frequency in the availability section specifies the time unit. Les valeurs de fréquence autorisées sont : Minute, Hour, Day, Week et Month.The allowed values for frequency are: Minute, Hour, Day, Week, and Month. La propriété interval (intervalle) dans la section availability (disponibilité) spécifie un multiplicateur de fréquence.The interval property in the availability section specifies a multiplier for frequency. Par exemple : si la fréquence est définie sur Jour et l’intervalle sur 1 pour un jeu de données de sortie, les données de sortie sont produites chaque jour.For example: if the frequency is set to Day and interval is set to 1 for an output dataset, the output data is produced daily. Si vous définissez la fréquence en minutes, nous vous recommandons de définir l’intervalle sur une valeur au moins égale à 15.If you specify the frequency as minute, we recommend that you set the interval to no less than 15.

Dans l’exemple suivant, les données d’entrée seront disponibles toutes les heures et les données de sortie sont produites toutes les heures ("frequency": "Hour", "interval": 1).In the following example, the input data is available hourly and the output data is produced hourly ("frequency": "Hour", "interval": 1).

Jeu de données d'entrée :Input dataset:

{
    "name": "AzureSqlInput",
    "properties": {
        "published": false,
        "type": "AzureSqlTable",
        "linkedServiceName": "AzureSqlLinkedService",
        "typeProperties": {
            "tableName": "MyTable"
        },
        "availability": {
            "frequency": "Hour",
            "interval": 1
        },
        "external": true,
        "policy": {}
    }
}

Jeu de données de sortieOutput dataset

{
    "name": "AzureBlobOutput",
    "properties": {
        "published": false,
        "type": "AzureBlob",
        "linkedServiceName": "StorageLinkedService",
        "typeProperties": {
            "folderPath": "mypath/{Year}/{Month}/{Day}/{Hour}",
            "format": {
                "type": "TextFormat"
            },
            "partitionedBy": [
                { "name": "Year", "value": { "type": "DateTime", "date": "SliceStart", "format": "yyyy" } },
                { "name": "Month", "value": { "type": "DateTime", "date": "SliceStart", "format": "MM" } },
                { "name": "Day", "value": { "type": "DateTime", "date": "SliceStart", "format": "dd" } },
                { "name": "Hour", "value": { "type": "DateTime", "date": "SliceStart", "format": "HH" }}
            ]
        },
        "availability": {
            "frequency": "Hour",
            "interval": 1
        }
    }
}

Le jeu de données de sortie pilote actuellement la planification.Currently, output dataset drives the schedule. En d’autres termes, la planification spécifiée pour le jeu de données de sortie est utilisée pour exécuter une activité lors de l’exécution.In other words, the schedule specified for the output dataset is used to run an activity at runtime. Vous devez donc créer un jeu de données de sortie même si l’activité ne génère aucune sortie.Therefore, you must create an output dataset even if the activity does not produce any output. Si l’activité ne prend aucune entrée, vous pouvez ignorer la création du jeu de données d’entrée.If the activity doesn't take any input, you can skip creating the input dataset.

Dans la définition de pipeline suivante, la propriété scheduler (planificateur) est utilisée pour spécifier la planification de l’activité.In the following pipeline definition, the scheduler property is used to specify schedule for the activity. Cette propriété est facultative.This property is optional. La planification de l’activité doit actuellement correspondre à la planification spécifiée pour le jeu de données de sortie.Currently, the schedule for the activity must match the schedule specified for the output dataset.

{
    "name": "SamplePipeline",
    "properties": {
        "description": "copy activity",
        "activities": [
            {
                "type": "Copy",
                "name": "AzureSQLtoBlob",
                "description": "copy activity",
                "typeProperties": {
                    "source": {
                        "type": "SqlSource",
                        "sqlReaderQuery": "$$Text.Format('select * from MyTable where timestampcolumn >= \\'{0:yyyy-MM-dd HH:mm}\\' AND timestampcolumn < \\'{1:yyyy-MM-dd HH:mm}\\'', WindowStart, WindowEnd)"
                    },
                    "sink": {
                        "type": "BlobSink",
                        "writeBatchSize": 100000,
                        "writeBatchTimeout": "00:05:00"
                    }
                },
                "inputs": [
                    {
                        "name": "AzureSQLInput"
                    }
                ],
                "outputs": [
                    {
                        "name": "AzureBlobOutput"
                    }
                ],
                "scheduler": {
                    "frequency": "Hour",
                    "interval": 1
                }
            }
        ],
        "start": "2017-04-01T08:00:00Z",
        "end": "2017-04-01T11:00:00Z"
    }
}

Dans cet exemple, l’activité s’exécute toutes les heures entre les heures de début et de fin du pipeline.In this example, the activity runs hourly between the start and end times of the pipeline. Les données de sortie sont produites toutes les heures pour des trois fenêtres de temps (8h-9h, 9h-10h et 10h-11h).The output data is produced hourly for three-hour windows (8 AM - 9 AM, 9 AM - 10 AM, and 10 AM - 11 AM).

Chaque unité de données consommée ou produite pendant l’exécution d’une activité est appelée tranche de données.Each unit of data consumed or produced by an activity run is called a data slice. Le diagramme suivant illustre un exemple d’une activité avec un jeu de données d’entrée et un jeu de données de sortie :The following diagram shows an example of an activity with one input dataset and one output dataset:

Planificateur de disponibilité

Les tranches de données recueillies toutes les heures pour le jeu de données d’entrée et de sortie sont affichées dans le diagramme.The diagram shows the hourly data slices for the input and output dataset. Le diagramme illustre trois tranches d’entrée qui sont prêtes pour le traitement.The diagram shows three input slices that are ready for processing. L’activité de 10 à 11 h est en cours, et produit la tranche de sortie de 10 à 11 h.The 10-11 AM activity is in progress, producing the 10-11 AM output slice.

Vous pouvez accéder à l’intervalle de temps associé à la tranche actuelle dans le jeu de données JSON à l’aide des variables SliceStart et SliceEnd.You can access the time interval associated with the current slice in the dataset JSON by using variables: SliceStart and SliceEnd. De même, vous pouvez accéder à l’intervalle de temps associé à une fenêtre d’activité à l’aide des variables WindowStart et WindowEnd.Similarly, you can access the time interval associated with an activity window by using the WindowStart and WindowEnd. La planification d’une activité doit correspondre à la planification du jeu de données de sortie pour l’activité.The schedule of an activity must match the schedule of the output dataset for the activity. Par conséquent, les valeurs SliceStart et SliceEnd sont identiques aux valeurs WindowStart et WindowEnd, respectivement.Therefore, the SliceStart and SliceEnd values are the same as WindowStart and WindowEnd values respectively. Pour plus d’informations sur ces variables, consultez les articles Variables système et fonctions Data Factory.For more information on these variables, see Data Factory functions and system variables articles.

Vous pouvez utiliser ces variables à différentes fins dans votre activité JSON.You can use these variables for different purposes in your activity JSON. Par exemple, vous pouvez les utiliser pour sélectionner les données à partir des jeux de données d’entrée et de sortie représentant les données de série chronologique (par exemple : entre 8h et 9h).For example, you can use them to select data from input and output datasets representing time series data (for example: 8 AM to 9 AM). Cet exemple utilise également WindowStart et WindowEnd pour sélectionner les données pertinentes pour l’exécution d’une activité et les copier sur un objet Blob avec le bon folderPath.This example also uses WindowStart and WindowEnd to select relevant data for an activity run and copy it to a blob with the appropriate folderPath. folderPath est paramétré pour avoir un dossier distinct pour chaque heure.The folderPath is parameterized to have a separate folder for every hour.

Dans l’exemple précédent, la planification spécifiée pour les jeux de données d’entrée et de sortie est la même (toutes les heures).In the preceding example, the schedule specified for input and output datasets is the same (hourly). Si le jeu de données d’entrée de l’activité est disponible à une fréquence différente, par exemple toutes les 15 minutes, l’activité qui produit ce jeu de données de sortie est toujours exécutée une fois par heure car le jeu de données de sortie pilote la planification de l’activité.If the input dataset for the activity is available at a different frequency, say every 15 minutes, the activity that produces this output dataset still runs once an hour as the output dataset is what drives the activity schedule. Pour plus d’informations, consultez Modélisation des jeux de données avec des fréquences différentes.For more information, see Model datasets with different frequencies.

Disponibilité et stratégies du jeu de donnéesDataset availability and policies

Vous avez vu l’utilisation des propriétés de fréquence et d’intervalle de la section availability (disponibilité) de la définition du jeu de données.You have seen the usage of frequency and interval properties in the availability section of dataset definition. D’autres propriétés affectent la planification et l’exécution d’une activité.There are a few other properties that affect the scheduling and execution of an activity.

Disponibilité du jeu de donnéesDataset availability

Le tableau suivant décrit les propriétés que vous pouvez utiliser dans la section availability :The following table describes properties you can use in the availability section:

PropriétéProperty DescriptionDescription ObligatoireRequired DefaultDefault
frequencyfrequency Spécifie l’unité de temps pour la production du segment du jeu de données.Specifies the time unit for dataset slice production.

Fréquence prise en charge : Minute, Hour, Day, Week, MonthSupported frequency: Minute, Hour, Day, Week, Month
OUIYes N/DNA
intervalinterval Spécifie un multiplicateur de fréquenceSpecifies a multiplier for frequency

«Frequency» et «interval» déterminent la fréquence à laquelle la tranche est produite.”Frequency x interval” determines how often the slice is produced.

Si vous voulez des tranches de jeu de données d’une heure, définissez frequency sur Hour et interval sur 1.If you need the dataset to be sliced on an hourly basis, you set Frequency to Hour, and interval to 1.

Remarque: Si vous définissez la fréquence en minutes, nous vous recommandons de définir l’intervalle sur une valeur au moins égale à 15.Note: If you specify Frequency as Minute, we recommend that you set the interval to no less than 15
OUIYes N/DNA
stylestyle Spécifie si le segment doit être généré au début / à la fin de l’intervalle.Specifies whether the slice should be produced at the start/end of the interval.
  • StartOfIntervalStartOfInterval
  • EndOfIntervalEndOfInterval


Si la fréquence est définie sur Month et le style défini sur EndOfInterval, le segment est généré le dernier jour du mois.If Frequency is set to Month and style is set to EndOfInterval, the slice is produced on the last day of month. Si le style est défini sur StartOfInterval, le segment est généré le premier jour du mois.If the style is set to StartOfInterval, the slice is produced on the first day of month.

Si la fréquence est définie sur Day et le style défini sur EndOfInterval, le segment est généré la dernière heure du jour.If Frequency is set to Day and style is set to EndOfInterval, the slice is produced in the last hour of the day.

Si la fréquence est définie sur Hour et le style défini sur EndOfInterval, le segment est généré à la fin de l’heure.If Frequency is set to Hour and style is set to EndOfInterval, the slice is produced at the end of the hour. Par exemple, pour un segment de la période 13 h-14 h, le segment est généré à 14 h.For example, for a slice for 1 PM – 2 PM period, the slice is produced at 2 PM.
NonNo EndOfIntervalEndOfInterval
anchorDateTimeanchorDateTime Définit la position absolue dans le temps utilisée par le planificateur pour calculer les limites de tranche de jeu de données.Defines the absolute position in time used by scheduler to compute dataset slice boundaries.

Remarque: Si AnchorDateTime contient des éléments de date plus précis que la fréquence, ces éléments plus précis sont ignorés.Note: If the AnchorDateTime has date parts that are more granular than the frequency then the more granular parts are ignored.

Par exemple, si interval est hourly (frequency: hour et interval: 1), et que AnchorDateTime contient minutes and seconds, les éléments minutes et seconds d’AnchorDateTime sont ignorés.For example, if the interval is hourly (frequency: hour and interval: 1) and the AnchorDateTime contains minutes and seconds, then the minutes and seconds parts of the AnchorDateTime are ignored.
NonNo 01/01/000101/01/0001
Offsetoffset Intervalle de temps marquant le déplacement du début et de la fin de toutes les tranches du jeu de données.Timespan by which the start and end of all dataset slices are shifted.

Remarque: Si anchorDateTime et offset sont spécifiés, on obtient un décalage combiné.Note: If both anchorDateTime and offset are specified, the result is the combined shift.
NonNo N/DNA

exemple offsetoffset example

Par défaut, les tranches quotidiennes ("frequency": "Day", "interval": 1) commencent à 0 h UTC (minuit).By default, daily ("frequency": "Day", "interval": 1) slices start at 12 AM UTC time (midnight). Si vous souhaitez que l’heure de début soit 6 h UTC, définissez le décalage comme indiqué dans l’extrait suivant :If you want the start time to be 6 AM UTC time instead, set the offset as shown in the following snippet:

"availability":
{
    "frequency": "Day",
    "interval": 1,
    "offset": "06:00:00"
}

Exemple anchorDateTimeanchorDateTime example

Dans l’exemple suivant, le jeu de données est généré toutes les 23 heures.In the following example, the dataset is produced once every 23 hours. La première tranche commence à l’heure spécifiée par anchorDateTime, qui est défini sur 2017-04-19T08:00:00 (heure UTC).The first slice starts at the time specified by the anchorDateTime, which is set to 2017-04-19T08:00:00 (UTC time).

"availability":    
{    
    "frequency": "Hour",        
    "interval": 23,    
    "anchorDateTime":"2017-04-19T08:00:00"    
}

Exemple de décalage/styleoffset/style Example

Le jeu de données suivant est un jeu de données mensuel et est généré le 3 de chaque mois à 8h00 (3.08:00:00) :The following dataset is a monthly dataset and is produced on 3rd of every month at 8:00 AM (3.08:00:00):

"availability": {
    "frequency": "Month",
    "interval": 1,
    "offset": "3.08:00:00", 
    "style": "StartOfInterval"
}

Stratégie du jeu de donnéesDataset policy

Un jeu de données peut avoir une stratégie de validation définie qui spécifie comment les données générées par l’exécution d’une tranche peuvent être validées avant qu’il soit prêt à la consommation.A dataset can have a validation policy defined that specifies how the data generated by a slice execution can be validated before it is ready for consumption. Dans ce cas, une fois que la tranche a terminé l’exécution, l’état de la tranche de sortie devient En attente avec un sous-état Validation.In such cases, after the slice has finished execution, the output slice status is changed to Waiting with a substatus of Validation. Une fois les tranches validées, l’état de la tranche passe à prêt.After the slices are validated, the slice status changes to Ready. Si une tranche de données a été générée mais n’a pas réussi la validation, l’activité s’exécute pour les tranches en aval dépendant de cette tranche qui ne sont pas traitées.If a data slice has been produced but did not pass the validation, activity runs for downstream slices that depend on this slice are not processed. Surveiller et gérer les pipelines .Monitor and manage pipelines covers the various states of data slices in Data Factory.

La section policy de la définition du jeu de données définit les critères ou la condition que les segments du jeu de données doivent remplir.The policy section in dataset definition defines the criteria or the condition that the dataset slices must fulfill. Le tableau suivant décrit les propriétés que vous pouvez utiliser dans la section policy (stratégie) :The following table describes properties you can use in the policy section:

Nom de la stratégiePolicy Name DescriptionDescription Appliqué(e) àApplied To ObligatoireRequired DefaultDefault
minimumSizeMBminimumSizeMB Valide le fait que les données dans un objet blob Azure répondent aux exigences de taille minimale (en mégaoctets).Validates that the data in an Azure blob meets the minimum size requirements (in megabytes). objet blob AzureAzure Blob NonNo N/DNA
minimumRowsminimumRows Valide le fait que les données dans une base de données Azure SQL ou une table Azure contiennent le nombre minimal de lignes.Validates that the data in an Azure SQL database or an Azure table contains the minimum number of rows.
  • Azure SQL DatabaseAzure SQL Database
  • table AzureAzure Table
NonNo N/DNA

ExemplesExamples

minimumSizeMB :minimumSizeMB:

"policy":

{
    "validation":
    {
        "minimumSizeMB": 10.0
    }
}

minimumRowsminimumRows

"policy":
{
    "validation":
    {
        "minimumRows": 100
    }
}

Pour plus d’informations sur ces propriétés et exemples, consultez l’article Créer des jeux de données.For more information about these properties and examples, see Create datasets article.

Stratégies d’activitéActivity policies

Les stratégies affectent le comportement d'exécution d'une activité, en particulier lors du traitement du segment d'une table.Policies affect the run-time behavior of an activity, specifically when the slice of a table is processed. Le tableau suivant fournit les détails.The following table provides the details.

PropriétéProperty Valeurs autoriséesPermitted values Valeur par défautDefault Value DescriptionDescription
accès concurrentielconcurrency EntierInteger

Valeur maximale : 10Max value: 10
11 Nombre d’exécutions simultanées de l’activité.Number of concurrent executions of the activity.

Il détermine le nombre d’exécutions en parallèle de l’activité qui peuvent se produire sur différents segments.It determines the number of parallel activity executions that can happen on different slices. Par exemple, si une activité doit passer par un grand ensemble de données disponibles, une valeur de concurrence plus élevée accélère le traitement des données.For example, if an activity needs to go through a large set of available data, having a larger concurrency value speeds up the data processing.
executionPriorityOrderexecutionPriorityOrder NewestFirstNewestFirst

OldestFirstOldestFirst
OldestFirstOldestFirst Détermine l’ordre des segments de données qui sont traités.Determines the ordering of data slices that are being processed.

Par exemple, si vous avez 2 segments (l’un se produisant à 16 heures et l’autre à 17 heures) et que les deux sont en attente d’exécution.For example, if you have 2 slices (one happening at 4pm, and another one at 5pm), and both are pending execution. Si vous définissez executionPriorityOrder sur NewestFirst, le segment à 17 h est traité en premier.If you set the executionPriorityOrder to be NewestFirst, the slice at 5 PM is processed first. De même, si vous définissez executionPriorityOrder sur OldestFIrst, le segment à 16 h est traité en premier.Similarly if you set the executionPriorityORder to be OldestFIrst, then the slice at 4 PM is processed.
retryretry EntierInteger

La valeur max peut être 10Max value can be 10
00 Nombre de nouvelles tentatives avant que le traitement des données du segment ne soit marqué comme un échec.Number of retries before the data processing for the slice is marked as Failure. L'exécution de l'activité pour un segment de données est répétée jusqu'au nombre de tentatives spécifié.Activity execution for a data slice is retried up to the specified retry count. La nouvelle tentative est effectuée dès que possible après l'échec.The retry is done as soon as possible after the failure.
timeouttimeout TimeSpanTimeSpan 00:00:0000:00:00 Délai d'expiration de l'activité.Timeout for the activity. Exemple : 00:10:00 (implique un délai d’expiration de 10 minutes)Example: 00:10:00 (implies timeout 10 mins)

Si une valeur n’est pas spécifiée ou est égale à 0, le délai d’expiration est infini.If a value is not specified or is 0, the timeout is infinite.

Si le temps de traitement des données sur un segment dépasse la valeur du délai d’expiration, il est annulé et le système tente de réexécuter le traitement.If the data processing time on a slice exceeds the timeout value, it is canceled, and the system attempts to retry the processing. Le nombre de nouvelles tentatives dépend de la propriété « retry ».The number of retries depends on the retry property. Quand le délai d’expiration est atteint, l’état est défini sur TimedOut.When timeout occurs, the status is set to TimedOut.
delaydelay TimeSpanTimeSpan 00:00:0000:00:00 Spécifie le délai avant le début du traitement des données du segment.Specify the delay before data processing of the slice starts.

L’exécution d’activité pour une tranche de données est démarrée une fois que le délai a dépassé l’heure d’exécution prévue.The execution of activity for a data slice is started after the Delay is past the expected execution time.

Exemple : 00:10:00 (implique un délai de 10 minutes)Example: 00:10:00 (implies delay of 10 mins)
longRetrylongRetry EntierInteger

Valeur maximale : 10Max value: 10
11 Le nombre de nouvelles tentatives longues avant l’échec de l’exécution du segment.The number of long retry attempts before the slice execution is failed.

Les tentatives longRetry sont espacées par longRetryInterval.longRetry attempts are spaced by longRetryInterval. Par conséquent, si vous devez spécifier un délai entre chaque tentative, utilisez longRetry.So if you need to specify a time between retry attempts, use longRetry. Si les valeurs Retry et longRetry sont spécifiées, chaque tentative longRetry inclut des tentatives Retry et le nombre maximal de tentatives sera égal à Retry * longRetry.If both Retry and longRetry are specified, each longRetry attempt includes Retry attempts and the max number of attempts is Retry * longRetry.

Par exemple, si nous avons les paramètres suivants dans la stratégie de l’activité :For example, if we have the following settings in the activity policy:
Retry : 3Retry: 3
longRetry : 2longRetry: 2
longRetryInterval : 01:00:00longRetryInterval: 01:00:00

Supposons qu’il existe un seul segment à exécuter (dont l’état est Waiting) et que l’exécution de l’activité échoue à chaque fois.Assume there is only one slice to execute (status is Waiting) and the activity execution fails every time. Au départ, il y aurait 3 tentatives consécutives d'exécution.Initially there would be 3 consecutive execution attempts. Après chaque tentative, l’état du segment serait Retry.After each attempt, the slice status would be Retry. Une fois les 3 premières tentatives terminées, l’état du segment serait LongRetry.After first 3 attempts are over, the slice status would be LongRetry.

Après une heure (c’est-à-dire la valeur de longRetryInterval), il y aurait un autre ensemble de 3 tentatives consécutives d’exécution.After an hour (that is, longRetryInteval’s value), there would be another set of 3 consecutive execution attempts. Ensuite, l'état du segment serait Failed et aucune autre tentative ne serait exécutée.After that, the slice status would be Failed and no more retries would be attempted. Par conséquent, 6 tentatives ont été exécutées.Hence overall 6 attempts were made.

Si une exécution réussit, l’état de la tranche est Ready et aucune nouvelle tentative n’est tentée.If any execution succeeds, the slice status would be Ready and no more retries are attempted.

La valeur longRetry peut être utilisée dans les situations où les données dépendantes arrivent à des moments non déterministes ou lorsque l’environnement global où le traitement des données se produit est douteux.longRetry may be used in situations where dependent data arrives at non-deterministic times or the overall environment is flaky under which data processing occurs. Dans ces cas, l’exécution de nouvelles tentatives l’une après l’autre peut ne pas être utile et procéder ainsi après un intervalle de temps précis produit la sortie désirée.In such cases, doing retries one after another may not help and doing so after an interval of time results in the desired output.

Mise en garde : ne définissez pas de valeurs élevées pour longRetry ou longRetryInterval.Word of caution: do not set high values for longRetry or longRetryInterval. En règle générale, des valeurs plus élevées impliquent d’autres problèmes systémiques.Typically, higher values imply other systemic issues.
longRetryIntervallongRetryInterval TimeSpanTimeSpan 00:00:0000:00:00 Le délai entre les nouvelles tentatives longuesThe delay between long retry attempts

Pour plus d’informations, consultez l’article Pipelines.For more information, see Pipelines article.

Traitement en parallèle des tranches de donnéesParallel processing of data slices

Vous pouvez définir la date de début du pipeline dans le passé.You can set the start date for the pipeline in the past. Lorsque vous procédez ainsi, Data Factory calcule (remplit postérieurement) automatiquement toutes les tranches de données dans le passé automatiquement et commence à les traiter.When you do so, Data Factory automatically calculates (back fills) all data slices in the past and begins processing them. Par exemple : si vous créez un pipeline avec la date de début 2017-04-01 et que la date actuelle est 2017-04-10.For example: if you create a pipeline with start date 2017-04-01 and the current date is 2017-04-10. Si la cadence du jeu de données de sortie est tous les jours, Data Factory commence immédiatement le traitement de toutes les tranches entre le 2017-04-01 et le 2017-04-09, car la date de début se situe dans le passé.If the cadence of the output dataset is daily, then Data Factory starts processing all the slices from 2017-04-01 to 2017-04-09 immediately because the start date is in the past. La tranche du 2017-04-10 n’est pas encore traitée, car la valeur de la propriété style dans la section availability (disponibilité) est EndOfInterval par défaut.The slice from 2017-04-10 is not processed yet because the value of style property in the availability section is EndOfInterval by default. La tranche la plus ancienne est traitée en premier, car la valeur par défaut de executionPriorityOrder est OldestFirst.The oldest slice is processed first as the default value of executionPriorityOrder is OldestFirst. Pour obtenir une description de la propriété style, consultez la section Disponibilité du jeu de données.For a description of the style property, see dataset availability section. Pour obtenir une description de la section executionPriorityOrder, consultez la section Stratégies d’activité.For a description of the executionPriorityOrder section, see the activity policies section.

Vous pouvez configurer des tranches de données pour qu’elles soient traitées en parallèle en définissant la propriété concurrency (concurrence) dans la section policy (stratégie) de l’activité JSON.You can configure back-filled data slices to be processed in parallel by setting the concurrency property in the policy section of the activity JSON. Cette propriété détermine le nombre d’exécutions en parallèle de l’activité qui peuvent se produire sur différents segments.This property determines the number of parallel activity executions that can happen on different slices. La valeur par défaut de la propriété de concurrence est 1.The default value for the concurrency property is 1. Une tranche est donc traitée à la fois par défaut.Therefore, one slice is processed at a time by default. La valeur maximale est 10.The maximum value is 10. Lorsqu’un pipeline doit passer par un grand ensemble de données disponibles, une valeur de concurrence plus élevée accélère le traitement des données.When a pipeline needs to go through a large set of available data, having a larger concurrency value speeds up the data processing.

Réexécuter une tranche de données ayant échouéRerun a failed data slice

Lorsqu’une erreur se produit pendant le traitement d’une tranche de données, vous pouvez savoir pourquoi le traitement d’une tranche a échoué à l’aide de panneaux du portail Azure ou de l’application Surveiller et gérer.When an error occurs while processing a data slice, you can find out why the processing of a slice failed by using Azure portal blades or Monitor and Manage App. Pour plus d’informations, consultez Surveillance et gestion des pipelines à l’aide des panneaux du portail Azure ou de l’application Surveillance et gestion.See Monitoring and managing pipelines using Azure portal blades or Monitoring and Management app for details.

Prenons l’exemple suivant, il montre les deux activités.Consider the following example, which shows two activities. Activity1 et Activity2.Activity1 and Activity 2. Activity1 utilise une tranche de Dataset1 et génère une tranche de Dataset2, qui est utilisé en entrée par Activity2 pour produire une tranche du jeu de données final.Activity1 consumes a slice of Dataset1 and produces a slice of Dataset2, which is consumed as an input by Activity2 to produce a slice of the Final Dataset.

Tranche de données ayant échoué

Le diagramme montre que, parmi les trois tranches récentes, il y a eu un échec, ce qui a généré une tranche 9 à 10 h pour Dataset2.The diagram shows that out of three recent slices, there was a failure producing the 9-10 AM slice for Dataset2. Data Factory effectue automatiquement le suivi de la dépendance du jeu de données.Data Factory automatically tracks dependency for the time series dataset. Par conséquent, il ne lance pas l’activité sur la tranche 9 à 10 h en aval.As a result, it does not start the activity run for the 9-10 AM downstream slice.

Les outils de supervision et de gestion Data Factory vous permettent d’examiner en détail les journaux de diagnostic pour la tranche ayant échoué, et de trouver facilement la cause du problème pour le régler.Data Factory monitoring and management tools allow you to drill into the diagnostic logs for the failed slice to easily find the root cause for the issue and fix it. Une fois le problème résolu, vous pouvez facilement lancer l’exécution de l’activité afin de générer la tranche ayant échoué.After you have fixed the issue, you can easily start the activity run to produce the failed slice. Pour plus d’informations sur la façon de lancer les réexécutions et comprendre les transitions d’état des tranches de données, consultez Surveillance et gestion des pipelines à l’aide des panneaux du portail Azure ou Application de surveillance et gestion.For more information on how to rerun and understand state transitions for data slices, see Monitoring and managing pipelines using Azure portal blades or Monitoring and Management app.

Une fois que vous avez relancé l’exécution de la tranche de 9-10 h pour Dataset2, Data Factory lance l’exécution de la tranche dépendante 9 à 10 h sur un jeu de données final.After you rerun the 9-10 AM slice for Dataset2, Data Factory starts the run for the 9-10 AM dependent slice on the final dataset.

Réexécuter une tranche de données ayant échoué

Plusieurs activités à l’intérieur d’un pipelineMultiple activities in a pipeline

Un pipeline peut toutefois contenir plusieurs activités.You can have more than one activity in a pipeline. Si vous avez plusieurs activités dans un pipeline et que la sortie d’une activité n’est pas une entrée dans une autre activité, les activités peuvent s’exécuter en parallèle si les tranches de données d’entrée pour les activités sont prêtes.If you have multiple activities in a pipeline and the output of an activity is not an input of another activity, the activities may run in parallel if input data slices for the activities are ready.

Vous pouvez chaîner deux activités (une après l’autre) en configurant le jeu de données de sortie d’une activité en tant que jeu de données d’entrée de l’autre activité.You can chain two activities (run one activity after another) by setting the output dataset of one activity as the input dataset of the other activity. Les activités peuvent être dans le même pipeline ou dans des pipelines différents.The activities can be in the same pipeline or in different pipelines. La seconde activité s’exécute uniquement quand la première se termine correctement.The second activity executes only when the first one finishes successfully.

Par exemple, considérez le cas suivant, dans lequel un pipeline a deux activités :For example, consider the following case where a pipeline has two activities:

  1. L’activité A1 nécessitant le jeu de données d’entrée externe D1 et qui produit le jeu de données de sortie D2.Activity A1 that requires external input dataset D1, and produces output dataset D2.
  2. L’activité A2 nécessitant le jeu de données d’entrée D2 et qui produit le jeu de données de sortie D3.Activity A2 that requires input from dataset D2, and produces output dataset D3.

Dans ce scénario, les activités A1 et A2 sont dans le même pipeline.In this scenario, activities A1 and A2 are in the same pipeline. L’activité A1 s’exécute lorsque les données externes seront disponibles et que la fréquence de disponibilité planifiée sera atteinte.The activity A1 runs when the external data is available and the scheduled availability frequency is reached. L’activité A2 s’exécute lorsque les tranches planifiées de D2 seront disponibles et que la fréquence de disponibilité planifiée sera atteinte.The activity A2 runs when the scheduled slices from D2 become available and the scheduled availability frequency is reached. S’il existe une erreur dans l’une des tranches du jeu de données D2, A2 n’est pas exécutée pour cette tranche jusqu’à ce que celle-ci devienne disponible.If there is an error in one of the slices in dataset D2, A2 does not run for that slice until it becomes available.

La vue de diagramme avec les deux activités dans le même pipeline se présente comme dans le diagramme suivant :The Diagram view with both activities in the same pipeline would look like the following diagram:

Chaînage des activités dans le même pipeline

Comme mentionné plus tôt, les activités peuvent être dans des pipelines différents.As mentioned earlier, the activities could be in different pipelines. Dans ce scénario, la vue de diagramme se présente comme dans le diagramme suivant :In such a scenario, the diagram view would look like the following diagram:

Chaînage des activités dans deux pipelines

Consultez la section Copier de manière séquentielle de l'annexe pour obtenir un exemple.See the copy sequentially section in the appendix for an example.

Modélisation des jeux de données avec des fréquences différentesModel datasets with different frequencies

Dans les exemples, les fréquences de planification des jeux de données d’entrée et de sortie et l’intervalle d’activité sont les mêmes.In the samples, the frequencies for input and output datasets and the activity schedule window were the same. Certains scénarios exigent que la fréquence de génération d’une sortie à soit différente de celles d’une ou de plusieurs entrées.Some scenarios require the ability to produce output at a frequency different than the frequencies of one or more inputs. Data factory prend en charge la modélisation de ces scénarios.Data Factory supports modeling these scenarios.

Exemple 1 : production d’un rapport de sortie quotidien pour des données d’entrée disponibles toutes les heuresSample 1: Produce a daily output report for input data that is available every hour

Imaginez un scénario dans lequel nous avons entré des données de mesure à partir de capteurs disponibles toutes les heures dans un stockage Azure Blob.Consider a scenario in which you have input measurement data from sensors available every hour in Azure Blob storage. Vous voulez générer un rapport d’agrégation quotidien avec des statistiques, comme les valeurs moyenne, maximum et minimum pour la journée avec une Activité Hive Data Factory.You want to produce a daily aggregate report with statistics such as mean, maximum, and minimum for the day with Data Factory hive activity.

Voici ce que vous pouvez modéliser ce scénario avec data factory :Here is how you can model this scenario with Data Factory:

Jeu de données d'entréeInput dataset

Les fichiers d’entrée des heures sont supprimés dans le dossier pour le jour donné.The hourly input files are dropped in the folder for the given day. La disponibilité de l’entrée est définie sur Hour (frequency: Hour, interval: 1).Availability for input is set at Hour (frequency: Hour, interval: 1).

{
  "name": "AzureBlobInput",
  "properties": {
    "type": "AzureBlob",
    "linkedServiceName": "StorageLinkedService",
    "typeProperties": {
      "folderPath": "mycontainer/myfolder/{Year}/{Month}/{Day}/",
      "partitionedBy": [
        { "name": "Year", "value": {"type": "DateTime","date": "SliceStart","format": "yyyy"}},
        { "name": "Month","value": {"type": "DateTime","date": "SliceStart","format": "MM"}},
        { "name": "Day","value": {"type": "DateTime","date": "SliceStart","format": "dd"}}
      ],
      "format": {
        "type": "TextFormat"
      }
    },
    "external": true,
    "availability": {
      "frequency": "Hour",
      "interval": 1
    }
  }
}

Jeu de données de sortieOutput dataset

Un fichier de sortie est créé chaque jour dans le dossier pour la journée.One output file is created every day in the day's folder. La disponibilité de sortie est définie sur Day (frequency: Day et interval: 1).Availability of output is set at Day (frequency: Day and interval: 1).

{
  "name": "AzureBlobOutput",
  "properties": {
    "type": "AzureBlob",
    "linkedServiceName": "StorageLinkedService",
    "typeProperties": {
      "folderPath": "mycontainer/myfolder/{Year}/{Month}/{Day}/",
      "partitionedBy": [
        { "name": "Year", "value": {"type": "DateTime","date": "SliceStart","format": "yyyy"}},
        { "name": "Month","value": {"type": "DateTime","date": "SliceStart","format": "MM"}},
        { "name": "Day","value": {"type": "DateTime","date": "SliceStart","format": "dd"}}
      ],
      "format": {
        "type": "TextFormat"
      }
    },
    "availability": {
      "frequency": "Day",
      "interval": 1
    }
  }
}

Activité : activité Hive dans un pipelineActivity: hive activity in a pipeline

Le script Hive reçoit les informations de DateTime en tant que paramètres qui utilisent la variable WindowStart comme indiqué dans l’extrait de code suivant.The hive script receives the appropriate DateTime information as parameters that use the WindowStart variable as shown in the following snippet. Le script Hive utilise cette variable pour charger les données à partir du dossier correspondant à la journée et exécuter l’agrégation pour générer la sortie.The hive script uses this variable to load the data from the correct folder for the day and run the aggregation to generate the output.

{  
    "name":"SamplePipeline",
    "properties":{  
    "start":"2015-01-01T08:00:00",
    "end":"2015-01-01T11:00:00",
    "description":"hive activity",
    "activities": [
        {
            "name": "SampleHiveActivity",
            "inputs": [
                {
                    "name": "AzureBlobInput"
                }
            ],
            "outputs": [
                {
                    "name": "AzureBlobOutput"
                }
            ],
            "linkedServiceName": "HDInsightLinkedService",
            "type": "HDInsightHive",
            "typeProperties": {
                "scriptPath": "adftutorial\\hivequery.hql",
                "scriptLinkedService": "StorageLinkedService",
                "defines": {
                    "Year": "$$Text.Format('{0:yyyy}',WindowStart)",
                    "Month": "$$Text.Format('{0:MM}',WindowStart)",
                    "Day": "$$Text.Format('{0:dd}',WindowStart)"
                }
            },
            "scheduler": {
                "frequency": "Day",
                "interval": 1
            },            
            "policy": {
                "concurrency": 1,
                "executionPriorityOrder": "OldestFirst",
                "retry": 2,
                "timeout": "01:00:00"
            }
         }
     ]
   }
}

Le diagramme suivant illustre le scénario du point de vue de la dépendance des données.The following diagram shows the scenario from a data-dependency point of view.

Dépendance des données

La tranche de sortie dépend des 24 tranches horaires depuis l’ensemble de données en entrée.The output slice for every day depends on 24 hourly slices from an input dataset. Data Factory calcule automatiquement ces dépendances en déterminant les tranches de données d’entrée qui tombent dans la même période que la tranche de données à générer.Data Factory computes these dependencies automatically by figuring out the input data slices that fall in the same time period as the output slice to be produced. Si une des 24 tranches d’entrée n’est pas disponible, Data Factory attend que la tranche d’entrée soit prête avant de lancer l’exécution d’activité quotidienne.If any of the 24 input slices is not available, Data Factory waits for the input slice to be ready before starting the daily activity run.

Exemple 2 : spécifier les dépendances avec des expressions et des fonctions Data FactorySample 2: Specify dependency with expressions and Data Factory functions

Prenons en compte un autre scénario.Let’s consider another scenario. Supposez que vous avez une activité Hive qui traite deux jeux de données d’entrée.Suppose you have a hive activity that processes two input datasets. Un d’eux a de nouvelles données tous les jours, mais l’autre obtient de nouvelles données toutes les semaines.One of them has new data daily, but one of them gets new data every week. Supposons que vous vouliez faire la jonction entre les deux entrées et générer une sortie quotidiennement.Suppose you wanted to do a join across the two inputs and produce an output every day.

L’approche simple consistant pour Data Factory à déterminer des tranches d’entrée appropriées à traiter en alignant la période de temps de la tranche de données en sortie ne fonctionne plus.The simple approach in which Data Factory automatically figures out the right input slices to process by aligning to the output data slice’s time period does not work.

Vous devez spécifier (pour chaque exécution d’activité que Data Factory doit utiliser) les tranches de données de la semaine précédente pour les jeux de données d’entrée.You must specify that for every activity run, the Data Factory should use last week’s data slice for the weekly input dataset. Vous utilisez les fonctions Azure Data Factory comme indiqué dans l’extrait de code suivant pour implémenter ce comportement.You use Azure Data Factory functions as shown in the following snippet to implement this behavior.

Entrée1 : objet blob AzureInput1: Azure blob

La première entrée est l’objet Azure Blob mis à jour quotidiennement.The first input is the Azure blob being updated daily.

{
  "name": "AzureBlobInputDaily",
  "properties": {
    "type": "AzureBlob",
    "linkedServiceName": "StorageLinkedService",
    "typeProperties": {
      "folderPath": "mycontainer/myfolder/{Year}/{Month}/{Day}/",
      "partitionedBy": [
        { "name": "Year", "value": {"type": "DateTime","date": "SliceStart","format": "yyyy"}},
        { "name": "Month","value": {"type": "DateTime","date": "SliceStart","format": "MM"}},
        { "name": "Day","value": {"type": "DateTime","date": "SliceStart","format": "dd"}}
      ],
      "format": {
        "type": "TextFormat"
      }
    },
    "external": true,
    "availability": {
      "frequency": "Day",
      "interval": 1
    }
  }
}

Entrée2 : objet blob AzureInput2: Azure blob

Entrée2 est l’objet Azure Blob mis à jour chaque semaine.Input2 is the Azure blob being updated weekly.

{
  "name": "AzureBlobInputWeekly",
  "properties": {
    "type": "AzureBlob",
    "linkedServiceName": "StorageLinkedService",
    "typeProperties": {
      "folderPath": "mycontainer/myfolder/{Year}/{Month}/{Day}/",
      "partitionedBy": [
        { "name": "Year", "value": {"type": "DateTime","date": "SliceStart","format": "yyyy"}},
        { "name": "Month","value": {"type": "DateTime","date": "SliceStart","format": "MM"}},
        { "name": "Day","value": {"type": "DateTime","date": "SliceStart","format": "dd"}}
      ],
      "format": {
        "type": "TextFormat"
      }
    },
    "external": true,
    "availability": {
      "frequency": "Day",
      "interval": 7
    }
  }
}

Sortie : objet blob AzureOutput: Azure blob

Un fichier de sortie est créé chaque jour dans le dossier pour la journée.One output file is created every day in the folder for the day. La disponibilité de sortie est définie sur day (frequency: Day, interval: 1).Availability of output is set to day (frequency: Day, interval: 1).

{
  "name": "AzureBlobOutputDaily",
  "properties": {
    "type": "AzureBlob",
    "linkedServiceName": "StorageLinkedService",
    "typeProperties": {
      "folderPath": "mycontainer/myfolder/{Year}/{Month}/{Day}/",
      "partitionedBy": [
        { "name": "Year", "value": {"type": "DateTime","date": "SliceStart","format": "yyyy"}},
        { "name": "Month","value": {"type": "DateTime","date": "SliceStart","format": "MM"}},
        { "name": "Day","value": {"type": "DateTime","date": "SliceStart","format": "dd"}}
      ],
      "format": {
        "type": "TextFormat"
      }
    },
    "availability": {
      "frequency": "Day",
      "interval": 1
    }
  }
}

Activité : activité Hive dans un pipelineActivity: hive activity in a pipeline

L’activité Hive accepte les deux entrées et génère une tranche de sortie tous les jours.The hive activity takes the two inputs and produces an output slice every day. Vous pouvez spécifier la tranche de sortie de tous les jours dépendant de la tranche de semaine précédente pour la sortie hebdomadaire comme suit.You can specify every day’s output slice to depend on the previous week’s input slice for weekly input as follows.

{  
    "name":"SamplePipeline",
    "properties":{  
    "start":"2015-01-01T08:00:00",
    "end":"2015-01-01T11:00:00",
    "description":"hive activity",
    "activities": [
      {
        "name": "SampleHiveActivity",
        "inputs": [
          {
            "name": "AzureBlobInputDaily"
          },
          {
            "name": "AzureBlobInputWeekly",
            "startTime": "Date.AddDays(SliceStart, - Date.DayOfWeek(SliceStart))",
            "endTime": "Date.AddDays(SliceEnd,  -Date.DayOfWeek(SliceEnd))"  
          }
        ],
        "outputs": [
          {
            "name": "AzureBlobOutputDaily"
          }
        ],
        "linkedServiceName": "HDInsightLinkedService",
        "type": "HDInsightHive",
        "typeProperties": {
          "scriptPath": "adftutorial\\hivequery.hql",
          "scriptLinkedService": "StorageLinkedService",
          "defines": {
            "Year": "$$Text.Format('{0:yyyy}',WindowStart)",
            "Month": "$$Text.Format('{0:MM}',WindowStart)",
            "Day": "$$Text.Format('{0:dd}',WindowStart)"
          }
        },
        "scheduler": {
          "frequency": "Day",
          "interval": 1
        },            
        "policy": {
          "concurrency": 1,
          "executionPriorityOrder": "OldestFirst",
          "retry": 2,  
          "timeout": "01:00:00"
        }
       }
     ]
   }
}

Pour obtenir la liste des fonctions et variables système prises en charge par Azure Data Factory, consultez Variables système et fonctions Data Factory .See Data Factory functions and system variables for a list of functions and system variables that Data Factory supports.

AnnexeAppendix

Exemple : Copier de manière séquentielleExample: copy sequentially

Il est possible d’exécuter plusieurs opérations de copie l’une après l’autre, de manière séquentielle/ordonnée.It is possible to run multiple copy operations one after another in a sequential/ordered manner. Si, par exemple, vous avez deux activités de copie dans un pipeline : (ActivitédeCopie1 et ActivitédeCopie2) avec les jeux de données de sortie de données d’entrée suivants :For example, you might have two copy activities in a pipeline (CopyActivity1 and CopyActivity2) with the following input data output datasets:

Activitédecopie1CopyActivity1

Entrée : JeudeDonnées.Input: Dataset. Sortie : JeudeDonnées2.Output: Dataset2.

Activitédecopie2CopyActivity2

Entrée : JeudeDonnées2.Input: Dataset2. Sortie : JeudeDonnées3.Output: Dataset3.

ActivitédeCopie2 s’exécute uniquement si ActivitédeCopie1 s’est exécutée avec succès et que JeudeDonnées2 est disponible.CopyActivity2 would run only if the CopyActivity1 has run successfully and Dataset2 is available.

Voici l’exemple de pipeline JSON :Here is the sample pipeline JSON:

{
    "name": "ChainActivities",
    "properties": {
        "description": "Run activities in sequence",
        "activities": [
            {
                "type": "Copy",
                "typeProperties": {
                    "source": {
                        "type": "BlobSource"
                    },
                    "sink": {
                        "type": "BlobSink",
                        "copyBehavior": "PreserveHierarchy",
                        "writeBatchSize": 0,
                        "writeBatchTimeout": "00:00:00"
                    }
                },
                "inputs": [
                    {
                        "name": "Dataset1"
                    }
                ],
                "outputs": [
                    {
                        "name": "Dataset2"
                    }
                ],
                "policy": {
                    "timeout": "01:00:00"
                },
                "scheduler": {
                    "frequency": "Hour",
                    "interval": 1
                },
                "name": "CopyFromBlob1ToBlob2",
                "description": "Copy data from a blob to another"
            },
            {
                "type": "Copy",
                "typeProperties": {
                    "source": {
                        "type": "BlobSource"
                    },
                    "sink": {
                        "type": "BlobSink",
                        "writeBatchSize": 0,
                        "writeBatchTimeout": "00:00:00"
                    }
                },
                "inputs": [
                    {
                        "name": "Dataset2"
                    }
                ],
                "outputs": [
                    {
                        "name": "Dataset3"
                    }
                ],
                "policy": {
                    "timeout": "01:00:00"
                },
                "scheduler": {
                    "frequency": "Hour",
                    "interval": 1
                },
                "name": "CopyFromBlob2ToBlob3",
                "description": "Copy data from a blob to another"
            }
        ],
        "start": "2016-08-25T01:00:00Z",
        "end": "2016-08-25T01:00:00Z",
        "isPaused": false
    }
}

Notez que dans l’exemple, le jeu de données de sortie de la première activité de copie (Dataset2) est spécifié en tant qu’entrée pour la deuxième activité.Notice that in the example, the output dataset of the first copy activity (Dataset2) is specified as input for the second activity. Par conséquent, la deuxième activité s’exécute uniquement lorsque le jeu de données de sortie de la première activité est prêt.Therefore, the second activity runs only when the output dataset from the first activity is ready.

Dans l’exemple, ActivitédeCopie2 peut avoir une entrée différente, par exemple JeudeDonnées3, mais vous spécifiez JeudeDonnées2 en tant qu’entrée pour ActivitédeCopie2, afin que l’activité ne s’exécute pas avant la fin d’ActivitédeCopie1.In the example, CopyActivity2 can have a different input, such as Dataset3, but you specify Dataset2 as an input to CopyActivity2, so the activity does not run until CopyActivity1 finishes. Par exemple :For example:

Activitédecopie1CopyActivity1

Entrée : JeudeDonnées1.Input: Dataset1. Sortie : JeudeDonnées2.Output: Dataset2.

Activitédecopie2CopyActivity2

Entrées : JeudeDonnées3, JeudeDonnées2.Inputs: Dataset3, Dataset2. Sortie : Jeudedonnées4.Output: Dataset4.

{
    "name": "ChainActivities",
    "properties": {
        "description": "Run activities in sequence",
        "activities": [
            {
                "type": "Copy",
                "typeProperties": {
                    "source": {
                        "type": "BlobSource"
                    },
                    "sink": {
                        "type": "BlobSink",
                        "copyBehavior": "PreserveHierarchy",
                        "writeBatchSize": 0,
                        "writeBatchTimeout": "00:00:00"
                    }
                },
                "inputs": [
                    {
                        "name": "Dataset1"
                    }
                ],
                "outputs": [
                    {
                        "name": "Dataset2"
                    }
                ],
                "policy": {
                    "timeout": "01:00:00"
                },
                "scheduler": {
                    "frequency": "Hour",
                    "interval": 1
                },
                "name": "CopyFromBlobToBlob",
                "description": "Copy data from a blob to another"
            },
            {
                "type": "Copy",
                "typeProperties": {
                    "source": {
                        "type": "BlobSource"
                    },
                    "sink": {
                        "type": "BlobSink",
                        "writeBatchSize": 0,
                        "writeBatchTimeout": "00:00:00"
                    }
                },
                "inputs": [
                    {
                        "name": "Dataset3"
                    },
                    {
                        "name": "Dataset2"
                    }
                ],
                "outputs": [
                    {
                        "name": "Dataset4"
                    }
                ],
                "policy": {
                    "timeout": "01:00:00"
                },
                "scheduler": {
                    "frequency": "Hour",
                    "interval": 1
                },
                "name": "CopyFromBlob3ToBlob4",
                "description": "Copy data from a blob to another"
            }
        ],
        "start": "2017-04-25T01:00:00Z",
        "end": "2017-04-25T01:00:00Z",
        "isPaused": false
    }
}

Notez que dans l’exemple, deux jeux de données d’entrée sont spécifiés pour la deuxième activité de copie.Notice that in the example, two input datasets are specified for the second copy activity. Quand plusieurs entrées sont spécifiées, seul le premier jeu de données d’entrée est utilisé pour copier des données, mais les autres jeux de données sont utilisés en tant que dépendances.When multiple inputs are specified, only the first input dataset is used for copying data, but other datasets are used as dependencies. L’exécution d’ActivitédeCopie2 démarre uniquement quand les conditions suivantes sont remplies :CopyActivity2 would start only after the following conditions are met:

  • ActivitédeCopie1 s’est terminée avec succès et JeudeDonnées2 est disponible.CopyActivity1 has successfully completed and Dataset2 is available. Ce jeu de données n’est pas utilisé lors de la copie des données vers JeudeDonnées4.This dataset is not used when copying data to Dataset4. Il sert uniquement de dépendance de planification pour ActivitédeCopie2.It only acts as a scheduling dependency for CopyActivity2.
  • JeudeDonnées3 est disponible.Dataset3 is available. Ce jeu de données représente les données qui sont copiées vers la destination.This dataset represents the data that is copied to the destination.