Démarrage rapide : Créer une fabrique de données Azure à l’aide d’Azure CLI

Ce guide de démarrage rapide explique comment utiliser Azure CLI pour créer une fabrique de données Azure. Le pipeline que vous créez dans cette fabrique de données copie les données d’un dossier vers un autre dossier dans un stockage Blob Azure. Pour plus d’informations sur la transformation des données à l’aide d’Azure Data Factory, consultez Transformer des données dans Azure Data Factory.

Pour une présentation du service Azure Data Factory, consultez Présentation d’Azure Data Factory.

Si vous n’avez pas d’abonnement Azure, créez un compte gratuit avant de commencer.

Prerequisites

Utilisez l’environnement Bash dans Azure Cloud Shell. Pour obtenir plus d’informations, consultez Démarrage d’Azure Cloud Shell.
Si vous préférez exécuter des commandes de référence CLI localement, installez Azure CLI. Si vous exécutez sur Windows ou macOS, envisagez d’exécuter Azure CLI dans un conteneur Docker. Pour plus d’informations, consultez Comment exécuter Azure CLI dans un conteneur Docker.
- Si vous utilisez une installation locale, connectez-vous à Azure CLI à l’aide de la commande az login. Pour terminer le processus d’authentification, suivez les étapes affichées dans votre terminal. Pour obtenir d’autres options de connexion, consultez S’authentifier auprès d’Azure à l’aide d’Azure CLI.
- Lorsque vous y êtes invité, installez l’extension Azure CLI lors de la première utilisation. Pour plus d’informations sur les extensions, consultez Utiliser et gérer des extensions avec Azure CLI.
- Exécutez az version pour rechercher la version et les bibliothèques dépendantes installées. Pour effectuer une mise à niveau vers la dernière version, exécutez az upgrade.

Note

Pour créer des instances Data Factory, le compte d’utilisateur que vous utilisez pour vous connecter à Azure doit être membre du rôle contributeur ou propriétaire, ou administrateur de l’abonnement Azure. Pour plus d’informations, voir Rôles Azure.

Préparer un conteneur et un fichier de test

Ce guide de démarrage rapide utilise un compte de stockage Azure, qui inclut un conteneur avec un fichier.

Pour créer un groupe de ressources nommé ADFQuickStartRG, utilisez la commande az group create :
```
az group create --name ADFQuickStartRG --location eastus
```

Créez un compte de stockage à l’aide de la commande az storage account create :

az storage account create --resource-group ADFQuickStartRG \
    --name adfquickstartstorage --location eastus

Créez un conteneur nommé adftutorial à l’aide de la commande az storage container create :

az storage container create --resource-group ADFQuickStartRG --name adftutorial \
    --account-name adfquickstartstorage --auth-mode key

Dans le répertoire local, créez un fichier nommé emp.txt pour le chargement. Si vous travaillez dans Azure Cloud Shell, vous trouverez le répertoire de travail actuel à l’aide de la echo $PWD commande Bash. Vous pouvez utiliser des commandes Bash standard, telles que cat, pour créer un fichier :
```
cat > emp.txt
This is text.
```
Utilisez Ctrl+D pour enregistrer votre nouveau fichier.
Pour charger le nouveau fichier dans votre conteneur de stockage Azure, utilisez la commande az storage blob upload :
```
az storage blob upload --account-name adfquickstartstorage --name input/emp.txt \
    --container-name adftutorial --file emp.txt --auth-mode key
```
Cette commande charge dans un nouveau dossier nommé input.

Créer une fabrique de données

Pour créer une fabrique de données Azure, exécutez la commande az datafactory create :

az datafactory create --resource-group ADFQuickStartRG \
    --factory-name ADFTutorialFactory

Important

Remplacer ADFTutorialFactory par un nom de fabrique de données unique au niveau mondial, par exemple ADFTutorialFactorySP1127.

Vous pouvez voir la fabrique de données que vous avez créée à l’aide de la commande az datafactory show :

az datafactory show --resource-group ADFQuickStartRG \
    --factory-name ADFTutorialFactory

Créer un service lié et des jeux de données

Ensuite, créez un service lié et deux jeux de données.

Obtenez la chaîne de connexion de votre compte de stockage à l’aide de la commande az storage account show-connection-string :
```
az storage account show-connection-string --resource-group ADFQuickStartRG \
    --name adfquickstartstorage --key primary
```

Dans votre répertoire de travail, créez un fichier JSON avec ce contenu, qui inclut votre propre chaîne de connexion à l’étape précédente. Nommez le fichier AzureStorageLinkedService.json:

{
    "type": "AzureBlobStorage",
    "typeProperties": {
        "connectionString": "DefaultEndpointsProtocol=https;AccountName=<accountName>;AccountKey=<accountKey>;EndpointSuffix=core.windows.net"
    }
}

Créez un service lié nommé AzureStorageLinkedServiceà l’aide de la commande az datafactory linked-service create :

az datafactory linked-service create --resource-group ADFQuickStartRG \
    --factory-name ADFTutorialFactory --linked-service-name AzureStorageLinkedService \
    --properties AzureStorageLinkedService.json

Dans votre répertoire de travail, créez un fichier JSON avec ce contenu, nommé InputDataset.json:

{
    "linkedServiceName": {
        "referenceName": "AzureStorageLinkedService",
        "type": "LinkedServiceReference"
    },
    "annotations": [],
    "type": "Binary",
    "typeProperties": {
        "location": {
            "type": "AzureBlobStorageLocation",
            "fileName": "emp.txt",
            "folderPath": "input",
            "container": "adftutorial"
        }
    }
}

Créez un jeu de données d’entrée nommé InputDataset à l’aide de la commande az datafactory dataset create :

az datafactory dataset create --resource-group ADFQuickStartRG \
    --dataset-name InputDataset --factory-name ADFTutorialFactory \
    --properties InputDataset.json

Dans votre répertoire de travail, créez un fichier JSON avec ce contenu, nommé OutputDataset.json:

{
    "linkedServiceName": {
        "referenceName": "AzureStorageLinkedService",
        "type": "LinkedServiceReference"
    },
    "annotations": [],
    "type": "Binary",
    "typeProperties": {
        "location": {
            "type": "AzureBlobStorageLocation",
            "folderPath": "output",
            "container": "adftutorial"
        }
    }
}

Créez un jeu de données de sortie nommé OutputDataset à l’aide de la commande az datafactory dataset create :

az datafactory dataset create --resource-group ADFQuickStartRG \
    --dataset-name OutputDataset --factory-name ADFTutorialFactory \
    --properties OutputDataset.json

Créer et exécuter un pipeline

Enfin, créez et exécutez le pipeline.

Dans votre répertoire de travail, créez un fichier JSON avec ce contenu nommé Adfv2QuickStartPipeline.json:

{
    "name": "Adfv2QuickStartPipeline",
    "properties": {
        "activities": [
            {
                "name": "CopyFromBlobToBlob",
                "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": true
                        }
                    },
                    "sink": {
                        "type": "BinarySink",
                        "storeSettings": {
                            "type": "AzureBlobStorageWriteSettings"
                        }
                    },
                    "enableStaging": false
                },
                "inputs": [
                    {
                        "referenceName": "InputDataset",
                        "type": "DatasetReference"
                    }
                ],
                "outputs": [
                    {
                        "referenceName": "OutputDataset",
                        "type": "DatasetReference"
                    }
                ]
            }
        ],
        "annotations": []
    }
}

Créez un pipeline nommé Adfv2QuickStartPipeline à l’aide de la commande az datafactory pipeline create :

az datafactory pipeline create --resource-group ADFQuickStartRG \
    --factory-name ADFTutorialFactory --name Adfv2QuickStartPipeline \
    --pipeline Adfv2QuickStartPipeline.json

Exécutez le pipeline à l’aide de la commande az datafactory pipeline create-run :
```
az datafactory pipeline create-run --resource-group ADFQuickStartRG \
    --name Adfv2QuickStartPipeline --factory-name ADFTutorialFactory
```
Cette commande retourne un ID d’exécution. Copiez-la pour une utilisation dans la commande suivante.

Vérifiez que l’exécution du pipeline a réussi à l’aide de la commande az datafactory pipeline-run show :

az datafactory pipeline-run show --resource-group ADFQuickStartRG \
    --factory-name ADFTutorialFactory --run-id 00000000-0000-0000-0000-000000000000

Vous pouvez également vérifier que votre pipeline s’est exécuté comme prévu à l’aide du portail Azure. Pour plus d’informations, consultez Vérifier les ressources déployées.

Nettoyer les ressources

Toutes les ressources de ce guide de démarrage rapide font partie du même groupe de ressources. Pour les supprimer tous, utilisez la commande az group delete :

az group delete --name ADFQuickStartRG

Si vous utilisez ce groupe de ressources pour tout autre élément, supprimez plutôt des ressources individuelles. Par exemple, pour supprimer le service lié, utilisez la commande az datafactory linked-service delete .

Dans ce guide de démarrage rapide, vous avez créé les fichiers JSON suivants :

AzureStorageLinkedService.json
InputDataset.json
OutputDataset.json
Adfv2QuickStartPipeline.json

Supprimez-les à l’aide de commandes Bash standard.

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2025-10-08