Lernprogramm: Programmgesteuertes Verwalten erweiterter Connectorrichtlinien

Erweiterte Connectorrichtlinien (ACP) steuern die Connectorverwendung mit einer strengen Zulassungsliste, die Connectors standardmäßig blockiert. Zusätzlich zur Power Platform Admin Center-Oberfläche können Sie ACP mit Code mithilfe der Power Platform-API und der Verwaltungs-SDKs (Admin) verwalten. Die Automatisierung von ACP ist nützlich, wenn Sie governance in vielen Umgebungsgruppen standardisieren, eine Basisrichtlinie zwischen Gruppen replizieren oder Richtlinien als Teil einer Bereitstellungspipeline verwalten.

In diesem Tutorial lernen Sie Folgendes:

Authentifizieren Sie sich mithilfe der Power Platform API.
Die Struktur der ACP-Richtlinie verstehen.
Erstellen Sie eine Richtlinie, und fügen Sie sie einer Umgebungsgruppe hinzu.
Aktivieren Sie eine einzelne Konnektoraktion.
Anwenden oder Aktualisieren einer Richtlinie für eine einzelne Umgebung.
Kopieren Sie eine Richtlinie aus einer Umgebungsgruppe in eine andere.
Entfernen Sie ACP aus einer Umgebungsgruppe.

Erweiterte Connectorrichtlinien werden über die governance/ruleBasedPolicies Vorgänge der Power Platform-API verfügbar gemacht. Eine Richtlinie enthält einen oder mehrere Regelsätze; die Regel, die mit der ID ConnectorManagement festgelegt ist, enthält die Allowlist des ACP-Connectors. Alle Beispiele im Artikel verwenden API-Version 2024-10-01.

Voraussetzungen

Eine App-Registrierung, die für die Power Platform-API konfiguriert ist. Beachten Sie die Anwendungs-ID (Client-ID) und die Verzeichnis-ID (Mandant) der App-Registrierung.
Berechtigung zum Verwalten von Governance-Richtlinien. Weisen Sie für Dienstprinzipale eine RBAC-Rolle zu, die Ressourcen schreiben kann, z. B. Power Platform-Mitwirkender oder Power Platform-Besitzer. Weitere Informationen finden Sie unter Tutorial: Zuweisen von Rollen zu Dienstprinzipalen.
Installieren Sie für die SDK-Beispiele das SDK, das monatlich in seiner öffentlichen Galerie veröffentlicht wird:
- C#: das Microsoft.PowerPlatform.Management NuGet-Paket.
- Python: das Powerplatform-Management PyPI-Paket.
```
dotnet add package Microsoft.PowerPlatform.Management
```
```
pip install powerplatform-management
```

Schritt 1. Mit der Power Platform-API authentifizieren

Alle Beispiele verwenden zur Authentifizierung die Client-ID Ihrer App-Registrierung gemäß den Anweisungen in Authentifizierung. Die folgenden Beispiele melden sich interaktiv als aktueller Benutzer an. Für die unbeaufsichtigte Ausführung als Dienstprinzipal finden Sie Informationen zum Ablauf für vertrauliche Clients im Artikel Authentifizierung, und weisen Sie dem Dienstprinzipal eine RBAC-Rolle zu.

# Requires the MSAL.PS module: Install-Module MSAL.PS -Scope CurrentUser
Import-Module "MSAL.PS"

$clientId  = "<application (client) ID of your app registration>"
$apiBaseUrl = "https://api.powerplatform.com"
$apiVersion = "2024-10-01"

# Sign in interactively and request a token for the Power Platform API
$auth = Get-MsalToken -ClientId $clientId -Scope "https://api.powerplatform.com/.default" -Interactive
$headers = @{ Authorization = "Bearer $($auth.AccessToken)" }

using Microsoft.PowerPlatform.Management;
using Microsoft.PowerPlatform.Management.Models;

// Create an interactive client using your app registration's client ID.
// A browser window opens for sign-in.
var factory = new ServiceClientFactory();
var client = factory.Create("YOUR_CLIENT_ID");

import asyncio
from azure.identity import InteractiveBrowserCredential
from kiota_authentication_azure.azure_identity_authentication_provider import (
    AzureIdentityAuthenticationProvider,
)
from kiota_http.httpx_request_adapter import HttpxRequestAdapter
from mspp_management.service_client_base import ServiceClientBase

# Sign in interactively using your app registration's client ID.
credential = InteractiveBrowserCredential(client_id="YOUR_CLIENT_ID")
auth_provider = AzureIdentityAuthenticationProvider(
    credentials=credential,
    scopes=["https://api.powerplatform.com/.default"],
)
adapter = HttpxRequestAdapter(authentication_provider=auth_provider)
client = ServiceClientBase(adapter)

Schritt 2. Die Form der ACP-Richtlinie verstehen

Eine erweiterte Connectorrichtlinie ist eine regelbasierte Richtlinie, die einen Regelsatz mit der ID ConnectorManagemententhält. Dieser Regelsatz umfasst ein version, und seine inputs enthalten ein AllowedConnectorList, wobei jeder Eintrag einen Verbinder zulässt und festlegt, wie seine Aktionen und Verbindungstypen geregelt werden:

{
  "name": "Contoso ACP baseline",
  "ruleSets": [
    {
      "id": "ConnectorManagement",
      "version": "1.0",
      "inputs": {
        "AllowedConnectorList": [
          {
            "AllowedConnector": "/providers/Microsoft.PowerApps/apis/shared_office365",
            "AllowedActionsMode": "AllAllowed",
            "AllowedConnectionTypesMode": "AllAllowed"
          },
          {
            "AllowedConnector": "/providers/Microsoft.PowerApps/apis/shared_commondataserviceforapps",
            "AllowedActionsMode": "SomeAllowed",
            "AllowedActions": ["GetItem", "CreateRecord"],
            "AllowedConnectionTypesMode": "AllAllowed"
          }
        ]
      }
    }
  ]
}

Beachten Sie die folgende Semantik:

Ein Connector, der sich nicht in AllowedConnectorList befindet, ist blockiert (standardmäßig verweigert).
Jeder Eintrag setzt AllowedActionsMode. AllAllowed erlaubt alle Aktionen für den Connector. SomeAllowed schränkt den Verbinder auf die Aktionen ein, die im Array des Eintrags AllowedActions aufgeführt sind. In Schritt 4 wird gezeigt, wie Sie eine Aktion hinzufügen und diesen Modus festlegen.
AllowedConnectionTypesMode bestimmt, welche Verbindungstypen zulässig sind, und folgt demselben AllAllowed Muster.
Schließen Sie den Regelsatz version ein, wenn Sie eine Richtlinie erstellen oder aktualisieren. Lesen Sie sie aus einer vorhandenen Richtlinie, und bewahren Sie den Wert auf, den der Dienst zurückgibt.

Tip

Der genaue Wert von AllowedConnector ist die Ressourcen-ID des Connectors. Die zuverlässigste Methode, um die Struktur für Konnektoren zu ermitteln, die in Ihrem Mandanten bereits vorhanden sind, besteht darin, zuerst eine vorhandene Richtlinie zu lesen (Schritt 4 zeigt, wie das geht) oder den Konnektorkatalog zu verwenden (im Folgenden beschrieben) und diese Struktur dann beim Erstellen oder Aktualisieren von Richtlinien zu übernehmen.

Suchen von Connector- und Aktions-IDs mit dem Connectorkatalog

Verwenden Sie die Connectorkatalog-API, um zu ermitteln, welche Connectors und Aktionen Sie zulassen können. Es werden die in einer Umgebung verfügbaren Konnektoren zusammen mit den Bezeichnern aufgelistet, die Sie in AllowedConnector und AllowedActions einfügen.

Note

Für die Connector-Katalogvorgänge muss eine Umgebungs-ID im Pfadund eine OData-$filter angegeben werden, die dieselbe Umgebung angibt, z. B. $filter=environment eq '<environmentId>'. Beide sind erforderlich.

$environmentId = "<environment ID>"
$filter = [uri]::EscapeDataString("environment eq '$environmentId'")

# List connectors available in the environment
$connectors = Invoke-RestMethod -Method Get `
    -Uri "$apiBaseUrl/connectivity/environments/$environmentId/connectors?`$filter=$filter&api-version=$apiVersion" `
    -Headers $headers
$connectors.value | Select-Object name, @{ n = "displayName"; e = { $_.properties.displayName } }

# Get a single connector by ID (the connector's name, such as shared_office365)
$connectorId = "shared_office365"
$connector = Invoke-RestMethod -Method Get `
    -Uri "$apiBaseUrl/connectivity/environments/$environmentId/connectors/$connectorId?`$filter=$filter&api-version=$apiVersion" `
    -Headers $headers
$connector.id   # full resource path to use as AllowedConnector

Verwenden Sie das id des Connectors (den vollständigen Ressourcenpfad, z. B. /providers/Microsoft.PowerApps/apis/shared_office365) als Wert für AllowedConnector, und die Operations-IDs des Connectors als Werte in AllowedActions. Sie können über den Namespace der Admin-SDKs auf denselben connectivity Katalog zugreifen.

Schritt 3: Erstellen Sie eine Richtlinie, und fügen Sie sie einer Umgebungsgruppe hinzu

Das Hinzufügen von ACP zu einer Umgebungsgruppe ist ein zweiteiliger Vorgang: Erstellen Sie die Richtlinie, und weisen Sie sie der Gruppe zu. Der Create-Aufruf gibt die neue Richtlinie idzurück, die Sie im Aufgabenaufruf verwenden.

Um die Richtlinie der gesamten Gruppe zuzuweisen, senden Sie eine Zuweisungsanforderung mit leerem Text ({}). Jede Umgebung in der Gruppe erbt die Richtlinie und bleibt damit synchronisiert.

$environmentGroupId = "<environment group ID>"

# 1. Create the policy with a ConnectorManagement rule set
$policyBody = @{
    name     = "Contoso ACP baseline"
    ruleSets = @(
        @{
            id      = "ConnectorManagement"
            version = "1.0"
            inputs  = @{
                AllowedConnectorList = @(
                    @{
                        AllowedConnector           = "/providers/Microsoft.PowerApps/apis/shared_office365"
                        AllowedActionsMode         = "AllAllowed"
                        AllowedConnectionTypesMode = "AllAllowed"
                    }
                )
            }
        }
    )
} | ConvertTo-Json -Depth 10

$policy = Invoke-RestMethod -Method Post `
    -Uri "$apiBaseUrl/governance/ruleBasedPolicies?api-version=$apiVersion" `
    -Headers $headers -ContentType "application/json" -Body $policyBody
Write-Host "Created policy $($policy.id)"

# 2. Assign the policy to the environment group (empty body = whole group)
Invoke-RestMethod -Method Post `
    -Uri "$apiBaseUrl/governance/ruleBasedPolicies/$($policy.id)/environmentGroups/$environmentGroupId/assignments?api-version=$apiVersion" `
    -Headers $headers -ContentType "application/json" -Body "{}"
Write-Host "Assigned policy $($policy.id) to group $environmentGroupId"

var environmentGroupId = "<environment group ID>";

// 1. Create the policy with a ConnectorManagement rule set
var ruleSet = new RuleSet { Id = "ConnectorManagement", Version = "1.0", Inputs = new RuleSet_inputs() };
ruleSet.Inputs.AdditionalData["AllowedConnectorList"] = new List<object>
{
    new Dictionary<string, object>
    {
        ["AllowedConnector"] = "/providers/Microsoft.PowerApps/apis/shared_office365",
        ["AllowedActionsMode"] = "AllAllowed",
        ["AllowedConnectionTypesMode"] = "AllAllowed"
    }
};

var policyRequest = new PolicyRequest
{
    Name = "Contoso ACP baseline",
    RuleSets = new List<RuleSet> { ruleSet }
};

var policy = await client.Governance.RuleBasedPolicies.PostAsync(policyRequest);
Console.WriteLine($"Created policy {policy.Id}");

// 2. Assign the policy to the environment group (empty request = whole group)
await client.Governance.RuleBasedPolicies[policy.Id]
    .EnvironmentGroups[environmentGroupId]
    .Assignments.PostAsync(new PolicyAssignmentRequest());
Console.WriteLine($"Assigned policy {policy.Id} to group {environmentGroupId}");

from mspp_management.models.policy_request import PolicyRequest
from mspp_management.models.rule_set import RuleSet
from mspp_management.models.rule_set_inputs import RuleSet_inputs
from mspp_management.models.policy_assignment_request import PolicyAssignmentRequest

async def create_and_assign(client, environment_group_id: str):
    # 1. Create the policy with a ConnectorManagement rule set
    rule_set = RuleSet()
    rule_set.id = "ConnectorManagement"
    rule_set.version = "1.0"
    rule_set.inputs = RuleSet_inputs()
    rule_set.inputs.additional_data = {
        "AllowedConnectorList": [
            {
                "AllowedConnector": "/providers/Microsoft.PowerApps/apis/shared_office365",
                "AllowedActionsMode": "AllAllowed",
                "AllowedConnectionTypesMode": "AllAllowed",
            }
        ]
    }

    policy_request = PolicyRequest()
    policy_request.name = "Contoso ACP baseline"
    policy_request.rule_sets = [rule_set]

    policy = await client.governance.rule_based_policies.post(policy_request)
    print(f"Created policy {policy.id}")

    # 2. Assign the policy to the environment group (empty request = whole group)
    await (
        client.governance.rule_based_policies
        .by_policy_id(policy.id)
        .environment_groups.by_group_id(environment_group_id)
        .assignments.post(PolicyAssignmentRequest())
    )
    print(f"Assigned policy {policy.id} to group {environment_group_id}")

Schritt 4. Eine einzelne Konnektoraktion aktivieren

Um nur bestimmte Aktionen bei einem Connector zuzulassen, setzen Sie AllowedActionsMode auf SomeAllowed und führen Sie die zulässigen Aktionen in AllowedActions auf. In diesem Beispiel wird die Zulassungsliste eines Connectors um eine Aktion ergänzt, z. B. um eine ausgeblendete Aktion, die im Admin Center nicht ausgewählt werden kann, und der Connector wird auf SomeAllowed festgelegt. Lesen Sie die Richtlinie, aktualisieren Sie den Connectoreintrag, und senden Sie mithilfe von Patch die aktualisierte Regel zurück. Patch aktualisiert eine Regel, die anhand der ID festgelegt ist, und lässt die anderen Regelsätze der Richtlinie unberührt.

$policyId     = "<policy ID>"
$connectorId  = "shared_commondataserviceforapps"   # last segment of AllowedConnector
$actionToAdd  = "aibuilderpredict_customprompt"

# 1. Read the current policy
$policy = Invoke-RestMethod -Method Get `
    -Uri "$apiBaseUrl/governance/ruleBasedPolicies/$policyId`?api-version=$apiVersion" `
    -Headers $headers

# 2. Find the ConnectorManagement rule set and the connector entry
$ruleSet = $policy.ruleSets | Where-Object { $_.id -eq "ConnectorManagement" }
$entry = $ruleSet.inputs.AllowedConnectorList |
    Where-Object { ($_.AllowedConnector -split "/")[-1] -eq $connectorId }

# 3. Restrict the connector to specific actions: add the action and set SomeAllowed
if ($entry) {
    $actions = @()
    if ($entry.PSObject.Properties.Name -contains "AllowedActions") { $actions = @($entry.AllowedActions) }
    if ($actions -notcontains $actionToAdd) { $actions += $actionToAdd }
    $entry | Add-Member -NotePropertyName AllowedActions -NotePropertyValue $actions -Force
    $entry.AllowedActionsMode = "SomeAllowed"

    # 4. Patch only the modified rule set back to the policy
    $patchBody = @{ name = $policy.name; ruleSets = @($ruleSet) } | ConvertTo-Json -Depth 10
    Invoke-RestMethod -Method Patch `
        -Uri "$apiBaseUrl/governance/ruleBasedPolicies/$policyId`?api-version=$apiVersion" `
        -Headers $headers -ContentType "application/json" -Body $patchBody
    Write-Host "Set '$connectorId' to SomeAllowed with '$actionToAdd' in policy $policyId"
}

var policyId = "<policy ID>";
var connectorId = "shared_commondataserviceforapps";   // last segment of AllowedConnector
var actionToAdd = "aibuilderpredict_customprompt";

// 1. Read the current policy
var policy = await client.Governance.RuleBasedPolicies[policyId].GetAsync();

// 2. Find the ConnectorManagement rule set and the connector entry
var ruleSet = policy.RuleSets.First(r => r.Id == "ConnectorManagement");
var connectorList = (List<object>)ruleSet.Inputs.AdditionalData["AllowedConnectorList"];
var entry = connectorList
    .Cast<Dictionary<string, object>>()
    .First(e => ((string)e["AllowedConnector"]).Split('/').Last() == connectorId);

// 3. Restrict the connector to specific actions: add the action and set SomeAllowed
if (!(entry.TryGetValue("AllowedActions", out var actionsObj) && actionsObj is List<object> actions))
{
    actions = new List<object>();
}
if (!actions.Contains(actionToAdd)) actions.Add(actionToAdd);
entry["AllowedActions"] = actions;
entry["AllowedActionsMode"] = "SomeAllowed";

// 4. Patch only the modified rule set back to the policy
var patch = new PolicyRequest { Name = policy.Name, RuleSets = new List<RuleSet> { ruleSet } };
await client.Governance.RuleBasedPolicies[policyId].PatchAsync(patch);
Console.WriteLine($"Set '{connectorId}' to SomeAllowed with '{actionToAdd}' in policy {policyId}");

async def enable_action(client, policy_id: str, connector_id: str, action_to_add: str):
    # 1. Read the current policy
    policy = await client.governance.rule_based_policies.by_policy_id(policy_id).get()

    # 2. Find the ConnectorManagement rule set and the connector entry
    rule_set = next(r for r in policy.rule_sets if r.id == "ConnectorManagement")
    connector_list = rule_set.inputs.additional_data["AllowedConnectorList"]
    entry = next(
        e for e in connector_list
        if e["AllowedConnector"].split("/")[-1] == connector_id
    )

    # 3. Restrict the connector to specific actions: add the action and set SomeAllowed
    actions = entry.get("AllowedActions") or []
    if action_to_add not in actions:
        actions.append(action_to_add)
    entry["AllowedActions"] = actions
    entry["AllowedActionsMode"] = "SomeAllowed"

    # 4. Patch only the modified rule set back to the policy
    from mspp_management.models.policy_request import PolicyRequest
    patch = PolicyRequest()
    patch.name = policy.name
    patch.rule_sets = [rule_set]
    await client.governance.rule_based_policies.by_policy_id(policy_id).patch(patch)
    print(f"Set '{connector_id}' to SomeAllowed with '{action_to_add}' in policy {policy_id}")

Schritt 5. Anwenden oder Aktualisieren einer Richtlinie für eine einzelne Umgebung

Sie können eine Richtlinie auf eine einzelne Umgebung anstatt auf eine Umgebungsgruppe ausrichten. Dieser Ansatz eignet sich für umgebungen mit hohem Risiko, Pilot oder regulierten Umgebungen. Weisen Sie die Richtlinie der Umgebung zu, und verwenden Sie das gleiche Patchmuster aus Schritt 4, um sie später zu ändern. Jede Umgebung unterstützt eine effektive ACP-Richtlinie.

$policyId       = "<policy ID>"
$environmentId  = "<environment ID>"

# Assign the policy directly to the environment
Invoke-RestMethod -Method Post `
    -Uri "$apiBaseUrl/governance/ruleBasedPolicies/$policyId/environments/$environmentId/assignments?api-version=$apiVersion" `
    -Headers $headers -ContentType "application/json" -Body "{}"
Write-Host "Assigned policy $policyId to environment $environmentId"

var policyId = "<policy ID>";
var environmentId = "<environment ID>";

// Assign the policy directly to the environment
await client.Governance.RuleBasedPolicies[policyId]
    .Environments[environmentId]
    .Assignments.PostAsync(new PolicyAssignmentRequest());
Console.WriteLine($"Assigned policy {policyId} to environment {environmentId}");

async def assign_to_environment(client, policy_id: str, environment_id: str):
    from mspp_management.models.policy_assignment_request import PolicyAssignmentRequest
    await (
        client.governance.rule_based_policies
        .by_policy_id(policy_id)
        .environments.by_environment_id(environment_id)
        .assignments.post(PolicyAssignmentRequest())
    )
    print(f"Assigned policy {policy_id} to environment {environment_id}")

Schritt 6: Eine Richtlinie von einer Umgebungsgruppe in eine andere kopieren

Wenn Sie eine Governancebasislinie in eine andere Gruppe replizieren, wählen Sie aus, wie viel kopiert werden soll, indem Sie das CopyAllRules Kennzeichen verwenden:

CopyAllRules = true: Erstellen Sie eine neue Richtlinie aus allen Regelsätzen der Quellgruppe, und weisen Sie sie der Zielgruppe zu. Die Governance der Zielgruppe wird zu einer unabhängigen Kopie der Quelle.
CopyAllRules = false: Extrahieren Sie nur den ConnectorManagement-Regelsatz aus der Quellrichtlinie und führen Sie ihn mit der vorhandenen Richtlinie der Zielgruppe zusammen. Durch den Patchvorgang wird die nach ID festgelegte Regel hinzugefügt oder aktualisiert, sodass die Zielgruppe ihre anderen Regeln behält.

$sourceGroupId = "<source environment group ID>"
$targetGroupId = "<target environment group ID>"
$CopyAllRules  = $true

# 1. Find and read the policy assigned to the source group
$sourceAssignments = Invoke-RestMethod -Method Get `
    -Uri "$apiBaseUrl/governance/ruleBasedPolicies/environmentGroups/$sourceGroupId/assignments?api-version=$apiVersion" `
    -Headers $headers
$sourcePolicyId = $sourceAssignments.value[0].policyId
$source = Invoke-RestMethod -Method Get `
    -Uri "$apiBaseUrl/governance/ruleBasedPolicies/$sourcePolicyId`?api-version=$apiVersion" `
    -Headers $headers

if ($CopyAllRules) {
    # 2a. Copy ALL rule sets into a new policy and assign it to the target group
    $copyBody = @{ name = "$($source.name) (copy)"; ruleSets = $source.ruleSets } | ConvertTo-Json -Depth 20
    $copy = Invoke-RestMethod -Method Post `
        -Uri "$apiBaseUrl/governance/ruleBasedPolicies?api-version=$apiVersion" `
        -Headers $headers -ContentType "application/json" -Body $copyBody
    Invoke-RestMethod -Method Post `
        -Uri "$apiBaseUrl/governance/ruleBasedPolicies/$($copy.id)/environmentGroups/$targetGroupId/assignments?api-version=$apiVersion" `
        -Headers $headers -ContentType "application/json" -Body "{}"
    Write-Host "Copied all rules to policy $($copy.id) and assigned it to group $targetGroupId"
}
else {
    # 2b. Merge ONLY the ConnectorManagement rule into the target group's existing policy
    $sourceCm = $source.ruleSets | Where-Object { $_.id -eq "ConnectorManagement" }

    $targetAssignments = Invoke-RestMethod -Method Get `
        -Uri "$apiBaseUrl/governance/ruleBasedPolicies/environmentGroups/$targetGroupId/assignments?api-version=$apiVersion" `
        -Headers $headers
    $targetPolicyId = $targetAssignments.value[0].policyId
    $targetPolicy = Invoke-RestMethod -Method Get `
        -Uri "$apiBaseUrl/governance/ruleBasedPolicies/$targetPolicyId`?api-version=$apiVersion" `
        -Headers $headers

    # Patch adds or updates the ConnectorManagement rule set by ID, keeping the target's other rules
    $patchBody = @{ name = $targetPolicy.name; ruleSets = @($sourceCm) } | ConvertTo-Json -Depth 20
    Invoke-RestMethod -Method Patch `
        -Uri "$apiBaseUrl/governance/ruleBasedPolicies/$targetPolicyId`?api-version=$apiVersion" `
        -Headers $headers -ContentType "application/json" -Body $patchBody
    Write-Host "Merged the ConnectorManagement rule into target policy $targetPolicyId"
}

var sourceGroupId = "<source environment group ID>";
var targetGroupId = "<target environment group ID>";
var copyAllRules = true;

// 1. Find and read the policy assigned to the source group
var sourceAssignments = await client.Governance.RuleBasedPolicies
    .EnvironmentGroups[sourceGroupId].Assignments.GetAsync();
var sourcePolicyId = sourceAssignments.Value.First().PolicyId;
var source = await client.Governance.RuleBasedPolicies[sourcePolicyId].GetAsync();

if (copyAllRules)
{
    // 2a. Copy ALL rule sets into a new policy and assign it to the target group
    var copyRequest = new PolicyRequest { Name = $"{source.Name} (copy)", RuleSets = source.RuleSets };
    var copy = await client.Governance.RuleBasedPolicies.PostAsync(copyRequest);
    await client.Governance.RuleBasedPolicies[copy.Id]
        .EnvironmentGroups[targetGroupId]
        .Assignments.PostAsync(new PolicyAssignmentRequest());
    Console.WriteLine($"Copied all rules to policy {copy.Id} and assigned it to group {targetGroupId}");
}
else
{
    // 2b. Merge ONLY the ConnectorManagement rule into the target group's existing policy
    var sourceCm = source.RuleSets.First(r => r.Id == "ConnectorManagement");

    var targetAssignments = await client.Governance.RuleBasedPolicies
        .EnvironmentGroups[targetGroupId].Assignments.GetAsync();
    var targetPolicyId = targetAssignments.Value.First().PolicyId;
    var targetPolicy = await client.Governance.RuleBasedPolicies[targetPolicyId].GetAsync();

    // Patch adds or updates the ConnectorManagement rule set by ID, keeping the target's other rules
    var patch = new PolicyRequest { Name = targetPolicy.Name, RuleSets = new List<RuleSet> { sourceCm } };
    await client.Governance.RuleBasedPolicies[targetPolicyId].PatchAsync(patch);
    Console.WriteLine($"Merged the ConnectorManagement rule into target policy {targetPolicyId}");
}

async def copy_policy(client, source_group_id: str, target_group_id: str, copy_all_rules: bool = True):
    from mspp_management.models.policy_request import PolicyRequest
    from mspp_management.models.policy_assignment_request import PolicyAssignmentRequest

    # 1. Find and read the policy assigned to the source group
    source_assignments = await (
        client.governance.rule_based_policies
        .environment_groups.by_environment_group_id(source_group_id)
        .assignments.get()
    )
    source_policy_id = source_assignments.value[0].policy_id
    source = await client.governance.rule_based_policies.by_policy_id(source_policy_id).get()

    if copy_all_rules:
        # 2a. Copy ALL rule sets into a new policy and assign it to the target group
        copy_request = PolicyRequest()
        copy_request.name = f"{source.name} (copy)"
        copy_request.rule_sets = source.rule_sets
        copy = await client.governance.rule_based_policies.post(copy_request)
        await (
            client.governance.rule_based_policies
            .by_policy_id(copy.id)
            .environment_groups.by_group_id(target_group_id)
            .assignments.post(PolicyAssignmentRequest())
        )
        print(f"Copied all rules to policy {copy.id} and assigned it to group {target_group_id}")
    else:
        # 2b. Merge ONLY the ConnectorManagement rule into the target group's existing policy
        source_cm = next(r for r in source.rule_sets if r.id == "ConnectorManagement")

        target_assignments = await (
            client.governance.rule_based_policies
            .environment_groups.by_environment_group_id(target_group_id)
            .assignments.get()
        )
        target_policy_id = target_assignments.value[0].policy_id
        target_policy = await client.governance.rule_based_policies.by_policy_id(target_policy_id).get()

        # Patch adds or updates the ConnectorManagement rule set by ID, keeping the target's other rules
        patch = PolicyRequest()
        patch.name = target_policy.name
        patch.rule_sets = [source_cm]
        await client.governance.rule_based_policies.by_policy_id(target_policy_id).patch(patch)
        print(f"Merged the ConnectorManagement rule into target policy {target_policy_id}")

Schritt 7: Entfernen von ACP aus einer Umgebungsgruppe

Während eine Gruppe über eine aktive ACP-Regel verfügt, entspricht jede Umgebung in der Gruppe der Richtlinie der Gruppe. Wie Sie die Erzwingung entfernen, hängt davon ab, ob diese Umgebungen ihre aktuelle Konfiguration beibehalten oder ACP vollständig löschen sollen:

Entfernen Sie die Regel aus der Gruppenrichtlinie , um zu verhindern, dass die Gruppe ACP verwaltet. Verwenden Sie den removeRule Vorgang, um den ConnectorManagement Regelsatz aus der Gruppenrichtlinie zu entfernen. Die Umgebungen behalten ihre zuletzt angewendete ACP-Konfiguration bei, werden aber nicht mehr mit der Gruppe synchronisiert. Sie können jede Umgebung einzeln verwalten und sie voneinander unterscheiden lassen.
Entfernen Sie ACP aus der Gruppe und aus jeder Umgebung , um ACP überall zu deaktivieren. Entfernen Sie die Regel aus der Gruppenrichtlinie, durchlaufen Sie dann die Gruppenumgebungen, und entfernen Sie den Regelsatz auch aus der ConnectorManagement Richtlinie jeder Umgebung.

Note

Das Entfernen der Regel aus der Richtlinie einer Gruppe entfernt ACP nicht automatisch aus den Umgebungen, die diese geerbt haben. Diese Umgebungen behalten ihre zuletzt angewendete Konfiguration bei, um eine Erzwingungslücke zu vermeiden. Um ACP überall zu löschen, entfernen Sie sie aus jeder Umgebung, wie im Beispiel der Schleife gezeigt. Weitere Informationen finden Sie unter "Erweiterte Connectorrichtlinien".

Regel aus der Gruppenrichtlinie entfernen

Im folgenden Beispiel wird der ConnectorManagement Regelsatz mithilfe des removeRule Vorgangs aus einer Richtlinie entfernt.

$policyId = "<policy ID>"

# Read the policy, then send the rule set to remove
$policy = Invoke-RestMethod -Method Get `
    -Uri "$apiBaseUrl/governance/ruleBasedPolicies/$policyId`?api-version=$apiVersion" `
    -Headers $headers
$ruleSet = $policy.ruleSets | Where-Object { $_.id -eq "ConnectorManagement" }

$body = @{ name = $policy.name; ruleSets = @($ruleSet) } | ConvertTo-Json -Depth 10
Invoke-RestMethod -Method Patch `
    -Uri "$apiBaseUrl/governance/ruleBasedPolicies/$policyId/removeRule?api-version=$apiVersion" `
    -Headers $headers -ContentType "application/json" -Body $body
Write-Host "Removed the ConnectorManagement rule set from policy $policyId"

var policyId = "<policy ID>";

// Remove the ConnectorManagement rule set from the policy
var policy = await client.Governance.RuleBasedPolicies[policyId].GetAsync();
var ruleSet = policy.RuleSets.First(r => r.Id == "ConnectorManagement");

var removeRequest = new PolicyRequest { Name = policy.Name, RuleSets = new List<RuleSet> { ruleSet } };
await client.Governance.RuleBasedPolicies[policyId].RemoveRule.PatchAsync(removeRequest);
Console.WriteLine($"Removed the ConnectorManagement rule set from policy {policyId}");

async def remove_rule(client, policy_id: str):
    from mspp_management.models.policy_request import PolicyRequest

    # Remove the ConnectorManagement rule set from the policy
    policy = await client.governance.rule_based_policies.by_policy_id(policy_id).get()
    rule_set = next(r for r in policy.rule_sets if r.id == "ConnectorManagement")

    remove_request = PolicyRequest()
    remove_request.name = policy.name
    remove_request.rule_sets = [rule_set]
    await client.governance.rule_based_policies.by_policy_id(policy_id).remove_rule.patch(remove_request)
    print(f"Removed the ConnectorManagement rule set from policy {policy_id}")

Entfernen von ACP aus jeder Umgebung in der Gruppe

Um ACP in allen Umgebungen einer Gruppe zu deaktivieren, entfernen Sie zuerst die Regel aus der Gruppenrichtlinie (vorheriges Beispiel), und wiederholen Sie dann das Entfernen für die eigene Richtlinie jeder Umgebung. Lesen Sie die jeder Umgebung zugewiesene Richtlinie in ihrer Umgebungszuweisung, und rufen Sie dann removeRule für diese Richtlinie auf. Stellen Sie die Umgebungs-IDs bereit, die zur Gruppe gehören, oder führen Sie diese mithilfe der Umgebungsverwaltungs-APIs auf.

# Environment IDs that belong to the group
$environmentIds = @("<environment ID 1>", "<environment ID 2>")

foreach ($environmentId in $environmentIds) {
    # Find the policy currently assigned to the environment
    $envAssignments = Invoke-RestMethod -Method Get `
        -Uri "$apiBaseUrl/governance/ruleBasedPolicies/environments/$environmentId/assignments?api-version=$apiVersion" `
        -Headers $headers
    if (-not $envAssignments.value) { continue }
    $envPolicyId = $envAssignments.value[0].policyId

    # Remove the ConnectorManagement rule set from that environment's policy
    $envPolicy = Invoke-RestMethod -Method Get `
        -Uri "$apiBaseUrl/governance/ruleBasedPolicies/$envPolicyId`?api-version=$apiVersion" `
        -Headers $headers
    $ruleSet = $envPolicy.ruleSets | Where-Object { $_.id -eq "ConnectorManagement" }
    if ($ruleSet) {
        $body = @{ name = $envPolicy.name; ruleSets = @($ruleSet) } | ConvertTo-Json -Depth 10
        Invoke-RestMethod -Method Patch `
            -Uri "$apiBaseUrl/governance/ruleBasedPolicies/$envPolicyId/removeRule?api-version=$apiVersion" `
            -Headers $headers -ContentType "application/json" -Body $body
        Write-Host "Removed ACP from environment $environmentId"
    }
}

Derselbe Aufruf pro Umgebung removeRule funktioniert mit den zuvor gezeigten C#- und Python SDKs. Schließen Sie den Aufruf in eine Schleife über die Umgebungs-IDs der Gruppe ein.

Erweiterte Connectorrichtlinien
Regelbasierte Richtlinien – REST-API-Referenz
Authentifizierung
Tutorial: Dienstprinzipalen Rollen zuweisen
Übersicht über Die Programmierbarkeit und Erweiterbarkeit

Feedback

War diese Seite hilfreich?

Last updated on 2026-07-16