github.com/gabrielperezs/terraform@v0.7.0-rc2.0.20160715084931-f7da2612946f/builtin/providers/aws/resource_aws_autoscaling_group_test.go (about) 1 package aws 2 3 import ( 4 "fmt" 5 "reflect" 6 "regexp" 7 "strings" 8 "testing" 9 10 "github.com/aws/aws-sdk-go/aws" 11 "github.com/aws/aws-sdk-go/aws/awserr" 12 "github.com/aws/aws-sdk-go/service/autoscaling" 13 "github.com/hashicorp/terraform/helper/acctest" 14 "github.com/hashicorp/terraform/helper/resource" 15 "github.com/hashicorp/terraform/terraform" 16 ) 17 18 func TestAccAWSAutoScalingGroup_basic(t *testing.T) { 19 var group autoscaling.Group 20 var lc autoscaling.LaunchConfiguration 21 22 randName := fmt.Sprintf("terraform-test-%s", acctest.RandString(10)) 23 24 resource.Test(t, resource.TestCase{ 25 PreCheck: func() { testAccPreCheck(t) }, 26 IDRefreshName: "aws_autoscaling_group.bar", 27 IDRefreshIgnore: []string{"force_delete", "metrics_granularity", "wait_for_capacity_timeout"}, 28 Providers: testAccProviders, 29 CheckDestroy: testAccCheckAWSAutoScalingGroupDestroy, 30 Steps: []resource.TestStep{ 31 resource.TestStep{ 32 Config: testAccAWSAutoScalingGroupConfig(randName), 33 Check: resource.ComposeTestCheckFunc( 34 testAccCheckAWSAutoScalingGroupExists("aws_autoscaling_group.bar", &group), 35 testAccCheckAWSAutoScalingGroupHealthyCapacity(&group, 2), 36 testAccCheckAWSAutoScalingGroupAttributes(&group, randName), 37 resource.TestCheckResourceAttr( 38 "aws_autoscaling_group.bar", "availability_zones.2487133097", "us-west-2a"), 39 resource.TestCheckResourceAttr( 40 "aws_autoscaling_group.bar", "name", randName), 41 resource.TestCheckResourceAttr( 42 "aws_autoscaling_group.bar", "max_size", "5"), 43 resource.TestCheckResourceAttr( 44 "aws_autoscaling_group.bar", "min_size", "2"), 45 resource.TestCheckResourceAttr( 46 "aws_autoscaling_group.bar", "health_check_grace_period", "300"), 47 resource.TestCheckResourceAttr( 48 "aws_autoscaling_group.bar", "health_check_type", "ELB"), 49 resource.TestCheckResourceAttr( 50 "aws_autoscaling_group.bar", "desired_capacity", "4"), 51 resource.TestCheckResourceAttr( 52 "aws_autoscaling_group.bar", "force_delete", "true"), 53 resource.TestCheckResourceAttr( 54 "aws_autoscaling_group.bar", "termination_policies.0", "OldestInstance"), 55 resource.TestCheckResourceAttr( 56 "aws_autoscaling_group.bar", "termination_policies.1", "ClosestToNextInstanceHour"), 57 resource.TestCheckResourceAttr( 58 "aws_autoscaling_group.bar", "protect_from_scale_in", "false"), 59 ), 60 }, 61 62 resource.TestStep{ 63 Config: testAccAWSAutoScalingGroupConfigUpdate(randName), 64 Check: resource.ComposeTestCheckFunc( 65 testAccCheckAWSAutoScalingGroupExists("aws_autoscaling_group.bar", &group), 66 testAccCheckAWSLaunchConfigurationExists("aws_launch_configuration.new", &lc), 67 resource.TestCheckResourceAttr( 68 "aws_autoscaling_group.bar", "desired_capacity", "5"), 69 resource.TestCheckResourceAttr( 70 "aws_autoscaling_group.bar", "termination_policies.0", "ClosestToNextInstanceHour"), 71 resource.TestCheckResourceAttr( 72 "aws_autoscaling_group.bar", "protect_from_scale_in", "true"), 73 testLaunchConfigurationName("aws_autoscaling_group.bar", &lc), 74 testAccCheckAutoscalingTags(&group.Tags, "Bar", map[string]interface{}{ 75 "value": "bar-foo", 76 "propagate_at_launch": true, 77 }), 78 ), 79 }, 80 }, 81 }) 82 } 83 84 func TestAccAWSAutoScalingGroup_autoGeneratedName(t *testing.T) { 85 asgNameRegexp := regexp.MustCompile("^tf-asg-") 86 87 resource.Test(t, resource.TestCase{ 88 PreCheck: func() { testAccPreCheck(t) }, 89 Providers: testAccProviders, 90 CheckDestroy: testAccCheckAWSAutoScalingGroupDestroy, 91 Steps: []resource.TestStep{ 92 resource.TestStep{ 93 Config: testAccAWSAutoScalingGroupConfig_autoGeneratedName, 94 Check: resource.ComposeTestCheckFunc( 95 resource.TestMatchResourceAttr( 96 "aws_autoscaling_group.bar", "name", asgNameRegexp), 97 ), 98 }, 99 }, 100 }) 101 } 102 103 func TestAccAWSAutoScalingGroup_terminationPolicies(t *testing.T) { 104 resource.Test(t, resource.TestCase{ 105 PreCheck: func() { testAccPreCheck(t) }, 106 Providers: testAccProviders, 107 CheckDestroy: testAccCheckAWSAutoScalingGroupDestroy, 108 Steps: []resource.TestStep{ 109 resource.TestStep{ 110 Config: testAccAWSAutoScalingGroupConfig_terminationPoliciesEmpty, 111 Check: resource.ComposeTestCheckFunc( 112 resource.TestCheckResourceAttr( 113 "aws_autoscaling_group.bar", "termination_policies.#", "0"), 114 ), 115 }, 116 117 resource.TestStep{ 118 Config: testAccAWSAutoScalingGroupConfig_terminationPoliciesUpdate, 119 Check: resource.ComposeTestCheckFunc( 120 resource.TestCheckResourceAttr( 121 "aws_autoscaling_group.bar", "termination_policies.#", "1"), 122 resource.TestCheckResourceAttr( 123 "aws_autoscaling_group.bar", "termination_policies.0", "OldestInstance"), 124 ), 125 }, 126 127 resource.TestStep{ 128 Config: testAccAWSAutoScalingGroupConfig_terminationPoliciesExplicitDefault, 129 Check: resource.ComposeTestCheckFunc( 130 resource.TestCheckResourceAttr( 131 "aws_autoscaling_group.bar", "termination_policies.#", "1"), 132 resource.TestCheckResourceAttr( 133 "aws_autoscaling_group.bar", "termination_policies.0", "Default"), 134 ), 135 }, 136 137 resource.TestStep{ 138 Config: testAccAWSAutoScalingGroupConfig_terminationPoliciesEmpty, 139 Check: resource.ComposeTestCheckFunc( 140 resource.TestCheckResourceAttr( 141 "aws_autoscaling_group.bar", "termination_policies.#", "0"), 142 ), 143 }, 144 }, 145 }) 146 } 147 148 func TestAccAWSAutoScalingGroup_tags(t *testing.T) { 149 var group autoscaling.Group 150 151 randName := fmt.Sprintf("tfautotags-%s", acctest.RandString(5)) 152 153 resource.Test(t, resource.TestCase{ 154 PreCheck: func() { testAccPreCheck(t) }, 155 Providers: testAccProviders, 156 CheckDestroy: testAccCheckAWSAutoScalingGroupDestroy, 157 Steps: []resource.TestStep{ 158 resource.TestStep{ 159 Config: testAccAWSAutoScalingGroupConfig(randName), 160 Check: resource.ComposeTestCheckFunc( 161 testAccCheckAWSAutoScalingGroupExists("aws_autoscaling_group.bar", &group), 162 testAccCheckAutoscalingTags(&group.Tags, "Foo", map[string]interface{}{ 163 "value": "foo-bar", 164 "propagate_at_launch": true, 165 }), 166 ), 167 }, 168 169 resource.TestStep{ 170 Config: testAccAWSAutoScalingGroupConfigUpdate(randName), 171 Check: resource.ComposeTestCheckFunc( 172 testAccCheckAWSAutoScalingGroupExists("aws_autoscaling_group.bar", &group), 173 testAccCheckAutoscalingTagNotExists(&group.Tags, "Foo"), 174 testAccCheckAutoscalingTags(&group.Tags, "Bar", map[string]interface{}{ 175 "value": "bar-foo", 176 "propagate_at_launch": true, 177 }), 178 ), 179 }, 180 }, 181 }) 182 } 183 184 func TestAccAWSAutoScalingGroup_VpcUpdates(t *testing.T) { 185 var group autoscaling.Group 186 187 resource.Test(t, resource.TestCase{ 188 PreCheck: func() { testAccPreCheck(t) }, 189 Providers: testAccProviders, 190 CheckDestroy: testAccCheckAWSAutoScalingGroupDestroy, 191 Steps: []resource.TestStep{ 192 resource.TestStep{ 193 Config: testAccAWSAutoScalingGroupConfigWithAZ, 194 Check: resource.ComposeTestCheckFunc( 195 testAccCheckAWSAutoScalingGroupExists("aws_autoscaling_group.bar", &group), 196 resource.TestCheckResourceAttr( 197 "aws_autoscaling_group.bar", "availability_zones.#", "1"), 198 resource.TestCheckResourceAttr( 199 "aws_autoscaling_group.bar", "availability_zones.2487133097", "us-west-2a"), 200 resource.TestCheckResourceAttr( 201 "aws_autoscaling_group.bar", "vpc_zone_identifier.#", "1"), 202 ), 203 }, 204 205 resource.TestStep{ 206 Config: testAccAWSAutoScalingGroupConfigWithVPCIdent, 207 Check: resource.ComposeTestCheckFunc( 208 testAccCheckAWSAutoScalingGroupExists("aws_autoscaling_group.bar", &group), 209 testAccCheckAWSAutoScalingGroupAttributesVPCZoneIdentifer(&group), 210 resource.TestCheckResourceAttr( 211 "aws_autoscaling_group.bar", "availability_zones.#", "1"), 212 resource.TestCheckResourceAttr( 213 "aws_autoscaling_group.bar", "availability_zones.2487133097", "us-west-2a"), 214 resource.TestCheckResourceAttr( 215 "aws_autoscaling_group.bar", "vpc_zone_identifier.#", "1"), 216 ), 217 }, 218 }, 219 }) 220 } 221 222 func TestAccAWSAutoScalingGroup_WithLoadBalancer(t *testing.T) { 223 var group autoscaling.Group 224 225 resource.Test(t, resource.TestCase{ 226 PreCheck: func() { testAccPreCheck(t) }, 227 Providers: testAccProviders, 228 CheckDestroy: testAccCheckAWSAutoScalingGroupDestroy, 229 Steps: []resource.TestStep{ 230 resource.TestStep{ 231 Config: testAccAWSAutoScalingGroupConfigWithLoadBalancer, 232 Check: resource.ComposeTestCheckFunc( 233 testAccCheckAWSAutoScalingGroupExists("aws_autoscaling_group.bar", &group), 234 testAccCheckAWSAutoScalingGroupAttributesLoadBalancer(&group), 235 ), 236 }, 237 }, 238 }) 239 } 240 241 func TestAccAWSAutoScalingGroup_withPlacementGroup(t *testing.T) { 242 var group autoscaling.Group 243 244 randName := fmt.Sprintf("tf_placement_test-%s", acctest.RandString(5)) 245 resource.Test(t, resource.TestCase{ 246 PreCheck: func() { testAccPreCheck(t) }, 247 Providers: testAccProviders, 248 CheckDestroy: testAccCheckAWSAutoScalingGroupDestroy, 249 Steps: []resource.TestStep{ 250 resource.TestStep{ 251 Config: testAccAWSAutoScalingGroupConfig_withPlacementGroup(randName), 252 Check: resource.ComposeTestCheckFunc( 253 testAccCheckAWSAutoScalingGroupExists("aws_autoscaling_group.bar", &group), 254 resource.TestCheckResourceAttr( 255 "aws_autoscaling_group.bar", "placement_group", randName), 256 ), 257 }, 258 }, 259 }) 260 } 261 262 func TestAccAWSAutoScalingGroup_withMetrics(t *testing.T) { 263 var group autoscaling.Group 264 265 resource.Test(t, resource.TestCase{ 266 PreCheck: func() { testAccPreCheck(t) }, 267 Providers: testAccProviders, 268 CheckDestroy: testAccCheckAWSAutoScalingGroupDestroy, 269 Steps: []resource.TestStep{ 270 resource.TestStep{ 271 Config: testAccAWSAutoscalingMetricsCollectionConfig_allMetricsCollected, 272 Check: resource.ComposeTestCheckFunc( 273 testAccCheckAWSAutoScalingGroupExists("aws_autoscaling_group.bar", &group), 274 resource.TestCheckResourceAttr( 275 "aws_autoscaling_group.bar", "enabled_metrics.#", "7"), 276 ), 277 }, 278 279 resource.TestStep{ 280 Config: testAccAWSAutoscalingMetricsCollectionConfig_updatingMetricsCollected, 281 Check: resource.ComposeTestCheckFunc( 282 testAccCheckAWSAutoScalingGroupExists("aws_autoscaling_group.bar", &group), 283 resource.TestCheckResourceAttr( 284 "aws_autoscaling_group.bar", "enabled_metrics.#", "5"), 285 ), 286 }, 287 }, 288 }) 289 } 290 291 func testAccCheckAWSAutoScalingGroupDestroy(s *terraform.State) error { 292 conn := testAccProvider.Meta().(*AWSClient).autoscalingconn 293 294 for _, rs := range s.RootModule().Resources { 295 if rs.Type != "aws_autoscaling_group" { 296 continue 297 } 298 299 // Try to find the Group 300 describeGroups, err := conn.DescribeAutoScalingGroups( 301 &autoscaling.DescribeAutoScalingGroupsInput{ 302 AutoScalingGroupNames: []*string{aws.String(rs.Primary.ID)}, 303 }) 304 305 if err == nil { 306 if len(describeGroups.AutoScalingGroups) != 0 && 307 *describeGroups.AutoScalingGroups[0].AutoScalingGroupName == rs.Primary.ID { 308 return fmt.Errorf("AutoScaling Group still exists") 309 } 310 } 311 312 // Verify the error 313 ec2err, ok := err.(awserr.Error) 314 if !ok { 315 return err 316 } 317 if ec2err.Code() != "InvalidGroup.NotFound" { 318 return err 319 } 320 } 321 322 return nil 323 } 324 325 func testAccCheckAWSAutoScalingGroupAttributes(group *autoscaling.Group, name string) resource.TestCheckFunc { 326 return func(s *terraform.State) error { 327 if *group.AvailabilityZones[0] != "us-west-2a" { 328 return fmt.Errorf("Bad availability_zones: %#v", group.AvailabilityZones[0]) 329 } 330 331 if *group.AutoScalingGroupName != name { 332 return fmt.Errorf("Bad Autoscaling Group name, expected (%s), got (%s)", name, *group.AutoScalingGroupName) 333 } 334 335 if *group.MaxSize != 5 { 336 return fmt.Errorf("Bad max_size: %d", *group.MaxSize) 337 } 338 339 if *group.MinSize != 2 { 340 return fmt.Errorf("Bad max_size: %d", *group.MinSize) 341 } 342 343 if *group.HealthCheckType != "ELB" { 344 return fmt.Errorf("Bad health_check_type,\nexpected: %s\ngot: %s", "ELB", *group.HealthCheckType) 345 } 346 347 if *group.HealthCheckGracePeriod != 300 { 348 return fmt.Errorf("Bad health_check_grace_period: %d", *group.HealthCheckGracePeriod) 349 } 350 351 if *group.DesiredCapacity != 4 { 352 return fmt.Errorf("Bad desired_capacity: %d", *group.DesiredCapacity) 353 } 354 355 if *group.LaunchConfigurationName == "" { 356 return fmt.Errorf("Bad launch configuration name: %s", *group.LaunchConfigurationName) 357 } 358 359 t := &autoscaling.TagDescription{ 360 Key: aws.String("Foo"), 361 Value: aws.String("foo-bar"), 362 PropagateAtLaunch: aws.Bool(true), 363 ResourceType: aws.String("auto-scaling-group"), 364 ResourceId: group.AutoScalingGroupName, 365 } 366 367 if !reflect.DeepEqual(group.Tags[0], t) { 368 return fmt.Errorf( 369 "Got:\n\n%#v\n\nExpected:\n\n%#v\n", 370 group.Tags[0], 371 t) 372 } 373 374 return nil 375 } 376 } 377 378 func testAccCheckAWSAutoScalingGroupAttributesLoadBalancer(group *autoscaling.Group) resource.TestCheckFunc { 379 return func(s *terraform.State) error { 380 if len(group.LoadBalancerNames) != 1 { 381 return fmt.Errorf("Bad load_balancers: %v", group.LoadBalancerNames) 382 } 383 384 return nil 385 } 386 } 387 388 func testAccCheckAWSAutoScalingGroupExists(n string, group *autoscaling.Group) resource.TestCheckFunc { 389 return func(s *terraform.State) error { 390 rs, ok := s.RootModule().Resources[n] 391 if !ok { 392 return fmt.Errorf("Not found: %s", n) 393 } 394 395 if rs.Primary.ID == "" { 396 return fmt.Errorf("No AutoScaling Group ID is set") 397 } 398 399 conn := testAccProvider.Meta().(*AWSClient).autoscalingconn 400 401 describeGroups, err := conn.DescribeAutoScalingGroups( 402 &autoscaling.DescribeAutoScalingGroupsInput{ 403 AutoScalingGroupNames: []*string{aws.String(rs.Primary.ID)}, 404 }) 405 406 if err != nil { 407 return err 408 } 409 410 if len(describeGroups.AutoScalingGroups) != 1 || 411 *describeGroups.AutoScalingGroups[0].AutoScalingGroupName != rs.Primary.ID { 412 return fmt.Errorf("AutoScaling Group not found") 413 } 414 415 *group = *describeGroups.AutoScalingGroups[0] 416 417 return nil 418 } 419 } 420 421 func testLaunchConfigurationName(n string, lc *autoscaling.LaunchConfiguration) resource.TestCheckFunc { 422 return func(s *terraform.State) error { 423 rs, ok := s.RootModule().Resources[n] 424 if !ok { 425 return fmt.Errorf("Not found: %s", n) 426 } 427 428 if *lc.LaunchConfigurationName != rs.Primary.Attributes["launch_configuration"] { 429 return fmt.Errorf("Launch configuration names do not match") 430 } 431 432 return nil 433 } 434 } 435 436 func testAccCheckAWSAutoScalingGroupHealthyCapacity( 437 g *autoscaling.Group, exp int) resource.TestCheckFunc { 438 return func(s *terraform.State) error { 439 healthy := 0 440 for _, i := range g.Instances { 441 if i.HealthStatus == nil { 442 continue 443 } 444 if strings.EqualFold(*i.HealthStatus, "Healthy") { 445 healthy++ 446 } 447 } 448 if healthy < exp { 449 return fmt.Errorf("Expected at least %d healthy, got %d.", exp, healthy) 450 } 451 return nil 452 } 453 } 454 455 func testAccCheckAWSAutoScalingGroupAttributesVPCZoneIdentifer(group *autoscaling.Group) resource.TestCheckFunc { 456 return func(s *terraform.State) error { 457 // Grab Subnet Ids 458 var subnets []string 459 for _, rs := range s.RootModule().Resources { 460 if rs.Type != "aws_subnet" { 461 continue 462 } 463 subnets = append(subnets, rs.Primary.Attributes["id"]) 464 } 465 466 if group.VPCZoneIdentifier == nil { 467 return fmt.Errorf("Bad VPC Zone Identifier\nexpected: %s\ngot nil", subnets) 468 } 469 470 zones := strings.Split(*group.VPCZoneIdentifier, ",") 471 472 remaining := len(zones) 473 for _, z := range zones { 474 for _, s := range subnets { 475 if z == s { 476 remaining-- 477 } 478 } 479 } 480 481 if remaining != 0 { 482 return fmt.Errorf("Bad VPC Zone Identifier match\nexpected: %s\ngot:%s", zones, subnets) 483 } 484 485 return nil 486 } 487 } 488 489 const testAccAWSAutoScalingGroupConfig_autoGeneratedName = ` 490 resource "aws_launch_configuration" "foobar" { 491 image_id = "ami-21f78e11" 492 instance_type = "t1.micro" 493 } 494 495 resource "aws_autoscaling_group" "bar" { 496 availability_zones = ["us-west-2a"] 497 desired_capacity = 0 498 max_size = 0 499 min_size = 0 500 launch_configuration = "${aws_launch_configuration.foobar.name}" 501 } 502 ` 503 504 const testAccAWSAutoScalingGroupConfig_terminationPoliciesEmpty = ` 505 resource "aws_launch_configuration" "foobar" { 506 image_id = "ami-21f78e11" 507 instance_type = "t1.micro" 508 } 509 510 resource "aws_autoscaling_group" "bar" { 511 availability_zones = ["us-west-2a"] 512 max_size = 0 513 min_size = 0 514 desired_capacity = 0 515 516 launch_configuration = "${aws_launch_configuration.foobar.name}" 517 } 518 ` 519 520 const testAccAWSAutoScalingGroupConfig_terminationPoliciesExplicitDefault = ` 521 resource "aws_launch_configuration" "foobar" { 522 image_id = "ami-21f78e11" 523 instance_type = "t1.micro" 524 } 525 526 resource "aws_autoscaling_group" "bar" { 527 availability_zones = ["us-west-2a"] 528 max_size = 0 529 min_size = 0 530 desired_capacity = 0 531 termination_policies = ["Default"] 532 533 launch_configuration = "${aws_launch_configuration.foobar.name}" 534 } 535 ` 536 537 const testAccAWSAutoScalingGroupConfig_terminationPoliciesUpdate = ` 538 resource "aws_launch_configuration" "foobar" { 539 image_id = "ami-21f78e11" 540 instance_type = "t1.micro" 541 } 542 543 resource "aws_autoscaling_group" "bar" { 544 availability_zones = ["us-west-2a"] 545 max_size = 0 546 min_size = 0 547 desired_capacity = 0 548 termination_policies = ["OldestInstance"] 549 550 launch_configuration = "${aws_launch_configuration.foobar.name}" 551 } 552 ` 553 554 func testAccAWSAutoScalingGroupConfig(name string) string { 555 return fmt.Sprintf(` 556 resource "aws_launch_configuration" "foobar" { 557 image_id = "ami-21f78e11" 558 instance_type = "t1.micro" 559 } 560 561 resource "aws_placement_group" "test" { 562 name = "asg_pg_%s" 563 strategy = "cluster" 564 } 565 566 resource "aws_autoscaling_group" "bar" { 567 availability_zones = ["us-west-2a"] 568 name = "%s" 569 max_size = 5 570 min_size = 2 571 health_check_type = "ELB" 572 desired_capacity = 4 573 force_delete = true 574 termination_policies = ["OldestInstance","ClosestToNextInstanceHour"] 575 576 launch_configuration = "${aws_launch_configuration.foobar.name}" 577 578 tag { 579 key = "Foo" 580 value = "foo-bar" 581 propagate_at_launch = true 582 } 583 } 584 `, name, name) 585 } 586 587 func testAccAWSAutoScalingGroupConfigUpdate(name string) string { 588 return fmt.Sprintf(` 589 resource "aws_launch_configuration" "foobar" { 590 image_id = "ami-21f78e11" 591 instance_type = "t1.micro" 592 } 593 594 resource "aws_launch_configuration" "new" { 595 image_id = "ami-21f78e11" 596 instance_type = "t1.micro" 597 } 598 599 resource "aws_autoscaling_group" "bar" { 600 availability_zones = ["us-west-2a"] 601 name = "%s" 602 max_size = 5 603 min_size = 2 604 health_check_grace_period = 300 605 health_check_type = "ELB" 606 desired_capacity = 5 607 force_delete = true 608 termination_policies = ["ClosestToNextInstanceHour"] 609 protect_from_scale_in = true 610 611 launch_configuration = "${aws_launch_configuration.new.name}" 612 613 tag { 614 key = "Bar" 615 value = "bar-foo" 616 propagate_at_launch = true 617 } 618 } 619 `, name) 620 } 621 622 const testAccAWSAutoScalingGroupConfigWithLoadBalancer = ` 623 resource "aws_vpc" "foo" { 624 cidr_block = "10.1.0.0/16" 625 tags { Name = "tf-asg-test" } 626 } 627 628 resource "aws_internet_gateway" "gw" { 629 vpc_id = "${aws_vpc.foo.id}" 630 } 631 632 resource "aws_subnet" "foo" { 633 cidr_block = "10.1.1.0/24" 634 vpc_id = "${aws_vpc.foo.id}" 635 } 636 637 resource "aws_security_group" "foo" { 638 vpc_id="${aws_vpc.foo.id}" 639 640 ingress { 641 protocol = "-1" 642 from_port = 0 643 to_port = 0 644 cidr_blocks = ["0.0.0.0/0"] 645 } 646 647 egress { 648 protocol = "-1" 649 from_port = 0 650 to_port = 0 651 cidr_blocks = ["0.0.0.0/0"] 652 } 653 } 654 655 resource "aws_elb" "bar" { 656 subnets = ["${aws_subnet.foo.id}"] 657 security_groups = ["${aws_security_group.foo.id}"] 658 659 listener { 660 instance_port = 80 661 instance_protocol = "http" 662 lb_port = 80 663 lb_protocol = "http" 664 } 665 666 health_check { 667 healthy_threshold = 2 668 unhealthy_threshold = 2 669 target = "HTTP:80/" 670 interval = 5 671 timeout = 2 672 } 673 674 depends_on = ["aws_internet_gateway.gw"] 675 } 676 677 resource "aws_launch_configuration" "foobar" { 678 // need an AMI that listens on :80 at boot, this is: 679 // bitnami-nginxstack-1.6.1-0-linux-ubuntu-14.04.1-x86_64-hvm-ebs-ami-99f5b1a9-3 680 image_id = "ami-b5b3fc85" 681 instance_type = "t2.micro" 682 security_groups = ["${aws_security_group.foo.id}"] 683 } 684 685 resource "aws_autoscaling_group" "bar" { 686 availability_zones = ["${aws_subnet.foo.availability_zone}"] 687 vpc_zone_identifier = ["${aws_subnet.foo.id}"] 688 max_size = 2 689 min_size = 2 690 health_check_grace_period = 300 691 health_check_type = "ELB" 692 wait_for_elb_capacity = 2 693 force_delete = true 694 695 launch_configuration = "${aws_launch_configuration.foobar.name}" 696 load_balancers = ["${aws_elb.bar.name}"] 697 } 698 ` 699 700 const testAccAWSAutoScalingGroupConfigWithAZ = ` 701 resource "aws_vpc" "default" { 702 cidr_block = "10.0.0.0/16" 703 tags { 704 Name = "terraform-test" 705 } 706 } 707 708 resource "aws_subnet" "main" { 709 vpc_id = "${aws_vpc.default.id}" 710 cidr_block = "10.0.1.0/24" 711 availability_zone = "us-west-2a" 712 tags { 713 Name = "terraform-test" 714 } 715 } 716 717 resource "aws_launch_configuration" "foobar" { 718 image_id = "ami-b5b3fc85" 719 instance_type = "t2.micro" 720 } 721 722 resource "aws_autoscaling_group" "bar" { 723 availability_zones = [ 724 "us-west-2a" 725 ] 726 desired_capacity = 0 727 max_size = 0 728 min_size = 0 729 launch_configuration = "${aws_launch_configuration.foobar.name}" 730 } 731 ` 732 733 const testAccAWSAutoScalingGroupConfigWithVPCIdent = ` 734 resource "aws_vpc" "default" { 735 cidr_block = "10.0.0.0/16" 736 tags { 737 Name = "terraform-test" 738 } 739 } 740 741 resource "aws_subnet" "main" { 742 vpc_id = "${aws_vpc.default.id}" 743 cidr_block = "10.0.1.0/24" 744 availability_zone = "us-west-2a" 745 tags { 746 Name = "terraform-test" 747 } 748 } 749 750 resource "aws_launch_configuration" "foobar" { 751 image_id = "ami-b5b3fc85" 752 instance_type = "t2.micro" 753 } 754 755 resource "aws_autoscaling_group" "bar" { 756 vpc_zone_identifier = [ 757 "${aws_subnet.main.id}", 758 ] 759 desired_capacity = 0 760 max_size = 0 761 min_size = 0 762 launch_configuration = "${aws_launch_configuration.foobar.name}" 763 } 764 ` 765 766 func testAccAWSAutoScalingGroupConfig_withPlacementGroup(name string) string { 767 return fmt.Sprintf(` 768 resource "aws_launch_configuration" "foobar" { 769 image_id = "ami-21f78e11" 770 instance_type = "c3.large" 771 } 772 773 resource "aws_placement_group" "test" { 774 name = "%s" 775 strategy = "cluster" 776 } 777 778 resource "aws_autoscaling_group" "bar" { 779 availability_zones = ["us-west-2a"] 780 name = "%s" 781 max_size = 1 782 min_size = 1 783 health_check_grace_period = 300 784 health_check_type = "ELB" 785 desired_capacity = 1 786 force_delete = true 787 termination_policies = ["OldestInstance","ClosestToNextInstanceHour"] 788 placement_group = "${aws_placement_group.test.name}" 789 790 launch_configuration = "${aws_launch_configuration.foobar.name}" 791 792 tag { 793 key = "Foo" 794 value = "foo-bar" 795 propagate_at_launch = true 796 } 797 } 798 `, name, name) 799 } 800 801 const testAccAWSAutoscalingMetricsCollectionConfig_allMetricsCollected = ` 802 resource "aws_launch_configuration" "foobar" { 803 image_id = "ami-21f78e11" 804 instance_type = "t1.micro" 805 } 806 807 resource "aws_autoscaling_group" "bar" { 808 availability_zones = ["us-west-2a"] 809 max_size = 1 810 min_size = 0 811 health_check_grace_period = 300 812 health_check_type = "EC2" 813 desired_capacity = 0 814 force_delete = true 815 termination_policies = ["OldestInstance","ClosestToNextInstanceHour"] 816 launch_configuration = "${aws_launch_configuration.foobar.name}" 817 enabled_metrics = ["GroupTotalInstances", 818 "GroupPendingInstances", 819 "GroupTerminatingInstances", 820 "GroupDesiredCapacity", 821 "GroupInServiceInstances", 822 "GroupMinSize", 823 "GroupMaxSize" 824 ] 825 metrics_granularity = "1Minute" 826 } 827 ` 828 829 const testAccAWSAutoscalingMetricsCollectionConfig_updatingMetricsCollected = ` 830 resource "aws_launch_configuration" "foobar" { 831 image_id = "ami-21f78e11" 832 instance_type = "t1.micro" 833 } 834 835 resource "aws_autoscaling_group" "bar" { 836 availability_zones = ["us-west-2a"] 837 max_size = 1 838 min_size = 0 839 health_check_grace_period = 300 840 health_check_type = "EC2" 841 desired_capacity = 0 842 force_delete = true 843 termination_policies = ["OldestInstance","ClosestToNextInstanceHour"] 844 launch_configuration = "${aws_launch_configuration.foobar.name}" 845 enabled_metrics = ["GroupTotalInstances", 846 "GroupPendingInstances", 847 "GroupTerminatingInstances", 848 "GroupDesiredCapacity", 849 "GroupMaxSize" 850 ] 851 metrics_granularity = "1Minute" 852 } 853 `