透過 API 管理快訊政策

static void RestorePolicies(string projectId, string filePath) {     var policyClient = AlertPolicyServiceClient.Create();     var channelClient = NotificationChannelServiceClient.Create();     List<Exception> exceptions = new List<Exception>();     var backup = JsonConvert.DeserializeObject<BackupRecord>(         File.ReadAllText(filePath), new ProtoMessageConverter());     var projectName = new ProjectName(projectId);     bool isSameProject = projectId == backup.ProjectId;     // When a channel is recreated, rather than updated, it will get     // a new name.  We have to update the AlertPolicy with the new     // name.  Track the names in this map.     var channelNameMap = new Dictionary<string, string>();     foreach (NotificationChannel channel in backup.Channels)     {     }     foreach (AlertPolicy policy in backup.Policies)     {         string policyName = policy.Name;         // These two fields cannot be set directly, so clear them.         policy.CreationRecord = null;         policy.MutationRecord = null;         // Update channel names if the channel was recreated with         // another name.         for (int i = 0; i < policy.NotificationChannels.Count; ++i)         {             if (channelNameMap.ContainsKey(policy.NotificationChannels[i]))             {                 policy.NotificationChannels[i] =                     channelNameMap[policy.NotificationChannels[i]];             }         }         try         {             Console.WriteLine("Updating policy.\n{0}",                 policy.DisplayName);             bool updated = false;             if (isSameProject)                 try                 {                     policyClient.UpdateAlertPolicy(null, policy);                     updated = true;                 }                 catch (Grpc.Core.RpcException e)                 when (e.Status.StatusCode == StatusCode.NotFound)                 { }             if (!updated)             {                 // The policy no longer exists.  Recreate it.                 policy.Name = null;                 foreach (var condition in policy.Conditions)                 {                     condition.Name = null;                 }                 policyClient.CreateAlertPolicy(projectName, policy);             }             Console.WriteLine("Restored {0}.", policyName);         }         catch (Exception e)         {             // If one failed, continue trying to update the others.             exceptions.Add(e);         }     }     if (exceptions.Count > 0)     {         throw new AggregateException(exceptions);     } } 

 // restorePolicies updates the project with the alert policies and // notification channels in r. func restorePolicies(w io.Writer, projectID string, r io.Reader) error { 	b := backup{} 	if err := json.NewDecoder(r).Decode(&b); err != nil { 		return err 	} 	sameProject := projectID == b.ProjectID  	ctx := context.Background()  	alertClient, err := monitoring.NewAlertPolicyClient(ctx) 	if err != nil { 		return err 	} 	defer alertClient.Close() 	channelClient, err := monitoring.NewNotificationChannelClient(ctx) 	if err != nil { 		return err 	} 	defer channelClient.Close()  	// When a channel is recreated, rather than updated, it will get 	// a new name.  We have to update the AlertPolicy with the new 	// name.  channelNames keeps track of the new names. 	channelNames := make(map[string]string) 	for _, c := range b.Channels { 		fmt.Fprintf(w, "Updating channel %q\n", c.GetDisplayName()) 		c.VerificationStatus = monitoringpb.NotificationChannel_VERIFICATION_STATUS_UNSPECIFIED 		updated := false 		if sameProject { 			req := &monitoringpb.UpdateNotificationChannelRequest{ 				NotificationChannel: c.NotificationChannel, 			} 			_, err := channelClient.UpdateNotificationChannel(ctx, req) 			if err == nil { 				updated = true 			} 		} 		if !updated { 			req := &monitoringpb.CreateNotificationChannelRequest{ 				Name:                "projects/" + projectID, 				NotificationChannel: c.NotificationChannel, 			} 			oldName := c.GetName() 			c.Name = "" 			newC, err := channelClient.CreateNotificationChannel(ctx, req) 			if err != nil { 				return err 			} 			channelNames[oldName] = newC.GetName() 		} 	}  	for _, policy := range b.AlertPolicies { 		fmt.Fprintf(w, "Updating alert %q\n", policy.GetDisplayName()) 		policy.CreationRecord = nil 		policy.MutationRecord = nil 		for i, aChannel := range policy.GetNotificationChannels() { 			if c, ok := channelNames[aChannel]; ok { 				policy.NotificationChannels[i] = c 			} 		} 		updated := false 		if sameProject { 			req := &monitoringpb.UpdateAlertPolicyRequest{ 				AlertPolicy: policy.AlertPolicy, 			} 			_, err := alertClient.UpdateAlertPolicy(ctx, req) 			if err == nil { 				updated = true 			} 		} 		if !updated { 			req := &monitoringpb.CreateAlertPolicyRequest{ 				Name:        "projects/" + projectID, 				AlertPolicy: policy.AlertPolicy, 			} 			if _, err = alertClient.CreateAlertPolicy(ctx, req); err != nil { 				log.Fatal(err) 			} 		} 	} 	fmt.Fprintf(w, "Successfully restored alerts.") 	return nil } 

private static void restoreRevisedPolicies(     String projectId, boolean isSameProject, List<AlertPolicy> policies) throws IOException {   try (AlertPolicyServiceClient client = AlertPolicyServiceClient.create()) {     for (AlertPolicy policy : policies) {       if (!isSameProject) {         policy = client.createAlertPolicy(ProjectName.of(projectId), policy);       } else {         try {           client.updateAlertPolicy(null, policy);         } catch (Exception e) {           policy =               client.createAlertPolicy(                   ProjectName.of(projectId), policy.toBuilder().clearName().build());         }       }       System.out.println(String.format("Restored %s", policy.getName()));     }   } }

const fs = require('fs');  // Imports the Google Cloud client library const monitoring = require('@google-cloud/monitoring');  // Creates a client const client = new monitoring.AlertPolicyServiceClient();  async function restorePolicies() {   // Note: The policies are restored one at a time due to limitations in   // the API. Otherwise, you may receive a 'service unavailable'  error   // while trying to create multiple alerts simultaneously.    /**    * TODO(developer): Uncomment the following lines before running the sample.    */   // const projectId = 'YOUR_PROJECT_ID';    console.log('Loading policies from ./policies_backup.json');   const fileContent = fs.readFileSync('./policies_backup.json', 'utf-8');   const policies = JSON.parse(fileContent);    for (const index in policies) {     // Restore each policy one at a time     let policy = policies[index];     if (await doesAlertPolicyExist(policy.name)) {       policy = await client.updateAlertPolicy({         alertPolicy: policy,       });     } else {       // Clear away output-only fields       delete policy.name;       delete policy.creationRecord;       delete policy.mutationRecord;       policy.conditions.forEach(condition => delete condition.name);        policy = await client.createAlertPolicy({         name: client.projectPath(projectId),         alertPolicy: policy,       });     }      console.log(`Restored ${policy[0].name}.`);   }   async function doesAlertPolicyExist(name) {     try {       const [policy] = await client.getAlertPolicy({         name,       });       return policy ? true : false;     } catch (err) {       if (err && err.code === 5) {         // Error code 5 comes from the google.rpc.code.NOT_FOUND protobuf         return false;       }       throw err;     }   } } restorePolicies();

use Google\Cloud\Monitoring\V3\AlertPolicy; use Google\Cloud\Monitoring\V3\AlertPolicy\Condition; use Google\Cloud\Monitoring\V3\AlertPolicy\Condition\MetricThreshold; use Google\Cloud\Monitoring\V3\AlertPolicy\ConditionCombinerType; use Google\Cloud\Monitoring\V3\Client\AlertPolicyServiceClient; use Google\Cloud\Monitoring\V3\ComparisonType; use Google\Cloud\Monitoring\V3\CreateAlertPolicyRequest; use Google\Protobuf\Duration;  /**  * @param string $projectId Your project ID  */ function alert_create_policy($projectId) {     $alertClient = new AlertPolicyServiceClient([         'projectId' => $projectId,     ]);     $projectName = 'projects/' . $projectId;      $policy = new AlertPolicy();     $policy->setDisplayName('Test Alert Policy');     $policy->setCombiner(ConditionCombinerType::PBOR);     /** @see https://cloud.google.com/monitoring/api/resources for a list of resource.type */     /** @see https://cloud.google.com/monitoring/api/metrics_gcp for a list of metric.type */     $policy->setConditions([new Condition([         'display_name' => 'condition-1',         'condition_threshold' => new MetricThreshold([             'filter' => 'resource.type = "gce_instance" AND metric.type = "compute.googleapis.com/instance/cpu/utilization"',             'duration' => new Duration(['seconds' => '60']),             'comparison' => ComparisonType::COMPARISON_LT,         ])     ])]);     $createAlertPolicyRequest = (new CreateAlertPolicyRequest())         ->setName($projectName)         ->setAlertPolicy($policy);      $policy = $alertClient->createAlertPolicy($createAlertPolicyRequest);     printf('Created alert policy %s' . PHP_EOL, $policy->getName()); }

def restore(project_name, backup_filename):     """Restore alert policies in a project.      Arguments:         project_name (str): The Google Cloud Project to use. The project name             must be in the format - 'projects/<PROJECT_NAME>'.         backup_filename (str): Name of the file (along with its path) from             which the alert policies will be restored.     """     print(         "Loading alert policies and notification channels from {}.".format(             backup_filename         )     )     record = json.load(open(backup_filename, "rt"))     is_same_project = project_name == record["project_name"]     # Convert dicts to AlertPolicies.     policies_json = [json.dumps(policy) for policy in record["policies"]]     policies = [         monitoring_v3.AlertPolicy.from_json(policy_json)         for policy_json in policies_json     ]     # Convert dicts to NotificationChannels     channels_json = [json.dumps(channel) for channel in record["channels"]]     channels = [         monitoring_v3.NotificationChannel.from_json(channel_json)         for channel_json in channels_json     ]      # Restore the channels.     channel_client = monitoring_v3.NotificationChannelServiceClient()     channel_name_map = {}      for channel in channels:         updated = False         print("Updating channel", channel.display_name)         # This field is immutable and it is illegal to specify a         # non-default value (UNVERIFIED or VERIFIED) in the         # Create() or Update() operations.         channel.verification_status = (             monitoring_v3.NotificationChannel.VerificationStatus.VERIFICATION_STATUS_UNSPECIFIED         )          if is_same_project:             try:                 channel_client.update_notification_channel(notification_channel=channel)                 updated = True             except google.api_core.exceptions.NotFound:                 pass  # The channel was deleted.  Create it below.          if not updated:             # The channel no longer exists.  Recreate it.             old_name = channel.name             del channel.name             new_channel = channel_client.create_notification_channel(                 name=project_name, notification_channel=channel             )             channel_name_map[old_name] = new_channel.name      # Restore the alerts     alert_client = monitoring_v3.AlertPolicyServiceClient()      for policy in policies:         print("Updating policy", policy.display_name)         # These two fields cannot be set directly, so clear them.         del policy.creation_record         del policy.mutation_record          # Update old channel names with new channel names.         for i, channel in enumerate(policy.notification_channels):             new_channel = channel_name_map.get(channel)             if new_channel:                 policy.notification_channels[i] = new_channel          updated = False          if is_same_project:             try:                 alert_client.update_alert_policy(alert_policy=policy)                 updated = True             except google.api_core.exceptions.NotFound:                 pass  # The policy was deleted.  Create it below.             except google.api_core.exceptions.InvalidArgument:                 # Annoying that API throws InvalidArgument when the policy                 # does not exist.  Seems like it should throw NotFound.                 pass  # The policy was deleted.  Create it below.          if not updated:             # The policy no longer exists.  Recreate it.             old_name = policy.name             del policy.name             for condition in policy.conditions:                 del condition.name             policy = alert_client.create_alert_policy(                 name=project_name, alert_policy=policy             )         print("Updated", policy.name)  

static void ListAlertPolicies(string projectId) {     var client = AlertPolicyServiceClient.Create();     var response = client.ListAlertPolicies(new ProjectName(projectId));     foreach (AlertPolicy policy in response)     {         Console.WriteLine(policy.Name);         if (policy.DisplayName != null)         {             Console.WriteLine(policy.DisplayName);         }         if (policy.Documentation?.Content != null)         {             Console.WriteLine(policy.Documentation.Content);         }         Console.WriteLine();     } } 

 // listAlertPolicies lists the alert policies in the project. func listAlertPolicies(w io.Writer, projectID string) error { 	ctx := context.Background() 	client, err := monitoring.NewAlertPolicyClient(ctx) 	if err != nil { 		return err 	} 	defer client.Close()  	req := &monitoringpb.ListAlertPoliciesRequest{ 		Name: "projects/" + projectID, 		// Filter:  "", // See https://cloud.google.com/monitoring/api/v3/sorting-and-filtering. 		// OrderBy: "", // See https://cloud.google.com/monitoring/api/v3/sorting-and-filtering. 	} 	it := client.ListAlertPolicies(ctx, req) 	for { 		resp, err := it.Next() 		if err == iterator.Done { 			fmt.Fprintln(w, "Done") 			break 		} 		if err != nil { 			return err 		} 		fmt.Fprintf(w, "  Name: %q\n", resp.GetName()) 		fmt.Fprintf(w, "  Display Name: %q\n", resp.GetDisplayName()) 		fmt.Fprintf(w, "  Documentation Content: %q\n\n", resp.GetDocumentation().GetContent()) 	} 	return nil } 

private static void listAlertPolicies(String projectId) throws IOException {   try (AlertPolicyServiceClient client = AlertPolicyServiceClient.create()) {     ListAlertPoliciesPagedResponse response = client.listAlertPolicies(ProjectName.of(projectId));      System.out.println("Alert Policies:");     for (AlertPolicy policy : response.iterateAll()) {       System.out.println(           String.format("\nPolicy %s\nalert-id: %s", policy.getDisplayName(), policy.getName()));       int channels = policy.getNotificationChannelsCount();       if (channels > 0) {         System.out.println("notification-channels:");         for (int i = 0; i < channels; i++) {           System.out.println("\t" + policy.getNotificationChannels(i));         }       }       if (policy.hasDocumentation() && policy.getDocumentation().getContent() != null) {         System.out.println(policy.getDocumentation().getContent());       }     }   } }

// Imports the Google Cloud client library const monitoring = require('@google-cloud/monitoring');  // Creates a client const client = new monitoring.AlertPolicyServiceClient();  async function listPolicies() {   /**    * TODO(developer): Uncomment the following lines before running the sample.    */   // const projectId = 'YOUR_PROJECT_ID';    const listAlertPoliciesRequest = {     name: client.projectPath(projectId),   };   const [policies] = await client.listAlertPolicies(listAlertPoliciesRequest);   console.log('Policies:');   policies.forEach(policy => {     console.log(`  Display name: ${policy.displayName}`);     if (policy.documentation && policy.documentation.content) {       console.log(`     Documentation: ${policy.documentation.content}`);     }   }); } listPolicies();

use Google\Cloud\Monitoring\V3\Client\AlertPolicyServiceClient; use Google\Cloud\Monitoring\V3\ListAlertPoliciesRequest;  /**  * Adds a new column to the Albums table in the example database.  * Example:  * ```  * alert_list_policies($projectId);  * ```  *  * @param string $projectId Your project ID  */ function alert_list_policies($projectId) {     $projectName = 'projects/' . $projectId;     $alertClient = new AlertPolicyServiceClient([         'projectId' => $projectId,     ]);     $listAlertPoliciesRequest = (new ListAlertPoliciesRequest())         ->setName($projectName);      $policies = $alertClient->listAlertPolicies($listAlertPoliciesRequest);     foreach ($policies->iterateAllElements() as $policy) {         printf('Name: %s (%s)' . PHP_EOL, $policy->getDisplayName(), $policy->getName());     } }

def list_alert_policies(project_name):     """List alert policies in a project.      Arguments:         project_name (str): The Google Cloud Project to use. The project name             must be in the format - 'projects/<PROJECT_NAME>'.     """      client = monitoring_v3.AlertPolicyServiceClient()     policies = client.list_alert_policies(name=project_name)     print(         str(             tabulate.tabulate(                 [(policy.name, policy.display_name) for policy in policies],                 ("name", "display_name"),             )         )     )  

static object EnablePolicies(string projectId, string filter, bool enable) {     var client = AlertPolicyServiceClient.Create();     var request = new ListAlertPoliciesRequest()     {         ProjectName = new ProjectName(projectId),         Filter = filter     };     var response = client.ListAlertPolicies(request);     int result = 0;     foreach (AlertPolicy policy in response)     {         try         {             if (policy.Enabled == enable)             {                 Console.WriteLine("Policy {0} is already {1}.",                     policy.Name, enable ? "enabled" : "disabled");                 continue;             }             policy.Enabled = enable;             var fieldMask = new FieldMask { Paths = { "enabled" } };             client.UpdateAlertPolicy(fieldMask, policy);             Console.WriteLine("{0} {1}.", enable ? "Enabled" : "Disabled",                 policy.Name);         }         catch (Grpc.Core.RpcException e)         when (e.Status.StatusCode == StatusCode.InvalidArgument)         {             Console.WriteLine(e.Message);             result -= 1;         }     }     // Return a negative count of how many enable operations failed.     return result; } 

 // enablePolicies enables or disables all alert policies in the project. func enablePolicies(w io.Writer, projectID string, enable bool) error { 	ctx := context.Background()  	client, err := monitoring.NewAlertPolicyClient(ctx) 	if err != nil { 		return err 	} 	defer client.Close()  	req := &monitoringpb.ListAlertPoliciesRequest{ 		Name: "projects/" + projectID, 		// Filter:  "", // See https://cloud.google.com/monitoring/api/v3/sorting-and-filtering. 		// OrderBy: "", // See https://cloud.google.com/monitoring/api/v3/sorting-and-filtering. 	} 	it := client.ListAlertPolicies(ctx, req) 	for { 		a, err := it.Next() 		if err == iterator.Done { 			break 		} 		if err != nil { 			return err 		} 		if a.GetEnabled().GetValue() == enable { 			fmt.Fprintf(w, "Policy %q already has enabled=%v", a.GetDisplayName(), enable) 			continue 		} 		a.Enabled = &wrappers.BoolValue{Value: enable} 		req := &monitoringpb.UpdateAlertPolicyRequest{ 			AlertPolicy: a, 			UpdateMask: &fieldmask.FieldMask{ 				Paths: []string{"enabled"}, 			}, 		} 		if _, err := client.UpdateAlertPolicy(ctx, req); err != nil { 			return err 		} 	} 	fmt.Fprintln(w, "Successfully updated alerts.") 	return nil } 

private static void enablePolicies(String projectId, String filter, boolean enable)     throws IOException {   try (AlertPolicyServiceClient client = AlertPolicyServiceClient.create()) {     ListAlertPoliciesPagedResponse response =         client.listAlertPolicies(             ListAlertPoliciesRequest.newBuilder()                 .setName(ProjectName.of(projectId).toString())                 .setFilter(filter)                 .build());      for (AlertPolicy policy : response.iterateAll()) {       if (policy.getEnabled().getValue() == enable) {         System.out.println(             String.format(                 "Policy %s is already %b.", policy.getName(), enable ? "enabled" : "disabled"));         continue;       }       AlertPolicy updatedPolicy =           AlertPolicy.newBuilder()               .setName(policy.getName())               .setEnabled(BoolValue.newBuilder().setValue(enable))               .build();       AlertPolicy result =           client.updateAlertPolicy(               FieldMask.newBuilder().addPaths("enabled").build(), updatedPolicy);       System.out.println(           String.format(               "%s %s",               result.getDisplayName(), result.getEnabled().getValue() ? "enabled" : "disabled"));     }   } }

// Imports the Google Cloud client library const monitoring = require('@google-cloud/monitoring');  // Creates a client const client = new monitoring.AlertPolicyServiceClient();  async function enablePolicies() {   /**    * TODO(developer): Uncomment the following lines before running the sample.    */   // const projectId = 'YOUR_PROJECT_ID';   // const enabled = true;   // const filter = 'A filter for selecting policies, e.g. description:"cloud"';    const listAlertPoliciesRequest = {     name: client.projectPath(projectId),     // See https://cloud.google.com/monitoring/alerting/docs/sorting-and-filtering     filter: filter,   };    const [policies] = await client.listAlertPolicies(listAlertPoliciesRequest);   const responses = [];   for (const policy of policies) {     responses.push(       await client.updateAlertPolicy({         updateMask: {           paths: ['enabled'],         },         alertPolicy: {           name: policy.name,           enabled: {             value: enabled,           },         },       })     );   }   responses.forEach(response => {     const alertPolicy = response[0];     console.log(`${enabled ? 'Enabled' : 'Disabled'} ${alertPolicy.name}.`);   }); } enablePolicies();

use Google\Cloud\Monitoring\V3\Client\AlertPolicyServiceClient; use Google\Cloud\Monitoring\V3\ListAlertPoliciesRequest; use Google\Cloud\Monitoring\V3\UpdateAlertPolicyRequest; use Google\Protobuf\FieldMask;  /**  * Enable or disable alert policies in a project.  *  * @param string $projectId Your project ID  * @param bool $enable Enable or disable the policies.  * @param string $filter Only enable/disable alert policies that match a filter.  *        See https://cloud.google.com/monitoring/api/v3/sorting-and-filtering  */ function alert_enable_policies($projectId, $enable = true, $filter = null) {     $alertClient = new AlertPolicyServiceClient([         'projectId' => $projectId,     ]);     $projectName = 'projects/' . $projectId;     $listAlertPoliciesRequest = (new ListAlertPoliciesRequest())         ->setName($projectName)         ->setFilter($filter);      $policies = $alertClient->listAlertPolicies($listAlertPoliciesRequest);     foreach ($policies->iterateAllElements() as $policy) {         $isEnabled = $policy->getEnabled()->getValue();         if ($enable == $isEnabled) {             printf('Policy %s is already %s' . PHP_EOL,                 $policy->getName(),                 $isEnabled ? 'enabled' : 'disabled'             );         } else {             $policy->getEnabled()->setValue((bool) $enable);             $mask = new FieldMask();             $mask->setPaths(['enabled']);             $updateAlertPolicyRequest = (new UpdateAlertPolicyRequest())                 ->setAlertPolicy($policy)                 ->setUpdateMask($mask);             $alertClient->updateAlertPolicy($updateAlertPolicyRequest);             printf('%s %s' . PHP_EOL,                 $enable ? 'Enabled' : 'Disabled',                 $policy->getName()             );         }     } }

def enable_alert_policies(project_name, enable, filter_=None):     """Enable or disable alert policies in a project.      Arguments:         project_name (str): The Google Cloud Project to use. The project name             must be in the format - 'projects/<PROJECT_NAME>'.         enable (bool): Enable or disable the policies.         filter_ (str, optional): Only enable/disable alert policies that match             this filter_.  See             https://cloud.google.com/monitoring/api/v3/sorting-and-filtering     """      client = monitoring_v3.AlertPolicyServiceClient()     policies = client.list_alert_policies(         request={"name": project_name, "filter": filter_}     )      for policy in policies:         if bool(enable) == policy.enabled:             print(                 "Policy",                 policy.name,                 "is already",                 "enabled" if policy.enabled else "disabled",             )         else:             policy.enabled = bool(enable)             mask = field_mask.FieldMask()             mask.paths.append("enabled")             client.update_alert_policy(alert_policy=policy, update_mask=mask)             print("Enabled" if enable else "Disabled", policy.name)  

static void ReplaceChannels(string projectId, string alertPolicyId,     IEnumerable<string> channelIds) {     var alertClient = AlertPolicyServiceClient.Create();     var policy = new AlertPolicy()     {         Name = new AlertPolicyName(projectId, alertPolicyId).ToString()     };     foreach (string channelId in channelIds)     {         policy.NotificationChannels.Add(             new NotificationChannelName(projectId, channelId)             .ToString());     }     var response = alertClient.UpdateAlertPolicy(         new FieldMask { Paths = { "notification_channels" } }, policy);     Console.WriteLine("Updated {0}.", response.Name); } 

 // replaceChannels replaces the notification channels in the alert policy // with channelIDs. func replaceChannels(w io.Writer, projectID, alertPolicyID string, channelIDs []string) error { 	ctx := context.Background()  	client, err := monitoring.NewAlertPolicyClient(ctx) 	if err != nil { 		return err 	} 	defer client.Close()  	policy := &monitoringpb.AlertPolicy{ 		Name: "projects/" + projectID + "/alertPolicies/" + alertPolicyID, 	} 	for _, c := range channelIDs { 		c = "projects/" + projectID + "/notificationChannels/" + c 		policy.NotificationChannels = append(policy.NotificationChannels, c) 	} 	req := &monitoringpb.UpdateAlertPolicyRequest{ 		AlertPolicy: policy, 		UpdateMask: &fieldmask.FieldMask{ 			Paths: []string{"notification_channels"}, 		}, 	} 	if _, err := client.UpdateAlertPolicy(ctx, req); err != nil { 		return fmt.Errorf("UpdateAlertPolicy: %w", err) 	} 	fmt.Fprintf(w, "Successfully replaced channels.") 	return nil } 

private static void replaceChannels(String projectId, String alertPolicyId, String[] channelIds)     throws IOException {   AlertPolicy.Builder policyBuilder =       AlertPolicy.newBuilder().setName(AlertPolicyName.of(projectId, alertPolicyId).toString());   for (String channelId : channelIds) {     policyBuilder.addNotificationChannels(         NotificationChannelName.of(projectId, channelId).toString());   }   try (AlertPolicyServiceClient client = AlertPolicyServiceClient.create()) {     AlertPolicy result =         client.updateAlertPolicy(             FieldMask.newBuilder().addPaths("notification_channels").build(),             policyBuilder.build());     System.out.println(String.format("Updated %s", result.getName()));   } }

 // Imports the Google Cloud client library const monitoring = require('@google-cloud/monitoring');  // Creates clients const alertClient = new monitoring.AlertPolicyServiceClient(); const notificationClient = new monitoring.NotificationChannelServiceClient();  async function replaceChannels() {   /**    * TODO(developer): Uncomment the following lines before running the sample.    */   // const projectId = 'YOUR_PROJECT_ID';   // const alertPolicyId = '123456789012314';   // const channelIds = [   //   'channel-1',   //   'channel-2',   //   'channel-3',   // ];    const notificationChannels = channelIds.map(id =>     notificationClient.projectNotificationChannelPath(projectId, id)   );    for (const channel of notificationChannels) {     const updateChannelRequest = {       updateMask: {         paths: ['enabled'],       },       notificationChannel: {         name: channel,         enabled: {           value: true,         },       },     };     try {       await notificationClient.updateNotificationChannel(         updateChannelRequest       );     } catch (err) {       const createChannelRequest = {         notificationChannel: {           name: channel,           notificationChannel: {             type: 'email',           },         },       };       const newChannel =         await notificationClient.createNotificationChannel(           createChannelRequest         );       notificationChannels.push(newChannel);     }   }    const updateAlertPolicyRequest = {     updateMask: {       paths: ['notification_channels'],     },     alertPolicy: {       name: alertClient.projectAlertPolicyPath(projectId, alertPolicyId),       notificationChannels: notificationChannels,     },   };   const [alertPolicy] = await alertClient.updateAlertPolicy(     updateAlertPolicyRequest   );   console.log(`Updated ${alertPolicy.name}.`); } replaceChannels();

use Google\Cloud\Monitoring\V3\AlertPolicy; use Google\Cloud\Monitoring\V3\Client\AlertPolicyServiceClient; use Google\Cloud\Monitoring\V3\Client\NotificationChannelServiceClient; use Google\Cloud\Monitoring\V3\UpdateAlertPolicyRequest; use Google\Protobuf\FieldMask;  /**  * @param string $projectId Your project ID  * @param string $alertPolicyId Your alert policy id ID  * @param string[] $channelIds array of channel IDs  */ function alert_replace_channels(string $projectId, string $alertPolicyId, array $channelIds): void {     $alertClient = new AlertPolicyServiceClient([         'projectId' => $projectId,     ]);      $channelClient = new NotificationChannelServiceClient([         'projectId' => $projectId,     ]);     $policy = new AlertPolicy();     $policy->setName($alertClient->alertPolicyName($projectId, $alertPolicyId));      $newChannels = [];     foreach ($channelIds as $channelId) {         $newChannels[] = $channelClient->notificationChannelName($projectId, $channelId);     }     $policy->setNotificationChannels($newChannels);     $mask = new FieldMask();     $mask->setPaths(['notification_channels']);     $updateAlertPolicyRequest = (new UpdateAlertPolicyRequest())         ->setAlertPolicy($policy)         ->setUpdateMask($mask);     $updatedPolicy = $alertClient->updateAlertPolicy($updateAlertPolicyRequest);     printf('Updated %s' . PHP_EOL, $updatedPolicy->getName()); }

def replace_notification_channels(project_name, alert_policy_id, channel_ids):     """Replace notification channel of an alert.      Arguments:         project_name (str): The Google Cloud Project to use. The project name             must be in the format - 'projects/<PROJECT_NAME>'.         alert_policy_id (str): The ID of the alert policy whose notification             channels are to be replaced.         channel_ids (str): ID of notification channel to be added as channel             for the given alert policy.     """      _, project_id = project_name.split("/")     alert_client = monitoring_v3.AlertPolicyServiceClient()     channel_client = monitoring_v3.NotificationChannelServiceClient()     policy = monitoring_v3.AlertPolicy()     policy.name = alert_client.alert_policy_path(project_id, alert_policy_id)      for channel_id in channel_ids:         policy.notification_channels.append(             channel_client.notification_channel_path(project_id, channel_id)         )      mask = field_mask.FieldMask()     mask.paths.append("notification_channels")     updated_policy = alert_client.update_alert_policy(         alert_policy=policy, update_mask=mask     )     print("Updated", updated_policy.name)  

        static void BackupPolicies(string projectId, string filePath)         {             var policyClient = AlertPolicyServiceClient.Create();             var channelClient = NotificationChannelServiceClient.Create();             var projectName = new ProjectName(projectId);             File.WriteAllText(filePath, JsonConvert.SerializeObject(                 new BackupRecord()                 {                     ProjectId = projectId,                     Policies = policyClient.ListAlertPolicies(projectName),                     Channels = channelClient.ListNotificationChannels(projectName)                 }, new ProtoMessageConverter()));         }         class BackupRecord         {             public string ProjectId { get; set; }             public IEnumerable<AlertPolicy> Policies { get; set; }             public IEnumerable<NotificationChannel> Channels { get; set; }         }          /// <summary>         /// Lets Newtonsoft.Json and Protobuf's json converters play nicely         /// together.  The default Netwtonsoft.Json Deserialize method will         /// not correctly deserialize proto messages.         /// </summary>         class ProtoMessageConverter : JsonConverter         {             public override bool CanConvert(System.Type objectType)             {                 return typeof(Google.Protobuf.IMessage)                     .IsAssignableFrom(objectType);             }              public override object ReadJson(JsonReader reader,                 System.Type objectType, object existingValue,                 JsonSerializer serializer)             {                 // Read an entire object from the reader.                 var converter = new ExpandoObjectConverter();                 object o = converter.ReadJson(reader, objectType, existingValue,                     serializer);                 // Convert it back to json text.                 string text = JsonConvert.SerializeObject(o);                 // And let protobuf's parser parse the text.                 IMessage message = (IMessage)Activator                     .CreateInstance(objectType);                 return Google.Protobuf.JsonParser.Default.Parse(text,                     message.Descriptor);             }              public override void WriteJson(JsonWriter writer, object value,                 JsonSerializer serializer)             {                 writer.WriteRawValue(Google.Protobuf.JsonFormatter.Default                     .Format((IMessage)value));             }         } 

 // backupPolicies writes a JSON representation of the project's alert // policies and notification channels. func backupPolicies(w io.Writer, projectID string) error { 	b := backup{ProjectID: projectID} 	ctx := context.Background()  	alertClient, err := monitoring.NewAlertPolicyClient(ctx) 	if err != nil { 		return err 	} 	defer alertClient.Close() 	alertReq := &monitoringpb.ListAlertPoliciesRequest{ 		Name: "projects/" + projectID, 		// Filter:  "", // See https://cloud.google.com/monitoring/api/v3/sorting-and-filtering. 		// OrderBy: "", // See https://cloud.google.com/monitoring/api/v3/sorting-and-filtering. 	} 	alertIt := alertClient.ListAlertPolicies(ctx, alertReq) 	for { 		resp, err := alertIt.Next() 		if err == iterator.Done { 			break 		} 		if err != nil { 			return err 		} 		b.AlertPolicies = append(b.AlertPolicies, &alertPolicy{resp}) 	}  	channelClient, err := monitoring.NewNotificationChannelClient(ctx) 	if err != nil { 		return err 	} 	defer channelClient.Close() 	channelReq := &monitoringpb.ListNotificationChannelsRequest{ 		Name: "projects/" + projectID, 		// Filter:  "", // See https://cloud.google.com/monitoring/api/v3/sorting-and-filtering. 		// OrderBy: "", // See https://cloud.google.com/monitoring/api/v3/sorting-and-filtering. 	} 	channelIt := channelClient.ListNotificationChannels(ctx, channelReq) 	for { 		resp, err := channelIt.Next() 		if err == iterator.Done { 			break 		} 		if err != nil { 			return err 		} 		b.Channels = append(b.Channels, &channel{resp}) 	} 	bs, err := json.MarshalIndent(b, "", "  ") 	if err != nil { 		return err 	} 	if _, err := w.Write(bs); err != nil { 		return err 	} 	return nil }  // alertPolicy is a wrapper around the AlertPolicy proto to // ensure JSON marshaling/unmarshaling works correctly. type alertPolicy struct { 	*monitoringpb.AlertPolicy }  // channel is a wrapper around the NotificationChannel proto to // ensure JSON marshaling/unmarshaling works correctly. type channel struct { 	*monitoringpb.NotificationChannel }  // backup is used to backup and restore a project's policies. type backup struct { 	ProjectID     string 	AlertPolicies []*alertPolicy 	Channels      []*channel }  func (a *alertPolicy) MarshalJSON() ([]byte, error) { 	m := &jsonpb.Marshaler{EmitDefaults: true} 	b := new(bytes.Buffer) 	m.Marshal(b, a.AlertPolicy) 	return b.Bytes(), nil }  func (a *alertPolicy) UnmarshalJSON(b []byte) error { 	u := &jsonpb.Unmarshaler{} 	a.AlertPolicy = new(monitoringpb.AlertPolicy) 	return u.Unmarshal(bytes.NewReader(b), a.AlertPolicy) }  func (c *channel) MarshalJSON() ([]byte, error) { 	m := &jsonpb.Marshaler{} 	b := new(bytes.Buffer) 	m.Marshal(b, c.NotificationChannel) 	return b.Bytes(), nil }  func (c *channel) UnmarshalJSON(b []byte) error { 	u := &jsonpb.Unmarshaler{} 	c.NotificationChannel = new(monitoringpb.NotificationChannel) 	return u.Unmarshal(bytes.NewReader(b), c.NotificationChannel) } 

private static void backupPolicies(String projectId, String filePath) throws IOException {   List<AlertPolicy> alertPolicies = getAlertPolicies(projectId);   List<NotificationChannel> notificationChannels = getNotificationChannels(projectId);   writePoliciesBackupFile(projectId, filePath, alertPolicies, notificationChannels);   System.out.println(String.format("Saved policies to %s", filePath)); }  private static List<AlertPolicy> getAlertPolicies(String projectId) throws IOException {   List<AlertPolicy> alertPolicies = Lists.newArrayList();   try (AlertPolicyServiceClient client = AlertPolicyServiceClient.create()) {     ListAlertPoliciesPagedResponse response = client.listAlertPolicies(ProjectName.of(projectId));      for (AlertPolicy policy : response.iterateAll()) {       alertPolicies.add(policy);     }   }   return alertPolicies; }  private static List<NotificationChannel> getNotificationChannels(String projectId)     throws IOException {   List<NotificationChannel> notificationChannels = Lists.newArrayList();   try (NotificationChannelServiceClient client = NotificationChannelServiceClient.create()) {     ListNotificationChannelsPagedResponse listNotificationChannelsResponse =         client.listNotificationChannels(ProjectName.of(projectId));     for (NotificationChannel channel : listNotificationChannelsResponse.iterateAll()) {       notificationChannels.add(channel);     }   }   return notificationChannels; }  private static void writePoliciesBackupFile(     String projectId,     String filePath,     List<AlertPolicy> alertPolicies,     List<NotificationChannel> notificationChannels)     throws IOException {   JsonObject backupContents = new JsonObject();   backupContents.add("project_id", new JsonPrimitive(projectId));   JsonArray policiesJson = new JsonArray();   for (AlertPolicy policy : alertPolicies) {     policiesJson.add(gson.toJsonTree(policy));   }   backupContents.add("policies", policiesJson);    JsonArray notificationsJson = new JsonArray();   for (NotificationChannel channel : notificationChannels) {     notificationsJson.add(gson.toJsonTree(channel));   }   backupContents.add("notification_channels", notificationsJson);    FileWriter writer = new FileWriter(filePath);   writer.write(backupContents.toString());   writer.close(); }

const fs = require('fs');  // Imports the Google Cloud client library const monitoring = require('@google-cloud/monitoring');  // Creates a client const client = new monitoring.AlertPolicyServiceClient();  async function backupPolicies() {   /**    * TODO(developer): Uncomment the following lines before running the sample.    */   // const projectId = 'YOUR_PROJECT_ID';    const listAlertPoliciesRequest = {     name: client.projectPath(projectId),   };    let [policies] = await client.listAlertPolicies(listAlertPoliciesRequest);    // filter out any policies created by tests for this sample   policies = policies.filter(policy => {     return !policy.displayName.startsWith('gcloud-tests-');   });    fs.writeFileSync(     './policies_backup.json',     JSON.stringify(policies, null, 2),     'utf-8'   );    console.log('Saved policies to ./policies_backup.json');

use Google\Cloud\Monitoring\V3\Client\AlertPolicyServiceClient; use Google\Cloud\Monitoring\V3\Client\NotificationChannelServiceClient; use Google\Cloud\Monitoring\V3\ListAlertPoliciesRequest; use Google\Cloud\Monitoring\V3\ListNotificationChannelsRequest;  /**  * Back up alert policies.  *  * @param string $projectId Your project ID  */ function alert_backup_policies($projectId) {     $alertClient = new AlertPolicyServiceClient([         'projectId' => $projectId,     ]);     $channelClient = new NotificationChannelServiceClient([         'projectId' => $projectId,     ]);     $projectName = 'projects/' . $projectId;      $record = [         'project_name' => $projectName,         'policies' => [],         'channels' => [],     ];     $listAlertPoliciesRequest = (new ListAlertPoliciesRequest())         ->setName($projectName);     $policies = $alertClient->listAlertPolicies($listAlertPoliciesRequest);     foreach ($policies->iterateAllElements() as $policy) {         $record['policies'][] = json_decode($policy->serializeToJsonString());     }     $listNotificationChannelsRequest = (new ListNotificationChannelsRequest())         ->setName($projectName);     $channels = $channelClient->listNotificationChannels($listNotificationChannelsRequest);     foreach ($channels->iterateAllElements() as $channel) {         $record['channels'][] = json_decode($channel->serializeToJsonString());     }     file_put_contents('backup.json', json_encode($record, JSON_PRETTY_PRINT));     print('Backed up alert policies and notification channels to backup.json.'); }

def backup(project_name, backup_filename):     """Backup alert policies from a project to a local file.      Arguments:         project_name (str): The Google Cloud Project to use. The project name             must be in the format - 'projects/<PROJECT_NAME>'         backup_filename (str): Name of the file (along with its path) to which             the alert policies will be written as backup.     """      alert_client = monitoring_v3.AlertPolicyServiceClient()     channel_client = monitoring_v3.NotificationChannelServiceClient()     record = {         "project_name": project_name,         "policies": list(alert_client.list_alert_policies(name=project_name)),         "channels": list(channel_client.list_notification_channels(name=project_name)),     }     json.dump(record, open(backup_filename, "wt"), cls=ProtoEncoder, indent=2)     print(         "Backed up alert policies and notification channels to {}.".format(             backup_filename         )     )   class ProtoEncoder(json.JSONEncoder):     """Encode protobufs as json."""      def default(self, obj):         if type(obj) in (monitoring_v3.AlertPolicy, monitoring_v3.NotificationChannel):             text = proto.Message.to_json(obj)             return json.loads(text)         return super(ProtoEncoder, self).default(obj)  

        static void RestorePolicies(string projectId, string filePath)         {             var policyClient = AlertPolicyServiceClient.Create();             var channelClient = NotificationChannelServiceClient.Create();             List<Exception> exceptions = new List<Exception>();             var backup = JsonConvert.DeserializeObject<BackupRecord>(                 File.ReadAllText(filePath), new ProtoMessageConverter());             var projectName = new ProjectName(projectId);             bool isSameProject = projectId == backup.ProjectId;             // When a channel is recreated, rather than updated, it will get             // a new name.  We have to update the AlertPolicy with the new             // name.  Track the names in this map.             var channelNameMap = new Dictionary<string, string>();             foreach (NotificationChannel channel in backup.Channels)             {                 try                 {                     bool updated = false;                     Console.WriteLine("Updating channel.\n{0}",                         channel.DisplayName);                     // This field is immutable and it is illegal to specify a                     // non-default value (UNVERIFIED or VERIFIED) in the                     // Create() or Update() operations.                     channel.VerificationStatus = NotificationChannel.Types                         .VerificationStatus.Unspecified;                     if (isSameProject)                         try                         {                             channelClient.UpdateNotificationChannel(                                 null, channel);                             updated = true;                         }                         catch (Grpc.Core.RpcException e)                         when (e.Status.StatusCode == StatusCode.NotFound)                         { }                     if (!updated)                     {                         // The channel no longer exists.  Recreate it.                         string oldName = channel.Name;                         channel.Name = null;                         var response = channelClient.CreateNotificationChannel(                             projectName, channel);                         channelNameMap.Add(oldName, response.Name);                     }                 }                 catch (Exception e)                 {                     // If one failed, continue trying to update the others.                     exceptions.Add(e);                 }             }             foreach (AlertPolicy policy in backup.Policies)             {                 string policyName = policy.Name;                 // These two fields cannot be set directly, so clear them.                 policy.CreationRecord = null;                 policy.MutationRecord = null;                 // Update channel names if the channel was recreated with                 // another name.                 for (int i = 0; i < policy.NotificationChannels.Count; ++i)                 {                     if (channelNameMap.ContainsKey(policy.NotificationChannels[i]))                     {                         policy.NotificationChannels[i] =                             channelNameMap[policy.NotificationChannels[i]];                     }                 }                 try                 {                     Console.WriteLine("Updating policy.\n{0}",                         policy.DisplayName);                     bool updated = false;                     if (isSameProject)                         try                         {                             policyClient.UpdateAlertPolicy(null, policy);                             updated = true;                         }                         catch (Grpc.Core.RpcException e)                         when (e.Status.StatusCode == StatusCode.NotFound)                         { }                     if (!updated)                     {                         // The policy no longer exists.  Recreate it.                         policy.Name = null;                         foreach (var condition in policy.Conditions)                         {                             condition.Name = null;                         }                         policyClient.CreateAlertPolicy(projectName, policy);                     }                     Console.WriteLine("Restored {0}.", policyName);                 }                 catch (Exception e)                 {                     // If one failed, continue trying to update the others.                     exceptions.Add(e);                 }             }             if (exceptions.Count > 0)             {                 throw new AggregateException(exceptions);             }         }          class BackupRecord         {             public string ProjectId { get; set; }             public IEnumerable<AlertPolicy> Policies { get; set; }             public IEnumerable<NotificationChannel> Channels { get; set; }         }          /// <summary>         /// Lets Newtonsoft.Json and Protobuf's json converters play nicely         /// together.  The default Netwtonsoft.Json Deserialize method will         /// not correctly deserialize proto messages.         /// </summary>         class ProtoMessageConverter : JsonConverter         {             public override bool CanConvert(System.Type objectType)             {                 return typeof(Google.Protobuf.IMessage)                     .IsAssignableFrom(objectType);             }              public override object ReadJson(JsonReader reader,                 System.Type objectType, object existingValue,                 JsonSerializer serializer)             {                 // Read an entire object from the reader.                 var converter = new ExpandoObjectConverter();                 object o = converter.ReadJson(reader, objectType, existingValue,                     serializer);                 // Convert it back to json text.                 string text = JsonConvert.SerializeObject(o);                 // And let protobuf's parser parse the text.                 IMessage message = (IMessage)Activator                     .CreateInstance(objectType);                 return Google.Protobuf.JsonParser.Default.Parse(text,                     message.Descriptor);             }              public override void WriteJson(JsonWriter writer, object value,                 JsonSerializer serializer)             {                 writer.WriteRawValue(Google.Protobuf.JsonFormatter.Default                     .Format((IMessage)value));             }         }