/* * 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 elasticloadbalancingv2-2015-12-01.normal.json service model. */ using System; using System.Threading; using System.Threading.Tasks; using System.Collections.Generic; using Amazon.Runtime; using Amazon.ElasticLoadBalancingV2.Model; namespace Amazon.ElasticLoadBalancingV2 { /// /// Interface for accessing ElasticLoadBalancingV2 /// /// Elastic Load Balancing /// /// A load balancer distributes incoming traffic across targets, such as your EC2 instances. /// This enables you to increase the availability of your application. The load balancer /// also monitors the health of its registered targets and ensures that it routes traffic /// only to healthy targets. 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. You configure a target group /// with a protocol and port number for connections from the load balancer to the targets, /// and with health check settings to be used when checking the health status of the targets. /// /// /// /// Elastic Load Balancing supports the following types of load balancers: Application /// Load Balancers, Network Load Balancers, Gateway Load Balancers, and Classic Load Balancers. /// This reference covers the following load balancer types: /// /// /// /// For more information, see the Elastic /// Load Balancing User Guide. /// /// /// /// All Elastic Load Balancing operations are idempotent, which means that they complete /// at most one time. If you repeat an operation, it succeeds. /// /// public partial interface IAmazonElasticLoadBalancingV2 : IAmazonService, IDisposable { #if AWS_ASYNC_ENUMERABLES_API /// /// Paginators for the service /// IElasticLoadBalancingV2PaginatorFactory Paginators { get; } #endif #region AddListenerCertificates /// /// Adds the specified SSL server certificate to the certificate list for the specified /// HTTPS or TLS listener. /// /// /// /// If the certificate in already in the certificate list, the call is successful but /// the certificate is not added again. /// /// /// /// For more information, see HTTPS /// listeners in the Application Load Balancers Guide or TLS /// listeners in the Network Load Balancers Guide. /// /// /// Container for the necessary parameters to execute the AddListenerCertificates service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AddListenerCertificates service method, as returned by ElasticLoadBalancingV2. /// /// The specified certificate does not exist. /// /// /// The specified listener does not exist. /// /// /// You've reached the limit on the number of certificates per load balancer. /// /// REST API Reference for AddListenerCertificates Operation Task AddListenerCertificatesAsync(AddListenerCertificatesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region AddTags /// /// Adds the specified tags to the specified Elastic Load Balancing resource. You can /// tag your Application Load Balancers, Network Load Balancers, Gateway Load Balancers, /// target groups, listeners, and rules. /// /// /// /// Each tag consists of a key and an optional value. If a resource already has a tag /// with the same key, AddTags updates its value. /// /// /// 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 ElasticLoadBalancingV2. /// /// A tag key was specified more than once. /// /// /// The specified listener does not exist. /// /// /// The specified load balancer does not exist. /// /// /// The specified rule does not exist. /// /// /// The specified target group does not exist. /// /// /// You've reached the limit on the number of tags per load balancer. /// /// REST API Reference for AddTags Operation Task AddTagsAsync(AddTagsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateListener /// /// Creates a listener for the specified Application Load Balancer, Network Load Balancer, /// or Gateway Load Balancer. /// /// /// /// For more information, see the following: /// /// /// /// This operation is idempotent, which means that it completes at most one time. If you /// attempt to create multiple listeners with the same settings, each call succeeds. /// /// /// Container for the necessary parameters to execute the CreateListener service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateListener service method, as returned by ElasticLoadBalancingV2. /// /// The specified ALPN policy is not supported. /// /// /// The specified certificate does not exist. /// /// /// A listener with the specified port already exists. /// /// /// The specified configuration is not valid with this protocol. /// /// /// The requested configuration is not valid. /// /// /// The requested action is not valid. /// /// /// The specified load balancer does not exist. /// /// /// The specified SSL policy does not exist. /// /// /// You've reached the limit on the number of load balancers per target group. /// /// /// The specified target group does not exist. /// /// /// You've reached the limit on the number of actions per rule. /// /// /// You've reached the limit on the number of certificates per load balancer. /// /// /// You've reached the limit on the number of listeners per load balancer. /// /// /// You've reached the limit on the number of times a target can be registered with a /// load balancer. /// /// /// You've reached the limit on the number of tags per load balancer. /// /// /// You've reached the limit on the number of targets. /// /// /// You've reached the limit on the number of unique target groups per load balancer across /// all listeners. If a target group is used by multiple actions for a load balancer, /// it is counted as only one use. /// /// /// The specified protocol is not supported. /// /// REST API Reference for CreateListener Operation Task CreateListenerAsync(CreateListenerRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateLoadBalancer /// /// Creates an Application Load Balancer, Network Load Balancer, or Gateway Load Balancer. /// /// /// /// For more information, see the following: /// /// /// /// This operation is idempotent, which means that it completes at most one time. If you /// attempt to create multiple load balancers with the same settings, each call succeeds. /// /// /// 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 ElasticLoadBalancingV2. /// /// The specified allocation ID does not exist. /// /// /// The specified Availability Zone is not supported. /// /// /// A load balancer with the specified name already exists. /// /// /// A tag key was specified more than once. /// /// /// The requested configuration is not valid. /// /// /// The requested scheme is not valid. /// /// /// The specified security group does not exist. /// /// /// The specified subnet is out of available addresses. /// /// /// This operation is not allowed. /// /// /// A specified resource is in use. /// /// /// The specified subnet does not exist. /// /// /// You've reached the limit on the number of load balancers for your Amazon Web Services /// account. /// /// /// You've reached the limit on the number of tags per load balancer. /// /// REST API Reference for CreateLoadBalancer Operation Task CreateLoadBalancerAsync(CreateLoadBalancerRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateRule /// /// Creates a rule for the specified listener. The listener must be associated with an /// Application Load Balancer. /// /// /// /// Each rule consists of a priority, one or more actions, and one or more conditions. /// Rules are evaluated in priority order, from the lowest value to the highest value. /// When the conditions for a rule are met, its actions are performed. If the conditions /// for no rules are met, the actions for the default rule are performed. For more information, /// see Listener /// rules in the Application Load Balancers Guide. /// /// /// Container for the necessary parameters to execute the CreateRule service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateRule service method, as returned by ElasticLoadBalancingV2. /// /// The specified configuration is not valid with this protocol. /// /// /// The requested configuration is not valid. /// /// /// The requested action is not valid. /// /// /// The specified listener does not exist. /// /// /// The specified priority is in use. /// /// /// You've reached the limit on the number of load balancers per target group. /// /// /// The specified target group does not exist. /// /// /// You've reached the limit on the number of actions per rule. /// /// /// You've reached the limit on the number of times a target can be registered with a /// load balancer. /// /// /// You've reached the limit on the number of rules per load balancer. /// /// /// You've reached the limit on the number of tags per load balancer. /// /// /// You've reached the limit on the number of target groups for your Amazon Web Services /// account. /// /// /// You've reached the limit on the number of targets. /// /// /// You've reached the limit on the number of unique target groups per load balancer across /// all listeners. If a target group is used by multiple actions for a load balancer, /// it is counted as only one use. /// /// /// The specified protocol is not supported. /// /// REST API Reference for CreateRule Operation Task CreateRuleAsync(CreateRuleRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateTargetGroup /// /// Creates a target group. /// /// /// /// For more information, see the following: /// /// /// /// This operation is idempotent, which means that it completes at most one time. If you /// attempt to create multiple target groups with the same settings, each call succeeds. /// /// /// Container for the necessary parameters to execute the CreateTargetGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateTargetGroup service method, as returned by ElasticLoadBalancingV2. /// /// A target group with the specified name already exists. /// /// /// The requested configuration is not valid. /// /// /// You've reached the limit on the number of tags per load balancer. /// /// /// You've reached the limit on the number of target groups for your Amazon Web Services /// account. /// /// REST API Reference for CreateTargetGroup Operation Task CreateTargetGroupAsync(CreateTargetGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteListener /// /// Deletes the specified listener. /// /// /// /// Alternatively, your listener is deleted when you delete the load balancer to which /// it is attached. /// /// /// Container for the necessary parameters to execute the DeleteListener service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteListener service method, as returned by ElasticLoadBalancingV2. /// /// The specified listener does not exist. /// /// /// A specified resource is in use. /// /// REST API Reference for DeleteListener Operation Task DeleteListenerAsync(DeleteListenerRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteLoadBalancer /// /// Deletes the specified Application Load Balancer, Network Load Balancer, or Gateway /// Load Balancer. Deleting a load balancer also deletes its listeners. /// /// /// /// You can't delete a load balancer if deletion protection is enabled. If the load balancer /// does not exist or has already been deleted, the call succeeds. /// /// /// /// Deleting a load balancer does not affect its registered targets. For example, your /// EC2 instances continue to run and are still registered to their target groups. If /// you no longer need these EC2 instances, you can stop or terminate them. /// /// /// 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 ElasticLoadBalancingV2. /// /// The specified load balancer does not exist. /// /// /// This operation is not allowed. /// /// /// A specified resource is in use. /// /// REST API Reference for DeleteLoadBalancer Operation Task DeleteLoadBalancerAsync(DeleteLoadBalancerRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteRule /// /// Deletes the specified rule. /// /// /// /// You can't delete the default rule. /// /// /// Container for the necessary parameters to execute the DeleteRule service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteRule service method, as returned by ElasticLoadBalancingV2. /// /// This operation is not allowed. /// /// /// The specified rule does not exist. /// /// REST API Reference for DeleteRule Operation Task DeleteRuleAsync(DeleteRuleRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteTargetGroup /// /// Deletes the specified target group. /// /// /// /// You can delete a target group if it is not referenced by any actions. Deleting a target /// group also deletes any associated health checks. Deleting a target group does not /// affect its registered targets. For example, any EC2 instances continue to run until /// you stop or terminate them. /// /// /// Container for the necessary parameters to execute the DeleteTargetGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteTargetGroup service method, as returned by ElasticLoadBalancingV2. /// /// A specified resource is in use. /// /// REST API Reference for DeleteTargetGroup Operation Task DeleteTargetGroupAsync(DeleteTargetGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeregisterTargets /// /// Deregisters the specified targets from the specified target group. After the targets /// are deregistered, they no longer receive traffic from the load balancer. /// /// Container for the necessary parameters to execute the DeregisterTargets service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeregisterTargets service method, as returned by ElasticLoadBalancingV2. /// /// The specified target does not exist, is not in the same VPC as the target group, or /// has an unsupported instance type. /// /// /// The specified target group does not exist. /// /// REST API Reference for DeregisterTargets Operation Task DeregisterTargetsAsync(DeregisterTargetsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeAccountLimits /// /// Describes the current Elastic Load Balancing resource limits for your Amazon Web Services /// account. /// /// /// /// For more information, see the following: /// /// /// /// 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 ElasticLoadBalancingV2. /// REST API Reference for DescribeAccountLimits Operation Task DescribeAccountLimitsAsync(DescribeAccountLimitsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeListenerCertificates /// /// Describes the default certificate and the certificate list for the specified HTTPS /// or TLS listener. /// /// /// /// If the default certificate is also in the certificate list, it appears twice in the /// results (once with IsDefault set to true and once with IsDefault /// set to false). /// /// /// /// For more information, see SSL /// certificates in the Application Load Balancers Guide or Server /// certificates in the Network Load Balancers Guide. /// /// /// Container for the necessary parameters to execute the DescribeListenerCertificates service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeListenerCertificates service method, as returned by ElasticLoadBalancingV2. /// /// The specified listener does not exist. /// /// REST API Reference for DescribeListenerCertificates Operation Task DescribeListenerCertificatesAsync(DescribeListenerCertificatesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeListeners /// /// Describes the specified listeners or the listeners for the specified Application Load /// Balancer, Network Load Balancer, or Gateway Load Balancer. You must specify either /// a load balancer or one or more listeners. /// /// Container for the necessary parameters to execute the DescribeListeners service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeListeners service method, as returned by ElasticLoadBalancingV2. /// /// The specified listener does not exist. /// /// /// The specified load balancer does not exist. /// /// /// The specified protocol is not supported. /// /// REST API Reference for DescribeListeners Operation Task DescribeListenersAsync(DescribeListenersRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeLoadBalancerAttributes /// /// Describes the attributes for the specified Application Load Balancer, Network Load /// Balancer, or Gateway Load Balancer. /// /// /// /// For more information, see the following: /// /// /// /// 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 ElasticLoadBalancingV2. /// /// The specified load balancer does not exist. /// /// REST API Reference for DescribeLoadBalancerAttributes Operation Task DescribeLoadBalancerAttributesAsync(DescribeLoadBalancerAttributesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeLoadBalancers /// /// Describes the specified load balancers or 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 ElasticLoadBalancingV2. /// /// The specified load balancer does not exist. /// /// REST API Reference for DescribeLoadBalancers Operation Task DescribeLoadBalancersAsync(DescribeLoadBalancersRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeRules /// /// Describes the specified rules or the rules for the specified listener. You must specify /// either a listener or one or more rules. /// /// Container for the necessary parameters to execute the DescribeRules service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeRules service method, as returned by ElasticLoadBalancingV2. /// /// The specified listener does not exist. /// /// /// The specified rule does not exist. /// /// /// The specified protocol is not supported. /// /// REST API Reference for DescribeRules Operation Task DescribeRulesAsync(DescribeRulesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeSSLPolicies /// /// Describes the specified policies or all policies used for SSL negotiation. /// /// /// /// For more information, see Security /// policies in the Application Load Balancers Guide or Security /// policies in the Network Load Balancers Guide. /// /// /// Container for the necessary parameters to execute the DescribeSSLPolicies service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeSSLPolicies service method, as returned by ElasticLoadBalancingV2. /// /// The specified SSL policy does not exist. /// /// REST API Reference for DescribeSSLPolicies Operation Task DescribeSSLPoliciesAsync(DescribeSSLPoliciesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeTags /// /// Describes the tags for the specified Elastic Load Balancing resources. You can describe /// the tags for one or more Application Load Balancers, Network Load Balancers, Gateway /// Load Balancers, target groups, listeners, or rules. /// /// 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 ElasticLoadBalancingV2. /// /// The specified listener does not exist. /// /// /// The specified load balancer does not exist. /// /// /// The specified rule does not exist. /// /// /// The specified target group does not exist. /// /// REST API Reference for DescribeTags Operation Task DescribeTagsAsync(DescribeTagsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeTargetGroupAttributes /// /// Describes the attributes for the specified target group. /// /// /// /// For more information, see the following: /// /// /// /// Container for the necessary parameters to execute the DescribeTargetGroupAttributes service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeTargetGroupAttributes service method, as returned by ElasticLoadBalancingV2. /// /// The specified target group does not exist. /// /// REST API Reference for DescribeTargetGroupAttributes Operation Task DescribeTargetGroupAttributesAsync(DescribeTargetGroupAttributesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeTargetGroups /// /// Describes the specified target groups or all of your target groups. By default, all /// target groups are described. Alternatively, you can specify one of the following to /// filter the results: the ARN of the load balancer, the names of one or more target /// groups, or the ARNs of one or more target groups. /// /// Container for the necessary parameters to execute the DescribeTargetGroups service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeTargetGroups service method, as returned by ElasticLoadBalancingV2. /// /// The specified load balancer does not exist. /// /// /// The specified target group does not exist. /// /// REST API Reference for DescribeTargetGroups Operation Task DescribeTargetGroupsAsync(DescribeTargetGroupsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeTargetHealth /// /// Describes the health of the specified targets or all of your targets. /// /// Container for the necessary parameters to execute the DescribeTargetHealth service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeTargetHealth service method, as returned by ElasticLoadBalancingV2. /// /// The health of the specified targets could not be retrieved due to an internal error. /// /// /// The specified target does not exist, is not in the same VPC as the target group, or /// has an unsupported instance type. /// /// /// The specified target group does not exist. /// /// REST API Reference for DescribeTargetHealth Operation Task DescribeTargetHealthAsync(DescribeTargetHealthRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region ModifyListener /// /// Replaces the specified properties of the specified listener. Any properties that you /// do not specify remain unchanged. /// /// /// /// Changing the protocol from HTTPS to HTTP, or from TLS to TCP, removes the security /// policy and default certificate properties. If you change the protocol from HTTP to /// HTTPS, or from TCP to TLS, you must add the security policy and default certificate /// properties. /// /// /// /// To add an item to a list, remove an item from a list, or update an item in a list, /// you must provide the entire list. For example, to add an action, specify a list with /// the current actions plus the new action. /// /// /// Container for the necessary parameters to execute the ModifyListener service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ModifyListener service method, as returned by ElasticLoadBalancingV2. /// /// The specified ALPN policy is not supported. /// /// /// The specified certificate does not exist. /// /// /// A listener with the specified port already exists. /// /// /// The specified configuration is not valid with this protocol. /// /// /// The requested configuration is not valid. /// /// /// The requested action is not valid. /// /// /// The specified listener does not exist. /// /// /// The specified SSL policy does not exist. /// /// /// You've reached the limit on the number of load balancers per target group. /// /// /// The specified target group does not exist. /// /// /// You've reached the limit on the number of actions per rule. /// /// /// You've reached the limit on the number of certificates per load balancer. /// /// /// You've reached the limit on the number of listeners per load balancer. /// /// /// You've reached the limit on the number of times a target can be registered with a /// load balancer. /// /// /// You've reached the limit on the number of targets. /// /// /// You've reached the limit on the number of unique target groups per load balancer across /// all listeners. If a target group is used by multiple actions for a load balancer, /// it is counted as only one use. /// /// /// The specified protocol is not supported. /// /// REST API Reference for ModifyListener Operation Task ModifyListenerAsync(ModifyListenerRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region ModifyLoadBalancerAttributes /// /// Modifies the specified attributes of the specified Application Load Balancer, Network /// Load Balancer, or Gateway Load Balancer. /// /// /// /// If any of the specified attributes can't be modified as requested, the call fails. /// Any existing attributes that you do not modify retain their current values. /// /// /// 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 ElasticLoadBalancingV2. /// /// The requested configuration is not valid. /// /// /// The specified load balancer does not exist. /// /// REST API Reference for ModifyLoadBalancerAttributes Operation Task ModifyLoadBalancerAttributesAsync(ModifyLoadBalancerAttributesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region ModifyRule /// /// Replaces the specified properties of the specified rule. Any properties that you do /// not specify are unchanged. /// /// /// /// To add an item to a list, remove an item from a list, or update an item in a list, /// you must provide the entire list. For example, to add an action, specify a list with /// the current actions plus the new action. /// /// /// Container for the necessary parameters to execute the ModifyRule service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ModifyRule service method, as returned by ElasticLoadBalancingV2. /// /// The specified configuration is not valid with this protocol. /// /// /// The requested action is not valid. /// /// /// This operation is not allowed. /// /// /// The specified rule does not exist. /// /// /// You've reached the limit on the number of load balancers per target group. /// /// /// The specified target group does not exist. /// /// /// You've reached the limit on the number of actions per rule. /// /// /// You've reached the limit on the number of times a target can be registered with a /// load balancer. /// /// /// You've reached the limit on the number of targets. /// /// /// You've reached the limit on the number of unique target groups per load balancer across /// all listeners. If a target group is used by multiple actions for a load balancer, /// it is counted as only one use. /// /// /// The specified protocol is not supported. /// /// REST API Reference for ModifyRule Operation Task ModifyRuleAsync(ModifyRuleRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region ModifyTargetGroup /// /// Modifies the health checks used when evaluating the health state of the targets in /// the specified target group. /// /// Container for the necessary parameters to execute the ModifyTargetGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ModifyTargetGroup service method, as returned by ElasticLoadBalancingV2. /// /// The requested configuration is not valid. /// /// /// The specified target group does not exist. /// /// REST API Reference for ModifyTargetGroup Operation Task ModifyTargetGroupAsync(ModifyTargetGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region ModifyTargetGroupAttributes /// /// Modifies the specified attributes of the specified target group. /// /// Container for the necessary parameters to execute the ModifyTargetGroupAttributes service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ModifyTargetGroupAttributes service method, as returned by ElasticLoadBalancingV2. /// /// The requested configuration is not valid. /// /// /// The specified target group does not exist. /// /// REST API Reference for ModifyTargetGroupAttributes Operation Task ModifyTargetGroupAttributesAsync(ModifyTargetGroupAttributesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region RegisterTargets /// /// Registers the specified targets with the specified target group. /// /// /// /// If the target is an EC2 instance, it must be in the running state when /// you register it. /// /// /// /// By default, the load balancer routes requests to registered targets using the protocol /// and port for the target group. Alternatively, you can override the port for a target /// when you register it. You can register each EC2 instance or IP address with the same /// target group multiple times using different ports. /// /// /// /// With a Network Load Balancer, you cannot register instances by instance ID if they /// have the following instance types: C1, CC1, CC2, CG1, CG2, CR1, CS1, G1, G2, HI1, /// HS1, M1, M2, M3, and T1. You can register instances of these types by IP address. /// /// /// Container for the necessary parameters to execute the RegisterTargets service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the RegisterTargets service method, as returned by ElasticLoadBalancingV2. /// /// The specified target does not exist, is not in the same VPC as the target group, or /// has an unsupported instance type. /// /// /// The specified target group does not exist. /// /// /// You've reached the limit on the number of times a target can be registered with a /// load balancer. /// /// /// You've reached the limit on the number of targets. /// /// REST API Reference for RegisterTargets Operation Task RegisterTargetsAsync(RegisterTargetsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region RemoveListenerCertificates /// /// Removes the specified certificate from the certificate list for the specified HTTPS /// or TLS listener. /// /// Container for the necessary parameters to execute the RemoveListenerCertificates service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the RemoveListenerCertificates service method, as returned by ElasticLoadBalancingV2. /// /// The specified listener does not exist. /// /// /// This operation is not allowed. /// /// REST API Reference for RemoveListenerCertificates Operation Task RemoveListenerCertificatesAsync(RemoveListenerCertificatesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region RemoveTags /// /// Removes the specified tags from the specified Elastic Load Balancing resources. You /// can remove the tags for one or more Application Load Balancers, Network Load Balancers, /// Gateway Load Balancers, target groups, listeners, or rules. /// /// 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 ElasticLoadBalancingV2. /// /// The specified listener does not exist. /// /// /// The specified load balancer does not exist. /// /// /// The specified rule does not exist. /// /// /// The specified target group does not exist. /// /// /// You've reached the limit on the number of tags per load balancer. /// /// REST API Reference for RemoveTags Operation Task RemoveTagsAsync(RemoveTagsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region SetIpAddressType /// /// Sets the type of IP addresses used by the subnets of the specified load balancer. /// /// Container for the necessary parameters to execute the SetIpAddressType service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the SetIpAddressType service method, as returned by ElasticLoadBalancingV2. /// /// The requested configuration is not valid. /// /// /// The specified subnet is out of available addresses. /// /// /// The specified load balancer does not exist. /// /// REST API Reference for SetIpAddressType Operation Task SetIpAddressTypeAsync(SetIpAddressTypeRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region SetRulePriorities /// /// Sets the priorities of the specified rules. /// /// /// /// You can reorder the rules as long as there are no priority conflicts in the new order. /// Any existing rules that you do not specify retain their current priority. /// /// /// Container for the necessary parameters to execute the SetRulePriorities service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the SetRulePriorities service method, as returned by ElasticLoadBalancingV2. /// /// This operation is not allowed. /// /// /// The specified priority is in use. /// /// /// The specified rule does not exist. /// /// REST API Reference for SetRulePriorities Operation Task SetRulePrioritiesAsync(SetRulePrioritiesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region SetSecurityGroups /// /// Associates the specified security groups with the specified Application Load Balancer. /// The specified security groups override the previously associated security groups. /// /// /// /// You can't specify a security group for a Network Load Balancer or Gateway Load Balancer. /// /// /// Container for the necessary parameters to execute the SetSecurityGroups service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the SetSecurityGroups service method, as returned by ElasticLoadBalancingV2. /// /// The requested configuration is not valid. /// /// /// The specified security group does not exist. /// /// /// The specified load balancer does not exist. /// /// REST API Reference for SetSecurityGroups Operation Task SetSecurityGroupsAsync(SetSecurityGroupsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region SetSubnets /// /// Enables the Availability Zones for the specified public subnets for the specified /// Application Load Balancer or Network Load Balancer. The specified subnets replace /// the previously enabled subnets. /// /// /// /// When you specify subnets for a Network Load Balancer, you must include all subnets /// that were enabled previously, with their existing configurations, plus any additional /// subnets. /// /// /// Container for the necessary parameters to execute the SetSubnets service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the SetSubnets service method, as returned by ElasticLoadBalancingV2. /// /// The specified allocation ID does not exist. /// /// /// The specified Availability Zone is not supported. /// /// /// The requested configuration is not valid. /// /// /// The specified subnet is out of available addresses. /// /// /// The specified load balancer does not exist. /// /// /// The specified subnet does not exist. /// /// REST API Reference for SetSubnets Operation Task SetSubnetsAsync(SetSubnetsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion } }