aws_sdk_elasticloadbalancingv2/
lib.rs

1#![allow(deprecated)]
2#![allow(unknown_lints)]
3#![allow(clippy::module_inception)]
4#![allow(clippy::upper_case_acronyms)]
5#![allow(clippy::large_enum_variant)]
6#![allow(clippy::wrong_self_convention)]
7#![allow(clippy::should_implement_trait)]
8#![allow(clippy::disallowed_names)]
9#![allow(clippy::vec_init_then_push)]
10#![allow(clippy::type_complexity)]
11#![allow(clippy::needless_return)]
12#![allow(clippy::derive_partial_eq_without_eq)]
13#![allow(clippy::result_large_err)]
14#![allow(clippy::unnecessary_map_on_constructor)]
15#![allow(rustdoc::bare_urls)]
16#![allow(rustdoc::redundant_explicit_links)]
17#![allow(rustdoc::invalid_html_tags)]
18#![forbid(unsafe_code)]
19#![warn(missing_docs)]
20#![cfg_attr(docsrs, feature(doc_auto_cfg))]
21//! 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.
22//!
23//! 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:
24//!   - Application Load Balancer - Operates at the application layer (layer 7) and supports HTTP and HTTPS.
25//!   - Network Load Balancer - Operates at the transport layer (layer 4) and supports TCP, TLS, and UDP.
26//!   - Gateway Load Balancer - Operates at the network layer (layer 3).
27//!
28//! For more information, see the [Elastic Load Balancing User Guide](https://docs.aws.amazon.com/elasticloadbalancing/latest/userguide/).
29//!
30//! All Elastic Load Balancing operations are idempotent, which means that they complete at most one time. If you repeat an operation, it succeeds.
31//!
32//! ## Getting Started
33//!
34//! > Examples are available for many services and operations, check out the
35//! > [examples folder in GitHub](https://github.com/awslabs/aws-sdk-rust/tree/main/examples).
36//!
37//! The SDK provides one crate per AWS service. You must add [Tokio](https://crates.io/crates/tokio)
38//! as a dependency within your Rust project to execute asynchronous code. To add `aws-sdk-elasticloadbalancingv2` to
39//! your project, add the following to your **Cargo.toml** file:
40//!
41//! ```toml
42//! [dependencies]
43//! aws-config = { version = "1.1.7", features = ["behavior-version-latest"] }
44//! aws-sdk-elasticloadbalancingv2 = "1.84.0"
45//! tokio = { version = "1", features = ["full"] }
46//! ```
47//!
48//! Then in code, a client can be created with the following:
49//!
50//! ```rust,no_run
51//! use aws_sdk_elasticloadbalancingv2 as elasticloadbalancingv2;
52//!
53//! #[::tokio::main]
54//! async fn main() -> Result<(), elasticloadbalancingv2::Error> {
55//!     let config = aws_config::load_from_env().await;
56//!     let client = aws_sdk_elasticloadbalancingv2::Client::new(&config);
57//!
58//!     // ... make some calls with the client
59//!
60//!     Ok(())
61//! }
62//! ```
63//!
64//! See the [client documentation](https://docs.rs/aws-sdk-elasticloadbalancingv2/latest/aws_sdk_elasticloadbalancingv2/client/struct.Client.html)
65//! for information on what calls can be made, and the inputs and outputs for each of those calls.
66//!
67//! ## Using the SDK
68//!
69//! Until the SDK is released, we will be adding information about using the SDK to the
70//! [Developer Guide](https://docs.aws.amazon.com/sdk-for-rust/latest/dg/welcome.html). Feel free to suggest
71//! additional sections for the guide by opening an issue and describing what you are trying to do.
72//!
73//! ## Getting Help
74//!
75//! * [GitHub discussions](https://github.com/awslabs/aws-sdk-rust/discussions) - For ideas, RFCs & general questions
76//! * [GitHub issues](https://github.com/awslabs/aws-sdk-rust/issues/new/choose) - For bug reports & feature requests
77//! * [Generated Docs (latest version)](https://awslabs.github.io/aws-sdk-rust/)
78//! * [Usage examples](https://github.com/awslabs/aws-sdk-rust/tree/main/examples)
79//!
80//!
81//! # Crate Organization
82//!
83//! The entry point for most customers will be [`Client`], which exposes one method for each API
84//! offered by Elastic Load Balancing. The return value of each of these methods is a "fluent builder",
85//! where the different inputs for that API are added by builder-style function call chaining,
86//! followed by calling `send()` to get a [`Future`](std::future::Future) that will result in
87//! either a successful output or a [`SdkError`](crate::error::SdkError).
88//!
89//! Some of these API inputs may be structs or enums to provide more complex structured information.
90//! These structs and enums live in [`types`](crate::types). There are some simpler types for
91//! representing data such as date times or binary blobs that live in [`primitives`](crate::primitives).
92//!
93//! All types required to configure a client via the [`Config`](crate::Config) struct live
94//! in [`config`](crate::config).
95//!
96//! The [`operation`](crate::operation) module has a submodule for every API, and in each submodule
97//! is the input, output, and error type for that API, as well as builders to construct each of those.
98//!
99//! There is a top-level [`Error`](crate::Error) type that encompasses all the errors that the
100//! client can return. Any other error type can be converted to this `Error` type via the
101//! [`From`](std::convert::From) trait.
102//!
103//! The other modules within this crate are not required for normal usage.
104
105// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
106pub use error_meta::Error;
107
108#[doc(inline)]
109pub use config::Config;
110
111/// Client for calling Elastic Load Balancing.
112/// ## Constructing a `Client`
113///
114/// A [`Config`] is required to construct a client. For most use cases, the [`aws-config`]
115/// crate should be used to automatically resolve this config using
116/// [`aws_config::load_from_env()`], since this will resolve an [`SdkConfig`] which can be shared
117/// across multiple different AWS SDK clients. This config resolution process can be customized
118/// by calling [`aws_config::from_env()`] instead, which returns a [`ConfigLoader`] that uses
119/// the [builder pattern] to customize the default config.
120///
121/// In the simplest case, creating a client looks as follows:
122/// ```rust,no_run
123/// # async fn wrapper() {
124/// let config = aws_config::load_from_env().await;
125/// let client = aws_sdk_elasticloadbalancingv2::Client::new(&config);
126/// # }
127/// ```
128///
129/// Occasionally, SDKs may have additional service-specific values that can be set on the [`Config`] that
130/// is absent from [`SdkConfig`], or slightly different settings for a specific client may be desired.
131/// The [`Builder`](crate::config::Builder) struct implements `From<&SdkConfig>`, so setting these specific settings can be
132/// done as follows:
133///
134/// ```rust,no_run
135/// # async fn wrapper() {
136/// let sdk_config = ::aws_config::load_from_env().await;
137/// let config = aws_sdk_elasticloadbalancingv2::config::Builder::from(&sdk_config)
138/// # /*
139///     .some_service_specific_setting("value")
140/// # */
141///     .build();
142/// # }
143/// ```
144///
145/// See the [`aws-config` docs] and [`Config`] for more information on customizing configuration.
146///
147/// _Note:_ Client construction is expensive due to connection thread pool initialization, and should
148/// be done once at application start-up.
149///
150/// [`Config`]: crate::Config
151/// [`ConfigLoader`]: https://docs.rs/aws-config/*/aws_config/struct.ConfigLoader.html
152/// [`SdkConfig`]: https://docs.rs/aws-config/*/aws_config/struct.SdkConfig.html
153/// [`aws-config` docs]: https://docs.rs/aws-config/*
154/// [`aws-config`]: https://crates.io/crates/aws-config
155/// [`aws_config::from_env()`]: https://docs.rs/aws-config/*/aws_config/fn.from_env.html
156/// [`aws_config::load_from_env()`]: https://docs.rs/aws-config/*/aws_config/fn.load_from_env.html
157/// [builder pattern]: https://rust-lang.github.io/api-guidelines/type-safety.html#builders-enable-construction-of-complex-values-c-builder
158/// # Using the `Client`
159///
160/// A client has a function for every operation that can be performed by the service.
161/// For example, the [`AddListenerCertificates`](crate::operation::add_listener_certificates) operation has
162/// a [`Client::add_listener_certificates`], function which returns a builder for that operation.
163/// The fluent builder ultimately has a `send()` function that returns an async future that
164/// returns a result, as illustrated below:
165///
166/// ```rust,ignore
167/// let result = client.add_listener_certificates()
168///     .listener_arn("example")
169///     .send()
170///     .await;
171/// ```
172///
173/// The underlying HTTP requests that get made by this can be modified with the `customize_operation`
174/// function on the fluent builder. See the [`customize`](crate::client::customize) module for more
175/// information.
176/// # Waiters
177///
178/// This client provides `wait_until` methods behind the [`Waiters`](crate::client::Waiters) trait.
179/// To use them, simply import the trait, and then call one of the `wait_until` methods. This will
180/// return a waiter fluent builder that takes various parameters, which are documented on the builder
181/// type. Once parameters have been provided, the `wait` method can be called to initiate waiting.
182///
183/// For example, if there was a `wait_until_thing` method, it could look like:
184/// ```rust,ignore
185/// let result = client.wait_until_thing()
186///     .thing_id("someId")
187///     .wait(Duration::from_secs(120))
188///     .await;
189/// ```
190pub mod client;
191
192/// Configuration for Elastic Load Balancing.
193pub mod config;
194
195/// Common errors and error handling utilities.
196pub mod error;
197
198mod error_meta;
199
200/// Information about this crate.
201pub mod meta;
202
203/// All operations that this crate can perform.
204pub mod operation;
205
206/// Primitives such as `Blob` or `DateTime` used by other types.
207pub mod primitives;
208
209/// Data structures used by operation inputs/outputs.
210pub mod types;
211
212mod auth_plugin;
213
214pub(crate) mod protocol_serde;
215
216mod sdk_feature_tracker;
217
218mod serialization_settings;
219
220mod endpoint_lib;
221
222mod lens;
223
224/// Supporting types for waiters.
225///
226/// Note: to use waiters, import the [`Waiters`](crate::client::Waiters) trait, which adds methods prefixed with `wait_until` to the client.
227pub mod waiters;
228
229mod rest_xml_wrapped_errors;
230
231mod serde_util;
232
233#[doc(inline)]
234pub use client::Client;