Backup Policies - Create Or Update

Service:

Data Protection

API Version:

2023-01-01

Vytvoří nebo Aktualizace zásady zálohování, které patří do trezoru záloh.

PUT https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataProtection/backupVaults/{vaultName}/backupPolicies/{backupPolicyName}?api-version=2023-01-01

Parametry identifikátoru URI

Name	V	Vyžadováno	Typ	Description
backupPolicyName	path	True	string	Název zásady
resourceGroupName	path	True	string	Název skupiny prostředků. V názvu se rozlišují malá a velká písmena.
subscriptionId	path	True	string uuid	ID cílového předplatného. Hodnota musí být UUID.
vaultName	path	True	string	Název trezoru záloh.
api-version	query	True	string	Verze rozhraní API, která se má použít pro tuto operaci.

Text požadavku

Name	Typ	Description
properties	BaseBackupPolicy: BackupPolicy	BaseBackupPolicy Vlastnosti BaseBackupPolicyResource

Odpovědi

Name	Typ	Description
200 OK	BaseBackupPolicyResource	OK
Other Status Codes	CloudError	Chybová odpověď popisující, proč operace selhala.

Zabezpečení

azure_auth

Tok Azure Active Directory OAuth2

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

Scopes

Name	Description
user_impersonation	zosobnění uživatelského účtu.

Příklady

CreateOrUpdate BackupPolicy

Sample Request

HTTP

PUT https://management.azure.com/subscriptions/04cf684a-d41f-4550-9f70-7708a3a2283b/resourceGroups/000pikumar/providers/Microsoft.DataProtection/backupVaults/PrivatePreviewVault/backupPolicies/OSSDBPolicy?api-version=2023-01-01

{
  "properties": {
    "policyRules": [
      {
        "backupParameters": {
          "backupType": "Full",
          "objectType": "AzureBackupParams"
        },
        "trigger": {
          "schedule": {
            "repeatingTimeIntervals": [
              "R/2019-11-20T08:00:00-08:00/P1W"
            ]
          },
          "taggingCriteria": [
            {
              "tagInfo": {
                "tagName": "Default"
              },
              "taggingPriority": 99,
              "isDefault": true
            },
            {
              "tagInfo": {
                "tagName": "Weekly"
              },
              "taggingPriority": 20,
              "isDefault": false,
              "criteria": [
                {
                  "scheduleTimes": [
                    "2019-03-01T13:00:00Z"
                  ],
                  "daysOfTheWeek": [
                    "Sunday"
                  ],
                  "objectType": "ScheduleBasedBackupCriteria"
                }
              ]
            }
          ],
          "objectType": "ScheduleBasedTriggerContext"
        },
        "dataStore": {
          "dataStoreType": "VaultStore",
          "objectType": "DataStoreInfoBase"
        },
        "name": "BackupWeekly",
        "objectType": "AzureBackupRule"
      },
      {
        "lifecycles": [
          {
            "sourceDataStore": {
              "dataStoreType": "VaultStore",
              "objectType": "DataStoreInfoBase"
            },
            "deleteAfter": {
              "objectType": "AbsoluteDeleteOption",
              "duration": "P1W"
            }
          }
        ],
        "isDefault": true,
        "name": "Default",
        "objectType": "AzureRetentionRule"
      },
      {
        "lifecycles": [
          {
            "sourceDataStore": {
              "dataStoreType": "VaultStore",
              "objectType": "DataStoreInfoBase"
            },
            "deleteAfter": {
              "objectType": "AbsoluteDeleteOption",
              "duration": "P12W"
            }
          }
        ],
        "isDefault": false,
        "name": "Weekly",
        "objectType": "AzureRetentionRule"
      }
    ],
    "datasourceTypes": [
      "OssDB"
    ],
    "objectType": "BackupPolicy"
  }
}

Java

import com.azure.resourcemanager.dataprotection.models.AbsoluteDeleteOption;
import com.azure.resourcemanager.dataprotection.models.AzureBackupParams;
import com.azure.resourcemanager.dataprotection.models.AzureBackupRule;
import com.azure.resourcemanager.dataprotection.models.AzureRetentionRule;
import com.azure.resourcemanager.dataprotection.models.BackupPolicy;
import com.azure.resourcemanager.dataprotection.models.BackupSchedule;
import com.azure.resourcemanager.dataprotection.models.DataStoreInfoBase;
import com.azure.resourcemanager.dataprotection.models.DataStoreTypes;
import com.azure.resourcemanager.dataprotection.models.DayOfWeek;
import com.azure.resourcemanager.dataprotection.models.RetentionTag;
import com.azure.resourcemanager.dataprotection.models.ScheduleBasedBackupCriteria;
import com.azure.resourcemanager.dataprotection.models.ScheduleBasedTriggerContext;
import com.azure.resourcemanager.dataprotection.models.SourceLifeCycle;
import com.azure.resourcemanager.dataprotection.models.TaggingCriteria;
import java.time.OffsetDateTime;
import java.util.Arrays;

/** Samples for BackupPolicies CreateOrUpdate. */
public final class Main {
    /*
     * x-ms-original-file: specification/dataprotection/resource-manager/Microsoft.DataProtection/stable/2023-01-01/examples/PolicyCRUD/CreateOrUpdateBackupPolicy.json
     */
    /**
     * Sample code: CreateOrUpdate BackupPolicy.
     *
     * @param manager Entry point to DataProtectionManager.
     */
    public static void createOrUpdateBackupPolicy(
        com.azure.resourcemanager.dataprotection.DataProtectionManager manager) {
        manager
            .backupPolicies()
            .define("OSSDBPolicy")
            .withExistingBackupVault("000pikumar", "PrivatePreviewVault")
            .withProperties(
                new BackupPolicy()
                    .withDatasourceTypes(Arrays.asList("OssDB"))
                    .withPolicyRules(
                        Arrays
                            .asList(
                                new AzureBackupRule()
                                    .withName("BackupWeekly")
                                    .withBackupParameters(new AzureBackupParams().withBackupType("Full"))
                                    .withDataStore(
                                        new DataStoreInfoBase()
                                            .withDataStoreType(DataStoreTypes.VAULT_STORE)
                                            .withObjectType("DataStoreInfoBase"))
                                    .withTrigger(
                                        new ScheduleBasedTriggerContext()
                                            .withSchedule(
                                                new BackupSchedule()
                                                    .withRepeatingTimeIntervals(
                                                        Arrays.asList("R/2019-11-20T08:00:00-08:00/P1W")))
                                            .withTaggingCriteria(
                                                Arrays
                                                    .asList(
                                                        new TaggingCriteria()
                                                            .withIsDefault(true)
                                                            .withTaggingPriority(99L)
                                                            .withTagInfo(new RetentionTag().withTagName("Default")),
                                                        new TaggingCriteria()
                                                            .withCriteria(
                                                                Arrays
                                                                    .asList(
                                                                        new ScheduleBasedBackupCriteria()
                                                                            .withDaysOfTheWeek(
                                                                                Arrays.asList(DayOfWeek.SUNDAY))
                                                                            .withScheduleTimes(
                                                                                Arrays
                                                                                    .asList(
                                                                                        OffsetDateTime
                                                                                            .parse(
                                                                                                "2019-03-01T13:00:00Z")))))
                                                            .withIsDefault(false)
                                                            .withTaggingPriority(20L)
                                                            .withTagInfo(new RetentionTag().withTagName("Weekly"))))),
                                new AzureRetentionRule()
                                    .withName("Default")
                                    .withIsDefault(true)
                                    .withLifecycles(
                                        Arrays
                                            .asList(
                                                new SourceLifeCycle()
                                                    .withDeleteAfter(new AbsoluteDeleteOption().withDuration("P1W"))
                                                    .withSourceDataStore(
                                                        new DataStoreInfoBase()
                                                            .withDataStoreType(DataStoreTypes.VAULT_STORE)
                                                            .withObjectType("DataStoreInfoBase")))),
                                new AzureRetentionRule()
                                    .withName("Weekly")
                                    .withIsDefault(false)
                                    .withLifecycles(
                                        Arrays
                                            .asList(
                                                new SourceLifeCycle()
                                                    .withDeleteAfter(new AbsoluteDeleteOption().withDuration("P12W"))
                                                    .withSourceDataStore(
                                                        new DataStoreInfoBase()
                                                            .withDataStoreType(DataStoreTypes.VAULT_STORE)
                                                            .withObjectType("DataStoreInfoBase")))))))
            .create();
    }
}

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.dataprotection import DataProtectionMgmtClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-dataprotection
# USAGE
    python create_or_update_backup_policy.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 = DataProtectionMgmtClient(
        credential=DefaultAzureCredential(),
        subscription_id="04cf684a-d41f-4550-9f70-7708a3a2283b",
    )

    response = client.backup_policies.create_or_update(
        resource_group_name="000pikumar",
        vault_name="PrivatePreviewVault",
        backup_policy_name="OSSDBPolicy",
        parameters={
            "properties": {
                "datasourceTypes": ["OssDB"],
                "objectType": "BackupPolicy",
                "policyRules": [
                    {
                        "backupParameters": {"backupType": "Full", "objectType": "AzureBackupParams"},
                        "dataStore": {"dataStoreType": "VaultStore", "objectType": "DataStoreInfoBase"},
                        "name": "BackupWeekly",
                        "objectType": "AzureBackupRule",
                        "trigger": {
                            "objectType": "ScheduleBasedTriggerContext",
                            "schedule": {"repeatingTimeIntervals": ["R/2019-11-20T08:00:00-08:00/P1W"]},
                            "taggingCriteria": [
                                {"isDefault": True, "tagInfo": {"tagName": "Default"}, "taggingPriority": 99},
                                {
                                    "criteria": [
                                        {
                                            "daysOfTheWeek": ["Sunday"],
                                            "objectType": "ScheduleBasedBackupCriteria",
                                            "scheduleTimes": ["2019-03-01T13:00:00Z"],
                                        }
                                    ],
                                    "isDefault": False,
                                    "tagInfo": {"tagName": "Weekly"},
                                    "taggingPriority": 20,
                                },
                            ],
                        },
                    },
                    {
                        "isDefault": True,
                        "lifecycles": [
                            {
                                "deleteAfter": {"duration": "P1W", "objectType": "AbsoluteDeleteOption"},
                                "sourceDataStore": {"dataStoreType": "VaultStore", "objectType": "DataStoreInfoBase"},
                            }
                        ],
                        "name": "Default",
                        "objectType": "AzureRetentionRule",
                    },
                    {
                        "isDefault": False,
                        "lifecycles": [
                            {
                                "deleteAfter": {"duration": "P12W", "objectType": "AbsoluteDeleteOption"},
                                "sourceDataStore": {"dataStoreType": "VaultStore", "objectType": "DataStoreInfoBase"},
                            }
                        ],
                        "name": "Weekly",
                        "objectType": "AzureRetentionRule",
                    },
                ],
            }
        },
    )
    print(response)


# x-ms-original-file: specification/dataprotection/resource-manager/Microsoft.DataProtection/stable/2023-01-01/examples/PolicyCRUD/CreateOrUpdateBackupPolicy.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 armdataprotection_test

import (
	"context"
	"log"

	"time"

	"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/dataprotection/armdataprotection/v2"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/1b33e81bbdc28fcd6644a1315b8d7b1b6d030590/specification/dataprotection/resource-manager/Microsoft.DataProtection/stable/2023-01-01/examples/PolicyCRUD/CreateOrUpdateBackupPolicy.json
func ExampleBackupPoliciesClient_CreateOrUpdate() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdataprotection.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewBackupPoliciesClient().CreateOrUpdate(ctx, "000pikumar", "PrivatePreviewVault", "OSSDBPolicy", armdataprotection.BaseBackupPolicyResource{
		Properties: &armdataprotection.BackupPolicy{
			DatasourceTypes: []*string{
				to.Ptr("OssDB")},
			ObjectType: to.Ptr("BackupPolicy"),
			PolicyRules: []armdataprotection.BasePolicyRuleClassification{
				&armdataprotection.AzureBackupRule{
					Name:       to.Ptr("BackupWeekly"),
					ObjectType: to.Ptr("AzureBackupRule"),
					BackupParameters: &armdataprotection.AzureBackupParams{
						ObjectType: to.Ptr("AzureBackupParams"),
						BackupType: to.Ptr("Full"),
					},
					DataStore: &armdataprotection.DataStoreInfoBase{
						DataStoreType: to.Ptr(armdataprotection.DataStoreTypesVaultStore),
						ObjectType:    to.Ptr("DataStoreInfoBase"),
					},
					Trigger: &armdataprotection.ScheduleBasedTriggerContext{
						ObjectType: to.Ptr("ScheduleBasedTriggerContext"),
						Schedule: &armdataprotection.BackupSchedule{
							RepeatingTimeIntervals: []*string{
								to.Ptr("R/2019-11-20T08:00:00-08:00/P1W")},
						},
						TaggingCriteria: []*armdataprotection.TaggingCriteria{
							{
								IsDefault: to.Ptr(true),
								TagInfo: &armdataprotection.RetentionTag{
									TagName: to.Ptr("Default"),
								},
								TaggingPriority: to.Ptr[int64](99),
							},
							{
								Criteria: []armdataprotection.BackupCriteriaClassification{
									&armdataprotection.ScheduleBasedBackupCriteria{
										ObjectType: to.Ptr("ScheduleBasedBackupCriteria"),
										DaysOfTheWeek: []*armdataprotection.DayOfWeek{
											to.Ptr(armdataprotection.DayOfWeekSunday)},
										ScheduleTimes: []*time.Time{
											to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2019-03-01T13:00:00Z"); return t }())},
									}},
								IsDefault: to.Ptr(false),
								TagInfo: &armdataprotection.RetentionTag{
									TagName: to.Ptr("Weekly"),
								},
								TaggingPriority: to.Ptr[int64](20),
							}},
					},
				},
				&armdataprotection.AzureRetentionRule{
					Name:       to.Ptr("Default"),
					ObjectType: to.Ptr("AzureRetentionRule"),
					IsDefault:  to.Ptr(true),
					Lifecycles: []*armdataprotection.SourceLifeCycle{
						{
							DeleteAfter: &armdataprotection.AbsoluteDeleteOption{
								Duration:   to.Ptr("P1W"),
								ObjectType: to.Ptr("AbsoluteDeleteOption"),
							},
							SourceDataStore: &armdataprotection.DataStoreInfoBase{
								DataStoreType: to.Ptr(armdataprotection.DataStoreTypesVaultStore),
								ObjectType:    to.Ptr("DataStoreInfoBase"),
							},
						}},
				},
				&armdataprotection.AzureRetentionRule{
					Name:       to.Ptr("Weekly"),
					ObjectType: to.Ptr("AzureRetentionRule"),
					IsDefault:  to.Ptr(false),
					Lifecycles: []*armdataprotection.SourceLifeCycle{
						{
							DeleteAfter: &armdataprotection.AbsoluteDeleteOption{
								Duration:   to.Ptr("P12W"),
								ObjectType: to.Ptr("AbsoluteDeleteOption"),
							},
							SourceDataStore: &armdataprotection.DataStoreInfoBase{
								DataStoreType: to.Ptr(armdataprotection.DataStoreTypesVaultStore),
								ObjectType:    to.Ptr("DataStoreInfoBase"),
							},
						}},
				}},
		},
	}, 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.BaseBackupPolicyResource = armdataprotection.BaseBackupPolicyResource{
	// 	Name: to.Ptr("OSSDBPolicy"),
	// 	Type: to.Ptr("Microsoft.DataProtection/backupVaults/backupPolicies"),
	// 	ID: to.Ptr("/subscriptions/04cf684a-d41f-4550-9f70-7708a3a2283b/resourceGroups/000pikumar/providers/Microsoft.DataProtection/backupVaults/PrivatePreviewVault/backupPolicies/OSSDBPolicy"),
	// 	Properties: &armdataprotection.BackupPolicy{
	// 		DatasourceTypes: []*string{
	// 			to.Ptr("OssDB")},
	// 			ObjectType: to.Ptr("BackupPolicy"),
	// 			PolicyRules: []armdataprotection.BasePolicyRuleClassification{
	// 				&armdataprotection.AzureBackupRule{
	// 					Name: to.Ptr("BackupWeekly"),
	// 					ObjectType: to.Ptr("AzureBackupRule"),
	// 					BackupParameters: &armdataprotection.AzureBackupParams{
	// 						ObjectType: to.Ptr("AzureBackupParams"),
	// 						BackupType: to.Ptr("Full"),
	// 					},
	// 					DataStore: &armdataprotection.DataStoreInfoBase{
	// 						DataStoreType: to.Ptr(armdataprotection.DataStoreTypesVaultStore),
	// 						ObjectType: to.Ptr("DataStoreInfoBase"),
	// 					},
	// 					Trigger: &armdataprotection.ScheduleBasedTriggerContext{
	// 						ObjectType: to.Ptr("ScheduleBasedTriggerContext"),
	// 						Schedule: &armdataprotection.BackupSchedule{
	// 							RepeatingTimeIntervals: []*string{
	// 								to.Ptr("R/2019-11-20T08:00:00-08:00/P1W")},
	// 							},
	// 							TaggingCriteria: []*armdataprotection.TaggingCriteria{
	// 								{
	// 									IsDefault: to.Ptr(true),
	// 									TagInfo: &armdataprotection.RetentionTag{
	// 										ID: to.Ptr("Default_"),
	// 										TagName: to.Ptr("Default"),
	// 									},
	// 									TaggingPriority: to.Ptr[int64](99),
	// 								},
	// 								{
	// 									Criteria: []armdataprotection.BackupCriteriaClassification{
	// 										&armdataprotection.ScheduleBasedBackupCriteria{
	// 											ObjectType: to.Ptr("ScheduleBasedBackupCriteria"),
	// 											DaysOfTheWeek: []*armdataprotection.DayOfWeek{
	// 												to.Ptr(armdataprotection.DayOfWeekSunday)},
	// 												ScheduleTimes: []*time.Time{
	// 													to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2019-03-01T13:00:00Z"); return t}())},
	// 											}},
	// 											IsDefault: to.Ptr(false),
	// 											TagInfo: &armdataprotection.RetentionTag{
	// 												ID: to.Ptr("Weekly_"),
	// 												TagName: to.Ptr("Weekly"),
	// 											},
	// 											TaggingPriority: to.Ptr[int64](20),
	// 									}},
	// 								},
	// 							},
	// 							&armdataprotection.AzureRetentionRule{
	// 								Name: to.Ptr("Default"),
	// 								ObjectType: to.Ptr("AzureRetentionRule"),
	// 								IsDefault: to.Ptr(true),
	// 								Lifecycles: []*armdataprotection.SourceLifeCycle{
	// 									{
	// 										DeleteAfter: &armdataprotection.AbsoluteDeleteOption{
	// 											Duration: to.Ptr("P1W"),
	// 											ObjectType: to.Ptr("AbsoluteDeleteOption"),
	// 										},
	// 										SourceDataStore: &armdataprotection.DataStoreInfoBase{
	// 											DataStoreType: to.Ptr(armdataprotection.DataStoreTypesVaultStore),
	// 											ObjectType: to.Ptr("DataStoreInfoBase"),
	// 										},
	// 								}},
	// 							},
	// 							&armdataprotection.AzureRetentionRule{
	// 								Name: to.Ptr("Weekly"),
	// 								ObjectType: to.Ptr("AzureRetentionRule"),
	// 								IsDefault: to.Ptr(false),
	// 								Lifecycles: []*armdataprotection.SourceLifeCycle{
	// 									{
	// 										DeleteAfter: &armdataprotection.AbsoluteDeleteOption{
	// 											Duration: to.Ptr("P12W"),
	// 											ObjectType: to.Ptr("AbsoluteDeleteOption"),
	// 										},
	// 										SourceDataStore: &armdataprotection.DataStoreInfoBase{
	// 											DataStoreType: to.Ptr(armdataprotection.DataStoreTypesVaultStore),
	// 											ObjectType: to.Ptr("DataStoreInfoBase"),
	// 										},
	// 								}},
	// 						}},
	// 					},
	// 				}
}

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 { DataProtectionClient } = require("@azure/arm-dataprotection");
const { DefaultAzureCredential } = require("@azure/identity");

/**
 * This sample demonstrates how to Creates or Updates a backup policy belonging to a backup vault
 *
 * @summary Creates or Updates a backup policy belonging to a backup vault
 * x-ms-original-file: specification/dataprotection/resource-manager/Microsoft.DataProtection/stable/2023-01-01/examples/PolicyCRUD/CreateOrUpdateBackupPolicy.json
 */
async function createOrUpdateBackupPolicy() {
  const subscriptionId =
    process.env["DATAPROTECTION_SUBSCRIPTION_ID"] || "04cf684a-d41f-4550-9f70-7708a3a2283b";
  const resourceGroupName = process.env["DATAPROTECTION_RESOURCE_GROUP"] || "000pikumar";
  const vaultName = "PrivatePreviewVault";
  const backupPolicyName = "OSSDBPolicy";
  const parameters = {
    properties: {
      datasourceTypes: ["OssDB"],
      objectType: "BackupPolicy",
      policyRules: [
        {
          name: "BackupWeekly",
          backupParameters: {
            backupType: "Full",
            objectType: "AzureBackupParams",
          },
          dataStore: {
            dataStoreType: "VaultStore",
            objectType: "DataStoreInfoBase",
          },
          objectType: "AzureBackupRule",
          trigger: {
            objectType: "ScheduleBasedTriggerContext",
            schedule: {
              repeatingTimeIntervals: ["R/2019-11-20T08:00:00-08:00/P1W"],
            },
            taggingCriteria: [
              {
                isDefault: true,
                tagInfo: { tagName: "Default" },
                taggingPriority: 99,
              },
              {
                criteria: [
                  {
                    daysOfTheWeek: ["Sunday"],
                    objectType: "ScheduleBasedBackupCriteria",
                    scheduleTimes: [new Date("2019-03-01T13:00:00Z")],
                  },
                ],
                isDefault: false,
                tagInfo: { tagName: "Weekly" },
                taggingPriority: 20,
              },
            ],
          },
        },
        {
          name: "Default",
          isDefault: true,
          lifecycles: [
            {
              deleteAfter: {
                duration: "P1W",
                objectType: "AbsoluteDeleteOption",
              },
              sourceDataStore: {
                dataStoreType: "VaultStore",
                objectType: "DataStoreInfoBase",
              },
            },
          ],
          objectType: "AzureRetentionRule",
        },
        {
          name: "Weekly",
          isDefault: false,
          lifecycles: [
            {
              deleteAfter: {
                duration: "P12W",
                objectType: "AbsoluteDeleteOption",
              },
              sourceDataStore: {
                dataStoreType: "VaultStore",
                objectType: "DataStoreInfoBase",
              },
            },
          ],
          objectType: "AzureRetentionRule",
        },
      ],
    },
  };
  const credential = new DefaultAzureCredential();
  const client = new DataProtectionClient(credential, subscriptionId);
  const result = await client.backupPolicies.createOrUpdate(
    resourceGroupName,
    vaultName,
    backupPolicyName,
    parameters
  );
  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

Sample Response

Status code:

200

{
  "id": "/subscriptions/04cf684a-d41f-4550-9f70-7708a3a2283b/resourceGroups/000pikumar/providers/Microsoft.DataProtection/backupVaults/PrivatePreviewVault/backupPolicies/OSSDBPolicy",
  "name": "OSSDBPolicy",
  "type": "Microsoft.DataProtection/backupVaults/backupPolicies",
  "properties": {
    "policyRules": [
      {
        "backupParameters": {
          "backupType": "Full",
          "objectType": "AzureBackupParams"
        },
        "trigger": {
          "schedule": {
            "repeatingTimeIntervals": [
              "R/2019-11-20T08:00:00-08:00/P1W"
            ]
          },
          "taggingCriteria": [
            {
              "tagInfo": {
                "tagName": "Default",
                "id": "Default_"
              },
              "taggingPriority": 99,
              "isDefault": true
            },
            {
              "tagInfo": {
                "tagName": "Weekly",
                "id": "Weekly_"
              },
              "taggingPriority": 20,
              "isDefault": false,
              "criteria": [
                {
                  "scheduleTimes": [
                    "2019-03-01T13:00:00Z"
                  ],
                  "daysOfTheWeek": [
                    "Sunday"
                  ],
                  "objectType": "ScheduleBasedBackupCriteria"
                }
              ]
            }
          ],
          "objectType": "ScheduleBasedTriggerContext"
        },
        "dataStore": {
          "dataStoreType": "VaultStore",
          "objectType": "DataStoreInfoBase"
        },
        "name": "BackupWeekly",
        "objectType": "AzureBackupRule"
      },
      {
        "lifecycles": [
          {
            "sourceDataStore": {
              "dataStoreType": "VaultStore",
              "objectType": "DataStoreInfoBase"
            },
            "deleteAfter": {
              "objectType": "AbsoluteDeleteOption",
              "duration": "P1W"
            }
          }
        ],
        "isDefault": true,
        "name": "Default",
        "objectType": "AzureRetentionRule"
      },
      {
        "lifecycles": [
          {
            "sourceDataStore": {
              "dataStoreType": "VaultStore",
              "objectType": "DataStoreInfoBase"
            },
            "deleteAfter": {
              "objectType": "AbsoluteDeleteOption",
              "duration": "P12W"
            }
          }
        ],
        "isDefault": false,
        "name": "Weekly",
        "objectType": "AzureRetentionRule"
      }
    ],
    "datasourceTypes": [
      "OssDB"
    ],
    "objectType": "BackupPolicy"
  }
}

Definice

Name	Description
AbsoluteDeleteOption	AbsoluteDeleteOption
AbsoluteMarker	obsahuje absolutní hodnoty jako "AllBackup" / "FirstOfDay" / "FirstOfWeek" / "FirstOfMonth" a měl by být součástí výčtu AbsoluteMarker.
AdhocBasedTaggingCriteria	AdhocBasedTaggingCriteria
AdhocBasedTriggerContext	AdhocBasedTriggerContext
AzureBackupParams	AzureBackupParams
AzureBackupRule	AzureBackupRule
AzureRetentionRule	AzureRetentionRule
BackupPolicy	Zásady zálohování
BackupSchedule	BackupSchedule
BaseBackupPolicyResource	BaseBackupPolicyResource
CloudError	CloudError
CopyOnExpiryOption	CopyOnExpiryOption
createdByType	Typ identity, která vytvořila prostředek.
CustomCopyOption	CustomCopyOption
DataStoreInfoBase	DataStoreInfoBase
DataStoreTypes	typ úložiště dat; Provoz/Trezor/Archiv
Day	Den
DayOfWeek	Měla by to být neděle/pondělí/t..../sobota
Error	Odpověď na chybu správy prostředků
ErrorAdditionalInfo	Další informace o chybě správy prostředků
ImmediateCopyOption	ImmediateCopyOption
Month	Mělo by to být leden/únor/....../prosinec.
RetentionTag	RetentionTag
ScheduleBasedBackupCriteria	ScheduleBasedBackupCriteria
ScheduleBasedTriggerContext	ScheduleBasedTriggerContext
SourceLifeCycle	SourceLifeCycle
systemData	Metadata týkající se vytvoření a poslední změny prostředku
TaggingCriteria	TaggingCriteria
TargetCopySetting	TargetCopySetting
WeekNumber	Měla by být první/druhá/třetí/čtvrtá/poslední.

AbsoluteDeleteOption

AbsoluteDeleteOption

Name	Typ	Description
duration	string	Doba odstranění po daném časovém rozsahu
objectType	string: AbsoluteDeleteOption	Typ konkrétního objektu – slouží k deserializaci.

AbsoluteMarker

obsahuje absolutní hodnoty jako "AllBackup" / "FirstOfDay" / "FirstOfWeek" / "FirstOfMonth" a měl by být součástí výčtu AbsoluteMarker.

Name	Typ	Description
AllBackup	string
FirstOfDay	string
FirstOfMonth	string
FirstOfWeek	string
FirstOfYear	string

AdhocBasedTaggingCriteria

AdhocBasedTaggingCriteria

Name	Typ	Description
tagInfo	RetentionTag	RetentionTag Informace o značkách uchovávání informací

AdhocBasedTriggerContext

AdhocBasedTriggerContext

Name	Typ	Description
objectType	string: AdhocBasedTriggerContext	Typ konkrétního objektu – slouží k deserializaci.
taggingCriteria	AdhocBasedTaggingCriteria	AdhocBasedTaggingCriteria Kritéria označování obsahující značku uchovávání informací pro adhoc zálohování.

AzureBackupParams

AzureBackupParams

Name	Typ	Description
backupType	string	BackupType ; Úplná/přírůstková atd.
objectType	string: AzureBackupParams	Typ konkrétního objektu – slouží k deserializaci.

AzureBackupRule

AzureBackupRule

Name	Typ	Description
backupParameters	BackupParameters: AzureBackupParams	BackupParameters BackupParameters – základna
dataStore	DataStoreInfoBase	DataStoreInfoBase DataStoreInfo – základna
name	string
objectType	string: AzureBackupRule
trigger	TriggerContext: AdhocBasedTriggerContext ScheduleBasedTriggerContext	TriggerContext Kontext triggeru

AzureRetentionRule

AzureRetentionRule

Name	Typ	Description
isDefault	boolean
lifecycles	SourceLifeCycle[]	SourceLifeCycle Životní cyklus zdroje
name	string
objectType	string: AzureRetentionRule

BackupPolicy

Zásady zálohování

Name	Typ	Description
datasourceTypes	string[]	Typ zdroje dat pro správu zálohování
objectType	string: BackupPolicy
policyRules	BasePolicyRule[]: AzureBackupRule[] AzureRetentionRule[]	Slovník pravidel zásad, který obsahuje pravidla pro každý typ zálohování, tj. úplné, přírůstkové, protokoly atd.

BackupSchedule

BackupSchedule

Name	Typ	Description
repeatingTimeIntervals	string[]	Formát časového intervalu opakování ISO 8601
timeZone	string	Časové pásmo pro plán. Příklad: Tichomoří (běžný čas)

BaseBackupPolicyResource

BaseBackupPolicyResource

Name	Typ	Description
id	string	ID prostředku představuje úplnou cestu k prostředku.
name	string	Název prostředku přidružený k prostředku.
properties	BaseBackupPolicy: BackupPolicy	BaseBackupPolicy Vlastnosti BaseBackupPolicyResource
systemData	systemData	Metadata týkající se vytvoření a poslední změny prostředku
type	string	Typ prostředku představuje úplnou cestu formuláře Namespace/ResourceType/ResourceType/...

CloudError

CloudError

Name	Typ	Description
error	Error	Odpověď na chybu správy prostředků

CopyOnExpiryOption

CopyOnExpiryOption

Name	Typ	Description
objectType	string: CopyOnExpiryOption	Typ konkrétního objektu – slouží k deserializaci.

createdByType

Typ identity, která vytvořila prostředek.

Name	Typ	Description
Application	string
Key	string
ManagedIdentity	string
User	string

CustomCopyOption

CustomCopyOption

Name	Typ	Description
duration	string	Data zkopírovaná po daném časovém rozsahu
objectType	string: CustomCopyOption	Typ konkrétního objektu – slouží k deserializaci.

DataStoreInfoBase

DataStoreInfoBase

Name	Typ	Description
dataStoreType	DataStoreTypes	typ úložiště dat; Provoz/Trezor/Archiv
objectType	string	Typ objektu Datasource, který slouží k inicializaci pravého zděděného typu

DataStoreTypes

typ úložiště dat; Provoz/Trezor/Archiv

Name	Typ	Description
ArchiveStore	string
OperationalStore	string
VaultStore	string

Day

Den

Name	Typ	Description
date	integer	Datum v měsíci
isLast	boolean	Určuje, jestli je datum posledním datem v měsíci.

DayOfWeek

Měla by to být neděle/pondělí/t..../sobota

Name	Typ	Description
Friday	string
Monday	string
Saturday	string
Sunday	string
Thursday	string
Tuesday	string
Wednesday	string

Error

Odpověď na chybu správy prostředků

Name	Typ	Description
additionalInfo	ErrorAdditionalInfo[]	Další informace o chybě
code	string	Kód chyby
details	Error[]	Podrobnosti o chybě
message	string	Chybová zpráva
target	string	Cíl chyby.

ErrorAdditionalInfo

Další informace o chybě správy prostředků

Name	Typ	Description
info	object	Další informace.
type	string	Další typ informací.

ImmediateCopyOption

ImmediateCopyOption

Name	Typ	Description
objectType	string: ImmediateCopyOption	Typ konkrétního objektu – slouží k deserializaci.

Month

Mělo by to být leden/únor/....../prosinec.

Name	Typ	Description
April	string
August	string
December	string
February	string
January	string
July	string
June	string
March	string
May	string
November	string
October	string
September	string

RetentionTag

RetentionTag

Name	Typ	Description
eTag	string	Verze značky uchovávání informací.
id	string	Verze značky uchovávání informací.
tagName	string	Název značky uchovávání informací pro jeho vztah k pravidlu uchovávání informací.

ScheduleBasedBackupCriteria

ScheduleBasedBackupCriteria

Name	Typ	Description
absoluteCriteria	AbsoluteMarker[]	obsahuje absolutní hodnoty jako "AllBackup" / "FirstOfDay" / "FirstOfWeek" / "FirstOfMonth" a měl by být součástí výčtu AbsoluteMarker.
daysOfMonth	Day[]	Toto je den v měsíci od 1 do 28 dalších moudrých posledních měsíců.
daysOfTheWeek	DayOfWeek[]	Měla by to být neděle/pondělí/t..../sobota
monthsOfYear	Month[]	Mělo by to být leden/únor/....../prosinec.
objectType	string: ScheduleBasedBackupCriteria	Typ konkrétního objektu – slouží k deserializaci.
scheduleTimes	string[]	Seznam naplánovaných časů zálohování
weeksOfTheMonth	WeekNumber[]	Měla by být první/druhá/třetí/čtvrtá/poslední.

ScheduleBasedTriggerContext

ScheduleBasedTriggerContext

Name	Typ	Description
objectType	string: ScheduleBasedTriggerContext	Typ konkrétního objektu – slouží k deserializaci.
schedule	BackupSchedule	BackupSchedule Plán pro toto zálohování
taggingCriteria	TaggingCriteria[]	Seznam značek, které lze použít pro daný plán

SourceLifeCycle

SourceLifeCycle

Name	Typ	Description
deleteAfter	DeleteOption: AbsoluteDeleteOption	DeleteOption Odstranit možnost
sourceDataStore	DataStoreInfoBase	DataStoreInfoBase DataStoreInfo – základna
targetDataStoreCopySettings	TargetCopySetting[]	TargetCopySetting Nastavení cílového kopírování

systemData

Metadata týkající se vytvoření a poslední změny prostředku

Name	Typ	Description
createdAt	string	Časové razítko vytvoření prostředku (UTC)
createdBy	string	Identita, která prostředek vytvořila.
createdByType	createdByType	Typ identity, která vytvořila prostředek.
lastModifiedAt	string	Časové razítko poslední změny prostředku (UTC)
lastModifiedBy	string	Identita, která naposledy změnila prostředek.
lastModifiedByType	createdByType	Typ identity, která naposledy změnila prostředek.

TaggingCriteria

TaggingCriteria

Name	Typ	Description
criteria	BackupCriteria[]: ScheduleBasedBackupCriteria[]	Kritéria, která rozhodují o tom, jestli je možné značku použít na aktivovanou zálohu.
isDefault	boolean	Určuje, jestli je výchozí značka.
tagInfo	RetentionTag	RetentionTag Informace o značkách uchovávání informací
taggingPriority	integer	Priorita značky uchovávání informací.

TargetCopySetting

TargetCopySetting

Name	Typ	Description
copyAfter	CopyOption: CopyOnExpiryOption CustomCopyOption ImmediateCopyOption	CopyOption Může to být CustomCopyOption nebo ImmediateCopyOption.
dataStore	DataStoreInfoBase	DataStoreInfoBase Informace o cílovém úložišti dat

WeekNumber

Měla by být první/druhá/třetí/čtvrtá/poslední.

Name	Typ	Description
First	string
Fourth	string
Last	string
Second	string
Third	string