azurerm_traffic_manager_profile - support for the interval_in_seconds, timeout_in_seconds, and tolerated_number_of_failures properties

azurerm/resource_arm_traffic_manager_profile.go

@@ -107,6 +107,21 @@ func resourceArmTrafficManagerProfile() *schema.Resource {
 							Type:     schema.TypeString,
 							Optional: true,
 						},
+						"interval_in_seconds": {
+							Type:         schema.TypeInt,
+							Optional:     true,
+							ValidateFunc: validation.IntInSlice([]int{10, 30}),
+						},
+						"timeout_in_seconds": {
+							Type:         schema.TypeInt,
+							Optional:     true,
+							ValidateFunc: validation.IntBetween(5, 10),
+						},
+						"tolerated_number_of_failures": {
+							Type:         schema.TypeInt,
+							Optional:     true,
+							ValidateFunc: validation.IntBetween(0, 9),
+						},
 					},
 				},
 				Set: resourceAzureRMTrafficManagerMonitorConfigHash,
@@ -121,7 +136,7 @@ func resourceArmTrafficManagerProfileCreateUpdate(d *schema.ResourceData, meta i
 	client := meta.(*ArmClient).trafficManagerProfilesClient
 	ctx := meta.(*ArmClient).StopContext
 
-	log.Printf("[INFO] preparing arguments for Azure ARM virtual network creation.")
+	log.Printf("[INFO] preparing arguments for TrafficManager Profile creation.")
 
 	name := d.Get("name").(string)
 	// must be provided in request
@@ -252,11 +267,17 @@ func expandArmTrafficManagerMonitorConfig(d *schema.ResourceData) *trafficmanage
 	proto := monitor["protocol"].(string)
 	port := int64(monitor["port"].(int))
 	path := monitor["path"].(string)
+	interval := int64(monitor["interval_in_seconds"].(int))
+	timeout := int64(monitor["timeout_in_seconds"].(int))
+	tolerated := int64(monitor["tolerated_number_of_failures"].(int))
 
 	return &trafficmanager.MonitorConfig{
-		Protocol: trafficmanager.MonitorProtocol(proto),
-		Port:     &port,
-		Path:     &path,
+		Protocol:                  trafficmanager.MonitorProtocol(proto),
+		Port:                      &port,
+		Path:                      &path,
+		IntervalInSeconds:         &interval,
+		TimeoutInSeconds:          &timeout,
+		ToleratedNumberOfFailures: &tolerated,
 	}
 }
 
@@ -292,6 +313,10 @@ func flattenAzureRMTrafficManagerProfileMonitorConfig(cfg *trafficmanager.Monito
 		result["path"] = *cfg.Path
 	}
 
+	result["interval_in_seconds"] = int(*cfg.IntervalInSeconds)
+	result["timeout_in_seconds"] = int(*cfg.TimeoutInSeconds)
+	result["tolerated_number_of_failures"] = int(*cfg.ToleratedNumberOfFailures)
+
 	return []interface{}{result}
 }
 
@@ -316,6 +341,18 @@ func resourceAzureRMTrafficManagerMonitorConfigHash(v interface{}) int {
 		if v, ok := m["path"]; ok && v != "" {
 			buf.WriteString(fmt.Sprintf("%s-", m["path"].(string)))
 		}
+
+		if v, ok := m["interval_in_seconds"]; ok && v != "" {
+			buf.WriteString(fmt.Sprintf("%d-", m["interval_in_seconds"].(int)))
+		}
+
+		if v, ok := m["timeout_in_seconds"]; ok && v != "" {
+			buf.WriteString(fmt.Sprintf("%d-", m["timeout_in_seconds"].(int)))
+		}
+
+		if v, ok := m["tolerated_number_of_failures"]; ok && v != "" {
+			buf.WriteString(fmt.Sprintf("%d-", m["tolerated_number_of_failures"].(int)))
+		}
 	}
 
 	return hashcode.String(buf.String())

azurerm/resource_arm_traffic_manager_profile_test.go

@@ -310,6 +310,35 @@ func TestAccAzureRMTrafficManagerProfile_priorityToWeighted(t *testing.T) {
 	})
 }
 
+func TestAccAzureRMTrafficManagerProfile_fastEndpointFailoverSettings(t *testing.T) {
+	resourceName := "azurerm_traffic_manager_profile.test"
+	rInt := tf.AccRandTimeInt()
+	location := testLocation()
+
+	resource.ParallelTest(t, resource.TestCase{
+		PreCheck:     func() { testAccPreCheck(t) },
+		Providers:    testAccProviders,
+		CheckDestroy: testCheckAzureRMTrafficManagerProfileDestroy,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccAzureRMTrafficManagerProfile_failover(rInt, location),
+				Check: resource.ComposeTestCheckFunc(
+					testCheckAzureRMTrafficManagerProfileExists(resourceName),
+					resource.TestCheckResourceAttr(resourceName, "monitor_config.#", "1"),
+					resource.TestCheckResourceAttr(resourceName, "monitor_config.3418284669.interval_in_seconds", "30"),
+					resource.TestCheckResourceAttr(resourceName, "monitor_config.3418284669.timeout_in_seconds", "6"),
+					resource.TestCheckResourceAttr(resourceName, "monitor_config.3418284669.tolerated_number_of_failures", "3"),
+				),
+			},
+			{
+				ResourceName:      resourceName,
+				ImportState:       true,
+				ImportStateVerify: true,
+			},
+		},
+	})
+}
+
 func testCheckAzureRMTrafficManagerProfileExists(resourceName string) resource.TestCheckFunc {
 	return func(s *terraform.State) error {
 		// Ensure we have enough information in state to look up in API
@@ -577,3 +606,32 @@ resource "azurerm_traffic_manager_profile" "test" {
 }
 `, rInt, location, rInt, rInt)
 }
+
+func testAccAzureRMTrafficManagerProfile_failover(rInt int, location string) string {
+	return fmt.Sprintf(`
+resource "azurerm_resource_group" "test" {
+  name     = "acctestRG-%d"
+  location = "%s"
+}
+
+resource "azurerm_traffic_manager_profile" "test" {
+  name                   = "acctesttmp%d"
+  resource_group_name    = "${azurerm_resource_group.test.name}"
+  traffic_routing_method = "Performance"
+
+  dns_config {
+    relative_name = "acctesttmp%d"
+    ttl           = 30
+  }
+
+  monitor_config {
+    protocol                     = "https"
+    port                         = 443
+    path                         = "/"
+    interval_in_seconds          = 30
+    timeout_in_seconds           = 6
+    tolerated_number_of_failures = 3
+  }
+}
+`, rInt, location, rInt, rInt)
+}

examples/traffic-manager/basic/main.tf

@@ -14,8 +14,11 @@ resource "azurerm_traffic_manager_profile" "example" {
   }
 
   monitor_config {
-    protocol = "http"
-    port     = 80
-    path     = "/"
+    protocol                     = "http"
+    port                         = 80
+    path                         = "/"
+    interval_in_seconds          = 30
+    timeout_in_seconds           = 9
+    tolerated_number_of_failures = 3
   }
 }

website/docs/r/traffic_manager_endpoint.html.markdown

@@ -38,9 +38,12 @@ resource "azurerm_traffic_manager_profile" "test" {
   }
 
   monitor_config {
-    protocol = "http"
-    port     = 80
-    path     = "/"
+    protocol                     = "http"
+    port                         = 80
+    path                         = "/"
+    interval_in_seconds          = 30
+    timeout_in_seconds           = 9
+    tolerated_number_of_failures = 3
   }
 
   tags = {

website/docs/r/traffic_manager_profile.html.markdown

@@ -39,9 +39,12 @@ resource "azurerm_traffic_manager_profile" "test" {
   }
 
   monitor_config {
-    protocol = "http"
-    port     = 80
-    path     = "/"
+    protocol                     = "http"
+    port                         = 80
+    path                         = "/"
+    interval_in_seconds          = 30
+    timeout_in_seconds           = 9
+    tolerated_number_of_failures = 3
   }
 
   tags = {
@@ -97,6 +100,12 @@ The `monitor_config` block supports:
 
 * `path` - (Optional) The path used by the monitoring checks. Required when `protocol` is set to `HTTP` or `HTTPS` - cannot be set when `protocol` is set to `TCP`.
 
+* `interval_in_seconds` - (Optional) The interval used to check the endpoint health from a Traffic Manager probing agent. You can specify two values here: 30 seconds (normal probing) and 10 seconds (fast probing). If no values are provided, the profile sets to a default value of 30 seconds.
+
+* `timeout_in_seconds` - (Optional) The amount of time the Traffic Manager probing agent should wait before considering that check a failure when a health check probe is sent to the endpoint. If the Probing Interval is set to 30 seconds, then you can set the Timeout value between 5 and 10 seconds. If no value is specified, it uses a default value of 10 seconds. If the Probing Interval is set to 10 seconds, then you can set the Timeout value between 5 and 9 seconds. If no Timeout value is specified, it uses a default value of 9 seconds.
+
+* `tolerated_number_of_failures` - (Optional) The number of failures a Traffic Manager probing agent tolerates before marking that endpoint as unhealthy. Its value can range between 0 and 9. A value of 0 means a single monitoring failure can cause that endpoint to be marked as unhealthy. If no value is specified, it uses the default value of 3.
+
 ## Attributes Reference
 
 The following attributes are exported: