Struct rusoto_route53resolver::Route53ResolverClient

pub struct Route53ResolverClient { /* fields omitted */ }

A client for the Route53Resolver API.

Implementations

impl Route53ResolverClient

pub fn new(region: Region) -> Route53ResolverClient

Creates a client backed by the default tokio event loop.

The client will use the default credentials provider and tls client.

pub fn new_with<P, D>(
    request_dispatcher: D,
    credentials_provider: P,
    region: Region
) -> Route53ResolverClient where
    P: ProvideAwsCredentials + Send + Sync + 'static,
    D: DispatchSignedRequest + Send + Sync + 'static, 

pub fn new_with_client(client: Client, region: Region) -> Route53ResolverClient

Trait Implementations

impl Clone for Route53ResolverClient

pub fn clone(&self) -> Route53ResolverClient

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Route53Resolver for Route53ResolverClient

pub fn associate_resolver_endpoint_ip_address<'life0, 'async_trait>(
    &'life0 self,
    input: AssociateResolverEndpointIpAddressRequest
) -> Pin<Box<dyn Future<Output = Result<AssociateResolverEndpointIpAddressResponse, RusotoError<AssociateResolverEndpointIpAddressError>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Adds IP addresses to an inbound or an outbound resolver endpoint. If you want to adding more than one IP address, submit one AssociateResolverEndpointIpAddress request for each IP address.

To remove an IP address from an endpoint, see DisassociateResolverEndpointIpAddress.

pub fn associate_resolver_rule<'life0, 'async_trait>(
    &'life0 self,
    input: AssociateResolverRuleRequest
) -> Pin<Box<dyn Future<Output = Result<AssociateResolverRuleResponse, RusotoError<AssociateResolverRuleError>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Associates a resolver rule with a VPC. When you associate a rule with a VPC, Resolver forwards all DNS queries for the domain name that is specified in the rule and that originate in the VPC. The queries are forwarded to the IP addresses for the DNS resolvers that are specified in the rule. For more information about rules, see CreateResolverRule.

pub fn create_resolver_endpoint<'life0, 'async_trait>(
    &'life0 self,
    input: CreateResolverEndpointRequest
) -> Pin<Box<dyn Future<Output = Result<CreateResolverEndpointResponse, RusotoError<CreateResolverEndpointError>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Creates a resolver endpoint. There are two types of resolver endpoints, inbound and outbound:

• An inbound resolver endpoint forwards DNS queries to the DNS service for a VPC from your network or another VPC.

• An outbound resolver endpoint forwards DNS queries from the DNS service for a VPC to your network or another VPC.

pub fn create_resolver_rule<'life0, 'async_trait>(
    &'life0 self,
    input: CreateResolverRuleRequest
) -> Pin<Box<dyn Future<Output = Result<CreateResolverRuleResponse, RusotoError<CreateResolverRuleError>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

For DNS queries that originate in your VPCs, specifies which resolver endpoint the queries pass through, one domain name that you want to forward to your network, and the IP addresses of the DNS resolvers in your network.

pub fn delete_resolver_endpoint<'life0, 'async_trait>(
    &'life0 self,
    input: DeleteResolverEndpointRequest
) -> Pin<Box<dyn Future<Output = Result<DeleteResolverEndpointResponse, RusotoError<DeleteResolverEndpointError>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Deletes a resolver endpoint. The effect of deleting a resolver endpoint depends on whether it's an inbound or an outbound resolver endpoint:

• Inbound: DNS queries from your network or another VPC are no longer routed to the DNS service for the specified VPC.

• Outbound: DNS queries from a VPC are no longer routed to your network or to another VPC.

pub fn delete_resolver_rule<'life0, 'async_trait>(
    &'life0 self,
    input: DeleteResolverRuleRequest
) -> Pin<Box<dyn Future<Output = Result<DeleteResolverRuleResponse, RusotoError<DeleteResolverRuleError>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Deletes a resolver rule. Before you can delete a resolver rule, you must disassociate it from all the VPCs that you associated the resolver rule with. For more infomation, see DisassociateResolverRule.

pub fn disassociate_resolver_endpoint_ip_address<'life0, 'async_trait>(
    &'life0 self,
    input: DisassociateResolverEndpointIpAddressRequest
) -> Pin<Box<dyn Future<Output = Result<DisassociateResolverEndpointIpAddressResponse, RusotoError<DisassociateResolverEndpointIpAddressError>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Removes IP addresses from an inbound or an outbound resolver endpoint. If you want to remove more than one IP address, submit one DisassociateResolverEndpointIpAddress request for each IP address.

To add an IP address to an endpoint, see AssociateResolverEndpointIpAddress.

pub fn disassociate_resolver_rule<'life0, 'async_trait>(
    &'life0 self,
    input: DisassociateResolverRuleRequest
) -> Pin<Box<dyn Future<Output = Result<DisassociateResolverRuleResponse, RusotoError<DisassociateResolverRuleError>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Removes the association between a specified resolver rule and a specified VPC.

If you disassociate a resolver rule from a VPC, Resolver stops forwarding DNS queries for the domain name that you specified in the resolver rule.

pub fn get_resolver_endpoint<'life0, 'async_trait>(
    &'life0 self,
    input: GetResolverEndpointRequest
) -> Pin<Box<dyn Future<Output = Result<GetResolverEndpointResponse, RusotoError<GetResolverEndpointError>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Gets information about a specified resolver endpoint, such as whether it's an inbound or an outbound resolver endpoint, and the current status of the endpoint.

pub fn get_resolver_rule<'life0, 'async_trait>(
    &'life0 self,
    input: GetResolverRuleRequest
) -> Pin<Box<dyn Future<Output = Result<GetResolverRuleResponse, RusotoError<GetResolverRuleError>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Gets information about a specified resolver rule, such as the domain name that the rule forwards DNS queries for and the ID of the outbound resolver endpoint that the rule is associated with.

pub fn get_resolver_rule_association<'life0, 'async_trait>(
    &'life0 self,
    input: GetResolverRuleAssociationRequest
) -> Pin<Box<dyn Future<Output = Result<GetResolverRuleAssociationResponse, RusotoError<GetResolverRuleAssociationError>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Gets information about an association between a specified resolver rule and a VPC. You associate a resolver rule and a VPC using AssociateResolverRule.

pub fn get_resolver_rule_policy<'life0, 'async_trait>(
    &'life0 self,
    input: GetResolverRulePolicyRequest
) -> Pin<Box<dyn Future<Output = Result<GetResolverRulePolicyResponse, RusotoError<GetResolverRulePolicyError>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Gets information about a resolver rule policy. A resolver rule policy specifies the Resolver operations and resources that you want to allow another AWS account to be able to use.

pub fn list_resolver_endpoint_ip_addresses<'life0, 'async_trait>(
    &'life0 self,
    input: ListResolverEndpointIpAddressesRequest
) -> Pin<Box<dyn Future<Output = Result<ListResolverEndpointIpAddressesResponse, RusotoError<ListResolverEndpointIpAddressesError>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Gets the IP addresses for a specified resolver endpoint.

pub fn list_resolver_endpoints<'life0, 'async_trait>(
    &'life0 self,
    input: ListResolverEndpointsRequest
) -> Pin<Box<dyn Future<Output = Result<ListResolverEndpointsResponse, RusotoError<ListResolverEndpointsError>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Lists all the resolver endpoints that were created using the current AWS account.

pub fn list_resolver_rule_associations<'life0, 'async_trait>(
    &'life0 self,
    input: ListResolverRuleAssociationsRequest
) -> Pin<Box<dyn Future<Output = Result<ListResolverRuleAssociationsResponse, RusotoError<ListResolverRuleAssociationsError>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Lists the associations that were created between resolver rules and VPCs using the current AWS account.

pub fn list_resolver_rules<'life0, 'async_trait>(
    &'life0 self,
    input: ListResolverRulesRequest
) -> Pin<Box<dyn Future<Output = Result<ListResolverRulesResponse, RusotoError<ListResolverRulesError>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Lists the resolver rules that were created using the current AWS account.

pub fn list_tags_for_resource<'life0, 'async_trait>(
    &'life0 self,
    input: ListTagsForResourceRequest
) -> Pin<Box<dyn Future<Output = Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Lists the tags that you associated with the specified resource.

pub fn put_resolver_rule_policy<'life0, 'async_trait>(
    &'life0 self,
    input: PutResolverRulePolicyRequest
) -> Pin<Box<dyn Future<Output = Result<PutResolverRulePolicyResponse, RusotoError<PutResolverRulePolicyError>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Specifies the Resolver operations and resources that you want to allow another AWS account to be able to use.

pub fn tag_resource<'life0, 'async_trait>(
    &'life0 self,
    input: TagResourceRequest
) -> Pin<Box<dyn Future<Output = Result<TagResourceResponse, RusotoError<TagResourceError>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Adds one or more tags to a specified resource.

pub fn untag_resource<'life0, 'async_trait>(
    &'life0 self,
    input: UntagResourceRequest
) -> Pin<Box<dyn Future<Output = Result<UntagResourceResponse, RusotoError<UntagResourceError>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Removes one or more tags from a specified resource.

pub fn update_resolver_endpoint<'life0, 'async_trait>(
    &'life0 self,
    input: UpdateResolverEndpointRequest
) -> Pin<Box<dyn Future<Output = Result<UpdateResolverEndpointResponse, RusotoError<UpdateResolverEndpointError>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Updates the name of an inbound or an outbound resolver endpoint.

pub fn update_resolver_rule<'life0, 'async_trait>(
    &'life0 self,
    input: UpdateResolverRuleRequest
) -> Pin<Box<dyn Future<Output = Result<UpdateResolverRuleResponse, RusotoError<UpdateResolverRuleError>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Updates settings for a specified resolver rule. ResolverRuleId is required, and all other parameters are optional. If you don't specify a parameter, it retains its current value.