Factories - Configure Factory Repo

Service:

Data Factory

API Version:

2018-06-01

Updates die Repositoryinformationen einer Factory.

POST https://management.azure.com/subscriptions/{subscriptionId}/providers/Microsoft.DataFactory/locations/{locationId}/configureFactoryRepo?api-version=2018-06-01

URI-Parameter

Name	In	Erforderlich	Typ	Beschreibung
locationId	path	True	string	Der Standortbezeichner.
subscriptionId	path	True	string	Die Abonnement-ID.
api-version	query	True	string	Die API-Version.

Anforderungstext

Name	Typ	Beschreibung
factoryResourceId	string	Die Factoryressourcen-ID.
repoConfiguration	FactoryRepoConfiguration: FactoryVSTSConfiguration FactoryGitHubConfiguration	Git-Repositoryinformationen der Factory.

Antworten

Name	Typ	Beschreibung
200 OK	Factory	OK.
Other Status Codes	CloudError	Eine vom Azure Data Factory Dienst empfangene Fehlerantwort.

Sicherheit

azure_auth

Azure Active Directory OAuth2 Flow.

Type: oauth2
Flow: implicit
Authorization URL: https://login.microsoftonline.com/common/oauth2/authorize

Scopes

Name	Beschreibung
user_impersonation	Annehmen der Identität Ihres Benutzerkontos

Beispiele

Factories_ConfigureFactoryRepo

Sample Request

HTTP

POST https://management.azure.com/subscriptions/12345678-1234-1234-1234-12345678abc/providers/Microsoft.DataFactory/locations/East US/configureFactoryRepo?api-version=2018-06-01

{
  "factoryResourceId": "/subscriptions/12345678-1234-1234-1234-12345678abc/resourceGroups/exampleResourceGroup/providers/Microsoft.DataFactory/factories/exampleFactoryName",
  "repoConfiguration": {
    "type": "FactoryVSTSConfiguration",
    "projectName": "project",
    "tenantId": "",
    "accountName": "ADF",
    "repositoryName": "repo",
    "collaborationBranch": "master",
    "rootFolder": "/",
    "lastCommitId": ""
  }
}

Java

import com.azure.resourcemanager.datafactory.models.FactoryRepoUpdate;
import com.azure.resourcemanager.datafactory.models.FactoryVstsConfiguration;

/** Samples for Factories ConfigureFactoryRepo. */
public final class Main {
    /*
     * x-ms-original-file: specification/datafactory/resource-manager/Microsoft.DataFactory/stable/2018-06-01/examples/Factories_ConfigureFactoryRepo.json
     */
    /**
     * Sample code: Factories_ConfigureFactoryRepo.
     *
     * @param manager Entry point to DataFactoryManager.
     */
    public static void factoriesConfigureFactoryRepo(com.azure.resourcemanager.datafactory.DataFactoryManager manager) {
        manager
            .factories()
            .configureFactoryRepoWithResponse(
                "East US",
                new FactoryRepoUpdate()
                    .withFactoryResourceId(
                        "/subscriptions/12345678-1234-1234-1234-12345678abc/resourceGroups/exampleResourceGroup/providers/Microsoft.DataFactory/factories/exampleFactoryName")
                    .withRepoConfiguration(
                        new FactoryVstsConfiguration()
                            .withAccountName("ADF")
                            .withRepositoryName("repo")
                            .withCollaborationBranch("master")
                            .withRootFolder("/")
                            .withLastCommitId("")
                            .withProjectName("project")
                            .withTenantId("")),
                com.azure.core.util.Context.NONE);
    }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

Python

from azure.identity import DefaultAzureCredential
from azure.mgmt.datafactory import DataFactoryManagementClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-datafactory
# USAGE
    python factories_configure_factory_repo.py

    Before run the sample, please set the values of the client ID, tenant ID and client secret
    of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
    AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
    https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
"""


def main():
    client = DataFactoryManagementClient(
        credential=DefaultAzureCredential(),
        subscription_id="12345678-1234-1234-1234-12345678abc",
    )

    response = client.factories.configure_factory_repo(
        location_id="East US",
        factory_repo_update={
            "factoryResourceId": "/subscriptions/12345678-1234-1234-1234-12345678abc/resourceGroups/exampleResourceGroup/providers/Microsoft.DataFactory/factories/exampleFactoryName",
            "repoConfiguration": {
                "accountName": "ADF",
                "collaborationBranch": "master",
                "lastCommitId": "",
                "projectName": "project",
                "repositoryName": "repo",
                "rootFolder": "/",
                "tenantId": "",
                "type": "FactoryVSTSConfiguration",
            },
        },
    )
    print(response)


# x-ms-original-file: specification/datafactory/resource-manager/Microsoft.DataFactory/stable/2018-06-01/examples/Factories_ConfigureFactoryRepo.json
if __name__ == "__main__":
    main()

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

Go

package armdatafactory_test

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/datafactory/armdatafactory/v3"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/5c9459305484e0456b4a922e3d31a61e2ddd3c99/specification/datafactory/resource-manager/Microsoft.DataFactory/stable/2018-06-01/examples/Factories_ConfigureFactoryRepo.json
func ExampleFactoriesClient_ConfigureFactoryRepo() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatafactory.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewFactoriesClient().ConfigureFactoryRepo(ctx, "East US", armdatafactory.FactoryRepoUpdate{
		FactoryResourceID: to.Ptr("/subscriptions/12345678-1234-1234-1234-12345678abc/resourceGroups/exampleResourceGroup/providers/Microsoft.DataFactory/factories/exampleFactoryName"),
		RepoConfiguration: &armdatafactory.FactoryVSTSConfiguration{
			Type:                to.Ptr("FactoryVSTSConfiguration"),
			AccountName:         to.Ptr("ADF"),
			CollaborationBranch: to.Ptr("master"),
			LastCommitID:        to.Ptr(""),
			RepositoryName:      to.Ptr("repo"),
			RootFolder:          to.Ptr("/"),
			ProjectName:         to.Ptr("project"),
			TenantID:            to.Ptr(""),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.Factory = armdatafactory.Factory{
	// 	Name: to.Ptr("exampleFactoryName"),
	// 	Type: to.Ptr("Microsoft.DataFactory/factories"),
	// 	ETag: to.Ptr("\"00004004-0000-0000-0000-5b28979e0000\""),
	// 	ID: to.Ptr("/subscriptions/12345678-1234-1234-1234-12345678abc/resourceGroups/exampleResourceGroup/providers/Microsoft.DataFactory/factories/exampleFactoryName"),
	// 	Location: to.Ptr("East US"),
	// 	Tags: map[string]*string{
	// 		"exampleTag": to.Ptr("exampleValue"),
	// 	},
	// 	Properties: &armdatafactory.FactoryProperties{
	// 		CreateTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2018-06-19T05:41:50.0041314Z"); return t}()),
	// 		ProvisioningState: to.Ptr("Succeeded"),
	// 		RepoConfiguration: &armdatafactory.FactoryVSTSConfiguration{
	// 			Type: to.Ptr("FactoryVSTSConfiguration"),
	// 			AccountName: to.Ptr("ADF"),
	// 			CollaborationBranch: to.Ptr("master"),
	// 			LastCommitID: to.Ptr(""),
	// 			RepositoryName: to.Ptr("repo"),
	// 			RootFolder: to.Ptr("/"),
	// 			ProjectName: to.Ptr("project"),
	// 			TenantID: to.Ptr(""),
	// 		},
	// 		Version: to.Ptr("2018-06-01"),
	// 	},
	// }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

JavaScript

const { DataFactoryManagementClient } = require("@azure/arm-datafactory");
const { DefaultAzureCredential } = require("@azure/identity");

/**
 * This sample demonstrates how to Updates a factory's repo information.
 *
 * @summary Updates a factory's repo information.
 * x-ms-original-file: specification/datafactory/resource-manager/Microsoft.DataFactory/stable/2018-06-01/examples/Factories_ConfigureFactoryRepo.json
 */
async function factoriesConfigureFactoryRepo() {
  const subscriptionId =
    process.env["DATAFACTORY_SUBSCRIPTION_ID"] || "12345678-1234-1234-1234-12345678abc";
  const locationId = "East US";
  const factoryRepoUpdate = {
    factoryResourceId:
      "/subscriptions/12345678-1234-1234-1234-12345678abc/resourceGroups/exampleResourceGroup/providers/Microsoft.DataFactory/factories/exampleFactoryName",
    repoConfiguration: {
      type: "FactoryVSTSConfiguration",
      accountName: "ADF",
      collaborationBranch: "master",
      lastCommitId: "",
      projectName: "project",
      repositoryName: "repo",
      rootFolder: "/",
      tenantId: "",
    },
  };
  const credential = new DefaultAzureCredential();
  const client = new DataFactoryManagementClient(credential, subscriptionId);
  const result = await client.factories.configureFactoryRepo(locationId, factoryRepoUpdate);
  console.log(result);
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

dotnet

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Azure;
using Azure.Core;
using Azure.Core.Expressions.DataFactory;
using Azure.Identity;
using Azure.ResourceManager;
using Azure.ResourceManager.DataFactory;
using Azure.ResourceManager.DataFactory.Models;
using Azure.ResourceManager.Resources;

// Generated from example definition: specification/datafactory/resource-manager/Microsoft.DataFactory/stable/2018-06-01/examples/Factories_ConfigureFactoryRepo.json
// this example is just showing the usage of "Factories_ConfigureFactoryRepo" operation, for the dependent resources, they will have to be created separately.

// get your azure access token, for more details of how Azure SDK get your access token, please refer to https://learn.microsoft.com/en-us/dotnet/azure/sdk/authentication?tabs=command-line
TokenCredential cred = new DefaultAzureCredential();
// authenticate your client
ArmClient client = new ArmClient(cred);

// this example assumes you already have this SubscriptionResource created on azure
// for more information of creating SubscriptionResource, please refer to the document of SubscriptionResource
string subscriptionId = "12345678-1234-1234-1234-12345678abc";
ResourceIdentifier subscriptionResourceId = SubscriptionResource.CreateResourceIdentifier(subscriptionId);
SubscriptionResource subscriptionResource = client.GetSubscriptionResource(subscriptionResourceId);

// invoke the operation
AzureLocation locationId = new AzureLocation("East US");
FactoryRepoContent content = new FactoryRepoContent()
{
    FactoryResourceId = new ResourceIdentifier("/subscriptions/12345678-1234-1234-1234-12345678abc/resourceGroups/exampleResourceGroup/providers/Microsoft.DataFactory/factories/exampleFactoryName"),
    RepoConfiguration = new FactoryVstsConfiguration("ADF", "repo", "master", "/", "project")
    {
        TenantId = Guid.Parse(""),
        LastCommitId = "",
    },
};
DataFactoryResource result = await subscriptionResource.ConfigureFactoryRepoInformationAsync(locationId, content);

// the variable result is a resource, you could call other operations on this instance as well
// but just for demo, we get its data from this resource instance
DataFactoryData resourceData = result.Data;
// for demo we just print out the id
Console.WriteLine($"Succeeded on id: {resourceData.Id}");

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

Sample Response

Status code:

200

Date: Tue, 19 Jun 2018 05:41:50 GMT
X-Content-Type-Options: nosniff
x-ms-ratelimit-remaining-subscription-writes: 1191
x-ms-request-id: c63640bd-3e5f-4ee0-bae1-cea74f761a7d
x-ms-correlation-request-id: c63640bd-3e5f-4ee0-bae1-cea74f761a7d

Response Body

{
  "name": "exampleFactoryName",
  "id": "/subscriptions/12345678-1234-1234-1234-12345678abc/resourceGroups/exampleResourceGroup/providers/Microsoft.DataFactory/factories/exampleFactoryName",
  "type": "Microsoft.DataFactory/factories",
  "properties": {
    "provisioningState": "Succeeded",
    "createTime": "2018-06-19T05:41:50.0041314Z",
    "version": "2018-06-01",
    "repoConfiguration": {
      "type": "FactoryVSTSConfiguration",
      "projectName": "project",
      "tenantId": "",
      "accountName": "ADF",
      "repositoryName": "repo",
      "collaborationBranch": "master",
      "rootFolder": "/",
      "lastCommitId": ""
    }
  },
  "eTag": "\"00004004-0000-0000-0000-5b28979e0000\"",
  "location": "East US",
  "tags": {
    "exampleTag": "exampleValue"
  }
}

Definitionen

Name	Beschreibung
CloudError	Das -Objekt, das die Struktur einer Azure Data Factory Fehlerantwort definiert.
CMKIdentityDefinition	Verwaltete Identität, die für CMK verwendet wird.
EncryptionConfiguration	Definition von CMK für die Factory.
Factory	Factoryressourcentyp.
FactoryGitHubConfiguration	GitHub-Repositoryinformationen von Factory.
FactoryIdentity	Identitätseigenschaften der Factoryressource.
FactoryIdentityType	Der Identitätstyp.
FactoryRepoUpdate	Git-Repositoryinformationen von Factory.
FactoryVSTSConfiguration	VSTS-Repositoryinformationen der Factory.
GitHubClientSecret	Geheime Clientinformationen für die Bring Your Own App Repository-Konfiguration der Factory.
GlobalParameterSpecification	Definition eines einzelnen Parameters für eine Entität.
GlobalParameterType	Globaler Parametertyp.
PublicNetworkAccess	Gibt an, ob der Zugriff auf öffentliche Netzwerke für die Data Factory zulässig ist.
PurviewConfiguration	Purview-Konfiguration.
UserAssignedIdentitySpecification	Definition einer einzelnen benutzerseitig zugewiesenen Identität für eine Factory.

CloudError

Das -Objekt, das die Struktur einer Azure Data Factory Fehlerantwort definiert.

Name	Typ	Beschreibung
error.code	string	Fehlercode
error.details	CloudError[]	Array mit zusätzlichen Fehlerdetails.
error.message	string	Fehlermeldung.
error.target	string	Eigenschaftsname/Pfad in der Anforderung, die einem Fehler zugeordnet ist.

CMKIdentityDefinition

Verwaltete Identität, die für CMK verwendet wird.

Name	Typ	Beschreibung
userAssignedIdentity	string	Die Ressourcen-ID der benutzerseitig zugewiesenen Identität zur Authentifizierung beim Schlüsseltresor des Kunden.

EncryptionConfiguration

Definition von CMK für die Factory.

Name	Typ	Beschreibung
identity	CMKIdentityDefinition	Benutzerseitig zugewiesene Identität, die zur Authentifizierung beim Schlüsseltresor des Kunden verwendet werden soll. Falls nicht angegeben, wird die verwaltete Dienstidentität verwendet.
keyName	string	Der Name des Schlüssels in Azure Key Vault, der als kundenseitig verwalteter Schlüssel verwendet werden soll.
keyVersion	string	Die Version des schlüssels, der für CMK verwendet wird. Falls nicht angegeben, wird die neueste Version verwendet.
vaultBaseUrl	string	Die URL der azure-Key Vault, die für CMK verwendet wird.

Factory

Factoryressourcentyp.

Name	Typ	Beschreibung
eTag	string	Etag identifiziert Änderungen in der Ressource.
id	string	Der Ressourcenbezeichner.
identity	FactoryIdentity	Verwaltete Dienstidentität der Factory.
location	string	Der Ressourcenspeicherort.
name	string	Der Name der Ressource.
properties.createTime	string	Zeitpunkt, zu dem die Fabrik im ISO8601-Format erstellt wurde.
properties.encryption	EncryptionConfiguration	Eigenschaften zum Aktivieren des kundenseitig verwalteten Schlüssels für die Factory.
properties.globalParameters	<string,  GlobalParameterSpecification>	Liste der Parameter für factory.
properties.provisioningState	string	Factorybereitstellungsstatus, Beispiel Erfolgreich.
properties.publicNetworkAccess	PublicNetworkAccess	Gibt an, ob der Zugriff auf öffentliche Netzwerke für die Data Factory zulässig ist.
properties.purviewConfiguration	PurviewConfiguration	Purview-Informationen der Factory.
properties.repoConfiguration	FactoryRepoConfiguration: FactoryGitHubConfiguration FactoryVSTSConfiguration	Git-Repositoryinformationen der Factory.
properties.version	string	Version der Factory.
tags	object	Die Ressourcentags.
type	string	Der Ressourcentyp.

FactoryGitHubConfiguration

GitHub-Repositoryinformationen von Factory.

Name	Typ	Beschreibung
accountName	string	Kontoname.
clientId	string	GitHub bringt Ihre eigene App-Client-ID mit.
clientSecret	GitHubClientSecret	GitHub bringt Ihre eigenen Geheiminformationen für den App-Client mit.
collaborationBranch	string	Zusammenarbeitsbranch.
disablePublish	boolean	Deaktivieren Sie den manuellen Veröffentlichungsvorgang in ADF Studio, um die automatisierte Veröffentlichung zu bevorzugen.
hostName	string	GitHub Enterprise-Hostname. Beispiel: https://github.mydomain.com
lastCommitId	string	Letzte Commit-ID.
repositoryName	string	Repositoryname.
rootFolder	string	Stammordner.
type	string: FactoryGitHubConfiguration	Typ der Repositorykonfiguration.

FactoryIdentity

Identitätseigenschaften der Factoryressource.

Name	Typ	Beschreibung
principalId	string	Die Prinzipal-ID der Identität.
tenantId	string	Die Clientmandanten-ID der Identität.
type	FactoryIdentityType	Der Identitätstyp.
userAssignedIdentities	<string,  UserAssignedIdentitySpecification>	Liste der benutzerseitig zugewiesenen Identitäten für die Factory.

FactoryIdentityType

Der Identitätstyp.

Name	Typ	Beschreibung
SystemAssigned	string
SystemAssigned,UserAssigned	string
UserAssigned	string

FactoryRepoUpdate

Git-Repositoryinformationen von Factory.

Name	Typ	Beschreibung
factoryResourceId	string	Die Factoryressourcen-ID.
repoConfiguration	FactoryRepoConfiguration: FactoryGitHubConfiguration FactoryVSTSConfiguration	Git-Repositoryinformationen der Factory.

FactoryVSTSConfiguration

VSTS-Repositoryinformationen der Factory.

Name	Typ	Beschreibung
accountName	string	Kontoname.
collaborationBranch	string	Zusammenarbeitsbranch.
disablePublish	boolean	Deaktivieren Sie den manuellen Veröffentlichungsvorgang in ADF Studio, um die automatisierte Veröffentlichung zu bevorzugen.
lastCommitId	string	Letzte Commit-ID.
projectName	string	VSTS-Projektname.
repositoryName	string	Repositoryname.
rootFolder	string	Stammordner.
tenantId	string	VSTS-Mandanten-ID.
type	string: FactoryVSTSConfiguration	Typ der Repositorykonfiguration.

GitHubClientSecret

Geheime Clientinformationen für die Bring Your Own App Repository-Konfiguration der Factory.

Name	Typ	Beschreibung
byoaSecretAkvUrl	string	Bring your own app client secret AKV URL.
byoaSecretName	string	Bringen Sie Ihren eigenen App-Clientgeheimnisnamen in AKV.

GlobalParameterSpecification

Definition eines einzelnen Parameters für eine Entität.

Name	Typ	Beschreibung
type	GlobalParameterType	Globaler Parametertyp.
value	object	Wert des Parameters.

GlobalParameterType

Globaler Parametertyp.

Name	Typ	Beschreibung
Array	string
Bool	string
Float	string
Int	string
Object	string
String	string

PublicNetworkAccess

Gibt an, ob der Zugriff auf öffentliche Netzwerke für die Data Factory zulässig ist.

Name	Typ	Beschreibung
Disabled	string
Enabled	string

PurviewConfiguration

Purview-Konfiguration.

Name	Typ	Beschreibung
purviewResourceId	string	Purview-Ressourcen-ID.

UserAssignedIdentitySpecification

Definition einer einzelnen benutzerseitig zugewiesenen Identität für eine Factory.