aws-sdk-elasticloadbalancing 1.0.0.rc6 → 1.0.0.rc7
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +4 -4
- data/lib/aws-sdk-elasticloadbalancing.rb +1 -1
- data/lib/aws-sdk-elasticloadbalancing/client.rb +828 -1
- metadata +4 -4
    
        checksums.yaml
    CHANGED
    
    | @@ -1,7 +1,7 @@ | |
| 1 1 | 
             
            ---
         | 
| 2 2 | 
             
            SHA1:
         | 
| 3 | 
            -
              metadata.gz:  | 
| 4 | 
            -
              data.tar.gz:  | 
| 3 | 
            +
              metadata.gz: 2c81bd9ff955c688d7b2bbfb7926b1270a45badd
         | 
| 4 | 
            +
              data.tar.gz: a71d0d774ce20866768497c89763577bcc1011de
         | 
| 5 5 | 
             
            SHA512:
         | 
| 6 | 
            -
              metadata.gz:  | 
| 7 | 
            -
              data.tar.gz:  | 
| 6 | 
            +
              metadata.gz: a17fb875356933a40f07c040f076570a63be0c95f03b69fa8cd19f8c3969e15ed599698e5a8d4df62b6ff03b6cbb4dc7dc281f2a004297e08cd52d24c60b2f44
         | 
| 7 | 
            +
              data.tar.gz: cf3340228b8f81504945dc4eaf199a2fc7e133feb32ec8810ac46ff32b9e60928bb81e966d2f83e665c97a4fcc904812d95e88baa6fe19ccd14efded71fbfcad
         | 
| @@ -167,6 +167,27 @@ module Aws::ElasticLoadBalancing | |
| 167 167 | 
             
                #
         | 
| 168 168 | 
             
                # @return [Struct] Returns an empty {Seahorse::Client::Response response}.
         | 
| 169 169 | 
             
                #
         | 
| 170 | 
            +
                #
         | 
| 171 | 
            +
                # @example Example: To add tags to a load balancer
         | 
| 172 | 
            +
                #
         | 
| 173 | 
            +
                #   # This example adds two tags to the specified load balancer.
         | 
| 174 | 
            +
                #
         | 
| 175 | 
            +
                #   resp = client.add_tags({
         | 
| 176 | 
            +
                #     load_balancer_names: [
         | 
| 177 | 
            +
                #       "my-load-balancer", 
         | 
| 178 | 
            +
                #     ], 
         | 
| 179 | 
            +
                #     tags: [
         | 
| 180 | 
            +
                #       {
         | 
| 181 | 
            +
                #         key: "project", 
         | 
| 182 | 
            +
                #         value: "lima", 
         | 
| 183 | 
            +
                #       }, 
         | 
| 184 | 
            +
                #       {
         | 
| 185 | 
            +
                #         key: "department", 
         | 
| 186 | 
            +
                #         value: "digital-media", 
         | 
| 187 | 
            +
                #       }, 
         | 
| 188 | 
            +
                #     ], 
         | 
| 189 | 
            +
                #   })
         | 
| 190 | 
            +
                #
         | 
| 170 191 | 
             
                # @example Request syntax with placeholder values
         | 
| 171 192 | 
             
                #
         | 
| 172 193 | 
             
                #   resp = client.add_tags({
         | 
| @@ -210,6 +231,25 @@ module Aws::ElasticLoadBalancing | |
| 210 231 | 
             
                #
         | 
| 211 232 | 
             
                #   * {Types::ApplySecurityGroupsToLoadBalancerOutput#security_groups #security_groups} => Array<String>
         | 
| 212 233 | 
             
                #
         | 
| 234 | 
            +
                #
         | 
| 235 | 
            +
                # @example Example: To associate a security group with a load balancer in a VPC
         | 
| 236 | 
            +
                #
         | 
| 237 | 
            +
                #   # This example associates a security group with the specified load balancer in a VPC.
         | 
| 238 | 
            +
                #
         | 
| 239 | 
            +
                #   resp = client.apply_security_groups_to_load_balancer({
         | 
| 240 | 
            +
                #     load_balancer_name: "my-load-balancer", 
         | 
| 241 | 
            +
                #     security_groups: [
         | 
| 242 | 
            +
                #       "sg-fc448899", 
         | 
| 243 | 
            +
                #     ], 
         | 
| 244 | 
            +
                #   })
         | 
| 245 | 
            +
                #
         | 
| 246 | 
            +
                #   resp.to_h outputs the following:
         | 
| 247 | 
            +
                #   {
         | 
| 248 | 
            +
                #     security_groups: [
         | 
| 249 | 
            +
                #       "sg-fc448899", 
         | 
| 250 | 
            +
                #     ], 
         | 
| 251 | 
            +
                #   }
         | 
| 252 | 
            +
                #
         | 
| 213 253 | 
             
                # @example Request syntax with placeholder values
         | 
| 214 254 | 
             
                #
         | 
| 215 255 | 
             
                #   resp = client.apply_security_groups_to_load_balancer({
         | 
| @@ -253,6 +293,26 @@ module Aws::ElasticLoadBalancing | |
| 253 293 | 
             
                #
         | 
| 254 294 | 
             
                #   * {Types::AttachLoadBalancerToSubnetsOutput#subnets #subnets} => Array<String>
         | 
| 255 295 | 
             
                #
         | 
| 296 | 
            +
                #
         | 
| 297 | 
            +
                # @example Example: To attach subnets to a load balancer
         | 
| 298 | 
            +
                #
         | 
| 299 | 
            +
                #   # This example adds the specified subnet to the set of configured subnets for the specified load balancer.
         | 
| 300 | 
            +
                #
         | 
| 301 | 
            +
                #   resp = client.attach_load_balancer_to_subnets({
         | 
| 302 | 
            +
                #     load_balancer_name: "my-load-balancer", 
         | 
| 303 | 
            +
                #     subnets: [
         | 
| 304 | 
            +
                #       "subnet-0ecac448", 
         | 
| 305 | 
            +
                #     ], 
         | 
| 306 | 
            +
                #   })
         | 
| 307 | 
            +
                #
         | 
| 308 | 
            +
                #   resp.to_h outputs the following:
         | 
| 309 | 
            +
                #   {
         | 
| 310 | 
            +
                #     subnets: [
         | 
| 311 | 
            +
                #       "subnet-15aaab61", 
         | 
| 312 | 
            +
                #       "subnet-0ecac448", 
         | 
| 313 | 
            +
                #     ], 
         | 
| 314 | 
            +
                #   }
         | 
| 315 | 
            +
                #
         | 
| 256 316 | 
             
                # @example Request syntax with placeholder values
         | 
| 257 317 | 
             
                #
         | 
| 258 318 | 
             
                #   resp = client.attach_load_balancer_to_subnets({
         | 
| @@ -294,6 +354,33 @@ module Aws::ElasticLoadBalancing | |
| 294 354 | 
             
                #
         | 
| 295 355 | 
             
                #   * {Types::ConfigureHealthCheckOutput#health_check #health_check} => Types::HealthCheck
         | 
| 296 356 | 
             
                #
         | 
| 357 | 
            +
                #
         | 
| 358 | 
            +
                # @example Example: To specify the health check settings for your backend EC2 instances
         | 
| 359 | 
            +
                #
         | 
| 360 | 
            +
                #   # This example specifies the health check settings used to evaluate the health of your backend EC2 instances.
         | 
| 361 | 
            +
                #
         | 
| 362 | 
            +
                #   resp = client.configure_health_check({
         | 
| 363 | 
            +
                #     health_check: {
         | 
| 364 | 
            +
                #       healthy_threshold: 2, 
         | 
| 365 | 
            +
                #       interval: 30, 
         | 
| 366 | 
            +
                #       target: "HTTP:80/png", 
         | 
| 367 | 
            +
                #       timeout: 3, 
         | 
| 368 | 
            +
                #       unhealthy_threshold: 2, 
         | 
| 369 | 
            +
                #     }, 
         | 
| 370 | 
            +
                #     load_balancer_name: "my-load-balancer", 
         | 
| 371 | 
            +
                #   })
         | 
| 372 | 
            +
                #
         | 
| 373 | 
            +
                #   resp.to_h outputs the following:
         | 
| 374 | 
            +
                #   {
         | 
| 375 | 
            +
                #     health_check: {
         | 
| 376 | 
            +
                #       healthy_threshold: 2, 
         | 
| 377 | 
            +
                #       interval: 30, 
         | 
| 378 | 
            +
                #       target: "HTTP:80/png", 
         | 
| 379 | 
            +
                #       timeout: 3, 
         | 
| 380 | 
            +
                #       unhealthy_threshold: 2, 
         | 
| 381 | 
            +
                #     }, 
         | 
| 382 | 
            +
                #   }
         | 
| 383 | 
            +
                #
         | 
| 297 384 | 
             
                # @example Request syntax with placeholder values
         | 
| 298 385 | 
             
                #
         | 
| 299 386 | 
             
                #   resp = client.configure_health_check({
         | 
| @@ -358,6 +445,17 @@ module Aws::ElasticLoadBalancing | |
| 358 445 | 
             
                #
         | 
| 359 446 | 
             
                # @return [Struct] Returns an empty {Seahorse::Client::Response response}.
         | 
| 360 447 | 
             
                #
         | 
| 448 | 
            +
                #
         | 
| 449 | 
            +
                # @example Example: To generate a stickiness policy for your load balancer
         | 
| 450 | 
            +
                #
         | 
| 451 | 
            +
                #   # This example generates a stickiness policy that follows the sticky session lifetimes of the application-generated cookie.
         | 
| 452 | 
            +
                #
         | 
| 453 | 
            +
                #   resp = client.create_app_cookie_stickiness_policy({
         | 
| 454 | 
            +
                #     cookie_name: "my-app-cookie", 
         | 
| 455 | 
            +
                #     load_balancer_name: "my-load-balancer", 
         | 
| 456 | 
            +
                #     policy_name: "my-app-cookie-policy", 
         | 
| 457 | 
            +
                #   })
         | 
| 458 | 
            +
                #
         | 
| 361 459 | 
             
                # @example Request syntax with placeholder values
         | 
| 362 460 | 
             
                #
         | 
| 363 461 | 
             
                #   resp = client.create_app_cookie_stickiness_policy({
         | 
| @@ -415,6 +513,17 @@ module Aws::ElasticLoadBalancing | |
| 415 513 | 
             
                #
         | 
| 416 514 | 
             
                # @return [Struct] Returns an empty {Seahorse::Client::Response response}.
         | 
| 417 515 | 
             
                #
         | 
| 516 | 
            +
                #
         | 
| 517 | 
            +
                # @example Example: To generate a duration-based stickiness policy for your load balancer
         | 
| 518 | 
            +
                #
         | 
| 519 | 
            +
                #   # This example generates a stickiness policy with sticky session lifetimes controlled by the specified expiration period.
         | 
| 520 | 
            +
                #
         | 
| 521 | 
            +
                #   resp = client.create_lb_cookie_stickiness_policy({
         | 
| 522 | 
            +
                #     cookie_expiration_period: 60, 
         | 
| 523 | 
            +
                #     load_balancer_name: "my-load-balancer", 
         | 
| 524 | 
            +
                #     policy_name: "my-duration-cookie-policy", 
         | 
| 525 | 
            +
                #   })
         | 
| 526 | 
            +
                #
         | 
| 418 527 | 
             
                # @example Request syntax with placeholder values
         | 
| 419 528 | 
             
                #
         | 
| 420 529 | 
             
                #   resp = client.create_lb_cookie_stickiness_policy({
         | 
| @@ -517,6 +626,151 @@ module Aws::ElasticLoadBalancing | |
| 517 626 | 
             
                #
         | 
| 518 627 | 
             
                #   * {Types::CreateAccessPointOutput#dns_name #dns_name} => String
         | 
| 519 628 | 
             
                #
         | 
| 629 | 
            +
                #
         | 
| 630 | 
            +
                # @example Example: To create an HTTP load balancer in a VPC
         | 
| 631 | 
            +
                #
         | 
| 632 | 
            +
                #   # This example creates a load balancer with an HTTP listener in a VPC.
         | 
| 633 | 
            +
                #
         | 
| 634 | 
            +
                #   resp = client.create_load_balancer({
         | 
| 635 | 
            +
                #     listeners: [
         | 
| 636 | 
            +
                #       {
         | 
| 637 | 
            +
                #         instance_port: 80, 
         | 
| 638 | 
            +
                #         instance_protocol: "HTTP", 
         | 
| 639 | 
            +
                #         load_balancer_port: 80, 
         | 
| 640 | 
            +
                #         protocol: "HTTP", 
         | 
| 641 | 
            +
                #       }, 
         | 
| 642 | 
            +
                #     ], 
         | 
| 643 | 
            +
                #     load_balancer_name: "my-load-balancer", 
         | 
| 644 | 
            +
                #     security_groups: [
         | 
| 645 | 
            +
                #       "sg-a61988c3", 
         | 
| 646 | 
            +
                #     ], 
         | 
| 647 | 
            +
                #     subnets: [
         | 
| 648 | 
            +
                #       "subnet-15aaab61", 
         | 
| 649 | 
            +
                #     ], 
         | 
| 650 | 
            +
                #   })
         | 
| 651 | 
            +
                #
         | 
| 652 | 
            +
                #   resp.to_h outputs the following:
         | 
| 653 | 
            +
                #   {
         | 
| 654 | 
            +
                #     dns_name: "my-load-balancer-1234567890.us-west-2.elb.amazonaws.com", 
         | 
| 655 | 
            +
                #   }
         | 
| 656 | 
            +
                #
         | 
| 657 | 
            +
                # @example Example: To create an HTTP load balancer in EC2-Classic
         | 
| 658 | 
            +
                #
         | 
| 659 | 
            +
                #   # This example creates a load balancer with an HTTP listener in EC2-Classic.
         | 
| 660 | 
            +
                #
         | 
| 661 | 
            +
                #   resp = client.create_load_balancer({
         | 
| 662 | 
            +
                #     availability_zones: [
         | 
| 663 | 
            +
                #       "us-west-2a", 
         | 
| 664 | 
            +
                #     ], 
         | 
| 665 | 
            +
                #     listeners: [
         | 
| 666 | 
            +
                #       {
         | 
| 667 | 
            +
                #         instance_port: 80, 
         | 
| 668 | 
            +
                #         instance_protocol: "HTTP", 
         | 
| 669 | 
            +
                #         load_balancer_port: 80, 
         | 
| 670 | 
            +
                #         protocol: "HTTP", 
         | 
| 671 | 
            +
                #       }, 
         | 
| 672 | 
            +
                #     ], 
         | 
| 673 | 
            +
                #     load_balancer_name: "my-load-balancer", 
         | 
| 674 | 
            +
                #   })
         | 
| 675 | 
            +
                #
         | 
| 676 | 
            +
                #   resp.to_h outputs the following:
         | 
| 677 | 
            +
                #   {
         | 
| 678 | 
            +
                #     dns_name: "my-load-balancer-123456789.us-west-2.elb.amazonaws.com", 
         | 
| 679 | 
            +
                #   }
         | 
| 680 | 
            +
                #
         | 
| 681 | 
            +
                # @example Example: To create an HTTPS load balancer in a VPC
         | 
| 682 | 
            +
                #
         | 
| 683 | 
            +
                #   # This example creates a load balancer with an HTTPS listener in a VPC.
         | 
| 684 | 
            +
                #
         | 
| 685 | 
            +
                #   resp = client.create_load_balancer({
         | 
| 686 | 
            +
                #     listeners: [
         | 
| 687 | 
            +
                #       {
         | 
| 688 | 
            +
                #         instance_port: 80, 
         | 
| 689 | 
            +
                #         instance_protocol: "HTTP", 
         | 
| 690 | 
            +
                #         load_balancer_port: 80, 
         | 
| 691 | 
            +
                #         protocol: "HTTP", 
         | 
| 692 | 
            +
                #       }, 
         | 
| 693 | 
            +
                #       {
         | 
| 694 | 
            +
                #         instance_port: 80, 
         | 
| 695 | 
            +
                #         instance_protocol: "HTTP", 
         | 
| 696 | 
            +
                #         load_balancer_port: 443, 
         | 
| 697 | 
            +
                #         protocol: "HTTPS", 
         | 
| 698 | 
            +
                #         ssl_certificate_id: "arn:aws:iam::123456789012:server-certificate/my-server-cert", 
         | 
| 699 | 
            +
                #       }, 
         | 
| 700 | 
            +
                #     ], 
         | 
| 701 | 
            +
                #     load_balancer_name: "my-load-balancer", 
         | 
| 702 | 
            +
                #     security_groups: [
         | 
| 703 | 
            +
                #       "sg-a61988c3", 
         | 
| 704 | 
            +
                #     ], 
         | 
| 705 | 
            +
                #     subnets: [
         | 
| 706 | 
            +
                #       "subnet-15aaab61", 
         | 
| 707 | 
            +
                #     ], 
         | 
| 708 | 
            +
                #   })
         | 
| 709 | 
            +
                #
         | 
| 710 | 
            +
                #   resp.to_h outputs the following:
         | 
| 711 | 
            +
                #   {
         | 
| 712 | 
            +
                #     dns_name: "my-load-balancer-1234567890.us-west-2.elb.amazonaws.com", 
         | 
| 713 | 
            +
                #   }
         | 
| 714 | 
            +
                #
         | 
| 715 | 
            +
                # @example Example: To create an HTTPS load balancer in EC2-Classic
         | 
| 716 | 
            +
                #
         | 
| 717 | 
            +
                #   # This example creates a load balancer with an HTTPS listener in EC2-Classic.
         | 
| 718 | 
            +
                #
         | 
| 719 | 
            +
                #   resp = client.create_load_balancer({
         | 
| 720 | 
            +
                #     availability_zones: [
         | 
| 721 | 
            +
                #       "us-west-2a", 
         | 
| 722 | 
            +
                #     ], 
         | 
| 723 | 
            +
                #     listeners: [
         | 
| 724 | 
            +
                #       {
         | 
| 725 | 
            +
                #         instance_port: 80, 
         | 
| 726 | 
            +
                #         instance_protocol: "HTTP", 
         | 
| 727 | 
            +
                #         load_balancer_port: 80, 
         | 
| 728 | 
            +
                #         protocol: "HTTP", 
         | 
| 729 | 
            +
                #       }, 
         | 
| 730 | 
            +
                #       {
         | 
| 731 | 
            +
                #         instance_port: 80, 
         | 
| 732 | 
            +
                #         instance_protocol: "HTTP", 
         | 
| 733 | 
            +
                #         load_balancer_port: 443, 
         | 
| 734 | 
            +
                #         protocol: "HTTPS", 
         | 
| 735 | 
            +
                #         ssl_certificate_id: "arn:aws:iam::123456789012:server-certificate/my-server-cert", 
         | 
| 736 | 
            +
                #       }, 
         | 
| 737 | 
            +
                #     ], 
         | 
| 738 | 
            +
                #     load_balancer_name: "my-load-balancer", 
         | 
| 739 | 
            +
                #   })
         | 
| 740 | 
            +
                #
         | 
| 741 | 
            +
                #   resp.to_h outputs the following:
         | 
| 742 | 
            +
                #   {
         | 
| 743 | 
            +
                #     dns_name: "my-load-balancer-123456789.us-west-2.elb.amazonaws.com", 
         | 
| 744 | 
            +
                #   }
         | 
| 745 | 
            +
                #
         | 
| 746 | 
            +
                # @example Example: To create an internal load balancer
         | 
| 747 | 
            +
                #
         | 
| 748 | 
            +
                #   # This example creates an internal load balancer with an HTTP listener in a VPC.
         | 
| 749 | 
            +
                #
         | 
| 750 | 
            +
                #   resp = client.create_load_balancer({
         | 
| 751 | 
            +
                #     listeners: [
         | 
| 752 | 
            +
                #       {
         | 
| 753 | 
            +
                #         instance_port: 80, 
         | 
| 754 | 
            +
                #         instance_protocol: "HTTP", 
         | 
| 755 | 
            +
                #         load_balancer_port: 80, 
         | 
| 756 | 
            +
                #         protocol: "HTTP", 
         | 
| 757 | 
            +
                #       }, 
         | 
| 758 | 
            +
                #     ], 
         | 
| 759 | 
            +
                #     load_balancer_name: "my-load-balancer", 
         | 
| 760 | 
            +
                #     scheme: "internal", 
         | 
| 761 | 
            +
                #     security_groups: [
         | 
| 762 | 
            +
                #       "sg-a61988c3", 
         | 
| 763 | 
            +
                #     ], 
         | 
| 764 | 
            +
                #     subnets: [
         | 
| 765 | 
            +
                #       "subnet-15aaab61", 
         | 
| 766 | 
            +
                #     ], 
         | 
| 767 | 
            +
                #   })
         | 
| 768 | 
            +
                #
         | 
| 769 | 
            +
                #   resp.to_h outputs the following:
         | 
| 770 | 
            +
                #   {
         | 
| 771 | 
            +
                #     dns_name: "internal-my-load-balancer-123456789.us-west-2.elb.amazonaws.com", 
         | 
| 772 | 
            +
                #   }
         | 
| 773 | 
            +
                #
         | 
| 520 774 | 
             
                # @example Request syntax with placeholder values
         | 
| 521 775 | 
             
                #
         | 
| 522 776 | 
             
                #   resp = client.create_load_balancer({
         | 
| @@ -575,6 +829,40 @@ module Aws::ElasticLoadBalancing | |
| 575 829 | 
             
                #
         | 
| 576 830 | 
             
                # @return [Struct] Returns an empty {Seahorse::Client::Response response}.
         | 
| 577 831 | 
             
                #
         | 
| 832 | 
            +
                #
         | 
| 833 | 
            +
                # @example Example: To create an HTTP listener for a load balancer
         | 
| 834 | 
            +
                #
         | 
| 835 | 
            +
                #   # This example creates a listener for your load balancer at port 80 using the HTTP protocol.
         | 
| 836 | 
            +
                #
         | 
| 837 | 
            +
                #   resp = client.create_load_balancer_listeners({
         | 
| 838 | 
            +
                #     listeners: [
         | 
| 839 | 
            +
                #       {
         | 
| 840 | 
            +
                #         instance_port: 80, 
         | 
| 841 | 
            +
                #         instance_protocol: "HTTP", 
         | 
| 842 | 
            +
                #         load_balancer_port: 80, 
         | 
| 843 | 
            +
                #         protocol: "HTTP", 
         | 
| 844 | 
            +
                #       }, 
         | 
| 845 | 
            +
                #     ], 
         | 
| 846 | 
            +
                #     load_balancer_name: "my-load-balancer", 
         | 
| 847 | 
            +
                #   })
         | 
| 848 | 
            +
                #
         | 
| 849 | 
            +
                # @example Example: To create an HTTPS listener for a load balancer
         | 
| 850 | 
            +
                #
         | 
| 851 | 
            +
                #   # This example creates a listener for your load balancer at port 443 using the HTTPS protocol.
         | 
| 852 | 
            +
                #
         | 
| 853 | 
            +
                #   resp = client.create_load_balancer_listeners({
         | 
| 854 | 
            +
                #     listeners: [
         | 
| 855 | 
            +
                #       {
         | 
| 856 | 
            +
                #         instance_port: 80, 
         | 
| 857 | 
            +
                #         instance_protocol: "HTTP", 
         | 
| 858 | 
            +
                #         load_balancer_port: 443, 
         | 
| 859 | 
            +
                #         protocol: "HTTPS", 
         | 
| 860 | 
            +
                #         ssl_certificate_id: "arn:aws:iam::123456789012:server-certificate/my-server-cert", 
         | 
| 861 | 
            +
                #       }, 
         | 
| 862 | 
            +
                #     ], 
         | 
| 863 | 
            +
                #     load_balancer_name: "my-load-balancer", 
         | 
| 864 | 
            +
                #   })
         | 
| 865 | 
            +
                #
         | 
| 578 866 | 
             
                # @example Request syntax with placeholder values
         | 
| 579 867 | 
             
                #
         | 
| 580 868 | 
             
                #   resp = client.create_load_balancer_listeners({
         | 
| @@ -622,6 +910,55 @@ module Aws::ElasticLoadBalancing | |
| 622 910 | 
             
                #
         | 
| 623 911 | 
             
                # @return [Struct] Returns an empty {Seahorse::Client::Response response}.
         | 
| 624 912 | 
             
                #
         | 
| 913 | 
            +
                #
         | 
| 914 | 
            +
                # @example Example: To create a policy that enables Proxy Protocol on a load balancer
         | 
| 915 | 
            +
                #
         | 
| 916 | 
            +
                #   # This example creates a policy that enables Proxy Protocol on the specified load balancer.
         | 
| 917 | 
            +
                #
         | 
| 918 | 
            +
                #   resp = client.create_load_balancer_policy({
         | 
| 919 | 
            +
                #     load_balancer_name: "my-load-balancer", 
         | 
| 920 | 
            +
                #     policy_attributes: [
         | 
| 921 | 
            +
                #       {
         | 
| 922 | 
            +
                #         attribute_name: "ProxyProtocol", 
         | 
| 923 | 
            +
                #         attribute_value: "true", 
         | 
| 924 | 
            +
                #       }, 
         | 
| 925 | 
            +
                #     ], 
         | 
| 926 | 
            +
                #     policy_name: "my-ProxyProtocol-policy", 
         | 
| 927 | 
            +
                #     policy_type_name: "ProxyProtocolPolicyType", 
         | 
| 928 | 
            +
                #   })
         | 
| 929 | 
            +
                #
         | 
| 930 | 
            +
                # @example Example: To create a public key policy
         | 
| 931 | 
            +
                #
         | 
| 932 | 
            +
                #   # This example creates a public key policy.
         | 
| 933 | 
            +
                #
         | 
| 934 | 
            +
                #   resp = client.create_load_balancer_policy({
         | 
| 935 | 
            +
                #     load_balancer_name: "my-load-balancer", 
         | 
| 936 | 
            +
                #     policy_attributes: [
         | 
| 937 | 
            +
                #       {
         | 
| 938 | 
            +
                #         attribute_name: "PublicKey", 
         | 
| 939 | 
            +
                #         attribute_value: "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAwAYUjnfyEyXr1pxjhFWBpMlggUcqoi3kl+dS74kj//c6x7ROtusUaeQCTgIUkayttRDWchuqo1pHC1u+n5xxXnBBe2ejbb2WRsKIQ5rXEeixsjFpFsojpSQKkzhVGI6mJVZBJDVKSHmswnwLBdofLhzvllpovBPTHe+o4haAWvDBALJU0pkSI1FecPHcs2hwxf14zHoXy1e2k36A64nXW43wtfx5qcVSIxtCEOjnYRg7RPvybaGfQ+v6Iaxb/+7J5kEvZhTFQId+bSiJImF1FSUT1W1xwzBZPUbcUkkXDj45vC2s3Z8E+Lk7a3uZhvsQHLZnrfuWjBWGWvZ/MhZYgEXAMPLE", 
         | 
| 940 | 
            +
                #       }, 
         | 
| 941 | 
            +
                #     ], 
         | 
| 942 | 
            +
                #     policy_name: "my-PublicKey-policy", 
         | 
| 943 | 
            +
                #     policy_type_name: "PublicKeyPolicyType", 
         | 
| 944 | 
            +
                #   })
         | 
| 945 | 
            +
                #
         | 
| 946 | 
            +
                # @example Example: To create a backend server authentication policy
         | 
| 947 | 
            +
                #
         | 
| 948 | 
            +
                #   # This example creates a backend server authentication policy that enables authentication on your backend instance using a public key policy.
         | 
| 949 | 
            +
                #
         | 
| 950 | 
            +
                #   resp = client.create_load_balancer_policy({
         | 
| 951 | 
            +
                #     load_balancer_name: "my-load-balancer", 
         | 
| 952 | 
            +
                #     policy_attributes: [
         | 
| 953 | 
            +
                #       {
         | 
| 954 | 
            +
                #         attribute_name: "PublicKeyPolicyName", 
         | 
| 955 | 
            +
                #         attribute_value: "my-PublicKey-policy", 
         | 
| 956 | 
            +
                #       }, 
         | 
| 957 | 
            +
                #     ], 
         | 
| 958 | 
            +
                #     policy_name: "my-authentication-policy", 
         | 
| 959 | 
            +
                #     policy_type_name: "BackendServerAuthenticationPolicyType", 
         | 
| 960 | 
            +
                #   })
         | 
| 961 | 
            +
                #
         | 
| 625 962 | 
             
                # @example Request syntax with placeholder values
         | 
| 626 963 | 
             
                #
         | 
| 627 964 | 
             
                #   resp = client.create_load_balancer_policy({
         | 
| @@ -661,6 +998,15 @@ module Aws::ElasticLoadBalancing | |
| 661 998 | 
             
                #
         | 
| 662 999 | 
             
                # @return [Struct] Returns an empty {Seahorse::Client::Response response}.
         | 
| 663 1000 | 
             
                #
         | 
| 1001 | 
            +
                #
         | 
| 1002 | 
            +
                # @example Example: To delete a load balancer
         | 
| 1003 | 
            +
                #
         | 
| 1004 | 
            +
                #   # This example deletes the specified load balancer.
         | 
| 1005 | 
            +
                #
         | 
| 1006 | 
            +
                #   resp = client.delete_load_balancer({
         | 
| 1007 | 
            +
                #     load_balancer_name: "my-load-balancer", 
         | 
| 1008 | 
            +
                #   })
         | 
| 1009 | 
            +
                #
         | 
| 664 1010 | 
             
                # @example Request syntax with placeholder values
         | 
| 665 1011 | 
             
                #
         | 
| 666 1012 | 
             
                #   resp = client.delete_load_balancer({
         | 
| @@ -686,6 +1032,18 @@ module Aws::ElasticLoadBalancing | |
| 686 1032 | 
             
                #
         | 
| 687 1033 | 
             
                # @return [Struct] Returns an empty {Seahorse::Client::Response response}.
         | 
| 688 1034 | 
             
                #
         | 
| 1035 | 
            +
                #
         | 
| 1036 | 
            +
                # @example Example: To delete a listener from your load balancer
         | 
| 1037 | 
            +
                #
         | 
| 1038 | 
            +
                #   # This example deletes the listener for the specified port from the specified load balancer.
         | 
| 1039 | 
            +
                #
         | 
| 1040 | 
            +
                #   resp = client.delete_load_balancer_listeners({
         | 
| 1041 | 
            +
                #     load_balancer_name: "my-load-balancer", 
         | 
| 1042 | 
            +
                #     load_balancer_ports: [
         | 
| 1043 | 
            +
                #       80, 
         | 
| 1044 | 
            +
                #     ], 
         | 
| 1045 | 
            +
                #   })
         | 
| 1046 | 
            +
                #
         | 
| 689 1047 | 
             
                # @example Request syntax with placeholder values
         | 
| 690 1048 | 
             
                #
         | 
| 691 1049 | 
             
                #   resp = client.delete_load_balancer_listeners({
         | 
| @@ -713,6 +1071,16 @@ module Aws::ElasticLoadBalancing | |
| 713 1071 | 
             
                #
         | 
| 714 1072 | 
             
                # @return [Struct] Returns an empty {Seahorse::Client::Response response}.
         | 
| 715 1073 | 
             
                #
         | 
| 1074 | 
            +
                #
         | 
| 1075 | 
            +
                # @example Example: To delete a policy from your load balancer
         | 
| 1076 | 
            +
                #
         | 
| 1077 | 
            +
                #   # This example deletes the specified policy from the specified load balancer. The policy must not be enabled on any listener.
         | 
| 1078 | 
            +
                #
         | 
| 1079 | 
            +
                #   resp = client.delete_load_balancer_policy({
         | 
| 1080 | 
            +
                #     load_balancer_name: "my-load-balancer", 
         | 
| 1081 | 
            +
                #     policy_name: "my-duration-cookie-policy", 
         | 
| 1082 | 
            +
                #   })
         | 
| 1083 | 
            +
                #
         | 
| 716 1084 | 
             
                # @example Request syntax with placeholder values
         | 
| 717 1085 | 
             
                #
         | 
| 718 1086 | 
             
                #   resp = client.delete_load_balancer_policy({
         | 
| @@ -753,6 +1121,32 @@ module Aws::ElasticLoadBalancing | |
| 753 1121 | 
             
                #
         | 
| 754 1122 | 
             
                #   * {Types::DeregisterEndPointsOutput#instances #instances} => Array<Types::Instance>
         | 
| 755 1123 | 
             
                #
         | 
| 1124 | 
            +
                #
         | 
| 1125 | 
            +
                # @example Example: To deregister instances from a load balancer
         | 
| 1126 | 
            +
                #
         | 
| 1127 | 
            +
                #   # This example deregisters the specified instance from the specified load balancer.
         | 
| 1128 | 
            +
                #
         | 
| 1129 | 
            +
                #   resp = client.deregister_instances_from_load_balancer({
         | 
| 1130 | 
            +
                #     instances: [
         | 
| 1131 | 
            +
                #       {
         | 
| 1132 | 
            +
                #         instance_id: "i-d6f6fae3", 
         | 
| 1133 | 
            +
                #       }, 
         | 
| 1134 | 
            +
                #     ], 
         | 
| 1135 | 
            +
                #     load_balancer_name: "my-load-balancer", 
         | 
| 1136 | 
            +
                #   })
         | 
| 1137 | 
            +
                #
         | 
| 1138 | 
            +
                #   resp.to_h outputs the following:
         | 
| 1139 | 
            +
                #   {
         | 
| 1140 | 
            +
                #     instances: [
         | 
| 1141 | 
            +
                #       {
         | 
| 1142 | 
            +
                #         instance_id: "i-207d9717", 
         | 
| 1143 | 
            +
                #       }, 
         | 
| 1144 | 
            +
                #       {
         | 
| 1145 | 
            +
                #         instance_id: "i-afefb49b", 
         | 
| 1146 | 
            +
                #       }, 
         | 
| 1147 | 
            +
                #     ], 
         | 
| 1148 | 
            +
                #   }
         | 
| 1149 | 
            +
                #
         | 
| 756 1150 | 
             
                # @example Request syntax with placeholder values
         | 
| 757 1151 | 
             
                #
         | 
| 758 1152 | 
             
                #   resp = client.deregister_instances_from_load_balancer({
         | 
| @@ -840,6 +1234,33 @@ module Aws::ElasticLoadBalancing | |
| 840 1234 | 
             
                #
         | 
| 841 1235 | 
             
                #   * {Types::DescribeEndPointStateOutput#instance_states #instance_states} => Array<Types::InstanceState>
         | 
| 842 1236 | 
             
                #
         | 
| 1237 | 
            +
                #
         | 
| 1238 | 
            +
                # @example Example: To describe the health of the instances for a load balancer
         | 
| 1239 | 
            +
                #
         | 
| 1240 | 
            +
                #   # This example describes the health of the instances for the specified load balancer.
         | 
| 1241 | 
            +
                #
         | 
| 1242 | 
            +
                #   resp = client.describe_instance_health({
         | 
| 1243 | 
            +
                #     load_balancer_name: "my-load-balancer", 
         | 
| 1244 | 
            +
                #   })
         | 
| 1245 | 
            +
                #
         | 
| 1246 | 
            +
                #   resp.to_h outputs the following:
         | 
| 1247 | 
            +
                #   {
         | 
| 1248 | 
            +
                #     instance_states: [
         | 
| 1249 | 
            +
                #       {
         | 
| 1250 | 
            +
                #         description: "N/A", 
         | 
| 1251 | 
            +
                #         instance_id: "i-207d9717", 
         | 
| 1252 | 
            +
                #         reason_code: "N/A", 
         | 
| 1253 | 
            +
                #         state: "InService", 
         | 
| 1254 | 
            +
                #       }, 
         | 
| 1255 | 
            +
                #       {
         | 
| 1256 | 
            +
                #         description: "N/A", 
         | 
| 1257 | 
            +
                #         instance_id: "i-afefb49b", 
         | 
| 1258 | 
            +
                #         reason_code: "N/A", 
         | 
| 1259 | 
            +
                #         state: "InService", 
         | 
| 1260 | 
            +
                #       }, 
         | 
| 1261 | 
            +
                #     ], 
         | 
| 1262 | 
            +
                #   }
         | 
| 1263 | 
            +
                #
         | 
| 843 1264 | 
             
                # @example Request syntax with placeholder values
         | 
| 844 1265 | 
             
                #
         | 
| 845 1266 | 
             
                #   resp = client.describe_instance_health({
         | 
| @@ -877,6 +1298,34 @@ module Aws::ElasticLoadBalancing | |
| 877 1298 | 
             
                #
         | 
| 878 1299 | 
             
                #   * {Types::DescribeLoadBalancerAttributesOutput#load_balancer_attributes #load_balancer_attributes} => Types::LoadBalancerAttributes
         | 
| 879 1300 | 
             
                #
         | 
| 1301 | 
            +
                #
         | 
| 1302 | 
            +
                # @example Example: To describe the attributes of a load balancer
         | 
| 1303 | 
            +
                #
         | 
| 1304 | 
            +
                #   # This example describes the attributes of the specified load balancer.
         | 
| 1305 | 
            +
                #
         | 
| 1306 | 
            +
                #   resp = client.describe_load_balancer_attributes({
         | 
| 1307 | 
            +
                #     load_balancer_name: "my-load-balancer", 
         | 
| 1308 | 
            +
                #   })
         | 
| 1309 | 
            +
                #
         | 
| 1310 | 
            +
                #   resp.to_h outputs the following:
         | 
| 1311 | 
            +
                #   {
         | 
| 1312 | 
            +
                #     load_balancer_attributes: {
         | 
| 1313 | 
            +
                #       access_log: {
         | 
| 1314 | 
            +
                #         enabled: false, 
         | 
| 1315 | 
            +
                #       }, 
         | 
| 1316 | 
            +
                #       connection_draining: {
         | 
| 1317 | 
            +
                #         enabled: false, 
         | 
| 1318 | 
            +
                #         timeout: 300, 
         | 
| 1319 | 
            +
                #       }, 
         | 
| 1320 | 
            +
                #       connection_settings: {
         | 
| 1321 | 
            +
                #         idle_timeout: 60, 
         | 
| 1322 | 
            +
                #       }, 
         | 
| 1323 | 
            +
                #       cross_zone_load_balancing: {
         | 
| 1324 | 
            +
                #         enabled: false, 
         | 
| 1325 | 
            +
                #       }, 
         | 
| 1326 | 
            +
                #     }, 
         | 
| 1327 | 
            +
                #   }
         | 
| 1328 | 
            +
                #
         | 
| 880 1329 | 
             
                # @example Request syntax with placeholder values
         | 
| 881 1330 | 
             
                #
         | 
| 882 1331 | 
             
                #   resp = client.describe_load_balancer_attributes({
         | 
| @@ -926,6 +1375,34 @@ module Aws::ElasticLoadBalancing | |
| 926 1375 | 
             
                #
         | 
| 927 1376 | 
             
                #   * {Types::DescribeLoadBalancerPoliciesOutput#policy_descriptions #policy_descriptions} => Array<Types::PolicyDescription>
         | 
| 928 1377 | 
             
                #
         | 
| 1378 | 
            +
                #
         | 
| 1379 | 
            +
                # @example Example: To describe a policy associated with a load balancer
         | 
| 1380 | 
            +
                #
         | 
| 1381 | 
            +
                #   # This example describes the specified policy associated with the specified load balancer.
         | 
| 1382 | 
            +
                #
         | 
| 1383 | 
            +
                #   resp = client.describe_load_balancer_policies({
         | 
| 1384 | 
            +
                #     load_balancer_name: "my-load-balancer", 
         | 
| 1385 | 
            +
                #     policy_names: [
         | 
| 1386 | 
            +
                #       "my-authentication-policy", 
         | 
| 1387 | 
            +
                #     ], 
         | 
| 1388 | 
            +
                #   })
         | 
| 1389 | 
            +
                #
         | 
| 1390 | 
            +
                #   resp.to_h outputs the following:
         | 
| 1391 | 
            +
                #   {
         | 
| 1392 | 
            +
                #     policy_descriptions: [
         | 
| 1393 | 
            +
                #       {
         | 
| 1394 | 
            +
                #         policy_attribute_descriptions: [
         | 
| 1395 | 
            +
                #           {
         | 
| 1396 | 
            +
                #             attribute_name: "PublicKeyPolicyName", 
         | 
| 1397 | 
            +
                #             attribute_value: "my-PublicKey-policy", 
         | 
| 1398 | 
            +
                #           }, 
         | 
| 1399 | 
            +
                #         ], 
         | 
| 1400 | 
            +
                #         policy_name: "my-authentication-policy", 
         | 
| 1401 | 
            +
                #         policy_type_name: "BackendServerAuthenticationPolicyType", 
         | 
| 1402 | 
            +
                #       }, 
         | 
| 1403 | 
            +
                #     ], 
         | 
| 1404 | 
            +
                #   }
         | 
| 1405 | 
            +
                #
         | 
| 929 1406 | 
             
                # @example Request syntax with placeholder values
         | 
| 930 1407 | 
             
                #
         | 
| 931 1408 | 
             
                #   resp = client.describe_load_balancer_policies({
         | 
| @@ -972,6 +1449,34 @@ module Aws::ElasticLoadBalancing | |
| 972 1449 | 
             
                #
         | 
| 973 1450 | 
             
                #   * {Types::DescribeLoadBalancerPolicyTypesOutput#policy_type_descriptions #policy_type_descriptions} => Array<Types::PolicyTypeDescription>
         | 
| 974 1451 | 
             
                #
         | 
| 1452 | 
            +
                #
         | 
| 1453 | 
            +
                # @example Example: To describe a load balancer policy type defined by Elastic Load Balancing
         | 
| 1454 | 
            +
                #
         | 
| 1455 | 
            +
                #   # This example describes the specified load balancer policy type.
         | 
| 1456 | 
            +
                #
         | 
| 1457 | 
            +
                #   resp = client.describe_load_balancer_policy_types({
         | 
| 1458 | 
            +
                #     policy_type_names: [
         | 
| 1459 | 
            +
                #       "ProxyProtocolPolicyType", 
         | 
| 1460 | 
            +
                #     ], 
         | 
| 1461 | 
            +
                #   })
         | 
| 1462 | 
            +
                #
         | 
| 1463 | 
            +
                #   resp.to_h outputs the following:
         | 
| 1464 | 
            +
                #   {
         | 
| 1465 | 
            +
                #     policy_type_descriptions: [
         | 
| 1466 | 
            +
                #       {
         | 
| 1467 | 
            +
                #         description: "Policy that controls whether to include the IP address and port of the originating request for TCP messages. This policy operates on TCP listeners only.", 
         | 
| 1468 | 
            +
                #         policy_attribute_type_descriptions: [
         | 
| 1469 | 
            +
                #           {
         | 
| 1470 | 
            +
                #             attribute_name: "ProxyProtocol", 
         | 
| 1471 | 
            +
                #             attribute_type: "Boolean", 
         | 
| 1472 | 
            +
                #             cardinality: "ONE", 
         | 
| 1473 | 
            +
                #           }, 
         | 
| 1474 | 
            +
                #         ], 
         | 
| 1475 | 
            +
                #         policy_type_name: "ProxyProtocolPolicyType", 
         | 
| 1476 | 
            +
                #       }, 
         | 
| 1477 | 
            +
                #     ], 
         | 
| 1478 | 
            +
                #   }
         | 
| 1479 | 
            +
                #
         | 
| 975 1480 | 
             
                # @example Request syntax with placeholder values
         | 
| 976 1481 | 
             
                #
         | 
| 977 1482 | 
             
                #   resp = client.describe_load_balancer_policy_types({
         | 
| @@ -1018,6 +1523,109 @@ module Aws::ElasticLoadBalancing | |
| 1018 1523 | 
             
                #   * {Types::DescribeAccessPointsOutput#load_balancer_descriptions #load_balancer_descriptions} => Array<Types::LoadBalancerDescription>
         | 
| 1019 1524 | 
             
                #   * {Types::DescribeAccessPointsOutput#next_marker #next_marker} => String
         | 
| 1020 1525 | 
             
                #
         | 
| 1526 | 
            +
                #
         | 
| 1527 | 
            +
                # @example Example: To describe one of your load balancers
         | 
| 1528 | 
            +
                #
         | 
| 1529 | 
            +
                #   # This example describes the specified load balancer.
         | 
| 1530 | 
            +
                #
         | 
| 1531 | 
            +
                #   resp = client.describe_load_balancers({
         | 
| 1532 | 
            +
                #     load_balancer_names: [
         | 
| 1533 | 
            +
                #       "my-load-balancer", 
         | 
| 1534 | 
            +
                #     ], 
         | 
| 1535 | 
            +
                #   })
         | 
| 1536 | 
            +
                #
         | 
| 1537 | 
            +
                #   resp.to_h outputs the following:
         | 
| 1538 | 
            +
                #   {
         | 
| 1539 | 
            +
                #     load_balancer_descriptions: [
         | 
| 1540 | 
            +
                #       {
         | 
| 1541 | 
            +
                #         availability_zones: [
         | 
| 1542 | 
            +
                #           "us-west-2a", 
         | 
| 1543 | 
            +
                #         ], 
         | 
| 1544 | 
            +
                #         backend_server_descriptions: [
         | 
| 1545 | 
            +
                #           {
         | 
| 1546 | 
            +
                #             instance_port: 80, 
         | 
| 1547 | 
            +
                #             policy_names: [
         | 
| 1548 | 
            +
                #               "my-ProxyProtocol-policy", 
         | 
| 1549 | 
            +
                #             ], 
         | 
| 1550 | 
            +
                #           }, 
         | 
| 1551 | 
            +
                #         ], 
         | 
| 1552 | 
            +
                #         canonical_hosted_zone_name: "my-load-balancer-1234567890.us-west-2.elb.amazonaws.com", 
         | 
| 1553 | 
            +
                #         canonical_hosted_zone_name_id: "Z3DZXE0EXAMPLE", 
         | 
| 1554 | 
            +
                #         created_time: Time.parse("2015-03-19T03:24:02.650Z"), 
         | 
| 1555 | 
            +
                #         dns_name: "my-load-balancer-1234567890.us-west-2.elb.amazonaws.com", 
         | 
| 1556 | 
            +
                #         health_check: {
         | 
| 1557 | 
            +
                #           healthy_threshold: 2, 
         | 
| 1558 | 
            +
                #           interval: 30, 
         | 
| 1559 | 
            +
                #           target: "HTTP:80/png", 
         | 
| 1560 | 
            +
                #           timeout: 3, 
         | 
| 1561 | 
            +
                #           unhealthy_threshold: 2, 
         | 
| 1562 | 
            +
                #         }, 
         | 
| 1563 | 
            +
                #         instances: [
         | 
| 1564 | 
            +
                #           {
         | 
| 1565 | 
            +
                #             instance_id: "i-207d9717", 
         | 
| 1566 | 
            +
                #           }, 
         | 
| 1567 | 
            +
                #           {
         | 
| 1568 | 
            +
                #             instance_id: "i-afefb49b", 
         | 
| 1569 | 
            +
                #           }, 
         | 
| 1570 | 
            +
                #         ], 
         | 
| 1571 | 
            +
                #         listener_descriptions: [
         | 
| 1572 | 
            +
                #           {
         | 
| 1573 | 
            +
                #             listener: {
         | 
| 1574 | 
            +
                #               instance_port: 80, 
         | 
| 1575 | 
            +
                #               instance_protocol: "HTTP", 
         | 
| 1576 | 
            +
                #               load_balancer_port: 80, 
         | 
| 1577 | 
            +
                #               protocol: "HTTP", 
         | 
| 1578 | 
            +
                #             }, 
         | 
| 1579 | 
            +
                #             policy_names: [
         | 
| 1580 | 
            +
                #             ], 
         | 
| 1581 | 
            +
                #           }, 
         | 
| 1582 | 
            +
                #           {
         | 
| 1583 | 
            +
                #             listener: {
         | 
| 1584 | 
            +
                #               instance_port: 443, 
         | 
| 1585 | 
            +
                #               instance_protocol: "HTTPS", 
         | 
| 1586 | 
            +
                #               load_balancer_port: 443, 
         | 
| 1587 | 
            +
                #               protocol: "HTTPS", 
         | 
| 1588 | 
            +
                #               ssl_certificate_id: "arn:aws:iam::123456789012:server-certificate/my-server-cert", 
         | 
| 1589 | 
            +
                #             }, 
         | 
| 1590 | 
            +
                #             policy_names: [
         | 
| 1591 | 
            +
                #               "ELBSecurityPolicy-2015-03", 
         | 
| 1592 | 
            +
                #             ], 
         | 
| 1593 | 
            +
                #           }, 
         | 
| 1594 | 
            +
                #         ], 
         | 
| 1595 | 
            +
                #         load_balancer_name: "my-load-balancer", 
         | 
| 1596 | 
            +
                #         policies: {
         | 
| 1597 | 
            +
                #           app_cookie_stickiness_policies: [
         | 
| 1598 | 
            +
                #           ], 
         | 
| 1599 | 
            +
                #           lb_cookie_stickiness_policies: [
         | 
| 1600 | 
            +
                #             {
         | 
| 1601 | 
            +
                #               cookie_expiration_period: 60, 
         | 
| 1602 | 
            +
                #               policy_name: "my-duration-cookie-policy", 
         | 
| 1603 | 
            +
                #             }, 
         | 
| 1604 | 
            +
                #           ], 
         | 
| 1605 | 
            +
                #           other_policies: [
         | 
| 1606 | 
            +
                #             "my-PublicKey-policy", 
         | 
| 1607 | 
            +
                #             "my-authentication-policy", 
         | 
| 1608 | 
            +
                #             "my-SSLNegotiation-policy", 
         | 
| 1609 | 
            +
                #             "my-ProxyProtocol-policy", 
         | 
| 1610 | 
            +
                #             "ELBSecurityPolicy-2015-03", 
         | 
| 1611 | 
            +
                #           ], 
         | 
| 1612 | 
            +
                #         }, 
         | 
| 1613 | 
            +
                #         scheme: "internet-facing", 
         | 
| 1614 | 
            +
                #         security_groups: [
         | 
| 1615 | 
            +
                #           "sg-a61988c3", 
         | 
| 1616 | 
            +
                #         ], 
         | 
| 1617 | 
            +
                #         source_security_group: {
         | 
| 1618 | 
            +
                #           group_name: "my-elb-sg", 
         | 
| 1619 | 
            +
                #           owner_alias: "123456789012", 
         | 
| 1620 | 
            +
                #         }, 
         | 
| 1621 | 
            +
                #         subnets: [
         | 
| 1622 | 
            +
                #           "subnet-15aaab61", 
         | 
| 1623 | 
            +
                #         ], 
         | 
| 1624 | 
            +
                #         vpc_id: "vpc-a01106c2", 
         | 
| 1625 | 
            +
                #       }, 
         | 
| 1626 | 
            +
                #     ], 
         | 
| 1627 | 
            +
                #   }
         | 
| 1628 | 
            +
                #
         | 
| 1021 1629 | 
             
                # @example Request syntax with placeholder values
         | 
| 1022 1630 | 
             
                #
         | 
| 1023 1631 | 
             
                #   resp = client.describe_load_balancers({
         | 
| @@ -1091,6 +1699,36 @@ module Aws::ElasticLoadBalancing | |
| 1091 1699 | 
             
                #
         | 
| 1092 1700 | 
             
                #   * {Types::DescribeTagsOutput#tag_descriptions #tag_descriptions} => Array<Types::TagDescription>
         | 
| 1093 1701 | 
             
                #
         | 
| 1702 | 
            +
                #
         | 
| 1703 | 
            +
                # @example Example: To describe the tags for a load balancer
         | 
| 1704 | 
            +
                #
         | 
| 1705 | 
            +
                #   # This example describes the tags for the specified load balancer.
         | 
| 1706 | 
            +
                #
         | 
| 1707 | 
            +
                #   resp = client.describe_tags({
         | 
| 1708 | 
            +
                #     load_balancer_names: [
         | 
| 1709 | 
            +
                #       "my-load-balancer", 
         | 
| 1710 | 
            +
                #     ], 
         | 
| 1711 | 
            +
                #   })
         | 
| 1712 | 
            +
                #
         | 
| 1713 | 
            +
                #   resp.to_h outputs the following:
         | 
| 1714 | 
            +
                #   {
         | 
| 1715 | 
            +
                #     tag_descriptions: [
         | 
| 1716 | 
            +
                #       {
         | 
| 1717 | 
            +
                #         load_balancer_name: "my-load-balancer", 
         | 
| 1718 | 
            +
                #         tags: [
         | 
| 1719 | 
            +
                #           {
         | 
| 1720 | 
            +
                #             key: "project", 
         | 
| 1721 | 
            +
                #             value: "lima", 
         | 
| 1722 | 
            +
                #           }, 
         | 
| 1723 | 
            +
                #           {
         | 
| 1724 | 
            +
                #             key: "department", 
         | 
| 1725 | 
            +
                #             value: "digital-media", 
         | 
| 1726 | 
            +
                #           }, 
         | 
| 1727 | 
            +
                #         ], 
         | 
| 1728 | 
            +
                #       }, 
         | 
| 1729 | 
            +
                #     ], 
         | 
| 1730 | 
            +
                #   }
         | 
| 1731 | 
            +
                #
         | 
| 1094 1732 | 
             
                # @example Request syntax with placeholder values
         | 
| 1095 1733 | 
             
                #
         | 
| 1096 1734 | 
             
                #   resp = client.describe_tags({
         | 
| @@ -1132,6 +1770,25 @@ module Aws::ElasticLoadBalancing | |
| 1132 1770 | 
             
                #
         | 
| 1133 1771 | 
             
                #   * {Types::DetachLoadBalancerFromSubnetsOutput#subnets #subnets} => Array<String>
         | 
| 1134 1772 | 
             
                #
         | 
| 1773 | 
            +
                #
         | 
| 1774 | 
            +
                # @example Example: To detach a load balancer from a subnet
         | 
| 1775 | 
            +
                #
         | 
| 1776 | 
            +
                #   # This example detaches the specified load balancer from the specified subnet.
         | 
| 1777 | 
            +
                #
         | 
| 1778 | 
            +
                #   resp = client.detach_load_balancer_from_subnets({
         | 
| 1779 | 
            +
                #     load_balancer_name: "my-load-balancer", 
         | 
| 1780 | 
            +
                #     subnets: [
         | 
| 1781 | 
            +
                #       "subnet-0ecac448", 
         | 
| 1782 | 
            +
                #     ], 
         | 
| 1783 | 
            +
                #   })
         | 
| 1784 | 
            +
                #
         | 
| 1785 | 
            +
                #   resp.to_h outputs the following:
         | 
| 1786 | 
            +
                #   {
         | 
| 1787 | 
            +
                #     subnets: [
         | 
| 1788 | 
            +
                #       "subnet-15aaab61", 
         | 
| 1789 | 
            +
                #     ], 
         | 
| 1790 | 
            +
                #   }
         | 
| 1791 | 
            +
                #
         | 
| 1135 1792 | 
             
                # @example Request syntax with placeholder values
         | 
| 1136 1793 | 
             
                #
         | 
| 1137 1794 | 
             
                #   resp = client.detach_load_balancer_from_subnets({
         | 
| @@ -1180,6 +1837,25 @@ module Aws::ElasticLoadBalancing | |
| 1180 1837 | 
             
                #
         | 
| 1181 1838 | 
             
                #   * {Types::RemoveAvailabilityZonesOutput#availability_zones #availability_zones} => Array<String>
         | 
| 1182 1839 | 
             
                #
         | 
| 1840 | 
            +
                #
         | 
| 1841 | 
            +
                # @example Example: To disable an Availability Zone for a load balancer
         | 
| 1842 | 
            +
                #
         | 
| 1843 | 
            +
                #   # This example removes the specified Availability Zone from the set of Availability Zones for the specified load balancer.
         | 
| 1844 | 
            +
                #
         | 
| 1845 | 
            +
                #   resp = client.disable_availability_zones_for_load_balancer({
         | 
| 1846 | 
            +
                #     availability_zones: [
         | 
| 1847 | 
            +
                #       "us-west-2a", 
         | 
| 1848 | 
            +
                #     ], 
         | 
| 1849 | 
            +
                #     load_balancer_name: "my-load-balancer", 
         | 
| 1850 | 
            +
                #   })
         | 
| 1851 | 
            +
                #
         | 
| 1852 | 
            +
                #   resp.to_h outputs the following:
         | 
| 1853 | 
            +
                #   {
         | 
| 1854 | 
            +
                #     availability_zones: [
         | 
| 1855 | 
            +
                #       "us-west-2b", 
         | 
| 1856 | 
            +
                #     ], 
         | 
| 1857 | 
            +
                #   }
         | 
| 1858 | 
            +
                #
         | 
| 1183 1859 | 
             
                # @example Request syntax with placeholder values
         | 
| 1184 1860 | 
             
                #
         | 
| 1185 1861 | 
             
                #   resp = client.disable_availability_zones_for_load_balancer({
         | 
| @@ -1225,6 +1901,26 @@ module Aws::ElasticLoadBalancing | |
| 1225 1901 | 
             
                #
         | 
| 1226 1902 | 
             
                #   * {Types::AddAvailabilityZonesOutput#availability_zones #availability_zones} => Array<String>
         | 
| 1227 1903 | 
             
                #
         | 
| 1904 | 
            +
                #
         | 
| 1905 | 
            +
                # @example Example: To enable an Availability Zone for a load balancer
         | 
| 1906 | 
            +
                #
         | 
| 1907 | 
            +
                #   # This example adds the specified Availability Zone to the specified load balancer.
         | 
| 1908 | 
            +
                #
         | 
| 1909 | 
            +
                #   resp = client.enable_availability_zones_for_load_balancer({
         | 
| 1910 | 
            +
                #     availability_zones: [
         | 
| 1911 | 
            +
                #       "us-west-2b", 
         | 
| 1912 | 
            +
                #     ], 
         | 
| 1913 | 
            +
                #     load_balancer_name: "my-load-balancer", 
         | 
| 1914 | 
            +
                #   })
         | 
| 1915 | 
            +
                #
         | 
| 1916 | 
            +
                #   resp.to_h outputs the following:
         | 
| 1917 | 
            +
                #   {
         | 
| 1918 | 
            +
                #     availability_zones: [
         | 
| 1919 | 
            +
                #       "us-west-2a", 
         | 
| 1920 | 
            +
                #       "us-west-2b", 
         | 
| 1921 | 
            +
                #     ], 
         | 
| 1922 | 
            +
                #   }
         | 
| 1923 | 
            +
                #
         | 
| 1228 1924 | 
             
                # @example Request syntax with placeholder values
         | 
| 1229 1925 | 
             
                #
         | 
| 1230 1926 | 
             
                #   resp = client.enable_availability_zones_for_load_balancer({
         | 
| @@ -1283,6 +1979,55 @@ module Aws::ElasticLoadBalancing | |
| 1283 1979 | 
             
                #   * {Types::ModifyLoadBalancerAttributesOutput#load_balancer_name #load_balancer_name} => String
         | 
| 1284 1980 | 
             
                #   * {Types::ModifyLoadBalancerAttributesOutput#load_balancer_attributes #load_balancer_attributes} => Types::LoadBalancerAttributes
         | 
| 1285 1981 | 
             
                #
         | 
| 1982 | 
            +
                #
         | 
| 1983 | 
            +
                # @example Example: To enable cross-zone load balancing
         | 
| 1984 | 
            +
                #
         | 
| 1985 | 
            +
                #   # This example enables cross-zone load balancing for the specified load balancer.
         | 
| 1986 | 
            +
                #
         | 
| 1987 | 
            +
                #   resp = client.modify_load_balancer_attributes({
         | 
| 1988 | 
            +
                #     load_balancer_attributes: {
         | 
| 1989 | 
            +
                #       cross_zone_load_balancing: {
         | 
| 1990 | 
            +
                #         enabled: true, 
         | 
| 1991 | 
            +
                #       }, 
         | 
| 1992 | 
            +
                #     }, 
         | 
| 1993 | 
            +
                #     load_balancer_name: "my-load-balancer", 
         | 
| 1994 | 
            +
                #   })
         | 
| 1995 | 
            +
                #
         | 
| 1996 | 
            +
                #   resp.to_h outputs the following:
         | 
| 1997 | 
            +
                #   {
         | 
| 1998 | 
            +
                #     load_balancer_attributes: {
         | 
| 1999 | 
            +
                #       cross_zone_load_balancing: {
         | 
| 2000 | 
            +
                #         enabled: true, 
         | 
| 2001 | 
            +
                #       }, 
         | 
| 2002 | 
            +
                #     }, 
         | 
| 2003 | 
            +
                #     load_balancer_name: "my-load-balancer", 
         | 
| 2004 | 
            +
                #   }
         | 
| 2005 | 
            +
                #
         | 
| 2006 | 
            +
                # @example Example: To enable connection draining
         | 
| 2007 | 
            +
                #
         | 
| 2008 | 
            +
                #   # This example enables connection draining for the specified load balancer.
         | 
| 2009 | 
            +
                #
         | 
| 2010 | 
            +
                #   resp = client.modify_load_balancer_attributes({
         | 
| 2011 | 
            +
                #     load_balancer_attributes: {
         | 
| 2012 | 
            +
                #       connection_draining: {
         | 
| 2013 | 
            +
                #         enabled: true, 
         | 
| 2014 | 
            +
                #         timeout: 300, 
         | 
| 2015 | 
            +
                #       }, 
         | 
| 2016 | 
            +
                #     }, 
         | 
| 2017 | 
            +
                #     load_balancer_name: "my-load-balancer", 
         | 
| 2018 | 
            +
                #   })
         | 
| 2019 | 
            +
                #
         | 
| 2020 | 
            +
                #   resp.to_h outputs the following:
         | 
| 2021 | 
            +
                #   {
         | 
| 2022 | 
            +
                #     load_balancer_attributes: {
         | 
| 2023 | 
            +
                #       connection_draining: {
         | 
| 2024 | 
            +
                #         enabled: true, 
         | 
| 2025 | 
            +
                #         timeout: 300, 
         | 
| 2026 | 
            +
                #       }, 
         | 
| 2027 | 
            +
                #     }, 
         | 
| 2028 | 
            +
                #     load_balancer_name: "my-load-balancer", 
         | 
| 2029 | 
            +
                #   }
         | 
| 2030 | 
            +
                #
         | 
| 1286 2031 | 
             
                # @example Request syntax with placeholder values
         | 
| 1287 2032 | 
             
                #
         | 
| 1288 2033 | 
             
                #   resp = client.modify_load_balancer_attributes({
         | 
| @@ -1377,6 +2122,35 @@ module Aws::ElasticLoadBalancing | |
| 1377 2122 | 
             
                #
         | 
| 1378 2123 | 
             
                #   * {Types::RegisterEndPointsOutput#instances #instances} => Array<Types::Instance>
         | 
| 1379 2124 | 
             
                #
         | 
| 2125 | 
            +
                #
         | 
| 2126 | 
            +
                # @example Example: To register instances with a load balancer
         | 
| 2127 | 
            +
                #
         | 
| 2128 | 
            +
                #   # This example registers the specified instance with the specified load balancer.
         | 
| 2129 | 
            +
                #
         | 
| 2130 | 
            +
                #   resp = client.register_instances_with_load_balancer({
         | 
| 2131 | 
            +
                #     instances: [
         | 
| 2132 | 
            +
                #       {
         | 
| 2133 | 
            +
                #         instance_id: "i-d6f6fae3", 
         | 
| 2134 | 
            +
                #       }, 
         | 
| 2135 | 
            +
                #     ], 
         | 
| 2136 | 
            +
                #     load_balancer_name: "my-load-balancer", 
         | 
| 2137 | 
            +
                #   })
         | 
| 2138 | 
            +
                #
         | 
| 2139 | 
            +
                #   resp.to_h outputs the following:
         | 
| 2140 | 
            +
                #   {
         | 
| 2141 | 
            +
                #     instances: [
         | 
| 2142 | 
            +
                #       {
         | 
| 2143 | 
            +
                #         instance_id: "i-d6f6fae3", 
         | 
| 2144 | 
            +
                #       }, 
         | 
| 2145 | 
            +
                #       {
         | 
| 2146 | 
            +
                #         instance_id: "i-207d9717", 
         | 
| 2147 | 
            +
                #       }, 
         | 
| 2148 | 
            +
                #       {
         | 
| 2149 | 
            +
                #         instance_id: "i-afefb49b", 
         | 
| 2150 | 
            +
                #       }, 
         | 
| 2151 | 
            +
                #     ], 
         | 
| 2152 | 
            +
                #   }
         | 
| 2153 | 
            +
                #
         | 
| 1380 2154 | 
             
                # @example Request syntax with placeholder values
         | 
| 1381 2155 | 
             
                #
         | 
| 1382 2156 | 
             
                #   resp = client.register_instances_with_load_balancer({
         | 
| @@ -1413,6 +2187,22 @@ module Aws::ElasticLoadBalancing | |
| 1413 2187 | 
             
                #
         | 
| 1414 2188 | 
             
                # @return [Struct] Returns an empty {Seahorse::Client::Response response}.
         | 
| 1415 2189 | 
             
                #
         | 
| 2190 | 
            +
                #
         | 
| 2191 | 
            +
                # @example Example: To remove tags from a load balancer
         | 
| 2192 | 
            +
                #
         | 
| 2193 | 
            +
                #   # This example removes the specified tag from the specified load balancer.
         | 
| 2194 | 
            +
                #
         | 
| 2195 | 
            +
                #   resp = client.remove_tags({
         | 
| 2196 | 
            +
                #     load_balancer_names: [
         | 
| 2197 | 
            +
                #       "my-load-balancer", 
         | 
| 2198 | 
            +
                #     ], 
         | 
| 2199 | 
            +
                #     tags: [
         | 
| 2200 | 
            +
                #       {
         | 
| 2201 | 
            +
                #         key: "project", 
         | 
| 2202 | 
            +
                #       }, 
         | 
| 2203 | 
            +
                #     ], 
         | 
| 2204 | 
            +
                #   })
         | 
| 2205 | 
            +
                #
         | 
| 1416 2206 | 
             
                # @example Request syntax with placeholder values
         | 
| 1417 2207 | 
             
                #
         | 
| 1418 2208 | 
             
                #   resp = client.remove_tags({
         | 
| @@ -1456,6 +2246,17 @@ module Aws::ElasticLoadBalancing | |
| 1456 2246 | 
             
                #
         | 
| 1457 2247 | 
             
                # @return [Struct] Returns an empty {Seahorse::Client::Response response}.
         | 
| 1458 2248 | 
             
                #
         | 
| 2249 | 
            +
                #
         | 
| 2250 | 
            +
                # @example Example: To update the SSL certificate for an HTTPS listener
         | 
| 2251 | 
            +
                #
         | 
| 2252 | 
            +
                #   # This example replaces the existing SSL certificate for the specified HTTPS listener.
         | 
| 2253 | 
            +
                #
         | 
| 2254 | 
            +
                #   resp = client.set_load_balancer_listener_ssl_certificate({
         | 
| 2255 | 
            +
                #     load_balancer_name: "my-load-balancer", 
         | 
| 2256 | 
            +
                #     load_balancer_port: 443, 
         | 
| 2257 | 
            +
                #     ssl_certificate_id: "arn:aws:iam::123456789012:server-certificate/new-server-cert", 
         | 
| 2258 | 
            +
                #   })
         | 
| 2259 | 
            +
                #
         | 
| 1459 2260 | 
             
                # @example Request syntax with placeholder values
         | 
| 1460 2261 | 
             
                #
         | 
| 1461 2262 | 
             
                #   resp = client.set_load_balancer_listener_ssl_certificate({
         | 
| @@ -1509,6 +2310,19 @@ module Aws::ElasticLoadBalancing | |
| 1509 2310 | 
             
                #
         | 
| 1510 2311 | 
             
                # @return [Struct] Returns an empty {Seahorse::Client::Response response}.
         | 
| 1511 2312 | 
             
                #
         | 
| 2313 | 
            +
                #
         | 
| 2314 | 
            +
                # @example Example: To replace the policies associated with a port for a backend instance
         | 
| 2315 | 
            +
                #
         | 
| 2316 | 
            +
                #   # This example replaces the policies that are currently associated with the specified port.
         | 
| 2317 | 
            +
                #
         | 
| 2318 | 
            +
                #   resp = client.set_load_balancer_policies_for_backend_server({
         | 
| 2319 | 
            +
                #     instance_port: 80, 
         | 
| 2320 | 
            +
                #     load_balancer_name: "my-load-balancer", 
         | 
| 2321 | 
            +
                #     policy_names: [
         | 
| 2322 | 
            +
                #       "my-ProxyProtocol-policy", 
         | 
| 2323 | 
            +
                #     ], 
         | 
| 2324 | 
            +
                #   })
         | 
| 2325 | 
            +
                #
         | 
| 1512 2326 | 
             
                # @example Request syntax with placeholder values
         | 
| 1513 2327 | 
             
                #
         | 
| 1514 2328 | 
             
                #   resp = client.set_load_balancer_policies_for_backend_server({
         | 
| @@ -1556,6 +2370,19 @@ module Aws::ElasticLoadBalancing | |
| 1556 2370 | 
             
                #
         | 
| 1557 2371 | 
             
                # @return [Struct] Returns an empty {Seahorse::Client::Response response}.
         | 
| 1558 2372 | 
             
                #
         | 
| 2373 | 
            +
                #
         | 
| 2374 | 
            +
                # @example Example: To replace the policies associated with a listener
         | 
| 2375 | 
            +
                #
         | 
| 2376 | 
            +
                #   # This example replaces the policies that are currently associated with the specified listener.
         | 
| 2377 | 
            +
                #
         | 
| 2378 | 
            +
                #   resp = client.set_load_balancer_policies_of_listener({
         | 
| 2379 | 
            +
                #     load_balancer_name: "my-load-balancer", 
         | 
| 2380 | 
            +
                #     load_balancer_port: 80, 
         | 
| 2381 | 
            +
                #     policy_names: [
         | 
| 2382 | 
            +
                #       "my-SSLNegotiation-policy", 
         | 
| 2383 | 
            +
                #     ], 
         | 
| 2384 | 
            +
                #   })
         | 
| 2385 | 
            +
                #
         | 
| 1559 2386 | 
             
                # @example Request syntax with placeholder values
         | 
| 1560 2387 | 
             
                #
         | 
| 1561 2388 | 
             
                #   resp = client.set_load_balancer_policies_of_listener({
         | 
| @@ -1586,7 +2413,7 @@ module Aws::ElasticLoadBalancing | |
| 1586 2413 | 
             
                    params: params,
         | 
| 1587 2414 | 
             
                    config: config)
         | 
| 1588 2415 | 
             
                  context[:gem_name] = 'aws-sdk-elasticloadbalancing'
         | 
| 1589 | 
            -
                  context[:gem_version] = '1.0.0. | 
| 2416 | 
            +
                  context[:gem_version] = '1.0.0.rc7'
         | 
| 1590 2417 | 
             
                  Seahorse::Client::Request.new(handlers, context)
         | 
| 1591 2418 | 
             
                end
         | 
| 1592 2419 |  | 
    
        metadata
    CHANGED
    
    | @@ -1,14 +1,14 @@ | |
| 1 1 | 
             
            --- !ruby/object:Gem::Specification
         | 
| 2 2 | 
             
            name: aws-sdk-elasticloadbalancing
         | 
| 3 3 | 
             
            version: !ruby/object:Gem::Version
         | 
| 4 | 
            -
              version: 1.0.0. | 
| 4 | 
            +
              version: 1.0.0.rc7
         | 
| 5 5 | 
             
            platform: ruby
         | 
| 6 6 | 
             
            authors:
         | 
| 7 7 | 
             
            - Amazon Web Services
         | 
| 8 8 | 
             
            autorequire: 
         | 
| 9 9 | 
             
            bindir: bin
         | 
| 10 10 | 
             
            cert_chain: []
         | 
| 11 | 
            -
            date: 2017-06- | 
| 11 | 
            +
            date: 2017-06-29 00:00:00.000000000 Z
         | 
| 12 12 | 
             
            dependencies:
         | 
| 13 13 | 
             
            - !ruby/object:Gem::Dependency
         | 
| 14 14 | 
             
              name: aws-sdk-core
         | 
| @@ -16,14 +16,14 @@ dependencies: | |
| 16 16 | 
             
                requirements:
         | 
| 17 17 | 
             
                - - "~>"
         | 
| 18 18 | 
             
                  - !ruby/object:Gem::Version
         | 
| 19 | 
            -
                    version: 3.0.0. | 
| 19 | 
            +
                    version: 3.0.0.rc14
         | 
| 20 20 | 
             
              type: :runtime
         | 
| 21 21 | 
             
              prerelease: false
         | 
| 22 22 | 
             
              version_requirements: !ruby/object:Gem::Requirement
         | 
| 23 23 | 
             
                requirements:
         | 
| 24 24 | 
             
                - - "~>"
         | 
| 25 25 | 
             
                  - !ruby/object:Gem::Version
         | 
| 26 | 
            -
                    version: 3.0.0. | 
| 26 | 
            +
                    version: 3.0.0.rc14
         | 
| 27 27 | 
             
            - !ruby/object:Gem::Dependency
         | 
| 28 28 | 
             
              name: aws-sigv4
         | 
| 29 29 | 
             
              requirement: !ruby/object:Gem::Requirement
         |