Skapa en datapipeline med hjälp av Azure Data Factory, DevOps och maskininlärning

Artikel
01/10/2024

Azure DevOps Services

Kom igång med att skapa en datapipeline med datainmatning, datatransformering och modellträning.

Lär dig hur du hämtar data från en CSV-fil (kommaavgränsade värden) och sparar data i Azure Blob Storage. Transformera data och spara dem i ett mellanlagringsområde. Träna sedan en maskininlärningsmodell med hjälp av transformerade data. Skriv modellen till bloblagring som en Python Pickle-fil.

Förutsättningar

Innan du börjar behöver du:

Ett Azure-konto som har en aktiv prenumeration. Skapa ett konto utan kostnad.
En aktiv Azure DevOps-organisation. Registrera dig för Azure Pipelines.
- Administratörsrollen för tjänstanslutningar i ditt Azure DevOps-projekt. Lär dig hur du lägger till administratörsrollen.
Data från sample.csv.
Åtkomst till datapipelinelösningen i GitHub.
DevOps för Azure Databricks.

Etablera Azure-resurser

Logga in på Azure-portalen.
På menyn väljer du knappen Cloud Shell . När du uppmanas att göra det väljer du Bash-upplevelsen.

Kommentar

Du behöver en Azure Storage-resurs för att spara alla filer som du skapar i Azure Cloud Shell. När du först öppnar Cloud Shell uppmanas du att skapa en resursgrupp, ett lagringskonto och en Azure Files-resurs. Den här konfigurationen används automatiskt för alla framtida Cloud Shell-sessioner.

Välj en Azure-region

En region är ett eller flera Azure-datacenter inom en geografisk plats. USA, östra, USA, västra och Europa, norra är exempel på regioner. Varje Azure-resurs, inklusive en App Service-instans, tilldelas en region.

Om du vill göra kommandon enklare att köra börjar du med att välja en standardregion. När du har angett standardregionen använder senare kommandon den regionen om du inte anger en annan region.

I Cloud Shell kör du följande az account list-locations kommando för att visa en lista över de regioner som är tillgängliga från din Azure-prenumeration.
```
az account list-locations \
  --query "[].{Name: name, DisplayName: displayName}" \
  --output table
```
Name I kolumnen i utdata väljer du en region som är nära dig. Välj till exempel asiapacific eller westus2.
Kör az config för att ange din standardregion. I följande exempel ersätter <REGION> du med namnet på den region som du har valt.
```
az config set defaults.location=<REGION>
```
I följande exempel anges westus2 som standardregion.
```
az config set defaults.location=westus2
```

Skapa Bash-variabler

Generera ett slumptal i Cloud Shell. Du använder det här numret för att skapa globalt unika namn för vissa tjänster i nästa steg.
```
resourceSuffix=$RANDOM
```
Skapa globalt unika namn för ditt lagringskonto och nyckelvalv. Följande kommandon använder dubbla citattecken, vilket instruerar Bash att interpolera variablerna med hjälp av den infogade syntaxen.
```
storageName="datacicd${resourceSuffix}"
keyVault="keyvault${resourceSuffix}"
```
Skapa ytterligare en Bash-variabel för att lagra namnen och regionen för resursgruppen. I följande exempel ersätter <REGION> du med den region som du valde för standardregionen.
```
rgName='data-pipeline-cicd-rg'
region='<REGION>'
```

Skapa variabelnamn för dina Azure Data Factory- och Azure Databricks-instanser.

datafactorydev='data-factory-cicd-dev'
datafactorytest='data-factory-cicd-test'
databricksname='databricks-cicd-ws'

Skapa Azure-resurser

Kör följande az group create kommando för att skapa en resursgrupp med hjälp rgNameav .
```
az group create --name $rgName
```

Kör följande az storage account create kommando för att skapa ett nytt lagringskonto.

az storage account create \
    --name $storageName \
    --resource-group $rgName \
    --sku Standard_RAGRS \
    --kind StorageV2

Kör följande az storage container create kommando för att skapa två containrar rawdata och prepareddata.

az storage container create -n rawdata --account-name $storageName 
az storage container create -n prepareddata --account-name $storageName

Kör följande az keyvault create kommando för att skapa ett nytt nyckelvalv.
```
az keyvault create \
    --name $keyVault \
    --resource-group $rgName
```
Skapa en ny datafabrik med hjälp av portalgränssnittet eller Azure CLI:
- Namn: data-factory-cicd-dev
- Version: V2
- Resursgrupp: data-pipeline-cicd-rg
- Plats: Din närmaste plats
- Avmarkera markeringen för Aktivera Git.
1. Lägg till Azure Data Factory-tillägget.
```
az extension add --name datafactory
```
2. Kör följande az datafactory create kommando för att skapa en ny datafabrik.
```
 az datafactory create \
     --name data-factory-cicd-dev \
     --resource-group $rgName
```
3. Kopiera prenumerations-ID:t. Datafabriken använder det här ID:t senare.
Skapa en andra datafabrik med hjälp av portalgränssnittet eller Azure CLI. Du använder den här datafabriken för testning.
- Namn: data-factory-cicd-test
- Version: V2
- Resursgrupp: data-pipeline-cicd-rg
- Plats: Din närmaste plats
- Avmarkera markeringen för Aktivera GIT.
1. Kör följande az datafactory create kommando för att skapa en ny datafabrik för testning.
```
 az datafactory create \
     --name data-factory-cicd-test \
     --resource-group $rgName
```
2. Kopiera prenumerations-ID:t. Datafabriken använder det här ID:t senare.
Lägg till en ny Azure Databricks-tjänst:
- Resursgrupp: data-pipeline-cicd-rg
- Namn på arbetsyta: databricks-cicd-ws
- Plats: Din närmaste plats
1. Lägg till Azure Databricks-tillägget om det inte redan är installerat.
```
 az extension add --name databricks
```
2. Kör följande az databricks workspace create kommando för att skapa en ny arbetsyta.
```
az databricks workspace create \
    --resource-group $rgName \
    --name databricks-cicd-ws  \
    --location eastus2  \
    --sku trial
```
3. Kopiera prenumerations-ID:t. Din Databricks-tjänst använder det här ID:t senare.

Ladda upp data till lagringscontainern

Öppna ditt lagringskonto i resursgruppen i data-pipeline-cicd-rg Azure-portalen.
Gå till Blob Service-containrar>.
Öppna containern prepareddata .
Ladda upp filen sample.csv.

Ställ in Key Vault

Du använder Azure Key Vault för att lagra all anslutningsinformation för dina Azure-tjänster.

Skapa en personlig Databricks-åtkomsttoken

I Azure-portalen går du till Databricks och öppnar sedan din arbetsyta.
I Azure Databricks-användargränssnittet skapar och kopierar du en personlig åtkomsttoken.

Kopiera kontonyckeln och anslutningssträng för ditt lagringskonto

Gå till ditt lagringskonto.
Öppna Åtkomstnycklar.
Kopiera den första nyckeln och anslutningssträng.

Spara värden i Key Vault

Skapa tre hemligheter:
- databricks-token: your-databricks-pat
- StorageKey: your-storage-key
- Lagring Anslut Sträng:your-storage-connection

Kör följande az keyvault secret set kommando för att lägga till hemligheter i ditt nyckelvalv.

az keyvault secret set --vault-name "$keyVault" --name "databricks-token" --value "your-databricks-pat"
az keyvault secret set --vault-name "$keyVault" --name "StorageKey" --value "your-storage-key"
az keyvault secret set --vault-name "$keyVault" --name "StorageConnectString" --value "your-storage-connection"

Importera datapipelinelösningen

Logga in på din Azure DevOps-organisation och gå sedan till projektet.
Gå till Lagringsplatser och importera sedan din förgrenade version av GitHub-lagringsplatsen. Mer information finns i Importera en Git-lagringsplats till projektet.

Lägga till en Azure Resource Manager-tjänstanslutning

Skapa en Azure Resource Manager-tjänstanslutning.
Välj Tjänstens huvudnamn (automatiskt).
Välj resursgruppen data-pipeline-cicd-rg.
Ge tjänstanslutningen azure_rm_connectionnamnet .
Välj Bevilja åtkomstbehörighet till alla pipelines. Du måste ha rollen Tjänst Anslut ionsadministratör för att välja det här alternativet.

Lägga till pipelinevariabler

Skapa en ny variabelgrupp med namnet datapipeline-vg.
Lägg till Azure DevOps-tillägget om det inte redan är installerat.
```
az extension add --name azure-devops 
```

Logga in på din Azure DevOps-organisation.

az devops login --org https://dev.azure.com/<yourorganizationname>

az pipelines variable-group create --name datapipeline-vg -p <yourazuredevopsprojectname> --variables \
                                    "LOCATION=$region" \
                                    "RESOURCE_GROUP=$rgName" \
                                    "DATA_FACTORY_NAME=$datafactorydev" \
                                    "DATA_FACTORY_DEV_NAME=$datafactorydev" \
                                    "DATA_FACTORY_TEST_NAME=$datafactorytest" \
                                    "ADF_PIPELINE_NAME=DataPipeline" \
                                    "DATABRICKS_NAME=$databricksname" \
                                    "AZURE_RM_CONNECTION=azure_rm_connection" \
                                    "DATABRICKS_URL=<URL copied from Databricks in Azure portal>" \
                                    "STORAGE_ACCOUNT_NAME=$storageName" \
                                    "STORAGE_CONTAINER_NAME=rawdata"

Skapa en andra variabelgrupp med namnet keys-vg. Den här gruppen hämtar datavariabler från Key Vault.
Välj Länka hemligheter från ett Azure-nyckelvalv som variabler. Mer information finns i Länka hemligheter från ett Azure-nyckelvalv.
Auktorisera Azure-prenumerationen.
Välj alla tillgängliga hemligheter som ska läggas till som variabler (databricks-token,StorageConnectString,StorageKey).

Konfigurera Azure Databricks och Azure Data Factory

Följ stegen i nästa avsnitt för att konfigurera Azure Databricks och Azure Data Factory.

Skapa testscope i Azure Databricks

Gå till Egenskaper för Nyckelvalv> i Azure-portalen.
Kopiera DNS-namnet och resurs-ID:t.
I din Azure Databricks-arbetsyta skapar du ett hemligt omfång med namnet testscope.

Lägga till ett nytt kluster i Azure Databricks

Gå till Kluster på Azure Databricks-arbetsytan.
Välj Skapa kluster.
Namnge och spara det nya klustret.
Välj ditt nya klusternamn.
I URL-strängen kopierar du innehållet mellan /clusters/ och /configuration. I strängen clusters/0306-152107-daft561/configurationkopierar 0306-152107-daft561du till exempel .
Spara strängen om du vill använda den senare.

Konfigurera din kodlagringsplats i Azure Data Factory

I Azure Data Factory går du till Författare och övervakare. Mer information finns i Skapa en datafabrik.
Välj Konfigurera kodlagringsplats och anslut sedan lagringsplatsen.
- Lagringsplatstyp: Azure DevOps Git
- Azure DevOps-organisation: Ditt aktiva konto
- Projektnamn: Ditt Azure DevOps-datapipelineprojekt
- Git-lagringsplatsnamn: Använd befintlig.
  - Välj huvudgrenen för samarbete.
  - Ange /azure-data-pipeline/factorydata som rotmapp.
- Gren för att importera resursen till: Välj Använd befintlig och main.

Länka Azure Data Factory till ditt nyckelvalv

Öppna nyckelvalvet i azure-portalens användargränssnitt.
Välj åtkomstprinciper.
Välj Lägg till åtkomstprincip.
För Konfigurera från mall väljer du Nyckel- och hemlighetshantering.
I Välj huvudnamn söker du efter namnet på din utvecklingsdatafabrik och lägger till den.
Välj Lägg till för att lägga till dina åtkomstprinciper.
Upprepa de här stegen för att lägga till en åtkomstprincip för testdatafabriken.

Uppdatera den länkade key vault-tjänsten i Azure Data Factory

Gå till Hantera>länkade tjänster.
Uppdatera Azure-nyckelvalvet för att ansluta till din prenumeration.

Uppdatera den länkade lagringstjänsten i Azure Data Factory

Gå till Hantera>länkade tjänster.
Uppdatera Azure Blob Storage-värdet för att ansluta till din prenumeration.

Uppdatera den länkade Azure Databricks-tjänsten i Azure Data Factory

Gå till Hantera>länkade tjänster.
Uppdatera Azure Databricks-värdet för att ansluta till din prenumeration.
För det befintliga kluster-ID:t anger du det klustervärde som du sparade tidigare.

Testa och publicera datafabriken

I Azure Data Factory går du till Redigera.
Öppna DataPipeline.
Välj variabler.
Kontrollera att storage_account_name refererar till ditt lagringskonto i Azure-portalen. Uppdatera standardvärdet om det behövs. Spara dina ändringar.
Välj Verifiera för att verifiera DataPipeline.
Välj Publicera för att publicera datafabrikstillgångar till grenen adf_publish av lagringsplatsen.

Kör CI/CD-pipelinen

Följ de här stegen för att köra ci/CD-pipelinen (continuous integration and continuous delivery):

Gå till sidan Pipelines . Välj sedan åtgärden för att skapa en ny pipeline.
Välj Azure Repos Git som plats för källkoden.
När listan över lagringsplatser visas väljer du din lagringsplats.
När du konfigurerar din pipeline väljer du Befintlig YAML-fil för Azure Pipelines. Välj YAML-filen: /azure-data-pipeline/data_pipeline_ci_cd.yml.
Köra pipelinen. Om din pipeline inte har körts tidigare kan du behöva ge behörighet att komma åt en resurs under körningen.

Rensa resurser

Om du inte kommer att fortsätta att använda det här programmet tar du bort din datapipeline genom att följa dessa steg:

data-pipeline-cicd-rg Ta bort resursgruppen.
Ta bort ditt Azure DevOps-projekt.

Nästa steg

Läs mer om data i Azure Data Factory

Dela via