@spec add_listener_certificates(listener_arn(), certificates()) ::
  ExAws.Operation.Query.t()

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.

To list the certificates for your listener, use describe_listener_certificates/1. To remove certificates from your listener, use remove_listener_certificates/2.

Examples:

iex> certificates = [
...>   %{certificate_arn: "certificate1_arn", is_default: true},
...>   %{certificate_arn: "certificate2_arn"}
...> ]
[
  %{certificate_arn: "certificate1_arn", is_default: true},
  %{certificate_arn: "certificate2_arn"}
]
iex> ExAws.ElasticLoadBalancingV2.add_listener_certificates("listener_arn", certificates)
%ExAws.Operation.Query{
  path: "/",
  params: %{
    "Action" => "AddListenerCertificates",
    "Certificates.member.1.CertificateArn" => "certificate1_arn",
    "Certificates.member.1.IsDefault" => true,
    "Certificates.member.2.CertificateArn" => "certificate2_arn",
    "ListenerArn" => "listener_arn",
    "Version" => "2015-12-01"
  },
  content_encoding: "identity",
  service: :elasticloadbalancing,
  action: :add_listener_certificates,
  parser: &ExAws.ElasticLoadBalancingV2.Parsers.parse/2
}

@spec add_tags(resource_arns(), tags()) :: ExAws.Operation.Query.t()

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, trust stores, listeners, and rules.

Each tag consists of a key and an optional value. If a resource already has a tag with the same key, add_tags/2 updates its value.

To list the current tags for your resources, use describe_tags/1. To remove tags from your resources, use remove_tags/2.

Examples:

iex> tags = [%{key: "hello", value: "test"}, %{key: "foo", value: "bar"}]
iex> ExAws.ElasticLoadBalancingV2.add_tags(["resource_arn1", "resource_arn2"], tags)
%ExAws.Operation.Query{
  path: "/",
  params: %{
    "Action" => "AddTags",
    "ResourceArns.member.1" => "resource_arn1",
    "ResourceArns.member.2" => "resource_arn2",
    "Tags.member.1.Key" => "hello",
    "Tags.member.1.Value" => "test",
    "Tags.member.2.Key" => "foo",
    "Tags.member.2.Value" => "bar",
    "Version" => "2015-12-01"
  },
  content_encoding: "identity",
  service: :elasticloadbalancing,
  action: :add_tags,
  parser: &ExAws.ElasticLoadBalancingV2.Parsers.parse/2
}

iex> tags = [hello: "test", foo: "bar"]
iex> ExAws.ElasticLoadBalancingV2.add_tags(["resource_arn1", "resource_arn2"], tags)
%ExAws.Operation.Query{
  path: "/",
  params: %{
    "Action" => "AddTags",
    "ResourceArns.member.1" => "resource_arn1",
    "ResourceArns.member.2" => "resource_arn2",
    "Tags.member.1.Key" => "hello",
    "Tags.member.1.Value" => "test",
    "Tags.member.2.Key" => "foo",
    "Tags.member.2.Value" => "bar",
    "Version" => "2015-12-01"
  },
  content_encoding: "identity",
  service: :elasticloadbalancing,
  action: :add_tags,
  parser: &ExAws.ElasticLoadBalancingV2.Parsers.parse/2
}

@spec add_trust_store_revocations(
  trust_store_arn(),
  add_trust_store_revocations_opts()
) ::
  ExAws.Operation.Query.t()

Adds the specified revocation file to the specified trust store.

Examples:

iex> revocation1 = %{revocation_type: "CRL", s3_bucket: "test_bucket"}
iex> revocation2 = %{revocation_type: "CRL", s3_bucket: "test_bucket2"}
iex> opts = [{:revocation_contents, [revocation1, revocation2]}]
iex> trust_store_arn = "trust_store_arn"
iex> ExAws.ElasticLoadBalancingV2.add_trust_store_revocations(trust_store_arn, opts)
%ExAws.Operation.Query{
        action: :add_trust_store_revocations,
        content_encoding: "identity",
        params: %{
          "Action" => "AddTrustStoreRevocations",
          "RevocationContents.member.1.RevocationType" => "CRL",
          "RevocationContents.member.1.S3Bucket" => "test_bucket",
          "RevocationContents.member.2.RevocationType" => "CRL",
          "RevocationContents.member.2.S3Bucket" => "test_bucket2",
          "TrustStoreArn" => "trust_store_arn",
          "Version" => "2015-12-01"
        },
        parser: &ExAws.ElasticLoadBalancingV2.Parsers.parse/2,
        path: "/",
        service: :elasticloadbalancing
      }

@spec create_listener(load_balancer_arn(), [action(), ...], create_listener_opts()) ::
  ExAws.Operation.Query.t()

Creates a listener for the specified Application Load Balancer or Network Load Balancer.

You can create up to 10 listeners per load balancer.

To update a listener, use modify_listener/1. When you are finished with a listener, you can delete it using delete_listener/1. If you are finished with both the listener and the load balancer, you can delete them both using delete_load_balancer/1.

More information:

• Listeners for Your Application Load Balancers in the Application Load Balancers Guide
• Listeners for Your Network Load Balancers in the Network Load Balancers Guide
• This function replaces the deprecated create_listener/5 function and moves all optional parameters to the opts argument.

Examples:

iex> default_actions = [%{type: "forward", target_group_arn: "target_arn"}]
iex> load_balancer_arn = "load_balancer_arn"
iex> opts = [protocol: "HTTP", port: 80,
...>         alpn_policy: ["HTTP1Only"],
...>         mutual_authentication: %{trust_store_arn: "trust_store_arn"}]
iex> ExAws.ElasticLoadBalancingV2.create_listener(load_balancer_arn, default_actions, opts)
%ExAws.Operation.Query{
  path: "/",
  params: %{
    "Action" => "CreateListener",
    "AlpnPolicy.member.1" => "HTTP1Only",
    "DefaultActions.member.1.TargetGroupArn" => "target_arn",
    "DefaultActions.member.1.Type" => "forward",
    "LoadBalancerArn" => "load_balancer_arn",
    "MutualAuthentication.TrustStoreArn" => "trust_store_arn",
    "Port" => 80,
    "Protocol" => "HTTP",
    "Version" => "2015-12-01"
  },
  content_encoding: "identity",
  service: :elasticloadbalancing,
  action: :create_listener,
  parser: &ExAws.ElasticLoadBalancingV2.Parsers.parse/2
}
iex> opts = %{protocol: "HTTP", port: 80}
iex> ExAws.ElasticLoadBalancingV2.create_listener(load_balancer_arn, default_actions, opts)
%ExAws.Operation.Query{
  path: "/",
  params: %{
    "Action" => "CreateListener",
    "DefaultActions.member.1.TargetGroupArn" => "target_arn",
    "DefaultActions.member.1.Type" => "forward",
    "LoadBalancerArn" => "load_balancer_arn",
    "Port" => 80,
    "Protocol" => "HTTP",
    "Version" => "2015-12-01"
  },
  content_encoding: "identity",
  service: :elasticloadbalancing,
  action: :create_listener,
  parser: &ExAws.ElasticLoadBalancingV2.Parsers.parse/2
}

@spec create_listener(
  load_balancer_arn(),
  protocol(),
  port_num(),
  [action(), ...],
  deprecated_create_listener_opts()
) :: ExAws.Operation.Query.t()

Creates a listener for the specified Application Load Balancer

Examples:

iex> default_actions = [%{type: "forward", target_group_arn: "target_arn"}]
iex> protocol = "HTTP"
iex> port = 80
iex> ExAws.ElasticLoadBalancingV2.create_listener("load_balancer_arn", protocol, port, default_actions)
%ExAws.Operation.Query{
  path: "/",
  params: %{
    "Action" => "CreateListener",
    "DefaultActions.member.1.TargetGroupArn" => "target_arn",
    "DefaultActions.member.1.Type" => "forward",
    "LoadBalancerArn" => "load_balancer_arn",
    "Port" => 80,
    "Protocol" => "HTTP",
    "Version" => "2015-12-01"
  },
  content_encoding: "identity",
  service: :elasticloadbalancing,
  action: :create_listener,
  parser: &ExAws.ElasticLoadBalancingV2.Parsers.parse/2
}

@spec create_load_balancer(load_balancer_name(), create_load_balancer_opts()) ::
  ExAws.Operation.Query.t()

Creates an Application Load Balancer or a Network Load Balancer.

When you create a load balancer, you can specify security groups, subnets, IP address type, and tags. Otherwise, you could do so later using set_security_groups/3, set_subnets/3, set_ip_address_type/2, and add_tags/2.

To create listeners for your load balancer, use create_listener/3. To describe your current load balancers, see describe_load_balancers/1. When you are finished with a load balancer, you can delete it using delete_load_balancer/1.

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 the following:

• Application Load Balancers
• Network Load Balancers
• Gateway Load Balancers

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.

Examples:

iex> ExAws.ElasticLoadBalancingV2.create_load_balancer("Loader")
%ExAws.Operation.Query{
  path: "/",
  params: %{
    "Action" => "CreateLoadBalancer",
    "Name" => "Loader",
    "Version" => "2015-12-01"
  },
  content_encoding: "identity",
  service: :elasticloadbalancing,
  action: :create_load_balancer,
  parser: &ExAws.ElasticLoadBalancingV2.Parsers.parse/2
}

iex> opts = [
...> scheme: "internet-facing",
...> subnet_mappings: [
...>   %{subnet_id: "1.2.3.4", allocation_id: "i2234342"}
...> ],
...> subnets: ["1.2.3.4", "5.6.7.8"],
...> security_groups: ["Secure123", "Secure456"],
...> type: "application", ip_address_type: "ipv4"]
iex> ExAws.ElasticLoadBalancingV2.create_load_balancer("Loader", opts)
%ExAws.Operation.Query{
  path: "/",
  params: %{
    "Action" => "CreateLoadBalancer",
    "IpAddressType" => "ipv4",
    "Name" => "Loader",
    "Scheme" => "internet-facing",
    "SecurityGroups.member.1" => "Secure123",
    "SecurityGroups.member.2" => "Secure456",
    "SubnetMappings.member.1.AllocationId" => "i2234342",
    "SubnetMappings.member.1.SubnetId" => "1.2.3.4",
    "Subnets.member.1" => "1.2.3.4",
    "Subnets.member.2" => "5.6.7.8",
    "Type" => "application",
    "Version" => "2015-12-01"
  },
  content_encoding: "identity",
  service: :elasticloadbalancing,
  action: :create_load_balancer,
  parser: &ExAws.ElasticLoadBalancingV2.Parsers.parse/2
}

@spec create_rule(
  listener_arn(),
  conditions(),
  priority(),
  actions(),
  create_rule_opts()
) ::
  ExAws.Operation.Query.t()

Creates a rule for the specified listener.

The listener must be associated with an Application Load Balancer. Rules are evaluated in priority order, from the lowest value to the highest value. When the condition for a rule is met, the specified action is taken. If no conditions are met, the action for the default rule is taken.

More information:

• Listener Rules Application Load Balancers Guide

To view your current rules, use describe_rules/1. To update a rule, use modify_rule/1. To set the priorities of your rules, use set_rule_priorities/1. To delete a rule, use delete_rule/1.

Examples

iex> conditions = [%{field: "path-pattern", values: ["/images/*", "/videos/*"]}]
iex> actions = [%{type: "forward", target_group_arn: "target_arn"}]
iex> priority = 10
iex> listener_arn = "arn:aws:test_arn"
iex> ExAws.ElasticLoadBalancingV2.create_rule(listener_arn, conditions, priority, actions)
%ExAws.Operation.Query{
  path: "/",
  params: %{
    "Action" => "CreateRule",
    "Actions.member.1.TargetGroupArn" => "target_arn",
    "Actions.member.1.Type" => "forward",
    "Conditions.member.1.Field" => "path-pattern",
    "Conditions.member.1.Values.member.1" => "/images/*",
    "Conditions.member.1.Values.member.2" => "/videos/*",
    "ListenerArn" => "arn:aws:test_arn",
    "Priority" => 10,
    "Version" => "2015-12-01"
  },
  content_encoding: "identity",
  service: :elasticloadbalancing,
  action: :create_rule,
  parser: &ExAws.ElasticLoadBalancingV2.Parsers.parse/2
}

@spec create_target_group(target_group_name(), create_target_group_opts()) ::
  ExAws.Operation.Query.t()

Creates a target group.

To register targets with the target group, use register_targets/2. To update the health check settings for the target group, use modify_target_group/1. To monitor the health of targets in the target group, use describe_target_health/1. To route traffic to the targets in a target group, specify the target group in an action using create_listener/3 or create_rule/5. To delete a target group, use delete_target_group/1.

More information:

• Target Groups for Your Application Load Balancers
• Target Groups for Your Network Load Balancers
• Target groups for your Gateway Load Balancers

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.

Examples:

iex> opts = [protocol: "HTTP", port: 80, health_check_path: "/health", vpc_id: "vpc_id"]
iex> ExAws.ElasticLoadBalancingV2.create_target_group("target_group_name", opts)
%ExAws.Operation.Query{
  path: "/",
  params: %{
    "Action" => "CreateTargetGroup",
    "HealthCheckPath" => "/health",
    "Name" => "target_group_name",
    "Port" => 80,
    "Protocol" => "HTTP",
    "Version" => "2015-12-01",
    "VpcId" => "vpc_id"
  },
  content_encoding: "identity",
  service: :elasticloadbalancing,
  action: :create_target_group,
  parser: &ExAws.ElasticLoadBalancingV2.Parsers.parse/2
}
iex> # Demonstrate passing opts as a map
iex> opts = %{protocol: "HTTP", port: 80, health_check_path: "/health", vpc_id: "vpc_id"}
iex> ExAws.ElasticLoadBalancingV2.create_target_group("target_group_name", opts)
%ExAws.Operation.Query{
  path: "/",
  params: %{
    "Action" => "CreateTargetGroup",
    "HealthCheckPath" => "/health",
    "Name" => "target_group_name",
    "Port" => 80,
    "Protocol" => "HTTP",
    "Version" => "2015-12-01",
    "VpcId" => "vpc_id"
  },
  content_encoding: "identity",
  service: :elasticloadbalancing,
  action: :create_target_group,
  parser: &ExAws.ElasticLoadBalancingV2.Parsers.parse/2
}

@spec create_trust_store(
  trust_store_name(),
  ca_certificates_bundle_s3_bucket(),
  ca_certificates_bundle_s3_key(),
  create_trust_store_opts()
) :: ExAws.Operation.Query.t()

Creates a trust store.

For more information, see Mutual TLS for Application Load Balancers.

Examples:

iex> trust_store_name = "my-trust-store"
iex> ca_certificates_bundle_s3_bucket = "amzn-s3-demo-bucket"
iex> ca_certificates_bundle_s3_key = "CACertBundle.pem"
iex> ExAws.ElasticLoadBalancingV2.create_trust_store(trust_store_name, ca_certificates_bundle_s3_bucket, ca_certificates_bundle_s3_key)
%ExAws.Operation.Query{
  path: "/",
  params: %{
    "Action" => "CreateTrustStore",
    "CaCertificatesBundleS3Bucket" => "amzn-s3-demo-bucket",
    "CaCertificatesBundleS3Key" => "CACertBundle.pem",
    "TrustStoreName" => "my-trust-store",
    "Version" => "2015-12-01"
  },
  content_encoding: "identity",
  service: :elasticloadbalancing,
  action: :create_trust_store,
  parser: &ExAws.ElasticLoadBalancingV2.Parsers.parse/2
}

@spec delete_listener(listener_arn()) :: ExAws.Operation.Query.t()

Deletes the specified listener.

Alternatively, your listener is deleted when you delete the load balancer it is attached to using delete_load_balancer/1.

Examples:

  iex> ExAws.ElasticLoadBalancingV2.delete_listener("listener_arn")
  %ExAws.Operation.Query{
    path: "/",
    params: %{
      "Action" => "DeleteListener",
      "ListenerArn" => "listener_arn",
      "Version" => "2015-12-01"
    },
    content_encoding: "identity",
    service: :elasticloadbalancing,
    action: :delete_listener,
    parser: &ExAws.ElasticLoadBalancingV2.Parsers.parse/2
  }

@spec delete_load_balancer(load_balancer_arn()) :: ExAws.Operation.Query.t()

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.

Examples:

  iex> ExAws.ElasticLoadBalancingV2.delete_load_balancer("load_balancer_arn")
  %ExAws.Operation.Query{
    path: "/",
    params: %{
      "Action" => "DeleteLoadBalancer",
      "LoadBalancerArn" => "load_balancer_arn",
      "Version" => "2015-12-01"
    },
    content_encoding: "identity",
    service: :elasticloadbalancing,
    action: :delete_load_balancer,
    parser: &ExAws.ElasticLoadBalancingV2.Parsers.parse/2
  }

@spec delete_rule(rule_arn()) :: ExAws.Operation.Query.t()

Deletes the specified rule

You can't delete the default rule.

Examples:

  iex> ExAws.ElasticLoadBalancingV2.delete_rule("rule_arn")
  %ExAws.Operation.Query{
    path: "/",
    params: %{
      "Action" => "DeleteRule",
      "RuleArn" => "rule_arn",
      "Version" => "2015-12-01"
    },
    content_encoding: "identity",
    service: :elasticloadbalancing,
    action: :delete_rule,
    parser: &ExAws.ElasticLoadBalancingV2.Parsers.parse/2
  }

@spec delete_shared_trust_store_association(resource_arn(), trust_store_arn()) ::
  ExAws.Operation.Query.t()

Deletes a shared trust store association

Examples:

  iex> ExAws.ElasticLoadBalancingV2.delete_shared_trust_store_association("resource_arn", "trust_store_arn")
  %ExAws.Operation.Query{
    path: "/",
    params: %{
      "Action" => "DeleteSharedTrustStoreAssociation",
      "ResourceArn" => "resource_arn",
      "TrustStoreArn" => "trust_store_arn",
      "Version" => "2015-12-01"
    },
    content_encoding: "identity",
    service: :elasticloadbalancing,
    action: :delete_shared_trust_store_association,
    parser: &ExAws.ElasticLoadBalancingV2.Parsers.parse/2
  }

@spec delete_target_group(target_group_arn()) :: ExAws.Operation.Query.t()

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.

Examples:

  iex> ExAws.ElasticLoadBalancingV2.delete_target_group("target_group_arn")
  %ExAws.Operation.Query{
    path: "/",
    params: %{
      "Action" => "DeleteTargetGroup",
      "TargetGroupArn" => "target_group_arn",
      "Version" => "2015-12-01"
    },
    content_encoding: "identity",
    service: :elasticloadbalancing,
    action: :delete_target_group,
    parser: &ExAws.ElasticLoadBalancingV2.Parsers.parse/2
  }

Deletes the specified trust store.

Examples:

  iex> ExAws.ElasticLoadBalancingV2.delete_trust_store("trust_store_arn")
  %ExAws.Operation.Query{
    path: "/",
    params: %{
      "Action" => "DeleteTrustStore",
      "TrustStoreArn" => "trust_store_arn",
      "Version" => "2015-12-01"
    },
    content_encoding: "identity",
    service: :elasticloadbalancing,
    action: :delete_trust_store,
    parser: &ExAws.ElasticLoadBalancingV2.Parsers.parse/2
  }

@spec deregister_targets(target_group_arn(), target_descriptions()) ::
  ExAws.Operation.Query.t()

Deregisters the specified targets from the specified target group

After the targets are deregistered, they no longer receive traffic from the load balancer.

The load balancer stops sending requests to targets that are deregistering, but uses connection draining to ensure that in-flight traffic completes on the existing connections. This deregistration delay is configured by default but can be updated for each target group.

For more information, see the following:

• Deregistration delay in the Application Load Balancers User Guide
• Deregistration delay in the Network Load Balancers User Guide
• Deregistration delay in the Gateway Load Balancers User Guide

Note: If the specified target does not exist, the action returns successfully.

Examples:

  iex>  targets = [%{id: "test"}, %{id: "test2", port: 8088, availability_zone: "us-east-1"}]
  [%{id: "test"}, %{id: "test2", port: 8088, availability_zone: "us-east-1"}]
  iex> ExAws.ElasticLoadBalancingV2.deregister_targets("target_group_arn", targets)
  %ExAws.Operation.Query{
    path: "/",
    params: %{
      "Action" => "DeregisterTargets",
      "TargetGroupArn" => "target_group_arn",
      "Targets.member.1.Id" => "test",
      "Targets.member.2.AvailabilityZone" => "us-east-1",
      "Targets.member.2.Id" => "test2",
      "Targets.member.2.Port" => 8088,
      "Version" => "2015-12-01"
    },
    content_encoding: "identity",
    service: :elasticloadbalancing,
    action: :deregister_targets,
    parser: &ExAws.ElasticLoadBalancingV2.Parsers.parse/2
  }

  iex> ExAws.ElasticLoadBalancingV2.deregister_targets("target_group_arn", [%{id: "i-0f76fade435676abd"}])
  %ExAws.Operation.Query{
    path: "/",
    params: %{
      "Action" => "DeregisterTargets",
      "TargetGroupArn" => "target_group_arn",
      "Targets.member.1.Id" => "i-0f76fade435676abd",
      "Version" => "2015-12-01"
    },
    content_encoding: "identity",
    service: :elasticloadbalancing,
    action: :deregister_targets,
    parser: &ExAws.ElasticLoadBalancingV2.Parsers.parse/2
  }

@spec describe_account_limits(describe_account_limits_opts()) ::
  ExAws.Operation.Query.t()

Describes the current Elastic Load Balancing resource limits for your AWS account.

For more information, see the following:

• Quotas for your Application Load Balancers
• Quotas for your Network Load Balancers
• Quotas for your Gateway Load Balancers

Examples:

  iex> ExAws.ElasticLoadBalancingV2.describe_account_limits()
  %ExAws.Operation.Query{
    path: "/",
    params: %{"Action" => "DescribeAccountLimits", "Version" => "2015-12-01"},
    content_encoding: "identity",
    service: :elasticloadbalancing,
    action: :describe_account_limits,
    parser: &ExAws.ElasticLoadBalancingV2.Parsers.parse/2
  }

Describes the capacity reservation status for the specified load balancer.

Examples:

  iex> ExAws.ElasticLoadBalancingV2.describe_capacity_reservation("load_balancer_arn")
  %ExAws.Operation.Query{
    path: "/",
    params: %{
      "Action" => "DescribeCapacityReservation",
      "LoadBalancerArn" => "load_balancer_arn",
      "Version" => "2015-12-01"
    },
    content_encoding: "identity",
    service: :elasticloadbalancing,
    action: :describe_capacity_reservation,
    parser: &ExAws.ElasticLoadBalancingV2.Parsers.parse/2
  }

Describes the attributes for the specified listener

Examples:

  iex> ExAws.ElasticLoadBalancingV2.describe_listener_attributes("listener_arn")
  %ExAws.Operation.Query{
    path: "/",
    params: %{
      "Action" => "DescribeListenerAttributes",
      "ListenerArn" => "listener_arn",
      "Version" => "2015-12-01"
    },
    content_encoding: "identity",
    service: :elasticloadbalancing,
    action: :describe_listener_attributes,
    parser: &ExAws.ElasticLoadBalancingV2.Parsers.parse/2
  }

@spec describe_listener_certificates(
  listener_arn(),
  describe_listener_certificates_opts()
) ::
  ExAws.Operation.Query.t()

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 is_default set to true and once with is_default set to false).

For more information, see SSL certificates in the Application Load Balancers Guide or Server certificates in the Network Load Balancers Guide.

Examples:

  iex> ExAws.ElasticLoadBalancingV2.describe_listener_certificates("listener_arn")
  %ExAws.Operation.Query{
    path: "/",
    params: %{
      "Action" => "DescribeListenerCertificates",
      "ListenerArn" => "listener_arn",
      "Version" => "2015-12-01"
    },
    content_encoding: "identity",
    service: :elasticloadbalancing,
    action: :describe_listener_certificates,
    parser: &ExAws.ElasticLoadBalancingV2.Parsers.parse/2
  }

@spec describe_listeners(describe_listeners_opts()) :: ExAws.Operation.Query.t()

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.

For an HTTPS or TLS listener, the output includes the default certificate for the listener. To describe the certificate list for the listener, use describe_listener_certificates/2.

Example

iex> ExAws.ElasticLoadBalancingV2.describe_listeners()
%ExAws.Operation.Query{
  path: "/",
  params: %{"Action" => "DescribeListeners", "Version" => "2015-12-01"},
  content_encoding: "identity",
  service: :elasticloadbalancing,
  action: :describe_listeners,
  parser: &ExAws.ElasticLoadBalancingV2.Parsers.parse/2
}

@spec describe_load_balancer_attributes(load_balancer_arn()) ::
  ExAws.Operation.Query.t()

Describes the attributes for the specified Application Load Balancer, Network Load Balancer, or Gateway Load Balancer.

For more information, see the following:

• Load balancer attributes in the Application Load Balancers Guide
• Load balancer attributes in the Network Load Balancers Guide
• Load balancer attributes in the Gateway Load Balancers Guide

Examples:

  iex> ExAws.ElasticLoadBalancingV2.describe_load_balancer_attributes("load_balancer_arn")
  %ExAws.Operation.Query{
    path: "/",
    params: %{
      "Action" => "DescribeLoadBalancerAttributes",
      "LoadBalancerArn" => "load_balancer_arn",
      "Version" => "2015-12-01"
    },
    content_encoding: "identity",
    service: :elasticloadbalancing,
    action: :describe_load_balancer_attributes,
    parser: &ExAws.ElasticLoadBalancingV2.Parsers.parse/2
  }

@spec describe_load_balancers(describe_load_balancers_opts()) ::
  ExAws.Operation.Query.t()

Describes the specified load balancers or all of your load balancers.

To describe the listeners for a load balancer, use describe_listeners/1. To describe the attributes for a load balancer, use describe_load_balancer_attributes/1.

Examples:

iex> # Describe all load balancers
iex> ExAws.ElasticLoadBalancingV2.describe_load_balancers()
%ExAws.Operation.Query{
  path: "/",
  params: %{"Action" => "DescribeLoadBalancers", "Version" => "2015-12-01"},
  content_encoding: "identity",
  service: :elasticloadbalancing,
  action: :describe_load_balancers,
  parser: &ExAws.ElasticLoadBalancingV2.Parsers.parse/2
}

@spec describe_rules(describe_rules_opts()) :: ExAws.Operation.Query.t()

Describes the specified rules or the rules for the specified listener.

You must specify either a listener or one or more rules.

Examples:

iex> ExAws.ElasticLoadBalancingV2.describe_rules()
%ExAws.Operation.Query{
  path: "/",
  params: %{"Action" => "DescribeRules", "Version" => "2015-12-01"},
  content_encoding: "identity",
  service: :elasticloadbalancing,
  action: :describe_rules,
  parser: &ExAws.ElasticLoadBalancingV2.Parsers.parse/2
}

iex> ExAws.ElasticLoadBalancingV2.describe_rules([listener_arn: "listener_arn", rule_arns: ["rule_arns"]])
%ExAws.Operation.Query{
  path: "/",
  params: %{
    "Action" => "DescribeRules",
    "ListenerArn" => "listener_arn",
    "RuleArns.member.1" => "rule_arns",
    "Version" => "2015-12-01"
  },
  content_encoding: "identity",
  service: :elasticloadbalancing,
  action: :describe_rules,
  parser: &ExAws.ElasticLoadBalancingV2.Parsers.parse/2
}

@spec describe_ssl_policies(describe_ssl_policies_opts()) :: ExAws.Operation.Query.t()

Describes the specified policies or all policies used for SSL negotiation.

For more information, see:

• Security policies in the Application Load Balancers Guide
• Security policies in the Network Load Balancers Guide.

Examples:

iex> ExAws.ElasticLoadBalancingV2.describe_ssl_policies()
%ExAws.Operation.Query{
  path: "/",
  params: %{"Action" => "DescribeSslPolicies", "Version" => "2015-12-01"},
  content_encoding: "identity",
  service: :elasticloadbalancing,
  action: :describe_ssl_policies,
  parser: &ExAws.ElasticLoadBalancingV2.Parsers.parse/2
}

iex> ExAws.ElasticLoadBalancingV2.describe_ssl_policies([ssl_policy_names: ["policy1", "policy2"]])
%ExAws.Operation.Query{
  path: "/",
  params: %{
    "Action" => "DescribeSslPolicies",
    "Names.member.1" => "policy1",
    "Names.member.2" => "policy2",
    "Version" => "2015-12-01"
  },
  content_encoding: "identity",
  service: :elasticloadbalancing,
  action: :describe_ssl_policies,
  parser: &ExAws.ElasticLoadBalancingV2.Parsers.parse/2
}