/* * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * * Licensed under the Apache License, Version 2.0 (the "License"). * You may not use this file except in compliance with the License. * A copy of the License is located at * * http://aws.amazon.com/apache2.0 * * or in the "license" file accompanying this file. This file is distributed * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either * express or implied. See the License for the specific language governing * permissions and limitations under the License. */ /* * Do not modify this file. This file is generated from the elasticloadbalancing-2012-06-01.normal.json service model. */ using System; using System.Threading; using System.Threading.Tasks; using System.Collections.Generic; using Amazon.Runtime; using Amazon.ElasticLoadBalancing.Model; namespace Amazon.ElasticLoadBalancing { ///

/// Interface for accessing ElasticLoadBalancing /// /// Elastic Load Balancing /// /// A load balancer can distribute incoming traffic across your EC2 instances. This enables /// you to increase the availability of your application. The load balancer also monitors /// the health of its registered instances and ensures that it routes traffic only to /// healthy instances. You configure your load balancer to accept incoming traffic by /// specifying one or more listeners, which are configured with a protocol and port number /// for connections from clients to the load balancer and a protocol and port number for /// connections from the load balancer to the instances. /// /// /// /// Elastic Load Balancing supports three types of load balancers: Application Load Balancers, /// Network Load Balancers, and Classic Load Balancers. You can select a load balancer /// based on your application needs. For more information, see the Elastic /// Load Balancing User Guide. /// /// /// /// This reference covers the 2012-06-01 API, which supports Classic Load Balancers. The /// 2015-12-01 API supports Application Load Balancers and Network Load Balancers. /// /// /// /// To get started, create a load balancer with one or more listeners using CreateLoadBalancer. /// Register your instances with the load balancer using RegisterInstancesWithLoadBalancer. /// /// /// /// All Elastic Load Balancing operations are idempotent, which means that they /// complete at most one time. If you repeat an operation, it succeeds with a 200 OK response /// code. /// ///

public partial interface IAmazonElasticLoadBalancing : IAmazonService, IDisposable { #if AWS_ASYNC_ENUMERABLES_API ///

/// Paginators for the service ///

IElasticLoadBalancingPaginatorFactory Paginators { get; } #endif #region AddTags ///

/// Adds the specified tags to the specified load balancer. Each load balancer can have /// a maximum of 10 tags. /// /// /// /// Each tag consists of a key and an optional value. If a tag with the same key is already /// associated with the load balancer, AddTags updates its value. /// /// /// /// For more information, see Tag /// Your Classic Load Balancer in the Classic Load Balancers Guide. /// ///

/// Container for the necessary parameters to execute the AddTags service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AddTags service method, as returned by ElasticLoadBalancing. /// /// The specified load balancer does not exist. /// /// /// A tag key was specified more than once. /// /// /// The quota for the number of tags that can be assigned to a load balancer has been /// reached. /// /// REST API Reference for AddTags Operation Task AddTagsAsync(AddTagsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region ApplySecurityGroupsToLoadBalancer ///

/// Associates one or more security groups with your load balancer in a virtual private /// cloud (VPC). The specified security groups override the previously associated security /// groups. /// /// /// /// For more information, see Security /// Groups for Load Balancers in a VPC in the Classic Load Balancers Guide. /// ///

/// Container for the necessary parameters to execute the ApplySecurityGroupsToLoadBalancer service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ApplySecurityGroupsToLoadBalancer service method, as returned by ElasticLoadBalancing. /// /// The specified load balancer does not exist. /// /// /// The requested configuration change is not valid. /// /// /// One or more of the specified security groups do not exist. /// /// REST API Reference for ApplySecurityGroupsToLoadBalancer Operation Task ApplySecurityGroupsToLoadBalancerAsync(ApplySecurityGroupsToLoadBalancerRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region AttachLoadBalancerToSubnets ///

/// Adds one or more subnets to the set of configured subnets for the specified load balancer. /// /// /// /// The load balancer evenly distributes requests across all registered subnets. For more /// information, see Add /// or Remove Subnets for Your Load Balancer in a VPC in the Classic Load Balancers /// Guide. /// ///

/// Container for the necessary parameters to execute the AttachLoadBalancerToSubnets service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AttachLoadBalancerToSubnets service method, as returned by ElasticLoadBalancing. /// /// The specified load balancer does not exist. /// /// /// The requested configuration change is not valid. /// /// /// The specified VPC has no associated Internet gateway. /// /// /// One or more of the specified subnets do not exist. /// /// REST API Reference for AttachLoadBalancerToSubnets Operation Task AttachLoadBalancerToSubnetsAsync(AttachLoadBalancerToSubnetsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region ConfigureHealthCheck ///

/// Specifies the health check settings to use when evaluating the health state of your /// EC2 instances. /// /// /// /// For more information, see Configure /// Health Checks for Your Load Balancer in the Classic Load Balancers Guide. /// ///

/// Container for the necessary parameters to execute the ConfigureHealthCheck service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ConfigureHealthCheck service method, as returned by ElasticLoadBalancing. /// /// The specified load balancer does not exist. /// /// REST API Reference for ConfigureHealthCheck Operation Task ConfigureHealthCheckAsync(ConfigureHealthCheckRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateAppCookieStickinessPolicy ///

/// Generates a stickiness policy with sticky session lifetimes that follow that of an /// application-generated cookie. This policy can be associated only with HTTP/HTTPS listeners. /// /// /// /// This policy is similar to the policy created by CreateLBCookieStickinessPolicy, /// except that the lifetime of the special Elastic Load Balancing cookie, AWSELB, /// follows the lifetime of the application-generated cookie specified in the policy configuration. /// The load balancer only inserts a new stickiness cookie when the application response /// includes a new application cookie. /// /// /// /// If the application cookie is explicitly removed or expires, the session stops being /// sticky until a new application cookie is issued. /// /// /// /// For more information, see Application-Controlled /// Session Stickiness in the Classic Load Balancers Guide. /// ///

/// Container for the necessary parameters to execute the CreateAppCookieStickinessPolicy service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateAppCookieStickinessPolicy service method, as returned by ElasticLoadBalancing. /// /// The specified load balancer does not exist. /// /// /// A policy with the specified name already exists for this load balancer. /// /// /// The requested configuration change is not valid. /// /// /// The quota for the number of policies for this load balancer has been reached. /// /// REST API Reference for CreateAppCookieStickinessPolicy Operation Task CreateAppCookieStickinessPolicyAsync(CreateAppCookieStickinessPolicyRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateLBCookieStickinessPolicy ///

/// Generates a stickiness policy with sticky session lifetimes controlled by the lifetime /// of the browser (user-agent) or a specified expiration period. This policy can be associated /// only with HTTP/HTTPS listeners. /// /// /// /// When a load balancer implements this policy, the load balancer uses a special cookie /// to track the instance for each request. When the load balancer receives a request, /// it first checks to see if this cookie is present in the request. If so, the load balancer /// sends the request to the application server specified in the cookie. If not, the load /// balancer sends the request to a server that is chosen based on the existing load-balancing /// algorithm. /// /// /// /// A cookie is inserted into the response for binding subsequent requests from the same /// user to that server. The validity of the cookie is based on the cookie expiration /// time, which is specified in the policy configuration. /// /// /// /// For more information, see Duration-Based /// Session Stickiness in the Classic Load Balancers Guide. /// ///

/// Container for the necessary parameters to execute the CreateLBCookieStickinessPolicy service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateLBCookieStickinessPolicy service method, as returned by ElasticLoadBalancing. /// /// The specified load balancer does not exist. /// /// /// A policy with the specified name already exists for this load balancer. /// /// /// The requested configuration change is not valid. /// /// /// The quota for the number of policies for this load balancer has been reached. /// /// REST API Reference for CreateLBCookieStickinessPolicy Operation Task CreateLBCookieStickinessPolicyAsync(CreateLBCookieStickinessPolicyRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateLoadBalancer ///

/// Creates a Classic Load Balancer. /// /// /// /// You can add listeners, security groups, subnets, and tags when you create your load /// balancer, or you can add them later using CreateLoadBalancerListeners, ApplySecurityGroupsToLoadBalancer, /// AttachLoadBalancerToSubnets, and AddTags. /// /// /// /// To describe your current load balancers, see DescribeLoadBalancers. When you /// are finished with a load balancer, you can delete it using DeleteLoadBalancer. /// /// /// /// You can create up to 20 load balancers per region per account. You can request an /// increase for the number of load balancers for your account. For more information, /// see Limits /// for Your Classic Load Balancer in the Classic Load Balancers Guide. /// ///

/// Container for the necessary parameters to execute the CreateLoadBalancer service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateLoadBalancer service method, as returned by ElasticLoadBalancing. /// /// The specified ARN does not refer to a valid SSL certificate in AWS Identity and Access /// Management (IAM) or AWS Certificate Manager (ACM). Note that if you recently uploaded /// the certificate to IAM, this error might indicate that the certificate is not fully /// available yet. /// /// /// The specified load balancer name already exists for this account. /// /// /// A tag key was specified more than once. /// /// /// The requested configuration change is not valid. /// /// /// The specified value for the schema is not valid. You can only specify a scheme for /// load balancers in a VPC. /// /// /// One or more of the specified security groups do not exist. /// /// /// The specified VPC has no associated Internet gateway. /// /// /// This operation is not allowed. /// /// /// One or more of the specified subnets do not exist. /// /// /// The quota for the number of load balancers has been reached. /// /// /// The quota for the number of tags that can be assigned to a load balancer has been /// reached. /// /// /// The specified protocol or signature version is not supported. /// /// REST API Reference for CreateLoadBalancer Operation Task CreateLoadBalancerAsync(CreateLoadBalancerRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateLoadBalancerListeners ///

/// Creates one or more listeners for the specified load balancer. If a listener with /// the specified port does not already exist, it is created; otherwise, the properties /// of the new listener must match the properties of the existing listener. /// /// /// /// For more information, see Listeners /// for Your Classic Load Balancer in the Classic Load Balancers Guide. /// ///

/// Container for the necessary parameters to execute the CreateLoadBalancerListeners service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateLoadBalancerListeners service method, as returned by ElasticLoadBalancing. /// /// The specified load balancer does not exist. /// /// /// The specified ARN does not refer to a valid SSL certificate in AWS Identity and Access /// Management (IAM) or AWS Certificate Manager (ACM). Note that if you recently uploaded /// the certificate to IAM, this error might indicate that the certificate is not fully /// available yet. /// /// /// A listener already exists for the specified load balancer name and port, but with /// a different instance port, protocol, or SSL certificate. /// /// /// The requested configuration change is not valid. /// /// /// The specified protocol or signature version is not supported. /// /// REST API Reference for CreateLoadBalancerListeners Operation Task CreateLoadBalancerListenersAsync(CreateLoadBalancerListenersRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateLoadBalancerPolicy ///

/// Creates a policy with the specified attributes for the specified load balancer. /// /// /// /// Policies are settings that are saved for your load balancer and that can be applied /// to the listener or the application server, depending on the policy type. /// ///

/// Container for the necessary parameters to execute the CreateLoadBalancerPolicy service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateLoadBalancerPolicy service method, as returned by ElasticLoadBalancing. /// /// The specified load balancer does not exist. /// /// /// A policy with the specified name already exists for this load balancer. /// /// /// The requested configuration change is not valid. /// /// /// One or more of the specified policy types do not exist. /// /// /// The quota for the number of policies for this load balancer has been reached. /// /// REST API Reference for CreateLoadBalancerPolicy Operation Task CreateLoadBalancerPolicyAsync(CreateLoadBalancerPolicyRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteLoadBalancer ///

/// Deletes the specified load balancer. /// /// /// /// If you are attempting to recreate a load balancer, you must reconfigure all settings. /// The DNS name associated with a deleted load balancer are no longer usable. The name /// and associated DNS record of the deleted load balancer no longer exist and traffic /// sent to any of its IP addresses is no longer delivered to your instances. /// /// /// /// If the load balancer does not exist or has already been deleted, the call to DeleteLoadBalancer /// still succeeds. /// ///

/// Container for the necessary parameters to execute the DeleteLoadBalancer service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteLoadBalancer service method, as returned by ElasticLoadBalancing. /// REST API Reference for DeleteLoadBalancer Operation Task DeleteLoadBalancerAsync(DeleteLoadBalancerRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteLoadBalancerListeners ///

/// Deletes the specified listeners from the specified load balancer. ///

/// Container for the necessary parameters to execute the DeleteLoadBalancerListeners service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteLoadBalancerListeners service method, as returned by ElasticLoadBalancing. /// /// The specified load balancer does not exist. /// /// REST API Reference for DeleteLoadBalancerListeners Operation Task DeleteLoadBalancerListenersAsync(DeleteLoadBalancerListenersRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteLoadBalancerPolicy ///

/// Deletes the specified policy from the specified load balancer. This policy must not /// be enabled for any listeners. ///

/// Container for the necessary parameters to execute the DeleteLoadBalancerPolicy service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteLoadBalancerPolicy service method, as returned by ElasticLoadBalancing. /// /// The specified load balancer does not exist. /// /// /// The requested configuration change is not valid. /// /// REST API Reference for DeleteLoadBalancerPolicy Operation Task DeleteLoadBalancerPolicyAsync(DeleteLoadBalancerPolicyRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeregisterInstancesFromLoadBalancer ///

/// Deregisters the specified instances from the specified load balancer. After the instance /// is deregistered, it no longer receives traffic from the load balancer. /// /// /// /// You can use DescribeLoadBalancers to verify that the instance is deregistered /// from the load balancer. /// /// /// /// For more information, see Register /// or De-Register EC2 Instances in the Classic Load Balancers Guide. /// ///

/// Container for the necessary parameters to execute the DeregisterInstancesFromLoadBalancer service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeregisterInstancesFromLoadBalancer service method, as returned by ElasticLoadBalancing. /// /// The specified load balancer does not exist. /// /// /// The specified endpoint is not valid. /// /// REST API Reference for DeregisterInstancesFromLoadBalancer Operation Task DeregisterInstancesFromLoadBalancerAsync(DeregisterInstancesFromLoadBalancerRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeAccountLimits ///

/// Describes the current Elastic Load Balancing resource limits for your AWS account. /// /// /// /// For more information, see Limits /// for Your Classic Load Balancer in the Classic Load Balancers Guide. /// ///

/// Container for the necessary parameters to execute the DescribeAccountLimits service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeAccountLimits service method, as returned by ElasticLoadBalancing. /// REST API Reference for DescribeAccountLimits Operation Task DescribeAccountLimitsAsync(DescribeAccountLimitsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeInstanceHealth ///

/// Describes the state of the specified instances with respect to the specified load /// balancer. If no instances are specified, the call describes the state of all instances /// that are currently registered with the load balancer. If instances are specified, /// their state is returned even if they are no longer registered with the load balancer. /// The state of terminated instances is not returned. ///

/// Container for the necessary parameters to execute the DescribeInstanceHealth service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeInstanceHealth service method, as returned by ElasticLoadBalancing. /// /// The specified load balancer does not exist. /// /// /// The specified endpoint is not valid. /// /// REST API Reference for DescribeInstanceHealth Operation Task DescribeInstanceHealthAsync(DescribeInstanceHealthRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeLoadBalancerAttributes ///

/// Describes the attributes for the specified load balancer. ///

/// Container for the necessary parameters to execute the DescribeLoadBalancerAttributes service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeLoadBalancerAttributes service method, as returned by ElasticLoadBalancing. /// /// The specified load balancer does not exist. /// /// /// The specified load balancer attribute does not exist. /// /// REST API Reference for DescribeLoadBalancerAttributes Operation Task DescribeLoadBalancerAttributesAsync(DescribeLoadBalancerAttributesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeLoadBalancerPolicies ///

/// Describes the specified policies. /// /// /// /// If you specify a load balancer name, the action returns the descriptions of all policies /// created for the load balancer. If you specify a policy name associated with your load /// balancer, the action returns the description of that policy. If you don't specify /// a load balancer name, the action returns descriptions of the specified sample policies, /// or descriptions of all sample policies. The names of the sample policies have the /// ELBSample- prefix. /// ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeLoadBalancerPolicies service method, as returned by ElasticLoadBalancing. /// /// The specified load balancer does not exist. /// /// /// One or more of the specified policies do not exist. /// /// REST API Reference for DescribeLoadBalancerPolicies Operation Task DescribeLoadBalancerPoliciesAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)); ///

/// Container for the necessary parameters to execute the DescribeLoadBalancerPolicies service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeLoadBalancerPolicies service method, as returned by ElasticLoadBalancing. /// /// The specified load balancer does not exist. /// /// /// One or more of the specified policies do not exist. /// /// REST API Reference for DescribeLoadBalancerPolicies Operation Task DescribeLoadBalancerPoliciesAsync(DescribeLoadBalancerPoliciesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeLoadBalancerPolicyTypes ///

/// Describes the specified load balancer policy types or all load balancer policy types. /// /// /// /// The description of each type indicates how it can be used. For example, some policies /// can be used only with layer 7 listeners, some policies can be used only with layer /// 4 listeners, and some policies can be used only with your EC2 instances. /// /// /// /// You can use CreateLoadBalancerPolicy to create a policy configuration for any /// of these policy types. Then, depending on the policy type, use either SetLoadBalancerPoliciesOfListener /// or SetLoadBalancerPoliciesForBackendServer to set the policy. /// ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeLoadBalancerPolicyTypes service method, as returned by ElasticLoadBalancing. /// /// One or more of the specified policy types do not exist. /// /// REST API Reference for DescribeLoadBalancerPolicyTypes Operation Task DescribeLoadBalancerPolicyTypesAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)); ///

/// Container for the necessary parameters to execute the DescribeLoadBalancerPolicyTypes service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeLoadBalancerPolicyTypes service method, as returned by ElasticLoadBalancing. /// /// One or more of the specified policy types do not exist. /// /// REST API Reference for DescribeLoadBalancerPolicyTypes Operation Task DescribeLoadBalancerPolicyTypesAsync(DescribeLoadBalancerPolicyTypesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeLoadBalancers ///

/// Describes the specified the load balancers. If no load balancers are specified, the /// call describes all of your load balancers. ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeLoadBalancers service method, as returned by ElasticLoadBalancing. /// /// The specified load balancer does not exist. /// /// /// A request made by Elastic Load Balancing to another service exceeds the maximum request /// rate permitted for your account. /// /// REST API Reference for DescribeLoadBalancers Operation Task DescribeLoadBalancersAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)); ///

/// Describes the specified the load balancers. If no load balancers are specified, the /// call describes all of your load balancers. ///

/// Container for the necessary parameters to execute the DescribeLoadBalancers service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeLoadBalancers service method, as returned by ElasticLoadBalancing. /// /// The specified load balancer does not exist. /// /// /// A request made by Elastic Load Balancing to another service exceeds the maximum request /// rate permitted for your account. /// /// REST API Reference for DescribeLoadBalancers Operation Task DescribeLoadBalancersAsync(DescribeLoadBalancersRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeTags ///

/// Describes the tags associated with the specified load balancers. ///

/// Container for the necessary parameters to execute the DescribeTags service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeTags service method, as returned by ElasticLoadBalancing. /// /// The specified load balancer does not exist. /// /// REST API Reference for DescribeTags Operation Task DescribeTagsAsync(DescribeTagsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DetachLoadBalancerFromSubnets ///

/// Removes the specified subnets from the set of configured subnets for the load balancer. /// /// /// /// After a subnet is removed, all EC2 instances registered with the load balancer in /// the removed subnet go into the OutOfService state. Then, the load balancer /// balances the traffic among the remaining routable subnets. /// ///

/// Container for the necessary parameters to execute the DetachLoadBalancerFromSubnets service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DetachLoadBalancerFromSubnets service method, as returned by ElasticLoadBalancing. /// /// The specified load balancer does not exist. /// /// /// The requested configuration change is not valid. /// /// REST API Reference for DetachLoadBalancerFromSubnets Operation Task DetachLoadBalancerFromSubnetsAsync(DetachLoadBalancerFromSubnetsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DisableAvailabilityZonesForLoadBalancer ///

/// Removes the specified Availability Zones from the set of Availability Zones for the /// specified load balancer in EC2-Classic or a default VPC. /// /// /// /// For load balancers in a non-default VPC, use DetachLoadBalancerFromSubnets. /// /// /// /// There must be at least one Availability Zone registered with a load balancer at all /// times. After an Availability Zone is removed, all instances registered with the load /// balancer that are in the removed Availability Zone go into the OutOfService /// state. Then, the load balancer attempts to equally balance the traffic among its remaining /// Availability Zones. /// /// /// /// For more information, see Add /// or Remove Availability Zones in the Classic Load Balancers Guide. /// ///

/// Container for the necessary parameters to execute the DisableAvailabilityZonesForLoadBalancer service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DisableAvailabilityZonesForLoadBalancer service method, as returned by ElasticLoadBalancing. /// /// The specified load balancer does not exist. /// /// /// The requested configuration change is not valid. /// /// REST API Reference for DisableAvailabilityZonesForLoadBalancer Operation Task DisableAvailabilityZonesForLoadBalancerAsync(DisableAvailabilityZonesForLoadBalancerRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region EnableAvailabilityZonesForLoadBalancer ///

/// Adds the specified Availability Zones to the set of Availability Zones for the specified /// load balancer in EC2-Classic or a default VPC. /// /// /// /// For load balancers in a non-default VPC, use AttachLoadBalancerToSubnets. /// /// /// /// The load balancer evenly distributes requests across all its registered Availability /// Zones that contain instances. For more information, see Add /// or Remove Availability Zones in the Classic Load Balancers Guide. /// ///

/// Container for the necessary parameters to execute the EnableAvailabilityZonesForLoadBalancer service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the EnableAvailabilityZonesForLoadBalancer service method, as returned by ElasticLoadBalancing. /// /// The specified load balancer does not exist. /// /// REST API Reference for EnableAvailabilityZonesForLoadBalancer Operation Task EnableAvailabilityZonesForLoadBalancerAsync(EnableAvailabilityZonesForLoadBalancerRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region ModifyLoadBalancerAttributes ///

/// Modifies the attributes of the specified load balancer. /// /// /// /// You can modify the load balancer attributes, such as AccessLogs, ConnectionDraining, /// and CrossZoneLoadBalancing by either enabling or disabling them. Or, /// you can modify the load balancer attribute ConnectionSettings by specifying /// an idle connection timeout value for your load balancer. /// /// /// /// For more information, see the following in the Classic Load Balancers Guide: /// ///

/// /// Cross-Zone /// Load Balancing /// ///
/// /// Connection /// Draining /// ///
/// /// Access /// Logs /// ///
/// /// Idle /// Connection Timeout /// ///

///

/// Container for the necessary parameters to execute the ModifyLoadBalancerAttributes service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ModifyLoadBalancerAttributes service method, as returned by ElasticLoadBalancing. /// /// The specified load balancer does not exist. /// /// /// The requested configuration change is not valid. /// /// /// The specified load balancer attribute does not exist. /// /// REST API Reference for ModifyLoadBalancerAttributes Operation Task ModifyLoadBalancerAttributesAsync(ModifyLoadBalancerAttributesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region RegisterInstancesWithLoadBalancer ///

/// Adds the specified instances to the specified load balancer. /// /// /// /// The instance must be a running instance in the same network as the load balancer (EC2-Classic /// or the same VPC). If you have EC2-Classic instances and a load balancer in a VPC with /// ClassicLink enabled, you can link the EC2-Classic instances to that VPC and then register /// the linked EC2-Classic instances with the load balancer in the VPC. /// /// /// /// Note that RegisterInstanceWithLoadBalancer completes when the request /// has been registered. Instance registration takes a little time to complete. To check /// the state of the registered instances, use DescribeLoadBalancers or DescribeInstanceHealth. /// /// /// /// After the instance is registered, it starts receiving traffic and requests from the /// load balancer. Any instance that is not in one of the Availability Zones registered /// for the load balancer is moved to the OutOfService state. If an Availability /// Zone is added to the load balancer later, any instances registered with the load balancer /// move to the InService state. /// /// /// /// To deregister instances from a load balancer, use DeregisterInstancesFromLoadBalancer. /// /// /// /// For more information, see Register /// or De-Register EC2 Instances in the Classic Load Balancers Guide. /// ///

/// Container for the necessary parameters to execute the RegisterInstancesWithLoadBalancer service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the RegisterInstancesWithLoadBalancer service method, as returned by ElasticLoadBalancing. /// /// The specified load balancer does not exist. /// /// /// The specified endpoint is not valid. /// /// REST API Reference for RegisterInstancesWithLoadBalancer Operation Task RegisterInstancesWithLoadBalancerAsync(RegisterInstancesWithLoadBalancerRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region RemoveTags ///

/// Removes one or more tags from the specified load balancer. ///

/// Container for the necessary parameters to execute the RemoveTags service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the RemoveTags service method, as returned by ElasticLoadBalancing. /// /// The specified load balancer does not exist. /// /// REST API Reference for RemoveTags Operation Task RemoveTagsAsync(RemoveTagsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region SetLoadBalancerListenerSSLCertificate ///

/// Sets the certificate that terminates the specified listener's SSL connections. The /// specified certificate replaces any prior certificate that was used on the same load /// balancer and port. /// /// /// /// For more information about updating your SSL certificate, see Replace /// the SSL Certificate for Your Load Balancer in the Classic Load Balancers Guide. /// ///

/// Container for the necessary parameters to execute the SetLoadBalancerListenerSSLCertificate service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the SetLoadBalancerListenerSSLCertificate service method, as returned by ElasticLoadBalancing. /// /// The specified load balancer does not exist. /// /// /// The specified ARN does not refer to a valid SSL certificate in AWS Identity and Access /// Management (IAM) or AWS Certificate Manager (ACM). Note that if you recently uploaded /// the certificate to IAM, this error might indicate that the certificate is not fully /// available yet. /// /// /// The requested configuration change is not valid. /// /// /// The load balancer does not have a listener configured at the specified port. /// /// /// The specified protocol or signature version is not supported. /// /// REST API Reference for SetLoadBalancerListenerSSLCertificate Operation Task SetLoadBalancerListenerSSLCertificateAsync(SetLoadBalancerListenerSSLCertificateRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region SetLoadBalancerPoliciesForBackendServer ///

/// Replaces the set of policies associated with the specified port on which the EC2 instance /// is listening with a new set of policies. At this time, only the back-end server authentication /// policy type can be applied to the instance ports; this policy type is composed of /// multiple public key policies. /// /// /// /// Each time you use SetLoadBalancerPoliciesForBackendServer to enable the /// policies, use the PolicyNames parameter to list the policies that you /// want to enable. /// /// /// /// You can use DescribeLoadBalancers or DescribeLoadBalancerPolicies to /// verify that the policy is associated with the EC2 instance. /// /// /// /// For more information about enabling back-end instance authentication, see Configure /// Back-end Instance Authentication in the Classic Load Balancers Guide. For /// more information about Proxy Protocol, see Configure /// Proxy Protocol Support in the Classic Load Balancers Guide. /// ///

/// Container for the necessary parameters to execute the SetLoadBalancerPoliciesForBackendServer service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the SetLoadBalancerPoliciesForBackendServer service method, as returned by ElasticLoadBalancing. /// /// The specified load balancer does not exist. /// /// /// The requested configuration change is not valid. /// /// /// One or more of the specified policies do not exist. /// /// REST API Reference for SetLoadBalancerPoliciesForBackendServer Operation Task SetLoadBalancerPoliciesForBackendServerAsync(SetLoadBalancerPoliciesForBackendServerRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region SetLoadBalancerPoliciesOfListener ///

/// Replaces the current set of policies for the specified load balancer port with the /// specified set of policies. /// /// /// /// To enable back-end server authentication, use SetLoadBalancerPoliciesForBackendServer. /// /// /// /// For more information about setting policies, see Update /// the SSL Negotiation Configuration, Duration-Based /// Session Stickiness, and Application-Controlled /// Session Stickiness in the Classic Load Balancers Guide. /// ///

/// Container for the necessary parameters to execute the SetLoadBalancerPoliciesOfListener service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the SetLoadBalancerPoliciesOfListener service method, as returned by ElasticLoadBalancing. /// /// The specified load balancer does not exist. /// /// /// The requested configuration change is not valid. /// /// /// The load balancer does not have a listener configured at the specified port. /// /// /// One or more of the specified policies do not exist. /// /// REST API Reference for SetLoadBalancerPoliciesOfListener Operation Task SetLoadBalancerPoliciesOfListenerAsync(SetLoadBalancerPoliciesOfListenerRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion } }