Struct aws_config::ConfigLoader

pub struct ConfigLoader { /* private fields */ }

Load default sources for all configuration with override support Load a cross-service SdkConfig from the environment

This builder supports overriding individual components of the generated config. Overriding a component will skip the standard resolution chain from for that component. For example, if you override the region provider, even if that provider returns None, the default region provider chain will not be used.

Implementations

impl ConfigLoader

pub fn region(self, region: impl ProvideRegion + 'static) -> Self

Override the region used to build SdkConfig.

Examples

use aws_types::region::Region;
let config = aws_config::from_env()
    .region(Region::new("us-east-1"))
    .load().await;

pub fn retry_config(self, retry_config: RetryConfig) -> Self

Override the retry_config used to build SdkConfig.

Examples

use aws_config::retry::RetryConfig;

let config = aws_config::from_env()
    .retry_config(RetryConfig::standard().with_max_attempts(2))
    .load()
    .await;

pub fn timeout_config(self, timeout_config: TimeoutConfig) -> Self

Override the timeout config used to build SdkConfig. Note: This only sets timeouts for calls to AWS services. Timeouts for the credentials provider chain are configured separately.

Examples

use aws_config::timeout::TimeoutConfig;

let config = aws_config::from_env()
   .timeout_config(
       TimeoutConfig::builder()
           .operation_timeout(Duration::from_secs(5))
           .build()
   )
   .load()
   .await;

pub fn sleep_impl(self, sleep: impl AsyncSleep + 'static) -> Self

Override the sleep implementation for this ConfigLoader. The sleep implementation is used to create timeout futures.

pub fn http_connector(self, http_connector: impl Into<HttpConnector>) -> Self

Override the HttpConnector for this ConfigLoader. The connector will be used when sending operations. This does not set the HTTP connector used by config providers. To change that connector, use ConfigLoader::configure.

Examples

use std::time::Duration;
use aws_smithy_client::{Client, hyper_ext};
use aws_smithy_client::erase::DynConnector;
use aws_smithy_client::http_connector::ConnectorSettings;

let https_connector = hyper_rustls::HttpsConnectorBuilder::new()
    .with_webpki_roots()
    .https_only()
    .enable_http1()
    .enable_http2()
    .build();
let smithy_connector = hyper_ext::Adapter::builder()
    // Optionally set things like timeouts as well
    .connector_settings(
        ConnectorSettings::builder()
            .connect_timeout(Duration::from_secs(5))
            .build()
    )
    .build(https_connector);
let sdk_config = aws_config::from_env()
    .http_connector(smithy_connector)
    .load()
    .await;

pub fn credentials_provider(
    self,
    credentials_provider: impl ProvideCredentials + 'static
) -> Self

Override the credentials provider used to build SdkConfig.

Examples

Override the credentials provider but load the default value for region:

let config = aws_config::from_env()
    .credentials_provider(create_my_credential_provider())
    .load()
    .await;

pub fn endpoint_resolver(
    self,
    endpoint_resolver: impl ResolveAwsEndpoint + 'static
) -> Self

👎Deprecated: use .endpoint_url(...) instead

Override the endpoint resolver used for all AWS Services

This method is deprecated. Use Self::endpoint_url instead.

This method will override the endpoint resolver used for all AWS services. This mainly exists to set a static endpoint for tools like LocalStack. For live traffic, AWS services require the service-specific endpoint resolver they load by default.

Examples

Use a static endpoint for all services

use aws_config::endpoint::Endpoint;

let sdk_config = aws_config::from_env()
    .endpoint_resolver(Endpoint::immutable("http://localhost:1234")?)
    .load()
    .await;

pub fn profile_files(self, profile_files: ProfileFiles) -> Self

Provides the ability to programmatically override the profile files that get loaded by the SDK.

The Default for ProfileFiles includes the default SDK config and credential files located in ~/.aws/config and ~/.aws/credentials respectively.

Any number of config and credential files may be added to the ProfileFiles file set, with the only requirement being that there is at least one of each. Profile file locations will produce an error if they don’t exist, but the default config/credentials files paths are exempt from this validation.

Example: Using a custom profile file path

use aws_config::profile::{ProfileFileCredentialsProvider, ProfileFileRegionProvider};
use aws_config::profile::profile_file::{ProfileFiles, ProfileFileKind};

let profile_files = ProfileFiles::builder()
    .with_file(ProfileFileKind::Credentials, "some/path/to/credentials-file")
    .build();
let sdk_config = aws_config::from_env()
    .profile_files(profile_files)
    .load()
    .await;

pub fn profile_name(self, profile_name: impl Into<String>) -> Self

Override the profile name used by configuration providers

Profile name is selected from an ordered list of sources:

1. This override.
2. The value of the AWS_PROFILE environment variable.
3. default

Each AWS profile has a name. For example, in the file below, the profiles are named dev, prod and staging:

[dev]
ec2_metadata_service_endpoint = http://my-custom-endpoint:444

[staging]
ec2_metadata_service_endpoint = http://my-custom-endpoint:444

[prod]
ec2_metadata_service_endpoint = http://my-custom-endpoint:444

See Named profiles for more information about naming profiles.

Example: Using a custom profile name

use aws_config::profile::{ProfileFileCredentialsProvider, ProfileFileRegionProvider};
use aws_config::profile::profile_file::{ProfileFiles, ProfileFileKind};

let sdk_config = aws_config::from_env()
    .profile_name("prod")
    .load()
    .await;

pub fn endpoint_url(self, endpoint_url: impl Into<String>) -> Self

Override the endpoint URL used for all AWS services.

This method will override the endpoint URL used for all AWS services. This primarily exists to set a static endpoint for tools like LocalStack. When sending requests to production AWS services, this method should only be used for service-specific behavior.

When this method is used, the Region is only used for signing; it is not used to route the request.

Examples

Use a static endpoint for all services

let sdk_config = aws_config::from_env()
    .endpoint_url("http://localhost:1234")
    .load()
    .await;

pub fn use_fips(self, use_fips: bool) -> Self

When true, send this request to the FIPS-compliant regional endpoint.

If no FIPS-compliant endpoint can be determined, dispatching the request will return an error.

pub fn use_dual_stack(self, use_dual_stack: bool) -> Self

When true, send this request to the dual-stack endpoint.

If no dual-stack endpoint is available the request MAY return an error.

Note: Some services do not offer dual-stack as a configurable parameter (e.g. Code Catalyst). For these services, this setting has no effect

pub fn configure(self, provider_config: ProviderConfig) -> Self

Set configuration for all sub-loaders (credentials, region etc.)

Update the ProviderConfig used for all nested loaders. This can be used to override the HTTPs connector used by providers or to stub in an in memory Env or Fs for testing.

Examples

use aws_config::provider_config::ProviderConfig;
let custom_https_connector = hyper_rustls::HttpsConnectorBuilder::new()
    .with_webpki_roots()
    .https_only()
    .enable_http1()
    .build();
let provider_config = ProviderConfig::default().with_tcp_connector(custom_https_connector);
let shared_config = aws_config::from_env().configure(provider_config).load().await;

pub async fn load(self) -> SdkConfig

Load the default configuration chain

If fields have been overridden during builder construction, the override values will be used.

Otherwise, the default values for each field will be provided.

NOTE: When an override is provided, the default implementation is not used as a fallback. This means that if you provide a region provider that does not return a region, no region will be set in the resulting SdkConfig

Trait Implementations

impl Debug for ConfigLoader

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for ConfigLoader

fn default() -> ConfigLoader

Returns the “default value” for a type.